16.注解和反射

最新推荐文章于 2024-11-11 00:03:55 发布
最新推荐文章于 2024-11-11 00:03:55 发布
阅读量60 收藏
点赞数 1
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45502524/article/details/121322266
版权
本文详细介绍了Java中的注解（Annotation）和反射（Reflection）机制。注解包括内置注解、元注解和自定义注解，以及其在类加载过程中的作用。反射机制则涉及到类的加载、Class对象的获取、类的结构信息（如字段、方法、构造器等）以及动态创建对象和调用方法等功能。此外，还讨论了反射的性能问题和泛型、注解的反射操作。
摘要由CSDN通过智能技术生成

所有框架（MyBatis、Spring、SpringBoot……）的底层

一、注解（Java.Annotation）

1.什么是注解

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

  • Annotation 的作用：

  • 不是程序本身，可以对程序作出解释（这一点和注释（comment）没什么区别）

  • 可以被其它程序（比如：编译器等）读取

public class Annotation_Base {
    @Override
    public String toString() {
        return super.toString();
    }
}

  • Annotation 的格式：

  • 注解是以“@注释名”在代码中存在的，还可以添加一些参数值，例如：@SuppressWarnings(value = "unchecked")

  • Annotation 在哪里使用？

  • 可以附加在package、class、method、field等上面，相当于给它们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元数据的访问

  • 注解还有检查的作用，检查和约束，必须按照规范去写，才能保证程序的正确性

2.内置注解

  • @Override：定义在java.lang.Override中，此注解只适用于修辞方法，表示一个方法声明打算重写超类中的另一个方法声明（重写一个方法）

    public class BuiltInAnnotation_Override {
    //@Override：重写的注解
    @Override
    public String toString() {
        return super.toString();
    }
}

  • @Deprecated：定义在java.lang.Deprecated中，此注解可以用于修辞方法、属性、类，表示不鼓励程序员使用这样的元素，通常是因为它很危险或者存在更好的选择（已过时的）

    public class BuiltInAnnotation_Deprecated {
    public static void main(String[] args) {
        deprecated();
    }
    
    //@Deprecated：不推荐程序员使用，但是可以使用，或者存在更好的方式
    @Deprecated
    public static void deprecated() {
        System.out.println("Deprecated");
    }
}

  • @SuppressWarnings：定义在java.lang.SuppressWarnings中，用来抑制编译时的警告信息（镇压警告）

    • 与前两个注解有所不同，你需要添加一个参数才能正确使用，这些参数都是已经定义好了的，我们选择性的使用就好了
      • @SuppressWarnings("all")：镇压全部警告
      • @SuppressWarnings("unchecked")：镇压未检查的
      • @SuppressWarnings(value = {"unchecked", "deprecation"})
      • 等等……
//不仅可以放在方法上，还可以放在类上
@SuppressWarnings("all")
public class BuiltInAnnotation_SuppressWarnings {
    //不仅可以放在方法上，还可以放在类上
    @SuppressWarnings("all")
    public void suppressWarnings() {
        List list = new ArrayList();
    }
}

3.元注解

  • 元注解的作用就是负责注解其它注解， Java 定义了4个标准的meta-annotation类型，它们被用来提供对其它annotation类型作说明
  • 这些类型和它们所支持的类在java.lang.annotation包中可以找到（@Target、@Retention、@Documented、@Inherited）

    • @Target：用于描述注解的使用范围（即，被描述的注解可以用在什么地方）

      • ElementType取值的类型:

        • TYPE: 类,接口或者枚举
        • FIELD: 域,包含枚举常量
        • METHOD: 方法
        • PARAMETER: 参数
        • CONSTRUCTOR: 构造方法
        • LOCAL_VARIABLE: 局部变量
        • ANNOTATION_TYPE: 注解类型
        • PACKAGE: 包

    • @Retention：表示需要在什么级别保存该注解信息，用于描述注解的生命周期

      • （SOURCE（源码）<CLASS（编译期，默认）<RUNTIME（运行时））

      • RetentionPolicy的取值类型有三种:

        • SOURCE: 源码级别保留，编译后即丢弃
        • CLASS: 编译级别保留,编译后的class文件中存在,在jvm运行时丢弃,这是默认值
        • RUNTIME: 运行级别保留,编译后的class文件中存在,在jvm运行时保留,可以被反射调用

    • @Documented：说明该注解将被包含在JavaDoc中

    • @Inherited：说明子类可以继承父类中的该注解

      • @Inherited需要和@AliasFor一起使用: 在子注解对应的属性使用@AliasFor

        • 注解是可以继承的,但是注解是不能继承父注解的属性
        • 也就是说,在类扫描时的注解的属性值依然是父注解的属性值,而不是自定义注解的属性值
        • 需要在注解的属性上使用@AliasFor
@MetaAnnotation
public class MetaAnnotation_MetaAnnotation {

}

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

//@Retention：表示注解在什么地方还有效
//SOURCE < CLASS < RUNTIME
@Retention(value = RetentionPolicy.RUNTIME)

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

//@Inherited：子类可以继承父类的注解
@Inherited
@interface MetaAnnotation {

}

