Java中的接口
和类一样， Java中的接口可以有方法和变量，但是接口中声明的方法默认是抽象的（只有方法签名，没有主体）。
- 接口指定一个类必须做什么而不是如何做。这是班级的蓝图。
- 接口是关于能力的，比如 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(); }
要实现一个接口，我们使用关键字：implement
// 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 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
一个真实世界的例子：
让我们以自行车、汽车、自行车……等车辆为例，它们具有共同的功能。所以我们制作了一个界面并放置了所有这些常见的功能。并让 Bicylce、Bike、car ....etc 在他们自己的类中实现所有这些功能。
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 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
JDK 8 接口中添加的新特性
- 在 JDK 8 之前，接口无法定义实现。我们现在可以为接口方法添加默认实现。这个默认实现有特殊用途，不会影响接口背后的意图。
假设我们需要在现有界面中添加一个新函数。显然，旧代码将无法工作，因为这些类还没有实现这些新功能。因此，在默认实现的帮助下，我们将为新添加的功能提供一个默认主体。那么旧代码仍然可以使用。
// An example 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 interface. class testClass implements in1 { // Driver Code public static void main (String[] args) { testClass t = new testClass(); t.display(); } }输出 ：
hello - JDK 8 中添加的另一个特性是我们现在可以在接口中定义静态方法，这些方法可以在没有对象的情况下独立调用。注意：这些方法不是继承的。
// An example 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 interface. class testClass implements in1 { // Driver Code public static void main (String[] args) { in1.display(); } }输出 ：
hello
关于界面或文章摘要的要点：
- 我们不能创建接口的实例（接口不能被实例化），但是我们可以引用它来引用它的实现类的对象。
- 一个类可以实现多个接口。
- 一个接口可以扩展另一个接口（但只能扩展一个接口）。
- 实现接口的类必须实现接口中的所有方法。
- 所有的方法都是公开的和抽象的。并且所有字段都是公共的、静态的和最终的。
- 它用于实现多重继承。
- 它用于实现松散耦合。
相关文章：
- 接口中方法的访问说明符
- Java中类或接口的访问说明符
- Java中的抽象类
- Java中的比较器接口
- Java接口方法
- Java中的嵌套接口