精华内容
下载资源
问答
  • * 本实例意在对比以下两种方法创建对象实例: * 直接new对象 * 反射 * 直接new对象:无法访问SCP类中的私有方法,仅能访问公有方法 * 反射:可访问private,default,protected,public任意方法 * 为...
    /**
     * 本实例意在对比以下两种方法创建对象实例:
     * 		直接new对象
     * 		反射
     *		直接new对象:无法访问SCP类中的私有方法,仅能访问公有方法
     *		反射:可访问private,default,protected,public任意方法	
     *	为清楚显示,用反射访问静态和非静态分成两个页面
     */
     
    //创建一个SCP类
    public class SCP {
        private String name;
        public int id;
        private String level;
        private static String gender;//静态属性
    
        public SCP() {
        }
    
        public SCP(String name, int id, String level) {
            this.name = name;
            this.id = id;
            this.level = level;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getLevel() {
            return level;
        }
    
        public void setLevel(String level) {
            this.level = level;
        }
    
        public static String getGender() {
            return gender;
        }
    
        public static void setGender(String gender) {
            SCP.gender = gender;
        }
    
        @Override
        public String toString() {
            return "SCP{" +
                    "name='" + name + '\'' +
                    ", id=" + id +
                    ", level='" + level + '\'' +
                    '}';
        }
        //自定义方法
        private String description (String des){
            System.out.println("表现出极高的" + des);
            return des;
        }
        //自定义静态方法
        private static void show(){
            System.out.println("SCP-682处决实验");
        }
    }
    
    /**
     * @author Prannt
     * 正常访问 SCP 类是这样的步骤,先 new对象(静态属性直接调用),再得到对象。
     * (包括静态属性和非静态属性,由于自定义方法show()已用private修饰,new对象访问不到)
     */
    public class TestCommon {
        public static void main(String[] args) {
            SCP scp1 = new SCP();
            scp1.setId(682);
            scp1.setName("不灭孽蜥");
            scp1.setLevel("Keter");
            SCP.setGender("未知");
            System.out.println("项目编号:" + "SCP-" + scp1.getId() + "," + scp1.getName()+ "。项目等级:" +
                    scp1.getLevel() + "。性别:" + SCP.getGender());
        }
    }
    

    打印结果如下图所示
    在这里插入图片描述

    //采用反射的方法(详细步骤),访问非静态属性和非静态方法
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    
    public class SCPTest {
        @Test
        //第一步:获取Class的三种方式,且三种方式等价
        public void step1() throws ClassNotFoundException {
            //方式一:
            Class<SCP> clazz1 = SCP.class; //加上泛型就不用强转了
            //方式二:
            SCP scp = new SCP();
            Class clazz2 = scp.getClass();
            //方式三:
            Class clazz3 = Class.forName("Summary.SCP");
            System.out.println(clazz3);
        }
        @Test
        //第二步:创建运行时类的对象
        public void step2() throws Exception {
            Class<SCP> clazz1 = SCP.class;
            SCP scp = clazz1.newInstance();
        }
        @Test
        //第三步:获取运行时类中指变量名的属性、方法
        public void step3() throws Exception {
            Class<SCP> clazz1 = SCP.class;
            SCP scp = clazz1.newInstance();
            //获取运行时类中指变量名的属性
            Field name = clazz1.getDeclaredField("name");
            Field id = clazz1.getDeclaredField("id");
            Field level = clazz1.getDeclaredField("level");
    
            //保证当前属性是可访问的
            name.setAccessible(true);
            id.setAccessible(true);
            level.setAccessible(true);
    
            //填参数
            name.set(scp,"不灭孽蜥");
            id.set(scp,682);
            level.set(scp,"Keter");
    
            System.out.println("项目编号:" + "SCP-" + id.get(scp) + "," + name.get(scp) + "。项目等级:" +
                    level.get(scp));
            System.out.println("");
    
            //获取运行时类中指变量名的方法
            Method description = clazz1.getDeclaredMethod("description", String.class);
            //保证当前属性是可访问的
            description.setAccessible(true);
            Object wisdom = description.invoke(scp, "智慧(这是private修饰的私有方法,访问到了)");//填参数
    
        }
    }
    

    采用反射打印结果如下
    在这里插入图片描述

    //采用反射的方法(详细步骤),访问静态属性和静态方法
    import Reflection2.Person1;
    import org.junit.Test;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    
    //下列代码为获取静态属性和静态方法
    public class SCPTestStatic {
        @Test
        public void testStatic() throws Exception {
            Class<SCP> clazz1 = SCP.class;
            SCP scp = clazz1.newInstance();
            //获取运行时类中指变量名的静态属性
            Field gender = clazz1.getDeclaredField("gender");//静态属性
            gender.setAccessible(true);
            gender.set(Person1.class,"未知");
            System.out.println("SCP-682的性别:" + gender.get(SCP.class));
    
            //获取运行时类中指变量名的静态方法
            Method show = clazz1.getDeclaredMethod("show");
            show.setAccessible(true);
            show.invoke(SCP.class);
        }
    }
    
    

    反射访问静态属性和静态方法如下图所示
    在这里插入图片描述

    展开全文
  • Java 反射new性能相差几十倍

    Java 反射与new对象性能相差几十倍,如下图
    在这里插入图片描述

    展开全文
  • Java反射和new效率对比

    2021-01-23 14:35:21
    ​ 可是,你有没有想一下,什么时候我们改用new创建对象,什么时候我们改用反射创建对象呢? ​ 两者创建对象的效率又是如何呢? //new 方式创建对象 ReflectDemo reflectDemo = new ReflectDemo(); //反射创建对象 ...

    一 基础概念

    ​ Java中,一般我们创建一个对象可能会选择new一下个实例。但是随着我们技术的不断提升,我们也学习到了,可以通过反射技术实现对象的创建。

    ​ 可是,你有没有想一下,什么时候我们改用new创建对象,什么时候我们改用反射创建对象呢?

    ​ 两者创建对象的效率又是如何呢?

    //new 方式创建对象
    ReflectDemo reflectDemo = new ReflectDemo();
    //反射创建对象  反射创建对象的三种方式
    (1)Class<ReflectDemo> reflectDemoClass = ReflectDemo.class;
    (2)Class<?> aClass = Class.forName ("com.whale.springtransaction.transactiondemo.reflectdemo.ReflectDemo");
    (3)Class<? extends Class> aClass = reflectDemoClass.getClass ();
    

    二 new 对象和反射创建对象的效率对比

    //测试代码如下
    public class ReflectDemo {
    	public static void main (String[] args) throws IllegalAccessException, InstantiationException {
    		proxyObject();
    		newObject();
    	}
    
    	//new 创建对象
    	//5
    	public static void newObject(){
    		long startTime = System.currentTimeMillis ();
    		int i;
    		for (i = 0; i < 100000000; i++) {
    			ReflectDemo reflectDemo = new ReflectDemo ();
    		}
    		if (i == 100000000) {
    			long endTime = System.currentTimeMillis ();
    			System.out.println ("new耗时为:" + (endTime - startTime));
    		}
    	}
    
    	//反射 创建对象
    	//30
    	public static void proxyObject() throws IllegalAccessException, InstantiationException {
    		long startTime = System.currentTimeMillis ();
    		Class<ReflectDemo> reflectDemoClass = ReflectDemo.class;
    		int i;
    		for (i = 0; i < 100000000; i++) {
    			ReflectDemo reflectDemo = reflectDemoClass.newInstance ();
    		}
    		if (i == 100000000) {
    			long endTime = System.currentTimeMillis ();
    			System.out.println ("反射耗时为:" + (endTime - startTime));
    		}
    	}
    }
    

    在这里插入图片描述

    最终我们发现,new 100000000 个对象和反射创建 100000000 个对象,效率相差了很多倍。

    所以下面我们来探讨一下为什么这么大差别?

    (1)首先第一点,一般我们的Java代码是需要编译后在虚拟机里面运行的。

    ​ 首先我们一般都是通过一个前端编辑器,比如javac,把java文件转为class文件。

    ​ 接下来,程序运行期间,可能会通过一个JIT,即时编译器将字节码文件转换为计算机认识的机器码文件。

    ​ 另外一种可能是通过一个AOT编译器,直接把java文件编译为本地机器码文件。其中JIT在程序运行期会对程序进行优化,但是反射是通过动态解析的方式,因此可能无法执行某些java虚拟机的优化。

    总结起来有下面几个原因:

    ​ 1.Method#invoke 方法会对参数做封装和解封操作

    1. 需要检查方法可见
    2. 需要校验参数
    3. 反射方法难以内联
    4. JIT 无法优化

    三 反射和new 的使用场景

    反射的部分使用场景 
      1.Spring通过反射来帮我们实例化对象,并放入到Ioc容器中
      2.使用JDBC链接数据库时加载数据库驱动Class.forName()
      3.逆向代码 例如反编译
      4.利用反射,在泛型为int的arryaList集合中存放一个String类型的对象
    
    //new 对象和反射的区别
    1.new的对象无法访问其中的私有属性,反射出来的可以通过设置setAccessible()方法来省略访问权限符。
    2.new必须要知道类名,而反射创建对象不需要知道类型也可以创建
    
    展开全文
  • 主要对比三种创建对象的方法.直接new.classClass.forName采用纳秒对比,毫秒对比结果是0.可见,创建一个对象的耗时,是纳秒级别.环境是OpenJDK Runtime Environment AdoptOpenJDK (build 14+36)结果: 直接new最快, ...

    主要对比三种创建对象的方法.

    直接new

    .class

    Class.forName

    采用纳秒对比,毫秒对比结果是0.可见,创建一个对象的耗时,是纳秒级别.

    环境是OpenJDK Runtime Environment AdoptOpenJDK (build 14+36)

    结果: 直接new最快, Class.forName次之, .class方式最慢

    new nanoTime:4600

    userObj1:{"User":{"id":null,"name":"null"}}

    .class nanoTime:84700

    userObj2:{"User":{"id":null,"name":"null"}}

    Class.forName nanoTime:22200

    userObj3:{"User":{"id":null,"name":"null"}}

    源码如下

    import java.lang.reflect.InvocationTargetException;

    /**

    * 测试用User

    *

    * @author ming san

    * @since 2020-07-22 21:32:11

    */

    public class User {

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, ClassNotFoundException {

    long timeStart1 = System.nanoTime();

    User userObj1 = new User();

    System.out.println("new nanoTime:" + (System.nanoTime() - timeStart1));

    System.out.println("userObj1:" + userObj1);

    System.out.println();

    long timeStart2 = System.nanoTime();

    Class userClass2 = User.class;

    User userObj2 = userClass2.getDeclaredConstructor().newInstance();

    System.out.println(".class nanoTime:" + (System.nanoTime() - timeStart2));

    System.out.println("userObj2:" + userObj2);

    System.out.println();

    long timeStart3 = System.nanoTime();

    Class> userClass3 = Class.forName("com.mingsan.User");

    User userObj3 = (User) userClass3.getDeclaredConstructor().newInstance();

    System.out.println("Class.forName nanoTime:" + (System.nanoTime() - timeStart3));

    System.out.println("userObj3:" + userObj3);

    }

    private Integer id;

    private String name;

    public User() {

    }

    public User(Integer id, String name) {

    this.id = id;

    this.name = name;

    }

    public Integer getId() {

    return id;

    }

    public void setId(Integer id) {

    this.id = id;

    }

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    @Override

    public String toString() {

    return "{\"User\":{"

    + "\"id\":"

    + id

    + ",\"name\":\""

    + name + '\"'

    + "}}";

    }

    }

    展开全文
  • //想要对对象进行初始化,使用构造器的方法newInstance(); Object obj = constructor.newInstance("zhagnsan",30); //获取所有构造器。 Constructor[ ] constructors = clazz.getConstructors(); //只包含公共的 //...
  • 本文实例讲述了Java使用反射创建对象。分享给大家供大家参考,具体如下:一 实战1 代码import java.util.*;import java.io.*;public class ObjectPoolFactory{// 定义一个对象池,前面是对象名,后面是实际对象...
  • java8反射创建对象

    2021-02-12 10:20:09
    创建类package classlode;/*** * * GOOK LUCK * *** @Author by wukainian,* @Date on 2019/2/22.*/public class Systemlike {public Systemlike(String name) {this.name = name;}private String name;public ...
  • Java反射机制创建对象

    2021-02-26 16:39:43
    } } /** * 使用反射机制来创建对象 * * @author lxf * @time 2014-4-8下午05:08:41 * */ public class CreateObject { /** * Java的反射机制是指:反射就是把Java类中的各种成分映射成相应相应的Java类, 然后就...
  • 测试代码 #Ball接口 ```java ... } } 运行结果 正常创建对象时间为0毫秒 反射创建对象时间为17毫秒 原因: 反射创建对象会调用一些安全判断机制,例如在 Classz.newInstance()每创建一个对象时都会进行安全检测
  • 这篇文章主要介绍了java通过反射创建对象并调用方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下1.用户类package com.lf.entity;import ...
  • 请各位道友,2-3分钟耐心...反射创建对象的几种方式: 1:首先先定义一个Person类 package com.icitic.reflection; public class Person { public String name; public String age; public String sex; public St
  • 首先两种方式在源码里所在的位置:Class.newInstance() → Inside java.lang 包Constructor.newInstance() → Inside java.lang.reflect 包使用方法:Class.newInstance():Class.forName("HelloWorld").newInstance...
  • 有两种方法来创建对象:使用no-args构造函数使用带参数的构造函数无参数构造函数如果您有一个 Class 对象的引用,您可以创建一个对象该类对Classclass使用 newInstance()方法。此方法不使用参数,并且是等效的使用n....
  • import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.Iterator;... User user = new User(); long startTime = System.currentTimeMillis()
  • JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性方法;对于任意一个对象,都能够调用它的任意方法属性;这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。JAVA反射...
  • JAVA反射创建对象3种方式 Class clazz = Class.forName("完全限定名"); Class clazz= 对象.getClass(); Class clazz = 类.class; Constructor ctor = clazz.getDeclareConstructor(); Object obj = ctor.new...
  • 我在实现该接口的其他.apks中具有接口各种类.我使用PackageManager的查询方法查找其他类,并使用Application#createPackageContext()获取该上下文的类加载器.然后,我加载该类,创建一个新实例,然后尝试将其强制转换...
  • 反射是发生在程序运行期间的行为,在一个类加载到内存时,就会存在一个当前类的Class对象,Class对象是唯一的,不变的,包含此类中的所用内容,所以反射的源头就是Class对象反射大量运用在框架,组件,服务器等的...
  • 利用反射创建对象 方式一:通过类名.class方式 前提条件:需要在编译时就知道存在Object类 例: Class<?> obj1 = Object.class; 方式二:通过已知对象实例.getClass方式 前提条件:存在该类创建的已知对象,...
  • // 把JSON string 转化成类的对象public static T bindModel(String content, Class cls) {try {JSONObject mjson = new JSONObject(content);try {T instance = cls.newInstance();Iterator it = mjson.keys();...
  • Java反射获取class对象的三种方式,反射创建对象的两种方式1、获取Class对象在 Java API 中,提供了获取 Class 类对象的三种方法:第一种,使用 Class.forName 静态方法。前提:已明确类的全路径名。第二种,使用 ....
  • //通过反射创建对象 Class beanClass = Class.forName("app.test.Student"); Student student= (Student) beanClass.newInstance(); //利用反射将获取字段 Field declaredField = student.getClass()....
  • 反射创建对象

    2021-02-06 11:41:59
    * 因此需要反射在运行时造对象 体现了反射的动态性 编译过程并不知道需要造哪个对象,只有在运行时,根据客户的需求造对象 package Reflection; import org.junit.Test; import java.lang.reflect.Constructor; ...
  • public class Outer { class Inner{ { System.out.println("inner"); } } @Test public void test() throws Exception { ... //直接new 可以 // new Inner();... //通过父类new 可以 // Outer outer = new Oute
  • 创建对象:1、使用Class对象的newInstance()方法创建该Class对象的实例,此时该Class对象必须要有无参数的构造方法。2、使用Class对象获取指定的Constructor对象,再调用Constructor的newInstance()方法创建对象类的...
  • 可以通过包含键值对的配置文件创建对象。读取配置文件中的键值对,程序可以用键值对创建一个“字符串-对象”的对象池,然后通过字符串访问这些对象。1、两种生成方式使用Class对象的newInstance()方法制作该Class...
  • newInstance与用new是区别的,区别在于创建对象的方式不一样,前者是使用类加载机制,那么为什么会有两种创建对象方式?这个就要从可伸缩、可扩展,可重用等软件思想上解释了。Java中工厂模式经常使用newInstance来...
  • * 通过反射获得私有构造器,创建对象 * * @author silence */ public class Demo1 { public static void main(String[] args) throws Exception { //获得字节码文件 Class<User> userClass = User....
  • 通过反射创建对象

    2021-10-04 20:39:02
    反射创建对象 .通过 public 的无参构造器创建实例 通过 public 的有参构造器创建实例 通过 private 的有参构造器创建实例 package com.ftn.reflection.question; import java.lang.reflect.Constructor; //通过...
  • Java 反射对象创建

    2021-03-05 16:15:18
    有两种方法来创建对象:使用no-args构造函数使用带参数的构造函数无参数构造函数如果你有一个Class对象的引用,你可以创建一个对象该类对Class类使用newInstance()方法。此方法不使用参数,并且是等效的使用new运算符...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 235,067
精华内容 94,026
关键字:

反射创建对象和new