关于Java反射你了解多少

今天任然是第二次看张老师的高新技术基础

今天，我看了反射，觉得这个很好，可以在很多地方用到

如替换一篇文章中的敏感词汇，制作框架等等都会有用到反射，

反射很强大

下面是一个实例，各位友友可以Copy运行从中学习反射的相关知识

如有不懂，留言，我会有相关答复！！

package im.fldy;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;

public class Reflection {

    public static void main(String[] args) throws ClassNotFoundException,
            SecurityException, NoSuchMethodException, IllegalArgumentException,
            InstantiationException, IllegalAccessException,
            InvocationTargetException, NoSuchFieldException {
        // Class 代表内存中的一份字节码
        /**
         * 得到字节码 类名.classs 如：System.class; 对象.getClass
         * Class.forName("类名")；如：Class.forName("java.util.Date");
         * 其实每一个类在内存中就是以字节码的形式存在！ 以下是得到字节码的三种方法！
         */
        String str = "abc";
        Class cls1 = str.getClass();
        Class cls2 = String.class;
        Class cls3 = Class.forName("java.lang.String");

        System.out.println(cls1 == cls2);
        System.out.println(cls3 == cls2);

        System.out.println(cls1.isPrimitive());// 字节码是否为基本类型的判断
        System.out.println(int.class.isPrimitive());

        System.out.println(int.class == Integer.class);
        System.out.println(int.class == Integer.TYPE);

        System.out.println(int[].class.isArray());// 判断是否为数组

        // 得到构造方法 ； 然后再把具体的对象穿给它，我们就可以得到具体对象的构造方法！！
        Constructor constructor = String.class
                .getConstructor(StringBuffer.class);
        String str2 = (String) constructor.newInstance(new StringBuffer("abc"));
        System.out.println(str2.charAt(2));// 用反射的到字符串的查找方法，并输出查找结果

        // 本来你要我去买可乐给你喝，因为每天都要，多以我直接进一批可乐每天卖给你，清爽！
        // 无参构造方法的实现
        ReflectionPoint pt1 = new ReflectionPoint(3, 5);
        Field fieldy = pt1.getClass().getField("y");// 得到可见的变量
        System.out.println(fieldy.get(pt1));
        // 得到私有变量
        Field fieldx = pt1.getClass().getDeclaredField("x");// 得到可见的变量
        fieldx.setAccessible(true);// 允许访问私有属性！也叫暴力反射
        System.out.println(fieldx.get(pt1));

        // 改变字符串，例如我面的是实例，就是对于一些不良言语我们可以使其用*号显示，这个在很多网页上我们都遇见过
        // 相信大家不会陌生
        changeStringValue(pt1);
        System.out.println(pt1);

        Method methodCharAt = String.class.getMethod("charAt", int.class);
        System.out.println("取出第二个字符" + methodCharAt.invoke(str, 1));

        // 一般调用main方法
        Test.main(new String[] { "asd", "qwe", "sdf" });
        // 用反射调用main方法
        String startingClassName = "im.fldy.Test";
        Method mainMethod = Class.forName(startingClassName).getMethod("main",
                String[].class);
        mainMethod.invoke(null, (Object) new String[] { "asd", "qwe", "sdf" });

        int[] a1 = new int[] { 1, 2, 34, 5, 5 };
        int[] a2 = new int[4];
        int[][] a3 = new int[2][1];
        String[] a4 = new String[] { "q", "ssda", "asd" };
        System.out.println(a1.getClass() == a2.getClass());
        System.out.println(a1.getClass().getName());// [I 整型数组名
        System.out.println(a3.getClass().getName());// [[I 字符数组名
        System.out.println(a1.getClass().getSuperclass().getName());
        System.out.println(a3.getClass().getSuperclass().getName());

        // 下面是检查是否可以直接打印集合中的元素结果发现Int[]数组中的元素不能直接遍历
        System.out.println(a1);
        System.out.println(a4);
        System.out.println(Arrays.asList(a1));
        System.out.println(Arrays.asList(a4));

        // 打印数组中的所有元素
        printObject(a1);
        printObject(a4);
    }

    // 对于Int数组不能直接打印其中的元素，我们可以采用下面的办法
    // 用反射的原理先判断传入的对象是不是数组，这样我们就可以同时遍历Int[]和String[]了
    private static void printObject(Object obj) {
        // TODO Auto-generated method stub
        Class claz = obj.getClass();
        if (claz.isArray()) {
            int len = Array.getLength(obj);
            for (int i = 0; i < len; i++) {
                System.out.println(Array.get(obj, i));
            }
        } else {
            System.out.println(obj);
        }
    }

    /**
     * 本方法利用反射的原理对传进去的ReflectionPoint类中的String字符串变量进行替换 如一些非法字符，不良言语等等替换
     */

    private static void changeStringValue(Object obj)
            throws IllegalArgumentException, IllegalAccessException {
        Field[] fields = obj.getClass().getFields();
        for (Field field : fields) {
            if (field.getType() == String.class) {
                String oldValue = (String) field.get(obj);
                String newValue = oldValue.replace('操', '*');
                field.set(obj, newValue);
            }
        }
    }

    public static class ReflectionPoint {
        private int x;
        public int y;
        public String s = "小日本我操你";
        public String sb = "广播体操";
        public String sbc = "操作系统";

        public ReflectionPoint(int x, int y) {
            super();
            this.x = x;
            this.y = y;
        }

        @Override
        public String toString() {
            return "1：" + s + "2：" + sb + "3：" + sbc + "";

        }
    }

}

class Test {
    public static void main(String[] args) {
        for (String arg : args) {
            System.out.println(arg);
        }
    }
}