设计模式之原型模式

• 定义
  用原型实例指定创建对象的种类，通过复制这些原型创建新的对象。
• 使用场景
  (1)类初始化需要消耗非常多的资源，这个资源包括数据、硬件资源等，通过原型避免这些消耗。
  (2)通过new产生一个对象需要非常繁琐的数据准备或访问权限，这时可以使用原型模式。
  (3)一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式复制多个对象供调用者使用，即保护性拷贝(修改拷贝对象的属性不会影响到被拷贝对象(原型对象)的属性)。
  需要注意的是，通过实现Cloneable接口的原型模式在调用clone函数构造实例时并不一定比通过new操作速度快，只有当通过new构造对象较为耗时或者成本较高时，通过clone方法才能够获得效率上的提升。

public class Sheep implements Cloneable{
    private String name;
    private int age;
    
    public Sheep(String name,int age){
        this.age = age;
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Sheep{" + "name=" + name + ", age=" + age  + '}';
    }
    
    @Override
    protected Sheep clone() throws CloneNotSupportedException {
        Sheep sheep = null;
        sheep = (Sheep) super.clone();//这样是浅拷贝
        return sheep; //To change body of generated methods, choose Tools | Templates.
    }
}

public class JavaApplication11 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws CloneNotSupportedException {
        // TODO code application logic here
        Sheep sheep = new Sheep("小明",12);
        System.out.println(sheep);
        
        Sheep sheep2 = sheep.clone();
        Sheep sheep3 = sheep.clone();
        
        sheep2.setName("小王");
        System.out.println(sheep2);
        System.out.println(sheep);
    }
    
}

• 深拷贝和浅拷贝
  (1)对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。
  (2)对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是将该成员变量的引用值(内存地址)复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。
  (3)浅拷贝是使用默认的clone方法来实现。

//深拷贝的实现方式1：重写clone方法
public class Dog implements Cloneable{
    public Dog(){}

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); //To change body of generated methods, choose Tools | Templates.
    }
}

public class Sheep implements Cloneable{
    private String name;
    private int age;
    private Dog friend;
    
    public Sheep(String name,int age){
        this.age = age;
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Dog getFriend() {
        return friend;
    }

    public void setFriend(Dog friend) {
        this.friend = friend;
    }

    @Override
    public String toString() {
        return "Sheep{" + "name=" + name + ", age=" + age + ", friend=" + friend + '}';
    }
    
    @Override
    protected Sheep clone() throws CloneNotSupportedException {
        Sheep sheep = null;
        sheep = (Sheep) super.clone();
        sheep.friend = (Dog) friend.clone();//这样是深拷贝，对象里面的引用字段也需要进行拷贝
        return sheep; //To change body of generated methods, choose Tools | Templates.
    }
}

public class JavaApplication11 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws CloneNotSupportedException {
        // TODO code application logic here
        Sheep sheep = new Sheep("小明",12);
        
        sheep.setFriend(new Dog());
        Sheep sheep2 = sheep.clone();

        System.out.println(sheep2.getFriend().hashCode());
        System.out.println(sheep.getFriend().hashCode());
    } 
}

//深拷贝的实现方式2：将要进行深拷贝的对象进行序列化为字节流，再进行反序列化为对象，就可以得到一个新的对象。