C++面向对象的程序设计9——类的继承

1、类的继承UML图的表示方法

从子类【派生的类】指向父类【被继承的类】，父类，也称为“基类”

除了“构造函数”和“析构函数”，

父类的所有成员函数，以及数据成员，都会被子类继承！

2、派生和继承的实现

Father.h
#pragma once
#include <string>

using namespace std;

class Father
{
public:
	Father(char *, int);
	char *getName() const;
	int getAge() const;
	string description() const;
	~Father();
private:
	char *name;
	int age;
};


Father.cpp
#include "Father.h"
#include <sstream>


Father::Father(char *name, int age)
{
	this->name = name;
	this->age = age;
}

char *Father::getName() const
{
	return this->name;
}

int Father::getAge() const
{
	return this->age;
}

string Father::description() const
{
	stringstream ret;
	ret << "姓名：" << this->name << " 年龄：" << this->age;
	return ret.str();
}

Father::~Father()
{

}

Son.h
#pragma once
#include "Father.h"
class Son: public Father  // 采用公有继承的方式继承
/*
公有继承的特点：
    原来的public数据成员和成员函数到子类中还是public数据成员和成员函数
    原来的protected数据成员和成员函数到子类中还是protected数据成员和成员函数
    原来的private数据成员和成员函数到子类中还是private数据成员和成员函数
*/
{
public:
	Son(char *, int, char *);
	char *getGame() const;
	string description() const;
	~Son();
private:
	char *game;
};


Son.cpp
#include "Son.h"
#include <sstream>


Son::Son(char *name, int age, char *game):Father(name, age)
{
	this->game = game;
}

char *Son::getGame() const
{
	return this->game;
}

// 当子类和父类都有相同的方法名时，先访问子类的方法
string Son::description() const 
{
	stringstream ret;
	// 使用public继承之后，父亲类的私有数据成员在子类中无法被访问，因此只能调用父类的公有方法来进行访问
	ret << "姓名：" << this->getName() << " 年龄：" << this->getAge() << " 爱好：" << this->game;
	return ret.str();
}
Son::~Son()
{
}

main.cpp

#include "Father.h"
#include "Son.h"
#include <iostream>
#include <Windows.h>

int main()
{
	Father zhangsan("张三", 52);
	Son lisi("李四", 22, "王者荣耀");
	cout << zhangsan.description() << endl;
	cout << lisi.description() << endl;
	system("pause");
	return 0;
}

如果想要子类可以访问父类的数据成员，可以将父类的属性变成protected类型。

子类, 一般会添加自己的数据成员/成员函数, 或者, 重新定义从父类继承的方法!!! 子类对象就会调用自己重新定义的方法, 不会调用父类的同名方法。

3、3种访问权限总结

public

    外部可以直接访问.

可以通过对象 来访问这个成员

Fahter  wjl("王健林", 65); 

wjl.getName();

private

    外部不可以访问

自己的成员函数内, 可以访问

Fahter  wjl("王健林", 65);

wjl.name; // 错误!!!

Father内的所有成员函数内, 可以直接访问name

protected

    protected和private非常相似

和private的唯一区别:

   protecte: 子类的成员函数中可以直接访问

   private:  子类的成员函数中不可以访问

4、派生和继承的各种方式

public（公有）继承 [使用最频繁]

父类中定义的成员（数据成员和函数成员）被继承后，访问权限不变！              

public     -->  public             

protected  -->  protected          

private    -->  private            

private（私有）继承

父类中定义的成员（数据成员和函数成员）被继承后，访问权限都变成private 

public    -->  private             

protected -->  private          

private   -->  private      

protected（保护）继承

public     -->  protected        

protected  -->  protected        

private    -->  private

小结：

public 继承全不变

private继承全变私

protected继承只把public降级为protected

5、什么时候使用继承和派生

1）准备实现多个类，但是这些类在现实世界中有某种特殊关系（比如：类别与子类别的关系）

例如：人  女人   男人

如果完全独立的实现这3个类，将有很多重复代码，而且不利于以后的维护。

2）准备构建一个类，但是这个类与已经开发好的某个类非常相似，而且在现实世界中具有某种特殊关系（比如：类别与子类别的关系）。

如果全部重新写这个新类，效率较低，因为有很多东西已经在这个已有的类中实现了。

实例：某卫星监控平台的ODU和ODU232

ODU

class  ODU232 : public ODU

3）对多个已经实现的类（这些类有某种特殊关系），进行重构。

一般在前两种情况使用，第3种（重构）是不得而为之。