1.反射基本概念：
01.定义：
反射是指在程序运行期间，能够观察和修改类或者类的对象的属性和行为的特性！
02.作用：
001.在运行期间获取类的修饰符，包名，类名，实现的接口，继承的父类。
002.在运行期间获取类的所有属性名，修饰符，属性类型。
003.在运行期间获取所有方法，方法的返回值类型，方法名，方法参数数量，方法参数类型。
004.在运行期间加载类的方法。
03.java反射API常用的类
001.java.lang.Class
002.java.lang.reflect.Method
003.java.lang.Constructor
004.java.lang.Filed
005.java.lang.Modifier
2.例子
01.使用java反射获取类的信息
001.父类代码
package cn.pb.bean;
/**
* 父类
*
* @author Administrator
*
*/
public class FatherTest {
private String teststr = "测试用";
public String getTeststr() {
return teststr;
}
public void setTeststr(String teststr) {
this.teststr = teststr;
}
}
002.子类代码
package cn.pb.bean;
/**
* 测试类 人类 继承了父类
*/
import java.io.Serializable;
public class Person extends FatherTest implements Serializable {
private int id;
private String name;
private String address;
private String message;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public Person() {
super();
}
public Person(int id, String name, String address, String message) {
super();
this.id = id;
this.name = name;
this.address = address;
this.message = message;
}
}
003.测试类代码：
package cn.pb.test;
/**
* 测试类 通过反射获取类的信息
*
* @author Administrator
*
*/
public class GetClassInfo {
public void test(String className) throws Exception {
// 获取Person类对象 传递的className为类的全类名
Class clazz = Class.forName(className);
// 获取类在的包名 clazz.getSimpleName()：获取类名
Package pkg = clazz.getPackage();
System.out.println(clazz.getSimpleName() + "定义在" + pkg.getName()
+ "包中！");
System.out.println("*********************");
// 获取此对象所表示的实体（类，接口，基本类型或者void）的超类Class
// 如果此对象是一个Object类，一个接口，一个基本类型或void，它的超类返回Null
// 如果此对象是一个数组类，返回表示Object类的Class对象
Class superClass = clazz.getSuperclass();
System.out.println(clazz.getSimpleName() + "的超类是"
+ superClass.getName());
System.out.println("*********************");
// 获取Person类所实现的接口
// 如果Person类没有实现任何接口，返回一个长度为0的数组
// 如果Person类是一个基本类型或者是void，那么也返回一个长度为0的数组
Class[] interfaces = clazz.getInterfaces();
System.out.println("所实现的接口有：");
for (Class c : interfaces) {
System.out.println(c.getName());
}
System.out.println("******************");
}
public static void main(String[] args) throws Exception {
GetClassInfo getClassInfo = new GetClassInfo();
getClassInfo.test("cn.pb.bean.Person");
}
}
02.使用java反射获取类的构造函数的参数列表，并通过构造函数实例化类
001.父类代码
package cn.pb.bean;
/**
* 父类
*
* @author Administrator
*
*/
public class FatherTest {
private String teststr = "测试用";
public String getTeststr() {
return teststr;
}
public void setTeststr(String teststr) {
this.teststr = teststr;
}
}
002.子类代码
package cn.pb.bean;
/**
* 测试类 人类 继承了父类
*/
import java.io.Serializable;
public class Person extends FatherTest implements Serializable {
private int id;
private String name;
private String address;
private String message;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public Person() {
super();
System.out.println("通过无参构造实例化Person对象");
}
public Person(int id, String name, String address, String message) {
super();
this.id = id;
this.name = name;
this.address = address;
this.message = message;
System.out.println("通过有参构造实例化Person对象");
}
@Override
public String toString() {
return "Person [id=" + id + ", name=" + name + ", address=" + address
+ ", message=" + message + "]";
}
}
003.测试代码
package cn.pb.test;
import java.lang.reflect.Constructor;
/**
* 使用java反射获取类的构造函数的参数列表，并通过构造函数实例化类
*
* @author Administrator
*
*/
public class GetClassConstructorInfo {
/**
* 通过反射实例化类的对象
*
* @throws Exception
*/
public void test1() throws Exception {
// 参数calssName，为类的全类名
Class clazz = Class.forName("cn.pb.bean.Person");
// 通过clazz.newInstance()方法，获取类的实例
Object obj = clazz.newInstance();
System.out.println("通过反射实例化的对象：" + obj);
}
/**
* 通过反射获取类的构造函数
*
* @throws Exception
*/
public void test2() throws Exception {
// 参数calssName，为类的全类名
Class clazz = Class.forName("cn.pb.bean.Person");
// 获取类的构造函数,返回类的所有公共的构造函数
Constructor[] constructors = clazz.getConstructors();
System.out.println(clazz.getSimpleName() + "类的公共的构造函数以及构造函数的参数列表类型：");
for (Constructor constructor : constructors) {
System.out.println("构造函数的名称为：" + constructor.getName());
// 获取构造函数的所有参数
Class[] params = constructor.getParameterTypes();
if (params.length == 0) {
System.out.println("此构造函数没有参数！");
} else {
System.out.println("该构造函数的参数列表为：【");
for (int i = 0; i < params.length; i++) {
if (i != 0) {
System.out.println(",");
}
System.out.println(params[i].getName());
}
System.out.println("】");
}
}
// 获取无参构造,如果参数为空，则获取无参构造
Constructor constructor = clazz.getConstructor();
// 通过无参构造方法获取类的实例
Object obj = constructor.newInstance();
System.out.println("通过无参构造实例化的对象为：" + obj);
/**
* 获取有参构造 这个方法只能获得公共的有参构造 想要获取私有的构造方法 可以使用
* clazz.getDeclaredConstructor(int.class, String.class, String.class,
* String.class);方法
*/
Constructor constructor2 = clazz.getConstructor(int.class,
String.class, String.class, String.class);
Object obj2 = constructor2.newInstance(12, "xiix", "hah", "wawa");
System.out.println("通过有参构造实例化的 对象为：" + obj2);
}
public static void main(String[] args) throws Exception {
GetClassConstructorInfo test = new GetClassConstructorInfo();
// test.test1();
test.test2();
}
}
03.使用java反射获取类的所有方法的信息，并调用类的setter方法进行属性的赋值
001.父类代码
package cn.pb.bean;
/**
* 父类
*
* @author Administrator
*
*/
public class FatherTest {
private String teststr = "测试用";
public String getTeststr() {
return teststr;
}
public void setTeststr(String teststr) {
this.teststr = teststr;
}
}
002.子类代码
package cn.pb.bean;
/**
* 测试类 人类 继承了父类
*/
import java.io.Serializable;
public class Person extends FatherTest implements Serializable {
private int id;
private String name;
private String address;
private String message;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public Person() {
super();
System.out.println("通过无参构造实例化Person对象");
}
public Person(int id, String name, String address, String message) {
super();
this.id = id;
this.name = name;
this.address = address;
this.message = message;
System.out.println("通过有参构造实例化Person对象");
}
@Override
public String toString() {
return "Person [id=" + id + ", name=" + name + ", address=" + address
+ ", message=" + message + "]";
}
}
003.测试代码
package cn.pb.test;
/**
* 使用java反射获取类的所有方法的信息，并调用类的setter方法进行属性的赋值
*/
import java.lang.reflect.Method;
public class GetClassMethodsInfo {
/**
* 调用类的setter方法进行属性的赋值
*
* @param className
* 类的全类名
* @param propName
* 属性名
* @param propType
* 属性类型
* @param propValue
* 属性值
* @throws Exception
*/
public void invokeSetter(String className, String propName,
String propType, Object propValue) throws Exception {
// 通过反射获取类的实例
Class clazz = Class.forName(className);
Object obj = clazz.newInstance();
// 将传过来的属性名 转换成set方法
String methodName = "set" + propName.substring(0, 1).toUpperCase()
+ propName.substring(1);
// 根据set方法名和参数列表获取set方法
Method method = clazz.getDeclaredMethod(methodName,
Class.forName(propType));
// 如果需要可以设置setAccessible方法，设置为可以访问
// method.setAccessible(true);
// 调用方法并传参 参数为：方法所属的对象和方法的参数
method.invoke(obj, propValue);//
System.out.println("通过set方法给类的属性赋值：" + obj);
}
/**
* 使用java反射获取类的所有方法的信息
*/
public void showMethods() throws Exception {
Method[] methods;
// 获取Person类中的所有的方法，不包括继承的类的方法
// 如果该类或接口没有生命任何方法，或者此Class 对象表示一个基本数据类型，一个数组类或void
// 那么返回一个长度为0的数组
methods = Class.forName("cn.pb.bean.Person").getDeclaredMethods();
System.out.println("******展示方法信息********");
for (Method method : methods) {
System.out.println("方法名：" + method.getName());
System.out.println("方法返回值类型：" + method.getReturnType().getName());
// 获取方法的参数列表
Class[] params = method.getParameterTypes();
if (params.length == 0) {
System.out.println("该方法没有参数！");
} else {
System.out.println("该方法的参数列表为：【");
for (int i = 0; i < params.length; i++) {
if (i != 0) {
System.out.println(",");
}
System.out.println(params[i].getName());
}
System.out.println("】");
}
// 获取方法所属的类或接口的class对象
Class declaringClass = method.getDeclaringClass();
System.out.println("方法声明在：" + declaringClass.getName() + "中！");
// 获取方法抛出的异常的类型，即throws子句中声明的异常
Class[] exceptions = method.getExceptionTypes();
if (exceptions.length > 0) {
System.out.println("该方法抛出的异常有：【");
for (int i = 0; i < exceptions.length; i++) {
if (i != 0) {
System.out.println(",");
}
System.out.println(exceptions[i].getName());
}
System.out.println("】");
}
System.out.println("***********************");
}
}
public static void main(String[] args) throws Exception {
GetClassMethodsInfo test = new GetClassMethodsInfo();
// test.invokeSetter("cn.pb.bean.Person", "name", "java.lang.String",
// "zhangsan");
test.showMethods();
}
}
04.使用java反射获取类的所有属性的名称和类型，并为其中一个属性赋值
001.父类代码
package cn.pb.bean;
/**
* 父类
*
* @author Administrator
*
*/
public class FatherTest {
private String teststr = "测试用";
public String getTeststr() {
return teststr;
}
public void setTeststr(String teststr) {
this.teststr = teststr;
}
}
002.子类代码
package cn.pb.bean;
/**
* 测试类 人类 继承了父类
*/
import java.io.Serializable;
public class Person extends FatherTest implements Serializable {
private int id;
private String name;
private String address;
private String message;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public Person() {
super();
System.out.println("通过无参构造实例化Person对象");
}
public Person(int id, String name, String address, String message) {
super();
this.id = id;
this.name = name;
this.address = address;
this.message = message;
System.out.println("通过有参构造实例化Person对象");
}
@Override
public String toString() {
return "Person [id=" + id + ", name=" + name + ", address=" + address
+ ", message=" + message + "]";
}
}
003.测试代码
package cn.pb.test;
import java.lang.reflect.Field;
/**
* 使用java反射获取类的所有属性的名称和类型，并为其中一个属性赋值
*
* @author Administrator
*
*/
public class GetClassFieldsInfo {
/**
* 使用java反射获取类的所有属性的名称和类型
*
* @throws Exception
*/
public void showFields() throws Exception {
Field[] fields;
// 获取Person类中的所有字段，但不包括继承的字段
// 如果该类或接口不声明任何字段，或者此Class 对象表示一个基本数据类型，一个数组类或void
// 那么返回一个长度为0的数组
fields = Class.forName("cn.pb.bean.Person").getDeclaredFields();
// 遍历
System.out.println("**********字段展示***********");
for (Field field : fields) {
System.out.println("字段名：" + field.getName());
System.out.println("字段类型：" + field.getType().getName());
System.out.println("********************");
}
}
/**
* 通过使用反射操作person类的字段 使用java反射获取类的对象的实例，并为其中一个属性赋值
*/
public void accessField() throws Exception {
// 通过反射加载一个Person实例
Class clazz = Class.forName("cn.pb.bean.Person");
Object obj = clazz.newInstance();
// 通过getDeclaredField("address")方法 获取类的指定字段
Field address = clazz.getDeclaredField("address");
// address字段为private，这里已经超出其访问范围，不能直接访问
// 通过setAccessable方法，设定为可以访问
address.setAccessible(true);
System.out.println("赋值前的address：" + address.get(obj));
// 为address属性赋值
address.set(obj, "北大青鸟");
System.out.println("赋值之后的address:" + address.get(obj));
}
public static void main(String[] args) throws Exception {
GetClassFieldsInfo test = new GetClassFieldsInfo();
test.showFields();
test.accessField();
}
}