Java反射機制（取得類的結構）

通過反射得到一個類中的完整的結構，就要使用java.lang.reflect包中的以下幾個類：

 

Constructor：表示類中的構造方法

Field：表示類中的屬性

Method:表示類中的方法

 

Class類中的常用方法：

 

確定此對象所表示的類或接口實現的接口。

public Class<?>[] getInterfaces()

取得父類

public Class<? super T> getSuperclass()

取得全部的構造方法

public  Constructor<?>[]  getConstructors()throws  SecurityException

 取得類中的全部方法

public  Method[]  getMethods()throws  SecurityException

 

Method類中的常用方法：

獲取全部異常拋出

public  Class<?>[]  getExceptionTypes()

獲取本方法的訪問修飾符（取出權限）

public int  getModifiers()

獲取方法的返回值類型

public  Class<?>  getReturnType()

獲得方法的全部參數類型

public  Class<?>[]  getParameterTypes()

 

 

Constructor<T>類中的常用的方法：

 

列出構造方法中的參數類型

public  Class<?>[]  getParameterTypes()

獲取本方法的訪問修飾符（取出權限）

public int  getModifiers()

注：在取得權限時發現返回的是一個數字而不是public，這是因為在整個java中對於方法的修飾符是使用一定的數字表示出來的，如果要把這個數字還原成用戶可以看懂的關鍵字，則必須依靠Modifier類完成；

int modifiers = constructors[i].getModifiers();

//還原權限(public static String toString(int mod))

System. out .println(Modifier.toString(modifiers));

輸出構造方法的名稱

public  String  getName()

 

Field(屬性)中的常用的方法：

 

一般獲取屬性時有兩種操作：

1：得到實現結構的接口或父類中的公共屬性：

public Field[] getFields() throws SecurityExceotion

2：得到本類中的全部屬性

public Field[] getDeclaredFields() throws SecurityExceotion

 

常用方法：

取得屬性的類型：

public  Class<?>  getType()

得到修飾符數字

public int  getModifiers()

 

實例：

package cn.itcast;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class ClassDemo05 {
	public static void main(String[] args) {
		Class<?> c1 = null;

		try {
			c1 = Class.forName("cn.itcast.Person");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("-----------------獲取實現的全部接口----------------");
		// 獲取實現的全部接口
		Class<?> interfaces[] = c1.getInterfaces();
		for (Class<?> thisclass : interfaces) {
			System.out.println(thisclass.getName());
		}

		System.out.println("-----------------取得父類----------------");
		Class<?> superclass = c1.getSuperclass();
		System.out.println(superclass.getName());

		System.out.println("-----------------取得一個類中的全部的構造方法----------------");
		Constructor<?> constructors[] = c1.getConstructors();
		for (int i = 0; i < constructors.length; i++) {
			Class<?> parameterTypes[] = constructors[i].getParameterTypes();
			//取得權限
			int modifiers = constructors[i].getModifiers();
			//還原權限(public static String toString(int mod))
			System.out.println(Modifier.toString(modifiers));
			//輸出構造方法名稱
			String name = constructors[i].getName();
			//循環打印參數類型
			for (int j = 0; j < parameterTypes.length; j++) {
				System.out.println(parameterTypes[j]);
				System.out.println(modifiers);
				System.out.println(name);
			}
			
		}
		System.out.println("-----------------------取得全部的方法-------------------------");
		//獲取全部的方法
		Method[] methods = c1.getMethods();
		for (int j = 0; j < methods.length; j++) {
			System.out.println(methods[j]);
			//得到方法的返回值類型
			Class<?> returnType = methods[j].getReturnType();
			System.out.println(returnType);
			//得到全部參數的類型
			Class<?>[] parameterTypes2 = methods[j].getParameterTypes();
			for (Class<?> class1 : parameterTypes2) {
				System.out.println(class1);
			}
			//獲得全部異常拋出
			Class<?>[] exceptionTypes = methods[j].getExceptionTypes();
			//判斷是否有異常
			if(exceptionTypes.length>0)
			{
				System.out.println(") throws ");
			}else{
				System.out.println(")");
			}
			for (int i = 0; i < exceptionTypes.length; i++) {
				System.out.println(exceptionTypes[i].getName());
				if(i<exceptionTypes.length-1)
				{
					System.out.println(",");
				}
			}
			System.out.println();
		}
		System.out.println("==================取得本類全部屬性==================");
		//得到本類中的屬性
		Field[] declaredFields = c1.getDeclaredFields();
		for (int i = 0; i < declaredFields.length; i++) {
			//取得本類中屬性類型
			Class<?> type = declaredFields[i].getType();
			System.out.println(type);
			//得到修飾符的數字
			int modifiers = declaredFields[i].getModifiers();
			System.out.println(modifiers);
			//取得屬性的修飾符
			String priv = Modifier.toString(modifiers);
			System.out.println(priv);
			
		}
		System.out.println("==================取得父類全部屬性==================");
		Field[] fields = c1.getFields();
		for (int i = 0; i < fields.length; i++) {
			Class<?> type = fields[i].getType();
			System.out.println(type);
			int modifiers = fields[i].getModifiers();
			System.out.println(modifiers);
			String priv = Modifier.toString(modifiers);
			System.out.println(priv);
		}
	}
}

　

Person類：
package cn.itcast02;

public class Person implements China{
	private String name;
	private int age;
	private char sex;

	public Person() {
		super();
	}

	public Person(String name, int age, char sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}
	public void eat()
	{
		System.out.println("吃了");
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
	}

	@Override
	public void sayChina() {
		// TODO Auto-generated method stub
		System.out.println("作者："+ AUTHOR + "國籍："+ NATIONAL);
	}

	@Override
	public String sayHello(String name, int age, char sex) {
		// TODO Auto-generated method stub
		return "姓名:" + name +"年齡："+ age +"性別:"+ sex;
	}

}

　　

China接口：
package cn.itcast02;

public interface China {
	public static final String NATIONAL = "China";
	public static final String AUTHOR = "成龍";

	public void sayChina();

	public String sayHello(String name, int age, char sex);
}