一、什么是注解?

Annotation是从JDK5.0开始引入的新技术。

Annotation的作用：可以被其他程序(如：编译器等)读取。

Annotation的格式：注解是以”@注释名”在代码中存在的，还可以添加一些参数值，如：@SuppressWarnings(value=”uncheched”) 作用：用于抑制编译器产生警告信息。

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

二、内置注解

@Override：定义在java.lang.Override中，此注释只适用修辞方法，表示一个方法声明打算重写超类中的另一个方法声明。
@Deprecated：定义在java.lang.Deprecated中，此注释可以用于修辞方法，属性，类，表示不鼓励程序员使用此元素。

jdk1.8的文档下载：传送

@SuppressWarnings:定义在java.lang.SuppressWarnings中，用来抑制编译时的警告信息。

与前两个注释有所不同，你需要添加一个参数才能正确使用，这些参数都是已经定义好的。
@SuppressWarnings(“all”) // 抑制所有类型的警告
@SuppressWarnings(“unchecked”) // 抑制单类型的警告
@SuppressWarnings(“value={“unchecked”,”deprecation”}”) // 抑制多类型的警告

二、元注解

元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他annotation类型作用说明。

@Target：用于描述注解的使用范围。
@Retention：表示要在什么级别保存改注释信息（SOURCE(源码级别) < CLASS(类级别) < RUNTIME(运行时)）
@Document：说明该注解将包含在javadoc中。
@Inherited：说明子类可以继承父类中的该注解。

三、自定义注解

使用@Interface自定义注解时，自动继承了java.lang.anntation.Annotation接口

import java.lang.annotation.*;

/**
 * @ClassName: Test02
 * @Description: 测试元注解
 * @author: xiaofei
 */
@MyAnnotation
public class Test02 {

    @MyAnnotation
    public void test() {
    }

}

// 定义一个注解
// 表示我们的注解可以使用在那些地方
@Target(value = {ElementType.METHOD, ElementType.TYPE})

// 表示我们的注解在什么地方有效
// runtime>class>sources
@Retention(value = RetentionPolicy.RUNTIME)

// 表示是否将我们注解生成在Javadoc中
@Documented

// 表示子类可以继承父类注解
@Inherited
@interface MyAnnotation {
}

四、反射机制

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

反射的优缺点：

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

缺点：
对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。

Class类的常用方法:

获取Class类的实例:

若已知具体的类，通过类的class属性获取，改方法最为安全可靠。

Class clazz = Person.class;

若已知某个类的实例，调用改实例的getClass()方法获取Class对象。

Class clazz = person.getClass();

若已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取。

Class clazz = Class.forName("demo01.Student")

内置基本数据类型可以直接用类名.Type，还可以利用ClassLoader。

/**
 * @ClassName: Test02
 * @Description: 测试class类的创建方式有哪些?
 * @author: xiaofei
 */
public class Test02 {

    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println(person.name);

        // 1、通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1.hashCode());

        // 2、forname获得
        Class c2 = Class.forName("com.xffjs.reflection.Student");
        System.out.println(c2.hashCode());

        // 3、通过类名.class获得
        Class<Student> c3 = Student.class;
        System.out.println(c3.hashCode());

        // 4、通过Type属性
        Class c4 = Integer.TYPE;
        System.out.println(c4);

        // 获得父类类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);

    }
}

class Person {
    String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

class Student extends Person {
    public Student() {
        this.name = "学生";
    }
}

class Teacher extends Person {
    public Teacher() {
        this.name = "老师";
    }
}

类的加载与ClassLoader的理解

加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表类的java.lang.Class
对象。

链接：将Java类的二进制代码合并到JVM的运行状态之中的过程。

初始化：

类的初始化

类的主动引用（会初始化）:

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

双亲委派： 我们自定义的类通过类加载器实例化对象时，类加载会向上查找父类加载器所在的类对象。如果我们自定义的类与父类加载器所加载的类的类对象一致，则会报错。这样设计的好处就是从一定程度上防止了危险代码的植入。

获取类的信息

public class Test07 {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("com.xffjs.reflection.User");

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

