克隆模式-深浅克隆

 

package create.clone;

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

/**
 * 简单形式，深浅克隆
 *
 * 适用于需要创建的原型对象数目较少且比较固定的情况，原型对象的保存交由客户端负责
 * @author zhangchy
 *
 */

// 作为成员变量的A要序列化
class A implements Serializable{
 
}

//自己要被克隆的对象
class ProtoType implements Cloneable,Serializable{
 private A a = new A();
 //浅克隆
 public Object clone() throws CloneNotSupportedException{
  return super.clone();
 }
 public A getA() {
  return a;
 }
 public void setA(A a) {
  this.a = a;
 }
 
 // 利用流来处理，使自己被深克隆
 public Object deepClone(){
  Object object = null;
  try{
   //字节流写入
   ByteArrayOutputStream bo = new ByteArrayOutputStream();
   ObjectOutputStream oo = new ObjectOutputStream(bo);
            //this 必须能够序列化 ,保证所有的成员变量都能序列化
   oo.writeObject(this);
   
   //字节流写出
   ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
   ObjectInputStream oi = new ObjectInputStream(bi);
   object=oi.readObject();
  }
  catch(Exception e){
   e.printStackTrace();
  }
  return object;
 }
}

public class ClonePattern {

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  //克隆需要原型，protoType为原型
  ProtoType protoType = new ProtoType();
  ProtoType protoTypeClone = null;
  ProtoType protoTypeDeepClone = null;
  
  try{
            //进行浅克隆
    protoTypeClone = (ProtoType)protoType.clone();
    protoTypeDeepClone = (ProtoType)protoType.deepClone();
  }
  catch(CloneNotSupportedException cloneE){
   cloneE.printStackTrace();
  }
  
  //克隆了一个新对象
  System.out.println(protoType);
  System.out.println(protoTypeClone);
  System.out.println(protoTypeDeepClone);
  //下面中两个方法获得的getA对象是同一个地址，所以浅克隆不能创建一个成员变量的新对象，
  //创建一个成员新对象，那么就需要对自己进行深克隆
  System.out.println(protoType.getA());
  System.out.println(protoTypeClone.getA());
  //深克隆后，
  System.out.println(protoTypeDeepClone.getA());
 }

}