Java注解和枚举详解

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量1k 收藏 2
点赞数
分类专栏： Java基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43389754/article/details/126695162
版权

一、注解

1. Java注解介绍

【1】引入：

JDK5.0 新增 — 注解（Annotation）,也叫元数据

【2】什么是注解？

注解其实就是代码里的特殊标记，这些标记可以在编译,类加载,运行时被读取,并执行相应的处理。通过使用注解,程序员可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息。代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署。

使用注解时要在其前面增加@符号,并把该注解当成一个修饰符使用。用于修饰它支持的程序元素。

【3】注解的重要性：

Annotation 可以像修饰符一样被使用，可用于修饰包，类，构造器,方法，成员变量,参数，局部变量的声明，这些信息被保存在Annotation的"name=value"对中。在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/ArIdroid中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗代码和XML配置等。未来的开发模式都是基于注解的，JPA(java的持久化API)是基于注解的，Spring2.5以. E都是基于注解的，Hibernate3.x以后也是基于注解的，现在的Struts2有一部分也是基于注解的了，注解是一种趋势，一定程度上可以说 ：框架=注解+反射+设计模式。

2. 注解的使用实例

2.1 文档相关的注解

说明注释允许你在程序中嵌入关于程序的信息。你可以使用 javadoc 工具软件来生成信息，并输出到HTML文件中。说明注释，使你更加方便的记录你的程序信息。
文档注解我们一般使用在文档注释中，配合javadoc工具

javadoc 工具软件识别以下标签：

在这里插入图片描述

其中注意：
  • @param @return和@exception这三个标记都是只用于方法的。
  • @param的格式要求: @param 形参名 形参类型 形参说明
  • @return的格式要求: @return 返回值类型返回值说明，如果方法的返回值类型是void就不能写
  • @exception的格式要求: @exception 异常类型异常说明
  • @param和@exception可以并列多个
示例代码：
public class Person {
    /**
     * 下面是eat方法，实现了XXX功能。
     * @param num1 就餐人数
     * @param num2 点了几个菜
     */
    public void eat(int num1,int num2){
    }
    /**
     * @param age 年龄
     * @return int
     * @exception RuntimeException 当年龄过大的时候
     * @exception IndexOutOfBoundsException 当年龄过小的时候
     * @see Student
     */
    public int sleep(int age){
        new Student();
        if(age>100){
            throw new RuntimeException();
        }
        if(age<0){
            throw new IndexOutOfBoundsException();
        }
        return 10;
    }
}
IDEA中的javadoc使用：

在这里插入图片描述

防止乱码：

在这里插入图片描述

2.2 JDK内置的3个注解

【1】@Override:限定重写父类方法，该注解只能用于方法

示例代码：

public class Person {
    public void eat(){
        System.out.println("父类eat..");
    }
}

public class Student extends Person {
    /*
    @Override的作用：限定重写的方法，只要重写方法有问题，就有错误提示。
     */
    @Override
    public void eat(){
        System.out.println("子类eat..");
    }
}
【2】@Deprecated:用于表示所修饰的元素(类,方法，构造器，属性等)已过时。通常是因为所修饰的结构危险或存在更好的选择

示例代码：

public class Student extends Person {
    /*
    @Override的作用：限定重写的方法，只要重写方法有问题，就有错误提示。
     */
    @Override
    public void eat(){
        System.out.println("子类eat..");
    }
    /*
    在方法前加入@Deprecated，这个方法就会变成一个废弃方法/过期方法/过时方法
     */
    @Deprecated
    public void study(){
        System.out.println("学习。。");
    }
}

在这里插入图片描述

【3】@SuppressWarnings:抑制编译器警告

示例代码：

public class Test02 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        @SuppressWarnings("unused")
        int age = 10;
        
        int num = 10;
        System.out.println(num);
        @SuppressWarnings({"unused","rwatypes"})
        ArrayList al = new ArrayList();
    }
}

2.3 实现替代配置文件功能的注解

案例代码

在servlet3.0之前的配置：

public class HelloServlet implements Servlet {
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {

    }

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

   
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("service方法被调用了...");
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {

    }
}

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!--配置Servlet-->
    <!--配置Servlet的信息-->
    <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>com.bjsxt.servlet.HelloServlet</servlet-class>
    </servlet>
    <!--配置Servlet的映射路径-->
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <!--http://localhost:8080/01-hello-servlet/hello-->
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

在servlet3.0之后使用注解：替代配置文件。

