面向对象绪论

Guderian出品

面向对象的基本概念

• 类 Class
• 对象 Object

浅显理解：类是抽象的对象，对象是具体的类

概念之间的互用

• 属性 Attribute == 数据 Data == 状态 State == 信息 Information
• 操作 Operation == 方法 Method == 行为 Behavior == 职责 Responsibility
• 对象 Object == 实例 Instance

面向对象的核心特征

• 封装 Encapsulation
• 继承 Inheritance
• 多态 Polymorphism

封装、继承和多态被称为所谓的“面向对象三大特征”

• 聚合/组合 Aggregation / Composition
• 接口/实现 Interface / Implementation
• 抽象 Abstraction

封装 Encapsulation

是指隐藏对象的属性和实现细节，仅对外提供公共访问方式

1. 封装什么？

• 内部的、不想让其他人随意了解的信息
• 类的属性 Attribute
• 类的方法 Method

1. 为什么要封装？

• 保护隐私
• 保护数据安全
• 隔离复杂度

1. 面向对象的封装有四种方式

• Public
• Private
• Protected
• Package

继承 Inheritance

一个类从其他类获得它的状态和行为，同时还可以加上自己额外的状态和行为

父类中的属性和方法，在子类中可以重复使用，子类就不需要再定义了，这样即可实现代码的可重用性。如以下类图例子，定义类C1Dobject一维物体，它有一个属性x对应x轴上的一个坐标，两个方法getx()和setx(int)分别表示x坐标的获取和设置。如果我们需要定义二维物体，就没有必要把x坐标重复定义。我们在类C1Dobject的基础上派生出子类C2Dobject，只需再定义属性y和方法gety()及sety(int)就可以完整地抽象出一个二维物体；类似地，如果我们需要定义三维物体，没有必要把x坐标、y坐标重复定义，只需再类C2Dobject的基础上派生出子类C3Dobject，再定义属性z和方法getz()及setz(int)即可。显而易见，继承提高了代码的可重用性，减少了创建类的工作量。

以上类图对应的C++代码如下：

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

class C1Dobject
{
private:
	int x = 0;
public:
	int getx() { return x; }
	void setx(int xPrime) { x = xPrime; }
};

class C2Dobject: public C1Dobject
{
private:
	int y = 0;
public:
	int gety() { return y; }
	void sety(int yPrime) { y = yPrime; }
};

class C3Dobject: public C2Dobject
{
private:
	int z = 0;
public:
	int getz() { return z; }
	void setz(int zPrime) { z = zPrime; }
};

二次曲面

图：Watch Dog 2 by Ubisoft

Guderian出品

2.双曲柱面

3.抛物柱面

4.椭球面

5.单叶双曲面

6.双叶双曲面

7.椭圆抛物面

8.双曲抛物面

变种：

9.二次锥面

面向对象设计七大原则

图：北京航空航天大学

Guderian出品

AKA：设计模式七大原则

1. 单一职责原则

• SRP，Single Responsibility Principle
• 每一个对象有且只有一个职责，从而实现”高内聚、低耦合“
• 防止一个类实现多个功能，改变一个功能后影响其他功能的正常运作

2. 开放-封闭原则

• OCP，Open-Closed Principle
• 对拓展开放、对修改关闭
• 需要对程序进行拓展的时候，不能修改原有代码，只能在原有代码的基础上添加

3. 李氏替换原则

• LSP，Liskov Substitution Principle
• 任何基类出现的地方，一定可以用派生类代替
• 派生类可以拓展基类的功能，但不能改变基类的功能

4. 依赖倒置原则

• DIP，Dependence Inversion Principle
• 实现依赖于抽象，而抽象不依赖于实现
• 解除高层组件对低层组件的依赖，是实现开闭原则的重要基础

5. 接口隔离原则

• ISP，Interface Segregation Principle
• 一个类对另外一个类的依赖性应当是建立在最小的接口上
• 在特定的使用场合给特定用户提供其需要的方法、屏蔽其不需要的方法

6. 组合重用原则

• CRP, Composite Reuse Principle,
• 尽量使用组合，尽量不用继承
• 在新的对象里面使用已有的对象，使之成为新的对象的一部分

7. 迪米特原则

• LoD，Law of Demeter
• 一个对象应该对其他对象又尽可能少的了解
• 尽量降低成员的访问权限，提供访问器而不公开成员变量

C++引用

图：LEGO小人仔

Guderian出品

C++跟C相比，多了很多独特的内容，其中有很多都是为了实现面向对象编程范式而引入的，C++的引用就是其一。

引用的概念

• 定义一个引用，并将其初始化为引用某个变量的通用写法：类型名 & 引用名 = 某变量名
• 某个变量的引用，等价于这个变量，相当于该变量的一个别名

1
2
3
4
5
6
7
8

