原型模式
1.经典案例
- 克隆羊多利。有姓名，身高，体重，年龄等属性。可以用来当作模板，克隆10只属性完全相同的羊。
- 三好学生奖状。有姓名，学校，获奖时间等属性。奖状可以当作模板，打印多份，使用时只需要修改姓名，学校，获奖时间。
常规解法
1.定义sheep实体类，生成构造方法、getter和setter方法、toString方法
2.实例化10个对象
缺点：
效率低，每次创建对象都需要获取原始对象的属性，不能动态获取对象运行时的状态。
新思路-原型模式
2.原型模式定义
【创建型】设计模式。允许另外一个对象再创建另外一个可定制的对象
用原型实例指定创建的对象，并通过拷贝原型，创建新对象，同时保证性能
3.工作原理
- 原型类声明克隆自己的接口
- Client类让具体的原型类对象克隆自己，创建一个新的对象
- Prototype：声明一个克隆自己的接口
- client：客户端让一个原型对象克隆自己
- ConcretePrototype:实现一个克隆自己的操作
4.原型模式分类
- 浅拷贝
代码思路：
在实体类的基础上实现Cloneable接口，重写clone方法
Demo中调用克隆对象
代码演示：
🐏的实体类
package com.henji.clone;
/**
* Sheep类基础上实现Cloneable接口，重写clone方法。
*
* @author henji
* @date 2023/3/6 19:08
*/
public class Sheep implements Cloneable {
private String name;
private int age;
@Override
protected Object clone () throws CloneNotSupportedException {
Sheep sheep = null;
sheep = (Sheep) super.clone ();
return sheep;
}
/*******省略构造方法、setter、getter、toString方法*******/
}
🐏的实现类
package com.henji.clone;
/**
* @author henji
* @date 2023/3/6 20:06
*/
public class Demo {
public static void main (String[] args) throws CloneNotSupportedException {
Sheep sheep = new Sheep ("喜羊羊", 2);
Object c1 = sheep.clone ();
Object c2 = sheep.clone ();
Object c3 = sheep.clone ();
System.out.println (c1 + "===" + c1.hashCode ());
System.out.println (c2 + "===" + c2.hashCode ());
System.out.println (c3 + "===" + c3.hashCode ());
}
}
运行结果
总结：
- 三个对象的哈希值不同，说明拷贝进行是值传递，而不是引用传递
继续往下看：
此时慢羊羊也来凑热闹了，再新建一个🐏的实体类，并再Sheep类添加一个引用属性。再拷贝一遍
新建的慢羊羊实体类
package com.henji.clone;
/**
* 慢羊羊的实体类
*
* @author henji
* @date 2023/3/6 19:08
*/
public class Sheep2 {
private String name;
private int age;
/*******省略构造方法、setter、getter、toString方法*******/
}添加了慢羊羊的引用属性的🐏实体类
package com.henji.clone;
/**
* Sheep类基础上实现Cloneable接口，重写clone方法。
*
* @author henji
* @date 2023/3/6 19:08
*/
public class Sheep implements Cloneable {
private String name;
private int age;
public Sheep2 sheep2;//引用慢羊羊
@Override
protected Object clone () throws CloneNotSupportedException {
Sheep sheep = null;
sheep = (Sheep) super.clone ();
return sheep;
}
/*******省略构造方法、setter、getter、toString方法*******/
}实例化慢羊羊
package com.henji.clone;
/**
* @author henji
* @date 2023/3/6 20:06
*/
public class Demo {
public static void main (String[] args) throws CloneNotSupportedException {
Sheep sheep = new Sheep ("喜羊羊", 2);
sheep.sheep2 = new Sheep2 ("慢羊羊", 8);
Sheep c1 = (Sheep) sheep.clone ();
Sheep c2 = (Sheep) sheep.clone ();
Sheep c3 = (Sheep) sheep.clone ();
System.out.println (c1 + "===" + c1.hashCode () + ":::" + c1.sheep2 + "===" + c1.sheep2.hashCode ());
System.out.println (c2 + "===" + c2.hashCode () + ":::" + c2.sheep2 + "===" + c2.sheep2.hashCode ());
System.out.println (c3 + "===" + c3.hashCode () + ":::" + c3.sheep2 + "===" + c3.sheep2.hashCode ());
}
}运行结果
总结：
- 拷贝的三个喜羊羊对象哈希地址各不相同，依旧发生了值传递，但三个慢羊羊的地址完全相同，没有发生拷贝动作，地址指向克隆前的同一个对象。（如何让慢羊羊的拷贝对象也发生值传递？）
特征：
- 浅拷贝使用默认的clone()方法实现
- 基本数据类型的成员变量，浅拷贝会直接进行值传递
- 引用数据类型的成员变量，浅拷贝会进行引用传递
- 深拷贝
代码思路:
- 慢羊羊的实体类也实现Cloneable接口
- 实体类实现序列化接口，不实现Cloneable接口
实现Cloneable接口，重写clone
/**
* 慢羊羊的实体类
*
* @author henji
* @date 2023/3/6 19:08
*/
public class Sheep2 implements Cloneable {
private String name;
private int age;
/*
使用默认clone方法
*/
@Override
protected Object clone () throws CloneNotSupportedException {
return super.clone ();
}
}
在喜羊羊的实体类clone方法中调用慢羊羊的clone方法
package com.henji.clone;
/**
* Sheep类基础上实现Cloneable接口，重写clone方法。
*
* @author henji
* @date 2023/3/6 19:08
*/
public class Sheep implements Cloneable {
private String name;
private int age;
public Sheep2 sheep2;
@Override
protected Object clone () throws CloneNotSupportedException {
Object deep = null;
//对基本数据类型拷贝
deep = super.clone ();
//对引用数据类型拷贝
Sheep sheep = (Sheep) deep;
sheep.sheep2 = (Sheep2) sheep2.clone ();
return sheep;
}
}
再次运行Demo类
运行结果：
总结：
- 两个类（基本数据类型，引用数据类型）的拷贝，都实现了值传递，达成了深拷贝。
特征：
- 基本数据类型和引用数据类型，深拷贝都会对其进行值传递【复制】
通过序列化实现深拷贝
慢羊羊的实体类实现序列化接口，不需要再实现Cloneable接口package com.henji.clone;
import java.io.Serializable;
/**
* 慢羊羊的实体类
*
* @author henji
* @date 2023/3/6 19:08
*/
public class Sheep2 implements Serializable {
private String name;
private int age;
}喜羊羊的实体类也实现序列化接口，并使用流package com.henji.clone;
import java.io.*;
/**
* Sheep类基础上实现Cloneable接口，重写clone方法。
*
* @author henji
* @date 2023/3/6 19:08
*/
public class Sheep implements Serializable {
private String name;
private int age;
public Sheep2 sheep2;
/**
* 深拷贝
*
* @return
*/
Object deepClone () {
//创建流对象
ByteArrayOutputStream bos = null;
ObjectOutputStream oos = null;
ByteArrayInputStream bis = null;
ObjectInputStream ois = null;
try {
//序列化
bos = new ByteArrayOutputStream ();
oos = new ObjectOutputStream (bos);
oos.writeObject (this);//输出当前对象
//反序列化
bis = new ByteArrayInputStream (bos.toByteArray ());
ois = new ObjectInputStream (bis);
Sheep sheep = (Sheep) ois.readObject ();
return sheep;
} catch (IOException e) {
throw new RuntimeException (e);
} catch (ClassNotFoundException e) {
throw new RuntimeException (e);
} finally {
try {
bos.close ();
oos.close ();
bis.close ();
ois.close ();
} catch (IOException e) {
throw new RuntimeException (e);
}
}
}
/*******省略构造方法、setter、getter、toString方法*******/客户端调用package com.henji.clone;
/**
* @author henji
* @date 2023/3/6 20:06
*/
public class Demo {
public static void main (String[] args) throws CloneNotSupportedException {
Sheep sheep = new Sheep ("喜羊羊", 2);
sheep.sheep2 = new Sheep2 ("慢羊羊", 8);
Sheep c1 = (Sheep) sheep.deepClone ();
Sheep c2 = (Sheep) sheep.deepClone ();
Sheep c3 = (Sheep) sheep.deepClone ();
System.out.println (c1 + "===" + c1.hashCode () + ":::" + c1.sheep2 + "===" + c1.sheep2.hashCode ());
System.out.println (c2 + "===" + c2.hashCode () + ":::" + c2.sheep2 + "===" + c2.sheep2.hashCode ());
System.out.println (c3 + "===" + c3.hashCode () + ":::" + c3.sheep2 + "===" + c3.sheep2.hashCode ());
}
}- 深拷贝和浅拷贝的区别
在于对引用数据类型的成员变量的拷贝
- 浅拷贝对引用数据类型进行引用传递
- 深拷贝对引用数据类型进行值传递
5.特点：
优点
- 动态获取对象运行时的状态，不需要重新初始化对象
- 原始对象发生增加或者减少属性，其他克隆对象也会发生变化，无须修改代码
- 创建的新对象比较复杂时，可以使用原型模式简化对象创建过程，提高效率
缺点
- 需要为每一个类重写一个克隆方法
- 对已存在的类进行改造需要修改源码，违背了开闭原则
- 对象存在多层引用，每一层对象都必须支持深拷贝，并且需要编写复杂的代码
6.应用场景
设计模式之原型设计应用-制作奖状