@WebServlet("/hello")
public class HelloServlet implements Servlet {
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {

    }

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    /**
    * 用于提供服务, 接收请求, 处理响应
    *
    * @param servletRequest
    * @param servletResponse
    * @throws ServletException
    * @throws IOException
    */
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("service方法被调用了...");
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {

    }
}

3. 自定义注解

【1】自定义注解使用很少，一般情况下都是用现成的注解。

【2】如何自定义注解：

发现定义的注解的声明使用的关键字：@interface，跟接口没有一点关系。

在这里插入图片描述

【3】注解的内部：

这value是属性还是方法？ 答案：看上去是无参数方法，实际上理解为一个成员变量，一个属性 无参数方法名字–》成员变量的名字
无参数方法的返回值–》成员变量的类型 这个参数叫 配置参数

无参数方法的类型：基本数据类型（八种），String，枚举，注解类型，还可以是以上类型对应的数组。

注意：如果只有一个成员变量的话，名字尽量叫value。因为使用时参数名可以省略不写

在这里插入图片描述

【4】使用注解：

（1）使用注解的话，如果你定义了配置参数，就必须给配置参数进行赋值操作：
@MyAnnotation(value={"abc","def","hij"})
public class Person {
}
（2）如果只有一个参数，并且这个参数的名字为value的话，那么value=可以省略不写。
@MyAnnotation({"abc","def","hij"})
public class Person {
}
（3）如果你给配置参数设置默认的值了，那么使用的时候可以无需传值：
public @interface MyAnnotation2 {
    String value() default "abc";
}

使用：

@MyAnnotation2
@MyAnnotation({"abc","def","hij"})
public class Person {
}
（4）一个注解的内部是可以不定义配置参数的：
public @interface MyAnnotation3 {
}
  • 内部没有定义配置参数的注解–》可以叫做标记

在这里插入图片描述

  • 内部定义配置参数的注解–》元数据
    在这里插入图片描述

4. 元注解介绍

元注解是用于修饰其它注解的注解。

JDK5.0提供了四种元注解：Retention, Target, Documented, Inherited

举例：
在这里插入图片描述

4.1 Retention注解学习

@Retention:用于修饰注解，用于指定修饰的那个注解的生命周期，@Rentention包含一个RetentionPolicy枚举类型的成员变量,使用@Rentention时必须为该value成员变量指定值:

【1】 RetentionPolicy.SOURCE:在源文件中有效(即源文件保留),编译器直接丢弃这种策略的注释，在.class文件中不会保留注解信息
案例：

在这里插入图片描述
反编译查看字节码文件：发现字节码文件中没有MyAnnotation这个注解：
在这里插入图片描述

【2】RetentionPolicy.CLASS:在class文件中有效(即class保留)，保留在.class文件中，但是当运行Java程序时，他就不会继续加载了，不会保留在内存中，JVM不会保留注解。如果注解没有加Retention元注解，那么相当于默认的注解就是这种状态。
案例：

在这里插入图片描述
反编译看字节码文件，字节码文件中带有MyAnnotation注解：
在这里插入图片描述

【3】RetentionPolicy.RUNTIME:在运行时有效(即运行时保留),当运行 Java程序时，JVM会保留注释，加载在内存中了，那么程序可以通过反射获取该注释。

4.2 Target注解学习

【1】概念

用于修饰注解的注解，用于指定被修饰的注解能用于修饰哪些程序元素。@Target也包含一个名为value的成员变量。

案例：
@Target({TYPE,CONSTRUCTOR,METHOD})
public @interface MyAnnotation4 {
}
使用：

在这里插入图片描述

4.3 Documented注解学习（使用很少）

【1】概念

用于指定被该元注解修饰的注解类将被javadoc工具提取成文档。默认情况下，javadoc是 不包括注解的，但是加上了这个注解生成的文档中就会带着注解了

案例：

如果：Documented注解修饰了Deprecated注解，那么Deprecated注解就会在javadoc提取的时候，提取到API中：

在这里插入图片描述

在这里插入图片描述

4.4 Inherited注解学习（使用极少）

【1】 概念

被它修饰的Annotation将具有继承性。如果某个类使用了被
@Inherited修饰的Annotation,则其子类将自动具有该注解。

案例：

注解：如果MyAnno注解使用了@Inherited之后，就具备了继承性，那么相当于子类Student也使用了这个MyAnno

在这里插入图片描述

二、枚举

1. 引入

【1】数学：枚举法：

例如 1<x<4，2<y<5，求x+y=6
枚举法：一枚一枚的列举出来。前提：有限，确定

