🏵️🏵️🏵️原型模式
🍊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();
}
}
运行结果：
图解：
如果喜欢文章可以三连支持！！！ 💖💖💖
