Java 注解与反射

本文是学习秦疆的注解和反射做的笔记，主要用于后续复习。

一、Annotatio（注解）

     1.注解入门

 Annotation作用： 可以被其他程序读取

Annotation的格式： @注释名（参数）

Annotation在哪里使用：可以附加在package，class，method，field 上面通过反射机制编程实现对这些元素的访问

     2.内置注解

@Override：表示一个方法打算重写超类中的另一个方法声明

@Deprecated：可修饰方法、属性、类 通常表示被修饰对象已过时

@SuppressWarnings：用来抑制编译时的警告信息

     3.自定义注解 + 元注解

元注解：基本注解类型

@Target：用于描述注解可用在哪些范围

@Retention：表示注解的生命周期（.java -> .class -> 运行jvm）

@Document：该注解被包含在javadoc中

@Inherited：子类是否可以继承父类中的注解

自定义注解：使用@interface自定义注解

例子：

    //注解可以显示赋值， 如果没有默认值default，我们必须给注解赋值
    @Myannotation2(name="fsz",schools={"电子科大"})
    public void text(){

    }

    @Myannotation3("123")
    public void text4(){

    }

}



@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface Myannotation2{
    //注解的参数： 参数类型+参数名+（）;
    String name();
    int age() default 0;
    int id() default -1; // 如果默认值为-1，代表不存在；

    String[] schools() default {"电子科技大学","清华大学"};
}

二、反射

    1.反射的功能

     2.反射对象的特征

     3.反射对象的方法

      4.获取反射对象方式

方式一：通过已有的类的对象获取

方式二：通过Class.forname获得

方式三：通过类名.class获得

  //方式一：通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1);

        //方式二：forname获得
        Class c2 = Class.forName("org.example.Student");
        System.out.println(c2.hashCode());

        //方式三：通过类名.class获得
        Class c3 = Student.class;
        System.out.println(c3.hashCode());

     

         5.哪些类具有反射对象

   

代码实例：

public static void main(String[] args) {
        Class c1 = Object.class; // 类
        Class c2 = Comparable.class;// 接口
        Class c3 = String[].class;// 一维数组
        Class c4 = int[][].class;// 二维数组
        Class c5 = Override.class;// 注解
        Class c6= ElementType.class;// 枚举
        Class c7 = Integer.class;// 基本数据类型
        Class c8 = void.class;// void
        Class c9 = Class.class; // Class

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);

        //只要元素类型与维度一样， 就是同一个class
        int[] a = new int[10];
        int[] b = new int[100];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());

             6.通过反射获取类的（名字-属性-方法-构造器）

//获取反射对象
        Class c1 = Class.forName("org.example.User");

        //获取反射对象类的名字
        System.out.println(c1.getName()); // 包名+类名
        System.out.println(c1.getSimpleName()); // 类名

        //获取反射对象类的属性
        System.out.println("-----------------");
        Field[] fields = c1.getFields(); //获取public的属性
        Field[] fields1 = c1.getDeclaredFields();//获取全部属性
        for(Field e : fields1){
            System.out.println(e);
        }

        //获得类指定属性
        //Field name = c1.getField("name");// 获取指定的public属性
        Field name1 = c1.getDeclaredField("name");// 获取指定的属性
        System.out.println(name1);


        //获得类的方法
        System.out.println("-----------------");
        Method[] methods = c1.getMethods(); // 获得本类及其父类的全部public方法
        Method[] methods1 = c1.getDeclaredMethods();//获得本类的方法

        for(Method m : methods){
            System.out.println("m:"+m);
        }

        for(Method m1 : methods1){
            System.out.println("m1:"+m1);
        }

        //获得类的指定方法
        //需要指定参数（重载）
        Method getName = c1.getMethod("getName",null);
        Method setName = c1.getMethod("setName",String.class);
        System.out.println(getName);
        System.out.println(setName);


        //获得指定的方法
        System.out.println("-----------------");
        Constructor[] constructors = c1.getConstructors(); //获得指定的构造方法
        for(Constructor e: constructors){
            System.out.println("constructors"+e);
        }

        Constructor[] constructors1 = c1.getConstructors(); //获得所有的构造方法
        for(Constructor e: constructors1){
            System.out.println("constructors1" + e);
        }

        //获得指定的构造器
        Constructor cone = c1.getDeclaredConstructor(String.class, int.class, int.class);
        System.out.println(cone);

                7.通过反射动态创建对象及操作

 public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class c1 = Class.forName("org.example.User");

        //构造一个对象
        User user = (User)c1.newInstance(); // 需要无参构造器，否则报错。
        System.out.println(user);

        //通过构造器创建一个对象
        Constructor con = c1.getDeclaredConstructor(String.class, int.class, int.class);
        User fsz = (User)con.newInstance("fsz", 001, 18);
        System.out.println(fsz);


        //通过反射操作对象一个方法
        User user1 =(User)c1.newInstance();
        Method setName = c1.getDeclaredMethod("setName", String.class);
        setName.invoke(user1, "fangsheng"); // 激活方法，需要方法的对象，和方法的参数。
        System.out.println(user1.getName());

        //通过反射操作对象一个属性
        System.out.println("-----------------");
        User user2 = (User)c1.newInstance();
        Field name = c1.getDeclaredField("name");
        name.setAccessible(true); //不能直接操作私有属性，需要关闭安全检测 设置为true
        name.set(user2,"范神");
        System.out.println(user2.getName()); //会报错因为getname是私有方法，需要关闭检查
    }

                 8.通过反射操作注解

public class Text08 {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("org.example.Student2");

        //通过反射获得注解
        Annotation[] a1 = c1.getAnnotations();

        for(Annotation e : a1){
            System.out.println(e);
        }

        //获得注解的value的值
        Table t1 = (Table)c1.getAnnotation(Table.class);
        String value = t1.value();
        System.out.println(value);

        //获得类指定的注解 （先获得对应的属性在通过vlaue得到）
         Field f = c1.getDeclaredField("id");
         Field1 annotation = f.getAnnotation(Field1.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());
    }
}

@Table("db_student")
class Student2{
    @Field1(columnName = "db_id",type = "int", length = 10)
    private int id;
    @Field1(columnName = "db_age",type = "int", length = 10)
    private int age;
    @Field1(columnName = "db_name",type = "String", length = 3)
    private String name;

    public Student2(){}

    public Student2(int id,int age,String name){
        this.id = id;
        this.age = age;
        this.name = name;
    }

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

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

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

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

    public int getId() {
        return id;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }
}

//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table{
    String value();
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Field1{
    String columnName();
    String type();
    int length();
}