反射常用API

1.Field类

package com.hspedu;

import java.lang.reflect.Field;


public class Car {
    public String brand = "宝马";//品牌
    public int price = 500000;
    public String color = "白色";

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + ''' +
                ", price=" + price +
                ", color='" + color + ''' +
                '}';
    }
}
class v{
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, InstantiationException {
        Class carClass = Car.class;
        Car car = carClass.newInstance();
        Field field = carClass.getField("brand");
        Field field2 = carClass.getField("price");

        //getType();以Class的形式返回类型
        Class type = field.getType();
        System.out.println(type);//class java.lang.String,只是返回数据类型
        Class type1 = field2.getType();
        System.out.println(type1);//int

        //返回属性名getName()
        String name = field.getName();
        System.out.println(field.getName());//brand

        //getModifiers();以数字形式返回属性的修饰符
        int modifiers = field.getModifiers();
        System.out.println(modifiers);//1

        // toString();返回属性的总体情况：public String brand
        // public java.lang.String com.hspedu.Car.brand
        //getType();只是返回数据类型
        System.out.println(field2.toString());//public int com.hspedu.Car.price

        //get(car);返回属性的值，需要传入参数对象，注意区分返回属性名getName()
        Object o2 = field.get(car);
        System.out.println(o2);//宝马
        Object o1 = field2.get(car);
        System.out.println(o1.getClass());//class java.lang.Integer


    }
}


import org.junit.Test;
import org.omg.CORBA.PERSIST_STORE;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

@selfTest2("selfTest2注解")
@selfTest(value = "aaa", t = "selfTest接口的属性值", a = 10)
class Person implements A,B{
    public String name;
    protected String username;
    String home;
    private int age;

    public Person(){}

    public Person(String name, String username, String home, int age) {
        this.name = name;
        this.username = username;
        this.home = home;
        this.age = age;
    }
    private Person(String name, String username, String home) {
        this.name = name;
        this.username = username;
        this.home = home;
    }
    Person(String name, String username) {
        this.name = name;
        this.username = username;

    }
//    private Person(String name, String username, String home, int age) {
//        this.name = name;
//        this.username = username;
//        this.home = home;
//        this.age = age;
//    }
    public String say(){
        return "hello world.";
    }

    public void eat(String s){
        System.out.println(s);
    }


    public void a() {
        System.out.println("接口aaaa");
    }

    public String b() {
        return "接口bbb";
    }

