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

    千次阅读 2017-12-15 16:04:49
    在实际开发过程中,JAVA的反射技术应用广泛,尤其是在一些广泛使用的框架中,如Spring、mybatis中更是大量使用。java语言并不是一种动态语言,也就是说在运行时不能...反射技术就是在程序运行时将所需要的类通过Class.f
    在实际开发过程中,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的反射机制内部实现非常的复杂,感兴趣的人可以在网上找资料看看它的实现机制。

    展开全文
  • 反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息,并能直接操作任意对象的内部属性及方法。 框架=反射+注解+设计模式   1.是什么? 加载完类之后,在堆内的方法区中就产生了一个Class类型的...
  • java反射机制创建对象实现:java 深度拷贝 -超完美 ,自己做的,下面  package aop; public class Student { private String name; private int age; public String getName() { return name; } public ...
  • 一.Java反射机制1.什么是反射:反射就是把Java类中的各种成份影射成一个个的Java对象。例:一个类有:成员变量,方法,构造方法等,包等等信息,利用反射技术可以对一个类进行剖析,把各个组成部分影射成一个个对象...

    一.Java反射机制
    1.什么是反射:反射就是把Java类中的各种成份影射成一个个的Java对象。例:一个类有:成员变量,方法,构造方法等,包等等信息,利用反射技术可以对一个类进行剖析,把各个组成部分影射成一个个对象。
    2.Java反射常用类:
    (1)Class类—可获取类和类的成员信息
    (2)Field类—可访问类的属性
    (3)Method—可调用类的方法
    (4)Constructor—可调用类的构造方法
    3.如何使用反射(基本步骤):
    (1)导入java.lang.reflect.*
    (2)获得需要操作的类的Java.lang.Class对象
    (3)调用Class的方法获取Field,Method等对象
    (4)使用反射API进行操作(设置属性,调用方法)
    4.Class类:
    (1)Class类是Java反射机制的起源和入口
    (2)Class类的实例化对象代表一个正在运行的Java类或接口
    ·每个类都有自己的Class对象
    ·用于获取与类相关的各种信息
    ·提供了获取类信息的相关方法
    ·Class类继承至Object类
    (3)Class类存放类的结构信息
    ·类名;·父类,接口;·方法,构造方法,属性;·注释
    5.获取Class类对象的三种方式:
    (1)方法一:
    //方法1:对象.getClass()
    Student stu=new Student();
    Class clazz=stu.getClass();
    (2)方法二:
    //方法2:类.class
    Class clazz= Student.class;
    Class clazz=String.class;
    方法三:
    //方法3:Class.forName()
    clazz=Class.forName("java.lang.String");
    clazz=Class.forName("java.util.Date");
    例(代码):
    学生信息类(bean)

    package org.reflect.Class;
    
    public class Student {
        private String name;
        private int age;
        private double score;
    
        public Student() {
        }
    
        public Student(String name, int age, double score) {
            this.name = name;
            this.age = age;
            this.score = score;
        }
    
        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;
        }
    
        public double getScore() {
            return score;
        }
    
        public void setScore(double score) {
            this.score = score;
        }
    
        public void learn() {
            System.out.println(this.name + "正在学习...");
        }
    
        @Override
        public String toString() {
            return "Student [name=" + name + ", age=" + age + ", score=" + score
                    + "]";
        }
    
    }
    

    获取Class类对象测试类

    package org.reflect.Class;
    
    import java.lang.reflect.Modifier;
    public class ClassDemo {
    
        public static void main(String[] args) {
            Student stu=new Student();
            Class<?> c1=stu.getClass();//方式一
            Class<Student> c2= Student.class;//方式二
            Class<?> c3=null;
            try {
                c3=Class.forName("org.reflect.Class.Student");   // 方式三
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            System.out.println("方式一获取的Class对象为:"+c1.getSimpleName());
            System.out.println("方式二获取的Class对象为:"+c2);
            System.out.println("方式三获取的Class对象为:"+c3);
            int mod=c1.getModifiers();//获取修饰符所对应的整数
            String modifier=Modifier.toString(mod);//获取修饰符
            System.out.println(c1+"类所用的修饰符为:"+modifier);
        }
    
    }
    

    运行结果:
    方式一获取Class类对象:Student
    方式二获取Class类对象:reflect.Student
    方式三获取Class类对象:reflect.Student
    Student类的修饰符:public
    6.使用Class类获取类的结构信息
    (1)获取类的Class对象:
    Java学习总结(十四)——java反射机制,利用反射动态创建对象

    (2)获取Filed对象
    Java学习总结(十四)——java反射机制,利用反射动态创建对象

    (3)获取Method对象
    Java学习总结(十四)——java反射机制,利用反射动态创建对象

    (4)获取Constructor对象
    Java学习总结(十四)——java反射机制,利用反射动态创建对象

    代码示例(示例均已上述Student类为基础)
    例1(获取Filed对象)

    package org.reflect.Filed;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.Modifier;
    public class FiledDemo {
    
        public static void main(String[] args) {
            Class<Student> cl=Student.class;//获取代表Student类的Class对象
            Field[] fields=cl.getDeclaredFields();//获取属性对象,返回数组
            System.out.println(cl.getSimpleName()+"类中声明的属性有:");
            for(Field f:fields){
                String filedName=f.getName();//获取属性名
                Class<?> filedType=f.getType();//获取属性类型
                int mod=f.getModifiers();//获取修饰符对应整数
                String modifier=Modifier.toString(mod);//获取修饰符
                System.out.println(modifier+" "+filedType.getSimpleName()+" "+filedName);
            }
        }
    
    }
    

    运行结果:
    Student类中声明的属性有:

    private String name
    private int age
    private double score

    例2(获取Method对象)

    package method;
    
    import java.lang.reflect.Method;
    import java.lang.reflect.Modifier;
    
    public class MethodDemo {
    
        public static void main(String[] args) {
            try {
                Class<?> cls=Class.forName("method.Student");
                Method[] methods=cls.getDeclaredMethods();
                for(Method method:methods){
                    String methodName=method.getName();   // 获取方法名称
                    Class<?> returnType=method.getReturnType();  // 获取方法的返回值类型
                    String modStr=Modifier.toString(method.getModifiers());   // 获取方法的修饰符
                    Class<?>[] paramTypes=method.getParameterTypes();   // 获取参数类型
                    System.out.print(modStr+" "+returnType.getSimpleName()+" "+methodName+"(");
                    if(paramTypes.length==0){
                        System.out.print(")");
                    }
                    for(int i=0;i<paramTypes.length;i++){   // 遍历形式参数类型
                        if(i==paramTypes.length-1){
                            System.out.print(paramTypes[i].getSimpleName()+" args"+i+")");
                        }else{
                            System.out.print(paramTypes[i].getSimpleName()+" args"+i+",");
                        }
                    }
                    System.out.println();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
    
        }
    
    }
    

    运行结果:
    public void eat(String args0,String args1)
    public int getAge()
    public void setAge(int args0)
    public double getScore()
    public void setScore(double args0)

    7.使用反射动态创建对象
    (1)方法一:
    使用Class的newInstance()方法,仅适用于无参构造方法

    Java学习总结(十四)——java反射机制,利用反射动态创建对象

    (2)方法二:
    方法二:调用Constructor的newInstance()方法,适用所有构造方法

    Java学习总结(十四)——java反射机制,利用反射动态创建对象

    例3(获取Constructor对象)

    package org.reflect.Constructor;
    
    import java.lang.reflect.Constructor;
    
    public class ConstructorDemo {
    
        public static void main(String[] args) {
            Class<Student> cl=Student.class;//获取Class对象,代表Student类
            try {
                Constructor<Student> con=cl.getDeclaredConstructor(String.class,int.class,double.class);//获取散参构造方法
                Student stu=con.newInstance("张无忌",23,96.7);
                System.out.println(stu);
            } catch (Exception e) {
                e.printStackTrace();
            } 
        }
    
    }
    

    运行结果:
    Student [name=张无忌, age=23, score=96.7]
    例4(动态创建方法):

    package method;
    
    import java.lang.reflect.Method;
    
    public class InvokeMethod {
    
        public static void main(String[] args) {
            Class<Student> cls=Student.class;
            try {
                Student stu=cls.newInstance();   // 通过反射机制实例化对象,使用此newInstance()方法,要求类中必须包含一个无参构造方法
                Method setNameMethod=cls.getMethod("setName",String.class);
                setNameMethod.invoke(stu,"风清扬");   // 使用stu对象调用setName(String name)方法,传入"风清扬"参数
                Method getNameMethod=cls.getMethod("getName");
                System.out.println(getNameMethod.invoke(stu));  // 使用stu对象调用getName()方法,返回一个值
            } catch (Exception e) {
                e.printStackTrace();
            } 
    
        }
    
    }
    

    运行结果:
    风清扬

    转载于:https://blog.51cto.com/13501268/2104207

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

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

    展开全文
  • 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通过反射机制动态设置对象属性值的方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • // 通过反射机制创建对象,给属性赋值 Class c = Class.forName(className); Object obj = c.newInstance(); String methodName = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName....
  • 在java中,只要给定类的名字,那么就可以通过反射机制来获得类的所有属性和方法。 反射可以创建类的对象. newInstance()方法可以创建类的实例.那么拥有该方法除了Class类之外,还有Constructor类. 可是,Class类中的...
  • Java反射机制创建对象

    万次阅读 多人点赞 2014-04-08 18:48:46
    使用反射机制创建对象的步骤如下: 1、先声明你要创建的对象的类全称;使用Class类的静态方法forName(String.className)加载这个类的字节码(注意,加载字节码不等于实例化对象) ,返回 一个Class对象,这个对象...
  • JAVA反射机制 java反射机制是在运行状态中,对于任意一个类, ...这种动态获取的信息以及动态调用对象的方法的功能称为JAVA语言的反射机制。 巧妙的利用java中的反射机制,能够帮助我们进行程序开发时达到意想不到...
  • java通过反射创建对象的两种方式

    千次阅读 2019-03-07 15:44:05
    在java中,通过反射创建对象有两种方式 使用Class对象的newInstance()方法来创建对象; 具体步骤是 1、获取类的Class对象(有三种方式可以获取,可以自行百度一下) 2、通过调用所获取到的Class对象的newInstance...
  • 通过反射机制创建Class对象使用最多的方法就是通过Class.forName返回Class对象,因为这种方法需要传递的参数是一个字符串,字符串可以写入配置文件,方便修改。 /** * 创建一个Text类作为反射机制的练习 * ...
  • JAVA中通过反射机制访问对象的属性 给属性赋值set 获取属性的值get 访问私有属性需要使用setAccessible(true)打破封装,但打破封装... //不使用反射机制创建对象 User user = new User(); //不使用反射机制修改属性
  • 在通常情况下,如果有一个类,可以通过创建对象;但是反射就是要求通过一个对象找到一个类的名称;   2:在反射操作中,握住一个核心概念: 一切操作都将使用Object完成,类,数组,的引用都可以使用Object...
  • JSP中通过反射机制创建javaBean对象

    千次阅读 2017-08-25 16:12:46
    out.print(session.getAttribute("user")); %> 在jsp文件中,可以调用jsp的动作:useBean去创建javaBean对象。 前提:被创建对象的类必须符合javaBean结构,即: ...id:是指向对象的引用class:需要被创建对象
  • 1.通过Java反射机制获取JavaBean对象。 2.通过JavaBean全路径字符串获取JavaBean对象。 3.获取JavaBean注解信息
  • java.lang.Class类和反射机制创建对象

    万次阅读 2015-11-24 00:12:02
    java.lang.Class类  Java程序在运行时,Java运行时系统一直对所有的对象进行所谓的运行时...Class类封装一个对象和接口运行时的状态,当装载类时,Class类型的对象自动创建。  Class 没有公共构造方法。Class 对象
  • Class类2.1 常用方法和示例2.2 获取Class对象的 3 种方法2.3 反射创建对象的 2 种方法3. 工厂设计模式(示例) 1.Java反射机制 1.1 反射机制是什么 在运行状态中,对于任意一个类都能够知道这个类所有的属性和方法...
  • 利用反射创建对象的几种方式

    千次阅读 2019-05-23 15:50:42
    创建对象 1.使用Class对象的newInstance()方法来创建类的实例,这种方式要求该Class对象的对应类有默认构造器,执行newInstance()实际上是利用默认构造器来创建该类的实例。 2.先使用Class对象获取到Constructor对象...
  • 之前一直想通过配置文件如xml,配置一个类名,通过这个类名创建对象通过基类指针来指向派生类,管理一系列这样对象,继承,这样的可以不修改管理咧,直接添加或修改配置文件来动态创建管理类,非常方便。...
  • 至于Java中出现RRTI的说法则是源于《ThinkinginJava》一书,其作用是在运行时识别一个对象的类型和类的信息,这里分两种:传统的”RRTI”,它假定我们在编译期已知道了所有类型(在没有反射机制创建和使用类对象时,...
  • 首先创建一个类public class ReflectDemo { private int m=0; //私有属性 private ReflectDemo(){ //私有无参构造函数 } public ReflectDemo(int aa){ //有参构造函数 } private int add(int a,int b){ //私有方法
  • Student类,有属性id, name, age, 还有对应的get,set方法和构造方法。 现产生一个Student对象通过反射复制此Student对象。复制时,并不知道源对象具体的属性名称。
  • 什么是反射创建对象的角度上来看,狭义的说,比如有个 class A ,你能直接 new A() 来创建 对象。...这种把 class 作为变量,又能在运行时创建对象机制,就叫做反射。 大部分的高级编程语言,先天是...
  • python使用反射机制实例化对象

    万次阅读 2018-01-19 22:06:44
    然后通过获取A的所有子类对象,用反射机制实例化对象,再调用数据查询的方法来完成所有类别的数据解析工作,这样如果再新增一个类别,只需要再添加一个A的子类对象即可。 例子: 项目结构如下:
  • 要根据字符串创建对象,可以使用 Class.forName(String) 方法;而要新建一个可以指定初始值参数的对象,就必须得使用 getConstructor(Class...) 方法;之后再对Constructor对象调用 newInstance(Object...) 方法。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 158,588
精华内容 63,435
关键字:

通过反射机制创建对象