Java枚举和注解

枚举

引入

• 要求创建季节Season对象，请设计并完成

分析：

创建Season对象有如下特点

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

package com.zanedu.enum_;

public class Enumeration01 {
   public static void main(String[] args) {
       //使用
       Season spring = new Season("春天", "温暖");
       Season winter = new Season("冬天", "寒冷");
       Season summer = new Season("夏天", "炎热");
       Season autumn = new Season("秋天", "凉爽");
//        autumn.setName("XXX");
//        autumn.setDesc("非常的热");
       //因为对于季节而言，他的对象(具体值), 是固定的四个，不会有更多
       //按老师的这个设计类的思路，不能体现季节是固定的四个对象
       //因此这样的设计不好 ==> 枚举类[枚：一个一个 举：例举，即把具体的对象一个一个例举出来的类就称为枚举类]
       Season other = new Season("红天", "~~~");
   }
}

class Season {
    private String name;
    private String desc; //描述

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

    public String getName() {
        return name;
    }

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

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }
}

• 因为对于季节而言，他的对象(具体值), 是固定的四个，不会有更多
• 按老师的这个设计类的思路，不能体现季节是固定的四个对象
• 因此这样的设计不好 ==> 枚举类[枚：一个一个 举：例举，即把具体的对象一个一个例举出来的类就称为枚举类]

枚举的基本介绍

枚举对应英文（enumeration，简写enum）

枚举是一组常量的集合

即：枚举属于一种特殊的类，里面只包含一组有限的特定的对象

• 枚举的两种实现方式

1. 自定义类实现枚举
2. 使用enum关键字实现枚举

自定义类实现枚举

枚举的要求：

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

package com.zanedu.enum_;

public class Enumeration02 {
    public static void main(String[] args) {
        System.out.println(Season.SPRING);
        System.out.println(Season.WINTER);
        System.out.println(Season.SUMMER);
        System.out.println(Season.AUTUMN);
    }
}

//演示自定义枚举实现
class Season {
    private String name;
    private String desc; //描述

    //定义了四个对象 ，固定
    public static final Season SPRING = new Season("春天", "温暖");
    public static final Season WINTER = new Season("冬天", "寒冷");
    public static final Season SUMMER = new Season("夏天", "炎热");
    public static final Season AUTUMN = new Season("秋天", "凉爽");

    //1. 将构造器私有化，目的防止直接new
    //2. 去掉setXxx相关的方法，目的是防止属性被修改
    //3. 在Season内部直接创建固定的对象
    //4. 优化：可以再加入final修饰符
    private Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }

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

自定义类实现枚举 - 小结

小结：进行自定义类实现枚举，有如下特点：

1. 构造器私有化
2. 本类内部创建一组对象【四个 春夏秋冬】
3. 对外暴露对象（通过为对象添加 public final static 修饰符）
4. 可以提供get方法，但是不要提供set方法

enum关键字实现枚举

package com.zanedu.enum_;

public class Enumeration03 {
    public static void main(String[] args) {
        System.out.println(Season2.SPRING);
        System.out.println(Season2.SUMMER);
    }
}

//演示使用enum关键字来实现枚举
enum Season2 {

    //定义了四个对象 ，固定
//    public static final Season SPRING = new Season("春天", "温暖");
//    public static final Season WINTER = new Season("冬天", "寒冷");
//    public static final Season SUMMER = new Season("夏天", "炎热");
//    public static final Season AUTUMN = new Season("秋天", "凉爽");
    //如果使用了enum 来实现枚举类
    //1. 使用关键字 enum 替代 class
    //2. public static final Season SPRING = new Season("春天", "温暖"); 直接使用 SPRING("春天", "温暖");
    //   常量名(实参列表)
    //3. 如果有多个常量(对象)，使用逗号间隔即可
    //4. 如果使用 enum 来实现枚举，要求将定义的常量对象写在最前面
    SPRING("春天", "温暖"), WINTER("冬天", "寒冷"), SUMMER("夏天", "炎热"), AUTUMN("秋天", "凉爽");
    //如果我们使用的是无参构造器创建常量对象，则可以省略 ()
//    What(),Wat; //==> Wat 等价于 Wat()
    private String name;
    private String desc; //描述

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

    private Season2() { //无参构造器

    }

    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }

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

enum关键字实现枚举注意事项

1. 当我们使用enum关键字开发一个枚举类时，默认会继承Enum类，而且是一个final类（用javap反编译来看）

