java 动态性

Java 动态性

Java 是一种静态类型的编程语言，其特点是在编译时进行类型检查，确保变量和方法的正确使用。然而，Java 也提供了一些机制来实现动态性，让开发者在运行时可以动态地创建、加载和执行代码。本文将介绍几种 Java 的动态性特性，并提供相应的代码示例。

反射（Reflection）

反射是 Java 提供的一种机制，用于在运行时检查、访问和修改类、对象、方法和属性的信息。通过反射，可以在程序运行时获得类的结构信息，实例化对象，调用方法和获取/设置属性的值。

下面是一个简单的示例，演示了如何使用反射来实例化对象并调用其中的方法：

public class MyClass {
    public void myMethod() {
        System.out.println("Hello, World!");
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("MyClass");
        Object obj = clazz.newInstance();
        Method method = clazz.getMethod("myMethod");
        method.invoke(obj);
    }
}

上述代码通过 Class.forName() 方法加载 MyClass 类，并使用 newInstance() 方法实例化一个对象。然后，通过 getMethod() 方法获取 myMethod 方法的引用，最后通过 invoke() 方法调用该方法。

动态代理（Dynamic Proxy）

动态代理是一种实现代理模式的方式，它可以在运行时创建代理对象，代理对象可以拦截并委托给真实对象执行相应的操作。在 Java 中，动态代理是通过 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来实现的。

下面是一个简单的示例，演示了如何使用动态代理来拦截方法调用：

public interface MyInterface {
    void myMethod();
}

public class MyRealObject implements MyInterface {
    public void myMethod() {
        System.out.println("Hello, World!");
    }
}

public class MyInvocationHandler implements InvocationHandler {
    private Object target;

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

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

public class Main {
    public static void main(String[] args) {
        MyInterface realObject = new MyRealObject();
        MyInvocationHandler handler = new MyInvocationHandler(realObject);
        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
                realObject.getClass().getClassLoader(),
                realObject.getClass().getInterfaces(),
                handler);
        proxy.myMethod();
    }
}

上述代码定义了一个接口 MyInterface 和一个实现该接口的类 MyRealObject。然后，定义了一个实现 InvocationHandler 接口的类 MyInvocationHandler，该类可以在方法调用前后进行一些操作。最后，在 Main 类中通过 Proxy.newProxyInstance() 方法创建了一个代理对象，并将方法调用委托给 MyInvocationHandler 处理。

动态编译（Dynamic Compilation）

动态编译是指在程序运行时动态地将源代码编译成字节码，并加载到 JVM 中执行。Java 提供了一些工具类和接口，如 javax.tools.JavaCompiler 和 java.lang.ClassLoader，用于实现动态编译。

下面是一个简单的示例，演示了如何使用动态编译来动态执行代码：

public class Main {
    public static void main(String[] args) throws Exception {
        String sourceCode = "public class MyClass { public void myMethod() { System.out.println(\"Hello, World!\"); } }";
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
        JavaFileObject source = new JavaSourceFromString("MyClass", sourceCode);
        JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, null, null, null, Arrays.asList(source));
        task.call();
        fileManager.close();

        URLClassLoader classLoader = URLClassLoader.newInstance(new URL[] { new File("").toURI().toURL() });
        Class<?> clazz = classLoader.loadClass("MyClass");
        Object obj = clazz.newInstance();
        Method method = clazz.getMethod("myMethod");
        method.invoke(obj);
    }
}

public class JavaSourceFromString