RT  希望看了之后工友们能对反射方面的知识能有一定的掌握,能提高最好拉~~.
1.通过反射创建新类的新对象。

1. import java.lang.reflect.*;
   
2. /**
   
3. *通过反射创新类的新对象
   
4. */
   
5. class CreateNewObj
   
6. {
   
7. //显式默认的构造器
   
8. public CreateNewObj(){
   
9. }
   
10. //重载构造器
    
11. public CreateNewObj(int a,int b){
    
12. System.out.println("a= "+a+" b="+b);
    
13. }
    
14. 
    
15. public static void main(String[] args) throws Exception
    
16. {
    
17. //得到本类的类对象
    
18. Class c=Class.forName("CreateNewObj");
    
19. //声明构造器的参数类型集合
    
20. Class []paramTypes=new Class[2];
    
21. //都为int型
    
22. paramTypes[0]=Integer.TYPE;
    
23. paramTypes[1]=Integer.TYPE;
    
24. //根据参数类型决定得到哪个构造器
    
25. Constructor cs=c.getConstructor(paramTypes);
    
26. //声明要传入的参数集合
    
27. Object []argList=new Object[2];
    
28. //传入37和43
    
29. argList[0]=new Integer(37);
    
30. argList[1]=new Integer(43);
    
31. //根据符合上述参数类型的构造器来创建新的对象
    
32. Object rtnObj=cs.newInstance(argList);
    
33. }
    
34. }
    

复制代码

2.获取指定类的字段相关信息

1. import java.lang.reflect.*;
   
2. /**
   
3. *获取指定类的字段相关信息
   
4. */
   
5. class FieldTest
   
6. {
   
7. //字段1
   
8. private double d;
   
9. //字段2
   
10. public static final int i=37;
    
11. //字段3
    
12. String str="fieldstest";
    
13. public static void main(String[] args) throws Exception
    
14. {
    
15. //获取本类的类对象
    
16. Class c=Class.forName("FieldTest");
    
17. //获取所有声明的的字段,getFields()包括继承来的字段
    
18. Field []fs=c.getDeclaredFields();
    
19. //遍历
    
20. for(int i=0;i<fs.length;i++){
    
21. Field f=fs[i];
    
22. //字段名
    
23. System.out.println("字段名"+(i+1)+"="+f.getName());
    
24. //字段声明所在的类
    
25. System.out.println("该字段所在的类为："+f.getDeclaringClass());
    
26. //字段的类型
    
27. System.out.println("字段"+(i+1)+"的类型："+f.getType());
    
28. //查看修饰符
    
29. int mod=f.getModifiers();
    
30. //为0就是默认的包类型
    
31. if(mod==0){
    
32. System.out.println("该字段的修饰符为：默认包修饰符");
    
33. }else{
    
34. //否则就是相应的类型
    
35. System.out.println("该字段的修饰符为："+Modifier.toString(mod));
    
36. }
    
37. System.out.println("---结束第"+(i+1)+"循环---");
    
38. }
    
39. }
    
40. }
    

复制代码

3.获取指定类的方法相关信息

1. import java.lang.reflect.*;
   
2. /**
   
3. *获取指定类的方法相关信息
   
4. */
   
5. class InformationTest
   
6. {
   
7. public static void main(String[] args) throws Exception
   
8. {
   
9. //得到String类对象
   
10. Class cls=Class.forName("java.lang.String");
    
11. //得到所有的方法，包括从父类继承过来的方法
    
12. Method []methList=cls.getMethods();
    
13. //下面是得到的是String类本身声明的方法
    
14. //Method []methList=cls.getDeclaredMethods();
    
15. //遍历所有的方法
    
16. for(Method m:methList){
    
17. //方法名
    
18. System.out.println("方法名="+m.getName());
    
19. //方法声明所在的类
    
20. System.out.println("声明的类="+m.getDeclaringClass());
    
21. //获取所有参数类型的集体
    
22. Class []paramTypes=m.getParameterTypes();
    
23. //遍历参数类型
    
24. for(int i=0;i<paramTypes.length;i++){
    
25. System.out.println("参数 "+i+" = "+paramTypes[i]);
    
26. }
    
27. //获取所有异常的类型
    
28. Class []excepTypes=m.getExceptionTypes();
    
29. //遍历异常类型
    
30. for(int j=0;j<excepTypes.length;j++){
    
31. System.out.println("异常 "+j+" = "+excepTypes[j]);
    
32. }
    
33. //方法的返回类型
    
34. System.out.println("返回类型 ="+m.getReturnType());
    
35. //结束一层循环标志
    
36. System.out.println("---------");
    
37. }
    
38. }
    
39. }
    

复制代码

4.通过反射改变字段的值

1. import java.lang.reflect.*;
   
2. /**
   
3. *通过反射改变字段的值
   
4. */
   
5. class ModifyField
   
6. {
   
7. //声明一个字段
   
8. public double d;
   
9. public static void main(String[] args) throws Exception
   
10. {
    
11. //得到类的类对象
    
12. Class c=Class.forName("ModifyField");
    
13. //根据字段名得到字段对象
    
14. Field f=c.getField("d");
    
15. //创建类的实例
    
16. ModifyField mf=new ModifyField();
    
17. //打印修改前字段的值
    
18. System.out.println("修改 "+f.getName()+" 前的值为："+mf.d);
    
19. //修改d的值为12.34
    
20. f.setDouble(mf,12.34);
    
21. //打印修改后的值
    
22. System.out.println("修改 "+f.getName()+" 后的值为："+mf.d);
    
23. 
    
24. }
    
25. }
    

