Java反射的使用（1）

一、利用反射创建对象

创建对象：
1、使用 Class 对象的 newInstance()方法创建该 Class 对象的实例，此时该 Class 对象必须要有无参数的构造方法。
2、使用 Class 对象获取指定的 Constructor 对象，再调用 Constructor 的 newInstance（）方法创建对象类的实例，此时可以选择使用某个构造方法。如果这个构造方法被私有化起来，那么必须先申请访问，将可以访问设置为 true；
示例代码（最简单的）

class User {	
	/*private User(){//将默认的构造方法私有化的话就不可以再创建对象，两种方法都是这样		
	}*/	 

	public String toString() {
		return "User对象创建成功！";
	}
}

public class ReflectDemo {
	public static void main(String[] args) throws Exception {
		// 传统方式创建对象
		System.out.println(new User());
		// 使用反射的方式
		Class c = User.class;
		User u = c.newInstance();// （直接newInstance的话必须保证默认的构造方法正常存在，也就是没有被私有化！这是前提条件）
		System.out.println(u);
	}
}

结果截图如下：

复杂点的，更强大的第二种：使用指定构造方法来创建对象：获取该类的 Class 对象。
利用 Class 对象的 getConstructor()方法来获取指定的构造方法。
调用 Constructor 的 newInstance()方法创建对象。
AccessibleObject 对象的 setAccessible(boolean flag)方法,当 flag 为 true 的时候，就会忽略访问
权限(可访问私有的成员)。
其子类有 Field, Method, Constructor;
若要访问对象 private 的成员？在调用之前使用 setAccessible(true),
Xxx x = getDeclaredXxxx();//才能得到私有的类字段.

总结步骤：

1. 获取该类的 Class 对象。
2. 利用 Class 对象的 getConstructor()方法来获取指定的构造方法。
3. 申请访问（设置为可访问）
4. 调用 Constructor（构造方法）的 newInstance()方法创建对象。

示例代码：

import java.lang.reflect.Constructor;

class Per {
	private String name;
	private int age;

	private Per() {
	}

	private Per(String name) {
	}

	public String toString() {
		return "对象！！！";
	}
}

public class ReflectDemo1 {
	public static void main(String[] args) throws Exception {
		Class c = Per.class;
		// System.out.println(c.newInstance());;//证明利用无参的可以
		// 先获得需要被调用的构造器(private 修饰的构造方法)
		Constructor con = c.getDeclaredConstructor();// 调用默认的，什么都不要写
		System.out.println(con); 		
		/**
		 * 现在只需要执行这个构造器，T newInstance(Object... initargs) 使用此 Constructor
		 * 对象表示的构造方法来创建该构造方法的声明 类的新实例，并用指定的初始化参数初始化该实例。
		 */
		// 私有的成员是受保护的,不能直接访问(无法直接访问的构造器不一定是私有的),若要访问私有的成员,得先申请一下
		con.setAccessible(true);// 允许访问
		Per p = con.newInstance();// 成功，通过私有的受保护的构造方法创建了对象
		System.out.println("无参构造方法" + p);
		con = c.getDeclaredConstructor(String.class);//获取指定的构造方法
		System.out.println(con);
		con.setAccessible(true);// 允许访问
		p = con.newInstance("duixiang");// 成功，通过私有的受保护的构造方法创建了对象
		System.out.println("String构造方法" + p);
	}
}

备注：对于此时的话，单例模式就不再安全了！反射可破之！！
结果截图：

总结：

（1）getDeclaredConstructor()当没有参数时，它就是默认获取无参构造器，也可以获取指定的构造方法，如con = c.getDeclaredConstructor(String.class);//获取指定的构造方法
（2）T newInstance(Object… initargs) 使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
（3）私有的成员是受保护的,不能直接访问(无法直接访问的构造器不一定是私有的),若要访问私有的成员,得先申请一下，如con.setAccessible(true);// 允许访问

二、使用反射调用方法

每个 Method 的对象对应一个具体的底层方法。获得 Method 对象后，程序可以使用 Method 里面的 invoke 方法来执行该底层方法。
Object invoke(Object obj,Object … args):obj 表示调用底层方法的对象，后面的 args 表示传递
的实际参数。
如果底层方法是静态的，那么可以忽略指定的 obj 参数。该参数可以为 null,想想为什么?
如果底层方法所需的形参个数为 0，则所提供的 args 数组长度可以为 0 或 null。
不写,null,或 new Object[]{}
若底层方法返回的是数组类型,invoke 方法返回的不是底层方法的值,而是底层方法的返回类
型;
示例代码：

import java.lang.reflect.Method;

class Dept {
	public String show(String name) {// 用反射的方法来调用正常的方法
		return name + "，您好！";
	}

	private void privateshow() {// 用反射来实现对私有化方法的调用
		System.out.println("私有的方法：privateshow");
	}

	public static void staticshow() {
		System.out.println("静态的方法：staticshow");
	}
}

public class InvokeDemo {
	public static void main(String[] args) throws Exception {
		//传统方式： 
		String name = new Dept().show("刘昭"); 
		System.out.println("传统方式：" + name);
		// 想要通过反射来调用Dept中的方法
		Class c = Dept.class;
		Method m = c.getMethod("show", String.class);
		Object o = m.invoke(c.newInstance(), "刘昭");
		System.out.println("反射调用的方式：" + o);
		// 私有化的方法
		m = c.getDeclaredMethod("privateshow");// 无参方法
		m.setAccessible(true);
		o = m.invoke(c.newInstance());
		// 静态方法的调用
		m = c.getMethod("staticshow");
		m.invoke(null);// staticshow为静态方法，不需创建对象，所以这里会是 null
	}
}

结果截图：

注：Method getMethod(String name, Class… parameterTypes)返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。name - 方法名；parameterTypes - 参数列表。