Java 接口（Interface）

在Java中，接口是一种抽象类型，它定义了一组方法和常量的集合。类或接口可以实现这些接口，从而继承这些方法和常量。通过使用接口，可以使不同的类具有相似的行为，同时保持设计的灵活性。

1. 定义一个简单的接口

// 定义一个简单的接口
interface SimpleInterface {
    // 接口中的默认访问修饰符是public
    void doSomething(); // 抽象方法
    
    // 常量定义在接口中也是允许的，并且常量必须是静态和最终的。
    static final int DEFAULT_VALUE = 42;
}

2. 实现一个接口

// 实现SimpleInterface接口的类
class ImplementingClass implements SimpleInterface {
    
    // 必须实现doSomething方法，因为它是抽象的
    public void doSomething() {
        System.out.println("Implementing doSomething in ImplementingClass");
    }
}

3. 使用接口作为引用类型

public class InterfaceUsage {

    public static void main(String[] args) {
        
        // 创建一个ImplementingClass对象
        SimpleInterface obj = new ImplementingClass();
        
        // 调用接口中的方法
        obj.doSomething(); // 输出: Implementing doSomething in ImplementingClass
        
        // 访问接口中的常量
        System.out.println(SimpleInterface.DEFAULT_VALUE); // 输出: 42
    }
}

4. 接口的多重实现

// 定义第二个接口
interface AnotherInterface {
    void doAnotherThing();
}

// 实现两个接口的类
class MultiImplementingClass implements SimpleInterface, AnotherInterface {

    // 实现SimpleInterface中的doSomething方法
    public void doSomething() {
        System.out.println("Multi class implementing doSomething");
    }

    // 实现AnotherInterface中的doAnotherThing方法
    public void doAnotherThing() {
        System.out.println("Multi class implementing doAnotherThing");
    }
}

// 使用多重实现的类
public class MultiImplementationUsage {

    public static void main(String[] args) {
        
        MultiImplementingClass obj = new MultiImplementingClass();
        
        // 调用不同接口中的方法
        obj.doSomething();         // 输出: Multi class implementing doSomething
        obj.doAnotherThing();      // 输出: Multi class implementing doAnotherThing
    }
}

5. 接口的继承

// 定义一个父接口
interface ParentInterface {
    void parentMethod();
}

// 定义一个子接口，继承自ParentInterface
interface ChildInterface extends ParentInterface {

    // 子接口可以添加新的方法或重写父接口的方法（如果需要）
    void childMethod();
}

// 实现ChildInterface的类
class ChildImplementingClass implements ChildInterface {
    
    public void parentMethod() {  // 必须实现父接口中的parentMethod()
        System.out.println("Parent method implemented in ChildImplementingClass");
    }
    
    public void childMethod() {   // 实现子接口中的childMethod()
        System.out.println("Child method implemented in ChildImplementingClass");
    }
}

// 使用继承的接口
public class InheritanceUsage {

    public static void main(String[] args) {
        
        ChildImplementingClass obj = new ChildImplementingClass();
        
        // 调用父接口和子接口中的方法
        obj.parentMethod();         // 输出: Parent method implemented in ChildImplementingClass
        obj.childMethod();          // 输出: Child method implemented in ChildImplementingClass
    }
}

6. 接口的默认方法

// 定义一个带有默认实现的方法接口
interface DefaultInterface {
    
    // 常规抽象方法，必须在实现类中被覆盖或提供具体实现
    void abstractMethod();
    
    // 默认方法（default） - 可以有具体的实现，并且可以在子接口中重写
    default void defaultMessage() {
        System.out.println("Default message from DefaultInterface");
    }
}

// 实现DefaultInterface的类，没有覆盖abstractMethod和defaultMessage
class SimpleImplementation implements DefaultInterface {

    public void abstractMethod() {  // 必须实现这个抽象方法
        System.out.println("Abstract method implemented in SimpleImplementation");
    }

    // 如果不重写defaultMessage，则会使用接口中的默认实现
}

// 使用DefaultInterface的类，并测试默认方法的行为
public class DefaultMethodsUsage {

    public static void main(String[] args) {
        
        // 创建一个SimpleImplementation对象
        DefaultInterface obj = new SimpleImplementation();
        
        // 调用abstractMethod，必须由子类实现
        obj.abstractMethod();         // 输出: Abstract method implemented in SimpleImplementation
        
        // 调用defaultMessage方法，默认会调用接口中的默认实现
        obj.defaultMessage();         // 输出: Default message from DefaultInterface
    }
}

7. 接口的静态方法

// 定义一个带有静态方法的接口
interface StaticMethodsInterface {
    
    // 静态方法可以直接在接口中定义，并且可以通过接口名直接调用，无需实例化类。
    static void staticMethod() {
        System.out.println("Static method called from interface");
    }
}

// 使用静态方法的示例
public class StaticMethodsUsage {

    public static void main(String[] args) {
        
        // 调用静态方法不需要创建对象实例
        StaticMethodsInterface.staticMethod();  // 输出: Static method called from interface
    }
}

总结

• 接口在Java中是非常强大的工具，用于定义类的行为规范。
• 接口可以被多个类实现，从而促进代码的复用和灵活性。
• Java允许通过默认方法和静态方法来增强接口的功能，同时保持向后兼容性。