4.自定义注解

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

  • 分析：

    • @interface用来声明一个注解，格式：

      public @interface 注解名 {
	定义内容
}

    • 其中的每一个方法实际上是声明了一个配置参数

    • 方法的名称就是参数的名称

    • 返回值类型就是参数的类型（返回值只能是基本类型、Class、String、enum）

    • 可以通过default来声明参数的默认值

    • 如果只有一个参数成员，一般参数名为value

    • 注解元素必须要有值，我们定义注解元素时，经常使用""、0作为默认值

      public class CustomAnnotation_MyAnnotation {
    //定义了参数，不写参数，注解就会报错
    //注解可以显式赋值，如果没有默认值，我们就必须给注解赋值
    @MyAnnotation(name = "张三", schools = {"清华大学", "北京大学"})
    public void method(){}

    @MyAnnotationValue("李四")
    public void methodValue(){}
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
    //注解的参数：参数类型 参数名();
    //有了默认值就可以不用写注解的参数
    String name() default "";
    int age() default 0;
    
    int id() default -1;  //如果默认值为 -1 ，代表不存在

    String[] schools();
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotationValue {
    //如果只有一个参数，建议使用 value() 命名，可以省略 value ，如果是其它的则不能省略
    String value();
}

二、反射（Java.Reflection）

1.静态语言 VS 动态语言

  • 动态语言

    • 是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其它结构上的变化。通俗点说，就是运行时代码可以根据某些条件改变自身结构
    • 主要动态语言： Object-C 、 C# 、 JavaScript 、 PHP 、 Python 等
    function f() {
    var x = "var a = 3; var b = 5; alert(a + b)";
    eval(x);
}

  • 静态语言

    • 与动态语言相对应的，运行时结构不可变的语言就是静态语言
    • Java 不是动态语言，但 Java 可以称之为“准动态语言”。即， Java 有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。 Java 的动态性让编程的时候更加灵活
    • 主要静态语言： Java 、 C 、 C++

2.Java.Reflection

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

Class c = Class.forName("java.lang.String");

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

    Java.Reflection

  • Java 反射机制研究及应用

  • Java 反射机制提供的功能

  • 在运行时判断任意一个对象所属的类

  • 在运行时构造任意一个类的对象

  • 在运行时判断任意一个类所具有的成员变量和方法

  • 在运行时获取泛型信息

  • 在运行时调用任意一个对象的成员变量和方法

  • 在运行时处理注解

  • 生成动态代理

  • 等等……

  • Java 反射优点和缺点

  • 优点：

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

  • 缺点：

    • 对性能有影响。使用反射基本上是一种解释操作，我们可以告诉 JVM ，我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作

  • 反射相关的主要 API

    • java.lang.Class：代表一个类
    • java.lang.reflect.Method：代表类的方法
    • java.lang.reflect.Field：代表类的成员变量
    • java.lang.reflect.Constructor：代表类的构造器
    • 等等……
public class Reflection_Reflection {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的 Class 对象
        Class c1 = Class.forName("com.minami.b_reflection.User");
        System.out.println(c1);  //class com.minami.b_reflection.User

        Class c2 = Class.forName("com.minami.b_reflection.User");
        Class c3 = Class.forName("com.minami.b_reflection.User");
        Class c4 = Class.forName("com.minami.b_reflection.User");

        //一个类在内存中只有一个 Class 对象，不可能有多个，百分百只有一个
        //一个类被加载后，类的整个结构都会被封装在 Class 对象中，通过这个 Class 对象就可以获得类里面的所有东西
        System.out.println(c1.hashCode());  //356573597
        System.out.println(c2.hashCode());  //356573597
        System.out.println(c3.hashCode());  //356573597
        System.out.println(c4.hashCode());  //356573597
    }
}

//实体类：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 +
                '}';
    }
}

3. Class 类

  • 在 Object 类中定义了以下的方法，此方法将被所有子类继承

    public final Class getClass();

    • 以上的方法返回值的类型是一个 Class 类，此类是 Java 反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即，可以通过对象反射求出类的名称

      Class类

  • 对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言， JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构（ class / interface / enum / annotation / primitive type / void / [] ）的有关信息

    • Class 本身也是一个类
    • Class 对象只能由系统建立对象（只能通过反射得到 Class 对象）
    • 一个加载的类在 JVM 中只会有一个 Class 实例（不管创建多少个对象，创建出来的 Class 的 hashCode 还是一个）
    • 一个 Class 对象对应的是一个加载到 JVM 中的一个 .class 文件（编译后生成的）
    • 每个类的实例都会记得自己是由哪个 Class 实例所生成
    • 通过 Class 可以完整地得到一个类中的所有被加载的结构
    • Class 类是 Reflection 的根源，针对任何你想动态加载、运行的类，唯有先获得相应的 Class 对象

  • Class 类的常用方法

  • static Class<?> forName(String className)：返回指定类名 name 的 Class 对象

  • T newInstance()：调用缺省构造函数，返回 Class 对象的一个实例

  • getName()：返回此 Class 对象所表示的实体（类、接口、数组类或 void ）的名称

  • Class<? super T> getSuperclass()：返回当前 Class 对象的父类的 Class 对象

  • Class<?>[] getInterfaces()：获取当前 Class 对象的接口

  • ClassLoader getClassLoader()：返回该类的类加载器

  • Constructor<?>[] getConstructors()：返回一个包含某些 Constructor 对象的数组

  • Method getMethod(String name, Class<?>... parameterTypes)：返回一个 Method 对象，此对象的形参类型为 parameterType

  • Field[] getDeclaredFields()：返回 Field 对象的一个数组

