java设计模式Prototype原型模式

  好记性不如烂笔头，仅以此记录

20200618

Prototype：原型模式（克隆模式）

     注：一般用于一个对象的属性已经确定，需要产生很多相同对象的时候

java中的原型模式(自带)

1.实现原型模式需要实现标记型接口Cloneable，一般会重写clone()方法

     如果只是重写clone()方法，而没实现Cloneable接口，调用时会报异常 java.lang.CloneNotSupportedException、

例：

  1.1 实现Cloneable，且重写clone()

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

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

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);

    }
}

 

2.深克隆和浅克隆

 

浅克隆

例：当执行 p1.loc.street = "sh"; 时 ，p2.loc的street也会改变为 "sh"

原因 ： clone() 会把 p1 整个在内存中copy出一份，p1.loc 和p2.loc的指向地址是相同的，改变了一个两个都会改变

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 {
        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;
    }
}

深克隆

例：loc也需要实现 Cloneable

原因 ： clone()时，loc1 也会在内存中clone()一份loc2，两个的地址不同，改变其中一个不会对另一个造成影响

注意： 如果不想clone的对象引用地址相同，需要实现Cloneable

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;
    }
}

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();
    }
}

问题：

     1.String需要进一步深克隆吗？

         不需要，因为 String指向的是常量池，本来就是共用的，修改其中一个不会修改常量池中的数据

     2.new String()呢？

         需要，因为 new对象实在堆中创建，虽然此对象引用依然指向常量池，但是clone出来的new String 修改是修改的堆中数据，引用改了，元数据的引用跟着就改变了

勉强可以看的图