Day41-设计模式-工厂设计模式

---

title: Day41-设计模式-工厂设计模式
date: 2021-03-04 14:32:31
author: Liu_zimo

---

设计模式

• 设计模式分为三种类型，共23种
  1. 创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。
  2. 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
  3. 行为型模式：模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式(Interpreter模式)、状态模式、策略模式、职责链模式(责任链模式)。

工厂设计模式

简单工厂模式

简单工厂模式也成为静态工厂模式

• 需求说明：要便于披萨种类的扩展，要便于维护

  1. 披萨的种类很多(比如GreekPizz、CheesePizz等)
  2. 披萨的制作有prepare（原料），bake（烘培），cut（裁剪），box（打包）
  3. 完成披萨店订购功能。

• 传统实现方式

  • 优缺点：
    1. 优点是比较好理解，简单易操作。
    2. 缺点是违反了设计模式的ocp原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码
    3. 比如我们这时要新增加一个Pizza的种类(Pepper披萨)，我们需要做如下修改
       1. 增加一个Pepper类
       2. 修改订单类，增加Pepper披萨的类型

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

基本介绍

1. 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式
2. 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)
3. 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式.

• 使用简单工厂模式
  1. 简单工厂模式的设计方案：定义一个可以实例化Pizza对象的类，封装创建对象的代码
  2. 编写简单工厂类，修改OrderPizza，使用简单工厂模式来创建对象，更加的方便灵活

package com.zimo.设计模式.工厂模式.简单工厂模式.PizzaFactory;

/**
 * 简单工厂模式：pizza案例
 *      -- Pizza抽象类
 *
 * @author Liu_zimo
 * @version v0.1 by 2021/3/4 14:38
 */
public abstract class Pizza {

    protected String name;

    public abstract void prepare();             // 准备原材料，不同披萨不一样，因此做成抽象方法
    public void bake(){
        System.out.println(name + " baking");    // 烘焙
    }
    public void cut() {
        System.out.println(name + " cutting");   // 切割
    }
    public void box(){
        System.out.println(name + " boxing");    // 打包
    }

    public void setName(String name) {
        this.name = name;
    }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.简单工厂模式.PizzaFactory;

/**
 * 简单工厂模式：pizza案例
 *      -- CheesePizza实现
 *
 * @author Liu_zimo
 * @version v0.1 by 2021/3/4 14:36
 */
public class CheesePizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("给制作奶酪披萨准备的原材料");
    }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.简单工厂模式.PizzaFactory;

/**
 * 简单工厂模式：pizza案例
 *      -- GreekPizza
 *
 * @author Liu_zimo
 * @version v0.1 by 2021/3/4 14:45
 */
public class GreekPizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("给制作希腊披萨准备的原材料");
    }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.简单工厂模式.PizzaFactory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 简单工厂模式：pizza案例 - 改进版
 *      -- OrderPizza订购披萨
 *
 * @author Liu_zimo
 * @version v0.2 by 2021/3/4 14:46
 */
public class OrderPizza {
    SimpleFactory simpleFactory;
    Pizza pizza = null;

    public OrderPizza(SimpleFactory simpleFactory) {
        setSimpleFactory(simpleFactory);
    }

