反射机制之取得类的结构

取得类的结构

操作类

package idemo;

public interface China {
	public static final String NATIONAL = "China";//定义全局常量
	public static final String AUTHOR = "yue";//定义全局常量
	
	public void sayChina();//无参的，没有返回值类型的
	public String sayHello(String name,int age);//定义有两个参数的方法，并返回内容
}


public class Per implements China{
	private String name;
	private int age;
	
	
	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 Per() {     //无参构造
		
	}
	
	public Per(String name) {	//设置name属性
		this.name = name;
	}
	
	public Per(String name,int age) {	//
		this.name = name;
		this.age = age;
	}

	@Override
	public void sayChina() {
		System.out.println("作者：" + AUTHOR + ",国籍：" + NATIONAL);
	}

	@Override
	public String sayHello(String name,int age) {
		
		return name + ",你好！我今年：" + age + "岁了！";
	}
	
	
	
}

1、取得类所实现的全部解口

如果想要取得一个类的全部接口，可以使用Class类中的

public Class<?>[] getInterfaces()

因为一个类可以同时实现多个接口，所以在此处将以一个数组的形式返回实现的全部接口

package classinfodemo;

public class GetInterfaceDemo {
	public static void main(String[] args) {
		Class<?> c1 = null;//声明Class对象
		
		try {
			c1 = Class.forName("idemo.Per");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}								//实例化对象
		
		Class<?> c[] = c1.getInterfaces();//以数形式返回实现的全部接口
		for(int i = 0;i<c.length;i++) {
			System.out.println("实现的接口名称：" + c[i].getName());//输出数组的接口名称
		}
	}
}

2、取得类的所有父类

一个类只能有一个父类，如果一个类中没有明确指明继承哪个类，则肯定继承object类

public Class<? super T> getSuperclass()

取得父类

package classinfodemo;

public class GetSurperClassDemo2 {
	public static void main(String[] args) {
		Class<?> c1 = null;//声明Class对象
		
		try {
			c1 = Class.forName("idemo.Per");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}								//实例化对象
		
		Class<?> c = c1.getSuperclass();//输出父类
		System.out.println(c.getName());
	}
}

结果是java.lang.Object

3、取得类中的全部构造方法

package classinfodemo;

import java.lang.reflect.Constructor;

public class GetConstructorDemo {
	public static void main(String[] args) {
		Class<?> c1 = null;//声明Class对象
		
		try {
			c1 = Class.forName("idemo.Per");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}								//实例化对象
		
		Constructor<?> c[] = c1.getConstructors();//取得一个类中的全部构造方法
		for(int i = 0;i<c.length;i++) {
			System.out.println("构造方法：" + c[i]);//输出构造直接打印
		}
	}
}

以上的操作确实取得了类中的构造方法，但是此时是通过对象直接打印取得的，肯定会调用Constructor类中的toString（）方法

Constructor类中存在了以下的几个方法：

a.取得修饰符：

public int getModifiers()

b.取得方法名称：

public String getName()

c.取得参数的类型

public Class<?>[] getParameterTypes()

下面是得到构造方法：自己取得并且拼凑的

package classinfodemo;

import java.lang.reflect.Constructor;

public class GetConstructorDemo2 {
	public static void main(String[] args) {
		Class<?> c1 = null;//声明Class对象
		
		try {
			c1 = Class.forName("idemo.Per");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}								//实例化对象
		
		Constructor<?> c[] = c1.getConstructors();//取得一个类中的全部构造方法
		for(int i = 0;i<c.length;i++) {
			Class<?> p[] = c[i].getParameterTypes();//得到所有的构造方法
			System.out.print("构造方法：");
			System.out.print(c[i].getModifiers()+" ");//得到修饰符
			System.out.print(c[i].getName());//取得构造方法的名字
			System.out.print("( ");
			for(int j = 0;j<p.length;j++) {
				System.out.print(p[j].getName()+" arg" + i);
				if(j<p.length-1) {
					//是否是最后一个参数
					System.out.print(",");
				}
			}
			System.out.println(")");
		}
	}
}

此时在操作之后，发现，所有的修饰符变成了数字，

构造方法：1 idemo.Per( java.lang.String arg0)
构造方法：1 idemo.Per( java.lang.String arg1,int arg1)
构造方法：1 idemo.Per( )

因为getModifiers返回值是一个数字

4、还原修饰符

public static String toString(int mod)

下面是利用以上的类还原修饰符：

package classinfodemo;

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

