一.反射进阶之动态设置类的私有域
"封装"是Java的三大特性之一，为了能更好保证其封装性，我们往往需要将域设置成私有的，
然后通过提供相对应的set和get方法来操作这个域。但是我们仍然可以用java的反射机制来
修改类的私有域，由于修改类的私有域会破坏Java"封装"的特性，故请慎重操作。
主要技术： Field类提供有关类或接口的单个字段的信息，以及对它的动态访问权限。
访问的字段可能是一个类（静态）字段或实例字段。 常用方法： set(Object obj,Object value)-----: 将指定对象变量上此Field对象表示的字段设置为指定的新值 setBoolean(Object obj,boolean z)-: 将字段使得设置为指定对象上的一个boolean值 setDouble(Object obj,double d)---: 将字段的值设置为指定对象上的一个double值 setInt(Object obj,int i)---------: 将字段的值设置为指定对象上的一个int值 setAccessible(boolean flag)------: 将此对象的accessible标志设置为指定的布尔值 注：对于私有域，外部类调用的时候一定要使用setAccessible()方法将其可见性设置为true才能设置新值， 否则将会抛出异。--支持知识共享，转载请标注地址" "——和佑博客园，谢谢~~--
实例代码：
package com.xhj.reflection_excetion;import java.lang.reflect.Field;/** * 动态修改类的私有域 * * @author XIEHEJUN * */public class DynamicChangePrivate { private String userName; private int userAge; private String userAddress; private boolean userGender; public DynamicChangePrivate(String userName, int userAge, String userAddress, boolean userGender) { super(); this.userName = userName; this.userAge = userAge; this.userAddress = userAddress; this.userGender = userGender; } public DynamicChangePrivate() { super(); } public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } public int getUserAge() { return userAge; } public void setUserAge(int userAge) { this.userAge = userAge; } public String getUserAddress() { return userAddress; } public void setUserAddress(String userAddress) { this.userAddress = userAddress; } public boolean isUserGender() { return userGender; } public void setUserGender(boolean userGender) { this.userGender = userGender; } /** * 根据获得的性别的真假,获取其String值： true--为男 false--为女 * * @param userGender * @return */ public String getGender(boolean userGender) { if (userGender) { return "男"; } else { return "女"; } } public static void main(String[] args) { DynamicChangePrivate user = new DynamicChangePrivate("小黑", 21, "北京路华西小区3单元446", true); Class clazz = user.getClass(); System.out.println("通过反射取得的对象全称为：" + clazz.getName()); try { // 获取要修改的类的字段名称 Field userName = clazz.getDeclaredField("userName"); Field userAge = clazz.getDeclaredField("userAge"); Field userAddress = clazz.getDeclaredField("userAddress"); Field userGender = clazz.getDeclaredField("userGender"); // 修改并输出新旧名称 System.out.print("原名称为：" + user.getUserName()); userName.set(user, "晓晓"); System.out.println("\t\t\t修改后的名称为：" + user.getUserName()); // 修改并输出新旧年龄 System.out.print("原年龄为：" + user.getUserAge()); userAge.set(user, 24); System.out.println("\t\t\t修改后的年龄为：" + user.getUserAge()); // 修改并输出新旧地址 System.out.print("原地址为：" + user.getUserAddress()); userAddress.set(user, "石景山八角南里3单元506"); System.out.println("\t修改后的地址为：" + user.getUserAddress()); // 修改并输出新旧性别 System.out.print("原性别为：" + user.getGender(user.isUserGender())); userGender.set(user, false); System.out.println("\t\t\t修改后的性别为：" + user.getGender(user.isUserGender())); } catch (SecurityException e) { e.printStackTrace(); } catch (NoSuchFieldException e) { e.printStackTrace(); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } }} 结果为：
注：任何类型的域，都可以通过set(Object obj, Object value) 方法将指定对象变量上此 Field 对象表示的字段设置为指定的新值。 但是Field本身也提供了其他类型相对应的set方法，如 setBoolean(Object obj, boolean z)，setDouble(Object obj, double d)
等。另外，通过Field也可以设置public.protected域，但一般情况下很少这么设置，尤其是public域。在这里特别要注意的是：一定
要明确修改的含义，不要轻易的通过反射来修改类的私有域，因为这破坏了java面向对象"封装"的特性。
二、反射进阶之动态调用类的方法
我们知道Java是一种面向对象的语言，对他而言，一切都是对象，因此要调用类的方法，只能通过建立类的对象来调用。当然如果是
静态的方法，那就可以直接通过类本身来调用，而不需要建立类的对象。那么还有没有其他可以调用类方法的方式呢？？
在Java的反射的机制中，提供了比较另类的调用方式，既可以根据需要指定要调用的方法，而不必在编程时确定。调用的方法不仅权限于public
的，还可以是private的。
Method类提供类或接口上单独某个方法（以及如何访问该方法）的信息，所反映的方法可能是类方法或实例方法（包括抽象方法）。它允许在匹配
要调用的实参与底层方法的形参时进行扩展转换，但是如果要进行收缩转换，则会抛出"非法参数异常"--IllegalArgumentExcetion。使用invoke() 可以实现动态调用方法： public Object invoke(Object obj,Object...args)throws IllegalArgumentException,IllegalAccessException,InvocationTargetExcetion obj--要调用的方法的类对象 args--方法调用的参数 注：对于私有域，外部类调用的时候一定要使用setAccessible，并且设置为true。 实例代码：package com.xhj.reflection_excetion;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;/** * 实现动态调用类的方法 * * @author XIEHEJUN * */public class DynamicCallMethod { public static void main(String[] args) { try { // 运行时动态调用Math的abs()静态方法 System.out.println("运行时动态调用Math的abs()静态方法"); Method meth = Math.class.getDeclaredMethod("abs", Integer.TYPE); Integer a = (Integer) meth.invoke(null, new Integer(-1)); System.out.println("-1的绝对值为：" + a); // 运行时动态调用String的非静态方法contains() System.out.println("运行时动态调用String的非静态方法contains()"); Method strMeth = String.class.getDeclaredMethod("contains", CharSequence.class); boolean str = (Boolean) strMeth.invoke(new String("xhjit"), "xhj"); System.out.println("xhjit中是否包含有xhj——" + str); } catch (SecurityException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (NoSuchMethodException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalArgumentException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (InvocationTargetException e) { // TODO Auto-generated catch block e.printStackTrace(); } }} 结果为：
三、反射进阶之动态实例化类
在Java中，要实例化一个类即创建一个类的对象，需要通过构造方法来实现。但是在Java中还可以使用另外一种方式来实现，
那就是通过反射来实例化一个类。
Constructor是Java中提供类的单个构造方法的信息以及访问权限的封装类。 它允许在将实参与带有底层构造方法的形参的newInstance()匹配时进行扩展转换， 但是如果发生收缩转换，则抛出IllegalArgumentExcetion。newInstance()方法可以 使用指定的参数来创建对象： public T newInstance(Object...initargs)throws InstantiationException,IllegalAccessException,IllegalArgumentException,InvocationTargetException initargs: 将作为变量传递给构造方法调用的对象数组。 注：对于私有域，外部类调用的时候一定要使用setAccessible，并且设置为true。
代码实例为：package com.xhj.reflection_excetion;import java.io.File;import java.io.FileOutputStream;import java.io.IOException;import java.io.OutputStream;import java.lang.reflect.Constructor;import java.lang.reflect.InvocationTargetException;/** * 动态实例化类 * * @author XIEHEJUN * */public class DynamiCreateClass { public static void main(String[] args) { // TODO Auto-generated method stub try { // 动态建立一个String对象， Constructor construtor = String.class .getConstructor(String.class); String str = (String) construtor.newInstance("000123"); System.out.println(Integer.parseInt(str)); // 动态建立一个txt文件，并将上面初始化后的String值写入文件的当中 construtor = File.class.getConstructor(String.class); String url = "C:\\Users\\XIEHEJUN\\Desktop\\XHj.txt"; File file = (File) construtor .newInstance(url); file.createNewFile(); if (file.exists()) { str += "---文件创建成功"; System.out.println(str); OutputStream os = new FileOutputStream(url); os.write(str.getBytes()); os.close(); } else { System.out.println("创建文件失败"); } } catch (SecurityException e) { e.printStackTrace(); } catch (NoSuchMethodException e) { e.printStackTrace(); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }} 结果为：
控制台输出
生成的文件：
注：在java中有两种不用new就可以建立类对象的方法，即Class.newInstance()和Constructor.newInstance(); 区别在于： 前者只能调用无参构造方法，而后者却能调用有参构造方法； 且前者需要被调用的构造方法可见，后者则在特定情况下运行调用不可见的构造方法
四、反射进阶之自定义可变数组工具类
在Java中，要创建可变数组可通过ArraryList类来实现。除此之外，我们也可以用自定义的方法来实现可变数组。
这里，我们将使用Java的反射机制实现一个工具类，通过这个工具类，我们就能实现可变数组的创建。
主要技术：
Array类提供了动态创建和访问Java数组的方法。它允许在执行get，set操作期间进行扩展转换，但若发生收缩 转换将抛出IllegalArgumentExcetion。为了创建新的数组对象，需要使用newInstance()方法，它可以根据指定 的元素类型和长度创建新的数组：
public static Object newInstance(Class<?> componentType,int length)throws NegativeArraySizeException
componentType: 表示新数组的组件类型的Class对象 length: 新数组的长度
注:Java 中的数组不管是几维的，都是Object类型的s
代码实例:
可变数组工具类的实现：package com.xhj.reflection_excetion;import java.lang.reflect.Array;/** * 用反射机制实现可变数组工具类 * * @author XIEHEJUN * */public class VariableArrayUtil { /** * 增加的数组长度值 */ private int addLength; /** * 需要增加长度的原数组 */ private Object array; public int getaddLength() { return addLength; } public Object getArray() { return array; } /** * 可变数组初始化 * @param addLength 需要增加的数组的长度 * @param array 需要增加长度的原数组 */ public VariableArrayUtil(int addLength, Object array) { super(); this.addLength = addLength; this.array = array; } /** * 可变数组的实现 * * @return */ public Object newArrary() { Class clazz = array.getClass(); if (clazz.isArray()) { Class type = clazz.getComponentType(); int length = Array.getLength(array); Object new_Array = Array.newInstance(type, length + addLength); System.arraycopy(array, 0, new_Array, 0, length); return new_Array; } return null; }} 测试类：
package com.xhj.test;import com.xhj.reflection_excetion.VariableArrayUtil;/** * 可变数组工具类的测试类 * * @author XIEHEJUN * */public class Test { public static void main(String[] args) { int[] a = new int[10]; System.out.println("原数组为:"); for (int i = 0; i < 10; i++) { a[i] = i; System.out.print(" " + a[i]); } System.out.println("\n数组长度为：" + a.length); VariableArrayUtil util = new VariableArrayUtil(5, (Object) a); int[] b = (int[]) util.newArrary(); System.out .println("==================================================\n" + "更改后的数组长度为：" + b.length); for (int i = 10; i < 15; i++) { b[i] = i; } System.out.println("更改后的数组为:"); for (int i : b) { System.out.print(" " + i); } } } 结果为：
五、反射进阶之重写toString方法
为了方便输出对象，在Object中定义了toString的方法，其默认值由类名和哈希码组成。但是很多时候，为了能更好的满足我们的需求，
我们都是需要重写这个方法的。下面我们将利用Java的反射机制，重写这个方法，并输出类的相关信息。
代码实例：
package com.xhj.reflection_excetion;import java.lang.reflect.Constructor;import java.lang.reflect.Field;import java.lang.reflect.Method;import java.lang.reflect.Type;/** * 利用反射重写Object的toString方法 * * @author XIEHEJUN * */public class RewriteToString { public String toString(Object obj) { Class clazz = obj.getClass(); // 建立一个容器用来存储类的信息 StringBuilder strBuilder = new StringBuilder(); strBuilder.append("以下是类的信息："); // 类名 String className = clazz.getSimpleName(); // 包名 Package packageName = clazz.getPackage(); // 公共构造方法 Constructor [] constructors = clazz.getConstructors(); // 公共域 Field[] fields = clazz.getFields(); // 接口 Type[] interfaces = clazz.getInterfaces(); // 公共方法 Method[] methods = clazz.getMethods(); strBuilder.append("\n此类的简单名称为--" + className); strBuilder.append("\n此类的包名为--" + packageName); strBuilder.append("\n此类的公共构造方法有："); if (constructors.length > 0) { for (Constructor constructor : constructors) { strBuilder.append("\n\t" + constructor); } } else { strBuilder.append("空"); } strBuilder.append("\n此类的公共域有："); if (fields.length > 0) { for (Field field : fields) { strBuilder.append("\n\t" + field); } } else { strBuilder.append("空"); } strBuilder.append("\n此类的接口有："); if (fields.length > 0) { for (Type type : interfaces) { strBuilder.append("\n\t" + type); } } else { strBuilder.append("空"); } strBuilder.append("\n此类的公共方法有："); if (methods.length > 0) { for (Method method : methods) { strBuilder.append("\n\t" + method); } } else { strBuilder.append("空"); } return strBuilder.toString(); } public static void main(String[] args) { RewriteToString rts = new RewriteToString(); System.out.println(rts.toString(new StringBuilder())); }} 结果为：
注：在实际开发当中，一般而言都是需要重写toString方法的，为了更好的开发，可使用Commons Lang 组件提供的工具类来重写此方法。
六、反射进阶之动态代理
代理是Java中很重要的一个特性，使用代理可以在程序运行时创建一个实现指定接口的新类。一般而言，我们只有在程序编译时
无法确定需要使用哪些接口时才会使用代理机制。代理更多的是用在系统的开发上，它可以为工具类提供更加灵活的特性。
InvocationHandle 接口是代理实例的调用处理程序实现的接口。每个代理实例都具有一个关联的调用处理程序。
对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的invoke()方法：
Object invoke(Object proxy,Method method,Object[]args)throws Throwable proxy:代理类 method: 代理实例上要被调用的方法 args: 代理实例上方法调用的参数数组
Proxy接口提供了用于创建动态代理类和实例的静态方法，它是所有动态代理类的父类。
获得一个指定接口的代理类实例： public static Object newProxyInstance(ClassLoader loader,Class<?> [] interfaces,InvocationHandle h)throws IllegalArgumentException loader:定义代理类的类加载器 interfaces:代理类要实现的接口列表 h:指派方法调用的代理处理程序
代码实例：
接口：
package com.xhj.reflection_excetion.dynamicProxy.bean;/** * 代理类和被代理类的共同接口 * * @author XIEHEJUN * */public interface DoBusiness { /** * 商品交易方式 */ public void trading();} 被代理类：
package com.xhj.reflection_excetion.dynamicProxy.service;import com.xhj.reflection_excetion.dynamicProxy.bean.DoBusiness;/** * 被代理类--厂家 * * @author XIEHEJUN * */public class Product implements DoBusiness { @Override public void trading() { System.out.println("厂家直销"); }} 代理处理器：
package com.xhj.reflection_excetion.dynamicProxy.proxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;/** * 代理处理器--商家代理 * * @author XIEHEJUN * */public class DynamicProxy implements InvocationHandler { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("商家代理定点销售"); return null; }} 测试类：
package com.xhj.reflection_excetion.dynamicProxy;import java.lang.reflect.Proxy;import com.xhj.reflection_excetion.dynamicProxy.bean.DoBusiness;import com.xhj.reflection_excetion.dynamicProxy.proxy.DynamicProxy;import com.xhj.reflection_excetion.dynamicProxy.service.Product;public class Test { public static void main(String[] args) { DoBusiness p = new Product(); System.out.print("没有启用代理模式---"); p.trading(); ClassLoader loader = p.getClass().getClassLoader(); p = (DoBusiness) Proxy.newProxyInstance(loader, Product.class.getInterfaces(), new DynamicProxy()); System.out.print("启用动态代理模式---"); p.trading(); }｝ 结果为：
注： java动态代理类位于java.lang.reflect包下，一般主要涉及到以下两个类：
Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method, Object[] args)。 在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的trading()，
args为该方法的参数数组。这个抽象方法在代理类（代理处理类）中动态实现。 Proxy：该类即为动态代理类。 Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)： 返回代理类的一个实例，返回后的代理类可以当作被代理类使用 (可使用被代理类的在接口中声明过的方法)。
总结：
动态代理类是一个实现在创建类并运行时指定接口列表的类， 1.代理接口是代理类所实现的一个接口。 2.代理实例是代理类的一个实例。 3.每一个代理实例都有一个关联的调用处理程序对象，它可以实现接口InvocationHandler。 4.通过调用代理处理器中的Invoke方法实现代理，并传递代理实例，识别调用方法以及方法上的参数数组。 5.调用对象加载器以及代理处理器中的方法，并以代理实例为结果返回。