Failed to mount /sysroot如何解決？
阿新 • • 發佈：2020-12-01
原型模式
克隆羊問題
現在有一隻羊tom,姓名為: tom,年齡為: 1,顏色為:白色，請編寫程式建立和tom羊屬性完全相同的10
只羊。
傳統方式解決克隆羊問題
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 + "]"; } //克隆該例項，使用預設的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());
}
}
原型模式在Spring框架中原始碼分析
- Spring中原型bean的建立，就是原型模式的應用
- 程式碼分析+Debug原始碼
深入討論-淺拷貝和深拷貝
淺拷貝介紹
- 對於資料型別是基本資料型別的成員變數,淺拷貝會直接進行值傳遞,也就是將該屬性值複製一份給新的物件。
- 對於資料型別是引用資料型別的成員變數，比如說成員變數是某個陣列、某個類的物件等，那麼淺拷貝會進行引用傳遞，也就是隻是將該成員變數的引用值(記憶體地址)複製一.份給新的物件。因為實際上兩個物件的該成員變數都指向同一個例項。在這種情況下，在一個物件中修改該成員變數會影響到另一個物件的該成員變數值
- 前面我們克隆羊就是淺拷貝
- 淺拷貝是使用預設的clone()方法來實現
sheep = (Sheep) super.clone();
深拷貝基本介紹
- 複製物件的所有基本資料型別的成員變數值
- 為所有引用資料型別的成員變數申請儲存空間，並複製每個引用資料型別成員變數所引用的物件，直到該物件可達的所有物件。也就是說，物件進行深拷貝要對整個物件(包括物件的引用型別)進行拷貝
- 深拷貝實現方式1:重寫clone方法來實現深拷貝
- 深拷貝實現方式2:通過物件序列化實現深拷貝(推薦)
深拷貝例項
- 使用重寫clone方法實現深拷貝
- 使用序列化來實現深拷貝
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 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());
}java
}
}
}
原型模式的注意事項和細節
- 建立新的物件比較複雜時，可以利用原型模式簡化物件的建立過程，同時也能夠提高效率
- 不用重新初始化物件，而是動態地獲得物件執行時的狀態
- 如果原始物件發生變化(增加或者減少屬性)，其它克隆物件的也會發生相應的變化，無需修改程式碼
- 在實現深克隆的時候可能需要比較複雜的程式碼
- 缺點:需要為每一個類配備一個克隆方法，這對全新的類來說不是很難，但對已有的類進行改造時，需要修改其原始碼，違背了ocp原則。