java反射基础详解--使用反射获取一切

1、使用反射获取类的常用结构（详细版见4、）

package reflectioin;

import org.junit.Test;

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

public class ReflectionTest {
    @Test
    public void reflectTest() throws Exception {
        Class clazz = GoodWorker.class; // 获取类

        System.out.println("********获取可见结构********");
        Constructor constructor = clazz.getConstructor(String.class,int.class); // 通过类对象获取构造器
        Object yunWeiXiaoCai = constructor.newInstance("yunWeiXiaoCai", 28); // 通过构造器创建对象
        GoodWorker goodWorker = (GoodWorker)yunWeiXiaoCai; // 类型转换

        Field name = clazz.getDeclaredField("name"); // 通过类对象获取可见属性对象
        name.set(yunWeiXiaoCai,"Tom"); // 通过属性对象设置属性
        System.out.println(goodWorker.name);
                                                // 方法名，参数类型
        Method method = clazz.getMethod("work",String.class); // 通过类对象获取可见方法对象
                        // 对象名称，方法实参列表
        method.invoke(goodWorker,"morning"); // 通过方法对象执行方法

        System.out.println("********获取私有结构********");
        Constructor constructor1 = clazz.getDeclaredConstructor(Boolean.class);
        constructor1.setAccessible(true);
        GoodWorker goodWorker1 = (GoodWorker)constructor1.newInstance(true);
        System.out.println(goodWorker1.name);

        Field age = clazz.getDeclaredField("age");
        age.setAccessible(true);
        age.set(goodWorker1,22);
        System.out.println(goodWorker1.getAge());

        Method method1 = clazz.getDeclaredMethod("play",String.class);
        method1.setAccessible(true);    // 设置为可获取
        String doing = (String)method1.invoke(goodWorker1, "Lily"); // 获取返回值
        System.out.println(doing);

    }
}

class GoodWorker {
    String name = "defaultName";
    private int age = 18 ;
    private boolean isMale;
    public GoodWorker(String name, int age) {
        this.name = name;
        this.age = age;
    }
    private GoodWorker(Boolean isMale) {
        this.isMale = isMale;
    }
    public void work(String time){
        System.out.println(name + "is working hardly in the " + time);
    }
    public int getAge() {
        return age;
    }
    private String play(String with){
        return name + " is playing with " + with;
    }
}

2、获取类对象的几种方法

可以有类对象的类型有：

• 类：外部类（包括Class）、成员内部类、静态内部类、局部内部类、匿名内部类
• 其他：接口、数组、枚举、注解、基本数据类型、void

@Test
    public void reflectTest() throws Exception {

        // 通过运行时类的属性 类名.class
        Class<GoodWorker> clazz = GoodWorker.class;
        System.out.println(clazz);

        // 通过运行时类的对象 对象.getClass()
        GoodWorker goodWorker = new GoodWorker("yyqx",22);
        Class<? extends GoodWorker> goodWorkerClass = goodWorker.getClass();
        System.out.println(goodWorkerClass);

        // 调用Class的静态方法 Class.forName()
        Class<?> aClass = Class.forName("reflection.GoodWorker"); // 从包开始的全类名
        System.out.println(aClass);

        // 使用类的加载器
        Class<?> loadClass = GoodWorker.class.getClassLoader().loadClass("reflection.GoodWorker");

        // 四种方式获取相同的类对象
        System.out.println(clazz == aClass);
        System.out.println(clazz == goodWorkerClass);
        System.out.println(loadClass == clazz);
    }

3、调用类的结构

package reflection;

import org.junit.Test;

import java.beans.FeatureDescriptor;
import java.lang.annotation.Annotation;
import java.lang.reflect.*;

public class ReflectionTest {
    @Test
    public void reflectTest() throws Exception {

        // 获取类的对象
        Class<GoodWorker> clazz = GoodWorker.class;
        
        //调用指定构造器
        Constructor<GoodWorker> declaredConstructor = clazz.getDeclaredConstructor(Boolean.class, String.class);
        declaredConstructor.setAccessible(true);
        GoodWorker zhangXueYou = declaredConstructor.newInstance(true,"ZhangXueYou");
        System.out.println(zhangXueYou.name);

        //获取对象（无参构造器）,常用
        GoodWorker goodWorker = clazz.newInstance();

        // 调用属性与设置
        Field name = clazz.getField("name");
        name.set(goodWorker,"ZhouJieLun");
        System.out.println(name.get(goodWorker));// 通过属性获取属性值

        Field age = clazz.getDeclaredField("age"); // 常用，可获取私有属性
        age.setAccessible(true); // 设置为可获取
        age.set(goodWorker,55);
        System.out.println(age.get(goodWorker));

        // 调用方法
        Method play = clazz.getDeclaredMethod("play",String.class);
        play.setAccessible(true);
        Object wangLiHong = play.invoke(goodWorker, "WangLiHong");
        System.out.println(wangLiHong);

        // 静态方法
        Method play1 = clazz.getDeclaredMethod("playStatic",String.class);
        play1.setAccessible(true);
        Object invoke = play1.invoke(null,"Dark Sky"); // null或者GoodWorker.class都可以，表示静态
        System.out.println(invoke);
    }
}
// 输出
ZhangXueYou
ZhouJieLun
55
ZhouJieLun is playing with WangLiHong
One worker is playing with Dark Sky

