C++第七节:继承

继    承

1、子类与父类

     1.1 子类自动继承父类所有成员（包括成员函数、成员变量），除了构造函数、析构函数和重载的赋值运算符。

     1.2 子类在用父类所有功能的同时，也扩展了一些新的功能。即子类成员分为两部分，继承自父类的部分和子类独有的成员即子类自己扩展的成员。

     1.3 子类也拥有父类的私有成员，但子类不能通过自己扩展的函数来访问继承自父类的私有成员，而必须通过继承自父类的公有成员函数来访问。

     1.4 在子类中调用被覆盖的父类版本的函数时，在函数名前加Base：：。

     1.5 面向对象最重要的目标：实现代码复用。通过继承子类自动拥有了父类代码，大大减少了代码书写量，十分方便维护程序（只需修改父类代码，子类就自动随着更改）

2、覆盖与重载

     2.1 子类可以自己实现与父类成员函数原型相同（函数名、函数列表）的成员函数，称为覆盖，覆盖是函数重载的特例，覆盖一定发生在继承的过程中。

     2.2 发生覆盖时，根据调用者对象本身的类型来确定，无法根据参数列表确定。

     2.3 ------

    //1.重写必须继承，重载不用。

    //2.重写的方法名，参数数目相同，参数类型兼容，重载的方法名相同，参数列表不同。

    //3.重写的方法修饰符大于等于父类的方法，重载和修饰符无关。

    //4.重写不可以抛出父类没有抛出的一般异常，可以抛出运行时异常

    //重写是子类的方法覆盖父类的方法，要求方法名和参数都相同

    //重载是在同一个类中的两个或两个以上的方法，拥有相同的方法名，但是参数却不相同，方法体也不相同

    一、重写（override）

    override是重写（覆盖）了一个方法，以实现不同的功能。一般是用于子类在继承父类时，重写（重新实现）父类中的方法。

    重写（覆盖）的规则：

    1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载.

    2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符（public>protected>default>private）。

    3、重写的方法的返回值必须和被重写的方法的返回一致；

    4、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类；

    5、被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没s有对其进行重写。

    6、静态方法不能被重写为非静态的方法（会编译出错）。

    二、overload是重载，一般是用于在一个类内实现若干重载的方法，这些方法的名称相同而参数形式不同。

    重载的规则：

    1、在使用重载时只能通过相同的方法名、不同的参数列表实现。不同的参数列表可以是不同的参数类型，不同的参数个数，不同的参数顺序（参数类型必须不一样）；

    2、不能通过访问权限、返回类型、抛出的异常进行重载；

    3、方法的异常类型和数目不会对重载造成影响；

    多态的概念比较复杂，有多种意义的多态，一个有趣但不严谨的说法是：继承是子类使用父类的方法，而多态则是父类使用子类的方法。

    一般，我们使用多态是为了避免在父类里大量重载引起代码臃肿且难于维护。

    

    重定义(隐藏)是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

    a 如果派生类的函数和基类的函数同名，但是参数不同，此时，不管有无virtual，基类的函数被隐藏。

    b 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有vitual关键字，此时，基类的函数被隐藏。

    

    重载和重写的区别：

    （1）范围区别：重写和被重写的函数在不同的类中，必须是继承，重载和被重载的函数在同一类中。

    （2）参数区别：重写与被重写的函数参数列表一定相同，重载和被重载的函数参数列表一定不同。

    （3）virtual的区别：重写的基类必须要有virtual修饰，重载函数和被重载函数可以被virtual修饰，也可以没有。

3、访问修饰符

     3.1 ------

public:
 1、修饰class里的成员，这些成员可以在class的内部被访问，也可以在外部被访问。
 2、公有成员可以被继承。
 3、当一个class作为父类被继承时，可以用public来修饰。如下：
 class Child : public Father
 {   };
 此时，父类中的public和protected成员都可以被子类继承，并且修饰符与父类一样。
 
 protected:
 1、修饰class里的成员，这些成员可以在class的内部被访问，也可以被友元类和友元方法访问，不可以在外部被访问。
 2、保护型成员可以被继承。
 3、当一个class作为父类被继承时，可以用protected来修饰。如下：
 class Child : protected Father
 {   };
 此时，父类中的public和protected成员都可以被子类继承，并且修饰符都是protected。
 
 private:
 1、修饰class里的成员，这些成员只可以在class的内部被访问。
 2、私有成员可以被继承，但不能被子类访问。
 3、当一个class作为父类被继承时，可以用private来修饰。如下：
 class Child : private Father
 {   };

 此时，父类中的public和protected成员都可以被子类继承，并且修饰符都是private。

