1. 引出反射链接:【韩顺平讲Java】Java反射专题
需求:
(1)根据配置文件re.properties指定信息,创建Cat对象并调用方法hi
classfullpath=com.qzy.Cat method=hi
思考:使用现有技术能做到吗?
(2)这样的需求在学习框架时特别多,即通过外部文件配置,在不修改源码情况下,来控制程序,也符合设计模式的OCP原则(开闭原则:不修改源码,扩容功能)
解答:
(1)传统方法
new 对象 => 调用方法
Cat cat = new Cat(); cat.hi();
(2)使用文件流读取文件的方法
//1. 使用Properties类,可以读写配置文件
Properties properties = new Properties();
properties.load(new FileInputStream("src\re.properties"));
String classfullpathName = properties.get("classfullpath").toString(); //"com.qzy.Cat
String methodName = properties.get("method").toString(); //"hi"
System.out.println("classfullpath=" + classfullpathName);
System.out.println("method=" + methodName);
//2. 创建对象,类似Cat cat1 = new com.qzy.Cat();
Cat cat1 = new classfullpathName() //报错,Cannot resolve symbol 'classfullpathName'
classfullpathName是一个字符串而非类,无法创建对象。
所以该方法不可行。
(3)使用反射机制
//(1)加载类,返回Class类型的对象cls
Class cls = Class.forName(classfullpathName);
//(2)通过cls得到你加载的类 com.qzy.Cat的对象实例
Object o = cls.newInstance();
System.out.println("o的运行类型=" + o.getClass()); //o的运行类型=class com.qzy.Cat
//(3)通过cls得到你加载的类com.qzy.Cat的methodName “hi” 的方法对象
// 即:在反射中,可以吧方法视为对象(万物皆对象)
Method method = cls.getMethod(methodName);
method.invoke(o); // 传统方法: 对象.方法(), 反射机制: 方法.invoke(对象)
2. 反射原理
2.1 原理图
2.2 反射相关类
- java.lang.Class:: 代表一个类,Class对象表示某个类加载后再堆中的对象
- java.lang.reflect.Method: 代表类的方法,Method对象表示某个类的方法
- java.lang.reflect.Field: 代表类的成员变量,Field对象表示某个类的成员变量
- java.lang.reflect.Constructor: 代表类的构造方法,Constructor对象表示构造器
这些类在java.lang.reflection
public class Reflection01 {
public static void main(String[] args) throws Exception {
//1. 使用Properties类,可以读写配置文件
Properties properties = new Properties();
properties.load(new FileInputStream("src\re.properties"));
String classfullpathName = properties.get("classfullpath").toString(); //"com.qzy.Cat
String methodName = properties.get("method").toString(); //"hi"
System.out.println("classfullpath=" + classfullpathName);
System.out.println("method=" + methodName);
//2. 使用反射机制解决
//(1)加载类,返回Class类型的对象cls
Class cls = Class.forName(classfullpathName);
//(2)通过cls得到你加载的类 com.qzy.Cat的对象实例
Object o = cls.newInstance();
System.out.println("o的运行类型=" + o.getClass()); //o的运行类型=class com.qzy.Cat
//(3)通过cls得到你加载的类com.qzy.Cat的methodName “hi” 的方法对象
// 即:在反射中,可以吧方法视为对象(万物皆对象)
Method method = cls.getMethod(methodName);
method.invoke(o); // 传统方法: 对象.方法(), 反射机制: 方法.invoke(对象)
//java.lang.reflect.Field: 代表类的成员变量,Field对象表示某个类的成员变量
//得到name字段
//getField不能得到私有的属性private
Field ageField = cls.getField("age");
System.out.println(ageField.get(o)); //传统写法:对象.成员变量,反射:成员变量对象.get(对象实例) //输出10
//java.lang.reflect.Constructor: 代表类的构造方法,Constructor对象表示构造器
Constructor constructor = cls.getConstructor(); //()可以指定构造器参数类型,返回午餐构造器
System.out.println(constructor); // public com.qzy.Cat()
Constructor constructor1 = cls.getConstructor(String.class); //这里传入的String.class就是String类的Class对象
System.out.println(constructor1); // public com.qzy.Cat(java.lang.String)
}
}
3. 反射调用优化
反射优点:可以动态的创建和使用对象(也是框架底层核心),使用灵活,没有反射机制,框架技术就失去底层支撑。
反射缺点:使用反射基本是解释执行,对执行速度有影响。 —>如何优化?
优化方法:
- Method和Field、Constructor对象都有setAccessible()方法
- setAccessible作用是启动和禁用访问安全检查的开关
- 参数值为true表示反射的对象在使用时取消访问检查,提高反射效率。参数值为false表示反射的对象在使用时开启访问检查
public class Reflection02 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
m1();
m2();
m3();
}
public static void m1() {
Cat cat = new Cat();
long start = System.currentTimeMillis();
for (int i = 0; i < 100000000; i++) {
cat.test();
}
long end = System.currentTimeMillis();
System.out.println("传统方法消耗时间:"+ (end-start));
}
public static void m2() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class cls = Class.forName("com.qzy.Cat");
Object o = cls.newInstance();
Method method = cls.getMethod("test");
long start = System.currentTimeMillis();
for (int i = 0; i < 100000000; i++) {
method.invoke(o);
}
long end = System.currentTimeMillis();
System.out.println("反射调用(未优化)消耗时间:"+ (end-start));
}
public static void m3() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class cls = Class.forName("com.qzy.Cat");
Object o = cls.newInstance();
Method method = cls.getMethod("test");
method.setAccessible(true);
long start = System.currentTimeMillis();
for (int i = 0; i < 100000000; i++) {
method.invoke(o);
}
long end = System.currentTimeMillis();
System.out.println("反射调用(优化)消耗时间:"+ (end-start));
}
}
运行结果:
传统方法消耗时间:5 反射调用(未优化)消耗时间:185 反射调用(优化)消耗时间:1294. Class类分析
(1)Class也是类,因此也继承Object类
(2)Class类对象不是new出来的,而是系统创建的
(3)对于某个类的Class类对象,在内存中只有一份,因为类只加载一次
(4)每个类的实例都会记得自己是由哪个Class 实例所生成
(5)通过Class对象可以完整地得到一个类的完整结构,通过一系列API
(6)Class对象是存放在堆的
(7)类的字节码二进制数据,是放在方法区的,有的地方称为类的元数据(包括方法代码,变量名,方法名,访问权限等等(参考:java虚拟机Class对象是放在方法区还是堆中 ?)
5. Class常用方法public class Class02 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
String classAllPath = "com.qzy.Car";
//1. 获取到Car类对应的Class对象
//> 表示不确定的Java类型
Class> cls = Class.forName(classAllPath);
//2. 输出cls
System.out.println(cls); //显示cls对象,是哪个类的Class对象 class com.qzy.Car
System.out.println(cls.getClass()); //输出cls运行类型 class java.lang.Class
//3. 得到包名
System.out.println(cls.getPackage().getName()); //com.qzy
//4. 得到全类名
System.out.println(cls.getName()); //com.qzy.Car
//5. 通过cls创建对象实例
//Object o = cls.newInstance();
Car car = (Car)cls.newInstance();
System.out.println(car); //Car{brand='宝马', price=100000, color='白色'}
//6. 通过反射获取属性 brand
Field brand = cls.getField("brand");
System.out.println(brand.get(car)); //宝马
//7. 通过反射给属性赋值
brand.set(car, "奔驰");
System.out.println(brand.get(car)); //奔驰
//8. 得到所有的属性
Field[] fields = cls.getFields();
for(Field f : fields) {
System.out.println(f.getName());
}
//brand
//price
//color
}
}
6. 获取Class对象的方法(6种)
-
前提:已知一个类的全类名,且该类在类路径下,可通过Class类的静态方法forName()获取,可能抛出ClassNotFoundException,实例:Class cls1 =Class.forName( "java.lang.Cat”);
应用场景:多用于配置文件,读取类全路径,加载类。 -
前提:若已知具体的类,通过类的class 获取,该方式最为安全可靠,程序性能最高实例:Class cls2 = Cat.class;
应用场景:多用于参数传递,比如通过反射得到对应构造器对象。 -
前提:已知某个类的实例,调用该实例的getClass()方法获取Class对象,实例:Class clazz =对象.getClass(0);
应用场景:通过创建好的对象,获取Class对象。 -
其他方式
ClassLoader cl =对象.getClass().getClassLoader);Class clazz4 = cl.loadClass(“类的全类名”);
-
基本数据(int, char,boolean,float,double,byte,long,short)按如下方式得到Class类对象
Class cls =基本数据类型.class
-
基本数据类型对应的包装类,可以通过.type得到Class类对象
Class cls =包装类.TYPE
public class Class03 {
public static void main(String[] args) throws ClassNotFoundException {
String classAllPath = "com.qzy.Car";
//1. Class.forName
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 extends Car> cls3 = car.getClass();
System.out.println(cls3);
//4. 通过类加载器【4种】来获取到类的Class对象
//(1)先得到类加载器car
ClassLoader classLoader = car.getClass().getClassLoader();
//(2)通过类加载器得到Class对象
classLoader.loadClass(classAllPath);
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. 基本数据(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); //int
System.out.println(integerClass.hashCode()); //1163157884
System.out.println(type1.hashCode()); //1163157884
}
}
7. 哪些类型可以有Class对象
- class:外部类,成员(成员内部类,静态内部类),局部内部类,匿名内部类
- interface:接口
- []:数组
- enum:枚举
- annotation:注解@interface
- primitive type:基本数据类型
- void
public class Class04 {
public static void main(String[] args) {
Class c1 = Object.class; //类 class java.lang.Object
Class c2 = Comparable.class; //接口 interface java.lang.Comparable
Class c3 = String[].class; //一位数组 class [Ljava.lang.String;
Class c4 = int[][].class; //二维数组 class [[I
Class c5 = Override.class; //注解 interface java.lang.Override
Class c6 = ElementType.class; //枚举 class java.lang.annotation.ElementType
Class c7 = Integer.class; //基本数据类型 class java.lang.Integer
Class c8 = void.class; //void void
Class c9 = Class.class; //Class class java.lang.Class
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
System.out.println(c5);
System.out.println(c6);
System.out.println(c7);
System.out.println(c8);
System.out.println(c9);
}
}
8. 类加载
8.1 静态加载和动态加载
反射机制是java实现动态语言的关键,也就是通过反射实现类动态加载。
静态加载:编译时加载相关的类,如果没有则报错,依赖性太强
动态加载:运行时加载需要的类,如果运行时不用该类,即使不存在该类,则不报错,降低了依赖性
类加载时机:
8.2 类加载流程图 9. 获取类结构信息 9.1 java.lang.Class类当创建对象时(new) //静态加载
当子类被加载时,父类也加载 //静态加载
调用类中的静态成员时 //静态加载
通过反射 //动态加载
9.2 java.lang.reflect.Field类
- getName:获取全类名
- getSimpleName:获取简单类名
- getFields:获取所有public修饰的属性,包含本类以及父类的
- getDeclaredFields:获取本类中所有属性
- getMethods:获取所有public修饰的方法,包含本类以及父类的
- getDeclaredMethod:获取本类中所有方法
- getConstructors:获取本类所有public修饰的构造器
- getDeclaredConstructors:获取本类中所有构造器
- getPackage:以Package形式返回包信息
- getSuperClass:以Class形式返回父类信息
- getInterfaces:以Class[]形式返回接口信息
- getAnnotations:以Annotation[]形式返回注解信息
9.3 java.lang.reflect.Method类
getModifiers: 以int形式返回修饰符
[说明:默认修饰符是0,public 是1,private是2,protected是4static是8,final是16]public(1) + static (8) = 9
getType:以Class形式返回类型
getName:返回属性名
9.4 java.lang.reflect.Constructor类
- getModifiers:以int形式返回修饰符
[ 说明:默认修饰符是0,public是1,private是2,protected是4,static是8,final是16 ]
getReturnType:以Class形式获取返回类型
getName:返回方法名
getParameterTypes:以Class[]返回参数类型数组
10. 通过反射创建对象
- getModifiers:以int形式返回修饰符
- getName:返回构造器名(全类名)
- getParameterTypes:以Class[]返回参数类型数组
调用类中的public修饰的无参构造器
调用类中的指定构造器
Class相关方法
newInstance: 调用类中的无参构造器,获取对应类的对象
getConstructor(Class…clazz):根据参数列表,获取对应的public构造器对象
getDecalaredConstructor(Class…clazz):根据参数列表,获取对应的所有构造器对象
Constructor类相关方法
setAccessible:暴破
newInstance(Object…obj):调用构造器
public class ReflecCreateInstance {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
//1. 先获取到User类的Class对象
Class> cls = Class.forName("com.qzy.reflection.reflectClass.User");
//2. 通过public的无参构造器创建实例
Object o = cls.newInstance();
System.out.println(o); //User [age=20, name=清蒸鱼]
//3. 通过public的有参构造器创建实例
//3.1 先得到对用构造器
Constructor> constructor = cls.getConstructor(String.class);
//3.2 创建实例,并传入实参
Object qzy = constructor.newInstance("qzy");
System.out.println(qzy); //User [age=20, name=qzy]
//4. 通过非public的有参构造器创建实例
Constructor> declaredConstructor = cls.getDeclaredConstructor(int.class, String.class);
//暴破,使用反射可以访问private构造器
declaredConstructor.setAccessible(true);
Object gl = declaredConstructor.newInstance(99, "小海");
System.out.println(gl); //User [age=99, name=小海]
}
}
class User {
private int age=20;
private String name="清蒸鱼";
public User() {} //public无参构造器
public User(String name) {
this.name = name;
} //public有参构造器
private User(int age, String name) { //private有参构造器
this.age = age;
this.name = name;
}
public String toString() {
return "User [age=" + age + ", name=" + name + "]";
}
}
11. 通过反射访问类中的成员
11.1 访问属性
根据属性名获取Field对象
Field f = clazz对象.getDeclaredField(属性名)
暴破: f.setAccessible(true) //f是Field
访问
f.set(o, 值);//o表示对象
syso(f.get(o))
如果是静态属性,则set和get中的参数o,可以写成null
public class Class05 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, InstantiationException {
Class> cls = Class.forName("com.qzy.reflection.reflectClass.Student");
Object o = cls.newInstance();
//1. 通过反射得到age属性对象
Field age = cls.getField("age");
//通过反射操作age属性
age.set(o, 99);
System.out.println(o); //Student [age=99, name=null]
System.out.println(age.get(o)); //99
//2. 通过反射得到name属性
Field name = cls.getDeclaredField("name");
name.setAccessible(true);
name.set(o, "小海");
//因为name是static,所以o也可以设置为null
//name.set(null, "小海");
System.out.println(name.get(o)); //小海
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 + "]";
}
}
11.2 访问方法
- 根据方法名和参数列表获取Method方法对象:Method m = clazz.getDeclaredMethod(方法名,XX.class);
- 获取对象:Object o=clazz.newlnstance();
- 暴破:m.setAccessible(true);
- 访问:Object returnValue = m.invoke(o,实参列表);
- 注意:如果是静态方法,则invoke的参数o,可以写成null!
public class Class06 {
public static void main(String[] args) throws Exception {
Class cls = Class.forName("com.qzy.reflection.reflectClass.Boss");
Object o = cls.newInstance();
//1. 通过反射获取hi方法
Method hi = cls.getMethod("hi", String.class);
hi.invoke(o, "小海"); //hi 小海
//2. 调用private static 方法
Method say = cls.getDeclaredMethod("say", int.class, String.class, char.class);
say.setAccessible(true);
System.out.println(say.invoke(o, 99, "小海", '男')); //99 小海 男
//反射中,如果方法有返回值,统一返回Object,但是他运行类型和方法定义的返回类型一致
Object reVal = say.invoke(null, 100, "小海", '男');
System.out.println(reVal); //100 小海 男
System.out.println("reVal的运行类型=" + reVal.getClass()); //reVal的运行类型=class java.lang.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);
}
}



