Day22,23 注解和反射：注解(内置注解，元注解，自定义注解)，反射（Class类、类加载内存分析、newInstance（）、invoke、setAccessible、泛型、注解）

注解

注解入门

内置注解

@Override//重写注解
@Deprecated//已过时的，不推荐使用但可以使用，或者有更好的方法
@SuppressWarnings//镇压警告，可以放在方法上，也可以放在类上面，等等

元注解

//测试元注解
public class Test02 {
    @MyAnnotation
    public void test(){

    }
}

//定义一个注解
//Target表示我们的注解可以用在哪些地方
@Target(value = {ElementType.METHOD,ElementType.TYPE})
//Retention表示注解在什么时候有效。RUNTIME表示运行时有效。
@Retention(value = RetentionPolicy.RUNTIME)
// Documented表示是否将我们的注解生成在Javadoc中
@Documented
//Inherited表示子类可以继承父类的注解
@Inherited
@interface MyAnnotation{
}

自定义注解

//自定义注解
public class Test03 {
    //注解可以显示赋值，如果没有默认值，我们就必须给注解赋值
    @MyAnnotation2(name="jyw",schools = "南林")
    public void test(){
    }
    
    @MyAnnotation3("jyw")
    public void test2(){
    }
}

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

    String[] schools() default {"1","2"} ;
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
    String value();
}

反射

静态vs动态语言

Java Reflection

java 反射机制的研究和应用

java 反射优点和缺点

java 反射的运用

反射用到的主要架包（Class、Field、Method、Constructor）

主要是运用Class类，java.lang.class包当中，导入用到了下面三个包。分别用来代表Class类的成员变量、方法和构造器。

java.lang.reflect.Field;
java.lang.reflect.Method;
java.lang.reflect.Constructor

Class类的分析说明定义

Class类的实例化方式

//测试class类的创建方式有哪些
public class Test03 {
    public static void main(String[] args) throws ClassNotFoundException {
        Persion student = new Student();
        System.out.println("这个人是：" + student.name);

        //方式一：通过对象获得class对象
        Class c1 = student.getClass();
        //方式二：forName获得class对象
        Class c2 = Class.forName("com.jyw.reflection.Student");
        //打印结果一样
        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
        //方式三：通过类名.class获得
        Class c3=Student.class;
        System.out.println(c3.hashCode());
        //方法四：基本内置类型的包装类都有一个Type对象
        Class c4=Integer.TYPE;
        System.out.println(c4);

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

class Persion {

    String name;

    public Persion() {
    }

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

    public String getName() {
        return name;
    }

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

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

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

拥有Class对象的类型有哪些

//所有类型的Class
public class Test04 {
    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[20];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());
    }
}

类加载过程内存分析

类的加载过程（加载、链接、初始化）

public class Test05 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.m);//100
        /*
        1.加载到内存，会产生一个类对应的Class对象
        2.链接，链接结束后m=0
        3.初始化
              <clinit>(){
                      System.out.println("A类静态代码块初始化");
                        m = 300;
                        m = 100;
              }
              m=100;
         */
    }

}

class A {
    //静态按顺序执行
    static {
        System.out.println("A类静态代码块初始化");
        m = 300;
    }
    static int m = 100;
}

类的初始化

//测试什么时候会初始化
public class Test06 {
    static {
        System.out.println("Main类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        //1.主动引用
        //Son son = new Son();

        //反射也会产生主动调用，但类名.class不会
        //Class.forName("com.jyw.reflection.Son");

        //不会产生类的引用方法
        //System.out.println(Son.b);//父类被加载，子类没有被加载

        //Son[] array=new Son[5];//只有Main方法被加载。

        //常量在链接阶段加载完毕，所以不会触发初始化。
        System.out.println(Son.M);
    }
}

class Father {
    static int b = -2;

    static {
        System.out.println("父类被加载！");
    }
}

class Son extends Father {

    static {
        System.out.println("子类被加载");
    }

    static int m = 100;
    static final int M = 1;
}

类加载器ClassLoader

public class Test07 {
    public static void main(String[] args) {
        //获取系统类的类加载器
        //系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //获取系统类加载器的父类加载器-->扩展类加载器
        //扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);//sun.misc.Launcher$ExtClassLoader@1540e19d

        //获取扩展类加载器的父类加载器-->根加载器(c/c++)
        //引导类加载器
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);//null

