类的封装

川长思鸟来 2022-12-26 09:11 173阅读 0赞

一、类。  
1、C++面向对象的三大特性？  
封装、继承、多态。

2、C++认为万事万物皆为对象，对象上有其属性与行为。  
例如：  
人可以作为对象，属性有姓名、年龄、身高、体重...，行为有走、跑、跳。吃饭、唱歌..。  
车也可以作为对象，属性有轮胎、方向盘。车灯...，行为有载人、放音乐、放空调...。  
具有相同性质的对象，我们可以抽象成为类，人属于人类，车属于车类。

二、封装。  
1、封装的意义。  
封装是C++面向对象的三大特性之一。  
其意义是：  
1）将属性和行为作为一个整体，表现生活中的事物。  
2）将属性与行为加以权限控制。

2、封装意义一。  
在设计类的时候，属性与行为写在一起，表现事物。  
语法：  
class 类名\{  
访问权限:  
属性/行为  
\};

案例1 --- 设计一个圆类，求圆的周长。

\#include <iostream>  
using namespace std;

//圆周率  
const double PI = 3.14;

//设计一个圆类，求圆的周长。  
//圆求周长公式: 2\*PI\*半径

/\*  
语法：  
class 类名\{  
访问权限:  
属性/行为  
\};  
\*/

class Circle\{  
public: //访问权限： 公共权限  
//属性  
//半径  
int m\_r;

//行为  
//获取圆的周长  
double calculateZC()  
\{  
return 2 \* PI \* m\_r;  
\}  
\};

int main()  
\{  
//通过圆类，创建具体的圆(对象)  
//1. 实例化(通过一个类，创建一个对象的过程)  
Circle c1;

//2. 给圆对象的属性进行赋值  
c1.m\_r = 10;

//3. 对象通过调用类中的行为来求出周长。  
//2\*PI\*10=62.8  
cout << "圆的周长:" << c1.calculateZC() << endl;

return 0;  
\}

练习1：设计一个学生类，属性有姓名与学号，行为可以给姓名和学号赋值，可以显示学生的姓名和学号。

\#include <iostream>  
using namespace std;

//设计一个学生类  
class Student\{  
public:  
//类中的属性与行为，我们统一成为成员。  
//属性： 成员属性 / 成员变量  
//行为： 成员函数 / 成员方法

//属性  
//属性有姓名与学号  
string m\_Name; //姓名  
int m\_Id; //学号

//行为  
//显示姓名与学号  
void showStudent()  
\{  
cout << "姓名: " << m\_Name << " 学号: " << m\_Id << endl;  
\}

//给姓名赋值  
void setName(string name)  
\{  
m\_Name = name;  
\}

//给学号赋值  
void setId(int id)  
\{  
m\_Id = id;  
\}  
\};

int main()  
\{  
//通过学生类，创建具体的学生。  
Student s1;

//给s1的对象进行属性赋值操作  
s1.setName("张三");  
s1.setId(1);

//显示学生的信息  
s1.showStudent();

//再创建一个学生  
Student s2;  
s2.m\_Name = "李四";  
s2.m\_Id = 2;

s2.showStudent();

return 0;  
\}

3、封装意义二。  
类在设计时候，可以把属性和行为放在不同的权限下，加以控制。  
访问权限有三种：  
1）public 公共权限 类内可以访问，类外可以访问。  
2）protected 保护权限 类内可以访问，类外不可以访问。 儿子可以访问父亲中的保护内容。  
3）private 私有权限 类内可以访问，类外不可以访问。 儿子不可以访问父亲中的私有内容。

\#include <iostream>  
using namespace std;

/\*  
访问权限有三种：  
1）public 公共权限 类内可以访问，类外可以访问。  
2）protected 保护权限 类内可以访问，类外不可以访问。  
3）private 私有权限 类内可以访问，类外不可以访问。  
\*/

class Person\{  
public:  
//公共权限  
string m\_Name; //姓名

protected:  
//保护权限  
string m\_Car; //汽车

private:  
//私有权限  
int m\_Password; //银行卡密码

public:  
void func()  
\{  
m\_Name = "张三"; //公共权限属性类内访问  
m\_Car = "拖拉机"; //保护权限属性类内访问  
m\_Password = 123456; //私有权限属性类内访问  
\}  
\};

int main()  
\{  
//实例化对象  
Person p1;  
p1.m\_Name = "李四"; //公共权限属性类外访问  
//p1.m\_Car = "奔驰"; //保护权限属性类外访问 -> 不可访问  
//p1.m\_Password = 123; //私有权限属性类外访问 -> 不可访问

p1.func();

return 0;  
\}

三、struct和class的区别？  
在C++中struct和class唯一的区别就是在于默认的访问权限不同。  
区别：  
struct 默认权限为公共。  
class 默认权限为私有。

\#include <iostream>  
using namespace std;

/\*  
struct 默认权限为公共。  
class 默认权限为私有。  
\*/

class C1\{  
int m\_A; //默认的权限就是私有权限。  
\};

