反射

1. 什么是反射

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

2.如何获取类对象(三种方式)

【注1】ClassNotFoundException(类名错|少jar包)
【注2】同一类的、类对象只会创建一个

案例

package com.caoguangli.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());
	}

	@Override
	public String toString() {
		return "Student [sid=" + sid + ", sname=" + sname + ", age=" + age + "]";
	}
}

1.Class.forName(“类的全路径名”);

Class cla = Class.forName(“com.caoguangli.reflect.Student”);

2.类名.class 做通用的查询

Class cla2 = Student.class;
System.out.println(cla2);

3.类(Class类类的类对象)实例 .getClass()

Student s = new Student();
Class cla3 = s.getClass();
System.out.println(cla3);

代码演示

package com.caoguangli.reflect;

/**
 * 如何获取类对象(三种方式)
 *   1.Class.forName("类的全路径名");   jdbc、自定义MVC框架
 *   2.类名.class  做通用的查询
 *   3.类(Class类类的类对象)实例 .getClass()   做通用的增删改
 *   
 * @author Administrator
 *
 */
public class Demo1 {

	public static void main(String[] args) throws Exception {
//		1.Class.forName("类的全路径名");
		Class cla = Class.forName("com.caoguangli.reflect.Student");
//		2.类名.class  做通用的查询
		Class cla2 = Student.class;
		System.out.println(cla2);
//		3.类(Class类类的类对象)实例 .getClass()   做通用的增删改
		Student s = new Student();
		Class cla3 = s.getClass();
		System.out.println(cla3);
		
		/**
		 * 为什么jdbc连接要使用class.forName("com.jdbc.mysql.Driver");
		 * 无论是mysql的驱动Driver还是Oracle的驱动......;它必然需要实现jdbc的一个驱动接口；
		 * java.sql.Driver d = Class.forName("com.jdbc.mysql.Driver")
		 * 
		 * 
		 * web.xml
		 * <servlet> 
		 *      <servlet-name>Xxx</servlet-name>
		 *      <servlet-class>com.caoguangli.XxxServlet</servlet-class>
		 * </servlet>
		 * .....
		 * 
		 * 
		 * com.caoguangli.XxxServlet extends httpServlet
		 * Class cla = Class.forName("com.caoguangli.XxxServlet");
		 * httpServlet httpServlet = cla.newInstanse;
		 * 
		 * XxxServlet 实例
		 * new XxxServlet();
		 * 
		 */
	}

}

运行结果：

3.反射实例化

1.能够实例化未知的类

2.能够通过私有构造器创建实例

package com.caoguangli.reflect;

import java.lang.reflect.Constructor;

/**
 * 反射实例化
 *  1.能够实例化未知的类
 *  2.能够通过私有构造器创建实例
 * @author Administrator
 *
 */
public class Demo2 {

	public static void main(String[] args) throws Exception{
		Class cla = Student.class;
//		反射调用无参构造方法创建了一个学生对象
		Student s = (Student)cla.newInstance();
//	          要拿到构造器类
		Constructor c = cla.getConstructor(String.class);
//		通过构造器实例对象
		Student s1 = (Student)c.newInstance("s001");
//		调用带二个参数的构造方法创建了一个学生对象
		Constructor c2 = cla.getConstructor(String.class,String.class);
//		通过构造器实例对象
		Student s2 = (Student)c2.newInstance("s001","hh");
		
//		调用Student类私有的构造方法创建一个学生对象
		
//		java.lang.NoSuchMethodException(getConstructor只能找到public修饰的构造器;getDeclaredConstructor可以找到任何修饰的构造器)
//		Constructor c3 = cla.getConstructor(Integer.class);
//		Exception in thread "main" java.lang.IllegalAccessException: Class com.caoguangli.reflect.Demo2 can not access a member of class com.caoguangli.reflect.Student with modifiers "private"
		
		Constructor c3 = cla.getDeclaredConstructor(Integer.class);
		c3.setAccessible(true);
//		通过构造器实例对象
		Student s3 = (Student)c3.newInstance(12);
	}
}

运行结果：

4.反射调用方法

package com.caoguangli.reflect;

import java.lang.reflect.Method;

/**
 * 反射调用方法
 *   AddOrderServlet
 *   delOrderServlet
 *   ...
 *   
 * -->OrderServlet
 *   jsp--> methodName
 *   dopost
 *   String methodName = req.getParameter("methodName");
 *   if("add".equals(methodName)){
 *      
 *   }else if("del".equals(methodName)){
 *      
 *   }
 *   
 * -->
 * 上面的代码全部都不需要
 *  del(req,resp);
 *  add(req,resp);
 * 
 * @author Administrator
 *
 */
public class Demo3 {

	public static void main(String[] args) throws Exception {
		Student s = new Student();
		s.hello();
		Class cla = s.getClass();
		Method m = cla.getDeclaredMethod("hello");
		m.invoke(s);
		Method m1 = cla.getDeclaredMethod("hello",String.class);
		
		System.out.println(m1.invoke(s, "哈哈"));
		
		Method m2 = cla.getDeclaredMethod("add",Integer.class,Integer.class);
		m2.setAccessible(true);
//		  invoke:如果反射动态调用的方法是被void所修饰，那么返回的就是null
//		  如果反射动态调用的方法是不被void所修饰，那么返回的就是被调用的方法的返回值
		
		Object invoke = m2.invoke(s, 20,6);
		System.out.println(invoke);
	}
}

运行结果：

5.反射属性赋值取值

package com.caoguangli.reflect;

import java.lang.reflect.Field;

/**
 * 反射属性赋值取值
 *    jsp
 *    --->uname,sex,age,pwd,phon,address......
 *    servlet
 *    String uname = req.getParameter("uname");
 *    .....
 *    
 *    User u = new User();
 *    u.setName(uname);
 *    .....
 *    
 *    -->
 *    反射能够将jsp传递过来的参数直接封装到实体类中
 * @author Administrator
 *
 */
public class Demo4 {

	public static void main(String[] args) throws Exception {
		Student s = new Student();
//		面向对象赋值
		s.setSid("s002");
		s.age = 22;
		System.out.println(s);
		
//		反射赋值
//		写
		Class cla = s.getClass();
		Field field = cla.getDeclaredField("sid");
		field.setAccessible(true);
		field.set(s, "s002");
		System.out.println(s);
//		读
		System.out.println(field.get(s));
		
		Field[] fields = cla.getDeclaredFields();
		for (Field field2 : fields) {
			field2.setAccessible(true);
			System.out.println(field2.getName() + " :" + field2.get(s));
		}
	}
}

运行结果：