反射

---

1. 什么是反射

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

1. 一切反射相关的代码都从获得类（java.lang.Class）对象开始
   注1：ClassNotFoundException(类名错|少jar包)
   注2：同一类的、类对象只会创建一个
   类：

    package com.houyitao;
    
    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);
    }
   
    @Override
    public String toString() {
    	return "Student [sid=" + sid + ", sname=" + sname + ", age=" + age + "]";
    }
   
    @SuppressWarnings("unused")
    private Integer add(Integer a, Integer b) {
    	return new Integer(a.intValue() + b.intValue());
    }
   

   }

1.1 Class.forName(完整类名)

package com.houyitao;

public class Demo1 {
/**
 * 如何获取类对象
 * 1.class。forname("类的全路径"); jdbc，自定义myv框架
 * 2.类名。class   做通用的查询
 * 3. 类实例。getclass 做通用增删改
 * @throws ClassNotFoundException 
 * 
 */
	public static void main(String[] args) throws ClassNotFoundException {
		Class<?> forName = Class.forName("com.houyitao.Student");
		System.out.println(forName);

		
	
		
	}
}

1.2 类名.class

package com.houyitao;

public class Demo1 {
/**
 * 如何获取类对象
 * 1.class。forname("类的全路径"); jdbc，自定义myv框架
 * 2.类名。class   做通用的查询
 * 3. 类实例。getclass 做通用增删改
 * @throws ClassNotFoundException 
 * 
 */
	public static void main(String[] args) throws ClassNotFoundException {
		
		Class<?> forName=Student.class;
		System.out.println(forName);
	
		
	
		
	}
}

1.3 对象.getClass()

package com.houyitao;

public class Demo1 {
/**
 * 如何获取类对象
 * 1.class。forname("类的全路径"); jdbc，自定义myv框架
 * 2.类名。class   做通用的查询
 * 3. 类实例。getclass 做通用增删改
 * @throws ClassNotFoundException 
 * 
 */
	public static void main(String[] args) throws ClassNotFoundException {
	
		
		Student stu=new Student();
		Class<?> forName=stu.getClass();
		System.out.println(forName);
		
	
		
	}
}

2. 反射三大作用(java.lang.reflect.*)

c.newInstance()
Constructor.getConstructor/Constructor.getDeclaredConstructor
注：一定要提供无参构造器


package com.houyitao;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Demo2 {
/**
 * 反射实例化
 * 好处：
 * 1.能够实例化未知的类
 * 2.能够通过私有构造器创建实例
 * @throws IllegalAccessException 
 * @throws InstantiationException 
 * @throws SecurityException 
 * @throws NoSuchMethodException 
 * @throws InvocationTargetException 
 * @throws IllegalArgumentException 
 */
	public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
		Class<Student> cl=Student.class;
//		反射调用无参构造方法创建一个学生对象
//		Student stu= (Student) cl.newInstance();
		
//		要拿到构造器类
//		Constructor con=cl.getConstructor(String.class);
//		通过构造器实例对象
//		Student stu=(Student)con.newInstance("s001");
//		System.out.println(stu);
		
		
//		要拿到构造器类
//		俩个参
//		Constructor con=cl.getConstructor(String.class,String.class);
//		通过构造器实例对象
//		Student stu=(Student)con.newInstance("1","无比");
//		System.out.println(stu);
		
//		调用Student类私有的构造方法创建一个学生对象
//		 java.lang.NoSuchMethodException
//		(getConstructor只能寻找到public修饰的构造器)
//		(getDeclaredConstructor可以寻找到任何修饰符修饰的构造器 )
//		Constructor con=cl.getConstructor(Integer.class);
		
//		通过构造器实例对象
		Constructor con=cl.getDeclaredConstructor(Integer.class);
		
		con.setAccessible(true);
		Student stu=(Student)con.newInstance(1);
		System.out.println(stu);
	}
}

结果
2.2 动态调用方法
Method m;
m.invoke

package com.houyitao;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Demo3 {
/**
 * 反射调用方法
 * @throws SecurityException 
 * @throws NoSuchMethodException 
 * @throws InvocationTargetException 
 * @throws IllegalArgumentException 
 * @throws IllegalAccessException 
 * 
 * 
 */
	public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		Student stu=new Student();
//		stu.setSname("无比");
//		stu.hello();
		
		Class clz=stu.getClass();
//		Method m=clz.getDeclaredMethod("hello");
//		m.invoke(stu);
		
//		Method m=clz.getDeclaredMethod("hello",String.class);
//		m.invoke(stu,"无比");
		
		
		Method m=clz.getDeclaredMethod("add",Integer.class,Integer.class);
		m.setAccessible(true);
//		invoke:如果返回动态调用的方法是被void所修饰，那么返回的就是null
//		如果反射动态调用的方法不被void所修饰，那么返回就是被调用的方法的返回值
		Object invoke = m.invoke(stu,1,2);
		System.out.println(invoke);
	}
}

2.3 读写属性
Field set/get

package com.houyitao;

import java.lang.reflect.Field;

public class Demo4 {
	/**
	 * 反射属性赋值取值
	 * @throws SecurityException 
	 * @throws NoSuchFieldException 
	 * @throws IllegalAccessException 
	 * @throws IllegalArgumentException 
	 * 
	 */
	public static void main(String[] args) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
//		Student stu=new Student();
//		stu.setSname("无比");
//		stu.age=22;
//		System.out.println(stu);
		
//		Class clz=stu.getClass();
//		Field field = clz.getDeclaredField("sname");
//		field.setAccessible(true);
//		field.set(stu, "wubi");
//		System.out.println(stu);
//		System.out.println(field.get(stu));
		
		
		Student stu=new Student("01","无比");
		stu.age=38;
		Class clz=stu.getClass();
		Field[] fields = clz.getDeclaredFields();
		for (Field field : fields) {
			field.setAccessible(true);
			System.out.println(field.getName()+" "+field.get(stu));
		}
				
	}

}