4.获取 Class 类的实例

  1. 若已知具体的类，通过类的 class 属性获取，该方法最为安全可靠，程序性能最高

    Class clazz = String.class;

  2. 已知某个类的实例，调用该实例的 getClass() 方法获取 Class 对象

    Class clazz = String.getClass();

  3. 已知一个类的全类名，且该类在类路径下，可通过 Class 类的静态方法 forName() 获取，可能抛出 ClassNotFoundExcepton

    Class c = Class.forName("java.lang.String");

  4. 内置基本数据类型可以直接用类名.TYPE

  5. 还可以利用 ClassLoader

package com.minami.b_reflection;

/**
 * Class 类的创建方式
 *
 * @author lemon
 * @create 2021-10-12 20:07
 */
public class GetInstanceOfClass_HowClassIsCreated {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("这个人是：" + person.name);

        //1. 通过 类名.class 获得
        Class c1 = Student.class;
        System.out.println(c1.hashCode());

        //2. 通过 对象 获得
        Class c2 = person.getClass();
        System.out.println(c2.hashCode());

        //3. 通过 forName 获得
        Class c3 = Class.forName("com.minami.b_reflection.Student");
        System.out.println(c3.hashCode());

        //4. 基本内置类型的包装类都有一个 Type 属性，可以直接用通过 类名.TYPE 获得
        Class c4 = Integer.TYPE;
        System.out.println(c4);  //int

        //获得父类类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);  //class com.minami.b_reflection.Person
    }
}

class Person {
    public 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 = "老师";
    }
}

5.哪些类型可以有 Class 对象？

  • class：外部类、成员（成员内部类、静态内部类）、局部内部类、匿名内部类（所有的类）
  • interface：接口
  • []：数组
  • enum：枚举
  • annotation：注解@interface
  • primitive type：基本数据类型
  • void：
public class WhatTypesCanHaveClassObjects_Classofalltypes {
    public static void main(String[] args) {
        Class c1 = Object.class;  //类
        Class c2 = Class.class;  //类
        Class c3 = Comparable.class;  //接口
        Class c4 = String[].class;  //一维数组
        Class c6 = int[][].class;  //二维数组
        Class c5 = ElementType.class;  //枚举
        Class c7 = Override.class;  //注解
        Class c8 = Integer.class;  //基本数据类型
        Class c9 = void.class;  //void

        System.out.println(c1);  //class java.lang.Object
        System.out.println(c2);  //class java.lang.Class
        System.out.println(c3);  //interface java.lang.Comparable
        System.out.println(c4);  //class [Ljava.lang.String;
        System.out.println(c6);  //class [[I
        System.out.println(c5);  //class java.lang.annotation.ElementType
        System.out.println(c7);  //interface java.lang.Override
        System.out.println(c8);  //class java.lang.Integer
        System.out.println(c9);  //void

        //只要元素类型与维度一样，就是同一个 Class
        int[] a = new int[10];
        int[] b = new int[100];
        System.out.println(a.getClass().hashCode());  //356573597
        System.out.println(b.getClass().hashCode());  //356573597
    }
}

6.类的加载过程（了解）

  • Java 内存分析

Java内存分析

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

类的加载过程（了解）

  • 类的加载与 ClassLoader 的理解
    • 加载：将 class 文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象（ Class 对象是加载到内存中才有的，所以不能主动创建，只能获取）
    • 链接：将 Java 类的二进制代码合并到 JVM 的运行状态之中的过程
      • 验证：确保加载的类信息符合 JVM 规范，没有安全方面的问题
      • 准备：正式为类变量（ static ）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配
      • 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程
    • 初始化：
      • 执行类构造器 () 方法的过程。类构造器 () 方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）
      • 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化
      • 虚拟机会保证一个类的 () 方法在多线程环境中被正确加锁和同步
public class ClassLoadingProcess_ClassLoader {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);  //A 静态代码块 /n A 无参构造器 /n 100
    }
}

class A {
    //静态代码块
    static {
        System.out.println("A 静态代码块");
        m = 300;
    }

    //静态变量
    static int m = 100;

    //无参构造器
    public A() {
        System.out.println("A 无参构造器");
    }
}

类的加载过程

  • 什么时候会发生类初始化？
    • 类的主动引用（一定会发生类的初始化）
      • 当虚拟机启动，先初始化main()方法所在的类
      • new一个类的对象
      • 调用类的静态成员（除了final常量）和静态方法
      • 使用java.lang.reflect包的方法对类进行反射调用
      • 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类
    • 类的被动引用（不会发生类的初始化）
      • 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化
      • 通过数组定义类引用，不会触发此类的初始化
      • 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）
package com.minami.b_reflection;

/**
 * 什么时候会发生类初始化？
 *
 * @author lemon
 * @create 2021-10-13 18:41
 */
public class ClassLoadingProcess_ActiveReferenceOfClass {
    static {
        System.out.println("main 被加载");
    }

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

        //反射也会产生主动引用，极大的消耗资源
//        Class.forName("com.minami.b_reflection.Son");  //main 被加载 -> Father 被加载 -> Son 被加载

