注解与反射

最新推荐文章于 2024-07-11 01:11:12 发布
最新推荐文章于 2024-07-11 01:11:12 发布
阅读量110 收藏
点赞数
分类专栏： 重学Java 文章标签： java 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Manjuas/article/details/112963872
版权
本文详细介绍了Java中的注解，包括内置注解、自定义注解以及元注解的使用。同时，深入探讨了Java反射机制，包括反射的概念、功能、优缺点以及如何通过反射获取类信息、创建对象、操作成员变量和方法。此外，还讲解了类的加载过程、类加载器的工作原理以及如何通过反射获取泛型信息和注解。
摘要由CSDN通过智能技术生成

1.注解入门

​ 注解 不是程序本身，但对程序可以做出解释，也可以被其他程序读取(编译器)

注解的格式: @+注解名，还可以加参数值
注解使用场合: package class method field(字段0)

2.内置注解

/*  @Override 就是注解，是重写的注解
    
    @Deprecated的程序元素是程序员不鼓励使用的程序元素，通常是因为它是危险的，或者因为存在更好的替代方法。编译器在不被弃用的代码中使用或覆盖不推荐使用的程序元素时发出警告。
    
    @SuppressWarnings("all")表示在注释元素（以及注释元素中包含的所有程序元素）中应该抑制命名的编译器警告。请注意，给定元素中抑制的一组警告是所有包含元素中抑制的警告的超集。例如，如果您注释一个类来抑制一个警告并注释方法来抑制另一个警告，则两个警告将在该方法中被抑制。
*/

3.自定义注解，元注解

3.1元注解

  1. 作用：负责注解其他注解，Java中定义了四个标准的meta-annotation类型，被用来提供对其他annotation类型作说明
  2. 四个类分别为：
    1. @Target: 用于描述注解的适用范围
    2. @Retention 表示在什么级别保存该注释信息，用于描述注解的生命周期
    3. @Document：说明该注解将被包含在Javadoc中
    4. @Inher：说明子类可以继承父类中的注解

3.2自定义注解

package Annotation;

import java.lang.annotation.*;

@MyAnnotation(name = "Lee",schools = {"西电大"})
public class Test02 {
}


@Documented // 可以包含在JavaDoc文档中
@Inherited //子类可以继承父类的注解
@Retention(RetentionPolicy.CLASS)//保留注解到什么级别：RUNTIME>CLASS>SOURCE
@Target(ElementType.TYPE) //作用域
@interface MyAnnotation{
    //注解的参数问题：类型 + 参数名 + ();
    //1. 只有一个参数的话， 一般使用value作为参数名 赋值可以省略前边的“=”
    //2. 可以有默认值，可以不用赋值
    //3. 不分先后顺序
    String[] schools();
    String name();
    int age() default 18;
}

4.反射概述

4.1概述

  1. 官方解释：

    在程序运行的过程中，可以动态的创建对象，并获取对象的基本信息，包括属性、方法等；

  2. 虽然你可以在Java中由很多对象，但这些对象在反射面前就是裸奔的，反射可以打破Java语言的封装特性。

静态：运行时不可变的语言。如：C，C++，java

动态：运行时可以改变其结构的语言。eg：新的函数、对象甚至代码可以被引进，已有的函数可以被删除……**就是运行时代码可以根据某些条件改变自身结构。**如JavaScript、PHP、Python……

Java因为反射机制，可以获得类似动态语言的特性，Java可以称为“准动态语言”

**正常方式：**引入所需要的包类名称—>通过new实例化—>获得实例对象

**反射方式: ** 实例化对象—>getClass()方法—>得到完整的包类名称

4.2Java反射机制提供的功能：

  1. 在运行时判断任意一个对象所属的类
  2. 在运行时构造任意一个类的对象
  3. 在运行时判断任意一个类所具有的成员变量和方法
  4. 在运行时获取泛型信息
  5. 在运行时调用任意一个对象的成员变量和方法
  6. 在运行时处理注解
  7. 生成动态代理
  8. ……

4.3Java反射的优缺点：

​ 优点：可以实现动态的创建对象和编译，灵活性

​ 缺点：对性能有一定的影响。使用反射基本上是一种解释操作，jvm满足我们的要求，这类操作总是慢于直接执行相同的操作

