注解和反射

注解

Annotation：注解

Comments：注释

注解入门

Annotation可以被其他程序（如编译器）读取

内置注解

@Override必须重写超类方法

@Deprecated 不推荐程序员使用

@SuppressWarnings("all")

自定义注解，元注解

元注解（meta-annotation）：*负责注解其他注解（4个）

@Target：表示注解的作用范围（TYPE，FIELD，METHOD）

@Retention：表示注解的生命周期（RunTime> Class > Source）

@Documented：表示注解是否生成在JAVAdoc中

@Inherited：子类可以继承父类的注解

一般使用前两种

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

// 定义一个注解
@Target(value = {ElementType.METHOD,ElementType.TYPE})
@Retention(value = RetentionPolicy.CLASS)
@Documented
@Inherited
public @interface MyAnnotation{

}

自定义注解

注解的参数 ：参数类型 + 参数名();

public class Test03 {
    @MyAnnotation2(age = 18)
    public void test1(){
    }

    @MyAnnotation3("coline") //String 参数名只有value时，value可省略
    public void test2(){
    }
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    // 注解的参数 ：参数类型 + 参数名();
    String name() default "";  // 默认值为空
    int age();
    int id() default -1;// 默认值为-1，代表不存在
    String[] schools() default {"五道口大学", "博古山大学"};
}


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

反射

Reflection：反射

• 动态语言：在运行时可以改变其结构的语言：C#，JavaScript，Python，PHP等

• 静态语言：在运行时不可以改变其结构的语言：Java，C，C++

• Java是准动态语言（因为反射机制）

反射机制

反射机制：加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象)，这个对象就包含了类的完整的结构信息。我们可以通过这个对象可以看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构,所以，我们形象的称之为：反射

• 反射是通过Class类来实现的

Class类

• 一个类被加载后，类的整个结构都会被封装在Class对象中

• 一个类在内存中只有一个Class类对象

获取Class类的方式

1. 对象.getClass()

2. Class.forName()（返回String ClassName）

3. 类名.class（class是Object类的属性）

4. 基本内置类型和包装类有TYPE属性（类似3，只不过把class换成TYPE）

5. Class类对象.getSuperclass

// 自写一个Person类和一个Student类，Student继承自Person类

Person person = new Student();

//方式一：通过对象获得
Class c1 = person.getClass();

//方式二:通过 Class.forName 获得
Class c2 = Class.forName("com.coline.reflection.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

// 只要元素类型与维度一样,就是同一个Class
int[] a = new int[10];
int[] b = new int[100];

类的加载与ClassLoader（了解）

类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化

• Load --> Link --> Initialize

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

2. 类的链接（Link）：将类的二进制数据合并到JRE中

3. 类的初始化（Initialize）：JVM负责对类进行初始化

// 类构造器方法<clinit>(){}在类的初始化时完成，合并静态代码块并执行
public class Test05 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);
    }
    /*
    1. (Load)加载到内存,会产生一个类对应的Class对象
    2. (Linked)链接,链接结束后 m = 0
    3. (Init)初始化
        <clinit>() {
                System.out.println("A类静态代码块初始化");
                m = 300;
                m = 100;
        }
    */
}

class A{
    static {
        System.out.println("A类静态代码块初始化");
        m = 300;
    }
    static int m = 100;
    
    public A() {
        System.out.println("A类的无参构造");
    }
}

类加载

会产生类加载：

1. new对象

2. 反射

不会产生类的加载的引用方法

1. 子类使用父类的静态方法，属性

2. 数组

3. 使用静态常量

// 1.主动引用
    Son son = new Son();

// 反射产生主动引用
    Class.forName("com.coline.reflection.Son");


// 不会产生类的引用的方法
    System.out.println(Son.b); // 子类使用父类的 静态属性,方法
Son.a();

Son[] array = new Son[5]; // 使用数组

System.out.println(Son.M);  // 使用静态常量

ClassLoader

双亲委派机制：

系统的加载器有的类,自写类与系统类同名,自写类无效

System < Extension < BootStrap（父子类关系）

• System ClassLoader：系统类的加载器（也叫App ClassLoader）
• Extension ClassLoader：扩展类加载器
• Bootstrap ClassLoader：根加载器(c/c++编写)

