java设计模式-原型模式

分手后的思念是犯贱 2022-05-28 11:12 213阅读 0赞

> 原型模式属于对象的创建模式。通过给出一个原型对象来创建一个和原型内部属性一样的对象，其实就是我们平常在java中用到的`克隆`。

参考：  
[汤高的Java设计模式（五）—-原型模式 ][Java_-_]

**备注补充：**  
1、添加通过序列化的形式快速clone原型对象，通过对象实现序列化接口和Cloneable接口，利用序列化把对象写入到字节缓存中，然后再读出来，形成新的对象，这样比较方便了避免对象嵌套对象的窘境。  
**代码**  
地址类，实现序列化，作为学生类的附属属性。

package com.madman.base.designMode.prototype;
    
    import java.io.Serializable;
    
    public class Address implements Serializable{ 
        private static final long serialVersionUID = -7013043673805221112L;
        public String addr;
    
        public String getAddr() {
            return addr;
        }
    
        /** * 创建人：madman * 创建时间：date() * * @param addr */
        public void setAddr(String addr) {
            this.addr = addr;
        }
    
        @Override
        public String toString() {
            return "Address{" +
                    "addr='" + addr + '\'' +
                    '}';
        }
    }

学生类，实现了序列化和克隆接口。

package com.madman.base.designMode.prototype;
    
    import java.io.*;
    
    public class Student3 implements Cloneable, Serializable{ 
        private static final long serialVersionUID = 4166071456736035421L;
        public String name;
        public int age;
        public Address address;
    
        public String getName() {
            return name;
        }
    
        /** * 创建人：madman * 创建时间：date() * * @param name */
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        /** * 创建人：madman * 创建时间：date() * * @param age */
        public void setAge(int age) {
            this.age = age;
        }
    
        public Address getAddress() {
            return address;
        }
    
        /** * 创建人：madman * 创建时间：date() * * @param address */
        public void setAddress(Address address) {
            this.address = address;
        }
    
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            Object obj = null;
            try {
                ByteArrayOutputStream bao = new ByteArrayOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(bao);
                oos.writeObject(this);
                ByteArrayInputStream bai = new ByteArrayInputStream(bao.toByteArray());
                ObjectInputStream ois = new ObjectInputStream(bai);
                obj = ois.readObject();
                 ois.close();
                bai.close();
                oos.close();
                bao.close();
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
    
            return obj;
        }
    
        @Override
        public String toString() {
            return "Student3{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", address=" + address +
                    '}';
        }
    }

客户端：

package com.madman.base.designMode.prototype;
    
    public class Client3{
        public static void main(String[] args) {
            try {
                Address addr = new Address();
                addr.setAddr("中国上海");
                Student3 s = new Student3();
                s.setAge(18);
                s.setName("madman");
                s.setAddress(addr);
    
                Student3 ss = (Student3) s.clone();
                s.setAge(11);
                s.setName("小彭");
                s.getAddress().setAddr("中国北京...");
                System.out.println(s.toString());
                System.out.println(ss.toString());
            } catch (Exception e) {
                e.printStackTrace();
            }
    
        }
    }

结果

Student3{name='小彭', age=11, address=Address{addr='中国北京...'}}
    Student3{name='madman', age=18, address=Address{addr='中国上海'}}

#### 使用场景 ####

在开发过程中，有时会遇到为一个类创建多个实例的情况，这些实例内部成员往往完全相同或有细微的差异，而且实例的创建开销比较大或者需要输入较多参数，如果能通过复制一个已创建的对象实例来重复创建多个相同的对象，这就可以大大减少创建对象的开销，这个时候就需要原型模式。

#### 原型对象概述 ####

原型模式主要用于对象的复制，对象要想被复制，需要实现满足一下条件：

--------------------

1、实现Cloneable接口。在java语言有一个Cloneable接口，它的作用只有一个，就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在java虚拟机中，只有实现了这个接口的类才可以被拷贝，否则在运行时会抛出 CloneNotSupportedException异常。

2、重写Object类中的clone方法。Java中，所有类的父类都是 Object类，Object类中有一个clone方法，作用是返回对象的一个拷贝，但是其作用域protected类型的，一般的类无法调用，因 此，Prototype类需要将clone方法的作用域修改为public类型。

### 浅度克隆和深度克隆 ###

**浅度克隆**

> 只负责克隆按值传递的数据（比如基本数据类型、String类型），而不复制它所引用的对象，换言之，所有的对其他对象的引用都仍然指向原来的对象。  
> 案例：  
> student1的原型类，实现了Cloneable接口，并重写了clone方法，但是属性类型都是基本数据类型。  
> **代码**

