Java反射

Java反射

类有类类型

• 首先，记住一句话：There is a class named Class

public class ClassDemo1{
    public static void main(String[] args) {
        Foo foo1 = new Foo();
    }
}
class Foo{}

• 看上面这段代码：我们称Foo为一个类，由于在面向对象的世界里，万事万物皆对象，所以这个类也有类型，那么如何表示这个类的类型呐？有三种方式

  1. Class c1 = Foo.class;c1就是Foo类的类类型。这个语句也可以告诉我们，每一个类中都有一个隐含的静态成员变量class
  2. Class c2 = foo1.getClass(); c2也是Foo类的类类型。这是通过已知类对象来获得类的类类型。
  3. Class c3 = Class.forName("Foo"); c3同样表示Foo类的类类型。并且c1==c2 && c2==c3，因为c1 c2 c3 都代表了一个类的类类型。一个类只可能是Class类的一个实例对象。

• 我们还可以通过类的类类型创建该类的实例：c1.newInstance();注意这里的返回值是Object类型，所有要强制转化为该类的真实类型。另外：通过这种方式创建该类的实例必须保证该类有无参数的构造方法。

动态加载类

• 首先我们来区分下什么是动态加载类，什么是静态加载类。动态加载类是指编译时刻加载的类，动态加载类是指在运行时刻加载的类。