// 获取 系统类的加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();

// 获取 系统类加载器的父类 加载器
ClassLoader parent = systemClassLoader.getParent();

// 获取 扩展类加载器 的父类加载器
ClassLoader parent1 = parent.getParent();

// 测试 当前类 是哪个 加载器加载 的
ClassLoader classLoader = Class.forName("com.coline.reflection.Test07").getClassLoader();

// 测试 JDK内置的类 是谁加载的
classLoader = Class.forName("java.lang.Object").getClassLoader();

//如何获得 系统类加载器 可以加载的路径
System.out.println(System.getProperty("java.class.path"));

/*
D:\MyJava\Java JDK\jre\lib\charsets.jar;
D:\MyJava\Java JDK\jre\lib\deploy.jar;
D:\MyJava\Java JDK\jre\lib\ext\access-bridge-64.jar;
D:\MyJava\Java JDK\jre\lib\ext\cldrdata.jar;
D:\MyJava\Java JDK\jre\lib\ext\dnsns.jar;
D:\MyJava\Java JDK\jre\lib\ext\jaccess.jar;
D:\MyJava\Java JDK\jre\lib\ext\jfxrt.jar;
D:\MyJava\Java JDK\jre\lib\ext\localedata.jar;
D:\MyJava\Java JDK\jre\lib\ext\nashorn.jar;
D:\MyJava\Java JDK\jre\lib\ext\sunec.jar;
D:\MyJava\Java JDK\jre\lib\ext\sunjce_provider.jar;
D:\MyJava\Java JDK\jre\lib\ext\sunmscapi.jar;
D:\MyJava\Java JDK\jre\lib\ext\sunpkcs11.jar;
D:\MyJava\Java JDK\jre\lib\ext\zipfs.jar;
D:\MyJava\Java JDK\jre\lib\javaws.jar;
D:\MyJava\Java JDK\jre\lib\jce.jar;
D:\MyJava\Java JDK\jre\lib\jfr.jar;
D:\MyJava\Java JDK\jre\lib\jfxswt.jar;
D:\MyJava\Java JDK\jre\lib\jsse.jar;
D:\MyJava\Java JDK\jre\lib\management-agent.jar;
D:\MyJava\Java JDK\jre\lib\plugin.jar;
D:\MyJava\Java JDK\jre\lib\resources.jar;
D:\MyJava\Java JDK\jre\lib\rt.jar;
C:\Users\13957\Desktop\JavaSE\9-注解和反射\out\production\9-注解和反射;
D:\MyJava\IntelliJ IDEA 2020.3.3\lib\idea_rt.jar
 */

获取运行时类的完整结构

1. 获取类的Class对象

2. 通过get方法，获取类名，属性，方法，构造器等

（类名，属性，方法，构造器）=*

• get*s()：获得所有public*

• getDeclared*s：获得所有*

• getDeclared*()：获取指定*

  1. 属性：属性名

  2. 方法：方法名

  3. 构造器：参数类型

Class c1 = Class.forName("com.coline.reflection.User");

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


// 获得类的属性
Field[] fields = c1.getFields();  // 只能找到public属性

fields = c1.getDeclaredFields();  // 找到全部属性
for (Field f : fields){
    System.out.println(f);
}

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


// 获得类的方法
Method[] methods = c1.getMethods();  // 获得本类和父类所有public方法
for (Method method : methods) {
    System.out.println("1: " + method);
}

methods = c1.getDeclaredMethods();  // 获得本类所有方法
for (Method method : methods) {
    System.out.println("2:" + method);
}

// 获得指定方法
Method getName = c1.getMethod("getName", ParameterTypes:null);
Method setName = c1.getMethod("setName", String.class);

// 获得指定的构造器
Constructor[] constructors = c1.getConstructors();  // 获得public 方法
for (Constructor constructor : constructors) {
    System.out.println(constructor);
}

constructors = c1.getDeclaredConstructors();  // 获得全部方法
for (Constructor constructor : constructors) {
    System.out.println("!" + constructor);
}

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


// User类
class User{
    private int age;
    private String name;

