1.封装：
封装是指将数据（属性）和行为（方法）捆绑在一起，形成一个对象，并通过公共接口来访问这个对象。封装的目的是保护对象的内部状态，防止外部直接访问和修改对象的数据，确保数据的完整性和程序的安全性。
封装的意义：
1.将属性和行为作为一个整体，表现在生活中的事物
2.将属性和行为加以权限控制
封装的意义一：
在设计类的时候，属性和行为写在一起，表现事物
语法：
class+类名+{访问权限：属性/行为}；
例如：设计一个圆类，求圆的周长
#include<iostream>
using namespace std;
class circle {
public://访问权限：共有的权限
int r;
double zhouchang() {
return 2 * 3.14 * r;
}
};
int main() {
circle c1;//通过圆类，创造圆的对象，c1是一个具体的圆
c1.r = 10;
cout << "周长为：" << c1.zhouchang() << endl;
return 0;
}封装意义二：
类在设计是，可以把属性和行为放在不同的权限下，加以控制
3种访问权限：
1.public 公有权限
2.protected 保护权限
3.private 私有权限
#pragma once
#include<iostream>
#include<vector>
#include<string>//c++中使用字符串使用的是string类
using namespace std;
class A {
int q;//私有成员：类的默认权限是私有的
public://共有权限：类内（类内的成员函数内访问），子类，对象访问（通过“.”访问）
int pub;
protected://受保护的：类内访问，子类访问
int pro;
private://私有的：只能在类内访问
int pri = 1;//类内可初始化
//pri=1;但不能赋值;
void fun() {//类内访问
pub = 1;
pro = 2;
pri = 3;
}
};
int main() {
A a;
//类外通过“.”访问。
a.pub = 3;
//a.pro=2;受保护成员只能在类内和子类中访问
//a.pri=1;私有成员只能在类内访问
}2.继承
继承是允许新的类（子类）继承一个现有类（父类）的属性和方法。继承促进了代码的复用和模块化，通过继承一个基类，子类可以继承基类（父类）的所有特性，同时还可以添加新的特性或者覆盖基类中的方法。
#include<iostream>
#include<unordered_map>
using namespace std;
class A //A父类、基类{
public:
int num;
void fun() {
cout << "A fun" << endl; }};//继承就是通过已经存在的类创建新的类
class B :public A //B子类、派生类{};
int main(){
B b;
b.num = 2;
b.fun();
return 0;
}继承的好处：
减少重复的代码
继承方式：priivate,protected,public
1.private
注意：
凡是基类（父类）中私有的，派生类都不可以访问（会继承下来，但不能访问）
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
class father{
private:
int pri;
protected:
int pro;
public:
int pub;
};
//以私有的方式继承父类，父类中的所有成员在子类中的权限都是私有的
class son : private father //son继承了类father，father中包含的 son中也包含
{
void fun() {
//pri = 1; 报错，因为 pri在father中是私有的所以不能再子类中访问
pro = 1;
pub = 1; }
};
//因为son以私有的方式继承了father，所以father中的成员在son中都是私有的，所以son的子类 grandson 不能访问 pro和pub
class grandSon :public son{
void fun(){
pro = 1;
pub = 1;
}
}2.protected
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
class father{
private:
int pri;
protected:
int pro;
public:
int pub;
};
//公有的方式继承father，pri仍然不可访问，pro仍然是受保护的，pub仍然是公有的
class son : public father //son继承了类father，father中包含的 son中也包含{
void fun(){
//pri = 1; 报错，因为 pri在father中是私有的所以不能再子类中访问
pro = 1; //pro在son中仍然是受保护的
pub = 1;//pub在son中是公有的
}
};
class grandson :public son{
void fun(){
//因为pro是受保护的所以可以在grandson中访问
//因为pub是公有的的所以可以在grandson中访问
pro = 1;
pub = 1;
}
};
int main(){
son s;
s.pro = 2;//因为pro和pub是受保护的所以不可以通过对象访问，会报错
s.pub = 2;//因为pub是公有的的所以可以通过对象访问
return 0；
}3.public
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
class father{
private:
int pri;
protected:
int pro;
public:
int pub;
};
//公有的方式继承father，pri仍然不可访问，pro仍然是受保护的，pub仍然是公有的
class son :
public father //son继承了类father，father中包含的 son中也包含{
void fun(){
//pri = 1; 报错，因为 pri在father中是私有的所以不能再子类中访问
pro = 1; //pro在son中仍然是受保护的
pub = 1;//pub在son中是公有的
}
};
class grandson :public son{
void fun(){
//因为pro是受保护的所以可以在grandson中访问
//因为pub是公有的的所以可以在grandson中访问
pro = 1;
pub = 1;
}
};
int main(){
son s;
//s.pro = 2;报错，因为pro和pub是受保护的所以不可以通过对象访问，会报错
s.pub = 2;//因为pub是公有的的所以可以通过对象访问
return 0;
}在继承中，先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反
在继承中，父类和子类共享同一个静态成员变量
3.多态：
多态性指的是同一个行为具有多个不同表现形式的特性。在面向对象编程中，多态性常用于实现接口或继承父类的对象，这样不同的子类对象就可以用相同的接口来调用其独特的方法。这使得程序设计更加灵活，可以对不同的数据类型进行统一处理。
多态的基本基本条件：有函数重写
函数重写：
子类重新定义父类中有相同名称，返回值和参数的虚函数，主要在继承关系中出现。重写的函数和被重写的函数必须都为virtual函数，并分别位于基类和派生类中，如果父类被重写的函数加了vritual，子类继承父类，那么子类重写的函数加不加vritual都是虚函数重写的函数和被重写的函数，返回值，函数名和函数参数必须完全一致；
#include<iostream>
using namespace std;
class father{
public:
virtual void fun(){
cout << "father" << endl;
}
};
class child:public father{
public:
virtual void fun(){
cout << "child" << endl；
}
};多态分为静态多态和动态多态
1.静态多态：
函数重载 和 运算符重载属于静态多态，复用函数名
2，动态多态：
派生类和虚函数实现运行时多态
二者区别：
静态多态的函数地址早绑定 ：编译阶段确定函数地址
动态多态的函数地址晚绑定 ：运行阶段确定函数地址
多态的基础： 需要有重写,子类重写父类的 返回值 名字 参数相同的虚函数，（只要父类的函数是虚函数即可）。
动态多态： 父类的指针或引用指向子类对象，并且通过该指针或引用调用子类重写的虚函数
多态的使用条件： 父类的指针或引用指向子类对象
#include<iostream>
#include<string>
#include<vector>
using namespace std;
class Animal{
public:
virtual void speak() {
cout << "anima speak" << endl;
}
void work(){
cout << "anima work" << endl;
}
};
class cat :public Animal{
public:
void speak(){
cout << "cat speak" << endl;
}
void work(){
cout << "cat work" << endl;
}
};
class dog :public Animal{
public:
void speak(){
cout << "dog speak" << endl;
}
void work(){
cout << "dog work" << endl;
}
};
int main() {
Animal *a = new dog;
//speak 是函数重写 ，work是函数隐藏
a->speak();//调用的是dog里的speak函数
a->work();//调用的函数是隐藏函数时，调用函数的指针或对象是什么类型调用哪里的函数，调用的是animal里的work函数
return 0;
}