软件构造笔记（十五）--PPT第十一讲

面向可复用性和可维护性的设计模式

• Creational patterns 创建型模式
• Structural patterns 结构型模式
• • Adapter 适配器模式
  • Decorator 装饰器模式
• Behavioral patterns 行为类模式
• • Strategy 策略模式
  • Template Method 模板模式
  • Iterator
  • Visitor
• 设计模式的对比
• • 共性模式1
  • 共性模式2

Creational patterns 创建型模式

工厂方法模式

   当client不知道要创建哪个具体类的实例，或者不想在client代码中指明要具体创建的实例时，用工厂方法。

   定义一个用于创建对象的接口，让其子类来决定实例化哪一个类，从而使一个类的实例化延迟到其子类。

比如静态工厂方法：

Structural patterns 结构型模式

Adapter 适配器模式

1.内容：将某个类/接口转换为client期望的其他形式，通过增加一个接口，将已存在的子类封装起来，client面向接口编程，从而隐藏了具体子类。

2.举例：

设置一个接口Shape，通过具体子类Rectangle实现display方法，但由于这个方法不是我们所期望的，我们需要通过一个适配器来实现内部的方法，并在Rectangle内部进行调用，这样可以通过接口封装内部实现

Decorator 装饰器模式

本节内容引用：https://www.cnblogs.com/yxlaisj/p/10446504.html

1.用每个子类实现不同的特性，为对象增加不同侧面的特性，对每一个特性构造子类，通过委派机制增加到对象上。使用subtyping and delegation

2.举例：

咖啡接口，获取价格和配料

/**
 * 咖啡
 */
interface Coffee {
    /** 获取价格 */
    double getCost();
    /** 获取配料 */
    String getIngredients();
}
           

原味咖啡类，实现咖啡接口，配料中只有咖啡

/**
 * 原味咖啡
 */
class SimpleCoffee implements Coffee {

    @Override
    public double getCost() {
        return 1;
    }

    @Override
    public String getIngredients() {
        return "Coffee";
    }
}
           

咖啡对象的装饰器类，同样实现Coffee接口，定义一个Coffe对象的引用，在构造器中进行初始化。并且将getCost（）和getIntegredients()方法转发给被装饰对象。

/**
 * 咖啡的"装饰器"，可以给咖啡添加各种"配料"
 */
abstract class CoffeeDecorator implements Coffee {
    protected final Coffee decoratedCoffee;

    /**
     * 在构造方法中，初始化咖啡对象的引用
     */
    public CoffeeDecorator(Coffee coffee) {
        decoratedCoffee = coffee;
    }

    /**
     * 装饰器父类中直接转发"请求"至引用对象
     */
    public double getCost() {
        return decoratedCoffee.getCost();
    }

    public String getIngredients() {
        return decoratedCoffee.getIngredients();
    }
}
           

具体的装饰器类，负责往咖啡中“添加”牛奶，注意看getCost（）方法和getIngredients()方法，可以在转发请求之前或者之后，增加功能。

/**
 * 此装饰类混合"牛奶"到原味咖啡中
 */
class WithMilk extends CoffeeDecorator {

    public WithMilk(Coffee coffee) {
        super(coffee);
    }

    @Override
    public double getCost() {
        double additionalCost = 0.5;
        return super.getCost() + additionalCost;
    }

    @Override
    public String getIngredients() {
        String additionalIngredient = "milk";
        return super.getIngredients() + ", " + additionalIngredient;
    }
}
           

另一个具体装饰器类，用来给咖啡加糖，一样的逻辑。

class WithSugar extends CoffeeDecorator {

    public WithSugar(Coffee coffee) {
        super(coffee);
    }

    @Override
    public double getCost() {
        return super.getCost() + 1;
    }

    @Override
    public String getIngredients() {
        return super.getIngredients() + ", Sugar";
    }
}
           

客户端使用装饰器模式

public class DecoratorDemo {

    static void print(Coffee c) {
        System.out.println("花费了: " + c.getCost());
        System.out.println("配料: " + c.getIngredients());
        System.out.println("============");
    }

    public static void main(String[] args) {
        //原味咖啡
        Coffee c = new SimpleCoffee();
        print(c);

        //增加牛奶的咖啡
        c = new WithMilk(c);
        print(c);

        //再加一点糖
        c = new WithSugar(c);
        print(c);
    }
}
           

Behavioral patterns 行为类模式

Strategy 策略模式

1.内容：有多种不同的算法来实现同一个任务，但需要client根据需要动态切换算法，而不是写死在代码里，为不同的实现算法构造抽象接口，利用delegation，运行时动态传入client倾向的算法类实例。

2.实现方式：

3.举例：

下图两个pay()方法的实现就是模板模式

Template Method 模板模式

1.问题：一些客户端共享相同的算法，但在细节上有所不同，例如，一个算法由可定制的部分和不变的部分组成。公共步骤不应在子类中重复，但需要重用。

解决方法：共性的步骤在抽象类内公共实现，差异化的步骤在各个子类中实现

使用继承和重写实现模板模式

2.举例：

具体代码：

抽象类的实现：

Iterator

客户端希望遍历被放入容器/集合类的一组ADT对象，无需关心容器的具体类型，也就是说，不管对象被放进哪里，都应该提供同样的遍历方式

Visitor

1.内容： 对特定类型的object 的特定操作(visit) ，在运行时将二者动态绑定到一起，该操作可以灵活更改，无需更改被visit 的类。本质上：将数据和作用于数据上的某种/ 些特定操作分离开来。为ADT 预留一个将来可扩展功能的“接入点”，外部实现的功能代码，可以在不改变ADT 本身的情况下通过delegation 接入ADT

2.举例：

Visitor vs Iterator

迭代器：以遍历的方式访问集合数据而无需暴露其内部表示，将“遍历”这项功能delegate到外部的iterator对象。

Visitor：在特定ADT上执行某种特定操作，但该操作不在ADT内部实现，而是delegate到独立的visitor对象，客户端可灵活扩展/改变visitor的操作算法，而不影响ADT

Visitor vs Strategy

二者都是通过delegation 建立两个对象的动态联系

但是Visitor强调是的外部定义某种对ADT的操作，该操作于ADT自身关系不大（只是访问ADT），故ADT内部只需要开放accept(visitor)即可，client通过它设定visitor操作并在外部调用。

而Strategy则强调是对ADT内部某些要实现的功能的相应算法的灵活替换。这些算法是ADT功能的重要组成部分，只不过是delegate到外部strategy类而已。

区别：visitor是站在外部client的角度，灵活增加对ADT的各种不同操作（哪怕ADT没实现该操作），strategy则是站在内部ADT的角度，灵活变化对其内部功能的不同配置。

设计模式的对比

共性模式1

对于Adapter

适用场合：你已经有了一个类，但其方法与目前client的需求不一致。

根据OCP原则，不能改这个类，所以扩展一个adaptor和一个统一接口。

对于模板模式：适用场合：有共性的算法流程，但算法各步骤有不同的实现，典型的“将共性提升至超类型，将个性保留在子类型”

共性模式2

对于Strategy：

对于Iterator

对于工厂方法：

对于Visitor：