1. 传统的 public static final Season2 SPRING = new Season2(“春天”, “温暖”); 简化成SPRING(“春天”, “温暖”); 这里我们要清楚它调用的是哪个构造器
2. 如果使用无参构造器来创建枚举对象，那么****实参列表和小括号都可以省略

1. **当有多个枚举对象时，**中间使用逗号(，)间隔，最后有一个分号结尾即可
2. 枚举对象必须放在枚举类的****行首（即最前面）

enum常用方法说明

• 说明：由于在使用关键字enum时，会隐式的继承Enum类，因此这样我们就可以使用Enum类相关的方法

enum常用方法应用实例

1. toString：Enum类已经重写过了，返回的是当前对象名，子类可以重写该方法，用于返回对象的属性信息
2. name：返回当前对象名（常量名），子类中不能重写

package com.zanedu.enum_;

/**
 * 演示Enum类的各种方法的使用
 */
public class EnumMethod {
    public static void main(String[] args) {
        //使用Season2来演示各种方法
        Season2 autumn = Season2.AUTUMN;
        //输出枚举对象的名字
        System.out.println(autumn.name());
    }
}

1. ordinal：返回当前对象的位置号，默认从0开始

package com.zanedu.enum_;

/**
 * 演示Enum类的各种方法的使用
 */
public class EnumMethod {
    public static void main(String[] args) {
        //使用Season2来演示各种方法
        Season2 autumn = Season2.AUTUMN;
        //ordinal() 输出的是该枚举对象的次序/编号，从0开始编号
        //AUTUMN 枚举对象是第四个，因此输出3
        System.out.println(autumn.ordinal());
    }
}

1. values：返回当前枚举类中所有的常量

package com.zanedu.enum_;

/**
 * 演示Enum类的各种方法的使用
 */
public class EnumMethod {
    public static void main(String[] args) {
        //使用Season2来演示各种方法
        Season2 autumn = Season2.AUTUMN;
        //values是隐藏的，从反编译可以查看
        //返回Season2[] ，含有定义的所有枚举对象
        System.out.println("========遍历取出枚举对象========");
        Season2[] values = Season2.values();
        for (Season2 season : values) { //增强for循环 - for-each循环
            System.out.println(season);
        }
    }
}

1. valueOf：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常

package com.zanedu.enum_;

/**
 * 演示Enum类的各种方法的使用
 */
public class EnumMethod {
    public static void main(String[] args) {
        //使用Season2来演示各种方法
        Season2 autumn = Season2.AUTUMN;
        //valueOf：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常
        //执行流程
        //1. 根据你输入的"AUTUMN"到Season2的枚举对象去查找
        //2. 如果找到了，就返回，如果没有找到，就报错
//        Season2 zan = Season2.valueOf("ZAN");//error
        Season2 autumn1 = Season2.valueOf("AUTUMN");
        System.out.println(autumn1);
        System.out.println(autumn == autumn1);
    }
}

1. compareTo：比较两个枚举常量，比较的就是编号

package com.zanedu.enum_;

/**
 * 演示Enum类的各种方法的使用
 */
public class EnumMethod {
    public static void main(String[] args) {
        //使用Season2来演示各种方法
        Season2 autumn = Season2.AUTUMN;
        //compareTo：比较两个枚举常量，比较的就是编号
        //解读
        //1. 就是把 Season2.AUTUMN 枚举对象的编号和 Season2.SUMMER 的枚举对象的编号进行比较
        //2. 看看结果 == 1
        /*
        return self.ordinal - other.ordinal;
        即 Season2.AUTUMN编号[3] - Season2.SUMMER编号[2] = 3 - 2 = 1
         */
        System.out.println(Season2.AUTUMN.compareTo(Season2.SUMMER));
    }
}

• 补充：for-each循环

enum实现接口

1. 使用enum关键字后，就不能再继承其他类了，因为enum会隐式继承Enum类，而Java是单继承机制

• 解释：

因为当继承多个父类的时候，会出现一个问题，假设两个父类中都有同一个方法，那么当子类调用方法的时候，该调用哪个方法，因此子类无法继承多个父类，是单继承机制

1. 枚举类和普通类一样，可以实现接口

enum 类名 implements 接口1, 接口2 { }

package com.zanedu.enum_;

