注解与反射、自定义注解

注解

1、什么是注解

注解不是程序本身， 可以对程序做出解释， 可以别其他程序读取，注解是可以带有参数的。可以使用在类、方法、字段上面， 相当于是添加了一些额外的信息， 我们可以通过反射机制来实现对这些数据的访问。

2、注解的分类

注解的分类：内置注解、元注解、自定义注解

内置注解：重写、废弃、镇压警告等。

元注解：元注解的作用就是负责解释其他的注解。

1、@target：用来描述当前注解的作用范围

2、@document ：用来产生当前注解的文档信息

3、@inherited：表明子类可以继承父类的该注解

4、@retention：表明需要在什么级别保存该注解，用于描述注解的生命周期

自定义注解：

1、使用关键字 @interface

2、格式：

public @interface{ }

3、可以带有参数， 只有一个参数的时候， 建议名为 ： value

4、实例参数：String name()

测试

// 测试元注解、自定义注解
@my1(value = "1", age = 2)
public class Test {
    @my1(age = 2)
    int age;
    @SuppressWarnings("all")
    @my1(value = "1", age = 2, id = 9)
    public void testmethod() {
        System.out.println(age);
    }
    public static void main(String[] args) {
        new Test().testmethod();
    }
}
// 标记运行时候的注解
@Retention(value = RetentionPolicy.RUNTIME)
// 标记产生文档
@Documented
// 标记作用的范围
@Target({ElementType.METHOD, ElementType.TYPE, ElementType.FIELD})
@interface my1 {
    // 使用 value的时候， 注解的参数可以直接写
    String value() default "";
    int age();
    // 可以设置默认值
    int id() default 1;
    // 数组类型
    String[] school() default {"洛阳师范学院", "北大"};
}

反射

1、反射概述

反射机制允许程序在执行的时候借助反射的API来获取类的基本信息。 并且能够操作类的内部属性以及方法。

每当类加载完毕后， 在堆中都会产生一个Class类型的对象， 这个对象包含了完整的类信息， 这个对象就是一面镜子一样，通过它我们能够得类的完成结构信息。

反射来获取对象：

实例化对象->getclass方法->得到完整的包类名称

java的反射能够动态的创建对象，很灵活。但是对性能有影响

2、理解Class类

Object类中定义了getClass()方法， 即所有的类也就拥有了此方法。

从代码上来看， java的反射就是通过对象的名字得到（反射）出类的名称。

获取Class对象的方法

1、通过类的名称， 直接调用.class

​ Person.class

2、以知类的实例后， 通过getclass()方法

3、知道类的全路径。通过Clas类的方法

​ Class.forName(path)

4、内置基本类型可以用：类名.Type

测试

public class Test01 {

    /**
     * 获得 对象的  Class
     * @param args
     * @throws ClassNotFoundException
     */
    public static void main(String[] args) throws ClassNotFoundException {
        Person p1 = new Stu();
        System.out.println("这个人是" + p1.name);
        // 1 getClass();
        Class p1Class = p1.getClass();
        System.out.println(p1Class.hashCode());
        // 2 Class.forName
        Class p2 = Class.forName("com.Reflaction.Stu");
        System.out.println(p2.hashCode());
        // 3  Stu.class
        Class<Stu> aClass = Stu.class;
        System.out.println(aClass.hashCode());
        // 4 Integer.TYPE;
        Class<Integer> type = Integer.TYPE;
        System.out.println(type);
        // 5 getSuperclass();
        Class<? super Stu> superclass = aClass.getSuperclass();
        System.out.println(superclass);
    }
}


class Person {
    public String name;

    public Person() {
    }

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

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

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

class Tea extends Person {
    public Tea() {
        this.name = "教师";
    }
}

3、类加载

当程序准备主动使用一个类的时候，如果该类还没加载到内存中，系统会通过下面三个步骤加载：

1、类的加载：将类的class文件读入到内存中， 并为之创建一个java.lang.Class对象，此过程由类加载器来完成。

2、类的链接：将类的二进制文件链接到jre中

3、类的初始化：jvm来操作

什么时候开始类的初始化？

一、主动引用

1、new 一个类的对象

2、调用类的静态成员、方法

3、使用反射方法进行反射的调用

4、初始化子类的时候， 会先初始化父类

二、被动引用

1、定义类的数组

2、引用常量的时候（链接的时候就加载到类的常量池中了）

解释：类在加载完毕的时候就会把类的Class对象放到堆内存中，一个Class对象代表一个类，加载的时候同时也会把类的数据信息（静态方法和变量、常量池）放到方法区中，方法区中的类数据和堆中Class对象是对应的。实例化类的时候是在栈中开辟空间来存放堆中对象（类的Class）的引用。

测试

spublic class Test04 {
    static {
        System.out.println("加载Main");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        // 主动引用
        // B b = new B();
        // Class.forName("com.Reflaction.B");
        // 不会产生子类的引用
        // System.out.println(B.n);
        // System.out.println(B.m);
        // 什么都不引用
        B[] arr = new B[5];
    }
}

class A {
    static int n = 10;

