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方法，參數被創建者的類型

 

總結：工廠模式的使用就是將創建對象與對象的使用解耦，在各個地方用對應的工廠類創造所需要的對象，最后如有修改對工廠統一修改