Java进阶之注解

最新推荐文章于 2024-01-12 16:59:53 发布
最新推荐文章于 2024-01-12 16:59:53 发布
阅读量329 收藏 1
点赞数
分类专栏： Java进阶 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20025033/article/details/112432048
版权

文章目录

注解（Annotation）

第一部分：Annotation简单说明

Java注解（Annotation），又称Java标注，是从JDK1.5开始引入的一种机制。

Java语言中的类、方法、变量、参数和包等都可以被Java注解进行标注，和Javadoc不懂，Java标注可以通过反射获取其标注的内容；在编译期生成类文件的同时，标注就被嵌入到字节码中，Java虚拟机可以保留主键内容，在运行时可以获取到标注的内容。

第二部分：Annotation整体架构

有关Annotation架构，可以先看看下图：

image-20210110110739779

上图分为左右两部分

  • 左侧部分：围绕Annotation、RetentionPlicy、ElementType这三个类的对应关系，如下：
    1. Annotation和RetentionPlicy是1：1的关系，即1个Annotation对应1个RetentionPolicy，具体就是1个Annotation对象，只有唯一的RetentionPolicy属性
    2. Annotation和ElementType是1：N的关系，即1个Annotaion对应多个ElementType，具体就是1个Annotation对象，可以有多个ElementType属性
  • 右侧部分：
    1. 围绕Annotation的继承体系展开的，Annotation有许多实现类，包括：Deprecated、Documented、Inherited、Override、Retention、Target等

第三部分：Annotation组成部分

Annotation组成概述

Annocation组成围绕：Annotation、RetentionPlicy、ElementType这个三个类，如下如：

image-20210110111842446

Annotation组成明细

Annotation、RetentionPlicy、ElementType类内容如下：

  1. Annotation

    package java.lang.annotation;
/**
 * @author  Josh Bloch
 * @since   1.5
 */
public interface Annotation {
    boolean equals(Object obj);   
    int hashCode();
    String toString();
    Class<? extends Annotation> annotationType();
}

  2. RetentionPlicy

    package java.lang.annotation;

/**
 * @author  Joshua Bloch
 * @since 1.5
 */
public enum RetentionPolicy {
	/*Annotation信息仅存在与编译器处理期（编译期），编译器处理完后就没有该Annotation信息了*/
    SOURCE,
	/*编译器将Annotaion信息存储到class文件中，它是默认行为*/
    CLASS,
    /*编译器将Annotation信息存储到class文件中，并且可以由JVM加载*/
    RUNTIME
}

  3. ElementType

    package java.lang.annotation;

/**
 * @author  Joshua Bloch
 * @since 1.5
 */
public enum ElementType {
	
    TYPE,			/*类、接口（包含注释类型）或枚举声明*/
    
    FIELD,			/*字段（包含枚举常量）*/
   
    METHOD, 		/*方法声明*/
	
    PARAMETER,		/*参数声明*/
	
    CONSTRUCTOR,	/*构造器声明*/
	
    LOCAL_VARIABLE,	/*局部变量声明*/
	
    ANNOTATION_TYPE,/*注释类型声明*/
	
    PACKAGE			/*包声明*/
}

说明：

  1. Annotation是一个接口类，包含4个抽象方法

  2. RetentionPolicy是Enum枚举类，它用来指定Annotation的策略，即：不同的RetentionPolicy类型的Annotation作用域不同，RetentionPolicy三种不同的策略

    • SOURCE

      意味着：Annotation 仅存在于编译器处理期间，编译器处理完之后，该 Annotation 就没用了。 例如，" @Override" 标志就是一个 Annotation。当它修饰一个方法的时候，就意味着该方法覆盖父类的方法，代表子类重写父类的方法；并且在编译期间会进行语法检查！编译器处理完后，"@Override" 就没有任何作用了。

    • CLASS

      意味着：编译器将 Annotation 存储于class 文件中，它是 Annotation 的默认行为

    • RUNTIME

      意味着：编译器将 Annotation 存储于 class 文件中，并且可由JVM读入

  3. ElementType是Enum枚举类，它用来指定Annotation的类型，即：Annotation用来修饰什么，比如ElementType.TYPE表示Annotation只能用来修改类、接口等；ElementType.METHOD表示Annotation只能用来修饰方法；如果是多个值{ElementType.TYPE,ElementType.METHOD}表示Annotation既可以修饰类，又可以修饰方法。