    public void setSimpleFactory(SimpleFactory simpleFactory) {
        String orderType ="";
        this.simpleFactory = simpleFactory;
        do {
            orderType = getType();
            pizza = this.simpleFactory.createPizza(orderType);
            if (pizza != null){
                // 订购成功
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else {
                System.out.println("订购失败");
                break;
            }
        }while (true);
    }

    // 写一个方法，可以获取客户希望订购的披萨种类
    private String getType(){
        try {
            BufferedReader str = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String s = str.readLine();
            return s;
        }catch (IOException e){
            e.printStackTrace();
            return "";
        }
    }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.简单工厂模式.PizzaFactory;

/**
 * 简单工厂模式：pizza案例
 *      -- PizzaStore披萨商店
 *
 * @author Liu_zimo
 * @version v0.2 by 2021/3/4 16:09
 */
public class PizzaStore {
    public static void main(String[] args) {
        OrderPizza orderPizza = new OrderPizza(new SimpleFactory());
    }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.简单工厂模式.PizzaFactory;

/**
 * 简单工厂模式：pizza案例 - 优化版
 * -- SimpleFactory 工厂实现
 *
 * @author Liu_zimo
 * @version v0.1 by 2021/3/4 15:36
 */
public class SimpleFactory {
    public Pizza createPizza(String type) {
        Pizza pizza = null;
        System.out.println("使用简单工厂模式");

        if (type.equals("greek")) {
            pizza = new GreekPizza();
        } else if (type.equals("cheese")) {
            pizza = new CheesePizza();
        }
        pizza.setName(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
    // 静态工厂模式
    public static Pizza createPizza1(String type) {
        Pizza pizza = null;
        System.out.println("静态工厂模式");

        if (type.equals("greek")) {
            pizza = new GreekPizza();
        } else if (type.equals("cheese")) {
            pizza = new CheesePizza();
        }
        pizza.setName(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

工厂方法模式

• 需求说明：客户在点披萨时，可以点不同口味的披萨，比如北京的奶酪pizza、北京的胡椒pizza或者是伦敦的奶酪pizza、伦敦的胡椒pizza。
• 使用简单工厂模式，创建不同的简单工厂类，比如BJPizzaSimpleFactory、LDPizzaSimpleFactory等等。从当前这个案例来说，也是可以的，但是考虑到项目的规模，以及软件的可维护性、可扩展性并不是特别好
• 使用工厂方法模式

基本介绍

• 工厂方法模式设计方案：将披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中具体实现。
• 工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

package com.zimo.设计模式.工厂模式.工厂方法模式;
/**
 * 工厂方法模式：pizza案例
 *      -- Pizza抽象类
 *
 * @author Liu_zimo
 * @version v0.1 by 2021/3/4 14:38
 */
public abstract class Pizza {
    protected String name;
    public abstract void prepare();             // 准备原材料，不同披萨不一样，因此做成抽象方法
    public void bake(){
        System.out.println(name + " baking");    // 烘焙
    }
    public void cut() {
        System.out.println(name + " cutting");   // 切割
    }
    public void box(){
        System.out.println(name + " boxing");    // 打包
    }
    public void setName(String name) {
        this.name = name;
    }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.工厂方法模式;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
 * 工厂方法模式：披萨实例
 *      -- PizzaStore披萨商店
 *
 * @author Liu_zimo
 * @version v0.1 by 2021/3/4 17:02
 */
public class PizzaStore {
    public static void main(String[] args) {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        try {
            if (bufferedReader.readLine().equals("bj")) {
                // 创建北京pizza
                new BJOrderPizza();
            }else {
                new LDOrderPizza();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.工厂方法模式;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 简单工厂模式：pizza案例
 *      -- OrderPizza订购披萨
 *
 * @author Liu_zimo
 * @version v0.1 by 2021/3/4 14:46
 */
public abstract class OrderPizza {
    // 定义抽象方法，createPizza，让各个工厂子类自己实现
    abstract Pizza createPizza(String orderType);
    public OrderPizza() {
        Pizza pizza = null;
        String orderType;   // 订购披萨的类型
        do {
            orderType = getType();
            pizza = createPizza(orderType);
            pizza.setName(orderType);
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }while (true);
    }
    private String getType(){
        try {
            BufferedReader str = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String s = str.readLine();
            return s;
        }catch (IOException e){
            e.printStackTrace();
            return "";
        }
    }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.工厂方法模式;
/**
 * 工厂方法模式: 披萨实例
 *      -- LDOrderPizza伦敦工厂实例
 *
 * @author Liu_zimo
 * @version v0.1 by 2021/3/4 16:52
 */
public class LDOrderPizza extends OrderPizza {
    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")){
            pizza = new CheesePizza_LD();
        }else if (orderType.equals("greek")){
            pizza = new GreekPizza_LD();
        }
        return pizza;
    }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.工厂方法模式;
/**
 * 工厂方法模式: 披萨实例
 *      -- BJOrderPizza北京工厂实例
 *
 * @author Liu_zimo
 * @version v0.1 by 2021/3/4 16:52
 */
public class BJOrderPizza extends OrderPizza {
    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")){
            pizza = new CheesePizza_BJ();
        }else if (orderType.equals("greek")){
            pizza = new GreekPizza_BJ();
        }
        return pizza;
    }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.工厂方法模式;
/**
 * 工厂方法模式：pizza案例
 *      -- 伦敦GreekPizza
 *
 * @author Liu_zimo
 * @version v0.1 by 2021/3/4 14:45
 */
public class GreekPizza_LD extends Pizza {
    @Override
    public void prepare() {
        System.out.println("给制作《伦敦希腊披萨》准备的原材料");
    }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.工厂方法模式;
/**
 * 工厂方法模式：pizza案例
 *      -- 北京GreekPizza
 *
 * @author Liu_zimo
 * @version v0.1 by 2021/3/4 14:45
 */
public class GreekPizza_BJ extends Pizza {
    @Override
    public void prepare() {
        System.out.println("给制作《北京希腊披萨》准备的原材料");
    }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.工厂方法模式;
/**
 * 工厂方法模式：pizza案例
 *      -- 伦敦CheesePizza实现
 *
 * @author Liu_zimo
 * @version v0.1 by 2021/3/4 14:36
 */
public class CheesePizza_LD extends Pizza {
    @Override
    public void prepare() {
        System.out.println("给制作《伦敦奶酪披萨》准备的原材料");
    }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.工厂方法模式;
/**
 * 工厂方法模式：pizza案例
 *      -- 北京CheesePizza实现
 *
 * @author Liu_zimo
 * @version v0.2 by 2021/3/4 16:41
 */
public class CheesePizza_BJ extends Pizza {
    @Override
    public void prepare() {
        System.out.println("给制作《北京奶酪披萨》准备的原材料");
    }
}

抽象工厂模式

基本介绍

1. 抽象工厂模式：定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类
2. 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
3. 从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
4. 将工厂抽象成两层，AbsFactory(抽象工厂)和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。
   

package com.zimo.设计模式.工厂模式.抽象工厂模式;

/**
 * 抽象工厂模式：披萨实例
 *      -- AbsFactory 抽象工厂接口
 *
 * @author Liu_zimo
 * @version v0.1 by 2021/3/4 17:27
 */
public interface AbsFactory {
    // 让子类实现
    public Pizza createPizza(String orderType);
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.抽象工厂模式;

public class CheesePizza_BJ extends Pizza {
    @Override
    public void prepare() { System.out.println("给制作《北京奶酪披萨》准备的原材料"); }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.抽象工厂模式;

public class CheesePizza_LD extends Pizza {
    @Override
    public void prepare() { System.out.println("给制作《伦敦奶酪披萨》准备的原材料"); }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.抽象工厂模式;
/**
 * 抽象工厂模式：披萨实例
 *      -- Factory_BJ北京工厂实例
 *
 * @author Liu_zimo
 * @version v0.1 by 2021/3/4 17:29
 */
public class Factory_BJ implements AbsFactory{
    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if(orderType.equals("cheese")){
            pizza = new CheesePizza_BJ();
        }else {
            pizza = new GreekPizza_BJ();
        }
        return pizza;
    }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.抽象工厂模式;
/**
 * 抽象工厂模式：披萨实例
 *      -- Factory_LD伦敦工厂实例
 *
 * @author Liu_zimo
 * @version v0.1 by 2021/3/4 17:29
 */
public class Factory_LD implements AbsFactory{
    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if(orderType.equals("cheese")){
            pizza = new CheesePizza_LD();
        }else {
            pizza = new GreekPizza_LD();
        }
        return pizza;
    }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.抽象工厂模式;

public class GreekPizza_BJ extends Pizza {
    @Override
    public void prepare() { System.out.println("给制作《北京希腊披萨》准备的原材料"); }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.抽象工厂模式;

public class GreekPizza_LD extends Pizza {
    @Override
    public void prepare() { System.out.println("给制作《伦敦希腊披萨》准备的原材料"); }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.抽象工厂模式;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class OrderPizza {
    AbsFactory absFactory;

    public OrderPizza(AbsFactory absFactory) {
        setAbsFactory(absFactory);
    }
    private void setAbsFactory(AbsFactory absFactory) {
        Pizza pizza = null;
        String orderType = "";
        this.absFactory = absFactory;
        do {
            orderType = getType();
            pizza = absFactory.createPizza(orderType);
            if(pizza != null){
                pizza.setName(orderType);
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else {
                System.out.println("订购失败");
                break;
            }
        }while (true);
    }
    private String getType(){
        try {
            BufferedReader str = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String s = str.readLine();
            return s;
        }catch (IOException e){
            e.printStackTrace();
            return "";
        }
    }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.抽象工厂模式;
public abstract class Pizza {
    protected String name;
    public abstract void prepare();             // 准备原材料，不同披萨不一样，因此做成抽象方法
    public void bake(){ System.out.println(name + " baking"); }
    public void cut() { System.out.println(name + " cutting"); }
    public void box(){ System.out.println(name + " boxing"); }
    public void setName(String name) { this.name = name; }
}
---------------------------------------------------------------------------------------------
package com.zimo.设计模式.工厂模式.抽象工厂模式;

public class PizzaStore {
    public static void main(String[] args) { new OrderPizza(new Factory_BJ()); }
}

工厂模式在JDK中的应用

1. JDK中的Calendar类中，使用了简单工厂模式

public class test{
    public static void main(String args[]){
        Calendar.getInstance();		// return createCalendar(时区，地区) --> provider.getInstance()
    }
}

工厂模式小结

1. 工厂模式的意义
   将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解藕。从而提高项目的扩展和维护性。
2. 三种工厂模式（简单工厂模式、工厂方法模式、抽象工厂模式）
3. 设计模式的依赖抽象原则

创建对象实例时，不要直接new类，而是把这个new类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。
不要让类继承具体类，而是继承抽象类或者是实现interface(接口)
不要覆盖基类中已经实现的方法。