5.理解class类并获取Class实例

package reflection;
//测试Class类的几种创建方式
public class test01 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person student = new Student();
        System.out.println("这个人是--->" + student.name);

        //1. 通过对象获得
        Class c1 = student.getClass();
        System.out.println(c1.hashCode());

        //2. Class.forname()获得
        Class c2 = Class.forName("reflection.Student");
        System.out.println(c2.hashCode());

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

        //4. 基本内置对象都有一个Type的属性
        Class c4 = Integer.TYPE;
        System.out.println(c4);

        //5. 获得父类对象
        Class c5 = c1.getSuperclass();
        System.out.println(c5);
    }

}
class Person{
    private int id;
    private int age;
    String name;

    public Person() {
        this.name = "老师";
    }

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

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

class Teacher extends Person{
    public Teacher(){
        this.name = "老师";
    }
}

所有类型的class

//所有类型的class
public class test02 {
    public static void main(String[] args) {
        Class c1 = Object.class; //类
        Class c2 = Runnable.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[100];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());
    }
}

6.类的加载与ClassLoader

6.1类的加载

//类加载内存分析
public class Test03 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.m);
        /*
        1.将A类加载到内存 ， 产生该类的Class对象
        2.链接 给类变量设置默认初始值 即 m=0；
        3.初始化
            <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类的无参构造");
    }
}

6.2类的初始化

package reflection;

public class Test04 {
    static {
        System.out.println("main类被加载");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        //什么时候会发生类的初始化(主动引用时)
        //1.new一个类的对象时
        //Son son = new Son();
        //2.调用静态变量和静态方法时
        //System.out.println(Son.a);
        //3.通过反射引用时
        //Class c1 = Class.forName("reflection.Son");
        //System.out.println(c1);

        //不会发生类的初始化(被动引用)
        //1.通过子类调用父类的静态变量 , 不会导致子类被初始化
        //System.out.println(Son.b);
        //2.数组定义类
        Son[] sons = new Son[5];
    }
}
class Father{
    static {
        System.out.println("父类被加载");
    }
    static int b = 20;
}
class Son extends Father{
    static{
        System.out.println("子类被加载");
    }
    static int a = 10;

    public Son() {
        System.out.println("子类的无参构造");
    }
}

6.3类的加载器

package reflection;


//类的加载器
/*
根加载器-->负责Java的核心类库-->rt
拓展加载器-->负责Java类库中另一个类库-->ext
用户加载器-->
 */
public class Test05 {
    public static void main(String[] args) throws ClassNotFoundException {
        //获得系统类的加载器(最常用的加载器)--->用户加载器
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        System.out.println(classLoader);
        //获得当前类加载器的父类--->拓展加载器
        classLoader = classLoader.getParent();
        System.out.println(classLoader);
        //获得拓展加载器的父类--->根加载器(C/C++编写java无法直接显示)
        classLoader = classLoader.getParent();
        System.out.println(classLoader);

        //测试当前类是哪一个加载器加载的
        classLoader = Class.forName("reflection.Test05").getClassLoader();
        System.out.println(classLoader);//用户加载器
        //测试jdk内部类
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);//根加载器

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

