`

Java 反射机制

    博客分类：
  • Java
 
阅读更多

   在我们使用形如 ClassName object = new ClassName();  的语句进行创建实例的时候，我们默认 ClassName 已经在系统内存在的了，所以直接使用new 的方式进行创建。

事实上，在启动虚拟机的时候，我们定义在系统内的类通过类的加载器（class loader）加载到系统内。所以当系统运行的时候，我们就可以使用该类。

           有时候，在系统运行的时候，类并没有存在在系统内，我们需要手动加载类文件到系统内，然后再使用它(创建对象或者使用其类方法等等)。

          

类的加载

                在运行时期加载类，是通过 JVM 内的Class对象 的 Class.forName()方法将类定义加载到系统内，返回一个对应的类文件的表示对象。

 

           例如，创建一个Animal的类，然后通过手动加载到内存中，代码如下：

      

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
 
  1. package com.lou;  
  2.   
  3. public abstract class Animal {  
  4.   
  5.     private Integer age;  
  6.     private double weight;  
  7.       
  8.     public Integer getAge() {  
  9.         return age;  
  10.     }  
  11.   
  12.     public void setAge(Integer age) {  
  13.         this.age = age;  
  14.     }  
  15.   
  16.     public double getWeight() {  
  17.         return weight;  
  18.     }  
  19.   
  20.     public void setWeight(double weight) {  
  21.         this.weight = weight;  
  22.     }  
  23.   
  24.     public abstract void walk();  
  25.       
  26. }  

 

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
 
  1. package com.lou;  
  2.   
  3. public class Client {  
  4.   
  5.     public static void main(String[] args) {  
  6.         try {  
  7.             Class clazz = Class.forName("com.lou.Animal");  
  8.             System.out.println("成功加载类文件 "+clazz.getSimpleName());  
  9.         } catch (ClassNotFoundException e) {  
  10.             e.printStackTrace();  
  11.         }  
  12.     }  
  13. }  

一个class 定义有什么？ 对应的class 对象有哪些组件？

      我们定义一个Java 类，基本上会具有：注解（Annotation），成员字段(Field)，Constructor(构造器)，方法(Method),定义的内部类，自己的父类，实现的接口等。

构造器（Constructor）及使用Class 对象创建 实例对象

        构造器的作用就是创建对象。一般创建构造器时，会有相应的描述符:public private 等；参数列表；抛出的异常信息。

      我们通过Class 对象取得构造器对象时，要提供相应的构造器的参数列表。参数列表构造器的"id"，每个构造器都不一样。如果提供没有定义过的参数列表，将会抛出异常。

       构造器的价值就是用于创建出实例对象和初始化。使用 构造器的 newInstance(Object ... varArgs) 方法可以创建出一个实例对象。不过该方法返回的是Object 对象，要根据相应的Class对象向下转型。

如下面所示的例子，获取Worker 的构造器对象，并且创建对象

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
 
  1. package com.lou;  
  2.   
  3. import java.math.BigDecimal;  
  4.   
  5. public class Worker {  
  6.   
  7.     public String id;//工号  
  8.     public String name;//姓名  
  9.     public BigDecimal salary;//工资  
  10.       
  11.     private Worker()  
  12.     {  
  13.           
  14.     }  
  15.     public Worker(String id,String name)  
  16.     {  
  17.         this.id = id;  
  18.         this.name = name;  
  19.     }  
  20.     public Worker(String id,String name,BigDecimal salary)  
  21.     {  
  22.         this(id,name);  
  23.         this.salary = salary;  
  24.     }  
  25.       
  26.     public void work()  
  27.     {  
  28.         System.out.println("Working......");  
  29.     }  
  30. }  



 

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
 
  1. package com.lou;  
  2.   
  3. import java.lang.reflect.Constructor;  
  4. import java.lang.reflect.InvocationTargetException;  
  5.   
  6. public class Client1 {  
  7.   
  8.   
  9.     public static void main(String[] args) {  
  10.         try {  
  11.             Class clazz = Class.forName("com.lou.Worker");  
  12.               
  13.             System.out.println("成功加载类文件 "+clazz.getSimpleName());  
  14.             //返回clazz 的公共构造器  
  15.             Constructor[] constructors = clazz.getConstructors();  
  16.             System.out.println("公共构造器共有 "+ constructors.length +" 个。");  
  17.             System.out.println("它们分别是：");  
  18.             for(Constructor cons : constructors)  
  19.             {  
  20.                 System.out.println(cons.toGenericString());  
  21.             }  
  22.               
  23.             //返回clazz 的指定公共构造器  
  24.             Constructor constructor = clazz.getConstructor(String.class,String.class);  
  25.               
  26.             //通过newInstance(Object ...varArgs) 创建对象  
  27.             Worker worker=(Worker)constructor.newInstance(new String("1234"),new String("louis"));  
  28.             System.out.println(worker.id);  
  29.               
  30.         } catch (Exception e) {  
  31.             e.printStackTrace();  
  32.         }  
  33.     }  
  34.   
  35. }  

 

成员字段(Field)及其操作


      Field 域作为字段域，可以获取其 修饰符，字段的类型，还有变量名；通过field对象，可以设置和某个 实例对象对应的字段的值。

以上面的Worker类为例，获取和设置其实例对象的值：

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
 
  1. package com.lou;  
  2.   
  3. import java.lang.reflect.Constructor;  
  4. import java.lang.reflect.Field;  
  5. import java.lang.reflect.InvocationTargetException;  
  6. import java.math.BigDecimal;  
  7.   
  8. public class Client1 {  
  9.   
  10.   
  11.     public static void main(String[] args) {  
  12.         try {  
  13.             Class clazz = Class.forName("com.lou.Worker");  
  14.               
  15.             System.out.println("成功加载类文件 "+clazz.getSimpleName());  
  16.             // 获取指定名称的可访问的field  
  17.             Field field = clazz.getField("id");           
  18.             System.out.println("Field " + field.getName() +"获取成功。");  
  19.               
  20.             Object o = clazz.getConstructor(String.class,String.class,BigDecimal.class).newInstance(new String("123"),new String("louis"),new BigDecimal(23));  
  21.             // 取出对象内对应字段的值  
  22.             String value = (String) field.get(o);  
  23.             System.out.println("对象对应字段的值是："+ value);  
  24.             // 设置某个对象内对应字段的值  
  25.             field.set(o, "321");  
  26.             System.out.println("对象对应的字段的值被设定为："+field.get(o));  
  27.               
  28.         } catch (Exception e) {  
  29.             e.printStackTrace();  
  30.         }   
  31.     }  
  32.   
  33. }  

Method 及其相关操作

    Method 对象代表类内的某个方法，可以获取其修饰符、返回的数据类型、方法名、抛出的异常类型、触发某个实例对象的这个方法。

 

 

 

 

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
 
  1. package com.lou;  
  2.   
  3. import java.lang.reflect.Constructor;  
  4. import java.lang.reflect.Field;  
  5. import java.lang.reflect.InvocationTargetException;  
  6. import java.lang.reflect.Method;  
  7. import java.math.BigDecimal;  
  8.   
  9. public class Client1 {  
  10.   
  11.   
  12.     public static void main(String[] args) {  
  13.         try {  
  14.             Class clazz = Class.forName("com.lou.Worker");  
  15.               
  16.             System.out.println("成功加载类文件 "+clazz.getSimpleName());  
  17.             // 获取指定名称的可访问的field  
  18.             Field field = clazz.getField("id");           
  19.             System.out.println("Field " + field.getName() +"获取成功。");  
  20.               
  21.             Object o = clazz.getConstructor(String.class,String.class,BigDecimal.class).newInstance(new String("123"),new String("louis"),new BigDecimal(23));  
  22.           
  23.             // 获取类的某个可访问的方法：  
  24.             Method method = clazz.getMethod("work", null);  
  25.               
  26.             System.out.println("Method " + method.getName() +"获取成功。");  
  27.             // 触发调用Worker类对应的方法  
  28.             method.invoke(o, null);  
  29.               
  30.         } catch (Exception e) {  
  31.             e.printStackTrace();  
  32.         }   
  33.     }  
  34.   
  35. }  


 

附录：一个完整的例子：

         一个Human 类继承自 抽象类Animal，实现接口Inventor，并且其上有注解 Author 和Function，现在通过以下的代码对Human类进行解析：

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
 
  1. package com.lou;  
  2.   
  3. @Author(id = "4321",name ="luan",date="2014")  
  4. public abstract class Animal {  
  5.   
  6.     private Integer age;  
  7.     private double weight;  
  8.       
  9.     public Integer getAge() {  
  10.         return age;  
  11.     }  
  12.   
  13.     public void setAge(Integer age) {  
  14.         this.age = age;  
  15.     }  
  16.   
  17.     public double getWeight() {  
  18.         return weight;  
  19.     }  
  20.   
  21.     public void setWeight(double weight) {  
  22.         this.weight = weight;  
  23.     }  
  24.   
  25.     public abstract void walk();  
  26.       
  27. }  


 

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
 
  1. package com.lou;  
  2.   
  3. public interface Inventor {  
  4.   
  5.     // 发明者的实现方法  
  6.     public void invent();  
  7. }  


 

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
 
  1. package com.lou;  
  2.   
  3.   
  4. // 注解区域  
  5. @Author(id = "1234",name ="louis",date="2014")  
  6. @Function(value ="人类的类定义")  
  7. public class Human extends Animal implements Inventor{  
  8.   
  9.     //成员变量区   Fields  
  10.     private String name;  
  11.     private String color;  
  12.     private String nationality;  
  13.     public String birthDate;  
  14.     // 构造器部分 Constructor  
  15.     public Human()  
  16.     {  
  17.     }  
  18.       
  19.     private Human(String name)  
  20.     {  
  21.         this.name= name;  
  22.     }  
  23.       
  24.     @Function(value = "构造器，带有三个参数")  
  25.     public Human(String name,String color,String nationality) throws Exception  
  26.     {  
  27.         this(name);  
  28.         this.color = color;  
  29.         this.nationality = nationality;  
  30.     }  
  31.     public Human(String name,String color,String nationality,String birthDate) throws Exception  
  32.     {  
  33.         this(name,color,nationality);  
  34.         this.birthDate = birthDate;  
  35.     }  
  36.       
  37.       
  38.     //方法区域  
  39.     public String getName() {  
  40.         return name;  
  41.     }  
  42.     public void setName(String name) {  
  43.         this.name = name;  
  44.     }  
  45.     public String getColor() {  
  46.         return color;  
  47.     }  
  48.       
  49.     public void setColor(String color) {  
  50.         this.color = color;  
  51.     }  
  52.     @Override  
  53.     public void invent() {  
  54.         System.out.println("人类发明。。。。。");  
  55.     }  
  56.     @Override  
  57.     public void walk() {  
  58.         System.out.println("Using two legs");  
  59.     }  
  60.   
  61.     @Author(id = "123",name ="luan",date="2014")  
  62.     public void speak()  
  63.     {  
  64.         System.out.println("You are in "+ nationality +",You can speak "+nationality);  
  65.     }  
  66.   
  67.     class Mind{}  
  68. }  


 

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
 
  1. package com.lou;  
  2.   
  3. import java.lang.annotation.Retention;  
  4. import java.lang.annotation.RetentionPolicy;  
  5. // 对书写的类或者方法进行标识  
  6. @Retention(value=RetentionPolicy.RUNTIME)  
  7. public @interface Author {  
  8.   
  9.     public String id() default "none";  
  10.     public String name() default "none";  
  11.     public String date();  
  12. }  


 

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
 
  1. package com.lou;  
  2.   
  3. import java.lang.annotation.Retention;  
  4. import java.lang.annotation.RetentionPolicy;  
  5. // 功能描述  
  6. @Retention(value=RetentionPolicy.RUNTIME)  
  7. @interface Function {  
  8.   
  9.     public String value() default "none";  
  10. }  

 


            Client 类的方法内对 Human 的 Annotation，Constructor，Field，Method 相关的操作进行了细致的示范。

 

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
 
  1. package com.lou;  
  2.   
  3. import java.lang.annotation.Annotation;  
  4. import java.lang.reflect.Constructor;  
  5. import java.lang.reflect.Field;  
  6. import java.lang.reflect.InvocationTargetException;  
  7. import java.lang.reflect.Method;  
  8. import java.lang.reflect.Modifier;  
  9. import java.lang.reflect.Type;  
  10.   
  11. public class Client {  
  12.   
  13.     public static void main(String[] args) throws Exception {  
  14.         // 注解操作  
  15.         annotationsOperations();  
  16.   
  17.         //构造器操作  
  18.         constructorOperations();  
  19.           
  20.         //字段操作  
  21.         fieldOperations();  
  22.           
  23.         //方法操作  
  24.         methodOperations();  
  25.   
  26.     }  
  27.   
  28.     /* 
  29.      * 注解相关 操作 
  30.      */  
  31.     private static void annotationsOperations() {  
  32.         Class clazz = Human.class;  
  33.         // 如果存在该元素的指定类型的注解，则返回这些注解，否则返回 null。  
  34.         Author author = (Author) clazz.getAnnotation(Author.class);  
  35.         System.out.println("这个类的作者是：" + author.name());  
  36.   
  37.         // 获取运用到当前class 上的所有 注解  
  38.         Annotation[] annotations = clazz.getDeclaredAnnotations();  
  39.         // Annotation[] annotations = clazz.getAnnotations();  
  40.         System.out.println("Class " + clazz.getSimpleName() + " has "  
  41.                 + annotations.length + " annotations。");  
  42.     }  
  43.   
  44.     /* 
  45.      * 构造器操作 
  46.      */  
  47.     private static void constructorOperations() throws SecurityException,  
  48.             NoSuchMethodException, IllegalArgumentException,  
  49.             InstantiationException, IllegalAccessException,  
  50.             InvocationTargetException {  
  51.   
  52.         Class clazz = Human.class;  
  53.   
  54.         /* 
  55.          * Constructor<T> getConstructor(Class<?>... parameterTypes) 返回一个 
  56.          * Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。 
  57.          */  
  58.   
  59.         Constructor constructor = clazz.getConstructor(null);// 无参构造器  
  60.         Constructor constructor2 = clazz.getConstructor(String.class,  
  61.                 String.class, String.class); // 三个个String 类型的参数构造器  
  62.   
  63.         /* 
  64.          * Constructor<?>[] getConstructors() 返回一个包含某些 Constructor 对象的数组，这些对象反映此 
  65.          * Class 对象所表示的类的所有公共构造方法。 
  66.          */  
  67.         Constructor[] cons = clazz.getConstructors();  
  68.         System.out.println("公共构造器数量为:" + cons.length);  
  69.   
  70.         /* 
  71.          * Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 
  72.          * 返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法。 
  73.          * 这个可以得到所有在这个类内定义的构造器，不管是不是public 的 
  74.          */  
  75.         Constructor[] constructs = clazz.getDeclaredConstructors();  
  76.         System.out.println("公共构造器数量为:" + constructs.length);  
  77.   
  78.         Constructor cons2 = clazz.getDeclaredConstructor(String.class,  
  79.                 String.class, String.class);  
  80.   
  81.         /* 
  82.          * 构造器上的注解 
  83.          */  
  84.         Annotation[] annos = cons2.getAnnotations();  
  85.         System.out.println("此构造器上的注解个数为：" + annos.length);  
  86.         Function function = (Function) cons2.getAnnotation(Function.class);  
  87.         System.out.println("Function 注解:" + function.value());  
  88.   
  89.         /* 
  90.          * 获取此构造器抛出来的异常信息 
  91.          */  
  92.         Class[] exceptions = cons2.getExceptionTypes();  
  93.         System.out.println("-----构造器抛出来的异常共有:" + exceptions.length  
  94.                 + "个。如下：----");  
  95.         for (Class c : exceptions) {  
  96.             System.out.println(c.getSimpleName());  
  97.         }  
  98.   
  99.         /* 
  100.          * Type[] getGenericExceptionTypes() 返回一组 Type 对象，这些对象表示声明要由此 
  101.          * Constructor 对象抛出的异常 
  102.          */  
  103.         System.out.println("----------构造器的Generic Exception Types-----------");  
  104.         Type[] types = cons2.getGenericExceptionTypes();  
  105.         for (Type t : types) {  
  106.             System.out.println(t.toString());  
  107.         }  
  108.   
  109.         /* 
  110.          * Type[] getGenericParameterTypes() 按照声明顺序返回一组 Type 对象，这些对象表示此 
  111.          * Constructor 对象所表示的方法的形参类型。 
  112.          */  
  113.   
  114.         System.out.println("------构造器方法形参的数据类型数组为：-------------");  
  115.         Type[] types2 = cons2.getGenericParameterTypes();  
  116.         for (Type t : types2) {  
  117.             System.out.println(t.toString());  
  118.         }  
  119.   
  120.         /* 
  121.          * Class<?>[] getParameterTypes() 按照声明顺序返回一组 Class 对象，这些对象表示此 
  122.          * Constructor 对象所表示构造方法的形参类型。 
  123.          */  
  124.   
  125.         /* 
  126.          * public int getModifiers() 以整数形式返回此 Constructor 对象所表示构造方法的 Java 
  127.          * 语言修饰符。应该使用 Modifier 类对这些修饰符进行解码。 
  128.          */  
  129.         System.out.println("---------构造器的修饰符是：-----------");  
  130.         System.out.println(cons2.getModifiers());  
  131.         if (Modifier.isPublic(cons2.getModifiers())) {  
  132.             System.out.println("Modifier is public ");  
  133.         }  
  134.   
  135.         /* 
  136.          * String getName() 以字符串形式返回此构造方法的名称。 
  137.          */  
  138.         String constructorName = cons2.getName();  
  139.         System.out.println("------此构造器的名称是：" + constructorName);  
  140.   
  141.         /* 
  142.          * Class<T> getDeclaringClass() 返回 Class 对象，该对象表示声明由此 Constructor 
  143.          * 对象表示的构造方法的类。 即返回这个构造器所在的类 
  144.          */  
  145.         Class parent = cons2.getDeclaringClass();  
  146.         System.out.println("----------此构造器所在的类是：");  
  147.         System.out.println(parent.getCanonicalName());  
  148.   
  149.         /* 
  150.          * boolean isVarArgs() 如果声明此构造方法可以带可变数量的参数，则返回 true；否则返回 false。 
  151.          */  
  152.         System.out.println("参数列表是否支持可变变量：" + cons2.isVarArgs());  
  153.   
  154.         /* 
  155.          * 通过constructor对象创建对象 T newInstance(Object... initargs) 
  156.          */  
  157.         Human human = (Human) cons2.newInstance(new String("louis"),  
  158.                 new String("yellow"), new String("nationality"));  
  159.         System.out.println("Human's name is " + human.getName());  
  160.   
  161.     }  
  162.   
  163.       
  164.     /* 
  165.      * Field 相关操作 
  166.      */  
  167.     private static void fieldOperations() throws Exception  
  168.     {  
  169.         Class clazz = Human.class;  
  170.           
  171.         //获取类内定义的所有成员字段,返回一个数组,包括私有成员字段  
  172.         Field[] fields =  clazz.getDeclaredFields();  
  173.         System.out.println(clazz.getSimpleName()+" 定义的成员字段共有："+fields.length);  
  174.         //获取类内定义的 指定名称的成员字段 包括私有成员字段  
  175.         Field field =  clazz.getDeclaredField("name");  
  176.           
  177.           
  178.         //返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。  
  179.         //包括从父类继承过来的可访问的字段  
  180.         Field[] fields1 = clazz.getFields();  
  181.         //返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。  
  182.         //包括从父类继承过来的可访问的字段  
  183.         Field field2 = clazz.getField("birthDate");  
  184.         Human human = new Human("lou","yellow","China","1991-10");  
  185.           
  186.         /* 
  187.          * 获取human对象的对应字段的值 
  188.          * Object get(Object obj) 
  189.          * XXX getXXX(Object obj) XXX Boolean,Byte,Char,Double,Long,Float,Int,Short 等    
  190.          */  
  191.         Object value = field2.get(human);  
  192.         System.out.println("human对应字段 " + field2.getName() +" 的值为："+value);  
  193.           
  194.         /* 
  195.          * 设置human对象的对应字段的值 
  196.          * void set(Object obj, Object value) 
  197.          * void setXXX(Object obj, XXX z) XXX Boolean,Byte,Char,Double,Long,Float,Int,Short 等    
  198.          */  
  199.         field2.set(human, "1990-1");  
  200.         System.out.println("human 对象的值已经被设定为："+field2.get(human));  
  201.           
  202.         /* 
  203.          * 获取成员字段的数据类型 
  204.          *  Class<?> getType() 
  205.          *   Type getGenericType()    
  206.          */  
  207.         Class type = field2.getType();  
  208.         System.out.println("字段"+field2.getName()+" 的类型是:"+type.getName());  
  209.           
  210.     }  
  211.        
  212.   
  213.     /* 
  214.      * Method 相关操作 
  215.      */  
  216.     private static void methodOperations() throws Exception  
  217.     {  
  218.          Class clazz = Human.class;  
  219.             
  220.          //返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。  
  221.          Method[] methods = clazz.getMethods();  
  222.          //返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。  
  223.          Method method = clazz.getMethod("speak", null);  
  224.   
  225.          //返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。  
  226.          Method[] methods2 = clazz.getDeclaredMethods();  
  227.          //返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法  
  228.          Method method2 = clazz.getDeclaredMethod("walk", null);  
  229.            
  230.          /* 
  231.           * Object invoke(Object obj, Object... args)  
  232.           * 对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。 
  233.           * 调用某个对象的这个方法 
  234.           */  
  235.          Human human = new Human("lou","yellow","China","1991-10");   
  236.          method2.invoke(human, null);  
  237.            
  238.            
  239.     }  
  240. }  
分享到：
| 使用命令行执行java文件、项目（class、ja ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java反射机制.zip

    java反射机制java反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制...

    java反射机制

    Java反射机制是Java编程语言中的一个强大工具，它允许程序在运行时检查和操作类、接口、对象等的内部结构。通过反射，开发者能够在运行时动态地获取类的信息（如类名、方法名、参数类型）并调用方法，创建对象，甚至...

    JAVA反射机制应用

    JAVA反射机制应用 JAVA反射机制是JAVA语言中的一种动态机制，它能够在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法。这种动态获取的信息以及动态...

    Java反射机制的实现_Reflection

    Java反射机制是Java编程语言中的一个强大特性，它允许程序在运行时检查和操作类、接口、对象等的内部信息。通过Java反射机制，开发者可以在不知道具体类名的情况下创建对象，调用方法，访问和修改私有成员变量，以及...

    一个例子让你了解Java反射机制

    Java反射机制是Java编程语言中的一个重要特性，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在Java中，反射机制的核心类集中在java.lang.reflect包下，包括Class、Constructor、Method和...

    java 反射机制

    ### Java反射机制深入理解 #### 一、反射机制概述 Java反射机制是一种强大的工具，它允许程序在运行时检查和操作任何类、方法、构造函数和字段等元素。这种能力对于构建灵活的应用程序和框架非常有用，特别是那些...

    JAVA反射机制的简单理解

    Java反射机制是Java语言提供的一种强大工具，它允许在程序运行时动态地获取类的信息以及对类的对象进行操作。在Java中，静态编译时类型检查确保了代码的稳定性，但有时我们需要在运行时根据需求动态地创建对象、调用...

    Java 反射机制 代码的实例

    Java反射机制是Java编程语言中的一个强大特性，它允许程序在运行时检查和操作类、接口、对象等的内部结构。通过反射，开发者可以动态地获取类的信息并调用其方法，创建对象，访问私有成员，甚至改变类的行为。在深入...

    候捷谈Java反射机制

    Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时获取和操作任何已知名称的类的内部信息。这一机制使得Java具备了一定的动态性，虽然在传统的分类中Java被视为静态类型语言。通过反射，开发者可以在...

    java 反射机制详解

    Java 反射机制是 Java 语言中的一个重要特性，它允许程序在运行时动态地获取类的信息（如类名、属性、方法等）并调用对象的方法，甚至修改对象的状态。这一机制极大地增强了 Java 程序的灵活性和可扩展性，尤其是在...

    Java反射机制学习（二）

    这篇博文"Java反射机制学习（二）"可能深入探讨了如何利用反射进行动态类型处理、访问私有成员以及创建对象等核心概念。在这里，我们将详细讨论Java反射的基本用法及其在实际开发中的应用。 1. **什么是反射**： ...

    java反射机制和动态代理的原理

    java反射机制和动态代理的原理，熟悉反射机制和动态代理

    Java反射机制 Java反射机制

    ### Java反射机制详解 #### 一、Java反射机制概述 Java反射机制是Java语言的一个重要特性，它允许程序在运行时获取类的信息并操作对象。Java反射机制的主要作用包括：获取类的所有属性和方法、构造动态实例、调用...

    Java反射机制课件ppt

    Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并操作类的对象。这种机制使得Java具有高度的灵活性和动态性，可以在编译时未知类的情况下进行类的加载、实例化、方法调用等操作...

    java反射机制工具类

    Java反射机制是Java编程语言中的一个强大特性，它允许程序在运行时检查和操作类、接口、字段和方法的信息。这个特性使得Java具备了高度的灵活性，能够在运行时动态地发现和使用类的属性和方法，即使这些信息在编译时...

    java反射机制,很安逸.不要错过

    Java反射机制是Java编程语言中的一个强大特性，它允许程序在运行时检查并操作类、接口、字段和方法的信息，打破了通常编译时静态绑定的限制。通过反射，我们可以动态地创建对象，调用方法，访问和修改字段值，甚至...

    java面试题--反射机制

    ### Java反射机制详解 #### 一、引言 在Java面试中，经常会出现与反射机制相关的题目。这是因为Java反射机制不仅是Java语言的一项重要特性，也是理解Java动态特性的关键所在。通过本文，我们将深入探讨Java反射...

    java反射机制核心代码

    java反射机制核心代码,小弟一直弄不明白，怎么通过反射来调用私有成员方法，看了这个后，你可以随心调用private方法，和属性，记得添加setAccessable(true),哦，要不还是不行，如：method.setAccessable(true);

    Java反射机制总结（实例分析）

    Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并进行操作。通过反射，开发者可以在程序执行时发现并访问类的字段（fields）、方法（methods）以及构造器（constructors），...

Magicbox
Global site tag (gtag.js) - Google Analytics