package com.madman.base.designMode.prototype;
    
    public class Student1 implements Cloneable{ 
        public String name;
        public int age;
    
    
        public Student1() {
        }
    
        @Override
        public String toString() {
            return "Student1{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        @Override
        protected Student1 clone() {
            try {
                return (Student1) super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public Student1(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        /** * 创建人：madman * 创建时间：date() * * @param name */
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        /** * 创建人：madman * 创建时间：date() * * @param age */
        public void setAge(int age) {
            this.age = age;
        }
    }

**客户端**

package com.madman.base.designMode.prototype;
    
    public class Client{
        public static void main(String[] args) {
            Student1 s = new Student1();
            s.setAge(18);
            s.setName("madman");
            System.out.println(s.toString());
    
            Student1 s2 = s.clone();
            s2.setName("fengzi");
            s2.setAge(10);
            System.out.println(s2.toString());
        }
    }

**结果：**

Student1{name='madman', age=18}
    Student1{name='fengzi', age=10}

**结论**  
浅克隆模式默认调用父类object的clone方法，对基本数据类型是值拷贝。  
如果在原型对象中放引用对象会怎么样呢。  
**代码**

package com.madman.base.designMode.prototype;
    
    public class Student implements Cloneable{ 
        public String name;
        public int age;
        public Student s;
    
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", s=" + s +
                    '}';
        }
    
        public Student getS() {
            return s;
        }
    
        /** * 创建人：madman * 创建时间：date() * * @param s */
        public void setS(Student s) {
            this.s = s;
        }
    
        public Student() {
        }
    
        @Override
        protected Student clone() {
            try {
                return (Student) super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        /** * 创建人：madman * 创建时间：date() * * @param name */
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        /** * 创建人：madman * 创建时间：date() * * @param age */
        public void setAge(int age) {
            this.age = age;
        }
    }

**客户端**

package com.madman.base.designMode.prototype;
    
    public class MainTest{
        public static void main(String[] args) {
            //##################################
            Student small = new Student("fengzi", 18);
            Student s2 = new Student("madman", 25);
            s2.setS(small);
            Student s3 = s2.clone();
            s3.setAge(11);
            s3.getS().setAge(41);
            System.out.println(s2 == s3);
            System.out.println(s2.toString());
            System.out.println(s3.toString());
            System.exit(0);
            Student s = new Student("madman", 25);
            System.out.println(s.toString());
            Student s1 = s;
            s1.setAge(30);
            System.out.println(s.toString());
            System.out.println(s1.toString());
    
    
        }
    }

**结果**

false
    Student{name='madman', age=25, s=Student{name='fengzi', age=41, s=null}}
    Student{name='madman', age=11, s=Student{name='fengzi', age=41, s=null}}

**结论**  
通过上面的例子发现，修改了age属性，原型中的age值没有变，修改了原型总的student的属性值之后，原型中的值也变了，这是因为调用父类的clone的时候，如果属性是引用类型的话，clone出的对象的引用类型和原型对象的引用类型指向的同一个内存地址，需要改变这种情况就需要`深克隆`.

##### 深克隆 #####

> 除了浅度克隆要克隆的值外，还负责克隆引用类型的数据。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深度克隆把要复制的对象所引用的对象都复制了一遍，而这种对被引用到的对象的复制叫做间接复制。  
> 深度克隆要深入到多少层，是一个不易确定的问题。在决定以深度克隆的方式复制一个对象的时候，必须决定对间接复制的对象时采取浅度克隆还是继续 采用深度克隆。因此，在采取深度克隆时，需要决定多深才算深。此外，在深度克隆的过程中，很可能会出现循环引用的问题，必须小心处理。  
> **代码**

package com.madman.base.designMode.prototype;
    
    public class Student2 implements Cloneable{ 
        public String name;
        public int age;
        public Student2 s;
    
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", s=" + s +
                    '}';
        }
    
        public Student2 getS() {
            return s;
        }
    
        /** * 创建人：madman * 创建时间：date() * * @param s */
        public void setS(Student2 s) {
            this.s = s;
        }
    
        public Student2() {
        }
    
        @Override
        protected Student2 clone() {
            try {
                Student2 s = (Student2) super.clone();
                if (this.s != null) {
                    Student2 ss = new Student2();
                    ss.setAge(this.getS().getAge());
                    ss.setName(this.getS().getName());
                    s.setS(ss);
                }
                return s;
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public Student2(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        /** * 创建人：madman * 创建时间：date() * * @param name */
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        /** * 创建人：madman * 创建时间：date() * * @param age */
        public void setAge(int age) {
            this.age = age;
        }
    }

**客户端**

package com.madman.base.designMode.prototype;
    
    public class Client2{
        public static void main(String[] args) {
            //##################################
            Student2 small = new Student2("fengzi", 18);
            Student2 s2 = new Student2("madman", 25);
            s2.setS(small);
            Student2 s3 = s2.clone();
            s3.setAge(11);
            s3.getS().setAge(41);
            s3.getS().setName("xinxiang");
            System.out.println(s2 == s3);
            System.out.println(s2.toString());
            System.out.println(s3.toString());
    
        }
    }

**结果：**

false
    Student{name='madman', age=25, s=Student{name='fengzi', age=18, s=null}}
    Student{name='madman', age=11, s=Student{name='xinxiang', age=41, s=null}}

**结论**  
上述代码中修改了clone的方法，对引用类型student2做了一层特殊处理，但是还有个问题，如果原型对象student2里面student2也包括引用类型student2也不为空的时候，就需要牵涉到循环clone的问题了，这个需要注意下，案例中只是简单的处理了下。

[Java_-_]: https://blog.csdn.net/tanggao1314/article/details/50596042