工厂模式理解

工厂模式是一种创建型的设计模式，所谓创建型设计模式，不是简单的使用new方法 实例化对象，创建对象时在—— 由谁？创建什么？何时？等方面，提高了设计的灵活性。

比如，普通工厂模式：对实现同一接口的类进行实例创建。
需求：定义一个生产龙虾的工厂，通过使用这个工厂能烹饪各种龙虾。
思路： 定义一个工厂类，去创建 其他类的实例，使用 时 先实例化这个工厂，调用工厂里的方法，达到隐匿的创建 其他类的实例，而后调用 其他类的实例 的方法。
结构：工厂，抽象产品，具体产品。

• 1. 创建一个烹饪龙虾的工厂

public class LobsterFactory { 
   public  Lobster getLobster(String  lobsterType){
      if(lobsterType == null){
         return null;
      } 
      if(lobsterType.equalsIgnoreCase("BOSTONLOBSTER")){
         return new BostonLobster();  //烹饪波士顿龙虾
      } else if(lobsterType.equalsIgnoreCase("PanulirusHomarus")){
         return new PanulirusHomarus(); //烹饪青龙
      }  else if(lobsterType.equalsIgnoreCase("AustralianLobster")){
         return new AustralianLobster(); //烹饪澳洲龙虾
      } 
      return null;
   }
}

• 2. 创建一个龙虾?的接口

public interface Lobster {
   void  taste(); //口味
}

• 3. 创建 其他类的实例 实现 龙虾的接口

//1）波士顿龙虾
public class  BostonLobster implements Lobster {
   @Override
   public void taste() {
      System.out.println("Spiced salt "); //椒盐
   }
}

//2）青龙
public class  AustralianLobster implements Lobster {
   @Override
   public void taste() {
      System.out.println("Scallion oil"); //葱油
   }
}

//3）澳洲龙虾
public class  PanulirusHomarus implements Lobster {
   @Override
   public void taste() {
      System.out.println("Scallion oil"); //葱油
   }
}

 

• 4. 使用工厂，来烹饪何种类型的龙虾

public class FactoryPatternDemo { 
   public static void main(String[] args) {
      LobsterFactory lobsterFactory = new LobsterFactory();
      
      //获取 BostonLobster 的对象
      Lobster lobster1 = lobsterFactory.getLobster("BostonLobster");
 
      //调用 BostonLobster 的 taste 方法
      lobster1.taste()；
   }
}

 
 
比如 抽象工厂模式，定义一个抽象工厂（工厂的工厂），再定义一些具体的子工厂去扩展抽象工厂的功能，使用前定义一个工厂生产器，使用时通过工厂生产器获取具体子工厂实例，而后获取具体要生产的产品实例，调用产品方法。其结构：抽象工厂，具体工厂，抽象产品，具体产品。

例子：我想创建一个海鲜加工厂，不仅能烹饪各种龙虾，还能烹饪何种好吃的鱼，提供各种类型的饮料。

• 1.先要确定下我想要吃的海鲜有哪些，也就创建接口和实体类

// 1 想吃龙虾
public interface Lobster {
   void  taste(); //口味
}
// 想吃波士顿龙虾
public class  BostonLobster implements Lobster {
   @Override
   public void taste() {
      System.out.println("Spiced salt "); //椒盐
   }
}
// 2 想吃鱼?
public interface Fish {
   void  taste(); //口味
}
// 想吃多宝鱼
public class  ScophthalmusMaximus implements Fish {
   @Override
   public void taste() {
     System.out.println("Scallion oil"); //葱油
   }
}

 

• 2 创建一个抽象类工厂

public abstract class AbstractFactory {
   public abstract Lobster getTaste(String lobsterType);   //返回类型龙虾
     public abstract Fish getTaste(String fishType);   //返回类型鱼
}

 

• 3. 创建两个子工厂类 ，一个工厂烹饪龙虾，一个烹饪鱼

// 龙虾加工厂
public class LobsterFactory extends AbstractFactory {
    
   @Override
   public Lobster getTaste(String lobsterType){
      if(lobsterType == null){
         return null;
      }        
      if(lobsterType.equalsIgnoreCase("BostonLobster")){
         return new BostonLobster();
      } 
      return null;
   }
   
   @Override
   public Fish getTaste(String fishType) {
      return null;
   }
}
// 鱼类加工厂 
public class FishFactory extends AbstractFactory {
    
   @Override
   public Lobster getTaste(String lobsterType){
      return null;
   }
   @Override
   public Fish getTaste(String fishType) {
        if(fishType == null){
         return null;
      }        
      if(fishType.equalsIgnoreCase("ScophthalmusMaximus")){
         return new ScophthalmusMaximus();
      } 
      return null;
   }
}

 

• 4. 创建工厂生产器 ， 通过 抽象工厂获取子工厂

public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("LOBSTER")){
         return new LobsterFactory();
      } else if(choice.equalsIgnoreCase("FISH")){
         return new FishFactory();
      }
      return null;
   }
}

 

• 5. 使用工厂生产器 ，烹饪食物

public class Demo {
   public static void main(String[] args) {
 
      //获取龙虾工厂
      AbstractFactory lobsterFactory = FactoryProducer.getFactory("LOBSTER");
      // 获取龙虾对象
       Lobster lobster1 = lobsterFactory.getTaste("BostonLobster")
       // 调用对象方法
      lobster1.taste();
   }
}