设计模式之原型模式

一.定义

原型模式：原型模式用于创建重复的对象，实现对象的拷贝。这种模式类似于创建型模式，提供了创建对象的最佳模式。

这种模式存在的应用场景在于，能够复制当前对象，实现对象数据的克隆。比如：如果一个对象的数据需要经过较高代价的数据库操作，采用原型模式能够较好的缓存当前对象，减少数据库的访问量。

二.使用场景

思想：用实例对象，指导对象的创建工作.

应用：1.一个复杂的对象，包含多种数据和结构，层次较深时，适用与原型模式（当需要创建一个与复杂对象部分数据相同的对象）

          2.当复杂对象需要独立于系统运行，而不破坏本系统中的结构

实例场景：1.一个楼盘有名称，地址和施工队三个成员变量。施工队有名称，人数和包工头。包工头有名称和年龄。现在要建设一个隔壁的楼盘，还是由这个施工队进行建设的，只是地址不同。

如果重新创建，过程较为复杂，费时费力，采取原型模式可以快速构建一个新的楼盘

                 2.系统中已经有一架飞机，飞机有名称和型号和厂商。厂商有名称，地址和负责人。负责人有姓名和年龄。现在要一家相同的飞机由不同的负责人进行指导生产的，如何快速创建这样的对象。

三.优缺点

优点：1.快速创建复杂对象实例 2.逃避构造函数约束

缺点：1.引用含有循环引用如何处理 2.必须实现Cloneable接口

下面是一张UML图用来说明原型模式的关系

 

下面是一个具体的应用场景：

如何实现不投的型号的手机由相同的工厂生产的问题，快速创建这样的一个对象

 

 

 结构：手机由名称,价格，生产工厂组成。生产工厂由工程师和名称组成。工程师由姓名这个基本属性。

现在为了快速复制同一工厂的不同手机，解决这一实际应用场景。

Phone类

public class Phone {
    public String name; //手机名称

    public float price; //价钱

    public Factory factory; //工厂

    @Override
    public String toString() {
        return "手机名称:"+this.name+"  价钱:"+this.price+this.factory.toString();
    }

    public Phone Clone(){
        Phone phone =null;
        try{
            phone=new Phone();
            if(this.name!=null){
                phone.name=this.name;
            }

            if(this.price!=0){
                phone.price=this.price;
            }

            if(this.factory!=null){
                phone.factory=this.factory.Clone();
            }
        }catch (Exception e){
            new  RuntimeException(e);
        }

        return phone;
    }
}

Factory类

public class Factory implements  Cloneable{

    public String name;  //工厂名称

    public Person Manager; //负责人

    @Override
    public String toString() {
        return "  工厂名称:"+this.name+"  负责人:"+Manager.toString();
    }

    public Factory Clone(){
        Factory factory =null;

        try{
            factory=new Factory();

            if(this.name!=null){
                factory.name=this.name;
            }

            if(this.Manager!=null){
                factory.Manager=this.Manager.Clone();
            }

        }catch (Exception e){
            new RuntimeException(e);
        }

        return factory;
    }
}

Person类

public class Person implements  Cloneable{

    public String name; //名称

    @Override
    public String toString() {
        return this.name;
    }

    public Person Clone(){
        Person person =null;

        try{
            person =new Person();

            person.name=this.name;
        }catch (Exception e){
            new RuntimeException(e);
        }

        return person;
    }
}

然后生产一部荣耀一部分华为

public class Main {

    public static void main(String[] args) {

        Phone phone =new Phone();

        phone.name="Honor";

        phone.price=new Float(1.5);

        phone.factory=new Factory();

        phone.factory.name="三星工厂";

        Person person =new Person();
        person.name="郭台铭";
        phone.factory.Manager=person;

        Phone phone1 =phone.Clone();

        phone1.name="华为";
        System.out.println(phone.toString());
        System.out.println(phone1.toString());
    }
}

运行结果：

 

 显然实现了对象的深复制，解决了对象克隆问题。