原型模式
前言
原型模式属于对象的创建模式。通过给出一个原型对象来指明所有创建的对象的类型，然后用复制这个原型对象的办法创建出更多同类型的对象。这就是选型模式的用意。
克隆羊问题：
现在有一只羊tom，姓名为: tom, 年龄为：1，颜色为：白色，请编写程序创建和tom 羊 属性完全相同的10只羊。传统方式解决克隆羊问题：
/**
* @author 孙一鸣 on 2020/2/6
*/
public class Client {
public static void main(String[] args) {
Sheep sheep =new Sheep("tom",1,"白色");
Sheep sheep1 =new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor());
Sheep sheep2 = new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor());
Sheep sheep3 = new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor());
Sheep sheep4 = new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor());
Sheep sheep5 =new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor());
System.out.println(sheep1);
System.out.println(sheep2);
System.out.println(sheep3);
}
}
传统的方式的优缺点 ：
- 优点是比较好理解，简单易操作。
- 在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂
时，效率较低（因为是克隆，所以属性值要相同） - 总是需要重新初始化对象，而不是动态地获得对象运行时的状态, 不够灵活
- 改进的思路分析
思路：
Java中Object类是所有类的根类，Object类提供了一个clone()方法，该方法可以
将一个Java对象复制一份，但是需要实现clone的Java类必须要实现一个
接口Cloneabl 该接口表示该类能够复制且具有复制的能力 => 原型模式
原型模式:
基本介绍:
此处引用https://blog.csdn.net/qq_40709468/article/details/82316418
多重影分身非常合适这个概念，鸣人本体是原型对象！通过“多重影分身术”也就是原型模式（自己本身使用忍术进行创建），进行分身！创建新对象，（分身）。
需要注意的是，创建新“分身”的人就是鸣人！这个意思就是说原型对象自己不仅是个对象还是个工厂！并且通过克隆方式创建的对象是全新的对象，它们都是有自己的新的地址，通常对克隆模式所产生的新对象（影分身）进行修改（攻击）是不会对原型对象（鸣人）造成任何影响的！，每一个克隆对象都是相对独立的，通过不同的方式对克隆对象进行修改后，可以的到一系列相似但不完全相同的对象。（参考多重影分身之色诱术）。
原型模式要求对象实现一个可以“克隆”自身的接口，这样就可以通过复制一个实例对象本身来创建一个新的实例。这样一来，通过原型实例创建新的对象，就不再需要关心这个实例本身的类型，只要实现了克隆自身的方法，就可以通过这个方法来获取新的对象，而无须再去通过new来创建。
sheep类实现cloneable接口：
public class Sheep implements Cloneable {
@Override
protected Object clone() {
Sheep sheep=null;
try{
sheep= (Sheep) super.clone();
}catch (Exception e){}
return sheep;
}
}
/**
* @author 孙一鸣 on 2020/2/6
*/
public class Client {
public static void main(String[] args) {
Sheep sheep =new Sheep("tom",1,"白色");
Sheep sheep1 =(Sheep)sheep.clone();
Sheep sheep2 =(Sheep)sheep .clone();
Sheep sheep3 =(Sheep)sheep.clone();
System.out.println(sheep1);
System.out.println(sheep2);
System.out.println(sheep3);
}
}
深入讨论-浅拷贝和深拷贝
Java的所有类都是从java.lang.Object类继承而来的，而Object类提供protected Object clone()方法对对象进行复制，子类当然也可以把这个方法置换掉，提供满足自己需要的复制方法。对象的复制有一个基本问题，就是对象通常都有对其他的对象的引用。当使用Object类的clone()方法来复制一个对象时，此对象对其他对象的引用也同时会被复制一份
Java语言提供的Cloneable接口只起一个作用，就是在运行时期通知Java虚拟机可以安全地在这个类上使用clone()方法。通过调用这个clone()方法可以得到一个对象的复制。由于Object类本身并不实现Cloneable接口，因此如果所考虑的类没有实现Cloneable接口时，调用clone()方法会抛出CloneNotSupportedException异常。
克隆满足的条件
clone()方法将对象复制了一份并返还给调用者。所谓“复制”的含义与clone()方法是怎么实现的。一般而言，clone()方法满足以下的描述：- 对任何的对象x，都有：x.clone()!=x。换言之，克隆对象与原对象不是同一个对象。
- 对任何的对象x，都有：x.clone().getClass() == x.getClass()，换言之，克隆对象与原对象的类型一样。
- 如果对象x的equals()方法定义其恰当的话，那么x.clone().equals(x)应当成立的。
在JAVA语言的API中，凡是提供了clone()方法的类，都满足上面的这些条件。JAVA语言的设计师在设计自己的clone()方法时，也应当遵守着三个条件。一般来说，上面的三个条件中的前两个是必需的，而第三个是可选的
浅拷贝基本介绍：
- 对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将
该属性值复制一份给新的对象。 - 对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类
的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内
存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个
实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象 的该成
员变量值 - 前面我们克隆羊就是浅拷贝
- 浅拷贝是使用默认的 clone()方法来实现
sheep = (Sheep) super.clone();
现在羊有它的朋友，克隆羊的话，它的朋友是被复制一份呢，还是指向原来的引用呢？
/**
* @author 孙一鸣 on 2020/2/6
*/
public class Client {
public static void main(String[] args) {
Sheep sheep =new Sheep("tom",1,"白色");
sheep.friend=new Sheep("jack",1,"黑色");
//现在羊有它的朋友，克隆羊的话，它的朋友是被复制一份呢，还是指向原来的引用呢？
Sheep sheep1 =(Sheep)sheep.clone();
Sheep sheep2 =(Sheep)sheep.clone();
Sheep sheep3 =(Sheep)sheep.clone();
System.out.println(sheep1.friend.hashCode());
System.out.println(sheep2.friend.hashCode());
System.out.println(sheep3.friend.hashCode());
}
}
结果分析:
深拷贝基本介绍
、- 复制对象的所有基本数据类型的成员变量值
- 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变
量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对
整个对象进行拷贝 - 深拷贝实现方式1：重写clone方法来实现深拷贝
- 深拷贝实现方式2：通过对象序列化实现深拷贝(推荐)
全部复制，然后各自独立。你修改克隆对象对于原型对象没有丝毫影响，完全的影分身！
重写clone方法来实现深拷贝
案例说明:
大圣 要制作分身 ，每一个分身有名字 和自己的武器，武器有着自己的高度和重量，每一个大圣要有自己独立思想。
代码实现：
大圣类：
package 设计模式.原型模式.深拷贝;
import java.io.Serializable;
/**
* 齐天大圣 孙悟空 分身术
* 深拷贝就是将孙悟空化为无数分身，每一个分身都不相同
*
* @author 孙一鸣 on 2020/2/6
*/
public class DaSheng implements Serializable, Cloneable {
public String name;
//齐天大圣的武器
public Wuqi wuqi;
//方法一：重写clone
@Override
protected Object clone() throws CloneNotSupportedException {
Object deep = null;
//这里完成对基本数据类型（属性）and String 的克隆
deep = super.clone();
//对引用类型的属性进行单独处理
// 首先，将已经处理好基本类型的deep，由 Object类型 转换为 DeepProtoType 类型
DaSheng sunWuKong = (DaSheng) deep;
//此时的deep 处理好的内容 有 name属性 ，
//将deep转为 DaSheng ，name属性已被复制，没有处理的有 孙悟空的金箍棒
//单独复制孙悟空的金箍棒
sunWuKong.wuqi = (Wuqi) wuqi.clone();
return sunWuKong;
}
}
武器类：
package 设计模式.原型模式.深拷贝;
import java.io.Serializable;
/**
* @author 孙一鸣 on 2020/2/6
*/
public class Wuqi implements Cloneable, Serializable {
private static final long serialVersionUID=1L;
//金箍棒的高度
public String wuqi_hight;
//金箍棒的重量
public String wuqi_weight;
public Wuqi(String wuqi_hight, String wuqi_weight) {
this.wuqi_hight = wuqi_hight;
this.wuqi_weight = wuqi_weight;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
测试类：
package 设计模式.原型模式.深拷贝;
/**
* @author 孙一鸣 on 2020/2/6
*/
public class Client {
public static void main(String[] args) throws Exception{
DaSheng monkey =new DaSheng();
monkey.name="孙悟空";
monkey.wuqi = new Wuqi("100","100");
System.out.println(monkey+"武器高："+monkey.wuqi.wuqi_hight +" 武器重： "+monkey.wuqi.wuqi_weight);
System.out.println("深拷贝..");
DaSheng monkey2= (DaSheng) monkey.clone();
DaSheng monkey3= (DaSheng) monkey.clone();
System.out.println(monkey2.hashCode() == monkey3.hashCode());
}
}
对象序列化方式深拷贝
这个时候要聊一聊什么是序列化了。
把对象写到流里的过程是序列化(Serialization)过程；而把对象从流中读出来的过程则叫反序列化(Deserialization)过程。应当指出的是，写到流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。
简单的讲就是序列化就将对象写到流的一个过程，写到流里面去（就是字节流）就等于复制了对象，但是原来的对象并没有动，只是复制将类型通过流的方式进行读取，然后写到另个内存地址中去！
大圣类:
package 设计模式.原型模式.深拷贝.对象序列化深拷贝;
import java.io.*;
/**
* 齐天大圣 孙悟空 分身术
* 深拷贝就是将孙悟空化为无数分身，每一个分身都不相同
*
* @author 孙一鸣 on 2020/2/6
*/
public class DaSheng implements Serializable, Cloneable {
public String name;
//齐天大圣的武器
public Wuqi wuqi;
//深拷贝 方式2 通过对象的序列化实现
public Object FenShen() {
//创建流对象
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);
DaSheng daSheng = (DaSheng) ois.readObject();
return daSheng;
} catch (Exception e) {
return null;
} finally {
try {
bos.close();
oos.close();
bis.close();
ois.close();
} catch (Exception e) {
}
}
}
}
武器类没有变化：
package 设计模式.原型模式.深拷贝.对象序列化深拷贝;
import java.io.Serializable;
/**
* @author 孙一鸣 on 2020/2/6
*/
public class Wuqi implements Cloneable, Serializable {
private static final long serialVersionUID=1L;
//金箍棒的高度
public String wuqi_hight;
//金箍棒的重量
public String wuqi_weight;
public Wuqi(String wuqi_hight, String wuqi_weight) {
this.wuqi_hight = wuqi_hight;
this.wuqi_weight = wuqi_weight;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
小结
原型模式的注意事项和细节
优点
- 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提
高效率 - 不用重新初始化对象，而是动态地获得对象运行时的状态
- 如果原始对象发生变化(增加或者减少属性)，其它克隆对象的也会发生相应的变化，
无需修改代码 - 在实现深克隆的时候可能需要比较复杂的代码
缺点：
需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有
的类进行改造时，需要修改其源代码，违背了ocp原则
原型模式适用场景
在以下情况可以考虑使用。
1创建对象成本比较大，比如初始化要很长时间的，占用太多CPU的，新对象可以通过复制已有的对象获得的，如果是相似的对象，则可以对其成员变量稍作修改。
2系统要保存对象状态的，而对象的状态改变很小。
3需要避免使用分层次的工厂类来创建分层次的对象，并且类的对象就只用一个或很少的组合状态！
扫一扫
548
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