struct C2\{  
int m\_A; //默认的权限就是公共权限。  
\};

int main()  
\{  
//C1 c1;  
//c1.m\_A = 10; // error: ‘int C1::m\_A’ is private  
// 类默认的属性就是私有的。

C2 c2;  
c2.m\_A = 100; //默认的权限就是公共权限，在类外可以访问。

return 0;  
\}

四、成员属性设置为私有。  
优点1：将所有成员属性设置为私有，可以自己控制读写权限。  
优点2：对于读写权限，我们可以检测数据的有效性。

\#include <iostream>  
using namespace std;

/\*  
优点1：将所有成员属性设置为私有，可以自己控制读写权限。  
优点2：对于读写权限，我们可以检测数据的有效性。  
\*/

//设计人类  
class Person\{  
public:  
//设置姓名  
void setName(string name)  
\{  
m\_Name = name;  
\}

//获取姓名  
string getName()  
\{  
return m\_Name;  
\}

//设置年龄  
void setAge(int age)  
\{  
if(age < 0 || age > 150)  
\{  
cout << "年龄有问题喔!" << endl;  
return;  
\}  
m\_Age = age;  
\}

//获取年龄  
int getAge()  
\{  
//m\_Age = 0;  
return m\_Age;  
\}

//设置情人  
void setLover(string lover)  
\{  
m\_Lover = lover;  
\}

private:  
//姓名: 可读可写  
string m\_Name;

//年龄: 可读可写  
int m\_Age;

//情人: 只写  
string m\_Lover;  
\};

int main()  
\{  
Person p1;  
//p1.m\_Name = "张三"; //写姓名  
p1.setName("张三");

//cout << "姓名:" << p1.m\_Name << endl;  
cout << "姓名: " << p1.getName() << endl;

p1.setAge(18);  
cout << "年龄: " << p1.getAge() << endl;

p1.setLover("关国源");

//无论用哪种办法，都无法访问到情人是谁。  
//cout << "情人: " << p1.m\_Lover << endl;  
//cout << "情人: " << p1.getLover() << endl;  
\}  
  
案例2： 设计立方体类。

设计立方体类(Cube)  
求出立方体的面积以及体积。  
分别使用全局函数与成员函数判断两个立方体是否相等？  
（判断两个立方体相等的条件是长等于长，宽等于宽，高等于高）

思路分析：  
class Cube\{  
public:  
//行为：  
//设置和获取长宽高  
//获取立方体的面积。  
//获取立方体的体积。

private:  
//属性：  
m\_L; -> 长  
m\_H; -> 高  
m\_W; -> 宽  
\};

\#include <iostream>  
using namespace std;

//立方体设计  
//1. 创建立方体类  
//2. 设置属性  
//3. 设置行为 获取立方体的面积以及体积  
//4. 分别使用全局函数和成员函数 判断两个立方体是否相等

class Cube\{  
public:  
//设置长  
void setL(int l)  
\{  
m\_L = l;  
\}

//获取长  
int getL()  
\{  
return m\_L;  
\}

//设置宽  
void setW(int w)  
\{  
m\_W = w;  
\}

//获取宽  
int getW()  
\{  
return m\_W;  
\}

//设置高  
void setH(int h)  
\{  
m\_H = h;  
\}

//获取高  
int getH()  
\{  
return m\_H;  
\}

//获取立方体的面积  
int calculateS()  
\{  
return 2\*m\_L\*m\_W + 2\*m\_L\*m\_H + 2\*m\_W\*m\_H;  
\}

//获取立方体的体积  
int calculateV()  
\{  
return m\_L \* m\_W \* m\_H;  
\}

//利用成员函数来判断两个立方体是否相等  
bool isSameByClass(Cube &c)  
\{  
if(m\_L == c.getL() && m\_W == c.getW() && m\_H == c.getH())  
\{  
return true;  
\}  
return false;  
\}

private:  
int m\_L; //长  
int m\_H; //高  
int m\_W; //宽  
\};

//使用全局函数来判断两个立方体是否相等  
bool isSame(Cube &c1,Cube &c2)  
\{  
if(c1.getL() == c2.getL() && c1.getW() == c2.getW() && c1.getH() == c2.getH())  
\{  
return true;  
\}

return false;  
\}

int main()  
\{  
//创建立方体对象  
Cube c1;  
c1.setL(10);  
c1.setW(10);  
c1.setH(10);

cout << "c1的面积为:" << c1.calculateS() << endl;  
cout << "c1的体积为:" << c1.calculateV() << endl;

Cube c2;  
c2.setL(10);  
c2.setW(10);  
c2.setH(9);

bool ret = isSame(c1,c2);  
if(ret)  
\{  
cout << "c1与c2是相等的" << endl;  
\}  
else\{  
cout << "c1与c2是不相等的" << endl;  
\}

ret = c1.isSameByClass(c2);  
if(ret)  
\{  
cout << "c1与c2是相等的" << endl;  
\}  
else\{  
cout << "c1与c2是不相等的" << endl;  
\}  
\}