11、枚举与注解：

于 2024-11-18 10:50:12 发布
阅读量441 收藏 10
点赞数 3
分类专栏： Java启动！ 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jiangxianfengge/article/details/143848123
版权

11、枚举与注解：

枚举（Enumeration）：

Season的例子：

package com.jiangxian.enum_;

public class Enumeration01 {
    public static void main(String[] args) {
        Season spring = new Season("Spring", "warm");
        Season summer = new Season("Summer", "hot");
        Season autumn = new Season("Autumn", "cool");
        Season winter = new Season("Winter", "cold");
        // 对于季节而言，其对象（具体值），是固定的四个，不会有更多
        // 所以我们这种设计思路是有问题的
        // 这种传统的方法是不可以的 ====> 所以出现了 枚举类[枚：一个个，举：列举；即把具体的对象一个个列举出来的类]
        Season computer = new Season("Computer", "hard");
        
    }
}

class Season{
    private String name;
    private String description;

    public Season(String name, String description) {
        this.name = name;
        this.description = description;
    }

    public String getName() {
        return name;
    }

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

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

在这个例子中，我们发现了一些特点：

  1. 值是有限的几个值（spring，summer，autumn，winter）；
  2. 只读，不需要修改。

枚举的介绍：

  1. 枚举——enumeration；
  2. 枚举是一组常量的集合；
  3. 可以这样理解：枚举是一种特殊的类，里面只包含一组有限的特定的对象

自定义枚举类：

  1. 不需要提供 setXxx 方法，因为枚举对象值通常为只读；
  2. 对枚举对象/属性使用 final + static 共同修饰，实现底层优化；
  3. 枚举对象名通常使用全部大写，常量的命名规范；
  4. 枚举对象根据需要，可以有多个属性。
package com.jiangxian.enum_;

/**
 * @author JiangXian~
 * @version 1.0
 */
public class Enumeration02 {
    public static void main(String[] args) {
        System.out.println(Season.SPRING);
        System.out.println(Season.SUMMER);
        System.out.println(Season.AUTUMN);
        System.out.println(Season.WINTER);
    }
}

// 演示自定义枚举的实现
class Season{
    private String name;
    private String description;

    public final static Season SPRING = new Season("Spring", "warm");
    public final static Season SUMMER = new Season("Summer", "hot");
    public final static Season AUTUMN = new Season("Autumn", "cool");
    public final static Season WINTER = new Season("Winter", "cold");
    // 1.先把构造器做成私有的形式，防止直接被 new
    // 2.删除 setXxx 方法，保证只读；
    // 3.在Season内部，创建规定的对象
    // 4.使用静态属性会导致Season的加载，优化可以使用final
    private Season(String name, String description) {
        this.name = name;
        this.description = description;
    }

    public String getName() {
        return name;
    }
    public String getDescription() {
        return description;
    }

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

小结特点：

  1. 构造器私有化；
  2. 本类内部创建一些对象；
  3. 对外暴露对象（public final static）;
  4. 可以提供get方法，但是不能有set。

使用enum关键字实现枚举：

  1. enum 关键字代替 class；
  2. 需要定义的常量写在最前面，格式：常量名(参数列表)；
  3. 多个常量间用逗号隔开。
/**
 * @author JiangXian~
 * @version 1.0
 */
public class Enumeration03 {
    public static void main(String[] args) {
        System.out.println(Season2.SPRING);
        System.out.println(Season2.SUMMER);
        System.out.println(Season2.AUTUMN);
        System.out.println(Season2.WINTER);
    }
}

// 使用enum关键字生成枚举类
enum Season2{
    // 解读：常量名(实参列表)；
    // 多个常量用逗号间隔
    // 同时要使用enum实现的话，要将需要定义的常量放在最前面。
    SPRING("Spring","warm"),
    SUMMER("Summer","hot"),
    AUTUMN("Autumn","cool"),
    WINTER("Winter","cold");
    private String name;
    private String description;
    
    
    private Season2(String name, String description) {
        this.name = name;
        this.description = description;
    }

    public String getName() {
        return name;
    }
    public String getDescription() {
        return description;
    }

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

注意事项：

  1. 当我们使用 enum 关键字开发一个枚举类的时候，其会默认继承Enum类，而且是一个final类型；
  2. 传统的 public final static Season2 SPRING = new Season2(“Spring”,“warm”);简化成了SPRING(“Spring”,“warm”);
  3. 若使用无参构造器 创建 枚举类的对象的化，则实参列表和小括号都可以省略——SPRING即可；
  4. 当有多个枚举对象时，使用 , 间隔，最后又个 ; 收尾；
  5. 枚举对象必须放在枚举类的首行。

enum常用方法：

toString()：

Enum类重写了toString方法，返回的是当前对象名，子类可以再重写（enum 关键字创建的类自动继承Enum），用于返回对象的属性。

name()：

返回当前对象名（常量名），子类中不能重写。

ordinal()：

返回当前对象的位置号，默认从零开始（可以理解为，常量会按照定义的顺序被存储在一个数组中）。

values()：

返回当前枚举类的所有常量，返回的类型是一个 类型数组。

valueOf()：

将字符串转化为枚举对象，要求字符串必须是已有的常量名，否则会报错。

compareTo()：

比较两个枚举对象的位置号，若为0表示相等，若为正数表示调用对象在比较对象的后面，若为负数则在前面。



/**
 * @author JiangXian~
 * @version 1.0
 */
public class Enumeration03 {
    public static void main(String[] args) {
        System.out.println(Season2.SPRING);
        System.out.println(Season2.SUMMER);
        System.out.println(Season2.AUTUMN);
        System.out.println(Season2.WINTER);
        System.out.println(Season2.SUMMER.name());
        System.out.println(Season2.SUMMER.ordinal());
        Season2[] values = Season2.values();
        System.out.println("==========Season==========");
        // 增强for循环,用于遍历容器
        for(Season2 season:values){
            System.out.println(season);
        }
        Season2 season2 = Season2.valueOf("SUMMER");
        // Season2 season21 = Season2.valueOf("S");
        System.out.println(Season2.SUMMER.compareTo(Season2.WINTER));
        System.out.println(Season2.SUMMER.compareTo(Season2.SPRING));
    }
}

// 使用enum关键字生成枚举类
enum Season2{
    // 解读：常量名(实参列表)；
    // 多个常量用逗号间隔
    // 同时要使用enum实现的话，要将需要定义的常量放在最前面。
    SPRING("Spring","warm"),
    SUMMER("Summer","hot"),
    AUTUMN("Autumn","cool"),
    WINTER("Winter","cold");
    private String name;
    private String description;


