原型模式

//原型类
// 实现拷贝需要继承Cloneable接口
public class Sheep implements Cloneable, Serializable {
    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + '\'' +
                ", master=" + master +
                '}';
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Master getMaster() {
        return master;
    }
    public void setMaster(Master master) {
        this.master = master;
    }
    private String name;
    private Master master;


    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    // 把引用的对象也进行拷贝
    // 这种方法要把所有要拷贝的类都继承Cloneable,并且当有多层引用关系时, 代码会很复杂
    // 不推荐
    public Object deepCloneAbandon() throws CloneNotSupportedException {
        Sheep clone=(Sheep) super.clone();
        clone.master=(Master) this.master.clone();
        return clone;
    }

    // 用流的方法实现深拷贝, 推荐使用
    public Object deepClone() throws CloneNotSupportedException {
        ByteArrayOutputStream byteArrayOutputStream = null;
        ObjectOutputStream objectOutputStream = null;
        ByteArrayInputStream byteArrayInputStream = null;
        ObjectInputStream objectInputStream = null;
        try {
            byteArrayOutputStream = new ByteArrayOutputStream();
            objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(this);

            byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
            objectInputStream = new ObjectInputStream(byteArrayInputStream);
            return objectInputStream.readObject();
        } catch (IOException iOException) {
            iOException.printStackTrace();
            return null;
        } catch (ClassNotFoundException classNotFoundException) {
            classNotFoundException.printStackTrace();
            return null;
        } finally {
            try {
                byteArrayOutputStream.close();
                objectOutputStream.close();
                byteArrayInputStream.close();
                objectInputStream.close();
            } catch (IOException iOException) {
                iOException.printStackTrace();
            }
        }
    }
}

//测试
@Test
public void testPrototype() throws CloneNotSupportedException {
    Sheep sheep = new Sheep();
    sheep.setName("喜洋洋");
    sheep.setMaster(new Master("村长"));
    Sheep copysheep = (Sheep) sheep.clone();
    // hashCode不同,说明不是复制引用而是拷贝对象
    // 拷贝对象中的属性为引用类型的时候, 拷贝的引用地址
    // 所以默认的clone方法是浅拷贝的方法
    System.out.println(sheep.hashCode() + " " + sheep.toString());
    System.out.println(copysheep.hashCode() + " " + copysheep.toString());

    // 人工再拷贝实现深拷贝
    System.out.println("人工再拷贝实现深拷贝");
    Sheep deepCopySheepAbandon = (Sheep) sheep.deepCloneAbandon();
    System.out.println(deepCopySheepAbandon.hashCode() + " " + deepCopySheepAbandon.toString());

    // 用流深拷贝
    System.out.println("用流深拷贝");
    Sheep deepCopySheep = (Sheep) sheep.deepClone();
    System.out.println(deepCopySheep.hashCode() + " " + deepCopySheep.toString());
}