1、 本对象 子类对象 其他函数
private属性 可见 不可见 不可见
protected属性 可见 可见 不可见
public属性 可见 可见 可见
public extends protected extends private extends
父类的private属性 不能访问 不能访问 不能访问
父类的protected属性 变成protected 不变 变成private，子类可以访问，子类的子类不能访问
父类的public属性 不变 变成protected 变成private，子类可以访问，子类的子类不能访问
2、 构造函数有很多种，因为没有指定构造函数，就会默认使用无参的构造函数。如果父类没有无参的构造函数，那么就会出现编译错误。
可以使用这种形式Teacher(char* name, int age, double salary):Person(name,age){......}，指定使用父类的有参构造函数。
3、多态的特征：
父类的指针可以指向子类的对象
通过父类指针只能调用父类中声明的方法
通过指针调用函数的时候，若函数是个虚函数，表现出来的行为是对象自身的行为
4、产生多态：（1）指针
（2）引用
父类的引用可以引用一个子类对象
通过父类引用只能调用父类函数
调用一个父类被覆盖了的，虚函数，能调用子类的函数
5、一个子类继承一个父类 --- 单继承
一个子类继承多个父类 --- 多继承
class SpiderMan : public Spider , public Person{....}
6、菱形继承，解决重复元素的冲突
让两个父类同时虚继承一个超类，把多继承中的重复元素放在超父类中
当有多个子类同时虚继承一个父类的时候，只有一个子类真正的构造父类
class Spider : vertual public Animal{.....}; class Person : vertual public Animal{.....}; class SpiderMan :public Person , public Spider{....};
多继承尽量不要使用三层以上
7、抽象类
只有函数声明，没有函数实现
纯虚函数：没有实现的函数 virtual void writeLog(char*)=0;
若不写" =0 "，则系统会认为是函数声明，会试图去别的" .cc "文件中去找函数实现
含有纯虚函数的类称为抽象类，是抽象数据类型，不能创建对象
抽象类型就是为了被别人继承的，子类覆盖纯虚函数，提供函数实现
通过父类规范子类的用法
如果子类没有完全实现抽象父类的所有纯虚函数，则认为子类还是一个抽象数据类型
用到virtual的地方：
（1）继承
（2）多继承
（3）纯虚函数
抽象类的规范很重要，在工程中，对于项目的并行开发很重要
而且对于项目中的改动，能方便的应付
用指针指向相应的子类对象，方便的调用子类的函数
8、友员
针对类来说，自身的私有变量，不能被别的类访问，但是，如果授权给一个类为自己的友员，就可以访问他的私有属性
可以作为友员的东西：另一个类，一个全局函数。
实现友员的授权：
class Girl; class Person{ ........ friend class Girl; //友员类的声明-->授权给Girl类，成为自己的友员，可以访问自己的私有变量了 }
class Girl; class Person{ ........ friend void fn(); //友员函数的声明-->授权给fn函数，成为自己的友员，可以访问自己的私有变量了 }
友员不是类的一部分
若不是互为友员，则不能访问友员类的私有变量
友员的使用：
Bus把售票员作为自己的友员，访问自己的私有变量，即装载乘客的数组
友员在项目中的使用
9、静态数据
在类中定义一个静态数据 （实际上就是一种全局变量）
（1）不依赖于对象,在对象不存在之前就已经存在了
（2）所有对象共享
与全局变量的区别：
（1）使用的类中的静态变量，必须通过类名使用
（2）而且受访问控制符号的限制
（3）静态变量在类中声明的时候不能赋值，要在类外初始化
class A{ public : static int a; }; int A::a = 100; //此时才分配空间 int main(){ cout << A::a <<endl; //静态变量的用法，不依赖对象，直接使用 }
与成员变量的区别
（1）成员变量依赖与对象，类对象不存在，成员变量也不存在
静态变量不依赖于对象，只要有类声明，就存在
（2）所有对象共享一份静态变量
10、静态函数
在函数前加static
不依赖于对象，没有对象依然可以通过类名调用静态函数
A::fn();
在类声明的时候，静态函数和静态变量就存在了
静态函数只能使用静态变量，不能使用成员变量
11、拷贝构造函数
#include <iostream> using namespace std; class Person{ public: Person(){ cout<<"Person()"<<endl; } ~Person(){ cout<<"~Person() "<<endl;} void speak(){ cout<<"hello"<<endl; } }; void fn( Person p ){ //这里的传递时值传递，形参是值传递，这里的形参的创建是使用拷贝构造函数 p.speak(); } int main(){ Person p ; fn( p ) ; return 0 ; }
输出结果：
Person() hello ~Person() ~Person() //2次析构，因为其中调用了的系统提供的拷贝构造函数，构造出一个新对象
拷贝构造函数，以一个已存在的对象为模版创建一个新对象
声明方法： Person(const Person & p){...} //即节省空间，又保证模版不会被修改
默认拷贝构造函数，执行的就是简单的内存拷贝 --- 浅拷贝
（1）浅拷贝
只拷贝地址，而不是对指针指向空间的拷贝，会造成2个指针指向同一个空间
（2）深拷贝
为指针创建新空间，拷贝指针指向空间的内容
调用拷贝构造函数的时机：
（1）在值传递的时候
（2）A a; //默认构造函数
A a1 = a; //在声明的时候，用一个对象赋值，使用的是拷贝构造函数
（3）A a1;
A a2(a1); //显示的调用拷贝构造函数，传的参数是个对象
什么时候需要自己写拷贝构造函数？
使用了动态内存，就会面临浅拷贝的现象，需要自己写拷贝构造函数
12、运算符重载
a1 = a2;
系统调用了函数 operator=
相当于执行了这样的操作： a1.operator=(a2);
Student& operator= (const Student &a);
函数返回左值，返回值为引用
函数返回右值，返回值为本身
View Code
/* *student a1; *student a2; *a1=a2; <=> a1.operator=(a2); */ Student& operator= (const Student &a){ age = a.age; id = a.id; strcpy(name , a.name); //不用new出一块空间，因为在声明a1和a2的时候，两个指针都指向一块自己的空间， 把指针指向的变量拷贝过去，即完成赋值 return *this; }
当在堆中申请空间，则覆盖赋值运算符（" = "）
作业：银行系统的账户类
把name , password 改用指针保存
（1）析构函数
（2）拷贝构造
（3）重载赋值运算符