1. 什么是反射
反射，java语言中的一种机制，通过这种机制可以动态的实例化对象、读写属性、调用方法
2. 类类
所有狗 狗类 Dog 狗对象 旺财
所有猫 猫类 Cat 猫对象 肥波
所有类 类类 java.lang.Class 类对象 特定类
狗类的实例是旺财，猫类的实例是肥波，类类的实例就是类。
狗类是类类的一个实例，猫类也是类类的一个实例，学生类也是类类的一个实例.........
狗类是描述所有的狗，猫类是描述所有的猫，类类就是描述所有的类
3. 一切反射相关的代码都从获得类对象开始
类对象：类对象就是类类的一个类的实例
类对象也称为类的实例
3.1 Class.forName(完整类名)
3.2 类名.class
3.3 对象.getClass()
注1：ClassNotFoundException(类名错|少jar包)
注2：同一类的、类对象只会创建一个
这是一个Student的测试类：
package com.lq.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 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.lq.reflect;
/**
*
* @ClassName: Demo1
* @Description: 获取类对象
* @author LQ
* @date 2019年2月22日 下午5:36:23
*
*/
public class Demo1 {
public static void main(String[] args)
throws ClassNotFoundException, InstantiationException, IllegalAccessException {
// 1. Class.forname
// 通过全限定名进行获取
// clz 就是类对象（类类的类对象）
// Class<?> clz = Class.forName("com.lq.reflect.Student");
// 2. 类名 . Class 通用查询方法
// Class clz=Student.class;
// 获取的是student类对象
// System.out.println(clz.newInstance());
// 3.通过具体的类实例拿到类类的类实例（对象 . getClass） 通用的增删改方法
// Student stu=new Student();
// Class clz=stu.getClass();
// System.out.println(clz.newInstance());
// 反射怎么实例化对象 clz.newInstance(); 就是实例化对象
//通过反射去创建一个学生对象的实例
Class clz = Student.class;
Student stu = (Student) clz.newInstance();
}
}4. 反射三大作用(java.lang.reflect.*)
4.1 实例化对象
c.newInstance()
Constructor.getConstructor/Constructor.getDeclaredConstructor
注：一定要提供无参构造器
4.2 动态调用方法
Method m;
m.invoke
4.3 读写属性
Field set/get
实例化对象：
package com.lq.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
*
* @ClassName: Demo2
* @Description: 实例化对象
* @author LQ
* @date 2019年2月22日 下午8:25:45
*
*/
public class Demo2 {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException,
SecurityException, IllegalArgumentException, InvocationTargetException {
// 一切反射相关的代码都从获得类对象开始
Class clz = Student.class;
// 所有的类默认提供了一个无参构造器（以后创建类，提供了有参构造器后要提供无参构造器）
// clz.newInstance();
// -->
// Constructor c= clz.getConstructor();
// Object newInstance = c.newInstance();
// 调用带一个参数的构造方法创建了一个学生对象
// Constructor = Student (String.class)传参数
// Constructor c= clz.getConstructor(String.class);
// c.newInstance("哈哈");
// 调用带二个参数的构造方法创建了一个学生对象
// Constructor c= clz.getConstructor(String.class,String.class);
// c.newInstance("哈哈","SDSDS");
// getDeclaredConstructor与Constructor的区别
// Constructor：只能拿到OOP思想能实例化的构造器
// getDeclaredConstructor：只要是个构造器都能拿到
Constructor c = clz.getDeclaredConstructor(Integer.class);
// 访问私有构造器时，要打开它的权限
c.setAccessible(true);
c.newInstance(45);
}
}动态调用方法：
package com.lq.reflect;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
*
* @ClassName: Demo3
* @Description: 动态调用方法
* @author LQ
* @date 2019年2月22日 下午8:53:08
*
*/
public class Demo3 {
public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException, InstantiationException {
// 一切反射相关的代码都从获得类对象开始
Class clz = Student.class;
// 第一种，调无参的
//// 第一个参数：方法名
//// 第二个参数：参数的类型
// Method method = clz.getMethod("hello");
//// 第一个参数：具体的类的类实例
//// 第二个参数：具体的参数值
// method.invoke(clz.newInstance());
// 第二种，调有参的
// Method method = clz.getMethod("hello", String.class);
// method.invoke(clz.newInstance(), "有点意思");
// method.invoke( )返回值问题
// 如果说，被调用的方法，本身是void类型，那么method.invoke( )返回值就是null
// 如果说，被调用的方法，本身是非void类型，那么method.invoke( )返回值就是被调用的方法的返回值
Method method = clz.getDeclaredMethod("add",Integer.class,Integer.class);
method.setAccessible(true);
Object invoke = method.invoke(clz.newInstance(),45,56);
System.out.println(invoke);
}
}读写属性：
package com.lq.reflect;
import java.lang.reflect.Field;
/**
*
* @ClassName: Demo4
* @Description: 读写属性
* @author LQ
* @date 2019年2月22日 下午9:14:27
*
*/
public class Demo4 {
public static void main(String[] args) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
// 一切反射相关的代码都从获得类对象开始
Class clz = Student.class;
Student stu =new Student();
// stu.age=22;
// Field field = clz.getField("age");
//// 第一个参数：具体的类的类实例
//// 第二个参数：就是给field对象需要赋的值
//// field.set(stu, 18);
// System.out.println("反射取值："+field.get(stu));
// System.out.println("OOP取值："+stu.age);
// 输出：
// 加载进jvm中！
// 调用无参构造方法创建了一个学生对象
// 反射取值：22
// OOP取值：22
// stu.setSname("有点意思");
// Field field = clz.getDeclaredField("sname");
// field.setAccessible(true);
// field.set(stu, "确实有点意思");
// System.out.println("反射赋值："+field.get(stu));
// System.out.println("OOP赋值："+stu.getSname());
// 输出：
// 加载进jvm中！
// 调用无参构造方法创建了一个学生对象
// 反射赋值：确实有点意思
// OOP赋值：确实有点意思
stu.age=18;
stu.setSid("s001");
stu.setSname("张三");
// 反射取值 VS oop取值
System.out.println(stu.age);
System.out.println(stu.getSid());
System.out.println(stu.getSname());
// Dao层插入操作
Field[] declaredFields = clz.getDeclaredFields();
for (Field field : declaredFields) {
field.setAccessible(true);
System.out.println(field.getName()+","+field.get(stu));
}
// 输出：
// 加载进jvm中！
// 调用无参构造方法创建了一个学生对象
// 18
// s001
// 张三
// sid,s001
// sname,张三
// age,18
}
}