        //2.类的被动引用，不会产生类的引用的方法
        //子类调用父类的静态方法或静态变量，并不会让子类加载
//        System.out.println(Son.b);  //main 被加载 -> Father 被加载 -> 2

        //通过数组根本不会引起类的任何初始化
//        Son[] sons = new Son[5];  //main 被加载

        //调用子类常量池里面的一个常量并不会引起父类和子类的初始化
        System.out.println(Son.M);  //main 被加载 -> 1
    }
}

class Father {
    //静态变量
    static int b = 2;

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

class Son extends Father {
    static {
        System.out.println("Son 被加载");
        m = 300;
    }

    //静态变量
    static int m = 100;

    //静态常量
    static final int M = 1;
}

7.类加载器的作用

  • 类加载的作用：将 class 文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口
  • 类缓存：标准的 JavaSE 类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过 JVM 垃圾回收机制可以回收这些 Class 对象

类加载器的作用

  • 类加载器作用是用来把类（ Class ）装载进内存的。 JVM 规范定义了如下类型的类的加载器：
  • 类加载器有哪些
    • Java 核心库：rt.jar包
package com.minami.b_reflection;

/**
 * 类加载器的作用
 *
 * @author lemon
 * @create 2021-10-13 20:08
 */
public class ClassLoader_RoleOfClassLoader {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取系统类的加载器（AppClassLoader / SystemClassLoader）
        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++写的， Java 读取不到）
        ClassLoader parentParent = parent.getParent();
        System.out.println(parentParent);  //null

        //测试当前类是哪个加载器加载的 -> 系统类的加载器加载的
        ClassLoader classLoader = Class.forName("com.minami.b_reflection.ClassLoader_RoleOfClassLoader").getClassLoader();
        System.out.println(classLoader);  //sun.misc.Launcher$AppClassLoader@18b4aac2

        //测试 JDK 内置的类是哪个加载器加载的 -> 引导类加载器加载的
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);  //null

        //获取系统类加载器可以加载的路径
        String property = System.getProperty("java.class.path");
        System.out.println(property);
        /* 如果类不在这些地方就读取不到
        D:\develop\Java\java8\jdk\jre\lib\charsets.jar;
        D:\develop\Java\java8\jdk\jre\lib\deploy.jar;
        D:\develop\Java\java8\jdk\jre\lib\ext\access-bridge-64.jar;
        D:\develop\Java\java8\jdk\jre\lib\ext\cldrdata.jar;
        D:\develop\Java\java8\jdk\jre\lib\ext\dnsns.jar;
        D:\develop\Java\java8\jdk\jre\lib\ext\jaccess.jar;
        D:\develop\Java\java8\jdk\jre\lib\ext\jfxrt.jar;
        D:\develop\Java\java8\jdk\jre\lib\ext\localedata.jar;
        D:\develop\Java\java8\jdk\jre\lib\ext\nashorn.jar;
        D:\develop\Java\java8\jdk\jre\lib\ext\sunec.jar;
        D:\develop\Java\java8\jdk\jre\lib\ext\sunjce_provider.jar;
        D:\develop\Java\java8\jdk\jre\lib\ext\sunmscapi.jar;
        D:\develop\Java\java8\jdk\jre\lib\ext\sunpkcs11.jar;
        D:\develop\Java\java8\jdk\jre\lib\ext\zipfs.jar;
        D:\develop\Java\java8\jdk\jre\lib\javaws.jar;
        D:\develop\Java\java8\jdk\jre\lib\jce.jar;
        D:\develop\Java\java8\jdk\jre\lib\jfr.jar;
        D:\develop\Java\java8\jdk\jre\lib\jfxswt.jar;
        D:\develop\Java\java8\jdk\jre\lib\jsse.jar;
        D:\develop\Java\java8\jdk\jre\lib\management-agent.jar;
        D:\develop\Java\java8\jdk\jre\lib\plugin.jar;
        D:\develop\Java\java8\jdk\jre\lib\resources.jar;
        D:\develop\Java\java8\jdk\jre\lib\rt.jar;
        E:\笔记\JavaSE\out\production\16.注解和反射;
        D:\develop\idea\IntelliJ IDEA 2019.1.1\lib\idea_rt.jar
         */

        /*双亲委派机制：定义一个类要去加载，会往上找，先去用户类加载器，再往上看扩展类加载器，再往上看根加载器，
        如果根加载器存在了，再手写一个一样的包，就会用根加载器里面的包，而不会用手写的包*/
    }
}
  • 程序不是凭空能运行的，由类加载器加载的，加载出来才能用

8.创建运行时类的对象

  • 创建运行时类的完整结构
    • 通过反射获取运行时类的完整结构： Field 、 Method 、 Constructor 、 Superclass 、 Interface 、 Annotation
      • 实现的全部接口
      • 所继承的父类
      • 全部的构造器
      • 全部的方法
      • 全部的 Field
      • 注解
      • 等等……
