反射 获取类的结构信息 创建对象 访问

一 通过反射获取类的结构信息的方法

测试类

@Deprecated
public class Cat extends Dog implements AA, BB {
    public String name;
    private String eat;
    public static int age;

    public void c1(String s) {
        System.out.println("c1" + s);
    }

    public static void c3(String name, String eat) {
        System.out.println("c3"+name + eat);
    }

    private void c2() {
    }
    public Date c4() {
        return new Date();
    }
    public Cat() {
    }

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

    private Cat(String name, String eat) {
        this.name = name;
        this.eat = eat;
    }

}

class Dog {
    public String username;
    private String good;

    public void d1() {
    }

    private void d2() {
    }


}

interface AA {
}

interface BB {
}

1. 第一组: java.lang.Class 类

/**
 * 获取类的结构信息,java.lang.Class
 */
public class ReflectionUtils {

    public static void main(String[] args) {
        Class<Cat> als = Cat.class;
        //1,获取全类名
        System.out.println("全类名=" + als.getName());
        //2，获取简单的类名
        System.out.println("简单的类名=" + als.getSimpleName());
        //3,获取所有public修饰的属性，包含本类及其父类
        System.out.println("=====public属性=======");
        for (Field field : als.getFields()) {
            System.out.println(field);
        }

        //4，获取本类中的所有属性
        System.out.println("=====本类中所有属性=======");
        Field[] fields = als.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        //5，获取所有public修饰的方法，包含本类以及父类
        System.out.println("=====本类以及父类public修饰的方法=======");
        Method[] methods = als.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        //6，获取本类中的所有方法
        System.out.println("=====本类所有方法=======");
        for (Method declaredMethod : als.getDeclaredMethods()) {
            System.out.println(declaredMethod);
        }

        //7，获取本类所有public修饰的构造器
        System.out.println("=====本类所有public修饰的构造器=======");
        for (Constructor<?> constructor : als.getConstructors()) {
            System.out.println(constructor);
        }
        //8，获取本类所有的构造器
        System.out.println("=====本类所有的构造器=======");
        for (Constructor<?> declaredConstructor : als.getDeclaredConstructors()) {
            System.out.println(declaredConstructor);
        }
        //9,包信息
        System.out.println("包信息=" + als.getPackage());
        //10,父类信息
        System.out.println("父类信息=" + als.getSuperclass());
        //11,接口信息
        System.out.println("=====接口信息=======");
        Class<?>[] interfaces = als.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println(anInterface);
        }
        //12，注解信息
        System.out.println("=====注解信息=======");
        Annotation[] annotations = als.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
    }
}

2. 第二组: java.lang.reflect.Field 类

@Test
//获取本类中所有属性getDeclaredFields
public void FieldsTest() {
    Class<Cat> acl = Cat.class;
    for (Field declaredField : acl.getDeclaredFields()) {
        System.out.println("属性名=" + declaredField.getName() +
                "修饰符=" + declaredField.getModifiers() +
                "类型=" + declaredField.getType());
    }
}

3. 第三组: java.lang.reflect.Method 类

@Test
//获取本类中所有方法getDeclaredMethods
public void MethodsTest() {
    Class<Cat> acl = Cat.class;
    for (Method declaredMethod : acl.getDeclaredMethods()) {
        System.out.println("方法名=" + declaredMethod.getName() +
                "\t修饰符=" + declaredMethod.getModifiers() +
                "\t类型=" + declaredMethod.getReturnType());

        //返回参数类型数组
        Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
        for (Class<?> parameterType : parameterTypes) {
            System.out.println("返回参数类型数组=" + parameterType);
        }

    }


}

4. 第四组: java.lang.reflect.Constructor 类

@Test
//getDeclaredConstructors:获取本类中所有构造器
public void ConstructorsTest() {
    Class<Cat> acl = Cat.class;
    for (Constructor<?> constructor : acl.getDeclaredConstructors()) {
        System.out.println("方法名=" + constructor.getName() +
                "\t修饰符=" + constructor.getModifiers());
        for (Class<?> parameterType : constructor.getParameterTypes()) {
            System.out.println("参数类型="+parameterType);
        }

    }

二 通过反射创建对象

/**
 * 通过反射创建对象
 */
@Test
public void ReflectionCreateInstance() throws InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
    Class<Cat> acl = Cat.class;
    //调用类中的无参构造器
    Cat cat = acl.newInstance();
    System.out.println(cat);
   //调用类中的指定构造器
      // 1.先得到对应构造器
    Constructor<Cat> constructor = acl.getConstructor(String.class);
      //2.创建建实例，并传入实参
    Cat cat1 = constructor.newInstance("wyk");
    System.out.println(cat1);
      //3.根据多个参数列表，创建对象
    Constructor<Cat> constructors = acl.getDeclaredConstructor(String.class, String.class);
    //使用反射可以访问 private 构造器/方法/属性
    constructors.setAccessible(true);
    Cat cat2 = constructors.newInstance("王", "肉");
    System.out.println(cat2);

}

三 通过反射访问类中的成员

1.访问属性

/**
 * 通过反射获取类中属性
 *
 */
@Test
public void ReflecAccessProperty() throws InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
    Class<Cat> acl = Cat.class;
    //创建对象实例
    Cat cat = acl.newInstance();
    //1,使用反射操作public属性
    Field name = acl.getDeclaredField("name");
    name.set(cat,"你是");
    System.out.println(name.get(cat));
    //2,使用反射操作private属性
    Field eat = acl.getDeclaredField("eat");
    //eat进行爆破操作private属性
    eat.setAccessible(true);
    eat.set(cat,"肉");
    System.out.println(eat.get(cat));
    //3,操作static静态属性，对象可以写成null
    Field age = acl.getDeclaredField("age");
    age.set(null,12);
    System.out.println(age.get(null));

}

2.访问方法

 /**
     * 通过反射获取类中方法
     *
     */
    @Test
    public void ReflecAccessMethod() throws InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class<Cat> acl = Cat.class;
        Cat cat = acl.newInstance();
        //得到public方法
//        Method c1 = acl.getMethod("c1",String.class);
//        System.out.println(c1);
        //1，得到public 对象方法
        Method c11 = acl.getDeclaredMethod("c1",String.class);
        //调用方法
       c11.invoke(cat,"你好");
     //2，调用 private static 方法，需要爆破，可以传nll对象
        Method c3 = acl.getDeclaredMethod("c3", String.class, String.class);
        c3.setAccessible(true);
      //  c3.invoke(cat,"你是","好人");
        c3.invoke(null,"你是","好人");
      //3，有返回值方法
        Method c4 = acl.getDeclaredMethod("c4");
        Object invoke = c4.invoke(cat);
        System.out.println(invoke.getClass()); //运行类型class java.util.Date
    }
3.setAccessible(true);
      //  c3.invoke(cat,"你是","好人");
        c3.invoke(null,"你是","好人");
      //3，有返回值方法
        Method c4 = acl.getDeclaredMethod("c4");
        Object invoke = c4.invoke(cat);
        System.out.println(invoke.getClass()); //运行类型class java.util.Date
    }