        //双亲委派机制-->从用户加载器逐级向上检查 写与内置类重名类时 自动覆盖
        /*
        双亲委派机制，的确是防止同名包、类与 jdk 中的相冲突，实际上加载类的时候，先通知 appLoader，看 appLoader 是否已经缓存，没有的话，appLoader 又委派给他的父类加载器(extLoader)询问，看他是不是能已经缓存加载,没有的话，extLoader 又委派他的父类加载器(bootstrapLoader)询问，BootstrapLoader看是不是自己已缓存或者能加载的，有就加载，没有再返回 extLoader，extLoader 能加载就加载，不能的话再返回给 appLoader 加载，再返回的路中，谁能加载，加载的同时也加缓存里。正是由于不停的找自己父级，所以才有 Parents 加载机制，翻译过来叫 双亲委派机制。
        /*
        D:\JAVA\jdk\jre\lib\charsets.jar;
        D:\JAVA\jdk\jre\lib\deploy.jar;
        D:\JAVA\jdk\jre\lib\ext\access-bridge-64.jar;
        D:\JAVA\jdk\jre\lib\ext\cldrdata.jar;
        D:\JAVA\jdk\jre\lib\ext\dnsns.jar;
        D:\JAVA\jdk\jre\lib\ext\jaccess.jar;
        D:\JAVA\jdk\jre\lib\ext\jfxrt.jar;
        D:\JAVA\jdk\jre\lib\ext\localedata.jar;
        D:\JAVA\jdk\jre\lib\ext\nashorn.jar;
        D:\JAVA\jdk\jre\lib\ext\sunec.jar;
        D:\JAVA\jdk\jre\lib\ext\sunjce_provider.jar;
        D:\JAVA\jdk\jre\lib\ext\sunmscapi.jar;
        D:\JAVA\jdk\jre\lib\ext\sunpkcs11.jar;
        D:\JAVA\jdk\jre\lib\ext\zipfs.jar;
        D:\JAVA\jdk\jre\lib\javaws.jar;
        D:\JAVA\jdk\jre\lib\jce.jar;
        D:\JAVA\jdk\jre\lib\jfr.jar;
        D:\JAVA\jdk\jre\lib\jfxswt.jar;
        D:\JAVA\jdk\jre\lib\jsse.jar;
        D:\JAVA\jdk\jre\lib\management-agent.jar;
        D:\JAVA\jdk\jre\lib\plugin.jar;
        D:\JAVA\jdk\jre\lib\resources.jar;
        D:\JAVA\jdk\jre\lib\rt.jar;
        D:\JavaEE\projects\注解与反射\out\production\注解与反射;
        D:\JavaEE\idea\IntelliJ IDEA 2020.2.3\lib\idea_rt.jar
         */
    }
}

7.创建运行时类的对象

7.1通过反射获取类的信息

package reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
@SuppressWarnings("all")
//获得类的信息
//获得指定类时，参数均为class对象
public class Test06 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("reflection.Person");

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

        //获取类的属性
        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 name = c1.getDeclaredField("name");//获取指定属性，同上
        System.out.println(name);
        System.out.println("====================");

        //获取类的方法
        Method[] methods = c1.getMethods();//获取当前类及其父类的所有public方法
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("====================");

        methods = c1.getDeclaredMethods();//获取当前类的所有方法
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("====================");
        System.out.println(c1.getMethod("getName", null));
        System.out.println(c1.getDeclaredMethod("setAge", int.class));
        System.out.println("====================");

        //获取类的构造器
        Constructor[] constructors = c1.getConstructors();//获取类的public构造器
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        //获得类的指定构造器
        Constructor constructor
                = c1.getConstructor(int.class,int.class,String.class);
        System.out.println(constructor);
    }
}

7.2动态创建类对象及操作类的信息

package reflection;

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

//动态创建对象执行方法
/*
    Method,Field,Constructor对象都有setAccessible()方法
    setAccessible()为了开启或关闭安全检测
    true为关闭
        1.提高反射的效率
        2.使得原本是私有权限的也可以被访问
 */
public class Test07 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class c1 = Class.forName("reflection.Person");

        Person person = (Person) c1.newInstance();//必须要有无参构造器
        System.out.println(person);

        //当没有无参构造器时
        /*
        1.通过Class对象获取一个构造器
        2.向构造器中传入参数(对象，参数值)
         */
        Constructor constructor
                = c1.getDeclaredConstructor(int.class, int.class, String.class);
        Person person1 = (Person)constructor.newInstance(001, 18, "小明");
        System.out.println(person1);

        //通过反射调用普通方法
        /*
        1.创建一个对象
        2.通过反射获取一个方法
        3.得到的方法通过invoke(对象，参数值)设置参数
         */
        Person person3 = (Person) c1.newInstance();
        Method setName = c1.getMethod("setName", String.class);
        setName.invoke(person3,"小刚");
        System.out.println(person3);

        //通过反射操作属性
        /*
        1.获取属性
        2.给私有属性关闭安全检测setAccessible(true)
        3.通过set(对象，参数值)操作属性
         */
        Person person4 = (Person) c1.newInstance();
        Field age = c1.getDeclaredField("age");
        age.setAccessible(true);
        age.set(person4,18);
        System.out.println(person4);
    }
}

7.3性能测试

package reflection;

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

