Java 反射机制是在运行状态中,对于任意一个类,都能够知道这个类中的所有属性和方法,对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为 Java 的反射机制。
1.Class也是类,因此也继承Object类
2.Class类对象不是new出来的,而是系统创建的
3.对于某个类的class类对象,在内存中只有一份,因为类只加载一次
4.每个类的实例都会记得自己是由哪个 Class 实例所生成
5.通过Class可以完整地得到一个类的完整结构,通过一系列API
6.Class对象是存放在堆的
7.类的字节码二进制数据,是放在方法区的,有的地方称为类的元数据(包括 方法代码变量名,方法名,访问权限等等)
Class的方法:
1.前提:已知一个类的全类名,且该类在类路径下,可通过Class类的静态方法forName0获取,可能抛出ClassNotFoundException,
实例: Class cls1 =Class.forName( "java.lang.Cat”);
应用场景:多用于配置文件,读取类全路径,加载类.
2.前提: 若已知具体的类,通过类的class 获取,该方式 最为安全可靠,程序性能最高
实例:Class cls2 = Cat.class;
应用场景: 多用于参数传递,比如通过反射得到对应构造器对象
3.前提: 已知某个类的实例,调用该实例的getClass0方法获取Class对象,
实例:Class clazz = 对象.getClass();
应用场景: 通过创建好的对象,获取Class对象
4.其他方式
ClassLoader cl = 对象.getClass().getClassLoader();
Class clazz4 = cl.loadClass(“类的全类名”);
5.基本数据(int, charboolean,float,double,byte,long,short) 按如下方式得到Class类对象
Class cls = 基本数据类型.class
6.基本数据类型对应的包装类,可以通过 .type 得到Class类对象
Class cls = 包装类.TYPE
//1. Class.forName
String classAllPath = "ref.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 integerClass = int.class;
Class characterClass = char.class;
Class booleanClass = boolean.class;
System.out.println(integerClass);//int
//6. 基本数据类型对应的包装类,可以通过 .TYPE 得到 Class 类对象
Class type1 = Integer.TYPE;
Class type2 = Character.TYPE; //其它包装类 BOOLEAN, DOUBLE, LONG,BYTE 等待
System.out.println(type1);
System.out.println(integerClass.hashCode());//?
System.out.println(type1.hashCode());//?
类加载过程图:
加载阶段:
JVM 在该阶段的主要目的是将字节码从不同的数据源(可能是class文件,也可能是jar 包,甚至网络)转化为二进制字节流加载到内存中,并生成一个代表该类的java.lang.Class 对象
连接阶段-验证:
目的是为了确保 Class 文件的字节流中包含的信息符合当前虚拟机的要求,并且不会危害虚拟机自身的安全。包括: 文件格式验证(是否以魔数 oxcafebabe开头)、元数据验证、字节码验证和符号引用验证。
连接阶段-准备:
JVM 会在该阶段对静态变量,分配内存并默认初始化 (对应数据类型的默认初始值,如 0、0L、null、false 等) 。这些变量所使用的内存都将在方法区中进行分配。
连接阶段-解析:
虚拟机将常量池内的符号引用替换为直接引用的过程。
Initialization (初始化):
1.到初始化阶段,才真正开始执行类中定义的 Java 程序代码,此阶段是执行
第一组: 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.getlnterfaces:以Class[]形式返回接口信息
12.getAnnotations:以Annotation[] 形式返回注解信息
第二组: java.lang.reflect.Field类
1.getModifiers: 以int形式返回修饰符
[说明: 默认修饰符 是0,public 是1 ,private 是 2protected 是 4 static 是 8 ,final 是 16] , 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.根据方法名和参数列表获取Method方法对象 : Method m =clazz.getDeclaredMethod(方法名,XX.class)://得到本类的所有方法
2.获取对象: Object o=clazz.newlnstance()
3.暴破 : m.setAccessible(true);
4.访问 :Object returnValue = m.invoke(o,实参列表)://o 就是对象
5.注意: 如果是静态方法,则invoke的参数o,可以写成null!
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflecAccessMethod {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
//1. 得到 Boss 类对应的 Class 对象
Class bossCls = Class.forName("ref.Boss");
//2. 创建对象
Object o = bossCls.newInstance();
//3. 调用 public 的 hi 方法
//Method hi = bossCls.getMethod("hi", String.class);//OK
//3.1 得到 hi 方法对象
Method hi = bossCls.getDeclaredMethod("hi", String.class);//OK
//3.2 调用
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
//在演示一个返回的案例
Method m1 = bossCls.getDeclaredMethod("m1");
Object reVal2 = m1.invoke(o);
System.out.println("reVal2 的运行类型=" + reVal2.getClass());//Monster
}
}
class Monster {}
class Boss {//类
public int age;
private static String name;
public Boss() {//构造器
}
public Monster m1() {
return new Monster();
}
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);
}
}
需求:
对于任意一个对象,该框架都可以把对象的字段名和对应的值,保存到文件中去。
实现步骤
1.定义一个方法,可以接收任意对象。
2.每收到个对象后,使用反射获取该对象的Class对象,然后获取全部的成员变量。
3.遍历成员变量,然后提取成员变量在该对象中的具体值。
4.把成员变量名、和其值,写出到文件中去即可。
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.lang.reflect.Field;
public class objectFrame {
public static void saveObject(Object obj) throws Exception {
PrintStream ps=new PrintStream(new FileOutputStream("D:\\text.txt",true));
Class c=obj.getClass();
String cName=c.getSimpleName();
ps.println("----------"+cName+"---------------");
Field[] fields=c.getDeclaredFields();
for(Field field:fields) {
String name=field.getName();
field.setAccessible(true);
String value=field.get(obj)+"";
ps.println(name+"="+value);
}
ps.close();
}
}
public class Test {
public static void main(String[] args) throws Exception {
Student s1=new Student("某人",15,'男');
Teacher t1=new Teacher("张老师",9999);
objectFrame.saveObject(s1);
objectFrame.saveObject(t1);
}
}