设计模式之原型模式

Posted 2021-12-03 醉酒的小男人

什么原型模式

原型模式是指通过原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象,属于创建型模式。在程序里面一般都是基于二进制流的复制。

浅克隆

package com;
import java.io.*;
import java.util.List;

public class ConcretePrototype implements Cloneable, Serializable {
    private int age;
    private String name;
    private List<String> houses;

    @Override
    public ConcretePrototype clone()  {
        try {
            return (ConcretePrototype)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }


    public ConcretePrototype deepClone()  {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);

            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);

            return (ConcretePrototype) ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public List<String> getHouses() {
        return houses;
    }

    public void setHouses(List<String> houses) {
        this.houses = houses;
    }

    @Override
    public String toString() {
        return "ConcretePrototype{" +
                "age=" + age +
                ", name='" + name + '\\'' +
                ", houses=" + houses +
                '}';
    }
}

package com;
import java.util.ArrayList;
import java.util.List;

public class ShallowCopyTest
{
    public static void main( String[] args )
    {
        //创建原型对象
        ConcretePrototype prototype = new ConcretePrototype();
        prototype.setAge(11);
        prototype.setName("张三");
        List<String> houses = new ArrayList<>();
        houses.add("北京房产");
        houses.add("上海房产");
        prototype.setHouses(houses);
        System.out.println("原对象: "+prototype);

        //拷贝原型对象
        ConcretePrototype cloneType = prototype.clone();
        cloneType.setAge(16);
        cloneType.getHouses().add("广州房产");

        System.out.println("原型对象: "+prototype);
        System.out.println("克隆对象: "+cloneType);
    }
}

执行结果:

深克隆

package com;
import java.io.*;
import java.util.List;

public class ConcretePrototype implements Cloneable, Serializable {
    private int age;
    private String name;
    private List<String> houses;

    @Override
    public ConcretePrototype clone()  {
        try {
            return (ConcretePrototype)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }


    public ConcretePrototype deepClone()  {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);

            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);

            return (ConcretePrototype) ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public List<String> getHouses() {
        return houses;
    }

    public void setHouses(List<String> houses) {
        this.houses = houses;
    }

    @Override
    public String toString() {
        return "ConcretePrototype{" +
                "age=" + age +
                ", name='" + name + '\\'' +
                ", houses=" + houses +
                '}';
    }
}

package com;

import java.util.ArrayList;
import java.util.List;

public class DeepCopyTest {
    public static void main(String[] args) {
        //创建原型对象
        ConcretePrototype prototype = new ConcretePrototype();
        prototype.setAge(11);
        prototype.setName("张三");
        List<String> houses = new ArrayList<>();
        houses.add("北京房产");
        houses.add("上海房产");
        prototype.setHouses(houses);
        System.out.println("原对象: "+prototype);

        //拷贝原型对象
        ConcretePrototype cloneType = prototype.deepClone();
        cloneType.getHouses().add("广州房产");

        System.out.println("原型对象: "+prototype);
        System.out.println("克隆对象: "+cloneType);
        System.out.println(prototype == cloneType);

        System.out.println("原型对象的房子: "+prototype.getHouses());
        System.out.println("克隆对象的房子: "+cloneType.getHouses());
        System.out.println(prototype.getHouses() == cloneType.getHouses());
    }
}

执行结果:

java浅克隆深克隆区别

1.浅克隆不会克隆原对象中的引用类型，仅仅拷贝了引用类型的指向。深克隆则拷贝了所有。也就是说深克隆能够做到原对象和新对象之间完全没有影响。
2.浅克隆：只复制基本类型的数据，引用类型的数据只复制了引用的地址，引用的对象并没有复制，在新的对象中修改引用类型的数据会影响原对象中的引用。
3.深克隆：是在引用类型的类中也实现了clone，是clone的嵌套，复制后的对象与原对象之间完全不会影响。
4.使用序列化也能完成深复制的功能：对象序列化后写入流中，此时也就不存在引用什么的概念了，再从流中读取，生成新的对象，新对象和原对象之间也是完全互不影响的。
5.使用clone实现的深克隆其实是浅克隆中嵌套了浅克隆，与toString方法差不多