1,什么是反射(把java类中的各种成分映射成一个个的Java对象)
反射是java语言的一种机制,利用反射机制动态的实例化对象(构造函数)、读写属性、调用方法。
2,类类(所有类的实例)
如何得到类对象(一切反射相关的代码都从获得类对象开始)三种获取方式:
1 Class.forName(完整类名)(最常用)
2 类名.class
3 对象名.getClass() (代码展示!)
测试文件Student类:
package com.reflect;
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 sname) {
System.out.println(sname + "你好!我是" + this.sname);
}
@SuppressWarnings("unused")
private Integer add(Integer a, Integer b) {
return new Integer(a.intValue() + b.intValue());
}
}
package com.reflect;
/**
* 类类的获取对象的三种方式
*
*/
public class Demo01 {
public static void main(String[] args) throws Exception {
// Class.forName
Class<Student> stucls1 = (Class<Student>) Class.forName("com.reflect.Student");
// 通用查询 类名.class
Class stucls2 = Student.class;
// 通用增删改 对象名.getClass()
Class stuclz3 = new Student().getClass();
//获取全限定名
System.out.println(stucls2.getName());
//获取包名
System.out.println(stucls2.getSimpleName());
//获取类名
System.out.println(stucls2.getPackage());
}
}
测试结果:
3,反射实例化
class.newInstance() 反射实例化对象
class.getConstrutor()与class.getDeclaredConstrutor() 获取单个构造方法
区别:class.getDeclaredConstrutor()包括私有、受保护、默认、公有的方法
如果是有参构造,需要在括号里写上参数类型
调用私有的方法,需打开访问权限:setAccessible(true)
(代码展示!)
package com.reflect;
import java.lang.reflect.Constructor;
/**
* 反射实例化
*
*/
public class Demo02 {
public static void main(String[] args) throws Exception {
// 获取对象
Class<Student> stucls1 = (Class<Student>) Class.forName("com.reflect.Student");
Student stu1 = stucls1.newInstance();// 生成一个实例
// 反射调用有参构造
// getConstructor与getDeclaredConstructor的区别
// getDeclaredConstructor可以获得私有的
Constructor<Student> c1 = stucls1.getConstructor(String.class);
Student s1 = c1.newInstance("一号");
Constructor<Student> c2 = stucls1.getConstructor(String.class,String.class);
Student s2 = c2.newInstance("001","小明");
s2.hello(s2.getSname());
Constructor<Student> c3 = stucls1.getDeclaredConstructor(Integer.class);
c3.setAccessible(true);// 打开访问权限
Student s3 = c3.newInstance(3);
}
}
测试结果:
4,反射动态方法调用
class.getMethod() 获取单个公有方法
class.getDeclaredMethod() 获取单个方法 (包括私有、受保护、默认、公有)
调用方法:invote(对象名,有参传值)
参数1:类实例,在这里指的是Student类实例
参数2:当前被调用的方法,传递的参数值
(代码展示!)
package com.reflect;
import java.lang.reflect.Method;
/**
* 反射动态方法调用
*
*/
public class Demo03 {
public static void main(String[] args) throws Exception {
// 获取对象
Class<Student> stucls1 = (Class<Student>) Class.forName("com.reflect.Student");
// 生成实例
Student s1 = stucls1.newInstance();
// 获取方法
Method m1 = stucls1.getDeclaredMethod("hello");
//invoke 参数1:类实例,在这里指的是Student类实例
// 参数2:当前被调用的方法,传递的参数值
System.out.println(m1.invoke(s1));
Method m2 = stucls1.getDeclaredMethod("hello",String.class);
System.out.println(m2.invoke(s1, "小明"));
Method m3 = stucls1.getDeclaredMethod("add",Integer.class,Integer.class);
m3.setAccessible(true);
System.out.println(m3.invoke(s1,10, 20));// 加法方法
}
}
测试结果:
5,反射读写属性
getDeclaredField(获取单个对象)
getDeclaredFields(获取所有对象)
(代码展示!)
package com.reflect;
import java.lang.reflect.Field;
/**
* 反射读写属性
*
*/
public class Demo04 {
public static void main(String[] args) throws Exception {
// 获取对象
Class<Student> stucls1 = (Class<Student>) Class.forName("com.reflect.Student");
// 生成实例
Student s1 = stucls1.newInstance();
// 获取属性对象
Field f1 = stucls1.getDeclaredField("sname");
// 设置权限
f1.setAccessible(true);
// 反射写属性
f1.set(s1, "小明");
System.out.println(s1.getSname());
// 反射读属性
System.out.println(f1.get(s1));
// 比较oop与反射读取属性值的方式
Student stu = new Student("001", "大明");
stu.age=19;
System.out.println("+++OOP获取+++");
// oop获取属性值的方式
System.out.println(stu.getSid());
System.out.println(stu.getSname());
System.out.println(stu.age);
System.out.println("+++反射获取+++");
// 反射获取该对象所有属性值
Field[] fields = stucls1.getDeclaredFields();
for (Field fie : fields) {
fie.setAccessible(true);
System.out.println(fie.getName()+":"+fie.get(stu));
}
}
}
测试结果:
OK!到这已经结束了,希望能帮到你!!!