[笔记] 常见设计模式

一、设计原则

1. 隔离变化
2. 针对接口编程，而不是针对实现编程
3. 多用组合，少用继承
4. 松耦合设计
5. 开闭原则
6. 依赖倒置原则
7. 最少知识原则
8. 好莱坞原则
9. 单一职责

二、模式分类

1. 创建型：Singleton、Builder、Prototype、Abstract Factory、Factory Method
2. 行为型：Template Method、Visitor、Mediator、Iterator、Command、Memento、Interpreter、Observer、Chain of Responsibility、State、Strategy
3. 结构型：Decorator、Proxy、Composite、Facade、Flyweight、Bridge、Adapter

三、策略模式（Strategy）

1. 策略模式定义了算法族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化独立于使用算法的客户
2. 类图

classDiagram
	%% 封装飞行行为
	class FlyDehavior {
		<<interface>>
		fly()
	}
	FlyDehavior <|.. FlyWithWings
	FlyWithWings: fly()
	FlyDehavior <|.. FlyNoWay
	FlyNoWay: fly()
	
	%% 客户
	class Duck {
		FlyDehavior flyDehavior
		QuackDehavior quackDehavior
		swim()
		display()
		performQuack()
		performFlay()
		setFlyBehavior()
		setQuackBehavior()
	}
	FlyDehavior <-- Duck: flyDehavior
	QuackDehavior <-- Duck: quackDehavior
	Duck <|-- MallardDuck
	MallardDuck: display()
	Duck <|-- RedHeadDuck
	RedHeadDuck: display()
	Duck <|-- RubberDuck
	RubberDuck: display()
	Duck <|-- DecoyDeck
	DecoyDeck: display()
	
	%% 封装呱呱叫行为
	class QuackDehavior {
		<<interface>>
		quack()
	}
	QuackDehavior <|.. Quack
	Quack: quack()
	QuackDehavior <|.. Squeak
	Squeak: quack()
	QuackDehavior <|.. MuteQuack
	MuteQuack: quack()

四、观察者模式（Observer）

1. 观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，他的所有依赖者都会收到通知并自动更新
2. 基本类图

classDiagram
	%% 主题接口，注册、删除、通知观察者
	class Subject {
		<<interface>>
		registerObserver()
		removeObserver()
		notifyObserver()
	}
	
	%% 观察者接口，状态变化时调用update方法
	class Observer {
		<<interface>>
		update()
	}
	Subject --> Observer
	
	%% 具体观察者
	class ConcreteObserver {
		update()
	}
	Observer <|.. ConcreteObserver
	ConcreteSubject <-- ConcreteObserver
	
	%% 具体主题
	class ConcreteSubject {
		registerObserver()
		removeObserver()
		notifyObserver()
		
		getState()
		setState()
	}
	Subject <|.. ConcreteSubject

3. 气象站类图

classDiagram
	%% 主题接口，注册、删除、通知观察者
	class Subject {
		<<interface>>
		registerObserver()
		removeObserver()
		notifyObserver()
	}
	
	%% 观察者接口，状态变化时调用update方法
	class Observer {
		<<interface>>
		update()
	}
	Subject --> Observer
	
	%% 公告板接口
	class DisplayElement {
		<<interface>>
		display()
	}
	
	%% 具体主题
	class WeatherData {
		registerObserver()
		removeObserver()
		notifyObserver()
		
		getTemperature()
		getHumidity()
		getPerssure()
		measurementsChanged()
	}
	Subject <|.. WeatherData
	
	%% 显示当前观测值
	class CurrentConditionsDisplay {
		update()
		display()
	}
	Observer <|.. CurrentConditionsDisplay
	DisplayElement <|.. CurrentConditionsDisplay
	
	%% 显示最大、最小、平均观测值
	class StatisticsDisplay {
		update()
		display()
	}
	Observer <|.. StatisticsDisplay
	DisplayElement <|.. StatisticsDisplay
	
	%% 显示天气预报
	class ForecastDisplay {
		update()
		display()
	}
	Observer <|.. ForecastDisplay
	DisplayElement <|.. ForecastDisplay
	
	%% 显示基于观测值的其他内容
	class ThirdPartyDisplay {
		update()
		display()
	}
	Observer <|.. ThirdPartyDisplay
	DisplayElement <|.. ThirdPartyDisplay

4. Java内置观察者，支持推或拉模式

classDiagram
	%% 可观察者类，注册、删除、通知观察者
	class Observable {
		addObserver()
		deleteObserver()
		notifyObservers()
		notifyObservers(Object arg)
		setChanged()
		clearChanged()
		hasChanged()
	}
	
	%% 观察者接口，状态变化时调用update方法
	class Observer {
		<<interface>>
		update()
	}
	Observer <-- Observable: obersers
	
	%% 具体主题
	class WeatherData {
		getTemperature()
		getHumidity()
		getPerssure()
	}
	Observable <|-- WeatherData
	
	%% 通用面板
	class GeneralDisplay {
		update()
		display()
	}
	Observer <|.. GeneralDisplay
	Observable <-- GeneralDisplay
	
	%% 显示最大、最小、平均观测值
	class StatisticsDisplay {
		update()
		display()
	}
	Observer <|.. StatisticsDisplay
	
	%% 显示天气预报
	class ForecastDisplay {
		update()
		display()
	}
	Observer <|.. ForecastDisplay

五、装饰者模式（Decorator）

