Java反射-例子

示例代码：

package com.lee.wait;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
 * 接口
 * @author wait
 *
 */
interface inter{
    String interfaceDeclared="interfaceDeclared";
    void interfaceMethod();
}
/**
 * 基类/父类
 * @author wait
 *
 */
class Base{
    //成员变量
    public String publicBase;
    protected String protectedBase;
    private String privateBase;
    String defaultBase;
    public static String publicStaticBase;
    //内部类
    public class PublicInnerBase{
        public String publicPublicInnerBase;
        public PublicInnerBase() {

        }
        private PublicInnerBase(String publicPublicInnerBase){

        }
    }

    protected class ProtectedInnerBase{
        public String publicProtectedInnerBase;
        public ProtectedInnerBase() {

        }
        private ProtectedInnerBase(String publicProtectedInnerBase){

        }
    }
    private class PrivateInnerBase{
        public String publicPrivateInnerBase;
        public PrivateInnerBase() {

        }
        private PrivateInnerBase(String publicPrivateInnerBase){

        }
    }
    //构造方法
    public Base(){

    }

    private Base(String protectedBase){

    }
    //成员方法
    public void publicMethodBase(){

    }
    protected void protectedMethodBase(){

    }
    void defaultMethodBase(){

    }
    private void privateMethodBase(){

    }



}
/**
 * 子类
 * @author wait
 *
 */
class Child extends Base implements inter{
    //成员变量
    public String publicChild;
    protected String protectedChild;
    private String privateChild;
    String defaultChild;
    public static String publicStaticChild;
    //内部类
    public class PublicInnerChild{
        public String publicPublicInnerChild;
        public PublicInnerChild() {

        }
        private PublicInnerChild(String publicInter){

        }
    }

    protected class ProtectedInnerChild{
        public String publicProtectedInnerChild;
        public ProtectedInnerChild() {

        }
        private ProtectedInnerChild(String publicInter){

        }
    }
    private class PrivateInnerChild{
        public String publicPrivateInnerChild;
        public PrivateInnerChild() {

        }
        private PrivateInnerChild(String publicInter){

        }
    }

    //构造方法
    public Child() {

    }
    private Child(String publicChild){

    }
    //成员方方法
    public void publicMethodChild(){

    }
    protected void protectedMethodChild(){

    }
    void defaultMethodChild(){

    }
    private void privateMethodChild(){

    }
    @Override
    public void interfaceMethod() {
        // TODO Auto-generated method stub

    }
}
public class RefacterDemo {
    public static void main(String[] args) throws ClassNotFoundException{
        Class classChild=Class.forName("com.lee.wait.Child");

        Constructor[] constructors1 = classChild.getConstructors();
        System.out.println("Child类的，getConstructors可以获取到类的public构造方法");
        for(int i=0,len=constructors1.length;i<len;i++){
            System.out.println(constructors1[i]);
        }
        System.out.println();

        Constructor[] constructors2 = classChild.getDeclaredConstructors();
        System.out.println("Child类的，getDeclaredConstructors可以获取到类的所有构造方法");
        for(int i=0,len=constructors2.length;i<len;i++){
            System.out.println(constructors2[i]);
        }
        System.out.println();

        Class[] classes1 = classChild.getInterfaces();
        System.out.println("Child类的，getInterfaces可以获取到类实现的接口");
        for(int i=0,len=classes1.length;i<len;i++){
            System.out.println(classes1[i]);
        }
        System.out.println();

        Class[] classes2 =classChild.getClasses();
        System.out.println("Child类的，getClasses可以获取到类内部Public的类，包括集成的父类的Public内部类");
        for(int i=0,len=classes2.length;i<len;i++){
            System.out.println(classes2[i]);
        }
        System.out.println();

        Class[] classes3=classChild.getDeclaredClasses();
        System.out.println("Child类的，getDeclaredClasses可以获取到类所有的内部类，不包括父类集成的内部类");
        for(int i=0,len=classes3.length;i<len;i++){
            System.out.println(classes3[i]);
        }
        System.out.println();

        ClassLoader classLoader=classChild.getClassLoader();
        System.out.println("Child类的，getClassLoader可以获取到类的加载器");
        System.out.println(classLoader);
        System.out.println();

        Class superClass =classChild.getSuperclass();
        System.out.println("Child类的，getSuperclass获取父类");
        System.out.println(superClass);
        System.out.println();

        Method[] methods1=classChild.getMethods();
        System.out.println("Child类的，getMethods可以获取到父类的方法，但是只能获取public的方法");
        for(int i=0,len=methods1.length;i<len;i++){
            System.out.println(methods1[i]);
        }
        System.out.println();

        Method[] methods2=classChild.getDeclaredMethods();
        System.out.println("Child类的，getDeclaredMethods获取不到父类的方法，但是可以获取本类所有的方法");
        for(int i=0,len=methods2.length;i<len;i++){
            System.out.println(methods2[i]);
        }
        System.out.println();

        Field[] fields1=classChild.getFields();
        System.out.println("Child类的，getFields可以获取到父类声明的变量，但是只能获取public的变量");
        for(int i=0,len=fields1.length;i<len;i++){
            System.out.println(fields1[i]);
        }
        System.out.println();

        Field[] fields2=classChild.getDeclaredFields();
        System.out.println("Child类的，getDeclaredFields不可以获取到父类的变量，但是可以获取到本类所有的变量");
        for(int i=0,len=fields2.length;i<len;i++){
            System.out.println(fields2[i]);
        }
        System.out.println();       
    }
}