第四部分：Annotation实现部分

Annotation实现类的语法定义

自定义Annotation实现：

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
}

使用自定义的Annotation：

package annotation;
@MyAnnotation
public class Test {
}

说明：

上述我们自定义了一个Annotation，MyAnnotation，这样我们就可以在Test这个类中使用了。

(01) @interface
使用@interface定义注解时，意味着它实现了java.lang.annotation.Annotation接口，即该注解就是一个Annotation。
定义Annotation时，@interface是必须的。
注意：它和我们通常的implemented实现接口的方法不同。Annotation接口的实现细节都由编译器完成。通过@interface定义注解后，该注解不能继承其他的注解或接口。

(02) @Documented
类和方法的Annotation在缺省情况下是不出现在javadoc中的。如果使用@Documented修饰该Annotation，则表示它可以出现在javadoc中。
定义Annotation时，@Documented可有可无；若没有定义，则Annotation不会出现在javadoc中。

(03) @Target(ElementType.TYPE)
前面我们说过，ElementType 是Annotation的类型属性。而@Target的作用，就是来指定Annotation的类型属性。
@Target(ElementType.TYPE) 的意思就是指定该Annotation的类型是ElementType.TYPE。这就意味着，MyAnnotation1是来修饰“类、接口（包括注释类型）或枚举声明”的注解。
定义Annotation时，@Target可有可无。若有@Target，则该Annotation只能用于它所指定的地方；若没有@Target，则该Annotation可以用于任何地方。

(04) @Retention(RetentionPolicy.RUNTIME)
前面我们说过，RetentionPolicy 是Annotation的策略属性，而@Retention的作用，就是指定Annotation的策略属性。
@Retention(RetentionPolicy.RUNTIME) 的意思就是指定该Annotation的策略是RetentionPolicy.RUNTIME。这就意味着，编译器会将该Annotation信息保留在.class文件中，并且能被虚拟机读取。
定义Annotation时，@Retention可有可无。若没有@Retention，则默认是RetentionPolicy.CLASS。

Annotation的Java自带的实现类

image-20210110121743475

Java自带定义了一套注解，共有7个，3个在java.lang包下，4个在java.lang.annotation包中

Java自带的注解可以分为作用在代码的注解和作用在其他注解的注解（元注解）

  • 作用在代码的注解
    • @Override：检查该方法是否是重写方法。如果发现其父类，或者是引用的接口中并没有该方法时，会报编译错误。
    • @Deprecated：标记过时方法。如果使用该方法，会报编译警告。
    • @SuppressWarnings：指示编译器去忽略注解中声明的警告。
  • 作用在其他注解的注解（元注解）
    • @Retention：标识这个注解怎么保存，是只在代码中，还是编入class文件中，或者是在运行时可以通过反射访问。
    • @Documented：标记这些注解是否包含在用户文档中
    • @Target： 标记这个注解应该是哪种 Java 成员。
    • @Inherited：标记这个注解是继承于哪个注解类(默认 注解并没有继承于任何子类)

从Java7开始，增加了 3个注解

  • @SafeVarargs：Java 7 开始支持，忽略任何使用参数为泛型变量的方法或构造函数调用产生的警告。
  • @FunctionalInterface：Java 8 开始支持，标识一个匿名函数或函数式接口
  • @Repeatable：Java 8 开始支持，标识某注解可以在同一个声明上使用多次。

  1. @Override 定义如下：

    package java.lang;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

    说明：

    • @interface：用来修饰Override，意味着Override实现了 java.lang.annotation.Annotation 接口；即Override是一个注解。
    • @Override：检查该方法是否是重写方法。如果发现其父类，或者是引用的接口中并没有该方法时，会报编译错误。
    • @Target：指定了Override注解的类型是METHOD，意味着@Override注解只能用来标注“方法”
    • @Retention：指定了Override注解的策略是RetentionPolicy.SOURCE，意味着注解仅存在于编译器处理期间，编译器处理完之后，该 Annotation 就没用了

    实例：

    以下的实例中，父类ReflectFather中有一个testFather方法，子类ReflectDemo如果重写了testFather方法，则会在子类重写的方法上用@Override注解进行标注，具体如下：

    package helloword;

