Java 8 新特性：接口与抽象类的区别

于 2024-06-03 00:38:26 发布
阅读量570 收藏 12
点赞数 11
分类专栏： Java新特性合集 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33326733/article/details/139400429
版权

在 Java 8 中，接口引入了一些新的特性，比如默认方法（default methods）和静态方法（static methods）。这些改动使得接口更为灵活，同时也引发了很多开发者关于接口和抽象类区别的讨论。

一、接口和抽象类的基本区别

1.1 接口多实现，类单继承

在 Java 中，一个类可以实现多个接口，但只能继承一个抽象类。这是 Java 单继承机制的一部分。

java

interface InterfaceA {
    void methodA();
}

interface InterfaceB {
    void methodB();
}

abstract class AbstractClass {
    abstract void methodC();
}

class ConcreteClass extends AbstractClass implements InterfaceA, InterfaceB {

    @Override
    public void methodA() {
        System.out.println("Method A implementation");
    }

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

    @Override
    void methodC() {
        System.out.println("Method C implementation");
    }
}

在上面的代码中，ConcreteClass 实现了两个接口 InterfaceA 和 InterfaceB，同时继承了一个抽象类 AbstractClass。

1.2 接口的方法和变量修饰符

接口中的方法默认是 public 和 abstract 的，变量默认是 public static final 的。抽象类的方法和变量则可以用任何访问修饰符。

java

interface MyInterface {
    // 接口方法默认是 public abstract 的
    void interfaceMethod();

    // 接口变量默认是 public static final 的
    int CONSTANT = 10;
}

abstract class MyAbstractClass {
    // 抽象类可以有任意访问修饰符的方法和变量
    protected abstract void abstractMethod();
    private String privateField;
    public int publicField;
}

二、接口和抽象类的使用场景

2.1 接口像是扩展插件

接口中的方法更像是扩展插件，你可以认为接口是用来定义行为契约的，而不关心具体实现。

java

interface Payment {
    void pay(double amount);
}

class CreditCardPayment implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("Paying with credit card: " + amount);
    }
}

class PayPalPayment implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("Paying with PayPal: " + amount);
    }
}

在上述例子中，Payment 接口定义了支付行为，而具体支付方式由实现类 CreditCardPayment 和 PayPalPayment 来完成。

2.2 抽象类是要继承的

抽象类则更像是一种模板，定义了一些基本的行为和状态，并要求子类去实现具体细节。

java

abstract class Animal {
    String name;

    Animal(String name) {
        this.name = name;
    }

    abstract void sound();

    void sleep() {
        System.out.println(name + " is sleeping");
    }
}

class Dog extends Animal {
    Dog(String name) {
        super(name);
    }

    @Override
    void sound() {
        System.out.println(name + " says: Woof Woof");
    }
}

在上述例子中，Animal 抽象类定义了动物的基本行为和状态，而具体的动物行为（例如狗的叫声）由子类 Dog 具体实现。

三、Java 8 中的默认方法和静态方法

Java 8 引入了默认方法和静态方法，这使得接口可以包含一些具体实现。这一特性主要是为了解决接口的可扩展性问题。

3.1 默认方法

java

interface MyInterface {
    default void defaultMethod() {
        System.out.println("This is a default method in interface");
    }
}

class MyClass implements MyInterface {
    // MyClass 可以选择重写 defaultMethod()，也可以直接使用接口中的实现
}

public class TestDefaultMethod {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.defaultMethod(); // 输出：This is a default method in interface
    }
}

3.2 静态方法

java

interface MyInterface {
    static void staticMethod() {
        System.out.println("This is a static method in interface");
    }
}

public class TestStaticMethod {
    public static void main(String[] args) {
        MyInterface.staticMethod(); // 输出：This is a static method in interface
    }
}

接口中的静态方法只能通过接口名来调用，不能通过实现类的实例来调用。

四、Java 8 引入默认方法和静态方法的动机

4.1 解决接口的可扩展性问题

在 Java 8 之前，接口中的方法只能是抽象方法。这意味着一旦接口被发布，如果要在接口中添加新的方法，所有实现该接口的类都必须实现新的方法。这对于大型项目或公共 API 来说，可能会导致严重的向后兼容性问题。

示例

假设我们有一个接口 Payment，在 Java 8 之前的版本中，如果要在这个接口中添加一个新的方法 refund，所有实现了 Payment 接口的类都需要实现这个新方法，哪怕这些类是由第三方开发者编写的。

