Java反射机制

我们定义的类和接口在Java应用程序中是Class的具体类。
每个数组也属于Class对象的一个类，所有具有相同元素类型和维数的数组都共享Class对象。

三种方法得到字节码

package com.company.反射与内省.ForName初始化类;

/**
 * Created by jason on 2017/12/8.
 * java团长 https://mp.weixin.qq.com/s/2a80YJGGBe4wjUp5reCZlw
 */
public class Run {
    public static void main(String[] args) {
        try {
            Class clazz = Class.forName("com.company.反射与内省.ForName初始化类.test");
            System.out.println(clazz.toString());
            test t = new test();
            Class aClass = t.getClass();
            System.out.println(aClass.toString());
            Class clazz1 = test.class;
            System.out.println(clazz1.toString());

            int[] a = new int[4];
            Class<? extends int[]> aClass1 = a.getClass();
            int[] b = new int[4];
            Class<? extends int[]> aClass2 = b.getClass();
            System.out.println(aClass1.toString());
            System.out.println(aClass2.toString());
            System.out.println(aClass1 == aClass2);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

其中test是同一个包中的类

public class test {
    private static int a = 3;
    static {
        System.out.println(a);
    }
}

输出结果，第一次调用Class.forName()的时候会初始化test类，static代码块会执行

3
class com.company.反射与内省.ForName初始化类.test
class com.company.反射与内省.ForName初始化类.test
class com.company.反射与内省.ForName初始化类.test
class [I
class [I
true

推荐用Class.forName() 若存在则加载，否则新建,往往使用第三种,类的名字在写源程序时不需要知道，到运行时再传递过来

通过Class类可以得到构造方法，属性，方法等。declaredMethods[i].invoke(dog)可以执行方法，constructor.newInstance可以执行构造函数，返回一个具体的Dog类。

//通过Class对象实例化，调用了默认无参的构造方法

Dog dog = constructor.newInstance("小白", 5, "白");

相当于 Dog dog = new Dog()

package com.company.反射与内省;

import org.junit.Test;

import java.lang.reflect.*;


/**
 * Created by Administrator on 2017/11/21 0021.
 */
public class ReflectionDemo {


    @Test
    public void test5(){
        Dog dog = new Dog("wnafy",4, "yo");
        Class<Dog> dogClass = Dog.class;
        //获取类的包名
        Package aPackage = dogClass.getPackage();
        System.out.println(aPackage.getName());

        //访问非私方法，包括父类
        Method[] methods = dogClass.getMethods();
        for (int i = 0; i < methods.length; i++) {
            System.out.println(methods[i]);
            if (methods[i].getName().equals("toString")){
                try {
                    String s =(String)methods[i].invoke(dog);
                    System.out.println(s);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("-------------------------------");
        //访问私有方法,获取到分类中定义的所有方法，不包括父类
        Method[] declaredMethods = dogClass.getDeclaredMethods();
        for (int i = 0; i <declaredMethods.length ; i++) {
            System.out.println(declaredMethods[i]);
            if(declaredMethods[i].getName().equals("set")){
                declaredMethods[i].setAccessible(true); //设置私有方法可以被访问（去除访问修饰符的检查
                try {
                    declaredMethods[i].invoke(dog);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void test4(){
        Class<Dog> dogClass = Dog.class;
        //获取非私有属性
        Field[] fields = dogClass.getFields();
        System.out.println(fields.length);

        Field[] declaredFields = dogClass.getDeclaredFields();
        System.out.println(declaredFields.length);

        for (int i = 0; i < declaredFields.length; i++) {
            int modifiers = declaredFields[i].getModifiers(); //获得修饰符
            System.out.println(Modifier.toString(modifiers) + " " + declaredFields[i].getName());
        }

    }


    //获取所有构造方法
    @Test
    public void test3(){
        Class<Dog> dogClass = Dog.class;
        Constructor<?>[] constructors = dogClass.getConstructors();
        for (int i = 0; i < constructors.length; i++) {
            System.out.println(constructors[i].getName());
            System.out.println(constructors[i].getParameterCount());
        }
        //获取一个指定的构造方法
        try {
            Constructor<Dog> constructor = dogClass.getConstructor(String.class, int.class, String.class);
            //调用带参数的构造器来实例化对象
            Dog dog = constructor.newInstance("小白", 5, "白");
            System.out.println(dog.toString());
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }


    }

    @Test
    public void test2(){
        Class<Dog> dogClass = Dog.class;
        try {
            //通过Class对象实例化，调用了默认无参的构造方法
            Dog dog = (Dog) dogClass.newInstance();
            System.out.println(dog.toString());
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

    }


    //获取Class对象的三种形式
    @Test
    public void test1(){
        //通过对象的getClass方法
        Dog dog = new Dog("wangwang",4, "白色");
        Class aClass = dog.getClass();

        //通过类.class
        Class dogclass = Dog.class;

        try {
           Class aclass1 = Class.forName("com.company.反射与内省.Dog");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

}

Dog类

package com.company.反射与内省;

/**
 * Created by Administrator on 2017/11/21 0021.
 */
public class Dog {
    private String name;
    private int age;
    private String color;

    private void set(){
        System.out.println("yo haha");
    }
    private int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }

    public Dog(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    public Dog() {
    }
}

经典例题
https://mp.weixin.qq.com/s/2a80YJGGBe4wjUp5reCZlw
1.将所有String类型的成员变量里的b改成a。

package com.company.反射与内省.Java团长.典型例题.将所有String类型的成员变量里的b改成a;

import java.lang.reflect.Field;

/**
 * Created by Administrator on 2018/6/25 0025.
 */
public class TestReflect {
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {
        ReflectPointer rp1 = new ReflectPointer(3,"bbc");
        changeBtoA(rp1);
        System.out.println(rp1);
    }

    private static void changeBtoA(Object obj) throws RuntimeException, Exception {
        Field[] fields = obj.getClass().getFields();
        for(Field field : fields) {
            //if(field.getType().equals(String.class))
            //由于字节码只有一份,用equals语义不准确
            if(field.getType()==String.class) {
                System.out.println(field.getType().toString());
                String oldValue = (String)field.get(obj);
                String newValue = oldValue.replace('b', 'a');
                field.set(obj,newValue);
            }
        }
    }
}


class ReflectPointer {
    private int x = 0;
    public String y = "bbcc";
    public String str1 = "ball";
    public String str2 = "basketball";
    public String str3 = "itcat";
    public ReflectPointer(int x,String y) {//alt + shift +s相当于右键source
        super();
        // TODO Auto-generated constructor stub
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "ReflectPointer [y=" + y + ", str1=" + str1 + ", str2=" + str2 + ", str3=" + str3 + "]";
    }

}

2.写一个程序根据用户提供的类名，调用该类的里的main方法。

package com.company.反射与内省.Java团长.典型例题.根据用户提供的类名调用该类的里的main方法;

import java.lang.reflect.Method;

/**
 * Created by Administrator on 2018/6/25 0025.
 */
public class TestReflection {
    public static void main(String[] args) throws Exception {
        String str = args[0];
        /*
         * 这样会数组角标越界，因为压根没有这个字符数组
         * 需要右键在run as-configurations-arguments里输入b.Inter（完整类名）
         */
        Method m = Class.forName(str).getMethod("main",String[].class);
        //下面这两种方式都可以,main方法需要一个参数
        m.invoke(null, new Object[]{new String[]{"111","222","333"}});
        m.invoke(null, (Object)new String[]{"111","222","333"});//这个可以说明，数组也是Object
        /*
         * m.invoke(null, new String[]{"111","222","333"})
         * 上面的不可以,因为java会自动拆包
         */
    }

}

Inter类如下：

package com.company.反射与内省.Java团长.典型例题.根据用户提供的类名调用该类的里的main方法;

/**
 * Created by Administrator on 2018/6/25 0025.
 */
public class Inter {
    public static void main(String[] args) {
        for(Object obj : args) {
            System.out.println(obj);
        }

    }
}