实战java反射机制-让你迅速认识java强大的反射机制

最新推荐文章于 2024-09-20 15:32:13 发布
最新推荐文章于 2024-09-20 15:32:13 发布
阅读量508 收藏
点赞数
分类专栏： Java 文章标签： java


  • 博客分类： 
  • java
Java SSH 框架 C C++ 
★★★ 本篇为原创，需要引用转载的朋友请注明：《 http://stephen830.iteye.com/blog/256723 》 谢谢支持！ ★★★ 


Reflection 是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等等）、superclass（例Object）、实现之interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于运行时改变fields内容或唤起methods。 （这句话是引用台湾作家侯捷对反射机制描述的一个概念） 

java的反射机制从java诞生之日起就成为java的一个重要特性。反射机制也是目前众多框架实现的一个基础。 

反射，简单的讲就是根据给出的类的名称，我就可以获得这个类所有的信息（包括属性，构造器，方法等），同时还可以对类的方法进行调用。这在需要动态加载类的情况下尤其显得重要。 

目前流行的大部分java框架（例如ssh等）的底层有很多都是基于反射机制来实现的。 

从下面的实例中可以了解并学会关于java反射的一些基本特点： 
（1）如何获得动态加载类的修饰符，包名，类名，使用的接口，继承的父类 
（2）动态获取类的所有属性名，修饰符，属性类型 
（3）动态获取所有定义的构造器，构造器使用的参数数量和参数类型 
（4）动态获取所有方法，方法的返回值类型，方法名，方法参数数量，方法参数类型 
（5）动态调用加载类的方法 


下面就从一个例子来深入浅出的认识下java的反射机制： 