    private Season2(String name, String description) {
        this.name = name;
        this.description = description;
    }

    public String getName() {
        return name;
    }
    public String getDescription() {
        return description;
    }

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

使用细节：

  1. 使用 enum 关键字后，就不能再继承其它类了（因为使用enum会自动继承Enum类，而Java是单继承机制）；
  2. 和普通类一样，枚举类也可以实现接口。
    1. enum 类 implements 接口1,接口…{}

注解（Annotation）：

注解的理解：

  1. 注解也被称为元数据（Metadata），用于修饰 包、类、方法、属性、构造器、局部变量等信息；
  2. 和注释一样，注解不影响程序逻辑，但注解可以被编译或运行，相当于嵌入再程序中的补充信息；
  3. 在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE中，注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的冗余代码和XML配置等。

Annotation基本介绍：

使用 Annotation 时要在前面增加 @ 符号，并把该 Annotation 当作一个修饰符使用。用于修饰它支持的程序元素。

三个基本的 Annotation：

  1. @Override:限定某个方法，是重写父类方法，该注解只能用于方法；
  2. @Deprecated:用于表示某个程序元素已经过时；
  3. @SuppressWarnings:抑制编译器警告。

@Override：

限定某个方法，是重写父类方法，该注解只能用于方法。

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

解释：

  1. 此时@Override放在toString方法上，表示子类的toString方法重写了父类的toString方法；
  2. 若这边没有写@Override，而父类仍然有该方法，还是会重写父类的方法；
  3. 若写了@Override，则编译器会去检查该方法是否真的重写了父类的方法，若构成重写，则编译通过，否则编译不通过。
  4. 该注解只能修饰方法，不能修饰其它类，包，属性等（看源码@Target那行）。

@Override的源码：

package java.lang;

import java.lang.annotation.*;

/**
 * Indicates that a method declaration is intended to override a
 * method declaration in a supertype. If a method is annotated with
 * this annotation type compilers are required to generate an error
 * message unless at least one of the following conditions hold:
 *
 * <ul><li>
 * The method does override or implement a method declared in a
 * supertype.
 * </li><li>
 * The method has a signature that is override-equivalent to that of
 * any public method declared in {@linkplain Object}.
 * </li></ul>
 *
 * @author  Peter von der Ah&eacute;
 * @author  Joshua Bloch
 * @jls 9.6.1.4 @Override
 * @since 1.5
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override { // @interface 不是 interface接口的意思，而是表面这是个注解类
}

@Deprecated：

说明：

  1. 用于表示某个程序元素已经过时（什么意思呢？就是可以用，但是不建议的意思）。
  2. 可以修饰方法，类，字段，包，参数等等；
  3. 其作用主要是做到新旧版本之间的兼容。
  4. 使用被其注解的元素时，会有一个删除线出现==像这样~==

@SuppressWarnings：

语法：@SuppressWarnings(“”)

在(“”)中应该写入希望抑制（不显示）警告信息。

有很多的类型，但实际上没必要背，看下黄色的warning信息是什么再一个个的修改，或者就直接all也行。

元注解（了解即可）：

基本介绍：

元Annotation用于修饰其它的Annotation，其本身的作用不大，但是看源码的时候需要能看得懂是什么意思。

种类：

  1. Retention：指定注解的作用范围，三种——SOURCE（源码），CLASS（类），RUNTIME（运行）；
  2. Target：指定注解在哪里使用；
  3. Documented：指定注解是否会在javadoc中体现；
  4. Inherited：子类会继承父类注解。

@Retention：

只能修饰一个Annotation定义，用于指定该注解可以保留多长时间，其包含一个RetentionPolicy类型的成员变量，使用@Retention是必须为该value成员变量指定值。

三种值：

  1. RetentionPolicy.SOURCE:编译器使用后，直接丢弃这种策略的注解
  2. RetentionPolicy.CLASS:编译器将注解记录在class文件中，当运行java程序时，JVM不会保留注解。这是默认值。
  3. RetentionPolicy.RUNTIME:编译器将注解记录在class文件中，当运行java程序时，JVM会保留注解。程序可以通过反射获取该注解。

看一下@Override的源码，其是SOURCE的值：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE) // 在编译的时候生效，其余部分就没有用了
public @interface Override {
}

@Target：

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

看一下@Deprecated 源码：

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

@Documented:

用于指定该元 Annotation 修饰的 Annotation 类将被 javadoc 工具提取成文档，即在生成文档时，可以看到该注解。

定义为Documented的注解必须将Retention的值设置为RUNTIME。

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

@Inherited：

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

实际应用中较少，了解即可。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

江弦凤歌

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值