java学习笔记之原型模式及深浅拷贝
一、原型模式的基本介绍
在聊原型模式之前，我们来思考一个小问题，传统的方式我们是如何克隆对象呢？
那我们以多利羊(Sheep)为例，来说明上述这个问题，具体代码见下面：
多利羊（Sheep）
public class Sheep {
private String sname;
private Date birthday;
public Sheep(String sname, Date birthday) {
this.sname = sname;
this.birthday = birthday;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
测试类（Client）
public class Client {
public static void main(String[] args) {
Sheep sheep=new Sheep("多利",new Date());
Sheep sheep2=new Sheep(sheep.getSname(),sheep.getBirthday());
System.out.println("sheep:"+sheep.getSname()+sheep.getBirthday());
System.out.println("sheep2:"+sheep2.getSname()+sheep2.getBirthday());
}
}
那我们来分析一下：
1、在创建新对象时，总是需要获取原始对象的属性，如果我们在实际项目中创建的对象复杂的话，效率是很低的。
2、总是需要重新初始化对象，而不是动态地获取对象运行时的状态，不够灵活。
有什么方法可以改进吗？，原型模式闪亮登场
大家都知道在Java中有一个Object类，这个类提供了一个clone()方法，该方法可以将Java对象复制一份，前提是该类实现一个Cloneable接口,这就是原型模式的源头。
什么是原型模式：
用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。
看了这个定义可能有的小伙伴们比较蒙，那我们来撸一把代码来说明（多利羊克隆）：
多利羊（Sheep）实现Cloneable
public class Sheep implements Cloneable {
private String sname;
private Date birthday;
private Sheep mother;
public Sheep getMother() {
return mother;
}
public void setMother(Sheep mother) {
this.mother = mother;
}
public Sheep(String sname, Date birthday) {
this.sname = sname;
this.birthday = birthday;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
@Override
public String toString() {
return "Sheep{" +
"sname='" + sname + '\'' +
", birthday=" + birthday +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
Sheep sheep=null;
try {
sheep=(Sheep) super.clone();
}catch (Exception e){
e.printStackTrace();
}
return sheep;
}
}
克隆方法的测试（Client）
public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
Sheep sheep=new Sheep("多利",new Date());
Sheep mother=new Sheep("多利的妈妈",new Date());
sheep.setMother(mother);
Sheep sheep1=(Sheep) sheep.clone();
System.out.println("sheep:"+sheep);
System.out.println("sheep1:"+sheep1);
System.out.println("sheep:"+sheep.getMother().hashCode());
System.out.println("sheep1:"+sheep1.getMother().hashCode());
}
}
运行结果：hashcode 的值一样
sheep:Sheep{sname='多利', birthday=Sun May 17 11:56:58 CST 2020}
sheep1:Sheep{sname='多利', birthday=Sun May 17 11:56:58 CST 2020}
sheephashcode:2061475679
sheep1hashcode:2061475679
二、原型模式实现浅克隆和深克隆
浅克隆的介绍：
对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。
对于数据类型是引用数据类型的成员变量（数组，对象），浅拷贝会进行引用传递，也就是将成员变量的引用值（内存地址）复制一份给新的对象，因为实际上两个对象的该成员变量都指向同一个实例（前面克隆羊就是浅拷贝，使用clone()方法实现）。
再次说明：其实就是克隆多利羊之后，克隆的对象没有被真正的复制一份，而是引用指向第一个对象的属性空间。
画图说明：
具体代码如下见上面（多利羊克隆）
深克隆的介绍：
1、对对象进行深拷贝要对整个对象（包括对象的引用类型）进行拷贝。
深克隆实现的方式：
1、重写clone()方法实现深克隆
2、通过对象序列化实现深克隆
第一种方式：重写clone()方法实现深克隆，参考下面代码实现：
public class Sheep implements Cloneable {
private String sname;
private Date birthday;
public Mother mother;
public Sheep() {
}
public Sheep(String sname, Date birthday,Mother mother ) {
this.sname = sname;
this.birthday = birthday;
this.mother=mother;
}
@Override
public String toString() {
return "Sheep{" +
"sname='" + sname + '\'' +
", birthday=" + birthday +
", mother=" + mother +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
Sheep sheep=null;
try {
Object obj= super.clone();
sheep=(Sheep) obj;
sheep.mother=(Mother) mother.clone();
} catch (Exception e) {
e.printStackTrace();
}
return sheep;
}
}
多利的妈咪
public class Mother implements Cloneable {
private int age;
private String name;
public Mother(int age, String name) {
this.age = age;
this.name = name;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
客户端测试：
public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
Sheep sheep=new Sheep("多利",new Date(),new Mother(12,"多利的妈妈"));
Sheep sheep1=(Sheep) sheep.clone();
System.out.println("sheep:"+sheep);
System.out.println("sheep1:"+sheep1);
System.out.println("sheephashcode:"+sheep.mother.hashCode());
System.out.println("sheep1hashcode:"+sheep1.mother.hashCode());
}
}
运行结果：hashcode 的值不一样
sheep:Sheep{sname='多利', birthday=Sun May 17 13:20:51 CST 2020, mother=com.designpattern.pattern.prototypepattern.sprototype.Mother@7adf9f5f}
sheep1:Sheep{sname='多利', birthday=Sun May 17 13:20:51 CST 2020, mother=com.designpattern.pattern.prototypepattern.sprototype.Mother@85ede7b}
sheephashcode:2061475679
sheep1hashcode:140435067
第二种方式：序列化和反序列化
需要在Sheep ,Mother 类实现一个序列化 Serializable，具体代码和上面第一种方式的代码一样，就是这Sheep代码中增加以下这段核心代码：
// 通过对象的序列化实现
public Object deepClone() throws Exception {
ByteArrayOutputStream bos=new ByteArrayOutputStream();
ObjectOutputStream oos=new ObjectOutputStream(bos);
oos.writeObject(this);
ObjectInputStream ois=new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
Sheep sheep=(Sheep) ois.readObject();
return sheep;
}
运行结果：
sheep:Sheep{sname='多利', birthday=Sun May 17 13:51:23 CST 2020, mother=com.designpattern.pattern.prototypepattern.sprototype.Mother@72ea2f77}
sheep1:Sheep{sname='多利', birthday=Sun May 17 13:51:23 CST 2020, mother=com.designpattern.pattern.prototypepattern.sprototype.Mother@17f052a3}
sheephashcode:1927950199
sheep1hashcode:401625763
三、原型模式的应用场景
Spring 中bean 的scope 属性的声明：
<bean id="student" class="com.Student" scope="prototype"/>
public class ProtoType {
public static void main(String[] args) {
// TODO Auto-generated method stub
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
// 获取monster[通过id获取monster]
Object bean = applicationContext.getBean("student");
System.out.println("bean:" + bean);
Object bean2 = applicationContext.getBean("student");
System.out.println("bean1" + bean2);
System.out.println(bean == bean2);
}
}
运行结果
bean:com.atguigu.spring.bean.Student@52bf72b5
bean1com.atguigu.spring.bean.Student@37afeb11
false
四、小结
优点：
1、创建新的对象比较复杂时，可以利用原型模式创建新的对象，不用重新初始化对象，而是动态地获得对象运行时的状态。
2、如果原始对象发生变化，其克隆的对象也会发生响应的变化，不需要修改代码来实现
缺点：
需要为每一个类配置一个克隆方法，需要器修改源代码，不符合OCP原则。
技术之路还很长，慢慢来吧，时间会证明一切。
最新文章
- iOS中的生命周期
- Spring(三)AOP面向切面编程
- PHP中常见魔术方法解析
- 解如下方程（java实现）
- BZOJ1588——[HNOI2002]营业额统计
- UVa 105 - The Skyline Problem（利用判断，在于想法）
- 最小瓶颈路 Uva 534 Frogger
- Linux命令-date
- 偷偷mark下一个
- Android中BroadCast与Activity之间的通信
- css（一）-- 概述以及引入方式
- java反射 顺序输出类中的方法
- Word Break(动态规划)
- 003 win7如何配置adb环境变量
- js ·节点的知识点
- 每日一练ACM 2019.04.14
- Python requests上传文件demo
- Linux系统学习之Linux账号管理
- eact native生成APP报错：You have not accepted the license agreements of the following SDK components:
- pytest进阶