Java学习——设计模式——创建型模式2

创建型模式

关注点是如何创建对象，核心思想是要把对象创建和使用相分离，这样两者能相对独立地变换

包括：
1、工厂方法：Factory Method
2、抽象工厂：Abstarct Factory
3、建造者：Builder
4、原型：Prototype
5、单例：Singleton

原型

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象
原型模式，是指创建新对象的时候，根据现有的一个原型来创建

结构
1、抽象原型类：规定了具体原型对象必须实现的clone()方法
2、具体原型类
3、访问类

使用场景：

• 对象的创建非常复杂，可以使用原型模式快捷的创建对象
• 性能和安全要求比较高

浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型，仍指向原有属性所指向的对象的内存地址
深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址

public class Realizetype implements Cloneable {
    public Realizetype(){
        System.out.println("具体原型对象创建成功");
    }
    @Override
    protected Realizetype clone() throws CloneNotSupportedException {
        System.out.println("具体原型对象复制成功");
        return (Realizetype) super.clone();
    }
}

public class Realizetype implements Cloneable {
    public Realizetype(){
        System.out.println("具体原型对象创建成功");
    }
    @Override
    protected Realizetype clone() throws CloneNotSupportedException {
        System.out.println("具体原型对象复制成功");
        return (Realizetype) super.clone();
    }
}

建造者模式

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

分离了部件的构造和装配，从而可以构造出复杂的对象。

适用于某个对象的构建过程复杂的情况

结构
1、抽象建造者类
2、具体建造者类
3、产品类
4、指挥者类

优点：

• 建造者模式封装性很好。
• 客户不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象
• 可以更加精细地控制产品的创建过程。
• 更容易扩展。有新的的需要，通过实现一个新的建造者类就可以完成。

缺点：所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，不适合使用建造者模式

使用场景：

• 创建的对象复杂，由多个部件构成，各部件面临着复杂的变化，但构件间的建造顺序是稳定的
• 创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的

扩展

在开发中常用的使用方式，就是当一个类构造器需要传入很多参数时，如果创建这个类的实例，代码的可读性会非常差，而且很容易引入错误，此时就可以利用建造者模式进行重构

重构前：

public class Phone {
private String cpu;
private String screen;
private String memory;
private String mainboard;
public Phone(String cpu, String screen, String memory, String
mainboard) {
this.cpu = cpu;
this.screen = screen;
this.memory = memory;
this.mainboard = mainboard;
}
public String getCpu() {
return cpu;
}
public void setCpu(String cpu) {
this.cpu = cpu;
}
public String getScreen() {
return screen;
}
public void setScreen(String screen) {
this.screen = screen;
}
public String getMemory() {
return memory;
}
public void setMemory(String memory) {
this.memory = memory;
}
public String getMainboard() {
return mainboard;
}
public void setMainboard(String mainboard) {
this.mainboard = mainboard;
}
@Override
public String toString() {
return "Phone{" +
"cpu='" + cpu + '\'' +
", screen='" + screen + '\'' +
", memory='" + memory + '\'' +
", mainboard='" + mainboard + '\'' +
'}';
}
}
public class Client {
public static void main(String[] args) {
//构建Phone对象
Phone phone = new Phone("intel","三星屏幕","金士顿","华硕");
System.out.println(phone);
}
}

重构后：

public class Phone {
    private String cpu;
    private String screen;
    private String memory;
    private String mainboard;

    private Phone(Builder builder) {
        cpu=builder.cpu;
        screen=builder.screen;
        memory=builder.memory;
        mainboard=builder.mainboard;
    }

    public static final class Builder{
        private String cpu;
        private String screen;
        private String memory;
        private String mainboard;

        public Builder(){}

        public Builder cpu(String val){
            cpu=val;
            return this;
        }

        public Builder mainboard(String val){
            mainboard=val;
            return this;
        }

        public Builder screen(String val){
            screen=val;
            return this;
        }

        public Builder memory(String val){
            memory=val;
            return this;
        }

        public Phone build(){
            return new Phone(this);
        }
    }

    @Override
    public String toString() {
        return "Phone{" +
                "cpu='" + cpu + '\'' +
                ", screen='" + screen + '\'' +
                ", memory='" + memory + '\'' +
                ", mainboard='" + mainboard + '\'' +
                '}';
    }
}
public class client {
    public static void main(String[] args) {
        Phone phone=new Phone.Builder()
                .cpu("cc")
                .mainboard("mainboard")
                .build();
        System.out.println(phone.toString());
    }
}

创建型模式对比

工厂方法模式vs建造者模式
工厂方法模式注重整体对象的创建方式，而建造者模式注重的是部件构造过程，意在通过一步一步地精确构造创建出一个复杂的对象

抽象工厂模式vs建造者模式
抽象工厂模式实现对产品家族的创建，一个产品家族是一系列产品，具有不同分类维度产品组合，采用抽象工厂模式不需要关系构建过程，只关心什么产品由什么工厂生产即可

建造者模式要求按照指定的蓝图建造产品，主要目的是通过组装零配件而产生一个新产品