public class CreateAnObjectForTheRuntimeClass_GetClassInformation {
    public static void main(String[] args) throws Exception {
        Admin admin = new Admin();
        Class clazz = admin.getClass();

        //getName()：获得类的名字（包名 + 类名）
        System.out.println(clazz.getName());  //com.minami.b_reflection.Admin
        System.out.println();

        clazz = Class.forName("com.minami.b_reflection.Admin");

        //getSimpleName()：获得类的简单名字（类名）
        System.out.println(clazz.getSimpleName());  //Admin
        System.out.println();

        //getFields()：获得类的所有 public 属性
        Field[] fields = clazz.getFields();
        for (Field field : fields) {
            System.out.println(field);  //public java.lang.String com.minami.b_reflection.Admin.name
        }
        System.out.println();

        //getDeclaredFields()：获得类的 所有 属性（public + private）
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
            /*
            public java.lang.String com.minami.b_reflection.Admin.name
            private int com.minami.b_reflection.Admin.id  私有属性
            private int com.minami.b_reflection.Admin.age  私有属性
             */
        }
        System.out.println();

        //getField(String name)：获得类的 指定 public 属性
        Field field = clazz.getField("name");
        System.out.println(field);  //public java.lang.String com.minami.b_reflection.Admin.name
        System.out.println();

        //getDeclaredField(String name)：获得类的 指定 属性
        Field declaredField = clazz.getDeclaredField("name");
        System.out.println(declaredField);  //public java.lang.String com.minami.b_reflection.Admin.name
        System.out.println();

        //getMethods()：获得类的方法（本类及其父类的全部 public 方法）
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            System.out.println(method);
            /*
            public java.lang.String com.minami.b_reflection.Admin.toString()
            public java.lang.String com.minami.b_reflection.Admin.getName()
            public int com.minami.b_reflection.Admin.getId()
            public void com.minami.b_reflection.Admin.setName(java.lang.String)
            public void com.minami.b_reflection.Admin.setAge(int)
            public void com.minami.b_reflection.Admin.setId(int)
            public int com.minami.b_reflection.Admin.getAge()
            public final void java.lang.Object.wait() throws java.lang.InterruptedException
            public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
            public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
            public boolean java.lang.Object.equals(java.lang.Object)
            public native int java.lang.Object.hashCode()
            public final native java.lang.Class java.lang.Object.getClass()
            public final native void java.lang.Object.notify()
            public final native void java.lang.Object.notifyAll()
             */
        }
        System.out.println();

        //getDeclaredMethods()：获得类的方法（本类的全部（public + private）方法）
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
            /*
            public java.lang.String com.minami.b_reflection.Admin.toString()
            public java.lang.String com.minami.b_reflection.Admin.getName()
            public int com.minami.b_reflection.Admin.getId()
            public void com.minami.b_reflection.Admin.setName(java.lang.String)
            private void com.minami.b_reflection.Admin.test()  私有方法
            public void com.minami.b_reflection.Admin.setId(int)
            public int com.minami.b_reflection.Admin.getAge()
            public void com.minami.b_reflection.Admin.setAge(int)             */
        }
        System.out.println();

        //getMethod(String name, Class<?>... parameterTypes)：获得类的 指定 public 方法
        Method method = clazz.getMethod("getName");
        System.out.println(method);  //public java.lang.String com.minami.b_reflection.Admin.getName()
        method = clazz.getMethod("setName", String.class);  //传入 方法名 和 参数类型（因为方法重载，所以需要参数类型）
        System.out.println(method);  //public void com.minami.b_reflection.Admin.setName(java.lang.String)
        System.out.println();

        //getMethod(String name, Class<?>... parameterTypes)：获得类的 指定 方法
        Method declaredMethod = clazz.getDeclaredMethod("test");
        System.out.println(declaredMethod);  //private void com.minami.b_reflection.Admin.test()
        System.out.println();

        //getConstructors()：获得类的 所有 构造器
        Constructor[] constructors = clazz.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
            /*
            public com.minami.b_reflection.Admin()
            public com.minami.b_reflection.Admin(java.lang.String,int,int)
             */
        }
        System.out.println();

        //getConstructors(Class<?>... parameterTypes)：获得类的 指定 构造器
        System.out.println(clazz.getConstructor(String.class, int.class, int.class));  //public com.minami.b_reflection.Admin(java.lang.String,int,int)
    }
}

class Admin {
    public String name;
    private int id;
    private int age;

    public Admin() {
    }

    public Admin(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;
    }

    private void test() {}

    @Override
    public String toString() {
        return "Admin{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", age=" + age +
                '}';
    }
}
  • 小结
    • 在实际的操作中，取得类的信息的操作代码，并不会经常开发
    • 一定要熟悉java.lang.reflect包的作用，反射机制
    • 如何取得属性、方法、构造器的名称、修饰符等

