面向对象编程思维（软件工程）

目录

结构化设计方法

面向对象方法

结合例子理解

封装

继承

多态

重载

---

结构化设计方法

---

基本点是面向过程，系统被分解成若干个过程。

面向对象方法

---

把对象作为由数据及可以施加在这些数据上的操作所构成的统一体。对象与传统的数据有本质区别，它不是被动地等待外界对它施加操作，它是进行处理地主体。

（1）对象：是由描述该对象属性的数据以及可以对这些数据施加的所有操作封装在一起构成的一体。

静态特征：属性（数据项）

动态特性：方法（操作，服务）

（2）类：是具有相同数据和相同操作的一组相似对象的定义。

类是对象的抽象，对象是类的具体化，是类的实例

（3）消息：对象彼此之间仅能通过传递消息互相联系

（4）方法：方法就是对象所能执行的操作，也就是类中所定义的服务。方法描述了对象执行操作的算法，响应消息的方法。在C++语言中把方法称为成员函数。

（5）属性：属性就是类中所定义的数据，它是对客观世界实体所具有的性质的抽象。类的每个实例都有自己特有的属性值。在C++中把属性称为成员变量。

结合例子理解

---

同一类事物，可以用“Circle类”来定义

相同的数据：圆心坐标、半径、颜色

相同的操作：显示、放大、缩小、移动、改变颜色。

// ConsoleApplication1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
 
#include 
using namespace std;
 
class Rectangle
{
public:
	int w, h;                 //属性
	void init(int w_, int h_);
	int area();
	int perimeter();
};                            //注意方法并没有写在里面
 
 
void Rectangle::init(int w_, int h_)
{
	w = w_;
	h = h_;
}
 
 
int Rectangle::area()       //方法
{
	return w * h;
 
}
 
 
int Rectangle::perimeter()
{
	return 2 * (w + h);
}
 
 
int main()
{
    std::cout << "Hello World!\n";
	int w, h;
	Rectangle r;
	cin >> w >> h;
	r.init(w, h);
	cout << "are is:" << r.area() << endl;
	cout << "perimeter is:" << r.perimeter() << endl;
	return 0;
}
 
// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单
 
// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件

封装

---

对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。使用封装有三大好处：
1、良好的封装能够减少耦合。
2、类内部的结构可以自由修改。
3、可以对成员进行更精确的控制。
4、隐藏信息，实现细节。
5、有一个清晰的边界。所有的私有数据和实现操作的代码都被封装在这个边界内，在外面看不见更不可能直接访问。

6、有确定的接口（即协议）。

7、受保护的内部实现。

继承

---

在面向对象的软件技术中，继承是子类自动地共享基类中定义的数据和方法的机制。

继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。

 同时在使用继承时需要记住三句话：

1、子类拥有父类非private的属性和方法。
2、子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
3、子类可以用自己的方式实现父类的方法。

// 继承.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include
#include
using namespace std;
 
class CStudent  //父类
{
private:
	string name;
	string id;
	char gender;
	int age;
public:
	void PrintInfo();
	void SetInfo(const string &name_, const string &id_, int age_;char gender_);
	string GetName()
	{
		return name;
	}
};
 
class CUndergraduageStudent :public CStudent    //子类
{
private:
	string department;
 
public:
	void Forbaoyan(){
		cout << "qulified for baoyan" << endl;
 
		void PrintInfo(){
			CStudent::PrintInfo();
			cout << "Department:" << department << endl;
		}
		void SetInfo(const string &name_, const string &id_, int age_; char gender_, const string &department_) {
			CStudent::SetInfo(name_, id_, age_, gender_);
			department = department_;
		}
	}
};
 

单继承/多重继承：

当类等级为树形结构时，类的继承是单继承；

当允许一个类有多个父类时，类的继承是多重继承。

多重继承的类可以组合多个父类的性质构成所需的性质，使用多重继承时要注意避免二义性。

代码重用：

继承是支持代码重用的重要机制之一，避免程序运行过程中效率上的浪费。

继承与派生：

例如A是基类，B是派生类（也称为子类）即类A“派生”出了类B，或者类B“继承”了类A。

多态

---

所谓多态就是指程序中  定义的引用变量所指向的具体类型  和  通过该引用变量发出的方法调用  在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。

多态性

在类等级的不同层次中可以共享（公用）一个行为（方法）的名字，然而不同层次中的每个类却各自按自己的需要来实现这个行为。

多态性机制不仅增加了面向对象软件系统的灵活性，进一步减少了信息冗余，而且显著提高了软件的可重用性和可扩展性。

实现方法1：通过基类指针实现多态

实现方法2：通过基类引用实现多态

// 多态.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include 
#include
using namespace std;
 
class A
{
public:
	virtual void Print() 
	{
		cout << "A::Print" << endl; 
	}
 
};
class B :public A
{
public:
	virtual void Print() { cout << "B::Print" << endl; }
};
 
 
void PrintInfo(A &r)
{
	r.Print();
	//多态，调用哪个Print，取决于r引用了哪个类的对象
}
 
int main()
{
    std::cout << "Hello World!\n";
	A a;
	B b;
	PrintInfo(a);
	PrintInfo(b);
	return 0;
}
 
// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单
 
// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件

重载

---

有两种重载：

函数重载  是指在同一作用域内的  若干个参数特征  不同的函数  可以使用相同的函数名字；

运算符重载  是指同一个运算符可以施加于不同类型的操作数上面（两个复数的+）。

重载进一步提高了面向对象的系统的灵活性和可读性。

// 重载.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
 
#include 
using namespace std;
 
class printData {
public:
	void print(int i) {
		cout << "整数为：" << i << endl;
	}
	void print(double f) {
		cout << "浮点数为：" << f << endl;
	}
	void print(char c[]) {
		cout << "字符串为：" << c << endl;
	}
};
 
int main(void) {
	printData pd;
	//输出整数
	pd.print(5);
	//输出浮点数
	pd.print(500.263);
	//输出字符串
	char c[] = "Hello C++";
	pd.print(c);
}
 
// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单
 
// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件

面向对象的程序设计有“抽象”、“封装”、“继承”、“多态”四个基本特点

---

抽象：将同一类事物的公共特点概述出来（属性和方法）

封装：通过某种语言形式，将数据（属性）和用以操作数据的算法捆绑在一起，即 类

继承：以基类为基础，”派生“出新类，达到代码扩充和代码重用的目的。

多态：不同种类的对象具有相同名称的行为，而具体实现的方式不同。