工厂模式

简单工厂模式

看一个具体的需求

一个关于披萨的项目：要便于披萨种类的扩展，要便于维护

• 披萨的种类很多，(比如：GreekPize，CheesePize 等)
• 披萨的制作有 prepare,bake,cut,box
• 完成披萨店的订购功能

使用传统的方式来完成

思路分析：使用类图

代码完成：

package com.atguigu.factory.simple;

public class OrderPizzaTest {
package com.atguigu.factory.use;

public class OrderPizzaTest {
    public static void main(String[] args) {
        CheesePizza cheesePizza = new CheesePizza();
        cheesePizza.prepare();

        GreekPizza greekPizza = new GreekPizza();
        greekPizza.prepare();

    }
}

开始准备奶酪披萨
开始准备希腊披萨

改进的思路分析：把创建Pizza 对象封装到一个类中，这样我们有新的Pizza 种类时，只需要修改该类即可，其他订购Pizza的对象代码不需要修改 – 简单工厂模式

简单工厂模式介绍

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

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

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

注：简单工厂模式又称静态工厂模式，但是违反 ocp 原则，

使用简单工厂模式

简单工厂公式的设计方案：定义一个可以实例化 Pizza 对象的类，封装创建对象的代码

代码实现：

pizza 实现规范类 ： 使用接口更好后续代码会进行修改

package com.atguigu.factory.simplefactory;

public abstract class Pizza {
    abstract void prepare();
    void bake(){
        System.out.println("开始烘烤");
    }

    void cut(){
        System.out.println("切割分片");
    }

    void box(){
        System.out.println("装箱运输");
    }
}

奶酪披萨：Pizza种类1

package com.atguigu.factory.simplefactory;

public class CheesePizza extends Pizza {

    @Override
    void prepare() {
        System.out.println("开始准备奶酪披萨");
    }
}

希腊披萨：Pizza 种类2

package com.atguigu.factory.simplefactory;

public class GreekPizza extends Pizza {

    @Override
    void prepare() {
        System.out.println("开始准备希腊披萨");
    }
}

胡椒披萨：Pizza种类3

package com.atguigu.factory.simplefactory;

public class PepperPizza extends Pizza {
    @Override
    void prepare() {
        System.out.println("准备胡椒披萨");
    }
}

SimpleFactory ：Pizza代工厂

package com.atguigu.factory.simplefactory;

//简单工厂类
public class SimpleFactory {

    public static Pizza makePizza(String orderType){
        if("cheese".equalsIgnoreCase(orderType)){
            return  new CheesePizza();
        }
        else if("greek".equalsIgnoreCase(orderType)){
            return  new GreekPizza();
        }else if("pepper".equalsIgnoreCase(orderType)){
            return  new PepperPizza();
        }

        return null;
    }
}

OrderPizzaTest ：测试类

package com.atguigu.factory.simplefactory;

public class OrderPizzaTest {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Pizza pizza = factory.makePizza("pepper");
        if(pizza != null){
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }else{
            System.out.println("本店没有您需要的披萨");
        }
    }
}

工厂方法模式

需求

一个关于披萨的项目：要便于披萨种类的扩展，要便于维护

• 披萨的种类很多，(比如：GreekPize，CheesePize 等)
• 披萨的制作有 prepare
• 完成披萨店的订购功能

工厂方法模式介绍

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

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

使用工厂方法模式

类图分析：

代码实现：

Pizza类：制作Pizza规范

package com.atguigu.factory.method;

public interface Pizza {
    void prepared();
}

CheesePizza 类：Pizza种类1

package com.atguigu.factory.method;

public class CheesePizza implements Pizza{
    @Override
    public void prepared() {
        System.out.println("开始制作奶酪披萨");
    }
}

GreekPizza 类：Pizza种类2

package com.atguigu.factory.method;

public class GreekPizza implements Pizza {
    @Override
    public void prepared() {
        System.out.println("开始制作希腊披萨");
    }
}

Factory ：工厂规范

package com.atguigu.factory.method;

public interface Factory {
    Pizza getPizza();
}

CheeseFactory ：奶酪披萨工厂，返回奶酪披萨实例

package com.atguigu.factory.method;

public class CheeseFactory implements Factory{
    @Override
    public Pizza getPizza() {
        return new CheesePizza();
    }
}

GreekFactory ：希腊披萨工厂，返回希腊披萨实例

package com.atguigu.factory.method;

public class GreekFactory implements Factory{
    @Override
    public Pizza getPizza() {
        return new GreekPizza();
    }
}

OrderPizza ：消费者订购披萨

package com.atguigu.factory.method;

public class OrderPizza {
    public static void main(String[] args) {
        Pizza cheese = new CheeseFactory().getPizza();
        cheese.prepared();

        Pizza greek = new GreekFactory().getPizza();
        greek.prepared();
    }
}

抽象工厂模式

基本介绍

抽象工厂模式：定义了一个interface 用于创建相关或有依赖关系的对象族，而无需指明具体的类

将工厂抽象为两层，AbsFactory(抽象工厂) 和 具体实现的工厂子类，程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂族，更利于代码的维护和扩展

使用场景：

• 客户端 (应用层) 不依赖于产品类实例如何被创建，实现等细节
• 强调一系列相关的产品对象 ( 属于同一产品族) 一起使用创建对象需要大量的重复代码
• 提供一个产品类的库，树油的产品以同样的接口出现，从而使得客户端不依赖于具体的实现

优点：

• 具体产品在应用层的代码隔离，无序关系创建的细节
• 将一个系列的产品统一到一起创建

缺点：

• 规定了所有可能被创建的产品集合，产品族中扩展新的产品非常困难
• 增加了系统的抽象性和理解难度

使用抽象工厂

图片表示：

类图实现：

Client代码展示：

package com.atguigu.factory.absfactory;

public class Client {
    public static void main(String[] args) {
        System.out.println("--------小米系列产品----------");
        //小米工厂
        XIfactory xifactory = new XIfactory();

        Iphone xiphone = xifactory.phone();
        xiphone.start();
        xiphone.shutdown();

        Irouter xirouter = xifactory.router();
        xirouter.openWifi();

        System.out.println("--------华为系列产品----------");
        //华为工厂
        HWfactory hwfactory = new HWfactory();

        Iphone hwphone = hwfactory.phone();
        hwphone.start();
        hwphone.shutdown();

        Irouter hwrouter = hwfactory.router();
        hwrouter.openWifi();

    }
}

--------小米系列产品----------
小米手机开机
小米手机关机
打开小米路由器
--------华为系列产品----------
华为手机开机
华为手机关机
打开华为路由器

小结

工厂模式的核心本质：

• 实例化对象不适用new ，用工厂方法代替
• 将选择实现类，创建对象统一管理和控制，从而将调用者跟实现类解耦

三种模式：

• 简单工厂模式：用来生产同一等级结构中的任意产品 (对于增加新的产品，需要修改现有的代码)
  虽然某种程度上不符合 ocp 原则，但实际上使用最多
• 工厂方法模式：用来生产同一等级结构中的任意产品 (支持增加任意产品)
  不修改已有类的情况下，通过增加新的工厂类来实现
• 抽象工厂模式：围绕一个超级工程创建其他工厂，该超级工程又称为其他工厂的工厂
  不可以增加产品，但可以增加产品族

参考文献

链接：尚硅谷Java设计模式
链接：通俗易懂的23种设计模式教学(停更)