Java 接口

在本教程中，我们将学习 Java 接口。我们将通过示例详细了解如何实现接口以及何时使用它们。

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

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

interface Language {
  public void getType();

  public void getVersion();
}

在这里，

语言 是一个接口。
包括抽象方法：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() .

这里，矩形 类实现 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
}

这里，多边形 接口扩展了 Line 界面。现在，如果任何类实现 Polygon ，它应该为 Line 的所有抽象方法提供实现和 多边形 .

扩展多个接口

一个接口可以扩展多个接口。例如，

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 {
…
}
```
这里，类 Rectangle 正在实现两个不同的接口。这就是我们在 Java 中实现多重继承的方式。

注意 :接口内的所有方法都隐含 public 并且所有字段都是隐式 public static final .例如，

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 和 方形 实现 Polygon .

矩形 类提供getArea()的实现方法并覆盖 getSides() 方法。但是，Square 类只提供getArea()的实现方法。

现在，在调用 getSides() 使用 矩形 的方法对象，则调用被覆盖的方法。但是，对于 Square 对象，调用默认方法。

接口中的私有和静态方法

Java 8 还添加了另一个特性，在接口中包含静态方法。

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

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

// access static method
Polygon.staticMethod();

注意 :随着 Java 9 的发布，接口也支持私有方法。

我们不能创建接口的对象。因此，私有方法被用作辅助方法，为接口中的其他方法提供支持。

接口实例

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

我们可以用同样的方式计算所有多边形的周长，所以我们实现了 getPerimeter() 的主体在 多边形 .

现在，所有实现 Polygon 的多边形可以使用getPerimeter() 计算周长。

但是，不同的多边形计算面积的规则是不同的。因此，getArea() 包含但未实现。

任何实现 Polygon 的类必须提供 getArea() 的实现 .

Java 抽象类和抽象方法 Java 多态性

java