Java三种实现工厂模式的方法

学习工厂模式的时候就曾思考过这么写的好处，再手动敲了代码后发现自己更糊涂了，后来搜索例子和各种文案才有点概念，特此记录一下个人的理解

工厂模式的好处：

1.减少了重复代码

2.让创建对象于使用方法分离，代码解耦

3.利于后期的维护，事实上你创建的工厂的作用就是给你提供你需要的对象，不用在代码中一个个new Class，后期如果需要换对象不用在调用的地方去改，修改工厂类中实例化对象的方法就可以，

这些都是个人理解，有什么不对留言指正，下面是实现工厂模式的三种方法

一，简单工厂模式

1.创建一个接口或者抽象方法

1 /**
2  * 被创建者的公共接口
3  * @author lql29
4  *
5  */
6 public interface Sender {
7        //公有方法
8     public void Send();
9 }

2.创建两个实现类

 1 public class MailSend implements Sender{
 2 
 3     @Override
 4     public void Send() {
 5         // TODO Auto-generated method stub
 6         //实现接口方法
 7         System.out.println("MailSender");
 8     }
 9 
10 }

public class SmsSend implements Sender{

    @Override
    public void Send() {
        // TODO Auto-generated method stub
        //实现接口方法
        System.out.println("SmsSend");
    }

}

3.创建一个工厂类

 1 /**
 2  * 工厂类
 3  * @author lql29
 4  *
 5  */
 6 public class SenderFactory {
 7     public Sender produce(String Type){
 8         if("mail".equals(Type)){
 9             return new MailSend();
10         }else if("sms".equals(Type)){
11             return new SmsSend();
12         }else{
13             System.out.println("请输入正确的类型！");
14             return null;
15         }
16     }
17 }

最后实例化工厂类调用工厂类的produce方法，参数是想要返回被创建者对象的类型

二，工厂方法模式

1.创建被创建者接口

1 /**
2  * 被创建者接口
3  * @author lql29
4  *
5  */
6 public interface PrudactInterface {
7     //定义公共方法
8     public void production();
9 }

2.创建工厂接口

1 /**
2  * 定义工厂类接口
3  * @author lql29
4  *
5  */
6 public interface FactoryInterface {
7     //创建对象方法
8     public PrudactInterface found();
9 }

3.实现被创建者接口

 1 /**
 2  * 产品实体类
 3  * @author lql29
 4  *
 5  */
 6 public class PrudactPojo implements PrudactInterface{
 7 
 8     @Override
 9     public void production() {
10         // TODO Auto-generated method stub
11         //定义生成什么产品
12         System.out.println("生产芒果饮料。。。。。");
13     }
14 
15 }

 1 /**
 2  * 定义产品实体类
 3  * @author lql29
 4  *
 5  */
 6 public class PrudactPojo_2 implements PrudactInterface{
 7 
 8     @Override
 9     public void production() {
10         // TODO Auto-generated method stub
11         System.out.println("生成苹果饮料。。。。。。。");
12     }
13     
14 }

4.实现工厂接口

 1 /**
 2  * 定义PrudactPojo工厂实体类
 3  * @author lql29
 4  *
 5  */
 6 public class FactoryPojo implements FactoryInterface{
 7 
 8     @Override
 9     public PrudactInterface found() {
10         // TODO Auto-generated method stub
11         //实现创建对象方法，
12         PrudactInterface prudactPojo = new PrudactPojo();
13         return prudactPojo;
14     }
15 
16 }

 1 public class FactoryPojo_2 implements FactoryInterface {
 2 
 3     @Override
 4     public PrudactInterface found() {
 5         // TODO Auto-generated method stub
 6         PrudactInterface prudactPojo_2 = new PrudactPojo_2();
 7         return prudactPojo_2;
 8     }
 9 
10 }

这两种的方法的实现都相对较简单，简单工厂模式就是一个大工厂，里面根据分支条件来判断你需要的各种对象，这种并不灵活，所有的创建对象的方法都在一个工厂类里面，工厂方法就是将工厂细分，一个工厂只生产创建一个对象，后期对于代码更好的维护，

三，抽象工厂模式

1.创建接口

1 /**
2 *公共接口
3 *
4 */
5 public interface Shape {
6    void draw();
7 }

2.实现接口

 1 /**
 2 *接口实体类
 3 */
 4 public class Rectangle implements Shape {
 5  
 6    @Override
 7    public void draw() {
 8       System.out.println("Inside Rectangle::draw() method.");
 9    }
10 }

 1 /**
 2 *接口实体类
 3 *
 4 */
 5 public class Square implements Shape {
 6  
 7    @Override
 8    public void draw() {
 9       System.out.println("Inside Square::draw() method.");
10    }
11 }

3.创建扩展接口

1 /**
2 *扩展接口，颜色
3 */
4 public interface Color {
5    void fill();
6 }

4.实现扩展接口

1 public class Red implements Color {
2  
3    @Override
4    public void fill() {
5       System.out.println("Inside Red::fill() method.");
6    }
7 }

1 public class Green implements Color {
2  
3    @Override
4    public void fill() {
5       System.out.println("Inside Green::fill() method.");
6    }
7 }

5.创建工厂抽象类

1 /**
2 *抽象工厂方法
3 */
4 public abstract class AbstractFactory {
5    public abstract Color getColor(String color);
6    public abstract Shape getShape(String shape) ;
7 }

6.实现工厂抽象类

 1 /**
 2 *实现工厂类，制定特定功能的工厂
 3 *
 4 */
 5 public class ShapeFactory extends AbstractFactory {
 6     
 7    @Override
 8    public Shape getShape(String shapeType){
 9       if(shapeType == null){
10          return null;
11       }        
12       if(shapeType.equalsIgnoreCase("CIRCLE")){
13          return new Circle();
14       } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
15          return new Rectangle();
16       } else if(shapeType.equalsIgnoreCase("SQUARE")){
17          return new Square();
18       }
19       return null;
20    }
21    
22    @Override
23    public Color getColor(String color) {
24       return null;
25    }
26 }

 1 public class ColorFactory extends AbstractFactory {
 2     
 3    @Override
 4    public Shape getShape(String shapeType){
 5       return null;
 6    }
 7    
 8    @Override
 9    public Color getColor(String color) {
10       if(color == null){
11          return null;
12       }        
13       if(color.equalsIgnoreCase("RED")){
14          return new Red();
15       } else if(color.equalsIgnoreCase("GREEN")){
16          return new Green();
17       } else if(color.equalsIgnoreCase("BLUE")){
18          return new Blue();
19       }
20       return null;
21    }
22 }

7.创建一个工厂创造器/生成器类

 1 public class FactoryProducer {
 2    public static AbstractFactory getFactory(String choice){
 3       if(choice.equalsIgnoreCase("SHAPE")){
 4          return new ShapeFactory();
 5       } else if(choice.equalsIgnoreCase("COLOR")){
 6          return new ColorFactory();
 7       }
 8       return null;
 9    }
10 }