傳統方式解決克隆羊問題

克隆羊問題

現在有一隻羊tom，姓名為: tom, 年齡為：1，顏色為：白色，請編寫程式建立和tom 羊屬性完全相同的10只羊。

1. 思路分析(圖解)
   

傳統的方式的優缺點

1. 優點是比較好理解，簡單易操作。
2. 在建立新的物件時，總是需要重新獲取原始物件的屬性，如果建立的物件比較複雜時，效率較低
3. 總是需要重新初始化物件，而不是動態地獲得物件執行時的狀態, 不夠靈活
4. 改進的思路分析
   思路：Java 中Object 類是所有類的根類，Object 類提供了一個clone()方法，該方法可以將一個Java 物件複製一份，但是需要實現clone 的Java 類必須要實現一個介面Cloneable，該介面表示該類能夠複製且具有複製的能力=>原型模式

原型模式

基本介紹

1. 原型模式(Prototype 模式)是指：用原型例項指定建立物件的種類，並且通過拷貝這些原型，建立新的物件
2. 原型模式是一種建立型設計模式，允許一個物件再建立另外一個可定製的物件，無需知道如何建立的細節
3. 工作原理是:通過將一個原型物件傳給那個要發動建立的物件，這個要發動建立的物件通過請求原型物件拷貝它們自己來實施建立，即物件.clone()
4. 形象的理解：孫大聖拔出猴毛， 變出其它孫大聖

原型模式原理結構圖-uml 類圖

 原理結構圖說明

