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

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

工厂模式的好处：

1.减少了重复代码

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

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

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

一，简单工厂模式

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

/**
 * 被创建者的公共接口
 * @author lql29
 *
 */
public interface Sender {
       //公有方法
    public void Send();
}

2.创建两个实现类

public class MailSend implements Sender{

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

}

public class SmsSend implements Sender{

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

}

3.创建一个工厂类

/**
 * 工厂类
 * @author lql29
 *
 */
public class SenderFactory {
    public Sender produce(String Type){
        if("mail".equals(Type)){
            return new MailSend();
        }else if("sms".equals(Type)){
            return new SmsSend();
        }else{
            System.out.println("请输入正确的类型！");
            return null;
        }
    }
}

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

二，工厂方法模式

1.创建被创建者接口

/**
 * 被创建者接口
 * @author lql29
 *
 */
public interface PrudactInterface {
    //定义公共方法
    public void production();
}

2.创建工厂接口

/**
 * 定义工厂类接口
 * @author lql29
 *
 */
public interface FactoryInterface {
    //创建对象方法
    public PrudactInterface found();
}

3.实现被创建者接口

/**
 * 产品实体类
 * @author lql29
 *
 */
public class PrudactPojo implements PrudactInterface{

    @Override
    public void production() {
        // TODO Auto-generated method stub
        //定义生成什么产品
        System.out.println("生产芒果饮料。。。。。");
    }

}

/**
 * 定义产品实体类
 * @author lql29
 *
 */
public class PrudactPojo_2 implements PrudactInterface{

    @Override
    public void production() {
        // TODO Auto-generated method stub
        System.out.println("生成苹果饮料。。。。。。。");
    }
    
}

4.实现工厂接口

/**
 * 定义PrudactPojo工厂实体类
 * @author lql29
 *
 */
public class FactoryPojo implements FactoryInterface{

    @Override
    public PrudactInterface found() {
        // TODO Auto-generated method stub
        //实现创建对象方法，
        PrudactInterface prudactPojo = new PrudactPojo();
        return prudactPojo;
    }

}

public class FactoryPojo_2 implements FactoryInterface {

    @Override
    public PrudactInterface found() {
        // TODO Auto-generated method stub
        PrudactInterface prudactPojo_2 = new PrudactPojo_2();
        return prudactPojo_2;
    }

}

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

三，抽象工厂模式

1.创建接口

/**
*公共接口
*
*/
public interface Shape {
   void draw();
}

2.实现接口

/**
*接口实体类
*/
public class Rectangle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}

/**
*接口实体类
*
*/
public class Square implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}

3.创建扩展接口

/**
*扩展接口，颜色
*/
public interface Color {
   void fill();
}

4.实现扩展接口

public class Red implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Red::fill() method.");
   }
}

public class Green implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Green::fill() method.");
   }
}

5.创建工厂抽象类

/**
*抽象工厂方法
*/
public abstract class AbstractFactory {
   public abstract Color getColor(String color);
   public abstract Shape getShape(String shape) ;
}

6.实现工厂抽象类

/**
*实现工厂类，制定特定功能的工厂
*
*/
public class ShapeFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }
      return null;
   }
   
   @Override
   public Color getColor(String color) {
      return null;
   }
}

public class ColorFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      return null;
   }
   
   @Override
   public Color getColor(String color) {
      if(color == null){
         return null;
      }        
      if(color.equalsIgnoreCase("RED")){
         return new Red();
      } else if(color.equalsIgnoreCase("GREEN")){
         return new Green();
      } else if(color.equalsIgnoreCase("BLUE")){
         return new Blue();
      }
      return null;
   }
}

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

public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("SHAPE")){
         return new ShapeFactory();
      } else if(choice.equalsIgnoreCase("COLOR")){
         return new ColorFactory();
      }
      return null;
   }
}

最后通过FactoryProducer对象调用getFactory方法，参数被创建者的类型

总结：工厂模式的使用就是将创建对象与对象的使用解耦，在各个地方用对应的工厂类创造所需要的对象，最后如有修改对工厂统一修改