在运行时将2个类合并为一个类

在运行时将2个类合并为一个类的方法是通过使用动态代理。动态代理是一种在运行时创建代理类的技术，它允许将多个类的方法合并到一个类中。动态代理可以在运行时动态地生成代理类，并将多个类的方法合并到一个类中。这样，我们可以在运行时将2个类的方法合并为一个类，而无需手动编写代码。

以下是使用动态代理将2个类合并为一个类的示例代码：

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

public class DynamicProxyExample {

    public static void main(String[] args) {
        // 创建代理对象
        MyClass proxy = (MyClass) createProxy(new MyClass1(), new MyClass2());

        // 调用代理对象的方法
        proxy.method1();
        proxy.method2();
    }

    public static Object createProxy(Object obj1, Object obj2) {
        // 创建代理对象的类加载器
        ClassLoader classLoader = DynamicProxyExample.class.getClassLoader();

        // 创建代理对象的接口列表
        Class<?>[] interfaces = new Class<?>[] { MyClass.class };

        // 创建InvocationHandler对象
        InvocationHandler handler = new MyInvocationHandler(obj1, obj2);

        // 创建代理对象
        Object proxy = Proxy.newProxyInstance(classLoader, interfaces, handler);

        return proxy;
    }

    public static class MyClass1 implements MyClass {
        @Override
        public void method1() {
            System.out.println("MyClass1.method1()");
        }

        @Override
        public void method2() {
            System.out.println("MyClass1.method2()");
        }
    }

    public static class MyClass2 implements MyClass {
        @Override
        public void method1() {
            System.out.println("MyClass2.method1()");
        }

        @Override
        public void method2() {
            System.out.println("MyClass2.method2()");
        }
    }

    public static interface MyClass {
        void method1();
        void method2();
    }

    public static class MyInvocationHandler implements InvocationHandler {
        private Object obj1;
        private Object obj2;

        public MyInvocationHandler(Object obj1, Object obj2) {
            this.obj1 = obj1;
            this.obj2 = obj2;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // 根据方法名判断调用哪个对象的方法
            if (method.getName().equals("method1")) {
                method.invoke(obj1, args);
            } else if (method.getName().equals("method2")) {
                method.invoke(obj2, args);
            }

            return null;
        }
    }
}

在上面的示例代码中，我们创建了一个代理对象，它将2个类的方法合并到一个类中。代理对象的方法可以根据方法名动态地调用不同的方法。这样，我们可以在运行时将2个类合并为一个类，并且可以动态地调用它们的方法。