        // 获得类的属性--只能找到public属性
        Field[] fields = c1.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        System.out.println("-------------------");

        Field[] declaredFields = c1.getDeclaredFields();
        for (Field field : declaredFields) {
            System.out.println(field);
        }

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

        System.out.println("========获取类的方法========");

        // 获得类的方法---获得本类及其父类的全部方法
        Method[] methods1 = c1.getMethods();
        for (Method method : methods1) {
            System.out.println(method);
        }

        System.out.println("-------------------");

        // 获得类的方法---获得本类方法
        Method[] methods2 = c1.getDeclaredMethods();
        for (Method method : methods2) {
            System.out.println(method);
        }

        System.out.println("========获取指定方法========");

        // 获取指定方法
        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();
        Constructor[] constructors2 = c1.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        System.out.println("-------------------");

        for (Constructor constructor : constructors2) {
            System.out.println(constructor);
        }

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

    }

}

有了Class对象可以做什么？

创建类的对象：调用Class对象的newInstance()方法

调用指定的方法

通过反射，调用类中的方法，通过Method类完成。

1、通过Class类的getMethod(String name, Class… parameterTypes)方法取得一个Method对象，并设置此方法操作时需要的参数类型。
2、之后使用Object invoke(Object obj, Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息。

Object invoke(Object obj, Object[] args)：

1、Object对应原方法的返回值，若原方法无返回值，此时返回null。
2、若原方法若为静态方法，此时形参Object obj为null。
3、若原方法参数列表为空，则Object[] args为null。
4、若原方法声明为private，则需要调用此invoke()方法之前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。

// 获得Class对象
Class<?> c1 = Class.forName("com.xffjs.reflection.User");
// 通过反射调用普通方法
User user3 = (User) c1.newInstance();
// 通过反射获取一个方法
Method setName = c1.getDeclaredMethod("test", String.class);
// 不能直接操作私有属性，需要关闭安全监测
setName.setAccessible(true);
// invoke()参数：对象，方法值
setName.invoke(user3, "小飞");
System.out.println(user3.getName());

setAccessible：

Method和Field、Constructor对象都有setAccessible()方法。
setAccessible作用是启用和禁用访问安全检查的开关；
参数值为true则指示反射的对象在使用时应该取消Java语言访问检查。

反射操作泛型

public class Test10 {

    public void test01(Map<String, User> map, List<User> list) {
        System.out.println("test01");
    }

    public Map<String, User> test02() {
        System.out.println("test02");
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {
        Method method = Test10.class.getMethod("test01", Map.class, List.class);
        // 获取泛型的参数类型
        Type[] genericParameterTypes = method.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println(genericParameterType);
            // 判断泛型参数类型是否一个参数化类型
            if (genericParameterType instanceof ParameterizedType) {
                // 获取泛型的参数信息
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }

        System.out.println("****************************");

        method = Test10.class.getMethod("test02");
        Type genericReturnType = method.getGenericReturnType();
        if (genericReturnType instanceof ParameterizedType) {
            // 获取泛型的参数信息
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }
}

反射操作注解

public class Test11 {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("com.xffjs.reflection.Student2");
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotatedInterface : annotations) {
            System.out.println(annotatedInterface);
        }

        // 获取注解value的值
        Tablexf tablexf = (Tablexf) c1.getAnnotation(Tablexf.class);
        String value = tablexf.value();
        System.out.println(value);

        // 获取类指定的注解
        Field f = c1.getDeclaredField("id");
        Fieldxf annotation = f.getAnnotation(Fieldxf.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());

    }
}

@Tablexf("db_student")
class Student2 {

    @Fieldxf(columnName = "db_id", type = "int", length = 10)
    private int id;
    @Fieldxf(columnName = "db_name", type = "varchar", length = 3)
    private String name;

    public Student2() {
    }

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

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

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


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

// 属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Fieldxf {
    String columnName();

    String type();

    int length();
}