4、获取类的结构（详细）

package reflection;

import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.*;

public class ReflectionTest {
    @Test
    public void reflectTest() throws Exception {

        // 获取类的对象
        Class<GoodWorker> clazz = GoodWorker.class;

        /*
        * 1.获取运行时类的属性结构
        * */
        System.out.println("****获取本类及父类的public属性****");
        Field[] fields = clazz.getFields();
        for(Field field:fields){
            System.out.println(field);
        }

        System.out.println("****获取本类的所有属性****");
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field field:declaredFields) {
            System.out.println(field);
        }

        System.out.println("****获取本类属性的权限修饰符****");
        for (Field field:declaredFields) {
            // 获取变量名
            System.out.print(field.getName() + "--");

            // 获取权限修饰符
            int modifier = field.getModifiers();
            switch (modifier){
                case 0:
                    System.out.print(modifier+"--default");
                    break;
                case 1:
                    System.out.print(modifier+"--public");
                    break;
                case 2:
                    System.out.print(modifier+"--private");
                    break;
            }

            // 获取变量类型
            Class<?> type = field.getType();
            System.out.print("--"+type);

            System.out.println();
        }

        /*
         * 2.获取运行时类的方法结构
         * */
        System.out.println("****获取本类及父类的public方法****");
        Method[] methods = clazz.getMethods();
        for (Method m:methods){
            System.out.println(m);
        }

