反射技术
-
java反射涵盖内容
java反射涵盖内容
-
根据需求引出反射
反射技术的引出
一、反射快速入门
-
创建Cat对象
package com.java.learning;
/**
* @author ljh
* @description
* @date 2022-06-2022/6/22
*/
public class Cat {
private String name = "招财猫";//猫的名字
public void hi() {//成员方法
System.out.println(String.format("hi " + name));
}
public void cry() {//
System.out.println(String.format(name+" 喵喵叫……"));
}
}
-
创建re.properties配置文件
classfullpath=com.java.learning.Cat
method=cry
-
ReflectionQuestion(反射入门测试类)
public class ReflectionQuestion {
public static void main(String[] args) throws Exception {
//根据配置文件re,properties指定信息，创建Cat对象并调用方法hi
//1、传统的方式：new 对象--》调用方法
Cat cat = new Cat();
cat.hi();
//2、尝试换一种方式。使用IO流技术中Properties 类（可以读取配置文件）
// testProperties();
//3、通过反射机制 创建Cat对象，调用方法hi
byReflectionImpl();
}
/**
* 通过反射实现
*/
private static void byReflectionImpl()
throws Exception {
Properties properties = new Properties();
properties.load(new FileInputStream("java-basic04/src/main/resources/re.properties"));
String classfullpath = properties.getProperty("classfullpath");
String methodName = properties.getProperty("method");
//1、加载类，返回Class 类型的对象
Class<?> aClass = Class.forName(classfullpath);
//2、通过 aClass 得到你加载的类， com.java.learning.Cat 的对象实例
Object obj = aClass.newInstance();
System.out.println("obj的运行类型："+obj.getClass());
//3、通过 aClass 得到你加载的类 com.java.learning.Cat 的 methodName数值（hi） 的方法
// 即：在反射中，可以把方法视为对象（万物皆对象）
Method method = aClass.getMethod(methodName);
//4、 通过method 调用方法，：即通过方法对象来实现调用方法
System.out.println("========================");
//传统方法： 对象.方法()
//反射机制： 方法.invoke(对象)
method.invoke(obj);
}
/**
* 通过Io中 Properties 类实现
*
* @throws Exception
*/
private static void byPropertiesImpl() throws Exception {
Properties properties = new Properties();
properties.load(new FileInputStream("java-basic04/src/main/resources/re.properties"));
String classfullpath = properties.getProperty("classfullpath");
String method = properties.getProperty("method");
System.out.println("classfullpath：" + classfullpath);
System.out.println("method：" + method);
Class<?> aClass = Class.forName(classfullpath);
Cat cat1 = (Cat) aClass.newInstance();
cat1.hi();
}
}
二、反射机制
什么是反射机制
-
反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息（比如成员变量，构造器，成员方法等等，并能操作对像的属性及方法。反射在设计模式和框架底层都会用到
-
加载完类之后，在堆中就产生了一个Class:类型的对像（一个类只有一个Class对象），这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个对象就像一面镜子，透过 这个镜子看到类的结构，所以，形象的称之为：反射
Java程序的三个阶段
反射机制可以完成的内容
-
在运行时判断任意一个对像所属的类
-
在运行时构造任意一个类的对象
-
在运行时得到任意一个类所具有的成员变量和方法
-
在运行时调用任意一个对像的成员变量和方法
-
生成动态代理
反射相关的主要类（Reflection01）
-
java.lang.Class: 代表一个类，Class对象表示某个类加载后在堆中的对像
-
java.lang.reflect.Method: 代表类的方法， Method对象表示某个类的方法
-
java.lang.reflect.Field: 代表类的成员变量，Field对象表示某个类的成员变量
-
java.lang.reflect.Constructor: 代表类的构造方法，Constructor对象表示构造器
反射机制的优缺点
-
优点：可以动态的创建和使用对象（也是框架底层核心），使用灵活，没有反射机制，框架技术就失去底层支撑。
-
缺点：使用反射基本是解释执行，对执行速度有影响.
应用案例
public class Reflection02 {
public static void main(String[] args)
throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
m1();
m2();
}
//传统方法来调用hi
public static void m1() {
long start = System.currentTimeMillis();
Cat cat = new Cat();
for (int i = 0; i < 90000000; i++) {
cat.hi();
}
long end = System.currentTimeMillis();
System.out.println("m1 耗时：" + (end - start));
}
//反射机制调用hi
public static void m2()
throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
long start = System.currentTimeMillis();
Class cls = Class.forName("com.java.learning.Cat");
Object obj = cls.newInstance();
Method method = cls.getMethod("hi");
for (int i = 0; i < 90000000; i++) {
method.invoke(obj);
}
long end = System.currentTimeMillis();
System.out.println("m2 耗时：" + (end - start));
}
}
执行结果，相比传统方法，使用反射确实会影响执行速度
m1 耗时：3
m2 耗时：415
反射调用优化--关闭访问检查
-
Method和Field、Constructor对象都有setAccessible()方法
-
setAccessible作用是启动和禁用访问安全检查的开关
-
参数值为tue表示反射的对像在使用时取消访问检查，提高反射的效率。参数值为false!则表示反射的对像执行访问检查
//反射机制优化调用hi, 关闭访问检查
public static void m3()
throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
long start = System.currentTimeMillis();
Class cls = Class.forName("com.java.learning.Cat");
Object obj = cls.newInstance();
Method method = cls.getMethod("hi");
method.setAccessible(true);//取消在反射调用方法时的访问检查
for (int i = 0; i < 90000000; i++) {
method.invoke(obj);
}
long end = System.currentTimeMillis();
System.out.println("m3 耗时：" + (end - start));
}
执行结果，与m2相比发现并没有快，反而慢了。因此我将setAccessible设置为false。反而比m2快了
此处有疑问？按常规的当setAccessible设置为true的应该相对m2方法执行要快的。
m1 耗时：3
m2 耗时：416
m3 耗时：421
三、Class类、类加载
1、Class类
基本介绍
-
Class也是类，因此也继承Object类
类图
-
Class类对象不是new出来的，而是系统创建的[由类加载器ClassLoader中的loadClass方法生成的]
-
对于某个类的clss类对象，在堆内存中只有一份，因为类只加载一次[演示]
-
每个类的实例都会记得自己是由哪个Class实例所生成
每个类的实例都会记得自己是由哪个Class实例所生成
-
通过Class对象可以完整地得到一个类的完整结构，通过一系列AP1
Class类的常用方法
Class类的常用方法
-
Class对象是存放在堆的
-
类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据（包括方法代码变量名，方法名，访问权限等等。
类的字节码二进制数据，是放在方法区的
通过Class对象可以完整地得到一个类的完整结构，通过一系列AP1?
代码演示
public class Class01 {
public static void main(String[] args)
throws ClassNotFoundException, IllegalAccessException, InstantiationException {
//1. Class也是类，因此也继承Object类，查看类图可看到
// Class
//2、Class类对象不是new出来的，而是系统创建的
// (1)、创痛new 对象，Debug模式启动，Debug调试界面，按 Force Step Into（或 Alt+Shift+F7）
// 看源码（ClassLoader类）
// public Class<?> loadClass(String name) throws ClassNotFoundException {
// return loadClass(name, false);
// }
// Cat cat = new Cat();
// （2）、使用反射的方式，Debug调试界面，按 Force Step Into（或 Alt+Shift+F7）,
// Dedug过程没有debug到ClassLoad类的 locadClass， 其原因是，我没有注销上面传统方式生成的Cat
// 对象：Cat cat = new Cat()，刚好印证了第3条：对于某个类的clss类对象，在堆内存中只有一份，因为类只加载一次
//
/**
* ClassLoader类，仍然是通过 ClassLoader类加载Cat类的Class对象
* public Class<?> loadClass(String name) throws ClassNotFoundException {
* return loadClass(name, false);
* }
*/
Class cls01 = Class.forName("com.java.learning.Cat");
//3、 对于某个类的clss类对象，在堆内存中只有一份，因为类只加载一次（在第2条已经展示出了）
Class cls02 = Class.forName("com.java.learning.Cat");
//hashcode值是一样的，说明是一个对象
Class cls03 = Class.forName("com.java.learning.Dog");
System.out.println(cls01.hashCode());
System.out.println(cls02.hashCode());
System.out.println(cls03.hashCode());
//4、每个类的实例都会记得自己是由哪个Class实例所生成
}
}
Class类的常用方法(应用案例)
-
Car
package com.java.learning;
/**
* @author ljh
* @description
* @date 2022-06-2022/6/23
*/
public class Car {
public String brand = "宝马";
public int price = 500000;
public String color = "红色";
@Override
public String toString() {
return "Car{" +
"brand='" + brand + '\'' +
", price=" + price +
", color='" + color + '\'' +
'}';
}
}
-
Class02
package com.java.learning.class_;
import com.java.learning.Car;
import java.lang.reflect.Field;
/**
* @author ljh
* @description
* @date 2022-06-2022/6/23
*/
public class Class02 {
public static void main(String[] args)
throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
String classAllPath = "com.java.learning.Car";
//1、获取到 Car 类 对应的 Class 对象
//<?> 表示不确定的Java类型
Class<?> cls = Class.forName(classAllPath);
//2、输出cls
System.out.println(cls);//显示cls对象，显示的是那个类的class对象===>com.java.learning.Car
System.out.println(cls.getClass());//java.lang.Class
//3、得到包名
System.out.println(cls.getPackage().getName());//包名
//4、得到类名
System.out.println(cls.getName());//全路径名
System.out.println(cls.getSimpleName());//类名
//5、通过 cls 创建对象实例
Car car = (Car) cls.newInstance();
System.out.println(car);//car.toString();
//6、通过反射获取属性: brand
Field field = cls.getField("brand");//此处属性，不能是私有属性，不然会报错：NoSuchFieldException
Object o = field.get(car);
System.out.println(o);
//7、通过反射给属性赋值
field.set(car,"奥迪");
System.out.println(field.get(car));
//8、我希望大家可以遍历到所有的属性（字段）
System.out.println("======所有的字段属性=======");
Field[] fields = cls.getFields();
for (Field f : fields) {
System.out.println(f.get(car));
}
}
}
获取Class类对象的方式
1、前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException,
实例：Class cls1= Class.forName("java.lang.Cat")
应用场景：多用于配置文件，读取类全路径，加载类；多用于代码编译阶段
2、前提：若已知具体的类，通过类的class获取，该方式最为安全可靠，程序性能最高
实例：Class cls2=Cat.class;
应用场景：多用于参数传递，比如通过反射得到对应构造器对象；多用于类加载阶段
3.前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象，
实例：Class clazz=对象.getClass();
应用场景：通过创建好的对象，获取Class对象。多用于Runtime运行时阶段
4.其他方式（在编译阶段，通过类加载器，获取Class对象）
ClassLoader cl=对象.getClass().getClassLoader();
Class clazz4=cl.loadClass("类的全类名”);
5.基本数据(int,char,boolean,float,double,byte,long,short)按如下方式得到Class类对象
Class cls=基本数据类型.class
6.基本数据类型对应的包装类，可以通过.type得到Class类对象
Class cls=包装类.TYPE
代码演示
package com.java.learning.class_;
import com.java.learning.Car;
/**
* @author ljh
* @description 演示得到Class对象的各种方式(6)
* @date 2022-06-2022/6/23
*/
public class GetClass_ {
public static void main(String[] args) throws ClassNotFoundException {
//1. Class.forName
String classAllPath = "com.java.learning.Car"; //通过读取配置文件获取
Class<?> cls1 = Class.forName(classAllPath);
System.out.println(cls1);
//2. 类名.class , 应用场景: 用于参数传递
Class cls2 = Car.class;
System.out.println(cls2);
//3. 对象.getClass(), 应用场景，有对象实例
Car car = new Car();
Class cls3 = car.getClass();
System.out.println(cls3);
//4. 通过类加载器【4种】来获取到类的Class对象
//(1)先得到类加载器 car
ClassLoader classLoader = car.getClass().getClassLoader();
//(2)通过类加载器得到Class对象
Class cls4 = classLoader.loadClass(classAllPath);
System.out.println(cls4);
//cls1 , cls2 , cls3 , cls4 其实是同一个对象
System.out.println(cls1.hashCode());
System.out.println(cls2.hashCode());
System.out.println(cls3.hashCode());
System.out.println(cls4.hashCode());
//5. 基本数据(int, char,boolean,float,double,byte,long,short) 按如下方式得到Class类对象
Class<Integer> integerClass = int.class;
Class<Character> characterClass = char.class;
Class<Boolean> booleanClass = boolean.class;
System.out.println(integerClass);//int
//6. 基本数据类型对应的包装类，可以通过 .TYPE 得到Class类对象
Class<Integer> type1 = Integer.TYPE;
Class<Character> type2 = Character.TYPE; //其它包装类BOOLEAN, DOUBLE, LONG,BYTE等待
System.out.println(type1);
System.out.println(integerClass.hashCode());//?
System.out.println(type1.hashCode());//?
}
}
哪些类型有Class对象
-
外部类，成员内部类，静态内部类，局部内部类，置名内部类
-
interface:接口
-
数组
-
enum:枚举
-
annotation:注解
-
基本数据类型
-
void
代码演示
package com.java.learning.class_;
import java.io.Serializable;
/**
* @author ljh
* @description 演示哪些类型有Class对象
* @date 2022-06-2022/6/23
*/
public class AllTypeClass {
public static void main(String[] args) {
Class<String> cls1 = String.class;//外部类
Class<Serializable> cls2 = Serializable.class;//接口
Class<Integer[]> cls3 = Integer[].class;//数组
Class<float[][]> cls4 = float[][].class;//二维数组
Class<Deprecated> cls5 = Deprecated.class;//注解
//枚举
Class<Thread.State> cls6 = Thread.State.class;
Class<Long> cls7 = long.class;//基本数据类型
Class<Void> cls8 = void.class;//void数据类型
Class<Class> cls9 = Class.class;//
System.out.println(cls1);
System.out.println(cls2);
System.out.println(cls3);
System.out.println(cls4);
System.out.println(cls5);
System.out.println(cls6);
System.out.println(cls7);
System.out.println(cls8);
System.out.println(cls9);
}
}
2、Class类加载
基本说明
反射机制是jva实现动态语言的关键，也就是通过反射实现类动态加载。
-
静态加载：编译时加载相关的类，如果没有则报错，依赖性太强
-
动态加载：运行时加载需要的类，如果运行时不用该类，则不报错，降低了依赖性
静态加载
通过notpad++ 功能手写一个ClassLoad_类
import com.java.learning.Dog;
import java.util.Scanner;
public class ClassLoad_ {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入key");
String key = scanner.next();
switch (key) {
case "1":
Dog dog = new Dog();//静态加载，依赖性很强
dog.cry();
break;
case "2":
System.out.println("ok");
break;
default:
System.out.println("do nothing..");
}
}
}
通过命令行，编译Java文件，会报错，报Dog这个类找不到，依赖性太强
编译结果如下：
.\ClassLoad_.java:12: 错误: 找不到符号
Dog dog = new Dog();
^
符号: 类 Dog
位置: 类 ClassLoad_
.\ClassLoad_.java:12: 错误: 找不到符号
Dog dog = new Dog();
^
符号: 类 Dog
位置: 类 ClassLoad_
2 个错误
动态加载
import java.util.Scanner;
import java.lang.reflect.*;
public class ClassLoad_ {
public static void main(String[] args) throws Exception{
Scanner scanner = new Scanner(System.in);
System.out.println("请输入key");
String key = scanner.next();
switch (key) {
case "1":
//Dog dog = new Dog();
//dog.cry();
break;
case "2":
//反射-> 动态加载。如果运行时不用该类，则不报错，降低了依赖性
Class cls = Class.forName("Person");
Object obj = cls.newInstance();
Method m = cls.getMethod("hi");
m.invoke(obj);
System.out.println("ok");
break;
default:
System.out.println("do nothing..");
}
}
}
通过命令行，编译Java文件，不会报错，降低了依赖性
编译结果如下：
注: .\ClassLoad_.java使用了未经检查或不安全的操作。
注: 有关详细信息, 请使用 -Xlint:unchecked 重新编译。
类加载流程
类加载流程图
类加载流程图
类加载的三个阶段详细流程图
类加载的三个阶段详细流程图
-
类加载阶段
JVM在该阶段的主要目的是将字节码从不同的数据源（可能是class文件、也可能是jar包，甚至网络)转化为二进制字节流加载到内存中，并生成一个代表该类 的java.lang.Class对象
-
连接阶段-验证
1、目的是为了确保Clss文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
2、包括：文件格式验证（是否以魔数 oxcafebabe 开头）、元数据验证、字节码验证和符号引用验证[举例说明]
3、可以考虑使用 -Xverify:none 参数来关闭大部分的类验证措施，缩短虚拟机类加载的时间。
-
连接阶段-准备
JVM会在该阶段对静态变量，分配内存并初始化（对应数据类型的默认初始值，如O、OL、null、false等)。这些变量所使用的内存都将在方法区中进行分配
代码演示
public class ClassLoad02 {
public static void main(String[] args) {
A a = new A();
}
}
class A{
//属性-成员变量-字段
//分析类加载的链接阶段-准备，属性是如何处理的
//1、n1 是实例变量，跟类不相干，不是静态变量。因此在准备阶段，是不会分配内存的
public int n1 = 10;
//2、n2 是静态变量，分配内存 n2是默认初始化为 0；而不是20（20会在初始化阶段进行赋值）
public static int n2 = 20;
//3、n3 是static final 是常量，他和静态变量不一样，因为一旦赋值就不变了。n3就是初始化为30
public static final int n3 = 30;
}
-
连接阶段-解析
虚拟机(JVM)将常量池内的符号引用替换为直接引用的过程。
-
类加载阶段
1、到初始化阶段，才真正开始执行类中定义的Jva程序代码，此阶段是执行 ()方法的过程。
2、()方法是由编译器按语句在源文件中出现的顺序，依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并。 [举例说明]
public class ClassLoad03 {
public static void main(String[] args) {
//类加载分析
//1、加载B类，并生成 B 的class 对象
//2、链接 num =0;
//3、初始化阶段
// 依次自动收集类中的所有 静态变量 的赋值动作和 静态代码块 中的语句，并进行合并
/**
* clinit(){
* System.out.println("B 静态代码块被执行");
* //
* int num = 100;
* }
* 合并：num = 100；
*/
//4、“B 构造器被执行”
new B();//类加载
System.out.println(B.num);//100，如果直接使用类的静态属性，也会导致类的加载
}
}
class B{
static {
System.out.println("B 静态代码块被执行");
}
static int num = 100;
public B() {
System.out.println("B 构造器被执行");
}
}
3、虚拟机会保证一个类的()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的()方法 ，其他线程都需要阻塞等待，直到活动线程执行O方法完毕[debug源码]
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException{
//正因为有这个机制，才能保证某个类在内存中只有一份Class对象
synchronized (getClassLoadingLock(name)) {
//...............
}
}
注意：加载和连接阶段是由JVM操作的
类加载时机
-
当创建对象时(new)
-
当子类被加载时
-
调用类中的静态成员时
-
通过反射
通过反射获取类的结构信息
com.java.learning.reflect.ReflectionUtils
-
第一组：java.lang.Class类
1、getName：获取全类名
2、getSimpleName：获取简单类名
3、getFields：获取所有oublic修饰的属性，包含本类以及父类的
4、getDeclaredFields：获取本类中所有属性
5、getMethods ：获取所有oublic修饰的方法，包含本类以及父类的
6、getDeclaredMethods：获取本类中所有方法
7、getConstructors：获取所有oublic修饰的构造器，包含本类以及父类的
8、getDeclaredConstructors：获取本类中所有构造器
9、getPackage：以Package形式返回包信息
10、getSuperClass：以Class形式返回父类信息
11、getInterfaces：以Class0形式返回接口信息
12、getAnnotations：以Annotation[]形式返回注解信息
-
第二组：java.lang.reflect.Field 类
1、getModifiers : 以int形式返回修饰符
[说明：默认修饰符是0，public是1，private是2，protected是4，static是8，final是16]
例如：public static修饰的------>public(1)+static(8)=9
2、getType :以Class形式返回类型
3、getName :返回属性名
-
第三组：java.lang.reflect.Method 类
1、getModifiers::以int形式返回修饰符
[说明：默认修饰符是0，public是1，private是2，protected是4，static是8，final是16]
2、getReturnType:以Class形试获取返回类型
3、getName:返回方法名
4、getParameterTypes:以Class[]返回参数类型数组
-
第四组：java.lang.reflect.Constructor 类
1、getModifiers:以int形式返回修饰符
2、getName:返回构造器名（全类名）
3、getParameterTypes:以Class[]返回参数类型数组
通过反射创建对象
1、方式一：调用类中的public修饰的无参构造器
2、方式二：调用类中的指定构造器
3、Class类相关方法
-
newlnstance：调用类中的无参构造器，获取对应类的对象
-
getConstructor(Class..clazz):根据参数列表，获取对应的public构造器对象
-
getDecalaredConstructor(Class..clazz):根据参数列表，获取对应本类所有的构造器对象
4、Constructor类相关方法
-
setAccessible::暴力破解（使用反射可以访问private构造器，反射面前，一切都是可以访问的）
-
newlnstance(Object.obj):调用构造器
package com.java.learning.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
* @author ljh
* @description 通过反射创建对象
* @date 2022-06-2022/6/24
*/
public class ReflectCreateInstance {
public static void main(String[] args)
throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
//1、先获取到User类的class对象
Class<?> userCls = Class.forName("com.java.learning.reflect.User");
//2、通过public的无参构造器创建实例
Object obj = userCls.newInstance();
System.out.println(obj);
//3、通过public的有参构造器创建实例
/**
* constructor 对象就是：
* public User(String name) {
* this.name = name;
* }
*/
//3.1、获取构造器，传入形参类型
Constructor<?> constructor = userCls.getConstructor(String.class);
//3.2、创建实例，并传入实参
Object obj01 = constructor.newInstance("李四");
System.out.println(obj01);
//4、通过非public的有参构造器创建实例
//4.1、先得到私有的构造器对象
Constructor<?> declaredConstructor = userCls.getDeclaredConstructor(int.class, String.class);
declaredConstructor.setAccessible(true);//设置Accessible为true。使反射可以访问private构造器
Object obj02 = declaredConstructor.newInstance(15, "张三丰");
System.out.println(obj02);
}
}
class User{
private int age = 10;
private String name = "张三";
public User() {//无参 public
}
public User(String name) {//public的有参构造器
this.name = name;
}
private User(int age, String name) { //private的有参构造器
this.age = age;
this.name = name;
}
@Override
public String toString() {
return "User{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
通过反射访问类中的成员
-
通过反射访问属性
1、根据属性名获取Field对象
Field f=clazz对象.getDeclaredField(属性名)i
2、暴破：f.setAccessible(true:/f是Field
3、访问
f.set(obj,值)：//obj表示对象
System.out.println(f.get(obj));
4、如果是静态属性，则set和get中的参数o,可以写成nul
package com.java.learning.reflect;
import java.lang.reflect.Field;
/**
* @author ljh
* @description 演示反射操作属性
* @date 2022-06-2022/6/24
*/
public class ReflectAccessProperty {
public static void main(String[] args)
throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
//1、得到Student对应的class类
Class<?> cls = Class.forName("com.java.learning.reflect.Student");
//2、创建对象
Object obj = cls.newInstance();
System.out.println(obj.getClass());
//3、使用反射得到age属性对象
Field age = cls.getField("age");
age.set(obj,28);
System.out.println(obj);
System.out.println(age.get(obj));//反射age属性值
//4、使用反射操作name属性
Field name = cls.getDeclaredField("name");
//对name属性，进行爆破，然后就可以操作private属性了
name.setAccessible(true);
// name.set(obj,"李白");
name.set(null,"李白");//此处形参指向的对象可以设置null。因为name属性是静态（static）的，是属于类属性，不是实例属性
System.out.println(obj);
System.out.println(name.get(obj));//获取属性值
System.out.println(name.get(null));//获取属性值，要求name属性是static
}
}
class Student {
public int age;
private static String name;
public Student() {
}
@Override
public String toString() {
return "Student{" +
"age=" + age + "，name=" + name +
'}';
}
}
-
通过反射访问方法
1、根据方法名和参数列表获取Method方法对象：
Method m = clazz.getDeclaredMethod(方法名，XX.class); //得到本类的所有方法
2、获取对象：Object o=clazz.newlnstance():
3、暴破：m.setAccessible(true):
4、访问：Object returnValue=m.invoke(obj,实参列表)；//obj就是要操作的对象
5、注意：如果是静态方法，则invoke的参数obj,可以写成null
public class ReflectAccessMethod {
public static void main(String[] args)
throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
//1、得到Student对应的class类
Class<?> cls = Class.forName("com.java.learning.reflect.Boss");
//2、创建对象
Object obj = cls.newInstance();
System.out.println(obj.getClass());
//3、调用public 的 hi方法
//3.1、采用 Class.getMethod方法获取
Method method = cls.getMethod("hi", String.class);
method.invoke(obj, "张三丰");
//3.1、采用 Class.getDeclaredMethod方法获取
Method method1 = cls.getDeclaredMethod("hi", String.class);
method1.invoke(obj, "刘备");
//4、调用private static方法
Method sayMethod = cls.getDeclaredMethod("say", int.class, String.class, char.class);
//4.1、因为say方法是private，所以需要爆破。
sayMethod.setAccessible(true);
System.out.println(sayMethod.invoke(obj, 20, "刘婵", 'A'));;
//4.2、因为say方法是static，对象可以传入null
System.out.println(sayMethod.invoke(null, 20, "刘婵", 'A'));;
//5、返回值（在反射中，如果方法有返回值，统一返回Object，但是他运行时类型和方法定义的返回类型是一致的）
Object result = sayMethod.invoke(null, 200, "张飞", 'B');
System.out.println("返回值类型："+result.getClass()+"；结果是："+result);
}
}
class Boss {
public int age;
private static String name;
public Boss() {
}
private static String say(int n, String s, char c) {//静态私有方法
return n + " " + s + " " + c;
}
public void hi(String s) {//普通的public方法
System.out.println("hi " + s);
}
}
扫一扫
564
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
