原型模式

一、java中的构建模型直接支持原始模型。所有的javaBean都继承Object类，Object类有一个clone方法，用于克隆对象，而克隆对象又分为浅复制和深复制。

二、大致结构

1、原始接口类

2、具体原始类

三、代码

1、原始接口类

package com.prototype;

public interface Prototype extends Cloneable {
    
    Prototype deepClone();
    
    Prototype shallowClone();
    
}

2、具体原始类

package com.prototype;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Person implements Prototype, Serializable {
    
    /**
     * 
     */
    private static final long serialVersionUID = -5730267042366141834L;

    private String name;
    
    private int age;
    
    private Dog dog;
    
    public Person(String name, int age, Dog dog) {
        this.name = name;
        this.age = age;
        this.dog = dog;
        
    }
    
    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

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

    
    /**
     * 深复制，会将dog引用的对象也复制一份
     */
    
    @Override
    public Prototype deepClone() {
        //创建数组输出流，将对象存到内存中
        ByteArrayOutputStream byteArrayOutputStream = null;
        ObjectOutputStream objectOutputStream = null;
        ByteArrayInputStream byteArrayInputStream = null;
        ObjectInputStream objectInputStream = null;
        Person person = null;
        try {
            byteArrayOutputStream = new ByteArrayOutputStream();
            objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            //将对象存入内存，并复制一份留在堆中
            objectOutputStream.writeObject(this);
            byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
            objectInputStream = new ObjectInputStream(byteArrayInputStream);
            //读取内存，将对象取出
            person = (Person) objectInputStream.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if(byteArrayOutputStream != null) {
                    
                    byteArrayOutputStream.close();
                }
                
                if(objectOutputStream != null) {
                    
                    objectOutputStream.close();
                }
                
                if(byteArrayInputStream != null) {
                    
                    byteArrayInputStream.close();
                }

                if(objectInputStream != null) {
                    
                    objectInputStream.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

            
        }
        return person;
    }

    /**
     * 浅复制，复制dog对象的引用
     */
    @Override
    public Prototype shallowClone() {
        Prototype obj = null;
        try {
            obj = (Person)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        
        return obj;
        
    }

        
        

}

3、Person的附属对象

package com.prototype;

import java.io.Serializable;

public class Dog implements Serializable {

    /**
     * 
     */
    private static final long serialVersionUID = 5518998591955476396L;

    private String name;
    
    private String color;
    
    public Dog(String name, String color) {
        this.name = name;
        
        this.color = color;
        
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Dog [name=" + name + ", color=" + color + "]";
    }
    
    

}

4、测试类

package com.prototype;

public class Test {
    
    public static void main(String[] args) {
        
        Person person1 = new Person("youth", 22, new Dog("阿黄", "黄色"));
        
        Person person2 = (Person) person1.shallowClone();
        //浅复制的dog对象仍然是原来的对象
        System.out.println(person1.getDog() == person2.getDog());
        
        Person person3 = (Person) person1.deepClone();
        //深复制的dog对象是不是同一个对象，两者为克隆关系
        System.out.println(person1.getDog() == person3.getDog());
        System.out.println("本尊：" + person1.getDog());
        System.out.println("克隆：" + person3.getDog());
        
        
    }

}

5、结果

true
false
本尊：Dog [name=阿黄, color=黄色]
克隆：Dog [name=阿黄, color=黄色]