java中反射：反射的应用--取得类的结构(三)

通过反射的到一个类的完整结构，那么这就要使用到 java.lang.reflect 包中的以下几个类。

Constructor：表示类中的构造方法。

Field：表示类中的属性。

Method：表示类中的方法。

这三个类都是AccessbleObject 类的子类

范例：
China接口：
package com.testFS.test;

public interface China {
 public static final String NATIONAL="China";//定义全局常量
 public static final String AUTHOR="li hua";
 public void sayChina();//定义无参的抽象方法
 public String sayHello(String name,int age);//定义有参的抽象方法

}
Person01类：
package com.testFS.test;

public class Person01 implements China {

 private String name;
 private int age;
 
 public Person01() {
  super();
  // TODO Auto-generated constructor stub
 }

 public Person01(String name, int age) {
  super();
  this.name = name;
  this.age = age;
 }

 @Override
 public String toString() {
  return "Person01 [name=" + name + ", age=" + 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;
 }

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

 @Override
 public String sayHello(String name, int age) {
  // TODO Auto-generated method stub
  return name+""+age+"";
 }
}
取得所有实现的全部接口：
要取得一个类所实现的全部接口，则必须使用Class类中的 getInterfaces() 方法。
定义如下：
public Class[] getInterfaces()
getInterfaces() 方法返回一个 Class 类中的getName()方法输出即可。
范例：取得Person01类实现的全部接口
package com.testFS.test;

public class GetInterfaceDemo {

 public static void main(String[] args) {
  Class<?> c1=null;
  try {
   c1=Class.forName("com.testFS.test.Person01"); //实例化对象
  } 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());
  }
 }
}
运行结果：
实现的接口名称：com.testFS.test.China

 

因为接口是类的特殊形式，而且一个类可以实现多个接口，所以此时以Class 数组的形式将全部的几口对象返回，并利用循环的方式将内容依次输出。

 

取得父类 

一个类可以实现多个接口，但是只能继承一个父类，所以如果要取得一个类的父类，可以直接使用Class类中的getSuperclass() 方法。

定义如下：

public Class<? super T> getSuperclass()

getSuperclass() 方法返回的是Class实例，和之前得到接口一样，可以通过getName() 方法取得名称。

范例：取得Person01的父类
package com.testFS.test;

public class GetSuperClassDemo {

 public static void main(String[] args) {
  Class<?> c1=null;
   try {
    c1=Class.forName("com.testFS.test.Person01");
   } catch (ClassNotFoundException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
   Class<?> c2=c1.getSuperclass();
   System.out.println("父类名称："+c2.getName());
 }
}
运行结果：
父类名称：java.lang.Object
Person01类没有明确地继承一个父类，所以默认继承Object类。
取得全部构造方法：
要取得一个类中的全部构造方法，则必须使用Class 类中的 getConstructors() 方法。
范例：
package com.testFS.test;

import java.lang.reflect.Constructor;

public class GetConstructorDemo01 {

 public static void main(String[] args) {
  Class<?> c1=null;
  try {
   c1=Class.forName("com.testFS.test.Person01"); //实例化对象
  } catch (ClassNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  Constructor<?> con[]=c1.getConstructors();
  for(int i=0;i<con.length;i++){
   System.out.println("Person01类中的构造方法："+con[i]);
  }
 }
}
运行结果：
Person01类中的构造方法：public com.testFS.test.Person01()
Person01类中的构造方法：public com.testFS.test.Person01(java.lang.String,int)

 

取得全部方法：

要取得一个类中的全部方法，可以使用Class类中的 getMethods() 方法，此方法返回一个Method类的对象数组。

范例：
package com.testFS.test;

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

public class GetMethodDemo {

 public static void main(String[] args) {
  Class<?> c1=null;
  try {
   c1=Class.forName("com.testFS.test.Person01"); //实例化对象
  } catch (ClassNotFoundException e) {
   e.printStackTrace();
  }
  Method m[]=c1.getMethods();
  for(int i=0;i<m.length;i++){
   Class<?> c2=m[i].getReturnType();//得到方法返回值类型
   Class<?> c3[]=m[i].getParameterTypes();//得到全部的参数类型
   int xx=m[i].getModifiers(); //得到方法的修饰
   System.out.print(Modifier.toString(xx)+" ");//还原修饰符
   System.out.print(c2.getName()+" ");//取得方法名
   System.out.print(m[i].getName());//取得方法名称
      System.out.print(" ("); //输出“（”
     
      for(int x=0;x<c3.length;x++){
       System.out.print(c3[x].getName()+ " " + "arg" + x); //输出参数
       if(x<c3.length-1){
        System.out.print(",");//判断是否输出“，”
       }
      }
      Class<?> ex[]=m[i].getExceptionTypes();//得到全部的异常抛出
      if(ex.length>0){
       System.out.print(") throws "); //输出“） throws ”
      }
      else{
       System.out.print(" ) "); //输出“）”
      }
      for(int j=0;j<ex.length;j++){
       System.out.print(ex[j].getName());//输出异常信息
             if(j<ex.length-1){
              System.out.print(",");//输出“，”
             }
      }
      System.out.println(); //换行
  }
 }
}
输出结果：
public int getAge ( )
public void setAge (int arg0 )
public void sayChina ( )
public java.lang.String sayHello (java.lang.String arg0,int arg1 )
public java.lang.String toString ( )
public java.lang.String getName ( )
public void setName (java.lang.String arg0 )
public final native java.lang.Class getClass ( )
public native int hashCode ( )
public boolean equals (java.lang.Object arg0 )
public final native void notify ( )
public final native void notifyAll ( )
public final void wait (long arg0,int arg1) throws java.lang.InterruptedException
public final void wait () throws java.lang.InterruptedException
public final native void wait (long arg0) throws java.lang.InterruptedException

从程序中看，程序不仅将Person类的方法输出，也把从Object 类中继承而来的方法同样进行了输出。

提示：在使用IDE进行程序开发时，基本都是带随笔提示功能，即使一个“."就可以找到类的全部方法，实际上这个功能就是利用此种方式完成的。