JAVA类反射学习资料

1、获取指定类的构造器相关信息

   import java.lang.reflect.*;   
import java.io.IOException;   
/**  
*获取指定类的构造器相关信息  
*/   
public class ConstructorTest    
{   
 private int i;   
 private double j;   
 //默认的构造器   
 public ConstructorTest(){   
 }   
 //重载的构造器   
 public ConstructorTest(int i,double j)throws IOException{   
  this.i=i;   
  this.j=j;   
 }   
 public static void main(String[] args) throws Exception   
 {   
  //得到本类的类对象   
  Class cls=Class.forName("ConstructorTest");   
  //取得所有在本类声明的构造器   
  Constructor []cs=cls.getDeclaredConstructors();   
  //遍历   
  for(Constructor c:cs){   
   //构造器名称   
   System.out.println("构造器名="+c.getName());   
   //构造器声明所在的类   
   System.out.println("其声明的类="+c.getDeclaringClass());   
   //取得参数的类型集合   
   Class []ps=c.getParameterTypes();   
   //遍历参数类型   
   for(int i=0;i<ps.length;i++){   
    System.out.println("参数类型"+i+"="+ps[i]);   
   }   
   //取得异常的类型集合   
   Class []es=c.getExceptionTypes();   
   //遍历异常类型   
   for(int j=0;j<es.length;j++){   
    System.out.println("异常类型"+j+"="+es[j]);   
   }   
   //结束一层循环标志   
   System.out.println("-----------");   
  }   
 }   
}    

 

 

 

2、通过反射创新类的新对象 

import java.lang.reflect.*;   
/**  
*通过反射创新类的新对象  
*/   
class CreateNewObj    
{   
 //显式默认的构造器   
 public CreateNewObj(){   
 }   
 //重载构造器   
 public CreateNewObj(int a,int b){   
  System.out.println("a= "+a+" b="+b);   
 }   
  
 public static void main(String[] args) throws Exception   
 {   
  //得到本类的类对象   
  Class c=Class.forName("CreateNewObj");   
  //声明构造器的参数类型集合   
  Class []paramTypes=new Class[2];   
  //都为int型   
  paramTypes[0]=Integer.TYPE;   
  paramTypes[1]=Integer.TYPE;   
        //根据参数类型决定得到哪个构造器   
  Constructor cs=c.getConstructor(paramTypes);   
  //声明要传入的参数集合   
  Object []argList=new Object[2];   
  //传入37和43   
  argList[0]=new Integer(37);   
  argList[1]=new Integer(43);   
  //根据符合上述参数类型的构造器来创建新的对象   
  Object rtnObj=cs.newInstance(argList);   
 }   
}   

 

 

3、获取指定类的字段相关信息 

import java.lang.reflect.*;   
/**  
*获取指定类的字段相关信息  
*/   
class FieldTest    
{   
 //字段1   
 private double d;   
 //字段2   
 public static final int i=37;   
 //字段3   
 String str="fieldstest";   
 public static void main(String[] args) throws Exception   
 {   
  //获取本类的类对象   
  Class c=Class.forName("FieldTest");   
  //获取所有声明的的字段,getFields()包括继承来的字段   
  Field []fs=c.getDeclaredFields();   
  //遍历   
  for(int i=0;i<fs.length;i++){   
   Field f=fs[i];   
   //字段名   
   System.out.println("字段名"+(i+1)+"="+f.getName());   
   //字段声明所在的类   
   System.out.println("该字段所在的类为："+f.getDeclaringClass());   
   //字段的类型   
   System.out.println("字段"+(i+1)+"的类型："+f.getType());   
   //查看修饰符   
   int mod=f.getModifiers();   
   //为0就是默认的包类型   
   if(mod==0){   
                System.out.println("该字段的修饰符为：默认包修饰符");   
   }else{   
    //否则就是相应的类型   
    System.out.println("该字段的修饰符为："+Modifier.toString(mod));   
   }   
   System.out.println("---结束第"+(i+1)+"循环---");   
  }   
 }   
}   

 

4、获取指定类的方法相关信息

import java.lang.reflect.*;   
/**  
*获取指定类的方法相关信息  
*/   
class InformationTest    
{   
 public static void main(String[] args) throws Exception   
 {   
  //得到String类对象   
  Class cls=Class.forName("java.lang.String");   
  //得到所有的方法，包括从父类继承过来的方法   
  Method []methList=cls.getMethods();   
  //下面是得到的是String类本身声明的方法   
  //Method []methList=cls.getDeclaredMethods();   
  //遍历所有的方法   
  for(Method m:methList){   
   //方法名   
   System.out.println("方法名="+m.getName());   
   //方法声明所在的类   
   System.out.println("声明的类="+m.getDeclaringClass());   
   //获取所有参数类型的集体   
   Class []paramTypes=m.getParameterTypes();   
   //遍历参数类型   
   for(int i=0;i<paramTypes.length;i++){   
    System.out.println("参数 "+i+" = "+paramTypes[i]);   
   }   
   //获取所有异常的类型   
   Class []excepTypes=m.getExceptionTypes();   
   //遍历异常类型   
   for(int j=0;j<excepTypes.length;j++){   
    System.out.println("异常 "+j+" = "+excepTypes[j]);   
   }   
   //方法的返回类型   
   System.out.println("返回类型 ="+m.getReturnType());   
   //结束一层循环标志   
   System.out.println("---------");   
  }   
 }   
}   

 