9.有了 Class 对象，能做什么？

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

    1. 类必须有一个无参构造器
    2. 类的构造器的访问权限需要足够
    • 思考：
      • 难道没有无参构造器就不能创建对象了吗？只要在操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以实例化操作。步骤如下：
        1. 通过 Class 类的getDeclaredConstructor(Class<?>... parameterTypes)取得本类的指定形参类型的构造器
        2. 向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数
        3. 通过 Constructor 实例化对象

  • 调用指定的方法

    • 通过反射，调用类中的方法，通过Method类完成
      1. 通过Class类的getMethod(String name, Class<?>... parameterTypes)方法取得一个Method对象，并设置此方法操作时所需要的参数类型
      2. 之后使用Object invoke(Object obj, Object... args)进行调用，并向方法中传递要设置的obj对象的参数信息

    调用指定的方法

  • Object invoke(Object obj, Object... args)

    • Object对应原方法的返回值，若原方法无返回值，此时返回null
      • 若原方法为静态方法，此时形参Object obj可为null
      • 若原方法形参列表为空，则Object... args为null
      • 若原方法声明为private，则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法

  • setAccessible(boolean flag)

    • Method 和 Field 、Constructor 对象都有setAccessible(boolean flag)方法
    • setAccessible(boolean flag)作用是启动和禁用访问安全检查的开关
    • 参数值为true则指示反射的对象在使用时应该取消 Java 语言访问检查
      • 提高反射的效率。如果代码中必须使用反射，而该句代码需要频繁的被调用，那么请设置为true
      • 使得原本无法访问的私有成员也可以访问
    • 参数值为false则指示反射的对象应该实施 Java 语言访问检查
public class Reflection_CreateObjectsDynamically {
    public static void main(String[] args) throws Exception {
        //获得 Class 对象
        Class clazz = Class.forName("com.minami.b_reflection.AdminUser");

        //通过 new 创建对象
        AdminUser adminUser = new AdminUser();
        System.out.println(adminUser);  //AdminUser{name='null', id=0, age=0}

        //构造一个对象（本质是调用了类的无参构造器）
        adminUser = (AdminUser) clazz.newInstance();
        System.out.println(adminUser);  //AdminUser{name='null', id=0, age=0}

       //通过构造器 传递参数 创建对象
        Constructor constructor = clazz.getDeclaredConstructor(String.class, int.class, int.class);
        //通过反射调用普通方法
        adminUser = (AdminUser) constructor.newInstance("张三", 1, 23);  //AdminUser{name='张三', id=1, age=23}
        System.out.println(adminUser);

        //通过反射获取一个方法
        Method setName = clazz.getMethod("setName", String.class);
        //invoke(Object obj, Object... args)：激活（对象，"方法的值"）
        setName.invoke(adminUser, "张三");
        System.out.println(adminUser.getName());  //张三

        //通过反射操作属性，不能直接操作私有属性，需要关闭程序的安全检测
        Field age = clazz.getDeclaredField("age");
        age.setAccessible(true);  //关闭权限检测，可以访问私有属性
        age.set(adminUser, 23);
        System.out.println(adminUser.getAge());  //23
    }
}

class AdminUser {
    public String name;
    private int id;
    private int age;

    public AdminUser() {
    }

    public AdminUser(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;
    }

    private void test() {}

    @Override
    public String toString() {
        return "AdminUser{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", age=" + age +
                '}';
    }
}
  • 分析性能问题
public class Reflection_AnalyzePerformance {
    public static void main(String[] args) throws Exception {
        normalWay();  //普通方式调用0
        reflectionWay();  //反射方式调用106
        reflectionWaySetAccessible();  //反射方式调用，关闭检测61
    }
        //普通方式调用
        public static void normalWay() {
            UserAdmin userAdmin = new UserAdmin();

            long startTime = System.currentTimeMillis();
            for (int i = 0; i < 10000000; i++) {
                userAdmin.getName();
            }
            long endTime = System.currentTimeMillis();
            System.out.println("普通方式调用" + (endTime - startTime));
        }

        //反射方式调用
        public static void reflectionWay() throws Exception {
            UserAdmin userAdmin = new UserAdmin();
            Class clazz = userAdmin.getClass();
            Method getName = clazz.getDeclaredMethod("getName");

            long startTime = System.currentTimeMillis();
            for (int i = 0; i < 10000000; i++) {
                getName.invoke(userAdmin);
            }
            long endTime = System.currentTimeMillis();
            System.out.println("反射方式调用" + (endTime - startTime));
        }

        //反射方式调用，关闭检测
        public static void reflectionWaySetAccessible() throws Exception {
            UserAdmin userAdmin = new UserAdmin();
            Class clazz = userAdmin.getClass();
            Method getName = clazz.getDeclaredMethod("getName");
            getName.setAccessible(true);

            long startTime = System.currentTimeMillis();
            for (int i = 0; i < 10000000; i++) {
                getName.invoke(userAdmin);
            }
            long endTime = System.currentTimeMillis();
            System.out.println("反射方式调用，关闭检测" + (endTime - startTime));
        }
}

class UserAdmin {
    public String name;
    private int id;
    private int age;

    public UserAdmin() {
    }

    public UserAdmin(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;
    }

    private void test() {}

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

10.反射操作泛型

