【框架基础】：Java反射机制详解(三)

最爱小坏

于 2016-12-08 16:48:28 发布

阅读量212

点赞数

分类专栏： java基础

java基础专栏收录该内容

39 篇文章 0 订阅

订阅专栏

通过上篇文章了解了一些相关的反射机制API，那么我们可以来看一些简单的例子。将获取类的成员变量信息、

获取类的成员函数信息以及获取类的构造函数信息的方法封装在一个叫作ClassUtil类中：

[java]view plaincopy 
   
print?
 package com.demo.reflect;  
   
 import java.lang.reflect.Constructor;  
 import java.lang.reflect.Field;  
 import java.lang.reflect.Method;  
   
 public class ClassUtil {  
       
      /** 
      * 获取类的成员变量信息 
      * @param obj 
      */  
     public static void printFieldMessage(Object object) {  
         Class<?> clazz = object.getClass();  
           
         /* 
          * 成员变量也是对象 
          * java.lang.reflect.Field 
          * Field类封装了关于成员变量的操作 
          * getFields()方法获取的是所有的public的成员变量的信息 
          * getDeclaredFields获取的是该类自己声明的成员变量的信息 
          */  
           
         //Field[] fs = c.getFields();  
         Field[] fields = clazz.getDeclaredFields();  
         for (Field field : fields) {  
             //得到成员变量的类型的类类型  
             Class<?> fieldType = field.getType();  
             String typeName = fieldType.getName();  
             //得到成员变量的名称  
             String fieldName = field.getName();  
             System.out.println(typeName+" "+fieldName);  
         }  
     }  
       
     /** 
      * 获取类的构造函数信息 
      * @param obj 
      */  
     public static void printConMessage(Object object){  
         Class<?> clazz = object.getClass();  
           
         /* 
          * 构造函数也是对象 
          * java.lang. Constructor中封装了构造函数的信息 
          * getConstructors获取所有的public的构造函数 
          * getDeclaredConstructors得到所有的构造函数 
          */  
         //Constructor[] cs = c.getConstructors();  
         Constructor<?>[] constructors= clazz.getDeclaredConstructors();  
           
         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(")");  
         }  
    }  
       
     /** 
      * 获取类的成员函数信息 
      * @param obj  
      */  
     public static void printClassMethodMessage(Object object){  
         //要获取类的信息就要首先要获取类的类类型  
         Class<?> clazz = object.getClass();//传递的是哪个子类的对象  c就是该子类的类类型  
         //获取类的名称  
         System.out.println("类的名称是:"+clazz.getName());  
           
         /* 
          * Method类，方法对象 
          * 一个成员方法就是一个Method对象 
          * getMethods()方法获取的是所有的public的函数，包括父类继承而来的 
          * getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问权限 
          */  
         Method[] methods = clazz.getMethods();//c.getDeclaredMethods()  
           
         for(int i = 0; i < methods.length;i++){  
             //得到方法的返回值类型的类类型  
             Class<?> returnType = methods[i].getReturnType();  
             System.out.print(returnType.getName()+" ");  
             //得到方法的名称  
             System.out.print(methods[i].getName()+"(");  
             //获取参数类型--->得到的是参数列表的类型的类类型  
             Class<?>[] paramTypes = methods[i].getParameterTypes();  
             for (Class<?> class1 : paramTypes) {  
                 System.out.print(class1.getName()+",");  
             }  
             System.out.println(")");  
         }  
     }  
       
 }  

获取类的成员变量信息：

[java]view plaincopy 
   
print?
 package com.demo.reflect;  
   
 public class ClassDemo4 {  
 <span style="white-space:pre">  </span>public static void main(String[] args) {  
 <span style="white-space:pre">      </span>ClassUtil.printFieldMessage("hello");  
 <span style="white-space:pre">      </span>  
 <span style="white-space:pre">      </span>System.out.println("=============");  
 <span style="white-space:pre">      </span>ClassUtil.printFieldMessage(new Integer(1));  
 <span style="white-space:pre">  </span>}  
   
 }  

运行结果：

获取类的构造函数信息：

[java]view plaincopy 
   
print?
 package com.demo.reflect;  
   
 public class ClassDemo5 {  
     public static void main(String[] args) {  
         ClassUtil.printConMessage("hello");  
           
         System.out.println("=============");  
         ClassUtil.printConMessage(new Integer(1));  
     }  
   
 }  

