精华内容
下载资源
问答
  • 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()方法可以使用默认的构造方法,也可以使用带参的构造方法来生成一个类的实例。

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

    展开全文
  • 闲话不多说,直接代码示例,给大家展示一下,创建对象的几种方式: package com.jason.study.reflect; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java...

    闲话不多说,直接代码示例,给大家展示一下,创建对象的几种方式:

    package com.jason.study.reflect;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    /*
     *创建对象有哪几种方式
     * 1)常见的通过new方式创建对象
     * 2)通过反射创建
     */
    public class TestReflect  {
        public static void main(String[] args) {
            try {
    
               //第一种创建方式,通过有参或者无参构造方法创建对象
                System.out.println("第一种方式:");
                //Connection   conn1=new Connection();//无参
                Connection   conn1=new Connection("Jason");//有参
                System.out.println("conn2="+conn1);
                System.out.println("");
    
                System.out.println("第二种方式:");
                //第二种创建方式,通过已知对象的getClass()。newInstance()创建新的对象
                Connection  conn2=conn1.getClass().newInstance();//前提是无参构造方法是公有(public)
                System.out.println("conn2="+conn2);
                System.out.println("");
    
    
                //第三种创建方式:反射,通过类的元数据创建类对象
                System.out.println("第三种方式:");
                Class   clazz=Class.forName("com.jason.study.reflect.Connection");//等同于Connection.class
                Connection conn3=(Connection) clazz.newInstance();
                System.out.println("conn3="+conn3);
                System.out.println("");
    
                //第四种创建方式:反射,通过类的元数据,获取声明的构造方法,重新设置构造方法的访问属性
                System.out.println("第四种方式:");
                //有参构造方法
    //            Constructor  constructor=Connection.class.getDeclaredConstructor(String.class);
    //            constructor.setAccessible(true);
    //            Connection connection=(Connection) constructor.newInstance("jason");
    //            System.out.println(connection);
                //无参
                Constructor  constructor=Connection.class.getDeclaredConstructor();
                constructor.setAccessible(true);
                Connection conn4=(Connection) constructor.newInstance();
                System.out.println("conn4="+conn4);
                System.out.println("");
    
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    package com.jason.study.reflect;
    
    public class Connection {
           private  static Connection connection;
           private String name;
           public Connection()
           {
               System.out.println("通过无参构造方法创建对象");
           }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Connection(String name) {
                this.name=name;
                System.out.println("通过有参构造方法创建对象");
            }
    
    //    private  static  Connection  getConnection()
    //       {
    //           if(connection==null)
    //           {
    //               synchronized(Connection.class)
    //               {
    //                   if(connection==null)
    //                   {
    //                          connection=new Connection();
    //                   }
    //                   return connection;
    //               }
    //           }else
    //           {
    //               return connection;
    //           }
    //
    //       }
        private  void testprivate()
        {
            System.out.println("============");
        }

    运行结果:

    第一种方式:
    通过有参构造方法创建对象
    conn2=com.jason.study.reflect.Connection@1b6d3586
    
    第二种方式:
    通过无参构造方法创建对象
    conn2=com.jason.study.reflect.Connection@4554617c
    
    第三种方式:
    通过无参构造方法创建对象
    conn3=com.jason.study.reflect.Connection@74a14482
    
    第四种方式:
    通过无参构造方法创建对象
    conn4=com.jason.study.reflect.Connection@1540e19d
    
    

     

    展开全文
  • 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()方法可以使用默认的构造方法,也可以使用带参的构造方法来生成一个类的实例

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

    展开全文
  • 利用反射创建对象的几种方式

    千次阅读 2019-05-23 15:50:42
    创建对象 1.使用Class对象的newInstance()方法来创建类的实例,这种方式要求该Class对象的对应类有默认构造器,执行newInstance()实际上是利用默认构造器来创建该类的实例。 2.先使用Class对象获取到Constructor对象...

    一.创建对象
    1.使用Class对象的newInstance()方法来创建类的实例,这种方式要求该Class对象的对应类有默认构造器,执行newInstance()实际上是利用默认构造器来创建该类的实例。

    2.先使用Class对象获取到Constructor对象,在调用Constructor对象的newInstance()方法来创建对应Class对象对应类的实例。采用这种方法可以指定构造函数来创建。

    二.如何获取Class对象?
    1.使用Class的forName()方法
    2.如果是对象,通过对象的getClass()方法则返回该类的Class对象
    3.也可以直接调用类的class属性。

    展开全文
  • 利用反射创建对象的三种方式

    万次阅读 2019-05-23 15:13:36
    源头:获取Class对象,用三种方式 phone iPhone=new phone(); //1.1.对象.getClass();获取对象 Class<?> clazz1 = iPhone.getClass(); //1.2.类.class clazz1=phone.class; //1.3.C...
  • * 本实例意在对比以下两种方法创建对象实例: * 直接new对象 * 反射 * 直接new对象:无法访问SCP类中的私有方法,仅能访问公有方法 * 反射:可访问private,default,protected,public任意方法 * 为...
  • java反射class的三种方式反射创建对象的两种方式

    万次阅读 多人点赞 2018-08-15 11:46:21
    反射中,欲获取一个类或者调用某个类的方法,首先要获取到该类的 Class 对象。 1、获取Class对象 在 Java API 中,提供了获取 Class 类对象的三种方法: 第一种,使用 Class.forName 静态方法。 前提:已明确类...
  • 通过反射创建对象

    千次阅读 2018-05-17 11:24:00
    通过反射创建对象的两种方法1.通过Class字节码对象newInstance();(默认通过无参构造创建)2.通过获取构造器getConstructor(Class&lt;?&gt;..parameterTypes);(通过有参的构造器,参数可以指定具体类型和多...
  • java基础-反射3(反射,反射创建对象,操作对象属性,调用对象方法)前面通过学习,我们了解的运行时类型信息的基本原理,以及通过Class对象和反射来获取运行时类型信息。下面来了解通过反射来创建对象,以及操作...
  • java使用反射创建对象

    千次阅读 2018-11-06 19:53:44
    Class对象中包括构造器(Constructor)、属性(Field)、方法(Method)。下面要讲的是通过反射...通过反射来生成对象有两种方式: 1、通过Class对象的newInstance()方法来创建Class对象对应类的实例。这个方法是...
  • 通过反射创建对象的思路: 1.首次获取类的类对象,获取方式看前一篇博客。 2.调用类对象的newInstance()方法创建该类的实体对象。这是调用的类的默认构造器。 若想调用非默认的构造器创建实例对象,需要先通过...
  • 反射:使用反射调用构造器创建对象

    千次阅读 2017-07-03 13:01:17
    为什么使用反射创建对象,为什么不直接来new呢? 在框架中,提供给我们的都是字符串. ----------------------------------------------------------- 使用反射创建对象: 步骤:  1);找到构造器所在类的字节码对象....
  • 反射可以创建类的对象. newInstance()方法可以创建类的实例.那么拥有该方法除了Class类之外,还有Constructor类. 可是,Class类中的newInstance()方法只能创建默认构造器的对象,想要创建有参的构造函数还是要使...
  • 通过对象获取创建对象的类型信息。 对类型(类)的一个抽象,就是JDK中的Class类; Class也是一个类,用来描述其他类的信息。 (二)Class对象的三种获取方式 序号 方式 1 通过对象的getClass()方法获取...
  • 将类的各个组成部分封装为其他对象就是反射机制。
  • JAVA反射机制创建对象

    千次阅读 2017-12-15 16:04:49
    在实际开发过程中,JAVA的反射技术应用广泛,尤其是在一些广泛使用的框架中,如Spring、mybatis中更是大量使用。java语言并不是一种动态语言,也就是说在运行时不能改变程序结构或者变量类型,但是JAVA提供了反射...
  • JAVA反射机制 java反射机制是在运行状态中,对于任意一个类, ...这种动态获取的信息以及动态调用对象的方法的功能称为JAVA语言的反射机制。 巧妙的利用java中的反射机制,能够帮助我们进行程序开发时达到意想不到...
  • 在通常情况下,如果有一个类,可以通过类创建对象;但是反射就是要求通过一个对象找到一个类的名称;   2:在反射操作中,握住一个核心概念: 一切操作都将使用Object完成,类,数组,的引用都可以使用Object...
  • - java可通过5种来创建实例化一个对象(new、反射、Class.forName、clone、序列化),多的不讲,就说说反射与Class.forName - 从下面的代码可分析出如果在当前类没有加载到jvm前,代码中步骤1、2、3在没有调用new...
  • C# 利用反射动态创建对象

    千次阅读 2016-06-30 21:58:12
    C# 利用反射动态创建对象 在VS.Net中,有很多种方法动态调用对象的构造函数。一是通过Activator类的CreateInstance()方法。这个方法我们在Remoting中也用过。它实际上是在本地或从远程创建对象类型,或...
  • 目录 什么是反射 反射原理 应用场景 基本用法 反射机制的相关类 ...什么是反射 ...JAVA反射机制是在运行状态中,对于任意一个...这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 反射原理 ...
  • Java通过反射创建对象

    万次阅读 2012-07-26 15:50:01
    一、通过反射创建不带参数的对象 这个比较简单,不需要获取这个类的构造方法类,不需要指明构造参数的参数列表。下面是要使用的类和方法,使用步骤如下: Class(类): Class 类的实例表示正在运行的 Java 应用...
  • Java反射机制创建对象

    万次阅读 多人点赞 2014-04-08 18:48:46
    * 使用反射机制来创建对象 * * @author lxf * @time 2014-4-8下午05:08:41 * */ public class CreateObject { /** * Java的反射机制是指:反射就是把Java类中的各种成分映射成相应相应的Java类, 然后就...
  • java.lang.Class类和反射机制创建对象

    万次阅读 2015-11-24 00:12:02
    java.lang.Class类  Java程序在运行时,Java运行时系统一直对所有的对象进行所谓的运行时...Class类封装一个对象和接口运行时的状态,当装载类时,Class类型的对象自动创建。  Class 没有公共构造方法。Class 对象
  • 单例防止暴力反射和反序列化创建对象 public class SigletonDemo06 implements Serializable {    private static final long serialVersionUID = -2152988798012593501L;  // 1.私有化构造  public ...
  • 一、****************************...b1:反射属于动态编译,意思就说只有到运行时才会去获得该对象的实例,大多框架都是使用反射获取对象实例,如Spring 二、*****************************************************...
  • 反射机制: 所谓的反射机制就是java语言在运行时拥有一项自观的能力。通过这种能力可以彻底的了解自身的情况为下一步的动作做准备...其中class代表的时类对 象,Constructor-类的构造器对象,Field-类的属性对象,...
  • Java中new创建对象 图来自知乎 如果我们在代码中如果写了一段 A a = new A(); 在JVM中会帮你做的事情有以下: JVM把类的.java文件编译为一个.class的字节码文件 类加载器把.class文件加载进jvm的内存中,一个Class...
  • 在Java中,一般情况下会使用new关键字来调用类的有参或者无参构造函数来建立一个对象,也可以通过Class.newInstance()方法来调用类的无参构造函数来建立一个对象。而如果一个类的构造函数为private 类型,不是public...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 198,211
精华内容 79,284
关键字:

反射创建对象的方式