简单的来说，反射机制指的是程序在运行时能够获取自身的信息。在java中，只要给定类的名字，那么就可以通过反射机制来获得类的所有信息.
反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中它的灵活性就表现的十分明显。
加载，链接，初始化3个操作对类进行初始化。
类字面常量”,class”创建Class对象的引用时，不会自动地初始化该Class对象，准备工作包含3个步骤:
1.加载:由类加载器执行，该步骤查找字节码,并从这些字节码中创建一个Class对象
2.链接:在链接阶段将验证类中的字节码，为静态域分配存储空间，并且如果必需的话，将解析这个类创建的对其他类的所有引用。
3.初始化:如果该类有超类，则对其初始化，执行静态初始化器和静态初始化块
类的初始化时机
1.创建类的实例
2.访问类或接口的静态变量（static final常量除外，static final变量可以）
3.调用类的静态方法
4.反射（Class.forName(packageName.className)）
5.初始化类的子类（子类初始化问题：满足主动调用，即访问子类中的静态变量、方法，否则仅父类初始化）
6.java虚拟机启动时被标明为启动类的类
注：加载顺序：启动类的static block最先加载
(父类静态成员、静态代码块—>子类静态成员、静态代码块—>父类实例成员、代码块——>父类构造函数—>子类实例成员、代码块—>子类构造函数)
我们需要明白在JAVA中任何class都要装载在虚拟机上才能运行，而forClass就是装载类用的，这是要和new不一样，要分清楚哦。
A a = (A)Class.forName(“package.A”).newInstance();和 A a = new A;是等价的。
记住一个概念，静态代码是和class绑定的,class装载成功就表示执行了你的静态代码，而且以后不会再走这套静态代码了。
Class.forName(xxx.xx.xx)的作用是要求JVM查找并加载指定的类，也即是说JVM会执行该类的静态代码段。
JAVA中获取Class对象有3种方式:
1.Class.forName()
2.Object.getClass()
3.类字面常量 xx.class
代码例子：
package Reflect;
class Demo{
//other codes...
}
class hello{
public static void main(String[] args) {
Class<?> demo1=null;
Class<?> demo2=null;
Class<?> demo3=null;
try{
//一般尽量采用这种形式
demo1=Class.forName("Reflect.Demo");
}catch(Exception e){
e.printStackTrace();
}
demo2=new Demo().getClass();
demo3=Demo.class;
System.out.println("类名称 "+demo1.getName());//Reflect.Demo
System.out.println("类名称 "+demo2.getName());//Reflect.Demo
System.out.println("类名称 "+demo3.getName());//Reflect.Demo
}
}
从Class中获取信息(可以查看Class的API文档了解)：
获取类的构造器
首先介绍一下Constructor类，这个类用来封装反射得到的构造器，Class有四个方法来获得Constructor对象
public Constructor<?>[] getConstructors() 返回类中所有的public构造器集合，默认构造器的下标为0
public Constructor<T> getConstructor(Class<?>... parameterTypes) 返回指定public构造器，参数为构造器参数类型集合
public Constructor<?>[] getDeclaredConstructors() 返回类中所有的构造器，包括私有
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 返回任意指定的构造器获取类的成员变量
成员变量用Field类进行封装，主要的方法非常的类似：
public Field getDeclaredField(String name) 获取任意指定名字的成员
public Field[] getDeclaredFields() 获取所有的成员变量
public Field getField(String name) 获取任意public成员变量
public Field[] getFields() 获取所有的public成员变量获取类的方法
public Method[] getMethods() 获取所有的共有方法的集合
public Method getMethod(String name,Class<?>... parameterTypes) 获取指定公有方法 参数1：方法名 参数2：参数类型集合
public Method[] getDeclaredMethods() 获取所有的方法
public Method getDeclaredMethod(String name,Class<?>... parameterTypes) 获取任意指定方法常用的就这些，知道这些，其他的都好办……
获取基本信息的例子:
import java.lang.reflect.*;
import java.lang.annotation.*;
//使用2个注释修饰该类
@SuppressWarnings(value="unchecked")
@Deprecated
public class ClassTest
{
//为该类定义一个私有的构造器
private ClassTest(){
}
//定义一个有参数的构造器
public ClassTest(String name){
System.out.println("执行有参数的构造器");
}
//定义一个无参数的info方法
public void info(){
System.out.println("执行无参数的info方法");
}
//定义一个有参数的info方法
public void info(String str){
System.out.println("执行有参数的info方法"
+ "，其实str参数值：" + str);
}
//定义一个测试用的内部类
class Inner{
}
public static void main(String[] args) throws Exception{
//下面代码可以获取ClassTest对应的Class
Class<ClassTest> clazz = ClassTest.class;
//获取该Class对象所对应类的全部构造器
Constructor[] ctors = clazz.getDeclaredConstructors();
System.out.println("ClassTest的全部构造器如下：");
for (Constructor c : ctors)
{
System.out.println(c);
//private ClassTest()
//public ClassTest(java.lang.String)
}
//获取该Class对象所对应类的全部public构造器
Constructor[] publicCtors = clazz.getConstructors();
System.out.println("ClassTest的全部public构造器如下：");
for (Constructor c : publicCtors)
{
System.out.println(c);
//public ClassTest(java.lang.String)
}
//获取该Class对象所对应类的全部public方法
Method[] mtds = clazz.getMethods();
System.out.println("ClassTest的全部public方法如下：");
for (Method md : mtds)
{
System.out.println(md);
//public static void ClassTest.main(java.lang.String[]) throws java.lang.Exception
//public void ClassTest.info()
//public void ClassTest.info(java.lang.String)
//public final void java.lang.Object.wait() throws java.lang.InterruptedException
//public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
//public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
//public native int java.lang.Object.hashCode()
//public final native java.lang.Class java.lang.Object.getClass()
//public boolean java.lang.Object.equals(java.lang.Object)
//public java.lang.String java.lang.Object.toString()
//public final native void java.lang.Object.notify()
//public final native void java.lang.Object.notifyAll()
}
//获取该Class对象所对应类的指定方法
System.out.println("ClassTest里带一个字符串参数的info方法为："
+ clazz.getMethod("info" , String.class));
//public void ClassTest.info(java.lang.String)
//获取该Class对象所对应类的上的全部注释
Annotation[] anns = clazz.getAnnotations();
System.out.println("ClassTest的全部Annotattion如下：");
for (Annotation an : anns)
{
System.out.println(an);
}
System.out.println("该Class元素上的@SuppressWarnings注释为："
+ clazz.getAnnotation(SuppressWarnings.class));
//获取该Class对象所对应类的全部内部类
Class<?>[] inners = clazz.getDeclaredClasses();
System.out.println("ClassTest的全部内部类如下：");
for (Class c : inners)
{
System.out.println(c);
//class ClassTest$Inner
}
//使用Class.forName方法加载ClassTest的Inner内部类
Class inClazz = Class.forName("ClassTest$Inner");
//通过getDeclaringClass()访问该类所在的外部类
System.out.println("inClazz对应类的外部类为：" + inClazz.getDeclaringClass());
//class ClassTest
System.out.println("ClassTest的包为：" + clazz.getPackage());
//null
System.out.println("ClassTest的父类为：" + clazz.getSuperclass());
//class java.lang.Object
}
}
通过Class调用其他类中的构造函数 （也可以通过这种方式通过Class创建其他类的对象）
package Reflect;
import java.lang.reflect.Constructor;
class Person{
public Person() {
}
public Person(String name){
this.name=name;
}
public Person(int age){
this.age=age;
}
public Person(String name, int age) {
this.age=age;
this.name=name;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString(){
return "["+this.name+" "+this.age+"]";
}
private String name;
private int age;
}
class hello{
public static void main(String[] args) {
Class<?> demo=null;
try{
demo=Class.forName("Reflect.Person");
}catch (Exception e) {
e.printStackTrace();
}
Person per1=null;
Person per2=null;
Person per3=null;
Person per4=null;
//取得全部的构造函数
Constructor<?> cons[]=demo.getConstructors();
try{
per1=(Person)cons[0].newInstance();
per2=(Person)cons[1].newInstance("Rollen");
per3=(Person)cons[2].newInstance(20);
per4=(Person)cons[3].newInstance("Rollen",20);
}catch(Exception e){
e.printStackTrace();
}
System.out.println(per1);//[null 0]
System.out.println(per2);//[Rollen 0]
System.out.println(per3);//[null 20]
System.out.println(per4);//[Rollen 20]
}
}
综合例子:
package Reflect;
interface China{
public static final String name="Rollen";
public static int age=20;
public void sayChina();
public void sayHello(String name, int age);
}
class Person implements China{
public Person() {
}
public Person(String sex){
this.sex=sex;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public void sayChina(){
System.out.println("hello ,china");
}
@Override
public void sayHello(String name, int age){
System.out.println(name+" "+age);
}
private String sex;
}
class hello{
public static void main(String[] args) {
Class<?> demo=null;
try{
demo=Class.forName("Reflect.Person");
}catch (Exception e) {
e.printStackTrace();
}
//保存所有的接口
Class<?> intes[]=demo.getInterfaces();
for (int i = 0; i < intes.length; i++) {
System.out.println("实现的接口 "+intes[i].getName());
// Reflect.China
}
//获得其他类中的全部构造函数
Constructor<?>cons[]=demo.getConstructors();
for (int i = 0; i < cons.length; i++) {
System.out.println("构造方法： "+cons[i]);
//public Reflect.Person()
/public Reflect.Person(java.lang.String)
}
for (int i = 0; i < cons.length; i++) {
Class<?> p[]=cons[i].getParameterTypes();
System.out.print("构造方法： ");
int mo=cons[i].getModifiers();
System.out.print(Modifier.toString(mo)+" ");
System.out.print(cons[i].getName());
System.out.print("(");
for(int j=0;j<p.length;++j){
System.out.print(p[j].getName()+" arg"+i);
if(j<p.length-1){
System.out.print(",");
}
}
System.out.println("){}");
}
//构造方法： public Reflect.Person(){}
//构造方法： public Reflect.Person(java.lang.String arg1){}
//通过反射调用其他类中的方法
try{
//调用Person类中的sayChina方法
Method method=demo.getMethod("sayChina");
method.invoke(demo.newInstance());//hello ,china
//调用Person的sayHello方法
method=demo.getMethod("sayHello", String.class,int.class);
method.invoke(demo.newInstance(),"Rollen",20);//Rollen 20
}catch (Exception e) {
e.printStackTrace();
}
System.out.println("===============本类属性========================");
// 取得本类的全部属性
Field[] field = demo.getDeclaredFields();
for (int i = 0; i < field.length; i++) {
// 权限修饰符
int mo = field[i].getModifiers();
String priv = Modifier.toString(mo);
// 属性类型
Class<?> type = field[i].getType();
System.out.println(priv + " " + type.getName() + " "
+ field[i].getName() + ";");
//private java.lang.String sex;
}
System.out.println("===============实现的接口或者父类的属性========================");
// 取得实现的接口或者父类的属性
Field[] filed1 = demo.getFields();
for (int j = 0; j < filed1.length; j++) {
// 权限修饰符
int mo = filed1[j].getModifiers();
String priv = Modifier.toString(mo);
// 属性类型
Class<?> type = filed1[j].getType();
System.out.println(priv + " " + type.getName() + " "
+ filed1[j].getName() + ";");
}
//public static final java.lang.String name;
//public static final int age;
Object obj = null;
try{
obj=demo.newInstance();
}catch (Exception e) {
e.printStackTrace();
}
//通过反射操作属性
Field field = demo.getDeclaredField("sex");
field.setAccessible(true);
field.set(obj, "男");
//通过反射取得并修改数组的信息：
int[] temp={1,2,3,4,5};
Class<?>demo=temp.getClass().getComponentType();
System.out.println("数组类型： "+demo.getName());// int
System.out.println("数组长度 "+Array.getLength(temp));//5
System.out.println("数组的第一个元素: "+Array.get(temp, 0));//1
Array.set(temp, 0, 100);
System.out.println("修改之后数组第一个元素为： "+Array.get(temp, 0));//100
}
}
将反射用于工厂模式(结合属性文件的工厂模式):
首先创建一个fruit.properties的资源文件，内容为：
apple=Reflect.Apple
orange=Reflect.Orange
主类代码:
package Reflect;
import java.io.*;
import java.util.*;
interface fruit{
public abstract void eat();
}
class Apple implements fruit{
public void eat(){
System.out.println("Apple");
}
}
class Orange implements fruit{
public void eat(){
System.out.println("Orange");
}
}
//操作属性文件类
class init{
public static Properties getPro() throws FileNotFoundException, IOException{
Properties pro=new Properties();
File f=new File("fruit.properties");
if(f.exists()){
pro.load(new FileInputStream(f));
}else{
pro.setProperty("apple", "Reflect.Apple");
pro.setProperty("orange", "Reflect.Orange");
pro.store(new FileOutputStream(f), "FRUIT CLASS");
}
return pro;
}
}
class Factory{
public static fruit getInstance(String ClassName){
fruit f=null;
try{
f=(fruit)Class.forName(ClassName).newInstance();
}catch (Exception e) {
e.printStackTrace();
}
return f;
}
}
class hello{
public static void main(String[] a) throws FileNotFoundException, IOException{
Properties pro=init.getPro();
fruit f=Factory.getInstance(pro.getProperty("apple"));
if(f!=null){
f.eat();//Apple
}
}
}
下面是通过反射获取属性名和相应值得列子：
1.获取属性名称：
Field[] fields =obj.getClass().getDeclaredFields();
ProjectBasicInfoDao dao = new ProjectBasicInfoDao();
int xmid = Integer.valueOf(request.getParameter("xmid"));
ProjectBasicInfo basicInfo = dao.getProjectBasicInfoByXmid(xmid);
Field[] fields = basicInfo.getClass().getDeclaredFields();//获取属性名称数组
JSONObject jObject = new JSONObject();
for (int i = 0; i < fields.length; i++) {
String name = fields[i].getName();
String value ="";
Object valueObj = getFieldValue(basicInfo ,fields[i].getName());//获取属性值
if (valueObj != null) {
value = valueObj.toString();
}
jObject.put(name,value);
}
JSONObject jObject2 = new JSONObject();
JSONArray jArray = new JSONArray();
jArray.put(jObject);
jObject2.put("data", jArray);
Dao获取对象：
public ProjectBasicInfo getProjectBasicInfoByXmid(int xmid) {
Session s = null;
ProjectBasicInfo projectBasicInfo = null;
try {
s = HibernateUtil.getSession();
s.beginTransaction();
Query query = s.createQuery("from ProjectBasicInfo where xmid = :xmid");
query.setInteger("xmid", xmid);
projectBasicInfo = (ProjectBasicInfo) query.uniqueResult();
} catch (Throwable e) {
logger.error(e.toString());
HibernateUtil.endSession(s);
} finally {
HibernateUtil.endSession(s);
}
return projectBasicInfo;
}
2.通过属性名称获取属性值：
(1).通过属性名创建getMethod
(2).用getMethod.invoke(obj)获取属性值
/**
* 通过反射，用属性名称获得属性值
* @param thisClass 需要获取属性值的类
* @param fieldName 该类的属性名称
* @return
*/
private Object getFieldValue(Object thisClass, String fieldName)
{
Object value = new Object();
Method method = null;
try {
String methodName = fieldName.substring(0, 1).toUpperCase()+ fieldName.substring(1);
method = thisClass.getClass().getMethod("get"+ methodName);
value = method.invoke(thisClass);
} catch (Exception e) {
e.printStackTrace();
}
return value;
} java的bean对象转map:
public static Map getValue11(Object thisObj) {
Map map = new HashMap();
Class c;
try {
c = Class.forName(thisObj.getClass().getName());
List<Field> fields = ReflectionUtils.getFields(c);
for (Field field : fields) {
String fieldName = field.getName();
System.out.print("fieldName---"+fieldName+"\n");
String methodName = fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
Method method = thisObj.getClass().getMethod("get" + methodName);
Object value = method.invoke(thisObj);
map.put(fieldName, value);
}
} catch (Exception e) {
System.out.println("error:" + e.getMessage());
}
return map;
}
Map<String, Object> userMap = getValue11(userInfo);
for (Entry<String, Object> entry: userMap.entrySet()) {
System.out.print("key2222----"+entry.getKey()+","+entry.getValue()+"\n");
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