public class EnumDetail {
    public static void main(String[] args) {
        Music classicmusic = Music.CLASSICMUSIC;
        classicmusic.playing();
    }
}
//2. enum实现的枚举类，仍然是一个类，所以还是可以实现接口的
interface Playing {
    public void playing();
}
enum Music implements Playing{
    CLASSICMUSIC;
    @Override
    public void playing() {
        System.out.println("播放好听的音乐...");
    }
}

注解

\1) 注解(Annotation)也被称为元数据(Metadata)，用于修饰解释包、类、方法、属性、构造器、局部变量等数据信息

\2) 和注释一样，注解不影响程序逻辑，但注解可以被编译或运行，相当于嵌入在代码中的补充信息

\3) 在 JavaSE 中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在 JavaEE 中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替 java EE 旧版中所遗留的繁冗代码和 XML 配置等

基本的注解(Annotation)介绍

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

三个基本的注释Annotation

1. @Override：限定某个方法，是重写父类方法，该注释只能用于方法
2. **@Deprecated：用于表示某个程序元素(类、方法等)**已过时
3. **@SuppressWarnings：**抑制编译器警告

基本的注解Annotation应用案例

@Override注解的案例

package com.zanedu.annotation_;

public class Override_ {
    public static void main(String[] args) {

    }
}
class Father {
    public void fly() {
        System.out.println("Father fly()...");
    }
    public void say() {

    }
}
//@Override
class Son extends Father {
    //解读
    /*
    1. @Override 注解放在fly方法上，表示子类的fly方法是重写了父类的fly方法
    2. 这里如果没有写 @Override 还是重写了父类的fly方法
    3. 如果写了@Override注解，编译器就回去检查该方法是否真的重写了父类的方法
       如果的确重写了，则编译通过，如果没有构成重写，则编译错误
    4. 看看@Override 的定义
    //解读：如果发现 @interface 表示一个 注解类
        @Target(ElementType.METHOD)
        @Retention(RetentionPolicy.SOURCE)
        public @interface Override {
        }
     */
    @Override
    public void fly() {
        System.out.println("Son fly()...");
    }
    @Override
    public void say() {

    }
}

• 补充：@interface的说明

@interface不是interface，是注解类，是JDK5.0之后加入的

@Override使用说明

1. @Override表示指定重写父类的方法（从编译层面验证），如果父类没有fly方法，则会报错
2. 如果不写@Override注释，，而父类仍有public void fly() {}，仍然构成重写
3. @Override只能修饰方法，不能修饰其他类、包、属性等等

1. 查看@Override注解源码为@Target(ELementType.METHOD)，说明只能修饰方法
2. @Target是修饰注解的注解，称为元注解

@Deprecated注解的案例

package com.zanedu.annotation_;

public class Deprecated_ {
    public static void main(String[] args) {
        A a = new A();
        a.hi();
        System.out.println(a.n1);
    }
}

//解读
/*
1. @Deprecated 修饰某个元素，表示该元素已经过时
2. 即不再推荐使用，但是仍然可以使用
3. 查看 @Deprecated 注解类的源码
4. 可以解释方法、类、字段、包、参数等等
5. @Deprecated 可以做版本升级过渡使用
    @Documented
    @Retention(RetentionPolicy.RUNTIME)
    @Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, MODULE, PARAMETER, TYPE})
    public @interface Deprecated {
    }
 */
@Deprecated
class A {
    @Deprecated
    public int n1 = 10;
    @Deprecated
    public void hi() {

    }
}

• 虽然过时了，但是不代表不能使用，这个仍然能使用

@Deprecated使用说明

