JAVA动态性——反射机制（二：通过反射获取类、操作类的信息）

自定义javabean类代码

package first.reflect;

 

public class Bean {

    private int age;

    private String name;

    private int id;

 

    public Bean() {

 

    }

 

    public Bean(int age, String name, int id) {

        this.age = age;

        this.name = name;

        this.id = id;

    }

 

    public int getAge() {

        return age;

    }

 

    public void setAge(int age) {

        this.age = age;

    }

 

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

 

    public int getId() {

        return id;

    }

 

    public void setId(int id) {

        this.id = id;

    }

}

 通过反射获取类的三种方式：

package first.reflect;

 

public class test {

    public static void main(String[] args) throws ClassNotFoundException {

        String path = "first.reflect.Bean";

 

//方式一，最常用的方式,通过Class类的静态方法forname(字符串的类名)获取

        Class c1 = Class.forName(path);

        System.out.println(c1);

 

        Class<Bean> c2 = (Class<Bean>) Class.forName(path);

        System.out.println(c2);

        System.out.println(c1 == c2);//true

 

//方式二，通过类名获取，包括所有类型（基本数据类型和引用数据类型）

        Class c3 = String.class;

        System.out.println(c3);

 

        Class c4 = int.class;

        System.out.println(c4);

 

//方式三，通过类对象的getClass()方法获取

Bean bean=new Bean();

        Class c5 = bean.getClass();

        System.out.println(c5);

 

        //维数和类型相同数组的类对象相同

        int[] arr01 = new int[10];

        int[][] arr02 = new int[30][3];

        int[] arr03 = new int[30];

        double[] arr04 = new double[10];

        System.out.println(arr01.getClass().hashCode());

        System.out.println(arr02.getClass().hashCode());

        System.out.println(arr03.getClass().hashCode());

        System.out.println(arr04.getClass().hashCode());

    }

}

通过反射获取类的信息 ：

package first.reflect;

 

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

 

public class test02 {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {

        String path = "first.reflect.Bean";

        //获取类

        Class c = Class.forName(path);

 

        //获取类的名字

        System.out.println(c.getName());//包名+类名

        System.out.println(c.getSimpleName());//类名

 

        //获取属性信息

        //获得某个类的所有的public的字段，包括父类中的字段。

        Field[] field = c.getFields();

        System.out.println(field.length);

        //获得某个类的所有声明的字段，即包括public、private和protected，但是不包括父类的申明字段。

        Field[] fields = c.getDeclaredFields();

        for (Field f : fields)

            System.out.println(f);

 

        //获取方法信息

        //获取本类以及父类或者父接口中所有的公共方法

        Method[] method = c.getMethods();

        System.out.println(method.length);

        for (Method m : method)

            System.out.println(m);

        //获取本类中的所有方法,包括私有的(private、protected、默认以及public)的方法。

        Method[] methods = c.getDeclaredMethods();

        System.out.println(methods.length);

        for (Method m : methods)

            System.out.println(m);

        //获取指定方法,第一个参数为方法名，第二个参数为参数类型，没有参数即null

        Method m1 = c.getDeclaredMethod("getName", null);

        Method m2 = c.getDeclaredMethod("setName", String.class);

 

        //获取构造器信息

        //返回指定参数类型访问权限是public的构造器

        Constructor[] constructor = c.getConstructors();

        System.out.println(constructor.length);

        //返回指定参数类型的所有构造器，包括public的和非public的，当然也包括private的

        Constructor[] constructors = c.getConstructors();

        for (Constructor con : constructors)

            System.out.println(con);

        //获取指定构造器,参数为参数类型的类对象，无参则为null

        Constructor constructor1 = c.getConstructor(null);

        System.out.println(constructor1);

        Constructor constructor2 = c.getConstructor(int.class, String.class, int.class);

        System.out.println(constructor2);

    }

}

通过反射操作类的信息 

package first.reflect;

 

import java.lang.reflect.Field;

import java.lang.reflect.Method;

 

public class test03 {

    public static void main(String[] args) throws Exception {

        String path = "first.reflect.Bean";

 

        //获取类

        Class<Bean> c = (Class<Bean>) Class.forName(path);

 

        //通过反射API调用无参构造方法

        Bean bean = c.getDeclaredConstructor().newInstance();

        System.out.println(bean);

        //通过反射API调用有参构造方法

        Bean bean1 = c.getDeclaredConstructor(int.class, String.class, int.class).newInstance(20, "zsr", 2018217876);

        System.out.println(bean1);

        System.out.println(bean1.getAge() + " " + bean1.getName() + " " + bean1.getId());

 

        //通过反射API调用普通方法

        Bean bean2 = c.getDeclaredConstructor().newInstance();

        Method method = c.getDeclaredMethod("setName", String.class);

        method.invoke(bean2, "gcc");

        System.out.println(bean2.getName());

 

        //通过反射API操作属性

        Bean bean3 = c.getDeclaredConstructor().newInstance();

        Field field = c.getDeclaredField("name");

        field.setAccessible(true);//这个属性不需要做安全检查了，可以直接访问

        field.set(bean3, "zsr");//通过反射直接写属性

        System.out.println(bean3.getName()); //通过反射直接读属性的值

        System.out.println(field.get(bean3));

    }

}