  • Java 采用泛型擦除的机制来引入泛型， Java 中的泛型仅仅是给编译器 javac 使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除
  • 为了通过反射操作这些类型， Java 新增了 ParameterizedType 、 GenericArrayType 、 TypeVariable 和 WildcardType 几种类型来代表不能被归一到 Class 类中的类型但是又和原始类型齐名的类型
  • ParameterizedType ：表示一种参数化类型，比如Collection<String>
  • GenericArrayType ：表示一种元素类型是参数化类型或者类型变量的数组类型
  • TypeVariable ：是各种类型变量的公共父接口
  • WildcardType ：代表一种通配符类型表达式
public class Reflection_GetGenerics {
    public static void main(String[] args) throws NoSuchMethodException {
        Method test = MyGetGenerics.class.getMethod("test", Map.class, List.class);

        //获取泛型参数类型
        Type[] genericParameterTypes = test.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println(genericParameterType);
            /*
            java.util.Map<java.lang.String, com.minami.b_reflection.MyUser>
            java.util.List<com.minami.b_reflection.MyUser>
             */
            if (genericParameterType instanceof ParameterizedType) {
                //获取泛型真实的参数信息
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                /*
                java.util.Map<java.lang.String, com.minami.b_reflection.MyUser>
                class java.lang.String
                class com.minami.b_reflection.MyUser
                java.util.List<com.minami.b_reflection.MyUser>
                class com.minami.b_reflection.MyUser
                 */
                }
            }
        }
        System.out.println();

        //获取泛型返回值类型
        test = MyGetGenerics.class.getMethod("test");
        Type genericReturnType = test.getGenericReturnType();
        System.out.println(genericReturnType);  //java.util.Map<java.lang.String, com.minami.b_reflection.MyUser>
        if (genericReturnType instanceof ParameterizedType) {
            //获取泛型真实的参数信息
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
                /*
                java.util.Map<java.lang.String, com.minami.b_reflection.MyUser>
                class java.lang.String
                class com.minami.b_reflection.MyUser
                 */
            }
        }
    }
}

class MyGetGenerics {
    public void test(Map<String, MyUser> map, List<MyUser> list) {
        System.out.println("test(parameter)");
    }

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

class MyUser {
    private String name;
    private int id;
    private int age;

    public MyUser() {
    }

    public MyUser(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 "MyUser{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", age=" + age +
                '}';
    }
}

11.反射操作注解

  • getAnnotations

  • getAnnotation

  • 练习： ORM

    • 了解什么是 ORM ？
      • Object Relationship Mapping （对象关系映射）
      • 类和表结构对应
      • 属性和字段对应
      • 对象和记录对应
    • 要求：利用注解和反射完成类和表结构的映射关系
public class Reflection_GetAnnotation {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class clazz = Class.forName("com.minami.b_reflection.MyGetAnnotation");

        //通过反射获得注解
        Annotation[] annotations = clazz.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);  //@com.minami.b_reflection.MyAnnotation(value=db_MyGetAnnotation)
        }

        //获得注解的 value 的值
        MyAnnotation myAnnotation = (MyAnnotation) clazz.getAnnotation(MyAnnotation.class);
        String value = myAnnotation.value();
        System.out.println(value);  //db_MyGetAnnotation

        //获得指定的注解
        Field name = clazz.getDeclaredField("name");
        MyField myField = name.getAnnotation(MyField.class);
        System.out.println(myField.columnName());  //db_name
        System.out.println(myField.type());  //varchar
        System.out.println(myField.length());  //3
    }
}

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

//作用于属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface MyField {
    String columnName();  //列名
    String type();  //数据类型
    int length();  //数据长度
}

@MyAnnotation("db_MyGetAnnotation")  //对应于数据库中的 db_MyGetAnnotation 表
class MyGetAnnotation {
    @MyField(columnName = "db_id", type = "int", length = 4)
    private int id;
    @MyField(columnName = "db_age", type = "int", length = 2)
    private int age;
    @MyField(columnName = "db_name", type = "varchar", length = 3)
    private String name;

    public MyGetAnnotation() {
    }

