反射

1、什么是反射？

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

2、为什么要学反射

用tomcat来举例，tomcat开发人员是不清楚未来程序员是否会编码出什么类也就不会去实例化未知的类，反射的好处：能够将未知的类进行实例化，

3、反射的三大作用

实例化对象 c.newInstance()
Constructor.getConstructor/Constructor.getDeclaredConstructor
注：一定要提供无参构造器
动态调用方 Method m; m.invoke
读写属性
Field set/get

4、案例

我们通过下面这个学生类来看

package com.liuchunming;

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());
	}
}

1，获取类对象的三种方式
一切反射的相关代码都从获取类对象开始
Class.forName(“完整类名”);
类名.class;
对象.getclass();

2，实例化对象

		Student stu =new Student();
		Class<? extends Student> clz = stu.getClass();
		//反射实例化
		//无参共有的实例化
		Student stu2= (Student) clz.newInstance();
		System.out.println(stu2);

调有一个参数的共有构造器实例化

有一个参数的共有构造器实例化
		Constructor<? extends Student> c = clz.getConstructor(String.class);
		Student stu3 = c.newInstance("s001");
		System.out.println(stu3);
		System.out.println("-----------------------------");

调有两个参数的共有构造器实例化

3、有两个参数的共有构造器实例化
		Constructor<? extends Student> c2 = clz.getConstructor(String.class,String.class);
		Student stu4 = c2.newInstance("s001","zhangshang");
		System.out.println(stu4);
		System.out.println("-----------------------------");

私有的构造器实例化

Constructor<? extends Student> c3 = clz.getDeclaredConstructor(Integer.class);
		c3.setAccessible(true);
		Student stu5 = c3.newInstance(22);

注意：这样要提几个点
调用私有的方法（private）,需要使用getDeclaredConstructor方法来调用，并且需要使用打开权限setAccessible(true);
这里有几个常见的错误：
java.lang.NoSuchMethodException:student中没有Inttegr为参数的方法

java.lang.IllegalAccessException 非法访问因为这个构造器是private修饰符

3、动态调用方法

Student stu =new Student();
		Class<? extends Student> clz = stu.getClass();
		Method m = clz.getMethod("hello");
		Object invoke = m.invoke(stu);
//		动态调用的方法，如果该方法是void类型返回值，那么invoke，此时结果为null
		System.out.println(invoke);
		System.out.println("----------");

有一个参数的共有方法调用

		Method m2 = clz.getMethod("hello", String.class);
		Object invoke2 = m2.invoke(stu, "zhangshang");
		System.out.println(invoke2);

私有的方法调用

这里的add是加法
Method m3 = clz.getDeclaredMethod("add", Integer.class,Integer.class);
		m3.setAccessible(true);
		Object invoke3 = m3.invoke(stu, 20,5);
//		动态调用的方法，如果该方法是非void类型的返回值，那么被invoke好，就是该调用方法的结果
		System.out.println(invoke3);

3，读写属性

Student stu =new Student("s001","zhangshang");
		stu.age=22;
		Class<? extends Student> clz = stu.getClass();
		System.out.println(stu.getSname());
		
		
		Field f = clz.getDeclaredField("sname");
		f.setAccessible(true);
		System.out.println(f.get(stu));
		
		System.out.println("-----------");

反射读写属性常用方法（一次性获取该类的所有属性值）

		Field[] fs = clz.getDeclaredFields();
		for (Field field : fs) {
			field.setAccessible(true);
			System.out.println(field.get(stu));
		}

同过反射设置值

System.out.println("----设置-------");
//		想通过反射改变sname的值
		f.set(stu, "lisi");
		System.out.println(stu.getSname());

总结

到这里反射使用的方法和使用方式都介绍完了，如果有些的不对的地方欢迎评论出来，改进