        //测试当前类是哪个加载器加载的
        try {
            //自定义的类是由用户类加载器加载。
            ClassLoader classLoader = Class.forName("com.jyw.annotation.Test07").getClassLoader();
            System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2
            //java核心类库，rt包下的，由根加载器加载。（引导类加载器）
            ClassLoader obj = Class.forName("java.lang.Object").getClassLoader();
            System.out.println(obj);//null

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //如何获得系统加载器可以加载的路径
        String property = System.getProperty("java.class.path");
        System.out.println(property);
        //双亲委外机制
        //java.lang.String-->一层一层网上找上面的包，保证安全性
        /*
        E:\Environment\java\jdk1.8\jre\lib\charsets.jar;
        E:\Environment\java\jdk1.8\jre\lib\deploy.jar;
        E:\Environment\java\jdk1.8\jre\lib\ext\access-bridge-64.jar;
        E:\Environment\java\jdk1.8\jre\lib\ext\cldrdata.jar;
        E:\Environment\java\jdk1.8\jre\lib\ext\dnsns.jar;
        E:\Environment\java\jdk1.8\jre\lib\ext\jaccess.jar;
        E:\Environment\java\jdk1.8\jre\lib\ext\jfxrt.jar;
        E:\Environment\java\jdk1.8\jre\lib\ext\localedata.jar;
        E:\Environment\java\jdk1.8\jre\lib\ext\nashorn.jar;
        E:\Environment\java\jdk1.8\jre\lib\ext\sunec.jar;
        E:\Environment\java\jdk1.8\jre\lib\ext\sunjce_provider.jar;
        E:\Environment\java\jdk1.8\jre\lib\ext\sunmscapi.jar;
        E:\Environment\java\jdk1.8\jre\lib\ext\sunpkcs11.jar;
        E:\Environment\java\jdk1.8\jre\lib\ext\zipfs.jar;
        E:\Environment\java\jdk1.8\jre\lib\javaws.jar;
        E:\Environment\java\jdk1.8\jre\lib\jce.jar;
        E:\Environment\java\jdk1.8\jre\lib\jfr.jar;
        E:\Environment\java\jdk1.8\jre\lib\jfxswt.jar;
        E:\Environment\java\jdk1.8\jre\lib\jsse.jar;
        E:\Environment\java\jdk1.8\jre\lib\management-agent.jar;
        E:\Environment\java\jdk1.8\jre\lib\plugin.jar;
        E:\Environment\java\jdk1.8\jre\lib\resources.jar;
        E:\Environment\java\jdk1.8\jre\lib\rt.jar;
        E:\workspace_java\注解和反射\out\production\注解和反射;
        E:\IntelliJ IDEA 2020.2.1\lib\idea_rt.jar
         */

    }
}

Class类的实例化后的使用

获取Class类内部结构的方法

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test08 {
    private String name = "jyw";

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {

        Class c1 = Class.forName("com.jyw.annotation.Test08");

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

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

        fields = c1.getDeclaredFields();//可以找到所有属性
        for (Field field : fields) {
            System.out.println(field);
        }

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

        //获得类的方法
        System.out.println("======");
        Method[] methods = c1.getMethods();//获得本类和父类的pubic公共方法
        Method[] declaredMethods = c1.getDeclaredMethods();//获得本类全部方法
        //获得指定方法,需要参数,因为存在重载.
        Method getName = c1.getMethod("getName", null);
        Method setName = c1.getMethod("setName", String.class);

        //获得构造器
        Constructor[] constructors = c1.getConstructors();//获得public方法
        Constructor[] declaredConstructors = c1.getDeclaredConstructors();//获得全部方法
        //获得指定构造器,需要加参数
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class,int.class,int.class);
        System.out.println(declaredConstructor);
    }
}

通过newInstance（）方法动态构造对象

可以用类的实例化对象，也可以用类的构造器，来构造对象

通过反射调用普通方法和属性

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

public class Test09 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {

        //获得class对象
        Class c1 = Class.forName("com.jyw.annotation.User");
        //构造对象
        User user = (User) c1.newInstance();//本质调用无参构造
        user.setName("jyw");
        user.setAge(25);
        System.out.println(user.toString());