1. Prototype : 原型類，宣告一個克隆自己的介面
2. ConcretePrototype: 具體的原型類, 實現一個克隆自己的操作
3. Client: 讓一個原型物件克隆自己，從而建立一個新的物件(屬性一樣）

原型模式解決克隆羊問題的應用例項

使用原型模式改進傳統方式，讓程式具有更高的效率和擴充套件性。
 程式碼實現
羊類

public class Sheep implements Cloneable {
	private String name;
	private int age;
	private String color;
	private String address = "蒙古羊";
	public Sheep friend; //是物件, 克隆是會如何處理
	public Sheep(String name, int age, String color) {
		super();
		this.name = name;
		this.age = age;
		this.color = color;
	}
	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 String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	
	
	
	@Override
	public String toString() {
		return "Sheep [name=" + name + ", age=" + age + ", color=" + color + ", address=" + address + "]";
	}
	//克隆該例項，使用預設的clone方法來完成
	@Override
	protected Object clone()  {
		
		Sheep sheep = null;
		try {
			sheep = (Sheep)super.clone();
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println(e.getMessage());
		}
		// TODO Auto-generated method stub
		return sheep;
	}
	
	
}

• 客戶端類

public class Client {

	public static void main(String[] args) {
		System.out.println("原型模式完成物件的建立");
		// TODO Auto-generated method stub
		Sheep sheep = new Sheep("tom", 1, "白色");
		
		sheep.friend = new Sheep("jack", 2, "黑色");
		
		Sheep sheep2 = (Sheep)sheep.clone(); //克隆
		Sheep sheep3 = (Sheep)sheep.clone(); //克隆
		Sheep sheep4 = (Sheep)sheep.clone(); //克隆
		Sheep sheep5 = (Sheep)sheep.clone(); //克隆
		
		
		
		
		System.out.println("sheep2 =" + sheep2 + "sheep2.friend=" + sheep2.friend.hashCode());
		System.out.println("sheep3 =" + sheep3 + "sheep3.friend=" + sheep3.friend.hashCode());
		System.out.println("sheep4 =" + sheep4 + "sheep4.friend=" + sheep4.friend.hashCode());
		System.out.println("sheep5 =" + sheep5 + "sheep5.friend=" + sheep5.friend.hashCode());
	}

}

• 結果

原型模式完成物件的建立
sheep2 =Sheep [name=tom, age=1, color=白色, address=蒙古羊]sheep2.friend=31168322
sheep3 =Sheep [name=tom, age=1, color=白色, address=蒙古羊]sheep3.friend=31168322
sheep4 =Sheep [name=tom, age=1, color=白色, address=蒙古羊]sheep4.friend=31168322
sheep5 =Sheep [name=tom, age=1, color=白色, address=蒙古羊]sheep5.friend=31168322

可得物件無法克隆

深入討論-淺拷貝和深拷貝

淺拷貝的介紹

1. 對於資料型別是基本資料型別的成員變數，淺拷貝會直接進行值傳遞，也就是將該屬性值複製一份給新的物件。
2. 對於資料型別是引用資料型別的成員變數，比如說成員變數是某個陣列、某個類的物件等，那麼淺拷貝會進行引用傳遞，也就是隻是將該成員變數的引用值（記憶體地址）複製一份給新的物件。因為實際上兩個物件的該成員變數都指向同一個例項。在這種情況下，在一個物件中修改該成員變數會影響到另一個物件的該成員變數值
3. 前面我們克隆羊就是淺拷貝
4. 淺拷貝是使用預設的clone()方法來實現
   sheep = (Sheep) super.clone();

深拷貝基本介紹

1. 複製物件的所有基本資料型別的成員變數值
2. 為所有引用資料型別的成員變數申請儲存空間，並複製每個引用資料型別成員變數所引用的物件，直到該物件可達的所有物件。也就是說，物件進行深拷貝要對整個物件(包括物件的引用型別)進行拷貝
3. 深拷貝實現方式1：重寫clone 方法來實現深拷貝
4. 深拷貝實現方式2：通過物件序列化實現深拷貝(推薦)

深拷貝應用例項

1. 使用重寫clone 方法實現深拷貝
2. 使用序列化來實現深拷貝
3. 程式碼演示

• DeepCloneableTarget.Java

package com.atguigu.prototype.deepclone;

import java.io.Serializable;

public class DeepCloneableTarget implements Serializable, Cloneable {
	
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	private String cloneName;

	private String cloneClass;

	//構造器
	public DeepCloneableTarget(String cloneName, String cloneClass) {
		this.cloneName = cloneName;
		this.cloneClass = cloneClass;
	}

	//因為該類的屬性，都是String , 因此我們這裡使用預設的clone完成即可
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}

• DeepProtoType.java

package com.atguigu.prototype.deepclone;

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

public class DeepProtoType implements Serializable, Cloneable{
	
	public String name; //String 屬性
	public DeepCloneableTarget deepCloneableTarget;// 引用型別
	public DeepProtoType() {
		super();
	}
	
	
	//深拷貝 - 方式 1 使用clone 方法
	@Override
	protected Object clone() throws CloneNotSupportedException {
		
		Object deep = null;
		//這裡完成對基本資料型別(屬性)和String的克隆
		deep = super.clone(); 
		//對引用型別的屬性，進行單獨處理
		DeepProtoType deepProtoType = (DeepProtoType)deep;
		deepProtoType.deepCloneableTarget  = (DeepCloneableTarget)deepCloneableTarget.clone();
		
		// TODO Auto-generated method stub
		return deepProtoType;
	}
	
	//深拷貝 - 方式2 通過物件的序列化實現 (推薦)
	
	public Object deepClone() {
		
		//建立流物件
		ByteArrayOutputStream bos = null;
		ObjectOutputStream oos = null;
		ByteArrayInputStream bis = null;
		ObjectInputStream ois = null;
		
		try {
			
			//序列化
			bos = new ByteArrayOutputStream();
			oos = new ObjectOutputStream(bos);
			oos.writeObject(this); //當前這個物件以物件流的方式輸出
			
			//反序列化
			bis = new ByteArrayInputStream(bos.toByteArray());
			ois = new ObjectInputStream(bis);
			DeepProtoType copyObj = (DeepProtoType)ois.readObject();
			
			return copyObj;
			
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			return null;
		} finally {
			//關閉流
			try {
				bos.close();
				oos.close();
				bis.close();
				ois.close();
			} catch (Exception e2) {
				// TODO: handle exception
				System.out.println(e2.getMessage());
			}
		}
		
	}
	
}

• Client.java

package com.atguigu.prototype.deepclone;

public class Client {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		DeepProtoType p = new DeepProtoType();
		p.name = "宋江";
		p.deepCloneableTarget = new DeepCloneableTarget("大牛", "小牛");
		
		//方式1 完成深拷貝
		
//		DeepProtoType p2 = (DeepProtoType) p.clone();
//		
//		System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
//		System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
	
		//方式2 完成深拷貝
		DeepProtoType p2 = (DeepProtoType) p.deepClone();
		
		System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
		System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
	
	}

}

原型模式的注意事項和細節

1. 建立新的物件比較複雜時，可以利用原型模式簡化物件的建立過程，同時也能夠提高效率
2. 不用重新初始化物件，而是動態地獲得物件執行時的狀態
3. 如果原始物件發生變化(增加或者減少屬性)，其它克隆物件的也會發生相應的變化，無需修改程式碼
4. 在實現深克隆的時候可能需要比較複雜的程式碼
5. 缺點：需要為每一個類配備一個克隆方法，這對全新的類來說不是很難，但對已有的類進行改造時，需要修改其原始碼，違背了ocp 原則，這點請同學們注意.