🏵️🏵️🏵️原型模式

🍊1.概述

用一个已经创建出来的实例对象作为原型，复制出一个与原型相同的新对象.（类似于 🤪一气化三清🤪）

使用场景：

• 对象的创建很复杂，这时使用原型模式可以快捷的创建对象
• 性能和安全要求比较高

🍊2.结构

• 抽象原型类： 定义具体原型对象必须实现的clone（）方法
• 具体原型类： 实现抽象原型类的clone（）方法，是能够被复制的原型类
• 访问类： 访问具体原型类中的clone（）方法来复制新的对象（测试类）

🍊3.实现

原型模式中的克隆分为浅拷贝和深拷贝

浅拷贝： 创建出的新对象的属性和原来对象完全相同，对于非基本类型属性，其内存地址仍指向原来对象所指向的内存地址

深拷贝： 创建出的新对象属性及属性中引用的其他对象也会被克隆，不再指向原有内存地址

注：无论是浅拷贝还是深拷贝，都会创建出一个新对象，这个对象的内存地址与原来对象一定是不相同的！！！

类似于我们电脑上的快捷方式和复制文件

🌸3.1浅拷贝

🌰1.浅拷贝实现

Java中的Object类中提供了clone()方法来实现浅拷贝。Cloneable接口是原型模式结构中的抽象原型类，而实现了Cloneable接口的子实现类就是具体的原型类。

Cloneable接口:

抽象原型类就是上图的Cloneable接口

具体原型类:

public class RealizeCopy implements Cloneable{
    public RealizeCopy(){
        System.out.println("具体原型对象创建完成!");
    }


    @Override
    protected RealizeCopy clone() throws CloneNotSupportedException {
        System.out.println("具体原型复制成功!");

        return (RealizeCopy) super.clone();
    }
}

访问类:

public class Client {
    public static void main(String[] args) {
        //创建一个原型类对象
        RealizeCopy realizeCopy = new RealizeCopy();

        //调用RealizeCopy类中的clone方法进行对象的拷贝
        try {
            RealizeCopy clone = realizeCopy.clone();

            //比较原型对象和拷贝出的对象
            System.out.print("原型对象 vs 拷贝出的对象:");
            System.out.println(realizeCopy== clone);

        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

    }
}

运行结果：

浅拷贝拷贝出的新对象和原对象相同，但是内存地址不同，相当于重新new了一个对象

🍉2.浅拷贝的问题

创建一个原型对象Study，其有一个属性是student对象

public class Study implements Cloneable{

    private Student student;

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }
    public  void show(){
        System.out.println(student.getName()+"开始学习啦......");
    }

    @Override
    protected Study clone() throws CloneNotSupportedException {
        return (Study) super.clone();
    }

}

学生类（原型对象属性引用的对象）

public class Student {
    private String name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}

访问类:

public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {

        //1.创建原型对象
        Study study1 = new Study();
        //创建一个学生对象
        Student student = new Student();
        student.setName("雪月清");
        //将学生对象赋值给study1对象
        study1.setStudent(student);

        //2.拷贝study1对象
        Study study2 = study1.clone();
        study2.getStudent().setName("李华");

        //3.调用show()方法
        study1.show();
        study2.show();

    }
}

运行结果：

震惊的发现李华原来竟是我自己！！！这就是浅拷贝的问题，只能拷贝一层，也就是原型对象本身，而原型对象所引用的对象则是指向同一内存地址，因此无论是study1对student进行修改，还是study2对student进行修改都会造成两者的student属性改变。

这就是浅拷贝的非基本类型属性，其内存地址仍指向原来对象所指向的内存地址

图解：

🌸3.2深拷贝

创建出的新对象属性及属性中引用的其他对象也会被克隆，不再指向原有内存地址

🌰1.深拷贝的实现

使用I/O流实现深拷贝

原型类（记得实现Serializable接口）

public class Student implements Serializable {
    private String name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}

原型类属性引用对象类(记得实现Serializable接口)

public class Study implements Cloneable,Serializable{

    private Student student;

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }
    public  void show(){
        System.out.println(student.getName()+"开始学习啦......");
    }

    @Override
    protected Study clone() throws CloneNotSupportedException {
        return (Study) super.clone();
    }

}

访问类

public class Client {
    public static void main(String[] args) throws Exception {

        //1.创建原型对象
        Study study1 = new Study();
        //创建一个学生对象
        Student student = new Student();
        student.setName("雪月清");
        //将学生对象赋值给study1对象
        study1.setStudent(student);

       //创建对象输出流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:/study.txt"));
        //写对象
        oos.writeObject(study1);
        //关闭资源
        oos.close();

        //创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/study.txt"));
        //读取对象
        Study study2 = (Study) ois.readObject();
        //释放资源
        ois.close();

       study2.getStudent().setName("李华");

       study1.show();
       study2.show();

    }
}

运行结果：

图解：

如果喜欢文章可以三连支持！！！ 💖💖💖