java反射

来源：互联网发布：泰格软件好用吗编辑：程序博客网时间：2024/05/21 21:40

什么是java反射？

　　JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；　　对于任意一个对象，都能够调用它的任意一个方法和属性；　　这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。（from：百度百科）

　　指程序可以访问，检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。
　　
　　简单来说就是，Java可以加载一个运行时才得知名称的class，获得其完整结构。

Class类

　　在面向对象的世界里，万事万物皆对象。
　　那么问题来了，java语言中，静态的成员、普通数据类型类是不是对象呢？类是谁的对象？
　　类是对象，是java.lang.Class类的实例对象。

　　那么这个对象如何表示呢？
　　
　　已知现有Test类：

Class Test{}

获取类的Class对象几种方式：

在知道该类对象的前提下，调用对象的getClass方法

Test t = new Test();Class c1 = t.getClass();

运用类名.class 语法

Class c2 = Test.class;

　　任何一个类都有隐含的静态成员变量。

运用Class类的静态方法 forName(“类的包路径”)

Class c3 = Class.forName("com.test.reflect.Test");

注意：该类是动态加载类。

这里简单的说下什么是动态加载类，前提需要我们区分编译和运行。

编译：把java源文件转换成机器可以识别的二进制语言的文件（eclipse等工具已经实现了对java文件自动编译）。运行：执行经过编译的二进制文件的这个程序。

　　编译时刻加载的类是静态加载类，运行时刻加载的类是动态加载类。其中 c1 == c2 == c3 ，一个类只可能是Class类的一个实例对象。
　　我们也可以通过Class类的对象调用newInstance()方法去获取对象类的实例（前提是对象类要有无参构造方法），方法如下：

Test t = (Test)c1.newInstance();    // 注意newInstance()返回的是Object类对象需强转成Test类。

　　既然类是对象，那基本的数据类型是不是对象呢？
　　
答案是肯定的，下面列举部分：

Class c1 = int.class; //int的类类型（class type）Class c2 = String.class;//String的类类型Class c3 = Double.class;//Double的类类型Class c4 = void.class;// void这个关键字也是有类类型的

Class类的基本API操作

Class c = obj.getClass(); //获取类类型Method[] ms = c.getMethods(); //获取的是所有的public的函数，包括父类继承而来的Method[] ms = c.getDeclaredMethods(); //获取的是所有该类自己声明的方法，不问访问权限Class returnType = ms[i].getReturnType(); //得到方法的返回值类型的类类型Class[] paramTypes = ms[i].getParameterTypes(); //获取参数列表的类型的类类型Field[] fs = c.getFields(); //获取的是所有的public的成员变量的信息Field[] fs = c.getDeclaredFields(); //获取的是该类自己声明的成员变量的信息Class fieldType = fs.get(i).getType(); //得到成员变量的类型的类类型Constructor[] cs = c.getConstructors(); //获取所有的public的构造函数Constructor[] cs = c.getDeclaredConstructors(); //获取所有的构造函数Class[] paramTypes = c.get(i).getParameterTypes(); //获取构造函数的参数列表的类类型

方法的反射

如何获取某个方法
　方法的名称和方法的参数列表才能唯一决定某个方法。
方法反射的操作

method.invoke(对象，参数列表)

举个栗子