public class GetConstructorDemo2 {
	public static void main(String[] args) {
		Class<?> c1 = null;//声明Class对象
		
		try {
			c1 = Class.forName("idemo.Per");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}								//实例化对象
		
		Constructor<?> c[] = c1.getConstructors();//取得一个类中的全部构造方法
		for(int i = 0;i<c.length;i++) {
			Class<?> p[] = c[i].getParameterTypes();//得到所有的构造方法
			System.out.print("构造方法：");
			int mo = c[i].getModifiers();
			System.out.print(Modifier.toString(mo)+" ");//得到修饰符
			System.out.print(c[i].getName());//取得构造方法的名字
			System.out.print("( ");
			for(int j = 0;j<p.length;j++) {
				System.out.print(p[j].getName()+" arg" + i);
				if(j<p.length-1) {
					//是否是最后一个参数
					System.out.print(",");
				}
			}
			System.out.println(")");
		}
	}
}

5、取得一个类中全部方法：

输出：本类中全部方法：不包括object类中的方法
public Method[] getDeclaredMethods()
                            throws SecurityException

输出全部方法：包括object中方法
public Method[] getMethods()
                    throws SecurityException

方法操作：

• 取得全部的返回值:public Class<?> getReturnType()

• 取得全部的参数：public Class<?>[] getParameterTypes()

• 取得修饰符：public int getModifiers()

• 取得异常信息：public Type[] getGenericParameterTypes()

package classinfodemo;

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

public class GetMethodDemo {
	public static void main(String[] args) {
		Class<?> c1 = null;//声明Class对象
		
		try {
			c1 = Class.forName("idemo.Per");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}								//实例化对象
		
		Method m[] = c1.getMethods();//取得全部方法
		for(int i = 0;i<m.length;i++) {
			Class<?> r = m[i].getReturnType();//得到返回值类型
			Class<?> p[] = m[i].getParameterTypes();//得到全部的参数类型
			int mo = m[i].getModifiers();
			System.out.print(Modifier.toString(mo) + " ");
			System.out.print(r.getName() + " ");
			System.out.print(m[i].getName()+ " ");
			System.out.print("(");
			for(int j = 0;j<p.length;j++) {
				System.out.println(p[j].getName());
				if(j<p.length-1) {
					System.out.print(",");
				}
			}
			
			Class<?> ex[] = m[i].getExceptionTypes();
			if(ex.length>0) {
				System.out.print(") throws ");
			}else {
				System.out.print(")");
			}
			
			for(int j = 0;j<ex.length;j++) {
				System.out.println(ex[j].getName());
				if(j<ex.length-1) {
					System.out.print(",");
				}
			}
			
			System.out.println();
		}
		
		
	}
}

在一般的开发工具中经常看见随笔提示工具，实际上此功能就是利用以上的开发工具完成的

6、取得一个类中全部属性

得到实现的接口或者父类中的公共属性：
public Field[] getFields()
                  throws SecurityException

package classinfodemo;

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

public class GetFieldDemo {
	public static void main(String[] args) {
		Class<?> c1 = null;//声明Class对象
		
		try {
			c1 = Class.forName("idemo.Per");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}								//实例化对象
		
		Field f[] = c1.getFields();//取得本类中的属性
		for(int i = 0;i<f.length;i++) {
			Class<?> r = f[i].getType();//得到属性类型
			int mo = f[i].getModifiers();//得到访问权限
			String pro = Modifier.toString(mo);//还原修饰符
			System.out.print("公共属性： ");
			System.out.print(pro+" ");
			System.out.print(r.getName() + " ");//输出属性类型
			System.out.print(f[i].getName() + " ");//输出属性名称
			System.out.println(";");
			System.out.println();
		}
		
		
	}
}

得到本类中的全部属性：
public Field[] getDeclaredFields()
                          throws SecurityException

package classinfodemo;

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

public class GetFieldDemo {
	public static void main(String[] args) {
		Class<?> c1 = null;//声明Class对象
		
		try {
			c1 = Class.forName("idemo.Per");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}								//实例化对象
		
		Field f[] = c1.getDeclaredFields();//取得本类中的全部属性
		for(int i = 0;i<f.length;i++) {
			Class<?> r = f[i].getType();//得到属性类型
			int mo = f[i].getModifiers();//得到访问权限
			String pro = Modifier.toString(mo);//还原修饰符
			System.out.print("本类属性： ");
			System.out.print(pro+" ");
			System.out.print(r.getName() + " ");//输出属性类型
			System.out.print(f[i].getName() + " ");//输出属性名称
			System.out.println(";");
			System.out.println();
		}
		
		
	}
}

总结：

1.在实际操作中，取得类的结构操作用户并不会经常开发

2.一定要熟悉java.lang.reflect包的作用，反射机制

3.如何取得属性，方法，构造的名称，修饰符

等等