复制代码

5.通过反射执行类的方法

1. import java.lang.reflect.*;
   
2. /**
   
3. *通过反射执行类的方法
   
4. */
   
5. class PerformMethod
   
6. {
   
7. //声明一个简单的方法，用于测试
   
8. public int add(int a,int b){
   
9. return a+b;
   
10. }
    
11. public static void main(String[] args)throws Exception
    
12. {
    
13. //获取本类的类对象
    
14. Class c=Class.forName("PerformMethod");
    
15. /**
    
16. *声明add方法参数类型的集合
    
17. *共有两个参数，都为Integer.TYPE
    
18. */
    
19. Class []paramTypes=new Class[2];
    
20. paramTypes[0]=Integer.TYPE;
    
21. paramTypes[1]=Integer.TYPE;
    
22. //根据方法名和参数类型集合得到方法
    
23. Method method=c.getMethod("add",paramTypes);
    
24. //声明类的实例
    
25. PerformMethod pm=new PerformMethod();
    
26. //传入参数的集合
    
27. Object []argList=new Object[2];
    
28. //传入37和43
    
29. argList[0]=new Integer(37);
    
30. argList[1]=new Integer(43);
    
31. //执行后的返回值
    
32. Object returnObj=method.invoke(pm,argList);
    
33. //类型转换下
    
34. Integer returnVal=(Integer)returnObj;
    
35. //打印结果
    
36. System.out.println("方法执行结果为："+returnVal.intValue());
    
37. }
    
38. }
    

复制代码

6.通过反射来操作数组

1. import java.lang.reflect.*;
   
2. /**
   
3. *通过反射来操作数组
   
4. */
   
5. class UserArray
   
6. {
   
7. public static void main(String[] args) throws Exception
   
8. {
   
9. //得到String类的类对象
   
10. Class c=Class.forName("java.lang.String");
    
11. //通过Array类的反射创建一个含有10个元素的String类型的数组
    
12. Object arr=Array.newInstance(c,10);
    
13. //为数组第5个位置元素赋一个值
    
14. Array.set(arr,5,"第5个位置元素");
    
15. //取得第5个位置元素的值
    
16. String s=(String)Array.get(arr,5);
    
17. //打印这个元素的值
    
18. System.out.println("值为："+s);
    
19. }
    
20. }
    

复制代码

7.通过反射创建和使用更复杂的数组

1. import java.lang.reflect.*;
   
2. /**
   
3. *通过反射创建和使用更复杂的数组
   
4. */
   
5. class UserArrayComplex
   
6. {
   
7. public static void main(String[] args) throws Exception
   
8. {
   
9. //声明数组的维数为5X10X15
   
10. int dims[]=new int []{5,10,15};
    
11. //创建该类型的数组，元素的类型为Integer
    
12. Object arr=Array.newInstance(Integer.TYPE,dims);
    
13. //得到第3个10X15的二维数组
    
14. Object arrObj=Array.get(arr,3);
    
15. //Class c=arrObj.getClass().getComponentType();
    
16. //System.out.println(c);
    
17. //得到第2维中的第2个15位长度的数组
    
18. arrObj=Array.get(arrObj,5);
    
19. //然后设置该数组里第10个元素的值为37
    
20. Array.set(arrObj,10,37);
    
21. //再将数组还原
    
22. int [][][]arrCast=(int [][][])arr;
    
23. //打印刚刚那个值
    
24. System.out.println(arrCast[3][5][10]);
    
25. 
    
26. }
    
27. }
    

复制代码

8.获取指定类的构造器相关信息

1. import java.lang.reflect.*;
   
2. import java.io.IOException;
   
3. /**
   
4. *获取指定类的构造器相关信息
   
5. */
   
6. public class ConstructorTest
   
7. {
   
8. private int i;
   
9. private double j;
   
10. //默认的构造器
    
11. public ConstructorTest(){
    
12. }
    
13. //重载的构造器
    
14. public ConstructorTest(int i,double j)throws IOException{
    
15. this.i=i;
    
16. this.j=j;
    
17. }
    
18. public static void main(String[] args) throws Exception
    
19. {
    
20. //得到本类的类对象
    
21. Class cls=Class.forName("ConstructorTest");
    
22. //取得所有在本类声明的构造器
    
23. Constructor []cs=cls.getDeclaredConstructors();
    
24. //遍历
    
25. for(Constructor c:cs){
    
26. //构造器名称
    
27. System.out.println("构造器名="+c.getName());
    
28. //构造器声明所在的类
    
29. System.out.println("其声明的类="+c.getDeclaringClass());
    
30. //取得参数的类型集合
    
31. Class []ps=c.getParameterTypes();
    
32. //遍历参数类型
    
33. for(int i=0;i<ps.length;i++){
    
34. System.out.println("参数类型"+i+"="+ps[i]);
    
35. }
    
36. //取得异常的类型集合
    
37. Class []es=c.getExceptionTypes();
    
38. //遍历异常类型
    
39. for(int j=0;j<es.length;j++){
    
40. System.out.println("异常类型"+j+"="+es[j]);
    
41. }
    
42. //结束一层循环标志
    
43. System.out.println("-----------");
    
44. }
    
45. }
    
46. }
    

复制代码

支持了。。。

学习学习！

猫大神终于发飙了{:soso_e179:}