        //通过构造器创建对象
        Constructor constructor = c1.getDeclaredConstructor(String.class,int.class,int.class);
        User jyw = (User)constructor.newInstance("jyw", 25, 100);
        System.out.println(jyw.toString());

        //通过反射调用普通方法
        //invoke:激活
        //invoke(对象,"方法的值")
        Method setName = c1.getDeclaredMethod("setName", String.class);
        setName.invoke(jyw,"jyw3");
        System.out.println(jyw.getName());

        //通过反射操作属性
        Field name = c1.getDeclaredField("name");
        //不能直接操作私有属性,我们需要关闭程序的安全检测
        //通过属性或者方法的setAccessible(true)
        name.setAccessible(true);//关闭安全检测
        name.set(jyw,"jyw4");        System.out.println(jyw.getName());
    }
}

setAccessible性能检测

性能检测

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

//分析性能
public class Test10 {
    //普通方式调用
    public void test01(){
        User user = new User();

        long startTime=System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            user.getName();
        }
        long endTime=System.currentTimeMillis();

        System.out.println("普通方法调用执行时间:"+(endTime-startTime)+"ms");

    }

    //反射方法调用
    public void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName",null);

        long startTime=System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            getName.invoke(user,null);
        }
        long endTime=System.currentTimeMillis();

        System.out.println("反射方法调用执行时间:"+(endTime-startTime)+"ms");
    }
    //反射方法调用 关闭检测
    public void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName",null);
        getName.setAccessible(true);

        long startTime=System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            getName.invoke(user,null);
        }
        long endTime=System.currentTimeMillis();

        System.out.println("反射方法调用执行时间:"+(endTime-startTime)+"ms");
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        Test10 test10 = new Test10();
        test10.test01();//3ms
        test10.test02();//292ms
        test10.test03();//170ms
    }
}

通过反射获取泛型

//通过反射获取泛型信息
public class Test11 {
    public void test01(Map<String, User> map, List<User> list, int i) {
        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 = Test11.class.getDeclaredMethod("test01", Map.class, List.class, int.class);
        //getGenericParameterTypes():获得方法的参数类型
        Type[] genericParameterTypes = method.getGenericParameterTypes();

        //打印方法的参数类型
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println("#" + genericParameterType);
            //判断方法的参数类型,是否属于参数化类型(泛型)ParameterizedType
            if (genericParameterType instanceof ParameterizedType) {
                //通过参数化类型ParameterizedType的getActualTypeArguments()方法,获得参数化详细信息
                Type[] types = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type type : types) {
                    System.out.println(type);
                }
            }
        }

        Method method2 = Test11.class.getDeclaredMethod("test02");
        //getGenericReturnType():获得方法的返回值类型
        Type genericReturnType = method2.getGenericReturnType();

        //判断方法的返回值类型,是否属于参数化类型(泛型)ParameterizedType
        if (genericReturnType instanceof ParameterizedType) {
            //通过参数化类型ParameterizedType的getActualTypeArguments()方法,获得参数化详细信息
            Type[] types = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type type : types) {
                System.out.println(type);
            }
        }
    }
}

通过反射获取注解

练习：ORM

import java.lang.annotation.*;
import java.lang.reflect.Field;

//练习反射操作注解
public class Test12 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("com.jyw.annotation.Student");
        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //获得注解的Value的值
        Tablejyw tablejyw = (Tablejyw)c1.getAnnotation(Tablejyw.class);
        String value = tablejyw.value();
        System.out.println(value);

        //获得类指定属性的注解
        Field name = c1.getDeclaredField("name");
        Fieldjyw annotation = name.getAnnotation(Fieldjyw.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());
    }
}

@Tablejyw("db_student")
class Student {
    @Fieldjyw(columnName="db_id",type="int",length = 10)
    private int id;
    @Fieldjyw(columnName="db_age",type="int",length = 10)
    private int age;
    @Fieldjyw(columnName="db_name",type="varchar",length = 3)
    private String name;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public int getId() {
        return id;
    }

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

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

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

//属性的注解
@Target({ElementType.FIELD})//作用域
@Retention(RetentionPolicy.RUNTIME)
@interface Fieldjyw {
    String columnName();//列名

    String type();//数据类型

    int length();//数据长度

}