    static {
        System.out.println("父类的静态代码加载");
    }

    public A() {
        System.out.println("加载父类");
    }
}

class B extends A {
    static final int m = 100;

    static {
        System.out.println("子类的静态代码加载");
    }

    public B() {
        System.out.println("加载子类");
    }
}

测试

public class Test07 {
    /**
     * 类加载器
     *
     * @param args
     */
    public static void main(String[] args) throws ClassNotFoundException {
        // 通过反射得到这类
        Class<?> aClass = Class.forName("com.Reflaction.Test07");
        // 得到用户的类加载器
        ClassLoader loader = aClass.getClassLoader();
        System.out.println(loader);
        // 得到系统加载器
        ClassLoader parent = loader.getParent();
        System.out.println(parent);
        // 得到根加载器
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);
        // 双亲委派机制
        // 运行时候java可以加载的目录
        String property = System.getProperty("java.class.path");
        System.out.println(property);
    }
}

4、获取类的结构

获取类的结构， 简单的说，就是先通过对象， 或者直接得到堆中的这个类的Class对象， 然后调用Class对象的API。

测试

public class Test08 {

    /**
     * 获取类的全部属性
     *
     * @param args
     */

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        // 先得到类得信息
        Class<?> name = Class.forName("com.Reflaction.User");
        System.out.println(name);
        System.out.println("==============================");
        // 得到类的公有属性
        Field[] fields = name.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("==============================");
        //得到全部的属性
        fields = name.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("==============================");
        // 得到类的共有方法
        Method[] methods = name.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("==============================");
        // 全部方法
        methods = name.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        // 获得指定的方法, 为了避免重载， 需要添加额外的传参数， 区分
        System.out.println("================================");
        Method method = name.getMethod(String.valueOf(name), String.class);
        System.out.println(method);
        // 获取构造器, 方法同上
        Constructor<?>[] constructors = name.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }
    }
}

5、调用类的结构

在上一步得到类的信息之后， 便可以开始调用了

public class Test09 {
    // 通过反射创建对象， 并且操作属性和方法
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        // 通过反射来创建对象， 默认调用无参构造器, 无参构造必须为公有
        Class<?> name = Class.forName("com.Reflaction.User");
        Object instance = name.newInstance();
        System.out.println(instance);


        Constructor<?>[] constructors = name.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }

        constructors = name.getDeclaredConstructors();

        for (Constructor<?> constructor : constructors) {

            System.out.println(constructor);
        }
        // 指定调用有参构造器
        Constructor<?> constructor = name.getDeclaredConstructor(Integer.class, String.class, Integer.class);
        Object c = constructor.newInstance(1, "c", 1);
        System.out.println(c);
        // 操作方法
        Object user = (User) name.newInstance();
        Method setName = name.getDeclaredMethod("setName", String.class);

        // 使用 invoke 表示激活的意思，后面带上参数
        setName.invoke(user,"cyt");
        System.out.println(user);

        // 操作属性, 需要开启权限
        Field field = name.getDeclaredField("name");

        field.setAccessible(true);
        field.set(user, "崔雨田");

        System.out.println(user);
    }
}

6、创建运行时类对象

使用的对象

public class User {

    private Integer id;
    private String name;
    private Integer age;
 
    // get、set
    // 有参、无参构造器
}

测试

       // 通过反射来创建对象， 默认调用无参构造器, 无参构造必须为公有
       Class<?> name = Class.forName("com.Reflaction.User");
       Object instance = name.newInstance();
       System.out.println(instance);

  // 指定调用有参构造器
        Constructor<?> constructor = name.getDeclaredConstructor(Integer.class, String.class, Integer.class);
        Object c = constructor.newInstance(1, "c", 1);
        System.out.println(c);

7、获得泛型信息

public class Test11 {

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

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

    /**
     * 通过反射来获得泛型的信息
     *
     * @param args
     */
    public static void main(String[] args) throws NoSuchMethodException {
        Method method = Test11.class.getDeclaredMethod("test2", Map.class, List.class);
        Type[] parameterTypes = method.getGenericParameterTypes();
        for (Type type : parameterTypes) {
            System.out.println(type);
            if (type instanceof ParameterizedType) {

                Type[] types = ((ParameterizedType) type).getActualTypeArguments();
                for (Type type1 : types) {

                    System.out.println(type1);
                }
            }
        }


        method = Test11.class.getDeclaredMethod("test1", null);
        Type returnType = method.getGenericReturnType();
        System.out.println(returnType);
        if (returnType instanceof ParameterizedType) {
            Type[] types = ((ParameterizedType) returnType).getActualTypeArguments();
            for (Type type1 : types) {
                System.out.println(type1);
            }
        }

    }
}

学习自：狂神教程

https://www.bilibili.com/video/BV1p4411P7V3?from=search&seid=4017859439455063941