网站推广平台搭建,aspnet网站开发的书籍,辽宁省住房和城乡建设厅网站打不开,全国定制网站服务器云主机反射
使用的前提条件#xff1a;必须先得到代表的字节码的Class#xff0c;Class类用于表示.class文件#xff08;字节码#xff09;
原理图 加载完类后#xff0c;在堆中就产生了一个Class类型的对象#xff08;一个类只有一个Class对象#xff09;#xff0c;这个对… 反射
使用的前提条件必须先得到代表的字节码的ClassClass类用于表示.class文件字节码
原理图 加载完类后在堆中就产生了一个Class类型的对象一个类只有一个Class对象这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个Class对象就像一面镜子透过这个镜子看到类的结构所以形象的称之为反射。
使用
配置文件re.properties
classfullpathcom.reflection.Cat
methodhi
package com.reflection;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;public class quection {public static void main(String[] args) {//问题根据配置文件 re.properties 中的指定信息创建Cat类 并 调用hi方法//反射//1. 使用Properties类 获取配置文件中的内容Properties properties new Properties();properties.load(new FileInputStream(src\\main\\resources\\re.properties));String classfullpath properties.getProperty(classfullpath);String methodname properties.getProperty(method);System.out.println(classfullpath: classfullpath);System.out.println(method: method);//2. 使用反射机制解决Class aClass Class.forName(classfullpath); //加载类返回Class类型的对象aClassObject o aClass.newInstance(); //通过aClass得到 com.reflection.Cat 类的对象实例System.out.println(o的运行类型 o.getClass());//通过 aClass 得到 com.reflection.Cat 类的 methodName为“hi”的方法对象//即在反射中可把方法视为对象万物接对象Method method1 aClass.getMethod(methodname);System.out.println();//通过 方法对象 来实现 调用方法; 也就是 通过 method1对象 来调用 Cat类中的方法method1.invoke(o);//传统方法对象.方法(); 反射方法.invoke(对象);}
}Java反射机制可以完成
1、在运行时判断任意一个对象所属的类 2、在运行时构造任意一个类的对象 3、在运行时得到任意一个类所具有的成员变量和方法 4、在运行时调用任意一个对象的成员变量和方法 5、生成动态代理
反射相关的主要类
在java.lang.reflection包中 1、java.lang.Class代表一个类Class对象表示某个类加载后在堆中的对象 2、java.lang.reflect.Method代表类的方法Method对象表示某个类的方法 3、java.lang.reflect.Field代表类的成员变量Field对象表示某个类的成员变量 4、java.lang.reflect.Constructor代表类的构造方法Constructor对象表示构造器
//java.lang.reflect.Field代表类的成员变量Field对象表示某个类的成员变量//得到name字段//getField不能得到私有的属性Field name cls.getField(age);System.out.println(name.get(o));//传统写法对象.成员变量 反射成员变量对象.get(对象)//java.lang.reflect.Constructor代表类的构造方法Constructor对象表示构造器Constructor constructor aClass.getConstructor();//()中可以指定构造器参数类型返回无参构造器System.out.println(constructor);//Cat()Constructor constructor1 aClass.getConstructor(String.class);//这里传入的String.class 就是String类的Class对象System.out.println(constructor1);//Cat(String name)反射的简单优化——关闭访问检查
1、Method 和 Field、Constructor对象都有setAccessible()方法 2、setAccessible作用是启动和禁用访问安全检查的开关 3、参数值为true表示反射的对象在使用时取消访问检查提高反射的效率。参数值为false则表示反射的对象执行访问检查。
Method method1 aClass.getMethod(hi);//通过 aClass 得到 com.reflection.Cat 类的 methodName为“hi”的方法对象method1.setAccessible(true);
Class类
1、Class也是类因此也继承Object类 2、Class类对象不是new出来的而是系统创建的通过类加载器创建的 3、对于某一个类的Class类对象在内存中只有一份因为类只加载一次同一个类的类加载只有一次 4、每个类的实例都会记得自己是由哪个Class实例所生成 5、通过Class对象可以完整地得到一个类的完整结构通过一系列API 6、Class对象是存放在堆的 7、类的字节码二进制数据是放在方法区的有的地方称为类的元数据(包括 方法代码变量名方法名访问权限等) Class? aClass Class.forName(com.reflection.Cat);//对于某一个类的Class类对象在内存中只有一份因为类只加载一次Class? bClass Class.forName(com.reflection.Cat);System.out.println(aClass.hashCode()); //hashCode356573597System.out.println(bClass.hashCode()); //hashCode356573597Class? cClass Class.forName(com.reflection.Dog);System.out.println(cClass.hashCode());//hashCode1735600054Class类的常用方法
package com.reflection.class_;import com.reflection.Car;import java.lang.reflect.Field;public class Class02 {public static void main(String[] args) throws Exception {String classpath com.reflection.Car;//1、返回指定类名 classpath 的 Class 对象//? 表示不确定的java类型Class? aClass Class.forName(classpath);System.out.println(aClass);//aClass是哪个类的Class对象com.reflection.CarSystem.out.println(aClass.getClass());//aClass 的运行类型java.lang.Class//2、获取包名System.out.println(aClass.getPackage().getName());//3、获取全类名System.out.println(aClass.getName());//4、创建实例对象//newInstance会调用无参构造方法无参构造方法必须存在Object car aClass.newInstance();Car car (Car) aClass.newInstance();System.out.println(car);//5、通过反射获取属性Field brand aClass.getField(brand);System.out.println(brand.get(car));//6、通过反射给属性赋值brand.set(car,凯迪拉克);System.out.println(brand.get(car));//7、获取所有的public属性字段Field[] fields aClass.getFields();for (Field f : fields) {System.out.println(f.getName());//名称}//8、获取所有的属性字段Field[] declaredFields aClass.getDeclaredFields();for (Field f : declaredFields) {System.out.println(f.getName());//名称}}
}如果只想让类的静态代码块执行只需要写Class.forName(); 获取Class对象的6种方式
1、Class.forName(“全类名”)
使用前提 已知一个类的全类名且该类在类路径下可通过Class类的静态方法forName()获取可能抛出ClassNotFoundException异常应用场景 多用于配置文件读取类全路径加载类
String classpath com.reflection.Car;
//1、返回指定类名 classpath 的 Class 对象
//? 表示不确定的java类型
Class? aClass Class.forName(classpath);
2、类名.class
使用前提 已知具体的类通过类的class获取该方式最为安全可靠程序性能最高应用场景 多用于参数传递比如通过反射得到对应构造器对象
Class cls Car.class;
3、对象.getClass()
使用前提 已知某个类的实例调用该实例的getClass()方法获取Class对象应用场景 通过创建好的对象获取Class对象
Car car new Car();
Class cls car.getClass();//运行类型
4、classLoader对象.loadClass(“类的全类名”);
//(1)先得到类加载器 car
Car car new Car();
ClassLoader classLoader car.getClass().getClassLoader();
//(2)通过类加载器得到Class对象
Class cls classLoader.loadClass(com.reflection.Car);5、基本数据intcharbooleanfloatdoublebytelongshort可以直接 基本数据类型.class 得到Class类对象
Class cls 基本数据类型.class;EX:
ClassInteger integerClass int.class;
6、基本数据类型对应的包装类可以通过.TYPE 得到Class类对象包装类.TYPE
Class cls 包装类.TYPEEX:
ClassCharacter type Character.TYPE;
哪些类型有Class对象
1、外部类成员内部类静态内部类局部内部类匿名内部类 2、interface接口 3、数组 4、enum枚举 5、annotation注解 6、基本数据类型 7、void
ClassString aClass1 String.class;//外部类
ClassSerializable aClass2 Serializable.class;//接口
ClassInteger[] aClass3 Integer[].class;//数组
Classfloat[][] aClass4 float[][].class;//二维数组
ClassDeprecated aClass5 Deprecated.class;//注释
//枚举
ClassThread.State aClass6 Thread.State.class;
//基本数据类型
ClassLong aClass7 long.class;
//void数据类型
ClassVoid aClass8 void.class;
ClassClass aClass9 Class.class;//class对象类加载
反射机制是java实现动态语言的关键java通过反射实现类动态加载 1、静态加载编译时(执行javac命令时)加载相关的类如果类不存在则报错依赖性太强 2、动态加载运行时加载需要的类如果运行时用不到该类则不会报错即使这个类不存在这样降低了依赖性
//静态加载
Dog dog new Dog();
//编译时类不存在则报错依赖性太强//反射 - 动态加载
Class cls Class.forName(Person)
//加载Person类,运行时执行到该段代码时才会进行加载用不到该类不会报错即使这个类不存在类加载时机
1、当创建对象时new//静态加载 2、当子类被加载时父类也加载 //静态加载 3、调用类中的静态成员时 //静态加载 4、通过反射 //动态加载
类加载的三个阶段
加载、连接验证、准备、解析、初始化 连接阶段-准备
class A{//属性-成员变量-字段 是如何处理的//1、n1 是实例属性不是静态变量在准备阶段是不会分配内存的//2、n2 是静态变量分配内存n2 并弄人初始化值为0而不是20(20是在初始化阶段进行赋值的)//3、n3 是static final是常量和静态变量不一样一旦赋值就不变 n3 30;public int n1 10;public static int n2 20;public static final int n3 30;
}路径问题
离开IDEA就无效了 src是类的根路径 //Thread.currentThread()是线程方法//getContextClassLoader()是线程对象的方法可以获取到当前线程的类加载器对象//getResource()是类加载器对象的方法当前线程的类加载器默认从类的根路径下加载资源从src的下一级开始写//可以拿到文件的绝对路径String path Thread.currentThread().getContextClassLoader().getResource(classinfo.properties).getPath();FileReader reader new FileReader(path);//拿到绝对路径自己new了一个流new Properties();
直接以流的形式返回
InputStream reader Thread.currentThread().getContextClassLoader().getResourceAsStream(classinfo.properties);
new Properties();
资源绑定器
java.util包下提供了一个资源绑定器便于获取属性配置文件中的内容属性配置文件xx.properties必须放在类路径下,从src的下一级开始最后不写properties后缀 ResourceBundle bundle ResourceBundle.getBundle(classinfo);String className bundle.getString(className);//不需要 new Properties();
通过反射获取类的结构信息
一、java.lang.Class类
1、getName获取全类名 2、getSimpleName获取简单类名 3、getFields获取所有public修饰的属性包含本类以及父类 4、getDeclaredFields获取本类中所有属性 5、getMethods获取所有public修饰的方法包含本类以及父类的 6、getDeclaredMethods获取本类中所有方法 7、getConstructors获取本类所有public修饰的构造器 8、getDeclaredConstructors获取本类中所有构造器 9、getPackage以package形式返回包信息 10、getSuperClass以Class形式返回父类信息 11、getIntergaces以Class[]形式返回接口信息 12、getAnnotations以Annotation[]形式返回注解信息
package com.reflection.class_;import org.junit.jupiter.api.Test;import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;public class ReflectionUtils {Testpublic void api_01() throws Exception {//得到Class对象Class? personCls Class.forName(com.reflection.class_.Person);//1、getName获取全类名System.out.println(personCls.getName());//com.reflection.class_.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());}//4、getDeclaredFields获取本类中所有属性Field[] declaredFields personCls.getDeclaredFields();for (Field declaredField : declaredFields) {System.out.println(本类中所有的属性:declaredField.getName());}//5、getMethods获取所有public修饰的方法包含本类以及父类的Method[] methods personCls.getMethods();for (Method method : methods) {System.out.println(本类以及父类中的public方法 method.getName());}//6、getDeclaredMethods获取本类中所有方法Method[] declaredMethods personCls.getDeclaredMethods();for (Method declaredMethod : declaredMethods) {System.out.println(本类中所有方法 declaredMethod.getName());}//7、getConstructors获取本类所有public修饰的构造器Constructor?[] constructors personCls.getConstructors();for (Constructor? constructor : constructors) {System.out.println(本类中所有public修饰的构造器constructor.getName());}//8、getDeclaredConstructors获取本类中所有构造器Constructor?[] declaredConstructors personCls.getDeclaredConstructors();for (Constructor? declaredConstructor : declaredConstructors) {System.out.println(本类中所有构造器declaredConstructor.getName());}//9、getPackage以package形式返回包信息System.out.println(personCls.getPackage());//com.reflection.class_//10、getSuperClass以Class形式返回父类信息Class? superclass personCls.getSuperclass();System.out.println(父类的Class对象superclass);//com.reflection.class_.A//11、getIntergaces以Class[]形式返回接口信息Class?[] interfaces personCls.getInterfaces();for (Class? anInterface : interfaces) {System.out.println(接口信息anInterface);}//12、getAnnotations以Annotation[]形式返回注解信息Annotation[] annotations personCls.getAnnotations();for (Annotation annotation : annotations) {System.out.println(注解信息annotation);}}
}class A {public String hobby;public void hi() {}public A() {}public A(String hobby) {}
}interface IA {}interface IB {}Deprecated
class Person extends A implements IA, IB {//属性public String name;protected static int age;String job;private double sal;//构造器public Person() {}public Person(String name) {}//私有的private Person(String name, int age) {}//方法public void m1(String name, int age, double sal) {}protected String m2() {return null;}void m3() {}private void m4() {}
}二、java.lang.reflect.Field类
1、getModifiers以int形式返回修饰符默认修饰符为0public 为 1private 为2protected 为 4static 为 8final 为 16public(1) static(8) 9
2、getType以Class形式返回类型
3、getName返回属性名
public void api_02() throws Exception {//得到Class对象Class? personCls Class.forName(com.reflection.class_.Person);//getDeclaredFields获取本类中所有属性Field[] declaredFields personCls.getDeclaredFields();for (Field declaredField : declaredFields) {//1、getModifiers以int形式返回修饰符默认修饰符为0public 为 1private 为2protected 为 4static 为 8final 为 16public(1) static(8) 9//2、getType以Class形式返回类型//3、getName返回属性名System.out.println(本类中所有的属性:declaredField.getName()该属性的修饰符值declaredField.getModifiers()该属性的类型 declaredField.getType());}三、java.lang.reflect.Method类
1、getModifiers以int形式返回修饰符默认修饰符为0public 为 1private 为2protected 为 4static 为 8final 为 16 2、getReturnType以Class形式获取返回类型 3、getName返回方法名 4、getParamterTypes以Class[]返回参数类型数组
Test
public void api_02() throws Exception {//得到Class对象Class? personCls Class.forName(com.reflection.class_.Person);//getDeclaredMethods获取本类中所有方法Method[] declaredMethods personCls.getDeclaredMethods();for (Method declaredMethod : declaredMethods) {//1、getModifiers以int形式返回修饰符默认修饰符为0public 为 1private 为2protected 为 4static 为 8final 为 16//2、getReturnType以Class形式获取返回类型//3、getName返回方法名System.out.println(本类中所有方法 declaredMethod.getName()该方法的访问修饰符值declaredMethod.getModifiers()该方法返回类型 declaredMethod.getReturnType());//4、getParamterTypes以Class[]返回参数类型数组输出当前这个方法的形参数组情况Class?[] parameterTypes declaredMethod.getParameterTypes();for (Class? parameterType : parameterTypes) {System.out.println(该方法的形参类型:parameterType);}}
}四、java.lang.reflect.Constructor类
1、getModifiers以int形式返回修饰符 2、getName返回构造器名全类名 3、getParameterTypes以Class[]返回参数类型数组
Test
public void api_02() throws Exception {//得到Class对象Class? personCls Class.forName(com.reflection.class_.Person);//getDeclaredConstructors获取本类中所有构造器Constructor?[] declaredConstructors personCls.getDeclaredConstructors();for (Constructor? declaredConstructor : declaredConstructors) {//1、getModifiers以int形式返回修饰符//2、getName返回构造器名全类名//3、getParameterTypes以Class[]返回参数类型数组System.out.println(本类中所有构造器declaredConstructor.getName()本类中构造器访问修饰符值declaredConstructor.getModifiers());Class?[] parameterTypes declaredConstructor.getParameterTypes();for (Class? parameterType : parameterTypes) {System.out.println(该构造器的形参类型 parameterType);}}通过反射创建对象
使用到的Class类中的相关方法
newInstance调用类中的无参构造器获取对应类的对象 getConstructor(Class…clazz)根据参数列表获取对应的public构造器对象 getDecalaredConstructor(Class…clazz)根据参数列表获取对应的构造器对象
Constructor类相关方法
setAccessible暴破 newInstance(Object…obj)调用构造器
package com.reflection.class_;import java.lang.reflect.Constructor;public class ReflecCreateInstance {public static void main(String[] args) throws Exception {//1、先获取到User类的Class对象Class? userClass Class.forName(com.reflection.class_.User);//2、通过public的无参构造器创建实例Object o userClass.newInstance();System.out.println(o);//3、通过public的有参构造器创建对象实例/* 此constructor对象就是public User(String name) {//有参public构造器this.name name;}* *///先得到对应的构造器Constructor? constructor userClass.getConstructor(String.class);//在创建实例并传入实参Object o1 constructor.newInstance(猫饭);System.out.println(o1);//4、通过private的有参构造器创建对象实例Constructor? constructor1 userClass.getDeclaredConstructor(int.class, String.class);//暴破使用反射可以访问private构造器/方法/属性 反射面前一切都是纸老虎constructor1.setAccessible(true);Object o2 constructor1.newInstance(28, 猫饭美少女);System.out.println(o2);}
}class User {private int age 18;private String name 小A;public User() { //无参public构造器}public User(String name) {//有参public构造器this.name name;}public User(int age, String name) {//有参private构造器this.age age;this.name name;}Overridepublic String toString() {return User{ age age , name name \ };}
}通过反射访问类中的成员
使用到的方法
1、属性名获取Field对象Field f class对象.getDeclaredField(属性名)私有公有都可以拿到
2、暴破f.setAccessible(true); //f是Field
3、访问 f.set(o,值)//o表示对象 syso(f.get(o)); //o表示对象
4、注意如果是静态属性则set和get中的参数o可以写成null因为静态属性是跟类相关绑定的
package com.reflection.class_;import java.lang.reflect.Field;public class ReflecAccessProperty {public static void main(String[] args) throws Exception {//1、获取Class对象Class? studentClass Class.forName(com.reflection.class_.Student);//2、创建对象Object o studentClass.newInstance();System.out.println(o.getClass());//获取运行类型//3、使用反射得到age属性对象Field age studentClass.getField(age);age.set(o,18);//通过反射给属性赋值System.out.println(o);System.out.println(age.get(o));//通过反射获取属性的值//4、通过反射操作 name属性Field name studentClass.getDeclaredField(name);name.setAccessible(true);
// name.set(o,猫饭);//通过反射给属性赋值name.set(null,猫饭);//因为name是static属性所以o也可以写出nullSystem.out.println(o);System.out.println(name.get(o));//通过反射获取属性的值System.out.println(name.get(null));//获取属性值因为name是static属性所以o也可以写出null}
}class Student {public int age;private static String name;public Student() {}Overridepublic String toString() {return Student{ age age , name name \ };}
}通过反射访问类中的方法
使用到的方法
1、根据方法名和参数列表获取Method方法对象Method m class对象.getDeclaredMethod(方法名XX.class);//得到本类中所有的方法
2、获取对象Objec o class对象.newInstance();
3、暴破m.setAccessible(true);
4、访问Object returnValue m.invoke(o实参列表); //o就是对象
5、注意如果是静态方法则invoke的参数o可以写成null
EX
package com.reflection.class_;import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;public class ReflecAccessMethod {public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {//1、获取Class对象Class? aClass Class.forName(com.reflection.class_.Boss);//2、创建对象Object o aClass.newInstance();//3、调用public 的 hi方法//Method hi1 aClass.getMethod(hi, String.class);Method hi aClass.getDeclaredMethod(hi, String.class);hi.invoke(o,猫饭);//4、调用private static 方法Method say aClass.getDeclaredMethod(say, int.class, String.class, char.class);say.setAccessible(true);System.out.println(say.invoke(o,18,猫饭,女));//5、在反射中如果方法有返回值统一返回Object但是他运行类型和方法定义的返回类型一致Object o1 say.invoke(null,28, 美少女, 女);System.out.println(o1的运行类型o1.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){//普通public方法System.out.println(hi! s);}
}