/**
 * 父类
 */
public class ReflectFather {
    public void testFather(String name){
    }
}
//-----------------------------------------------------------------

package helloword;

/**
 * 子类
 */
public class ReflectDemo extends ReflectFather{
    @Override
    public void testFather(String name) {
        super.testFather(name);
    }
}

  2. @Deprecated的定义如下：

    package java.lang;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.LOCAL_VARIABLE, ElementType.METHOD, ElementType.PACKAGE, ElementType.PARAMETER, ElementType.TYPE})
public @interface Deprecated {
}

    说明：

    • @interface：用来修饰Deprecated，意味着Deprecated实现了 java.lang.annotation.Annotation 接口；即Deprecated是一个注解。
    • @Deprecated： 它的作用是所标注内容，不再被建议使用。
    • @Retention：指定了Deprecated注解的策略是RetentionPolicy.RUNTIME，意味着，编译器会将 Deprecated的信息保留在 .class 文件中，并且能被虚拟机读取。
    • @Target：指定了Deprecated注解的类型是ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.LOCAL_VARIABLE, ElementType.METHOD, ElementType.PACKAGE, ElementType.PARAMETER, ElementType.TYPE，意味着@Deprecated可以用来标注构造器、字段、局部变量、方法、包、参数、类或接口

    实例：

    public class ReflectDemo extends ReflectFather{
    @Deprecated
    private String name ;

    public ReflectDemo() {
    }

    @Deprecated
    public ReflectDemo(String name) {
        this.name = name;
    }

    @Override
    @Deprecated
    public void testFather(String name) {
        super.testFather(name);
    }

    public static void main(String[] args) {
        ReflectDemo  reflectDemo  = new ReflectDemo();
        //java不建议使用该构造方法
        reflectDemo = new ReflectDemo("");
        //java不建议使用该方法
        reflectDemo.testFather("");
        //java不建议使用该字段
        String name =  reflectDemo.name;
        //java不建议使用该类
        Son son = new Son();

        @Deprecated
        int age = 18;

        System.out.println(age);
    }

    @Deprecated
    static class Son{
    }
}

    image-20210110151656206

  3. @SuppressWarnings的定义如下：

    package java.lang;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.CONSTRUCTOR, ElementType.LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
    String[] value();
}

    说明：

    • @interface：用来修饰SuppressWarnings，意味着SuppressWarnings实现了java.lang.annotation.Annotation 接口；即SuppressWarnings是一个注解。

    • @SuppressWarnings： 它的作用是指示编译器去忽略注解中声明的警告。"@SuppressWarnings(value={“deprecation”, “unchecked”})" 表示对“它所标注的内容”中的 “SuppressWarnings不再建议使用警告”和“未检查的转换时的警告”保持沉默。

    • @Retention：指定了SuppressWarnings注解的策略是RetentionPolicy.SOURCE，意味着注解仅存在于编译器处理期间，编译器处理完之后，该 Annotation 就没用了

    • @Target：指定了SuppressWarnings注解的类型是ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.CONSTRUCTOR, ElementType.LOCAL_VARIABLE，意味着@Deprecated可以用来标注构造器、字段、局部变量、方法、包、参数、类或接口

    • String[] value(); 意味着，SuppressWarnings能指定参数

      deprecation  -- 使用了不赞成使用的类或方法时的警告
unchecked    -- 执行了未检查的转换时的警告，例如当使用集合时没有用泛型 (Generics) 来指定集合保存的类型。
fallthrough  -- 当 Switch 程序块直接通往下一种情况而没有 Break 时的警告。
path         -- 在类路径、源文件路径等中有不存在的路径时的警告。
serial       -- 当在可序列化的类上缺少 serialVersionUID 定义时的警告。
finally      -- 任何 finally 子句不能正常完成时的警告。
all          -- 关于以上所有情况的警告。

    实例：

    image-20210110152938636

  4. @Retention的定义如下：

    package java.lang.annotation;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.ANNOTATION_TYPE})
