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学习文档

JAVA类反射学习资料

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method