设计模式——原型模式

类型：创建型
定义：用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象。 
原型模式的本质：克隆生成对象
克隆是手段,目的是生成新的对象实例(具有与原对象同样的属性值).

克隆最简单的方法就是new一个自己对象的实例,然后把自己实例中的数据取出来,设置到新的对象实例中。

public class Person{
public String name;
public int age;

public Person clonePerson(){
	//new一个新实例，并将属性值赋值到新对象中
	Person newPerson=new Person();
	newPerson.name=this.name;
	newPerson.age=this.age;
	
	return newPerson;
 }
}
//测试
public static void main(String[] args) {
   Person person = new Person();
   person.name="张三";
   person.age=30;
   
   Person clonePerson = person.clonePerson();
   boolean equal=person==clonePerson;//false
   String name=clonePerson.name; //张三
   int age=clonePerson.age; //30	   	   
}

JDK也提供了对克隆的支持

实现Clonable接口,覆写clone方法,然后调用 super.clone();即可克隆出自身对象

public class Person implements Cloneable{
	public String name;
	public int age;
  
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone(); //
	}
}

克隆又分为浅表克隆和深度克隆

1、浅表克隆
克隆对象的属性与原对象里的属性指向同一个地址
举例说明

public class Car{
	public String carType;//车型
	public float price; //车价
}
public class Person implements Cloneable{
	public String name;
	public int age;
	public Car car;
	
	//自己实现浅表克隆
	public Person clonePerson() {
		// new一个新实例，并将属性赋值到新对象中
		Person newPerson = new Person();
		newPerson.name = this.name;
		newPerson.age = this.age;
		newPerson.car = this.car;//直接赋值car属性

		return newPerson;
	}
     //使用clone()实现
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}

//测试
public static void main(String[] args) {
  Car car = new Car();
  car.carType="奔驰";
  car.price=1000000;
  
  Person person = new Person();
  person.name="张三";
  person.age=30;
  person.car=car;
  
  Person clonePerson = person.clonePerson();
  //浅表克隆，clonePerson.car与person.car相同(指向同一个内存地址)
  boolean equal=clonePerson.car==person.car; 
  
  //改变原始对象中的car属性值，也会改变克隆对象中的car属性值
  person.car.carType="宝马";
  String carType=clonePerson.car.carType; //宝马
	   
}

2、深度克隆

// 实现Cloneable接口
public class Car implements Cloneable {
	public String carType;// 车型
	public float price; // 车价

	@Override
	protected Car clone() throws CloneNotSupportedException {
		return (Car) super.clone();
	}
}

public class Person implements Cloneable {
	public String name;
	public int age;
	public Car car;

	//1、自己实现深度克隆
	public Person clonePerson() {
		// new一个新实例，并将属性赋值到新对象中
		Person newPerson = new Person();
		newPerson.name = this.name;
		newPerson.age = this.age;
		
		Car newCar=new Car();
		newCar.carType=this.car.carType;
		newCar.price=this.car.price;
		newPerson.car = newCar;

		return newPerson;
	}

	//2、使用clone()实现
	@Override
	protected Person clone() throws CloneNotSupportedException {
		Person newPerson=(Person) super.clone();
		newPerson.car=this.car.clone();//克隆car属性
		return newPerson;
	}
}
public static void main(String[] args) {
	Car car = new Car();
	car.carType = "奔驰";
	car.price = 1000000;

	Person person = new Person();
	person.name = "张三";
	person.age = 30;
	person.car = car;

	Person clonePerson = person.clonePerson();
	// 深度克隆，clonePerson.car与person.car不相同
	boolean equal = clonePerson.car == person.car; //false

	// 改变原始对象中的car中的属性值，不会改变克隆对象中的car属性值
	person.car.carType = "宝马";
	String carType = clonePerson.car.carType; // 还是之前"奔驰"

}

克隆的使用还是挺常见的，比如ArrayList

List<String> list=new ArrayList<String>();
list.add("one");
list.add("two");

//将list中的值赋值到newList中
List<String> newList = new ArrayList<>(list);
newList.add("three");

说到底，原型模式就是创建一个与原对象有相同属性值的新对象。