public @interface Retention {
    RetentionPolicy value();
}

    说明：

    • @interface：用来修饰Retention，意味着Retention实现了java.lang.annotation.Annotation 接口；即Retention是一个注解。
    • @Retention： 它的作用是指示编译器去忽略注解中声明的警告。
    • @Retention：指定了Retention注解的策略是RetentionPolicy.RUNTIME，意味着，编译器会将 Retention的信息保留在 .class 文件中，并且能被虚拟机读取。
    • @Target：指定了Retention注解的类型是ElementType.ANNOTATION_TYPE，意味着@Retention只能被用来标注“Annotation类型”

    实例：

    package java.lang.annotation;

@Documented
@Retention(RetentionPolicy.RUNTIME)//在注解上使用@Retention
@Target({ElementType.ANNOTATION_TYPE})
public @interface Retention {
    RetentionPolicy value();
}

package java.lang;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.CONSTRUCTOR, ElementType.LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)//在注解上使用@Retention
public @interface SuppressWarnings {
    String[] value();
}

  5. @Documented的定义如下：

    package java.lang.annotation;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.ANNOTATION_TYPE})
public @interface Documented {
}

    说明：

    • @interface：用来修饰Documented，意味着Documented实现了java.lang.annotation.Annotation 接口；即Documented是一个注解。
    • @Documented： 它的作用是标记这些注解是否包含在用户文档中。
    • @Retention：指定了Documented注解的策略是RetentionPolicy.RUNTIME，意味着，编译器会将 Documented的信息保留在 .class 文件中，并且能被虚拟机读取。
    • @Target：指定了Documented注解的类型是ElementType.ANNOTATION_TYPE，意味着@Documented只能被用来标注“Annotation类型”

    实例：

    image-20210110154120269

    如上图所示：如果@Documented使用在类上时，对应的IDE就会提示“@Documented not applicable to type”

  6. @Target的定义如下：

    package java.lang.annotation;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.ANNOTATION_TYPE})
public @interface Target {
    ElementType[] value();
}

    说明：

    • @interface：用来修饰Target，意味着Target实现了java.lang.annotation.Annotation 接口；即Target是一个注解。
    • @Target： 它的作用是指定注解类型。
    • @Retention：指定了Target注解的策略是RetentionPolicy.RUNTIME，意味着，编译器会将 Target的信息保留在 .class 文件中，并且能被虚拟机读取。
    • @Target：指定了Target注解的类型是ElementType.ANNOTATION_TYPE，意味着@Target只能被用来标注“Annotation类型”

    实例：

    package java.lang.annotation;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.ANNOTATION_TYPE})//指定注解的类型
public @interface Target {
    ElementType[] value();
}

  7. @Inherited的定义如下：

    package java.lang.annotation;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Inherited {
}

    说明：

    • @interface：用来修饰Inherited，意味着Inherited实现了java.lang.annotation.Annotation 接口；即Inherited是一个注解。
    • @Inherited： 它的作用是标记这个注解是继承于哪个注解类(默认 注解并没有继承于任何子类)。
    • @Retention：指定了Inherited注解的策略是RetentionPolicy.RUNTIME，意味着，编译器会将 Inherited的信息保留在 .class 文件中，并且能被虚拟机读取。
    • @Target：指定了Inherited注解的类型是ElementType.ANNOTATION_TYPE，意味着@Inherited只能被用来标注“Annotation类型”

    实例：

    /*自定义注解，没有@Inherited标注进行标注自定义注解*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
//@Inherited
public @interface InheritedAnnocation {
}

/**
 * 被自定义注解@InheritedAnnocation标注的类
 */
@InheritedAnnocation
public class ReflectFather {
}

/**
 * 继承自ReflectFather
 */
public class ReflectDemo extends ReflectFather{

    public static void main(String[] args) {
        System.out.println("父类ReflectFather被注解InheritedAnnocation标注了？"+ReflectFather.class.isAnnotationPresent(InheritedAnnocation.class));
        System.out.println("子类ReflectDemo被注解InheritedAnnocation标注了？"+ReflectDemo.class.isAnnotationPresent(InheritedAnnocation.class));
    }
}

