Java 入门指南：接口（Interface）

ZachOn1y

于 2024-08-15 22:50:08 发布

阅读量1.1k

点赞数 26

分类专栏： Java 文章标签： java 开发语言后端 eclipse java-ee

本文链接：https://blog.csdn.net/Zachyy/article/details/141233190

版权

Java 专栏收录该内容

79 篇文章 3 订阅

订阅专栏

引言

在Java编程中，接口（Interface）是一种非常重要的概念，它不仅是面向对象编程（OOP）的基石之一，也是实现高内聚、低耦合设计原则的关键工具。接口定义了一组方法，但不提供这些方法的实现细节，而是由实现接口的类来具体实现。这种机制使得Java程序更加灵活、易于扩展和维护。

定义接口

基本语法

接口在Java中通过 interface 关键字来定义。一个接口可以包含常量（默认是 public static final 的）、方法（默认是 public abstract 的）以及从Java 8开始引入的默认方法和静态方法。接口不能包含实例变量（但可以包含静态常量）和构造方法。

public interface MyInterface {  
    // 常量  
    int MAX_SIZE = 100;  
  
    // 方法声明  
    void doSomething();  
  
    // Java 8 默认方法  
    default void defaultMethod() {  
        // 默认实现  
    }  
  
    // Java 8 静态方法  
    static void staticMethod() {  
        // 静态方法实现  
    }  
}

详情解释

接口中定义的变量会在编译的时候自动加上 public static final 修饰符（注意看一下反编译后的字节码）

Java 官方文档上有这样的声明：

Every field declaration in the body of an interface is implicitly public, static, and final.

换句话说，接口可以用来作为常量类使用，还能省略掉 public static final，看似不错，但这种选择并不可取。因为接口的本意是对方法进行抽象，而常量接口会对子类中的变量造成命名空间上的“污染”。

没有使用 private、default 或者 static 关键字修饰的方法是隐式抽象的，在编译的时候会自动加上 public abstract 修饰符。
从 Java 8 开始，接口中允许有静态方法

静态方法无法由（实现了该接口的）类的对象调用，它只能通过接口名来调用，比如说 Electronic.isEnergyEfficient("LED")。

接口中定义静态方法的目的是为了提供一种简单的机制，使我们不必创建对象就能调用方法，从而提高接口的竞争力。
默认方法为实现该接口而不覆盖该方法的类提供默认实现。既然要提供默认实现，就要有方法体，后面不能直接使用“;”号来结束——编译器会报错。

假如我们需要在所有的实现类中追加某个具体的方法， default 方法就很有帮助。

接口不允许直接实例化，否则编译器会报错。

接口可以是空的，既可以不定义变量，也可以不定义方法。最典型的例子就是 Serializable 接口，在 java.io 包下。

public interface Serializable { }

Serializable 接口用来为序列化的具体实现提供一个标记，也就是说，只要某个类实现了 Serializable 接口，那么它就可以用来序列化了。

不要在定义接口的时候使用 final 关键字，否则会报编译错误，因为接口就是为了让子类实现的，而 final 阻止了这种行为。

接口的抽象方法不能是 private、protected 或者 final，否则编译器都会报错。

接口的变量是隐式 public static final（常量），所以其值无法改变。

实现接口

类通过 implements 关键字来实现接口。一个类可以实现多个接口，但必须用逗号分隔接口名。实现接口的类必须提供接口中所有方法的实现（除非该类是抽象类）。

public class MyClass implements MyInterface {  
    @Override  
    public void doSomething() {  
        // 方法实现  
    }  
  
    // 对于默认方法，可以选择覆盖或不覆盖  
    @Override  
    public void defaultMethod() {  
        // 覆盖默认方法实现  
    }  
  
    // 静态方法不能被覆盖，但可以直接通过接口名调用  
}

默认方法和静态方法

从Java 8开始，接口中可以包含默认方法和静态方法。默认方法提供了一种在不破坏现有实现的情况下向接口添加新方法的方式。静态方法则类似于工具方法，可以直接通过接口名调用。

Lambda表达式与函数式接口

Lambda 表达式 是Java 8引入的一种简洁的匿名函数实现方式。函数式接口是只包含一个抽象方法的接口（可以包含多个默认方法或静态方法）。Lambda 表达式 可以用于实现函数式接口，从而以更简洁的方式编写代码。

接口的作用

使某些实现类具有需要的功能，比如说，实现了 Cloneable 接口的类具有拷贝的功能，实现了 Comparable 或者 Comparator 的类具有比较功能。
Java 原则上只支持单一继承，但通过接口可以实现多重继承的目的。