Java代码   收藏代码
  1. /* 
  2.  * Created on 2005-6-12 
  3.  * Author stephen 
  4.  * Email zhoujianqiang AT gmail DOT com 
  5.  * CopyRight(C)2005-2008 , All rights reserved. 
  6.  */  
  7. import java.lang.reflect.Constructor;  
  8. import java.lang.reflect.Field;  
  9. import java.lang.reflect.InvocationTargetException;  
  10. import java.lang.reflect.Method;  
  11. import java.lang.reflect.Modifier;  
  12.   
  13. /** 
  14.  * java反射机制的测试类. 
  15.  *  
  16.  * @author stephen 
  17.  * @version 1.0.0 
  18.  */  
  19. public class ReflectTest {  
  20.       
  21.     /** 
  22.      * 数组参数的标志字符和实际对应的类型. 
  23.      * 其中'L'表示对象数组，其余表示java基础类型的数组. 
  24.      */  
  25.     public static final char[]   CODES = new char[]  
  26.     {'Z',      'B',   'C',  'L','D',     'F',    'I',   'J',  'S'};  
  27.     public static final String[] VALUES =            
  28.     {"boolean","byte","char","","double","float","int","long","short"};  
  29.       
  30.     /** 
  31.      * 解析方法的参数. 
  32.      * @param parameter 待解析的参数. 
  33.      * @return 
  34.      */  
  35.     public static String parseParameter(String parameter) {  
  36.         /* 在java.lang.Class类中关于参数的说明补充 
  37.          * ------------------------------------ 
  38.          * Examples: 
  39.          * String.class.getName() 
  40.          *     returns "java.lang.String" 
  41.          * byte.class.getName() 
  42.          *     returns "byte" 
  43.          * (new Object[3]).getClass().getName() 
  44.          *     returns "[Ljava.lang.Object;" 
  45.          * (new int[3][4][5][6][7][8][9]).getClass().getName() 
  46.          *     returns "[[[[[[[I" 
  47.          * ------------------------------------ 
  48.          * 1个[表示1维数组，2个[表示2维数组，...，依此类推。 
  49.          */  
  50.         boolean isArray = false;  
  51.         //如果是数组的可能会在最后带个分号过来,需要去掉.  
  52.         if(parameter.charAt(parameter.length()-1)==';'){  
  53.             //去掉最后的分号  
  54.             parameter = parameter.substring(0,parameter.length()-1);  
  55.         }  
  56.         while(parameter.indexOf('[')==0){  
  57.             isArray = true;  
  58.             parameter = parameter.substring(1)+"[]";  
  59.         }  
  60.         if(isArray){  
  61.             char code = parameter.charAt(0);  
  62.             for(int i=0;i<CODES.length;i++){  
  63.                 if(CODES[i]==code){  
  64.                     parameter=VALUES[i]+parameter.substring(1);  
  65.                     break;  
  66.                 }  
  67.             }  
  68.         }  
  69.         return parameter;  
  70.     }  
  71.       
  72.     /** 
  73.      * 解析属性的类型. 
  74.      * @param parameter 待解析的属性. 
  75.      * @return 
  76.      */  
  77.     public static String parseFieldParameter(String parameter) {  
  78.         return parseParameter(parameter);  
  79.     }  
  80.       
  81.     /** 
  82.      * 解析方法返回值的类型. 
  83.      * @param parameter 待解析的方法返回值类型. 
  84.      * @return 
  85.      */  
  86.     public static String parseMethodParameter(String parameter) {  
  87.         return parseFieldParameter(parameter);  
  88.     }  
  89.       
  90.   
  91.     /** 
  92.      * main方法. 
  93.      * @param args 
  94.      */  
  95.     public static void main(String[] args) {  
  96.         try {  
  97.             StringBuffer debugInfo = new StringBuffer();  
  98.               
  99.             String className = "java.lang.StringBuffer";//填写要测试的类  
  100.             Class c = Class.forName(className);//载入类  
  101.               
  102.             debugInfo.append("****************************************\n");  
  103.             debugInfo.append("*  "+className+" \n*  通过java反射机制取出的信息"+"\n");  
  104.             debugInfo.append("****************************************\n");  
  105.               
  106.             //获取包和类名  
  107.             Package thePackage = c.getPackage();//获取类的包  
  108.             String[] names = c.getName().split("[.]");  
  109.             String name = names[names.length-1];  
  110.             //获取类的修饰符[如 public final private等等]，  
  111.             //具体的含义请查看 [java.lang.reflect.Modifier] 中定义的修饰符常量  
  112.             //java.lang.String的修饰符是 public final  
  113.             int modifiers = c.getModifiers();  
  114.             debugInfo.append(Modifier.toString(modifiers)+" class "+ name);  
  115.               
  116.             //取出类的父类(extends)  
  117.             Class superClass = c.getSuperclass();  
  118.             if(superClass!=null && (!"java.lang.Object".equals(superClass.getName()))){  
  119.                 debugInfo.append(" extends ");  
  120.                 debugInfo.append(superClass.getName());  
  121.             }  
  122.               
  123.             //取出类的接口(implements)  
  124.             Class[] interfaces = c.getInterfaces();  
  125.             if(interfaces!=null && interfaces.length>0){  
  126.                 debugInfo.append(" implements ");  
  127.                 for(int i=0;i<interfaces.length;i++){  
  128.                     if(i>0) debugInfo.append(",");  
  129.                     debugInfo.append(interfaces[i].getName());  
  130.                 }  
  131.             }  
  132.               
  133.             debugInfo.append(" {\n");  
  134.               
  135.             //取出所有定义的属性  
  136.             debugInfo.append("    //取出所有定义的属性\n");  
  137.             Field[] fields = c.getDeclaredFields();  
  138.             for(int i=0;fields!=null && i<fields.length;i++){  
  139.                 //取出属性  
  140.                 debugInfo.append("    "+Modifier.toString(fields[i].getModifiers())  
  141.                         +" "+parseFieldParameter(fields[i].getType().getName())  
  142.                         +" "+fields[i].getName());  
  143.                 debugInfo.append(";\n");  
  144.             }  
  145.               
  146.             //获取构造器方法  
  147.             debugInfo.append("    //取出所有的构造器方法\n");  
  148.             Constructor[] constructors = c.getConstructors();//取出所有定义的构造器方法  
  149.             for(int i=0;constructors!=null && i<constructors.length;i++){  
  150.                 //取出构造器  
  151.                 debugInfo.append("    "+Modifier.toString(constructors[i].getModifiers())  
  152.                         +" "+name+"(");  
  153.                 Class[] parameterTypes = constructors[i].getParameterTypes();  
  154.                 for(int j=0;parameterTypes!=null&&j<parameterTypes.length;j++){  
  155.                     if(j>0) debugInfo.append(",");  
  156.                     debugInfo.append(parseParameter(parameterTypes[j].getName()));//构造器参数  
  157.                 }  
  158.                 debugInfo.append("){}\n");  
  159.             }  
  160.               
  161.             //取出构造器以外的所有方法  
  162.             debugInfo.append("    //取出构造器以外的所有方法\n");  
  163.             Method[] methods = c.getDeclaredMethods();  
  164.             for(int i=0;methods!=null && i<methods.length;i++){  
  165.                 //取出方法  
  166.                 debugInfo.append("    "+Modifier.toString(methods[i].getModifiers())+" "  
  167.                         + parseMethodParameter(methods[i].getReturnType().getName()) +" "  
  168.                         +methods[i].getName()+"(");  
  169.                 Class[] parameterTypes = methods[i].getParameterTypes();  
  170.                 for(int j=0;parameterTypes!=null&&j<parameterTypes.length;j++){  
  171.                     if(j>0) debugInfo.append(",");  
  172.                     debugInfo.append(parseParameter(parameterTypes[j].getName()));//构造器参数  
  173.                 }  
  174.                 debugInfo.append("){}\n");  
  175.             }  
  176.             debugInfo.append("}\n");  
  177.               
  178.             System.out.println(debugInfo.toString()+"\n");//输出debug信息  
  179.               
  180.             //利用反射机制来调用类中的方法  
  181.             //创建一个StringBuffer对象实例 相当于 StringBuffer o = new StringBuffer();  
  182.             Object o = c.newInstance();  
  183.             //调用方法 o.append(String):认识当参数为对象类型怎么调用的  
  184.             Class[] paramTypes = {Class.forName("java.lang.String")};//定义append方法需要的参数  
  185.             Object[] values = {new String("hello world")};//定义append方法需要的参数对应的数据  
  186.             //调用append(String)方法 相当于 o.append("hello world");  
  187.             o.getClass().getMethod("append",paramTypes).invoke(o,values);  
  188.             //这里将输出 hello world  
  189.             System.out.println("o.append(\""+values[0]+"\").toString()="+o.toString());  
  190.             //调用方法 o.append(int):认识当参数为int,float,double,char,boolean等基础类型时候怎么调用的  
  191.             paramTypes = new Class[]{int.class};  
  192.             values = new Object[]{new Integer(100)};  
  193.             o.getClass().getMethod("append",paramTypes).invoke(o,values);  
  194.             //这里将输出 hello world100  
  195.             System.out.println("o.append(\""+values[0]+"\").toString()="+o.toString());  
  196.               
  197.               
  198.         } catch (ClassNotFoundException e) {  
  199.             e.printStackTrace();  
  200.         } catch (SecurityException e) {  
  201.             e.printStackTrace();  
  202.         } catch (NoSuchMethodException e) {  
  203.             e.printStackTrace();  
  204.         } catch (InstantiationException e) {  
  205.             e.printStackTrace();  
  206.         } catch (IllegalAccessException e) {  
  207.             e.printStackTrace();  
  208.         } catch (IllegalArgumentException e) {  
  209.             e.printStackTrace();  
  210.         } catch (InvocationTargetException e) {  
  211.             e.printStackTrace();  
  212.         }  
  213.     }  
  214. }  


