设计模式之原型模式(Prototype)

最新推荐文章于 2024-05-08 01:10:01 发布

意田天

最新推荐文章于 2024-05-08 01:10:01 发布

阅读量1.1w

点赞数

分类专栏：设计模式文章标签：设计模式 prototype java

本文链接：https://blog.youkuaiyun.com/A_Java_Dog/article/details/117927826

版权

设计模式专栏收录该内容

13 篇文章

订阅专栏

本文探讨了原型模式在创建重复对象时的作用，并通过实例展示了浅克隆和深克隆的区别。在Java中，浅克隆无法完全复制复杂对象，例如当对象包含可变引用时，如Location对象。深克隆则可以解决这个问题，确保克隆后的对象与原对象相互独立。对于字符串，由于其不可变性，不需要深克隆。然而，对于可变对象如StringBuilder，不进行深克隆会导致副本与原对象同步变化。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

原型模式

原型模式

原型模式

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

这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。

在这里插入图片描述

浅克隆

package com.cyc.design.prototype.v1;

/**
 * 浅克隆
 */

public class Test {
    public static void main(String[] args) throws Exception {
        Person p1 = new Person();
        Person p2 = (Person)p1.clone();
        System.out.println(p2.age + " " + p2.score);
        System.out.println(p2.loc);

        System.out.println(p1.loc == p2.loc);
        //由于这里实现的浅克隆,p2中loc属性的引用和p1中的loc指向的是同一个地址,
        //因此,p1的loc.street值改变之后, 会影响p2.loc
        p1.loc.street = "sh";
        System.out.println(p2.loc);

    }
}

class Person implements Cloneable {
    int age = 8;
    int score = 100;

    Location loc = new Location("bj", 22);
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class Location {
    String street;
    int roomNo;

    @Override
    public String toString() {
        return "Location{" +
                "street='" + street + '\'' +
                ", roomNo=" + roomNo +
                '}';
    }

    public Location(String street, int roomNo) {
        this.street = street;
        this.roomNo = roomNo;
    }
}

深克隆

package com.cyc.design.prototype.v2;

/**
 * 深克隆的处理
 */
public class Test {
    public static void main(String[] args) throws Exception {
        Person p1 = new Person();
        Person p2 = (Person)p1.clone();
        System.out.println(p2.age + " " + p2.score);
        System.out.println(p2.loc);

        System.out.println(p1.loc == p2.loc);
        p1.loc.street = "sh";
        System.out.println(p2.loc);



    }
}

class Person implements Cloneable {
    int age = 8;
    int score = 100;

    Location loc = new Location("bj", 22);
    @Override
    public Object clone() throws CloneNotSupportedException {
        Person p = (Person)super.clone();
        p.loc = (Location)loc.clone();
        return p;
    }
}

/**
 * 这里让Location同样实现Cloneable接口,在Person克隆是,里面的属性location同样也克隆一份
 * 此时p2中的location和p1中的location便不再是同一个
 */
class Location implements Cloneable {
    String street;
    int roomNo;

    @Override
    public String toString() {
        return "Location{" +
                "street='" + street + '\'' +
                ", roomNo=" + roomNo +
                '}';
    }

    public Location(String street, int roomNo) {
        this.street = street;
        this.roomNo = roomNo;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

字符串需要深克隆吗

package com.cyc.design.prototype.v3;

/**
 * String需要进一步深克隆吗？
 */
public class Test {
    public static void main(String[] args) throws Exception {
        Person p1 = new Person();
        Person p2 = (Person)p1.clone();
        System.out.println(p2.age + " " + p2.score);
        System.out.println(p2.loc);

        System.out.println(p1.loc == p2.loc);
        p1.loc.street = "sh";
        System.out.println(p2.loc);

        p1.loc.street.replace("sh", "sz");
        System.out.println(p2.loc.street);
    }
}

class Person implements Cloneable {
    int age = 8;
    int score = 100;

    Location loc = new Location("bj", 22);
    @Override
    public Object clone() throws CloneNotSupportedException {
        Person p = (Person)super.clone();
        p.loc = (Location)loc.clone();
        return p;
    }
}

class Location implements Cloneable {
    //因为String类型指向的本来就一个常量池, 常量池中有bj和sh,
    // 第一个p1中的loc.street指向的是常量池中的bj,克隆出来的p2中的loc.street指向的也是bj
    // 虽然p1.loc.street和p2.loc.street指向的都是常量池中同一个bj,
    // 改变p1里面的内容,让其指向sh,但是克隆出来的那个p2依然指向的是bj, 因此字符串不需要深克隆
    String street;
    int roomNo;

    @Override
    public String toString() {
        return "Location{" +
                "street='" + street + '\'' +
                ", roomNo=" + roomNo +
                '}';
    }

    public Location(String street, int roomNo) {
        this.street = street;
        this.roomNo = roomNo;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

StringBuilder 克隆

package com.cyc.design.prototype.v4;

/**
 * String需要进一步深克隆吗？
 */
public class Test {
    public static void main(String[] args) throws Exception {
        Person p1 = new Person();
        Person p2 = (Person)p1.clone();
        System.out.println("p1.loc == p2.loc? " + (p1.loc == p2.loc));
        //由于p1和p2中的StringBuilder对象指向的是同一个地址
        //所以p1的StringBuilder对象变了之后, p2的也会跟着边
        p1.loc.street.reverse();
        System.out.println(p2.loc.street);
    }
}

class Person implements Cloneable {
    int age = 8;
    int score = 100;

    Location loc = new Location(new StringBuilder("bj"), 22);
    @Override
    public Object clone() throws CloneNotSupportedException {
        Person p = (Person)super.clone();
        p.loc = (Location)loc.clone();
        return p;
    }
}

class Location implements Cloneable {
    StringBuilder street;
    int roomNo;

    @Override
    public String toString() {
        return "Location{" +
                "street='" + street + '\'' +
                ", roomNo=" + roomNo +
                '}';
    }

    public Location(StringBuilder street, int roomNo) {
        this.street = street;
        this.roomNo = roomNo;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}