【2】在java中，类的对象是有限个，确定的。这个类我们可以定义为枚举类。

举例：
星期：一二三四五六日
性别：男女
季节：春夏秋冬

【3】自定义枚举类：（JDK1.5之前自定义枚举类）

示例代码：
public class Season {
    //属性：
    private final String seasonName ;//季节名字
    private final String seasonDesc ;//季节描述
    //利用构造器对属性进行赋值操作：
    //构造器私有化，外界不能调用这个构造器，只能Season内部自己调用
    private Season(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    //提供枚举类的有限的  确定的对象：
    public static final Season SPRING = new Season("春天","春暖花开");
    public static final Season SUMMER = new Season("夏天","烈日炎炎");
    public static final Season AUTUMN = new Season("秋天","硕果累累");
    public static final Season WINTER = new Season("冬天","冰天雪地");
    //额外因素：
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
    //toString();
    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

测试类：

public class TestSeason {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Season summer = Season.SUMMER;
        System.out.println(summer/*.toString()*/);
        System.out.println(summer.getSeasonName());
    }
}

2. JDK1_5之后使用enum关键字来创建枚举类

在这里插入图片描述

示例代码：

public enum Season {
    //提供枚举类的有限的  确定的对象：--->enum枚举类要求对象（常量）必须放在最开始位置
    //多个对象之间用，进行连接，最后一个对象后面用;结束
    SPRING("春天","春暖花开"),
    SUMMER("夏天","烈日炎炎"),
    AUTUMN("秋天","硕果累累"),
    WINTER("冬天","冰天雪地");
    //属性：
    private final String seasonName ;//季节名字
    private final String seasonDesc ;//季节描述
    //利用构造器对属性进行赋值操作：
    //构造器私有化，外界不能调用这个构造器，只能Season内部自己调用
    private Season(String seasonName, String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    //额外因素：
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
    //toString();
    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

使用枚举类：

public class TestSeason {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Season winter = Season.WINTER;
        System.out.println(winter);
        //enum关键字对应的枚举类的上层父类是 ：java.lang.Enum
        //但是我们自定义的枚举类的上层父类：Object
        System.out.println(Season.class.getSuperclass().getName());//java.lang.Enum
    }
}

在源码中经常看到别人定义的枚举类形态：

public enum Season {
    SPRING,
    SUMMER,
    AUTUMN,
    WINTER;
}

为什么这么简单：因为这个枚举类底层没有属性，属性，构造器，toString，get方法都删掉不写了，然后案例来说应该
写为：SPRING() 现在连（）可以省略 就变成 SPRING
看到的形态就剩：常量名（对象名）

案例代码：

Thread中的枚举类：State

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,
        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,
        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,
        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING,
        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,
        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }

3. Enum类的常用方法

示例代码：

public class TestSeason {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //用enum关键字创建的Season枚举类上面的父类是：java.lang.Enum,常用方法子类Season可以直接拿过来使用：
        //toString();--->获取对象的名字
        Season autumn = Season.AUTUMN;
        System.out.println(autumn/*.toString()*/);//AUTUMN
        System.out.println("--------------------");
        //values:返回枚举类对象的数组
        Season[] values = Season.values();
        for(Season s:values){
            System.out.println(s/*.toString()*/);
        }
        System.out.println("--------------------");
        //valueOf：通过对象名字获取这个枚举对象
        //注意：对象的名字必须传正确，否则抛出异常
        Season autumn1 = Season.valueOf("AUTUMN");
        System.out.println(autumn1);
    }
}

4. 枚举类实现接口

【1】 定义一个接口：

public interface TestInterface {
    void show();
}

【2】枚举类实现接口，并且重写show方法：

public enum Season implements TestInterface {
    SPRING,
    SUMMER,
    AUTUMN,
    WINTER;
    @Override
    public void show() {
        System.out.println("这是Season....");
    }
}

【3】测试类：

public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Season autumn = Season.AUTUMN;
        autumn.show();
        Season summer = Season.SUMMER;
        summer.show();
    }
}

上面发现所有的枚举对象，调用这个show方法的时候走的都是同一个方法，结果都一样：

在这里插入图片描述

【4】实现不同的对象 调用的show方法也不同代码案列：

public enum Season implements TestInterface {
    SPRING{
        @Override
        public void show() {
            System.out.println("这是春天。。。");
        }
    },
    SUMMER{
        @Override
        public void show() {
            System.out.println("这是夏天。。");
        }
    },
    AUTUMN{
        @Override
        public void show() {
            System.out.println("这是秋天");
        }
    },
    WINTER{
        @Override
        public void show() {
            System.out.println("这是冬天");
        }
    };
    /*@Override
    public void show() {
        System.out.println("这是Season....");
    }*/
}
测试类：
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Season autumn = Season.AUTUMN;
        autumn.show();
        Season summer = Season.SUMMER;
        summer.show();
    }
}