除了例子中给出的一些用法，其实通过java反射还可以进行更多的事情，有兴趣的朋友可以自己再深入研究下。 

如果你要更好的理解一些框架(例如ssh等)的结构，那么你更加需要好好的研究下这个反射机制。 




  • 博客分类： 
  • java
Java SSH 框架 C C++ 
★★★ 本篇为原创，需要引用转载的朋友请注明：《 http://stephen830.iteye.com/blog/256723 》 谢谢支持！ ★★★ 


Reflection 是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等等）、superclass（例Object）、实现之interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于运行时改变fields内容或唤起methods。 （这句话是引用台湾作家侯捷对反射机制描述的一个概念） 

java的反射机制从java诞生之日起就成为java的一个重要特性。反射机制也是目前众多框架实现的一个基础。 

反射，简单的讲就是根据给出的类的名称，我就可以获得这个类所有的信息（包括属性，构造器，方法等），同时还可以对类的方法进行调用。这在需要动态加载类的情况下尤其显得重要。 

目前流行的大部分java框架（例如ssh等）的底层有很多都是基于反射机制来实现的。 

从下面的实例中可以了解并学会关于java反射的一些基本特点： 
（1）如何获得动态加载类的修饰符，包名，类名，使用的接口，继承的父类 
（2）动态获取类的所有属性名，修饰符，属性类型 
（3）动态获取所有定义的构造器，构造器使用的参数数量和参数类型 
（4）动态获取所有方法，方法的返回值类型，方法名，方法参数数量，方法参数类型 
（5）动态调用加载类的方法 


