基本语法

继承是面向对象三大特性之一，有些类和类之间存在特殊关系。

下级别成员除了拥有上一级的共性还有自己的特点。

这个时候我们就可以考虑利用继承的技术，减少重复代码。

基本语法：class 子类：继承方式父类

子类也称为派生类，父类也称为基类。

，

派生类中的成员包含两大部分：

一类是从基类继承过来的，一类是自己增加的成员

#include<iostream>
#include<string>
using namespace std;
class basepage//公共页面类
{
public:
	void header()
	{
		cout << " 主页面 " << endl;
	}
};
class JAVA:public basepage//继承公共页面
{
public:
	void content()
	{
		cout << "java教学" << endl;
	}
};
void test01()
{
	JAVA ja;
	ja.content();
	ja.header();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

继承方式

基本语法：class 子类：继承方式父类

公共继承

保护继承

私有继承

protected和private都只有类内可以访问，但是区别在于，protected可以继承，private不能继承。

总结一下继承的级别：private>protected>public

继承中的对象模型

父类中所有静态成员属性都会被子类继承

父类中私有成员属性，是被编译器隐藏了，因此访问不到，但确实是被继承下去了。

这里学习一下使用开发人员命令提示符

继承中的构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数。

先构造父类，再构造子类

析构顺序一般与构造顺序相反

继承同名成员处理方式

当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

访问子类同名成员直接访问即可

访问父类同名成员需要加作用域

如果通过子类对象，访问到父类中的同名成员需要加作用域

#include<iostream>
#include<string>
using namespace std;
class base 
{
public:
	base()
	{
		m_a = 100;
	}
	int m_a;
};
class son :public base
{
public:
	son()
	{
		m_a = 200;
	}
	int m_a ;
};
int main()
{
	son s;
	cout<<s.m_a<<endl;//200
	cout << s.base::m_a << endl;//100
	system("pause");
	return 0;
}

如果通过子类对象，访问到父类中的同名函数需要加作用域

#include<iostream>
#include<string>
using namespace std;
class base 
{
public:
	void func()
	{
		cout << "调用base里的func函数" << endl;
	}
};
class son :public base
{
public:
	void func()
	{
		cout << "调用son里的func函数" << endl;
	}
};
int main()
{
	son s;
	s.func();
	s.base::func();
	system("pause");
	return 0;
}

如果子类中出现和父类同名的函数，编译器会隐藏掉父类中所有同名成员函数

如果想访问到父类中被隐藏的同名成员函数，要加作用域。

同名静态成员处理

静态成员和非静态成员出现同名，处理方式一致

不过有两种访问的方式（通过对象和通过类名）

#include<iostream>
#include<string>
using namespace std;
class base 
{
public:
	static int m_a;
};
int base::m_a = 100;//静态成员变量，类内声明，类外初始化
class son :public base
{
public:
	static int m_a;
};
int son::m_a = 200;

int main()
{
	//通过对象访问
	son s;
	cout << s.m_a << endl;//200
	cout << s.base::m_a << endl;//100

	//通过类名直接访问
	cout << base::m_a << endl;
	cout << son::m_a << endl;

	cout << son::base::m_a << endl;
	//第一个::代表要通过类名的方式来访问数据
	//第二个::代表要访问父类作用域下的m_a
	system("pause");
	return 0;
}

静态函数访问方式跟上面类似，不赘述。