java反射

什么是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(); //获取构造函数的参数列表的类类型

方法的反射

1. 如何获取某个方法

   　方法的名称和方法的参数列表才能唯一决定某个方法。

2. 方法反射的操作

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();
        }
    }

}

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