5、通过反射改变字段的值

import java.lang.reflect.*;   
/**  
*通过反射改变字段的值  
*/   
class ModifyField    
{   
 //声明一个字段   
 public double d;   
 public static void main(String[] args) throws Exception   
 {   
  //得到类的类对象   
  Class c=Class.forName("ModifyField");   
  //根据字段名得到字段对象   
  Field f=c.getField("d");   
  //创建类的实例   
  ModifyField mf=new ModifyField();   
  //打印修改前字段的值   
  System.out.println("修改 "+f.getName()+" 前的值为："+mf.d);   
  //修改d的值为12.34   
  f.setDouble(mf,12.34);   
  //打印修改后的值   
  System.out.println("修改 "+f.getName()+" 后的值为："+mf.d);   
  
 }   
}   

 

 

6、通过反射执行类的方法

import java.lang.reflect.*;   
/**  
*通过反射执行类的方法  
*/   
class PerformMethod    
{   
 //声明一个简单的方法，用于测试   
 public int add(int a,int b){   
  return a+b;   
 }   
 public static void main(String[] args)throws Exception   
 {   
  //获取本类的类对象   
  Class c=Class.forName("PerformMethod");   
  /**  
  *声明add方法参数类型的集合  
  *共有两个参数，都为Integer.TYPE  
  */   
  Class []paramTypes=new Class[2];   
  paramTypes[0]=Integer.TYPE;   
  paramTypes[1]=Integer.TYPE;   
  //根据方法名和参数类型集合得到方法   
  Method method=c.getMethod("add",paramTypes);   
  //声明类的实例   
  PerformMethod pm=new PerformMethod();   
  //传入参数的集合   
  Object []argList=new Object[2];   
  //传入37和43   
  argList[0]=new Integer(37);   
  argList[1]=new Integer(43);   
  //执行后的返回值   
  Object returnObj=method.invoke(pm,argList);   
  //类型转换下   
  Integer returnVal=(Integer)returnObj;   
  //打印结果   
  System.out.println("方法执行结果为："+returnVal.intValue());   
 }   
}   

 

7、通过反射来操作数组 

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

 

 

8、通过反射创建和使用更复杂的数组

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

 

 

下面把上面所述的java类打包在附近，需要的可以下载，另附带一java反射doc学习文档

 

1.入门的入门
2.注释太多
3.代码风格存在严重的问题，这要是来个代码评审，绝对第一个PASS掉
4.楼主很认真，加油！

很少见到有觉得注释多的。个人觉得：注释解释的越清楚越好。

作为学习笔记,多记注释,就等于自己的笔记了.

但是实在生产中,我认为仅需要对自己产出的代码逻辑进行注释即可.这种情况下,LZ所给的代码注释基本都不需要了,否则会因为注释太多,反而淹没真正需要让别人看的.

注释多？不存在这个缺点一说。

代码中注释越多越好，尽管有时候比较简单的代码行也添加注释，只要不是文不达意总比没有的好。
代码风格存在严重的问题，这点楼主的意思是
{
} 这样的就存在问题 {

}这样的就不存在吗。因为我一直是用第一种花括号风格，不敢认同楼主的观点

代码整洁之道上说

注释越少越好。。。那怎么才能看得懂呢。

就把变量的命名。。类命名，方法的命名 变得有意义。能一看就知道怎么回事，省略掉注释

当然，既然是初学者的学习用的，那么自然是中文注释越多越好。几乎每一行都有。毕竟初学者不熟悉这些东西。如果能把将注释记忆下来。变成代码。那么写了那么多注释就成功啦。

现在的外面卖的教程，哪本也是都注释的啊。。没注释学起来费力呢。。
简单的说，把注释当成是讲解代码的方式
而不是程序员的。理解代码的方式。

所以，以上的朋友就不要钻牛角尖了

代码风格应该说得是换行吧？
注释太多我感觉这个没啥错误，曾经做过一个项目，结果类中代码没注释多，崩溃啊；我第一次做练习的时候也喜欢把 注意事项、问题、答案信息当作注释写到代码里，然后发到网上备份，如http://lgsun592.iteye.com/admin/blogs/977825。但是没有LZ勇敢，我不敢发到论坛，呵呵。
再有，注释也分/*...*/、/** ... */和// 的，lz 要注意哦。

说注释多的很明显都是新手
不过代码风格确实有问题，一会是
{
}
一会是{
}

都说了这是学习资料

怎么做技术的老是吹毛求疵