原型模式（四）

基本介绍

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();
   }