转https://www.jianshu.com/p/15bc149bd0af
前言
使用原形模式可以解决复杂对象构建资源消耗的问题
原形模式是一种创建型模式，原形模式多用于创建复杂对象或者构造耗时的实例。它的作用主要是"克隆"，用户从原形对象复制出一个内部属性一样的对象。因为类的初始化需要耗费很多的资源，原形拷贝则可以更高效。
原形模式
由原形实例指定创建对象的种类，并通过拷贝这些原形创建新的对象
原形模式举例
继承Cloneable然后必须用Object clone。把需要clone的东西属性放进去。
浅拷贝支持对象：（8种基本数据类型byte,char,short,int,long,float,double，boolean）、
其他的都需要深拷贝：数组、对象等、string
浅拷贝如果用了8种数据之外的，会有影响到原始的对象。所有要进行深拷贝。
浅拷贝理解成获取到的是变量的本身，所以调用的时候直接得到的值就是原对象的数据
深拷贝理解成得到了一个一模一样的权限变量，可以对其赋值等等，不会影响到原对象。
深拷贝就需要对深拷贝的对象加上clone.也可以理解成拷贝两次吧。就是person已经在前面的clone了一次，再调用一次clone
person.books = (ArrayList<String>) this.books.clone();
import android.util.Log;
import java.util.ArrayList;
public class Person implements Cloneable{
private String name;
private int age;
private ArrayList<String> books = new ArrayList<String>();
public Person() {
}
@Override
public Object clone() {
Person person = null;
try {
person = (Person) super.clone(); //super.clone()理解成一组
person.age = this.age;
person.name = this.name;
person.books = this.books;
return person;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public ArrayList<String> getBooks() {
return books;
}
public void addBook(String bookName) {
books.add(bookName);
}
public void printPerson() {
Log.d("prototype","age = " + age);
Log.d("prototype","name = " + name);
if (books.size() > 0 ) {
for (String bookName:books) {
Log.d("prototype","book name = " + bookName);
}
}
}
}
1、Person类继承implements Cloneable接口，Cloneable标示接口，表示这个对象可以被拷贝。
2、clone方法是Object中的方法，如果实现clone方法没有继承Cloneable会抛出异常
看看如何调用：
Person xiaoMing = new Person();
xiaoMing.addBook("a");
xiaoMing.addBook("b");
xiaoMing.setAge(18);
xiaoMing.setName("xiaoMing");
Person xiaoHong = (Person) xiaoMing.clone();
xiaoHong.setName("xiaoHong");
xiaoHong.addBook("c");
xiaoHong.printPerson();
xiaoMing.printPerson();
输出如下：
age = 18
name = xiaoHong
book name = a
book name = b
book name = c
age = 18
name = xiaoMing
book name = a
book name = b
book name = c
1、对象xiaoHong由xiaoMing克隆生成。
2、调用clone方法克隆一个对象时不会走其构造方法。
浅拷贝、深拷贝
我们可以看到private ArrayList<String> books输出都一样，说明xiaoHong和xiaoMing这两个实例对象的参数是相同的。他们指向同一个引用地址。这种拷贝就叫做浅拷贝。通常我们想在clone的时候不想印象原本的对象xiaoMing，因为我们不想改变xiaoHong的时候还会改变xiaoMing，这时候，我们就应该深拷贝。
深拷贝应该这样：
@Override
public Object clone() {
Person person = null;
try {
person = (Person) super.clone();
person.age = this.age;
person.name = this.name;
person.books = (ArrayList<String>) this.books.clone();
return person;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
我们再看下这个时候的输出
age = 18
name = xiaoHong
book name = a
book name = b
book name = c
age = 18
name = xiaoMing
book name = a
book name = b
这个时候books输出就正确了，这个时候我们思考这样一个问题，age和name为啥不会影响，而只有books是浅拷贝呢。
其实这个更好理解了，因为int和String一个是整形一个是字符串，都是值类型而不是引用类型，因此他们不需要clone，在副本对象克隆好之后，直接返回给客户端对象即可。
深拷贝的只读保护
深拷贝还有一个用处就是只读。当我们想保护某一个实例不被随意更改的时候，通常我们把set方法设为私有。我们先看这样写
public class Master {
private static Master master;
private Person mPerson;
private Master() {}
public static Master getMaster () {
if (master == null) {
master = new Master();
}
return master;
}
protected void setPerson(Person person) {
this.mPerson = person;
}
public Person getPerson() {
return mPerson;
}
}
1、我们创建了一个Master，Master是单例，拥有一个Person类，我们视为一个主人。
2、设置这个主人的方法我们定义为protected,包安全，即在同一个包名下的类才可以修改。唯一修改主人的途径。
在使用的时候发现没能真正的保护起来，当我想在其他包名下调用时确实不能调用
Master master = Master.getMaster();
//master.setPerson(xiaoMing); 不能调用会提示方法protected
但是我们却可以这样来改
Master master = Master.getMaster();
master.getPerson().setName("jack");
这样肯定不行的，因为我们的目的是只能通过包级私方法去设置修改，那么我们应该这样做
public Person getPerson() {
return (Person)mPerson.clone();
}
至此，我们返回的是clone的一个对象，你拿到这个对象无论怎么修改，都不会影响Master真正的主人
总结
最后，原形模式其实就是对象的拷贝，这跟C++/Object-C中的clone类似，容易出问题的也就在深浅拷贝上，使用原形模式可以解决复杂对象构建资源消耗的问题。也可以用来只读保护。注意其clone时不会走构造函数。
作者：Yink_Liu
链接：https://www.jianshu.com/p/15bc149bd0af
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
