死磕 Java 基础
首页 死磕 Java 优质系列 Java 技术总览 Java 面试宝典 关于我

Java 接口的进化之路

原
 2023-11-19  阅读(4)
©版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://www.skjava.com/series/article/2097690925

Java 接口我相信所有学过 Java 的人一定都知道，而且我也相信 99% 的人一定都背过这个面试题：Java 接口和抽象类的区别是什么？答案都是什么接口方法不能有实现，都是抽象的，接口的方法都默认为 public 修饰等等之类的，这些在 Java 8 之前是正确的，但是随着 Java 的发展，它不再是正确的了。

这篇文章就跟着大明哥一起来探索 Java 接口的进化之路。

出生：Java 1.0 引入接口

Java 1.0 ，作为 Java 语言的最初版本，于 1996 年发布。在这个版本中，Java 引入了接口（Interface）这一概念，标志着面向对象编程（OOP）在 Java 中的深入应用。

在 Java 1.0 中，接口被定义为完全抽象的，它具备如下特点：

  • 完全抽象：接口被定义为完全抽象，意味着它不能包含任何方法的具体实现。
  • 只能包含方法签名和常量：接口中只能声明方法签名（没有方法体）和公共静态常量（public static final）。这意味着，在接口中定义的所有字段都会自动成为公共、静态、最终的，而所有方法都被视为公共的和抽象的。
  • 没有构造函数：接口不能被实例化，所以它们不能包含构造函数。
  • 多重实现：不同于类的继承，Java 允许一个类实现多个接口。由于 Java 只允许单继承，所以接口的出现，为 Java 的多重继承提供了实现的可能。
  • 实现类必须实现所有方法：任何一个实现接口的类都必须实现接口中声明的所有方法，除非该类被声明为抽象类。

这个时候我们定义接口只能定义为如下形式：

public interface MyInterface {
    String SK_URL = "https://skjava.com/";

    String getSeriesUrl();
}

属性 SK_URL 默认为 public static final。

Java 1.1 引入内部类，内部类提供了一种强大的机制，它允许将一个类的定义放置在另一个类的定义内部，从而与外部类紧密地绑定在一起。内部类中的匿名内部类，可以用于实现接口，这对接口的使用有着特别的意义，它提高了代码的封装性和可维护性。

会爬了：Java 1.5 引入泛型

Java 5 于 2004 年发布，它引入了泛型，泛型的引入对接口的使用产生了深远的影响。

在引入泛型之前，Java 接口通常处理的是 Object 类型的数据，这意味着任何类型的对象都可以传递给这些接口。在实现类中我们需要将 Object 类型的数据转换为其它具体类型，这种转换可能会导致 ClassCastException。

引入泛型后，接口可以在定义时就指定具体的类型参数，这使得接口在编译时就能够检查和确认数据类型，从而大大增强了类型安全。同时，泛型允许接口定义通用的模板，例如List<E> 或 Comparator<T>，这些接口可以被不同类型的数据重用，而不需要为每种数据类型创建新的接口。

下面举一个简单的例子来说明，引入 泛型对接口好处。

在 Java 5 引入泛型之前，集合类如 List 接口存储的元素类型是不确定的，它们默认存储 Object 类型的对象。这使得集合可以存储任何类型的对象，但也带来了类型安全问题。

List list = new ArrayList();
list.add("skjava.com");
list.add(1); // 这是合法的，因为集合可以存储任何类型的对象

// 获取时需要进行类型转换
String str = (String) list.get(0);
Integer num = (Integer) list.get(1);

list 可以同时存储 String 和 Integer。但是，在获取元素时，我们需要进行显式的类型转换。如果在运行时类型不匹配，会抛出 ClassCastException。

引入泛型后，可以在定义集合时指定存储的元素类型。这提高了类型安全，并减少了运行时的错误。

List<String> list = new ArrayList<>();
list.add("skjava.com");
// list.add(1);       // 这行代码会导致编译错误，因为 list 只能存储字符串

// 获取时不需要进行类型转换
String str = list.get(0);

list 被定义为仅能存储 String 类型的 List，当我们尝试添加非 String 类型（如 Integer）到该 list 中会在编译时报错，而不是在运行时。同时，获取元素时也不需要显式的类型转换，因为编译器已经确保了所有元素都是 String 类型。

