什么是反射
（1）Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。
（2）Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。
（3）反射机制允许程序在执行期借助于 Reflection API取得任何类的内部信息（比如成员变量，成员方法，构造器等等），并能操作对象的属性及方法。反射在设计模式和框架底层都会用到。
（4）加载类完成之后，在堆中就产生了一个 Class类型的对象（一个类只有一个Class对象）这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，形象的称之为：反射
反射机制
-
Java反射机制可以完成
1.在运行时判断任意一个对象所属的类
2.在运行时构造任意一个类的对象
3.在运行时得到任意一个类锁具有的成员和方法
4.在运行时调用任意一个对象的成员和方法
5.生成动态代理 -
反射相关的主要类：
1.java.lang.Class:代表一个类，Class对象表示某个类加载后在堆中的对象
2.java.lang.reflect.Method:代表类的方法，Method 对象表示某个类的方法
3.java.lang.reflect.Field：代表类的成员变量，Field对象表示某个类的成员变量
4.java.lang.reflect.Constructor：代表类的构造方法，Constructor对象表示构造器 -
缺点和优点
1.优点：可以动态的创建和使用对象（也是框架的底层核心），使用灵活，没有反射机制，框架机制就失去底层支撑。
2.缺点：使用反射基本是解释执行，对执行速度有影响
获取Class类对象
1.前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException,
实例：Class cls1 = Class.Name(“java.lang.Cat”);
应用场景：多用于配置文件，读取类全路径，加载类
2.前提：若已知具体的类，通过类的calss获取，该方式最为安全可靠，程序性能
最高实例：Class cls2 = Cat.class
应用场景：多用于参数传递，比如通过反射得到对应构造器对象。
3.已知某个类的实例，调用该实例的getClass()方法获取Class对象，
实例：Class clazz = 对象.getClass();
应用场景：通过创建好的对象，获取Class对象。
4.其他方式：
ClassLoader cl = 对象.getClass().getClassLoader();
Class clazz4 = cl.loadClass(“类的全类名”)
5.基本数据类型（byte int shot char float double long boolean）按如下方式得到Class类对象
6.基本数据类型对应包装类可以通过 .TYPE 得到 Class 类对象
package com.hspedu.reflection.class_;
import com.hspedu.Car;
/**
* @author 山河与you皆无恙
*演示得到class对象的各种方式
*/
public class GetClass_ {
public static void main(String[] args) throws ClassNotFoundException {
//1.Class.forName
String classAllPath = "com.hspedu.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);
System.out.println(cls1.hashCode());
System.out.println(cls2.hashCode());
System.out.println(cls3.hashCode());
System.out.println(cls4.hashCode());
//5.基本数据类型（byte int shot char float double long boolean）按如下方式得到Class类对象
Class<Integer> integerClass = int.class;
Class<Character> characterClass = char.class;
Class<Boolean> booleanClass = boolean.class;
System.out.println(integerClass);
//6.基本数据类型对应包装类可以通过 .TYPE 得到 Class 类对象
Class<Integer> type1 = Integer.TYPE;
Class<Character> type2 = Character.TYPE;
System.out.println(type1);
}
}
哪些类型有Class对象
package com.hspedu.reflection.class_;
import java.io.Serializable;
/**
* @author 山河与you皆无恙
* 演示哪些类型有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;//枚举
Class<Long> cls7 = Long.class;
Class<Void> cls8 = void.class;
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(cls7);
System.out.println(cls8);
System.out.println(cls9);
}
}
类加载
-
基本说明
反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载
1.静态加载：编译时加载相关的类，如果没有则报错，依赖性太强
2.动态加载：运行时加载需要的类，如果运行时不用该类，即使不存在该类，则不报错，降低了依赖性 -
类加载时机
1.当创建对象时（new）//静态加载
2.当子类被加载时，父类也加载//静态加载
3.调用类中的静态成员时//静态加载
4.通过反射//动态加载
类加载流程图
package com.hspedu.reflection.classLoad_;
/**
* @author 山河与you皆无恙
*/
public class ClassLod03 {
public static void main(String[] args) {
//1.加载 B类，生成Class对象
//2.链接 num = 0
//3.初始化
//依次自动收集类中所有静态变量的赋值动作和静态代码块中的语句，并合并
/*
clinit(){
System.out.println("B 的静态代码块被执行");
num = 30;
num = 100;
}
合并：num = 100
*/
new B();
System.out.println(B.num);//100,如果直接使用类的静态属性，也会导致类的加载
}
}
class B{
static {
System.out.println("B 的静态代码块被执行");
num = 30;
}
static int num = 100;
public B(){
System.out.println("B 的构造方法被执行");
}
}
获取类结构信息
package com.hspedu.reflection;
import org.junit.Test;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* @author 山河与you皆无恙
* 获取类的结构信息
*/
public class ReflectionUtils {
public static void main(String[] args) {
}
@Test
public void api_02() throws ClassNotFoundException {
//得到Class对象
Class<?> personCls = Class.forName("com.hspedu.reflection.Person");
//规定：说明：默认修饰符是 0，public是1，private是2，protected是4，static是8，final是16
Field[] declaredFields = personCls.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(" 本类中所有属性 "+declaredField.getName()+
" 本类中所有修饰符值 " +declaredField.getModifiers()+
" 该属性的类型 "+declaredField.getType());
}
//getDeclaredMethods:获取本类所有方法
Method[] declaredMethods = personCls.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println(" 获取本类所有方法 "+declaredMethod);
System.out.println(" 本类中所有属性 "+declaredMethod.getName()+
" 本方法访问修饰符值 " +declaredMethod.getModifiers()+
" 该方法返回的类型 "+declaredMethod.getReturnType());
Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
for (Class<?> parameterType : parameterTypes) {
System.out.println(" 该方法的形参类型 "+parameterType);
}
}
System.out.println("================================");
//getDeclaredConstructors：获取本类所有构造器
Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
for (Constructor<?> declaredConstructor : declaredConstructors) {
System.out.println("获取本类所有构造器"+declaredConstructor.getName());
Class<?>[] parameterTypes = declaredConstructor.getParameterTypes();
for (Class<?> parameterType : parameterTypes) {
System.out.println(" 该构造器的形参类型 "+parameterType);
}
}
}
@Test
public void api_01() throws ClassNotFoundException {
//得到Class对象
Class<?> personCls = Class.forName("com.hspedu.reflection.Person");
//getName:获取全类名
System.out.println(personCls.getName());//com.hspedu.reflection.Person
//getSimpleName:获取简单类名
System.out.println(personCls.getSimpleName());//Person
//getFields：获取所有public修饰的属性，包含本类以及父类的
Field[] fields = personCls.getFields();
for (Field field: fields) {
System.out.println("本类以及父类的="+field.getName());
}
//getFields：获取本类所有属性
Field[] declaredField = personCls.getDeclaredFields();
for (Field field : declaredField) {
System.out.println("获取本类所有属性="+field.getName());
}
//getMethods：获取所有public修饰的方法，包含本类及父类的
Method[] methods = personCls.getMethods();
for (Method method : methods) {
System.out.println();
}
//getDeclaredMethods:获取本类所有方法
Method[] declaredMethods = personCls.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println("获取本类所有方法"+declaredMethod);
}
//getConstructors:获取本类以及父类的构造器
Constructor<?>[] constructors = personCls.getConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println("获取本类以及父类的构造器"+constructor.getName());
}
//getDeclaredConstructors：获取本类所有构造器
Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
for (Constructor<?> declaredConstructor : declaredConstructors) {
System.out.println("获取本类所有构造器"+declaredConstructor.getName());
}
//getPackage:以Package形式返回 包信息
System.out.println(personCls.getPackage());
//getSuperclass:以Class形式返回父类信息
Class<?> superclass = personCls.getSuperclass();
System.out.println("父类的Class对象="+superclass);
//getInterfaces：以Class[]返回接口信息
Class<?>[] personClsInterfaces = personCls.getInterfaces();
for (Class<?> personClsInterface : personClsInterfaces) {
System.out.println("接口信息="+personClsInterface);
}
//getAnnotations：以Annotation[]返回注解信息
Annotation[] annotations = personCls.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println("注解信息="+annotations);
}
}
}
class A{
public String hobby;
}
class Person extends A{
//属性
public String name;
protected int age;
String job;
private double sal;
public Person(){}
public Person(String name){}
public void m1(){
}
protected void m2(){
}
void m3(){
}
private void m4(){
}
}
反射爆破创建实例
package com.hspedu.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
* @author 山河与you皆无恙
*/
public class ReflectCreateInstance {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
//1.先获取User类的Class对象
Class<?> userClass = Class.forName("com.hspedu.reflection.User");
//2.通过pubic的无参构造器创建实例
Object o = userClass.newInstance();
System.out.println(o);
//3.通过pubic的有参构造器创建实例
//3.1先得到对应的构造器
Constructor<?> constructor = userClass.getConstructor(String.class);
//3.2 创建实例并传入实参
Object hsp = constructor.newInstance("韩顺平");
System.out.println("hsp = "+hsp);
//4.通过非pubic的有参构造器创建实例
//4.1先得到私有的构造器对象
Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class,String.class);
//4.2 创建实例并传入实参
constructor1.setAccessible(true);//爆破【包里破解】使用反射可以访问private构造器/方法/属性
Object user2 = constructor1.newInstance(100, "张三丰");
System.out.println("user2 = "+user2);
}
}
class User{
private int age = 10;
private String name = "韩顺平教育";
public User(){}
public User( String name){
this.age = age;
this.name = name;
}
private User(int age,String name){
this.age = age;
this.name = name;
}
@Override
public String toString() {
return "User{" +
"age=" + age +
", name='" + name + ''' +
'}';
}
}
反射爆破操作属性
package com.hspedu.reflection;
import java.lang.reflect.Field;
/**
* @author 山河与you皆无恙
* 演示反射操作属性
*/
public class ReflectAccessProperty {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
//1.得到Student对应的Class对象
Class<?> stuClass = Class.forName("com.hspedu.reflection.Student");
//2.创建实例
Object o = stuClass.newInstance();
//3.使用反射得到age属性对象
Field age = stuClass.getField("age");
age.set(o,88);//通过反射操作属性
System.out.println(o);
System.out.println(age.get(o));//返回age属性的值
//4.使用反射操作name属性
Field name = stuClass.getDeclaredField("name");
//对name使用爆破，可以操作private属性
name.setAccessible(true);
//name.set(o,"老韩");
name.set(null,"老韩~");//因为name是static属性，因此 o 也可以写为null
System.out.println(o);
System.out.println(name.get(o));//获取属性值
System.out.println(name.get(null));//获取属性值，要求name是static
System.out.println(o);
}
}
class Student{
public int age;
private static String name;
public Student(){
}
/* public Student(String name){
this.name=name;
}*/
@Override
public String toString() {
return "Student{" +
" age=" + age +" name="+name+
'}';
}
}
反射爆破操作方法
package com.hspedu.reflection;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* @author 山河与you皆无恙
* 演示反射操作方法
*/
public class ReflectAccessMethod {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
//1.得到Boss类的class对象
Class<?> bossCls = Class.forName("com.hspedu.reflection.Boss");
//2.创建对象
Object o = bossCls.newInstance();
//3.调用public的hi方法
//Method hi = bossCls.getMethod("hi",String.class);
//3.1得到hi方法对象
Method hi = bossCls.getDeclaredMethod("hi",String.class);
hi.invoke(o,"韩顺平教育");
//4.调用private static 方法
//4.1 得到say方法对象
Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
//4.2因为say方法是private 所以需要爆破
say.setAccessible(true);
System.out.println( say.invoke(o,100,"张三",'男'));
//4.3因为say方法是static 还可以这样调用，可以传入null
System.out.println( say.invoke(null,200,"李四",'女'));
//5.在反射中，如果方法有返回值，统一返回Object 运行类型和方法定义的返回类型一致
Object reVal = say.invoke(null,300,"王五",'男');
System.out.println("reVal 的运行类型"+reVal.getClass());//String
}
}
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){
System.out.println("hi "+s);
}
}
我亦无他，唯他熟尔！
原文始发于微信公众号（itmkyuan）：Java反射
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/39466.html
