JAVA设计模式之原型模式

原型模式

1、用原型实例指定创建对象的类型、通过拷贝原型来创建新的对象

2、创建型设计模式、允许一个对象在创建另一个可定制对象

羊原型

public class Sheep implements Cloneable{
    private String name;
    private int age;
    private String address;

    public Sheep(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Sheep sheep = null;
        try {
            sheep = (Sheep) super.clone();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return sheep;
    }

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

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

克隆

public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Sheep sheep = new Sheep("肖恩", 1, "东北羊");
        Sheep cloneSheep1 = (Sheep) sheep.clone();
        Sheep cloneSheep2 = (Sheep) sheep.clone();
        System.out.println(cloneSheep1);
        System.out.println(cloneSheep2);
    }
}

Spring源码

设置bean实例的作用域scope=”protoType“

采用了原型模式

浅拷贝

1、对于基本数据类型的成员变量、浅拷贝将值传递（复制）给一个新对象

2、对于引用类型的成员变量，只是将该成员变量的引用（内存地址）复制给新的对象

3、浅拷贝默认使用clone() 方法实现

4、克隆羊采用浅拷贝

深拷贝

1、复制对象的所有基本数据类型的成员变量值

2、为所有引用类型的成员变量申请存储空间、并复制每个引用数据类型成员变量所引用的对象（深拷贝对所有对象进行拷贝）

实现方式：

• 重写clone方法
• 通过对象序列化实现

Sheep类

public class Sheep implements Cloneable, Serializable {
    private String name;
    private String address;

    public Sheep(String name, String address) {
        this.name = name;
        this.address = address;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    
    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
}

SheepMan类

public class SheepMan implements Cloneable, Serializable {
    private String name;
    private Sheep sheep;

    public SheepMan() {
    }

    public SheepMan(String name, Sheep sheep) {
        this.name = name;
        this.sheep = sheep;
    }

    //深拷贝方法1：重写clone方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object deep = null;
        //对基本数据类型的拷贝
        deep = super.clone();

        //对引用类型的拷贝,单独处理
        SheepMan sheepMan = (SheepMan) deep;
        sheepMan.sheep = (Sheep) sheep.clone();

        return sheepMan;
    }

    //深拷贝方法2：采用序列化
    public Object deepClone() throws Exception {
        ByteArrayInputStream bis=null;
        ObjectInputStream ois=null;
        ByteArrayOutputStream bos=null;
        ObjectOutputStream oos=null;
        try {
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this); //当前对象以对象流方式输出 （序列化）

            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            SheepMan sheepMan = (SheepMan) ois.readObject();
            return sheepMan;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            try {
                bis.close();
                ois.close();
                bos.close();
                oos.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Sheep getSheep() {
        return sheep;
    }
    public void setSheep(Sheep sheep) {
        this.sheep = sheep;
    }
}

方法实现

public class DeepTest {
    public static void main(String[] args) throws Exception{
        //方法1：重写clone方法
        SheepMan sheepMan1 = new SheepMan();
        sheepMan1.setName("小明");
        sheepMan1.setSheep(new Sheep("肖恩","东北羊"));
        SheepMan clone = (SheepMan)sheepMan1.clone();
        System.out.println(sheepMan1.getSheep().hashCode());
        System.out.println(clone.getSheep().hashCode());
        //使用序列化方法
        SheepMan sheepMan2 = new SheepMan();
        sheepMan2.setName("小明");
        sheepMan2.setSheep(new Sheep("肖恩","东北羊"));
        SheepMan clone1 =(SheepMan) sheepMan2.deepClone();
        System.out.println(sheepMan2.getSheep().hashCode());
        System.out.println(clone1.getSheep().hashCode());
    }
}

打印结果：