浅拷贝和深拷贝(java)

 拷贝：多用于prototype原型模式的复制。

         数据库连接池，将properties中的jdbc信息（user/password/url/port）等获取后赋值给jdbcData对象，然后将对象复制n份，连接数据库，创建连接池。

 浅拷贝：

复制对象指向，不复制值，除过基本类型.当有对象在里面时，修改原对象的值，会导致clone后的内容值也发生变化。因为指向不变。

如果一个对象中没有引用其它对象，String不算。可以使用浅拷贝。因为String每次会新创建而不会破坏克隆后对象的引用。
***   浅拷贝clone要implements Cloneable接口

深拷贝：

对象指向及其值一起拷贝，（如果一个对象中引用了另一个对象，而另一个对象中没有再引用其它内容，可在拷贝时，将内部对象重新拷贝再赋给当前对象）。

要通过输出流输入流的形式对象需要序列化操作。

**** 深拷贝clone要implements Serializable接口,其内部对象也要串型化

以下为创建的示例：

/**
 * 原型模式要实现克隆，必须实现Cloneable
 * 拷贝分深拷贝和
 * 浅拷贝：复制对象指向，不复制值，除过基本类型.当有对象在里面时，修改原对象的值，会导致clone后的内容值也发生变化。因为指向不变。
 *      如果一个对象中没有引用其它对象，String不算。可以使用浅拷贝。因为String每次会新创建而不会破坏克隆后对象的引用。
 *      浅拷贝clone要implements Cloneable接口
 * 深拷贝：对象指向及其值一起拷贝，（如果一个对象中引用了另一个对象，而另一个对象中没有再引用其它内容，可在拷贝时，将内部对象重新拷贝再赋给当前对象）。要通过输出流输入流的形式
 *      对象需要序列化操作。
 *      深拷贝clone要implements Serializable接口,其内部对象也要序列号
 * 
 * @author DennyZhao
 * @date 2017年6月13日
 * @version 1.0
 */
public class PrototypeFactory implements Cloneable, Serializable{

    /**
     * 自动生成序列号
     */
    private static final long serialVersionUID = 1416969741781583897L;
    private String name;
    private String englishName;
    private String nickName;
    private int age;
    private AnimalFactory animal;
    
    public String getNickName() {
        return nickName;
    }
    public void setNickName(String nickName) {
        this.nickName = nickName;
    }
    public String getEnglishName() {
        return englishName;
    }
    public void setEnglishName(String englishName) {
        this.englishName = englishName;
    }
    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 AnimalFactory getAnimal() {
        return animal;
    }
    public void setAnimal(AnimalFactory animal) {
        this.animal = animal;
    }
    @Override
    public String toString() {
        return "PrototypeFactory [name=" + name + ", englishName="
                + englishName + ", nickName=" + nickName + ", age=" + age
                + ", animal=" + animal + "]";
    }
    
    /**
     * 浅拷贝
     */
    public PrototypeFactory clone() throws CloneNotSupportedException{
        return (PrototypeFactory)super.clone();
    }
    
    /**
     * 这种拷贝只能针对对象内的对象内都是基本数据类型才可以。且内部对象也具有克隆方法
     */
    public PrototypeFactory clone2() throws CloneNotSupportedException{
        PrototypeFactory pro = (PrototypeFactory)super.clone();
        //pro.animal = (PrototypeFactory)pro.animal.clone;
        return pro;
    }
    
    /**
     * 深拷贝
     */
    public PrototypeFactory deepClone(){
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        ObjectOutputStream oos = null;
        ObjectInputStream ois = null;
        PrototypeFactory pro = null;
        try {
            oos = new ObjectOutputStream(os);
            oos.writeObject(this);
            ois = new ObjectInputStream(new ByteArrayInputStream(os.toByteArray()));
            pro = (PrototypeFactory)ois.readObject();
        } catch (ClassNotFoundException e) {
                e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return pro;
    }
    
}

测试示例：

public class TestProtoType {

    public static void main(String[] args) throws CloneNotSupportedException {
        //原型模式
        PrototypeFactory protoFactory = new PrototypeFactory();
        protoFactory.setEnglishName("DennyZhao");
        protoFactory.setName("~~~~强~~");
        protoFactory.setNickName("~~王~~");
        protoFactory.setAge(10);
        Rabit rabit22 = new Rabit();
        rabit22.getHeader("A", 2, "B");
        protoFactory.setAnimal(rabit22);
        PrototypeFactory cloneProto = protoFactory.clone();
        PrototypeFactory cloneDeep = protoFactory.deepClone();
        System.out.println("protoFactory:--" + protoFactory.toString());
        System.out.println("cloneProto:---" + cloneProto.toString());
        System.out.println("cloneDeep:---" + cloneDeep.toString());
        // 修改原数据参数
        protoFactory.setEnglishName("Denny....");
        protoFactory.setAge(8);
        ((Rabit)protoFactory.getAnimal()).getHeader("C", 3, "D");
        System.out.println("2protoFactory:--" + protoFactory.toString());
        System.out.println("2cloneProto:---" + cloneProto.toString());
        System.out.println("2cloneDeep:---" + cloneDeep.toString());
        System.out.println("3protoFactory---" + ((Rabit)protoFactory.getAnimal()).getHeader());
        System.out.println("3cloneProto---" + ((Rabit)cloneProto.getAnimal()).getHeader());
        System.out.println("3cloneDeep---" + ((Rabit)cloneDeep.getAnimal()).getHeader());

    }

运行结果：

protoFactory:--PrototypeFactory [name=~~~~强~~, englishName=DennyZhao, nickName=~~王~~, age=10, animal=pattern.creation.factory.animal.Rabit@a57993]
cloneProto:---PrototypeFactory [name=~~~~强~~, englishName=DennyZhao, nickName=~~王~~, age=10, animal=pattern.creation.factory.animal.Rabit@a57993]
cloneDeep:---PrototypeFactory [name=~~~~强~~, englishName=DennyZhao, nickName=~~王~~, age=10, animal=pattern.creation.factory.animal.Rabit@17327b6]
2protoFactory:--PrototypeFactory [name=~~~~强~~, englishName=Denny...., nickName=~~王~~, age=8, animal=pattern.creation.factory.animal.Rabit@a57993]
2cloneProto:---PrototypeFactory [name=~~~~强~~, englishName=DennyZhao, nickName=~~王~~, age=10, animal=pattern.creation.factory.animal.Rabit@a57993]
2cloneDeep:---PrototypeFactory [name=~~~~强~~, englishName=DennyZhao, nickName=~~王~~, age=10, animal=pattern.creation.factory.animal.Rabit@17327b6]
3protoFactory---C3D
3cloneProto---C3D
3cloneDeep---A2B

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

内容借鉴：（Java中的深拷贝(深复制)和浅拷贝(浅复制)）http://www.cnblogs.com/shuaiwhu/archive/2010/12/14/2065088.html

以上，为个人总结，如有写的不当之处，还望指正。

                                                                    -----------DennyZhao