A、简单继承类

Base.h

#ifndef __C__No803Class__Base__
#define __C__No803Class__Base__

#include <iostream>
using namespace std;
class Base
{
private:
    int bnumber;
public:
    Base (int n);
    int getNumber();
    void print ();
};
#endif /* defined(__C__No803Class__Base__) */

Base.cpp

#include "Base.h"
Base::Base (int n) : bnumber(n) {}

int Base::getNumber()
{
    return bnumber;
}
void Base::print ()
{
    cout << "bnumber is " << bnumber << endl;
}

Derived.h

#ifndef __C__No803Class__Derived__
#define __C__No803Class__Derived__

#include <iostream>
#include "Base.h"
//using namespace std;
class Derived : public Base
{
private:
    int dnumber;
public:
    Derived (int i, int j);
    void print();
};
#endif /* defined(__C__No803Class__Derived__) */

Derived.cpp

#include "Derived.h"
Derived::Derived (int i, int j):Base(i)
{
    dnumber = j;
}
void Derived::print()
{
    cout << "bnumber is " << getNumber() << " ";  //与下面等价
    Base::print();
    //cout << bnumber << endl;  //子类不能直接访问父类的私有成员变量
    cout << "dnumber is " << dnumber << endl;
    //OOP三大特性：继承，多态，封装
}

main.cpp

#include <iostream>
#include "Derived.h"
int main(int argc, const char * argv[])
{
    Base a(2);
    a.print();
    
    Derived b (3, 4);
    b.print();
    
    cout << "Base part of b " ;
    b.Base::print();
    
    return 0;
}

B、简单探究访问修饰符

Father.h

#ifndef __C__No803Class__Father__
#define __C__No803Class__Father__

#include <iostream>
using namespace std;
class Father
{
public:
    int i;
private:
    int j;
protected:
    int k;
public:
    Father(int ii, int jj, int kk);
    int getI();
    int getJ();
    int getK();
    void print();
};
#endif /* defined(__C__No803Class__Father__) */

Father.cpp

#include "Father.h"
Father::Father(int ii, int jj, int kk)
{
    i = ii;
    j = jj;
    k = kk;
}
int Father::getI()
{
    return i;
}
int Father::getJ()
{
    return j;
}
int Father::getK()
{
    return k;
}
void Father::print()
{
    cout << "i = " << i << " ";
    cout << "j = " << j << " ";
    cout << "k = " << k << endl;
}

Son.h

#ifndef __C__No803Class__Son__
#define __C__No803Class__Son__

#include <iostream>
#include "Father.h"
class Son : private Father
{
public:
    int a;
private:
    int b;
protected:
    int c;
public:
    Son(int ii, int jj, int kk, int aa, int bb, int cc);
    void print();
};
#endif /* defined(__C__No803Class__Son__) */

Son.cpp

#include "Son.h"
Son::Son(int ii, int jj, int kk, int aa, int bb, int cc):Father(ii, jj, kk)
{
    a = aa;
    b = bb;
    c = cc;
}
void Son::print()
{
    Father::print();
    cout << "i = " << i << " ";
    //cout << "j = " << j << " ";  //public,protected,private下，私有成员变量子类无法访问
    cout << "k = " << k << endl;
    cout << getI() << getJ() << getK() <<endl;
    cout << "a = " << a << " ";
    cout << "b = " << b << " ";
    cout << "c = " << c << endl;
}

main.cpp

#include "Son.h"
int main ()
{
    Father t(1, 2, 3);
    t.print();
    Son s(0, 9, 8, 7, 6, 5);
    //s.Father::print();  //protect，private下，该语句编译不通过
    s.print();
    
    return 0;
}