精华内容
下载资源
问答
  • 主要介绍了java通过反射创建对象并调用方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 反射创建对象和正常对象的底层理解 1. java 利用反射创建运行时类的对象 1.1. 创建类的对象:调用Class对象的newInstance()方法 要 求: 类必须有一个无参数的构造器。(默认无参,指定调用有...

    1. java 利用反射创建运行时类的对象

    1.1. 创建类的对象:调用Class对象的newInstance()方法

    要 求:

    1. 类必须有一个无参数的构造器。(默认无参,指定调用有参的构造器)
    2. 类的构造器的访问权限需要足够。

    难道没有无参的构造器就不能创建对象了吗?
    不是!只要在操作的时候明确的调用类中的构造方法,并将参数传递进去之后,才可以实例化操作。步骤如下:

    1. 通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器
    2. 向构造器的形参中传递一个对象数组进去,里面包含了构造器中所需的各个参数。
    3. 在Constructor类中存在一个方法
      public T newInstance(Object … initargs)

    注:以上为反射最常用的和用的最多的地方了

    2.例子demo

    1. 代码
    @Test
    	public void test1() throws Exception {
    		String className = "testReflection.Person";
    		Class clazz = Class.forName(className);
    		//创建对应的运行时类的对象.使用newInstance(),实际就是调用了运行时类的空参的构造器
    		//要想能够创建承购:①要求对应的运行时类要有空参的构造器
    		//②构造器的权限修饰符的权限要足够
    		Object obj = clazz.newInstance();
    		Person p = (Person)obj;
    		System.out.println(p);		
    	}
    
    1. 总结
    2. 创建类的时候,尽量保留空参的构造器
      好处:
      • 有可能我们要通过Java反射机制去创建类对象
      • 子类实例化的时候,会调用父类的空参构造器,如果没有空参构造器,会报错

    3. 反射创建对象和正常对象的底层理解

    1. 其实两种方法都是通过调用类的构造器(Constructor)创建对象的,只是反射的方法,是先有一个大的Class类,再去找到其对应的构造器,然后创建。
    2. 正常方式的创建对象是当我们new 的时候,就已经调用的构造器去创建对象了。
    展开全文
  • Java通过反射创建对象

    千次阅读 2016-11-13 23:28:35
    通过反射创建对象 创建对象之前,我们必须先知道要为哪个类创建对象。我们需要拿到这个类的全路径名。类似java.lang.String,除此之外我们还需要知道这个类的构造函数,是否有参数,参数的类型各是什么。下面分两种...
    • 通过反射创建对象

      创建对象之前,我们必须先知道要为哪个类创建对象。我们需要拿到这个类的全路径名。类似java.lang.String,除此之外我们还需要知道这个类的构造函数,是否有参数,参数的类型各是什么。下面分两种情况

      1. 无参构造函数

        Class clazz = null;
        try{
            //这里forName方法可能会抛出找不到类的异常
            clazz = Class.forName("java.lang.String");
        }catch (ClassNotFoundException e1){
            e1.printStackTrace();
        }
        
        String str;
        try{
            //这是最简单的一种实例化方法
            str = (String)clazz.newInstance();
            System.out.println(str.isEmpty());
        }catch (InstantiationException e1){
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }catch (IllegalAccessException e1){
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        

        直接调用class对象的newInstance方法,这可以应对大部分情况。

      2. 有参构造函数

        首先我们写一个测试需要用到的类,包含了3个参数不同的构造函数。

        package test11;    
        
        public class ThisIsTestClass{
        
            public ThisIsTestClass(){
                System.out.println("无参构造器");
            }
            public ThisIsTestClass(String str){
                System.out.println("一参构造器,参数为:" + str);
            }
            public ThisIsTestClass(String str, Integer i){
                System.out.println("二参构造器, 参数为:" + str + ", " + i);
            }
        }

        接下来我们用下面的代码来演示,如何调用参数不同的构造函数。

            try{
        
                Class clazz = Class.forName("test11.ThisIsTestClass");
                /**
                 *调用无参构造函数,
                 * 效果上和使用class.newInstance()差不多
                 * 构造函数无参的情况下,可以传入一个空数组,也可以不传入数组
                 **/
                Constructor<ThisIsTestClass> con = clazz.getConstructor();
                ThisIsTestClass thisIsTestClass = con.newInstance();
                System.out.println("-------------------------------------");
                //依然是无参构造函数
                Class[] paramTypeEmpty = {};
                Constructor<ThisIsTestClass> con0 = clazz.getConstructor(paramTypeEmpty);
                Object[] paramEmpty = {};
                ThisIsTestClass thisIsTestClassEmpty = con0.newInstance(paramEmpty);
                System.out.println("-------------------------------------");
        
                //getConstructor接受变长参数,以Class数组形式传入,
                //告诉jdk我们要调用哪个构造器
                Class[] paramType1 = {String.class};
                Constructor<ThisIsTestClass> con1 = clazz.getConstructor(paramType1);
        
                //Constructor实例的newInstance同样也是接受一个变长参数,
                //参数数组中类型要和getConstructor的类型对应
                Object[] params1 = {"ParamOne"};
                ThisIsTestClass thisIsTestClass1 = con1.newInstance(params1);
                System.out.println("-------------------------------------");
        
                //params2中的数据类型要和paramTypes2中的类型相对应
                Class[] paramTypes2 = {String.class, Integer.class};
                Constructor<ThisIsTestClass> con2 = clazz.getConstructor(paramTypes2);
                Object[] params2 = {"ParamOne", 2};
                ThisIsTestClass thisIsTestClass2 = con2.newInstance(params2);
                System.out.println("-------------------------------------");
            }catch(ClassNotFoundException e){
                e.printStackTrace();
            }catch (NoSuchMethodException e){
                e.printStackTrace();
            }catch (SecurityException e){
                e.printStackTrace();
            }catch (InstantiationException e){
                e.printStackTrace();
            }catch (IllegalAccessException e){
                e.printStackTrace();
            }catch (IllegalArgumentException e){
                e.printStackTrace();
            }catch (InvocationTargetException e){
                e.printStackTrace();
            }
    展开全文
  • java 反射

    通过反射创建对象有如下两种方式:

    • 使用Class对象的newInstance()方法来创建该Class对象对应类的实例,这种方式要求该Class对象的对应类有默认构造器,而执行newInstance()方法时实际上是利用默认构造器来创建该类的实例。
    private Object createObject(String clazzName) throws Exception{
    Class<?> clazz = Class.forName(classzzName);
    return clazz.newInstance();
    } 
    • 先使用Class对象获取指定的Construtor对象,再调用Constructor对象的newInstance()方法来创建该Class对象对应类的实例。通过这种方式可以选择使用指定的构造器来创建实例。
    Class<?> jframeClazz = Class.forName("javax.swing.JFrame");
    Constructor ctor = jframeClazz.getConstructor(String.class);
    Object obj = ctor.newInstance("测试窗口");
    System.out.println(obj);
    




    展开全文
  • java使用反射创建对象

    万次阅读 2016-10-08 17:12:41
    Class对象中包括构造器(Constructor)、属性(Field)、方法(Method)。...这个方法是使用Class对象对应类的默认构造器创建对象,这就要求Class对象对应类必须要有默认构造器。 2、使用Class对象获取指定

    Class对象中包括构造器(Constructor)、属性(Field)、方法(Method)。下面要讲的是通过反射来构造对应类的实例。

    通过反射来生成对象有两种方式:

    1、通过Class对象的newInstance()方法来创建Class对象对应类的实例。这个方法是使用Class对象对应类的默认构造器创建对象,这就要求Class对象对应类必须要有默认构造器。

    2、使用Class对象获取指定的Constructor对象,调用Constructor对象的newInstance()方法来创建Class对象对应类的实例。这个方法可以使用Class对象对应类的任意指定的构造器来创建实例。

    第一种方法比较常见,在spring这些框架中,会根据配置文件自动创建类的实例并注入到依赖此类的类中。这时候用的最多的就是默认构造器。像是在spring的配置文件中,我们提供的是某个类的全类名,这种情况要创建类的实例,就必须使用反射了。

    第一种方法的使用:

    package test922;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Properties;
    
    /**
     * Created by Ernest on 2016/9/22.
     */
    public class ObjectPoolFactory {
        //定义一个对象池,前面是对象名,后面是实际对象
        private Map<String, Object> objectPool = new HashMap<> ();
        //定义一个创建对象的方法
        //该方法只要传入一个字符串类名,程序可以根据该类名生成Java对象
        private Object createObject(String clazzName) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
            Class<?> clazz = Class.forName(clazzName);
            return clazz.newInstance();
        }
        //该方法通过文件来初始化对象池
        //它会根据配置文件创建对象
        public void initPool(String fileName) throws IOException, IllegalAccessException, InstantiationException, ClassNotFoundException {
            FileInputStream fis = null;
            try {
                fis = new FileInputStream(fileName);
                Properties props = new Properties();
                props.load(fis);
                for (String name : props.stringPropertyNames()) {
                    //每取出一个键值对,就根据属性值创建对象
                    //每调用createObject创建对象,并将对象添加到对象池中
                    objectPool.put(name, createObject(props.getProperty(name)));
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } finally {
                if (fis != null) {
                    fis.close();
                }
            }
        }
        public Object getObject(String name) {
            return objectPool.get(name);
        }
    
        public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException {
            ObjectPoolFactory opf = new ObjectPoolFactory();
            opf.initPool("obj.txt");
            System.out.println(opf.getObject("a"));
            System.out.println(opf.getObject("b"));
        }
    }
    配置文件:

    a=java.util.Date
    b=javax.swing.JFrame

    结果:

    Sat Oct 08 17:04:35 CST 2016
    javax.swing.JFrame[frame0,0,0,0x0,invalid,hidden,layout=java.awt.BorderLayout,title=,resizable,normal,defaultCloseOperation=HIDE_ON_CLOSE,rootPane=javax.swing.JRootPane[,0,0,0x0,invalid,layout=javax.swing.JRootPane$RootLayout,alignmentX=0.0,alignmentY=0.0,border=,flags=16777673,maximumSize=,minimumSize=,preferredSize=],rootPaneCheckingEnabled=true]
    
    使用第二种方法创建对象:

    public class CreateFrame {
        public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
            Class<?> clazz = Class.forName("javax.swing.JFrame");
            Constructor constructor = clazz.getConstructor(String.class);
            Object obj = constructor.newInstance("测试窗口");
            System.out.println(obj);
        }
    }
    结果:

    javax.swing.JFrame[frame0,0,0,0x0,invalid,hidden,layout=java.awt.BorderLayout,title=测试窗口,resizable,normal,defaultCloseOperation=HIDE_ON_CLOSE,rootPane=javax.swing.JRootPane[,0,0,0x0,invalid,layout=javax.swing.JRootPane$RootLayout,alignmentX=0.0,alignmentY=0.0,border=,flags=16777673,maximumSize=,minimumSize=,preferredSize=],rootPaneCheckingEnabled=true]
    





    展开全文
  • java通过反射创建对象的两种方式

    千次阅读 2019-03-07 15:44:05
    java中,通过反射创建对象有两种方式 使用Class对象的newInstance()方法来创建对象; 具体步骤是 1、获取类的Class对象(有三种方式可以获取,可以自行百度一下) 2、通过调用所获取到的Class对象的newInstance...
  • java通过反射创建对象的两种方式与区别 1.使用Class对象的newInstance()方法来创建对象: 具体步骤是: 1、获取类的Class对象(有三种方式可以获取,可以自行百度一下) 2、通过调用所获取到的Class对象的newInstance...
  • import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class ReflectPO { private String h1; private String h2; public String getH1() { return h1; } public...
  • java通过反射创建对象的小例子

    千次阅读 2014-12-02 16:23:38
    利用Java反射原理,通过Class 对象生成对应类的 对象。这句话有点绕,我给你举几个例子 下面的代码是伪代码,不可以直接拿去,但是思想是对的 代码1 class A{  A(){ /五惨构造器  }    String...
  • Java反射创建对象效率高还是通过new创建对象的效率高? 通过new创建对象的效率比较高。 通过反射时,先找查找类资源,使用类加载器创建,过程比较繁琐,所以效率较低。
  • java 中通过反射创建对象
  • 主要介绍了Java 用反射设置对象的属性值实例详解的相关资料,需要的朋友可以参考下
  • java反射创建工厂对象

    2016-03-30 15:08:00
    问题:通过类的全限定名来创建对象,并创建工厂对象 DEOM案例如下: package invokeBeanFactorty;... * java反射通过类全限定名创建对象  * @author Administrator  *  */ public class invokeObject {
  • java基础-反射3(反射,反射创建对象,操作对象属性,调用对象方法)前面通过学习,我们了解的运行时类型信息的基本原理,以及通过Class对象和反射来获取运行时类型信息。下面来了解通过反射来创建对象,以及操作...
  • Java利用反射进行对象赋值与类型转换 首先利用反射创建目标类对象,获取当前对象以及目标类所有的成员,然后对这些属性双层循环遍历比较变量名,变量名称相等则进行赋值。 获取成员属性时注意点:class....
  • Java - 如何通过反射创建对象

    万次阅读 2019-03-16 23:46:32
    分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!... - 方法1:通过类对象调用...- 方法2:通过类对象的getConstructor()或getDeclaredConstructor()方法获得构造器(Cons...
  • java中除了使用new来创建对象,还可以使用反射技术来创建对象。 首先获得类对象的class后,然后通过java反射机制来创建对象,有两个方法,Class.neeInstance()以及调用类对象的构造方法来创建。 class.newInstance...
  • 我的教程里少一个工具类的方法: ... //传入一个对象,方法名,形参 通过反射对象属性赋值 } 我写的时候发现无法实例化Object就无法为属性赋值。 请帮助我完成此方法或提供功能相同的工具类,Thanks♪(・ω・)ノ
  • 反射创建对象 当我们反射创建对象,一般采用 Class clazz = Class.forName("java.lang.String"); Object instance = c.newInstance(); 这样创建对象,但这样默认是无参的构造函数,当我们想通过反射调用...
  • java中如何用反射创建一个对象 如何理解java的反射,反射是一种怎么样的机制呢
  • 1 /* 2 * 通过反射创建带参数的对象 3 */ 4 public Object Creatobject(String ClassPath, Object[] Params) throws Exception { 5 Class<?> demo = null; 6 Object obj =...
  •   反射Java中至关重要的一个概念,我们必须要对它进行掌握。 1. 反射概念   反射指的是对对象的反向处理操作。所谓反向指的是根据对象来获得对象的来源信息(对象类的来源信息 包名.类名)。   为了区分...
  • 利用反射创建对象

    2017-02-28 15:47:30
    /* * 通过反射创建带参数的对象 */ public Object Creatobject(String ClassPath, Object[] Params) throws Exception { Class<?> demo = null; Object obj = null; demo = Class.forName
  • Java 用反射设置对象的属性值

    千次阅读 2017-01-21 10:41:34
    Java 反射 创建对象的方法 1、通过Class对象的newInstance()方法,这种方法的局限是只能取调用默认的构造函数 2、通过取得Class对象的getConstructor方法取得Construtor对象,然后再通过调用Constructor类的new...
  • 利用反射创建对象 使用指定构造方法来创建对象: 获取该类的Class对象。 利用Class对象的getConstructor()方法来获取指定的构造方法。 调用Constructor的newInstance()方法创建对象。   AccessibleObject...
  • 用Java反射创建对象执行方法案例分析: 需求写一个"框架",不能改变该类的任何代码的前提下,可以帮我们创建任意类的对象,并且执行其中任意方法 实现: 1.配置文件 2.反射 步骤: 1.将需要创建的对象的全类名和需要执行的...
  • 反射中,欲获取一个类或者调用某个类的方法,首先要获取到该类的 Class 对象。 1、获取Class对象Java API 中,提供了获取 Class 类对象的三种方法: 第一种,使用 Class.forName 静态方法。 前提:已明确类的全...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 169,522
精华内容 67,808
关键字:

java利用反射创建对象

java 订阅