目录
封装案例1：设计一个学生类，可以给姓名和学号赋值，可以显示学生的姓名和学号。
类和对象
面向对象编程（OOP）是现代编程的基石之一。C++是一种支持OOP的语言，允许你创建类（Class）和对象（Object）。
类和对象的概念
-
类是对对象的抽象。类是一种抽象的数据类型。它们的关系是，对象是类的实例，类是对象的模板。对象是通过new className产生的，用来调用类的方法;类的构造方法 。
-
类的意义:
2-1.类是把属性和方法进行封装，同时对类的属性和方法进行访问控制。
2-2.类是由我们根据客观事物抽象而成，形成一类事物，然后用类去定义对象，形成这类事物的具体个体。
2-3.类是一个数据类型，类是抽象的，而对象是一个具体的变量，是占用内存空间的。
-
类的访问控制
在C++中可以对类的属性和方法定义访问级别，public修饰的属性和方法，可以在类的内部访问，也可以在类的外部进行访问。private修饰的属性和方法，只能在类的内部进行访问。
-
行为
所有对象公有操作即成员函数（通常习惯为public属性）属性：所有对象公有特性即数据成员（通常习惯为protected属性）
C++面向对象的三大特性
C++面向对象的三大特性为：封装，继承，多态。
封装目的是实现代码模块化，继承目的是实现代码扩展，静态多态的目的是函数重载和泛型编程，动态多态的目的是虚函数重写。
C++认为万事皆为对象，对象上有其属性和行为
例如:
人可以作为对象，属性有姓名、年龄、身高、体重...，行为有走、跑、跳、吃饭、唱歌...
车也可以作为对象，属性有轮胎、方向盘、车灯...行为有载人、放音乐、放空调...
具有相同性质的对象，我们 可以抽象称为类，人属于人类，车属于车类
一、封装
封装是C++面向对象的三大特性之一，封装就是将数据和行为有机结合起来，形成一个整体。把数据和处理数据的操作结合形成类，数据和函数都是类的成员。
1.封装的意义：
- 将属性和行为作为一个整体，表现生活中的事务
- 将属性和行为加以权限控制
2.语法：
class 类名{访问权限：属性/行为}
示例：通过一个圆类中的行为得到圆的周长
cpp
#include<iostream>
#include<string>
using namespace std;
// 圆周率
const double PI = 3.14;
// 设计一个圆类 求圆的周长
// class（一个类） 类名
// class代表设计一个类，类后面紧跟着的就是类的名称
class circle {
// 访问权限
// 公共权限
public:
// 属性
// 半径
int r;
//行为：一般为函数
// 获取周长
double calculateZC()
{
return 2 * PI * r;
}
};
int main()
{
// 通过圆类创建具体的圆（对象）
// 实例化 ( 通过一个类 创建一个对象的过程 )
circle c1;
// 给圆对象 的属性进行赋值
c1.r = 10;
cout << "圆的周长：" << c1.calculateZC() << endl;
return 0;
}运行结果：
封装案例1：设计一个学生类，可以给姓名和学号赋值，可以显示学生的姓名和学号。
cpp
#include<iostream>
#include<string>
using namespace std;
// 设计一个学生类，属性有姓名和学号
// 可以给姓名和学号赋值，可以显示学生的姓名和学号
// 设计学生类
class student {
public: // 公共权限
// 类中的属性和行为 我们统一称为 成员
// 属性 成员属性 成员变量
// 行为 成员函数 成员方法
// 属性
string name;
int id;
// 行为
// 显示姓名与学号
void showstu()
{
cout << "姓名: " << name << " 学号: " << id << endl;
}
// 可以通过对象的行为给属性赋值
void setname(string i_name)
{
name = i_name;
}
void setID(int i_id)
{
id=i_id;
}
};
int main()
{
// 创建一个具体的学生
// 实例化对象
class student s1;
// 给s1属性赋值
s1.setname("张三");
s1.id = 01;
s1.showstu();
class student s2;
// 给s2属性赋值
s2.name = "李四";
s2.id = 02;
s2.showstu();
class student s3;
// 通过对象的行为给属性赋值
s3.setname("王五");
s3.setID(03);
s3.showstu();
return 0;
}运行结果：
二、访问权限
类在设计时，可以把属性和行为放在不同的权限下，加以控制。
访问权限有三种
-
public 公共权限 成员 类内类外都可以访问
-
protected 保护权限 成员 类内可以访问，类外不可以访问（有继承关系，父子关系）
-
private 私有权限 成员 类内可以访问，类外不可以访问（父子关系也不可以访问）
示例：
cpp
#include<iostream>
using namespace std;
class person{
public:
// 公共权限
string name;
protected:
// 保护权限
string car;
private:
// 私有权限
int password;
public:
void fun()
{
name = "张三";
car = "BMW";
password = 123456;
}
// 不管哪种形式在类内都是可以访问的
};
int main ()
{
// 实例化具体的对象
class person p1;
p1.name = "李四";
p1.car = "AMG"; // 保护权限的内容在类外是不能访问的
p1.password = 258258; // 私有权限的内容在类外是不能访问的
return 0;
}
报错显示：
struct和class的区别
在c++中struct和class唯一的区别就在于默认的访问权限不同
区别：
struct 默认是公共权限
class 默认是私有权限
示例：
cpp
#include<iostream>
using namespace std;
class C1
{
int m_A;// 默认权限 是私有
};
struct C2
{
int m_A;// 默认权限 是公共
};
int main ()
{
class C1 c1;
c1.m_A=1000;
struct C2 c2;
c2.m_A=100;
return 0;
}
报错显示：
三、成员属性私有化
成员属性私有化的优点：
-
将所有成员属性设置为私有，可以自己控制读写权限
-
对于写权限，可以检测数据的有效性
示例：
cpp
#include<iostream>
#include<string>
using namespace std;
// 设计一个人类
class person{
// 设计一个public 的公共接口
public:
// 设置姓名
void set_name(string in_name)
{
name = in_name;
}
// 获取姓名
string get_name()
{
return name;
}
// 设置年龄
void set_age(int in_age)
{
if(in_age<=0||in_age>150){
cout<<"你输入的年龄有误!"<<endl;
return;
}
age=in_age;
}
// 获取年龄
int get_age()
{
return age;
}
// 设置情人，只写
void set_lover(string in_lover)
{
lover = in_lover;
}
private:
// 姓名 可读可写
string name;
// 年龄 可读可写
int age = 0;
// 情人 只写
string lover;
};
int main()
{
class person p1;
p1.set_name("张三");
cout<<"姓名为: "<<p1.person::get_name()<<endl;
p1.set_age(200);
cout<<"年龄为: "<<p1.person::get_age()<<endl;
p1.set_lover("鞠婧祎");
return 0;
}运行结果：
四、封装案例
案例1：设计立方体类
设计立方体类（Cube）
求出立方体的面积和体积
分别用全局函数和成员函数判断两个立方体是否相等。
示例：
cpp
#include<iostream>
#include<string>
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+m_W*m_H+m_L*m_H);
}
// 获取立方体的体积
int calculateV()
{
return m_L*m_H*m_W;
}
// 利用成员函数判断两个立方体是否相等
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_W;// 宽
int m_H;// 高
};
// 利用全局函数判断 两个立方体是否相等
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()
{
// 创建一个立方体对象
class Cube C1;
C1.setL(10);
C1.setW(10);
C1.setH(10);
cout<<"C1的面积为："<<C1.calculateS()<<endl;
cout<<"C1的体积为："<<C1.calculateV()<<endl;
// 创建第二个立方体
class Cube C2;
C2.setL(10);
C2.setW(20);
C2.setH(10);
// 全局函数判断
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;
}
return 0;
}运行结果：
案例2：点和圆的关系
设计一个圆形类（Circle），和一个点类（Point），计算点和圆的关系。
示例：
cpp
#include<iostream>
#include<string>
#include<cmath>
using namespace std;
// 判断点和圆的关系
/*
点到圆心的距离== 半径 点在圆上
点到圆心的距离 > 半径 点在圆外
点到圆心的距离 < 半径 点在圆内
*/
class Point
{
public:
void setX(int X)
{
m_X=X;
}
int getX()
{
return m_X;
}
void setY(int Y)
{
m_Y=Y;
}
int getY()
{
return m_Y;
}
private:
int m_X;
int m_Y;
};
class Circle
{
public:
// 设置半径
void setR(int R)
{
m_R=R;
}
int getR()
{
return m_R;
}
// 设置圆心
void setCenter(Point center)
{
m_Center=center;
}
Point getCenter()
{
return m_Center;
}
private:
int m_R; // 半径
class Point m_Center;
};
// 判断点和圆的关系
void isInCircle(Circle &c,Point &p)
{
// 计算两点间距离
int distance=pow((pow(c.getCenter().getX()-p.getX(),2))+(pow(c.getCenter().getY()- p.getY(),2)),0.5);
if(distance==c.getR()){
cout<<"点在圆上"<<endl;
}else if(distance > c.getR()){
cout<<"点在圆外"<<endl;
}else{
cout<<"点在圆内"<<endl;
}
}
int main()
{
// 创建一个圆 和一个圆心 的对象
Circle c;
c.setR(10);
Point center;
center.setX(10);
center.setY(0);
c.setCenter(center);
// 创建一个点
Point P;
P.setX(10);
P.setY(9);
// 全局函数判断点和圆的位置关系
isInCircle(c,P);
return 0;
}运行结果：
