java 如何调用接口

Java 调用接口的基本方法

在 Java 中调用接口通常涉及接口的实现和调用接口方法。以下是常见的方法：

定义接口

接口是一种抽象类型，用于定义方法签名但不提供实现。

public interface MyInterface {
    void myMethod();
}

实现接口

通过类实现接口，并提供具体的方法实现。

public class MyClass implements MyInterface {
    @Override
    public void myMethod() {
        System.out.println("Method implementation");
    }
}

调用接口方法

创建实现类的实例，并通过接口类型引用调用方法。

public class Main {
    public static void main(String[] args) {
        MyInterface obj = new MyClass();
        obj.myMethod();
    }
}

使用匿名类实现接口

对于临时或简单的实现，可以使用匿名类。

public class Main {
    public static void main(String[] args) {
        MyInterface obj = new MyInterface() {
            @Override
            public void myMethod() {
                System.out.println("Anonymous class implementation");
            }
        };
        obj.myMethod();
    }
}

使用 Lambda 表达式（Java 8+）

如果接口是函数式接口（只有一个抽象方法），可以使用 Lambda 表达式简化代码。

public class Main {
    public static void main(String[] args) {
        MyInterface obj = () -> System.out.println("Lambda implementation");
        obj.myMethod();
    }
}

通过反射调用接口方法

利用 Java 反射机制动态调用接口方法。

import java.lang.reflect.Method;

public class Main {
    public static void main(String[] args) throws Exception {
        MyInterface obj = new MyClass();
        Method method = MyInterface.class.getMethod("myMethod");
        method.invoke(obj);
    }
}

接口默认方法（Java 8+）

Java 8 引入了默认方法，允许接口提供默认实现。

public interface MyInterface {
    default void myDefaultMethod() {
        System.out.println("Default method implementation");
    }
}

public class Main {
    public static void main(String[] args) {
        MyInterface obj = new MyClass();
        obj.myDefaultMethod();
    }
}

静态方法调用

接口可以包含静态方法，直接通过接口名调用。

public interface MyInterface {
    static void myStaticMethod() {
        System.out.println("Static method implementation");
    }
}

public class Main {
    public static void main(String[] args) {
        MyInterface.myStaticMethod();
    }
}

多接口实现

一个类可以实现多个接口，分别调用不同接口的方法。

public interface InterfaceA {
    void methodA();
}

public interface InterfaceB {
    void methodB();
}

public class MyClass implements InterfaceA, InterfaceB {
    @Override
    public void methodA() {
        System.out.println("Method A");
    }

    @Override
    public void methodB() {
        System.out.println("Method B");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.methodA();
        obj.methodB();
    }
}

接口继承

接口可以继承其他接口，扩展方法定义。

public interface ParentInterface {
    void parentMethod();
}

public interface ChildInterface extends ParentInterface {
    void childMethod();
}

public class MyClass implements ChildInterface {
    @Override
    public void parentMethod() {
        System.out.println("Parent method");
    }

    @Override
    public void childMethod() {
        System.out.println("Child method");
    }
}

public class Main {
    public static void main(String[] args) {
        ChildInterface obj = new MyClass();
        obj.parentMethod();
        obj.childMethod();
    }
}

以上方法涵盖了 Java 中调用接口的常见场景，根据具体需求选择合适的方式。