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反射机制的威力, 其实更可怕的是反射不仅仅用于编译程序时可以使用的类, 更多的是在程序运行的时候动态地分析类的结构并创建实例, 再通过代理机制与之配合,  (这也就是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类的所有公有成员
 
怎么样,就问你可怕不可怕??? 
 
有人会说: 这样也只是能看到结构而已, 又有什么用呢,所以上面说了, 搭配代理使用更可怕!

反射(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.'可以被实现化';

 
}

反射之前，我们知道在集合类中一旦指定了泛型的类型，则只能在该集合中用该类型。但是我们可以利用反射机制来越过泛型检查。比如说利用反射机制获取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 + "]";
}

}