初识设计模式

每一个模式描述了一个在我们周围不断重复发生的问题,以及该问题的解决方案的核心.这样,你就能一次又一次地使用该方法而不必做重复劳动
by Christopher Alexander

从目前的编码过程中，可能我的状态就是比较注重功能的实现，然而面对其他的比如对象之间的耦合关系什么的基本没有考虑到，虽然使用着面向对象的语言，做的好像不是面向对象的事情。学习设计模式能让人加深对面向对象编程的理解，有时候会让人有一种醍醐灌顶的感觉。然而设计模式虽好，但不要沉迷其中无法自拔，还是得有自己的思考。好了说了些废话，正文开始了。

说到设计模式就不得不提一本书GOF设计模式：可复用面向对象软件的基础，我们把目光锁定在后面的解释，可复用，正如开头所引用的话，模式的最终目标就是复用，放在软件开发中也是如此，一个臃肿的类体系是人们不愿意看到的。另外，设计模式提供了一种不同的思维方式，它使得我们跳出了事物本身的局限，去考虑更加本质的东西，首先就从java的面向对象说起，这里有两种不同的思维方式

• 底层思维：向下，如何把握机器底层，我们是从微观的角度去理解对象构造，这涉及到了很多方面的知识：
• 语言构造
• 编译转换
• 内存模型
• 运行时机制
• 抽象思维：向上，这种思维方式在设计领域的时候用的比较多，抛开一些编码和编译的细节，主要关心如何将我们周围的世界抽象为程序代码，这个过程就关系着设计最终的好坏，代码的品质：
• 面向对象
• 组件封装
• 设计模式
• 架构模式
  在抽象思维里，上面的方式是基本互通的，只是表达方式不同。

抽象思维是建立在比较升入理解了底层思维的基础上的，面向对象的三大特性：封装（隐藏内部实现），继承（复用现有代码），多态（改写对象行为），这三大特性在设计模式里十分重要，在设计模式里，理解灵活多变的利用这三大特性来描述现实世界，也就理解了设计模式这样设计的原因和意义所在。

由于个人水平比较菜，所以现在也还没有参与过什么项目，然而耳闻过。为什么说软件设计很复杂，因为在项目开展的过程中，会有永运猜不透想法的客户的需求变化，你不得不接受的团队成员的流动，技术平台日新月异的更新等一系列不可控因素，然而在软件设计的初期要尽可能的把这些变化考虑进去，难不难，当然难。需不需要去解决，当然需要！怎么解决？当人们遇到比较复杂的问题的时候，都这样做，我也这样做：

• 分解
• 人们面向复杂性有一个常见的做法：即分而治之，将大问题分解问哦多个小问题，将复杂问题分解为多个简单问题，这个方法在一些场景里是非常适用的，比如算法里分治法的使用。不过在面对复杂性多样变化的场景时，就不是那么的可爱了，首先大问题的划分就很难统一，因为未来的变化总是未知的，掌握所有的情况是不可能的。
• 抽象
• 更高层次来讲，人们处理复杂性有一个通用的技术，即抽象。由于不能掌握全部的复杂对象，我们选择忽略它的非本质细节，而去处理泛化和理想化了的对象模型。这有点哲学的味道了，关注本质。

比如我们有两个图形类：

//直线类
class Line {
    public int startX;
    public int startY;
    public int endX;
    public int endY;

    public Line(int startX, int startY, int endX, int endY) {
        this.startX = startX;
        this.startY = startY;
        this.endX = endX;
        this.endY = endY;
    }
}

//矩形类
class Rect {
    public int left;
    public int top;
    public int right;
    public int bottom;

    public Rect(int left, int top, int right, int bottom) {
        this.left = left;
        this.top = top;
        this.right = right;
        this.bottom = bottom;
    }
}

然后在MainActivity中分别实现，不需要在意功能，就只关心使用的地方

  Vector<Line> lineVector = new Vector<Line>();
  Vector<Rect> rectVector = new Vector<Rect>();

     if (lineRadio.isChecked()) {
                    lineVector.add(new Line(startPoint.x,
                            startPoint.y,
                            endPoint.x,
                            endPoint.y));
                } else if (rectRadio.isChecked()) {
                    rectVector.add(new Rect(startPoint.x,
                            startPoint.y,
                            endPoint.x,
                            endPoint.y));
                }
                //更改...
                else if(...){

                }
          }

            for (int i = 0; i < lineVector.size(); i++) {

                canvas.drawLine(lineVector.get(i).startX,
                        lineVector.get(i).startY,
                        lineVector.get(i).endX,
                        lineVector.get(i).endY,
                        paint);
            }

            for (int i = 0; i < rectVector.size(); i++) {

                canvas.drawRect(rectVector.get(i).left,
                        rectVector.get(i).top,
                        rectVector.get(i).right,
                        rectVector.get(i).bottom,
                        paint);

            }

