工厂设计模式

简单工厂模式

  看一个具体的需求
 ​
  有一个披萨的项目，要求便于披萨种类的扩展，便于维护
 ​
 1. 披萨的种类很多 比如：GreekPizza CheesePizza等
 2. 披萨的生产过程有：prepare、bake、cut、box
 3. 完成披萨店订购的功能

 + 优点是比较好理解，简单易操作
 + 缺点是违反了设计模式的ocp原则，即对扩展开放，对修改关闭，即当我们给类增加新功能的时候，尽量不修改代码，或者尽量少修改代码
 + 如果要增加一个新的口味的披萨，则需要增加一个类的代码，并且在实际获取新口味的披萨的时候还要增加代码，这样比较麻烦，不是我们所想要的

 + 分析： 修改代码可以接收，但是如果我们在其他地方也有创建Pizza的代码，就意味着，也需要修改，而创建Pizza的代码，往往有多处
 + 思路：把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类时，只需要修改该类就可以，其他有创建到Pizza对象的代码就不需要修改了，这就是**简单工厂模式**

 //简单工厂类
 public class SimpleFactory {
   //更加 orderType 返回对应的 Pizza 对象 
   public Pizza createPizza(String orderType) {
     Pizza pizza = null;
     System.out.println("使用简单工厂模式"); 
     if (orderType.equals("greek")) {
       pizza = new GreekPizza();
       pizza.setName(" 希腊披萨 ");
     } else if (orderType.equals("cheese")) {
       pizza = new CheesePizza();
       pizza.setName(" 奶酪披萨 ");
     } else if (orderType.equals("pepper")) {
       pizza = new PepperPizza();
       pizza.setName("胡椒披萨"); 
     }
     return pizza; 
 }
 public static Pizza createPizza2(String orderType) { 
   Pizza pizza = null;
   System.out.println("使用简单工厂模式 2"); 
   if (orderType.equals("greek")) {
     pizza = new GreekPizza();
     pizza.setName(" 希腊披萨 ");
   } else if (orderType.equals("cheese")) {
     pizza = new CheesePizza();
     pizza.setName(" 奶酪披萨 ");
   } else if (orderType.equals("pepper")) {
     pizza = new PepperPizza();
     pizza.setName("胡椒披萨"); 
   }
     return pizza; 
   }
 }

 public class OrderPizza {
   //定义一个简单工厂对象 
   SimpleFactory simpleFactory; 
   Pizza pizza = null;
   //构造器
   public OrderPizza(SimpleFactory simpleFactory) {
     setFactory(simpleFactory); 
   }
   public void setFactory(SimpleFactory simpleFactory) { 
     String orderType = ""; //用户输入的
     this.simpleFactory = simpleFactory; //设置简单工厂对象
     do {
       orderType = getType();
       pizza = this.simpleFactory.createPizza(orderType);
       //输出 pizza
       if(pizza != null) { //订购成功
         pizza.prepare(); pizza.bake(); pizza.cut(); pizza.box();
       } else {
         System.out.println(" 订购披萨失败 "); break;
       } 
     }while(true);
   }
   // 写一个方法，可以获取客户希望订购的披萨种类 private String getType() {
   try {
     BufferedReader strin = new BufferedReader(new InputStreamReader(System.in)); System.out.println("input pizza 种类:");
     String str = strin.readLine();
     return str;
   } catch (IOException e) { 
     e.printStackTrace(); return "";
   } 
 }

 public abstract class OrderPizza {
 //定义一个抽象方法，createPizza , 让各个工厂子类自己实现 
   abstract Pizza createPizza(String orderType);
   // 构造器
   public OrderPizza() {
     Pizza pizza = null;
     String orderType; // 订购披萨的类型 
     do {
       orderType = getType();
       pizza = createPizza(orderType); //抽象方法，由工厂子类完成 //输出 pizza 制作过程
       pizza.prepare();
       pizza.bake();
       pizza.cut();
       pizza.box();
     } while (true); 
   }
   // 写一个方法，可以获取客户希望订购的披萨种类 
   private String getType() {
     try {
       BufferedReader strin = new BufferedReader(new InputStreamReader(System.in)); System.out.println("input pizza 种类:");
       String str = strin.readLine();
       return str;
     } catch (IOException e) { e.printStackTrace(); return "";} 
   }
 }

 public class BJOrderPizza extends OrderPizza {
   @Override
   Pizza createPizza(String orderType) {
     Pizza pizza = null; 
     if(orderType.equals("cheese")) {
       pizza = new BJCheesePizza();
     } else if (orderType.equals("pepper")) {
       pizza = new BJPepperPizza(); 
     }
     return pizza; 
   }
 }

 public class LDOrderPizza extends OrderPizza {
   @Override
   Pizza createPizza(String orderType) {
     Pizza pizza = null; 
     if(orderType.equals("cheese")) {
       pizza = new LDCheesePizza();
     } else if (orderType.equals("pepper")) {
       pizza = new LDPepperPizza(); 
     }
     return pizza; 
   }
 }

