Java基础再回顾-Java反射

静态加载和动态加载

为了更好地了解Java反射，我们先来理解一下Java的静态加载和动态加载。

静态加载

  package com.howie.testreFlect;

  public class Offcie {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
         //new 创建对象，是静态加载类，编译时刻需要加载所有的可能使用到的类  
      if("Word".equals(args[0])){  
          Word w = new Word();  
          w.start();  
      }  
      if("Excel".equals(args[0])){  
          Excel e = new Excel();  
          e.start();  
      } 
    }
}

静态加载需要在编译时就需要加载所有可能使用到的类，例如上面的例子如果没有对应的类在Eclipse里面就会报错：

Paste_Image.png

动态加载

package com.howie.testreFlect;

public class Offcie02 {
public static void main(String[] args) {
    // TODO Auto-generated method stub
    try{
        //动态加载类，在运行时刻加载  
        Class c = Class.forName("com.howie.testreFlect.Excel");
        //通过类类型，创建该类对象(先转换为Word和Excel的共同接口OfficeAble)  
        OfficeAble oa = (OfficeAble)c.newInstance();  
        oa.start();  
    }catch(Exception e){
        e.printStackTrace();
    }
}
}

动态加载是指在运行时刻加载，跳过编译，不通过new加载类而是其他方式创建类对象。通常伴随着接口和接口实现类进行应用。

什么是Java反射

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
JAVA反射（放射）机制：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。但是JAVA有着一个非常突出的动态相关机制：Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。

JDK为反射机制提供的类

JDK中为Java反射机制提供了几个类，都在lang工具包下。具体属性和方法可以在JDK源码和API进行查询。这里只涉及到我们用到的一些东西。

•   java.lang.Class（获取类类型）               
     通过CLass获取类信息的几种方法
  
        Foo foo1 = new Foo();
        //任何一个类都是Class的实例对象，3种表示方式      
        //1、每个类都有一个隐含的静态成员变量Class
        Class c1 = Foo.class;
        //2、通过该类(副类的类类型)的对象的getClass方法
        Class c2 = foo1.getClass();     
        System.out.println(c1 == c2);   //结果为true
        //3、Class加载
        Class c3 = null;
        try {
        c3 = Class.forName("com.howie.reflect.Foo");
        } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
        }
        System.out.println(c2 == c3);   //true
  

•   java.lang.reflect.Constructor
    Constructor 提供关于类的单个构造方法的信息以及对它的访问权限，用来封装反射得到的构造器。
  
    获取构造器信息
  
        public static void printConMessage(Object obj){
          Class<? extends Object> c = obj.getClass();
          Constructor[] cs = c.getDeclaredConstructors();
          for(Constructor constructor : cs){
             System.out.print(constructor.getName()+"(");
         //获取构造函数的参数列表  参数列表的类类型
         Class[] paramTypes = constructor.getParameterTypes();
         for(Class class1:paramTypes){
            System.out.print(class1.getName()+",");
         }
           System.out.println(")");
         }
         }
  

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

  获取成员变量信息

         public static void getFieldMessage(Object obj){
           Class<? extends Object> c = obj.getClass();
           System.out.println("打印成员变量的信息：");
           System.out.println("类名："+c.getName());
           Field[] fs = c.getDeclaredFields();
           for(Field field:fs){
               //得到成员变量的类型的类类型
               Class fieldType = field.getType();
               String typeName = fieldType.getName();
               //得到成员变量的名称
               String fieldName = field.getName();
               System.out.println(typeName + " "+fieldName);
           }
          }       
  

•   java.lang.reflect.Method
    获取方法信息
  
        public static void printClassMessage(Object obj){
            Class<? extends Object> c = obj.getClass(); //获取类类型
            System.out.println("类名："+c.getName());//获取类名
        /*
         * 万事万物皆对象
         * Method类，方法对象
         * 一个成员方法就是一个Method对象
         * */
          Method[] ms = c.getMethods(); //获取所有的public函数
          c.getDeclaredMethods();   //获取所有该类自己声明的方法
          for(int i=0;i <ms.length;i++){
            //得到方法返回值类型的类类型
            Class returType = ms[i].getReturnType();
            System.out.print(returType.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反射的一些基本机制之后，我们就能够理解为什么在用spring时只需要通过配置文件就可以获得指定方法和变量，就是所说的框架为我们生产对象。