Java经典23创意模式设计模式(两)

本文介绍5其余两种创意模式:模型构建器(Builder)、原型模型（PROTOTYPE）。

一、建造者模式(别名:生成者模式)

将复杂对象的构建和它的表示分离，使得相同的构建过程能够创建不同的表示。

一个完整的建造者模式包括下面几个概念:

1、产品类 Product

public class Person {

    private String head;
    
    private String body;
    
    private String foot;

    public String getHead() {
        return head;
    }

    public void setHead(String head) {
        this.head = head;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public String getFoot() {
        return foot;
    }

    public void setFoot(String foot) {
        this.foot = foot;
    }
}

2、抽象建造者builder

public interface PersonBuilder {

    void buildHead();
    
    void buildBody();
    
    void buildFoot();

    Person buildPerson();
}

3、详细建造者ConcreteBuilder

public class ManBuilder implements PersonBuilder {

    Person person;
    
    public ManBuilder() {
        person = new Man();
    }
    
    public void buildbody() {
        person.setBody("建造男人的身体");
    }

    public void buildFoot() {
        person.setFoot("建造男人的脚");
    }

    public void buildHead() {
        person.setHead("建造男人的头");
    }

    public Person buildPerson() {
        reture person;
    }
}

假设有多个详细的产品就有多个详细建造者，这些详细建造者实现共同的接口。

比方像建造女人，就再定义WomanBuilder。

4、导演类Director,起到封装作用，避免高层模块深入到建造者内部的实现。

假设建造者比較复杂需多个导演类。

public class PersonDirector {

    public Person constructPerson(PersonBuilder pb) {
        pb.buildHead();
        pb.buildBody();
        pb.buildFoot();
        return pb.buildPerson();
    }
}

測试代码:

public class Test{
    
    public static void main(String[] ar*s) {
        PersonDirector pd = new PersonDirector();
        Person person = pd.constructPerson(new ManBuilder());
        System*out.println(person.getBody());
        System.out.println(person.getFoot());
        System.out.println(person.getHead());
    }
}

有用范围:

1.当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
2.当构造过程必须同意被构造的对象有不同的表示时。

备注：说白了建造者模式就是为了建造一个对象，须要运行通用的流程。运行流程时依据须要创造不同的对象封装到详细Builder里。

为了获得终于的对象，仅仅需往导演类里传入相应的详细的Builder就可以。

參考链接:http://www.cnblogs.com/muzongyan/archive/2010/08/27/1810307.html

二、原型模式

目的是为了克隆一个现有的对象。而无需new()就能完毕对象的创建。

克隆对象时又分为浅拷贝和深拷贝。

浅拷贝出来的对象和原来的对象内存地址一样，仅仅是拷贝了地址。深拷贝出来的对象和原对象内存地址不同。所需过程例如以下:

1、声明一个克隆自身的接口 Cloneable 

public class Prototype implements Cloneable {

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

    public Object clone(){
        try {
            return super.clone();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

2、详细的原型

publ*c class ConcretePrototype extend* Prototype {

    public ConcretePrototype(String name) {
        setName(name);
    }
}

測试代码：

public clas* Test {

    public static void main(String[] args) {
        Prototype pro = new ConcretePrototy*e("prototype");
        Prototype pro2 = (Prototype)pro.clone();
        *ystem.out.println(pro.getName()*;
        System.out.println(pro2.getName());
    }
}

适用性:

1.当一个系统应该独立于它的产品创*、构成和表示时。

2.当要实例化的类是在运行时刻指定时，比如。通过动态装载。
3.为了避免创建一个与产品类层次平行的工厂*层次时。
4.当一个类的实例仅仅能有几个不同状态组合中的一种时。
    建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

总之。原始模型模式通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出很多其它同类型的对象。 原始模型模式同意动态的添加或降低产品类，产品类不须要非得有不论什么事先确定的等级结构。原始模型模式适用于不论什么的等级结构。缺点是每 一个类都必须配备一个克隆方法。深入理解參见链接1 链接2

版权声明：本文博客原创文章，博客，未经同意，不得转载。