Java 深入探討設(shè)計模式之原型模式篇

更新時間：2021年10月28日 14:19:15 作者：龍弟-idea

設(shè)計模式（Design pattern）是一套被反復使用、多數(shù)人知曉的、經(jīng)過分類編目的、代碼設(shè)計經(jīng)驗的總結(jié)。使用設(shè)計模式是為了可重用代碼、讓代碼更容易被他人理解、保證代碼可靠性

傳統(tǒng)方式

克隆羊問題

現(xiàn)在有一只羊 tom，姓名為: tom，年齡為:1，顏色為:白色，請編寫程序創(chuàng)建和 tom羊?qū)傩酝耆嗤?0只羊。

傳統(tǒng)方式解決克隆羊問題

思路分析（圖解）

代碼演示:

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
		//傳統(tǒng)方法
		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);
		//...
	}
}

傳統(tǒng)方式的優(yōu)缺點

①優(yōu)點是比較好理解，簡單易操作。

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

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

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

原型模式基本介紹

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

②原型模式是一種創(chuàng)建型設(shè)計模式，允許一個對象再創(chuàng)建另外一個可定制的對象，無需知道如何創(chuàng)建的細節(jié)

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

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

原型模式原理結(jié)構(gòu)圖-uml圖

原理結(jié)構(gòu)圖說明

Prototype :原型類，聲明一個克隆自己的接口
ConcretePrototype:具體的原型類，實現(xiàn)一個克隆自己的操作
Client:讓一個原型對象克隆自己，從而創(chuàng)建一個新的對象(屬性一樣)

原型模式解決克隆羊問題的應用實例
使用原型模式改進傳統(tǒng)方式，讓程序具有更高的效率和擴展性。
代碼演示：

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 + "]";
	}
	//克隆該實例，使用默認的構(gòu)造方法來完成
	@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("原型模式完成對象的創(chuàng)建");
		// 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 的創(chuàng)建，就是原型模式的應用

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

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

深拷貝基本介紹

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

深拷貝應用案例;

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

public class DeepProtoType implements Serializable, Cloneable{
	
	public String name; //String屬性
	public DeepCloneableTarget deepCloneableTarget;//引用類型
	public DeepProtoType() {
		super();
	}
	
	
	//深拷貝實現(xiàn)方式1:重寫clone方法來實現(xiàn)深拷貝
	@Override
	protected Object clone() throws CloneNotSupportedException {
		
		Object deep = null;
		//這里完成對基本數(shù)據(jù)類型（屬性）和String的克隆
		deep = super.clone(); 
		//對引用類型的屬性，進行單獨處理
		DeepProtoType deepProtoType = (DeepProtoType)deep;
		deepProtoType.deepCloneableTarget  = (DeepCloneableTarget)deepCloneableTarget.clone();
		
		// TODO Auto-generated method stub
		return deepProtoType;
	}
	
	//深拷貝實現(xiàn)方式2:通過對象序列化實現(xiàn)深拷貝
	
	public Object deepClone() {
		
		//創(chuàng)建流對象
		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 {
			//關(guān)閉流
			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;
 
	//構(gòu)造器
	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());
	
	}
}

原型模式的注意事項和細節(jié)

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

到此這篇關(guān)于Java 深入探討設(shè)計模式之原型模式篇的文章就介紹到這了,更多相關(guān)Java 設(shè)計模式內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: