关于设计模式:05创建型模式工厂模式

36次阅读

共计 7880 个字符，预计需要花费 20 分钟才能阅读完成。

1 简略工厂模式

1.1 看一个具体的需要

看一个披萨的我的项目：要便于披萨品种的扩大，要便于保护

  1. 披萨的品种很多(比方 GreekPizz、CheesePizz 等)。
  2. 披萨的制作有 prepare，bake, cut, box。
  3. 实现披萨店订购性能。

1.2 应用传统的形式来实现

  1. 思路剖析(类图)
  2. 编写 OrderPizza.java 去订购须要的各种 Pizza
// 当新增一个 Pizza 品种时，须要批改 OrderPizza。当很多类用 OrderPizza 时，会面临很多批改。public class OrderPizza {public static void main(String[] args) {new OrderPizza();
    }
    
    // 结构器
    public OrderPizza() {
        Pizza pizza = null;
        String orderType; //  订购披萨的类型
        do {orderType = getType();
            if (orderType.equals("greek")) {pizza = new GreekPizza();
                pizza.setName("希腊披萨");
            } else if (orderType.equals("cheese")) {pizza = new CheesePizza();
                pizza.setName("奶酪披萨");
            } else {break;}
            // 输入 pizza 制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();} while (true);
    }

    // 获取客户心愿订购的 pizza 品种
    private String getType() {
        try {BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            return in.readLine();} catch (Exception e) {e.printStackTrace();
            return "";
        }
    }
}

public abstract class Pizza {
    protected String name;

    // 筹备原材料，不同 Pizza 不一样。因而定义为形象办法
    public abstract void prepare();

    public void bake() {System.out.println(name + "baking;");
    }

    public void cut() {System.out.println(name + "cuting;");
    }

    public void box() {System.out.println(name + "boxing;");
    }

    public void setName(String name) {this.name = name;}
}

public class CheesePizza extends Pizza{
    @Override
    public void prepare() {System.out.println("制作奶酪披萨，筹备原材料");
    }
}

public class GreekPizza extends Pizza {
    @Override
    public void prepare() {System.out.println("制作希腊披萨，筹备原材料");
    }
}

1.3 传统的形式的优缺点

  1. 长处是比拟好了解，简略易操作。
  2. 毛病是违反了设计模式的 ocp 准则，即对扩大凋谢，对批改敞开。即当咱们给类减少新性能的时候，尽量不批改代码，或者尽可能少批改代码.
  3. 比方咱们这时要新减少一个 Pizza 的品种(Pepper 披萨)，咱们须要做如下批改. 如果咱们减少一个 Pizza 类，只有是订购 Pizza 的代码都须要批改。

1.4 改良的思路剖析

剖析：批改代码能够承受，然而如果咱们在其它的中央也有创立 Pizza 的代码，就意味着，也须要批改，而创立 Pizza 的代码，往往有多处。

思路：把创立 Pizza 对象封装到一个类中，这样咱们有新的 Pizza 品种时，只须要批改该类就可，其它有创立到 Pizza 对象的代码就不须要批改了。-> 简略工厂模式

1.5 简略工厂模式根本介绍

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

1.6 应用简略工厂模式

简略工厂模式的设计方案: 定义一个能够实例化 Pizaa 对象的类，封装创建对象的代码。

代码示例：

// 简略工厂模式
public class SimpleFactory {

    // 更多 orderType 返回对应的 Pizza 对象。使用者无需关系证实创立 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("奶酪披萨");
        }
        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("奶酪披萨");
        }
        return pizza;
    }
}

应用简略工厂：新增 Pizza 品种时，OrderPizza 不必做任何批改。

public class OrderPizza2 {
    // 定义一个简略工厂对象
    private SimpleFactory simpleFactory;
    private Pizza pizza = null;

    // 结构器
    public OrderPizza2(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 in = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 品种:");
            String str = in.readLine();
            return str;
        } catch (IOException e) {e.printStackTrace();
            return "";
        }
    }

    public static void main(String[] args) {new OrderPizza2(new SimpleFactory());
    }
}

2 工厂办法模式

2.1 看一个新的需要

披萨我的项目新的需要：客户在点披萨时，能够点不同口味的披萨，比方 北京的奶酪 pizza、北京的胡椒 pizza 或者是伦敦的奶酪 pizza、伦敦的胡椒 pizza。

  1. 思路 1：
    应用简略工厂模式，创立不同的简略工厂类，比方 BJPizzaSimpleFactory、LDPizzaSimpleFactory 等等. 从以后这个案例来说，也是能够的，然而思考到我的项目的规模，以及软件的可维护性、可扩展性并不是特地好
  2. 思路 2：
    应用工厂办法模式

2.2 工厂办法模式介绍

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

2.3 工厂办法模式利用案例

  1. 披萨我的项目新的需要：客户在点披萨时，能够点不同口味的披萨，比方 北京的奶酪 pizza、北京的胡椒 pizza 或者是伦敦的奶酪 pizza、伦敦的胡椒 pizza。
  2. 思路剖析图解
  3. 代码实现
