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