接口中的default和static方法_接口中的static方法-优快云博客

前言

Java 8 于 2014 年 3 月发布，是一次重大的更新，引入了许多新特性，如 Lambda 表达式、流 API 以及 接口中的默认方法、静态方法。

接口中的默认方法

背景和原因

默认方法的引入是为了【增强接口的可扩展性】。Java 在引入默认方法之前，接口中只能包含抽象方法。这样，如果在接口中添加新方法，那么所有实现该接口的类都需要实现此新方法，这在维护和升级现有代码时带来了不便。为了解决这个问题并保持向后兼容，Java 8 引入了默认方法，使接口能够包含具有默认实现的方法，从而避免对实现类的修改。

用途

允许在接口中添加新方法而不破坏现有实现类。

供了一种简单的方法来为接口添加新功能。

示例

public interface MyInterface {
    default void defaultMethod(String s) {
        System.out.println("Default Method:" + s);
    }
}

class MyClass implements MyInterface {
}

说明:

默认方法也属于实例方法, 通过实例对象来访问
默认方法可以调用静态方法
默认方法可以被子类继承

默认方法的反射行为

默认方法可以像普通方法一样使用反射

@Test
void reflectDefaultMethod1() throws Exception {
    MyClass obj = new MyClass();
    Method method = MyInterface.class.getMethod("defaultMethod", String.class);
    method.invoke(obj, "reflectDefaultMethod1");
}

这种反射是最常见的一种

使用MethodHandles.Lookup实现反射调用

/**
 * 使用 MethodHandles.privateLookupIn 结合 findSpecial 方法查找特定类中的方法
 * 对比第二种方法更高效
 */
@Test
void defaultMethod1() throws Throwable {
    MethodHandles.Lookup lookup = MethodHandles.lookup();
    MethodType methodType = MethodType.methodType(void.class, String.class);
    MethodHandle methodHandle = lookup.findVirtual(MyInterface.class, "defaultMethod", methodType);
    methodHandle.invoke(new MyClass(), "参数1");
}

这是java7出现的一种对方法进行反问的api

MethodHandles 是 Java 中提供的一种低级但灵活的方式来直接访问和调用方法、字段和构造函数。它们在 java.lang.invoke 包中定义，主要用于实现动态语言支持、增强 Java 反射机制，以及提供更高效的调用操作。

MethodHandle：是一个类似于方法指针的对象，可以在运行时对方法进行调用。不同于 Java 反射中的 Method 对象，MethodHandle 更加轻量并且执行效率较高

findVirtual方法用于查找实例方法的 MethodHandle

特点和优势

高效调用：MethodHandle 的调用性能接近于直接调用，远高于传统反射调用

灵活性：支持动态语言实现和元编程。

安全性：MethodHandles.Lookup 使用访问控制机制，保证只能访问合法的类成员

这种机制被引入是为了增强 Java 7 及以上版本中的动态调用支持，特别是为了配合 invokedynamic 指令用于运行时方法解析和执行。

还可以按照如下方式使用

/**
 * 使用 Java 反射结合 MethodHandles.unreflectSpecial 方法来转换 Method 为 MethodHandle
 */
@Test
void defaultMethod2() throws Throwable {
    MethodHandles.Lookup lookup = MethodHandles.lookup();
    MethodHandles.Lookup privateLookupIn =
            (MethodHandles.Lookup) MethodHandles.class.getMethod("privateLookupIn", Class.class, MethodHandles.Lookup.class)
                    .invoke(null, MyInterface.class, lookup);

    Method defaultMethod = MyInterface.class.getMethod("defaultMethod", String.class);
    MethodHandle unboundHandle = privateLookupIn.unreflectSpecial(defaultMethod, MyInterface.class);
    MyClass myClass = new MyClass();
    MethodHandle handle = unboundHandle.bindTo(myClass);
    handle.invokeWithArguments("aa");
}

这种方式结合传统java反射也是先获取方法的MethodHandle句柄再调用具体方法。

其中unreflectSpecial将传统反射的 Method、Constructor、Field 转换为 MethodHandle。

在openFeign中就是使用的这种方式包装接口中的默认方法。感兴趣的小伙伴可以去了解一下MethodHandles.Lookup

注意:一个类实现了有多个相同默认方法的接口, 在覆盖方法的时候, 如果需要调用父类的默认方法, 需要手动指定具体是哪个接口

例如下面的例子

interface InterfaceA {
    default void defaultMethod() {
        System.out.println("Default Method in InterfaceA");
    }
}
interface InterfaceB {
    default void defaultMethod() {
        System.out.println("Default Method in InterfaceB");
    }
}
class MyClass2 implements InterfaceA, InterfaceB {
    @Override
    public void defaultMethod() {
        // 指定调用哪一个默认方法
        InterfaceA.super.defaultMethod();
    }
}

接口中的静态方法

在 Java 8 中，接口中引入了静态方法的概念。静态方法是可以在接口内声明并实现的方法，与类中的静态方法类似，它们不依赖于接口的实现类，可以直接通过接口本身调用。

1.声明与调用：

静态方法使用 static 关键字在接口中声明。调用时需要使用接口名称来调用，而不能通过实现类或接口实例来调用。

public interface MyInterface {
    static void staticMethod(String s) {
        System.out.println("Static Method:" + s);
    }
}

调用也很简单, 直接用接口名字调用就行, 例如:

@Test
void staticMethod() throws Throwable {
    MyInterface.staticMethod("staticMethod");
}

使用场景：

• 提供工具方法，类似于 java.util.Collections 中的工具类方法。

• 为接口增加功能方法，使实现类无需重复实现公共逻辑。

区别于默认方法：

• 静态方法只能通过接口调用，不能被实现类继承或重写。

• 默认方法可以被实现类继承或重写，是用于接口中定义默认实现的实例方法。

静态方法的反射行为

可以像普通的静态方法一样反射

@Test
void reflectStaticMethod() throws Throwable {
    Method method = MyInterface.class.getMethod("staticMethod", String.class);
    method.invoke(null, "aa");
}

也可以使用MethodHandle类实现反射

@Test
void reflectStaticMethod2() throws Throwable {
   MethodHandles.Lookup lookup = MethodHandles.lookup();
   MethodType methodType = MethodType.methodType(void.class, String.class);
   MethodHandle methodHandle = lookup.findStatic(MyInterface.class, "staticMethod", methodType);
   methodHandle.invoke("参数1");
}