在看spring的时候发现很多都是通过反射实现的,所以也看了看java关于反射的部分,总结如下,方便以后查找
Arithmetic.java
ReflectConstructor.java
ReflectMethod.java
ReflectFiled.java
附件为工程文件
参考http://www.ibm.com/developerworks/cn/java/j-dyn0603/
Arithmetic.java
/**
* Class Arithmetic
* 反射目标类
* 水平有限,所以此类纯是为了测试而写,无任何逻辑而言
* @author lgsun
* Date: 2011-3-27
*/
package com.lgsun.target;
@SuppressWarnings("all")
public class Arithmetic
{
private int parmaerOne;
private int parmaerTwo;
public int sum;
private Arithmetic()
{
this.parmaerOne = -1;
this.parmaerTwo = -2;
}
public Arithmetic(int parmaerOne, int parmaerTwo)
{
this.parmaerOne = parmaerOne;
this.parmaerTwo = parmaerTwo;
}
public int getParmaerOne()
{
return parmaerOne;
}
public void setParmaerOne(int parmaerOne)
{
this.parmaerOne = parmaerOne;
}
public int getParmaerTwo()
{
return parmaerTwo;
}
public void setParmaerTwo(int parmaerTwo)
{
this.parmaerTwo = parmaerTwo;
}
public int getSum()
{
sum = sum(parmaerOne, parmaerTwo);
return this.sum;
}
public double getDivision()
{
return (parmaerOne / parmaerTwo);
}
private int sum(int p1, int p2)
{
return (p1 + p2);
}
public void getInfo()
{
System.out.println();
System.out.println("parmaerOne=" + parmaerOne);
System.out.println("parmaerTwo=" + parmaerTwo);
System.out.println("sum=" + sum);
}
}
ReflectConstructor.java
/**
* Class ReflectConstructor
* Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数,
* Constructor[] getConstructors() -- 获得类的所有公共构造函数
* Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)
* Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)
* 前2个可以返回继承自父类的构造方法;后2个只能返回当前类定义的,并且包含私有方法
* @author lgsun
* Date: 2011-3-27
*/
package com.lgsun.test;
import java.lang.reflect.Constructor;
import com.lgsun.target.Arithmetic;
public class ReflectConstructor
{
@SuppressWarnings("all")
public static void main(String[] args)
{
try
{
// 返回Arithmetic类全部的构造方法,包含私有构造方法
Constructor[] con = Class.forName("com.lgsun.target.Arithmetic").getDeclaredConstructors();
for (int i = 0; i < con.length; i++)
{
System.out.println(con[i].toGenericString());
}
// 通过Arithmetic(int p1,int p2)构造方法创建实例
Class[] type = new Class[] { int.class, int.class };
Constructor pCon1 = Class.forName("com.lgsun.target.Arithmetic").getDeclaredConstructor(type);
Arithmetic arit1 = (Arithmetic) pCon1.newInstance(3, 4);
arit1.getInfo();
// 通过Arithmetic()构造方法创建实例
Constructor pCon2 = Class.forName("com.lgsun.target.Arithmetic").getDeclaredConstructor();
// 由于此构造方法是私有的,所以必须设置Accessible为true
pCon2.setAccessible(true);
Arithmetic arit2 = (Arithmetic) pCon2.newInstance();
arit2.getInfo();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
ReflectMethod.java
/**
* Class ReflectMethod
* Method getMethod(String name, Class[] params) -- 使用特定的参数类型,获得命名的公共方法
* Method[] getMethods() -- 获得类的所有公共方法
* Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型,获得类声明的命名的方法
* Method[] getDeclaredMethods() -- 获得类声明的所有方法
* 前2个方法会返回所有的属性,包括父类属性;后2个只会返回此类中定义的属性,包含私有属性
* @author lgsun
* Date: 2011-3-28
*/
package com.lgsun.test;
import java.lang.reflect.Method;
import com.lgsun.target.Arithmetic;
@SuppressWarnings("all")
public class ReflectMethod
{
public static void main(String[] args)
{
Arithmetic arithmetic = new Arithmetic(7, 8);
Method[] methods = arithmetic.getClass().getDeclaredMethods();
for (int i = 0; i < methods.length; i++)
{
System.out.println(methods[i].toGenericString());
}
try
{
Class[] types = new Class[] { int.class, int.class };
Method method1 = arithmetic.getClass().getDeclaredMethod("sum", types);
method1.setAccessible(true);
// 这样写是错误的
// int[] parms=new int[]{17,18};
Object[] parms = new Object[] { 17, 18 };
Object result = method1.invoke(arithmetic, parms);
System.out.println(((Integer) result).intValue());
arithmetic.getInfo();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
ReflectFiled.java
/**
* Class ReflectFiled
* Field getField(String name) -- 获得命名的公共字段
* Field[] getFields() -- 获得类的所有公共字段
* Field getDeclaredField(String name) -- 获得类声明的命名的字段
* Field[] getDeclaredFields() -- 获得类声明的所有字段
* 同样,前2个方法会返回所有的属性,包括父类属性;后2个只会返回此类中定义的属性,包含私有属性
* @author lgsun
* Date: 2011-3-28
*/
package com.lgsun.test;
import java.lang.reflect.Field;
import com.lgsun.target.Arithmetic;
public class ReflectFiled
{
@SuppressWarnings("all")
public static void main(String[] args)
{
// 返回Arithmetic类全部属性,包含私有属性
Arithmetic arithmetic = new Arithmetic(4, 5);
Field[] fields = arithmetic.getClass().getDeclaredFields();
for (int i = 0; i < fields.length; i++)
{
System.out.println(fields[i].toGenericString());
}
try
{
// 直接给public属性sum赋值
Field field1 = arithmetic.getClass().getDeclaredField("sum");
field1.set(arithmetic, 19);
arithmetic.getInfo();
// 给private属性parmaerOne赋值
Field field2 = arithmetic.getClass().getDeclaredField("parmaerOne");
// 必加
field2.setAccessible(true);
field2.set(arithmetic, 14);
arithmetic.getInfo();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
附件为工程文件
参考http://www.ibm.com/developerworks/cn/java/j-dyn0603/