java23种设计模式-创建型模式-原型模式

一、定义

原型模式是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

 

二、优点及缺点

优点：

　　 1、性能提高。

　　 2、避免多次创建复杂对象。

缺点：

　　1、必须实现 Cloneable 接口。

 

三、代码实现：

直接上深拷贝了，我这个Phone的拷贝方式就是浅拷贝，这个Person实现的就是深拷贝，说白了，深拷贝和浅拷贝的区别就是，深拷贝把自己引用对象的值也拷贝一下子，上代码了：

Person类：

/**
 *  @author: wsq
 *  @Date: 2020/9/24 9:51
 *  @Description: 人员类
 */
public class Person implements Cloneable {
    private int id;
    private String name;
    private Phone phone;

    public int getId() {
        return id;
    }

    public Person setId(int id) {
        this.id = id;
        return this;
    }

    public String getName() {
        return name;
    }

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

    public Phone getPhone() {
        return phone;
    }

    public Person setPhone(Phone phone) {
        this.phone = phone;
        return this;
    }
    public static Person build(){
        return new Person();
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", phone=" + phone +
                '}';
    }
    public Object clone(){
        Object o = null;
        try {
            o = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        Person p = (Person)o;
        p.phone = (Phone) p.getPhone().clone();
        return o;
    }
}

 

Phone类：

/**
 *  @author: wsq
 *  @Date: 2020/9/24 9:51
 *  @Description: 电话类
 */
public class Phone implements Cloneable{
    private String name;
    private double price;

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public Phone setPrice(double price) {
        this.price = price;
        return this;
    }
    public static Phone build(){
        return new Phone();
    }

    @Override
    public String toString() {
        return "Phone{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
    public Object clone(){
        Object o = null;
        try {
            o = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return o;
    }
}

 

测试类：

/**
 *  @author: wsq
 *  @Date: 2020/9/24 10:02
 *  @Description: 测试类
 */
public class Test {
    public static void main(String[] args) {
        Phone phone = Phone.build().setName("华为").setPrice(1222.99);
        Person p = Person.build().setId(1).setName("李明").setPhone(phone);
        System.out.println(p);
        System.out.println("----------");
        Person p1= (Person) p.clone();
        System.out.println(p1);
    }
}

 

四、源码级别

 其实大家都非常熟悉的ArrayList类就使用到了克隆的方法，来看一眼源码吧

 

 先克隆对象本身，然后进行数组的克隆，还是深拷贝，这就是很典型的原型模式

五、总结

使用场景

　　1、需要对一个类创建多次时候，可以使用克隆，效率会高很多。

　　2、如果一个对象的初始化需要很多其他对象的数据准备或其他资源的繁琐计算，那么可以使用原型模式。

　　3、当需要一个对象的大量公共信息，少量字段进行个性化设置的时候，也可以使用原型模式拷贝出现有对象的副本进行加工处理。

 

 发现有个大佬写的这个设计模式很有趣，我也借鉴了一下他的博客：https://www.cnblogs.com/fengyumeng/p/10646487.html