反射机制补充

最新推荐文章于 2022-01-03 13:53:27 发布
最新推荐文章于 2022-01-03 13:53:27 发布
阅读量675 收藏
点赞数
分类专栏： 编程-Java 文章标签： class constructor object integer string exception
Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。例如，使用它能获得 Java 类中各成员的名称并显示出来。JavaBean 是 reflection 的实际应用之一，它能让一些工具可视化的操作软件组件。这些工具通过 reflection 动态的载入并取得 Java 组件(类) 的属性。
    1. 一个简单的例子
    考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。
    import java.lang.reflect.*;
    public class DumpMethods {
        public static void main(String args[]) {
            try {
                Class c = Class.forName(args[0]);
                Method m[] = c.getDeclaredMethods();
                for (int i = 0; i < m.length; i++)
                    System.out.println(m[i].toString());
            } catch (Throwable e) {
                System.err.println(e);
            }
        }
    }
    按如下语句执行：
    java DumpMethods java.util.Stack
    它的结果输出为：
    public java.lang.Object java.util.Stack.push(java.lang.Object)
    public synchronized java.lang.Object java.util.Stack.pop()
    public synchronized java.lang.Object java.util.Stack.peek()
    public boolean java.util.Stack.empty()
    public synchronized int java.util.Stack.search(java.lang.Object)
    这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。
    这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。还有就是getDeclaredMethod(para1,para2)来获取这个类中的具体某一个方法，其中para1是一个String类型，具体代表的是方法名，para2是个一个Class类型的数组，其中定义个方法的具体参数类型。
    例如：
  1. Class cls = Class.forName("chb.test.reflect.Student");   
  2. Method m = cls.getDeclaredMethod("方法名",new Class[]{int.class,String.class});   
  3. m.invoke(cls.newInstance(),20,"chb");
    总结：
            //使用反射类调用某个类中的方法
               Class c = Class.forName("com.inspur.reflect.MethodTest");
               Method n = c.getDeclaredMethod("show", new Class[]{String.class,int.class});
               n.invoke(c.newInstance(), "guoxzh",20);
   a.使用Class.forName("类名")来获取类
   b.其次使用getDeclaredMethods()方法获取该类所有的方法，也可以使用getDeclaredMethod("方法名",new Class[]{int.class,String.class})方法类获取具体的某一个方法
   c.接着可以使用invoke(c.newInstance,param....)来调用具体的方法。


    2.详细介绍开始使用 Reflection
    用于 reflection 的类，如 Method，可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤：第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。
    下面就是获得一个 Class 对象的方法之一：
    Class c = Class.forName("java.lang.String");
    这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句：
    Class c = int.class;
    或者
    Class c = Integer.TYPE;
    它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Integer) 中预先定义好的 TYPE 字段。
    第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。
    一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码：
    Class c = Class.forName("java.lang.String");
    Method m[] = c.getDeclaredMethods();
    System.out.println(m[0].toString());
    它将以文本方式打印出 String 中定义的第一个方法的原型。
    在下面的例子中，这三个步骤将为使用 reflection 处理特殊应用程序提供例证。
    模拟 instanceof 操作符
    得到类信息之后，通常下一个步骤就是解决关于 Class 对象的一些基本的问题。例如，Class.isInstance 方法可以用于模拟 instanceof 操作符：
    class A {
    }
    public class instance1 {
        public static void main(String args[]) {
            try {
                Class cls = Class.forName("A");
                boolean b1 = cls.isInstance(new Integer(37));   //判断Integer(37)该对象是否是A类的对象
                System.out.println(b1);
                boolean b2 = cls.isInstance(new A());
                System.out.println(b2);
            } catch (Throwable e) {
                System.err.println(e);
            }
        }
    }
    在这个例子中创建了一个 A 类的 Class 对象，然后检查一些对象是否是 A 的实例。Integer(37) 不是，但 new A() 是。


    3.找出类的方法
    找出一个类中定义了些什么方法，这是一个非常有价值也非常基础的 reflection 用法。下面的代码就实现了这一用法：

package com.inspur.reflect;

import java.lang.reflect.Method;


public class Methodtest1 {
 
 
 private int abc(Object p,int x) throws NullPointerException{
  if(p==null)throw new NullPointerException();
  return x;
 }

