精华内容
下载资源
问答
  • java反射机制创建对象实现:java 深度拷贝 -超完美 ,自己做的,下面  package aop; public class Student { private String name; private int age; public String getName() { return name; } public ...
  • 反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息,并能直接操作任意对象的内部属性及方法。 框架=反射+注解+设计模式   1.是什么? 加载完类之后,在堆内的方法区中就产生了一个Class类型的...
  • JAVA反射机制创建对象

    千次阅读 2017-12-15 16:04:49
    在实际开发过程中,JAVA的反射技术应用广泛,尤其是在一些广泛使用的框架中,如Spring、mybatis中更是大量使用。java语言并不是一种动态语言,也就是说在运行时不能改变程序结构或者变量类型,但是JAVA提供了反射...
    在实际开发过程中,JAVA的反射技术应用广泛,尤其是在一些广泛使用的框架中,如Spring、mybatis中更是大量使用。java语言并不是一种动态语言,也就是说在运行时不能改变程序结构或者变量类型,但是JAVA提供了反射技术,可以让我们在运行时加载所需要的类。反射的英文单词是reflect,也可以翻译成为映像,个人认为叫映像可能更好理解一些。反射技术就是在程序运行时将所需要的类通过Class.forname将类影响交给使用者使用。先看一下使用new创建类对象的方式:
    public class newServiceImpl {
        private String name;
        public newServiceImpl(){
        }
        public newServiceImpl(String name){
            this.name = name;
        }
        
        public void sayHello(String name){
            System.err.println("Hello " + name);
        }
        
        public void sayHello(){
            System.err.println("Hello " + this.name);
        }
    }
    在newServiceImpl类中,有两个构造函数和两个sayHello方法,使用这个类的方法如下:
    public class NewTest {
    public static void main(String[] args) {
    	// TODO Auto-generated method stub
    		
    	newServiceImpl ns1 = new newServiceImpl("newService");
    	ns1.sayHello();
    	newServiceImpl ns2 = new newServiceImpl();
    	ns2.sayHello("newService2");
        }
    }
    在设立我们使用了new关键字来创建类对象,这时,在编译的时候就会将newServiceImpl类加载进来并且构造。而反射机制,可以这样操作:
    package com.springstudy.reflect;
    public class ReflectServiceImpl {
    private String name;
    public ReflectServiceImpl(){
    }
    public ReflectServiceImpl(String name){
        this.name = name;
    }
    public void sayHello(){
        System.err.println("Hello " + this.name);
    }
    public void sayHello(String name){
        System.err.println("Hello " + name);
    }
    使用这个类:
    import java.lang.reflect.InvocationTargetException;
    public class ReflectTest {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ReflectServiceImpl rs1 = getInstance();
        rs1.sayHello("reflectservice1");
        ReflectServiceImpl rs2 = getInstance2();
        rs2.sayHello();
    }
    public static ReflectServiceImpl getInstance(){
        ReflectServiceImpl object = null;
        try{
            object = (ReflectServiceImpl)Class.forName("com.springstudy.reflect.ReflectServiceImpl").newInstance();
        }catch(ClassNotFoundException|InstantiationException|IllegalAccessException ex){
            ex.printStackTrace();
        }
        return object;
    }
    public static ReflectServiceImpl getInstance2(){
        ReflectServiceImpl object = null;
        try{
    object = (ReflectServiceImpl)Class.forName("com.springstudy.reflect.ReflectServiceImpl").
    getConstructor(String.class).newInstance("reflectservice2");
    }catch (ClassNotFoundException | InstantiationException 
    | IllegalAccessException | NoSuchMethodException 
    | SecurityException | IllegalArgumentException 
    | InvocationTargetException ex) {
        ex.printStackTrace();
        }
        return object;
        }
    }
    JAVA的反射机制是通过java.lang.reflect.*来实现的,在这里,我们使用
    (ReflectServiceImpl)Class.forName("com.springstudy.reflect.ReflectServiceImpl").newInstance();
    (ReflectServiceImpl)Class.forName("com.springstudy.reflect.ReflectServiceImpl").getConstructor(String.class).newInstance("reflectservice2");
    在运行的时候来构造无参数构造器或有参数构造器的对象,实现运行时创建使用类对象的方式,这就是通过JAVA的反射机制来创建对象的方法,JAVA的反射机制内部实现非常的复杂,感兴趣的人可以在网上找资料看看它的实现机制。

    展开全文
  • java.lang.Class类和反射机制创建对象

    万次阅读 2015-11-24 00:12:02
    java.lang.Class类  Java程序在运行时,Java运行时系统一直对所有的对象进行所谓的运行时...Class类封装一个对象和接口运行时的状态,当装载类时,Class类型的对象自动创建。  Class 没有公共构造方法。Class 对象

                      java.lang.Class类

        Java程序在运行时,Java运行时系统一直对所有的对象进行所谓的运行时类型标识。这项信息纪录了每个对象所属的类。虚拟机通常使用运行时类型信息选准正确方法去执行,用来保存这些类型信息的类是Class类。Class类封装一个对象和接口运行时的状态,当装载类时,Class类型的对象自动创建。

          Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的,因此不能显式地声明一个Class对象。 
          虚拟机为每种类型管理一个独一无二的Class对象。也就是说,每个类(型)都有一个Class对象。运行程序时,Java虚拟机(JVM)首先检查是否所要加载的类对应的Class对象是否已经加载。如果没有加载,JVM就会根据类名查找.class文件,并将其Class对象载入。
          基本的 Java 类型(boolean、byte、char、short、int、long、float 和 double)和关键字 void 也都对应一个 Class 对象。 
          每个数组属于被映射为 Class 对象的一个类,所有具有相同元素类型和维数的数组都共享该 Class 对象。

          一般某个类的Class对象被载入内存,它就用来创建这个类的所有对象。

    一、获取Class实例的三种方式:
         (1)利用对象调用getClass()方法获取该对象的Class实例;
         (2)使用Class类的静态方法forName(),用类的名字获取一个Class实例(staticClass forName(String className)  Returns the Classobject associated with the class or interface with the given stringname. );
         (3)运用.class的方式来获取Class实例,对于基本数据类型的封装类,还可以采用.TYPE来获取相对应的基本数据类型的Class实例
       在newInstance()调用类中缺省的构造方法 ObjectnewInstance()(可在不知该类的名字的时候,常见这个类的实例) Creates a new instance of the class represented by this Classobject.
       在运行期间,如果我们要产生某个类的对象,Java虚拟机(JVM)会检查该类型的Class对象是否已被加载。如果没有被加载,JVM会根据类的名称找到.class文件并加载它。一旦某个类型的Class对象已被加载到内存,就可以用它来产生该类型的所有对象

    public class ClassTest {
         public static void main(String [] args)throws Exception{
             String str1="abc";
             Class cls1=str1.getClass();
             Class cls2=String.class;
             Class cls3=Class.forName("java.lang.String");
             System.out.println(cls1==cls2);
             System.out.println(cls1==cls3);
         }
     }

    返回结果为:true,true.
    解释: 虚拟机只会产生一份字节码, 用这份字节码可以产生多个实例对象。

    二、Class类的常用方法
        1、getName() 
        一个Class对象描述了一个特定类的属性,Class类中最常用的方法getName以 String 的形式返回此 Class 对象所表示的实体(类、接口、数组类、基本类型或 void)名称。

        2、newInstance()
        Class还有一个有用的方法可以为类创建一个实例,这个方法叫做newInstance()。例如:
        x.getClass.newInstance(),创建了一个同x一样类型的新实例。newInstance()方法调用默认构造器(无参数构造器)初始化新建对象。
        3、getClassLoader() 
        返回该类的类加载器。
        4、getComponentType() 
        返回表示数组组件类型的 Class。
        5、getSuperclass() 
        返回表示此 Class 所表示的实体(类、接口、基本类型或 void)的超类的 Class。
        6、isArray() 
        判定此 Class 对象是否表示一个数组类。
    三、Class的一些使用技巧
        1、forName和newInstance结合起来使用,可以根据存储在字符串中的类名创建对象。例如
        Object obj = Class.forName(s).newInstance();
        2、虚拟机为每种类型管理一个独一无二的Class对象。因此可以使用==操作符来比较类对象。例如:
        if(e.getClass() == Employee.class)...

    反射

          反射就是把Java类中的各种成分映射成相应的java类。例如,一个Java类中用一个Class类的对象来表示,一个类中的组成部分:成员变量,方法,构造方法,包等等信息也用一个个的Java类来表示,就像汽车是一个类,汽车中的发动机,变速箱等等也是一个个的类。表示Java类的Class类显示要提供一系列的方法,来获得其中的变量,方法,构造方法,修饰符,包等信息,这些信息就是用相应类的实例对象来表示,它们是Field、Method、Contructor、Package等等。

          一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示,通过调用Class类的方法可以的得到这些实例对象后,得到这些实例对象后有什么用呢?怎么用呢?这正是学习和应用反射的要点。

    构造方法的反射应用

    Consturctor(构造器)类代表某个类中的一个构造方法

    @1@ 得到某个类所有的构造方法:例如:Constructor [] constructors = Class.forName("java.lang.String").getConstructors();

    @2@ 得到某一个构造方法:例如:Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);

    @3@ 创建实例对象:通常方式:String str=new String(new StringBuffer("abc"));
                                反射方式:String str=(String) constructor.newInstance(new StringBuffer("abc"));

    Java反射机制创建对象

    package lxf;  
    import java.lang.reflect.Constructor;  
    import java.lang.reflect.Field;  
    import java.lang.reflect.Method;  
      
    class Person {  
        private String name;  
        private int age;  
      
        public Person(String name, int age) {  
            this.name = name;  
            this.age = age;  
        }  
      
        public Person() {  
            // TODO Auto-generated constructor stub  
        }  
      
        public String getName() {  
            return name;  
        }  
      
        public void setName(String name) {  
            this.name = name;  
        }  
      
        public int getAge() {  
            return age;  
        }  
      
        public void setAge(int age) {  
            this.age = age;  
        }  
      
    }  
      
    /** 
     * 使用反射机制来创建对象 
     *  
     * @author lxf 
     * @time 2014-4-8下午05:08:41 
     *  
     */  
    public class CreateObject {  
      
        /** 
         * Java的反射机制是指:反射就是把Java类中的各种成分映射成相应相应的Java类, 然后就可以获取这个类的所有信息 
         *  
         * @throws Exception 
         */  
        public static void createObj1() throws Exception {  
            // 返回与带有给定字符串名的类或接口相关联的 Class 对象。  
            // Class classType = Person.class;  
            Class classType = Class.forName("lxf.Person");  
            Object obj = classType.newInstance();  
            System.out.println("使用反射反射机制创建出来的对象是否是Person类的对象:"  
                    + (obj instanceof Person));  
        }  
      
        /** 
         * 创建带有构造参数的对象的时候我们需要使用另外一种方式即: 1.先获取操作类的Class对象即字节码文件 
         * 2.使用Class对象的getConstructor 
         * (parameterTypes)方法获取该对象的构造方法的对象,注意括号中可以带不等的可变参数, 
         * 3.使用构造方法对象的newInstance(initargs)方法就可以实例化一个对象 4.注意,使用这些方法都不可以访问被 
         * private修饰的方法,需要设置某些访问权限setAccessable()方法 
         *  
         * @throws Exception 
         */  
        public static void createObj2() throws Exception {  
            @SuppressWarnings("rawtypes")  
            Class classType = Person.class;  
      
            @SuppressWarnings("unchecked")  
            Constructor<Person> con = classType.getConstructor(String.class,  
                    int.class);  
            Object obj = con.newInstance("lxf", 23);  
            System.out.println("使用constructor对象的newInstance方法创建对象的信息:"  
                    + ((Person) obj).getName());  
        }  
      
        /** 
         * 操作方法包括(private方法) 步骤: 1.首先获取要操作类的Class对象 
         * 2.然后通过Class对象的getMethod方法获取要操作的方法的Method对象(两个参数,第一个参数是方法名,第二个参数是参数类型) 
         * 3.调用Method的方法的invoke方法(两个参数,第一个参数是该方法属于的类对象,具体参数) 
         * 4.当方法被private修饰的时候,首先需要调用getDeclaredMethod()方法获取要操作的被private修饰的类。 
         * 在这里要注意这个getDeclaredMethod方法,它既可以用作获取普通方法的对象也可以用来操作private修饰的方法, 
         * 但是操作private修饰的方法的时候,必须使用这个方法,其它方法不可以。普通方法还可以使用getMethod方法, 
         * 且属性操作也是如此。另外,还需要设置访问权限setAccessable(true)才可以 
         *  
         * @throws Exception 
         */  
        public static void methodDo() throws Exception {  
            Person p = new Person();  
            Class classType = Person.class;  
            Method method = classType.getMethod("setName", String.class);  
            method.invoke(p, "ckl");  
            System.out.println("使用反射操作SetName方法后,Person对象的name值是:" + p.getName());  
      
            Method method2 = classType.getDeclaredMethod("test");  
            method2.setAccessible(true);  
            method2.invoke(p);  
        }  
      
        /** 
         * 操作字段 
         *  
         * @throws Exception 
         */  
        public static void FieldDo() throws Exception {  
            Person p = new Person();  
            Class classType = Person.class;  
            Field field = classType.getDeclaredField("name");  
            Field field2 = classType.getDeclaredField("age");  
            field.setAccessible(true);  
            field2.setAccessible(true);  
            field.set(p, "lxf");  
            field2.set(p, 23);  
            System.out.println("使用反射机制操作被private修饰的对象字段后得到的属性值是:" + p.getName());  
            System.out.println("使用反射机制操作被private修饰的对象字段后得到的属性值是:" + p.getAge());  
        }  
      
        public static void main(String[] args) throws Exception {  
            new CreateObject().FieldDo();  
        }  
      
    }


    根据以上代码:.使用反射机制创建对象的步骤如下:
    1、先声明你要创建的对象的类全称;使用Class类的静态方法forName(String.className)加载这个类的字节码(注意,加载字节码不等于实例化对象) ,返回 一个Class对象,这个对象代表的是一个字节码文件。

    2、调用这个类对象(字节码)的方法newInstance()方法(注意:这里的这个newInstance方法默认调用默认的构造方法即调用无参的构造方法, 一旦构造方法有参数时,此方法行不通,需要使用构造方法的对象的相关方法来 实例化)实例化类Person,返回的是Object类型
    3、强制转换成Person类型即你所需类型
    而获得Class对象的方法还有:
    Class c = Class.forName("java.lang.String");这条语句得到一个 String 类的类对象。还有另一种方法,如下面的语句:Class c = int.class; 或者 Class c = Integer.TYPE;它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Integer) 中预先定义好的 TYPE 字段。
    到此反射基本操作就结束了,详细方法可参看API。


    参考:http://lavasoft.blog.51cto.com/62575/15433/
         http://blog.csdn.net/smartboy_01/article/details/23201391





    展开全文
  • C#利用反射机制创建对象

    千次阅读 2019-09-25 14:47:11
    反射”其实就是利用程序集的元数据信息。 反射可以有很多方法,编写程序时请先导入 System.Reflection 命名空间。 1、假设你要反射一个 DLL 中的类,并且没有引用它(即未知的类型): Assembly assembly = ...

    “反射”其实就是利用程序集的元数据信息。 反射可以有很多方法,编写程序时请先导入 System.Reflection 命名空间。

    1、假设你要反射一个 DLL 中的类,并且没有引用它(即未知的类型): 
    Assembly assembly = Assembly.LoadFile("程序集路径,不能是相对路径"); // 加载程序集(EXE 或 DLL) 
    dynamic obj = assembly.CreateInstance("类的完全限定名(即包括命名空间)"); // 创建类的实例 

    2、若要反射当前项目中的类(即当前项目已经引用它了)可以为:

    Assembly assembly = Assembly.GetExecutingAssembly(); // 获取当前程序集 
    dynamic obj = assembly.CreateInstance("类的完全限定名(即包括命名空间)"); // 创建类的实例,返回为 object 类型,需要强制类型转换

    3、也可以为:

    Type type = Type.GetType("类的完全限定名"); 
    dynamic obj = type.Assembly.CreateInstance(type); 

    4、不同程序集的话,则要装载调用,代码如下:
    System.Reflection.Assembly.Load("程序集名称(不含文件后缀名)").CreateInstance("命名空间.类名", false);
    如:
    dynamic o = System.Reflection.Assembly.Load("MyDll").CreateInstance("MyNameSpace.A", false);

    5、根据对象实例创建该对象所属类的新对象
    Type type = protocol.GetType(); //获取protocol类型

    Assembly assembly = Assembly.GetExecutingAssembly(); // 获取当前程序集

    string name = type.FullName;

    IProtocol obj = (IProtocol)assembly.CreateInstance(name); //根据类名获得新对象

    注意:由于要用到dynamic ,需要把target 改为4.0 ,如果编译时出现“找不到编译动态表达式所需的一个或多个类型。是否缺少引用?”的错误,是因为缺少一个引用,在项目里引用Miscorsoft.CSharp类库,添加后就能编译成功。

    摘自:http://www.cnblogs.com/feiyuhuo/p/5793606.html

    展开全文
  • JAVA中通过反射机制用构造方法创建对象 public class ConstructorTest01 { public static void main(String[] args) throws Exception{ Class c = Class.forName("reflection.constructor.UserService"); //调用...

    JAVA中通过反射机制用构造方法创建对象

    public class ConstructorTest01 {
        public static void main(String[] args) throws Exception{
            Class c = Class.forName("reflection.constructor.UserService");
            //调用无参构造方法创建对象
            Object o1 = c.newInstance();
    
            //通过形参列表确认要创建的构造器对象
            Constructor con = c.getDeclaredConstructor(String.class, int.class, boolean.class);
            Object newObj = con.newInstance("jack", 20, true);
            System.out.println(newObj);
            
            //获取无参构造方法
            Constructor con2 = c.getDeclaredConstructor();
            Object newObj2 = con2.newInstance();
            System.out.println(newObj2);
        }
    }
    

    测试类:

    public class UserService {
        String name;
        int age;
        boolean sex;
    
        public UserService() {
            System.out.println("调用了无参构造方法");
        }
    
        public UserService(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public UserService(String name, int age, boolean sex) {
            this.name = name;
            this.age = age;
            this.sex = sex;
            System.out.println("调用了有参数构造方法");
        }
    
        @Override
        public String toString() {
            return "UserService{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", sex=" + sex +
                    '}';
        }
    }
    
    
    展开全文
  • 一.Java反射机制1.什么是反射:反射就是把Java类中的各种成份影射成一个个的Java对象。例:一个类有:成员变量,方法,构造方法等,包等等信息,利用反射技术可以对一个类进行剖析,把各个组成部分影射成一个个对象...
  • Java反射机制创建对象

    万次阅读 多人点赞 2014-04-08 18:48:46
    使用反射机制创建对象的步骤如下: 1、先声明你要创建的对象的类全称;使用Class类的静态方法forName(String.className)加载这个类的字节码(注意,加载字节码不等于实例化对象) ,返回 一个Class对象,这个对象...
  • 通过反射创建对象

    千次阅读 2018-05-17 11:24:00
    通过反射创建对象的两种方法1.通过Class字节码对象newInstance();(默认通过无参构造创建)2.通过获取构造器getConstructor(Class&lt;?&gt;..parameterTypes);(通过有参的构造器,参数可以指定具体类型和多...
  • 下面小编就为大家带来一篇Java通过反射机制动态设置对象属性值的方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 什么是反射创建对象的角度上来看,狭义的说,比如有个 class A ,你能直接 new A() 来创建 对象。...这种把 class 作为变量,又能在运行时创建对象机制,就叫做反射。 大部分的高级编程语言,先天是...
  • 反射机制 : 指的是程序在运行时能够获取自身的信息。在java中,只要给定类的名字,那么就可以通过反射机制来获得类的所有属性和方法。 反射可以创建类的对象. newInstance()方法可以创建类的实例.那么拥有该方法...
  • // 通过反射机制创建对象,给属性赋值 Class c = Class.forName(className); Object obj = c.newInstance(); String methodName = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName....
  • python使用反射机制实例化对象

    万次阅读 2018-01-19 22:06:44
    然后通过获取A的所有子类对象,用反射机制实例化对象,再调用数据查询的方法来完成所有类别的数据解析工作,这样如果再新增一个类别,只需要再添加一个A的子类对象即可。 例子: 项目结构如下:
  • JAVA反射机制 java反射机制是在运行状态中,对于任意一个类, ...这种动态获取的信息以及动态调用对象的方法的功能称为JAVA语言的反射机制。 巧妙的利用java中的反射机制,能够帮助我们进行程序开发时达到意想不到...
  • 深入理解Java类型信息(Class对象)与反射机制

    万次阅读 多人点赞 2017-05-01 23:19:19
    【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权) ...深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解
  • class Demo { public static void main(String[] args) { ... //根据类名获取Class对象 Class c = Class.forName("Test"); //参数类型数组 Class[] parameterTypes={int.class,int.class}; /
  • Class类2.1 常用方法和示例2.2 获取Class对象的 3 种方法2.3 反射创建对象的 2 种方法3. 工厂设计模式(示例) 1.Java反射机制 1.1 反射机制是什么 在运行状态中,对于任意一个类都能够知道这个类所有的属性和方法...
  • java通过反射创建对象的两种方式与区别 1.使用Class对象的newInstance()方法来创建对象: 具体步骤是: 1、获取类的Class对象(有三种方式可以获取,可以自行百度一下) 2、通过调用所获取到的Class对象的newInstance...
  • 反射:使用反射调用构造器创建对象

    千次阅读 2017-07-03 13:01:17
    为什么使用反射创建对象,为什么不直接来new呢? 在框架中,提供给我们的都是字符串. ----------------------------------------------------------- 使用反射创建对象: 步骤:  1);找到构造器所在类的字节码对象....
  • 在通常情况下,如果有一个类,可以通过类创建对象;但是反射就是要求通过一个对象找到一个类的名称;   2:在反射操作中,握住一个核心概念: 一切操作都将使用Object完成,类,数组,的引用都可以使用Object...
  • 在java的世界中,java有类这一个概念,java对象是java类的一个实例,这里就不画uml图了,这都是很简单的概念。 那么问题来了,类的是谁的对象实例呢?从其他的语言上,我们或多或少回听说,一切皆是组件啊,一切皆是...
  • java 的反射机制可以很好的为我们解决这个问题: 使用 Class onwClass = Class.forName(classPath); 获取类的定义 如果你实例这个对象的时候 这个类的构造函数带参数那么 你可以使用: Constructor con = ...
  • JSP中通过反射机制创建javaBean对象

    千次阅读 2017-08-25 16:12:46
    out.print(session.getAttribute("user")); %> 在jsp文件中,可以调用jsp的动作:useBean去创建javaBean对象。 前提:被创建对象的类必须符合javaBean结构,即: ...id:是指向对象的引用class:需要被创建对象
  • 总结一下今天所学,我们在学习java的时候,总会多多少少的听到过反射机制,但是我们好像听过之后就过去了,从来没去了解过它,然后平时做东西,也没有用到过。久而久之就慢慢给淡忘了。有时候面试的时候会被问道,你...
  • 转载请注明来源 赖赖的博客前景概要在 01 走进Spring,Context、Bean和IoC 中,我们看到了强大的Spring通过ApplicationContext实现了bean工厂(也就是对象工厂),那究竟是怎么实现的呢,本次给大家写一个小Demo展现...
  • 自学毕向东老师java基础课程...最近看到反射机制这一节,其他都没有问题,就是在创建带参对象时遇到一点问题,我们从头说起! 首先,我创建一个Person类: class Person { private int age; private String n
  • 利用java反射机制动态创建对象

    千次阅读 2011-10-22 17:51:15
    // 把JSON string 转化成类的对象public static T bindModel(String content, Class cls) { try { JSONObject mjson = new JSONObject(content); try { T instance = cls.newInstance(); Iterator ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 151,248
精华内容 60,499
关键字:

反射机制创建对象