Java中的接口

Java编程语言中的接口被定义为用于指定类行为的抽象类型。 Java中的接口是类的蓝图。 Java接口包含静态常量和抽象方法。

Java中的接口是一种实现抽象的机制。 Java接口中只能有抽象方法，不能有方法体。它用于在Java中实现抽象和多重继承。换句话说，你可以说接口可以有抽象方法和变量。它不能有方法体。 Java接口也代表 IS-A 关系。

和类一样，接口可以有方法和变量，但是接口中声明的方法默认是抽象的（只有方法签名，没有主体）。

• 接口指定一个类必须做什么而不是如何做。这是班级的蓝图。
• 接口是关于能力的，比如 Player 可能是一个接口，任何实现 Player 的类都必须能够（或必须实现）move()。所以它指定了类必须实现的一组方法。
• 如果一个类实现了一个接口并且没有为接口中指定的所有函数提供方法体，那么这个类必须被声明为抽象的。
• Java库示例是比较器接口。如果一个类实现了这个接口，那么它就可以用来对集合进行排序。

句法：

interface {

    // declare constant fields
    // declare methods that abstract 
    // by default.   
}

要声明接口，请使用 interface 关键字。它用于提供完全抽象。这意味着接口中的所有方法都使用空主体声明并且是公共的，并且所有字段默认情况下都是公共的、静态的和最终的。实现接口的类必须实现接口中声明的所有方法。要实现接口，请使用 implements 关键字。

为什么我们使用接口？

• 它用于实现完全抽象。
• 由于Java在类的情况下不支持多重继承，通过使用接口可以实现多重继承。
• 它也用于实现松散耦合。
• 接口用于实现抽象。那么问题来了，当我们有抽象类时为什么要使用接口？

原因是，抽象类可能包含非最终变量，而接口中的变量是最终的、公共的和静态的。

// A simple interface

interface Player
{
    final int id = 10;
    int move();
}

类和接口之间的区别

类和接口之间的主要区别是：

S. No.	Class	Interface
1.	In class, you can instantiate variables and create an object.	In an interface, you can’t instantiate variables and create an object.
2.	Class can contain concrete(with implementation) methods	The interface cannot contain concrete(with implementation) methods
3.	The access specifiers used with classes are private, protected, and public.	In Interface only one specifier is used- Public.

实现：要实现一个接口，我们使用关键字implements

Java

// Java program to demonstrate working of
// interface
  
import java.io.*;
  
// A simple interface
interface In1 {
    
    // public, static and final
    final int a = 10;
  
    // public and abstract
    void display();
}
  
// A class that implements the interface.
class TestClass implements In1 {
    
    // Implementing the capabilities of
    // interface.
    public void display(){ 
      System.out.println("Geek"); 
    }
  
    // Driver Code
    public static void main(String[] args)
    {
        TestClass t = new TestClass();
        t.display();
        System.out.println(a);
    }
}

输出

Geek
10

真实示例：让我们考虑自行车、汽车、自行车…………等车辆的示例，它们具有共同的功能。所以我们制作了一个界面并放置了所有这些常见的功能。并让 Bicycle、Bike、car ....etc 以自己的方式在自己的类中实现所有这些功能。

Java

// Java program to demonstrate the 
// real-world example of Interfaces
  
import java.io.*;
  
interface Vehicle {
      
    // all are the abstract methods.
    void changeGear(int a);
    void speedUp(int a);
    void applyBrakes(int a);
}
  
class Bicycle implements Vehicle{
      
    int speed;
    int gear;
      
    // to change gear
    @Override
    public void changeGear(int newGear){
          
        gear = newGear;
    }
      
    // to increase speed
    @Override
    public void speedUp(int increment){
          
        speed = speed + increment;
    }
      
    // to decrease speed
    @Override
    public void applyBrakes(int decrement){
          
        speed = speed - decrement;
    }
      
    public void printStates() {
        System.out.println("speed: " + speed
            + " gear: " + gear);
    }
}
  
class Bike implements Vehicle {
      
    int speed;
    int gear;
      
    // to change gear
    @Override
    public void changeGear(int newGear){
          
        gear = newGear;
    }
      
    // to increase speed
    @Override
    public void speedUp(int increment){
          
        speed = speed + increment;
    }
      
    // to decrease speed
    @Override
    public void applyBrakes(int decrement){
          
        speed = speed - decrement;
    }
      
    public void printStates() {
        System.out.println("speed: " + speed
            + " gear: " + gear);
    }
      
}
class GFG {
      
    public static void main (String[] args) {
      
        // creating an inatance of Bicycle
        // doing some operations
        Bicycle bicycle = new Bicycle();
        bicycle.changeGear(2);
        bicycle.speedUp(3);
        bicycle.applyBrakes(1);
          
        System.out.println("Bicycle present state :");
        bicycle.printStates();
          
        // creating instance of the bike.
        Bike bike = new Bike();
        bike.changeGear(1);
        bike.speedUp(4);
        bike.applyBrakes(3);
          
        System.out.println("Bike present state :");
        bike.printStates();
    }
}

输出

Bicycle present state :
speed: 2 gear: 2
Bike present state :
speed: 1 gear: 1

Java中接口的优点

在Java中使用接口的优点如下：

1. 无需关心实现部分，我们就可以实现实现的安全性。
2. 在Java中，不允许多重继承，但是，您可以使用一个接口来使用它，因为您可以实现多个接口。

JDK 8 的接口中添加的新功能

1 、在JDK 8之前，接口不能定义实现。我们现在可以为接口方法添加默认实现。此默认实现具有特殊用途，不会影响接口背后的意图。

假设我们需要在现有界面中添加一个新函数。显然，旧代码将无法工作，因为这些类还没有实现这些新功能。因此，在默认实现的帮助下，我们将为新添加的功能提供一个默认主体。那么旧代码仍然可以使用。

Java

// Java program to show that interfaces can
// have methods from JDK 1.8 onwards
  
interface In1
{
    final int a = 10;
    default void display()
    {
        System.out.println("hello");
    }
}
  
// A class that implements the interface.
class TestClass implements In1
{
    // Driver Code
    public static void main (String[] args)
    {
        TestClass t = new TestClass();
        t.display();
    }
}

输出

hello

2. JDK 8 中添加的另一个特性是，我们现在可以在接口中定义静态方法，这些方法可以在没有对象的情况下独立调用。注意：这些方法不是继承的。

Java

// Java Program to show that interfaces can
// have methods from JDK 1.8 onwards
  
interface In1
{
    final int a = 10;
    static void display()
    {
        System.out.println("hello");
    }
}
  
// A class that implements the interface.
class TestClass implements In1
{
    // Driver Code
    public static void main (String[] args)
    {
        In1.display();
    }
}

输出

hello

关于界面或文章摘要的要点：

• 我们不能创建接口的实例（接口不能被实例化），但我们可以对其实现类的对象进行引用。
• 一个类可以实现多个接口。
• 一个接口可以扩展到另一个接口或接口（多个接口）。
• 实现接口的类必须实现接口中的所有方法。
• 所有的方法都是公开的和抽象的。并且所有字段都是公共的、静态的和最终的。
• 它用于实现多重继承。
• 它用于实现松散耦合。

JDK 9 的接口中添加的新功能

从Java 9 开始，接口还可以包含以下内容：

1. 静态方法
2. 私有方法
3. 私有静态方法

相关文章：

• 接口中方法的访问说明符
• Java中类或接口的访问说明符
• Java中的抽象类
• Java中的比较器接口
• Java接口方法
• Java中的嵌套接口