设计模式4-原型模式

设计模式4-原型模式

---

一、什么是原型模式？

原型模式：创建重复的对象。

二、模式实现

需要拷贝的原型类必须实现Cloneable接口，然后重写clone()方法，从而实现复制粘贴
1.原型类

@AllArgsConstructor
public class Person implements Cloneable{
    public String name;
    public Integer age;
    public Computer computer;

    @Override
    protected Object clone()  {
        Person person = null;
        try {
             person = (Person)super.clone();
            return person;
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return person;
    }
}

public class Computer implements Cloneable{
    public String colour;
    public String brand;
    public Computer(String colour, String brand) {
        this.colour = colour;
        this.brand = brand;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

2.测试

public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer("white", "惠普");
        Person person = new Person("刘云", 26, computer);
        Person clone1 = (Person)person.clone();
        System.out.println("hashcode:"+person.computer.hashCode());
        System.out.println("hashcode:"+clone1.computer.hashCode());
    }
}

这时我们注意到2个对象的hashcode值一样，说明复制的只是引用数据类型的地址值，并没有实际意义上复制，引用数据类型的成员变量依然指向原来的地址。这就是所谓的“浅克隆”。我们先来看看定义。
浅拷贝：当类的成员变量是基本数据类型时，浅拷贝会复制该属性的值给新对象；当成员变量是引用数据类型时，浅拷贝复制的是引用数据类型的地址值，这种情况下，当拷贝出的某一个类的修改了引用数据类型的成员变量后，会导致所有拷贝出的类都发生变化。
深拷贝：深拷贝不仅会复制成员变量为基本数据了类型的值，给新对象。还会给引用数据类型的成员变量申请储存空间，并复制
接下来实现深拷贝
第一种，实现Cloneable接口，重写clone()方法。

 @Override
    protected Object clone()  {
        Person person = null;
        try {
             person = (Person)super.clone();
            person.computer = (Computer)this.computer.clone();
            return person;
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return person;
    }

第二种采用反序列化，所以原型类和成员变量类需要实现Serializable接口。

    public Object deepClone(){
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;
        try {
            //序列化
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this);
            //反序列化
            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            Person person = (Person)ois.readObject();
            return person;
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

测试

public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer("white", "惠普");
        Person person = new Person("刘云", 26, computer);
        Person clone1 = (Person)person.deepClone();
        System.out.println("  hashcode:"+person.computer.hashCode());
        System.out.println("  hashcode:"+clone1.computer.hashCode());
    }
}

---

总结

1. 通过原型模式可以简化创建重量级对象的过程，并提高程序的效率。
2. 原型设计模式是动态获取对象运行时的状态进行创建对象的。
3. 使用原型设计模式可以使代码变的更加灵活，因为当原型类发生变化（增、减属性）时，克隆的对象也会做出相应的改变。
4. 对已经创建好的类进行改造，使其支持克隆时需要修改源代码，这就是违背了ocp原则。