了解Java接口

    本文将借助示例学习如何实现接口以及何时使用它们。
    接口是一个完全抽象的类，它包含一组没有主体的方法。在Java中，接口定义了其他类必须实现的一组规范。例如：

interface Language {
   public void getName();
}

    这里，我们使用interface关键字创建一个名为Language的接口。Language接口定义了一个getName()规范。
    现在，每个使用此接口的类都应实现该getName()规范。
    示例：Java接口

// create an interface
interface Language {
  void getName(String name);
}

// class implements interface
class ProgrammingLanguage implements Language {

  // implementation of abstract method
  public void getName(String name) {
    System.out.println("Programming Language: " + name);
  }
}

class Main {
  public static void main(String[] args) {
    ProgrammingLanguage language = new ProgrammingLanguage();
    language.getName("Java");
  }
}

    输出：

Programming Language: Java

    在上面的示例中，我们创建了一个名为Language的接口。该接口包括一个抽象方法getName()。
    在这里ProgrammingLanguage类实现接口并提供内部方法的实现。
    在接口内声明抽象方法时，并不强制使用abstract关键字。这是因为接口只包含抽象方法而不是常规方法。
    注意：接口内的所有方法都是隐式的public，所有字段都是隐式的public static final。例如：

interface Language {
  
  // by default public static final
  String type = "programming language";

  // by default public
  void getName();
}

1. 实现接口

    像抽象类一样，我们不能创建接口的对象。但是，我们可以实现一个接口。
    我们使用implements关键字来实现一个接口。例如：

// create an interface
interface Polygon {
  void getArea(int length, int breadth);
}

// implement the Polygon interface
class Rectangle implements Polygon {

  // implementation of abstract method
  public void getArea(int length, int breadth) {
    System.out.println("The area of the rectangle is " + (length * breadth));
  }
}

class Main {
  public static void main(String[] args) {
    // create an object
    Rectangle r1 = new Rectangle();
    r1.getArea(5, 6);
  }
}

    输出：

The area of the rectangle is 30

    在上面的示例中，我们创建了一个名为Polygon的接口。该接口包含一个抽象方法getArea()。这里，Rectangle类实现了Polygon，并且，提供了getArea()方法的实现。
    注意：一个类可以实现多个接口。例如：

interface A {
  // members of A
}

interface B {
  // members of B
}

class C implements A, B {
  // abstract members of A
  // abstract members of B
}

2. 扩展接口

    与类相似，接口可以扩展其他接口。extends关键字用于扩展接口。例如：

interface Line {
  // members of Line interface
}

// extending interface
interface Polygon extends Line {
  // members of Polygon interface
  // members of Line interface
}

    在这里，Polygon接口扩展了Line接口。现在，如果任何类实现Polygon，它应该为Line和Polygon的所有抽象方法提供实现。
    注意：一个接口可以扩展多个接口。例如：

interface A {
   ...
}
interface B {
   ... 
}

interface C extends A, B {
   ...
}

3. Java接口的优点

    现在我们已经知道了接口是什么了，让我们了解一下为什么在Java中使用接口。

• 接口提供类（实现它）必须遵循的规范。
  在前面的示例中，我们使用getArea()作为Polygon接口内部的规范。这就像设置了一个规则，我们应该能够得到每个Polygon的面积。
  现在，任何实现Polygon接口的类都必须为getArea()方法提供一个实现。
• 与抽象类相似，接口帮助我们在Java中实现抽象。
  在这里，我们知道getArea()计算多边形的面积，但是对于不同的多边形，计算面积的方式是不同的。因此，getArea()的实现是相互独立的。
• 接口还用于在Java中实现多重继承。例如：

interface Line {
...
}

interface Polygon {
...
}

class Rectangle implements Line, Polygon {
...
}

    在这里，Rectangle类实现了两个不同的接口。这就是我们在Java中实现多重继承的方法。

4. Java接口中的默认方法

    随着Java 8的发布，我们现在可以在接口内部添加具有实现的方法。这些方法称为默认方法。
    要在接口内部声明默认方法，我们使用default关键字。例如：

public default void getSides() {
   // body of getSides()
}

