如何使用LambdaMetafactory调用默认构造函数

import java.lang.invoke.CallSite;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles.Lookup;
import java.lang.reflect.Constructor;

interface MyFunctionalInterface {
    void myMethod();
}

public class Main {
    public static void main(String[] args) throws Throwable {
        // 定义函数式接口
        Class<?> functionalInterface = MyFunctionalInterface.class;

        // 获取默认构造函数
        Constructor<?> defaultConstructor = MyClass.class.getDeclaredConstructor();

        // 创建MethodType，用于描述方法的返回类型和参数类型
        MethodType methodType = MethodType.methodType(void.class);

        // 获取MethodHandles.Lookup对象
        Lookup lookup = MethodHandles.lookup();

        // 创建CallSite对象
        CallSite callSite = LambdaMetafactory.metafactory(
                lookup,
                "myMethod",
                MethodType.methodType(functionalInterface),
                methodType,
                lookup.findConstructor(MyClass.class, methodType),
                methodType
        );

        // 获取MethodHandle
        MethodHandle methodHandle = callSite.dynamicInvoker();

        // 调用默认构造函数
        MyFunctionalInterface instance = (MyFunctionalInterface) methodHandle.invoke();

        // 调用函数式接口的方法
        instance.myMethod();
    }
}

class MyClass {
    public MyClass() {
        System.out.println("Default constructor called.");
    }
}