作者：whisper

链接：http://proprogrammar.com:443/article/442

声明：请尊重原作者的劳动，如需转载请注明出处

　　有的对象比较复杂，创建消耗较大，可以用一个对象原型不断复制出其它对象

　　有三种方式

　　浅拷贝

package creational.pattern.prototype.shallowclone;

public class Prototype implements Cloneable{
    public Prototype clone(){
        Prototype prototype = null;
        try{
            prototype = (Prototype)super.clone();
        }catch(CloneNotSupportedException e){
            e.printStackTrace();
        }
        return prototype; 
    }
}

package creational.pattern.prototype.shallowclone;

public class ConcretePrototype extends Prototype {
    public void show()
    {  
        System.out.println("原型模式实现类");  
    }
}

　　测试代码

package creational.pattern.prototype.shallowclone;

public class Client {
    public static void main(String[] args)
    {
        ConcretePrototype cp = new ConcretePrototype();
        for(int i=0; i< 10; i++)
        {
            ConcretePrototype clonecp = (ConcretePrototype)cp.clone();
            clonecp.show();
            System.out.println(clonecp);
        }
    }
}

　　运行结果

　　浅拷贝的问题在对于对象属性，克隆出的对象和原对象的对象属性是同一个

　　深拷贝

package creational.pattern.prototype.deepclone;

import java.util.ArrayList;

public class Prototype implements Cloneable {
    private ArrayList list = new ArrayList();  
    public Prototype clone(){  
        Prototype prototype = null;  
        try{  
            prototype = (Prototype)super.clone();  
            prototype.list = (ArrayList) this.list.clone();  
        }catch(CloneNotSupportedException e){  
            e.printStackTrace();  
        }  
        return prototype;   
    }
}

package creational.pattern.prototype.deepclone;

public class ConcretePrototype extends Prototype {
    public void show()
    {  
        System.out.println("原型模式实现类");  
    }
}

　　测试代码

package creational.pattern.prototype.deepclone;

public class Client {
    public static void main(String[] args)
    {
        ConcretePrototype cp = new ConcretePrototype();
        for(int i=0; i< 10; i++)
        {
            ConcretePrototype clonecp = (ConcretePrototype)cp.clone();
            clonecp.show();
            System.out.println(clonecp);
        }
    }
}

　　运行结果

　　深拷贝在于将对类中的对象属性也进行了克隆，上面两个要实现Cloneabl接口

　　序列化

package creational.pattern.prototype.serilizable;

import java.io.Serializable;

public class SerializableObject implements Serializable {
    private static final long serialVersionUID = -6071344933545997422L;
}

package creational.pattern.prototype.serilizable;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Prototpye implements Serializable, Cloneable {

    private static final long serialVersionUID = -1045333494067611913L;
    
    // String类型，可以clone拷贝
    private String string;
    // 引用类型，无法clone拷贝
    private SerializableObject obj;
    
    //浅复制.利用Object的clone（）方法
    public Object   clone()throws CloneNotSupportedException {
        Prototpye proto=(Prototpye)super.clone();
        return proto;       
    }
    
    //要实现深复制，需要采用流的形式读入当前对象的二进制输入，再写出二进制数据对应的对象。
    public Object deepClone()throws IOException ,ClassNotFoundException{
        ByteArrayOutputStream bos=new ByteArrayOutputStream();
        ObjectOutputStream oos=new ObjectOutputStream(bos);
        oos.writeObject(this);

        ByteArrayInputStream bis=new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois=new ObjectInputStream(bis);
        return ois.readObject();

    }

    public String getString() {
        return string;
    }

    public void setString(String str) {
        this.string=str;

    }

    public SerializableObject getObj() {
        return obj;
    }
}

　　上面有浅拷贝和序列化两种方法实现，要实现序列化，必须实现Serializable接口

亲爱的读者：有时间可以点赞评论一下