4.1 为什么使用默认方法？

    让我们以一个场景来理解为什么Java中引入了默认方法。
    假设我们需要在接口中添加一个新方法。
    我们可以很容易地在接口中添加方法，而无需实现。然而，这并不是故事的结尾。实现该接口的所有类都必须实现该方法。
    如果有大量的类实现这个接口，我们需要跟踪所有这些类并对它们进行更改。这不仅乏味而且容易出错。
    为了解决这个问题，Java引入了默认方法。默认方法和普通方法一样是继承的。
    让我们举一个例子来更好地理解默认方法。

4.2 示例：Java接口中的默认方法

interface Polygon {
  void getArea();

  // default method 
  default void getSides() {
    System.out.println("I can get sides of a polygon.");
  }
}

// implements the interface
class Rectangle implements Polygon {
  public void getArea() {
    int length = 6;
    int breadth = 5;
    int area = length * breadth;
    System.out.println("The area of the rectangle is " + area);
  }

  // overrides the getSides()
  public void getSides() {
    System.out.println("I have 4 sides.");
  }
}

// implements the interface
class Square implements Polygon {
  public void getArea() {
    int length = 5;
    int area = length * length;
    System.out.println("The area of the square is " + area);
  }
}

class Main {
  public static void main(String[] args) {

    // create an object of Rectangle
    Rectangle r1 = new Rectangle();
    r1.getArea();
    r1.getSides();

    // create an object of Square
    Square s1 = new Square();
    s1.getArea();
    s1.getSides();
  }
}

    输出：

The area of the rectangle is 30
I have 4 sides.
The area of the square is 25
I can get sides of a polygon.

    在上面的示例中，我们创建了一个名为Polygon的接口。它具有默认方法getSides()和抽象方法getArea()。
    这里，我们创建了Rectangle和Square两个类来实现Polygon。
    Rectangle类提供getArea()方法的实现并重写getSides()方法。但是，Square类仅提供getArea()方法的实现。
    现在，当Rectangle对象调用getSides()方法时，调用重写的方法。但是，对于Square对象，将调用默认方法。

5. 接口中的私有方法和静态方法

    Java 8还添加了另一个功能，在接口内部包含静态方法。
    与类相似，我们可以使用接口的引用访问接口的静态方法。例如：

// create an interface
interface Polygon {
  staticMethod(){..}
}

// access static method
Polygon.staticMethod();

    注意：随着Java 9的发布，接口中还支持私有方法。
我们不能创建接口的对象。因此，私有方法被用作辅助方法，为接口中的其他方法提供支持。

5.1 接口实例

    让我们看一个更实际的Java接口示例。

// To use the sqrt function
import java.lang.Math;

interface  Polygon {
   void getArea();
  
 // calculate the perimeter of a Polygon
   default void getPerimeter(int... sides) {
      int perimeter = 0;
      for (int side: sides) {
         perimeter += side;
      }

   System.out.println("Perimeter: " + perimeter);
   }
}

class Triangle implements Polygon {
   private int a, b, c;
   private double s, area;

// initializing sides of a triangle
   Triangle(int a, int b, int c) {
      this.a = a;
      this.b = b;
      this.c = c;
      s = 0;
   }

// calculate the area of a triangle
   public void getArea() {
      s = (double) (a + b + c)/2;
      area = Math.sqrt(s*(s-a)*(s-b)*(s-c));
      System.out.println("Area: " + area);
   }
}

class Main {
   public static void main(String[] args) {
      Triangle t1 = new Triangle(2, 3, 4);

// calls the method of the Triangle class
      t1.getArea();

// calls the method of Polygon
      t1.getPerimeter(2, 3, 4);
   }
}

    输出：

Area: 2.9047375096555625
Perimeter: 9

    在上面的程序中，我们创建了一个名为Polygon的接口，它包括默认方法getPerimeter()和抽象方法getArea()。
    我们可以用同样的方式计算所有多边形的周长，因此我们在Polygon中实现了getPerimeter()的主体。
    现在，所有实现Polygon的多边形可以使用getPerimeter()来计算周长。
    但是，对于不同的多边形，计算面积的规则是不同的。因此，getArea()方法不包含实现。
    任何实现Polygon的类都必须实现getArea()。

参考文档

[1]Parewa Labs Pvt.Java InputStream Class[EB/OL].https://www.programiz.com/java-programming/interfaces,2020-01-01.