运行结果：

获取类的成员函数信息：

[java]view plaincopy 
   
print?
 package com.demo.reflect;  
   
 public class ClassDemo3 {  
     public static void main(String[] args) {  
         String s = "hello";  
         ClassUtil.printClassMethodMessage(s);  
           
         System.out.println("=============");  
         Integer n1 = 1;  
         ClassUtil.printClassMethodMessage(n1);  
     }  
   
 }  

运行结果：

下面来介绍通过反射来操作方法的实例：

[java]view plaincopy 
   
print?
 package com.demo.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 {  
             //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) {  
             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());  
     }  
       
 }  

运行结果：

接着再来通过反射认识泛型的本质：

[java]view plaincopy 
   
print?
 package com.demo.reflect;  
   
 import java.lang.reflect.Method;  
 import java.util.ArrayList;  
   
 public class MethodDemo4 {  
     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);  
         //反射的操作都是编译之后的操作  
           
         /* 
          * 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();  
         }  
     }  
   
 }  

运行结果：

最后是通过反射调用方法：

User.Java

[java]view plaincopy 
   
print?
 package com.demo.reflect;  
   
 /** 
  * 标准的JavaBean类有私有属性都对应有get/set方法，有无参数的构造方法 
  * @author Administrator 
  * @date 2016年11月29日 
  */  
 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;  
     }  
       
 }  

UserService.java

[java]view plaincopy 
   
print?
 package com.demo.reflect;  
   
 public class UserService {  
     public void delete(){  
         System.out.println("删除用户");  
     }  
       
     public void update(){  
         System.out.println("修改用户");  
     }  
       
     public void find(){  
         System.out.println("查找用户");  
     }  
       
 }  

MethodDemo2.java

[java]view plaincopy 
   
print?
 package com.demo.reflect;  
   
 import java.io.BufferedReader;  
 import java.io.InputStreamReader;  
 import java.lang.reflect.Method;  
   
 public class MethodDemo2 {  
     public static void main(String[] args) {  
         UserService us = new UserService();  
           
         /* 
          * 通过键盘输入命令执行操作 
          * 输入update命令就调用update方法 
          * 输入delete命令就调用delete方法 
          * ... 
          */  
         try {  
             BufferedReader br = new BufferedReader(  
                     new InputStreamReader(System.in));  
             System.out.println("请输入命令：");  
             String action = br.readLine();  
             /*if("update".equals(action)){ 
                 us.update(); 
             } 
             if("delete".equals(action)){ 
                 us.delete(); 
             } 
             if("find".equals(action)){ 
                 us.find(); 
             }*/  
               
             /* 
              * action就是方法名称， 都没有参数--->通过方法的反射操作就会简单很多 
              * 通过方法对象然后进行反射操作 
              */  
             Class<?> c = us.getClass();  
             Method m = c.getMethod(action);  
             m.invoke(us);  
               
         } catch (Exception e) {  
             e.printStackTrace();  
         }  
     }  
   
 }  

运行结果：

BeanUtil.java

[java]view plaincopy 
   
print?
 package com.demo.reflect;  
   
 import java.lang.reflect.Method;  
   
 public class BeanUtil {  
     /** 
      * 根据标准javaBean对象的属性名获取其属性值 
      *  
      * @param obj 
      * @param propertyName 
      * @return 
      */  
     public static Object getValueByPropertyName(Object object, String propertyName) {  
         // 1.根据属性名称就可以获取其get方法  
         String getMethodName = "get"  
                 + propertyName.substring(0, 1).toUpperCase()  
                 + propertyName.substring(1);  
           
         //2.获取方法对象  
         Class<?> clazz = object.getClass();  
         try {  
             //get方法都是public的且无参数  
             Method method = clazz.getMethod(getMethodName);  
             //3 通过方法的反射操作方法  
             Object value = method.invoke(object);  
             return value;  
         } catch (Exception e) {  
             e.printStackTrace();  
             return null;  
         }  
     }  
 }  

MethodDemo3.java

[java]view plaincopy 
   
print?
 package com.demo.reflect;  
   
 public class MethodDemo3 {  
     public static void main(String[] args) {  
         User u1 = new User("zhangsan", "123456", 30);  
         System.out.println(BeanUtil.getValueByPropertyName(u1, "username"));  
         System.out.println(BeanUtil.getValueByPropertyName(u1, "userpass"));  
     }  
     
 }  