JavaSE_反射机制

package it.cast.bean;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectDemo_1 {
	public static void main(String[] args) throws Exception {
		method_10();
	}
	private static void method_10() throws Exception {
		/*方法说明：
		*通过Class类，获得特定名字的特定参数的函数，并传值运行
		*/
		String className="it.cast.bean.Person";
		Class clazz=Class.forName(className);
		Method m=clazz.getMethod("paramMethod", String.class,int.class);
		Object obj=clazz.newInstance();
		m.invoke(obj, "小强",23);
		/*
		 * person 空参构造函数 run
			小强...带参数的方法paramMethod run...23
		 */
	}
	private static void method_9() throws InstantiationException, 
IllegalAccessException, ClassNotFoundException, NoSuchMethodException,
SecurityException, IllegalArgumentException, InvocationTargetException {
		/*方法说明：
		*通过Class类，获得带参数的构造器进行实例化，
		获得特定名字的无参数方法并运行
		*/
		String className="it.cast.bean.Person";
		Class clazz=Class.forName(className);
		Method m=clazz.getMethod("show", null);//空参数的方法，后面的参数列表是null
		Constructor con=clazz.getConstructor(String.class,int.class);
		Object obj=con.newInstance("小强",22);		
		m.invoke(obj, null);
		/*
		 * person 带参数构造函数 run:   小强...22
			小强...公有方法show run...22
		 */
	}
	private static void method_8() throws ClassNotFoundException,
NoSuchMethodException, SecurityException, InstantiationException, 
IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		/*方法说明：
		*通过Class类，获得特定名字的无参数的函数
		*/
		String className="it.cast.bean.Person";
		Class clazz=Class.forName(className);
		Method m=clazz.getMethod("show", null);//空参数的方法，后面的参数列表是null
		Object obj=clazz.newInstance();
		m.invoke(obj, null);
		/*
		 * person 空参构造函数 run
			null...公有方法show run...0
		 */
	}
	private static void method_7() throws ClassNotFoundException {
		/*方法说明：
		*通过Class类，获得公共的函数
		*/
		String className="it.cast.bean.Person";
		Class clazz=Class.forName(className);
		Method[] m=clazz.getMethods();//获取公有的方法，含父类和父接口
		m=clazz.getDeclaredMethods();//只获取本类中的所有方法，含私有
		for (Method method : m) {
			System.out.println(method);
		}
		/*
		 * 
private void it.cast.bean.Person.privateMethod()
public void it.cast.bean.Person.show()
public void it.cast.bean.Person.paramMethod(java.lang.String,int)
public static void it.cast.bean.Person.staticMethod()
		 */
		/*
		 * 
public static void it.cast.bean.Person.staticMethod()
public void it.cast.bean.Person.show()
public void it.cast.bean.Person.paramMethod(java.lang.String,int)
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
		 */
	}
	private static void method_6() throws NoSuchFieldException, 
SecurityException, ClassNotFoundException, 
InstantiationException, IllegalAccessException {
		/*方法说明：
		*通过Class类，获得指定字段Field，并对其进行get和set
		*/
		String className="it.cast.bean.Person";
		Class clazz=Class.forName(className);
		Field f=clazz.getDeclaredField("age");
		System.out.println(f);//private int it.cast.bean.Person.age
		Object obj=clazz.newInstance();
		//字段获取值之前 一定要进行对私有字段取消权限检查，又称暴力获取（访问）
		//用的是Field的基类AccessibleObject类的void setAccessible(blooean flag)
		f.setAccessible(true);
		//字段还可以设置值,后面一个参数可以自动装箱
		f.set(obj, new Integer(23));
		Object val=f.get(obj);
		System.out.println(val);
	}
	private static void method_5() throws ClassNotFoundException, 
NoSuchMethodException, SecurityException, InstantiationException,
IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		/*方法说明：
		*获得指定构造器Constructor对象，再用Constructor对象的newInstance方法进行实例化对象
		*/
		String className="it.cast.bean.Person";
		Class clazz=Class.forName(className);
		System.out.println(clazz.getConstructors());
		//[Ljava.lang.reflect.Constructor;@16e588e
		Constructor con=clazz.getConstructor(String.class,int.class);
		Object obj=con.newInstance("beyond",29);
		//person 带参数构造函数 run:   beyond...29
	}
	private static void method_4() throws ClassNotFoundException, 
