设计模式——建造者模式和装饰器模式_建造者模式 装饰器模式

1、建造者模式：

定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示；

说明：一步一步构造一个由多个部分组成的复杂对象；

复杂对象示意图：
（就像车是由轮胎、方向盘、发动机等等部分组成的）

建造者模式结构图：

①Builder（抽象建造者）：创建一个产品Product对象的各个部件指定抽象接口，在该接口中一般声明两类方法，一类方法是buildPartX()，它们用于创建复杂对象的各个部件；另一类方法是getResult()，它们用于返回复杂对象；它既可以是抽象类也可以是接口；
②ConcreteBuilder（具体建造者）：实现了抽象建造者接口，实现各个部件的构造和装配方法，定义并明确它所创建的复杂对象，也可以提供一个方法返回创建好的复杂产品对象；
③Product（产品角色）：产品角色是被构建的复杂对象，包含多个组成部件，具体建造者创建该产品的内部表示并定义他的装配过程；
④Director（指挥者）：负责安排复杂对象的创建次序，指挥者与抽象建造者之间存在关联关系，可以在其Construct（）建造方法中调用建造者对象的部件构造与装配方法，完成复杂对象的建造；客户端一般只需要与指挥者交互；

实例：
建造者模式可以用于描述KFC然后创建套餐：套餐是一个复杂对象，它一般包含主食（如汉堡、鸡肉卷等）和饮料（如果汁、可乐等）等组成部分，不同的套餐有不同的组成部分，而KFC的服务员可以根据顾客的要求，一步一步装配这些组成部分，构造一份完整的套餐，然后返回给顾客；

/**
 * @ClassName Meal
 * @Description 产品类（套餐类）
 * @Author lzq
 * @Date 2019/6/5 15:03
 * @Version 1.0
 **/
public class Meal {
    private String food;
    private String drink;

    public void setFood(String food) {
        this.food = food;
    }

    public void setDrink(String drink) {
        this.drink = drink;
    }

    public String getFood() {
        return food;
    }

    public String getDrink() {
        return drink;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

/**
 * @ClassName MealBuilder
 * @Description  抽象建造者类（套餐建造者类）
 * @Author lzq
 * @Date 2019/6/5 15:05
 * @Version 1.0
 **/
public abstract class MealBuilder {
    protected Meal meal = new Meal();

    public abstract void buildFood();
    public abstract void buildDrink();

    public Meal getMeal() {
        return this.meal;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

/**
 * @ClassName SubMealBuilderA
 * @Description 具体建造者（A套餐建造者类）
 * @Author lzq
 * @Date 2019/6/5 15:07
 * @Version 1.0
 **/
public class SubMealBuilderA extends MealBuilder{
    @Override
    public void buildFood() {
        meal.setFood("一个鸡腿堡...");
    }

    @Override
    public void buildDrink() {
        meal.setDrink("一杯可乐...");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/**
 * @ClassName SubMealBuilderB
 * @Description 具体建造者（B套餐建造者类）
 * @Author lzq
 * @Date 2019/6/5 15:08
 * @Version 1.0
 **/
public class SubMealBuilderB extends MealBuilder{
    @Override
    public void buildFood() {
        meal.setFood("一个鸡肉卷...");
    }

    @Override
    public void buildDrink() {
        meal.setDrink("一杯果汁...");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/**
 * @ClassName KFCWaiter
 * @Description 服务员类(指挥者)
 * @Author lzq
 * @Date 2019/6/5 15:10
 * @Version 1.0
 **/
public class KFCWaiter {
    private MealBuilder mb;

    public void setMealBuilder(MealBuilder mb) {
        this.mb = mb;
    }

    public Meal construct() {
        mb.buildFood();
        mb.buildDrink();
        return mb.getMeal();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

/**
 * @ClassName TestDemo
 * @Description 测试类
 * @Author lzq
 * @Date 2019/6/5 15:12
 * @Version 1.0
 **/
public class TestDemo {
    public static void main(String[] args) {
        MealBuilder mb = new SubMealBuilderA();
        KFCWaiter kfcWaiter = new KFCWaiter();
        kfcWaiter.setMealBuilder(mb);
        Meal meal = kfcWaiter.construct();

        System.out.println("套餐组成：");
        System.out.println(meal.getFood());
        System.out.println(meal.getDrink());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

运行结果：

2、装饰器模式：

定义：动态地给一个对象添加一些额外的职责，就扩展功能而言，它比生成子类方式更为灵活；

简单说明：不使用继承而通过关联关系来调用现有类中的方法，达到复用的目的，并使得对象的行为可以灵活变化；

模式结构图：

• Component（抽象构件）：定义了对象的接口，可以给这些对象动态的增加职责（方法）；
• ConcreteComponent（具体构件）：定义了具体的构建对象，实现了在抽象构建中声明的方法，装饰器可以给它增加额外的职责；
• Decorator（抽象装饰类）：抽象装饰类是抽象构件类的子类，用于 给具体构件增加职责，但是具体职责在其子类中实现；
• ConcreteDecorator（具体装饰类）：具体装饰类是抽象装饰类的子类，复杂向构件添加新的职责；

比如：
变形金刚在变形之前是一辆汽车，它可以在陆地上移动。当它变成机器人之后除了能在陆地上移动之外，还可以说话；如果需要，他还可以变成飞机，还能飞翔；

代码如下：

/**
 * @ClassName Transfrom
 * @Description 抽象构件类（变形金刚）
 * @Author lzq
 * @Date 2019/5/29 23:42
 * @Version 1.0
 **/
public interface Transfrom {
    public void move();
}
1
2
3
4
5
6
7
8
9
10

/**
 * @ClassName Car
 * @Description 具体构件类（汽车类）
 * @Author lzq
 * @Date 2019/5/29 23:43
 * @Version 1.0
 **/
public final class Car implements Transfrom{
    public Car() {
        System.out.println("变形金刚是一辆车");
    }

    @Override
    public void move() {
        System.out.println("在陆地上移动");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

/**
 * @ClassName Changer
 * @Description 抽象装饰类（变化类）
 * @Author lzq
 * @Date 2019/5/29 23:45
 * @Version 1.0
 **/
public class Changer implements Transfrom{
    private Transfrom transfrom;

    public Changer(Transfrom transfrom) {
        this.transfrom = transfrom;
    }

    @Override
    public void move() {
        transfrom.move();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/**
 * @ClassName Robot
 * @Description 具体装饰类（机器人类）
 * @Author lzq
 * @Date 2019/5/29 23:46
 * @Version 1.0
 **/
public class Robot extends Changer{
    public Robot(Transfrom transfrom) {
        super(transfrom);
        System.out.println("变成机器人");
    }

   public void say() {
       System.out.println("说话");
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

/**
 * @ClassName Airplane
 * @Description 具体装饰类（飞机类）
 * @Author lzq
 * @Date 2019/5/29 23:49
 * @Version 1.0
 **/
public class Airplane extends Changer{
    public Airplane(Transfrom transfrom) {
        super(transfrom);
        System.out.println("变成飞机");
    }

    public void fly() {
        System.out.println("在天空飞翔");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

/**
 * @ClassName Client
 * @Description 测试类
 * @Author lzq
 * @Date 2019/5/29 23:50
 * @Version 1.0
 **/
public class Client {
    public static void main(String[] args) {
        Transfrom camaro;
        camaro = new Car();
        camaro.move();
        System.out.println("---------------");
        Robot robot = new Robot(camaro);
        robot.move();
        robot.say();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

运行结果：