类型:创建型
定义:用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象。
原型模式的本质:克隆生成对象
克隆是手段,目的是生成新的对象实例(具有与原对象同样的属性值).
JDK也提供了对克隆的支持
克隆又分为浅表克隆和深度克隆
2、深度克隆
克隆的使用还是挺常见的,比如ArrayList
定义:用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象。
原型模式的本质:克隆生成对象
克隆是手段,目的是生成新的对象实例(具有与原对象同样的属性值).
克隆最简单的方法就是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");
说到底,原型模式就是创建一个与原对象有相同属性值的新对象。