Java 接口

原文： https://javabeginnerstutorial.com/core-java-tutorial/java-interface/

定义合同意味着创建接口。 该合同规定了一个类可以做什么而不必强制它应​​该怎么做。 在本 Java 接口教程中，我们将讨论接口。 如何创建一个和应用于接口的规则。

声明接口

可以使用interface关键字定义接口。 在 Java 8 之后，接口定义发生了很多变化。

Java 接口示例

  1. public interface MyInterface
  2. {
  3. int i=0;
  4. public void Height(int height);
  5. public abstract void setHeight();
  7. }

Java 8 接口示例

  1. package com.jbt;
  3. public interface Interface_JAVA8 {
  5.     public void method();
  7.     public abstract void method1();
  9.     public default void method2() {
  10.     }
  12.     public static void method3() {
  13.     }
  14. }

Java 8 引入了默认方法的概念。 现在，如果接口不是抽象的，则可以包含方法主体。 接口内部的方法可以包含“抽象”，“静态”或“默认”修饰符。

Java 9 接口私有方法

在 Java 9 中，允许在接口中使用私有方法。

接口声明规则

接口需要遵循一些规则。

  • 所有接口方法都是隐式公开抽象的。 即使您使用关键字，也不会产生问题，如第二个方法声明中所见。 （在 Java 8 之前）
  • 接口只能声明常量。 实例变量是不允许的。 这意味着接口内的所有变量必须是公开的，静态的，最终的。 接口内的变量是隐式公开静态最终的。
  • 接口方法不能为静态。 （在 Java 8 之前）
  • 接口方法不能是final，strictfp或native。
  • 该接口可以扩展一个或多个其他接口。 注意：该接口只能扩展另一个接口。

接口声明规则（JAVA 8）

接口逻辑在 Java 8 中已更改。因此，上述某些逻辑不适用于 Java 8 之后的接口。

  • 所有接口方法都可以具有abstract，static或默认修饰符。
  • 如果对方法使用static或default修饰符，则接口方法可以具有主体。

接口与抽象类

接口就像100% 抽象类一样。 接口不能具有非抽象方法，而抽象类则可以。 一个类可以实现多个接口，而只能扩展一个类。 由于抽象类属于类的层次结构，因此它们可以扩展其他类，而接口只能扩展接口。

在类中使用接口

用 Java 创建接口后如何利用接口？ 为了利用我们需要利用给定的接口实现我们的类。 Implement关键字可用于此目的。

类实现接口的示例

示例 1：

  1. public class InterfaceExampleOne implements interfaceOne {
  3. }
  5. interface interfaceOne {
  7. }

示例 2：

  1. /*
  2.  * As implmeneted Interface have any abstract method so this class
  3.  * need to implement any method.
  4.  */
  5. class InterfaceExampleTwo implements interfaceTwo {
  7.     @Override
  8.     public void methhod() {
  9.         System.out.println(var);
  10.     }
  12. }
  14. /*
  15.  * Below interface has an abstract method so implemented class needs to
  16.  * implement this method unless and untill it is abstract itself
  17.  */
  18. interface interfaceTwo {
  19.     public final int var = 9;
  21.     public abstract void methhod();
  22. }

示例 3：

  1. /*
  2.  * As below class is not abstract class and it is extending abstract class which
  3.  * has not yet implemented the method from interface so this class is FORCED to
  4.  * implement method from Interface in hierarachy(interfaceTwo).
  5.  */
  6. class InterfaceExampleTwo extends InterfaceExampleThree {
  8.     @Override
  9.     public void methhod() {
  10.         System.out.println(var);
  11.     }
  13. }
  15. /*
  16.  * Below interface has an abstract method so implemented class needs to
  17.  * implement this method unless and untill it is abstract itself
  18.  */
  19. interface interfaceTwo {
  20.     public final int var = 9;
  22.     public abstract void methhod();
  23. }
  25. /*
  26.  * Even if Interface has abstract method ABSTRACT CLASS is not forced to
  27.  * implement it. Abstract class may/may not navigate this responsibility of
  28.  * implementing abstract method to class which is not abstract.
  29.  */
  30. abstract class InterfaceExampleThree implements interfaceTwo {
  32. // Method from Interface is not implemented here
  34. }

重点

  • 接口是 100% 抽象类（隐式）。 在 Java 8 之后，它不成立。
  • 接口可以由任何继承树中的任何类实现。
  • 接口中的所有方法都是抽象的。 （在 Java 8 中为abstract/static/默认）
  • 接口可以具有常量，这些常量是公开的，静态的和最终的（隐式）。
  • 接口方法是隐式公开和抽象的。 （在 Java 8 之前）
  • 接口也可以具有私有方法。 （Java 9）
  • 实现接口的类也可以是抽象类。
  • 实现接口的抽象类不必实现所有抽象方法。
  • 一个类可以实现多个接口。
  • 接口不能扩展类或实现接口。
  • 一个接口可以扩展另一个接口。
  • 实现接口的非抽象类需要遵循一些规则。
    1. 此类需要提供所有抽象方法的具体实现。
    2. 必须遵守所有覆盖规则。
    3. 它必须维护方法的确切签名。
  • 在 Java 9 更改之后，接口看上去很像抽象类，但是还是有一些区别。
    • 抽象类可以具有带有不同修饰符的变量，这些修饰符不是常数
    • 抽象类中的方法可以具有不同于私有或公开签名的签名