一、类与类的关系
has-A，uses-A 和 is-A
has-A ：包含关系，用以描述一个类由多个“部件类”构成。实现has-A关系用类成员表示，即一个类中的数据成员是另一种已经定义的类。
uses-A ： 一个类部分地使用另一个类。通过类之间成员函数的相互联系，定义友员或对象参数传递实现。
is-A ： 机制称为“继承”。关系具有传递性,不具有对称性。
二、继承的基本语法
#include<iostream>
using namespace std;
class Parent
{
public:
void print()
{
a = 0;
b = 0;
cout<<"a: "<<a<<endl;
cout<<"b: "<<b<<endl;
}
int a;
int b;
protected:
private:
//int a;如果改成这样报错
};
//class Child : private Parent
//class Child : protected Parent
class Child : public Parent
{
public:
int c;
protected:
private:
};
int main()
{
Child c1;
c1.c = 1;
c1.a = 2;
c1.b = 3;
c1.print();
system("pause");
return 0;
}三、单个类的访问控制---共有继承
#include<iostream>
using namespace std;
//public 关键字修饰的成员变量、方法 在类的内部外部够可以使用
//protected 修饰的成员变量、方法,在类的内部使用，在继承的子类中使用
//private 修饰的成员变量、方法，只能在类的内部使用
class Parent
{
public:
int a;
protected:
int b;
private:
int c;
public:
void printT()
{
cout<<"printT"<<endl;
}
};
class Child : public Parent
{
public:
void useVar()
{
a = 0;//ok 变量a 在基类中属性是共有的，在派生类继承后也是共有的public
b = 0;//变量b 在基类中属性是保护的，在派生类继承后也是保护的，言外之意就是在类的内部可以使用
//c = 0;// c私有的 派生类不能访问
}
protected:
private:
};
int main()
{
Parent t1,t2;
t1.a = 10;//OK public 之后还是public
/*
t1.b = 20;//Error public继承之后还是private 继承还是private,只能在类的内部使用，不能在类的外部使用
t2.c = 30;//私有的更不能用
*/
system("pause");
return 0;
}
#include<iostream>
using namespace std;
//public 关键字修饰的成员变量、方法 在类的内部外部够可以使用
//protected 修饰的成员变量、方法,在类的内部使用，在继承的子类中使用
//private 修饰的成员变量、方法，只能在类的内部使用
class Parent
{
public:
int a;//不恰当的比喻： 共有的相当于 老爹的名字--“老王”
protected:
int b;//老爹的银行密码---即不对外（public）公开，也不对内（protect）公开
private:
int c;//相当于老爹的情人
public:
void printT()
{
cout<<"printT"<<endl;
}
};
/*
“三看”原则
C++中的继承方式（public、private、protected）会影响子类的对外访问属性
判断某一句话，能否被访问
1）看调用语句，这句话写在子类的内部、外部
2）看子类如何从父类继承（public、private、protected）
3）看父类中的访问级别（public、private、protected）
*/
/*
C++中的继承方式会影响子类的对外访问属性
public继承：父类成员在子类中保持原有访问级别
private继承：父类成员在子类中变为private成员
protected继承：父类中public成员会变成protected
父类中protected成员仍然为protected
父类中private成员仍然为private
*/
class Child2 : private Parent
{
public:
void useVar()
{
//子类继承老爹的名字 ---小王---可以使用“王”这个姓氏
a = 0;//OK 1：写在了子类的内部；2：子类从父类public继承；3：仍然为public
//假如小王变成了老王，老王变成了太上王，太上王有一天“挂了”，这个太上王肯定会把银行密码给小王，继承遗产 可以使用
b = 0;//OK 1：写在了子类的内部；2：子类从父类protect继承；3：仍然为protect 在子类的内部可以用，外部不可以用
//小王在名义上继承了这个“老爹的情人”--但是他如果想使用这个属性---不妥
// c = 0;//Error 1：写在了子类的内部；2：子类从父类private继承；3：仍然为private 不能访问
//父类当中私有的属性和方法，子类当中都不可以使用，但是它是继承的
}
protected:
private:
};
int main()
{
Child2 c2;
//c1.a = 10;Error
//c2.b = 20;Error
//c3.c = 10;Error
system("pause");
return 0;
}五、单个类的访问控制--保护继承
#include<iostream>
using namespace std;
//public 关键字修饰的成员变量、方法 在类的内部外部够可以使用
//protected 修饰的成员变量、方法,在类的内部使用，在继承的子类中使用
//private 修饰的成员变量、方法，只能在类的内部使用
//protect 关键字 修饰的成员变量 和成员函数 是为了在家族中使用 是为了继承
//派生类类成员访问级别设置的原则
//思考：如何恰当的使用public，protected和private为成员声明访问级别？
//1、需要被外界访问的成员直接设置为public
//2、只能在当前类中访问的成员设置为private
//3、只能在当前类和子类中访问的成员设置为protected，protected成员的访问权限介于public和private之间。
class Parent
{
public:
int a;
protected:
int b;
private:
int c;
public:
void printT()
{
cout<<"printT"<<endl;
}
};
class Child3 : protected Parent
{
public:
void useVar()
{
a = 0;//protected
b = 0;//protected
c = 0;//private---Error
}
protected:
private:
};
int main()
{
Parent c3;
c3.a = 10;
/*
c3.b = 20;//Error
c3.c = 30//Error
*/
system("pause");
return 0;
}