//测试性能
public class Test08 {
    //普通方式
    public static void test1(){
        Person person = new Person();

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 10_0000_0000; i++) {
            person.getName();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通方式需要："+(endTime-startTime)+"ms");
    }

    //反射方式
    public static void test2() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class c1 = Person.class;
        Person person = (Person)c1.newInstance();
        Method getName = c1.getMethod("getName");

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 10_0000_0000; i++) {
            getName.invoke(person,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射方式需要："+(endTime-startTime)+"ms");
    }

    //反射方式 关闭安全检测
    public static void test3() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class c1 = Person.class;
        Person person = (Person)c1.newInstance();
        Method getName = c1.getMethod("getName");
        getName.setAccessible(true);

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 10_0000_0000; i++) {
            getName.invoke(person,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("关闭检测需要："+(endTime-startTime)+"ms");
    }

    public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
        test1();//3ms
        test2();//2128ms
        test3();//1038ms
    }
}

7.4获取泛型

package reflection;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Map;

//通过反射获取泛型
public class Test09 {

    public static void test1(Map<String,Person> map){

    }
    public static Map<String,Person> test2(){
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {
        Method method = Test09.class.getMethod("test1", Map.class);
        Type[] parameterTypes = method.getGenericParameterTypes();
        for (Type parameterType : parameterTypes) {
            System.out.println(parameterType);
            if(parameterType instanceof ParameterizedType)//是否为参数化类型
            {
                //如果为参数化类型，强制转换为参数化类型，获得其真实的参数类型
                Type[] actualTypeArguments = ((ParameterizedType) parameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }
        method = Test09.class.getMethod("test2",null);
        Type genericReturnType = method.getGenericReturnType();
        System.out.println(genericReturnType);
        if(genericReturnType instanceof ParameterizedType){
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }
}

7.5获取注解

package reflection;

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

//通过反射获取注解
public class Test10 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Student1.class;
        TableAnnotation annotation = (TableAnnotation)c1.getAnnotation(TableAnnotation.class);
        System.out.println(annotation);
        System.out.println(annotation.value());

        //获得属性的注解
        Field id = c1.getDeclaredField("id");
        FieldAnnotation annotation1 = id.getAnnotation(FieldAnnotation.class);
        System.out.println(annotation1);
        System.out.println(annotation1.column());
        System.out.println(annotation1.type());
        System.out.println(annotation1.length());
    }
}

@TableAnnotation("db_Student")
class Student1{
    @FieldAnnotation(column = "db_id",type = "int",length = 10)
    private int id;
    @FieldAnnotation(column = "db_age",type = "int",length = 3)
    private int age;
    @FieldAnnotation(column = "db_name",type = "String",length = 5)
    private String name;

    public Student1() {
    }

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

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldAnnotation{
    String column();
    String type();
    int length();
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableAnnotation{
    String value();
}
Manjuas
关注
专栏目录
Java反射、注解
浅谈Android
09-25 1836
最近本着不求甚解的态度重温了一下主流框架的源码，所以趁热打铁的总结一下，学习框架或开发框架所必备的基础知识： Java反射 Java注解 注解代码自动生成 Java动态代理 AOP 一、反射 1.1、简介 本文简单总结一下Java反射和注解，反射可以算是必备条件了，基本学习的主流框架中都会看到反射的身影，他的灵活使用也为很多逻辑的扩展提供了可能，通过Java的反射机制，可以在程序中访...
反射注解
街角
06-28 186
反射注解 开发工具与关键技术：myEclipse javaEE 作者：林国佳 撰写时间：201806027 通过反射来获取注解 生成 mysql表 先自定义两个注解 存放 表的属性 2. import java.lang.annotation.ElementType; 3. import java.lang.annotation.Retention; 4. import java.l...
通过反射获取注解（java）
最新发布
weixin_51395608的博客
07-11 1443
通过反射获取注解，注解使用
反射，注解
qq_43516208的博客
12-02 151
//注解 @UserInfo(userName = "枫叶",userPassword = "123456") public class Person { public String nikeName="枫叶"; public String name; private String age; private String idNum; public Per...
反射-注解
weixin_42547039的博客
10-27 578
注解 什么是注解？ 类似一个标签，给字段、方法、类、做一个标记 注解不仅仅是通过反射一种方式来使用，也可以使用APT在编译期处理 为什么要用注解？ 使用它们修饰我们的代码， 可以让我们提高程序的开发效率。 以及对代码施以规范，让代码更加有可读性 元注解 定义注解的存活时间，注解运用的地方等 @Target 说明了Annotation所修饰的对象范围 TYPE:用于描述类、接口(包括注解类型) 或enum声明 METHOD:用于描述方法 CONSTRUCTOR:用于描述构造器 PACKAGE:用于描述包
反射、注解
BNMZY的博客
04-04 144
反射 基本 定义：将各类的各个部分封装为其他对象（如方法集） 好处 可以在程序运行过程中，操作这些对象 可以解耦，提高程序扩展性 获取Class //第一阶段获取 Class class1 = Class.forName("反射.entity.Person"); //第二阶段获取 Class class2 = Person.class; //第三阶段获取 Person person ...
Java注解与反射原理说明
08-26
当注解与反射结合时，我们可以利用反射机制来读取和处理注解中的信息。在Java中，`AnnotatedElement`接口提供了获取注解的方法，包括`getAnnotations()`和`getAnnotation(Class<T> annotationClass)`。 1. `...
反射操作注解与反射操作泛型.docx
04-16
反射操作注解与反射操作泛型 在 Java 编程中，反射操作和泛型是两个重要的概念。反射操作是指在运行时检查和修改类、对象、方法、字段等信息的能力，而泛型是指在编译时检查和限制类型的能力。本文将详细介绍反射...
Android-注解与反射注解知识点反射知识点注解java反射
08-13
6. **注解与反射**：反射可以读取类、方法、字段上的注解信息，这在运行时动态处理逻辑、实现插件化等方面非常有用。 在`AnnotationDemo-master`这个项目中，可能包含了注解和反射的实践案例，例如通过注解定义接口...
注解与反射高效开发法.pdf
05-26
总之，注解与反射是Java语言的核心高级特性之一，它们能够提供强大的代码动态性，对于实现框架设计、简化代码编写等都有极大的帮助。Java开发者应当充分理解和掌握这些高级特性，以便在实际开发中运用自如。
Java 注解和反射详解
Woo_home的博客
09-15 3627
文章目录注解什么是注解？内置注解元注解@Target@Retention@Documented@Inherited自定义注解反射静态语言 VS 动态语言动态语言静态语言Java 反射机制概述Java 反射机制提供的功能Java 反射优点和缺点反射相关的主要 API理解 Class 类并获取 Class 实例Class 类Class 类的常用方法获取 Class 类的实例所有类型的 Class 对象Java 内存分析类的加载与 ClassLoader 的理解 注解 什么是注解？ Annotation 是从
反射+注解
weixin_42634971的博客
04-12 124
IDEA基本设置 设置编码格式 Configure - Settings - Editor - File Encodings 将三个编码全部设置为UTF-8 启用Ctrl+滑轮缩放代码 Configure - Settings - Editor - General 将右边第二个勾选中。 启用鼠标悬浮智能提示 Configure - Settings - Editor - General ...
注解和反射.代码部分
qq_54803395的博客
06-07 112
annotation package com.kuang.annotation; import java.util.ArrayList; import java.util.List; public class Test01 extends Object{ @Override public String toString() { return super.toString(); } //Deprecated 不推荐程序员使用，但是可以使用，或者存在更好
反射和注解
welcomword的博客
08-01 670
反射和注解 1. 概述 1.1 注解 注解（Annotation）和反射（reflection）是许多Java框架的底层，例如Mybatis，SpringBoot等。 注解（Annotation），“注”，即注释（comment），这是方便我们理解所产生的注解名；“解”，即注解的真正意义，它由程序来进行解析 Annotation是JDK5.0开始引入的一个新技术 Annotation的作用 它不是程序，但可以对程序作出解释（和注释Comment类似） 可以被其它程序（例如：编译器等）读取 Annot
day01【基础加强】_Junit单元测试、反射、注解
爱洗澡的拉布拉多的博客
12-30 215
今日内容 1. Junit单元测试 2. 反射 3. 注解
利用反射操作注解
yym201910101的博客
04-05 348
利用反射操作注解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值