反射

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

package com.lj.reflect;

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

2、类名.class

package com.lj.reflect;
/**
 * 
 * 获取类对象的方式 通过Java提供的反射机制获取到com.zking.reflect.Student.class
 * 1、Class.forName("全路径名"); jdbc/自定义mvc框架要用 2、类名.class 结合泛型做通用分页查询方法会用
 * 类java.lang.Class实例(Student.class)的类实例(宋万喜)的getClass()获取 通用的增删改结合泛型使用
 * @author yyj mmm
 *
 */
 public class Demo1 {
          public static void main(String[] args) {
        	// 1、Class.forName("全路径名"); jdbc/自定义mvc框架要用
      		// Class stuClz = Class.forName("com.zking.reflect.Student");

      		// 2、类名.class 结合泛型做通用分页查询方法会用
      		// Class stuClz = Student.class;

//     		Student stu = new Student();
      		// 3、类java.lang.Class实例(Student.class)的类实例(宋万喜)的getClass()获取 通用的增删改结合泛型使用
//      		Class stuClz = stu.getClass();
//      		System.out.println(stuClz);
		}
}

1.2 public有参

package com.lj.reflect;

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

/**
 * 利用反射进行对象的实例化 之前：通过new关键字进行实例化 现在： 通过java.lang.reflect.construct来实例化对象
 * 优势：
 * 	1、能够对未知的对象进行实例化
 * 	2、能够对私有构造器实例化对象
 * @author yyj mmm
 *
 */
 public class Demo2 {
             public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
            	 Student stu = new Student();
//         		Class stuClz = stu.getClass();
         		Class<Student> stuClz = Student.class;
//         		newInstance这个方法默认是使用无参构造器去实例化对象
//         		Student stu2 = (Student) stuClz.newInstance();
//         		System.out.println(stu2);
//         		调用有参构造器去实例化对象
//         		Constructor<Student> constructor = stuClz.getConstructor(String.class);
//         		Student stu2 = (Student) constructor.newInstance("zs");
         		
//         		调用有构造器去实例化对象
//         		Constructor<Student> constructor = stuClz.getConstructor(String.class,String.class);
//         		Student stu2 = (Student) constructor.newInstance("s001","zs");
调用私有构造器去实例化对象
//         		 java.lang.NoSuchMethodException: 
//         		getConstructor与getDeclaredConstructor的区别（getConstructor只能获取被public修饰的构造器，getDeclaredConstructor被所有关键字修饰的构造器）
//         		Class com.zking.reflect.Demo2 can not access a member of class com.zking.reflect.Student with modifiers "private"
         		
         		Constructor<Student> constructor = stuClz.getDeclaredConstructor(Integer.class);
         		constructor.setAccessible(true);
         		Student stu2 = (Student) constructor.newInstance(18);
         	
			}
}

动态方法调用

package com.lj.reflect;

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

/**
 * 动态方法调用
 * 构造方法是不是方法
 * @author yyj mmm
 *
 */
 public class Demo3 {
             public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
            	 Student stu = new Student();
         		Class<? extends Student> stuClz = stu.getClass();
//         		Method m= stuClz.getDeclaredMethod("hello");
//         		m.invoke(stu);
         		
//         		Method m= stuClz.getDeclaredMethod("hello",String.class);
//         		m.invoke(stu,"zs");
         		
         		Method m= stuClz.getDeclaredMethod("add",Integer.class,Integer.class);
         		m.setAccessible(true);
//         		Method.invoke的返回值是被动态调用的方法的返回值
         		Object invoke = m.invoke(stu,20,5);
         		System.out.println(invoke);
         	}
			
}

反射读写属性

package com.lj.reflect;

import java.lang.reflect.Field;

/**
 * 反射读写属性 自定义标签库、通用分页、自定义mvc也要用
 * 
 * 5. 访问修饰符
   getModifiers()
   	java:
   	private 1
   	protected 2
   	public 4
   	static 8
   	final abstract....
   	怎么判定属性或方法被那些修饰符所修饰呢？
   	getModifiers
   	3 private protected
   	5	
 * @author yyj mmm
 *
 */
 public class Demo4 {
        public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException {
        	Student stu = new Student("s001", "zs");
    		stu.age = 22;
    		System.out.println(stu.getSid());
    		System.out.println(stu.getSname());
    		Class<? extends Student> stuClz = stu.getClass();
    		// Field f = stuClz.getDeclaredField("age");
    		// f.setAccessible(true);
    		// System.out.println(f.get(stu));
    		// 获取当前Student实例中的stu所有属性及其属性值
    		Field[] fields = stuClz.getDeclaredFields();
    		for (Field field : fields) {
    			field.setAccessible(true);
    			System.out.println(field.getName() + ":" + field.get(stu));
    		}
		}
}