        System.out.println("****获取本类所有方法****");
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method m:declaredMethods){
            System.out.println(m);
        }

        System.out.println("****获取本类方法的权限修饰符****");
        for (Method m:declaredMethods) {
            // 获取方法名
            System.out.print(m.getName() + "--");

            // 获取权限修饰符
            int modifier = m.getModifiers();
            switch (modifier){
                case 0:
                    System.out.print(modifier+"--default");
                    break;
                case 1:
                    System.out.print(modifier+"--public");
                    break;
                case 2:
                    System.out.print(modifier+"--private");
                    break;
            }

            // 获取方法注解
            Annotation[] annotations = m.getAnnotations();
            for (Annotation a:annotations) {
                System.out.print(a);

            }

            // 获取方法返回值类型
            System.out.print("--"+m.getReturnType()+"--");

            // 获取形参类型列表
            Class<?>[] parameterTypes = m.getParameterTypes();
            System.out.print("(");
            for (Class c:parameterTypes) {
                System.out.print(c+",");
            }
            System.out.print(")--");

            // 方法抛出的异常
            Class<?>[] exceptionTypes = m.getExceptionTypes();
            for (Class e:exceptionTypes) {
                System.out.println(e.getName());
            }

            System.out.println();

            /*
             * 3.获取运行时类的构造器
             * */
            System.out.println("****获取本类的public构造器****");
            Constructor<?>[] constructors = clazz.getConstructors();
            for (Constructor c:constructors) {
                System.out.println(c);
            }
            System.out.println("****获取本类的构造器****");
            Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
            for (Constructor c:declaredConstructors) {
                System.out.println(c);
            }
            /*
             * 4.获取运行时类的父类
             * */
            System.out.println("****获取本类的父类****");
            Class superclass = clazz.getSuperclass();
            System.out.println(superclass);

            System.out.println("****获取本类带泛型的父类****");
            Type genericSuperclass = clazz.getGenericSuperclass();
            System.out.println(genericSuperclass);
            // 获取父类泛型类型
            ParameterizedType parameterizedType = (ParameterizedType)genericSuperclass;
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            for (Type t:actualTypeArguments) {
                System.out.println(t);
            }

            /*
             * 5.其他
             * */
            System.out.println("****获取运行时类实现的接口****");
            Class<?>[] interfaces = clazz.getInterfaces();
            System.out.println(interfaces[0]);

            System.out.println("****获取运行时类所在的包****");
            System.out.println(clazz.getPackage());

            Annotation[] annotations1 = clazz.getAnnotations();
            System.out.println(annotations1[0]);
        }
    }
}
// 输出：
****获取本类及父类的public属性****
public boolean reflection.GoodWorker.isMale
public java.lang.String reflection.Worker.name
****获取本类的所有属性****
private int reflection.GoodWorker.age
public boolean reflection.GoodWorker.isMale
java.lang.String reflection.GoodWorker.height
****获取本类属性的权限修饰符****
age--2--private--int
isMale--1--public--boolean
height--0--default--class java.lang.String
****获取本类及父类的public方法****
public int reflection.GoodWorker.compareTo(java.lang.Object)
public int reflection.GoodWorker.getAge()
public void reflection.GoodWorker.work(java.lang.String,java.lang.Boolean) throws java.lang.NoClassDefFoundError
public java.lang.String reflection.Worker.getId()
public void reflection.Worker.setId(java.lang.String)
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()
****获取本类所有方法****
public int reflection.GoodWorker.compareTo(java.lang.Object)
private java.lang.String reflection.GoodWorker.play(java.lang.String)
public int reflection.GoodWorker.getAge()
public void reflection.GoodWorker.work(java.lang.String,java.lang.Boolean) throws java.lang.NoClassDefFoundError
****获取本类方法的权限修饰符****
compareTo--1--public--int--(class java.lang.Object,)--
****获取本类的public构造器****
public reflection.GoodWorker(java.lang.String,int,java.lang.String)
****获取本类的构造器****
public reflection.GoodWorker(java.lang.String,int,java.lang.String)
private reflection.GoodWorker(java.lang.Boolean,java.lang.String)
****获取本类的父类****
class reflection.Worker
****获取本类带泛型的父类****
reflection.Worker<java.lang.String>
class java.lang.String
****获取运行时类实现的接口****
interface java.lang.Comparable
****获取运行时类所在的包****
package reflection
@reflection.TestAnnotation(value=myClass)
play--2--private--class java.lang.String--(class java.lang.String,)--
****获取本类的public构造器****
public reflection.GoodWorker(java.lang.String,int,java.lang.String)
****获取本类的构造器****
public reflection.GoodWorker(java.lang.String,int,java.lang.String)
private reflection.GoodWorker(java.lang.Boolean,java.lang.String)
****获取本类的父类****
class reflection.Worker
****获取本类带泛型的父类****
reflection.Worker<java.lang.String>
class java.lang.String
****获取运行时类实现的接口****
interface java.lang.Comparable
****获取运行时类所在的包****
package reflection
@reflection.TestAnnotation(value=myClass)
getAge--1--public--int--()--
****获取本类的public构造器****
public reflection.GoodWorker(java.lang.String,int,java.lang.String)
****获取本类的构造器****
public reflection.GoodWorker(java.lang.String,int,java.lang.String)
private reflection.GoodWorker(java.lang.Boolean,java.lang.String)
****获取本类的父类****
class reflection.Worker
****获取本类带泛型的父类****
reflection.Worker<java.lang.String>
class java.lang.String
****获取运行时类实现的接口****
interface java.lang.Comparable
****获取运行时类所在的包****
package reflection
@reflection.TestAnnotation(value=myClass)
work--1--public--void--(class java.lang.String,class java.lang.Boolean,)--java.lang.NoClassDefFoundError

****获取本类的public构造器****
public reflection.GoodWorker(java.lang.String,int,java.lang.String)
****获取本类的构造器****
public reflection.GoodWorker(java.lang.String,int,java.lang.String)
private reflection.GoodWorker(java.lang.Boolean,java.lang.String)
****获取本类的父类****
class reflection.Worker
****获取本类带泛型的父类****
reflection.Worker<java.lang.String>
class java.lang.String
****获取运行时类实现的接口****
interface java.lang.Comparable
****获取运行时类所在的包****
package reflection
@reflection.TestAnnotation(value=myClass)

5、用于测试的结构

1）worker类

package reflection;

public class Worker<T> {
    public String name = "defaultName";
    private String id;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Worker(String name) {
        this.name = name;
    }
}

2）TestAnnotation 注解

package reflection;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.CONSTRUCTOR,ElementType.FIELD,ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {
    String value() default "defaultValue";
}

3）GoodWorker类

package reflection;

@TestAnnotation("myClass")
class GoodWorker extends Worker<String> implements Comparable{

    @TestAnnotation
    private int age = 18 ;

    public boolean isMale;

    String height;

    public GoodWorker(String name, int age,String id) {
        super(id);
        this.name = name;
        this.age = age;
    }
    @TestAnnotation("myConstructor")
    private GoodWorker(Boolean isMale,String id) {
        super(id);
        this.isMale = isMale;
    }
    public void work(String time,Boolean isAlone) throws NoClassDefFoundError{
        System.out.println(name + "is working hardly in the " + time + isAlone);
    }
    public int getAge() {
        return age;
    }
    private String play(String with){
        return name + " is playing with " + with;
    }

    @Override
    public int compareTo(Object o) {
        return 0;
    }
}