【C++ 基础知识】封装、继承、多态

面向对象三大特性：封装、继承、多态

封装：

定义

class 类名
{
成员属性、成员变量
成员方法
}

//设计类和类名
class circle
{
   //属性（变量）
   int radiu;
   //行为（函数）
   double calculate()
   {
       return 2*radiu;
   }
   //通过行为给属性赋值
   void setshow(int banjing)
   {
      radiu=banjing;
   }
}
int main(){
  //实例化：通过一个类创建一个对象
  circle c1;
  //给对象的属性赋值
  c1.mr=10;
  c1.setshow(5);
  cout<<c1.calculate()<<endl;
  return 0;
}

访问权限

1. 公共权限 public: 类内、类外都可以访问
2. 保护权限 protected：类内可以访问，类外不可以访问；
   子代可以访问父代中的保护内容
3. 私有权限 private：类内可以访问，类外不可以访问；
   子代不可以访问父代的私有内容

class 和 struct 区别：
struct 默认权限为公共public
class 默认权限为私有private

成员属性私有化

1.可以自己控制读写权限
2.对于写入权限可以检测数据有效性

class person
{
   public:
   void setname(string name)//写入数据
   {
      i_name = name;
   }
   string getname()//读取数据,并可以判断成员属性有效性
   {
      return i_name;
   }
   int getage()//读取数据,并可以判断成员属性有效性
   {
     // i_age=0;//初始化
      return i_age;
   }
   void setlover(string lover)//写入数据
   {
      
   }
   private:
   string i_name;//名字可读可写
   int i_age;//年龄可读
   string i_lover;//爱人可写
}

总结

1. 定义类
2. 成员属性私有化private
3. 为成员属性赋值public，设置void set,获取int get()
4. 成员函数进行操作

---

对象特性

构造函数和析构函数

构造函数：初始化 ； 析构函数：清理

构造函数：类名（）{}
1.没有返回值，不用写void
2.函数名与类名相同
3.可以有参数，可以发生函数重载
4.每次创建对象自动调用，且只调用一次
5.不写的话编辑器自动空实现

析构函数：~类名（）{}

class Person
{publlic:
   //构造函数进行初始化
   Person()
   {
      cout<<"Person构造函数调用"<<endl;
   }
   //析构函数进行清理
   ~Person()
   {
      cout<<"Person析构函数调用"<<endl;
   }
}
void test01()
{
   Person p;
}
int main()
{
   
}

拷贝构造函数

Person(const Person &p)
{
   age = p.a;
}

静态成员

---

继承：

减少重复代码

定义

语法： class 子类 ：继承方式 父类
（子类——派生类，父类——基类）
派生类包括：基类继承+新增成员

//公共页面
class Base
{
   public:
   
}
//继承
class java : public Base
{
   public:
   void content(){}
}

父类
public: int A;
protected: int B;
private: int C;
子类;
public继承：A——public；B——protected；
protected继承：A——protected；B——protected；
private继承：A——private；B——private；

p.s.父类中所有的非静态成员属性都会被子类继承，但父类中的私有成员属性会被编辑器隐藏，但是字节大小里确实继承了
——利用开发人员命令提示工具查看对象模型

同名成员处理

子类父类有成员同名，直接访问，得到的是子类数据；加作用域，可以得到父类数据 s.Base::fuction()

class Base
{
 public:
   int A;
   void B(){};
   static int C;
   static void func()
   {
      cout<<"Base_func()"<<endl;
   }
}
class son
{
   public:
   int A;
   void B(){};
   static int C;
   static void func()
   {
      cout<<"Base_func()"<<endl;
   }
}
int main()
{
   son s1:public Base
   //访问子类成员
   s1.A;
   s1.B();
   s1.C;//静态成员通过对象访问
   s1.func();
   son::C;//静态成员通过类名访问
   son::func();
   //访问父类成员
   s1.Base::A;
   s1.Base::B();
   s1.Base::C;//静态成员通过对象访问
   s1.Base::func();
   son::Base::C;//静态成员通过类名访问
   son::Base::func();
}

多继承语法

class son : public Base1 : public Base2
{
}

继承中先构造父类，再构造子类，析构顺序相反

---

多态

提示：这里统计学习计划的总量
静态多态：函数地址早绑定——编译阶段确定函数地址
动态多态：函数地址晚绑定——运行阶段确定函数地址

• 满足条件：

1.有继承关系
2.子类重写父类虚函数

• 使用：

父类的指针 / 引用指向子类对象，发生多态

class Animal
{
 public:
 virtual void speak()
 {
    //cout<<"动物在说话"<<endl;
 }
}
class Cat : public Animal
{
 public:
 void speak()
 {
    cout<<"小猫在说话"<<endl;
 }
}
void Dospeak(Animal & animal)
{
   animal.speak();
}
void test01()
{
   Cat cat;
   Dospeak(cat);
   
}

纯虚函数和抽象类

virtual 返回值类型 函数名 （参数列表）=0；

virtual void func()=0;

1.只要有一个纯虚函数，抽象类无法实例化对象，该类为抽象类；
2.子类必须重写父类的纯虚函数，否则也是抽象类；

class constructing
{
public:
   virtual void boil()=0;
   virtual void brew()=0;
   virtual void pour()=0;
   virtual void putsth()=0;
   void makedrink()
   {
      boil();
      brew();
      pour();
      putsth();
   }
}
class coffee : public constructing
{
public:
   virtual void boil()
   {
      cout<<"烧水"<<endl;
   }
   virtual void brew()
   {
      cout<<"冲泡咖啡"<<endl;
   }
   virtual void pour()
   {
      cout<<"倒水"<<endl;
   }
   virtual void putsth()
   {
      cout<<"冲泡咖啡"<<endl;
   }
}
void dowork(constructing *abs)
{
   abs->makedrink();
   delete abs;
}
void test01()
{
   dowork(new coffe);
   cout<<"制作咖啡"<<endl;
}

---