反射(reflection)

1. 一个需求引出反射

1.1 请看下面的问题

根据配置文件 re.properties 指定信息,创建Cat对象并调用方法hi

我们用之前的方式处理就是：

先创建一个Cat类，里面创建一个hi()方法;
再创建一个ReflectionQuestion类，然后new 一个Cat对象，再调用Cat类里面的hi()方法;

代码演示：

Cat类

public class Cat {private String name = "咪咪";public void hi(){System.out.println("hi"+name);}
}

re.properties类

classfullpath=com.song.Cat
method=hi

ReflectionQuestion类

public class ReflectionQuestion {public static void main(String[] args) {//传统方式//1. 创建Cat对象Cat cat = new Cat();//2. 调用hi()方法cat.hi();//输出 hi咪咪//尝试一下取出propertiesProperties properties = new Properties();properties.load(new FileInputStream("src\\re.properties"));String classfullpath = properties.get("classfullpath").toString();String methodName = properties.getProperty("method");System.out.println("classfullpath ="+classfullpath);System.out.println("method ="+methodName);//2. 创建对象，传统的方法不行 --> 反射机制//new classfullpath();}
}

但是现在要求我们根据配置文件 re.properties 指定信息,创建Cat对象并调用方法hi，利用传统的方法实现不了
这样的需求在学习框架时特别多，即通过外部文件配置，在不修改源码情况下来控制程序，也符合设计模式的 ocp原则
ocp原则(开闭原则: 不修改源码，扩容功能)

利用反射机制的做法就是：

先加载类,返回class类型的对象

Class cls = Class.forName(classfullpath);

通过 cls 得到你加载的类 com.song.Cat 的对象实例

Object o = cls.newInstance(); //运行类型是cat
System.out.println("o的运行类型 ="+o.getClass());
//输出 o的运行类型 =class com.song.Cat

通过 cls 得到你加载的类 com.song.Cat 的 methodName "hi"的方法对象

//      即：在反射中，可以把方法视为对象（万物皆对象）
Method method1 = cls.getMethod(methodName);

通过 method1 调用方法：即通过方法对象来实现调用方法

System.out.println("==========================");
method1.invoke(o);//输出 hi咪咪
//传统方法是 对象.方法()
//反射机制是 方法.invoke(对象)

当我们Cat类里面有多种方法的时候

public class Cat {private String name = "咪咪";public void hi(){System.out.println("hi"+name);}public void cry(){System.out.println(name+"叫了一声~");}
}

如果我们用传统的方法调用Cat类里面的其他方法，需要修改一下源码
但是当我们用反射机制的时候，只要我们修改一下re.properties中的method
```
classfullpath=com.song.Cat
method=cry
```

原先的代码都不用动，他自己就调用了其他的方法

//3. 使用反射机制解决
//(1) 先加载类,返回class类型的对象
Class cls = Class.forName(classfullpath);//(2) 通过 cls 得到你加载的类 com.song.Cat 的对象实例
Object o = cls.newInstance(); //运行类型是cat
System.out.println("o的运行类型 ="+o.getClass());
//输出 o的运行类型 =class com.song.Cat//(3) 通过 cls 得到你加载的类 com.song.Cat 的 methodName "hi"的方法对象
//      即：在反射中，可以把方法视为对象（万物皆对象）
Method method1 = cls.getMethod(methodName);//(4) 通过 method1 调用方法：即通过方法对象来实现调用方法
System.out.println("==========================");
method1.invoke(o);//输出 咪咪叫了一声~

2. 反射机制

2.1 Java Reflection

反射机制允许程序在执行期借助于 ReflectionAPI 取得任何类的内部信息(比如成员变量，构造器，成员方法等等)，并能操作对象的属性及方法。反射在设计模式和框架底层都会用到
加载完类之后，在堆中就产生了一个Class类型的对象 (一个类只有一个Class对象)，这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个Class对象就像一面镜子，透过这个镜子看到类的结构，所以，形象的称之为:反射

2.2 Java 反射机制原理示意图！

2.3 Java 反射机制可以完成

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时得到任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的成员变量和方法
生成动态代理

2.4 反射相关的主要类

java.lang.Class:代表一个类， Class对象表示某个类加载后在堆中的对象
java.lang.reflect.Method: 代表类的方法,Method对象表示某个类的方法
java.lang.reflect.Field: 代表类的成员变量, Field对象表示某个类的成员变量
java.lang.reflect.Constructor: 代表类的构造方法, Constructor对象表示构造器
这些类在java.lang.reflection
代码演示：Reflection01.java

public class Reflection01 {public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {//尝试一下取出propertiesProperties properties = new Properties();//加载properties.load(new FileInputStream("src\\re.properties"));String classfullpath = properties.getProperty("classfullpath");String methodName = properties.getProperty("method");//使用反射机制//(1) 先加载类,返回class类型的对象Class<?> cls = Class.forName(classfullpath);//(2) 通过 cls 得到你加载的类 com.song.Cat 的对象实例Object o = cls.newInstance();//(3) 通过 cls 得到你加载的类 com.song.Cat 的 methodName "hi"的方法对象//      即：在反射中，可以把方法视为对象（万物皆对象）Method method1 = cls.getMethod(methodName);//(4) 通过 method1 调用方法：即通过方法对象来实现调用方法method1.invoke(o);//java.lang.reflect.Field: 代表类的成员变量, Field对象表示某个类的成员变量//得到name字段//getFiled不能得到私有的属性//Field nameField = cls.getField("name");//NoSuchFieldExceptionField nameField = cls.getField("age");//我们取出成员变量的传统方法是 对象.成员变量//在反射中是返过来的     成员变量对象.get(对象)System.out.println(nameField.get(o));//java.lang.reflect.Constructor: 代表类的构造方法, Constructor对象表示构造器//()中可以指定构造器参数类型，// 这里返回的是无参构造器Constructor<?> constructor = cls.getConstructor();System.out.println(constructor);//public com.song.Cat()//这里的 String.class 就是 String 类的 Class 对象Constructor<?> constructor2 = cls.getConstructor(String.class);System.out.println(constructor2);}
}

2.5 反射优点和缺点

优点: 可以动态的创建和使用对象(也是框架底层核心)，使用灵活,没有反射机制，框架技术就失去底层支撑。
缺点: 使用反射基本是解释执行，对执行速度有影响
代码演示：Reflection02.java

/*** 测试反射调用的性能，和优化方案*/
public class Reflection02 {public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {m1();// m1() 耗时 = 4m2();// m2() 耗时 = 1602}//先写一个传统方法调用hipublic static void m1() {Cat cat = new Cat();long start = System.currentTimeMillis();for (int i = 0; i < 900000000; i++) {cat.hi();}long end = System.currentTimeMillis();System.out.println("m1() 耗时 = " + (end - start));}//再写一个反射机制调用方法public static void m2() throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {Class<?> cls = Class.forName("com.song.Cat");Object o = cls.newInstance();Method method = cls.getMethod("hi");long start = System.currentTimeMillis();for (int i = 0; i < 900000000; i++) {method.invoke(o);}long end = System.currentTimeMillis();System.out.println("m2() 耗时 = " + (end - start));}
}

2.6 反射调用优化-关闭访问检查

Method和Field、Constructor对象都有setAccessible0方法
setAccessible作用是启动和禁用访问安全检查的开关
参数值为true表示反射的对象在使用时取消访问检查，提高反射的效率。
参数值为false则表示反射的对象执行访问检查

类图

代码实现：

/*** 测试反射调用的性能，和优化方案*/
public class Reflection02 {public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {m1();// m1() 耗时 = 4m2();// m2() 耗时 = 1602m3();// m3() 耗时 = 1099}//先写一个传统方法调用hipublic static void m1() {Cat cat = new Cat();long start = System.currentTimeMillis();for (int i = 0; i < 900000000; i++) {cat.hi();}long end = System.currentTimeMillis();System.out.println("m1() 耗时 = " + (end - start));}//再写一个反射机制调用方法public static void m2() throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {Class<?> cls = Class.forName("com.song.Cat");Object o = cls.newInstance();Method method = cls.getMethod("hi");long start = System.currentTimeMillis();for (int i = 0; i < 900000000; i++) {method.invoke(o);}long end = System.currentTimeMillis();System.out.println("m2() 耗时 = " + (end - start));}//反射调用优化 ：+ 关闭访问检查public static void m3() throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {Class<?> cls = Class.forName("com.song.Cat");Object o = cls.newInstance();Method method = cls.getMethod("hi");method.setAccessible(true);//在反射调用方法时，取消访问检查long start = System.currentTimeMillis();for (int i = 0; i < 900000000; i++) {method.invoke(o);}long end = System.currentTimeMillis();System.out.println("m3() 耗时 = " + (end - start));}
}

3. Class类

3.1 基本介绍

Class也是类，因此也继承Object类[类图]
Class类对象不是new出来的，而是系统创建的 [演示]

对于某个类的Class类对象，在内存中只有一份，因为类只加载一次[演示]

/*** 对Class类特点的理解*/
public class Class01 {public static void main(String[] args) throws ClassNotFoundException {//1. Class也是类，因此也继承Object类[类图]//  Class也是类，因此也继承了Object类//2. Class类对象不是new出来的，而是系统创建的//(1) 传统 new 对象//Cat cat = new Cat();/*ClassLoader类public Class<?> loadClass(String name) throws ClassNotFoundException {return loadClass(name, false);}*///(2) 反射方式Class cls1 = Class.forName("com.song.Cat");/*ClassLoader类public Class<?> loadClass(String name) throws ClassNotFoundException {return loadClass(name, false);}*///3. 对于某个类的Class类对象，在内存中只有一份，因为类只加载一次//在上面第二点进行 Debug的时候，传统 new 对象和反射只进入一次ClassLoader类Class cls2 = Class.forName("com.song.Cat");System.out.println(cls1.hashCode());//460141958System.out.println(cls2.hashCode());//460141958//不同的类会重新再加载一次Class cls3 = Class.forName("com.song.Dog");System.out.println(cls3.hashCode());//1163157884}
}

每个类的实例都会记得自己是由哪个 Class 实例所生成
通过Class对象可以完整地得到一个类的完整结构,通过一系列API
Class对象是存放在堆的
类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据(包括方法代码变量名，方法名，访问权限等等) https://www.zhihu.com/question/38496907[示意图]

类图：

3.2 Class 类的常用方法

代码演示：

/*** *演示 Class 类的常用方法*/
public class Class02 {public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {String classAllPath = "com.song.Car";//1. 获取得到 Car 类对应的 Class 对象// <?> 表示不确定的 Java 类型Class<?> cls = Class.forName(classAllPath);//2. 输出 cls//(1) 显示 cls 对象System.out.println(cls);//输出 class com.song.Car//(2) 显示 cls 的运行类型System.out.println(cls.getClass());//输出 class java.lang.Clas//3. 得到包名System.out.println(cls.getPackage().getName());//com.song//4. 得到全类名System.out.println(cls.getName());//com.song.Car//5. 通过 cls 创建对象实例Object o = cls.newInstance();// 这个就是对象实例，可以向下转型Car car = (Car) cls.newInstance();System.out.println(car);//输出 Car{brand='保时捷', price=600000, color='黄色'}//6. 通过反射获取属性 brandField brand = cls.getField("brand");System.out.println(brand.get(car));//保时捷//7. 通过反射给属性赋值brand.set(car, "特斯拉");System.out.println(brand.get(car));//特斯拉//8. 遍历car里面所有的属性Field[] fields = cls.getFields();for (Field f : fields) {System.out.println(f.getName());//brand//price//color}}
}

4. 获取 Class 类对象

前提: 已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException，实例: Cass cls1 =Class.forName( "java.lang.Cat”);

应用场景:多用于配置文件,读取类全路径，加载类
```
//1. Class.forName
String allFilePath = "com.song.Car";
Class<?> cls1 = Class.forName(allFilePath);
System.out.println(cls1);//class com.song.Car
```
前提: 若已知具体的类，通过类的class 获取，该方式最为安全可靠，

程序性能最高实例: Class cls2 = Cat.class;

应用场景: 多用于参数传递，比如通过反射得到对应构造器对象
```
//2.类名.class    应用场景:用于参数传递
Class cls2 = Car.class;
System.out.println(cls2);//class com.song.Car
```
前提: 已知某个类的实例，调用该实例的getClass()方法获取Class对象，

实例:Class clazz = 对象.getClass0://运行类型

应用场景: 通过创建好的对象，获取Class对象
```
//3.对象.getClass()   应用场景:已经有对象实例
Car car = new Car();
Class cls3 = car.getClass();
System.out.println(cls3);//class com.song.Car
```

其他方式

ClassLoader cl = 对象.getClass().getClassLoader0);

Class clazz4 = cl.loadClass(“类的全类名”);

//4. 通过类加载器来获取到类的 class 对象
// (1) 先得到类加载器 car
ClassLoader classLoader = car.getClass().getClassLoader();
// (2) 通过类加载器得到 Class对象
Class<?> cls4 = classLoader.loadClass(allFilePath);
System.out.println(cls4);//class com.song.Car

基本数据(int, char,boolean,float,double,byte,long,short) 按如下方式得到Class类

Class cls = 基本数据类型.class

//5. 基本数据(int, char,boolean,float,double,byte,long,short) 按如下方式得到Class类
//  这里稍微拿两个举例说明
Class<Integer> integerClass = int.class;
Class<Character> characterClass = char.class;
System.out.println(integerClass);//int
System.out.println(characterClass);//char

基本数据类型对应的包装类，可以通过 .TYPE 得到Class类对象

Class cls = 包装类.TYPE

//6. 基本数据类型对应的包装类，可以通过 .TYPE 得到Class类对象
//  这里稍微拿两个举例说明
Class<Integer> type1 = Integer.TYPE;
Class<Character> type2 = Character.TYPE;
System.out.println(type1);//int
System.out.println(type2);//char

5. 哪些类型有 Class 对象

5.1 如下类型有Class 对象

外部类，成员内部类，静态内部类，局部内部类，匿名内部类
interface : 接口
数组
enum:枚举
annotation :注解
基本数据类型
void
简单代码演示：

/*** 演示哪些类型有Class对象*/
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;//枚举//public enum State {}Class<Long> cls7 = long.class;//基本数据类型Class<Void> cls8 = void.class;//void数据类型Class<Class> cls9 = Class.class;//ClassSystem.out.println(cls1);//输出 class java.lang.StringSystem.out.println(cls2);//输出 interface java.io.SerializableSystem.out.println(cls3);//输出 class [Ljava.lang.Integer;System.out.println(cls4);//输出 class [[FSystem.out.println(cls5);//输出 interface java.lang.DeprecatedSystem.out.println(cls6);//输出 class java.lang.Thread$StateSystem.out.println(cls7);//输出 longSystem.out.println(cls8);//输出 voidSystem.out.println(cls9);//输出 class java.lang.Class}
}

6. 类加载

6.1 基本说明

反射机制是 java实现动态语言的关键，也就是通过反射实现类动态加载

静态加载:编译时加载相关的类，如果没有则报错，依赖性太强
动态加载:运行时加载需要的类，如果运行时不用该类，即使不存在该类，则不报错，降低了依赖性

举例说明

比如下面这行代码，new Dog() 是静态加载，如果不先创建一个Dog类，则在编译期间就会报错
而下面Cat类的反射机制是动态加载，不先创建Cat类，在编译的时候也不会报错，只有当运行的时候才会报错

import java.util.*;
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("Cat");//加载Person类Object o = cls.newInstance();Method m = cls.getMethod("hi");m.invoke(o);System.out.println("皮皮");break;default:System.out.println("do nothing...");}}
}
//因为 new Dog() 是静态加载，因此必须编写 Dog类
//Cat类是动态加载，所以没有编写Cat类也不会报错，只有当动态加载该类时，才会报错
class Dog{public void cry(){System.out.println("皮皮一直在叫~");}
}

6.2 类加载时机

当创建对象时 (new) //静态加载
当子类被加载时，父类也加载 //静态加载
调用类中的静态成员时 //静态加载
0通0过反射 //动态加载
Class.forName(“com.test.Cat”);

6.3 类加载过程图

6.4 类加载各阶段完成任务

6.5 加载阶段

JVM 在该阶段的主要目的是将字节码从不同的数据源(可能是 class 文件、也可能是jar 包，甚至网络)转化为二进制字节流加载到内存中，并生成一个代表该类的java.lang.Class 对象

6.6 连接阶段-验证

目的是为了确保 Class 文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
包括:文件格式验证(是否以魔数 oxcafebabe开头)、元数据验证、字节码验证和符号引用验证
可以考虑使用 -Xverify:none 参数来关闭大部分的类验证措施，缩短虚拟机类加载的时间。

6.7 连接阶段-准备

JVM 会在该阶段对静态变量，分配内存并默认初始化 (对应数据类型的默认初始值，如 0、0L、null、false 等)。这些变量所使用的内存都将在方法区中进行分配
举例说明: ClassLoad02.java

/*** 说明一个类加载的链接阶段-准备*/
public class ClassLoad02 {public static void main(String[] args) {}
}class A {//属性-成员变量-字段//分析类加载的链接阶段-准备 属性是如何处理//1. n1 是实例属性, 不是静态变量，因此在准备阶段，是不会分配内存//2. n2 是静态变量，分配内存 n2 是默认初始化 0 ,而不是 20//3. n3 是 static final 是常量, 他和静态变量不一样, 因为一旦赋值就不变 n3 = 30public int n1 = 10;public static int n2 = 20;public static final int n3 = 30;
}

6.8 连接阶段-解析

虚拟机将常量池内的符号引用替换为直接引用的过程
举例说明:
- 比如有一个A类跟一个B类，他们在编译的过程中（类加载）没有真正的放到内存中；
- 这个时候是以符号的形式引用，比如A为①，B为②，他们就通过符号之间相互引用
- 到了内存以后就会给其分配内存地址，比如A为0x1122,B为0x1136，他们之间就通过地址直接引用
这个过程都是JVM虚拟机来完成的

6.9 Initialization（初始化)

到初始化阶段，才真正开始执行类中定义的 Java 程序代码，此阶段是执行()方法的过程。
() 方法是由编译器按语句在源文件中出现的顺序，依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并。[举例说明ClassLoad03.javal
虚拟机会保证一个类的 () 方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的 () 方法，其他线程都需要阻塞等待，直到活动线程执行 () 方法完毕[debug源码]
简单代码演示：

/*** 演示类加载的初始化*/
public class ClassLoad03 {public static void main(String[] args) {//代码分析//1. 先加载B类，并生成B的 class 对象//2. 链接 num = 0;//3. 初始化阶段//   依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句,并合并/*执行<clinit>()方法clinit() {System.out.println("B 静态代码块被执行");//num = 300;num = 100;}合并过后: num = 100*///4. 如果输入new B()的时候，还会输出 B 构造器被执行//new B();//类加载//5. 如果不输入 new B() 只写下面那句输出代码的话，//  照样执行上面三个步骤，但不会执行第4步的调用构造器//System.out.println(B.num);//输出 100, 如果直接使用类的静态属性，也会导致类的加载B b = new B();//追一下源码/*protected Class<?> loadClass(String name, boolean resolve)throws ClassNotFoundException{//正因为有这个机制，才能保证某个类在内存中, 只有一份 Class 对象synchronized (getClassLoadingLock(name)) {//...}}*/}
}class B {static {System.out.println("B 静态代码块被执行");num = 300;}static int num = 100;public B() {//构造器System.out.println("B 构造器被执行");}
}

7. 通过反射获取类的结构信息

7.1 第一组: java.lang.Class 类

getName:获取全类名
getSimpleName:获取简单类名
getFields:获取所有public修饰的属性，包含本类以及父类的
getDeclaredFields:获取本类中所有属性
getMethods:获取所有public修饰的方法，包含本类以及父类的
getDeclaredMethods:获取本类中所有方法
getConstructors: 获取本类所有public修饰的构造器
getDeclaredConstructors:获取本类中所有构造器
getPackage:以Package形式返回包信息
getSuperClass:以Class形式返回父类信息
getInterfaces:以Classl]形式返回接口信息
getAnnotations:以Annotation[] 形式返回注解信息

7.2 第二组: java.lang.reflect.Field 类

getModifiers: 以int形式返回修饰符

[说明: 默认修饰符是0，public 是1，private 是 2,protected 是4,static 是 8 ，final 是 16] ,

如果是有不止一个修饰符则是累加，例如public(1) + static (8) = 9
getType:以Class形式返回类型3.getName:返回属性名

7.3 第三组: java.lang.reflect.Method 类

getModifiers:以int形式返回修饰符

[说明: 默认修饰符是0，public 是1 ，private 是2，protected 是4.static 是8，final是16]

如果是有不止一个修饰符则是累加，例如public(1) + static (8) = 9
getReturnType:以Class形式获取返回类型
getName:返回方法名
getParameterTypes:以Class[]返回参数类型数组

7.4 第四组: java.lang.reflect.Constructor 类

getModifiers: 以int形式返回修饰符
getName:返回构造器名 (全类名)
getParameterTypes:以Class[]返回参数类型数组

7.5 上述的四组的方法的综合演示

/*** 演示如何通过反射获取类的信息*/
public class ReflectionUtils {public static void main(String[] args) {}//第二、三、四组方法API02@Testpublic void api_02() throws ClassNotFoundException, NoSuchMethodException {//第一步：得到class对象Class<?> personCls = Class.forName("com.song.reflection.Person");//第二组: java.lang.reflect.Field 类//1. getModifiers: 以int形式返回修饰符//2. getType:以Class形式返回类型3.getName:返回属性名//   [说明: 默认修饰符 是0，public 是1，private 是 2,protected 是4,static 是 8 ，final 是 16] ,//  如果是有不止一个修饰符则是累加，例如public(1) + static (8) = 9//  getDeclaredFields:获取本类中所有属性Field[] declaredFields = personCls.getDeclaredFields();for (Field declaredField : declaredFields) {System.out.println("本类中所有的属性 = " + declaredField.getName()+ " 该属性的修饰符值 = " + declaredField.getModifiers()+ " 该属性的类型 = " + declaredField.getType());//输出//本类中所有的属性 = name 该属性的修饰符值 = 1 该属性的类型 = class java.lang.String//本类中所有的属性 = age 该属性的修饰符值 = 4 该属性的类型 = int//本类中所有的属性 = job 该属性的修饰符值 = 0 该属性的类型 = class java.lang.String//本类中所有的属性 = sal 该属性的修饰符值 = 2 该属性的类型 = double}//第三组: java.lang.reflect.Method 类//1. getModifiers: 以int形式返回修饰符//2. getReturnType:以Class形式获取 返回类型//3. getName:返回方法名//   [说明: 默认修饰符 是0，public 是1，private 是 2,protected 是4,static 是 8 ，final 是 16] ,//  如果是有不止一个修饰符则是累加，例如public(1) + static (8) = 9//  getDeclaredMethods:获取本类中所有方法Method[] declaredMethods = personCls.getDeclaredMethods();for (Method declaredMethod : declaredMethods) {System.out.println("本类中所有的方法 = " + declaredMethod.getName()+ " 该方法的访问修饰符值 = " + declaredMethod.getModifiers()+ " 该方法的返回类型 = " + declaredMethod.getReturnType()+ "");//输出//本类中所有的方法 = m1 该方法的访问修饰符值 = 1 该方法的返回类型 = void//本类中所有的方法 = m2 该方法的访问修饰符值 = 4 该方法的返回类型 = class java.lang.String//本类中所有的方法 = m4 该方法的访问修饰符值 = 2 该方法的返回类型 = void//本类中所有的方法 = m3 该方法的访问修饰符值 = 0 该方法的返回类型 = void//4. getParameterTypes:以Class[]返回参数类型数组//输出当前这个方法的形参数组情况Class<?>[] parameterTypes = declaredMethod.getParameterTypes();for (Class<?> parameterType : parameterTypes) {System.out.println("该方法的形参类型 = " + parameterType);//只输出了Person类中 m1() 方法的形参类型，其他方法是无参类型//该方法的形参类型 = class java.lang.String//该方法的形参类型 = int//该方法的形参类型 = double}}//第四组: java.lang.reflect.Constructor 类//1. getModifiers: 以int形式返回修饰符//2. getName:返回构造器名 (全类名)//   getDeclaredConstructors:获取本类中所有构造器Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();for (Constructor<?> declaredConstructor : declaredConstructors) {System.out.println("本类中所有的构造器 = " + declaredConstructor.getName()+ " 该构造器的访问修饰符值 = " + declaredConstructor.getModifiers());//输出//本类中所有的构造器 = com.song.reflection.Person 该构造器的访问修饰符值 = 1//本类中所有的构造器 = com.song.reflection.Person 该构造器的访问修饰符值 = 1//本类中所有的构造器 = com.song.reflection.Person 该构造器的访问修饰符值 = 2//3. getParameterTypes:以Class[]返回参数类型数组Class<?>[] parameterTypes = declaredConstructor.getParameterTypes();for (Class<?> parameterType : parameterTypes) {System.out.println("该构造器的形参类型 = " + parameterType);//返回了两个有参构造器的形参//第一个是 public Person(String name){} 构造器的//该构造器的形参类型 = class java.lang.String//第二个是 private Person(String name , int age){} 构造器的//该构造器的形参类型 = class java.lang.String//该构造器的形参类型 = int}}}//第一组方法API01@Testpublic void api_01() throws ClassNotFoundException, NoSuchMethodException {//第一步：得到class对象Class<?> personCls = Class.forName("com.song.reflection.Person");//1. getName:获取全类名System.out.println("全类名 = " + personCls.getName());//输出 全类名 = com.song.reflection.Person//2. getSimpleName:获取简单类名System.out.println("类名 = " + personCls.getSimpleName());//输出 类名 = Person//3. getFields:获取所有public修饰的属性，包含本类以及父类的Field[] fields = personCls.getFields();for (Field field : fields) {System.out.println("本类及父类的属性 = " + field.getName());//输出//本类及父类的属性 = name//本类及父类的属性 = hobby}//4. getDeclaredFields:获取本类中所有属性Field[] declaredFields = personCls.getDeclaredFields();for (Field declaredField : declaredFields) {System.out.println("本类中所有的属性 = " + declaredField.getName());//输出//本类中所有的属性 = name//本类中所有的属性 = age//本类中所有的属性 = job//本类中所有的属性 = sal}//5. getMethods:获取所有public修饰的方法，包含本类以及父类的Method[] methods = personCls.getMethods();for (Method method : methods) {System.out.println("本类及父类的方法 = " + method.getName());//输出//本类及父类的方法 = m1//本类及父类的方法 = f1//本类及父类的方法 = wait//本类及父类的方法 = wait//本类及父类的方法 = wait//本类及父类的方法 = equals//本类及父类的方法 = toString//本类及父类的方法 = hashCode//本类及父类的方法 = getClass//本类及父类的方法 = notify//本类及父类的方法 = notifyAll}//6. getDeclaredMethods:获取本类中所有方法Method[] declaredMethods = personCls.getDeclaredMethods();for (Method declaredMethod : declaredMethods) {System.out.println("本类中所有的方法 = " + declaredMethod.getName());//输出//本类中所有的方法 = m1//本类中所有的方法 = m2//本类中所有的方法 = m4//本类中所有的方法 = m3}//7. getConstructors: 获取本类所有public修饰的构造器Constructor<?>[] constructors = personCls.getConstructors();for (Constructor<?> constructor : constructors) {System.out.println("本类的构造器 = " + constructor.getName());//输出//本类的构造器 = com.song.reflection.Person//本类的构造器 = com.song.reflection.Person}//8. getDeclaredConstructors:获取本类中所有构造器Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();for (Constructor<?> declaredConstructor : declaredConstructors) {System.out.println("本类中所有的构造器 = " + declaredConstructor.getName());//输出//本类中所有的构造器 = com.song.reflection.Person//本类中所有的构造器 = com.song.reflection.Person//本类中所有的构造器 = com.song.reflection.Person}//9. getPackage:以Package形式返回 包信息System.out.println("包信息 = " + personCls.getPackage());//输出//包信息 = package com.song.reflection//10. getSuperClass:以Class形式返回父类信息System.out.println("父类信息 = " + personCls.getSuperclass());//输出//父类信息 = class com.song.reflection.A//11. getInterfaces:以Classl]形式返回接口信息Class<?>[] interfaces = personCls.getInterfaces();for (Class<?> anInterface : interfaces) {System.out.println("接口信息 = " + anInterface.getName());//输出//接口信息 = com.song.reflection.IA//接口信息 = com.song.reflection.IB}//12. getAnnotations:以Annotation[] 形式返回注解信息Annotation[] annotations = personCls.getAnnotations();for (Annotation annotation : annotations) {System.out.println("注解信息 = " + annotation);//输出//注解信息 = @java.lang.Deprecated()}}
}class A {//属性public String hobby;//方法public void f1() {}//构造器public A() {}
}//接口
interface IA {}interface IB {}@Deprecated
class Person extends A implements IA, IB {//属性public String name;protected int age;String job;private double sal;//方法public void m1(String name, int age, double sal) {}protected String m2() {return null;}void m3() {}private void m4() {}//构造器public Person() {}public Person(String name) {}//私有的private Person(String name, int age) {}
}

8. 通过反射创建对象

8.1 基本介绍

方式一:调用类中的public修饰的无参构造器
方式二:调用类中的指定构造器
Class类相关方法

newInstance : 调用类中的无参构造器，获取对应类的对象

getConstructor(Class…clazz):根据参数列表，获取对应的public构造器对象

getDecalaredConstructor(Class…clazz):根据参数列表，获取对应的所有构造器对象
Constructor类相关方法

setAccessible:暴破

newInstance(Object…obj):调用构造器

8.2 案例演示 ReflecCreateInstance.java

测试 1：通过反射创建某类的对象，要求该类中必须有 public 的无参构造
测试 2：通过调用某个特定构造器的方式，实现创建某类的对象
简单代码演示：

/*** 演示通过反射机制创建实例*/
public class ReflecCreateInstance {public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {//1. 先获取到User类的class对象Class<?> userClass = Class.forName("com.song.reflection.User");//测试 1：通过反射创建某类的对象，要求该类中必须有 public 的无参构造//(1)通过public的无参构造器创建实例//  newInstance : 调用类中的无参构造器，获取对应类的对象Object o = userClass.newInstance();System.out.println(o);//输出 User [age=10, name=sys学java]//(2)通过public的有参构造器创建实例//  getConstructor(Class...clazz):根据参数列表，获取对应的public构造器对象/*这里的constructor对象就是public User(String name) {//public 的有参构造器this.name = name;}*///先得到对应的构造器Constructor<?> constructor = userClass.getConstructor(String.class);//然后创建实例，并传入参数Object sys = constructor.newInstance("sys");System.out.println("sys = " + sys);//输出 sys = User [age=10, name=sys]//测试 2：通过调用某个特定构造器的方式，实现创建某类的对象//(1)通过非public的有参构造器创建实例//  getDecalaredConstructor(Class...clazz):根据参数列表，获取对应的所有构造器对象Constructor constructor1 = constructor1 = userClass.getDeclaredConstructor(int.class, String.class);//如果不关闭访问安全检查，那么就不能给它赋值，因为它不是public类型的constructor1.setAccessible(true);//也就是爆破//然后创建实例，并传入参数Object sys2 = constructor1.newInstance(15, "sys");System.out.println("sys2 = " + sys2);//输出 sys2 = User [age=15, name=sys]}
}class User { //User 类private int age = 10;private String name = "sys学java";public User() {//public 的无参构造器}public User(String name) {//public 的有参构造器this.name = name;}private User(int age, String name) {//private 的有参构造器this.age = age;this.name = name;}public String toString() {return "User [age=" + age + ", name=" + name + "]";}
}

9. 通过反射访问类中的成员

9.1 访问属性

根据属性名获取Field对象

Field f = clazz对象.getDeclaredField(属性名);
暴破 : f.setAccessible(true); //f 是Field
访问

f.set(o,值): // o 表示对象

syso(f.get(o));//o 表示对象
注意: 如果是静态属性，则set和get中的参数o，可以写成null
简单代码演示： ReflecAccessProperty.java

/*** 演示反射操作属性*/
public class ReflecAccessProperty {public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {//1. 得到Student类对应的Class对象Class<?> studentClass = Class.forName("com.song.reflection.Student");//2. 创建对象Object o = studentClass.newInstance();System.out.println(o.getClass());//class com.song.reflection.Student//3. 使用反射得到 age 属性对象Field age = studentClass.getField("age");age.set(o, 18);//通过反射来操作对象System.out.println(o);//Student [age=18, name=null]System.out.println(age.get(o));//也可以这么写    直接输出18//4. 使用反射操作 name 属性Field name = studentClass.getDeclaredField("name");//因为name属性是私有的，所以我们要进行爆破name.setAccessible(true);//爆破name.set(o, "song");//因为name是 static 属性，因此 o 也可以写为 null//name.set(o,"song");System.out.println(name.get(o));//song//只有当静态的时候才可以写为null//System.out.println(name.get(null));}
}class Student {//类public int age;private static String name;public Student() {//构造器}public String toString() {return "Student [age=" + age + ", name=" + name + "]";}
}

9.2 访问方法

根据方法名和参数列表获取Method方法对象:

Method m =clazz.getDeclaredMethod(方法名，XX.class); //得到本类的所有方法
获取对象: Object o=clazz.newlnstance0);
暴破 : m.setAccessible(true);
访问 :Object returnValue = m.invoke(o,实参列表)

反射(reflection)基础相关推荐
1. C#反射(Reflection)详解
  1. 什么是反射 2. 命名空间与装配件的关系 3. 运行期得到类型信息有什么用 4. 如何使用反射获取类型 5. 如何根据类型来动态创建对象 6. 如何获取方法以及动态调用方法 7. 动态创建委托 ...
2. CSharpGL(43)环境映射(Environment Mapping)-天空盒(Skybox)反射(Reflection)和折射(Refraction)...
  CSharpGL(43)环境映射(Environment Mapping)-天空盒(Skybox)反射(Reflection)和折射(Refraction) 开始如图所示,本文围绕GLSL里的sam ...
3. JavaScript 中Proxy（代理）和Reflect（反射）基础知识
  JavaScript 中Proxy(代理)和Reflect(反射)基础知识最近在Vue3项目开发中,我们经常使用与Proxy和Reflect相关的函数.这些函数以各种形式出现在Vue3 Reac ...
4. JavaSE——第23章反射reflection
  JavaSE--第23章反射reflection(老师:韩顺平) 文章目录 JavaSE--第23章反射reflection(老师:韩顺平) 23.2 反射机制 23.2.1 Java refle ...
5. Java基础--反射Reflection
  Reflection 反射能在运行时获取一个类的全部信息,并且可以调用类方法,修改类属性,创建类实例. 而在编译期间不用关心对象是谁反射可用在动态代理,注解解释,和反射工厂等地方. -------- ...
6. java f反射_java反射机制[基础学习]
  1.4 找出类的方法找出一个类中定义了些什么方法,这是一个非常有价值也非常基础的 reflection 用法.下面的代码就实现了这一用法: import java.lang.reflect.*; p ...
7. java基础之反射_Java基础之反射原理与用法详解
  本文实例讲述了Java基础之反射原理与用法.分享给大家供大家参考,具体如下: 1.什么是反射? 反射其实就是动态的加载类,我们在写JDBC的时候加载驱动Class.forName("xxx& ...
8. 反射(Reflection)
  能够分析类能力的程序称为反射. 检查类的结构(反射机制最重要的内容) 使用反射在运行时分析对象使用反射编写泛型数组代码调用任意方法与构造器动态语言的关键,允许程序在执行期间借助 Reflecti ...
9. 什么是反射 (Reflection)?可以用它做什么？
  一.什么是反射: (1)Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息,从而操作类或对象的属性和方法.本质是JVM得到class对象之后,再通过class对象进行反编译,从而获取对象 ...
最新文章
热门文章

反射(reflection)基础