InstantiationException, IllegalAccessException {
		/*方法说明：
		*通过Class类中的方法：
		newInstance()创建此 Class 对象所表示的类的一个新实例。
		*public T newInstance()
              throws InstantiationException,
                     IllegalAccessException
					 创建此 Class 对象所表示的类的一个新实例。
					 如同用一个带有一个空参数列表的 new 表达式实例化该类。
					 如果该类尚未初始化，则初始化这个类。 
注意，此方法传播 null 构造方法所抛出的任何异常，包括已检查的异常。
使用此方法可以有效地绕过编译时的异常检查，
而在其他情况下编译器都会执行该检查。 
Constructor.newInstance 方法将该构造方法所抛出的任何异常包装在
一个（已检查的）InvocationTargetException 中，从而避免了这一问题。 
返回：
此对象所表示的类的一个新分配的实例。 
抛出： 
IllegalAccessException - 如果该类或其 null 构造方法是不可访问的。 
InstantiationException - 
如果此 Class 表示一个抽象类、接口、数组类、基本类型或 void； 
或者该类没有 null 构造方法； 或者由于其他某种原因导致实例化失败。 
ExceptionInInitializerError - 如果该方法引发的初始化失败。 
SecurityException - 如果存在安全管理器 s，并满足下列任一条件： 
调用 s.checkMemberAccess(this, Member.PUBLIC) 拒绝创建该类的新实例 
调用者的类加载器不同于也不是当前类的类加载器的一个祖先，
并且对 s.checkPackageAccess() 的调用拒绝访问该类的包 
		*/
		String className="it.cast.bean.Person";
		Class clazz=Class.forName(className);
		Object obj=clazz.newInstance();
		System.out.println(obj);
		/*
		 * person 空参构造函数 run
			it.cast.bean.Person@91fa78
		 */
	}
	private static void method_3() throws Exception {
		/*方法说明：
		*用Class类中的静态方法：static Class<?> forName(String className) 
          返回与带有给定字符串名的类或接口相关联的 Class 对象。 
		public static Class<?> forName(String className)
		                        throws ClassNotFoundException
		返回与带有给定字符串名的类或接口相关联的 Class 对象。
		调用此方法等效于： 
		  Class.forName(className, true, currentLoader)
		 其中 currentLoader 表示当前类的定义类加载器。 
		例如，以下代码片段返回命名为 java.lang.Thread 的类的运行时 Class 描述符。 
		   Class t = Class.forName("java.lang.Thread")
		 调用 forName("X") 将导致命名为 X 的类被初始化。 
		参数：
		className - 所需类的完全限定名。 
		返回：
		具有指定名的类的 Class 对象。 
		抛出： 
		LinkageError - 如果链接失败 
		ExceptionInInitializerError - 如果此方法所激发的初始化失败 
		ClassNotFoundException - 如果无法定位该类
		*/
		String className="it.cast.bean.Person";
		Class clazz=Class.forName(className);
		System.out.println(clazz);//class it.cast.bean.Person
	}
	private static void method_2() {
		/*方法说明：
		*任何一个数据类型，都具备一个静态的属性。
		class来获取其对应的字节码对象
		*特别：虽然不用再创建对象，但是还是要用到类的静态成员
		*/
		Class cla=Person.class;
		Class cla2=Person.class;
		System.out.println(cla==cla2);
		System.out.println(cla);//class it.cast.bean.Person
	}
	public static void method_1() {
		/*
		 * 获取字节码对象的方法一：
		 * 使用Object类中的getClass()方法，缺点：需明确类，需创建对象
		 */
		Person p=new Person();
		Person p2=new Person();
		Class cla=p.getClass();
		Class cla2=p2.getClass();
		System.out.println(cla==cla2);
		/*
		 * person 空参构造函数 run
			person 空参构造函数 run
			true
		 */
		System.out.println(cla);//class it.cast.bean.Person
	}
}
/*ClassNotFoundException, 
NoSuchMethodException, 
SecurityException, 
InstantiationException, 
IllegalAccessException, 
IllegalArgumentException, 
InvocationTargetException
*/