 public static void main(String[] args) {
  
  try{
   Class cls = Class.forName("com.inspur.reflect.Methodtest1");
   Method methodlist[]= cls.getDeclaredMethods();
   for(int i = 0;i<methodlist.length;i++){
    Method m = methodlist[i];
    System.out.println("name=="+m.getName());//得到方法的名称
    System.out.println("decl class=="+m.getDeclaringClass());//得到定义的类名
    Class prev[] = m.getParameterTypes();   //取m方法中的所有参数
    //遍历所有的参数
    for(int j = 0; j<prev.length;j++){
     System.out.println("param["+j+"]=="+prev[j]);
    }
    Class exec[] = m.getExceptionTypes(); //得到所有的异常
    //遍历所有的异常
    for(int k=0;k<exec.length;k++){
     System.out.println("execption["+k+"]=="+exec[k]);
    }
   
    Class ret = m.getReturnType(); //得到每个方法的返回值
    System.out.println("return leixing=="+ret.toString()); 
   }
  }catch(Throwable e){
   System.err.println(e.getMessage());
  }
 }

}

    这个程序首先取得 method1 类的描述，然后调用 getDeclaredMethods 来获取一系列的 Method 对象，它们分别描述了定义在类中的每一个方法，包括 public 方法、protected 方法、package 方法和 private 方法等。 如果你在程序中使用 getMethods 来代替 getDeclaredMethods ，你还能获得继承来的各个方法的信息。同时你也可以使用Modifier.toString(m.getModifiers())来获取方法的限制属性。
    取得了 Method 对象列表之后，要显示这些方法的参数类型、异常类型和返回值类型等就不难了。这些类型是基本类型还是类类型，都可以由描述类的对象按顺序给出。
    输出的结果如下：
   name==main
