一、原型模式介绍
原型模式：原型模式就是从一个对象再创建另外一个可定制的对象，而且不需要知道任何创建的细节。
所谓原型模式，就是java中的克隆技术，以某个对象为原型。复制出新的对象。显然新的对象具备原型对象的特点。效率高（避免了重新执行构造过程步骤）
克隆类似于new，但和new不同。new创建新的对象属性采用的是默认值。克隆出来的对象的属性值完全和原型对象相同。并且克隆出的新对象不会影响原型对象，克隆后。还可以再修改克隆对象的值。
要实现原型模式，必须实现Cloneable接口，而这个接口里面是空的。
Cloneable接口是一个空接口，使用Cloneable接口都不用导入包。而clone方法是属于Object对象的。如果要克隆某个对象的话必须实现Cloneable接口
|
1
2
3
4
5
6
7
|
*
@author
unascribed
*
@see
java.lang.CloneNotSupportedException
*
@see
java.lang.Object#clone()
*
@since
JDK1.
0
*/
public
interface
Cloneable {
}
|
重写Object对象的clone方法，clone方法为本地方法。效率比较高
|
1
|
protected
native
Object clone()
throws
CloneNotSupportedException;
|
如果我们要克隆某个对象有浅克隆和深克隆
浅克隆：copy该对象，然后保留该对象原有的引用。也就是说不克隆该对象的属性。
深克隆：copy该对象，并且把该对象的所有属性也克隆出一份新的。
二、代码实现
1、浅克隆代码实现：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
/**
* 原型模式:浅克隆
* Cloneable是一个空接口（标记接口），是一个规范。但是如果要克隆这个类对象的话必须实现Cloneable接口
*/
public
class
Sheep
implements
Cloneable{
private
String sname;
private
Date birthday;
/**
* 重写Object对象的clone方法
*/
@Override
protected
Object clone()
throws
CloneNotSupportedException {
//直接调用Object对象的clone方法
Object obj =
super
.clone();
return
obj;
}
//省略get，set方法和构造方法
}
/**
* 测试原型模式（浅克隆）
*/
public
class
Test {
public
static
void
main(String[] args)
throws
Exception {
Date date =
new
Date(1274397294739L);
Sheep s1 =
new
Sheep(
"原型羊"
,date);
Sheep s2 = (Sheep) s1.clone();
//克隆一个羊
System.out.println(s1);
System.out.println(s1.getSname());
System.out.println(
"原日期："
+s1.getBirthday());
date.setTime(34732834827389L);
//改变原有date的值
System.out.println(
"改变后的日期："
+date.toString());
//克隆羊的信息
System.out.println(
"---------------------------------"
);
System.out.println(s2);
System.out.println(s2.getSname());
System.out.println(s2.getBirthday());
//此时的birthday日期使用的是改变后的日期对象引用
}
}
|
最后的结果为：克隆的对象仍然保留了原有对象的引用，值随着改变而改变
|
1
2
3
4
5
6
7
8
|
com.fz.prototype.Sheep
@153f67e
原型羊
原日期：Fri May
21
07
:
14
:
54
CST
2010
改变后的日期：Mon Aug
22
17
:
40
:
27
CST
3070
---------------------------------
com.fz.prototype.Sheep
@18f51f
原型羊
Mon Aug
22
17
:
40
:
27
CST
3070
|
2、深克隆代码实现：克隆对象的同时，把该对象的属性也连带着克隆出新的。
深克隆只需要在clone方法中将该对象的属性也克隆即可
|
1
2
3
4
5
6
7
8
9
10
11
12
|
/**
* 重写Object对象的clone方法
*/
@Override
protected
Object clone()
throws
CloneNotSupportedException {
//直接调用Object对象的clone方法
Object obj =
super
.clone();
//深克隆：把对象下的所有属性也克隆出来
Sheep22 s = (Sheep22) obj;
s.birthday = (Date)
this
.birthday.clone();
return
s;
}
|
测试代码不变，结果则会变了。克隆了之后把原来的日期改变后，克隆的对象2的属性则不会被影响。
|
1
2
3
4
5
6
7
8
|
com.fz.prototype.Sheep2
@15bdc50
原型羊
原日期：Fri May
21
07
:
14
:
54
CST
2010
改变后的日期：Mon Aug
22
17
:
40
:
27
CST
3070
---------------------------------
com.fz.prototype.Sheep2
@18f51f
原型羊
Fri May
21
07
:
14
:
54
CST
2010
|
3、通过序列化和反序列化来实现深克隆对象：序列化需要原型对象实现Serializable接口
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
import
java.io.ByteArrayInputStream;
import
java.io.ByteArrayOutputStream;
import
java.io.ObjectInputStream;
import
java.io.ObjectOutputStream;
import
java.util.Date;
/**
* 测试原型模式（利用序列化和反序列化实现深克隆）
*/
public
class
Test3 {
public
static
void
main(String[] args)
throws
Exception {
Date date =
new
Date(1274397294739L);
Sheep s1 =
new
Sheep(
"原型羊"
,date);
// Sheep s2 = (Sheep) s1.clone();//克隆一个羊
//使用序列化和反序列化实现深复制
//1、将s1对象序列化为一个数组
//通过ObjectOutputStream流将s1对象读出来给ByteArrayOutputStream流
ByteArrayOutputStream bos =
new
ByteArrayOutputStream();
ObjectOutputStream oos =
new
ObjectOutputStream(bos);
oos.writeObject(s1);
//ByteArrayOutputStream流将对象信息转成byte数组，这样byte数组里就包含了对象的数据
byte
[] bytes = bos.toByteArray();
//2、将字节数组中的内容反序列化为一个Sheep对象
//通过ByteArrayInputStream流读入bytes字节数组中数据，然后传给ObjectInputStream对象输入流
ByteArrayInputStream bis =
new
ByteArrayInputStream(bytes);
ObjectInputStream ois =
new
ObjectInputStream(bis);
//通过ObjectInputStream返回一个Sheep对象
Sheep s2 = (Sheep) ois.readObject();
//原型羊的信息
System.out.println(s1);
System.out.println(
"原日期："
+s1.getBirthday());
date.setTime(34732834827389L);
//改变原有date的值
System.out.println(
"改变后的日期："
+date.toString());
//克隆羊的信息
System.out.println(
"---------------------------------"
);
System.out.println(s2);
System.out.println(s2.getBirthday());
}
}
|
通过序列化和反序列化的结果，最终结果还是和深克隆一样。
|
1
2
3
4
5
6
7
8
9
10
11
|
com.fz.prototype.Sheep
@1a116c9
原日期：Fri May
21
07
:
14
:
54
CST
2010
改变后的日期：Mon Aug
22
17
:
40
:
27
CST
3070
---------------------------------
com.fz.prototype.Sheep
@7eb6e2
Fri May
21
07
:
14
:
54
CST
2010
|
三、测试克隆对象的效率
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
package
com.fz.prototype;
/**
* 测试clone对象的效率
*/
public
class
TestClone {
//new 对象
public
static
void
testNew(
int
size){
long
start = System.currentTimeMillis();
for
(
int
i =
0
; i < size; i++) {
Laptop l =
new
Laptop();
}
long
end = System.currentTimeMillis();
System.out.println(
"new 对象耗时："
+(end-start));
}
//clone 对象
public
static
void
testClone(
int
size){
long
start = System.currentTimeMillis();
Laptop l =
new
Laptop();
for
(
int
i =
0
; i < size; i++) {
try
{
Laptop temp = (Laptop) l.clone();
}
catch
(CloneNotSupportedException e) {
e.printStackTrace();
}
}
long
end = System.currentTimeMillis();
System.out.println(
"clone 对象耗时："
+(end-start));
}
public
static
void
main(String[] args) {
testNew(
1000
);
testClone(
1000
);
}
}
class
Laptop
implements
Cloneable{
public
Laptop() {
//模拟创建Laptop对象的时候比较耗时
try
{
Thread.sleep(
10
);
}
catch
(InterruptedException e) {
e.printStackTrace();
}
}
@Override
protected
Object clone()
throws
CloneNotSupportedException {
return
super
.clone();
}
}
|
最后结果为：
new 对象耗时：10063
clone 对象耗时：10
四、使用场景
原型模式适用场景：如果某个对象new的过程中很耗时，则可以考虑使用原型模式。
Spring框架中bean对象的创建就两种模式：单例模式或者原型模式
参考资料：
大话设计模式(带目录完整版).pdf
HEAD_FIRST设计模式（中文版）.pdf
尚学堂_高淇_java300集最全视频教程_【GOF23设计模式】