如果有两个类共同继承（extends）一个父类，那么父类的方法就会被两个子类重写。然后，如果有一个新类同时继承了这两个子类，那么在调用重写方法的时候，编译器就不能识别要调用哪个类的方法了。这也正是著名的菱形问题

在这里插入图片描述
Java通过以下方式解决了这个问题：

默认方法：从Java 8开始，接口可以包含具有默认实现的方法，称为默认方法。这样，即使多个接口中有相同的方法签名，实现这些接口的类也可以直接使用其中一个接口中的默认实现，或者覆盖该方法以提供自己的实现。
静态方法：接口还可以包含静态方法，但这些方法不会被实现类继承。
显式覆盖：如果多个接口中存在相同的方法签名，并且每个接口提供了不同的默认实现，那么实现这些接口的类必须明确地覆盖这个方法并提供自己的实现。

interface InterfaceA {
    default void method() {
        System.out.println("InterfaceA's method");
    }
}

interface InterfaceB extends InterfaceA {
    default void method() {
        System.out.println("InterfaceB's method");
    }
}

class MyClass implements InterfaceB {
    // 必须覆盖method()方法，因为InterfaceA和InterfaceB中都有相同的默认实现
    @Override
    public void method() {
        System.out.println("MyClass's method");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.method();  // 输出: MyClass's method
    }
}

在这个例子中：

InterfaceA 和 InterfaceB 都声明了一个默认方法 method()。
InterfaceB 继承了 InterfaceA 并重写了 method() 方法。
MyClass 实现了 InterfaceB，并且必须明确地覆盖 method() 方法，因为它同时继承了来自 InterfaceA 和 InterfaceB 的不同实现。

接口的用途

定义规范

接口为类提供了一种定义规范的方式。任何实现接口的类都必须实现接口中声明的所有方法（除非该类是抽象类）。这有助于确保类的行为一致性，并使得代码更加易于理解和维护。

假设我们需要为一组形状定义通用的行为，比如计算面积和周长。我们可以创建一个接口 Shape，其中定义了这两个方法。

public interface Shape {
    double area();
    double perimeter();
}

然后，我们可以创建几个类来实现这个接口，例如 Circle 和 Rectangle。

public class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }

    @Override
    public double perimeter() {
        return 2 * Math.PI * radius;
    }
}

public class Rectangle implements Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double area() {
        return width * height;
    }

    @Override
    public double perimeter() {
        return 2 * (width + height);
    }
}

多态

接口是实现多态性的重要手段。通过接口引用，我们可以指向实现了该接口的任何对象，并在运行时调用其实现的方法。这种机制提高了代码的灵活性和可扩展性。

现在我们可以通过 Shape 接口引用来指向 Circle 或 Rectangle 的实例，并调用它们的方法。

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5.0);
        Shape rectangle = new Rectangle(4.0, 6.0);

        System.out.println("Circle Area: " + circle.area());
        System.out.println("Rectangle Perimeter: " + rectangle.perimeter());
    }
}

解耦

接口有助于实现模块之间的解耦。通过定义接口，我们可以将模块之间的依赖关系从具体的实现类中分离出来，从而降低了模块之间的耦合度。这使得在修改或替换某个模块的实现时，不需要修改其他模块的代码。

如果我们需要改变 Circle 或 Rectangle 类的具体实现，只要它们仍然遵循 Shape 接口的定义，那么上面的 Main 类就不需要做任何改动。

框架设计

在 Java 框架设计中，接口扮演着核心角色。许多框架都通过定义接口来提供扩展点，允许开发者通过实现这些接口来定制框架的行为。例如，Spring 框架中的大量接口用于实现依赖注入、AOP等功能。

在框架设计中，接口可以作为扩展点。例如，我们可以创建一个 ShapeFactory 接口，允许用户通过实现该接口来定制创建形状的方式。

public interface ShapeFactory {
    Shape createShape(String type);
}

// 具体实现
public class SimpleShapeFactory implements ShapeFactory {
    @Override
    public Shape createShape(String type) {
        if ("circle".equals(type)) {
            return new Circle(1.0);  // 默认半径
        } else if ("rectangle".equals(type)) {
            return new Rectangle(1.0, 1.0);  // 默认尺寸
        }
        throw new IllegalArgumentException("Unsupported shape type");
    }
}

// 使用
public class Main {
    public static void main(String[] args) {
        ShapeFactory factory = new SimpleShapeFactory();
        Shape shape = factory.createShape("circle");
        System.out.println("Shape Area: " + shape.area());
    }
}