# Java 接口

> 原文： [https://javabeginnerstutorial.com/core-java-tutorial/java-interface/](https://javabeginnerstutorial.com/core-java-tutorial/java-interface/)

定义合同意味着创建接口。 该合同规定了一个类可以做什么而不必强制它应​​该怎么做。 在本 Java 接口教程中，我们将讨论接口。 如何创建一个和应用于接口的规则。

## 声明接口

可以使用`interface`关键字定义接口。 在 Java 8 之后，接口定义发生了很多变化。

## Java 接口示例

```java
public interface MyInterface
{
int i=0;
public void Height(int height);
public abstract void setHeight();

}
```

## Java 8 接口示例

```java
package com.jbt;

public interface Interface_JAVA8 {

	public void method();

	public abstract void method1();

	public default void method2() {
	}

	public static void method3() {
	}
}
```

Java 8 引入了默认方法的概念。 现在，如果接口不是抽象的，则可以包含方法主体。 接口内部的方法可以包含“抽象”，“静态”或“默认”修饰符。

## Java 9 接口私有方法

在 Java 9 中，允许在接口中使用私有方法。

## 接口声明规则

接口需要遵循一些规则。

*   所有接口方法都是*隐式公开抽象*的。 即使您使用关键字，也不会产生问题，如第二个方法声明中所见。 （在 Java 8 之前）
*   接口只能声明*常量*。 实例变量是不允许的。 这意味着接口内的所有变量必须是公开的，静态的，最终的。 接口内的变量是*隐式公开静态最终*的。
*   接口方法不能为*静态*。 （在 Java 8 之前）
*   接口方法不能是`final`，`strictfp`或`native`。
*   该接口可以*扩展*一个或多个其他接口。 注意：该接口只能扩展另一个接口。

## 接口声明规则（JAVA 8）

接口逻辑在 Java 8 中已更改。因此，上述某些逻辑不适用于 Java 8 之后的接口。

*   所有接口方法都可以具有`abstract`，`static`或默认修饰符。
*   如果对方法使用`static`或`default`修饰符，则接口方法可以具有主体。

## 接口与抽象类

*接口*就像*100% 抽象类*一样。 接口不能具有*非抽象方法*，而抽象类则可以。 一个类可以实现多个接口，而只能扩展一个类。 由于抽象类属于类的层次结构，因此它们可以扩展其他类，而接口只能扩展接口。

## 在类中使用接口

用 Java 创建接口后如何利用接口？ 为了利用我们需要利用给定的接口实现我们的类。 `Implement`关键字可用于此目的。

* * *

## 类实现接口的示例

**示例 1**：

```java
public class InterfaceExampleOne implements interfaceOne {

}

interface interfaceOne {

}
```

**示例 2**：

```java
/*
 * As implmeneted Interface have any abstract method so this class
 * need to implement any method.
 */
class InterfaceExampleTwo implements interfaceTwo {

	@Override
	public void methhod() {
		System.out.println(var);
	}

}

/*
 * Below interface has an abstract method so implemented class needs to
 * implement this method unless and untill it is abstract itself
 */
interface interfaceTwo {
	public final int var = 9;

	public abstract void methhod();
}
```

**示例 3**：

```java
/*
 * As below class is not abstract class and it is extending abstract class which
 * has not yet implemented the method from interface so this class is FORCED to
 * implement method from Interface in hierarachy(interfaceTwo).
 */
class InterfaceExampleTwo extends InterfaceExampleThree {

	@Override
	public void methhod() {
		System.out.println(var);
	}

}

/*
 * Below interface has an abstract method so implemented class needs to
 * implement this method unless and untill it is abstract itself
 */
interface interfaceTwo {
	public final int var = 9;

	public abstract void methhod();
}

/*
 * Even if Interface has abstract method ABSTRACT CLASS is not forced to
 * implement it. Abstract class may/may not navigate this responsibility of
 * implementing abstract method to class which is not abstract.
 */
abstract class InterfaceExampleThree implements interfaceTwo {

// Method from Interface is not implemented here

}
```

### 重点

*   接口是 100% 抽象类（**隐式**）。 在 Java 8 之后，它不成立。
*   接口可以由任何继承树中的任何类实现。
*   接口中的所有方法都是抽象的。 （在 Java 8 中为`abstract`/`static`/默认）
*   接口可以具有**常量**，这些常量是公开的，静态的和最终的（**隐式**）。
*   接口方法是隐式公开和抽象的。 （在 Java 8 之前）
*   接口也可以具有私有方法。 （Java 9）
*   实现接口的类也可以是抽象类。
*   实现接口的抽象类不必实现所有抽象方法。
*   一个类可以*实现多个*接口。
*   接口不能扩展类或实现接口。
*   一个接口可以扩展另一个接口。
*   实现接口的非抽象类需要遵循一些规则。
    1.  此类需要提供所有抽象方法的具体实现。
    2.  必须遵守所有覆盖规则。
    3.  它必须维护方法的确切签名。
*   在 Java 9 更改之后，接口看上去很像抽象类，但是还是有一些区别。
    *   抽象类可以具有带有不同修饰符的变量，这些修饰符不是常数
    *   抽象类中的方法可以具有不同于私有或公开签名的签名