上面第一段代码是先生成每一个图形的Vector，然后分别add，下面的for循环可以理解为轮询每一个不同的Vector对象，然后画出图形。当代码写完了，突然想起，哎呀忘记Circle了，于是首先得在写出一个Circle的类，然后new一个Circle的Vector数组，接着在add处也要修改，最后还要增加一个for循环，忘记一个就要更改4处，是不是很复杂，而且当代码多的时候，更改的出错率会增多，这是很危险的。
如果我们从另外一方面，或者说抽象出来，这些都是属于图形，那我们定义一个抽象图形类：

//形状基类
abstract class  Shape {

    abstract void draw(Canvas canvas, Paint paint);

}

然其他无论什么图形都继承它。接着生成了一个Vector数组：

Vector<Shape> shapeVector = new Vector<Shape>();

而add时，增加具体图形的数据，for循环也是它，这样不管是什么图形，都可以绘制出来，不用单独去考虑：

      for (int i = 0; i < shapeVector.size(); i++) {

                shapeVector.get(i).draw(canvas, paint);

            }

如果需求变更了，增加了图形，我们只需要继承Shape写一个实体类，再在add处增加新图形的add方法，其他的都不会变化。相对于第一种，当需求变化发生的时候，很多的代码得以复用，而不用像第一种手忙脚乱，这里那里修改，所以相对于分解思维模式，抽象模式的优势就体现出来--复用。

所以用了java语言，并不一定拥有了抽象的设计思维，说的就是我。

重新认识面向对象：

• 理解隔离变化
• 从宏观层面来看，面向对象的构建方式更能使用软件的变化，比如上面的例子，能将变化所带来的影响减为最小
• 各司其职
• 从微观层面，面向对象的方式更强调各个类的责任
• 由于需求变化导致的新增类型不应该影响原来的类型的实现-就是叫做所谓各负其责。
• 对象深入
• 从语言实现层面来说，对象封装了代码和数据
• 从规格层面来讲，对象是一系列可被使用的公共接口
• 从概率层面讲，对象是某种拥有责任的抽象

面向对象设计原则：

1. 依赖倒置原则(DIP)

• 高层模块（稳定）不应该依赖低层模块（变化），二者都应该依赖于抽象（稳定）
• 抽象（稳定）不应该依赖与实现细节（变化），实现细节应该依赖于抽象 （稳定）

3. 开放封闭原则(OCP)

• 对扩展开发，对更改封闭
• 类模块应该是可扩展，但是不可修改

4. 单一职责原则(SRP)

• 一个类应该仅有一个引起它变化的原因
• 变化的方向隐含这类的责任。

5. Liskov替换原则(LSP)

• 子类必须能够替换他们的基类
• 继承表达类型抽象

6. 接口隔离原则(ISP)

• 不应该强迫客户程序依赖他们不用的方法
• 接口应该小而完备

7. 优先使用对象组合，而不是类继承

• 类继承通常为"白箱复用"，对象组合通常为"黑箱复用"
• 类继承在某种程度上破坏了封装性，子类父类耦合度高
• 而对象组合则只要求被组合的对象具有良好定义的接口，耦合度低

8. 封装变化点

• 使用封装来创建对象之间的分界层，让设计者可以在分界层的一侧进行修改，而不会对另一侧产生不良的影响，从而实现层次间的松耦合

9. 针对接口编程，而不是针对实现编程

• 不将变量类型声明为某个特定的具体类，而是声明为某个接口
• 客户程序无需获知对象的具体类型，只需要知道对象所具有的接口。
• 减少系统中各部分的依赖关系，从而实现“高内聚，松耦合”的类型设计方案

老师举了两个例子，一个是秦统一六国之后，统一货币统一度量衡，从软件开发的角度来说就是统一了接口，并且使其规范化。再一个是毕升的活字印刷术，它的发明之所以推进了人类文明的发展，是因为首先复用了每个汉字，按需所用，不需要像雕版印刷一样来一篇文章刻一次版，其次规定了每个字模的大小规格，毕升就是松耦合大师。通过这个感性的认识，就会体会到接口规范化对于行业的贡献。

以上，欢迎指正。