int n = 7;
int & r = n;
//r引用了n，r的类型是int &
r = 4;
cout << r;	//输出4
cour << n;	//输出4
n = 5;
cout << n;

• 定义引用时一定要将其初始化成引用某个变量，而不像指针可以指向某个变量也可以不指向某个变量
• 初始化后，它就一直引用该变量，不会再引用别的变量了（引用是从一而终的）
• 引用只能引用变量，不能引用常量和表达式

1
2
3
4
5
6
7

double a = 3, b = 5;
double & r1 = a;
double & r2 = r1;	//r2也引用a
r2 = 10;
cout << a << endl;	//输出10
r1 = b;				//r1并没有引用b
cout << a << endl;	//输出5

引用的应用

C中，如何编写交换两个整型变量值的函数?

• 这样写吗？

1
2
3
4
5
6
7
8

void swap(int a, int b)
{
    int tmp;
    tmp = a; a = b; b = tmp;
}
int n1, n2;
swap(n1, n2);
//n1, n2的值没有被交换

这是错误的，改变形参不会改变实参。

• 或者用指针？

1
2
3
4
5
6
7
8

void swap(int *a, int *b)
{
    int tmp;
    tmp = *a; *a = *b; *b = tmp;
}
int n1, n2;
swap(& n1, & n2);	//取地址
//n1, n2的值被交换

正确，但丑陋！

那么C++中，如何编写交换两个整型变量值的函数?

引用作为参数

C++示例：交换两个整数

1
2
3
4
5
6
7
8

void swap(int & a, int & b)	//a就是n1，b就是n2
{
    int tmp;
    tmp = a; a = b; b = tmp;
}
int n1, n2;
swap(n1, n2);
//n1, n2的值被交换

引用作为返回值

1
2
3
4
5
6
7
8
9
10
11
12
13

int n = 4;
int & SetValue() { return n; }

int main()
{
    //神奇之处，对函数的返回值进行赋值
    SetValue() = 40;
    //然而它究竟有什么作用呢？我还没想好...
    cout << n;
    //输出：40
    
    return 0;
}

注意被引用的对象不能超过作用域，返回一个局部变量的引用是不合法的，但是，可以返回一个静态类型变量的引用。

常引用

定义引用时，在前面加const关键字即为“常引用”。

1
2

int n;
const int & r = n;

1
2
3
4

int n = 100;
const int & r = n;
r = 200;	//err
n = 300;	//ok

常引用和非常引用的转换

• const T &和T &是不同的类型（千万要注意！！！）
• T &类型的引用或T类型的变量可以用来初始化const T &类型的引用
• const T类型的常变量和const T &类型的引用则不能用来初始化T &类型的引用，除非进行强制类型转换

C++继承和派生

图：古老的地球

Guderian出品

基本概念

• 继承和派生实际上是一回事：在定义一个新的类B时，如果该类与某个已有的类A相似（指的是B拥有A的全部特点），那么可以把A作为一个基类，而把B作为基类的一个派生类（也称子类），这使得创建和维护一个程序更加容易
• 派生类拥有基类的全部特点，派生类还可以对基类进行修改和扩充。在派生类中，可以扩充新的成员变量和成员函数
• 派生类一经定义，可以独立使用，定义对象时不依赖于基类
• 派生类拥有基类的全部成员函数和成员变量。不论是private、protected、public
• 在派生类的各个成员函数中，不能访问基类的private成员

简单理解成员修饰符protected和private的区别：protected成员在派生类中可以被访问，而private不能

• 对象不同类型对应的访问权限：

派生类的写法

1
2
3
4
5

class 派生类名: 访问修饰符 基类名	//Zh
class derived-class: access-specifier base-class	//En
{
	//...
};

访问修饰符可以是private、protected、public中的一个。如果未使用访问修饰符，则默认为private。该访问修饰符规定了继承类型。

继承类型

• 公有继承（public）：继承public和protected且类型不变，不继承private
• 保护继承（protected）：继承public和protected且类型都为protected，不继承private
• 私有继承（private）：继承public和protected且类型都变为private，不继承private

一般使用公有继承。

写法示例：学生管理系统

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

class CStudent
{
    private:
    	string sName;
    	int nAge;
    public:
    	bool IsThreeGood()	{};
    void SetName(const string & name)	{ sName = name; }
    //...
};
class CUndergraduteStudent: public CStudent
//本科生
{
	private:
		int nDepartment;
	public:
		bool IsThreeGood()	{/*...*/};	//覆盖（不是重载！覆盖的参数表不变，重载的参数表改变！）
		//名字与基类一样，但行为不一样
		bool CanBaoYan()	{/*...*/};
};
class CGraduatedStudent: public CStudent
//研究生
{
	private:
		int nDepartment;
		char szMentorName[20];
	public:
		int CountSalary()	{/*...*/};
};

派生类对象的内存空间

在派生类对象中，包含基类对象，而且基类对象的存储位置位于派生类对象新增的成员变量之前。