java反射

java反射初了解

写一个Star类里面防属性，构造方法和get，set方法

public class Star extends Object implements Serializable {
    private int  age;
    public String name;
    private String city;

    private Star(int age, String name){
        this.age = age;
        this.name = name;
    }
    public Star(){}

    public Star(int age, String name, String city) {
        this.age = age;
        this.name = name;
        this.city = city;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    @Override
    public String toString() {
        return "Star{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", city='" + city + '\'' +
                '}';
    }
}

获取star类里面的全部信息，private修饰的也可以获取

public class StarTest {
    public static void main(String[] args) throws Exception {
        Class<?> star = Class.forName("com.w0812.Star");
        //获取包名
        System.out.println(star.getPackage().getName());
        //获取类的修饰符
        System.out.println(Modifier.toString(star.getModifiers()));
        //判断类的修饰符是否被public修饰
        System.out.println(Modifier.isPublic(star.getModifiers()));
        //判断类的修饰符是否被abstract修饰
        System.out.println(Modifier.isAbstract(star.getModifiers()));
        //判断类的修饰符是否被final修饰
        System.out.println(Modifier.isFinal(star.getModifiers()));
        //获取star的父类
        Class<?> superclass = star.getSuperclass();
        System.out.println(superclass);
        System.out.println("------------------------");
       //获取public修饰的属性
        Field[] fields = star.getFields();
        for (Field f:fields){
            System.out.println(f.getName());
            //获取属性类型
            Class<?> type = f.getType();
            System.out.println(type);
            //获取修饰符
            System.out.println(Modifier.toString(f.getModifiers()));
        }
        System.out.println("------------------------");
        //获取全部属性
        Field[] declaredFields = star.getDeclaredFields();
        for (Field d:declaredFields){
            //属性名字
            System.out.println(d.getName());
            int modifiers = d.getModifiers();
            //属性修饰符
            System.out.println(Modifier.toString(modifiers));
            //属性类型
            System.out.println(d.getType());
        }
        System.out.println("-------------------------");
        //获取公开的构造方法
        Constructor<?>[] constructors = star.getConstructors();
        for (Constructor c:constructors){
            //获取构造方法名字
            System.out.println(c.getName());
            //获取构造方法的修饰符
            System.out.println(Modifier.toString(c.getModifiers()));
            //获取获取构造器的形参
            Class[] parameterTypes = c.getParameterTypes();
            for (Class p:parameterTypes){
                //获取形参的类型
                System.out.println(p.getName());
            }
        }
        System.out.println("--------------------");
        //获取所有类型的构造方法
        Constructor<?>[] declaredConstructors = star.getDeclaredConstructors();
        for (Constructor dc:declaredConstructors){
            System.out.println(dc.getName());
            int modifiers = dc.getModifiers();
            //获取所有构造方法的修饰符
            System.out.println(Modifier.toString(modifiers));
            //获取所有构造器的形参
            Class[] parameterTypes = dc.getParameterTypes();
            //获取所有构造器的形参类型
            for (Class p:parameterTypes){
                System.out.println(p.getName());
            }
        }
        System.out.println("---------------------------");
        //获取指定构造函数
        Constructor<?> constructor = star.getConstructor(int.class, String.class,String.class);
        System.out.println(constructor);
        //获取私有的构造函数
        Constructor<?> declaredConstructor = star.getDeclaredConstructor(int.class, String.class);
        System.out.println(declaredConstructor);
        System.out.println("------------------------------");
        //获取该类及其父类的public方法，但不能获取到私有方法
        Method[] methods = star.getMethods();
        for (Method m:methods){
            System.out.println(m);
            //获取方法名
            System.out.println(m.getName());
            //获取方法名的修饰符
            int modifiers = m.getModifiers();
            System.out.println(Modifier.toString(modifiers));
            //获取方法名的返回值
            Class<?> returnType = m.getReturnType();
            System.out.println(returnType);
            //方法的形参
            Class<?>[] parameterTypes = m.getParameterTypes();
            for (Class p:parameterTypes){
                System.out.println("形参"+p);
            }
        }
        System.out.println("-------------------------------");
        //获取本类所申明的所有方法
        Method[] declaredMethods = star.getDeclaredMethods();
        for (Method dc:declaredMethods){
            System.out.println(dc);
            //方法名
            System.out.println(dc.getName());
            //方法名的修饰符
            int modifiers = dc.getModifiers();
            System.out.println(Modifier.toString(modifiers));
            Class<?> returnType = dc.getReturnType();
            //方法名的返回值类型
            System.out.println(returnType);
            //读取方法的输出类型
            Class<?>[] parameterTypes = dc.getParameterTypes();
            for (Class p:parameterTypes){
                System.out.println("类型"+p);
            }
        }
        System.out.println("------------------------");
    }
}