一.反射的介绍
java反射机制就是在运行状态的时候,能瞒住下面两点:
1.对于任何一个类,都能够知道改类的所有属性和方法;
2.对于任何一个对象,都能调用改对象的任何方法和属性;
这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象,
而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象。
二.Class类
通过阅读API的Class类得知,Class 没有公共构造方法;
Class 对象是在加载类时,由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。
获取Class对象的三种方式:
1.通过Object类中的getObject()方法
Person p = new Person();
Class c = p.getClass();
2.通过 类名.class 获取到字节码文件对象(任意数据类型都具备一个class静态属性,看上去要比第一种方式简单)
Class c2 = Person.class;
3.通过Class类中的方法(将类名作为字符串传递给Class类中的静态方法forName即可)
Class c3 = Class.forName("Person");
第三种和前两种的区别:
1.前两种你必须明确Person类型;
2.后面是指定这种类型的字符串就行(这种扩展更强.我不需要知道你的类.我只提供字符串,按照配置文件加载就可以了)
Demo演示:
/*
* 获取.class字节码文件对象的方式
* 1:通过Object类中的getObject()方法
* 2: 通过 类名.class 获取到字节码文件对象
* 3: 反射中的方法,
* public static Class<?> forName(String className) throws ClassNotFoundException
* 返回与带有给定字符串名的类或接口相关联的 Class 对象
*/
public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException {
// 1: 通过Object类中的getObject()方法
// Person p1 = new Person();
// Class c1 = p1.getClass();
// System.out.println("c1 = "+ c1);
// 2: 通过 类名.class 获取到字节码文件对象
// Class c2 = Person.class;
// System.out.println("c2 = "+ c2);
// 3: 反射中的方法
Class c3 = Class.forName("cn.lsy.Person");// 包名.类名
System.out.println("c3 = " + c3);
}
}
Person类:
package cn.lsy;
public class Person {
//成员变量
public String name;
public int age;
private String address;
//构造方法
public Person() {
System.out.println("空参数构造方法");
}
public Person(String name) {
this.name = name;
System.out.println("带有String的构造方法");
}
//私有的构造方法
private Person(String name, int age){
this.name = name;
this.age = age;
System.out.println("带有String,int的构造方法");
}
public Person(String name, int age, String address){
this.name = name;
this.age = age;
this.address = address;
System.out.println("带有String, int, String的构造方法");
}
//成员方法
//没有返回值没有参数的方法
public void method1(){
System.out.println("没有返回值,没有参数的方法");
}
//没有返回值,有参数的方法
public void method2(String name){
System.out.println("没有返回值,有参数的方法 name= "+ name);
}
//有返回值,没有参数
public int method3(){
System.out.println("有返回值,没有参数的方法");
return 123;
}
//有返回值,有参数的方法
public String method4(String name){
System.out.println("有返回值,有参数的方法");
return "你好" + name;
}
//私有方法
private void method5(){
System.out.println("私有方法");
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", address=" + address+ "]";
}
}
在反射机制中,把类中的成员(构造方法、成员方法、成员变量)都封装成了对应的类进行表示。
其中,构造方法使用类Constructor表示,可通过Class类中提供的方法获取构造方法:
1.返回一个构造方法:
public Constructor<T> getConstructor(Class<?>... parameterTypes) 获取public修饰, 指定参数类型所对应的构造方法
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 获取指定参数类型所对应的构造方法(包含私有的)
2.返回多个构造方法
public Constructor<?>[] getConstructors() 获取所有的public 修饰的构造方法
public Constructor<?>[] getDeclaredConstructors() 获取所有的构造方法(包含私有的)
Demo演示:
ublic class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
//获取Class对象
Class c = Class.forName("cn.lsy.Person");//包名.类名
System.out.println("-----------获取所有的构造方法-----------");
//Constructor[] cons = c.getConstructors();
Constructor[] cons = c.getDeclaredConstructors();
for (Constructor con : cons) {
System.out.println(con);
}
System.out.println("-----------获取一个构造方法-------------");
//public Person()
Constructor con1 = c.getConstructor(null);
System.out.println(con1);
//public Person(String name)
Constructor con2 = c.getConstructor(String.class);
System.out.println(con2);
//private Person(String name, int age)
Constructor con3 = c.getDeclaredConstructor(String.class, int.class);
System.out.println(con3);
//public Person(String name, int age, String address)
Constructor con4 = c.getDeclaredConstructor(String.class, int.class, String.class);
System.out.println(con4);
}
}
获取构造方法,步骤如下:
1. 获取到Class对象
2. 获取指定的构造方法
3. 通过构造方法类Constructor中的方法,创建对象,public T newInstance(Object... initargs)
Demo演示:
public class ConstructorDemo {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException,
SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException,
InvocationTargetException {
//1,获取到Class对象
Class c = Class.forName("cn.lsy.Person");//包名.类名
//2,获取指定的构造方法
//public Person()
//Constructor con = c.getConstructor(null);
//public Person(String name, int age, String address)
Constructor con = c.getConstructor(String.class, int.class, String.class);
//3,通过构造方法类中Constructor的方法,创建对象
//Object obj = con.newInstance(null);
Object obj = con.newInstance("小明", 22, "哈尔滨");
//显示
System.out.println(obj);
}
}
分析:
1.AccessibleObject 类是 Field、Method 和 Constructor 对象的父类,它提供了将反射的对象标记为在使用时取消默认 Java 语言访 问控制检查的能力;
2.对于公共成员、默认(打包)访问成员、受保护成员和私有成员,在分别使用 Field、Method 或 Constructor 对象来设置或获取字段、调用方法,或者创建和初始化类的新实例的时候,会执行访问检查。
3.常用方法如下:
public void setAccessible(boolean flag) throws SecurityException
参数值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查;
参数值为 false 则指示反射的对象应该实施 Java 语言访问检查。
获取私有构造方法,步骤如下:
1. 获取到Class对象
2. 获取指定的构造方法
3. 暴力访问, 通过setAccessible(boolean flag)方法(共有和私有构造方法访问的唯一区别)
4. 通过构造方法类Constructor中的方法,创建对象,public T newInstance(Object... initargs)
Demo演示:
public class ConstructorDemo2 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException,
SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException,
InvocationTargetException {
//1,获取到Class对象
Class c = Class.forName("cn.lsy.Person");//包名.类名
//2,获取指定的构造方法
//private Person(String name, int age)
Constructor con = c.getDeclaredConstructor(String.class, int.class);
//3,暴力反射
con.setAccessible(true);//取消 Java 语言访问检查
//4,通过构造方法类中的功能,创建对象
Object obj = con.newInstance("小明", 23);
System.out.println(obj);
}
}
在反射机制中,类中的成员变量使用类Field表示。
可通过Class类中提供的方法获取成员变量:
1.返回一个成员变量
public Field getField(String name) 获取指定的 public修饰的变量
public Field getDeclaredField(String name) 获取指定的任意变量
2.返回多个成员变量
public Field[] getFields() 获取所有public 修饰的变量
public Field[] getDeclaredFields() 获取所有的 变量 (包含私有)
Demo演示:
public class FieldDemo {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException {
//获取Class对象
Class c = Class.forName("cn.lsy.Person");
//获取成员变量
//多个变量
//Field[] fields = c.getFields();
Field[] fields = c.getDeclaredFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("-----------------");
//一个变量
//public int age;
Field ageField = c.getField("age");
System.out.println(ageField);
//private String address
Field addressField = c.getDeclaredField("address");
System.out.println(addressField);
}
}
获取成员变量,步骤如下:
1. 获取Class对象
2. 获取构造方法
3. 通过构造方法,创建对象
4. 获取指定的成员变量(私有成员变量,通过setAccessible(boolean flag)方法暴力访问)
5. 通过方法,给指定对象的指定成员变量赋值或者获取值
public void set(Object obj, Object value) 在指定对象obj中,将此 Field 对象表示的成员变量设置为指定的新值
public Object get(Object obj) 返回指定对象obj中,此 Field 对象表示的成员变量的值
Demo演示:
public class FieldDemo2 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException,
SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException,
InvocationTargetException, NoSuchFieldException {
//1,获取Class对象
Class c = Class.forName("cn.lsy.Person");
//2,获取构造方法
//public Person(String name)
Constructor con = c.getConstructor(String.class);
//3,通过构造方法,创建对象
Object obj = con.newInstance("lsy");
//4,获取指定的成员变量
//public String name;
Field nameField = c.getField("name");
//public int age;
Field ageField = c.getField("age");
//private String address;
Field addressField = c.getDeclaredField("address");
addressField.setAccessible(true); //取消 Java 语言访问检查
//5,通过方法,给指定对象的指定成员变量赋值或者获取值
System.out.println("name = "+ nameField.get(obj));
System.out.println("age = "+ ageField.get(obj));
System.out.println("address = "+ addressField.get(obj));
//赋值
ageField.set(obj, 12);
addressField.set(obj, "马尔代夫");
System.out.println("------------------------");
System.out.println("name = "+ nameField.get(obj));
System.out.println("age = "+ ageField.get(obj));
System.out.println("address = "+ addressField.get(obj));
}
}
在反射机制中,把类中的成员方法使用类Method表示。
可通过Class类中提供的方法获取成员方法:
1.返回获取一个方法:
public Method getMethod(String name, Class<?>... parameterTypes)获取public 修饰的方法
public Method getDeclaredMethod(String name, Class<?>... parameterTypes)获取任意的方法,包含私有的
参数1: name 要查找的方法名称; 参数2: parameterTypes 该方法的参数类型
2.返回获取多个方法:
public Method[] getMethods() 获取本类与父类中所有public 修饰的方法
public Method[] getDeclaredMethods() 获取本类中所有的方法(包含私有的)
Demo演示:
public class MethodDemo {
public static void main(String[] args) throws ClassNotFoundException,
NoSuchMethodException, SecurityException {
//获取Class对象
Class c = Class.forName("cn.lsy.Person");
//获取多个方法
//Method[] methods = c.getMethods();
Method[] methods = c.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println("-----------------------");
//获取一个方法:
//public void method1()
Method method = c.getMethod("method1", null);
System.out.println(method);
//public String method4(String name){
method = c.getMethod("method4", String.class);
System.out.println(method);
//私有方法
//private void method5()
method = c.getDeclaredMethod("method5", null);
System.out.println(method);
}
}
获取成员方法,步骤如下:
1. 获取Class对象
2. 获取构造方法
3. 通过构造方法,创建对象
4. 获取指定的方法
5. 执行找到的方法
public Object invoke(Object obj, Object... args)
执行指定对象obj中,当前Method对象所代表的方法,方法要传入的参数通过args指定。
public class MethodDemo2 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException,
SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException,
InvocationTargetException {
//1, 获取Class对象
Class c = Class.forName("cn.lsy.Person");
//2,获取构造方法
//public Person(String name, int age, String address){
Constructor con = c.getConstructor(String.class, int.class, String.class);
//3,通过构造方法,创建对象
Object obj = con.newInstance("小明", 23, "哈尔滨");
//4,获取指定的方法
//public void method1() 没有返回值没有参数的方法
//Method m1 = c.getMethod("method1", null);
//public String method4(String name)
Method m4 = c.getMethod("method4", String.class);
//5,执行找到的方法
//m1.invoke(obj, null);
Object result = m4.invoke(obj, "itcast");
System.out.println("result = " + result);
}
}
获取私有成员方法,步骤如下:
1. 获取Class对象
2. 获取构造方法
3. 通过构造方法,创建对象
4. 获取指定的方法
5. 开启暴力访问
6. 执行找到的方法
public Object invoke(Object obj, Object... args)
执行指定对象obj中,当前Method对象所代表的方法,方法要传入的参数通过args指定。
public class MethodDemo3 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException,
SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException,
InvocationTargetException {
//1, 获取Class对象
Class c = Class.forName("cn.lsy.Person");
//2,获取构造方法
//public Person(String name, int age, String address){
Constructor con = c.getConstructor(String.class, int.class, String.class);
//3,通过构造方法,创建对象
Object obj = con.newInstance("小明", 23, "哈尔滨");
//4,获取指定的方法
//private void method5(){
Method m5 = c.getDeclaredMethod("method5", null);
//5,开启暴力访问
m5.setAccessible(true);
//6,执行找到的方法
m5.invoke(obj, null);
}
}