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

男娘i 2024-04-08 09:20 75阅读 0赞

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

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

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

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

public interface InterfaceTest {
        
    
        void test(String testStr);
    
    }

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

public class TestClass extends AbstractTest implements InterfaceTest {
        
    
        public static void main(String[] args) {
        
            TestClass testClass = new TestClass();
            testClass.test("我调用了谁？");
        }
    }

执行main方法，程序运行结果如下:  
![在这里插入图片描述][dafb51a1ac444b6a8aa73716409a29d9.png_pic_center]

从程序运行结果来看，我们的**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("我调用了谁？");
        }
    }

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

![在这里插入图片描述][c6a85c03867a4fe696f9446395c3da0d.png_pic_center]

结论: 当子类重写**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);
    
    }

接口**InterfaceTest**如下:

public interface InterfaceTest {
    
        void test(String testStr);
    
        void testMethod(String str);
    
    }

由于抽象类中的抽象方法以及接口中的方法必须要重写，所以子类需要重写**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?");
        }
    }

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

![在这里插入图片描述][ada0dddb4cb14a68afe69aae310f0d77.png_pic_center]

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

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

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

[dafb51a1ac444b6a8aa73716409a29d9.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/ef2f709814f14606b23448d7d2f94a0d.png
[c6a85c03867a4fe696f9446395c3da0d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/240493a501634899a566891b95e0faf8.png
[ada0dddb4cb14a68afe69aae310f0d77.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/c2a573b858b045948ee4d81553bbe2fb.png