設計模式之原型設計

設計模式之原型模式

1. 問題：現在有一隻羊tom,姓名爲：tom,年齡爲：1，顏色爲：白色，請編寫程序創建和tom羊屬性完全相同的10只羊

   1. 代碼

      //傳統的解決思路：可以使用類圖展示一下
      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;
          }
          //編寫setter和getter方法
          //編寫toString()
      }
      ​
      //客戶端
      public class Test{
          public static void main(String[] args){
              //傳統方式：
              //優點：   比較好理解，簡單易操作
              //缺點：1.在創建新的對象的時候，總是需要重新獲取原始對象的屬性，如果創建的對象比較複雜的時候，效率較低 2.總是需要重新初始化對象，而不是動態的獲取對象運行時的狀態，不夠靈活
              //改進思路：java中Object類是所有類的根類。Object類提供了一個clone()方法，該方法可以將一個java對象複製一份，但是需要實現clone()方法的java類必須要實現一個接口CloneAble,該接口表示該類可以複製並且具有複製能力-----》原型模式
              
              Sheep sheep=new Sheep("tom",1,"白色");
              Sheep sheep1= new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor());
              Sheep sheep2= new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor());       Sheep sheep3= new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor());
          }
                                               
              
          }
      }

       

   2. 原型模式

      1. 基本介紹

         1. 原型模式：是指用原型實例指定創建對象的種類，並且通過拷貝這些原型，創建新的對象

         2. 原型模式是一種創建型模式，允許一個對象再創建另一個可定製對象，無需知道如何創建的細節

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

         4. 形象的瞭解：孫悟空拔出猴毛變出其他孫悟空

      2. 代碼

         .//實現cloneable接口。重寫clone()方法
         class Sheep implements Cloneable{
             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;
             }
             //編寫setter和getter方法
             //編寫toString()
             //重寫clone(),克隆該實例，使用默認的克隆方法老完成
             @Override
             protected Object clone(){
                 Sheep sheep = null;
                 try{
                     sheep =(Sheep)super.clone();
                 }catch(Exception e){
                     System.out.println(e.getMessage());
                 }
                 return sheep;
             }
         }
         ​
         //客戶端
         public class Client{
             public static void main(String[] args){
                 Sheep sheep=new Sheep("tom",1,"白色");
                 Sheep  sheep1=(Sheep)sheep.clone();
             }
         }

          

      3. 原型模式在Spring框架中的使用

         1. spring中bean的創建就是使用了原型模式，通過.xml中的bean標籤中的scope屬性設置的prototype

      4. 原型模式中淺拷貝和深拷貝介紹

         1. 淺拷貝介紹

            1. 對於數據類型是基本數據類型的成員變量，淺拷貝會直接進行值傳遞，也就是將該屬性值複製一份給新的對象

            2. 對於數據類型是引用數據類型的成員變量，比如說成員變量是某個數組、某個類的對象等，那麼淺拷貝會進行引用傳遞，也就是隻將該成員變量的引用值(內存地址)複製一份給新的對象。因爲兩個對象的該成員變量都指向同一個實例。在這種情況下，在一個對象中修改該成員變量會影響到另一個對象的該成員變量值(代碼證明)

            3. 上面所說的克隆羊就是淺拷貝

            4. 淺拷貝是使用默認的clone()方法來實現的

         2. 深拷貝介紹

            1. 複製對象的所有基本數據類型的成員變量值

            2. 爲所有引用數據類型的成員變量申請存儲空間，並複製每個引用數據類型成員變量所引用的對象，知道該對象可達的對象。也就是說，對象進行深拷貝要對整個對象進行拷貝

            3. 深拷貝實現方式

               1. 重寫clone方法來實現深拷貝

               2. 通過對象序列化實現深拷貝

               3. 代碼實現

                  //深拷貝實現,實現序列化接口和克隆接口
                  public class DeepCloneTarget implements Serializable,Clobeable{
                      private String cloneName;
                      private String cloneClass;
                      //全參構造
                      //重寫clone()方法,因爲該類的屬性都是String,因此這裏使用默認的克隆方法
                      protected Object clone() throws CloneNotSupportedException{
                          return super.clone();
                      }
                  }
                  ​
                  //深拷貝原型類
                  public class DeepProtoType implements Serializable,Conleable{
                      //方便期間使用public
                      public String name;
                      public DeepCloneTarget deepCloneTarget;
                      //編寫無參構造
                      //實現深拷貝--方式一：clone方法
                      @Override 
                      protected Object clone() throws CloneNotSupportedException{
                          Object deep = null;
                          //先完成基本數據類型和string類型的克隆
                          deep = super.clone();
                          //對引用數據類型的屬性進行單獨處理
                          DeepProtoType deepProtoType=(DeepProtoType)deep;
                          deepProtoType.deepCloneTarget=(DeepCloneTarget)deepCloneTarget.clone();
                          return deepProtoType;
                      }
                      
                      //深拷貝 方式二 通過對象的序列化實現深拷貝(強烈推薦)
                      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 copy=(DeepProtoType) ois.readObject(this);
                              return copy;
                          }catch(Exception e){
                              e.printStackTrace();
                              return null;
                          }finally{
                             //關閉流
                              try{
                                ois.close();  
                                bis.close();
                                oos.close();
                                bos.close();
                              }catch(Exception e2){
                                  System.out.println(e2.getMassage());
                              }
                          }
                    
                      }
                  }
                  ​
                  //client
                  public class client{
                      public static void main(String[] args) throws