继承（Extends）常见面试题

我们都知道，使用继承可以实现代码的重用。通过继承，子类可以继承父类的成员变量及成员方法，同时还可以定义自己的成员变量和成员方法。所以，通过继承，子类将具有父类的成员及本类的成员——Java语言不支持多重继承，即：一个类只能继承一个父类，但一个父类可以有多个子类。

public class Father{
    Cell[] cells;
    public Father() {
        cells = new Cell[4];
    }
    public void drop() ;
    public void moveLeft() ;
    public void moveRight() ;
    public void print() ;
}

public class Son extends Father{
    public Son(int row, int col) {
        cells[0] = new Cell(row, col);
        cells[1] = new Cell(row, col + 1);
        cells[2] = new Cell(row, col + 2);
        cells[3] = new Cell(row + 1, col + 1); 
    }
}

代码说明：声明父类Father，放置公共信息，声明无参构造函数，对成员变量Cell数组进行实例化。声明子类Son继承Father，并声明有参构造函数，传递行row，列col参数。
然后在main方法中，声明一个T型对象，即可以实现T型对象的构建：

Son t   =  new  Son( 1 , 1)；

创建子类对象时，调用了子类的有参构造函数进行数据的初始化，那么，父类Father的无参构造函数执行了吗？(这个对于理解继承特别重要)
——查询知：父类的无参构造函数被执行了。

在程序中并没有声明父类的构造函数，那它是如何执行的呢？
——父类的无参构造方法之所以被执行，是因为java规定，子类在构造之前必须先构造父类。

并且事实上，子类的构造方法中是必须要通过super关键字来调用父类的构造方法的，这样才可以保证妥善的初始化继承自父类的成员变量。

上一个案例中，代码并没有super调用父类构造方法，是因为，如果子类的构造方法中没有调用父类的构造方法，则java编译器会自动的加入对父类无参构造方法的调用。请看如下代码，演示了super关键字的用法：

public Son(int row, int col) {
super ( ) ;  
    cells[0] = new Cell(row, col);
    cells[1] = new Cell(row, col + 1);
    ……    
}  

上面的代码中，super();为编译器自动加入的，需要注意的是----super关键字必须位于子类构造方法的第一行，否则会有编译错误。

另外一点需要注意的是，若父类没有提供无参的构造方法，则会出现编译错误。

结论：若在子类构造方法中没有写super调用父类构造方法，那么编译器会默认添加super()来调用父类的无参构造方法，但是若是父类中没有定义无参的构造方法，那就会发生编译错误。

解决方案：
(1)在父类中添加无参的构造方法
(2)在子类构造方法中显示调用父类的有参构造方法（推荐）

super关键字作用总结：
1：主要存在于子类方法中，用于指向子类对象中父类对象。
2：访问父类的属性
3：访问父类的函数
4：访问父类的构造函数
this和super====this指向的是当前对象的调用，super指向的是当前调用对象的父类。类加载完毕，创建对象，父类的构造方法会被调用（默认自动无参），然后执行子类相应构造创建了一个子类对象，该子类对象还包含了一个父类对象。该父类对象在子类对象内部。this和super只能在有对象的前提下使用，不能在静态上下文使用。

二、继承的意义(重写)
在java语言中，子类可以重写（覆盖）继承自父类的方法，即方法名和参数列表与父类的方法相同，但是方法的实现不同。

当子类重写了父类的方法后，该重写方法被调用时（无论是通过子类的引用调用还是通过父类的引用调用），运行的都是子类重写后的版本。看如下代码：

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

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

class Test{
    public static void main(String[] args){
        Goo obj1 = new Goo();
        obj1.f();
        Foo obj2 = new Goo();
        obj2.f();
    }
}

输出结果：均为“Goo.f()”，因为都是Goo的对象，所以无论是子类的引用还是父类的引用，最终运行的都是子类重写后的版本。那么，如何使用父类版本呢？
------在子类重写的方法中，可以通过super关键字调用父类的版本，参见如下：

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

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

class Test{
    public static void main(String[] args){
        Foo obj2 = new Goo();
        obj2.f();
    }
}

输出结果：Foo.f() Goo.f()。
super.f()即可以调用父类Foo的f()方法，这样的语法通常用于子类的重写方法在父类方法的基础之上进行的功能扩展。

继承的父子关系：

• 子类拥有父类的所有属性和行为
• 子类就是一种特殊的父类
• 子类对象可以当做父类对象使用
• 子类中可以添加父类没有的方法和属性