1. 用于表示某个程序元素（类、方法）已过时
2. 可以修饰方法、类、字段、包、参数等等
3. @Target(value = {CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
4. @Deprecated的作用可以做到新旧版本的兼容和过度

@SuppressWarnings注解的案例

package com.zanedu.annotation_;

import java.util.ArrayList;
import java.util.List;

@SuppressWarnings({"rawtypes", "unchecked", "unused"})
public class SuppressWarnings_ {
    //解读
    //1. 当我们不希望看到这些警告的时候，可以使用 SuppressWarnings注解来抑制警告信息
    //2. {""} 中，可以写入你希望抑制（不显示）警告信息
    //3. 可以指定的警告类型有
    /*
        all，抑制所有警告
        boxing，抑制与封装/拆装作业相关的警告
        cast，抑制与强制转型作业相关的警告
        dep-ann，抑制与淘汰注释相关的警告
        deprecation，抑制与淘汰的相关警告
        fallthrough，抑制与switch陈述式中遗漏break相关的警告
        finally，抑制与未传回finally区块相关的警告
        hiding，抑制与隐藏变数的区域变数相关的警告
        incomplete-switch，抑制与switch陈述式(enum case)中遗漏项目相关的警告
        javadoc，抑制与javadoc相关的警告
        nls，抑制与非nls字串文字相关的警告
        null，抑制与空值分析相关的警告
        rawtypes，抑制与使用raw类型相关的警告
        resource，抑制与使用Closeable类型的资源相关的警告
        restriction，抑制与使用不建议或禁止参照相关的警告
        serial，抑制与可序列化的类别遗漏serialVersionUID栏位相关的警告
        static-access，抑制与静态存取不正确相关的警告
        static-method，抑制与可能宣告为static的方法相关的警告
        super，抑制与置换方法相关但不含super呼叫的警告
        synthetic-access，抑制与内部类别的存取未最佳化相关的警告
        sync-override，抑制因为置换同步方法而遗漏同步化的警告
        unchecked，抑制与未检查的作业相关的警告
        unqualified-field-access，抑制与栏位存取不合格相关的警告
        unused，抑制与未用的程式码及停用的程式码相关的警告
     */
    //4. 关于 SuppressWarnings 作用范围是和你放置的位置相关
    //   比如： SuppressWarnings 放置在 main方法，那么抑制警告的范围就是 main方法
    //   通常我们可以放置具体的语句，方法，类
    //5. 看看 SuppressWarnings 的源码
    //（1）放置的位置就是 TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, MODULE
    //（2）该注解类有一个数组 String[] values() 设置一个数组，比如{"rawtypes", "unchecked", "unused"}
    /*
        @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, MODULE})
            @Retention(RetentionPolicy.SOURCE)
            public @interface SuppressWarnings {
                String[] value();
        }

     */
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("jack");
        list.add("tom");
        list.add("mary");
        int i;
        System.out.println(list.get(1));
    }

    public void f1() {
        List list = new ArrayList();
        list.add("jack");
        list.add("tom");
        list.add("mary");
        int i;
        System.out.println(list.get(1));
    }
}

• 加了@SuppressWarnings({“rawtypes”, “unchecked”, “unused”})之后警告消失了

说明各种值：

1. unchecked是忽略没有检查的警告
2. rawtypes是忽略没有指定泛型的警告（传参时没有指定泛型的i警告错误）
3. unused是忽略没有使用某个变量的警告错误
4. @SuppressWarnings可以修饰的程序元素为，查看@Target
5. 生成@SuppressWarnings时，不用背，直接点击右侧的黄色提示，就可以选择（但要注意可以指定生成的位置）

JDK的元注解（元Annotation，了解）

基本介绍

JDK的元注解用于修饰其他注解

元注解：本身作用不大，只是为了看源码的时候，能看懂知道他时干什么的

元注解的种类（使用不多，了解）

1. Retention注解

• 指定注解的作用范围，三种 SOURCE, CLASS, RUNTIME

说明：

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

@Retention的三种值

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

一个**@Retention的案例**

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.SOURCE) //这个就是**@Retention**的取值

public @interface Override {

}

@Retention的源码

package java.lang.annotation;

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

说明：Override的作用域在SOURCE，当编译器编译时生效，不会写入到.class文件，也不会在runtime(运行时)生效

2. @Target注解

基本说明：

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

• ElementType包含的value

public enum ElementType {
    
    TYPE,

    FIELD,

    METHOD,

    PARAMETER,

    CONSTRUCTOR,

    LOCAL_VARIABLE,

    ANNOTATION_TYPE,

    PACKAGE,

    TYPE_PARAMETER,

    TYPE_USE,

    MODULE,

    RECORD_COMPONENT;
}

• 源码说明

@Documented
@Retention(RetentionPolicy.RUNTIME) //它的作用范围是RUNTIME
@Target(ElementType.ANNOTATION_TYPE) //这里的ANNOTATION_TYPE说明@Target只能修饰注释
public @interface Target {
    ElementType[] value(); //可以看ElementType的取值//比如TYPE等，如上
}

3. @Documented注解

基本说明：

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

说明：定义为Documented的注解必须设置Retention值为RUNTIME

• 源码分析

package java.lang.annotation;

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

4. @Inherited注解

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

说明：实际应用中，使用较少，了解即可