package com.fanshe.obj;
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("com.fanshe.obj.ConstructorTest");
//取得所有在本類聲明的構造器
Constructor<?> []cs=cls.getDeclaredConstructors();
//遍歷
System.out.println("----------------");
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("-----------");
}
}
}
package com.fanshe.obj;
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("com.fanshe.obj.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);
}
}
package com.fanshe.obj;
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("com.fanshe.obj.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)+"循環---");
}
}
}
package com.fanshe.obj;
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("---------");
}
}
}
package com.fanshe.obj;
import java.lang.reflect.*;
/**
*通過反射改變字段的值
*/
class ModifyField
{
//聲明一個字段
public double d;
public static void main(String[] args) throws Exception
{
//得到類的類對象
Class<?> c=Class.forName("com.fanshe.obj.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);
}
}
package com.fanshe.obj;
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("com.fanshe.obj.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());
}
}
package com.fanshe.obj;
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);
}
}
package com.fanshe.obj;
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]);
}
}