public class Office{
    public static void main(String[] args) {
        if("Word".equals(args[0])){
            Word word = new Word();
            word.start();
        }
        if("Excel".equals(args[0]){
            Excel excel = new Excel();
            excel.start();
        }
    }
}

• 如果编译上面这段代码，必然会编译错误。因为我们没有定义Word和Excel这两个类。如果我们去定义了Word类，不去定义Excel类，程序编译依然会报错。这是因为用new创建对象是静态加载类，在编译时刻就要加载所有可能使用到的类。 这样说明：即使我们只想要运行word也不能运行这个程序Office。那么如何才能通过动态加载类来解决这个问题呐？？

public class OfficeBetter{
    public static void main(String[] args) {
        try{
            //在运行时刻动态加载类
            Class c = Class.forName(args[0]);
            OfficeAble oa = (OfficeAble)c.newInstance();
            oa.start();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

public class Word implements OfficeAble{
    @override
    public void start(){
        System.out.println("Word started!");
    }
}

interface OfficeAble{
    public void start();
}

• 现在我们更新了Office类的代码为OfficeBetter并编写了一个接口和一个实现类，这是我们编译OfficeBetter类并不会出现编译错误。我们输入命令java OfficeBetter Word就可以运行word了，是不是变的更加方便了呐。
• 当我们需要运行新的Office软件的时候只需要编写新的OfficeAble的实现类，不需要修改或者重新编译OfficeBetter。
• 功能性的类我们最好使用动态加载而不是静态加载，这样便于以后的升级和维护。

通过反射获取方法信息

• 并不是只有类才有类类型，所有在类中出现的关键字都有自己的类类型。看下面的代码：

public class ClassDemo2{
    public static void main(String[] args) {
        Class c1 = int.class;   //int类类型
        Class c2 = Integer.class;   //Integer类类型
        System.out.println(c1==c2); //false

        Class c3 = String.class; //String的类类型
        Class c4 = void.class; //只要在类里面声明的，都有相应的类类型

        System.out.println(c1.getName());       //int
        System.out.println(c2.getName());       //java.lang.Integer
        System.out.println(c2.getSimpleName()); //Integer
        System.out.println(c4.getName());       //void


    }
}

• 下面我们来编写一个通过反射来获取类的方法信息的静态方法，通过下面这个类你可以了解有关获取类的方法信息的一些基本操作

/**
 * Created by Chang on 15/12/28.
 */
public class ClassUtil{
    /**
     * 打印类的信息，包括类的成员函数、成员变量
     * @param obj
     */
    public static void printClassMessage(Object obj){
        //首先要获取类的类类型
        Class c = obj.getClass(); // 传递的是那个子类的对象，c就是该子类的类类型
        //获取类的名称
        System.out.println("类的名称是："+c.getName());

        /*
        * Method类，对象方法
        * 一个成员方法就是一个Method对象
        * getMethods() 方法获取的是所有的public的函数，包括父类继承而来的
        * getDeclaredMethods() 获取的是所有该类自己声明的的方法，不问访问权限，不包括父类继承的方法
        */
        Method[] ms = c.getMethods();
        for(int i=0; i<ms.length; i++){
            //得到方法的返回值类型的类类型
            Class returnType = ms[i].getReturnType();
            System.out.print(returnType.getName()+" ");
            //得到方法的名称
            System.out.print(ms[i].getName()+"(");
            //获取参数类型--->得到的是参数列表类型的类类型
            Class[] paramTypes = ms[i].getParameterTypes();
            for(Class class1:paramTypes){
                System.out.print(class1.getName()+",");
            }
            System.out.println(")");

        }
    }
}

获取成员变量和构造函数信息

• 获取成员变量信息

  • 成员变量也是对象,是java.lang.reflect.Field的对象
  • Field类封装了关于成员变量的操作
  • getFields()方法获取的所有的public的成员变量信息
  • getDeclaredField()方法获取的是所有该类自己声明的成员变量的信息

   Field[] fields = c.getFields();
  for(Field field:fields){
      //得到成员变量的类型的类类型
      Class fieldType = field.getType();
      String typeName = fieldType.getTypeName();
      //得到成员变量的名称
      String fieldName = field.getName();
      System.out.println(typeName+" "+fieldName);  
 }

• 获取构造方法

  • 构造函数也是对象 java.lang.Constructor
  • getConstructors()方法获取所有的public的构造函数
  • getDeclaredConstructors()方法获取所有的(该类的)构造方法

     public static void printConMessage(Object object){
        Class c = object.getClass();

        Constructor[] constructors = c.getConstructors();
        for (Constructor constructor:
             constructors) {
            System.out.print(constructor.getName()+"(");
            //获取构造函数的参数列表
            Class[] paramTypes = constructor.getParameterTypes();
            for (Class class1:
            paramTypes){
                System.out.print(class1.getName()+",");
            }
            System.out.println(")");

        }
    }

• 还有更多关于Class类的方法，可以查看相关API

方法的反射操作

• 如何获取某个方法：方法的名称和方法的参数列表才能唯一决定某个方法
• 方法反射的操作：method.invoke(对象，参数列表)

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * Created by Chang on 15/12/29.
 */
public class MethodDemo1 {
    public static void main(String[] args) {
        //1.要获取print(int,int)方法
        A a1 = new A();
        Class c = a1.getClass();
        //2. 获取方法 名称和参数列表来决定
        try {
//          Method method = c.getMethod("print",new Class[]{int.class, int.class});
            Method method = c.getMethod("print",int.class,int.class);

            //方法的反射操作,方法如果没有返回值object为null,如果有返回值就返回相应的值(需要强制转换)
            Object object = method.invoke(a1,1,2);

            System.out.println("=====================");
            Method method1 = c.getMethod("print",String.class,String.class);
            method1.invoke(a1,"a","a");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

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

通过反射机制了解集合范型的本质

• 泛型在编译之后是去泛型化的，可以通过方法的反射来添加不同的类型

**
 * Created by Chang on 15/12/29.
 */
public class MethodDemo4 {
    public static void main(String[] args) {
        ArrayList list  = new ArrayList();

        ArrayList<String> list1 = new ArrayList<>();

        Class c1 = list.getClass();
        Class c2 = list.getClass();
        list1.add("Hello");
        //list1.add(1);     //会报错
        //反射操作是编译之后的操作
        System.out.println(c1==c2);//True

        /**
         * c1==c2为真,说明编译之后的集合的泛型是去泛型化的
         * Java中集合的类型,是防止输入错误的,只在编译阶段有效,绕过编译就无效了
         * 可以通过方法的反射来操作
         */

        try {
            Method m = c1.getMethod("add",Object.class);
            m.invoke(list1,10);
            System.out.println(list1.size());
            //通过反射操作就绕过了泛型,可是这样不能通过指定类型的foreach遍历
            System.out.println(list1);

            //因为其中有一个类型不是String会有错误
//            for (String s:
//                 list1) {
//                System.out.println(s);
//            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

    }


}