设计模式第6弹：原型模式

Java中针对对象的复制方式，有三种不同级别的操作方式

• 引用复制
  • 不创建对象，只是将当前对象的引用复制存储到另一个变量中，多个变量指向的是同一个对象
• 浅拷贝
  • 创建新的对象，但是对象中如果包含引用属性，付出出来的多个对象中的引用属性，指向同一个对象
• 深拷贝
  • 创建全新的对象，多个复制出来的对象互相独立

package com.damu.copy;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.experimental.Accessors;

import java.io.*;
import java.util.ArrayList;
import java.util.List;


public class CopyMethod {

    public static void main(String[] args) {
 // 创建对象
 List list = new ArrayList<>();
 list.add("战神");
 list.add("上神");
 ConcretePrototype pt = new ConcretePrototype(1, "九宬", list);

 // section 1: 引用复制
 ConcretePrototype pt1 = pt;
 System.out.println(pt);
 System.out.println(pt1);

 // section 2: 浅拷贝
 ConcretePrototype pt2 = pt.clone();
 pt2.addNickname("小九");
 System.out.println("copy: " + pt1);
 System.out.println("copy: " + pt2);

 // section 3: 深拷贝
 ConcretePrototype pt3 = pt.deepClone();
 pt3.addNickname("小宸");
 System.out.println("deep clone:" + pt1);
 System.out.println("deep clone:" + pt3);
    }
}

interface Prototype extends Cloneable{
    Prototype clone();
    Prototype deepClone();
}


@Data
@Accessors(chain = true)
@AllArgsConstructor
class ConcretePrototype implements Prototype, Serializable {
    private Integer id;     // 编号
    private String name;    // 名称
    private List nickname = new ArrayList<>();

    public ConcretePrototype addNickname(String nickname) {
 this.nickname.add(nickname);
 return this;
    }

    public ConcretePrototype clone() {
 ConcretePrototype pt = null;
 try {
     pt = (ConcretePrototype) super.clone();
 } catch (CloneNotSupportedException e) {
     e.printStackTrace();
 }
 return pt;
    }

    public ConcretePrototype deepClone() {
 ConcretePrototype pt = null;

 try {
     ByteArrayOutputStream bos = new ByteArrayOutputStream();
     ObjectOutputStream oos = new ObjectOutputStream(bos);
     oos.writeObject(this);

     ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
     ObjectInputStream ois = new ObjectInputStream(bis);
     pt = (ConcretePrototype) ois.readObject();
 } catch (IOException e) {
     e.printStackTrace();
 } catch (ClassNotFoundException e) {
     e.printStackTrace();
 }
 return pt;
    }
}

ConcretePrototype(id=1, name=九宬, nickname=[战神, 上神])
ConcretePrototype(id=1, name=九宬, nickname=[战神, 上神])

copy: ConcretePrototype(id=1, name=九宬, nickname=[战神, 上神, 小九])
copy: ConcretePrototype(id=1, name=九宬, nickname=[战神, 上神, 小九])

deep clone:ConcretePrototype(id=1, name=九宬, nickname=[战神, 上神, 小九])
deep clone:ConcretePrototype(id=1, name=九宬, nickname=[战神, 上神, 小九, 小宸])

"""
原型模式
"""
import copy


class Product:
    """产品类型"""
    pass

    
class ProductManager:
    """产品管理器：需要的话添加"""
    pass
    
    
if __name__ == "__main__":
    """测试代码"""
    # 创建对象
    product = Product()
    
    # 引用赋值
    prod1 = product
    
    # 浅拷贝
    prod2 = copy.copy(product)
    
    # 深拷贝
    prod3 = copy.deepcopy(product)

package main

import (
	"fmt"
)

type PersonalInfo struct {
	name string
	sex  string
	age  string
}

type Address struct {
	province string
	company  string
	city	 string
}

type Resume struct {
	PersonalInfo
	Address
}

func (this *Resume) SetPersonalInfo(name string, sex string, age string) {
	this.name = name
	this.sex = sex
	this.age = age
}

func (this *Resume) SetWorkExperience(province string, company string, city string) {
	this.province = province
	this.company = company
	this.city = city
}

func (this *Resume) Display() {
	fmt.Println(this.name, this.sex, this.age)
	fmt.Println(this.province, this.company, this.city)
}

func (this *Resume) Clone() *Resume {
	resume := *this
	return &resume
}

func main() {
	person_damu := &Resume{}
	person_damu.SetPersonalInfo("大牧", "男", "29")
	person_damu.SetWorkExperience("河南", "郑州", "金水区")

	person_copy := person_damu.Clone()
	person_copy.SetWorkExperience("甘肃", "天水", "秦安")

	person_damu.Display()
	person_copy.Display()
}