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

如：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);
    }
    
   }
  }