原型模式-JAVA实现深克隆的两种方式(通过重写clone方法和序列化反序列化实现深克隆)

一.原型模式介绍

A.优点:

当创建新的对象实例较为复杂时，使用原型模式可以简化的对象的创建过程，通过复制一个已有实例可以提高新实例的创建效率。

原型模式允许动态增加或减少产品类。

原型模式具有给一个应用软件动态加载新功能的能力。

产品类不需要非得有任何事先确定的等级结构 。

B.缺点：

原型模式的最主要缺点就是每一个类必须配备一个克隆方法。而且这个克隆方法需要对类的功能进行通盘考虑，这对全新的类来说不是很难，但对已有的类进行改造时，不一定是件容易的事。

原型模式的另一个缺点是在实现深克隆时需要编写较为复杂的代码

C.应用情况:

创建新对象成本较大(CPU，初始化)。

系统要保存对象的状态，对象状态变化很小。

当一个类的实例只有几个不同状态组合时，建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化更为方便。

二.java实现深克隆的方法:

 1). 实现Cloneable接口并重写Object类中的clone()方法； 
 2). 实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆，主要用来解决多层克隆问题

2.1实现Cloneable接口实现深克隆

A.Card类

public class Card  implements Cloneable{
  private int  cardId;
  private String name;
public int getCardId() {
	return cardId;
}
public void setCardId(int cardId) {
	this.cardId = cardId;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public Card(int cardId, String name) {
	super();
	this.cardId = cardId;
	this.name = name;
}
  public Object colne()
  {
	 Card c=null;
	 try {
		 c=(Card) super.clone();
	 }
 	catch(CloneNotSupportedException e) 
 	{  
 	     e.printStackTrace();  
     }  
	 return c;
  }
}

B.Student类

public class Student implements Cloneable {
     private String name;
     private String sex;
     private String major;
     private String phoneNumber;
     private Card card;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public String getMajor() {
		return major;
	}
	public void setMajor(String major) {
		this.major = major;
	}
	public String getPhoneNumber() {
		return phoneNumber;
	}
	public void setPhoneNumber(String phoneNumber) {
		this.phoneNumber = phoneNumber;
	}
    
    public  Object clone()
    {
    	Student s=null;
    	try 
    	{
    	    
    		s=(Student) super.clone();
    	}
    	catch(CloneNotSupportedException e) 
    	{  
    	     e.printStackTrace();  
        }  
    	
    	s.setCard((Card) card.colne());
    	return   s;
    }
	public Card getCard() {
		return card;
	}
	public void setCard(Card card) {
		this.card = card;
	}
}

2.2通过序列话实现深克隆

A.Card类（只需实现Serializable接口，并定义序列号）

public class Card  implements Serializable{
  private static final long serialVersionUID = 872390113109L; 
｝

B.Student类

public class Student implements Serializable{
	 private static final long serialVersionUID = 369285298572941L;
     private String name;
     private String sex;
     private String major;
     private String phoneNumber;
     private Card card;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public String getMajor() {
		return major;
	}
	public void setMajor(String major) {
		this.major = major;
	}
	public String getPhoneNumber() {
		return phoneNumber;
	}
	public void setPhoneNumber(String phoneNumber) {
		this.phoneNumber = phoneNumber;
	}
    
    public  Object clone()
    {
    	Student s=null;
    	try 
    	{
    	    //字节数组输出流在内存中创建一个字节数组缓冲区，所有发送到输出流的数据保存在该字节数组缓冲区中。创建字节数组缓冲区  无参数传入时为32字节
    		ByteArrayOutputStream baos=new ByteArrayOutputStream();
    		//创建对象输出流
    		ObjectOutputStream oo=new ObjectOutputStream(baos);
    	    //将对象写入内存
    		oo.writeObject(this);
    		//字节数组输入流在内存中创建一个字节数组缓冲区，所有发送到输入流中的数据保存再该字节数组缓冲区
    		ByteArrayInputStream bais=new ByteArrayInputStream(baos.toByteArray());
    		//创建对象输入流
    		ObjectInputStream  oi=new ObjectInputStream(bais);
    		//将对象从内存的输出流中读回对象，完成深克隆 反序列化
    		s=(Student) oi.readObject();
    		oi.close();
    		oo.close();
    		
    	}
        catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}  
    	return   s;
    }
	public Card getCard() {
		return card;
	}
	public void setCard(Card card) {
		this.card = card;
	}
}

三.序列化的详情

（来自于各种大佬的博客）

 

A. 只有实现Serializable接口才能实现对象的序列化。

B. serialVersionUID 是用于记录class文件的版本信息的，serialVersionUID这个数字是JVM(JAVA虚拟界)通过一个类的类名、成员、包名、工程名算出的一个数字。

C. 如果序列化与反序列化的时候可能会修改类的成员，那么最好一开始就给这个类指定一个serialVersionUID，如果一类已经指定的serialVersionUID，然后在序列化与反序列化的时候，jvm都不会再自己算这个 class的serialVersionUID了。

D. 对象的反序列化创建对象的时候并不会调用到构造方法的。

E. 如果一个对象某个数据不想被序列化到硬盘上，可以使用关键字transient修饰。 

F. 如果一个类维护了另外一个类的引用，则另外一个类也需要实现Serializable接口 

G. 序列化只将对象的状态信息转化成可以传输或者储存的二进制文件(对象写到流的过程，写到流中的对象是原有对象的一个拷贝，而原对象仍然存在于内存中。)。在序列化期间，对象将其当前状态写入到临时存储区或持久性存储区，之后，便可以通过从存储区中读取或反序列化对象的状态信息，来重新创建该对象

 H. Serializable主要用来支持两种主要的特性：

1、Java的RMI（remote method invocation），RMI允许像在本机上一样操作远程机器上的对象，当发送消息给远程对象时，就需要用到序列化机制来发送参数和接受返回值

2、Java的JavaBean，Bean的状态信息通常是在设计时配置的，Bean的状态信息必须被保存下来，以便当程序运行时能恢复这些状态信息，这也需要序Serializable机制。