目录
一、反射
1、什么是反射?
java语言中的一种机制,通过这种机制可以动态的读写属性,实例化对象,调用方法
2、为什么学反射?
反射是框架的核心,使用灵活。能够降低模块的耦合度,增加自身的适应能力
二、类类
获取类类的三种方法
①类.class
package com.maomao.reflect;
public class Demo1 {
public static void main(String[] args) throws Exception {
//类.class
Class clz1 = Student.class;
System.out.println(clz1);
}
}
②类实例.getClass()
package com.maomao.reflect;
public class Demo1 {
public static void main(String[] args) throws Exception {
//类实例.getClass()
Student stu = new Student();
Class clz2 = stu.getClass();
}
}
③Class.forName("类的全路径名")
package com.maomao.reflect;
public class Demo1 {
public static void main(String[] args) throws Exception {
//Class.forName("类的全路径名")
Class clz3 = Class.forName("com.ruojuan.aa.Student");
}
}
三、反射实例化
返回实例化
newInstance():获取到该类的一个对象
getConstructor():调用方法,括号里面放类型
getDeclaredConstructor():调用方法,括号里面放类型
注意:getDeclaredConstructor()要有打开权限的代码否则会说非法访问异常
打开权限的方法:
setAccessible(true);
package com.maomao.reflect;
import java.lang.reflect.Constructor;
/**
* 返实例化
* 1,无参数 共有的构造方法
* 2,有参数 共有的构造方法
* 3,有多个参数 共有的构造方法
* 4,私有的构造方法
* @author Administrator
*/
public class Demo2 {
public static void main(String[] args) throws Exception {
Student stu1 = new Student();
Student stu2 = new Student("s001");
Student stu3 = new Student("s002","aa");
//获取类类
Class<? extends Student> clz1 = stu1.getClass();
//默认就是调用无参 公有的 构造函数
//1.无参数 共有的构造方法
Student stu4 = clz1.newInstance();
//2.有参数 共有的构造方法
//拿到构造对象 三个.代表可以传1个2个...n个参数
Constructor<? extends Student> c1 = clz1.getConstructor(String.class);
Student stu5 = c1.newInstance("s001");
//3,有多个参数 共有的构造方法 拿到有两个参数的构造器对象
Constructor<? extends Student> c2 = clz1.getConstructor(String.class,String.class);
Student stu6 = c2.newInstance("s001","bb");
//4,私有的构造方法
//getConstructor只能够获取共有的构造方法,要获取私有的构造器getDeclaredConstructor
Constructor<? extends Student> c3 = clz1.getDeclaredConstructor(Integer.class);
//打开访问权限
c3.setAccessible(true);
Student stu7 = c3.newInstance(14);
}
}
四、反射动态方法调用
getMethod();
getDeclaredMethod();
package com.maomao.reflect;
import java.lang.reflect.Method;
/**
* 反射动态调用方法
* 1,调用无参的共有方法
* 2,调用1个有参的 共有方法
* 3,调用2个有参的 私有方法
* @author Administrator
*/
public class Demo3 {
public static void main(String[] args) throws Exception {
//1.先拿到类类
Class<Student> clz = Student.class;
//调用1个有参的 共用方法
Method m2 = clz.getMethod("hello",String.class);
Object invoke2 = m2.invoke(clz.newInstance(),"cc");
System.out.println(invoke2);
//name:方法名 parameterTypes:方法对应的参数
Method m1 = clz.getMethod("hello");
//1.调用对应的方法
//第一个参数:那个类实例 第二个参数
//m1.invoke方法调用的返回值就是方法对象本身的返回值hello方法的返回值
Object invoke = m1.invoke(clz.newInstance());
System.out.println(invoke);
//调用2个有参的 私有方法
Method m3 = clz.getDeclaredMethod("add", Integer.class,Integer.class);
m3.setAccessible(true);
Object invoke3 = m3.invoke(clz.newInstance(),5,5);
System.out.println(invoke3);
}
}
五、反射读写属性
package com.maomao.reflect;
import java.lang.reflect.Field;
/**
* 反射读写属性
* @author Administrator
*/
public class Demo4 {
public static void main(String[] args) throws Exception {
Student stu = new Student("s003","ee");
stu.age = 20;
//需求,要拿到这个学生所有的属性及属性值
System.out.println("age:"+stu.age);
System.out.println("sname:"+stu.getSname());
System.out.println("sid:"+stu.getSid());
/*
* 上述代码存在的问题
* 1.你事先得知到这个类有哪些属性
* 2.假设student有30个属性呢?
*/
//一切反射从类类开始
Class<? extends Student> clz = stu.getClass();
//当前类的所有属性对象
Field[] fields = clz.getDeclaredFields();
System.out.println(fields.length);
//for循环中的f代表一个属性名称
for (Field f : fields) {
//打开访问权限
f.setAccessible(true);
//通过属性对象拿到属性名称
System.out.println(f.getName());
//拿到当前的属性对象的属性值
System.out.println(f.get(stu));
}
}
}
六、getModifiers()
modifier: 修饰符。
getModifiers()方法返回int类型值表示该字段的修饰符,其中该修饰符是java.lang.reflect.Modifier的静态属性
修饰符 | 对应的int类型值 |
---|---|
public | 1 |
private | 2 |
protected | 4 |
static | 8 |
final | 16 |
synchronized | 32 |
volatile | 64 |
transient | 128 |
native | 256 |
interface | 512 |
abstract | 1024 |
strict | 2048 |