运行结果：

Child类的，getConstructors可以获取到类的public构造方法
public com.lee.wait.Child()

Child类的，getDeclaredConstructors可以获取到类的所有构造方法
public com.lee.wait.Child()
private com.lee.wait.Child(java.lang.String)

Child类的，getInterfaces可以获取到类实现的接口
interface com.lee.wait.inter

Child类的，getClasses可以获取到类内部Public的类，包括集成的父类的Public内部类
class com.lee.wait.Child$PublicInnerChild
class com.lee.wait.Base$PublicInnerBase

Child类的，getDeclaredClasses可以获取到类所有的内部类，不包括父类集成的内部类
class com.lee.wait.Child$PrivateInnerChild
class com.lee.wait.Child$ProtectedInnerChild
class com.lee.wait.Child$PublicInnerChild

Child类的，getClassLoader可以获取到类的加载器
sun.misc.Launcher$AppClassLoader@73d16e93

Child类的，getSuperclass获取父类
class com.lee.wait.Base

Child类的，getMethods可以获取到父类的方法，但是只能获取public的方法
public void com.lee.wait.Child.publicMethodChild()
public void com.lee.wait.Child.interfaceMethod()
public void com.lee.wait.Base.publicMethodBase()
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()

Child类的，getDeclaredMethods获取不到父类的方法，但是可以获取本类所有的方法
public void com.lee.wait.Child.publicMethodChild()
protected void com.lee.wait.Child.protectedMethodChild()
void com.lee.wait.Child.defaultMethodChild()
private void com.lee.wait.Child.privateMethodChild()
public void com.lee.wait.Child.interfaceMethod()

Child类的，getFields可以获取到父类声明的变量，但是只能获取public的变量
public java.lang.String com.lee.wait.Child.publicChild
public static java.lang.String com.lee.wait.Child.publicStaticChild
public static final java.lang.String com.lee.wait.inter.interfaceDeclared
public java.lang.String com.lee.wait.Base.publicBase
public static java.lang.String com.lee.wait.Base.publicStaticBase

Child类的，getDeclaredFields不可以获取到父类的变量，但是可以获取到本类所有的变量
public java.lang.String com.lee.wait.Child.publicChild
protected java.lang.String com.lee.wait.Child.protectedChild
private java.lang.String com.lee.wait.Child.privateChild
java.lang.String com.lee.wait.Child.defaultChild
public static java.lang.String com.lee.wait.Child.publicStaticChild