执行输入结果：
    父类ReflectFather被注解InheritedAnnocation标注了？true
	子类ReflectDemo被注解InheritedAnnocation标注了？true

    /*自定义注解，有@Inherited标注进行标注自定义注解*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface InheritedAnnocation {
}

/**
 * 被自定义注解@InheritedAnnocation标注的类
 */
@InheritedAnnocation
public class ReflectFather {
}

/**
 * 继承自ReflectFather
 */
public class ReflectDemo extends ReflectFather{

    public static void main(String[] args) {
        System.out.println("父类ReflectFather被注解InheritedAnnocation标注了？"+ReflectFather.class.isAnnotationPresent(InheritedAnnocation.class));
        System.out.println("子类ReflectDemo被注解InheritedAnnocation标注了？"+ReflectDemo.class.isAnnotationPresent(InheritedAnnocation.class));
    }
}

执行输入结果：
    父类ReflectFather被注解InheritedAnnocation标注了？true
	子类ReflectDemo被注解InheritedAnnocation标注了？false

  8. @SafeVarargs的定义如下：

    package java.lang;

import java.lang.annotation.*;
/**
*@since 1.8
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD})
public @interface SafeVarargs {}

    说明：

    • @interface：用来修饰SafeVarargs，意味着SafeVarargs实现了java.lang.annotation.Annotation 接口；即SafeVarargs是一个注解。
    • @SafeVarargs： 它的作用是忽略任何使用参数为泛型变量的方法或构造函数调用产生的警告。
    • @Retention：指定了SafeVarargs注解的策略是RetentionPolicy.RUNTIME，意味着，编译器会将 SafeVarargs的信息保留在 .class 文件中，并且能被虚拟机读取。
    • @Target：指定了SafeVarargs注解的类型是ElementType.CONSTRUCTOR, ElementType.METHOD，意味着@SafeVarargs可以用来标注构造器、方法

  9. @FunctionalInterface的定义如下：

    package java.lang;

import java.lang.annotation.*;

/**
 * @since 1.8
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}

    说明：

    • @interface：用来修饰FunctionalInterface，意味着FunctionalInterface实现了java.lang.annotation.Annotation 接口；即FunctionalInterface是一个注解。
    • @FunctionalInterface： 它的作用是标识一个匿名函数或函数式接口。
    • @Retention：指定了FunctionalInterface注解的策略是RetentionPolicy.RUNTIME，意味着，编译器会将 FunctionalInterface的信息保留在 .class 文件中，并且能被虚拟机读取。
    • @Target：指定了FunctionalInterface注解的类型是ElementType.TYPE，意味着@FunctionalInterface只能用来标注类或接口

    实例：

    package java.lang;

@FunctionalInterface
public interface Runnable {
  
    public abstract void run();
}

  10. @Repeatable的定义如下：

    package java.lang.annotation;

/**
 * @since 1.8
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Repeatable {
    /**
     * Indicates the <em>containing annotation type</em> for the
     * repeatable annotation type.
     * @return the containing annotation type
     */
    Class<? extends Annotation> value();
}

第五部分：Annotation应用部分

Annotation在反射中相关的接口，我们可以在反射中解析并使用这些注解

package annotation;

import java.lang.annotation.*;
/**
 *自定义注解
 */
@Documented
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "你好";
    String method() default "POST";
}

/**
 * 测试类
 */
public class ReflectDemo{