    public User() {}
    public User(int age, String name) {
        this.age = age;
        this.name = name;}
    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;}
    private void test(){}

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

并不会经常用到，在开发时。

动态创建对象执行方法

通过Class对象构造实例对象

Class c1 = Class.forName("com.coline.reflection.User");

// 构造一个对象
User user = (User) c1.newInstance();  // 本质是调用了类的无参构造

// 通过构造器创建对象
Constructor constructor = c1.getDeclaredConstructor(int.class, String.class);
User user2 = (User) constructor.newInstance(15,"coline");

通过反射调用方法：

1. 获取类的Class对象

2. 构造类的对象，Class对象.newInstance()

3. 获取对象的方法

4. 方法.invoke(对象，"传入对象的参数")

通过反射操作属性：

1. 获取类的Class对象

2. 构造类的对象，Class对象.newInstance()

3. 获取对象的属性对象

4. 属性对象.set(对象,"传入的参数")

// 1.获得Class对象
Class c1 = Class.forName("com.coline.reflection.User");

// 2.通过反射调用普通方法
User user3 = (User) c1.newInstance(); // 创建一个实例对象
// 3.通过反射获取一个方法
Method setName = c1.getDeclaredMethod("setName", String.class);  // 赋值给一个Method类的实例对象

// 4.invoke : 调用(对象 , "方法的参数")
setName.invoke(user3,"国梁");  // 调用setName对象的invoke方法
System.out.println(user3.getName());


// 2. 创建实例对象
User user4 = (User) c1.newInstance(); // 创建一个实例对象
// 3. 获取属性
Field name = c1.getDeclaredField("name");  // 赋值给一个Field类的实例对象

// 4.不能直接操作私有属性,我们需要关闭程序的安全监测,属性或者方法的setAccessible(true)
name.setAccessible(true);
name.set(user4,"国梁2");

获取泛型信息（了解）

获取的是方法的参数和返回值的泛型信息

// 两个方法
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;
}


// 获取方法泛型参数类型
 Method method = Test11.class.getMethod("test01", Map.class, List.class);


// get泛型参数类型,传入Type数组
Type[] genericParameterTypes = method.getGenericParameterTypes();

for (Type gpt : genericParameterTypes) {  // 遍历Type数组
    // 泛型参数类型 是 参数类型的实例
    if (gpt instanceof ParameterizedType){

        // 强转成参数类型实例,调用getActualTypeArguments,获得真实类型参数
        Type[] actualTypeArguments = ((ParameterizedType) gpt).getActualTypeArguments();

        // 遍历 ata Type数组
        for (Type actualTypeArgument : actualTypeArguments) {
            System.out.println(actualTypeArgument);  // 打印真实参数类型
        }
    }
}


// 获取方法返回泛型（同理使用for循环打印）
method = Test11.class.getMethod("test02", null);
Type genericReturnType = method.getGenericReturnType();  // 获取方法返回类型

获取注解信息

1. 获取类的Class对象

2. 获得类的注解

// 1
Class c1 = Class.forName("com.coline.reflection.Student2");

// 2.1获得类的所有注解
Annotation[] annotations = c1.getAnnotations();

// 2.2获得类的注解
MyTable table = (MyTable) c1.getAnnotation(MyTable.class);  // 获得MyTable类的注解

1. 获取类的Class对象

2. 获得类的属性

3. 通过属性获得注解

Class c1 = Class.forName("com.coline.reflection.Student2");

// 获得属性的注解
Field f = c1.getDeclaredField("name");  // 传入属性(字段)名,获得Field

MyField annotation = f.getAnnotation(MyField.class);  // 从属性获得注解
// 使用注解访问注解的值
System.out.println(annotation.colName());
System.out.println(annotation.type());
System.out.println(annotation.length());

Student2类和相应的注解

@MyTable("db_student")
class Student2{

    @MyField(colName = "db_id", type = "int", length = 10)
    private int id;
    @MyField(colName = "db_age", type = "int", length = 8)
    private int age;
    @MyField(colName = "db_name", type = "varchar", length = 3)
    private String name;

    public Student2() {
    }

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

// 类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME) // RetentionPolicy: 保留政策
@interface MyTable{
    String value();
}

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