精华内容
下载资源
问答
  • 儿童神经系统检查和反射检查.doc
  • 通过条纹反射检查光学表面缺陷
  • Java反射检查/使用类

    千次阅读 2011-10-10 15:46:02
    1:反射检查/使用类 try{  // 检查是否有 Camera 类  Class.forName("android.hardware.Camera"); // 检查是否有 CameraInfo 内部类 Class.forName("and

    1:反射检查/使用类

    try{

          // 检查是否有 Camera
          Class.forName("android.hardware.Camera");

    // 检查是否有 CameraInfo 内部类
    Class.forName("android.hardware.Camera$CameraInfo");

          // 反射使用类 

    android.hardware.Camera.CameraInfo cameraInfo = new android.hardware.Camera.CameraInfo();
    int numberOfCameras = android.hardware.Camera.getNumberOfCameras();

    for(int i = 0; i < numberOfCameras; i++){
    android.hardware.Camera.getCameraInfo(i,cameraInfo);
    if(cameraInfo.facing == android.hardware.Camera.CameraInfo.CAMERA_FACING_FRONT){
    haveFrontCamera = i;
    }
    }


         // 反射使用类 

                   Method method = null;

         method = Class.forName("android.hardware.Camera").getDeclaredMethod("open", int.class,int.class);

         Camera camer =  (Camera)method.invoke(method,2,1);

    } catch(ClassNotFoundException  e){

    }

    catch(Exception ex){
    ex.printStackTrace();

    }


    展开全文
  • 先上运行效果: 输入我们想分析检查的类(全类名, 带包名), 以java.lang.Double为例 可以看到Double类的结构一览无余,无论公有私有 是否为final和static, 即使native的本地方法都被我们的火眼金睛发现了, 这就是...

    先上运行效果:  输入我们想分析检查的类(全类名, 带包名), 以java.lang.Double为例

    可以看到Double类的结构一览无余,无论公有私有 是否为final和static, 即使native的本地方法都被我们的火眼金睛发现了, 这就是java反射机制的威力, 其实更可怕的是反射不仅仅用于编译程序时可以使用的类, 更多的是在程序运行的时候动态地分析类的结构并创建实例, 再通过代理机制与之配合,  (这也就是java框架的核心机制) 所以java.lang.reflect包是开发人员的利器啊!

     

    看到效果了, 那我们的反射到底怎么用呢? java.lang.reflect包又有啥工具呢?

     

    java.lang.reflect包中有三个类Field, Method, Contructor分别用于描述类的域, 方法和构造器

    Field类中有一个getType方法,用来返回描述域所属类型的Class对象

    Method 和 Contructor 类有能够报告参数类型的方法,Method类还有一个可以报告返回类型的方法

    三个类都有一个叫做getModifiers的方法, 它将返回一个整形数值, 用不同的位开关描述public和static 这样的描述符的使用情况

    另外,还可以利用java.lang.reflect包中的Modifier类的静态方法分析getModifiers()返回的整形数值。

    例如,可以使用Modifier类中的isPublic 、isPrivate 、或isFinal判断方法或者构造器是否是public、private或者final。

    我们需要做的全部工作就是调用Modifier类中的相应方法,并对返回的整型数值进行分析,另外,还可以利用Modifier.toString 方法 将修饰符打印出来。

    Class类中的getFields,getMethods和getContructors 方法将分别返回类提供的public域,方法,和构造器数组,其中包括超类公有成员

    Class类的getDeclareFields、getDeclareMethods和getDeclareContructors 方法将分别返回类中声明的全部域、方法和构造器,其中包括私有的和受保护的成员,但不包括超类的成员

     

    我们的demo源码:

    package test;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.lang.reflect.Modifier;
    import java.util.Scanner;
    
    public class ReflectionTest {
    
    	public static void main(String[] args) {
    		String name;
    		if(args.length>0) name=args[0];
    		else {
    			Scanner in=new Scanner(System.in);
    			System.out.println("Enter class name (e.g. java.util.Date):");
    			name=in.next();
    			
    		}
    		try {
    			Class cl=Class.forName(name);
    			Class supercl=cl.getSuperclass();
    			String modifiers=Modifier.toString(cl.getModifiers());
    			if(modifiers.length()>0)System.out.print(modifiers+"");
    			System.out.print("class "+name);
    			if(supercl!=null&&supercl!=Object.class)System.out.print(" extends"+supercl.getName());
    			System.out.println("\n{\n");
    			printConstructors(cl);
    			System.out.println();
    			printMethods(cl);
    			System.out.println();
    			printFields(cl);
    			System.out.println("}");
    		}
    		catch(ClassNotFoundException e){
    			e.printStackTrace();
    		}
    		System.exit(0);
    	}
    
    	
    	
    	
    	public static void printConstructors(Class cl){
    		Constructor[] constructors=cl.getDeclaredConstructors();
    		//Declared
    		for(Constructor c:constructors)
    		{
    			String name=c.getName();
    			System.out.print("	");
    			String modifiers=Modifier.toString(c.getModifiers());
    			if(modifiers.length()>0)
    				System.out.print(modifiers+" ");
    			System.out.print(name+"(");
    			Class[] paramTypes=c.getParameterTypes();
    			for(int j=0;j<paramTypes.length;j++)
    			{
    				if(j>0)
    					System.out.print(",");
    				System.out.print(paramTypes[j].getName());
    			}	
    			System.out.println(");");
    		}
    		
    	}
    	
    	public static void printMethods(Class cl) 
    	{
    		//Method[] methods= cl.getMethods();
    		Method[] methods= cl.getDeclaredMethods();
    		for(Method m:methods)
    		{
    			Class retType= m.getReturnType();
    			String name=m.getName();
    			System.out.print("	");
    			String modifiers=Modifier.toString(m.getModifiers());
    			if(modifiers.length()>0)	
    				System.out.print(modifiers +" ");
    			System.out.print(retType.getName()+" "+name+"(");
    			Class[] paramTypes=m.getParameterTypes();
    			for(int j = 0;j<paramTypes.length;j++)
    			{
    				if(j>0)
    					System.out.print(", ");
    				System.out.print(paramTypes[j].getName());
    			}
    			System.out.println(");");
    		}
    	}
    	public static void printFields(Class cl) {
    		Field[] fields=cl.getDeclaredFields();
    		for(Field f:fields)
    		{
    			Class type=f.getType();
    			String name=f.getName();
    			System.out.print("	");
    			String modifiers=Modifier.toString(f.getModifiers());
    			if(modifiers.length()>0)
    				System.out.print(modifiers+" ");
    			System.out.println(type.getName()+" "+name+";");
    		}
    	}
    
    }

    上面的demo用的是getDeclareFields、getDeclareMethods和getDeclareContructors方法, 包含本类的私有和受保护成员, 但不包括其父类成员, 我们把上述demo的 对应方法全换成getFields,getMethods和getContructors看看效果:

     

    因为Double的成员太多了, 带上父类成员就更多了, 为了清晰,我又写了一个父类和子类做例子:

    父类是这样式儿的:

    package test;
    
    public class Father 
    {
    	public int father_public_field;
    	int father_default_field;
    	
    	public Father() {
    		
    	}
    	
    	public void father_public_method() {
    		
    	}
    	private void father_private_method() {
    			
    	}
    }
    

     子类是这样式儿的:

    package test;
    
    public class Son extends Father 
    {
    	public int son_public_field;
    	int son_default_field;
    	
    }
    

    简单吧, 注意两个类的修饰符, 我们把上面的demo对应方法换成getFields,getMethods和getContructors:

    可以看到只返回了公有成员, 连Son的默认成员都没有,更别说私有的了

    同样需要注意的是 ,返回的不止有Father类和Son类的成员, 还有Object类的成员(wait(),notify().......), 也就是说上述的"父类"不单单指直接父亲, 而是家族树向上一直到Object类(JAVA所有类的祖宗!), Father没有显式继承所以Father默认继承了Object, 否则返回的包含Son, Father, Fahter的父类, Fahter的父类的父类.....Object类的所有公有成员

    怎么样,就问你可怕不可怕??? 

    有人会说: 这样也只是能看到结构而已, 又有什么用呢,所以上面说了, 搭配代理使用更可怕!

    展开全文
  • php反射 检查

    2013-03-07 21:24:19
    反射(reflection) 提供了很多类,可以在运行时访问对象、函数和脚本中的扩展信息。 由于反射API非常强大,应该尽量使用反射API,而少用类和对象函数。  ReflectionClass提供提示给定类所有信息的方法,无论这...
    反射(reflection)  提供了很多类,可以在运行时访问对象、函数和脚本中的扩展信息。
    
    由于反射API非常强大,应该尽量使用反射API,而少用类和对象函数。 

    ReflectionClass提供提示给定类所有信息的方法,无论这个类是用户定义的还是PHP自带的内置类。 ReflectionClass的构造方法接受类名作为它的唯一参数  (简单地说,这个这个类,可以输出某个类,包括内置类和用户自定义的类的全部信息,包括属性和方法 )  , 如
    $m=new ReflectionClass('Memcache');
    Reflection::export($m);   // export 是个静态方法
    注意是  Reflection类的静态方法,而不是 ReflectionClass的 

    var_dump()和它的姐妹函数print_r()  是检查PHP代码中数据据的利器,但对于类和函数,反射API提供了更高层次的功能。

    2、查询类:
    ReflectionClass::getName()  返回要检查的类名
    ReflectionClass::isuserDefined()  检查这个类是否是用户定义的类,是返回true,否则返回false
    ReflectionClass::isInternal()  检查这个类是否是内置的。与上面相反
    ReflectionClass::isFinal()     检查这个类是否可以被继承
    ReflectionClass::isAbstract()   检查这个类是否是抽象类
    ReflectionClass::isInterface()  检查某个类是否是接口
    ReflectionClass::isInstantiable()  测试某个类是否可产生实例

    ReflectionClass::getMethods()  获取对象的所有方法,以数组的形式返回
    ReflectionClass::getFileName()   获取类所在的文件,包括绝对路径
    ReflectionClass::getStartLine()  获取类的开始行
    ReflectionClass::getEndLine()    获取类的结束行


    例1: 
    <?php
    echo '<pre>';
    $r=new ReflectionClass('Memcache');
    Reflection::export($r);
    echo '<hr/>';
    $methods=$r->getMethods();
    print_r($methods);
    echo '<hr/>';

    $className=$r->getName();
    if($r->isUserDefined()){
            echo $className.'是用户定义的类';
    }
    if($r->isInternal()){
            echo $className.'是内置类';
    }
    if($r->isFinal()){
            echo $className.'是最终类,不被有子类';
    }
    if($r->isAbstract()){
            echo $className.'是抽象类';
    }
    if($r->isInterface()){
            echo $className.'是接口';
    }
    if($r->isInstantiable()){
            echo $className.'可以被实现化';
    }
    展开全文
  • java 反射之越过泛型检查

    千次阅读 2016-08-05 16:33:35
    比如说利用反射机制获取ArrayList中的add()方法,再调用add方法时,就会越过泛型检查,只是由于泛型检查是在编译时期进行的,也就是说编译后的add()方法其实和没有指定泛型的add()方法是一致的,都是不能进行泛型...

    反射之前,我们知道在集合类中一旦指定了泛型的类型,则只能在该集合中用该类型。但是我们可以利用反射机制来越过泛型检查。比如说利用反射机制获取ArrayList中的add()方法,再调用add方法时,就会越过泛型检查,只是由于泛型检查是在编译时期进行的,也就是说编译后的add()方法其实和没有指定泛型的add()方法是一致的,都是不能进行泛型检查的。所以通过反射获取ArrayList的Class文件对象中的add()方法,在调用该add()方法时是不用泛型检查的。如下所示:

    测试主类

    package cn.edu.tju.versace;
    
    import java.lang.reflect.Method;
    import java.util.ArrayList;
    
    import cn.edu.tju.reflect.Student;
    
    /**
     * 反射越过泛型检查
     * @author feige
     */
    public class ReflectDemo {
    
        public static void main(String[] args) throws Exception {
         ArrayList<Integer> arrayList=new ArrayList<Integer>();//指定泛型为Integer
         Class c=arrayList.getClass();//获取Class文件对象
         Method addMethod=c.getDeclaredMethod("add",Object.class);//获取Class文件对象中的add()方法
         Student  s=new Student("arui",25);
         addMethod.invoke(arrayList, "afei");//越过泛型检查,添加String类型
         addMethod.invoke(arrayList, s);//越过泛型检查,添加Student类型
         System.out.println(arrayList);//结果为:[afei, Student [name=arui, age=25]]
        }
    
    }
    Student类:

    package cn.edu.tju.reflect;
    
    public class Student {
     private String name;
     public int age;
     
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    
    private Student() {
        super();
    }
    
    private void showName(String name) {
        this.name=name;
        System.out.println("name is:"+name);
    }
    
    public int showAge() {
        return age;
    }
    
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
    
    }
    

    展开全文
  • 反射检查类型是否实现某个接口

    千次阅读 2009-09-06 13:18:00
    public interface IBookRetailer : IDisposable { void Purchage(); void ApplyDiscount(); } public interface IMusicRetailer { void Purchase(); }
  • 使用反射检查 COM 对象

    千次阅读 2009-08-14 16:47:00
    对于生产使用,如果您编写的应用程序采用插件组件,并且用户将其组件放置在某个目录中或将其列在注册表中,而您的应用程序必须检查这些组件并找出它们所公开的类和方法,那么反射也非常有用。例如,Visual Studio ...
  • Java 反射调用方法 - 不跳过安全检查、跳过安全检查和普通方法性能比较测试 java中反射提供灵活性同时,给运行效率带来了一定影响。写个代码测试一下 package com.xzlf.reflectTest; import java.lang.reflect....
  • 使用反射机制绕过泛型检查类型

    千次阅读 2017-07-24 15:54:07
    //使用反射机制绕过泛型检查 Class c = list.getClass(); Method method = null; try { method = c.getDeclaredMethod("add", Object.class);//取得add方法 method.invoke(list, "hello"); } catch ...
  • 比如知道一个类的对象,我们知道方法的名称,但是只有在运行的时候才知道调用哪个方法,这样只能用反射的方式调用了,拿List举例 List list = new ArrayList(); 但是我们只有在实际运行的时候材质到时调用他的add...
  • Java反射 遍历判断值是否属于枚举类

    千次阅读 2020-08-19 23:37:02
    后来想了一下实在太麻烦了,加入枚举类改变的话业务代码的判断也需要改变比较麻烦,工具类也没找到相关的,于是自己通过反射写了一个循环遍历判断枚举类。 枚举类: public enum AuditState { TO_BE_AUDIT(0, ...
  • 利用反射越过泛型检查,我们知道泛型其实就是在编译的时候检查,其实在class文件中,并没有泛型的存在,所以我们可以利用泛型来跳过编译的检查 3.代码: java代码: import java.lang.reflect.Method; import
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    反射机制优缺点 反射机制的应用场景有哪些? Java获取反射的三种方法 网络编程 常用API String相关 字符型常量和字符串常量的区别 什么是字符串常量池? String 是最基本的数据类型吗 String有哪些特性 String为...
  • js反射获取对象属性

    2014-04-30 14:28:10
    [code="javascript"] 测试 function showObject(obj){ var arr=new Array(); for(i in obj){ if(typeof(obj[i])=='object') ... arr.push(i+'={'+showObject(...
  • Java的安全检查以及反射的性能问题

    千次阅读 2016-12-21 15:00:40
    在说反射的性能问题之前先简单了解下Java的安全性,Java语言是安全的,这是因为它在编译和加载时都会进行安全检查。每次都进行检查,就像我们每次做事前都要准备一下,这样势必会降低我们的执行效率,因此这也是Java...
  • 使用太赫兹时域反射光谱法检查人结肠腺癌细胞系
  • 轻量级工具,用于检查URL中的反射参数。 受的启发。 安装 go get -u github.com/KathanP19/Gxss 如果上述步骤不起作用,则可以尝试从此处预构建二进制文件 用法 _____ __ __ _____ _____ | __| | | __| __| | ...
  • java反射知识点

    2018-01-16 16:57:28
    7.通过反射越过泛型检查 8.其他一些文本笔记 读者需要补充的知识点我来说一下,补充: 1.反射数组应用 2.反射main方法 3.反射代理(设计模式) 4.反射数据库操作 5.反射框架 6.反射其他的 希望大家可以给我好评
  • 1.setAccessible 启用和禁用访问安全检查的开关,值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查,值为 false 则指示反射的对象不实施 Java 语言访问检查,并不是为 true 就能访问为 false 就不能...
  • JAVA反射机制详解视频

    2018-12-30 15:05:21
    (类的加载概述和加载时机) (类加载器的概述和分类) ...(通过反射越过泛型检查) (通过反射写一个通用的设置某个对象的某个属性为指定的值) (通过用户的增删改查和学生的登录注册引出中介) (动态代理的概述和实现)
  • 规定用户输入格式 模块名/函数名 通过__import__的形式导入模块,并通过 hasattr和getattr 检查并获取函数返回值。 相关方法: getattr:–根据字符串的形式去某个模块中寻找东西 hasattr:–根据字符串的形式去...
  • 什么是反射 大多数时候,Go中的变量,类型和函数非常简单直接。当需要一个类型、变量或者是函数时,...反射使您能够在运行时检查类型。它还允许您在运行时检查,修改和创建变量,函数和结构体。 Go中的反射是基于三个
  • 为什么 .NET 的反射这么慢?

    千次阅读 2016-12-26 21:34:11
    大家都知道.NET的反射很慢,但是为什么会出现这种情况呢?这篇文章会带你寻找这个问题的真正原因。 CLR 类型系统的设计目标 原因之一是,在设计的时候反射本身就不是以高性能为目标的,可以参考Type System ...
  • WinForms应用程序允许对反射中使用的进行反复试验检查。 项目中有两个类, Base和Dervied ,它们仅简单地行使可以使用的BindingFlags的各种组合。 要使用该应用程序,请运行该应用程序,选择是否要使用基类或派生...
  • JAVA反射之取消对访问控制检查

    千次阅读 2014-02-10 11:04:08
    package test; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; ... * AccessibleObject类是Field、Method、和...它提供了将反射的对象标
  • c反射机制介绍_介绍反射

    千次阅读 2020-06-30 05:33:58
    在“ Java编程动力学,第1部分 ”中,我向您介绍了... 为了使即使对于已经了解反射基础知识的开发人员来说,也使事情变得有趣,我将介绍反射性能与直接访问的比较。 不要错过本系列的其余部分 第1部分,“ 类和...
  • 反射越过泛型检查

    千次阅读 2015-11-25 12:59:43
    在博客 《泛型--前世今生》 中,我们了解到像如下: ...通过反射可以越过泛型检查,我理解的越过检查,实际上是越过了编译时期的检查。才疏学浅,如果理解不到位之处请高手指教。
  • 可以使用集合来定义数组,利用反射获取类中指定的方法, 而Method类中的invoke()允许调用包装在当前method对象中的方法 因此可以直接调用add方法添加字符串元素 invoke(Object obj, Object... args) 参数:obj ...
  • Java中通过反射越过泛型检查

    千次阅读 2016-11-21 19:31:40
    要想Java通过反射越过泛型检查,你就得先明白,泛型是在什么时候起作用的。 泛型是在编译期间起作用的。在编译后的.class文件中是没有泛型的。所有比如T或者E类型啊,本质都是通过Object处理的。 编译时是调用检查你...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 133,652
精华内容 53,460
关键字:

反射检查