接口是一种抽象类型，它定义了方法签名（方法名、参数列表和返回值类型），接口可以被任何类实现（Implement），实现接口的类必须提供接口中所有抽象方法的具体实现。

接口的特点：

• 接口中的方法默认是 public abstract（Java 8之前）的，即它们是公开的抽象方法。
• 从Java 8开始，接口可以包含默认方法\静态方法（带有方法体的方法 允许在接口中定义多个默认方法）。
• 接口可以包含常量（即静态final字段）。
• 接口不能直接实例化，但可以被实现或继承。
• 接口可以被其他接口继承，形成接口继承体系。

接口的优势：

• 多态性： 通过接口，可以将不同类型的对象视为相同类型，从而实现多态性。
• 代码重用： 接口定义了方法签名，可以被多个类实现，避免代码重复。
• 灵活性和可扩展性： 可以轻松地添加新的接口方法，而不会影响已实现接口的类。
• 解耦： 接口将实现与使用分离，提高代码的模块化和可维护性。

接口定义代码示例

接口定义

public interface MyInterface {
    void method1();
    int method2(int a, int b);

    // 默认方法
    default void defaultMethod() {
        System.out.println("This is a default method.");
    }

    // 静态方法
    static void staticMethod() {
        System.out.println("This is a static method.");
    }
}

接口实现

public class MyClass implements MyInterface {

    @Override
    public void method1() {
        // 实现方法1的逻辑
    }

    @Override
    public int method2(int a, int b) {
        // 实现方法2的逻辑
        return a + b;
    }
}

调用：
MyClass myClass = new MyClass();
myClass.method1();
myClass.method2(1, 2);
myClass.defaultMethod(); // 调用默认方法
MyInterface.staticMethod(); // 调用静态方法

嵌套接口的特点：

嵌套接口是指在另一个类或接口内部定义的接口。

1、可以是 public 或 package-private（默认）。

2、可以被声明为 static 或非 static。

• 静态嵌套接口（Static Nested Interface）：可以不依赖于外部接口的实例而直接使用。
• 非静态嵌套接口：需要外部接口的实例才能被访问。

3、可以被外部类或嵌套在其他接口中的类访问。

4、可以被接口或类实现。

嵌套接口代码示例

public interface OuterInterface {
    void outerMethod();

    // 静态嵌套接口
    static interface StaticNestedInterface {
        void staticNestedMethod();
    }

    // 非静态嵌套接口
    interface NestedInterface {
        void nestedMethod();
    }
}

// 实现嵌套接口
class Implementor implements OuterInterface.NestedInterface {
    public void nestedMethod() {
        // 实现细节
    }
}

// 使用静态嵌套接口
class StaticImplementor implements OuterInterface.StaticNestedInterface {
    public void staticNestedMethod() {
        // 实现细节
    }
}

====== java8 后定义========
public class OuterClass {
    public interface InnerInterface {
        void innerMethod();

        // 默认方法
        default void defaultMethod() {
            System.out.println("This is a default method.");
        }

        // 静态方法
        static void staticMethod() {
            System.out.println("This is a static method.");
        }
    }
}

========  使用 =============
OuterClass.InnerInterface inner = new OuterClass.InnerInterface() {
    @Override
    public void innerMethod() {
        // 实现 innerMethod 的逻辑
    }
};

inner.defaultMethod(); // 调用默认方法
OuterClass.InnerInterface.staticMethod(); // 调用静态方法

使用场景

接口使用场景

• 定义规范： 接口定义了类应该实现的方法，作为一种规范和约束。
• 实现多态性： 通过接口，可以将不同类型的对象视为相同类型，实现多态性。
• 代码重用： 接口可以被多个类实现，避免代码重复。
• 解耦： 接口将实现与使用分离，提高代码的模块化和可维护性。
• 回调机制： 接口可以用于实现回调机制，例如事件监听器。
• 泛型编程： 接口可以用于泛型编程，提供通用的类型参数。

嵌套接口使用场景

• 组织代码： 将相关接口组织在一起，提高代码的可读性和可维护性。
• 访问控制： 嵌套接口可以设置为私有或公共，控制访问权限。
• 命名空间： 嵌套接口可以避免与外部接口的命名冲突。
• 回调机制： 嵌套接口可以用于实现内部回调机制。