在Java中模拟静态方法调用的静态抽象和动态链接

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface MyInterface {
    static void staticMethod() {
        System.out.println("Static method called");
    }

    default void defaultMethod() {
        System.out.println("Default method called");
    }
}

class MyInvocationHandler implements InvocationHandler {
    private Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method called");
        Object result = method.invoke(target, args);
        System.out.println("After method called");
        return result;
    }
}

class MyImpl implements MyInterface {
    public void defaultMethod() {
        System.out.println("Default method overridden");
    }
}

public class Main {
    public static void main(String[] args) {
        MyInterface myInterface = new MyImpl();
        myInterface.defaultMethod();
        MyInterface.staticMethod();

        MyInterface proxyInterface = (MyInterface) Proxy.newProxyInstance(
                MyInterface.class.getClassLoader(),
                new Class<?>[]{MyInterface.class},
                new MyInvocationHandler(new MyImpl())
        );
        proxyInterface.defaultMethod();
    }
}