时间过得很快，一转眼3个月过去了，昨天人事找我谈了话，转正谈话走个流程；有意思的是非要我提意见；我提什么意见；问我未来职业发展；我能说我现在是迷茫状态吗；看不清当初的梦想；只剩下回忆了吗；所以买了3本书；一本寻求内心的富足；一本寻求财富的富足；一本寻求技能的提升；定个小目标；每看完一章都要写心得体会；持之以恒才能长远；好了我们今天研究下原型模式；
开门见山看下定义：
Specify the kinds of objects to create using a prototypical instance,and create new objects by
copying this prototype.（用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对
象。）
通用类图：
图片.png
今天我们不扯淡直接写个Demo开门见山的讲述什么是原型模式；因为它的简单程度仅次于单例模式和迭代器模式。
定义个人类：
package com.ldl.prototypepattern;
public class Person implements Cloneable {
private String name;
private String age;
private int gender;
public Person(String name, String age, int gender) {
super();
this.name = name;
this.age = age;
this.gender = gender;
}
public Person() {
}
@Override
public String toString() {
String outsex = (gender == 1) ? "男" : "女";
return "Person [name=" + name + ", age=" + age + ", gender=" + outsex + "]";
}
@Override
protected Object clone() {
Person person = null;
try {
person = (Person) super.clone();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return person;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public int getGender() {
return gender;
}
public void setGender(int gender) {
this.gender = gender;
}
}
看下有什么异常；没错就是实现了java的Cloneable 接口；原型模式就是这样的，在已有对象的基础上，以此为原型，克隆一个对象的过程我们就认为是原型设计模式；我们测试一下：
package com.ldl.prototypepattern;
public class PersonCloneTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
Person person = new Person("Darling", "22", 1);
Person cloneperson = (Person) person.clone();
cloneperson.setName("老炮儿");
cloneperson.setAge("99");
cloneperson.setGender(0);
System.out.println(person.toString());
System.out.println(cloneperson.toString());}}
图片.png
由结果可见：我们成功的复制了一个对象；并且改动了其内容值两个互不影响：这种方式在一
个循环体内产生大量的对象时，原型模式可以更好地体现其优点；因为是运行时的复制所以更高效；但是复制的对象并不再去执行构造方法，无论是有参构造还是无参构造；
我们证明一下：
我们在Person类构造方法加一段打印说明如下:
public Person(String name, String age, int gender) {
super();
this.name = name;
this.age = age;
this.gender = gender;
System.out.println("老夫聊发少年狂......");
}
public Person() {
System.out.println("老夫聊发少年狂......");
}
图片.png
执行程序，克隆之后并未走构造器，由此可见这是在内存方面的克隆；
其实并不是所有类型都可以被完全克隆；
下面我们再看下原型模式的浅克隆和深克隆:同样我们改造一下代码:
package com.ldl.prototypepattern;
import java.util.ArrayList;
import java.util.List;
public class Person implements Cloneable {
private String name;
private String age;
private int gender;
private List<Integer> test = new ArrayList<Integer>();
public Person(String name, String age, int gender) {
super();
this.name = name;
this.age = age;
this.gender = gender;
System.out.println("老夫聊发少年狂......");
}
public Person() {
System.out.println("老夫聊发少年狂......");
}
public List<Integer> getTest() {
return this.test;
}
public void setTest(int temp) {
this.test.add(temp);
}
@Override
public String toString() {
String outsex = (gender == 1) ? "男" : "女";
return "Person [name=" + name + ", age=" + age + ", gender=" + outsex + "]";
}
@Override
protected Object clone() {
Person person = null;
try {
person = (Person) super.clone();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return person;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public int getGender() {
return gender;
}
public void setGender(int gender) {
this.gender = gender;
}
}
只是加了个私有ArrayList类型变量：我们在测试一下：
package com.ldl.prototypepattern;
public class PersonCloneTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
Person person = new Person("Darling", "22", 1);
person.setTest(100);
Person cloneperson = (Person) person.clone();
cloneperson.setTest(9999);
cloneperson.setName("老炮儿");
cloneperson.setAge("99");
cloneperson.setGender(0);
System.out.println("测试一下" + person.getTest());
// System.out.println(person.toString());
// System.out.println(cloneperson.toString());
}
}
图片.png
哎我操怎么会是这个结果；不是应该是100吗？什么鬼，这就是原型模式中的浅复制；一些类实现cloanabble接口后向jvm声明我是可以复制的；我们具体实现clone()方法后就变成了能够复制的对象；但是类成员变量不是所有都被复制；引用型只是复杂了引用；引用对象的地址并没有复制；有人说那么string类型也属于引用类型怎么没问题？string是比较特殊的它是从字符串常量池中区，没有时候再去创建的；在这里我们可以把string作为基本类型来看；
妈的太恶心了，这么干如果类里面的成员变量多了，我怎么区分，会不会出问题；我就是要全复制互不影响能不能做到？
其实可以的：我们在稍微改造一下代码：
@Override
protected Object clone() {
Person person = null;
try {
person = (Person) super.clone();
person.test=(ArrayList<Integer>) this.test.clone();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return person;
}
测试一下：
卧槽竟然可以了哈哈；棒棒的；
下面我们总结下一些重要事项：
1.克隆模式不会再走构造方法;
2.克隆模式引用型对象只是复制其引用对象不会复制引用的对象地址；
3.克隆模式是使对象可变的的，所以切记不可在类成员变量使用final修饰
4.克隆模式是一种常用模式一般不会单独出现，一般根据工厂方法一起混用；
5.克隆模式一般使用在循环创建对象较多时候，是内存层面的克隆
6.深拷贝和浅拷贝建议不要混合使用，尤其是继承时候，父类有多个引用
的情况就非常复杂，应该分开使用避免踩坑；
网友评论