精华内容
下载资源
问答
  • JAVA的反射

    千次阅读 2010-09-09 16:44:00
    java 反射

    展开全文
  • Java 中所有的类都继承自 ...在Java的反射机制中,通过 数组的 class 对象的getComponentType()方法可以取得一个数组的Class对象, 通过Array.newInstance()可以反射生成数组对象,看示例代码:package com.ips.reflec

    Java 中所有的类都继承自 Object,数组本身也是一个 Class,如果我们能够得到数据的 Class 对象,那么我们可以通过反射生成数组对象。

    在Java的反射机制中,通过 数组的 class 对象的getComponentType()方法可以取得一个数组的Class对象, 通过Array.newInstance()可以反射生成数组对象,看示例代码:

    package com.ips.reflect;
    
    import java.lang.reflect.Array;
    
    public class GetComponentType {
        public static void main(String [] args){
            Class<char[]>  aa = (Class<char[]>) char.class.getComponentType();
            System.out.println("the componentType of the char is :" + char.class.getComponentType());
            System.out.println("the componentType of the char[] is :" + char[].class.getComponentType());
            System.out.println("the componentType of the String is :" + String.class.getComponentType());
            System.out.println("the componentType of the String[] is :" + String[].class.getComponentType());
            System.out.println("the componentType of the int is :" + int.class.getComponentType());
            System.out.println("the componentType of the int[] is :" + int[].class.getComponentType());
            System.out.println("the componentType of the Integer is :" + Integer.class.getComponentType());
            System.out.println("the componentType of the Integer[] is :" + Integer[].class.getComponentType());
    
            try {
                char c = (char)Array.newInstance(char.class.getComponentType(), 10);
            } catch (Exception e) {
                e.printStackTrace();
            }
            char[] charArray = (char [])Array.newInstance(char[].class.getComponentType(), 100);
            System.out.println("the length of the charArray is :" + charArray.length);
    
            try {
                String c = (String)Array.newInstance(String.class.getComponentType(), 10);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            String[] strArray = (String [])Array.newInstance(String[].class.getComponentType(), 10);
            System.out.println("the length of the strArray is :" + strArray.length);
    
        }
    }
    
    

    执行结果:

    the componentType of the char is :null
    the componentType of the char[] is :char
    the componentType of the String is :null
    the componentType of the String[] is :class java.lang.String
    the componentType of the int is :null
    the componentType of the int[] is :int
    the componentType of the Integer is :null
    the componentType of the Integer[] is :class java.lang.Integer
    java.lang.NullPointerException
    at java.lang.reflect.Array.newArray(Native Method)
    at java.lang.reflect.Array.newInstance(Array.java:70)
    at com.ips.reflect.GetComponentType.main(GetComponentType.java:23)
    the length of the charArray is :100
    java.lang.NullPointerException
    at java.lang.reflect.Array.newArray(Native Method)
    at java.lang.reflect.Array.newInstance(Array.java:70)
    at com.ips.reflect.GetComponentType.main(GetComponentType.java:31)
    the length of the strArray is :10

    通过以上代码我们可以发现:

    1. 非数组类型无法通过getComponentType()获取到相应的 Class 对象;
    2. 非数组类型无法通过(String [])Array.newInstance(String[].class.getComponentType(), 10)方法反射生成数组对象,因为获取不到 Class 对象;
    3. 无论基本数据类型(byte short int long float double char boolean)的数组还是引用数据类型(Integer String 等)的数组,都可以通过getComponentType()获取到相应的 Class 对象,都可以通过(String [])Array.newInstance(String[].class.getComponentType(), 10)方法反射生成数组对象。
    展开全文
  • Java的反射机制:  JAVA反射机制是就是运行的状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能...

    Java的反射机制:

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

    最常用的反射机制就是:(当然  reflect 类还有其他的很多的方法 不一一列举)

    <pre name="code" class="java">Class.forName("obj name").newInstance();                                                                                               
    
    

    抽象工厂模式:

    抽象工厂角色: 这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
    具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。
    抽象产品(方法)角色:它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

    抽象工厂通常和java的反射机制紧密联系在一起。当遇到新的具体工厂角色出现时,如果没有java的反射机制,我们需要首先创建具体的工厂类,在UI(客户端)修改相关代码, 将具体的工厂的实例化代码加入。严重违反了开闭原则。但是通过java的反射机制就可以将抽象工厂模式的实现对修改封闭,在拓展开放,将新的具体的工厂类名的写入xml文件中,通过读取xml文件就可以读取到新增的具体工厂的类名,根据类名自动生成相应类的实例化。

    具体代码如下:

    抽象工厂角色:

    //iifactory.java
    public interface iffactory {
          public void createob();
    }

    具体工厂角色:

    //javafactory
    public class javafactory implements iffactory{
    
    	@Override
    	public void createob() {
    		// TODO Auto-generated method stub
    		System.out.println("create java object");
    	}
          
    }
    
    //cppfactory
    public class cppfactory  implements iffactory{
    
    	@Override
    	public void createob() {
    		// TODO Auto-generated method stub
    		System.out.println("create c++ object");
    	}
        
    }
    
    //csharpfactory
    public class csharpfactory implements iffactory{
    
    	@Override
    	public void createob() {
    		// TODO Auto-generated method stub
    		System.out.println("create a csharp object");
    	}
         
    }
    testUI(客户端)

    public class testUI {
        private String objectstr;
        public void setselect(String key){
        	this.objectstr=key;
        }
        public String getselect(String key){
        	return this.objectstr;
        }
        public iffactory createobj(){
        	iffactory iffac = null;
        	try{
        		//
        		iffac=(iffactory) Class.forName(objectstr).newInstance();
        	}catch(Exception e){
        		e.printStackTrace();
        	}
        	return iffac;
        }
        public static void main(String[] args) {
    		testUI test=new testUI();
    		iffactory iffac=null;
    		test.setselect("cppfactory");
    		iffac=test.createobj();
    		iffac.createob();
    	}
    }
    运行结果:

    因此我们如果再有其他的具体的工厂加入,首先创建具体的工厂类去生产具体的对象,接着讲具体的类名写入xml文件中,通过xml文件的具体字符串类名,去实现具体工厂的实例化。
    展开全文
  • 什么是Java的反射机制

    千次阅读 2016-09-01 19:29:31
    类在运行的时候,可以得到该类的信息,并且 可以动态的修改这些信息,自己能看到自己,跟照镜子一样,也就是说Java的反射机制是在编辑的时候并不确定哪个类被加载了,而是在程序运行的时候才加载、探知、自审,使用...

    Java反射机制是Java的特点,是框架实现的基础,百度结果:JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。java通常是先有类再有对象,有对象我就可以调用方法或者属性。反射其实是通过Class对象来调用类里面的方法。通过反射可以调用私有方法和私有属性。大部分框架都是运用反射原理,精简总结一下:
    1.什么是反射
    答:就是可以在程序运行的时候动态装载类,查看类的信息,生成对象,或操作生成对象。类在运行的时候,可以得到该类的信息,并且 可以动态的修改这些信息,自己能看到自己,跟照镜子一样,也就是说Java的反射机制是在编辑的时候并不确定哪个类被加载了,而是在程序运行的时候才加载、探知、自审,使用在编译期并不知道的类,这样的特点就是反射。
    2.那么Java反射有什么作用呢? 
    假如我们有两个程序员,一个程序员在写程序的时候,需要使用第二个程序员所写的类,但第二个程序员并没完成他所写的类。那么第一个程序员的代码能否通过编译呢?这是不能通过编译的。利用Java反射的机制,就可以让第一个程序员在没有得到第二个程序员所写的类的时候,来完成自身代码的编译。Java反射机制主要提供了以下功能: 在运行时判断任意一个对象所属的类;在运行时构造任意一个类的对象;在运行时判断任意一个类所具有的成员变量和方法;在运行时调用任意一个对象的方法;生成动态代理。
    Java的反射机制它知道类的基本结构,这种对Java类结构探知的能力,我们称为Java类的“自审”。大家都用过Jcreator和eclipse。 当我们构建出一个对象的时候,去调用该对象的方法和属性的时候。一按点,编译工具就会自动的把该对象能够使用的所有的方法和属性全部都列出来,供用户进行 选择。这就是利用了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的反射机制实现对象的拷贝

    千次阅读 2016-11-02 10:44:51
    通过Java的反射机制实现对象的拷贝
  • 利用java的反射机制实现通用dao

    千次阅读 2016-08-15 17:27:29
    java的反射机制前面已经讲过,这里不再赘述,这篇文章将会利用反射,来实现一个通用的dao层。 1 一般情况下的dao层我们先来看一下,通常,我们是如何写dao的。public class Person { public int pid; public ...
  • java进阶之java的反射机制

    千次阅读 2016-08-12 15:24:41
    这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 Java反射机制主要提供了以下功能: 在运行时判断任意一个对象所属的类; 在运行时构造任意一个类的对象; 在运行时判断任意一个类所具有...
  • java的反射机制浅谈

    万次阅读 多人点赞 2010-09-26 19:52:00
    一、java的反射机制浅谈最近研究java研究得很给力,主要以看博文为学习方式。以下是我对java的反射机制所产生的一些感悟,希望各位童鞋看到失误之处不吝指出。受到各位指教之处,如若让小生好好感动,说不定会请各位...
  • JAVA的反射机制主要提供的功能有: 1、在运行时判断任意一个对象所属的类; 2、在运行时构造任意一个类的对象; 3、在运行时判断任意一个类所具有的成员变量和方法; 4、在运行时调用任意一个对象的方法; ...
  • android使用java的反射机制跳转Activity

    千次阅读 2017-05-25 17:33:31
    使用java的反射机制可以达到所要的效果 try { Class clz = Class.forName("com.testdemo.MainActivity"); startActivity(new Intent(JsonAct.this, clz)); } catch (ClassNo
  • Java的反射机制

    千次阅读 2014-07-08 11:34:10
    JAVA反射机制:“程序运行时,允许改变程序结构或变量类型...这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 功能: Java反射机制主要提供了以下功能: 在运行时判断任意一个对象所属的类;
  • 大佬,到底什么是Java的反射

    千次阅读 多人点赞 2020-08-06 23:23:05
    这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制 一般情况下,我们使用类来创建对象都是一开始就知道具体的类型以及类的用途,直接通过类来创建对象 Order order = new Order(new BigDecimal...
  • 详解Java的反射技术

    千次阅读 2020-03-01 14:47:59
    反射:框架设计灵魂 框架:半成品软件 可以在框架基础上进行软件开发 简化编码 反射机制:将类各个组成部分封装为其他对象 相当于创建了一个大数组 存放了所有成员变量 又创建了另一个大数组 存放了所有...
  • C++实现类似JAVA的反射 .

    千次阅读 2012-08-21 23:04:43
    一个JAVA程序员都知道,JAVA的反射功能让框架程序可以变得很强大,可以在运行期间根据一个类名,动态地创建该类的一个对象.  一个C++程序员都知道,C++本身是不具备反射能力的.但是,JAVA的反射说白了,就是对内存的玩弄...
  • 利用Java的反射与代理机制实现AOP

    千次阅读 2016-01-19 17:10:13
    在上一篇文章中,我们讲述了利用Java的反射机制中实现Spring中的IOC,在本文中,我们将更进一步,讲述用Java的反射和动态代理机制来实现Spring的AOP。 一.AOP概述  AOP(Aspect Oriented Programing),即面向切面...
  • java的反射机制原理

    千次阅读 2018-08-15 15:13:02
    一 反射机制的概念: 指在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法,对于任意一个对象,都能调用它的任意一个方法.这种动态获取信息,以及动态调用对象方法的功能叫java语言的反射
  • C++实现类似JAVA的反射

    千次阅读 2011-03-26 14:38:00
    <br /> 一个JAVA程序员都知道,JAVA的反射功能让框架程序可以变得很强大,可以在运行期间根据一个类名,动态地创建该类的一个对象.  一个C++程序员都知道,C++本身是不具备反射能力的.但是,JAVA的反射说白...
  • 使用Java的反射功能调用类中的方法

    千次阅读 2014-11-05 10:57:27
    最近一直在搞Java的反射,今天使用反射调用方法时出现了很多问题,主要是没有详细参考官方API。所以走了很多弯路。 所以想把这个例子记下来,供自己也供他人学习。
  • Java的反射和内省的区别

    千次阅读 2017-03-30 00:00:13
    反射 反射就是运行时获取一个类的所有信息,可以获取到.class的任何定义的信息(包括成员 变量,成员方法,构造...生活中 反射就像我们照镜子,照镜子时候 你的所有信息会毫无出错毫无保留的反射到镜子中,而java中反
  • 就以上这种动态获取信息的机制就称为Java的反射机制 彻底了解反射之前,我们还需要知道一个知识点:一般情况下,Java类在编译前,该类的相关数据就已经被加载到JVM中,而我们的反射机制可以在程序运行时,去操作类的...
  • java的反射与内省机制的实现

    千次阅读 2010-09-18 18:24:00
    java的反射机制的实现 <br />很多朋友在深入的接触JAVA语言后就会发现这样两个词:反射(Reflection)和内省(Intro spector),经常搞不清楚这到底是怎么回事,在什么场合下应用以及如何使用?...
  • Android 使用Java的反射机制总结

    千次阅读 2018-01-12 19:31:13
    反射是一种具有与Java类进行动态交互能力一种机制,在Java和Android开发中,一般需要访问隐藏属性或者调用方法改变程序原来逻辑时会用到,这个比较常见,由于一些原因,系统并没有开放一些接口出来,这个时候...
  • [Java密码学] 1、Java的反射

    千次阅读 2019-12-04 21:14:54
    首先,我们需要学习一下反射的概念 ... Class类类表示正在运行的Java应用程序中类和接口 Class.forName() 有2个重载方法 public static Class forName(String className) public static Cl...
  • Java的反射机制简述

    千次阅读 2016-07-19 18:56:01
    反射机制是Java语言中一个非常重要特性,它允许程序在运行时进行自我检查,同时也允许内部成员进行操作。虽然这个特性在实际开发中使用不多,但是像Pascal、C和C++等语言根本没有提供这样特性。由于反射机制...
  • 关于Java的反射机制,你需要理解这些..

    万次阅读 多人点赞 2016-12-18 21:53:51
    这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。【翻译于 官方文档】 本篇将从以下几个方面讲述反射的知识: calss的使用 方法的反射 构造函数的反射 成员变量的反射 一、什么是class类在...
  • Java的反射特征一般结合注解和配置文件(如:XML)来使用,这也是大部分的框架(Spring等)支持两种配置方式的原因。 如果是注解方式:当服务端启动时,Spring框架会去扫描指定目录下的类,通过反射看类有没有Service...
  • java的反射机制

    千次阅读 2014-04-03 17:19:36
    一、反射的概念 :
  • Java的反射机制---面试

    千次阅读 多人点赞 2018-10-09 18:02:05
    反射的原理是什么 ...它出发点就在于JVM会为每个类创建一个java.lang.Class类实例,通过该对象可以获取这个类信息,然后通过使用java.lang.reflect包下API以达到各种动态需求。 Class类含义和作用是...
  • 运行时进行编程,类似Java的反射。运行时编程和Java反射的对比如下:1.相同点 都可以实现的功能:获取类信息、属性设置获取、类的动态加载(NSClassFromString(@“className”))、方法的动态调用 下面是iOS中涉及...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 62,158
精华内容 24,863
关键字:

java的反射

java 订阅