面向对象三大特征之继承详解

面向对象三大特征：

1. 继承
2. 多态
3. 封装

一、继承

先从代码层次理解

class Student{    String name;    int age;    String adress;    String calssName;    void eat(){}    void sleep(){}    void study(){}}

class Teacher{    String name;    int age;    String address;    int salary;    void eat(){}    void sleep(){}    void teach(){}}

class Doctor{    String name;    int age;    String address;    String level;    void eat(){}    void sleep(){}    void cut(){}}

可以清晰地看到三个类中有公共的属性，可以通过继承来避免重复。

父类中包含所有子类共有的属性和方法；
子类中包含所特有的属性和方法；

创建一个父类-Person,让三个类都继承Person

class Person{    String name;    int age;    String address;    void eat(){}    void sleep(){}}

以下改写的类统称为子类

class Student extends Person{    String className;    void study(){}}

class Teacher extends Person{    int salary;    void teach(){}}

class Doctor extends Person{    String level;    void cut(){}}

子类可以访问父类的成员变量和方法，但是通常情况下，父类不可以访问子类的成员变量和方法。
不能跨子类访问属性和方法/各属性之间是相互独立的，即使它们共同继承了一个父类。

extends关键字：

• 通过extends关键字可以实现类的继承
• 子类（Sub class）可以继承父类（Super class）的成员变量及成员方法，同时也可以定义自己的成员变量和成员变量；
• * Java语言不支持多重继承，一个类只能继承一个父类，但是一个父类可以有多个子类。*

继承中的构造方法

·子类的构造方法中必须通过super关键字调用父类的构造方法，这样可以妥善的初始化继承自父类的成员变量。
·如果子类的构造方法中没有调用父类的构造方法，Java编译器会自动的加入对父类无参构造器方法的调用
注：如果该父类没有无参的构造方法，编译器会报错。
注：super关键字必须位于子类构造方法的第一行

父类的引用指向子类的对象

一个子类的对象可以向上造型（转型）为父类的类型。即，定义父类型的引用可以指向子类的对象。
强调：父类的引用可以指定子类的对象，但通过父类的引用只能访问父类定义的成员，不能访问子类拓展的部分。

Person p = new Student(); //编译通过Student S = new Person(); //编译不通过

重写

· 子类可以重写（覆盖）继承自父类的方法，即方法名和参数列表与父类的方法相同；但方法的实现不同。
· 当子类对象的重写方法被调用时（无论是通过子类的引用还是通过父类的引用调用），运行的是子类重写后版本。

class Foo {    public void f(){        System.out.println("Foo.f()");    }}

class Goo extends Foo{    public void f(){        System.out.println("Goo.f()");    }}

Goo obj1 = new Goo();obj1.f();Foo obj2 = new Goo();obj2.f();/**    输出结果均为“Goo.f()”    验证了当子类对象的重写方法被调用时（无论是通过子类的引用还是通过父类的引用调用），运行的是子类重写后版本。**/

子类在重写父类的方法时，可以通过super关键字调用父类的版本。

此类问题常见的面试题：
1、重写（override）和重载（overload）的区别

重载和重写是完全不同的语法现象
重载是指在一个类中定义多个方法名相同但参数列表不同的方法，在编译时，根据参数的个数和类型决定绑定哪个方法；重载遵循所谓“编译器绑定”，即在编译时根据参数变量的类型判断应该调用哪个方法。
重写是指在子类中定义和父类完全相同的方法，在程序运行时，根据对象的类型不同（而不是引用类型，是指new后边的对象）而调用不同的版本；重写遵循所谓“运行时绑定”，即在运行的时候根据引用变量指向的实际对象类型调用方法。