当前位置：首页 > Java

java如何编写接口

2026-01-15 16:58:21Java

编写Java接口的基本语法

在Java中，接口通过interface关键字定义，可以包含抽象方法、默认方法、静态方法和常量。

public interface MyInterface {
    // 抽象方法（隐式public abstract）
    void abstractMethod();

    // 默认方法（Java 8+）
    default void defaultMethod() {
        System.out.println("Default method implementation");
    }

    // 静态方法（Java 8+）
    static void staticMethod() {
        System.out.println("Static method implementation");
    }

    // 常量（隐式public static final）
    String CONSTANT = "Interface constant";
}

实现接口的类

类通过implements关键字实现接口，必须实现所有抽象方法（除非是抽象类）。

java如何编写接口

public class MyClass implements MyInterface {
    @Override
    public void abstractMethod() {
        System.out.println("Implemented abstract method");
    }
}

接口的多重继承

Java支持一个类实现多个接口，解决单继承的限制。

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");
    }
}

接口的继承

接口可以通过extends继承其他接口，形成接口层次结构。

java如何编写接口

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 interface MyInterface {
    default void show() {
        System.out.println("Default method");
    }

    static void display() {
        System.out.println("Static method");
    }
}

public class Main {
    public static void main(String[] args) {
        MyInterface obj = new MyInterface() {};
        obj.show();            // 调用默认方法
        MyInterface.display(); // 调用静态方法
    }
}

函数式接口（Java 8+）

仅包含一个抽象方法的接口称为函数式接口，可用@FunctionalInterface注解标记，支持Lambda表达式。

@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        Calculator add = (a, b) -> a + b;
        System.out.println(add.calculate(5, 3)); // 输出8
    }
}