设计模式 - 创建型 - 原型设计模式学习

现象：
设计模式 - 创建型 - 原型模式学习

实现：
用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象
原型的复制分为浅克隆和深克隆。
1、浅克隆：创建一个新对象，复制基本类型的值，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。
2、深克隆：创建一个新对象，基本类型和引用类型都会被克隆，引用类型不再指向原有对象地址。

方法：
一：浅克隆
1、创建原型类实现Cloneable接口 拥有基本属性 和引用属性user

// 原型类 实现Cloneable接口
class RealizeType implements Cloneable{
    private int id;
    private Integer ids;
    private User user;
    public User getUser() {
        return user;
    }

    // 构造方法
    RealizeType(){}
    public RealizeType(int id, Integer ids) {
        System.out.println("原型创建");
        this.id = id;
        this.ids = ids;
        this.user=new User("zhang");
    }

    // 复制：浅克隆(复制基本类型)
    public Object clone() throws CloneNotSupportedException {
        System.out.println("原型复制");
        return super.clone();
    }

    @Override
    public String toString() {
        return "RealizeType{" +
                "id=" + id +
                ", ids=" + ids +
                ", user=" + user +
                '}';
    }
}

// 测试引用类型克隆
class User{
    private String name;

    public User() {
        super();
    }

    public User(String name) {
        this.name = name;
    }
}

2、测试对象浅克隆

public static void main(String[] args) {
	//  创建对象realizeType
	RealizeType realizeType=new RealizeType(1,2);
	RealizeType realizeType2 = null;
	try {
		//  复制对象realizeType2 
	   realizeType2 = (RealizeType)realizeType.clone();
	} catch (CloneNotSupportedException e) {
	   e.printStackTrace();
	}
	
	System.out.println(realizeType);
	System.out.println(realizeType2);
	
	System.out.println(realizeType.getUser().equals(realizeType2.getUser()));
	// true

	System.out.println(realizeType.getUser()==realizeType2.getUser());
	// 引用对象地址相同 true

	System.out.println(realizeType.equals(realizeType2));
	// 对象复制出来是新对象  结果：false
	
	System.out.println(realizeType==realizeType2);
	// 结果：false
}

3、输出：
原型创建
原型复制
RealizeType{id=1, ids=2, user=com.example.shirotest_demo.utils.User@2a84aee7}
RealizeType{id=1, ids=2, user=com.example.shirotest_demo.utils.User@2a84aee7}
true
true
false
false

二：深克隆

1、创建原型类实现Cloneable接口 拥有基本属性 和引用属性user

// 深克隆原型
public class RealizeDeepType implements Cloneable {
    private int id;
    private Integer ids;
    private User user;

    public User getUser() {
        return user;
    }

    /** 构造方法 */
    RealizeDeepType() {}
    public RealizeDeepType(int id, Integer ids) {
        System.out.println("原型创建");
        this.id = id;
        this.ids = ids;
        this.user = new User("zhang");
    }

    /** 复制：深克隆(复制基本类型、复制引用类型) */
    @Override
    public RealizeDeepType clone() throws CloneNotSupportedException {
        System.out.println("原型复制");
        // 基本属性复制
        var realizeDeepType =(RealizeDeepType) super.clone();
        // 引用属性复制
        realizeDeepType.user=this.user.clone();
        return realizeDeepType;
    }

    @Override
    public String toString() {
        return "RealizeType{" + "id=" + id + ", ids=" + ids + ", user=" + user + '}';
    }
}


/** 测试引用类型克隆 */
class User implements Cloneable{
    private String name;

    public User() {
        super();
    }

    public User(String name) {
        this.name = name;
    }

    @Override
    public User clone() throws CloneNotSupportedException {
        System.out.println("user原型复制");
        return (User)super.clone();
    }

}

2、测试对象深克隆

public static void main(String[] args){
   // 创建对象realizeType
    RealizeDeepType realizeType=new RealizeDeepType(1,2);
    RealizeDeepType realizeType2 = null;
    try {
        // 复制对象realizeType2
        realizeType2 = (RealizeDeepType)realizeType.clone();
    } catch (CloneNotSupportedException e) {
        e.printStackTrace();
    }

    System.out.println(realizeType);
    System.out.println(realizeType2);

    System.out.println(realizeType.getUser().equals(realizeType2.getUser()));
    // 引用对象不一样false

    System.out.println(realizeType.getUser()==realizeType2.getUser());
    // 引用对象地址不相同 false


    System.out.println(realizeType.equals(realizeType2));
    // 对象复制出来是新对象  结果：false
    
    System.out.println(realizeType==realizeType2);
    // 结果：false
  }

3、输出：