package reflect;import java.lang.reflect.Method;public class MethodDemo1 {    public static void main(String[] args) {       //要获取print(int ,int )方法  1.要获取一个方法就是获取类的信息，获取类的信息首先要获取类的类类型        A a1 = new A();        Class c = a1.getClass();        /*         * 2.获取方法 名称和参数列表来决定           * getMethod获取的是public的方法         * getDelcaredMethod自己声明的方法         */        try {            //public Method getMethod(String name, Class<?>... parameterTypes) 第一个参数传方法名称，第二个可变参数传方法的参数类型            //Method m =  c.getMethod("print", new Class[]{int.class,int.class});            Method m = c.getMethod("print", int.class,int.class);            //方法的反射操作              //a1.print(10, 20);方法的反射操作是用m对象来进行方法调用 和a1.print调用的效果完全相同            //方法如果没有返回值返回null,有返回值返回具体的返回值            //Object o = m.invoke(a1,new Object[]{10,20});            Object o = m.invoke(a1, 10,20);            System.out.println("==================");            //获取方法print(String,String)             Method m1 = c.getMethod("print",String.class,String.class);             //用方法进行反射操作             //a1.print("hello", "WORLD");             o = m1.invoke(a1, "hello","WORLD");             System.out.println("===================");           //  Method m2 = c.getMethod("print", new Class[]{});                Method m2 = c.getMethod("print");               // m2.invoke(a1, new Object[]{});                m2.invoke(a1);        } catch (Exception e) {            // TODO Auto-generated catch block            e.printStackTrace();        }     }}class A{    public void print(){        System.out.println("helloworld");    }    public void print(int a,int b){        System.out.println(a+b);    }    public void print(String a,String b){        System.out.println(a.toUpperCase()+","+b.toLowerCase());    }}

　 3. 为什么要用方法的反射

　　好处是可以指定方法名称调用方法。
　　
举个栗子
　　通过标准JavaBean的属性名获取其属性值
　　
BeanUtil类

package reflect;import java.lang.reflect.Method;public class BeanUtil {    /**     * 根据标准javaBean对象的属性名获取其属性值     *      * @param obj     * @param propertyName     * @return     */    public static Object getValueByPropertyName(Object obj, String propertyName) {        // 1.根据属性名称就可以获取其get方法        String getMethodName = "get"                + propertyName.substring(0, 1).toUpperCase()                + propertyName.substring(1);        //2.获取方法对象        Class c = obj.getClass();        try {            //get方法都是public的且无参数            Method m= c.getMethod(getMethodName);            //3 通过方法的反射操作方法            Object value = m.invoke(obj);            return value;        } catch (Exception e) {            e.printStackTrace();            return null;        }    }}

User javabean类

package reflect;//标准的JavaBean类有私有属性都对应有get/set方法，有无参数的构造方法public class User {    private String username;    private String userpass;    private int age;    public User(){}    public User(String username, String userpass, int age) {        super();        this.username = username;        this.userpass = userpass;        this.age = age;    }    public String getUsername() {        return username;    }    public void setUsername(String username) {        this.username = username;    }    public String getUserpass() {        return userpass;    }    public void setUserpass(String userpass) {        this.userpass = userpass;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }}

测试类

package reflect;public class MethodDemo2 {    public static void main(String[] args) {        User user = new User("zhangsan", "123456", 30);        System.out.println(BeanUtil.getValueByPropertyName(user, "username"));            System.out.println(BeanUtil.getValueByPropertyName(user, "userpass"));    }}

　４.通过Class,Method来认识泛型的本质
　

举个栗子package reflect;import java.lang.reflect.Method;import java.util.ArrayList;public class MethodDemo3 {    public static void main(String[] args) {        ArrayList list = new ArrayList();        ArrayList<String> list1 = new ArrayList<String>();        list1.add("hello");        //list1.add(20);错误的        Class c1 = list.getClass();        Class c2 = list1.getClass();        System.out.println(c1 == c2); // true        //反射的操作都是编译之后的操作        /*         * c1==c2结果返回true说明编译之后集合的泛型是去泛型化的         * Java中集合的泛型，是防止错误输入的，只在编译阶段有效，         * 绕过编译就无效了         * 验证：我们可以通过方法的反射来操作，绕过编译         */        try {            Method m = c2.getMethod("add", Object.class);            m.invoke(list1, 20);//绕过编译操作就绕过了泛型            System.out.println(list1.size());            System.out.println(list1);            /*for (String string : list1) {                System.out.println(string);            }*///现在不能这样遍历,会抛异常，类型转换错误        } catch (Exception e) {          e.printStackTrace();        }    }}

　　反射的操作是在编译之后进行的，泛型只是为了在编译期间防止输入错误类型，编译之后就会去泛型化。

0 0