反射

一、反射是什么？

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

二、一切反射相关的代码都从获得类（java.lang.Class）对象开始

类对象获取的三种方式

Class.forName(完整类名)
以下例子都以Student为例：

package com.aixincheng.fanshe;

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.zhuyuncong.fanshe;

public class Demo1 {

	public static void main(String[] args) throws ClassNotFoundException {
		Class<?> clz = Class.forName("com.zhuyuncong.fanshe.Student");
	}
}

2、类名.class

package com.aixincheng.fanshe;

public class Demo1 {

	public static void main(String[] args) throws ClassNotFoundException {
//		1、Class<?> clz = Class.forName("com.zhuyuncong.fanshe.Student");
		Class<?> clz=Student.class;
		System.out.println(clz);
	}
}

3、类对象.getClass()

package com.aixincheng.fanshe;

public class Demo1 {

	public static void main(String[] args) throws ClassNotFoundException {
//		1、Class<?> clz = Class.forName("com.zhuyuncong.fanshe.Student");
		
//		2、Class<?> clz=Student.class;
//		System.out.println(clz);
	
		Student stu=new Student();
		Class<?> clz = stu.getClass();
		System.out.println(clz);
	}
}
1
三、反射三大作用(java.lang.reflect.*)
1、反射实例化对象
1.1 public无参：

    package com.zhuyuncong.fanshe;
    
    import java.lang.reflect.Constructor;
    
    /**
     * 通过反射进行实例化
     *  1、能够实例化未知的类
     *  2、能够通过私有构造器创建对象
     * @author MACHENIKE
     *
     */
    public class Demo2 {
    
    	public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException {
    		//一切反射相关的代码都从获得类（java.lang.Class）对象开始
    		Class clz=Student.class;
    		Student stu = (Student)clz.newInstance();
    		}
    	}

1.2 public有参

      package com.aixincheng.fanshe;
        
        import java.lang.reflect.Constructor;
        
        /**
         * 通过反射进行实例化
         *  1、能够实例化未知的类
         *  2、能够通过私有构造器创建对象
         * @author MACHENIKE
         *
         */
    
    public class Demo2 {
    
    	public static void main(String[] args) throws Exception {
    		//一切反射相关的代码都从获得类（java.lang.Class）对象开始
    		Class clz=Student.class;
    		//Student stu = (Student)clz.newInstance();
    		//拿到构造器类
    		Constructor con=clz.getConstructor(String.class);
    		//通过构造器实例化对象
    		Student stu = (Student)con.newInstance("s001");
    	}
    }
1.3 private有参

package com.zhuyuncong.fanshe;

import java.lang.reflect.Constructor;

/**
 * 通过反射进行实例化
 *  1、能够实例化未知的类
 *  2、能够通过私有构造器创建对象
 * @author MACHENIKE
 *
 */
public class Demo2 {

	public static void main(String[] args) throws Exception {
		//一切反射相关的代码都从获得类（java.lang.Class）对象开始
		Class clz=Student.class;
		//Student stu = (Student)clz.newInstance();
		//拿到构造器类(public 1个参数)
//		Constructor con=clz.getConstructor(String.class);
//		//通过构造器实例化对象
//		Student stu = (Student)con.newInstance("s001");
		//public 2个参数
//		Constructor con=clz.getConstructor(String.class,String.class);
//		//通过构造器实例化对象
//		Student stu = (Student)con.newInstance("s001","zs");
		
		//private 1参数
		//getConstructor方法只能寻找到public修饰的构造器
		//getDeclaredConstructor方法能寻找到任何修饰符的构造器
		Constructor con = clz.getDeclaredConstructor(Integer.class);
		//设置可以访问private方法
		con.setAccessible(true);
		Student stu = (Student)con.newInstance(12);
	}
}

package com.aixincheng.fanshe;

import java.lang.reflect.Method;

/**
 * 反射调用方法
 *  
 * @author MACHENIKE
 *
 */
public class Demo3 {

	public static void main(String[] args) throws Exception {
		//正常调用方法
		Student stu = new Student();
//		stu.hello();
//		一切反射相关的代码都从获得类（java.lang.Class）对象开始
		Class<?> clz = stu.getClass();
		//public 无参
//		Method m = clz.getDeclaredMethod("hello");
//		m.invoke(stu);
		//public 有参
//		Method m = clz.getDeclaredMethod("hello",String.class);
//		m.invoke(stu,"zs");
		
		//private 有参
		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);
	}
}

3、反射读写属性

package com.aixincheng.fanshe;

import java.lang.reflect.Field;

/**
 * 反射属性赋值取值
 * @author MACHENIKE
 *
 */
public class Demo4 {

	public static void main(String[] args) throws Exception {
		//一般读取属性
		Student stu = new Student();
//		stu.setSid("s001");
//		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));
	}
}