会走路了：Java 8 引入默认方法和静态方法

Java 8 是一个重大的里程碑，因为它为Java接口引入了两个重要的新特性：默认方法和静态方法，这两个特性让 Java 接口可以走路了。

在 Java 8 之前，接口中申明的方法必须是抽象的，实现该接口就需要实现该接口的所有方法。我们知道接口的设计是一项巨大的工作，因为如果我们需要在接口中新增一个方法，需要对它的所有实现类都进行修改，如果它的实现类比较少还可以接受，如果实现类比较多则工作量就比较大了。而且有些实现类根本不需要实现该方法，也由于 Java 接口的限制导致它强迫实现该方法。

为了解决这个问题，Java 8 引入了默认方法，默认方法允许在接口中添加具有默认实现的方法，它使得接口可以包含方法的实现，而不仅仅是抽象方法的定义。这一特性可以在不破坏现有实现的前提下向接口添加新方法，使得接口具备了向后兼容的能力。

用法如下：

  • 使用default关键字标识方法，然后方法提供具体实现。
public interface MyInterface {
    
    default void print() {
        System.out.println("我是大明哥");
    }
}

实现接口的类可以直接使用这些默认方法，或者根据需要重写它们：

public class MyInterfaceImpl implements MyInterface{

    @Override
    public void print() {
        System.out.println("我是大明哥 2 号");
    }
}

Java 8 中还允许在接口中定义静态方法。这些方法与类中的静态方法一样，是属于接口的而不是接口的实例。静态方法主要用于提供辅助方法，例如根据传入参数构建接口的实现，或者提供通用的工具方法。

用法：

  • 静态方法使用static关键字声明，并且必须提供实现。
  • 是通过接口名直接调用静态方法，不需要接口的实例。
public interface MyInterface {
    static int add(int a, int b) {
        return a + b;
    }
}

add() 是通过MyInterface.add(5, 3)直接调用，而不需要创建MyInterface的实例。

Java 引入默认方法和静态方法大大增强了 Java 接口的能力，提高了 Java 接口的灵活性和功能性。

更多关于接口默认方法和静态方法，阅读：Java 8 新特性—接口默认方法和静态方法

可以跑了：Java 9 引入私有方法

Java 8 为引入了默认方法和静态方法，提高了 Java 接口的灵活性和功能性。但是这些依然是 public 的，这在某些情况下会导致了代码重复和封装性不足的问题。为了解决这个问题，Java 9 引入私有方法。

  • 私有方法只能在定义它们的接口内部被访问。这就意味着接口可以有自己的内部逻辑，而不必将所有逻辑都暴露给实现该接口的类。这样，接口的设计者可以更好地控制接口的行为，并防止实现类误用接口内部的代码，增强了接口的封装性。
  • 由于私有方法只能在接口内部使用，无法在接口的实现类中被滥用，这有助于保持接口的一致性和约定。

在接口中使用私有方法有如下几个限制：

  1. 私有方法不能是抽象的。
  2. 私有方法只能在接口内部使用，无法被接口的实现类或外部类访问。
  3. 私有方法不会继承给接口的子接口，每个接口都必须自己定义自己的私有方法。
  4. 私有静态方法可以在其他静态和非静态接口方法中使用。
  5. 私有非静态方法不能在私有静态方法内部使用。

下面是私有方法的简单使用：

public interface MyInterface {
    private void print() {
        System.out.println("我是大明哥");
    }
}

更多关于接口私有方法，请阅读：Java 9 新特性—接口支持私有方法

总示例

下面用一个例子来演示上面所有功能。

public interface MyInterface {
    String NAME = "MyInterface";

    /**
     * 抽象方法，所有实现类都要实现
     * @return
     */
    void abstractMethod();

    /**
     * 默认方法
     */
    default void defaultMethod() {
        //默认方法里可以调用私有方法
        privateMethod();
        
        // 默认方法可以调用静态私有方法
        staticPrivateMethod();

        System.out.println("默认方法-MyInterface-defaultMethod");
    }

    /**
     * 静态方法
     * @return
     */
    static void staticMethod() {
        // 静态方法只能调用静态私有方法，不能调用私有方法
        System.out.println("静态方法-MyInterface-staticMethod");
    }

