傳統方式

克隆羊問題

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

傳統方式解決克隆羊問題

思路分析（圖解）

代碼演示:

public class Sheep {
	private String name;
	private int age;
	private String color;
	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 + "]";
	}
	
	
}

public class Client {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//傳統方法
		Sheep sheep = new Sheep("tom", 1, "白色  ");
		
		Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
		Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
		Sheep sheep4 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
		Sheep sheep5 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
		//....
		
		System.out.println(sheep);
		System.out.println(sheep2);
		System.out.println(sheep3);
		System.out.println(sheep4);
		System.out.println(sheep5);
		//...
	}
}

傳統方式的優缺點

①優點是比較好理解，簡單易操作。

②在創建新的對象時，總是需要重新獲取原始對象的屬性，如果創建的對象比較復雜時，效率較低

③總是需要重新初始化對象，而不是動態地獲得對象運行時的狀態，不夠靈活

④改進的思路分析
思路:Java中 Object類是所有類的根類，Object類提供了一個clone()方法，該方法可以將一個Java對象復制一份,但是需要實現clone的Java類必須要實現一個接口Cloneable,該接口表示該類能夠復制且具有復制的能力

原型模式基本介紹

①原型模式(Prototype模式)是指:用原型實例指定創建對象的種類，并且通過拷貝這些原型，創建新的對象

②原型模式是一種創建型設計模式，允許一個對象再創建另外一個可定制的對象，無需知道如何創建的細節

③工作原理是:通過將一個原型對象傳給那個要發動創建的對象，這個要發動創建的對象通過請求原型對象拷貝它們自己來實施創建，即對象.clone()

④形象的理解:孫大圣拔出猴毛，變出其它孫大圣

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

原理結構圖說明

Prototype :原型類，聲明一個克隆自己的接口
ConcretePrototype:具體的原型類，實現一個克隆自己的操作
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 + "]";
	}
	//克隆該實例，使用默認的構造方法來完成
	@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());
	}
}

原型模式在spring框架中源碼分析

Spring 中原型bean 的創建，就是原型模式的應用

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

淺拷貝基本介紹
①對于數據類型是基本數據類型的成員變量，淺拷貝會直接進行值傳遞，也就是將該屬性值復制一份給新的對象。
②對于數據類型是引用數據類型的成員變量，比如說成員變量是某個數組、某個類的對象等，那么淺拷貝會進行引用傳遞，也就是只是將該成員變量的引用值〈內存地址）復制一份給新的對象。因為實際上兩個對象的該成員變量都指向同一個實例。在這種情況下，在一個對象中修改該成員變量會影響到另一個對象的該成員變量值
③前面的克隆羊就是淺拷貝
④淺拷貝是使用默認的clone()方法來實現，sheep= (Sheep) super.clone();

深拷貝基本介紹

①復制對象的所有基本數據類型的成員變量值
②為所有引用數據類型的成員變量申請存儲空間，并復制每個引用數據類型成員變量所引用的對象，直到該對象可達的所有對象。也就是說，對象進行深拷貝要對整個對象(包括對象的引用類型)進行拷貝
③深拷貝實現方式1:重寫clone方法來實現深拷貝
④深拷貝實現方式2:通過對象序列化實現深拷貝(推薦)

深拷貝應用案例;

①使用重寫clone方法實現深拷貝
②使用序列化來實現深拷貝
③代碼演示

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());
			}
		}
		
	}
	
}

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();
	}
}

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());
	
	}
}

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

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

到此這篇關于Java 深入探討設計模式之原型模式篇的文章就介紹到這了,更多相關Java 設計模式內容請搜索服務器之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持服務器之家！

原文鏈接：https://blog.csdn.net/weixin_48838340/article/details/120942348