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

发布于: 2020 年 06 月 24 日

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

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):表示自己还有孩子

用户头像

a晖

关注

还未添加个人签名 2018.12.05 加入

还未添加个人简介

评论

发布
暂无评论
week3 总结-面向对象的设计模式