目录
一、什么是反射
二、类类
三、反射实例化
四、反射动态方法调用
五、反射读写属性
一、什么是反射
反射是java语言中的一种机制,通过这种机制可以动态的实例化对象、读写属性、调用方法
二、类类
类类的获取方式
二、类类
类类的获取方式
1、Class.forName(完整类名)
2、类名.class
3、对象.getClass
案例:学生类
package com.zwc.fs;
public class Student {
private String sid;
private String sname;
public Integer age;
static{
System.out.println("加载进jvm中");
}
public Student() {
super();
System.out.println("调用无参构造方法创建了一个学生对象?");
}
public Student(String sid) {
super();
this.sid = sid;
System.out.println("调用带一个参数的构造方法创建了一个学生对象");
}
public Student(String sid, String sname) {
super();
this.sid = sid;
this.sname = sname;
System.out.println("调用带二个参数的构造方法创建了一个学生对象");
}
@SuppressWarnings("unused")
private Student(Integer age) {
System.out.println("调用Student类私有的构造方法创建一个学生对象");
this.age = age;
}
public String getSid() {
return sid;
}
public void setSid(String sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public void hello() {
System.out.println("你好!我是" + this.sname);
}
public void hello(String name) {
System.out.println(name + "你好!我是" + this.sname);
}
@SuppressWarnings("unused")
private Integer add(Integer a, Integer b) {
return new Integer(a.intValue() + b.intValue());
}
}
package com.zwc.fs;
public class Demo1 {
public static void main(String[] args) throws Exception {
// 类.class
Class clz1 = Student.class;
// 2、类实例.getclass
Student stu = new Student();
Class clz2 = stu.getClass();
// 3、Class.forName("类的全路径名")
Class clz3 = Class.forName("com.zwc.fs.Student");
}
}
运行结果
三、反射实例化
我们通过学生类拿到以下
1、无参数 公有的构造方法
2、有参数 公有的构造方法
3、有多个参数公有的构造方法
4、私有的构造方法
package com.zwc.fs;
import java.lang.reflect.Constructor;
public class Demo2 {
public static void main(String[] args) throws Exception {
Student stu1 = new Student();
Student stu2 = new Student("s001");
Student stu3 = new Student("s001", "张三");
// 以下均为反射的方式实例化对象
//获取类类
Class extends Student> clz1 = stu1.getClass();
// 默认调用无参的公有的构造函数
// 1、无参数 公有的构造方法
Student stu4 = clz1.newInstance();
// 2、有参数公有的构造方法
// 拿到构造器对象 ...代表可以传1个2个....n个参数-->拿到一个参数为String的构造对象
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","李四");
// 4、私有的构造方法
// getConstructor只能够获取公有的构造方法
Constructor extends Student> c3 = clz1.getDeclaredConstructor(Integer.class);
// 打开访问权限
c3.setAccessible(true);
Student stu7 = c3.newInstance(12);
}
}
注意:在拿私有的构造方法时,我们还要打开访问权限,不然会报java.lang.IllegalAccessException非法访问
下面是拿私有方法没有打开访问权限的运行结果
下面是打开权限的结果
四、反射动态方法调用
1、无参数 公有的构造方法
2、有参数 公有的构造方法
3、私有的构造方法
首先:1、先拿到类类
2、拿到方法对象
3、调用对应的方法
代码如下:
package com.zwc.fs;
import java.lang.reflect.Method;
public class Demo3 {
public static void main(String[] args) throws Exception{
// 1、拿到类类
Class clz = Student.class;
// name:方法名 parameterTypes:方法对应的参数
// 2、拿到方法对象
Method m1 = clz.getMethod("hello");
// 3、调用对应的方法
// 第一个参数obj指的是类实例 第二个参数,指的是方法调用时的实参
// m1.invoke方法调用的返回值就是方法对象本身的返回值hello方法的返回值
// 1、调用无参的公有方法
Object invoke = m1.invoke(clz.newInstance());
System.out.println(invoke);
// 2、调用1个有参的公有方法
Method m2 = clz.getMethod("hello", String.class);
Object invoke2 = m2.invoke(clz.newInstance(), "张三");
System.out.println(invoke2);
// 3、调用私有的方法
Method m3 = clz.getDeclaredMethod("add", Integer.class,Integer.class);
// 访问权限
m3.setAccessible(true);
Object invoke3 = m3.invoke(clz.newInstance(), 5,5);
System.out.println(invoke3);
}
}
运行结果
五、反射读写属性
在我们没有学习反射,是用以下代码来拿
public static void main(String[] args) throws Exception {
Student stu = new Student("s003","张三");
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个属性等我们需要写三十行代码,代码量太大
通过反射我们可以很简便的拿出学生类的所有属性和属性值
代码如下:
package com.zwc.fs;
import java.lang.reflect.Field;
public class Demo4 {
public static void main(String[] args) throws Exception {
Student stu = new Student("s003","张三");
stu.age = 20;
//
// 一切反射从类类开始
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));
System.out.println("拿修饰符:"+Modifier.toString(f.getModifiers()));
}
}
}
运行结果:



