Java 8中的默认方法-yiteyi-C++库

在Java8之前，接口只能有抽象方法。这些方法的实现必须在单独的类中提供。因此，如果要在接口中添加新方法，则必须在实现同一接口的类中提供其实现代码。为了克服这个问题，Java8引入了默认方法的概念，它允许接口具有带有实现的方法，而不影响实现接口的类。

null

                     // A simple program to Test Interface default                   
                     // methods in java                   
                     interface                               TestInterface                   
                     {                   
                                         // abstract method                   
                                         public                               void                               square(                               int                               a);                   
                             
                                         // default method                   
                                         default                               void                               show()                   
                                         {                   
                                         System.out.println(                               "Default Method Executed"                               );                   
                                         }                   
                     }                   
                             
                     class                               TestClass                               implements                               TestInterface                   
                     {                   
                                         // implementation of square abstract method                   
                                         public                               void                               square(                               int                               a)                   
                                         {                   
                                         System.out.println(a*a);                   
                                         }                   
                             
                                         public                               static                               void                               main(String args[])                   
                                         {                   
                                         TestClass d =                               new                               TestClass();                   
                                         d.square(                               4                               );                   
                             
                                         // default method executed                   
                                         d.show();                   
                                         }                   
                     }                   

输出：

 16
 Default Method Executed

引入默认方法是为了提供向后兼容性，以便现有接口可以使用lambda表达式，而无需在实现类中实现方法。默认方法也称为 防守方法 或 虚拟扩展方法 .

静态方法： 接口也可以有静态方法，这类似于类的静态方法。

                     // A simple Java program to TestClassnstrate static                   
                     // methods in java                   
                     interface                               TestInterface                   
                     {                   
                                         // abstract method                   
                                         public                               void                               square (                               int                               a);                   
                             
                                         // static method                   
                                         static                               void                               show()                   
                                         {                   
                                         System.out.println(                               "Static Method Executed"                               );                   
                                         }                   
                     }                   
                             
                     class                               TestClass                               implements                               TestInterface                   
                     {                   
                                         // Implementation of square abstract method                   
                                         public                               void                               square (                               int                               a)                   
                                         {                   
                                         System.out.println(a*a);                   
                                         }                   
                             
                                         public                               static                               void                               main(String args[])                   
                                         {                   
                                         TestClass d =                               new                               TestClass();                   
                                         d.square(                               4                               );                   
                             
                                         // Static method executed                   
                                         TestInterface.show();                   
                                         }                   
                     }                   

输出：

 16
 Static Method Executed

默认方法和多重继承 如果两个实现的接口都包含具有相同方法签名的默认方法，那么实现类应该明确指定要使用的默认方法，或者应该重写默认方法。

                     // A simple Java program to demonstrate multiple                   
                     // inheritance through default methods.                   
                     interface                               TestInterface1                   
                     {                   
                                         // default method                   
                                         default                               void                               show()                   
                                         {                   
                                         System.out.println(                               "Default TestInterface1"                               );                   
                                         }                   
                     }                   
                             
                     interface                               TestInterface2                   
                     {                   
                                         // Default method                   
                                         default                               void                               show()                   
                                         {                   
                                         System.out.println(                               "Default TestInterface2"                               );                   
                                         }                   
                     }                   
                             
                     // Implementation class code                   
                     class                               TestClass                               implements                               TestInterface1, TestInterface2                   
                     {                   
                                         // Overriding default show method                   
                                         public                               void                               show()                   
                                         {                   
                                         // use super keyword to call the show                   
                                         // method of TestInterface1 interface                   
                                         TestInterface1.                               super                               .show();                   
                             
                                         // use super keyword to call the show                   
                                         // method of TestInterface2 interface                   
                                         TestInterface2.                               super                               .show();                   
                                         }                   
                             
                                         public                               static                               void                               main(String args[])                   
                                         {                   
                                         TestClass d =                               new                               TestClass();                   
                                         d.show();                   
                                         }                   
                     }                   

输出：

Default TestInterface1
Default TestInterface2

要点：

接口可以有默认方法，并在以后的Java 8中实现。
接口也可以有静态方法，类似于类中的静态方法。
引入默认方法是为了为旧接口提供向后兼容性，这样它们就可以在不影响现有代码的情况下拥有新方法。

本文由 阿卡什奥哈 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用贡献极客。组织或者把你的文章寄到contribute@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Java