目录
在Java中，接口（interface）是一种引用类型，它类似于类（class），但是与类不同的是，接口不能包含任何具体的方法实现（除了默认方法和静态方法之外）。接口定义了一组规则或行为，这些规则由实现该接口的类来提供具体的实现。接口可以看作是类之间的一种契约，规定了类应该具有哪些方法。
以下是关于Java接口的一些关键点：
1.定义接口
使用interface关键字来定义一个接口。
public interface MyInterface {
void method1();
int method2(String param);
}2.实现接口
类使用implements关键字来实现一个或多个接口，并且必须为接口中的所有抽象方法提供实现。
public class MyClass implements MyInterface {
@Override
public void method1() {
// 实现代码
}
@Override
public int method2(String param) {
// 实现代码
return 0;
}
}3.多重继承
Java类不支持多重继承，但可以通过实现多个接口来达到类似的效果。
public class MultiInheritClass implements Interface1, Interface2 {
// 必须实现两个接口的所有方法
}4.抽象方法
抽象方法是接口中最基本的方法类型。它们没有方法体（即没有实现），并且默认是public和abstract的。实现该接口的类必须提供这些方法的具体实现。
public interface MyInterface {
// 抽象方法
void myMethod(); // 等同于 public abstract void myMethod();
}5.默认方法
从Java 8开始，接口可以有默认方法实现。这样做的目的是为了向后兼容，允许在不破坏现有实现的情况下添加新方法。
以下是关于如何定义和使用接口中的默认方法的一些示例：
定义默认方法
在接口中，你可以通过default关键字来定义一个默认方法。例如：
public interface MyInterface {
// 抽象方法
void abstractMethod();
// 默认方法
default void defaultMethod() {
System.out.println("This is a default method.");
}
// 另一个默认方法
default void anotherDefaultMethod(int number) {
System.out.println("The number is: " + number);
}
}实现接口并使用默认方法
当你有一个实现了上述接口的类时，你可以选择是否重写默认方法。如果不重写，默认方法的实现将被继承。
public class MyClass implements MyInterface {
@Override
public void abstractMethod() {
System.out.println("Implementing the abstract method.");
}
// 这里可以选择性地重写defaultMethod
// 如果没有重写，则会使用接口中提供的默认实现
}
public class Main {
public static void main(String[] args) {
MyClass myClass = new MyClass();
myClass.abstractMethod(); // 输出: Implementing the abstract method.
myClass.defaultMethod(); // 输出: This is a default method.
myClass.anotherDefaultMethod(42); // 输出: The number is: 42
}
}在这个例子中，MyClass实现了MyInterface，但并没有重写defaultMethod和anotherDefaultMethod，因此这两个方法将使用接口中提供的默认实现。
重写默认方法
如果需要不同的行为，你可以在实现类中重写默认方法：
public class AnotherClass implements MyInterface {
@Override
public void abstractMethod() {
System.out.println("Another implementation of the abstract method.");
}
@Override
public void defaultMethod() {
System.out.println("Overriding the default method in AnotherClass.");
}
}
public class Main {
public static void main(String[] args) {
AnotherClass anotherClass = new AnotherClass();
anotherClass.abstractMethod(); // 输出: Another implementation of the abstract method.
anotherClass.defaultMethod(); // 输出: Overriding the default method in AnotherClass.
}
}在这个例子中，AnotherClass重写了defaultMethod，因此当调用这个方法时，将执行新的实现而不是接口中的默认实现。
默认方法为接口提供了更多的灵活性，使得在保持二进制兼容性的同时能够扩展接口的功能。这在库的设计中尤其有用，因为它允许库维护者增加新的功能而不影响现有的客户端代码。
6.静态方法
从Java 8开始，接口也可以包含静态方法。这些方法也是public的。下面是一个简单的例子来展示如何在接口中定义和使用静态方法。
定义接口并包含静态方法
public interface MyInterface {
// 抽象方法
void myMethod();
// 默认方法
default void defaultMethod() {
System.out.println("This is a default method.");
}
// 静态方法
static void staticMethod() {
System.out.println("This is a static method in MyInterface.");
}
}使用静态方法
静态方法可以通过接口名直接调用，不需要任何实现类。下面是如何在主程序中调用这个静态方法：
public class Main {
public static void main(String[] args) {
// 直接通过接口名调用静态方法
MyInterface.staticMethod(); // 输出: This is a static method in MyInterface.
// 创建接口的实现类实例
MyInterface myInstance = new MyClass();
// 调用抽象方法
myInstance.myMethod(); // 输出: Implementing myMethod from MyInterface
// 调用默认方法
myInstance.defaultMethod(); // 输出: This is a default method.
}
}
// 实现接口的类
class MyClass implements MyInterface {
@Override
public void myMethod() {
System.out.println("Implementing myMethod from MyInterface");
}
}通过这种方式，你可以在接口中定义静态方法，并在需要时直接通过接口名调用这些方法。这在提供工具方法或辅助功能时非常有用。
7.私有方法
从Java 9开始，接口可以拥有私有方法，这些私有方法主要用于帮助默认方法或静态方法内部实现逻辑，并且不能被外部访问。私有方法有两种形式：普通私有方法和私有静态方法。
普通私有方法：普通私有方法可以在接口的默认方法或静态方法中使用，但不能直接从接口的外部调用。
私有静态方法：私有静态方法同样只能在接口内部使用，用于辅助静态方法的实现。
下面是一个简单的例子来展示如何在接口中定义和使用私有方法：
public interface MyInterface {
// 抽象方法
void myMethod();
// 默认方法
default void defaultMethod() {
System.out.println("This is a default method.");
privateHelper(); // 调用私有方法
}
// 静态方法
static void staticMethod() {
System.out.println("This is a static method in MyInterface.");
privateStaticHelper(); // 调用私有静态方法
}
// 私有方法
private void privateHelper() {
System.out.println("This is a private helper method.");
}
// 私有静态方法
private static void privateStaticHelper() {
System.out.println("This is a private static helper method.");
}
}
// 实现接口的类
class MyClass implements MyInterface {
@Override
public void myMethod() {
System.out.println("Implementing myMethod from MyInterface");
}
}
// 主程序
public class Main {
public static void main(String[] args) {
// 创建接口的实现类实例
MyInterface myInstance = new MyClass();
// 调用默认方法
myInstance.defaultMethod(); // 输出:
// This is a default method.
// This is a private helper method.
// 调用静态方法
MyInterface.staticMethod(); // 输出:
// This is a static method in MyInterface.
// This is a private static helper method.
}
}通过这种方式，你可以在接口中定义私有方法和私有静态方法，以帮助实现更复杂的逻辑，同时保持接口的封装性和清晰性。这有助于减少代码重复，并提高代码的可维护性。
8.常量
接口中的字段自动隐式地是public static final，即它们是公共的、静态的和最终的（不可改变）。当你声明一个字段时，即使你不显式地指定这些修饰符，编译器也会自动添加它们。
public interface Constants {
int MAX = 100; // 自动是 public static final
}你不能改变这个行为来使用不同的访问级别或去掉static和final修饰符。也就是说，在接口中声明的字段总是会被视为常量，并且必须在声明时初始化。
如果你尝试显式地给接口中的字段加上非public static final的修饰符，编译器会报错。例如，下面的代码会导致编译错误：
public interface MyInterface {
// 错误：不能修改为private
private int MY_CONSTANT = 10;
// 错误：不能修改为non-final
int ANOTHER_CONSTANT;
}而显示指定public static final三个中任意一个修饰符都是合法的，因为这与默认行为一致。