week3 总结 - 面向对象的设计模式

架构师第三周主要讲面向对象的设计模式

1，设计模式的定义

什么是设计模式：

• 每一种模式都描述了一种通用的解决方案

• 模式是一种可以重复使用的解决方案

2，模式的四个组成部分

• 模式的名称 由少量的字组成的名称，有助于表达我们的设计

• 待解问题 描述了何时使用这种模式，以及模式的使用环境

• 解决方案 描述了组成设计的元素，他们的关系，职责以及合作

• 结论 运用这种方案的利弊。主要是它对系统的扩展性，弹性和可移植性的影响

3，模式的分类

从功能分：

• 创建模式 对类实例化过程的抽象

• 结构模式 将类和对象组合成更大的结构

• 行为模式 对在不同的对象之间划分责任和算法的抽象化

从方式分：

• 类模式 以继承的方式实现模式，是静态的

• 对象模式 以组合的方式实现模式，是动态的

4，简单工厂

• 如何创建一个对象

• UML 图：

•  简单工厂及 Client 程序

public class SorterFactory {	public static <T> Sorter<T> getSorter() {		return new BubbleSorter<T>();	}}
public class Client {	public static void main() {		Integer[] array = { 5, 4, 9, 7, 6, 3, 8, 1, 0, 2};
		Sorter<Integer> sorter = SorterFactory.getSorter();		Sortable<Integer> sortable = SortableFactory.getSortable(array);		Comparator<Integer> comparator = ComparatorFactory.getComparator();
		sorter.sort(sortable, comparator);		......	}}

• 简单工厂的优缺点

优点：

• 使 Client 不再依赖 Sorter 的具体实现（如 BubbleSorter）

• 对 Client 实现 OCP - 增加 Sorter 不影响 Client

缺点：

• 对 Factory 未实现 OCP - 增加 Sorter 需要修改 Factory

5，单例模式

单例模式保证产生单一实例，就是一个类产生一个实例。

使用单例原因：

• 因为只有一个实例，可以减免实例频繁创建和销毁带来的资源消耗。

• 当多个用户使用这个实例的时候，便于进行简单控制

前者是性能需求，后者是功能需求。

单例实现的两种方式：

1，饿汉式

public class HungrySingleton {	private static HungrySingleton instance = new HungrySingleton();	private HungrySingleton() {	}	public static HungrySingleton getInstance() {		return instance;	}}

注意：一定要有私有的构造函数，保证实例只能通过getInstance() 方法获得。

尽量使用饿汉式构造单实例。单例中的成员变量是多线程重用的，可能会产生意想不到的结果，因此尽量将单例设计为无状态对象（只提供服务，不保存状态）。

饿汉式 Singleton 的问题是，应用一启动就加载对象进内存，就算从来未被用过。

2，懒汉式

publci class LazySingleton {	private static LazySingleton instance = null;	private LazySingleton() {		}
	public static synchronized LazySingleton getInstance() {		if (instance == null) {			instance = new LazySingleton();		}
		return instance;	}}

注意： getInstance() 的修饰符 synchronized 一定要加上，否则可能会产生多重实例。

懒汉式 Singleton 解决了饿汉式 Singleton，当调用的时候才去加载对象到内存。但是引发了另外一个性能问题，每次访问对象都要加锁。

6，适配器模式

适配器的作用：系统需要使用现有的类，而这个类的接口与我们所需要的不同。

例子： 我们需要对 List 进行排序，但是我们需要一个 Sortable 接口，原有的 List 接口不能满足要求

•  类的适配器

  由于原 Sortable 接口和 ArrayList 不兼容，只好定义一个 NewSortable

public class Sortable<T> extends ArrayList<T> implements NewSortable<T> {	public T getElement(int i) {		return get(i);	}		public void setElement(int i, T o) {		set(i, o);	}}
public interface NewSortalbe<T> {	int size();	T getElement(int i);	void setElement(int i, T o);}

• 对象适配器

public class ListSortable<T> implements Sortable<T> {	private final List<T> list;
	public ListSortable(List<T> list) {		this.list = list;	}
	public int size() {		return list.size();	}
	public T get(int i) {		return list.get(i);	}
	public void set(int i, T o) {		list.set(i, o);	}}

• 适配器的应用

JDBC Driver

• 是对具体数据库的适配器

• 例如，将 Oracle 适配到 JDBC 中

JDBC-ODBC Bridge

• 是将 Windows ODBC 适配到 JDBC 接口中

7，模板模式

模板方式是扩展功能最基本的方式之一

• 它是一种类的行为模式

它通过继承的方式实现扩展

• 基类实现算法的轮廓和骨架

• 子类负责算法的具体实现

组合 VS. 继承

• 基于继承的模板模式比组合更容易实现

• 在很多情况下，可以适当使用这种模式

模板方法的形式：

• 抽象方法 protected abstract void step1() 强制子类实现这一方法

• 具体方法    protected void dosomething() 子类可以覆盖 也可以不覆盖该方法

• 钩子方法 protected void setup（）{} 空的实现

8，策略模式

策略模式是扩展功能的另一种基本方法，它是一种对象的行为模式，通过组合的方式来实现扩展。

什么时候使用策略模式：

• 系统需要在多种算法中使用一种

• 重构系统时 将条件语句转化成对于策略的多态性调用

策略模式的优点：

• 将使用策略的人和策略的具体实现分离

• 策略对象可以自由组合

9，组合模式

组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。这种模式创建了一个包含自己对象组的类。该类提供了修改相同对象组的方式。

组合模式可以使用一棵树来表示，一共有三个角色：

1）组合部件（Component）：它是一个抽象接口。

2）叶子(Leaf）：在组合中表示子节点对象。

3）合成部件（Composite）：表示自己还有孩子