02.java的注解以及反射

一.注解

1.1.什么是注解

1.注解从jdk1.5引入
2.可以对程序进行解释和被其他程序读取
3.注解就是以@注释名方式出现的，还能带value参数
4.注解可以在哪使用:注解可以用在package.class,method,field上使用,相当于添加了额外的辅助信息，可以通过反射机制编程实现对元数据的访问

1.2.java的内置注解

• @Deprecated 已过期，表示方法是不被建议使用的
• @Override 重写，标识覆盖它的父类的方法
• @SuppressWarnings 压制警告，抑制警告，就是讲警告解除

1.3.元注解（代码包含了怎么自定义注解）

作用在其他注解的注解(或者说 元注解)是:

• @Retention - 表示注解在什么地方还有效
• @Documented - 标记这些注解是否包含在javadoc文档中。
• @Target - 标记这个注解应该是哪种 Java 成员，描述注解可以用在什么地方，比如用在方法上，用在类上。
• @Inherited - 标记这个注解可以使得子类继承父类的注解

import java.lang.annotation.*;

public class annotation {

}
//1.表示注解可以用在哪些地方
@Target(value = {ElementType.METHOD,ElementType.TYPE})
//2.Retention表示注解在什么地方还有效，,一般souce
@Retention(value = RetentionPolicy.RUNTIME)
//3.Documented表示是否讲我们的注解生成在javadoc中
@Documented

//4.子类可以继承父类的注解
@Inherited

**//这个就是相当于定义了一个自定义注解MyAnnotation**
@interface MyAnnotation{

}

1.4.自定义注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

public class annotation2 {
    @MyAnnotation2(name = "xx",age=11)
    public void test1(){

    }
    
    
    @MyAnnotation3("dd")
    public  void test2(){

    }
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    //注解的参数：参数类型+参数名().default如下
    String name() default "";
    int age();
    int id() default  -1;//默认值是-1代表不存在
    //数组
    String[] schools() default {"清华","北大"};
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
    //当只有一个参数的时候，默认写参数名字就是value;
    String value();

}

二.反射（java.Reflection）

2.1反射概述

2.1.0 反射题外话

利用反射机制可以使得java获得类似动态语言的特性，java的动态性让编程的时候更加灵活。
jdbc就是就是通过使用反射加载驱动，关于为什么jdbc要使用反射加载驱动？
直接import com.mysql.jdbc.Driver其实效果是一样的，但是为啥要反射加载
a.以反射形式加载的一个好处是当驱动jar包不存在时，可以做更多的操作。运行期以反射的方式来检查JDBC驱动的主类com.mysql.jdbc.Driver是否存在，若不存则表示运行环境中没有这个驱动，进入catch段，然后做相应操作，因为不知道它存在不存在，直接引入包的话，就会报错。
b.还有就是解耦，直接引入import com.mysql.jdbc.Driver违反了开闭原则的扩展原则
https://www.cnblogs.com/tenlee/p/5059813.html

（1）动态语言（弱类型语言）
动态语言是在运行时确定数据类型的语言。比如python里面变量不需要类型声明，变量的类型就是被赋值的那个值的类型。
如PHP/Ruby/Python/SQL/JavaScript等等。
（2）静态语言（强类型语言）
静态语言是在编译时变量的数据类型即可确定的语言，多数静态类型语言要求在使用变量之前必须声明数据类型。
例如：C,C++、Java。

2.1.1 反射基本概念

1.反射使得java在生成class文件后还能够对对象进行修改、
2.反射机制允许程序在执行期能够借助Reflection API取得任何类的内部信息，并能直接操作对象的内部属性和方法
3.加载类后，在堆内存方法区域中产生了class类型的对象，这个对象包含了完整的类的结构信息。可以通过这个对象去看到类的结构。这个对象就像是镜子，通过这个镜子去看到类内结构，所以形象称之为反射。
4.正常new和反射的差别（引入包类名称就是import包）

2.1.2 反射优缺点

优点：可以实现动态创建对象和编译，有很大灵活性。举例子（项目底层有时是用mysql，有时用oracle，需要动态地根据实际情况加载驱动类，这个时候反射就有用）
缺点：对性能有很大影响（反射是动态的对类型、方法进行解析，肯定是会比直接调用慢一点，vm无法进行优化）

