Java反射机制
Class类和实例化Class对象
Java Reflection
Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法
Java反射机制提供的功能
●在运行时判断任意一个对象所属的类
●在运行时构造任意一个类的对象
●在运行时判断任意一个类所具有的成员变量和方法
●在运行时调用任意一个对象的成员变量和方法
●生成动态代理
Class类
在Object类中定义了以下的方法，此方法将被所有子类继承：
public final Class getClass()
以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。
特点
◆ Class本身也是一个类
◆ Class 对象只能由系统建立对象
◆ 一个类在JVM 中只会有一个Class实例
◆ 一个Class对象对应的是一个加载到JVM中的一个.class文件
◆ 每个类的实例都会记得自己是由哪个Class 实例所生成
◆ 通过Class可以完整地得到一个类中的完整结构
常用方法
实例化Class类对象的四种方法
通过类的class属性获取
该方法最为安全可靠，程序性能最高
Class clazz = String.class;
用实例的getClass()方法获取Class对象
Class clazz = person.getClass();
通过Class类的静态方法forName()获取
Class clazz = Class.forName("java.lang.String");
其他（了解）
ClassLoader cl = this.getClass().getClassLoader();
Class clazz = cl.loadClass("类的全类名");
示例
Person类
package com.qingsu.reflection;
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
public void show() {
System.out.println(name+":"+age);
}
}
测试类
package com.qingsu.reflection;
import static org.junit.Assert.*;
import org.junit.Test;
public class ReflectionTestOne {
//没有反射概念之前 我们如何使用对象 1.实例化对象 2.调用对象的属性和方法
@Test
public void test01() throws Exception {
Person person = new Person();
person.setAge(18);
person.setName("张三");
person.show();
}
//有了反射我们多了一种对象的使用方式
@Test
public void test02() throws Exception {
//返回Class对象
Class clazz = Person.class;
//使用clazz 实例化对象
Person person = (Person) clazz.newInstance();
person.setAge(20);
person.setName("王五");
person.show();
}
//返回class对象的四种方式
@Test
public void test03() throws Exception {
System.out.println("--------------------第一种--------------------");
//第一种 通过类的class属性获取
Class c1 = Person.class;
Person person = (Person) c1.newInstance();
person.setAge(20);
person.setName("王五");
person.show();
System.out.println("--------------------第二种--------------------");
//第二种 通过getClass()方法获取Class对象
Class c2 = person.getClass();
Person person2 = (Person) c1.newInstance();
person2.setAge(26);
person2.setName("李四");
person2.show();
System.out.println("--------------------第三种--------------------");
//第三种 已知类的全路径调用forName方法
Class c3 = Class.forName("com.qingsu.reflection.Person");
Person person3 = (Person) c3.newInstance();
person3.setAge(24);
person3.setName("珊珊");
person3.show();
System.out.println("--------------------第四种--------------------");
ClassLoader cl = this.getClass().getClassLoader();
Class c4 = cl.loadClass("com.qingsu.reflection.Person");
Person person4 = (Person) c4.newInstance();
person4.setAge(36);
person4.setName("老刘");
person4.show();
}
}
运行时创建类对象并获取完整结构
类的加载过程
当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。
ClassLoader（类加载器）
类加载器是用来把类(class)装载进内存的。JVM 规范定义了两种类型的类加载器：启动类加载器(bootstrap)和用户自定义加载器(user-defined class loader)。JVM在运行时会产生3个类加载器组成的初始化加载器层次结构
获取类的完整结构
创建类对象 newInstance()
1）类必须有一个无参数的构造器。（没有无参构造器调用时需要传递参数）
2）类的构造器的访问权限需要足够。
示例
package com.qingsu.reflection;
import static org.junit.Assert.*;
import java.lang.reflect.Constructor;
import javax.swing.SpringLayout.Constraints;
import org.junit.Test;
public class ReflectionTestTwo {
@Test
public void test01() throws Exception {
//调用无参构造
Class c1 = Person.class;
Person person1 = (Person)c1.newInstance();
person1.setAge(16);
person1.setName("王五");
person1.show();
//调用有参构造
Class c2 = Person.class;
//获取构造器 Constraints
Constructor ct1 = c2.getDeclaredConstructor(String.class,int.class);
Person person2 = (Person) ct1.newInstance("李四",19);
person2.show();
}
}
获取接口
public Class<?>[] getInterfaces()
确定此对象所表示的类或接口实现的接口。
获取所继承的父类
public Class<? Super T> getSuperclass()
返回表示此Class 所表示的实体（类、接口、基本类型）的父类的Class
获取全部构造器
public Constructor<T>[] getConstructors()
返回此Class 对象所表示的类的所有public构造方法。
public Constructor<T>[] getDeclaredConstructors()
返回此Class 对象表示的类声明的所有构造方法。
◆Constructor类中：
◆取得修饰符: public int getModifiers();
◆取得方法名称: public String getName();
◆取得参数的类型：public Class<?>[] getParameterTypes();
获取全部方法
public Method[] getDeclaredMethods()
返回此Class对象所表示的类或接口的全部方法
public Method[] getMethods()
Method类中：
◆public Class<?> getReturnType()取得全部的返回值
◆public Class<?>[] getParameterTypes()取得全部的参数
◆public int getModifiers()取得修饰符
◆public Class<?>[] getExceptionTypes()取得异常信息
返回此Class对象所表示的类或接口的public的方法
获取全部的Field
public Field[] getFields()
返回此Class对象所表示的类或接口的public的Field。
public Field[] getDeclaredFields()
返回此Class对象所表示的类或接口的全部Field。
Field方法中：
◆public int getModifiers() 以整数形式返回此Field的修饰符
◆public Class<?> getType() 得到Field的属性类型
◆public String getName() 返回Field的名称。
获取泛型
获取父类泛型类型：Type getGenericSuperclass()
泛型类型：ParameterizedType
获取实际的泛型类型参数数组：getActualTypeArguments()
类所在的包
Package getPackage()
示例
package com.qingsu.reflection;
import static org.junit.Assert.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Field;
import org.junit.Test;
public class ReflectionTestThree {
//获取运行时的父类
@Test
public void test01() throws Exception {
System.out.println("-----------------获取父类---------------");
Class c1 = Person.class;
//获取运行时的父类
Class superClass = c1.getSuperclass();
System.out.println(superClass.getName());
}
//获取接口
@Test
public void test02() throws Exception {
System.out.println("-----------------获取接口---------------");
Class c2 = Person.class;
//获取运行时的接口 此时Person已经实现了IFood接口
Class[] interfaces = c2.getInterfaces();
for (Class c : interfaces) {
System.out.println(c.getName());
}
}
//获取包
@Test
public void test03() throws Exception {
System.out.println("-----------------获取包---------------");
Class c3 = Person.class;
//获取运行时的接口 此时Person已经实现了IFood接口
Package package1 = c3.getPackage();
System.out.println(package1);
}
//获取构造方法
@Test
public void test04() throws Exception {
System.out.println("-----------------获取构造方法---------------");
Class c4 = Person.class;
//获取运行时的接口 此时Person已经实现了IFood接口
//getConstructors 获取public权限的方法 获取非公开权限的方法
Constructor[] constructors = c4.getDeclaredConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor.getName());
//获取修饰符
System.out.println(constructor.getModifiers());
//获取参数类型
System.out.println(constructor.getParameterTypes());
}
}
//获取所有方法
@Test
public void test05() throws Exception {
System.out.println("-----------------获取成员方法---------------");
Class c5 = Person.class;
Method[] declaredMethods = c5.getDeclaredMethods();
for (Method method : declaredMethods) {
System.out.println(method);
System.out.println(method.getModifiers());
System.out.println(method.getParameterTypes());
}
}
//获取所有属性
@Test
public void test06() throws Exception {
System.out.println("-----------------获取属性---------------");
Class c5 = Person.class;
Field[] fields = c5.getDeclaredFields();
for (Field field : fields) {
System.out.println(field);
}
}
}
通过反射调用类的指定方法、指定属性
调用指定方法
通过反射，调用类中的方法，通过Method类完成。
1.通过Class类的getMethod(String name,Class…parameterTypes)方法取得一个Method对象，并设置此方法操作时所需要的参数类型。
2.之后使用Object invoke(Object obj, Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息
1.Object 对应原方法的返回值，若原方法无返回值，此时返回null
2.若原方法若为静态方法，此时形参Object obj可为null
3.若原方法形参列表为空，则Object[] args为null
4.若原方法声明为private,则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。
调用指定属性
在反射机制中，可以直接通过Field类操作类中的属性，通过Field类提供的set()和get()方法就可以完成设置和取得属性内容的操作。
●public Field getField(String name) 返回此Class对象表示的类或接口的指定的public的Field。
●public Field getDeclaredField(String name)返回此Class对象表示的类或接口的指定的Field。
●在Field中：
●public Object get(Object obj) 取得指定对象obj上此Field的属性内容
●public void set(Object obj,Object value) 设置指定对象obj上此Field的属性内容注：在类中属性都设置为private的前提下，在使用set()和get()方法时，首先要使用Field类中的setAccessible(true)方法将需要操作的属性设置为可以被外部访问。
●public void setAccessible(true)访问私有属性时，让这个属性可见。
示例
public class ReflectionTestFour {
@Test
public void test01() throws Exception {
Class c1 = Person.class;
Method method = (Method) c1.getMethod("show");
Person person = (Person) c1.newInstance();
Object invoke = method.invoke(person);
}
}
扫一扫
1056
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
