原型模式（四）

基本介紹

1. 原型模式（Prototype模式）是指：用原型實體指定創建物件的種類，并且通過拷貝這些原型，創建新的物件，
2. 原型模式是一種創建型設計模式，允許一個物件再創建另一個可定制的物件，無需知道創建的細節
3. 作業原理是：通過將一個原型物件傳給那個發動創建的物件，這個發動創建的物件通過請求原型物件拷貝她們自己來實施創建，即物件clone()

代碼

public class Sheep implements Cloneable {

    private String name;
    private int age;
    private String color;
    public Sheep(String name,int age,String color){
        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
    protected Object clone() {
        Sheep sheep = null;
        try {
            sheep = (Sheep) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return sheep;
    }
}

在spring框架的應用

1、beans.xml

<bean id="id01"  scope="prototype" />

2、Test.java

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
Object bean  = applicationContext.getBean("id01");
System.out("bean"+bean);

淺拷貝介紹

1. 對于資料型別是基本資料型別的成員變數，淺拷貝會直接進行值的傳遞，也就是屬性值復制一份給新的物件，

2. 對于資料型別是參考資料型別的成員變數，比如說成員變數是某個陣列，某個類的物件等，那么淺拷貝會進行參考傳遞，也就是只是該成員變數的參考值（記憶體地址）復制一份給新的物件，因為實際上兩個物件的該成員變數都指向同一個實體，在這個情況下，在一個物件中修改成員變數會影響到另一個物件的該成員變數值

3. 淺拷貝是使用，默認的clone()方法來實作，

   public class Person implements Cloneable{
       public String pname;
       public int page;
       public Address address;
       public Person() {}
       
       public Person(String pname,int page){
           this.pname = pname;
           this.page = page;
           this.address = new Address();
       }
       
       @Override
       protected Object clone() throws CloneNotSupportedException {
           return super.clone();
       }
       
       public void setAddress(String provices,String city ){
           address.setAddress(provices, city);
       }
       public void display(String name){
           System.out.println(name+":"+"pname=" + pname + ", page=" + page +","+ address);
       }
   
       public String getPname() {
           return pname;
       }
   
       public void setPname(String pname) {
           this.pname = pname;
       }
   
       public int getPage() {
           return page;
       }
   
       public void setPage(int page) {
           this.page = page;
       }
       
   }
   

深拷貝介紹

1. 復制物件的所有基本資料型別的成員變數值

2. 為所有參考資料型別的成員變數中申請存盤空間，并復制每個參考資料型別成員變數所參考的物件，直到該物件可達到的所有物件，也就是說，物件進行深拷貝要對整個物件進行拷貝

3. 深拷貝實作方式1：重寫clone方法來實作深拷貝

   public class Address implements Cloneable{
       private String provices;
       private String city;
       public void setAddress(String provices,String city){
           this.provices = provices;
           this.city = city;
       }
       @Override
       public String toString() {
           return "Address [provices=" + provices + ", city=" + city + "]";
       }
       @Override
       protected Object clone() throws CloneNotSupportedException {
           return super.clone();
       }
   
   }
   

   Person.class 的 clone() 方法：

   @Override
       protected Object clone() throws CloneNotSupportedException {
           Person p = (Person) super.clone();
           p.address = (Address) address.clone();
           return p;
       }
   

4. 深拷貝實作方式2：通過物件序列化實作深拷貝

   //深度拷貝
   public Object deepClone() throws Exception{
       // 序列化
       ByteArrayOutputStream bos = new ByteArrayOutputStream();
       ObjectOutputStream oos = new ObjectOutputStream(bos);
   
       oos.writeObject(this);
   
       // 反序列化
       ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
       ObjectInputStream ois = new ObjectInputStream(bis);
   
       return ois.readObject();
   }
   

標籤：設計模式

上一篇：責任鏈模式的實踐

下一篇：優雅地處理錯誤真是一門學問啊！