    public int c() {
        return 'c';
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + ''' +
                ", username='" + username + ''' +
                ", home='" + home + ''' +
                ", age=" + age +
                '}';
    }
}
interface A{
    String name = "AAAA";
    void a();
}
class Student extends Person {
    public String grade;
    protected String username;
    String school;
    private int phone;

    public Student(){}
    public Student(String grade){
        this.grade = grade;
    }

    public void study(){
        System.out.println("学生学习");

    }

}
interface B extends C{
    String bname = "bbb";
    int bint = 20;
    String b();
}
interface C{
    String cname = "ccc";
    int  cage = 30;
    int c();
}
class MTest{
    public static void main(String[] args) {
        //获取接口B的Class对象
        Class bClass = B.class;
        Field[] declaredFields = bClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        //控制台输出如下，和类的Class对象相同
        //getDeclaredFields();获取本类所有public的属性，不包含父类（接口）的
        //public static final java.lang.String B.bname
        //public static final int B.bint

        Field[] fields = bClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        //getFields();本类和父类的所有public的属性，不包含父类（接口）的
        //public static final java.lang.String B.bname
        //public static final int B.bint
        //public static final java.lang.String C.cname
        //public static final int C.cage

        //1.获取Person类的Class对象
        Class personClass = Person.class;
        //2.获取注解getAnnotation(Class annotationClass)，参数为所需注解的Class类型
        selfTest annotation1 = personClass.getAnnotation(selfTest.class);
        //3.得到注解的属性
        String t = annotation1.t();
        int a = annotation1.a();
        System.out.println(a);//10
        System.out.println(t);//bbb
        Annotation[] annotations = personClass.getAnnotations();

        //
        //

//        Class aClass = A.class;
//        Field[] fields = aClass.getFields();
//        for (Field field : fields) {
//            System.out.println(field.getName());
//        }
//        Constructor[] constructors = aClass.getDeclaredConstructors();
//        for (Constructor constructor : constructors) {
//            System.out.println(constructor);
//        }

    }


}
public class ClassTest {
    @Test
    public void getAnnotation() {
        //通过反射获取类的指定注解
        //1.获取类的Class对象
        Class personClass = Person.class;
        //2.getAnnotation(selfTest.class);获取接口对象
        selfTest annotation = personClass.getAnnotation(selfTest.class);
        //3. annotation.t();接口对象.属性
        String t = annotation.t();
        System.out.println(t);//selfTest接口的属性值

        //通过反射获取类的所有注解
        Annotation[] annotations = personClass.getAnnotations();
        //@selfTest2(value=selfTest2注解)
        //@selfTest(value=[aaa], t=selfTest接口的属性值, a=10)
        for (Annotation annotation1 : annotations) {
            System.out.println(annotation1);
        }
    }

    @Test
    public void getInterface() {
        Class personClass = Person.class;
        //getInterfaces();获取类上所有接口，不包括接口的父接口
        Class[] interfaces = personClass.getInterfaces();
        //interface A
        //interface B
        for (Class anInterface : interfaces) {
            System.out.println(anInterface);
        }
    }

    @Test
    public void getConstructors() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class personClass = Person.class;
        //1.getConstructor(Class... parameterTypes),
        // 获取构造器参数为 参数.class
        //只能掉public的，其余三种不能调用，否则报错NoSuchMethodException
        Constructor constructor = personClass.getConstructor(String.class, String.class, String.class, int.class);
        Person person = constructor.newInstance("ni", "hao", "a", 56);
        System.out.println(person);//Person{name='ni', username='hao', home='a', age=56}
        //2.getConstructor(),无参构造方法
        // newInstance();方法无参数，是调用无参构造，所以Bean一般必须提供无参构造
        Constructor constructor1 = personClass.getConstructor();
        Person person1 = constructor1.newInstance();
        System.out.println(person1);//Person{name='null', username='null', home='null', age=0}

        //3.getDeclaredConstructor(Class... parameterTypes)
        //可以根据参数来获取相应的构造器，四种修饰符的无参，有参构造器
        Constructor declaredConstructor1 = personClass.getDeclaredConstructor();

        //4.getConstructors() 不含私有构造方法，只有public的
        //public Person(java.lang.String,java.lang.String,java.lang.String,int)
        //public Person()
        Constructor[] constructors = personClass.getConstructors();
        for (Constructor constructor2 : constructors) {
            System.out.println(constructor2);
        }

        //5.getDeclaredConstructors() 本类的(不含父类，与Method不同)所有的构造方法
        // Person(java.lang.String,java.lang.String)
        //private Person(java.lang.String,java.lang.String,java.lang.String)
        //public Person(java.lang.String,java.lang.String,java.lang.String,int)
        //public Person()
        Constructor[] declaredConstructor = personClass.getDeclaredConstructors();
        for (Constructor constructor2 : declaredConstructor) {
            System.out.println(constructor2);
        }

        //Class[]   getParameterTypes();有参构造器获取构造器参数类型
        Class[] parameterTypes = constructor.getParameterTypes();
        for (Class parameterType : parameterTypes) {
            System.out.println(parameterType.getName());
        }
        //getName();和toString相比前边没有class
        //java.lang.String
        //java.lang.String
        //java.lang.String
        //int
        // class java.lang.String
        // class java.lang.String
        // class java.lang.String
        // int
    }

    @Test
    public void getMethod() {
        Class personClass = Person.class;
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
//        public java.lang.String Person.toString()
//        public int Person.c()
//        public void Person.a()
//        public java.lang.String Person.b()
//        public java.lang.String Person.say()
//        public void Person.eat(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 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()
    }

    @Test
    public void getFeild() {
        Class personClass = Person.class;
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        System.out.println(personClass);
    }

    @Test
    public void getFeildStudent() {
        Class studentClass = Student.class;
        Field[] declaredFields = studentClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }//本类所有属性
        //public java.lang.String Student.grade
        //protected java.lang.String Student.username
        //java.lang.String Student.school
        //private int Student.phone

        Field[] declaredField = studentClass.getFields();
        for (Field field : declaredField) {
            System.out.println(field);
        }
        //本类及父类所有public属性以及接口的所有属性，接口的传递性
//        public java.lang.String Student.grade
//public static final java.lang.String A.name
//public static final java.lang.String B.bname
//public static final int B.bint
//public static final java.lang.String C.cname
//public static final int C.cage
//public java.lang.String Person.name

    }
}