定义:
原型模式是一种创建型设计模式，它允许一个对象创建另一个可定制的对象，而无需了解如何创建这个对象的细节。这种模式的核心在于对象拷贝，即通过将一个原型对象传给要创建的对象，然后由这个要创建的对象通过请求原型对象拷贝自身来实施创建。
本期代码:小麻雀icknn/设计模式练习 - Gitee.com
工作原理:
通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对像拷贝它们自己来实现创建，即对象的clone()
原型模式组成
- 抽象原型类（CloneSource）：定义了一个抽象的克隆方法。
- 具体原型类（CloneTest1&CloneTest2）：实现抽象原型类（接口）定义的克隆方法，提供一个具体的克隆方法来复制自己。
- 客户端（PrototypeMain）：使用原型类的对象来实现具体的操作，即通过复制原型对象来创建新的对象。
例子:
克隆源
package com.study.main.Prototype;
public class CloneSource implements Cloneable{
public String getName() {
return "克隆源";
}
@Override
protected Object clone() throws CloneNotSupportedException {
CloneSource cloneSource = null;
try{
cloneSource = (CloneSource) super.clone();
}
catch (CloneNotSupportedException err){
err.printStackTrace();
}
return cloneSource;
}
}
克隆1类
package com.study.main.Prototype;
public class CloneTest1 extends CloneSource{
public void show(){
System.out.println("测试克隆1");
}
}
克隆2类
package com.study.main.Prototype;
public class CloneTest2 extends CloneSource{
public void show(){
System.out.println("测试克隆2");
}
}
实现类
目标:克隆出2个克隆1类,2个克隆类
package com.study.main.Prototype;
public class PrototypeMain {
public static void main(String[] args) throws CloneNotSupportedException {
CloneTest1 cloneSource = new CloneTest1();
CloneTest2 cloneSource2 = new CloneTest2();
for (int i = 0; i < 2; i++) {
CloneTest1 cloneTest= (CloneTest1) cloneSource.clone();
cloneTest.show();
System.out.println(cloneTest.getName());
}
for (int i = 0; i < 2; i++) {
CloneTest2 cloneTest2= (CloneTest2) cloneSource2.clone();
cloneTest2.show();
System.out.println(cloneTest2.getName());
}
}
}结果:
注意 :
- 实现 cloneable 接口: cloneable 接口与序列化接口的作用类似，它只是告诉虚拟机可以安全地在实现了这个接口的类上使用 clone() 方法。在 JVM 中，只有实现了Cloneable 接口的类才可以被拷贝，否则会抛出 CloneNotSupportedException 异常。
- 重写 object 类中的 clonel() 方法: 在 Java 中，所有类的父类都是 object 类，而 object类中有一个 clone)方法，作用是返回对象的一个拷贝。
- 在重写的 clone() 方法中调用 super.clone(): 默认情况下，类不具备复制对象的能力,需要调用 super.clone() 来实现
深拷贝&浅拷贝
浅拷贝
例子:
学生类:
package com.study.main.Prototype.Test;
public class Student implements Cloneable {
String name;
private Teacher teacher;
public Teacher getTeacher() {
return teacher;
}
public void setTeacher(Teacher teacher) {
this.teacher = teacher;
}
@Override
protected Object clone() throws CloneNotSupportedException {
Student student = null;
try{
Student clone = (Student) super.clone();
return clone;
}catch (CloneNotSupportedException err) {
err.printStackTrace();
}
return student;
}
}
教师类
package com.study.main.Prototype.Test;
public class Teacher implements Cloneable {
String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
protected Object clone() throws CloneNotSupportedException {
Teacher teacher = null;
try{
Teacher clone = (Teacher) super.clone();
return clone;
}catch (CloneNotSupportedException err) {
err.printStackTrace();
}
return teacher;
}
}
测试&运行
package com.study.main.Prototype.Test;
public class TestMain {
public static void main(String[] args) throws CloneNotSupportedException {
// 创建教师
Teacher teacher = new Teacher();
// 设置教师姓名
teacher.setName("A");
// 创建学生
Student stu1 = new Student();
// 设置学生1教师
stu1.setTeacher(teacher);
// 克隆学生1==>学生2
Student stu2 = (Student) stu1.clone();
// 设置学生2教师
stu2.setTeacher(teacher);
// 获取stu2老师
Teacher stu2Teacher = stu2.getTeacher();
// 学生2改变名字
teacher.setName("B");
System.out.println("学生1老师姓名:"+stu1.getTeacher().getName());
System.out.println("学生2老师姓名:"+stu2.getTeacher().getName());
}
}
结果
深拷贝
只改变上面学生类中的克隆方法让教师对象也进行一边克隆即可
完整学生类
package com.study.main.Prototype.Test;
public class Student implements Cloneable {
String name;
private Teacher teacher;
public Teacher getTeacher() {
return teacher;
}
public void setTeacher(Teacher teacher) {
this.teacher = teacher;
}
@Override
protected Object clone() throws CloneNotSupportedException {
Student student = null;
try{
Student clone = (Student) super.clone();
teacher = (Teacher) this.teacher.clone();
return clone;
}catch (CloneNotSupportedException err) {
err.printStackTrace();
}
return student;
}
}
结果:
附加Typescript版本
interface Cloneable{
clone():any;
}
class Student implements Cloneable{
public name:string|undefined;
public age:number|undefined;
constructor(name:string,age:number){
this.name = name;
this.age = age;
}
public setName(name:string){
this.name = name
}
clone(): any {
const student:Object =new Object;
const that = this;
Object.assign(student,that)
return student?student:new Error("创建失败");
}
}
const stu1 = new Student('ycw',10);
const stu2:Student = stu1.clone();
stu1.setName("abc")
console.log(stu1,"stu1")
console.log(stu2,"stu2")
原型模式在JAVA中的应用
ArrayList
HashMap
原型模式的优缺点
优点:
- 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效1.
- 率。
- 不用重新初始化对象，而是动态地获得对象运行时的状态。
- 如果原始对象发生变化(增加或者减少属性)，其他克隆对象也会发生变化，无需修改
- 代码。
- 在实现深克隆的时候可能需要比较复杂的代码
缺点
- 需要为每一个配置类配置一个克隆方法，这对全新的类来说不是很难,但对已有的类进5行改造时，需要修改其源代码，违背了 ocp 原则。(违反开闭原则,如果需要对某个对象进行深克隆则需要对代码进行修改)
