写在前面

本文一起看下面向对象的设计原则和GOF 23 种常用的设计模式。

1：面向对象设计原则

面向对象设计原则可以简单的总结为SOLID，分别看下。

1.1：S

single responsibility principle，单一职责原则，即一个类只干一件事。这样做的好处是，便于后期的维护，修改某个功能，不会影响到其他的功能。

1.2：O

open close principle,开放关闭原则，即对修改关闭，对扩展开放。如果需要修改的话，可以通过子类，装饰等方式来实现。最典型的就是模板方法设计模式。

1.3：L

liskov substituion principle，里氏替换原则，如下图：

这里的类A，类B，类C,任何一个替换另外一个，最终的行为都是一致的，这里的核心点是行为是什么？个人理解行为包括如下内容:

复制代码

1:符合基类定义的在什么场景下抛出什么异常
2：符合基类定义的在什么场景下返回什么值
3：符合基类定义的在什么场景下执行什么操作

对于1比如List接口的get方法关于异常进行了如下的定义：

复制代码

/**
    * Returns the element at the specified position in this list.
    *
    * @param index index of the element to return
    * @return the element at the specified position in this list
    * @throws IndexOutOfBoundsException if the index is out of range
    *         (<tt>index &lt; 0 || index &gt;= size()</tt>)
    */
E get(int index);

即当index超出范围时抛出IndexOutOfBoundsException，对于子类ArrayList，和LinkedList实现如下：

复制代码

// ArrayList java.util.ArrayList#rangeCheck
private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

// LinkedList java.util.LinkedList#checkElementIndex
private void checkElementIndex(int index) {
    if (!isElementIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

所以对于代码List list = new ArrayList, 以及List list = new LinkedList在index超出范围时的行为是一致的，都是抛出IndexOutOfBoundsException,但是如果定义了如下的子类：

复制代码

class CustomList<T> extends ArrayList<T> {
    @Override
    public T get(int index) {
        if (index >= size)
             throw new UnsupportedOperationException();
        // other operation
    }
}

CustomList在index超出范围时不是抛出IndexOutOfBoundsException，而是抛出UnsupportedOperationException，这就破坏了基类的定义了，也就不符合里氏替换原则了。

1.4：I

interface segregation principle,接口隔离原则，接口定义的要独立，不能有重合的部分，如Lambda定义的相关接口。

java.util.function.Function
对接受一个参数，并返回一个值的抽象。
java.util.function.Predicate
对接受一个参数，并根据其返回真假的抽象。
java.util.function.Consumer
对接受一个参数，但是不返回值的抽象。
java.util.function.Supplier
对不要任何入参，返回一个值的抽象。

1.5：D

dependency inversion principle，依赖倒置原则，编程时要依赖于抽象，而非依赖于具体实现，这样做的好处是，程序不需要绑定到某个具体的实现类上，这样当业务变更，程序的改动更加容易（或程序本身就不要修改）。

2：GOF 23种设计模式

GOF全称是gang of four，即四个小伙伴,就是下边这四个人：

gof 23种设计模式按照类型可以分为3类，创建型，结构型，行为型。分别看下。

2.1：创建型

创建型，顾名思义，就是用来创建对象的相关设计模式。创建型的设计模式一共5中，如下：

复制代码

1:工厂方法 factory method
2:抽象工厂 abstract factory
3：建造者 buidler
4：原型 prototype
5：单例 singleton

分别看下。

面向对象设计原则和GOF23种设计模式

写在前面

1：面向对象设计原则

1.1：S

1.2：O

1.3：L

1.4：I

1.5：D

2：GOF 23种设计模式

2.1：创建型

2.1.1：工厂设计模式

2.1.2：抽象工厂设计模式

2.1.3：建造设计模式

2.1.4：原型模式

2.1.5：单例模式

2.2：结构型

2.2.1：适配器设计模式

2.2.2：桥接设计模式

2.2.3：组合设计模式

2.2.4：装饰设计模式

2.2.5：门面设计模式

2.2.6：享元设计模式

2.2.7：代理设计模式

2.2.8：解释器设计模式

2.2.9：模板方法设计模式

2.3：行为型

2.3.1：责任链设计模式

2.3.2：命令设计模式

2.3.3：迭代器设计模式

2.3.4：中介设计模式

2.3.5：备忘录设计模式

2.3.6：观察者设计模式

2.3.7：状态设计模式

2.3.8：状态设计模式

2.3.9：状态设计模式

写在后面

参考文章列表