重新认识面向对象

1、重新认识面向对象

1.1、理解隔离的变化

• 从宏观层面来看，面向对象的构建方式更能适应软件的变化，能将变化所带来的影响减为最小。

1.2、各司其职

• 从微观层面来看，面向对象的方式更强调各个类的“责任“。
• 由于需求变化导致的新增类型不应该影响原来类型的实现——是所谓各负其责。

1.3、对象是什么

• 从语言实现层面来看，对象封装了代码和数据。
• 从规格层面讲，对象是一系列可被使用的公共接口。
• 从概念层面讲，对象是某种拥有责任的抽象。

2、面向对象设计基本原则（八个原则）

先介绍分而治之的思想构造类

点、直线和矩形的类

class Point
{
public:
    int x;
    int y;
};

class Line
{
public:
    Point start;
    Point end;

    Line(const Point& start, const Point& end)
    {
        this->start = start;
        this->end = end;
    }
};


class Rect
{
public:
    Point leftUp;
    int width;
    int height;

    Rect(const Point& leftUp, int width, int height)
    {
        this->leftUp = leftUp;
        this->width = width;
        this->height = height;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

MainForm类

class MainForm
{
private:
    vector<Line> lineVector;
    vector<Rect> rectVector;

public:
    void addLine(const Line& line) { lineVector.push_back(line); }
    void addRect(const Rect rect) { rectVector.push_back(rect); }

    void run();
};

void MainForm::run()
{
	// 画直线
    for (int i = 0; i < lineVector.size(); i ++ )
    {
        drawLine(
            red, 
            lineVector[i].start.x, 
            lineVector[i].start.y;
            lineVector[i].end.x;
            lineVector[i].end.y;
        );
    }
	
	// 画矩形
    for (int i = 0; i < rectVector.size(); i ++ )
    {
        drawRect(
            red, 
            rectVector[i].leftUp, 
            rectVector[i].width, 
            rectVector[i].height
        );
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

不难发现我们如果需要增加一个画圆形的方法就要修改MainForm类的很多代码

介绍抽象类的方法构造类

Shape抽象类、点、直线和矩形的类

class Shape
{
public:
    virtual void draw() = 0;
    virtual ~Shape() {};
};

class Point
{
public:
    int x;
    int y;
};

class Line : public Shape
{
public:
    Point start;
    Point end;

    Line(const Point& start, const Point& end)
    {
        this->start = start;
        this->end = end;
    }

    void draw()
    {
        drawLine(
            red, 
            start.x,
            start.y,
            end.x,
            end.y
        );
    }
};


class Rect : public Shape
{
public:
    Point leftUp;
    int width;
    int height;

    Rect(const Point& leftUp, int width, int height)
    {
        this->leftUp = leftUp;
        this->width = width;
        this->height = height;
    }


    void draw()
    {
        drawRect(
            red, 
            rectVector[i].leftUp, 
            rectVector[i].width, 
            rectVector[i].height
        );
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

MainForm类

class MainForm
{
private:
	// 使用基类指针
    vector<Shape*> ShapeVector;

public:
    void add(Shape* shape)
    {
        ShapeVector.push_back(shape);
    }
    void run();
};

void MainForm::run()
{
	// 只需要调用虚函数方法
    for (int i = 0; i < ShapeVector.size(); i ++ )
    {
        ShapeVector[i]->draw();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2.1、依赖倒置原则(DIP )

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

2.2、开放封闭原则(OCP )

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

2.3、单一职责原则（SRP)

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

2.4、Liskov替换原则(LSP)

• 子类必须能够替换它们的基类(IS-A)。
• 继承表达类型抽象。

2.5、接口隔离原则(ISP)

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

2.6、优先使用对象组合，而不是类继承

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

2.7、封装变化点

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

2.8、针对接口编程，而不是针对实现编程

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

3、接口标准化

3.1、以史为鉴（1）

• 秦为什么能够统一六国?
  • 据史书记载和考古发现,秦的兵器不论东西南北,出土地点都有统一的标准
    戈,弩，甚至弩机,弩体，箭头都是一样的.而其他六国则不是.

3.2、以史为鉴（2）

• 毕升的活字印刷为什么成为四大发明，推动了人类文明的前进?
  • 毕升之前的雕版印刷将字刻死在木板或石板上，每次印刷不同文章，要刻不同的版。而毕升发明的活字印刷首先在板上刻好字格然后再刻单独的字模。印刷时，将活的字模“按需索取”中，不同的排列方法产生不同的文章，而不必重新刻版。

4、将设计原则提升为设计经验

4.1、设计习语Design Idioms

• Design Idioms 描述与特定编程语言相关的低层模式，技巧，惯用法。

4.2、设计模式Design Patterns

• Design Patterns主要描述的是“类与相互通信的对象之间的组织关系，包括它们的角色、职责、协作方式等方面。

4.3、架构模式Architectural Patterns

• Architectural Patterns描述系统中与基本结构组织关系密切的高层模式，包括子系统划分，职责，以及如何组织他们之间的关系原则。

5、模型分类

5.1、GOF-23分类

根据目的来分

• 创建型模式：用于描述“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”。GoF 中提供了单例、原型、工厂方法、抽象工厂、建造者等 5 种创建型模式。
• 结构型模式：用于描述如何将类或对象按某种布局组成更大的结构，GoF 中提供了代理、适配器、桥接、装饰、外观、享元、组合等 7 种结构型模式。
• 行为型模式：用于描述类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，以及怎样分配职责。GoF 中提供了模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器等 11 种行为型模式。

根据作用范围来分

• 类模式（静态）：用于处理类与子类之间的关系，这些关系通过继承来建立，是静态的，在编译时刻便确定下来了。GoF中的工厂方法、（类）适配器、模板方法、解释器属于该模式。
• 对象模式（动态）：用于处理对象之间的关系，这些关系可以通过组合或聚合来实现，在运行时刻是可以变化的，更具动态性。GoF 中除了以上 4 种，其他的都是对象模式。

5.2、从封装变化角度对模式分类

1. 组件协作
2. 单一职责
3. 对象创建
4. 对象性能
5. 接口隔离
6. 状态变化
7. 数据结构
8. 行为变化
9. 领域问题

6、重构关键技法