原型设计模式

引用：

原型设计：

关键词：用原型实例，指定创建对象的种类，并且通过拷贝这些原型对象创建新的对象

  java可以通过实现Cloneable接口，并且重写clone方法来简单的实现原型设计模式

clone又分为，浅克隆和深度克隆

浅克隆：在克隆基本数据类型的时候是没有问题的，但是存在引用类型的变量的时候只是简单的复制引用而不是指向不同的引用对象。

public class Person implements Cloneable{


    public String name;
    public int age;
    public worker worker;

    public com.lql.prototype.worker getWorker() {
        return worker;
    }

    public void setWorker(com.lql.prototype.worker worker) {
        this.worker = worker;
    }


    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;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
            Person  p = null;
            p = (Person) super.clone();

            p.worker = (com.lql.prototype.worker) worker.clone();
        return p;
    }
}

package com.lql.prototype;

public class worker implements Cloneable{

    public String workName;

    public String getWorkName() {
        return workName;
    }

    public void setWorkName(String workName) {
        this.workName = workName;
    }

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

package com.lql.prototype;


import javafx.concurrent.Worker;

/**
 *
 * 原型设计：
 * 关键词：用原型实例，指定创建对象的种类，并且通过拷贝这些原型对象创建新的对象
 */
public class prototype {

    public static void main(String[] args) throws CloneNotSupportedException {

        Person p = new Person();
        p.worker = new worker();
        p.name = "张三";
        p.worker.workName = "java";
        Person p1 = (Person) p.clone();
        p1.name = "李四";
        p1.worker.workName = ".net";

        System.out.println(p.name);
        System.out.println(p1.name);

        System.out.println(p.worker.workName);
        System.out.println(p1.worker.workName);

    }

}