Java 接口

接口是一个完全 抽象类。它包含一组 抽象方法（没有方法体的 方法）。

我们在 Java 中使用 interface 关键字 来创建接口。例如，

interface Language {
  public void getType();

  public void getVersion();
}

这里，

• Language 是一个接口。
• 它包含抽象方法：getType() 和 getVersion()。

实现接口

与抽象类一样，我们不能创建接口的对象。

要使用接口，其他类必须实现它。我们使用 implements 关键字来实现接口。

示例 1：Java 接口

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) {
    Rectangle r1 = new Rectangle();
    r1.getArea(5, 6);
  }
}

输出

The area of the rectangle is 30

在上面的示例中，我们创建了一个名为 Polygon 的接口。该接口包含一个抽象方法 getArea()。

在这里，Rectangle 类实现了 Polygon。并提供了 getArea() 方法的实现。

示例 2：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 类实现了该接口并为该方法提供了实现。

实现多个接口

在 Java 中，一个 类 也可以实现多个接口。例如，

interface A {
  // members of A
}

interface B {
  // members of B
}

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

扩展接口

与类类似，接口可以扩展其他接口。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 {
   ...
}

Java 接口的优点

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

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

interface Line {
…
}

interface Polygon {
…
}

class Rectangle implements Line, Polygon {
…
}

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

  // by default public
  void getName();
}

Java 接口中的默认方法

随着 Java 8 的发布，我们现在可以在接口中添加带有实现的默认方法。这些方法称为默认方法。

要使用 default 关键字在接口中声明默认方法。例如，

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

为什么需要默认方法？

让我们看一个场景来理解为什么在 Java 中引入默认方法。

假设我们需要在接口中添加一个新方法。

我们可以在接口中轻松添加该方法而不实现它。但是，故事并没有就此结束。所有实现该接口的类都必须为该方法提供实现。

如果大量类实现了该接口，我们需要跟踪所有这些类并对其进行更改。这不仅繁琐，而且容易出错。

为了解决这个问题，Java 引入了默认方法。默认方法像普通方法一样被继承。

让我们举一个例子来更好地理解默认方法。

示例：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 对象，会调用默认方法。

接口中的 private 和 static 方法

Java 8 还增加了另一项功能，可以在接口中包含 静态方法。

与类类似，我们可以使用接口的引用来访问接口的静态方法。例如，

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

// access static method
Polygon.staticMethod();

接口的实际示例

让我们看一个更实际的 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() 的实现。