java设计模式 GOF23 03 建造类模式

package com.lz.builder;

/*
 * 组装者实现类,提供一个可以获取产品的公共方法
 */
public class LzCarDirector implements CarDirector{
    private CarBuilder cb;
    private Car car;

    public LzCarDirector(CarBuilder cb) {
        this.cb = cb;
    }

    @Override
    public Car CarDirector() {
        Car car = new Car(cb.BuilderDoor(), cb.BuilderEngine(), cb.BuilderTyre());
        return car;
    }
}
package com.lz.builder;

/*
 * 建造者接口
 */
public interface CarBuilder {
    Door BuilderDoor();
    Engine BuilderEngine();
    Tyre BuilderTyre();
}
package com.lz.builder;
/*
 * 组装者接口
 */
public interface CarDirector {
    Car CarDirector();
}
package com.lz.builder;

/*
 * 建造者实现类
 */
public class LzCarBuilder implements CarBuilder{

    @Override
    public Door BuilderDoor() {
        return new Door("车门");
    }

    @Override
    public Engine BuilderEngine() {
        return new Engine("发动机");
    }

    @Override
    public Tyre BuilderTyre() {
        return new Tyre("轮胎");
    }

}
package com.lz.builder;

/*
 * 产品类:有多个组件
 * 将这些类的实现封装,用户只需要调用制造着和组装者就可以得到
 * 实现类。
 */
public class Car {
    private Door door;
    private Engine engine;
    private Tyre tyre;
    public Car() {
    }
    public Car(Door door, Engine engine, Tyre tyre) {
        super();
        this.door = door;
        this.engine = engine;
        this.tyre = tyre;
    }
    public Door getDoor() {
        return door;
    }
    public void setDoor(Door door) {
        this.door = door;
    }
    public Engine getEngine() {
        return engine;
    }
    public void setEngine(Engine engine) {
        this.engine = engine;
    }
    public Tyre getTyre() {
        return tyre;
    }
    public void setTyre(Tyre tyre) {
        this.tyre = tyre;
    }
}

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

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

class Tyre {
    private String name;
    public Tyre() {
    }
    public Tyre(String name) {
        super();
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
package com.lz.builder;

/*
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        Car car = new LzCarDirector(new LzCarBuilder()).CarDirector();
        System.out.println(car.getDoor().getName());
        System.out.println(car.getEngine().getName());
        System.out.println(car.getTyre().getName());
    }
}
时间: 2024-09-29 17:03:57

java设计模式 GOF23 03 建造类模式的相关文章

java设计模式 GOF23 11 享元模式

一.享元模式简介 如果有很多相同或者相似的对象可以使用享元模式,从而节约内存. 二.关键点 享元对象需要区分内部状态和外部状态. 内部状态:可以共享,不会随着外部状态改变. 外部状态:不可以共享,随外部状态改变. 享元共享类实现享元池管理享元对象. 三.简单实现 package com.lz.flyWeight; /* * 享元模式 * 内部状态 * 模拟棋盘,因为一盘棋其中棋子的颜色都一样 * 只有位置不一样,所以可以将颜色共享,这样可以节省内存空间 * 棋盘接口 */ interface C

Java设计模式(十) 备忘录模式 状态模式

(十九)备忘录模式 备忘录模式目的是保存一个对象的某个状态,在适当的时候恢复这个对象. class Memento{ private String value; public Memento(String value){ this.value = value; } public String getValue() { return value; } public void setValue(String value) { this.value = value; } } class Storage

设计模式学习03—抽象工厂模式

1.动机与定义 工厂模式中,一个工厂仅仅能提供一个或一类产品,当产品种类较多,形成产品系列(比方我们要创建跨平台的button,菜单,文本框等等一系列GUI控件: 单纯使用工厂模式会产生大量工厂,并且后期维护也不方便,我们能够从产品中找到规律,假设产品等级相对固定,以后仅仅会新增产品族,那么我们就能够把整个产品族放到一个工厂创建,以后新增其它系统产品族也很方便,例如以下图: 这样的模式就是抽象工厂,工厂方法模式针对的是一个产品等级结构,而抽象工厂模式则须要面对多个产品等级结构,一个工厂等级结构能

Java设计模式(五)外观模式 桥梁模式

(九)外观模式 外观模式为子系统提供一个接口,便于使用.解决了类与类之间关系的,外观模式将类之间的关系放在一个 Facade 类中,降低了类类之间的耦合度,该模式不涉及接口. class CPU { public void startup(){ System.out.println("cpu start"); } public void shutdown(){ System.out.println("cpu stop"); } } class Memory { pu

Java设计模式(六)合成模式 享元模式

(十一)合成模式 Composite 合成模式是一组对象的组合,这些对象可以是容器对象,也可以是单对象.组对象允许包含单对象,也可以包含其他组对象,要为组合对象和单对象定义共同的行为.合成模式的意义是 保证客户端调用单对象与组合对象的一致性. class TreeNode{ private String name; private TreeNode parent; private Vector<TreeNode> children = new Vector<TreeNode>();

java设计模式--观察者模式和事件监听器模式

文章转载于:http://www.java2000.net/p9452 复习设计模式,看到observer观察者模式,说法是该模式和iterator迭代器模式类似已经被整合进jdk,但是jdk提供了两种接口: 一.java.util.Observer -- 观察者接口 对应: java.util.Observable --受查者根类 二.java.util.EventListener -- 事件监听/处理接口 对应: java.util.EventObject -- 事件(状态)对象根类 研究了

Java设计模式(三)原型模式

(五)原型模式 Prototype 原型模式目的是复制一个现有对象来生成新的对象,而不是通过实例化的方式.原型模式需要实现 Cloneable 接口,覆写clone方法,复制分为浅复制.深复制. 浅复制:将一个对象复制后,基本数据类型的变量都重新创建,引用类型,指向的还是原对象所指向的. 深复制:讲一个对象复制后,不论基本数据类型和引用类型,都是重新创建,是完全的彻底的复制. public class ProtoType { public static void main(String[] ar

Java设计模式(十一)访问者模式 中介者模式

(二十一)访问者模式 对已存在的类进行扩展,通常需要增加方法,但是如果需要的行为与现有的对象模型不一致,或者无法修改现有代码.在这种情况下,不更改类的层次结构,就无法扩展该层次结构的行为.如果运用了访问者模式,就可以支持开发人员扩展该类层次结构的行为. 和解释器模式一样,访问者模式通常是基于合成模式的. 访问者模式在不改变类层次结构的前提下,对该层次结构进行扩展. interface Visitor{ public void visit(VisiSubject sub); } interface

Java设计模式(七)策略模式 模板模式

(十三)策略模式 策略模式定义了多个封装起来的算法,封装的算法可以相互替换,并且算法的变化不会影响到使用算法的客户.借用另一位大神的例子. interface ICalculator{ public int calculate(String exp); } abstract class AbstractCalculator{ public int[] split(String exp,String opt){ String array[] = exp.split(opt); int arrayI