1. 装饰者模式动态地将责任附加到对象上，若要扩展功能，装饰者模式提过了比继承更有弹性的替代方案
2. 基本类图

classDiagram
	%% 公共父组件
	class Component {
		methodA()
		methodB()
	}
	
	%% 需要动态添加行为的对象
	class ConcreteComponent {
		methodA()
		methodB()
	}
	Component <|-- ConcreteComponent
	
	%% 装饰者接口
	class Decorator {
		methodA()
		methodB()
	}
	Component <|-- Decorator
	Component <-- Decorator: warppedObj
	
	%% 具体装饰者
	class ConcreteDecoratorA {
		Component wrappedObj
		methodA()
		methodB()
	}
	Decorator <|-- ConcreteDecoratorA
	
	%% 具体装饰者
	class ConcreteDecoratorB {
		Component wrappedObj
		Object newState
		methodA()
		methodB()
	}
	Decorator <|-- ConcreteDecoratorB

3. 饮料类图

classDiagram
	%% 饮料
	class Beverage {
		description
		getDescription()
		cost()
	}
	
	%% 具体咖啡
	class HouseBlend {
		cost()
	}
	Beverage <|-- HouseBlend
	
	%% 具体咖啡
	class Espresso {
		cost()
	}
	Beverage <|-- Espresso
	
	%% 具体咖啡
	class DarkRoast {
		cost()
	}
	Beverage <|-- DarkRoast
	
	%% 具体咖啡
	class Decaf {
		cost()
	}
	Beverage <|-- Decaf
	
	%% 调料装饰者
	class CondimentDecorator {
		getDescription()
	}
	Beverage <|-- CondimentDecorator
	Beverage <-- CondimentDecorator: beverage
	
	%% 具体调料
	class Milk {
		Beverage beverage
		cost()
		getDescription()
	}
	CondimentDecorator <|-- Milk
	
	%% 具体调料
	class Mocha {
		Beverage beverage
		cost()
		getDescription()
	}
	CondimentDecorator <|-- Mocha
	
	%% 具体调料
	class Soy {
		Beverage beverage
		cost()
		getDescription()
	}
	CondimentDecorator <|-- Soy
	
	%% 具体调料
	class Whip {
		Beverage beverage
		cost()
		getDescription()
	}
	CondimentDecorator <|-- Whip

4. Java IO类图

classDiagram
	%% 输入流公共父类
	class InputStream {
	}
	
	%% 具体子类
	InputStream <|-- FileInputStream
	InputStream <|-- StringBufferInputStream
	InputStream <|-- ByteArrayInputStream
	
	%% 抽象装饰者
	class FilterInputStream {
	}
	InputStream <|-- FilterInputStream
	
	%% 具体装饰者
	FilterInputStream <|-- PushbackInputStream
	FilterInputStream <|-- BufferedInputStream
	FilterInputStream <|-- DataInputStream
	FilterInputStream <|-- LineNumberInputStream

六、工厂模式（Factory）

1. 简单工厂：通常定义一个静态方法创建具体对象，不属于设计模式
2. 工厂方法模式：定义了一个创建对象的接口，由子类决定要实例化的类是哪一个，让类把实例化推迟到了子类
3. 抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体的类

七、单例模式（Singleton）

1. 确保一个类只有一个实例，并提供一个全局访问点

八、命令模式（Command）

1. 将请求封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象；也支持可撤销的操作

九、适配器模式（Adapter）

1. 将一个类的接口转换成客户期望的另一个接口；让原本接口不兼容的类可以合作无间

十、外观模式（Facade）

1. 提供了一个统一的接口，用来访问子系统中的一群接口；定义了一个高层的接口，让子系统更容易使用

十一、模版方法模式（Template Method）

1. 在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中；使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤

十二、迭代器模式（Iterator）

1. 提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示

十三、组合模式（Composite）

1. 允许将对象组合成树形结构来表现”整体/部分“层次结构；让客户以一致的方法处理个别对象以及对象组合

十四、状态模式（State）

1. 允许对象在内部状态改变时改变他的行为，对象看起来好像修改了他的类

十五、代理模式（Proxy）

1. 为另一个对象提供一个替身或者占位符以控制这个对象的访问

十六、复合模式（Compound）

1. 结合两个或以上模式，组成一个解决方案
2. MVC模式，结合了观察者模式、策略模式、组合模式

十七、桥接模式（Bridge）

1. 将实现和抽象放在两个不同的层次中而使他们可以独立改变

十八、生成器模式（Builder）

1. 封装一个产品的构造过程，并允许按步骤构造

十九、责任链模式（Chain of Responsibility）

1. 可以为某个请求创建一个对象链；每个对象依次检查此请求，或者将它传给链中的下一个对象

二十、蝇量模式（Flyweight）

1. 让某个类的一个实例能用来提供许多虚拟实例

二十一、解释器模式（Interpreter）

1. 将每个语法规则表示成一个类，用于实现简单的语言

二十二、中介者模式（Mediator）

1. 用来集中相关对象之间复杂的沟通和控制方式

二十三、备忘录模式（Memento）

1. 可以储存对象的状态，需要时返回对象之前的状态

二十四、原型模式（Prototype）

1. 允许通过复制现有的实例来创建新的实例，向客户隐藏了制造新对象的复杂性

二十五、访问者模式（Visitor）

1. 允许对组合结构加入新的操作，而无需改变结构本身