2.1.3 反射的简单创建

一个类被加载后，类的整个结构都会被封装在class对象中，一个类的内存中只有一个class对象

package reflection;
//什么叫反射
public class test01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的class对象
        Class<?> c1 = Class.forName("reflection.User");
        Class<?> c2 = Class.forName("reflection.User");
        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
    }
}

//实体类：pojo，entity
class User{
    private String name;
    private int id;
    private int age;

    public User() {
    }

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

    public String getName() {
        return name;
    }

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

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

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

2.1.4 class类

因为在object中定义了一个final方法：public final Class getClass（），所以此方法将被所有的子类继承
Class类是java反射的源头，其实反射就是通过对象去求出类的名称。见2.1.1。

1.是一个类，存在于java.lang包中，它的构造函数是私有的，由JVM（类加载器）创建Class对象，我们可以通过getClass()方法获取到Class对象
2.Class类的作用
（1）获取类中属性的类型
（2）获取类中属性的名称
（3）获取类的方法
（4）获取类的基类等等
（5）综合上述通过表class可以完整得到一个类中的所有被加载的结构，他是反射的根源，可以利用它完成反射
3.class类常用方法

4.反射获得class类的四种方式
1.调用运行时类本身的.class属性
Class clazz = String.class;
2,通过运行时类的对象获取
Person p = new Person();
Class clazz = p.getClass();
3.通过Class的静态方法获取:体现反射的动态性
String className = “java.util.commons”;
Class clazz = Class.forName(className);
4.通过类的加载器
String className = “java.util.commons”;
ClassLoader classLoader = this.getClass().getClassLoader();
Class clazz = classLoader.loadClass(className);
5.哪些类型具有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; // 空类型
Class c9 = Class.class; // Class本身
注意点：如果数组的维度和类型是一样的，就是同一个class

2.1.5 反射能干嘛

项目底层有时是用mysql，有时用oracle，需要动态地根据实际情况加载驱动类，可以根据反射根据实际情况动态的加载驱动类。
运行时候获取注解的信息等等。

还有比如动态获取注解的信息，注解参数传入的信息。

2.2类的加载

2.2.1 java运行时内存

2.2.2 类的加载过程

(1)类的加载

(2)类的链接
验证：验证的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
准备：正式为类变量(即static变量)分配内存(方法区)并为类变量赋初默认值.
解析：将虚拟机中常量池内的符号引用替换为直接引用(地址)。.

(3)类的初始化
0.执行类构造器（不是普通的类对象的构造器）的()方法，它是讲所有的变量的赋值动作什么的进行合并产生的。就是讲代码进行整合。
1.如果这个类没有被加载、连接，则程序先加载、连接该类；
2.如果该类的直接父类没有被初始化，则先初始化直接父类；
3.如果该类中有初始化语句则先执行初始化语句

2.2.3 类的初始化（什么时候会发生类的初始化）

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

• 2.类的被动引用（不会发生类的初始化）
  （1）当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化
  （2）通过数组定义类引用，不会触发此类的初始化，就是类是class son{},然后Son[] array = new Son[5],这种类是不会有初始化的
  （3）引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中）

2.2.3 类加载器

类加载器负责加载 Java 类的字节代码（.class）到 Java 虚拟机中。

2.2.4 通过反射获得了class对象后可以做什么？

获得这个类对象后可以对这个对象操作，可以获得对象实例，通过反射获取方法，属性等

Class c3  = Class.forName("reflection.User");


        //通过这个可以获取一个对象实例，其实就是调用了一个无参构造器
        User user3 = (User)c3.newInstance();
        //通过反射获取普通方法，表示获取setName方法，这个方法的传入参数是String
        Method setName = c3.getDeclaredMethod("setName",String.class);
        //invoke：激活这个方法
        //(对象,"方法的值"),这样就完成了这个方法的调用
        setName.invoke(user3,"xxx");
        //获取反射的属性，属性是private就获取不了
        //除非前面加上setAccessible(true)。
        Field name  = c1.getDeclaredField("name");
        name.setAccessible(true);
        name.set(user3,"fwe");