精华内容
下载资源
问答
  • 主要介绍了java通过反射创建对象并调用方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java通过反射创建对象的两种方式

    千次阅读 2019-03-07 15:44:05
    java中,通过反射创建对象有两种方式 使用Class对象的newInstance()方法来创建对象; 具体步骤是 1、获取类的Class对象(有三种方式可以获取,可以自行百度一下) 2、通过调用所获取到的Class对象的newInstance...

    我个人觉得我自己是个比较粗心的人,所以各位大佬发现有什么不对的地方还请留言告知
    在java中,通过反射创建对象有两种方式

    1. 使用Class对象的newInstance()方法来创建对象;
      具体步骤是:
      1、获取类的Class对象(有三种方式可以获取,可以自行百度一下)
      2、通过调用所获取到的Class对象的newInstance()来获得对象,该方法会返回一个Object类型的对象,所以还需要强转一下;
      举个例子:
      新建一个Hog,里面定义一个方法getName()输出一句话,可以看到运行之后控制台输出了青青草原四个字,
    package Lin;
    
    public class Pig {
        public static void main(String[] args) throws IllegalAccessException, InstantiationException {
            //通过类.class的方式获取一个该类的Class实例
            Class hogClass = Hog.class;
            //通过调用newInstance()方法获取一个Hog的实例, 该方法会返回一个Object类型的对象并且会抛出两个异常,
            Hog hog = (Hog) hogClass.newInstance();
            hog.getName();
        }
    }
    class Hog {
        public void getName() {
            System.out.println("青青草原");
        }
    }
    

    在这里插入图片描述

    把上面的代码再修改一下
    修改后的代码在Hog类构造函数中添加了一句代码,输出一句话,然后运行代码,可以发现构造函数被调用了,说明在使用Class类的newInstance()方法获得一个类的实例时,依然会调用他的(默认)构造函数;

    package Lin;
    
    public class Pig {
        public static void main(String[] args) throws IllegalAccessException, InstantiationException {
            //通过类.class的方式获取一个该类的Class实例
            Class hogClass = Hog.class;
            //通过调用newInstance()方法获取一个Hog的实例, 该方法会返回一个Object类型的对象并且会抛出两个异常,
            Hog hog = (Hog) hogClass.newInstance();
            hog.getName();
        }
    }
    class Hog {
        public Hog() {
            System.out.println("无参构造函数");
        }
        public void getName() {
            System.out.println("青青草原");
        }
    }
    

    在这里插入图片描述

    1. 通过Constructor类的newInstance()方法获取
      具体步骤是
      1、获取一个类的一个Class实例;
      2、调用Class中的getConstructor()方法获得一个Constructor对象,
      3、调用Constructor的newInstance()方法获得一个类的实例;

      再举个例子,把上面的代码稍微改一下:
      Hog类中的代码不变,在主方法中通过getConstructor()方法获得一个Constructor类的实例,然后通过Constructor的newInstance()方法获得一个类的实例;

    getConstructor(Class<?>… parameterTypes)方法中可以传递Class类型的参数(不知到Class…的可以把他理解成参数是Class类型的数组),通过传递的参数来获得Class对象所包含的类的指定的public构造方法(就是找指定的构造方法,因为一个类可以有好多个构造方法,当你的一个构造方法为public Hog(int a) 时, 那就可以传递int.class进去)想知道的就查相关api吧,

    package Lin;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationTargetException;
    
    public class Pig {
        public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
            //通过类.class的方式获取一个该类的Class实例
            Class hogClass = Hog.class;
            //调用Class类的getConstructor()获得一个指定的构造器(参数为空则获得默认的构造器)对象   注意 获得的构造器得是被public修饰的
            Constructor constructor = (Constructor) hogClass.getConstructor();
            //调用Constructor的newInstance()方法获取一个Hog实例(注意要强转)
            Hog hog = (Hog) constructor.newInstance();
            hog.getName();
        }
    }
    class Hog {
        public Hog() {
            System.out.println("无参构造函数");
        }
        public void getName() {
            System.out.println("青青草原");
        }
    }
    

    运行截图:
    在这里插入图片描述
    将上面的代码再进行修改一下
    1.在Hog类中定义一个带参的构造函数,形参为String类型
    2.在主方法中调用Class的getConstructor()方法并传递String.class进去(告诉方法我要找到一个参数 是String类型的构造函数)
    3.调用Constructor的newInstance()方法并传递一个String类型的字符串进去(可以理解成就是传递构造函数的参数进去)
    运行之后可以看到带参数的构造函数被调用了;

    package Lin;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationTargetException;
    
    public class Pig {
        public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
            //通过类.class的方式获取一个该类的Class实例
            Class hogClass = Hog.class;
            //调用Class类的getConstructor()获得一个参数为String类型的构造器对象
            Constructor constructor = (Constructor) hogClass.getConstructor(String.class);
            //调用Constructor的newInstance()方法获取一个Hog实例(传递一个String类型的参数)
            Hog hog = (Hog) constructor.newInstance("我是Constructor类调用的");
            hog.getName();
        }
    }
    
    class Hog {
        public Hog() {
            System.out.println("无参构造函数");
        }
    
        public Hog(String message) {
            System.out.println(message);
        }
    
        public void getName() {
            System.out.println("青青草原");
        }
    }
    

    在这里插入图片描述
    两种方法的区别
    第一种方法、通过Class的newInstance()方法只能使用默认的构造方法,换句话说就是使用此方法是不能通过带参的构造函数来生成一个类的实例;

    第二种方法、通过Constructor的newInstance()方法可以使用默认的构造方法,也可以使用带参的构造方法来生成一个类的实例

    在只有一个默认的构造函数(或不带参数的构造函数)时,使用第一种方法比较方便,如果要使用类中的其他构造方法那只能使用第二种方法了。

    展开全文
  • java通过反射创建对象的两种方式与区别 1.使用Class对象的newInstance()方法来创建对象: 具体步骤是: 1、获取类的Class对象(有三种方式可以获取,可以自行百度一下) 2、通过调用所获取到的Class对象的newInstance...

    java通过反射创建对象的两种方式与区别

    1.使用Class对象的newInstance()方法来创建对象:

    具体步骤是:
    1、获取类的Class对象(有三种方式可以获取,可以自行百度一下)
    2、通过调用所获取到的Class对象的newInstance()来获得对象,该方法会返回一个Object类型的对象,所以还需要强转一下。
    在这里s 插入图片描述

    2.通过Constructor类的newInstance()方法获取

    具体步骤是
    1、获取一个类的一个Class实例
    2、调用Class中的getConstructor()方法获得一个Constructor对象
    3、调用Constructor的newInstance()方法获得一个类的实例
    在这里插入图片描述

    两种方法的区别

    第一种方法:通过Class的newInstance()方法只能使用默认的构造方法,换句话说就是使用此方法是不能通过带参的构造函数来生成一个类的实例。

    第二种方法:通过Constructor的newInstance()方法可以使用默认的构造方法,也可以使用带参的构造方法来生成一个类的实例。

    注意:在只有一个默认的构造函数(或不带参数的构造函数)时,使用第一种方法比较方便,如果要使用类中的其他构造方法那只能使用第二种方法了。

    展开全文
  • 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();
            }
    展开全文
  • class Demo { public static void main(String[] args) { ... //根据类名获取Class对象 Class c = Class.forName("Test"); //参数类型数组 Class[] parameterTypes={int.class,int.class}; /

    class Demo {
    	public static void main(String[] args) {		  
    		try {
    		
    			//根据类名获取Class对象  
    			Class c = Class.forName("Test");
    			//参数类型数组
    			Class[] parameterTypes={int.class,int.class};
    			//根据参数类型获取相应的构造函数
    			Constructor constructor=c.getConstructor(parameterTypes);
    			//参数数组
    			Object[] parameters={1,1};
    			//根据获取的构造函数和参数,创建实例
    			Object o=constructor.newInstance(parameters);
    			
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }
    
    
    class Test{
        public Test(int x, int y){
            System.out.println(x+y);
        }
    }



    展开全文
  • Java试题-5:应用反射创建对象,调用对象方法 反射为Java的高级技术应用
  • 下面小编就为大家带来一篇Java通过反射机制动态设置对象属性值的方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了Java使用反射创建对象,结合实例形式分析了java使用反射创建对象的具体实现方法及相关操作技巧,需要的朋友可以参考下
  • 一、java反射机制概述 Reflection (反射)被视为动态语言的关键,为什么这么说呢,是因为它在运行时就确定下来了。反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息,并能直接操作任意对象的...
  • java反射机制创建对象实现:java 深度拷贝 -超完美 ,自己做的,下面  package aop; public class Student { private String name; private int age; public String getName() { return name; } public ...
  • 主要介绍了Java反射设置对象的属性值实例详解的相关资料,需要的朋友可以参考下
  • java通过反射创建对象
  • 主要介绍了Java 通过反射给实体类赋值操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Java反射创建对象效率高还是通过new创建对象的效率高? 通过new创建对象的效率比较高。 通过反射时,先找查找类资源,使用类加载器创建,过程比较繁琐,所以效率较低。
  • JAVA反射机制创建对象

    千次阅读 2017-12-15 16:04:49
    在实际开发过程中,JAVA反射技术应用广泛,尤其是在一些广泛使用的框架中,如Spring、mybatis中更是大量使用。java语言并不是一种动态语言,也就是说在运行时不能...反射技术就是在程序运行时将所需要的类通过Class.f
  • java使用反射创建对象

    万次阅读 2016-10-08 17:12:41
    Class对象中包括构造器(Constructor)、属性(Field)、方法(Method)。...这个方法是使用Class对象对应类的默认构造器创建对象,这就要求Class对象对应类必须要有默认构造器。 2、使用Class对象获取指定
  • java中如何用反射创建一个对象 如何理解java的反射,反射是一种怎么样的机制呢
  • java基础-反射3(反射,反射创建对象,操作对象属性,调用对象方法)前面通过学习,我们了解的运行时类型信息的基本原理,以及通过Class对象和反射来获取运行时类型信息。下面来了解通过反射来创建对象,以及操作...
  • 主要介绍了java使用反射创建并操作对象的方法,文中讲解非常细致,代码帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • java中,只要给定类的名字,那么就可以通过反射机制来获得类的所有属性和方法。 反射可以创建类的对象. newInstance()方法可以创建类的实例.那么拥有该方法除了Class类之外,还有Constructor类. 可是,Class类中的...
  • 通过对象获取创建对象的类型信息。 对类型(类)的一个抽象,就是JDK中的Class类; Class也是一个类,用来描述其他类的信息。 (二)Class对象的三种获取方式 序号 方式 1 通过对象的getClass()方法获取...
  • Java - 如何通过反射创建对象

    万次阅读 2019-03-16 23:46:32
    分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!... - 方法1:通过对象调用...- 方法2:通过对象的getConstructor()或getDeclaredConstructor()方法获得构造器(Cons...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 219,392
精华内容 87,756
关键字:

java通过反射创建对象

java 订阅