设计模式之原型设计

设计模式之原型模式

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 Exception{
                          DeepProtoType p = new DeepProtoType();
                          p.name="宋江";
                          p.deepCloneTarget = new DeepCloneTarget("小特","王牌君");
                          
                          //使用方式一完成深拷贝
                         DeepProtoType p1=(DeepProtoType) p.clone();
                          System.out.println(p.deepCloneTarget.hashCode()==p1.deepCloneTarget.hashCode());//应该为false
                          
                          //方式2实现深拷贝
                          DeepProtoType p = new DeepProtoType();
                          p.name="宋江";
                          p.deepCloneTarget = new DeepCloneTarget("小特","王牌君");
                           DeepProtoType p1= (DeepProtoType)p.deepClone();
                          System.out.println(p.deepCloneTarget.hashCode()==p1.deepCloneTarget.hashCode());//应该为false
                      }
                  }

                   

      5. 原型模式的注意事项和细节

         1. 创建型的对象比较复杂的时候，可以利用原型模式简化对象的创建过程，同时也能够提高效率

         2. 不用重新初始化对象，而是动态的获取对象的运行时状态

         3. 如果原始对象发生变化(增加或者减少属性)其他可能对象也会发生相应的变化，而不需要修改代码

         4. 在实现深拷贝的时候可能需要比较复杂的代码

         5. 缺点：需要为每一个类配备一个克隆方法，这对于一个全新的类来说并不难，但是对于已经有的类进行改造时，需要修改其源代码，违背了ocp原则