下面就从一个例子来深入浅出的认识下java的反射机制： 

Java代码   收藏代码
  1. /* 
  2.  * Created on 2005-6-12 
  3.  * Author stephen 
  4.  * Email zhoujianqiang AT gmail DOT com 
  5.  * CopyRight(C)2005-2008 , All rights reserved. 
  6.  */  
  7. import java.lang.reflect.Constructor;  
  8. import java.lang.reflect.Field;  
  9. import java.lang.reflect.InvocationTargetException;  
  10. import java.lang.reflect.Method;  
  11. import java.lang.reflect.Modifier;  
  12.   
  13. /** 
  14.  * java反射机制的测试类. 
  15.  *  
  16.  * @author stephen 
  17.  * @version 1.0.0 
  18.  */  
  19. public class ReflectTest {  
  20.       
  21.     /** 
  22.      * 数组参数的标志字符和实际对应的类型. 
  23.      * 其中'L'表示对象数组，其余表示java基础类型的数组. 
  24.      */  
  25.     public static final char[]   CODES = new char[]  
  26.     {'Z',      'B',   'C',  'L','D',     'F',    'I',   'J',  'S'};  
  27.     public static final String[] VALUES =            
  28.     {"boolean","byte","char","","double","float","int","long","short"};  
  29.       
  30.     /** 
  31.      * 解析方法的参数. 
  32.      * @param parameter 待解析的参数. 
  33.      * @return 
  34.      */  
  35.     public static String parseParameter(String parameter) {  
  36.         /* 在java.lang.Class类中关于参数的说明补充 
  37.          * ------------------------------------ 
  38.          * Examples: 
  39.          * String.class.getName() 
  40.          *     returns "java.lang.String" 
  41.          * byte.class.getName() 
  42.          *     returns "byte" 
  43.          * (new Object[3]).getClass().getName() 
  44.          *     returns "[Ljava.lang.Object;" 
  45.          * (new int[3][4][5][6][7][8][9]).getClass().getName() 
  46.          *     returns "[[[[[[[I" 
  47.          * ------------------------------------ 
  48.          * 1个[表示1维数组，2个[表示2维数组，...，依此类推。 
  49.          */  
  50.         boolean isArray = false;  
  51.         //如果是数组的可能会在最后带个分号过来,需要去掉.  
  52.         if(parameter.charAt(parameter.length()-1)==';'){  
  53.             //去掉最后的分号  
  54.             parameter = parameter.substring(0,parameter.length()-1);  
  55.         }  
  56.         while(parameter.indexOf('[')==0){  
  57.             isArray = true;  
  58.             parameter = parameter.substring(1)+"[]";  
  59.         }  
  60.         if(isArray){  
  61.             char code = parameter.charAt(0);  
  62.             for(int i=0;i<CODES.length;i++){  
  63.                 if(CODES[i]==code){  
  64.                     parameter=VALUES[i]+parameter.substring(1);  
  65.                     break;  
  66.                 }  
  67.             }  
  68.         }  
  69.         return parameter;  
  70.     }  
  71.       
  72.     /** 
  73.      * 解析属性的类型. 
  74.      * @param parameter 待解析的属性. 
  75.      * @return 
  76.      */  
  77.     public static String parseFieldParameter(String parameter) {  
  78.         return parseParameter(parameter);  
  79.     }  
  80.       
  81.     /** 
  82.      * 解析方法返回值的类型. 
  83.      * @param parameter 待解析的方法返回值类型. 
  84.      * @return 
  85.      */  
  86.     public static String parseMethodParameter(String parameter) {  
  87.         return parseFieldParameter(parameter);  
  88.     }  
  89.       
  90.   
  91.     /** 
  92.      * main方法. 
  93.      * @param args 
  94.      */  
  95.     public static void main(String[] args) {  
  96.         try {  
  97.             StringBuffer debugInfo = new StringBuffer();  
  98.               
  99.             String className = "java.lang.StringBuffer";//填写要测试的类  
  100.             Class c = Class.forName(className);//载入类  
  101.               
  102.             debugInfo.append("****************************************\n");  
  103.             debugInfo.append("*  "+className+" \n*  通过java反射机制取出的信息"+"\n");  
  104.             debugInfo.append("****************************************\n");  
  105.               
  106.             //获取包和类名  
  107.             Package thePackage = c.getPackage();//获取类的包  
  108.             String[] names = c.getName().split("[.]");  
  109.             String name = names[names.length-1];  
  110.             //获取类的修饰符[如 public final private等等]，  
  111.             //具体的含义请查看 [java.lang.reflect.Modifier] 中定义的修饰符常量  
  112.             //java.lang.String的修饰符是 public final  
  113.             int modifiers = c.getModifiers();  
  114.             debugInfo.append(Modifier.toString(modifiers)+" class "+ name);  
  115.               
  116.             //取出类的父类(extends)  
  117.             Class superClass = c.getSuperclass();  
  118.             if(superClass!=null && (!"java.lang.Object".equals(superClass.getName()))){  
  119.                 debugInfo.append(" extends ");  
  120.                 debugInfo.append(superClass.getName());  
  121.             }  
  122.               
  123.             //取出类的接口(implements)  
  124.             Class[] interfaces = c.getInterfaces();  
  125.             if(interfaces!=null && interfaces.length>0){  
  126.                 debugInfo.append(" implements ");  
  127.                 for(int i=0;i<interfaces.length;i++){  
  128.                     if(i>0) debugInfo.append(",");  
  129.                     debugInfo.append(interfaces[i].getName());  
  130.                 }  
  131.             }  
  132.               
  133.             debugInfo.append(" {\n");  
  134.               
  135.             //取出所有定义的属性  
  136.             debugInfo.append("    //取出所有定义的属性\n");  
  137.             Field[] fields = c.getDeclaredFields();  
  138.             for(int i=0;fields!=null && i<fields.length;i++){  
  139.                 //取出属性  
  140.                 debugInfo.append("    "+Modifier.toString(fields[i].getModifiers())  
  141.                         +" "+parseFieldParameter(fields[i].getType().getName())  
  142.                         +" "+fields[i].getName());  
  143.                 debugInfo.append(";\n");  
  144.             }  
  145.               
  146.             //获取构造器方法  
  147.             debugInfo.append("    //取出所有的构造器方法\n");  
  148.             Constructor[] constructors = c.getConstructors();//取出所有定义的构造器方法  
  149.             for(int i=0;constructors!=null && i<constructors.length;i++){  
  150.                 //取出构造器  
  151.                 debugInfo.append("    "+Modifier.toString(constructors[i].getModifiers())  
  152.                         +" "+name+"(");  
  153.                 Class[] parameterTypes = constructors[i].getParameterTypes();  
  154.                 for(int j=0;parameterTypes!=null&&j<parameterTypes.length;j++){  
  155.                     if(j>0) debugInfo.append(",");  
  156.                     debugInfo.append(parseParameter(parameterTypes[j].getName()));//构造器参数  
  157.                 }  
  158.                 debugInfo.append("){}\n");  
  159.             }  
  160.               
  161.             //取出构造器以外的所有方法  
  162.             debugInfo.append("    //取出构造器以外的所有方法\n");  
  163.             Method[] methods = c.getDeclaredMethods();  
  164.             for(int i=0;methods!=null && i<methods.length;i++){  
  165.                 //取出方法  
  166.                 debugInfo.append("    "+Modifier.toString(methods[i].getModifiers())+" "  
  167.                         + parseMethodParameter(methods[i].getReturnType().getName()) +" "  
  168.                         +methods[i].getName()+"(");  
  169.                 Class[] parameterTypes = methods[i].getParameterTypes();  
  170.                 for(int j=0;parameterTypes!=null&&j<parameterTypes.length;j++){  
  171.                     if(j>0) debugInfo.append(",");  
  172.                     debugInfo.append(parseParameter(parameterTypes[j].getName()));//构造器参数  
  173.                 }  
  174.                 debugInfo.append("){}\n");  
  175.             }  
  176.             debugInfo.append("}\n");  
  177.               
  178.             System.out.println(debugInfo.toString()+"\n");//输出debug信息  
  179.               
  180.             //利用反射机制来调用类中的方法  
  181.             //创建一个StringBuffer对象实例 相当于 StringBuffer o = new StringBuffer();  
  182.             Object o = c.newInstance();  
  183.             //调用方法 o.append(String):认识当参数为对象类型怎么调用的  
  184.             Class[] paramTypes = {Class.forName("java.lang.String")};//定义append方法需要的参数  
  185.             Object[] values = {new String("hello world")};//定义append方法需要的参数对应的数据  
  186.             //调用append(String)方法 相当于 o.append("hello world");  
  187.             o.getClass().getMethod("append",paramTypes).invoke(o,values);  
  188.             //这里将输出 hello world  
  189.             System.out.println("o.append(\""+values[0]+"\").toString()="+o.toString());  
  190.             //调用方法 o.append(int):认识当参数为int,float,double,char,boolean等基础类型时候怎么调用的  
  191.             paramTypes = new Class[]{int.class};  
  192.             values = new Object[]{new Integer(100)};  
  193.             o.getClass().getMethod("append",paramTypes).invoke(o,values);  
  194.             //这里将输出 hello world100  
  195.             System.out.println("o.append(\""+values[0]+"\").toString()="+o.toString());  
  196.               
  197.               
  198.         } catch (ClassNotFoundException e) {  
  199.             e.printStackTrace();  
  200.         } catch (SecurityException e) {  
  201.             e.printStackTrace();  
  202.         } catch (NoSuchMethodException e) {  
  203.             e.printStackTrace();  
  204.         } catch (InstantiationException e) {  
  205.             e.printStackTrace();  
  206.         } catch (IllegalAccessException e) {  
  207.             e.printStackTrace();  
  208.         } catch (IllegalArgumentException e) {  
  209.             e.printStackTrace();  
  210.         } catch (InvocationTargetException e) {  
  211.             e.printStackTrace();  
  212.         }  
  213.     }  
  214. }  


