Java反射

package bean;

public class User {
    private String private_name;
    int default_age;
    protected String protected_address;
    public String public_sex;

    public User() {
    }

    public User(String name, int age, String address, String sex) {
        this.private_name = name;
        this.default_age = age;
        this.protected_address = address;
        this.public_sex = sex;
    }

    private void private_method(String msg){
        System.out.println("private_method"+msg);
    }

    void default_method(){
        System.out.println("default_method");
    }

    protected void protected_method(){
        System.out.println("protected_method");
    }

    public void public_method(){
        System.out.println("public_method");
    }


    @Override
    public String toString() {
        return "User{" +
                "private_name=‘" + private_name + ‘\‘‘ +
                ", default_age=" + default_age +
                ", protected_address=‘" + protected_address + ‘\‘‘ +
                ", public_sex=‘" + public_sex + ‘\‘‘ +
                ‘}‘;
    }
}

import bean.User;

import java.lang.reflect.*;

public class Test {
    public static void main(String[] args) {
        Class<?> clazz = null;

        try {
            System.out.println("########### Class 相关 ##############");
            clazz = Class.forName("bean.User");   // 获取Class对象方式一
            // clazz = User.class;                  // 获取Class对象方式二
            // User user = new User();
            // clazz = user.getClass();              // 获取Class对象方式三（Object类提供的getClass()）

            System.out.println(clazz.getClassLoader());  // 获取其类加载器
            System.out.println(clazz.getName());         // 获取类的全限定名
            System.out.println(clazz.getPackage());      // 获取类的包名
            System.out.println(clazz.getSimpleName());   // 获取类的简单名
            System.out.println(clazz.getSuperclass());   // 获取类的父类的全限定名

            Object obj = clazz.newInstance();    // 利用无参构造器实例化
            System.out.println(obj);

            System.out.println("########### Constructor 相关 ##############");
            Constructor<?> constructor = clazz.getConstructor(String.class,int.class,String.class,String.class);  // 获取指定参数类型的构造器
            Object obj1 = constructor.newInstance("jzx",25,"Nanjing","M"); // 利用有参构造器实例化
            System.out.println(obj1);

            System.out.println("########### Field 相关 ##############");
            Field field1 = clazz.getField("public_sex");  // 获取指定的public属性对象
            //Field field1 = clazz.getDeclaredField("private_name");  // 获取指定的属性对象
            User user1 = new User();
            //field1.setAccessible(true); // 忽略修饰符（暴力反射）,不然get不能访问private修饰的private_name属性
            // Method/Constructor也有setAccessible方法
            Object obj2 = field1.get(user1);  // 获取该属性的值给所属对象
            System.out.println(obj2);
            field1.set(user1,"F");            // 设置所属对象该属性的值
            System.out.println(user1);

            //Field[] field2 = clazz.getFields();   // 获取类中所有public修饰的属性
            Field[] field2 = clazz.getDeclaredFields();  // 获取类中所有的属性

            for(Field f : field2){
                System.out.println(f.getName());   // 获取属性变量名
                System.out.println(f.getModifiers()); // 获取访问权限修饰符的int值
                System.out.println(Modifier.toString(f.getModifiers())); // 将int值转换为访问权限修饰符,default是没有修饰符的
                Class type = f.getType();      // 获取属性类型的class对象
                System.out.println(type.getName());
            }

            System.out.println("########### Method 相关 ##############");
            Method method = clazz.getMethod("public_method"); // 获取指定名称，指定参数类型（无参则不写）的public方法
            //Method method = clazz.getDeclaredMethod("private_method", String.class); // 获取指定名称，指定参数类型的方法

            User user2 = new User();
            method.invoke(user2);    // 调用所属对象的该方法，对象名，参数类型（无参则不写）

            Method[] methods = clazz.getMethods();  // 获取所有public方法
            //Method[] methods = clazz.getMethods();  // 获取所有方法

        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}