J2E入门反射

1.什么是反射？
反射是一种机制,利用反射机制动态的实例化对象、读写属性、调用方法、构造函数。

2.如何得到类对象
   一切反射相关的代码都从获得类对象开始
   3种获取方式：
     2.1 类名.class;
     2.2 对象名.getClass();
     2.3 Class.forName(全限定名/全路径名)

3.根据类得到类名（全限定名/全路径名）
    1）cName.getName();            -->获取全限定名
    2）cName.getSimpleName();         -->获取类名
    3）cName.getPackage();             -->获取包名

4.根据类得到类的属性
    Field field=cla.getField(“属性名”);

    field.getName();            -->获取属性名            
    filed.getType();            -->获取属性类型        
    field.getModifiers();            -->获取属性访问修饰符    
    field.set(Object,Object);         -->设置属性值，参数1：要设置属性所在对象；参数2：要设置的值;    
    field.get(Object);            -->获取属性值，参数：要获取属性值的对象                
    field.getDeclaredField(“属性名”);    -->获取单个属性（私有、公有、受保护、默认、静态）    
    field.getDeclaredFields();        -->获取所有属性（私有、公有、受保护、默认、静态）

5.根据类得到类的方法
    //无参无返回、无参有参会、有参无返回、有参有返回
    cla.getMethod();            -->获取单个公有方法
    cla.getDeclaredMethod();        -->获取当个方法(包括私有、受保护、默认、公有)
    cla.getMethods();            -->获取所有公有方法
    cla.getDeclaredMethods();        -->获取所有的方法(包括私有、受保护、默认、公有)

6.根据类得到类的构造方法
    cla.getConstrutor();            -->获取单个公有构造方法
    cla.getDeclaredConstrutor();        -->获取单个构造方法(包括私有、受保护、默认、公有)
    cla.getConstrutors();            -->获取所有的公有构造方法
    cla.getDeclaredConstrutors();        -->获取所有的构造方法(包括私有、受保护、默认、公有)

7.根据类得到类的实现接口列表
    Class[] interface=cla.getInterfaces();    -->获取类对象中所有实现接口列表

课堂代码

package com.zking.utils;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;

import com.zking.entity.Hello;
import com.zking.entity.Student;

public class Demo1 {

	public static void main(String[] args)
			throws InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchFieldException,
			SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {
		// 1.什么是反射
		// 反射是一种机制，利用反射机制可以动态的实例化对象，读写属性

		// 异常
		// 1）InstantiationException:反射机制实例化异常
		// 2）ClassNotFoundException:类没有反射异常
		// 3)NoSuchFieldException:没有属性异常
		// 4）IllegalArgumentException：没有权限
		// 5)NoSuchMethodException:没有匹配的异常
		// 6)IllegalArgumentException同名不同参

		// 应用场景，
		// 加载驱动
		// 框架的层技术与反射机制实例化的对象的区别

		// 2.传统实例化对象与对象反机制实例化对象的区别
		// 1)传统方式
		/*
		 * Hello hello =new Hello(); //hello.setName("张三"); System.out.println(hello);
		 */
		// 2)反射方式
		/*
		 * Class cls=Hello.class; Object hello01 =cls.newInstance();
		 * System.out.println(hello01);
		 */

		// 一切与反射相关的从获取类对象开始！！！（三种）
		// 1)类名.class
		// Class cls=Hello.class;

		// 2)对象名.getClass()
		/*
		 * Hello h =new Hello(); Class cls = h.getClass();
		 */

		// 3)Class.forName(类的全集)
		/*
		 * Class cls = Class.forName("com.zking.reflect.entity.Htllo");
		 * System.out.println("类的全路径名:"+cls.getName());
		 * System.out.println("获取简单类名:"+cls.getSimpleName());
		 * System.out.println("获取访问修饰符:"+cls.getModifiers());
		 * System.out.println("获取类所在的包名:"+cls.getPackage());
		 */

		Class cls = Class.forName("com.zking.entity.Student");
		// 反射机制实例化对象
		Student stu = (Student) cls.newInstance();

		// 3.获取属性（Field）
		// 3.1）获取单个公共属性
		// Field field =cls.getField("age");

		// 3.2）获取单个公共的，私有的，爱保护的等等属性
		// Field field = cls.getDeclaredField("sid");

		// 3.3)获取所有的公共的属性
		// Field[] fields =cls.getFields();

		// 3.4)获取所有的公共的。私有的，受保护的
		/*
		 * Field[] fields = cls.getDeclaredFields();
		 * 
		 * for(Field field : fields) { System.out.println("获取属性名" + field.getName());
		 * System.out.println("获取属性的访问修饰符" + field.getModifiers());
		 * System.out.println("获取属性类型" + field.getType()); System.out.println(
		 * "-----------------------------------------------------------"); }
		 */

		// 3.5)赋值
		/*
		 * Field field = cls.getDeclaredField("sid"); // 设置访问权限
		 * field.setAccessible(true); // 赋值方法 // 参数1：实例化对象名 // 参数2：赋值的值 field.set(stu,
		 * "p007"); // 3.6）取值 // 参数：实例化对象名 Object obj = field.get(stu);
		 * System.out.println(obj);
		 */

		// 4.调用方法（Method）
		// 有参有返回 有参无返回 无参有返回 无参无返回
		// 4.1)获取单个的方法
		/*
		 * Method method =cls.getMethod("hello", null);
		 */
		// 4.2)获取单个公共的，私有的，受保护的
		/*
		 * Method method =cls.getDeclaredMethod("hello",String.class);
		 */ // 4.3获取所有公共的方法
		/*
		 * Method[] methods =cls.getDeclaredMethods();
		 */

		// 4.4获取所有的公共的，私有的，受保护的，最终的等等方法
		/*
		 * Method[] methods = cls.getDeclaredMethods();
		 */
		/*
		 * for (Method method : methods) { System.out.println("获取方法名" +
		 * method.getName()); System.out.println("获取方法的访问修饰符" + method.getModifiers());
		 * System.out.println("获取方法的参数" + method.getParameterCount());
		 * System.out.println("获取方法的访问类型" + method.getReturnType());
		 * 
		 * }
		 */
		// 4.5)调用方法
		/*
		 * Method method=cls.getMethod("hello", String.class);
		 */
		Method method = cls.getDeclaredMethod("add", Integer.class);
		/*
		 * method.setAccessible(true); //执行方法 //参数1：实例化对象名 //参数2：方法参数 Object
		 * returnValue=method.invoke(stu, "张三",10); System.out.println(returnValue);
		 */

		// 5.调用构造函数
		/*
		 * Constructor cons =cls.getConstructor(String.class); cons.newInstance(null);
		 */
		Constructor cons = cls.getDeclaredConstructor(Integer.class);
		cons.setAccessible(true);
		cons.newInstance(10);

	}

}