除了例子中给出的一些用法，其实通过java反射还可以进行更多的事情，有兴趣的朋友可以自己再深入研究下。 

如果你要更好的理解一些框架(例如ssh等)的结构，那么你更加需要好好的研究下这个反射机制。 

附录：你可以下载本篇使用的例子 ReflectTest.zip 



------------------------------------------------------------- 
分享知识 分享快乐,分享知识，分享快乐，希望文章能给需要的朋友带来小小的帮助。
xiecj_2006
关注
专栏目录
Java中功能强大的反射机制
EchorJY的博客
05-26 113
博主也是今天刚刚学习了Java的反射机制，收获颇多，后面的一个案列，已经框架式编程给了我很大的震撼 反射： Java反射机制:是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。由于这种动态性，可以极大的增强程序的灵活性,程序不用在编译期就完成确定，在运行期仍然可以扩展. 我们要想通过反射去使用一个类，首先我们要获取到该类的字节码文件对象，也就是类型为Class类型的对象，获取class类对象有以下方法 使用类的class属性来获取该类对应的Class对象。
java 反射 强制转换_Java框架基础——反射(reflect) （转）
weixin_42499159的博客
02-12 2044
阅读目录一、Class类的使用二、动态加载类三、获取方法信息四、获取成员变量、构造函数信息五、方法的反射六、通过反射了解集合泛型的本质一、Class类的使用1)在面向对象(oop)的世界里，万事万物皆对象。在Java中，包括基本的数据类型，都是对象。Class c = int.class;//int 的类类型那就是说：类是对象，类是java.lang.Class类的实例对象。这个对象我们称之为类类...
java基础强化——深入理解反射
dcnmm48064的专栏
07-28 134
目录 1.从Spring容器的核心谈起 2. 反射技术初探 2.1 什么是反射技术 2.2 类结构信息和java对象的映射 3 Class对象的获取及需要注意的地方 4. 运行时反射获取类的结构信息 5. 运行时反射获取泛...
java.lang.ClassCastException: [I cannot be cast to [Ljava.lang.Object解决方案
热门推荐
junranhuigu的专栏
05-26 1万+
java.lang.ClassCastException: [I cannot be cast to [Ljava.lang.Object解决方案
JAVA反射详解（JAVA Reflection）
whhwch1986的博客
02-03 163
JAVA Reflection 定义 反射是Java被视为动态语言的关键，反射机制允许程序在执行过程中借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。 类加载完成后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的机构。这个对象就像一面镜子，透过这个镜子能看到类的结构，因此，被形象的称为**“反射”** 。 优点：可以实现动态创建对象和编译，体现出很大的灵活性
Java进阶-反射的详解与应用
踏雨歌青春，诗酒趁年华
04-02 4286
本文深入探讨了Java反射机制的核心概念、应用实例及其在现代Java开发中的重要性。文章首先介绍了反射的基本原理和能力，包括在运行时动态获取类信息、操作对象字段和方法的能力。随后，通过具体代码示例，展示了如何利用反射进行字段访问、方法调用、处理泛型方法以及访问私有成员等高级应用，进一步讨论了反射在动态代理、框架开发、数据映射和软件测试中的实用场景。最后，文章总结了反射的优缺点，提出了在实际开发中使用反射的最佳实践和注意事项，为Java开发者提供了一份既全面又深入的反射机制指南。
Java反射机制：修改父类私有属性
孔乙己大叔的博客
09-13 978
反射机制是Java语言提供的一种强大工具，它允许程序在运行时检查或修改类的行为。通过反射，程序可以获取任何类的内部信息（如成员变量、构造方法、成员方法等），并可以动态地创建对象、调用方法以及访问和修改属性，即使这些属性是私有的。Java反射的核心在于包，该包提供了几个关键的类和接口，如ClassFieldMethod和等，它们共同构成了Java反射的基石。
反射机制大揭秘-进阶Java技巧,直击核心!
w风雨无阻w的专栏
05-29 1110
首先，我们定义一个插件接口，所有插件都必须实现这个接口。
JAVA高级--反射机制
qq_44672113的博客
04-25 617
Java反射说明和使用
Java反射--实战篇
云原生Java Web领域技术博客
03-05 786
从实际应用的角度，说明如何在Java中使用反射
java反射机制实战示例分享
09-04
Java反射机制是Java语言提供的一种强大的工具，它允许程序在运行时动态地获取类的信息以及对类的对象进行操作。在上述示例中，通过反射机制，我们能够访问类的私有成员，包括字段（fields）、方法（methods）和构造...
Java高级程序设计实战教程第三章-Java反射机制.pptx
05-30
Java反射机制是Java编程语言中的一个强大工具，它允许程序在运行时检查和操作类、对象、字段和方法。在本教程中，我们将深入探讨Java反射机制的核心概念、功能、API以及应用场景。 **3.1 应用场景** 反射机制在...
Java软件开发实战 Java基础与案例开发详解 15-2 使用Java反射机制 共16页.pdf
07-07
通过本文档的学习，你已经掌握了如何使用Java反射机制获取类的信息，包括类的名称、构造方法、字段等。此外，还学习了如何使用反射来创建对象和调用方法。这些技能对于开发灵活且可扩展的应用程序至关重要。
Java-网络
2301_81543552的博客
09-14 805
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Java企业面试题3
m0_74972727的博客
09-15 869
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
JDK17新增语法特性
最新发布
2201_76124988的博客
09-20 512
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
上传文件到钉盘流程详解
jspyth的博客
09-14 820
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 170
faiss版本 faiss-v1.7.4。
Java反射机制详解与实战
Java反射机制是一种强大的工具，它扩展了Java编程的边界，使得程序在运行时能够对自身进行深入的检查和控制，为开发带来了更大的灵活性。通过深入理解和合理使用反射，我们可以编写出更高效、更通用的代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值