// 办法工厂
public abstract class MethodFactory {

    // 定义一个形象办法，createPizza ,  让各个工厂子类本人实现
    abstract Pizza createPizza(String orderType);

    // 结构器
    public MethodFactory() {
        Pizza pizza;
        String orderType; //  订购披萨的类型
        do {orderType = getType();
            pizza = createPizza(orderType); // 形象办法，由工厂子类实现
            // 输入 pizza 制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();} while (true);
    }

    // 写一个办法，能够获取客户心愿订购的披萨品种
    private String getType() {
        try {BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 品种:");
            String str = in.readLine();
            return str;
        } catch (IOException e) {e.printStackTrace();
            return "";
        }
    }
}

创立北京口味相干的 pizza：

public class BJPizzaFactory extends MethodFactory {
    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {pizza = new BJCheesePizza();
        } else if (orderType.equals("greek")) {pizza = new BJGreekPizza();
        }
        return pizza;
    }
}

创立伦敦口味相干的 pizza：

public class LDPizzaFactory extends MethodFactory {
    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {pizza = new LDCheesePizza();
        } else if (orderType.equals("greek")) {pizza = new LDGreekPizza();
        }
        return pizza;
    }
}
public abstract class Pizza {
    protected String name;
    // 筹备原材料，不同 Pizza 不一样。因而定义为形象办法
    public abstract void prepare();

    public void bake() {System.out.println(name + "baking;");
    }

    public void cut() {System.out.println(name + "cuting;");
    }

    public void box() {System.out.println(name + "boxing;");
    }

    public void setName(String name) {this.name = name;}

}

public class BJCheesePizza extends Pizza {
    @Override
    public void prepare() {System.out.println("制作北京奶酪披萨，筹备原材料");
    }
}

使用者应用对应的 Pizza：

public class OrderPizza {public static void main(String[] args) {
        // 北京口味的 Pizza
        new BJPizzaFactory();}
}

3 形象工厂模式

3.1 根本介绍

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

3.2 形象工厂模式利用实例

应用形象工厂模式来实现披萨我的项目：

// 一个形象工厂模式的形象层(接口)
public interface AbsFactory {
    // 让上面的工厂子类来 具体实现
    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("greek")) {pizza = new BJGreekPizza();
        }
        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("greek")) {pizza = new LDGreekPizza();
        }
        return pizza;
    }
}

Pizza：

public abstract class Pizza {

    protected String name;

    // 筹备原材料，不同 Pizza 不一样。因而定义为形象办法
    public abstract void prepare();

    public void bake() {System.out.println(name + "baking;");
    }

    public void cut() {System.out.println(name + "cuting;");
    }

    public void box() {System.out.println(name + "boxing;");
    }

    public void setName(String name) {this.name = name;}

}

public class BJCheesePizza extends Pizza {
    @Override
    public void prepare() {System.out.println("制作北京奶酪披萨，筹备原材料");
    }
}

public class BJGreekPizza extends Pizza {
    @Override
    public void prepare() {System.out.println("制作北京希腊披萨，筹备原材料");
    }
}

应用工厂：

public class OrderPizza {
    private AbsFactory factory;

    // 结构器
    public OrderPizza(AbsFactory factory) {setFactory(factory);
    }

    private void setFactory(AbsFactory factory) {
        Pizza pizza;
        String orderType = ""; //  用户输出
        this.factory = factory;
        do {orderType = getType();
            // factory  可能是北京的工厂子类，也可能是伦敦的工厂子类
            pizza = factory.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 in = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 品种:");
            return in.readLine();} catch (IOException e) {e.printStackTrace();
            return "";
        }
    }

    public static void main(String[] args) {new OrderPizza(new BJFactory());
    }
}

4 工厂模式在 JDK-Calendar 利用的源码剖析

  1. JDK 中的 Calendar 类中，就应用了简略工厂模式
  2. 源码剖析 +Debug 源码 + 阐明
  3. 简略工厂模式：

5 工厂模式小结

  1. 工厂模式的意义
    将实例化对象的代码提取进去，放到一个类中对立治理和保护，达到和主我的项目的依赖关系的解耦。从而进步我的项目的扩大和维护性。
  2. 三种工厂模式 (简略工厂模式、工厂办法模式、形象工厂模式)
  3. 设计模式的依赖形象准则
    创建对象实例时，不要间接 new 类, 而是把这个 new 类的动作放在一个工厂的办法中，并返回。有的书上说，变量不要间接持有具体类的援用。

不要让类继承具体类，而是继承抽象类或者是实现 interface(接口)

不要笼罩基类中曾经实现的办法。

正文完
设计模式
发表至： 设计模式
2021-07-06
 0
关于设计模式:设计模式学习笔记二十四策略模式
关于设计模式:设计模式学习笔记二十五模板方法模式
关于设计模式:设计模式学习笔记十二装饰模式
关于设计模式:设计模式工厂模式