抽象工厂模式

介绍

1.  
2.  
3.  
4.  
5.  

使用实例

//一个抽象工厂模式的抽象层(接口) 
public interface AbsFactory {
	//让下面的工厂子类来 具体实现
	public Pizza createPizza(String orderType); 
}

 //这是工厂子类
 public class BJFactory implements AbsFactory {
   @Override
   public Pizza createPizza(String orderType) {
     System.out.println("~使用的是抽象工厂模式~");
     Pizza pizza = null;
     if(orderType.equals("cheese")) {
       pizza = new BJCheesePizza();
     } else if (orderType.equals("pepper")){ 
       pizza = new BJPepperPizza();
     }
     return pizza; }
 }

 public class LDFactory implements AbsFactory {
   @Override
   public Pizza createPizza(String orderType) {
     System.out.println("~使用的是抽象工厂模式~"); 
     Pizza pizza = null;
     if (orderType.equals("cheese")) {
       pizza = new LDCheesePizza();
     } else if (orderType.equals("pepper")) { 
       pizza = new LDPepperPizza();
     }
     return pizza; 
   }
 }

 public class OrderPizza {
   AbsFactory factory;
   // 构造器
   public OrderPizza(AbsFactory factory) {
     setFactory(factory); 
   }
   private void setFactory(AbsFactory factory) { 
     Pizza pizza = null;
     String orderType = ""; // 用户输入 
     this.factory = factory;
     do {
       orderType = getType();
       // factory 可能是北京的工厂子类，也可能是伦敦的工厂子类 
       pizza = factory.createPizza(orderType);
     if (pizza != null) { // 订购 ok
       pizza.prepare(); 
       pizza.bake(); 
       pizza.cut();
       pizza.box(); 
     } else {
       System.out.println("订购失败");
       break; }
     } while (true); 
   }
   // 写一个方法，可以获取客户希望订购的披萨种类 
   private String getType() {
     try {
       BufferedReader strin = new BufferedReader(new InputStreamReader(System.in)); System.out.println("input pizza 种类:");
       String str = strin.readLine();
       return str;
     } catch (IOException e) { e.printStackTrace(); return "";} 
   }
 }

•  
•  
•  

1.  
2.  
3.  

工厂模式总结

总结：

• 我们使用工厂方法模式可以很灵活的去定制我们需要的对象

  1. 使用抽象Abstract类，在类中添加抽象方法，由具体的子类去重写这个方法

  2. 抽象类中书写相关逻辑方法

  3. 逻辑方法调用重写的抽象方法

• 定制化需求强

• 耦合度低，便于系统扩展

1) 工厂方法模式设计方案:将披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中具体实现。

2) 工厂方法模式:定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例 化推迟到子类。

介绍

工厂方法模式

看到以上的代码了么？上面的逻辑就是接收用户输入的种类type信息，然后在SimpleFactory类中返回我们想要的Pizza对象，这就是一个简单的工厂类，当我们在需要这个类的时候就可以直接调用工厂类，传入type参数就能拿到相应的类，是不是很方便么？这就是使用工厂设计模式的好处！

使用简单工厂模式

1. 简单工厂模式属于创建型模式，是工厂模式的一种，简单工厂模式是由一个工厂对象决定创建哪一种产品类的实例，简单工厂模式是工厂模式家族中最简单实用的模式

2. 简单工厂模式，定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)

3. 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会用到工厂模式

简单工厂模式介绍

改进思路分析

传统方式的优缺点

我们使用传统方式去创建，就是使用一个基础的Pizza父类，后面的扩展类继承其类，然后重写其中的方法

使用传统的方式来完成