第23 章 ： 反射与类操作
104 反射获取类结构信息
反射机制处理不仅仅只是一个实例化对象的处理，
更多情况下还有类的组成结构操作
任何一个类的组成结构：
父类、父接口、包、属性、方法（构造方法，普通方法）
// 获取包名
public Package getPackage()
// 获取继承父类
public native Class<? super T> getSuperclass()
// 获取实现父接口
public Class<?>[] getInterfaces()
import java.util.Arrays;
abstract class AbstractHuman{
}
interface IConnectService{
public boolean isConnect();
}
interface IChannelService{
public void send();
}
class Person extends AbstractHuman implements IConnectService, IChannelService{
@Override
public boolean isConnect() {
return true;
}
@Override
public void send() {
if(this.isConnect()){
System.out.println("发送");
}
}
}
class Demo{
public static void main(String[] args) {
Class<?> cls = Person.class;
System.out.println(cls.getPackage());
// null
System.out.println(cls.getSuperclass());
// class AbstractHuman
System.out.println(Arrays.toString(cls.getInterfaces()));
// [interface IConnectService, interface IChannelService]
}
}
105 反射调用构造方法
实例化方法
// 获取指定构造方法
public Constructor<T> getConstructor(Class<?>... parameterTypes)
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
// 获取全部构造方法
public Constructor<?>[] getConstructors()
public Constructor<?>[] getDeclaredConstructors()
Class.getDeclaredConstructor().newInstance()
class Person{
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
class Demo{
public static void main(String[] args) throws Exception {
Class<?> cls = Person.class;
// 获取有参构造
Constructor constructor = cls.getConstructor(String.class, int.class);
Object obj = constructor.newInstance("小强", 23);
System.out.println(obj);
// Person{name='小强', age=23}
}
}
使用反射的类最好提供无参构造方法，便于统一操作
继承关系
AccessibleObject(AnnotatedElement)
-Executable
-Constructor
-Method
-Field(Member)
106 反射调用普通方法
了解即可
// 获取指定方法
public Method getMethod(String name, Class<?>... parameterTypes)
// 获取全部方法
public Method[] getMethods()
// 获取本类方法
public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
// 获取本类全部方法
public Method[] getDeclaredMethods()
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
class Person {
public String geMessage(String message) {
return message;
}
}
class Demo {
public static void main(String[] args) throws Exception {
Class<?> cls = Person.class;
Method method = cls.getMethod("geMessage", String.class);
System.out.println(method);
// public java.lang.String Person.geMessage(java.lang.String)
System.out.println(Modifier.toString(method.getModifiers()));
// public
System.out.println(method.getReturnType().getName());
// java.lang.String
System.out.println(method.getName());
// geMessage
System.out.println(Arrays.toString(method.getParameterTypes()));
// [class java.lang.String]
}
}
Method类 重要方法 invoke
// 反射调用类中的方法
public Object invoke(Object obj, Object... args)
整个操作形式上没有任何明确的类对象产生，依靠反射操作，避免耦合问题
import java.lang.reflect.Method;
class Person {
private String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class Demo {
public static void main(String[] args) throws Exception {
Class<?> cls = Class.forName("Person");
String key = "name";
String value = "Tom";
// 获取指定方法
Method setNameMethod = cls.getMethod("setName", String.class);
Method getNameMethod = cls.getMethod("getName");
// 调用无参构造方法实例化
Object obj = cls.getDeclaredConstructor().newInstance();
setNameMethod.invoke(obj, value); // 等价于 person.setName(value)
System.out.println(getNameMethod.invoke(obj));
// Tom
}
}
107 反射调用成员
// 获取本类全部成员
public Field[] getDeclaredFields()
// 获取本类指定成员
public Field getDeclaredField(String name)
// 获取父类全部成员
public Field[] getFields()
// 获取父类指定成员
public Field getField(String name)
Field 类
// 设置属性内容
public void set(Object obj, Object value)
// 获取属性内容
public Object get(Object obj)
// 解除封装
public void setAccessible(boolean flag)
import java.lang.reflect.Field;
class Person {
private String name;
public Person() {
}
}
class Demo {
public static void main(String[] args) throws Exception {
Class<?> cls = Class.forName("Person");
Object obj = cls.getDeclaredConstructor().newInstance();
Field nameField = cls.getDeclaredField("name");
// 解除封装性，访问私有成员
nameField.setAccessible(true);
nameField.set(obj, "Tom");
System.out.println(nameField.get(obj));
// Tom
}
}
不建议打破封装机制
Field类重要方法 getType
public Class<?> getType()
Class<?> cls = Class.forName("Person");
Field nameField = cls.getDeclaredField("name");
System.out.println(nameField.getType());
// class java.lang.String
System.out.println(nameField.getType().getName());
// 获取包.类 java.lang.String
System.out.println(nameField.getType().getSimpleName());
// 获取类名称 String
108 Unsafe工具类
通过反射获取对象，并且直接使用底层的C++代码
可以绕过JVM相关管理机制，就无法使用内存管理和垃圾回收
Unsafe 类
public final class Unsafe {
private static final Unsafe theUnsafe;
private Unsafe() {}
}
Unsafe绕过实例化对象的管理
import sun.misc.Unsafe;
import java.lang.reflect.Field;
// 将构造函数私有化
class Person{
private Person(){};
public void print(){
System.out.println("hi");
}
}
class Demo {
public static void main(String[] args) throws Exception {
Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafeField.setAccessible(true);
Unsafe unsafeObject = (Unsafe) theUnsafeField.get(null);
// 通过unsafe 实例化构造函数私有化的对象
Person person = (Person) unsafeObject.allocateInstance(Person.class);
person.print();
// hi
}
}
如果不是必须的情况下，不建议使用
Unsafe 类也是单例设计
