• 工厂模式

    概述

    工厂模式是一个创建型模式，将对象的实例化从new方式改为工厂的方法，将选择实现类，创建对象统一管理和控制，实现调用者和实现类解耦

    简单工厂模式

    基本介绍

    1. 简单工厂模式属于创建型模式，是工厂模式的一种，简单工厂模式是由一个工厂对象决定创建哪一种产品类的实例
    2. 简单工厂模式定义了一个创建对象的类，有这个类来封装实例化对象的行为
    3. 在软件开发中，如果会用到大量的创建某种、某类或者某批对象时，就会用到工厂模式

    案例

    假设一个披萨店项目

    1. 披萨种类有很多，如GreekPizza、CheesePizza等
    2. 披萨的制作流程有prepare、bake、cut、box
    3. 完成披萨的订购制作功能

    传统方式

    /***
 * @author shaofan
 * @Description 未使用简单工厂模式的方式
 */
public class PizzaStore {
    public static void main(String[] args) {
        new OrderPizza1();
    }
}

abstract class Pizza{
    abstract void prepare();
    abstract void bake();
    abstract void cut();
    abstract void box();

}

class CheesePizza extends Pizza{

    @Override
    void prepare() {
        System.out.println("CheesePizza prepare");
    }

    @Override
    void bake() {
        System.out.println("CheesePizza bake");
    }

    @Override
    void cut() {
        System.out.println("CheesePizza cut");
    }

    @Override
    void box() {
        System.out.println("CheesePizza box");
    }
}

class GreekPizza extends Pizza{

    @Override
    void prepare() {
        System.out.println("GreekPizza prepare");
    }

    @Override
    void bake() {
        System.out.println("GreekPizza bake");
    }

    @Override
    void cut() {
        System.out.println("GreekPizza cut");
    }

    @Override
    void box() {
        System.out.println("GreekPizza box");
    }
}

/***
 * 披萨订购
 */
class OrderPizza1{
    public OrderPizza1(){
        Pizza pizza = null;
        String orderType;
        while (true){
            orderType = getOrderType();
            switch(orderType){
                case "Cheese":
                    pizza = new CheesePizza();
                    break;
                case "Greek":
                    pizza = new GreekPizza();
                    break;
                default:
                    System.out.println("finish");
                    System.exit(0);
            }
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }
    }

    private String getOrderType(){
        Scanner in = new Scanner(System.in);
        System.out.println("请输入披萨种类");
        return in.next();
    }
}

/***
 * 披萨订购
 */
class OrderPizza2{
    public OrderPizza2(){
        Pizza pizza = null;
        String orderType;
        while (true){
            orderType = getOrderType();
            switch(orderType){
                case "Cheese":
                    pizza = new CheesePizza();
                    break;
                case "Greek":
                    pizza = new GreekPizza();
                    break;
                default:
                    System.out.println("finish");
                    System.exit(0);
            }
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }
    }

    private String getOrderType(){
        Scanner in = new Scanner(System.in);
        System.out.println("请输入披萨种类");
        return in.next();
    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133

    如果需要增加一款披萨，这个时候除了扩展一个新的类继承Pizza，还需要修改Pizza的调用方OrderPizza的代码，违反了开闭原则；加上不同的店铺可能有不同的orderPizza方式，导致增加一个pizza每个OrderPizza都要修改
    如果我们把创建Pizza对象封装到一个类中，当出现新的Pizza种类时，就只用修改该类；将Pizza对象的实例化和OrderPizza调用方隔离

    使用简单工厂模式

    /***
 * @author shaofan
 * @Description 使用简单工厂模式的改进
 */
public class PizzaStore {
    public static void main(String[] args) {
        new OrderPizza(new SimpleFactory()).order();
    }
}

/***
 * 披萨简单工厂
 */
class SimpleFactory{
    public Pizza createPizza(String orderType){
        Pizza pizza = null;
        switch(orderType){
            case "Cheese":
                pizza = new CheesePizza();
                break;
            case "Greek":
                pizza = new GreekPizza();
                break;
            default:
                System.out.println("订购失败");
                return pizza;
        }
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

class OrderPizza{
    private SimpleFactory simpleFactory;

    public OrderPizza(SimpleFactory simpleFactory) {
        this.simpleFactory  =simpleFactory;
    }

    public void setSimpleFactory(SimpleFactory simpleFactory) {
        this.simpleFactory = simpleFactory;
    }

    public void order(){
        while(true){
            String orderType = getOrderType();
            if(orderType.equals("exit")){
                break;
            }
            simpleFactory.createPizza(orderType);
        }
    }

    private String getOrderType(){
        Scanner in = new Scanner(System.in);
        System.out.println("请输入披萨种类");
        return in.next();
    }
}

abstract class Pizza{
    abstract void prepare();
    abstract void bake();
    abstract void cut();
    abstract void box();

}

class CheesePizza extends Pizza {

    @Override
    void prepare() {
        System.out.println("CheesePizza prepare");
    }

    @Override
    void bake() {
        System.out.println("CheesePizza bake");
    }

    @Override
    void cut() {
        System.out.println("CheesePizza cut");
    }

    @Override
    void box() {
        System.out.println("CheesePizza box");
    }
}

class GreekPizza extends Pizza {

    @Override
    void prepare() {
        System.out.println("GreekPizza prepare");
    }

    @Override
    void bake() {
        System.out.println("GreekPizza bake");
    }

    @Override
    void cut() {
        System.out.println("GreekPizza cut");
    }

    @Override
    void box() {
        System.out.println("GreekPizza box");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117

    使用一个简单工厂将对象的创建和调用分离，这样不论多少个OrderPizza类，他们都从SimpleFactory来获取Pizza，对于新增的Pizza只用修改SimpleFactory即可

    工厂方法模式

    基本介绍

    基于简单工厂模式，可以发现是根据参数的不同来生成不同的对象实例，在扩展的时候需要修改工厂的代码，工厂方法模式旨在将不同实体的实例由不同的工厂来创建，在扩展的时候，只需要新增新的工厂和实体类，不需要修改代码

    案例

    /***
 * @author shaofan
 * @Description 工厂方法模式
 */
public class FactoryMethod {
    public static void main(String[] args) {
        new BenchCarFactory().createCar();
        new TeslaCarFactory().createCar();
    }
}

interface CarFactory{
    Car createCar();
}

class BenchCarFactory implements CarFactory{

    @Override
    public Car createCar() {
        return new BenchCar();
    }
}

class TeslaCarFactory implements CarFactory{

    @Override
    public Car createCar() {
        return new TeslaCar();
    }
}

abstract class Car{
    String name;
}

class BenchCar extends Car{
    public BenchCar(){
        this.name = "奔驰";
    }
}
class TeslaCar extends Car{
    public TeslaCar(){
        this.name = "特斯拉";
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

    实体继承一个抽象类Car，工厂也实现一个接口CarFactory，每个工厂只负责自己的这一个产品的创建，需要新增产品时，新增一个产品类和一个工厂，而不用覆盖代码

    抽象工厂模式

    产品等级和产品族

    1. 产品等级是指产品的产品的继承结构，继承自同一父类的产品属于同一等级，比如小米手机、华为手机等都继承自手机类
    2. 产品族是指同一个工厂生产的，位于不同产品等级结构的一组产品，比如小米路由器、小米手机，他们都会由小米工厂生产，但是一个位于手机等级，一个位于路由器等级，他们属于同一产品族，而不是同一等级

    基本介绍

    抽象工厂模式定义了一个interface用于创建相关或有依赖关系的产品族，而无需指明具体的类，这个创建多个等级的同族产品的工厂就是抽象工厂

    案例

    /***
 * @author shaofan
 * @Description 抽象工厂模式
 */
public class AbsFactory {
}

/***
 * 手机等级产品
 */
abstract class Phone{
    abstract void start();
    abstract void shutDown();
    abstract void call();
}

class XiaomiPhone extends Phone{

    @Override
    void start() {
        System.out.println("小米手机启动");
    }

    @Override
    void shutDown() {
        System.out.println("小米手机关闭");
    }

    @Override
    void call() {
        System.out.println("小米手机通话");
    }
}

class HuaweiPhone extends Phone{
    @Override
    void start() {
        System.out.println("华为手机启动");
    }

    @Override
    void shutDown() {
        System.out.println("华为手机关闭");
    }

    @Override
    void call() {
        System.out.println("华为手机通话");
    }
}
/***
 * 路由器等级产品
 */
abstract class Router{
    abstract void start();
    abstract void shutDown();
    abstract void setting();
}

class XiaomiRouter extends Router{

    @Override
    void start() {
        System.out.println("小米路由器启动");
    }

    @Override
    void shutDown() {
        System.out.println("小米路由器关闭");
    }

    @Override
    void setting() {
        System.out.println("小米路由器设置");
    }
}

class HuaweiRouter extends Router{
    @Override
    void start() {
        System.out.println("华为路由器启动");
    }

    @Override
    void shutDown() {
        System.out.println("华为路由器关闭");
    }

    @Override
    void setting() {
        System.out.println("华为路由器设置");
    }
}

/***
 * 抽象产品工厂
 */
interface AbstractFactory{
    Phone createPhone();
    Router createRouter();
}

class XiaomiFactory implements AbstractFactory{

    @Override
    public Phone createPhone() {
        return new XiaomiPhone();
    }

    @Override
    public Router createRouter() {
        return new XiaomiRouter();
    }
}

class HuaweiFactory implements AbstractFactory{

    @Override
    public Phone createPhone() {
        return new HuaweiPhone();
    }

    @Override
    public Router createRouter() {
        return new HuaweiRouter();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127

    JDK源码分析

    JDK中的Calendar类中，使用到了简单工厂模式
    在这里插入图片描述
    在Calendar.getInstance()中，通过传入的时区参数，来创建不同时区的Calendar对象

    总结

    1. 简单工厂，重点在于caller通过参数创建不同类型的对象，而不直接创建，将对象的创建和caller隔离，在扩展同等级的对象时，只需要修改创建对象的工厂即可，与caller解耦
    2. 工厂方法，为了保存旧代码，扩展功能时不对代码进行修改，同一等级的不同对象有自己的工厂，每个工厂只创建自己的对象，这样在扩展的时候只用创建一个工厂类和一个对象类，不用修改代码
    3. 抽象工厂，对具有相同特点的同一对象族进行抽象，得到的抽象工厂可以创建同一个对象族不同等级的对象，一个工厂类对应一个对象族，一个方法对应一个对象等级
  • 相关阅读:
    Vue 模板语法 v-bind
    国债期货合约代码是什么字母
    sql添加索引
    因特网中的DNS域名系统
    Logistic回归——银行违约情况分析
    Python无废话-办公自动化Excel读取操作
    企业微信获取客户群里用户的unionid；企业微信获取客户详情
    Android项目网络请求支持Brotli压缩记录
    GDPU 数据结构 天码行空8
    python - 数据类型及结构
  • 原文地址：https://blog.csdn.net/m0_48468380/article/details/126032991