04-子类一定要重写接口中定义的方法吗？

Java摒弃了C++中的多重继承，只支持单继承，但是可以通过接口实现“多继承”的效果。如果一个非抽象子类继承了一个抽象类的同时又实现了某个接口，赶巧的是这个抽象类包含的非抽象方法与接口中的方法相同，那么当子类使用该方法时会发生什么？先来看看第一个例子:

定义一个抽象类AbstractTest,包含一个非抽象方法test返回值类型为void,参数类型为String,如下:

public abstract class AbstractTest {

    public void test(String testStr){
        System.out.println(testStr + ":Abstract 非抽象方法被调用");
    }

}
1
2
3
4
5
6
7

定义一个接口InterfaceTest,接口中定义test返回值类型为void,方法参数类型String,与上面的抽象类中的方法相同，如下:

public interface InterfaceTest {

    void test(String testStr);

}
1
2
3
4
5

定义一个子类TestClass,继承抽象类AbstractTest实现接口InterfaceTest,且不重写test方法先来看一下，如下:

public class TestClass extends AbstractTest implements InterfaceTest {

    public static void main(String[] args) {
        TestClass testClass = new TestClass();
        testClass.test("我调用了谁？");
    }
}
1
2
3
4
5
6
7

执行main方法，程序运行结果如下:

从程序运行结果来看，我们的TestClass 可以不声明接口中的方法而且可以调用test方法,具体执行为抽象类AbstractTest中的test方法，
结论: 在抽象类中的非抽象方法与接口中的方法相同时，继承该抽象类以及实现该接口的子类可以不声明接口中的方法，具体调用的为抽象中的方法。这正体现了Java中的“类优先”法则。

那么当子类重写test方法时，又会怎样？

下面将TestClass稍作改造，重写test方法，如下:

public class TestClass extends AbstractTest implements InterfaceTest {

    @Override
    public void test(String str){
        System.out.println(str +"子类重写的test方法被调用");
    }

    public static void main(String[] args) {
        TestClass testClass = new TestClass();
        testClass.test("我调用了谁？");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

再次执行main方法,程序运营结果如下:

结论: 当子类重写test方法后，不管是抽象类中非抽象方法还是接口中的方法，当子类重写时,具体调用为子类重写后的方法，这样其实保证了Java的向后兼容以及高扩展性，体现了Java中的多态理念。

在对我们的例子进行一下改造，在抽象类AbstractTest中添加抽象方法testMethod 以及在接口中添加相同方法，如下:

抽象类AbstractTest如下:

public abstract class AbstractTest {

    public void test(String testStr){
        System.out.println(testStr + ":Abstract 非抽象方法被调用");
    }

    public abstract void testMethod(String str);

}
1
2
3
4
5
6
7
8
9

接口InterfaceTest如下:

public interface InterfaceTest {

    void test(String testStr);

    void testMethod(String str);

}
1
2
3
4
5
6
7

由于抽象类中的抽象方法以及接口中的方法必须要重写，所以子类需要重写testMethod方法，如下:

public class TestClass extends AbstractTest implements InterfaceTest {

    @Override
    public void test(String str){
        System.out.println(str +"子类重写的test方法被调用");
    }

    @Override
    public void testMethod(String str) {
        System.out.println(str + "抽象类的抽象方法和接口方法必须重写");
    }

    public static void main(String[] args) {
        TestClass testClass = new TestClass();
        testClass.test("我调用了谁？");
        testClass.testMethod("Hello?");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

执行main方法，程序运行结果如下:

结论: 当抽象类中的抽象方法与接口中的方法相同时，子类必须重写该方法，体现Java中的抽象类与接口的特点。

综合上面的例子可以看到接口是比抽象类更加抽象的一种形式，当抽象类中的非抽象方法与接口中的相同时，子类可以不显示实现该方法，但具体调用一定是重写了该方法，只不过在这种特殊的情况下，子类继承了抽象类中的方法用以实现。
ava中的抽象类与接口的特点。

综合上面的例子可以看到接口是比抽象类更加抽象的一种形式，当抽象类中的非抽象方法与接口中的相同时，子类可以不显示实现该方法，但具体调用一定是重写了该方法，只不过在这种特殊的情况下，子类继承了抽象类中的方法用以实现。