类加载器及反射机制(一)-基础

 (1)、java.lang.Class 类表示正在运行的 Java 应用程序中的类和接口。通过getClass()或者静态方法可去取得Class对象。

      如：String str="HelloWorld".

       java.lang. Class strClass=str.getClass()  

      或者(类名.class)//得到类对象。

      或者通过加载器加载

      Class className = Class.forName("java.lang.String");

      得到类对象(类别)后可以有如下方法

      getName()  以字符串返回类对象名称

 

(2)、按需加载方法forName()或ClassLoader类的loadClass()方法

     java.lang.Class bookClass=java.lang.Class.forName("Book"); //Book为一个类

     或者 java.lang.Class bookClass=ClassLoader.loadClass("Book")。

     补充：Class类的信息是在编译的时候就被加入到.class档案中的，执行期间JVM会检查对应的Class对象是否已经加载，如果没有加载，则会寻找对应的.class档案载入。

 

(3)、反射机制

      定义：JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；

      这种动态获取的信息以  及动态调用对象的方法的功能称为java语言的反射机制。注意：动态两字。

     由对象得到类别： java.lang.Class aClass=obj.getClass();

     由类别得到对象属性，（静态和动态的） Field field=aClass.getField(fieldName);

     由属性得到该属性的对象 Object obj=field.get(obj); 

    由类别得到某个方法  

public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
     Object[] args:方法需要的参数数组
     Class ownerClass = aClass.getClass();
 
     Class[] argsClass = new Class[args.length];
 
     for (int i = 0, j = args.length; i < j; i++) {
         argsClass[i] = args[i].getClass();
     }
     //得到这个方法
     Method method = ownerClass.getMethod(methodName, argsClass);
     //执行这个方法 返回值是Object，也既是该方法的返回值。
     return method.invoke(owner, args);

(4) 反射应用：

  动态调用对象的方法

// 实体类
 public class ReflectionDemo {

  public void method1(String str) {
   System.out.println("method1()==>" + "String==>" + str);
  }

  public void method2(String str, int n) {
   System.out.println("method2()==>" + "String==>" + str + "int==>"
     + n);
  }

  public void method3(String str, int n, char ch) {
   System.out.println("method3()==>" + "String==>" + str + "int==>"
     + n + "char==>" + ch);
  }

  public String method4(String str, double n) {
   return str + n;
  }
 }

 

 public class ReflectionDemo {
  
   public void method1(String str){
    System.out.println("method1()==>"+"String==>"+str);
   }
  
   public void method2(String str,int n){
    System.out.println("method2()==>"+"String==>"+str+"int==>"+n);
   }
  
   public void method3(String str,int n,char ch){
    System.out.println("method3()==>"+"String==>"+str+"int==>"+n+"char==>"+ch);
   }
  
   public String method4(String str,double n){
    return str+n;
   }
 }

 

public class InvokeDemo {
    
   //定义方法对象
   private Method method = null;
   //定义方法返回值
   private Object result = null;
  
   private Map hashMap = new HashMap();
  
   //把方法名和对于的参数类型数组封装在hashMap里
   public void initMap(Object obj){
    Class className = obj.getClass();
    Method []methos = className.getMethods();
    for (int i = 0; i<methos.length; i++){
     String name = methos[i].getName();
     Class []args = methos[i].getParameterTypes();
     hashMap.put(name, args);
    }
   }

  

   /**
    *
    * @param obj 执行该方法的具体对象
    * @param methodName 执行的具体对象
    * @param args执行该方法的具体参数
    * @return
    * @throws InvocationTargetException
    * @throws IllegalAccessException
    * @throws IllegalArgumentException
    * @throws NoSuchMethodException
    * @throws SecurityException
    */
   public Object getResultByMethod(Object obj,String methodName,Object[] args){
    Class className = obj.getClass();
    try {
     method = className.getMethod(methodName, (Class[]) hashMap.get(methodName));
     result = method.invoke(obj,args);
    } catch (SecurityException e) {
     e.printStackTrace();
    } catch (NoSuchMethodException e) {
     e.printStackTrace();
    }catch (IllegalArgumentException e) {
     e.printStackTrace();
    } catch (IllegalAccessException e) {
     e.printStackTrace();
    } catch (InvocationTargetException e) {
     e.printStackTrace();
    }
    return result;
   }
  

  

  //测试
   public static void main(String []args){
    InvokeDemo ind = new InvokeDemo();
    ReflectionDemo ref = new ReflectionDemo();
    ind.initMap(ref);
    List<String> list = new ArrayList<String>();
    for (int i = 1; i<=4;i++){
     list.add("method"+i);
    }
    //第一个方法形参数
    Object []realArgs1 = new Object[1];
    realArgs1[0] = "HelloWorld";
    //第二个方法形参数
    Object []realArgs2 = new Object[2];
    realArgs2[0] = "HelloWorld";
    realArgs2[1] = 12;
    //第三个方法形参数
    Object []realArgs3 = new Object[3];
    realArgs3[0] = "HelloWorld";
    realArgs3[1] = 14;
    realArgs3[2] = 'c';
    //第四个方法形参数
    Object []realArgs4 = new Object[2];
    realArgs4[0] = "HelloWorld";
    realArgs4[1] = 23;
   
    Object result = null;
    //调用方法method1
    result = ind.getResultByMethod(ref, list.get(0), realArgs1);
   
    //调用方法method2
    result = ind.getResultByMethod(ref, list.get(1), realArgs2);
   
    //调用方法method3
    result = ind.getResultByMethod(ref, list.get(2), realArgs3);
   
    //调用方法method4
    result = ind.getResultByMethod(ref, list.get(3), realArgs4);
    if (result != null) {
     System.out.println("result:"+result);
    }
   
   }
  }