在java的很多技术框架中，我们时常能看到函数的反射，回调等等。一开始感觉很高大上的东西，有木有？但是慢慢了解了之后，也就明白了其实就是一种很简单的方式，同时也是java设计中必不可少的机制。
一、反射机制及其作用
反射可以帮助我们在类动态运行的时候，对于任意一个类，可以获得其所有的方法（public private protected等），所有的变量（同上），然后对其进行操作。了解了反射机制的定义，我们其实可以很容易看出它的作用，获取某些类的一些私有变量。
二、代码实现
设定一个pojo类，里面含有一些私有成员变量，如下：
public class User {
private String name;
private String sex;
public User() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("{");
sb.append("\"name\":\"")
.append(name).append('\"');
sb.append(",\"sex\":\"")
.append(sex).append('\"');
sb.append('}');
return sb.toString();
}
}
java反射工具包（java.lang.reflect），利用反射来获取类的信息
public class Main {
public static void main(String[] args) throws Exception {
example5();
}
/**
* 通过java反射机制得到类的信息
*/
public static void example1() {
User user = new User();
System.out.println("例1：包名：" + user.getClass().getPackage().getName() + ","
+ "类名：" + user.getClass().getName());
}
/**
* 验证所有类都是Class类的实例对象
* @throws ClassNotFoundException
*/
public static void example2() throws ClassNotFoundException {
Class<?> class1 = null;
Class<?> class2 = null;
//动态加载类,这一步已经执行了该类中的静态代码段
class1 = Class.forName("com.hust.reflect.User");
System.out.println("例2.1：包名：" + class1.getClass().getPackage().getName() + ","
+ "类名：" + class1.getClass().getName());
class2 = User.class;
System.out.println("例2.2：包名：" + class2.getClass().getPackage().getName() + ","
+ "类名：" + class2.getClass().getName());
}
/**
*通过java反射机制用Class创建类对象
* @throws Exception
*/
public static void example3() throws Exception{
Class<?> class1 = null;
class1 = Class.forName("com.hust.reflect.User");//动态加载类
User user = (User) class1.newInstance(); //这两句相当于User user = new User();
user.setName("钢铁侠");
user.setSex("未知");
System.out.println("例3："+user.getName()+"-"+user.getSex());
}
/**
* 通过java反射机制得到一个类的构造函数，并实例化对象
* @throws Exception
*/
public static void example4() throws Exception{
Class<?> class1 = null;
User user1 = null;
User user2 = null;
class1 = Class.forName("com.hust.reflect.User");//动态加载类
//得到一系列构造函数集合
Constructor<?>[] constructors = class1.getConstructors();
user1 = (User) constructors[0].newInstance();
user2 = (User) constructors[1].newInstance();
user1.setName("black widow");
user2.setName("doctor strange");
System.out.println("例4："+user1.getName()+"-"+user2.getName());
}
/**
* 通过反射操作成员变量
* @throws Exception
*/
public static void example5() throws Exception {
Class<?> class1 = null;
class1 = Class.forName("com.hust.reflect.User");//动态加载类
Object obj = class1.newInstance();
Field userNameField = class1.getDeclaredField("name");
userNameField.setAccessible(true);
userNameField.set(obj,"groot");
System.out.println("例5：获取成员变量并进行设置"+userNameField.get(obj));
}
/**
* 通过反射得到类的一些属性：成员信息、函数信息；当然还可已获得父类、继承的接口等等
* @throws Exception
*/
public static void example6() throws Exception{
Class<?> class1 = null;
class1 = Class.forName("com.hust.reflect.User");//动态加载类
Field[] fields = class1.getDeclaredFields();
for (int i = 0; i <fields.length ; i++) {
System.out.println("成员变量："+fields[i]);
}
Method[] methods = class1.getDeclaredMethods();
for (int i = 0; i < methods.length ; i++) {
System.out.println("取得User类的方法："+"\n"
+"函数名："+methods[i].getName()+"\n"
+"函数返回的类型："+methods[i]+"\n"
+"函数代码写法："+methods[i]);
}
}
/**
* 通过反射机制调用类方法
* @throws Exception
*/
public static void example7() throws Exception{
Class<?> class1 = null;
class1 = Class.forName("com.hust.reflect.User");//动态加载类
System.out.println("调用无参方法toString()");
Method method = class1.getMethod("toString");
method.invoke(class1.newInstance());
}
/**
* 通过反射机制得到类加载信息
* @throws Exception
*/
public static void example8() throws Exception{
Class<?> class1 = null;
class1 = Class.forName("com.hust.reflect.zcl");//动态加载类
String loaderName = class1.getClassLoader().getClass().getName();
System.out.println("例8：类加载类名："+loaderName);
}
}
new 与 newInstance的区别
用newInstance与用new是区别的，区别在于创建对象的方式不一样，前者是使用类加载机制，那么为什么会有两种创建对象方式?这个就要从可伸缩、可扩展，可重用等软件思想上解释了。
Java中工厂模式经常使用newInstance来创建对象，因此从为什么要使用工厂模式上也可以找到具体答案。
案例：
Class c = Class.forName(“A”);factory = (AInterface)c.newInstance();
其中AInterface是A的接口，如果下面这样写，你可能会理解：
String className = “A”;Class c = Class.forName(className);factory = (AInterface)c.newInstance();
进一步，如果下面写，你可能会理解：
String className = readfromXMlConfig;//从xml 配置文件中获得字符串Class c = Class.forName(className);factory = (AInterface)c.newInstance();
上面代码就消灭了A类名称，优点：无论A类怎么变化，上述代码不变，甚至可以更换A的兄弟类B , C , D….等，只要他们继承Ainterface就可以。
从jvm的角度看，我们使用new的时候，这个要new的类可以没有加载；
但是使用newInstance时候，就必须保证：1、这个类已经加载；2、这个类已经连接了。而完成上面两个步骤的正是class的静态方法forName（）方法，这个静态方法调用了启动类加载器（就是加载javaAPI的那个加载器）。
有了上面jvm上的理解，那么我们可以这样说，newInstance实际上是把new这个方式分解为两步,即，首先调用class的加载方法加载某个类，然后实例化。
这样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好的灵活性，提供给了我们降耦的手段。
[补充:]
newInstance: 弱类型。低效率。只能调用无参构造。
new: 强类型。相对高效。能调用任何public构造。
newInstance()是实现IOC、反射、面对接口编程 和 依赖倒置 等技术方法的必然选择，new 只能实现具体类的实例化，不适合于接口编程。
关于上述代码中Class.forName()的具体机制与用法，可以查看这篇博文
