原型设计模式

1、概念

原型模式是一种创建型设计模式,允许一个对象创建另外一个可定制的对象,无需知道创建的细节。

2、浅拷贝和深拷贝

  • 浅拷贝:对于基本数据类型的成员变量,浅拷贝会直接进行值拷贝,也就是将该属性复制一份给新的对象;引用数据类型的成员变量(数组或者对象),那么浅拷贝会进行引用传递,也就是将该成员变量的引用值复制一份给新的对象。
  • 深拷贝:对于基本数据类型的成员变量,将该属性复制一份给新的对象;为每个引用数据类型的成员变量申请空间,并复制每个成员变量所引用的对象,直到该对象可到的所有对象。

3、实现

3.1、浅拷贝

借助Object类的clone方法,可以简单实现对象的复制。(但是clone方法是实现的浅拷贝,如果要实现深拷贝,还需要写代码实现)

  • 实现Cloneable接口。
  • 重写clone方法,并修改方法访问级别为public。
package com.mine.design.prototype;

public class Person implements Cloneable {
   
	private String name;
	private int age;
	private String sex;
	private String country;
	private Phone phone;

	public String getName() {
   
		return name;
	}

	public void setName(String name) {
   
		this.name = name;
	}

	public int getAge() {
   
		return age;
	}

	public void setAge(int age) {
   
		this.age = age;
	}

	public String getSex() {
   
		return sex;
	}

	public void setSex(String sex) {
   
		this.sex = sex;
	}

	public String getCountry() {
   
		return country;
	}

	public void setCountry(String country) {
   
		this.country = country;
	}

	public Phone getPhone() {
   
		return phone;
	}

	public void setPhone(Phone phone) {
   
		this.phone = phone;
	}

	@Override
	public String toString() {
   
		return "Person [name=" + name + ", age=" + age + ", sex=" + sex + ", country=" + country + ", phone=" + phone
				+ "]";
	}

	@Override
	public Object clone() throws CloneNotSupportedException {
   
		return super.clone();
	}
}
package com.mine.design.prototype;

public class Phone {
   
	private String brand;
	private String type;

	public String getBrand() {
   
		return brand;
	}

	public void setBrand(String brand) {
   
		this.brand = brand;
	}

	public String getType() {
   
		return type;
	}

	public void setType(String type) {
   
		this.type = type;
	}
}
package com.mine.design.prototype;

public class Client {
   

	public static void main(String[] args) throws Exception {
   
		Person p = new Person();
		p.setName("西施");
		p.s
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
非常感谢您的提问!以下是一个使用原型设计模式实现深拷贝的示例代码: ``` class Prototype { public: virtual Prototype* clone() = 0; }; class ConcretePrototype : public Prototype { public: ConcretePrototype(int value) : m_value(value) {} Prototype* clone() override { return new ConcretePrototype(m_value); } int getValue() const { return m_value; } private: int m_value; }; int main() { ConcretePrototype* original = new ConcretePrototype(42); ConcretePrototype* clone = dynamic_cast<ConcretePrototype*>(original->clone()); std::cout << "Original value: " << original->getValue() << std::endl; std::cout << "Clone value: " << clone->getValue() << std::endl; delete original; delete clone; return 0; } ``` 在这个示例中,我们定义了一个 `Prototype` 接口,其中包含了一个 `clone()` 方法,用于创建一个与原型对象相同的对象。然后,我们实现了一个具体的原型类 `ConcretePrototype`,其中包含了一个整型成员变量 `m_value`,并重写了 `clone()` 方法,返回一个的 `ConcretePrototype` 对象。最后,我们在 `main()` 函数中创建了一个原型对象 `original`,并通过调用 `clone()` 方法创建了一个的克隆对象 `clone`。 需要注意的是,这里的深拷贝只是一个简单的示例,实际上在实现深拷贝时需要考虑对象的所有成员变量,并递归地进行拷贝。此外,还需要注意内存管理,确保在不需要使用对象时及时释放内存。 希望这个示例能够帮助您理解原型设计模式和深拷贝的实现方式。如果您有任何问题或需要进一步的帮助,请随时提出。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值