    /**
     * 私有方法
     */
    private void privateMethod() {
        System.out.println("私有方法-MyInterface-privateMethod");
    }
    
    /**
     * 静态私有方法
     */
    private static void staticPrivateMethod() {
        System.out.println("静态私有方法-MyInterface-staticPrivateMethod");
    }
}

接口 MyInterface 里面定义了抽象方法，默认方法，静态方法，私有方法。这里要注意一下几点：

  1. 私有方法为接口所有，只能在接口的默认方法中调用。
  2. 静态私有方法既可以在静态方法中调用，也可以在默认方法中调用。
  3. 默认方法也可以调用静态方法，但是静态方法不能调用默认方法。
  • 两个实现类
public class MyImplements1 implements MyInterface{

    @Override
    public void abstractMethod() {
        // 调用接口的静态方法
        MyInterface.staticMethod();

        System.out.println("抽象方法-MyImplements1-getName");
    }


    /**
     * 重写默认方法
     */
    @Override
    public void defaultMethod() {
        System.out.println("重写默认方法-MyImplements1-defaultMethod");
    }
}


public class MyImplements2 implements MyInterface{
    @Override
    public void abstractMethod() {
        // 调用接口的静态方法
        MyInterface.staticMethod();

        System.out.println("抽象方法-MyImplements1-getName");
    }
}

MyImplements1 重写了默认方法。所以当我们调用 MyImplements1 示例对象的 defaultMethod() 时，会调用到重写的这个方法。

  • 测试
public class InterfaceTest {
    public static void main(String[] args) {
        MyInterface implements1 = new MyImplements1();
        MyInterface implements2 = new MyImplements2();

        implements1.abstractMethod();
        implements1.defaultMethod();
        System.out.println("===========================");
        implements2.abstractMethod();
        implements2.defaultMethod();
    }
}
  • 运行结果
静态方法-MyInterface-staticMethod
抽象方法-MyImplements1-getName
重写默认方法-MyImplements1-defaultMethod
===========================
静态方法-MyInterface-staticMethod
抽象方法-MyImplements1-getName
私有方法-MyInterface-privateMethod
静态私有方法-MyInterface-staticPrivateMethod
静态方法-MyInterface-staticMethod
默认方法-MyInterface-defaultMethod

Java 面试宝典是大明哥全力打造的 Java 精品面试题，它是一份靠谱、强大、详细、经典的 Java 后端面试宝典。它不仅仅只是一道道面试题，而是一套完整的 Java 知识体系，一套你 Java 知识点的扫盲贴。

它的内容包括：

  • 大厂真题：Java 面试宝典里面的题目都是最近几年的高频的大厂面试真题。
  • 原创内容：Java 面试宝典内容全部都是大明哥原创，内容全面且通俗易懂，回答部分可以直接作为面试回答内容。
  • 持续更新：一次购买，永久有效。大明哥会持续更新 3+ 年，累计更新 1000+，宝典会不断迭代更新，保证最新、最全面。
  • 覆盖全面：本宝典累计更新 1000+，从 Java 入门到 Java 架构的高频面试题，实现 360° 全覆盖。
  • 不止面试：内容包含面试题解析、内容详解、知识扩展，它不仅仅只是一份面试题，更是一套完整的 Java 知识体系。
  • 宝典详情：https://www.yuque.com/chenssy/sike-java/xvlo920axlp7sf4k
  • 宝典总览：https://www.yuque.com/chenssy/sike-java/yogsehzntzgp4ly1
  • 宝典进展：https://www.yuque.com/chenssy/sike-java/en9ned7loo47z5aw

目前 Java 面试宝典累计更新 400+ 道，总字数 42w+。大明哥还在持续更新中，下图是大明哥在 2024-12 月份的更新情况：

想了解详情的小伙伴，扫描下面二维码加大明哥微信【daming091】咨询

同时，大明哥也整理一套目前市面最常见的热点面试题。微信搜[大明哥聊 Java]或扫描下方二维码关注大明哥的原创公众号[大明哥聊 Java] ，回复【面试题】 即可免费领取。

阅读全文
文章标签： 死磕 Java 基础死磕 Java