5. 实际应用

示例代码：

public class Person {
    //属性：
    private int age;
    private String name;
    private Gender sex;
    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;
    }
    public Gender getSex() {
        return sex;
    }
    public void setSex(Gender sex) {
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
}
将性别单独抽出来做一个枚举类
public enum Gender {
    男,
    女;
}
测试类
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(19);
        p.setName("lili");
        p.setSex(Gender.男);//传入枚举类Gender的对象：-->在入口处对参数进行了限制
        System.out.println(p);
    }
}
还可以通过枚举结合switch处理：
public class Test02 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Gender sex = Gender.男;
        //switch后面的（）中可以传入枚举类型
        //switch后面的（）:int,short,byte,char,String ,枚举
        switch (sex){
            case 女:
                System.out.println("是个女孩");
                break;
            case 男:
                System.out.println("是个男孩");
                break;
        }
    }
}
缘灬小太阳
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java注解详解
行云间
04-19 1300
文章目录参考资料源码地址概述Annotation元素默认值用途元注解@Documented@Target@Retention@Inherited@Override@SuppressWarnings抑制警告的关键字@Deprecated@SafeVarargs@FunctionalInterface@Repeatable检索注解 参考资料 Java中的注解是如何工作的？ Java基础加强总结(一)...
Java-注解详解
wzgiceman
11-30 7701
注解-JAVA使用篇背景在之前的Rxjava+ReTrofit+okHttp深入浅出-终极封装和RxBus完全一样的 EventBus中我们频繁的使用了注解，通过注解大大的提升了我们开发的效率，但是很多同学反馈说对里面的使用不是很了解，所以决定对java和android注解的使用做详细的介绍。版本 在Java中，注解(Annotation)引入始于Java5，用来描述Java代码的元信息，通常情
Java枚举类与注解
zssxcj的博客
01-15 1559
1、私有化类的构造器，保证不能在类的外部创建对象2、在类的内部创建枚举类的实例。声明为：public static final3、对象如果有实例变量，应声明为private final，并在构造器中实例化使用enum定义的枚举类默认继承了java.lang.Enum类，因此不能在继承其他类枚举类的构造器只能使用private权限修饰符枚举类的所有实例必须在枚举类中显示列出（，分隔；结尾）。列出的实例系统会自动添加private static final修饰必须在枚举类的第一行声明枚举类对象。
枚举类的使用和注解总结
weixin_44630656的博客
01-31 1313
枚举类的使用和注解总结一、枚举类（一）概述（二）如何自定义枚举类？（三）JDK 5.0 新增使用enum定义枚举类（四）Enum类的常用方法（五）用Enum类定义的枚举类对象实现接口二、注解 一、枚举类 （一）概述 枚举类的理解：类的对象只有有限个，确定的。我们称此类为枚举类 当需要定义一组常量时，强烈建议使用枚举类 枚举类的实现： JDK 5.0以前需要自定义 JDK 5.0后新增enum关键字用于定义枚举类 如果枚举类中只一个对象，则可以作为单例模式的实现方式。 枚举类的属性： 枚举类对象的属性不应
java----枚举与注解
@王某人
06-06 297
简介： JDK1.5引入了新的类型——枚举。 枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。 用于定义有限数量的一组同类常量
【java基础】 注解，枚举
qq_46289793的博客
01-02 650
注解枚举
10、枚举类&注解
qq_44774198的博客
07-18 451
二、如何定义枚举类方式一：JDK1.5之前需要自定义枚举类方式二：JDK 1.5 新增的enum 关键字用于定义枚举类//自定义枚举类 class Season {//1.声明Season对象的属性:private final修饰 private final String seasonName;//2.私有化类的构造器,并给对象属性赋值 private Season(String seasonName , String seasonDesc) {
最全Java注解图文超详解(建议收藏)
03-19
以下是对Java注解的全面详解： 1. **注解类型**： Java注解有三种类型：源码级注解、编译器注解和运行时注解。源码级注解在编译后不会保留，仅用于编译器进行语法检查；编译器注解会影响编译过程，如`@Override`；...
Java注解Annotation与自定义注解详解
08-27
Java注解Annotation与自定义注解详解 Java注解（Annotation）是一种元数据，提供了关于程序元素（如类、方法、字段等）的补充信息，能够被Java虚拟机（JVM）和其他Java工具读取。Java注解可以分为两类：预定义注解...
详解Java注解教程及自定义注解
09-02
总之，Java注解是一种强大的工具，它们增强了代码的可读性和可维护性，同时也简化了复杂任务的处理，如框架配置和元数据的管理。通过自定义注解，开发者可以创建自己的元数据标准，以适应特定项目或库的需求。
java语言注解基础概念详解
08-28
Java语言注解基础概念详解 Java语言注解基础概念详解是Java编程语言中的一种元数据，提供了一种便捷的方式来关联信息到程序元素上，例如类、方法、变量等。通过使用注解，可以在编译时、运行时或加载时提供有用的...
java @interface 注解详解及实例
08-30
java @interface 注解详解及实例 Java 中的注解（Annotation）是从 Java 5 开始引入的一种特殊类型的接口，它可以在编译时、类加载时或运行时被读取，并且可以被用来生成描述信息、强制编译检查、.runtime ...
Java基础之枚举类与注解
weixin_48457745的博客
09-29 275
Java基础之枚举类与注解
Java注释小技巧：使用linkplain链接跳转到对应的代码
qq_28834355的博客
10-23 3292
写注释的时候，偶尔需要提醒阅读的人参考其他代码，可以创建 @linkplain 链接，按住ctrl+鼠标左键，就能直接跳转 跳转到类、枚举 /** * 状态枚举 {@linkplain com.test.modules.enums.StatusEnum} */ private Integer status; 跳转到方法 /** * 状态枚举 {@linkplain StatusEnum#getCode()} */ private Integer status; ...
JAVA枚举和注解
weixin_62740713的博客
10-23 507
将构造器私有化,防止直接new将set相关的方法去掉,防止属性被修改在该类的内部,创建固定的对象对枚举对象/属性使用共同修饰,实现底层优化枚举的对象名通常使用大写字母,常量命名规范/***/}}//描述//定义四个对象public static final Season SPRING = new Season("春天", "温暖");public static final Season WINTER = new Season("冬天", "寒冷");
java核心类库—9.枚举、注解和反射
不放手，不错过的博客
07-23 330
枚举、注解和反射
枚举类&注解
TANGWENYU_的博客
10-09 517
枚举类&注解 文章目录一、什么是枚举？1.枚举的实现自定义枚举实现enum关键字实现enum常用方法enum类实现接口二、注解1.三个基本的Annotation2.四种元注解 一、什么是枚举？ 枚：一个一个。 举：举例。 枚举类（enumertation,简写：enum）：把具体的对象一个一个举例出来的类。 枚举是一组常量的集合，枚举属于一种特殊的类，里面只包含一组有限的特定的对象。 1.枚举的实现 自定义枚举实现 1.将构造器私有化，目的：防止直接 new 2.去掉setXXX方法，防止属性被修改
枚举和注解、异常
m0_72041293的博客
10-27 727
枚举、注解和异常
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 730
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
mybatisplus注释讲解
03-27
MyBatis Plus 是一个基于 MyBatis 的增强工具，它简化了 MyBatis 的操作，提供了更加强大和便捷的功能。下面是 MyBatis Plus 中常见的注释讲解： 1. @TableName: 用于指定实体类对应的数据库表名，如果不指定，则默认使用类名作为表名。 2. @TableId: 用于指定实体类中的主键字段，可以指定主键类型、主键生成策略等。 3. @TableField: 用于指定实体类中的字段对应的数据库列名，可以指定列名、是否为主键、是否为自增等。 4. @Version: 用于乐观锁，指定实体类中的版本号字段。 5. @EnumValue: 用于枚举类，指定枚举值对应的数据库存储值。 6. @SqlParser: 用于指定 SQL 解析器，用于解析 SQL 语句中的自定义语法。 7. @SqlStatement: 用于指定 SQL 语句，可以在 Mapper 接口中使用该注解指定 SQL 语句，而不需要写 XML 映射文件。 8. @SqlParam: 用于指定 SQL 语句中的参数，可以在 Mapper 接口中使用该注解指定参数值。 9. @InsertBatch: 用于批量插入数据，可以在 Mapper 接口中使用该注解指定批量插入的数据列表。 10. @UpdateBatch: 用于批量更新数据，可以在 Mapper 接口中使用该注解指定批量更新的数据列表。 以上是 MyBatis Plus 中常见的注释讲解，可以帮助开发者更好地理解和使用 MyBatis Plus。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值