溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
本篇內容主要講解“java中的原型模式是什么”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“java中的原型模式是什么”吧!
引例
原型模式
淺拷貝
在原先Sheep類基礎上實現Cloneable接口，重寫clone方法。
客戶端調用
Sheep類
新添的Cow類
客戶端調用克隆
深拷貝
1.Cow類也實現Cloneable接口
Sheep類的clone再添加調用cow的clone
客戶端調用
1.Cow類實現序列化接口，不必實現Cloneable接口了
2.在Sheep類實現序列化接口
3.客戶端調用
問題：
現在有一只羊（包含屬性：名字Dolly、年齡2），需要克隆10只屬性完全相同的羊。
一般解法：
定義Sheep類表示羊，包括構造器、getter()和toString()。
public class Sheep {
private String name;
private int age;
public Sheep(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "Sheep{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}在客戶端實例化多利，然后再根據多利的屬性去實例化10只羊。
public class Client {
public static void main(String[] args) {
Sheep sheepDolly=new Sheep("Dolly",2);
Sheep sheep1 = new Sheep(sheepDolly.getName(), sheepDolly.getAge());
Sheep sheep2 = new Sheep(sheepDolly.getName(), sheepDolly.getAge());
Sheep sheep3 = new Sheep(sheepDolly.getName(), sheepDolly.getAge());
//....
System.out.println(sheep1+",hashCode:"+sheep1.hashCode());
System.out.println(sheep2+",hashCode:"+sheep2.hashCode());
System.out.println(sheep3+",hashCode:"+sheep3.hashCode());
//...
}
}運行結果
優缺點：
這種方法是我們首先很容易就能想到的，也是絕大多數人的第一做法。
但缺點也很明顯，每次創建新對象時需要獲取原始對象的屬性，對象復雜時效率很低；此外不能動態獲得對象運行時的狀態，若類增減屬性需要改動代碼。
下面我們看下原型模式的解法。
原型模式(Prototype Pattern)是一種創建型設計模式，允許一個對象再創建另外一個可定制的對象，無需知道如何創建的細節。即用原型實例指定創建對象的種類，并且通過拷貝這些原型，創建新的對象。
工作原理：將原型對象傳給那個要發動創建的對象，這個要發動創建的對象通過請求原型對象拷貝它們自己來實施創建。即用基類Object的clone()方法或序列化。
UML類圖：
Prototype：原型類，聲明一個克隆自己的接口
ConcretePrototype: 具體的原型類, 實現一個克隆自己的操作
Client: 客戶端讓一個原型對象克隆自己，從而創建一個新的對象
原型模式又可分為淺拷貝和深拷貝，區別在于對引用數據類型的成員變量的拷貝，小朋友你是否有很多問號？ 不急 ，看完這兩種方法實現你就懂了。
public class Sheep implements Cloneable{
private String name;
private int age;
@Override
protected Object clone() {//克隆該實例，使用默認的clone方法來完成
Sheep sheep = null;
try {
sheep = (Sheep)super.clone();
} catch (Exception e) {
System.out.println(e.getMessage());
}
return sheep;
}
public Sheep(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Sheep{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}public class Client {
public static void main(String[] args) {
Sheep sheepDolly=new Sheep("Dolly",2);
Sheep sheep1 = (Sheep)sheepDolly.clone();
Sheep sheep2 = (Sheep)sheepDolly.clone();
Sheep sheep3 = (Sheep)sheepDolly.clone();
//....
System.out.println("sheep1:"+sheep1+",hashCode:" + sheep1.hashCode());
System.out.println("sheep2:"+sheep2+",hashCode:" + sheep2.hashCode());
System.out.println("sheep3:"+sheep3+",hashCode:" + sheep3.hashCode());
//...
}
}運行結果
至此，原型模式的淺拷貝也成功克隆了三個對象，但是看進度條發現并不簡單。
現在小羊有了一個朋友小牛，Sheep類添加了一個引用屬性Cow，我們同樣再克隆一遍。
public class Sheep implements Cloneable{
private String name;
private int age;
public Cow friend;//新朋友Cow對象，其余不變
@Override
protected Object clone() {
Sheep sheep = null;
try {
sheep = (Sheep)super.clone();
} catch (Exception e) {
System.out.println(e.getMessage());
}
return sheep;
}
public Sheep(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Sheep{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}public class Cow {
private String name;
private int age;
public Cow(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Cow{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}public class Client {
public static void main(String[] args) {
Sheep sheepDolly=new Sheep("Dolly",2);
sheepDolly.friend=new Cow("Tom",1); //并實例化朋友
Sheep sheep1 = (Sheep)sheepDolly.clone();
Sheep sheep2 = (Sheep)sheepDolly.clone();
Sheep sheep3 = (Sheep)sheepDolly.clone();
//....
System.out.println("sheep1:"+sheep1+",hashCode:" + sheep1.hashCode());
System.out.println("sheep1.friend:"+sheep1.friend+",hashCode:" + sheep1.friend.hashCode()+'\n');
System.out.println("sheep2:"+sheep2+",hashCode:" + sheep2.hashCode());
System.out.println("sheep2.friend:"+sheep2.friend+",hashCode:" + sheep2.friend.hashCode()+'\n');
System.out.println("sheep3:"+sheep3+",hashCode:" + sheep3.hashCode());
System.out.println("sheep3.friend:"+sheep3.friend+",hashCode:" + sheep3.friend.hashCode()+'\n');
//...
}
}運行結果
通過運行結果發現，淺拷貝通過Object的clone()成功克隆實例化了三個新對象，但是并沒有克隆實例化對象中的引用屬性，也就是沒有克隆friend對象（禁止套娃 ），三個新克隆對象的friend還是指向原克隆前的friend，即同一個對象。
這樣的話，他們四個的friend是引用同一個，若一個對象修改了friend屬性，勢必會影響其他三個對象的該成員變量值。
小結：
淺拷貝是使用默認的 clone()方法來實現
基本數據類型的成員變量，淺拷貝會直接進行值傳遞（復制屬性值給新對象）。
引用數據類型的成員變量，淺拷貝會進行引用傳遞（復制引用值(內存地址)給新對象）。
方法一：
機靈的人兒看出，再clone一遍cow不就好了，但是手動遞歸下去不推薦。
public class Cow implements Cloneable{
private String name;
private int age;
public Cow(String name, int age) {
this.name = name;
this.age = age;
}
//無引用類型，直接clone即可
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone(); //直接拋出了，沒用try-catch
}
@Override
public String toString() {
return "Cow{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}public class Sheep implements Cloneable{
private String name;
private int age;
public Cow friend;//新朋友Cow對象，其余不變
@Override
protected Object clone() throws CloneNotSupportedException {
Object deep = null;
//完成對基本數據類型(屬性)和String的克隆
deep = super.clone();
//對引用類型的屬性，進行再次clone
Sheep sheep = (Sheep)deep;
sheep.friend = (Cow)friend.clone();
return sheep;
}
public Sheep(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Sheep{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
Sheep sheepDolly=new Sheep("Dolly",2);
sheepDolly.friend=new Cow("Tom",1); //并實例化朋友
Sheep sheep1 = (Sheep)sheepDolly.clone();
Sheep sheep2 = (Sheep)sheepDolly.clone();
Sheep sheep3 = (Sheep)sheepDolly.clone();
//....
System.out.println("sheep1:"+sheep1+",hashCode:" + sheep1.hashCode());
System.out.println("sheep1.friend:"+sheep1.friend+",hashCode:" + sheep1.friend.hashCode()+'\n');
System.out.println("sheep2:"+sheep2+",hashCode:" + sheep2.hashCode());
System.out.println("sheep2.friend:"+sheep2.friend+",hashCode:" + sheep2.friend.hashCode()+'\n');
System.out.println("sheep3:"+sheep3+",hashCode:" + sheep3.hashCode());
System.out.println("sheep3.friend:"+sheep3.friend+",hashCode:" + sheep3.friend.hashCode()+'\n');
//...
}
}運行結果
方法二：
通過對象序列化實現深拷貝(推薦)
public class Cow implements Serializable {
private String name;
private int age;
public Cow(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Cow{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}public class Sheep implements Serializable { //實現序列化接口
private String name;
private int age;
public Cow friend;
public Sheep(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Sheep{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
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);
Sheep sheep = (Sheep) ois.readObject();
return sheep;
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
//關閉流
try {
bos.close();
oos.close();
bis.close();
ois.close();
} catch (Exception e2) {
System.out.println(e2.getMessage());
}
}
}
}public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
Sheep sheepDolly=new Sheep("Dolly",2);
sheepDolly.friend=new Cow("Tom",1); //并實例化朋友
Sheep sheep1 = (Sheep)sheepDolly.deepClone();
Sheep sheep2 = (Sheep)sheepDolly.deepClone();
Sheep sheep3 = (Sheep)sheepDolly.deepClone();
//....
System.out.println("sheep1:"+sheep1+",hashCode:" + sheep1.hashCode());
System.out.println("sheep1.friend:"+sheep1.friend+",hashCode:" + sheep1.friend.hashCode()+'\n');
System.out.println("sheep2:"+sheep2+",hashCode:" + sheep2.hashCode());
System.out.println("sheep2.friend:"+sheep2.friend+",hashCode:" + sheep2.friend.hashCode()+'\n');
System.out.println("sheep3:"+sheep3+",hashCode:" + sheep3.hashCode());
System.out.println("sheep3.friend:"+sheep3.friend+",hashCode:" + sheep3.friend.hashCode()+'\n');
//...
}
}運行結果
原型模式總結：
創建新的對象比較復雜時，可以利用原型模式簡化對象的創建過程，同時也能夠提高效率
可以不用重新初始化對象，動態地獲得對象運行時的狀態。
如果原始對象發生變化(增加或者減少屬性)，其它克隆對象的也會發生相應的變化，無需修改代碼
若成員變量無引用類型，淺拷貝clone即可；若引用類型的成員變量很少，可考慮遞歸實現clone，否則推薦序列化。
到此，相信大家對“java中的原型模式是什么”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
