【设计模式】设计模式——创建型

总览https://www.cnblogs.com/OhOfCourse/p/17163285.html

创建型，主要解决如何灵活创建对象或者类的问题。

注：从OneNote搬运过来，缺少一些UML图和代码示例。

 

一.简单工厂

1.0参考资料

 

1.1说明

 又称静态工厂模式，根据输入参数进行分case处理、创建对应的对象并返回

1.2示例

 

1.3优缺点

优点

客户端与产品的创建分离，客户端不需要知道产品创建的逻辑，只需要消费该产品即可。

缺点

工厂类集成了所有产品的创建逻辑，当工厂类出现问题，所有产品都会出现问题；
当新增加产品都会修改工厂类，违背开闭原则

 

二.工厂模式

2.0参考资料

 

2.1说明

 多态性工厂模式

 

2.2示例

 

2.3优缺点

优点

更符合开闭原则，增加一个产品类，则只需要实现其他具体的产品类和具体的工厂类即可；
符合单一职责原则，每个工厂只负责生产对应的产品

缺点

增加一个产品，就需要实现对应的具体工厂类和具体产品类；
每个产品需要有对应的具体工厂和具体产品类

 

三.抽象工厂

3.0参考资料

抽象工厂

3.1说明

封装出一个接口，这个接口负责创建一系列互相关联的对象，但用户在使用接口时不需要指定对象所在的具体的类。
抽象工厂模式为一个产品家族提供了统一的创建接口。当需要这个产品家族的某一系列的时候，可以从抽象工厂中选出相对应的系列来创建一个具体的工厂类别。
抽象工厂模式与工厂方法模式最大的区别在于，工厂方法模式针对的是一种产品的继承结构，而抽象工厂模式需要面对多个产品的继承结构。

3.2模式中的各角色

抽象工厂（AbstractFactory）：担任这个角色的是工厂方法模式的核心，它是与应用系统商业逻辑无关的。

具体工厂（ConcreteFactory）：这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。
抽象产品（AbstractProduct）：担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。
具体产品（ConcreteProduct）：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。这是客户端最终需要的东西，其内部一定充满了应用系统的商业逻辑

3.3示例

 

3.4优缺点

优点

具体产品从客户代码中被分离出来
容易改变产品的系列
将一个系列的产品族统一到一起创建

缺点

在产品族中扩展新的产品是很困难的，它需要修改抽象工厂的接口，如增加一种产品变得非常麻烦

 

四.建造者模式

4.0参考资料

 

4.1说明

 将一个复杂对象的构建与其表示分离，使得同样的构建方法可以创建不同的表示(因为构建过程不同)。

一句话来说，当一个类的构造函数参数个数超过4个，而且这些参数有些是可选的参数，考虑使用构造者模式。
总结来说适用以下两个场景：
（1）创建一个对象，由于构建方法调用顺序的不同而产生的结果不同；
（2）创建一个对象，过程复杂、参数众多，而且很多参数都有默认值(意味着不必实例化时必须传入)。

 最常见的例子：StringBuilder的append、reverse的调用顺序不同，最后的ToString结果就不同

 

4.2示例

 历史老旧方法，折叠构造函数，使用起来容易但理解成本高

public class Computer {
        public Computer(String cpu, String ram) {
        this(cpu, ram, 0);
    }
    public Computer(String cpu, String ram, int usbCount) {
        this(cpu, ram, usbCount, "罗技键盘");
    }
    public Computer(String cpu, String ram, int usbCount, String keyboard) {
        this(cpu, ram, usbCount, keyboard, "三星显示器");
    }
    public Computer(String cpu, String ram, int usbCount, String keyboard, String display) {
        this.cpu = cpu;
        this.ram = ram;
        this.usbCount = usbCount;
        this.keyboard = keyboard;
        this.display = display;
    }
}
JavaBean模式，构件过程取决于客户端，容易出错
public class Computer {
public String getCpu() {
        return cpu;
    }
    public void setCpu(String cpu) {
        this.cpu = cpu;
    }
    public String getRam() {
        return ram;
    }
    public void setRam(String ram) {
        this.ram = ram;
    }
    public int getUsbCount() {
        return usbCount;
    }
}

简化实现方式，核心是链式调用

（1）在Computer 中创建一个静态内部类 Builder，然后将Computer 中的参数都复制到Builder类中。

（2）在Computer中创建一个private的构造函数，参数为Builder类型

（3）在Builder中创建一个public的构造函数，参数为Computer中必填的那些参数，cpu 和ram。

（4）在Builder中创建设置函数，对Computer中那些可选参数进行赋值，返回值为Builder类型的实例

（5）在Builder中创建一个build()方法，在其中构建Computer的实例并返回

public class Computer {
    private final String cpu;//必须
    private final String ram;//必须
    private final int usbCount;//可选
    private final String keyboard;//可选
    private final String display;//可选

private Computer(Builder builder){
        this.cpu=builder.cpu;
        this.ram=builder.ram;
        this.usbCount=builder.usbCount;
        this.keyboard=builder.keyboard;
        this.display=builder.display;
    }

    public static class Builder{
        private String cpu;//必须
        private String ram;//必须
        private int usbCount;//可选
        private String keyboard;//可选
        private String display;//可选

public Builder(String cup,String ram){
            this.cpu=cup;
            this.ram=ram;
        }
public Builder setUsbCount(int usbCount) {
            this.usbCount = usbCount;
            return this;
        }
        public Builder setKeyboard(String keyboard) {
            this.keyboard = keyboard;
            return this;
        }
        public Builder setDisplay(String display) {
            this.display = display;
            return this;
        }        
        public Computer build(){
            return new Computer(this);
        }
    }
}
客户端使用
Computer computer=new Computer.Builder("因特尔","三星")
                .setDisplay("三星24寸")
                .setKeyboard("罗技")
                .setUsbCount(2)
                .build();

 

4.3优缺点

 

五.单例模式

5.0参考资料

 

5.1说明

 注意双检锁

5.2示例

 

5.3优缺点

 

六.原型模式

6.0参考资料

 

6.1说明

需求来源

（1）用于解决大量相同或相似对象的创建问题,
（2）保护性拷贝，防止外部对只读对象进行修改。

解决方式

深拷贝而不是new，因为new比较耗资源

6.2示例

 

6.3优缺点