    public static void main(String[] args) {
        getMyAnnotation();
    }
    @MyAnnotation
    @Deprecated
    public void test1(){
    }
    @MyAnnotation(value = "方法test2",method = "GET")
    public void test2(){
    }
    public static  void getMyAnnotation(){
        try {
            Class cl = Class.forName("helloword.ReflectDemo");
            Method test1 = cl.getMethod("test1");
            MyAnnotation myAnnotation1 = test1.getAnnotation(MyAnnotation.class);
            System.out.println(myAnnotation1.value());
            System.out.println(myAnnotation1.method());

            System.out.println("---------------------------");
            Method test2 = cl.getMethod("test2");
            MyAnnotation myAnnotation2 = test2.getAnnotation(MyAnnotation.class);
            System.out.println(myAnnotation2.value());
            System.out.println(myAnnotation2.method());
            
            System.out.println("---------------------------");
            //获取方法上所有注解
            Annotation[] annotations = test1.getAnnotations();
            for(Annotation annotation:annotations){
                System.out.println(annotation);
            }

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

输出：

image-20210110163043576

RubyWinner
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
lombok构造方法_最佳实践Lombok
weixin_39719585的博客
12-01 5046
一、Lombok简介Lombok项目是一个Java库，它会自动插入编辑器和构建工具中，Lombok提供了一组有用的注释，用来消除Java类中的大量样板代码二、Lombok插件安装(Idea)在线安装：File->Settings->Plugins离线安装：如下地址可以找到所有对应版本的安装包，然后在上图界面点击设置按钮，选择Disk安装下载地址:https://plugins...
JAVA学习日记: 注解(3)
SIESTA030的博客
10-13 248
今天我学习的是注解的第三课(基础) 今天学习了的主要内容： 1.注解使用的一些小解析 2.标记注解 注解使用: 当注解中有且仅有一个元素且元素名称就叫做value 可以使用如下方法赋值: @注解名(要赋的值) 标记注解: 标记注解和标记接口类似，该注解不具有任何元素 标记接口，是没有任何抽象方法的接口；看似无用，即便实现这样的接口也没有需要实现的方法 但是标记接口有一个重要的作用，即可以将一些实现了该接口的类看似同一个类型；更便于实现多态。 标记注解也类似，虽然本身没有
Java学习————————————注解
weixin_44501770的博客
10-04 256
一、Java常用注解： 1、@Override 检测被该注解标注的方法是否继承于父类（接口） 2、@Deprecated 表示被标注的方法已过时 3、@SuppressWarnings 压制警告 二、Java自定义注解 1、格式 （1）元注解：描述注解的注解 常见： @Target:描述注解作用的位置 ElementType.TYPE：作用于类 ElementType.METHOD：作用于方法 Element...
Lombok中的三个构造方法（annotation）：@NoArgsConstructor, @RequiredArgsConstructor, @AllArgsContructor
weixin_44947740的博客
08-15 1万+
@NoArgsConstructor, @RequiredArgsConstructor, @AllArgsContructorTOC 在Lombok中使用这三个annotation来完成项目中对于不同构造方法的需求。 @NoArgsConstructor ： 生成一个无参数的构造方法，这个annotation在与其他的annotation配合起来使用的时候更加能凸显出他的重要性，当在使用hibe...
lombok构造模式
逸轩
11-10 3484
lombok常用注解 @Getter / @Setter 可以作用在类上和属性上，放在类上，会对所有的非静态(non-static)属性生成Getter/Setter方法，放在属性上，会对该属性生成Getter/Setter方法。并可以指定Getter/Setter方法的访问级别。@EqualsAndHashCode 默认情况下，会使用所有非瞬态(non-transient)和非静态(non-s...
Java进阶之SpringIoC源码深度剖析共19页.pd
11-20
【标题】"Java进阶之SpringIoC源码深度剖析共19页.pd" 提供的是一项关于Java开发中的高级主题，特别是针对Spring框架的依赖注入（Inversion of Control，IoC）部分的深入研究。Spring IoC是Spring框架的核心特性之一...
Java进阶之SpringMVC应用附录共11页.pdf
11-20
这个“Java进阶之SpringMVC应用附录共11页.pdf”文档很可能是对SpringMVC深入使用的详细教程，涵盖了一些高级主题和实践技巧。 1. **SpringMVC核心组件**：SpringMVC的核心组件包括DispatcherServlet、Controller、...
Java基础和Java进阶
10-16
Java是世界上最流行的编程语言之一，尤其在企业级应用开发领域占据主导地位。深入理解Java的基础和进阶知识对于成为一位熟练的Java开发者至关重要。本文将详细介绍Java中的JUnit使用流程、集合框架及其进阶、Stream...
Java进阶之SpringMVCSSM整合共8页.pdf
11-20
总之，掌握SpringMVC和SSM整合是Java开发者进阶的必经之路。理解它们的工作原理、配置方式以及如何优化性能，将有助于提升开发效率和项目的稳定性。不断实践和学习，才能在这个快速发展的IT行业中保持竞争力。
java 进阶之路.zip
最新发布
03-14
动态性：Java可以通过反射、注解等机制实现在运行时动态加载类和修改行为，增加了程序的灵活性。 综上所述，Java凭借其强大的特性和广泛的适用范围，在企业级应用、互联网服务、移动开发等领域均扮演着举足轻重的...
lombok生成构造方法
weixin_44523741的博客
09-04 4269
lombok生成构造方法
Java奇淫巧技之Lombok
热门推荐
寻道
09-08 8万+
背景   我们在开发过程中，通常都会定义大量的JavaBean，然后通过IDE去生成其属性的构造器、getter、setter、equals、hashcode、toString方法，当要对某个属性进行改变时，比如命名、类型等，都需要重新去生成上面提到的这些方法，那Java中有没有一种方式能够避免这种重复的劳动呢？答案是有，我们来看一下下面这张图，右面是一个简单的JavaBean，只定义了两个属性
Mybatis Lombok讲解
difgsief的博客
03-18 188
18.Lombok Project Lombok is a java library that automatically plugs into your editor and build tools, spicing up your java. Never write another getter or equals method again, with one annotation your class has a fully featured builder, Automate your loggin
SpringBoot（四）SpringBoot中lombok使用
a878787877的专栏
03-22 410
lombok概述 lombok简介 Lombok想要解决了的是在我们实体Bean中大量的Getter/Setter方法，以及toString, hashCode等可能不会用到，但是某些时候仍然需要复写，以期方便使用的方法；在使用Lombok之后，将由其来自动帮你实现代码生成，注意，其是 在运行过程中，帮你自动生成的 。就是说，将极大减少你的代码总量。 lombok作用 消除模板代码 g...
【JAVA开发工具】lombok 详解，包括注解
代码的魅力，根本走不出来
01-12 963
Lombok（以“简化Java开发”的目标）是一个Java库，可以。它通过注解来自动生成一些样板代码，减少了开发人员需要手动编写的重复代码，提高了代码的简洁性和可读性。
Lombok 之 Constructor
lvshuchangyin的专栏
03-29 3万+
在Lombok中，生成构造方法的annotation一共有三个，@NoArgsConstructor, @RequiredArgsConstructor, @AllArgsContructor。使用这三个annotation来完成项目中对于不同构造方法的需求。 @NoArgsConstructor ： 生成一个无参数的构造方法，这个annotation在与其他的annotation配合起来
‘@Test‘ not applicable to type；使用@Test测试时出现的问题及解决办法。
jiban5678的博客
10-11 4355
我是在学习拉姆达表达式的时候测试时想用@Test替换掉main方法，索性直接把mian方法去掉，直接在class上加了@Test出现的上述问题，后来上网查阅资料得知@Test需要加在方法上使用。 后来直接把main方法去掉，替换成一个无参方法，在无参方法上加@Test就可以正常测试了。开头：之所以出现这个问题，其实是对@Test注解理解不够深刻。这句话就是提示@Test不应该加在类上。
lombok有参构造注解_Java高效开发工具: Lombok
weixin_39850062的博客
01-10 1万+
Lombok, 一个Java开发必备效率工具，可以大大避免编写一些常用方法(get/set, hashcode等)，简化开发。虽然现在IDE很多都可以通过快捷键生成POJO的一些方法了，但是如果该POJO字段发生变动后，还是需要程序员再次手动重新生成相关方法。而Lombok只需要使用注解即可，且是在代码编译期间将注解替换为相应的代码，而非通过反射。同时会使得源码文件更简洁配置IDEA环境下的的Lo...
JavaSE进阶：注解详解与应用
"JavaSE进阶课程关于注解的讲解" 在Java编程中，注解（Annotation）是一种元数据，它可以提供额外的信息给编译器、IDE或其他工具，以帮助处理代码。注解并不直接影响程序的运行，但它们可以用于生成文档、进行代码...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值