decl class==class com.inspur.reflect.Methodtest1
param[0]==class [Ljava.lang.String;
return leixing==void
name==abc
decl class==class com.inspur.reflect.Methodtest1
param[0]==class java.lang.Object
param[1]==int
execption[0]==class java.lang.NullPointerException
return leixing==int    4.获取构造器信息
    获取类构造器的用法与上述获取方法的用法类似，如：
    import java.lang.reflect.*;
    public class constructor1 {
        public constructor1() {
        }
        protected constructor1(int i, double d) {
        }
        public static void main(String args[]) {
            try {
                Class cls = Class.forName("constructor1");
                Constructor ctorlist[] = cls.getDeclaredConstructors();
                for (int i = 0; i < ctorlist.length; i++) {
                    Constructor ct = ctorlist[i];
                    System.out.println("name = " + ct.getName());
                    System.out.println("decl class = " + ct.getDeclaringClass());
                    Class pvec[] = ct.getParameterTypes();
                    for (int j = 0; j < pvec.length; j++)
                        System.out.println("param #" + j + " " + pvec[j]);
                    Class evec[] = ct.getExceptionTypes();
                    for (int j = 0; j < evec.length; j++)
                        System.out.println("exc #" + j + " " + evec[j]);
                    System.out.println("-----");
                }
            } catch (Throwable e) {
                System.err.println(e);
            }
        }
    }
    这个例子中没能获得返回类型的相关信息，那是因为构造器没有返回类型。
这个程序运行的结果是：
    name = constructor1
    decl class = class constructor1
    -----
    name = constructor1
    decl class = class constructor1
    param #0 int
    param #1 double
    -----
    5.获取类的字段(域)
    找出一个类中定义了哪些数据字段也是可能的，下面的代码就在干这个事情： 
    import java.lang.reflect.*;
    public class field1 {
        private double d;
        public static final int i = 37;
        String s = "testing";
        public static void main(String args[]) {
            try {
                Class cls = Class.forName("field1");
                Field fieldlist[] = cls.getDeclaredFields();
                for (int i = 0; i < fieldlist.length; i++) {
                    Field fld = fieldlist[i];
                    System.out.println("name = " + fld.getName());
                    System.out.println("decl class = " + fld.getDeclaringClass());
                    System.out.println("type = " + fld.getType());
                    int mod = fld.getModifiers();
                    System.out.println("modifiers = " + Modifier.toString(mod));
                    System.out.println("-----");
                }
            } catch (Throwable e) {
                System.err.println(e);
            }
        }
    }
    这个例子和前面那个例子非常相似。例中使用了一个新东西 Modifier，它也是一个 reflection 类，用来描述字段成员的修饰语，如“private int”。这些修饰语自身由整数描述，而且使用 Modifier.toString 来返回以“官方”顺序排列的字符串描述 (如“static”在“final”之前)。这个程序的输出是：
    name = d
    decl class = class field1
    type = double
    modifiers = private
    -----
    name = i
    decl class = class field1
    type = int
    modifiers = public static final
    -----
    name = s
    decl class = class field1
    type = class java.lang.String
    modifiers =
    -----
    和获取方法的情况一下，获取字段的时候也可以只取得在当前类中申明了的字段信息 (getDeclaredFields)，或者也可以取得父类中定义的字段 (getFields) 。
    6.根据方法的名称来执行方法
    文本到这里，所举的例子无一例外都与如何获取类的信息有关。我们也可以用 reflection 来做一些其它的事情，比如执行一个指定了名称的方法。下面的示例演示了这一操作：
    import java.lang.reflect.*;
    public class method2 {
        public int add(int a, int b) {
            return a + b;
        }
        public static void main(String args[]) {
            try {
                Class cls = Class.forName("method2");
                Class partypes[] = new Class[2];
                partypes[0] = Integer.TYPE;
                partypes[1] = Integer.TYPE;
                Method meth = cls.getMethod("add", partypes);
                method2 methobj = new method2();
                Object arglist[] = new Object[2];
                arglist[0] = new Integer(37);
                arglist[1] = new Integer(47);
                Object retobj = meth.invoke(methobj, arglist);
                Integer retval = (Integer) retobj;
                System.out.println(retval.intValue());
            } catch (Throwable e) {
                System.err.println(e);
            }
        }
    }
假如一个程序在执行的某处的时候才知道需要执行某个方法，这个方法的名称是在程序的运行过程中指定的 (例如，JavaBean 开发环境中就会做这样的事)，那么上面的程序演示了如何做到。
    上例中，getMethod 用于查找一个具有两个整型参数且名为 add 的方法。找到该方法并创建了相应的 Method 对象之后，在正确的对象实例中执行它。执行该方法的时候，需要提供一个参数列表，这在上例中是分别包装了整数 37 和 47 的两个 Integer 对象。执行方法的返回的同样是一个 Integer 对象，它封装了返回值 84。
    7.创建新的对象
    对于构造器，则不能像执行方法那样进行，因为执行一个构造器就意味着创建了一个新的对象 (准确的说，创建一个对象的过程包括分配内存和构造对象)。所以，与上例最相似的例子如下：
    import java.lang.reflect.*;
    public class constructor2 {
        public constructor2() {
        }
        public constructor2(int a, int b) {
            System.out.println("a = " + a + " b = " + b);
        }
        public static void main(String args[]) {
            try {
                Class cls = Class.forName("constructor2");
                Class partypes[] = new Class[2];
                partypes[0] = Integer.TYPE;
                partypes[1] = Integer.TYPE;
                Constructor ct = cls.getConstructor(partypes);
                Object arglist[] = new Object[2];
                arglist[0] = new Integer(37);
                arglist[1] = new Integer(47);
                Object retobj = ct.newInstance(arglist);
            } catch (Throwable e) {
                System.err.println(e);
            }
        }
    }
    根据指定的参数类型找到相应的构造函数并执行它，以创建一个新的对象实例。使用这种方法可以在程序运行时动态地创建对象，而不是在编译的时候创建对象，这一点非常有价值。
    （这里如果使用无参构造器创建对象的话，这可以直接使用Class.forName("...").newInstance();来创建对象）
    8.改变字段(域)的值
    reflection 的还有一个用处就是改变对象数据字段的值。reflection 可以从正在运行的程序中根据名称找到对象的字段并改变它，下面的例子可以说明这一点：
    import java.lang.reflect.*;
    public class field2 {
        public double d;
        public static void main(String args[]) {
            try {
                Class cls = Class.forName("field2");
                Field fld = cls.getField("d");
                field2 f2obj = new field2();
                System.out.println("d = " + f2obj.d);
                fld.setDouble(f2obj, 12.34);
                System.out.println("d = " + f2obj.d);
            } catch (Throwable e) {
                System.err.println(e);
            }
        }
    }
    这个例子中，字段 d 的值被变为了 12.34。
    9.使用数组
    本文介绍的 reflection 的最后一种用法是创建的操作数组。数组在 Java 语言中是一种特殊的类类型，一个数组的引用可以赋给 Object 引用。观察下面的例子看看数组是怎么工作的：
    import java.lang.reflect.*;
    public class array1 {
        public static void main(String args[]) {
            try {
                Class cls = Class.forName("java.lang.String");
                Object arr = Array.newInstance(cls, 10);
                Array.set(arr, 5, "this is a test");
                String s = (String) Array.get(arr, 5);
                System.out.println(s);
            } catch (Throwable e) {
                System.err.println(e);
            }
        }
    }
    例中创建了 10 个单位长度的 String 数组，为第 5 个位置的字符串赋了值，最后将这个字符串从数组中取得并打印了出来。
    下面这段代码提供了一个更复杂的例子：
    import java.lang.reflect.*;
    public class array2 {
        public static void main(String args[]) {
            int dims[] = new int[]{5, 10, 15};
            Object arr = Array.newInstance(Integer.TYPE, dims);
            Object arrobj = Array.get(arr, 3);
            Class cls = arrobj.getClass().getComponentType();
            System.out.println(cls);
            arrobj = Array.get(arrobj, 5);
            Array.setInt(arrobj, 10, 37);
            int arrcast[][][] = (int[][][]) arr;
            System.out.println(arrcast[3][5][10]);
        }
    }
    例中创建了一个 5 x 10 x 15 的整型数组，并为处于 [3][5][10] 的元素赋了值为 37。注意，多维数组实际上就是数组的数组，例如，第一个 Array.get 之后，arrobj 是一个 10 x 15 的数组。进而取得其中的一个元素，即长度为 15 的数组，并使用 Array.setInt 为它的第 10 个元素赋值。
    注意创建数组时的类型是动态的，在编译时并不知道其类型。

本篇文章为在工作中使用JAVA反射的经验总结，也可以说是一些小技巧，以后学会新的小技巧，会不断更新。

        在开始之前，我先定义一个测试类Student，代码如下：

  1. package chb.test.reflect;   
  2.   
  3. public class Student {   
  4.     private int age;   
  5.     private String name;   
  6.     public int getAge() {   
  7.         return age;   
  8.      }   
  9.     public void setAge(int age) {   
  10.         this.age = age;   
  11.      }   
  12.     public String getName() {   
  13.         return name;   
  14.      }   
  15.     public void setName(String name) {   
  16.         this.name = name;   
  17.      }   
  18.        
  19.     public static void hi(int age,String name){   
  20.          System.out.println("大家好，我叫"+name+"，今年"+age+"岁");   
  21.      }   
  22. }<PRE></PRE>  

一、JAVA反射的常规使用步骤

    反射调用一般分为3个步骤：

  • 得到要调用类的class
  • 得到要调用的类中的方法(Method)
  • 方法调用(invoke)

     代码示例：

  1. Class cls = Class.forName("chb.test.reflect.Student");   
  2. Method m = cls.getDeclaredMethod("hi",new Class[]{int.class,String.class});   
  3. m.invoke(cls.newInstance(),20,"chb");<PRE></PRE>  

二、方法调用中的参数类型

        在方法调用中，参数类型必须正确，这里需要注意的是不能使用包装类替换基本类型，比如不能使用Integer.class代替int.class。

       如我要调用Student的setAge方法，下面的调用是正确的：

  1. Class cls = Class.forName("chb.test.reflect.Student");   
  2. Method setMethod = cls.getDeclaredMethod("setAge",int.class);   
  3. setMethod.invoke(cls.newInstance(), 15);<PRE></PRE>  

 

       而如果我们用Integer.class替代int.class就会出错，如：

  1. Class cls = Class.forName("chb.test.reflect.Student");   
  2. Method setMethod = cls.getDeclaredMethod("setAge",Integer.class);   
  3. setMethod.invoke(cls.newInstance(), 15);<PRE></PRE>  

 

       jvm会报出如下异常：

  1. java.lang.NoSuchMethodException: chb.test.reflect.Student.setAge(java.lang.Integer)   
  2.      at java.lang.Class.getDeclaredMethod(Unknown Source)   
  3.      at chb.test.reflect.TestClass.testReflect(TestClass.java:23)<PRE></PRE>  

 

三、static方法的反射调用

 

       static方法调用时，不必得到对象示例，如下：

  1. Class cls = Class.forName("chb.test.reflect.Student");   
  2. Method staticMethod = cls.getDeclaredMethod("hi",int.class,String.class);   
  3. staticMethod.invoke(cls,20,"chb");//这里不需要newInstance   
  4. //staticMethod.invoke(cls.newInstance(),20,"chb");<PRE></PRE>  

四、private的成员变量赋值

    如果直接通过反射给类的private成员变量赋值，是不允许的，这时我们可以通过setAccessible方法解决。代码示例：

  1. Class cls = Class.forName("chb.test.reflect.Student");   
  2. Object student = cls.newInstance();//得到一个实例   
  3. Field field = cls.getDeclaredField("age");   
  4. field.set(student, 10);   
  5. System.out.println(field.get(student));<PRE></PRE>  

 

     运行如上代码，系统会报出如下异常：

  1. java.lang.IllegalAccessException: Class chb.test.reflect.TestClass can not access a member of class chb.test.reflect.Student with modifiers "private"   
  2.      at sun.reflect.Reflection.ensureMemberAccess(Unknown Source)   
  3.      at java.lang.reflect.Field.doSecurityCheck(Unknown Source)   
  4.      at java.lang.reflect.Field.getFieldAccessor(Unknown Source)   
  5.      at java.lang.reflect.Field.set(Unknown Source)   
  6.      at chb.test.reflect.TestClass.testReflect(TestClass.java:20)<PRE></PRE>  

    解决方法：

  1. Class cls = Class.forName("chb.test.reflect.Student");   
  2. Object student = cls.newInstance();   
  3. Field field = cls.getDeclaredField("age");   
  4. field.setAccessible(true);//设置允许访问   
  5. field.set(student, 10);   
  6. System.out.println(field.get(student));<PRE></PRE>  

    其实，在某些场合下(类中有get,set方法)，可以先反射调用set方法，再反射调用get方法达到如上效果，代码示例：

  1. Class cls = Class.forName("chb.test.reflect.Student");   
  2. Object student = cls.newInstance();   
  3.   
  4. Method setMethod = cls.getDeclaredMethod("setAge",Integer.class);   
  5. setMethod.invoke(student, 15);//调用set方法   
  6.                
  7. Method getMethod = cls.getDeclaredMethod("getAge");   
  8. System.out.println(getMethod.invoke(student));//再调用get方法<PRE></PRE>

posted on 2009-01-11 17:28 forgood 阅读(570) 评论(1)  编辑  收藏 所属分类: java

评论

# re: 反射机制补充 2009-01-11 17:52 forgood

JAVA反射机制 
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 
Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。 
1. 得到某个对象的属性 

1 public Object getProperty(Object owner, String fieldName) throws Exception { 
2 Class ownerClass = owner.getClass(); 
3 
4 Field field = ownerClass.getField(fieldName); 
5 
6 Object property = field.get(owner); 
7 
8 return property; 
9 } 
Class ownerClass = owner.getClass()：得到该对象的Class。 

Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。 

Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。 

2. 得到某个类的静态属性 

1 public Object getStaticProperty(String className, String fieldName) 
2 throws Exception { 
3 Class ownerClass = Class.forName(className); 
4 
5 Field field = ownerClass.getField(fieldName); 
6 
7 Object property = field.get(ownerClass); 
8 
9 return property; 
10 } 

Class ownerClass = Class.forName(className) ：首先得到这个类的Class。 

Field field = ownerClass.getField(fieldName)：和上面一样，通过Class得到类声明的属性。 

Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class里取。 

3. 执行某对象的方法 

1 public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception { 
2 
3 Class ownerClass = owner.getClass(); 
4 
5 Class[] argsClass = new Class[args.length]; 
6 
7 for (int i = 0, j = args.length; i < j; i++) { 
8 argsClass[i] = args[i].getClass(); 
9 } 
10 
11 Method method = ownerClass.getMethod(methodName, argsClass); 
12 
13 return method.invoke(owner, args); 
14 } 
Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class。 

5～9行：配置参数的Class数组，作为寻找Method的条件。 

Method method = ownerClass.getMethod(methodName, argsClass)：通过Method名和参数的Class数组得到要执行的Method。 

method.invoke(owner, args)：执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。返回值是Object，也既是该方法的返回值。 

4. 执行某个类的静态方法 

1 public Object invokeStaticMethod(String className, String methodName, 
2 Object[] args) throws Exception { 
3 Class ownerClass = Class.forName(className); 
4 
5 Class[] argsClass = new Class[args.length]; 
6 
7 for (int i = 0, j = args.length; i < j; i++) { 
8 argsClass[i] = args[i].getClass(); 
9 } 
10 
11 Method method = ownerClass.getMethod(methodName, argsClass); 
12 
13 return method.invoke(null, args); 
14 } 

基本的原理和实例3相同，不同点是最后一行，invoke的一个参数是null，因为这是静态方法，不需要借助实例运行。 

5. 新建实例 
1 
2 public Object newInstance(String className, Object[] args) throws Exception { 
3 Class newoneClass = Class.forName(className); 
4 
5 Class[] argsClass = new Class[args.length]; 
6 
7 for (int i = 0, j = args.length; i < j; i++) { 
8 argsClass[i] = args[i].getClass(); 
9 } 
10 
11 Constructor cons = newoneClass.getConstructor(argsClass); 
12 
13 return cons.newInstance(args); 
14 
15 } 

这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance()来实现。 

Class newoneClass = Class.forName(className)：第一步，得到要构造的实例的Class。 

第5～第9行：得到参数的Class数组。 

Constructor cons = newoneClass.getConstructor(argsClass)：得到构造子。 

cons.newInstance(args)：新建实例。 

6. 判断是否为某个类的实例 

1 public boolean isInstance(Object obj, Class cls) { 
2 return cls.isInstance(obj); 
3 } 

7. 得到数组中的某个元素 
1 public Object getByArray(Object array, int index) { 
2 return Array.get(array,index); 
3 } 

alexbxp
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简述反射机制
唔得够
11-02 2183
反射机制 一：反射机制： 反射机制，是java中十分常用的重要特性。 运用反射机制，可以动态的调用某一个对象的特定方法，或读取任意一个JavaBean（公共类）的所有属性，进行赋值等操作。 二：反射的应用 反射可以访问 - - 构造方法，方法，成员变量 1.访问前需要获取Class对象： 获取Class对象的三种方法： 代码 1. 通过Object类的getClass（）方法...
java反射知识点
01-16
这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 我的代码里主要有一下知识点： 1.获取Class对象的三种方式 2.获取构造方法并调用 3.获取成员方法 4.获取成员变量 5.反射数组 6.通过反射...
Java反射机制详解
热门推荐
ChangWen的博客
05-22 1万+
Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。 1、关于Class     1、Class是一个类，一个描述类的类（也就是描述类本身），封装了描述方法的Method，描述字段的Filed，描述构造器的Constructor等属
C++实现反射机制
cxu123321的博客
04-01 680
C++实现反射机制 NET下的很多技术都是基于反射机制来实现的，反射让.NET平台下的语言变得得心应手。最简单的，比如枚举类型，我们我可以很容易的获得一个枚举变量的数值以及其名称字符串。 可是，在C++中，枚举变量本质上和一个整形变量没有区别，我们很难获取一个枚举变量的名称字符串。 其实在C++中，我们可以通过宏来实现类似反射的机制。 接下来，我想总结一下如何在C++中实现一个类似于C#枚...
详解Java反射机制
lmb55的专栏
06-14 745
一、什么是JAVA的反射机制Java反射是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的类的内部信息，包括其方法（诸如public, static 等）、父类（例如Object）、实现接口（例如Cloneable），也包括属性和方法的所有信息，并可于运行时改变属性值或调用方法。Jav
反射机制
D冰城的博客
08-11 678
1.1 反射机制概述 Java的反射机制是Java特性之一，是构建框架技术的所在。所以在我们讲Struts2之前，让我们先来了解一下反射。灵活掌握Java的反射机制，对以后学习框架技术是大有帮助的。 Java反射机制是指在运行时，动态获取类或者对象的信息及动态调用对象的方法的功能。 Java反射具有3个动态性质： A.运行时生成对象实例。 B.运行期
java反射机制的用处_java反射机制原理详解 java的反射机制用处在哪？
weixin_30696571的博客
03-02 310
Java中的反射机制的原理和用途是什么？java反射机制的实现原理java反射机制有什么用,具体举例说明增加程序的灵活性。 如struts中。请CSS布局HTML小编今天和大家分享的派发控制。 当请CSS布局HTML小编今天和大家分享来到时。struts通过查询配置文件。找到该请CSS布局HTML小编今天和大家分享对应的action。已经方法。 然后通过反射实例化action。并调用响应metho...
反射机制调用方法（补充）
yooppa的博客
01-03 228
在之前的博客均是通过反射机制来像传统方式一样操作，比如创建实例化对象 获取类对象以及访问属性… 这次作为补充 是通过反射机制来调用一个对象的方法 代码示例： //在这之前的实例化对象 players p2=new players(); p2.name="dsd"; try{ //一下使用反射机制来创建，利用相应构造器 Class p1=new players().getClass();
PHP - 反射机制(Reflection) - 学习/实践
william_n的博客
04-25 3887
参考: https://www.cnblogs.com/nixi8/p/5176213.html 后续补充...
Java中的反射机制
qq_44383308的博客
06-11 1058
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、反射机制的作用二、反射机制中相关的类三、反射机制中具体功能的实现1.获取类Class的三种方式2.读入数据总结 前言 Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。通过java语言的反射机制可以操作字节码文件。 一、反射机制的作用 1.反编译：.class–&
Java反射机制学习
苏苏爱自由
10-26 2714
一.概念 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。 JAVA反射（放射）机制：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言
2020老杜最新Java零基础进阶视频教程-反射机制课件
12-10
总结来说，Java反射机制是Java面向对象特性的重要补充，它允许程序在运行时动态地获取和修改类的结构和行为，极大地提升了代码的灵活性。然而，使用反射时需权衡其带来的性能损失和潜在的安全风险，合理地在灵活性和...
leon9dragon#all_blogs#086.JAVA反射机制_反射操作的方法补充1
07-25
1. 反射其他相关 API1.1. Class 类中的一些操作方法1. 反射其他相关 API1.1. Class 类中的一些操作方法定义:作用:返回此类或接口以
java中反射的概念
08-01
总的来说，Java反射机制是面向对象编程的一个重要补充，它扩展了Java程序的动态性，允许程序员在运行时访问和操作类的内部结构，增强了代码的灵活性。理解和熟练掌握反射技术，对于提升Java编程能力，尤其是处理复杂...
JAVA语言程序设计补充材料及例题代码
11-08
11. **反射**：Java反射机制允许在运行时动态访问和修改类的信息，如创建对象、调用方法、访问字段等。 12. **集合框架的新特性**：在Java 8及以上版本，集合框架增加了Lambda表达式、Stream API、Optional类等新...
Arcmap天地图历史影像插件全国版-免费！免费！
07-22
2024版“天地图”首次开放多时相影像专题，公众可查看32个省级天地图节点近半个世纪的历史影像；本arcmap插件集成了全国天地图历史影像接口，累计上千期。 免费使用。不收费！！不收费！！不收费！！
毕业设计javajsp网上服装商城管理系统ssh-qkrp源码含文档工具包
07-22
毕业设计javajsp网上服装商城管理系统ssh-qkrp源码含文档工具包 后台是ssh框架，页面是jsp，数据库mysql，jdk1.8，开发工具用ecplise、myecplise、sts、idea都可以 通过网上交易这个平台，我们足不出户就可以了解商品的信息和价格，不仅方便了用户也为用户节约了时间，系统的主要功能就是：商品类别管理、商品信息管理、订单管理、会员管理、系统公告管理等。分为管理员用户、会员用户这二种用户平台。 包含：源码、数据库脚本、论文、环境工具包、相同框架项目的安装教程（在说明文档中）
mysql安装配置教程
07-22
MySQL的安装和配置过程可能因操作系统和版本而异，但以下是一些通用的步骤，适用于大多数情况： ### Windows系统安装MySQL： 1. **下载MySQL Installer**： - 访问[MySQL官方网站](https://dev.mysql.com/downloads/installer/)下载MySQL Installer。 2. **启动MySQL Installer**： - 运行下载的安装程序。 3. **选择安装类型**： - 选择“Developer Default”安装类型，它包括MySQL Server和常用的开发工具。 4. **配置MySQL Server**： - 在“Server Instance Configuration”中，输入root用户的密码，并配置MySQL的安装路径。 5. **详细配置**： - 根据需要配置MySQL Server的详细设置，如字符集、默认存储引擎等。 6. **安装**： - 检查配置，然后点击“Execute”开始安装。 7. **安装完成**： -
文化娱乐-微博情感分析-含实验报告-约150行（分词、朴素贝叶斯模型）.rar
最新发布
07-22
数据可视化实例的python实现，可供学习了解
java反射和注解的原理
02-17
Java反射（Reflection）是指在运行时动态地获取类的信息，包括类的属性、方法、构造器等...在编译时，Java编译器会将注解信息保存到类文件中，通过反射机制可以在运行时获取这些注解信息，从而实现对程序的控制和操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值