精华内容
下载资源
问答
  • 指的一类应用,它们能够自描述和自控制。这样说太抽象了。我们看个例子,实践:import java。...forName() 这是反射的一种方式。将类在运行时自动加载进来Class c = Class。forName(“java。l...

    指的是一类应用,它们能够自描述和自控制。这样说太抽象了。我们看个例子,实践:import java。lang。reflect。*;public class Refl {

    public static void main(String args[]) {

    try {

    //Class。

    forName() 这是反射的一种方式。将类在运行时自动加载进来

    Class c = Class。forName(“java。lang。String”);

    // getDeclaredMethods()获取这个类中定义了的方法列表

    Method m[] = c。

    getDeclaredMethods();

    for (int i = 0; i < m。length; i++)

    System。out。println(m[i]。toString());

    } catch (Throwable e) {

    System。

    err。println(e);

    }}}

    执行的时候发现输出了,String 类的所有方法打印了出来。重要的是,Class。forName这句话它是反射的一种方式。就是在运行时改变Refl类的状态,通过”java。lang。String”改变。

    Java语言提供了一套反射类,java。lang。reflect。*;这些类可以用做:l

    构造新类实例和新数组l

    访问并修改对象(Object)和类的字段(Field)l

    调用对象和类中的方法(Method)l

    访问并修改数组的元素

    反射是一种强大的工具,但也存在一些不足。

    一个主要的缺点是对性能有影响。使用反射基本上是一种解释操作,我们可以告诉JVM,我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。一边执行的时候,一边加载其它类,肯定会慢的。但是它有很强的扩展性,具有开放性的系统很多都采用这种机制,因为在安全允许的情况下它可以随意加载类,和调用方法。

    在windows编程里面的dll与它几乎是一个意思。

    全部

    展开全文
  • Java 反射机制 Java 语言一个重要特性,它在服务器程序和中间件程序中得到了广泛运用。在服务器端,往往需要根据客户请求,动态调用某一个对象特定方法。此外,在 ORM 中间件实现中,运用 java 反射机制...

    Java 反射机制是 Java 语言的一个重要特性,它在服务器程序和中间件程序中得到了广泛运用。在服务器端,往往需要根据客户的请求,动态调用某一个对象的特定方法。此外,在 ORM 中间件的实现中,运用 java 反射机制可以读取任意一个 JavaBean 的所有属性,或者给这些属性赋值。

    Java 反射机制主要提供了以下功能,这些功能都位于 java.lang.reflect 包。

    • 在运行时判断任意一个对象所属的类。
    • 在运行时构造任意一个类的对象。
    • 在运行时判断任意一个类所具有的成员变量和方法。
    • 在运行时调用任意一个对象的方法。
    • 生成动态代理。


    众所周知,所有 Java 类均继承了 Object 类,在 Object 类中定义了一个 getClass() 方法,该方法返回同一个类型为 Class 的对象。例如,下面的示例代码:

    
     
    1. Class labelCls=label1.getClass(); //label1为 JLabel 类的对象


    利用 Class 类的对象 labelCls 可以访问 labelCls 对象的描述信息、JLabel 类的信息以及基类 Object 的信息。表 1 列出了通过反射可以访问的信息。
     

    表1 反射可访问的常用信息
    类型 访问方法 返回值类型 说明
    包路径 getPackage() Package 对象 获取该类的存放路径
    类名称 getName() String 对象 获取该类的名称
    继承类 getSuperclass() Class 对象 获取该类继承的类
    实现接口 getlnterfaces() Class 型数组 获取该类实现的所有接口
    构造方法 getConstructors() Constructor 型数组 获取所有权限为 public 的构造方法
    getDeclaredContxuectors() Constructor 对象 获取当前对象的所有构造方法
    方法 getMethods() Methods 型数组 获取所有权限为 public 的方法
    getDeclaredMethods() Methods 对象 获取当前对象的所有方法
    成员变量 getFields() Field 型数组 获取所有权限为 public 的成员变量
    getDeclareFileds() Field 对象 获取当前对象的所有成员变量
    内部类 getClasses() Class 型数组 获取所有权限为 public 的内部类
    getDeclaredClasses() Class 型数组 获取所有内部类
    内部类的声明类 getDeclaringClass() Class 对象 如果该类为内部类,则返回它的成员类,否则返回 null


    如表 1 所示,在调用 getFields() 和 getMethods() 方法时将会依次获取权限为 public 的字段和变量,然后将包含从超类中继承到的成员实量和方法。而通过 getDeclareFields() 和 getDeclareMethod()只是获取在本类中定义的成员变量和方法。

    展开全文
  • 一、概念RTTI(Run-Time Type Identification,运行时类型识别)含义就是在运行时识别一个对象类型,其对应Class对象,怎么理解这个Class对象呢?如果说类所有对象方法、属性集合,那就可以把这个Class...

    一、概念

    RTTI(Run-Time Type Identification,运行时类型识别)的含义就是在运行时识别一个对象的类型,其对应的类是Class对象,怎么理解这个Class对象呢?如果说类是所有对象方法、属性的集合,那就可以把这个Class对象理解成是所有class的集合,然后利用这个Class对象动态的解析出相关类,并可以获得其构造器和方法等,甚至实例化这个类的对象。开始文章前,先提重要的一点:无论是RTTI还是反射,其本质都是一样的,都是去动态的获取类的信息,他们唯一的区别仅是:

    RTTI 在编译期知道要解析的类型。

    反射 在运行期知道要解析的类型。

    二、RTTI

    有以下两种方式可以获取到Class对象:

    public static voidmain(String[] args)

    {try{//第一种方式

    Class rtti = Class.forName("com.jomoo.test.rtti.RTTI");//第二种方式

    Class type=RTTI.class;

    }catch(ClassNotFoundException e) {

    e.printStackTrace();

    }

    }

    可以看到,采用RTTI的方式必须在写程序的时候就知道了类的名字,才能获取到Class对象对这个类的引用,并利用这个引用,得到大量关于这个类的信息,包括接口,父类,方法,静态成员,甚至是像newInstance()方法这样的一个实现“虚拟构造器”的一种方式。

    RTTI r =(RTTI)rtti.newInstance();//newInstance的类必须要有一个缺省构造器

    另外需要提一个经常用到 instanceof 该关键字的调用其实就是使用了Class对象,并且返回一个布尔值。

    Object o =rtti.newInstance();if (o instanceofRTTI){

    System.out.println(true);//这里需要注意的是,如果 o 是 RTTI的子类的话,返回的也会true;

    }

    三、反射

    Java中有时候在编译器为程序生成代码很久之后才会出现要处理的那个类,那么这个时候怎么才能处理这个类呢,即在编译的时候根本无法获知这个对象所属的类。答案就是利用Java的反射机制。废话不多说,看完下面这个代码你就很清楚的明白 RTTI 和 反射的区别在哪里了。

    public classRTTI

    {private static final String usage="usage";private static Pattern pattern=Pattern.compile("\\w+\\.");public static voidmain(String[] args)

    {if (args.length<1){

    System.out.println(usage);

    System.exit(0);

    }int lines=0;try{

    Class c= Class.forName(args[0]);//看这里类的名字在编译的时候是无法得知的,只有在运行的时候动态传进去

    Method[] method =c.getMethods();

    Constructor[] constructors=c.getConstructors();if (args.length==1){for (int i=0;i

    System.out.println(pattern.matcher(method[i].toString()).replaceAll(""));

    }for (int i=0;i

    System.out.println(pattern.matcher(constructors[i].toString()).replaceAll(""));

    }

    lines=method.length+constructors.length;

    }else{for (int i=0;i

    System.out.println(pattern.matcher(method[i].toString()).replaceAll(""));

    }

    lines++;

    }for (int i=0;i

    System.out.println(pattern.matcher(constructors[i].toString()).replaceAll(""));

    }

    lines++;

    }

    }

    }catch(ClassNotFoundException e) {

    System.out.println("NO!!!!");

    }

    }

    }

    如何在main方法中带入参数可以参考,我用原生的 javac -encoding UTF-8 RTTI.java 和 java RTTI com.jomoo.test.seven.ActionCharacter来运行 竟然报错了:Error: Could not find or load main class RTTI,我的JDK有毒!无奈借助了强大的IDE工具:

    cd8c40cd2b31241ea5a40ab7dd56482d.png

    b62116971b9ba915a2078a1faaa5ff2a.png

    四、总结

    其实 RTTI 的概念只是在《Thinking in Java》中提到的,才引来这么多人的讨论,原生的Java中并没有这个概念的说法。所以勒,我们根本不必纠结是 RTTI 还是反射,他们无论用法还是本质都是一样的,都是为了实现一样的目的——动态的获取类的信息,我们应该把重点放在使用上,而不要过多在纠结在差异上。

    展开全文
  • 1、JAVA反射机制在运行状态中,  对于任意一个类,都能够知道这个类所有属性和方法;  对于任意一个对象,都能够调用它任意一个方法和属性; 这种动态获取信息以及动态调用对象方法功能称为java...

    1、JAVA反射机制是在运行状态中,
     对于任意一个类,都能够知道这个类的所有属性和方法;
     对于任意一个对象,都能够调用它的任意一个方法和属性;
    这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

    2、Java反射机制主要提供了以下功能:
     在运行时判断任意一个对象所属的类;
     在运行时构造任意一个类的对象;
     在运行时判断任意一个类所具有的成员变量和方法;
     在运行时调用任意一个对象的方法;
     生成动态代理。

    3、反射技术大量用于Java设计模式和框架技术,最常见的设计模式就是工厂模式单例模式

    单例模式(Singleton)

    这个模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在。在很多操作中,比如建立目录 数据库连接都需要这样的单线程操作。这样做就是为了节省内存空间,保证我们所访问到的都是同一个对象。
    单例模式要求保证唯一,那么怎么样才能保证唯一性呢?对了,这就是静态变量。单例模式有以下两种形式:

    第一种形式:

    package reflect; 
    public class Singleton {  
        private Singleton() { 
        }  
        private static Singleton instance = new Singleton(); 
        // 这里提供了一个供外部访问本class的静态方法,可以直接访问 
        public static Singleton getInstance() { 
               return instance; 
        }    
    } 
    class SingRun{ 
        public static void main(String[] args){ 
           //这样的调用不被允许,因为构造方法是私有的。 
           //Singleton x=new Singleton();      
           //得到一个Singleton类实例 
           Singleton x=Singleton.getInstance();   
           //得到另一个Singleton类实例 
           Singleton y=Singleton.getInstance();     
           //比较x和y的地址,结果为true。说明两次获得的是同一个对象 
           System.out.println(x==y); 
        } 
    } 
    

    第二种形式:

    public class Singleton { 
        //先申明该类静态对象 
        private static Singleton instance = null;   
        //创建一个静态访问器,获得该类实例。加上同步,表示防止两个线程同时进行对象的创建 
        public static synchronized Singleton getInstance() {      
           //如果为空,则生成一个该类实例 
           if (instance == null){ 
               instance = new Singleton(); 
           } 
           return instance; 
        } 
    } 
    

    工厂模式(Factory)

    工厂模式是我们最常用的模式了,著名的Jive论坛 ,就大量使用了工厂模式,工厂模式在Java程序系统可以说是随处可见。
     为什么工厂模式是如此常用?是因为工厂模式利用Java反射机制和Java多态的特性可以让我们的程序更加具有灵活性。用工厂模式进行大型项目的开发,可以很好的进行项目并行开发。就是一个程序员和另一个程序员可以同时去书写代码,而不是一个程序员等到另一个程序员写完以后再去书写代码。其中的粘合剂就是接口和配置文件。之前说利用接口可以将调用和实现相分离。那么这是怎么样去实现的呢?工厂模式可以为我们解答。
     我们先来回顾一下软件的生命周期,分析、设计、编码、调试与测试。其中分析就是指需求分析,就是知道这个软件要做成什么样子,要实现什么样的功能。功能知道了,这时就要设计了。设计的时候要考虑到怎么样高效的实现这个项目,如果让一个项目团队并行开发。这时候,通常先设计接口,把接口给实现接口的程序员和调用接口的程序员,在编码的时候,两个程序员可以互不影响的实现相应的功能,最后通过配置文件进行整合。
    代码示例:

    interface InterfaceTest{ 
        public void getName();//定义获得名字的方法 
    } 
    

    接口有了,那么得到这个接口,进行实现编码的程序员应该怎么做呢?对了,实现这个接口,重写其中定义的方法
    接口实现方法:

    class Test1 implements InterfaceTest{ 
        public void getName() { 
           System.out.println("test1"); 
        } 
    } 
    class Test2 implements InterfaceTest{ 
        public void getName() { 
           System.out.println("test2"); 
        } 
       
    } 
    

    大家可以发现,当接口定义好了以后,不但可以规范代码,而且可以让程序员有条不紊的进行功能的实现。实现接口的程序员根本不用去管,这个类要被谁去调用。 那么怎么能获得这些程序员定义的对象呢?在工厂模式里,单独定义一个工厂类来实现对象的生产,注意这里返回的接口对象。
    工厂类,生产接口对象:

    class Factory{ 
        //创建私有的静态的Properties对象 
        private static Properties pro=new Properties(); 
        //静态代码块 
        static{ 
           try {        
               //加载配置文件 
               pro.load(new FileInputStream("file.txt")); 
           } catch (Exception e) { 
               e.printStackTrace(); 
           } 
        } 
        private static Factory factory=new Factory(); 
        private Factory(){}   
        public static Factory getFactory(){ 
           return factory; 
        } 
        public  InterfaceTest getInterface(){ 
           InterfaceTest interfaceTest=null;//定义接口对象     
           try { 
               //根据键,获得值,这里的值是类的全路径 
               String classInfo=pro.getProperty("test");  
               //利用反射,生成Class对象 
               Class c=Class.forName(classInfo);  
               //获得该Class对象的实例 
               Object obj=c.newInstance(); 
               //将Object对象强转为接口对象 
               interfaceTest=(InterfaceTest)obj; 
           } catch (Exception e) { 
               e.printStackTrace(); 
           } 
           //返回接口对象 
           return interfaceTest; 
        } 
    } 
    

    配置文件内容:

    test=factory.Test2 
    

    通过这个类,大家可以发现,在调用的时候,得到的是个接口对象。而一个接口变量可以指向实现了这个接口的类对象。在利用反射的时候,我们并没有直接把类的 全路径写出来,而是通过键获得值。这样的话,就有很大的灵活性,只要改变配置文件里的内容,就可以改变我们调用的接口实现类,而代码不需做任何改变。在调 用的时候,我们也是通过接口调用,甚至我们可以连这个接口实现类的名字都不知道。
    调用方法:

    public class FactoryTest { 
        public static void main(String[] args) { 
           //获得工厂类的实例 
           Factory factory=Factory.getFactory(); 
           //调用获得接口对象的方法,获得接口对象 
           InterfaceTest inter=factory.getInterface(); 
           //调用接口定义的方法 
           inter.getName(); 
        } 
    } 
    

    上面的代码就是调用方法。大家可以发现,在调用的时候,我们根本没有管这个接口定义的方法要怎么样去实现它,我们只知道这个接口定义这个方法起什么作用就行了。上面代码运行结果要根据配置文件来定。如果配置文件里的内容是test=factory.Test2。那么表示调用factory.Test2这个 类里实现接口的方法,这时候打印“test2”。如果配置文件里的内容是test=factory.Test1。那么表示调用factory.Test1 这个类里实现接口的方法,这时候打印“test1”。

    展开全文
  • Java反射机制Java语言一个重要特性,首先话,我们先要来了解一下2个概念,一个编译期,一个运行期。编译期-指把源码交给编译器编译成计算机可以执行文件过程。在Java当中,也就是把Java代码编成class...
  • 如题。... 大家谁能告诉我 反射是什么概念。 有什么用。? 在编程 是否用到它。 或者 它有什么优势? 希望个位大牛能知道点 就说点。 错 了大家一起讨论。 我学了快3年C# 对反射很茫然啊
  • 反射的引入:Object obj = new Student();若程序运行时接收到外部传入的一个对象,该对象的编译类型Object,但程序又需要调用该对象运行类型的方法:1.若编译和运行类型都知道,使用 instanceof判断后,强转。2....
  • java 反射的概念

    2019-07-05 10:17:00
    反射的引入: Object obj = new Student(); 若程序运行时接收到外部传入的一个对象,该对象的编译类型Object,但程序又需要调用该对象运行类型的方法: 1.若编译和运行类型都知道,使用 instanceof判断后,...
  • 反射的基本概念什么是反射:反射就是把java中的各个部分,映射成一个个的java对象,也可以理解为这一种创建对象的方式,然后利用这个对象来做一些事情。既然说反射反射java类中的各个组成部分,那么一个类的组成...
  • 1.反射的概念1.1 补充1.2 小总结2. 反射的使用3.动态加载二、反射的应用1.访问字段1.1 获取字段值提问:1.2设置字段值 前言 反射一个Java中很重要的一点,也面试官常考的考点;同时在后期如果学习到Spring框架时...
  • (js的反射随处可见,而且你自己可能经常用)反射的概念比较强的语言像java和go。因为他们都静态语言。缺乏很多动态特性。他们只有通过一大堆api才能反射。所以才会有比较强反射的概念。js一个基于原型继承的...
  • 反射的概念及应用

    2020-03-17 19:09:13
    一、什么是反射 反射总是围绕Class对象进行,先来了解一下对象加载过程。 1.一个.java文件经过编译成功后,生成一个.class文件 2.当我们执行了初始化操作(有可能new、有可能子类初始化 父类也一同被初始...
  • 1.反射机制定义反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问、检测和修改其本身状态或行为的一种能力。在Java环境中,反射机制允许程序在执行时获取某个类自身的定义信息,例如熟悉和方法等也可以...
  • chapter29 反射的概念

    2018-06-17 21:48:01
    生活中的反射:B超检查研究地球内部构造使用“地震波”什么是反射程序在在运行过程中,可以查看其它程序集或本身程序集中元数据行为。名词解释:程序集:项目中所有代码以及嵌入式资源集合。元数据:我们编写...
  • 一、什么是反射机制 简单来说,反射...二、哪里用到反射机制 有些时候,我们用过一些知识,但是并不知道它专业术语是什么,在刚刚学jdbc时用过一行代码,Class.forName("com.mysql.jdbc.Driver.class").newInsta...
  • Introspector 一个专门处理bean工具类.用来获取Bean体系里 propertiesDescriptor,methodDescriptor. 要理解这个,就要理解下面几个议题. *bean啥?  普通class 可能有 computerAges(){ }等方法.  ...
  • 反射的基本概念

    2019-07-31 14:33:05
    什么是反射 反射是一种机制,利用该机制可以在程序运行过程中对类进行解剖并操作类中方法,属性,构造方法等成员。 使用反射机制解剖类前提 必须先要获取到该类字节码文件对象,即Class类型对象。 获取...
  • 反射的概念与简单示例什么事反射:反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问、检测和修改它本身状态或行为的一种能力(自省)。 hasattr(object,name)判断object类中是否有name这个方法,或者是...
  • 框架半成品软件,可以在框架基础上进行软件开发,简化编码,而反射是框架灵魂。 Java在计算机中经历阶段:三个阶段 source源代码阶段 class类对象阶段 运行时阶段 class类:class类对象由成员变量...
  • 1.反射机制定义反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问、检测和修改其本身状态或行为的一种能力。在Java环境中,反射机制允许程序在执行时获取某个类自身的定义信息,例如熟悉和方法等也可以...
  • JAVA中反射是什么时间:2017-11-17相关问题:匿名网友:反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射...
  • JAVA反射机制在运行状态中,对于任意一个类,都能够知道这个类所有属性和方法;对于任意一个对象,都能够调用它任意一个方法和属性;反射其实通过Class对象来调用类里面方法。通过反射可以调用私有方法和...
  • 1、反射的概念: 反射是相对于正射来说的,正射是先通过构造方法创建类的对象,然后使用类的各种属性和方法 而反射是什么时候想要用到这个类了,就通过类名把这个类加载进来,然后获得构造方法,获得属性和方法...
  • Introspector 一个专门处理bean工具类.用来获取Bean体系里 propertiesDescriptor,methodDescriptor. 要理解这个,就要理解下面几个议题. *bean啥?  普通class 可能有 computerAges(){ }等方法. ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,812
精华内容 724
关键字:

反射的概念是什么