软件构造感悟之面向可复用性和可维护性的设计模式

面向可复用性和可维护性的设计模式 {ignore=true}

1. 创造型模式

工厂方法模式也被称为虚拟构造器模式，它是一种对象创建型模式。工厂方法模式的目的是定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法模式使一个类的实例化延迟到其子类。

举例

public class FactoryMethodPattern {
    public static void main(String[] args) {
        LoggerFactory factory;
        Logger logger;
        factory = new FileLoggerFactory(); // 可引入配置文件实现
        logger = factory.createLogger();
        logger.writeLog();
    }
}

interface Logger {
    void writeLog();
}

class FileLogger implements Logger {
    @Override
    public void writeLog() {
        System.out.println("File logger write log.");
    }
}

interface LoggerFactory {
    Logger createLogger();
}

class FileLoggerFactory implements LoggerFactory {
    @Override
    public Logger createLogger() {
        return new FileLogger();
    }
}

2. 结构式模型

2.1 适配器模式

适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

例如，我们有一个日志记录器，它可以将日志记录到文件中，但是我们需要将日志记录到数据库中，我们可以使用适配器模式，将数据库适配成日志记录器。对应的代码为

public class AdapterPattern {
    public static void main(String[] args) {
        LogAdapter adapter = new LogAdapter();
        adapter.writeLog("Hello world!");
    }
}

interface Log {
    void writeLog(String log);
}

class FileLog implements Log {
    @Override
    public void writeLog(String log) {
        System.out.println("File log: " + log);
    }
}

class LogAdapter implements Log {
    private FileLog fileLog = new FileLog();

    @Override
    public void writeLog(String log) {
        fileLog.writeLog(log);
    }
}

2.2 装饰器模型

装饰器模式可以在不改变一个对象本身功能的基础上给对象增加额外的新行为。

就像穿衣服。

举例

public class DecoratorPattern {
    public static void main(String[] args) {
        Component component = new ConcreteComponent();
        component.operation();
        System.out.println("----------");
        Decorator decorator = new ConcreteDecorator(component);
        decorator.operation();
    }
}

interface Component {
    void operation();
}

class ConcreteComponent implements Component {
    @Override
    public void operation() {
        System.out.println("Concrete component operation.");
    }
}

class Decorator implements Component {
    private Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void operation() {
        component.operation();
    }
}

class ConcreteDecorator extends Decorator {
    public ConcreteDecorator(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        super.operation();
        System.out.println("Concrete decorator operation.");
    }
}

3. 行为类模型

3.1 策略模式

策略模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响到使用算法的客户。

3.2 模板模式

模板模式定义了一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

模板模式利用继承与重写实现。

3.3 迭代器模式

迭代器模式提供了一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。

3.4 Visitor模式

访问者模式是一种将算法与对象结构分离的软件设计模式。这种分离的实际结果是能够在不修改现有对象结构的情况下向该结构中添加新的操作。