原型模式（四）

基本介绍

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" class="com.atguigu.spring.bean.Monster" 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();
   }