[Java知识库]浅谈Java注解与反射

注解的作用

不是程序本身，可以对程序作出解释（这一点和注释一样），可以被其他程序（比如：编译器等）读取 通过反射读取。

注解格式：以“@注释名”在代码中存在，还可以添加一些参数值

定义注解的格式：

@interface Name{
}

注解使用地方：

可以附加在package，class，method，field等上面，相当于给他们添加了额外的辅助信息，可以通过反射机制编程实现对这些元数据的访问。

注解还有检查和约束的功能 约束代表注解的作用域 如果作用域在方法上就代表只能在方法上使用。

三个内置注解

@Override
重写的注解 具有检查和约束的功能 比如方法名的检查
@Deprecated
不推荐使用 但是可以使用 或许存在更好的方法
@SuppressWarnings(“all”)
镇压警告 该注解可以让警告不在显示 传入的参数代表镇压该方法的全部警告

元注解

作用：负责注解其他注解，Java定义了4个标准的meta-annotation类型，被用来提供对其他annotation类型作说明。
Retention：注解的有效时期
SOURCE（源码期）< CLASS （编译期) < RUNTIME（运行期）

//定义一个注解
//Target 表示我们的注解可以用在哪些地方 传入value数组 数组内的数据代表作用域的使用范围
@Target(value = {ElementType.TYPE, ElementType.METHOD})
//Retention  注解的有效时期
@Retention(value = RetentionPolicy.CLASS)
//表示是否将我们的注解生成在Java doc中
@Documented
//子类可以继承父类的注解
@Inherited
@interface MyAnnotation {

}

自定义注解

//自定义注解
public class Annotation3 {

    //注解可以显示赋值（有默认值也可以显示）  如果没有默认值 就需要给注解赋值
    @MyAnnotation1(name = "test",age = 0)
    public void test(){
    }

    //如果该注解内部只有一个参数并用value命名的话可以直接赋值
    @MyAnnotation2("keyl")
    public void test2(){}
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation1 {
    //不是方法 是参数
    //注解的参数 ： 参数类型 + 参数名();
    //default 给参数赋默认值
    String name() default "";
    int age() default  -1;
    //如果int类型的赋值为-1就代表不存在 indexof 如果找不到就返回-1

}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2 {
    String value();
    //如果只有一个参数的话通常用value表示
}

注解的参数 ： 参数类型 + 参数名（）；

如果该注解只有一个参数没有初始化赋值并且该注解的名字为value时 在使用该注解时可以直接赋值 其他的需要 注解名 = xxx 来赋值

注解没有初始化时使用一定要赋值

反射机制

• 动态语言 （Object-C，C#，JavaScript，PHP，Python）

是一类在运行时可以改变其结构的语言：例如新的函数，对象，甚至代码可以被引起，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。

• 静态语言（Java，C，C++）

与动态语言相对应的，运行时结构不可变的语言就是静态语言。

Java不是动态语言，但Java可以称为”准动态语言“，即Java有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。）

反射

Reflection（反射）是Java被视为动态语言的关键，它允许程序在执行期借助Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

Class c = Class.forName("java.lang.String")

加载完类之后，在堆内存的方法区就产生了一个Class对象，这个对象就包含了完整的类的结构信息。可以通过这个对象看到类的结构。Class类管理反射

反射方式：实例化对象 -> getClass()方法 -> 得到完整的”包类“名称

Java反射的优缺点

优点：实现动态创建对象和编译，体现出很大的灵活性

缺点：对性能有影响

获得Class类的方法

方法一：通过对象获得

Class c1 = p1.getClass();

方法二：forname获得

Class c2 = Class.forName("JavaDemo.Student");

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

Class c3 = Student.class;

方法四：基本类型的包装类都有一个Type属性

Class c4 = Integer.TYPE;

获取父类类型

Class c5 = c1.getSuperclass();

所有类型的Class

        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

类的初始化

主动引用（一定会发生类的初始化 ）

1. 当虚拟机启动，先初始化main方法所在的类
2. new一个类的对象
3. 调用类的静态成员（除了final常量）和静态方法
4. 使用java.lang.reflect包的方法对类进行反射调用
5. 当初始化一个类，如果其父类也没有被初始化，则会先初始化父类

被动引用 （不会发生类的初始化）

1. 引用常量类不会被初始化（常量在链接阶段就存入调用类的常量池中）
2. 通过数组定义类的引用 不会初始化该类
3. 访问静态域时，只有真正声明这个域的类才会被初始化

反射的基本操作

• 获取类的名字

        System.out.println(c1.getName());   //获得包名+类名
        System.out.println(c1.getSimpleName());  //获得类名

• 获取类的属性

        Field[] fields = c1.getFields();    //只能找到public属性的
        fields = c1.getDeclaredFields();    //找到全部的属性

        //获得指定属性的值
        Field name = c1.getDeclaredField("name");

• 获取类的方法

        Method[] m = c1.getMethods();      //获得本类及其父类的全部public方法
        m = c1.getDeclaredMethods();        //获得本类的所有方法

        //获得指定的方法
        //重载 有参数的需要传入参数  没有传入null
        Method m1 = c1.getMethod("getName",null);
        m1 = c1.getMethod("setName",String.class);

• 获取类的构造器

        Constructor[] c = c1.getConstructors(); //public类
        c = c1.getDeclaredConstructors();   //全部

        //获得指定构造器的方法
        Constructor c2 = c1.getConstructor(String.class, int.class);

• 获取注解信息的demo

        Class c1 = Class.forName("JavaDemo.Student2");

        //通过反射获得注解
        java.lang.annotation.Annotation[] annotations =  c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

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

        //获得类指定的注解
        Field f = c1.getDeclaredField("name");
        Fields tab1 = f.getAnnotation(Fields.class);
        System.out.println(tab1.Name());
        System.out.println(tab1.length());
        System.out.println(tab1.type());

@Tab("student")
class Student2{

    @Fields(Name = "db_id", type = "int", length = 10)
    private int id;
    @Fields(Name = "db_age", type = "int", length = 10)
    private int age;
    @Fields(Name = "db_name", type = "String", length = 20)
    private String name;

    public Student2() {
    }

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

    public int getId() {
        return id;
    }

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

    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;
    }

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

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

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Fields {
    String Name();
    String type();
    int length();
}