java

interface Payment {
    void pay(double amount);
    // 新增的方法
    void refund(double amount);
}

class CreditCardPayment implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("Paying with credit card: " + amount);
    }

    // 必须实现新的方法
    @Override
    public void refund(double amount) {
        System.out.println("Refunding with credit card: " + amount);
    }
}

为了解决这个问题，Java 8 引入了默认方法，使得接口可以在不破坏现有实现的情况下向接口中添加新方法。

java

interface Payment {
    void pay(double amount);

    // 使用默认方法为接口添加新方法
    default void refund(double amount) {
        System.out.println("Refunding: " + amount);
    }
}

class CreditCardPayment implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("Paying with credit card: " + amount);
    }

    // 可以选择性地重写默认方法
    @Override
    public void refund(double amount) {
        System.out.println("Refunding with credit card: " + amount);
    }
}

4.2 提供默认实现以减少重复代码

在某些情况下，不同的接口实现可能会有一些共同的逻辑。在 Java 8 之前，这些共同的逻辑需要在每个实现类中重复编写。通过引入默认方法，可以在接口中提供一个默认实现，减少代码重复。

示例

假设我们有一个接口 Logger，用于记录日志。在 Java 8 之前，每个实现类都需要自己实现记录日志的方法。

java

interface Logger {
    void log(String message);
}

class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("Log to console: " + message);
    }
}

class FileLogger implements Logger {
    @Override
    public void log(String message) {
        // 逻辑代码
        System.out.println("Log to file: " + message);
    }
}

通过引入默认方法，可以在接口中提供一个默认实现，共享一些常用的逻辑。

java

interface Logger {
    default void log(String message) {
        System.out.println("Log: " + message);
    }
}

class ConsoleLogger implements Logger {
    // 可以直接使用默认实现或重写
}

class FileLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("Log to file: " + message);
    }
}

4.3 静态方法提供工具方法

在 Java 8 之前，接口只能包含抽象方法，无法包含工具方法。引入静态方法后，可以在接口中定义一些与接口相关的工具方法，增强接口的功能性。

示例

假设我们有一个接口 MathOperations，需要提供一些数学操作的工具方法。在 Java 8 之前，这些工具方法只能放在单独的类中。

java

class MathUtils {
    public static int add(int a, int b) {
        return a + b;
    }

    public static int subtract(int a, int b) {
        return a - b;
    }
}

在 Java 8 中，我们可以将这些工具方法直接放在接口中。

java

interface MathOperations {
    static int add(int a, int b) {
        return a + b;
    }

    static int subtract(int a, int b) {
        return a - b;
    }
}

此时，我们可以通过接口名直接调用这些工具方法。

java

public class TestStaticMethod {
    public static void main(String[] args) {
        int result1 = MathOperations.add(5, 3);
        int result2 = MathOperations.subtract(5, 3);
        System.out.println("Addition: " + result1); // 输出：Addition: 8
        System.out.println("Subtraction: " + result2); // 输出：Subtraction: 2
    }
}

五、小结

尽管 Java 8 引入了默认方法和静态方法，使得接口可以包含一些具体实现，但接口和抽象类在设计意图和使用场景上依然有显著的区别：

  1. 接口多实现，类单继承：一个类可以实现多个接口，但只能继承一个抽象类。
  2. 接口的方法和变量修饰符：接口中的方法默认是 public abstract 的，变量默认是 public static final 的，而抽象类的方法和变量可以用任何访问修饰符。
  3. 接口像是扩展插件：接口主要用来定义行为契约，而不关心具体实现。抽象类则更像是模板，定义了一些基本的行为和状态，并要求子类去实现具体细节。

Java 8 引入默认方法和静态方法主要是为了解决以下几个问题：

  1. 接口的可扩展性：允许在不破坏现有实现的情况下向接口中添加新方法。
  2. 减少代码重复：在接口中提供默认实现，共享一些常用的逻辑。
  3. 提供工具方法：在接口中定义与接口相关的工具方法，增强接口的功能性。

这些改动使得接口更加灵活和强大，同时也增强了代码的可维护性和可读性。通过这些新特性，开发者可以更方便地对已有接口进行扩展和优化，而不必担心兼容性问题。

qq_33326733
关注
  • 11
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值