package com.reflect;

/**
 * 类对象的获取方式：
 * 1.Class.forName()
 * 
 * @author 云村小威
 *
 */
public class Demo1 {
	public static void main(String[] args) throws Exception {
		/**
		 * 多应用于jdbc数据库连接中
		 */
		Class forName = Class.forName("com.reflect.Student");
		System.out.println(forName);
		
	}
}

2. 类名.class

package com.reflect;

/**
 * 类对象的获取方式：
 * 2.类实例.getClass()
 * 
 * @author 云村小威
 *
 */
public class Demo1 {
	public static void main(String[] args) throws Exception {
		/**
		 * 通用增删改
		 */
		Student stu = new Student();
		System.out.println(stu.getClass());
	}
}

3. 对象.getClass()

package com.reflect;

/**
 * 类对象的获取方式：
 * 3.类名.class
 * 
 * @author 云村小威
 *
 */
public class Demo1 {
	public static void main(String[] args) throws Exception {
		/**
		 * 通用查询
		 */
		Class<?> c = Student.class;
		System.out.println(c);
	}
}

其中类名.class、对象名.getClass()方式在编码时已经知道了要操作的类，而Class.forName()方式在操作的时候，可以知道，也可以不知道要操作的类。所以当编码时还不知道要操作的具体类，就只能使用Class.forName()方式了。

三、反射实例化

配置测试类：

package com.reflect;

/**
 * 学生实体类
 * 
 * @author 云村小威
 *
 */
public class Student {
	private String sid;
	private String sname;
	public Integer age;

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

1.通过 Class 对象的 newInstance() 方法

package com.reflect;

/**
 * 反射实例化 
 * 1.通过 Class 对象的 newInstance() 方法
 * 
 * @author 云村小威
 *
 */
public class Demo2 {
	public static void main(String[] args) throws Exception {
		// 获取类对象
		Class c = new Student().getClass();
		// 调用无参构造方法创建一个对象
		Object object = c.newInstance();
		System.out.println(object);
	}
}

重点是：newInstance()调用的是无参构造，必须保证无参构造是存在的！

2. 通过 Constructor 对象的 newInstance() 方法

package com.reflect;

import java.lang.reflect.Constructor;

/**
 * 反射实例化 
 * 1.通过 Constructor 对象的 newInstance() 方法
 * 
 * @author 云村小威
 *
 */
public class Demo2 {
	public static void main(String[] args) throws Exception {
		// 获取类对象
		Class c = new Student().getClass();
		// 1.调用带一个参数（sid）的构造方法创建了一个学生对象
		Constructor constructor1 = c.getConstructor(String.class);
		// 强转为了获取实体类参数值
		Student object = (Student) constructor1.newInstance("s10");
		System.out.println(object.getSid());
		
		// 2.调用带两个参数（sid，sname）的构造方法创建了一个学生对象
		Constructor constructor2 = c.getConstructor(String.class, String.class);
		Student object2 = (Student) constructor2.newInstance("s101", "ikun");

		System.out.println(object2.getSid() + "--" + object2.getSname());
	}
}

3. 通过 DeclarredConstructor 对象的 newInstance() 方法

package com.reflect;

import java.lang.reflect.Constructor;

/**
 * 反射实例化 
 * 3. 通过 DeclarredConstructor 对象的 newInstance() 方法
 * 
 * @author 云村小威
 *
 */
public class Demo2 {
	public static void main(String[] args) throws Exception {
		// 获取类对象
		Class c = new Student().getClass();
		//调用Student类私有的构造方法创建一个构造方法
		Constructor constructor = c.getDeclaredConstructor(Integer.class);
		//打开私有修饰符的访问权限
		constructor.setAccessible(true);
		Student object = (Student) constructor.newInstance(18);
		System.out.println(object.getAge());
	}

}

注：不设置 setAccessible(true) 则会报错 Class com.reflect.Demo2 can not access a member of class com.reflect.Student with modifiers "private"

四、反射动态方法调用

1. getMethod 方法

package com.reflect;

import java.lang.reflect.Method;

/**
 * 反射动态方法调用
 * 
 * @author 云村小威
 *
 */
public class Demo3 {
	public static void main(String[] args) throws Exception {
		// 获取类对象
		Class c = new Student().getClass();
		// 调用newInstance()方法创建一个对象
		Student stu = (Student) c.newInstance();
		/**
		 * 1.public 的无参数方法调用
		 */
		// 获取方法对象
		// getMethod(方法名, 参数类型);
		Method m = c.getMethod("hello");
		// invoke(类实例, 实参)
		Object invoke = m.invoke(stu);
		// 注：方法返回值是void 结果是null
		System.out.println(invoke);
		
		/**
		 * 2.public 的有参数方法调用
		 */
        Method m2 = c.getMethod("hello", String.class);
        System.out.println(m2.invoke(stu, "小黑宝"));

	}
}

2. DeclaredMethod 方法

package com.reflect;

import java.lang.reflect.Method;

/**
 * 反射私有方法调用
 * 
 * @author 云村小威
 *
 */
public class Demo3 {
	public static void main(String[] args) throws Exception {
		// 获取类对象
		Class c = new Student().getClass();
		// 调用newInstance()方法创建一个对象
		Student stu = (Student) c.newInstance();

        /**
         * 私有带参数方法调用
         */
        Method m3 = c.getDeclaredMethod("add", Integer.class, Integer.class);
        // 打开私有修饰符的访问权限
        m3.setAccessible(true);
        System.out.println("返回结果："+m3.invoke(stu, 1, 10));
	}
}

五、反射读写属性

package com.reflect;

import java.lang.reflect.Field;

/**
 * 反射读写属性
 * 
 * @author 云村小威
 *
 */
public class Demo4 {
	public static void main(String[] args) throws Exception {
		// 获取类对象
		Class c = new Student().getClass();
		// 调用newInstance()方法创建一个对象
		Student stu = (Student) c.newInstance();
		/**
		 * 通过反射存值getDeclaredField(属性名); 
		 * set(对象,值)
		 */
		Field declaredField = c.getDeclaredField("sname");
		//打开修饰符访问权限
		declaredField.setAccessible(true);
		declaredField.set(stu, "小黑宝");
		
		/**
		 * 通过反射读取值getDeclaredFields() return arr[]
		 * get(对象) 获取值
		 * getName() 获取属性名
		 */
		Field[] fields = c.getDeclaredFields();
		for (Field f : fields) {
			//打开修饰符访问权限
			f.setAccessible(true);
			System.out.println(f.getName()+":"+f.get(stu));
		}
	}
}