    public MyGetAnnotation(int id, int age, String name) {
        this.id = id;
        this.age = age;
        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;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "MyGetAnnotation{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
菁苧萌
关注
专栏目录
java注解和反射原理_Java中的注解和反射
weixin_35803802的博客
02-16 1290
最近又回顾了一下 Java 中的注解和反射知识点，注解在日常开发中使用很多，但是反射比较少。值得注意的是 Java 的各种框架底层源码中大量使用了注解和反射，阅读源码，这些是基本功，面试中这部分内容也经常问到。这里面概念不多，内容略微有些枯燥，但是通过一些简单的例子，能让我们明白一些基本概念和 API 的使用。所以，说到底，这篇博客只能算是一个简单的笔记，希望对你有帮助。 以前也写过枚举类和注解...
注解与反射
weixin_49512993的博客
07-18 1678
文章目录注解与反射一、注解的概念1、什么是注解（Annotation）？Annotation的作用：Annotation的格式：Annotation在哪里使用？2、内置注解@Override@Deprecated@SuppressWarings定义在java.lang.SuppressWarning中，用来抑制编译时的警告信息；3、元注解4、自定义注解二、反射的概念1、静态语言&动态语言动态语言2、Java Reflection3、java反射机制眼研究与应用java反射机制提供的功能4、Java反
Java进阶——注解和反射
万里顾一程的博客
03-26 6376
文章目录Java基础——注解和反射1、注解1.1、什么是注解(Annotation)1.2、内置注解1.3、自定义注解和元注解(meta-annotation)2、反射1、反射和反射机制2、CLass类3、哪些类型可以有Class对象4、类加载理解5、类加载器6、通过反射动态的创建对象7、反射操作注解 Java基础——注解和反射 1、注解 1.1、什么是注解(Annotation) 从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记， 注解的作
Java：注解和反射
Jocab_jl的博客
02-23 2046
（一）注解 1注解入门 Annotation是jdk1.5开始引入的新技术。 Annotation的作用： （1）不是程序本身，可以对程序作出解释； （2）可以被其他程序（例如编译器）读取。 Annotation的格式 “@注解名”，也可以带参数，例如：@SuppressWarnings(value=“unchcked”) Annotation在哪里使用？ 可以附加在package、class、method、field上，相当于给它们添加了额外的辅助信息，还可以通过反射机制编程实现对这些元数
Java 注解和反射详解
Woo_home的博客
09-15 3667
文章目录注解什么是注解？内置注解元注解@Target@Retention@Documented@Inherited自定义注解反射静态语言 VS 动态语言动态语言静态语言Java 反射机制概述Java 反射机制提供的功能Java 反射优点和缺点反射相关的主要 API理解 Class 类并获取 Class 实例Class 类Class 类的常用方法获取 Class 类的实例所有类型的 Class 对象Java 内存分析类的加载与 ClassLoader 的理解 注解 什么是注解？ Annotation 是从
反射与注解
wyy的博客
03-31 994
文章目录一、反射二、注解 一、反射 1.1反射引入 • 编译时知道类或对象的具体信息，此时直接对类和对象进行操作即可，无需反射（reflection） • 如果编译不知道类或对象的具体信息，此时应该如何做呢？使用反射来实现。比如类的名称放在XML文件中，属性和属性值放在XML文件中，需要在运行时读取XML文件，动态获取类的信息 • 反射的应用场合 o 在编译时根本无法知道该对象或类可能属于哪些类，程序只依靠运行时信息来发现该对象和类的真实信息 o 比如log4j，Servlet、SSM框架技术都用到了反射
android 注解和反射 (入门以及使用)
高级开发者进阶ing... QaQ
08-16 994
先来看一看今天的效果: 代码效果: 效果不重要,重要的是代码: 注解 官方解释: 从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。 百度百科 定义一个注解: public @interface SZJ{ } 元注解: 元注解是用来标示当前注解是干什么用的,什么时候用,常用的有2个 @Target E
Java入坑之注解和反射
qq_62377885的博客
04-16 1164
当我们理解了内置注解, 元注解和获取注解的反射接口后，我们便可以开始自定义注解了。创建自定义注解和创建一个接口相似，但是注解的interface关键字需要以@符号开头，我们可以为注解声明方法。// 元注解public @interface 注解名称{// 属性列表在Java中，我们可以使用@interface关键字来定义自己的注解，这和定义接口或类类似。@Retention(RetentionPolicy.RUNTIME) // 注解保留到运行时。
java 反射和注解
weixin_41765786的博客
07-19 1494
示例12】自定义注解}//如果只有一个配置参数，一般命名为value}@MyAnnoation(id=5,name="张三",scoreArr={78,89,34})}}}定义注解的关键字是@interface自定义注解中可以定义多个配置参数，不是成员方法,不是成员变量；说明参数的名称，以及参数值的类型如果只有一个配置参数，一般命名为value如果配置参数是value，并且只有一个配置参数，value可以省略。...
注解和反射(狂神) 笔记
weixin_43905212的博客
12-14 1430
视频链接 p1 什么是注解：不是程序本身，可以对程序作出解释，但是区别于注释，注解可以写入参数，通过反射机制来获取所注解信息的访问。 p2 元注解：用来注解其他注解，有4个标准的meta-annotation：@Target、@Retention、@Documented、@Inherited，前两个常用。 Target需要传入ElementType数组作为value表示使用范围，其中ElementType是一个枚举类enum，包括类、域、方法、参数等。 Retention表示注解在什么地方有效，SO
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
java注解和反射的12个demo.zip
04-28
Java注解和反射是Java编程中的重要特性，它们极大地增强了代码的灵活性和可维护性。在Java中，注解（Annotation）是一种元数据，它提供了将信息附加到代码（类、方法、变量等）的方式，而反射则允许我们在运行时检查...
java基础知识学习教程-12注解和反射.pptx
10-30
11. 案例：三酷猫的注解反射对比小程序 本节提供了一个案例，演示了如何使用注解和反射机制来实现一个小程序。 12. 练习和实验 本节提供了一些练习和实验题目，旨在帮助读者更好地理解和掌握注解和反射机制的知识点...
Java注解与反射原理说明
08-26
当注解与反射结合时，我们可以利用反射机制来读取和处理注解中的信息。在Java中，`AnnotatedElement`接口提供了获取注解的方法，包括`getAnnotations()`和`getAnnotation(Class<T> annotationClass)`。 1. `...
Java基础07
最新发布
m0_74977981的博客
11-11 476
如图下图：每个case中都有一个break，如果没有这个break，就不会跳出case，直到遇见break为止。
JAVA-01-变量
LJH_laura_li的博客
11-08 332
在方法、构造函数或块内部定义的变量。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
chusheng1840的博客
11-09 835
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 638
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
Java注解与反射机制详解
"Java中关于注解和反射机制的内容" 在Java编程中，注解（Annotation）和反射机制是两个非常重要的特性，它们极大地扩展了Java语言的功能和灵活性。 ### 注解 #### 1.1 注解简介 注解是自Java 5版本引入的一种元...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值