Java反射机制应用问题示例

原创 ╰+攻爆jí腚メ 2024-11-08 06:06 7阅读 0赞

Java反射机制是一种强大的功能，它允许程序在运行时访问和操作类和对象的属性、方法和构造函数。以下是一些Java反射机制的应用示例：

###1.动态创建对象```javaClass<?> clazz = Class.forName("java.lang.String");
Object obj = clazz.newInstance();
System.out.println(obj); // 输出：null```###2. 获取类的方法并调用```javaClass<?> clazz = Class.forName("java.lang.String");
Method method = clazz.getMethod("valueOf", boolean.class);
String result = (String) method.invoke(null, true);
System.out.println(result); // 输出：true```###3. 获取类的属性并设置值```javaClass<?> clazz = Class.forName("java.util.Properties");
Constructor<?> constructor = clazz.getConstructor();
Object obj = constructor.newInstance();
Method method = clazz.getMethod("setProperty", String.class, String.class);
method.invoke(obj, "key", "value");

Method getMethod = clazz.getMethod("getProperty", String.class);
String value = (String) getMethod.invoke(obj, "key");
System.out.println(value); // 输出：value```###4. 获取类的构造函数并创建对象```javaClass<?> clazz = Class.forName("java.util.ArrayList");
Constructor<?> constructor = clazz.getConstructor(int.class);
Object obj = constructor.newInstance(10);
System.out.println(obj); // 输出：[Ljava.util.ArrayList;@...
```###5. 获取类的注解```javaClass<?> clazz = Class.forName("java.lang.Override");
Annotation[] annotations = clazz.getAnnotations();
for (Annotation annotation : annotations) {
 System.out.println(annotation.annotationType().getName());
}
```###6.动态代理```javaimport java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class DynamicProxyExample {
 public static void main(String[] args) {
 final RealSubject realSubject = new RealSubject();
InvocationHandler handler = new InvocationHandler() {
@Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 System.out.println("Before method: " + method.getName());
Object result = method.invoke(realSubject, args);
 System.out.println("After method: " + method.getName());
 return result;
 }
};
Subject proxyInstance = (Subject) Proxy.newProxyInstance(
Subject.class.getClassLoader(),
 new Class[] { Subject.class },
 handler);
 proxyInstance.request();
 }
}

interface Subject {
 void request();
}

class RealSubject implements Subject {
 public void request() {
 System.out.println("RealSubject: request");
 }
}
```这些示例展示了Java反射机制的一些常见应用场景。反射机制虽然强大，但也应谨慎使用，因为它可能会降低代码的可读性和性能。