反射

1.1什么是反射

反射java语言中的一种机制，通过这种机制可以动态的实例化对象、读写属性、调用方法

1.2反射获取类对象（三种方式）

*1.Class.forName(“类的全路径名”); jdbc,自定义mvc框架要用
2.类名.class 做通用的查询
3.类(Class类类的类对象)实例.getClass() 做通用的增删改
*
首先一个Student类

package com.chenkang.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.chenkang.reflect;
public class Demo1 {
	public static void main(String[] args) throws Exception {
		Class<?> clz = Class.forName("com.chenkang.reflect.Student");
		
		
		Class<?> clz1=Student.class;
		System.out.println(clz1);
		
		
		Student stu=new Student();
		Class<?> clz11=stu.getClass();
		System.out.println(clz11);
	}
}

输出结果

1.3通过反射进行实例化

1.能够实例化未知的类
2.能够通过私有构造器创建实例
代码块

package com.chenkang.reflect;

import java.lang.reflect.Constructor;

/**
 * 反射实例化
 * 1.能够实例化未知的类
 * 2.能够通过私有构造器创建实例
 * @author 20190528
 *
 */
public class Demo2 {
	public static void main(String[] args) throws Exception {
		 Class clz=Student.class;
//		1.反射 调用无参构造方法创建了一个学生对象
//		 Student stu = (Student) clz.newInstance(); 
		 
//		2.调用一个参数的构造方法创建了一个学生对象
//		Constructor con=clz.getConstructor(String.class);
//		Student stu = (Student)con.newInstance("s001");
		 
//		 3.调用一个参数的构造方法创建了一个学生对象
//		 Constructor con=clz.getConstructor(String.class,String.class);
//		Student stu = (Student)con.newInstance("s001","zs");
//		(getConstructor)只能寻找到punlic修饰的构造器
//		 Constructor con=clz.getConstructor(Integer.class);
		 
//		 4.调用Student类私有的构造方法创建一个学生对象
//		 (getDeclaredConstructor)可以寻找到任何修饰的构造器
		 Constructor con=clz.getDeclaredConstructor(Integer.class);
		 con.setAccessible(true);
////		通过构造器实例化对象
		Student stu = (Student)con.newInstance(13);
		
		
	}
}

运行结果就是那四条！！！！！

1.4反射动态调用方法

代码块

package com.chenkang.reflect;

import java.lang.reflect.Method;

/**
 * 反射调用方法
 * AddOrderServlet
 * DelOrderServlet
 * @author 20190528
 *
 */
public class Demo3 {
	public static void main(String[] args) throws Exception {
		Student stu=new Student();
//		stu.hello();
		Class clz=stu.getClass();
//		Method m=clz.getDeclaredMethod("hello");
//		m.invoke(stu);
		
		
//		Method m=clz.getDeclaredMethod("hello",String.class);
//		m.invoke(stu,"zs");
		
		Method m=clz.getDeclaredMethod("add",Integer.class,Integer.class);
		m.setAccessible(true);
//		invoke:如果反射动态调用的方法是被void修饰，那么返回的是null
//		如果反射动态调用的方法不是被void修饰，那么返回的是被调用的返回值
		Object invoke = m.invoke(stu,20,5);
		System.out.println(invoke);
	}
}

运行结果

1.5、反射属性赋值取值

代码块

package com.chenkang.reflect;

import java.lang.reflect.Field;

/**
 * 反射属性赋值取值
 * -->
 * 反射能够将jsp传递过来的参数封装到实体类中
 * @author 20190528
 *
 */
public class Demo4 {
	public static void main(String[] args) throws Exception {
		Student stu=new Student("s002","zs");
//		面向对象的赋值
//		stu.setSid("s001");
		stu.age=22;
//		System.out.println(stu);
//		反射赋值
//		写属性
		Class clz = stu.getClass();
//		Field field = clz.getDeclaredField("sid");
//		field.setAccessible(true);
//		field.set(stu, "s002");
//		System.out.println(stu);
//		读属性
//		System.out.println(field.get(stu));
		
		
		Field[] fields = clz.getDeclaredFields();
		for (Field field : fields) {
			field.setAccessible(true);
			System.out.println(field.getName()+":"+field.get(stu));
		}
	}
}

输出结果