韩顺平Java22——枚举类和注解

枚举（enumeration）类

两种实现方式：自定义类实现、使用enum关键字实现

 

自定义枚举类

• 引出：

　　定义一个Season类，但是只想要春夏秋冬四个对象，不想让人为添加

• 格式：

　　1.将构造器私有化，防止直接new

　　2.去掉set方法，防止属性被修改，可以留下get方法

　　3.在类的内部直接创建固定的对象

　　4.优化 加入 public static final 修饰符

/**
 * @author 紫英
 * @version 1.0
 * @discription 自定义枚举类
 */
public class Enums01 {

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

class Season {

    private String name;//季节名称
    private String desr;//季节名称

    private Season(String name, String desr) {
        this.name = name;
        this.desr = desr;
    }

    public String getName() {
        return name;
    }

    public String getDesr() {
        return desr;
    }

    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("冬天", "寒冷");

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

 

enum关键字

/**
 * @author 紫英
 * @version 1.0
 * @discription enum关键字
 */
public class Enums02 {
    public static void main(String[] args) {
        System.out.println(Season01.AUTUMN);
        System.out.println(Season01.SPRING);
        System.out.println(Season01.SUMMER);
        System.out.println(Season01.WINTER);
    }
}
enum Season01 {
    SPRING("春天", "温暖"), SUMMER("夏天", "炎热"), AUTUMN ("秋天", "凉爽"),WINTER("冬天", "寒冷")，WHAT;
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//这里的WHAT调用了无参构造器所以实参列表和小括号都可以省略
　　　　
    private String name;//季节名称
    private String desr;//季节名称

    private Season01(String name, String desr) {
        this.name = name;
        this.desr = desr;
    }

    public String getName() {
        return name;
    }

    public String getDesr() {
        return desr;
    }

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

• enum常用方法

使用enum关键字时会隐式地继承Enum类，因此可以调用Enum类的相关方法

1.name()方法

 Season01 winter=Season01.WINTER;
        //name()方法——输出枚举对象的名字
        System.out.println(winter.name());//WINTER

2.ordinal()方法

//ordinal()方法——输出枚举对象的序列号（从0开始）
        System.out.println(winter.ordinal());//3

这里因为刚才定义了四个季节，winter是第四个，序列号从0开始算，所以是3。

3.values()方法

通过javap 反编译命令我们可以看到在原先的枚举类中隐藏了一个values()方法

 可以看出values()的返回类型是一个Season01类型的数组，也就是说将所有Season类定义的所有常量对象以数组的方式返回

//values()方法
        Season01 [] values=Season01.values();
        for(Season01 season01:values){
            System.out.println(season01);
//这里是按照toString（）方法的格式输出的
        }
//        Season{name='春天', desr='温暖'}
//        Season{name='夏天', desr='炎热'}
//        Season{name='秋天', desr='凉爽'}
//        Season{name='冬天', desr='寒冷'}

4.valueOf()方法

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

//valueOf()方法
        Season01 winter01 = Season01.valueOf("WINTER");
        System.out.println(winter01==winter);//true

可以看到这里的winter01和之前的winter是同一个对象

如果输入一个任意的字符串则会报错

Season01 winter02 = Season01.valueOf("jaskhd");

5.compareTo()方法

比较两个常量对象的序列号，返回两值相减

return self.ordinal - other.ordinal;

 //compareTo()方法
        System.out.println(autumn.compareTo(winter));//-1

因为之前定义的顺序所以这里相当于2-3=-1

6.toString()方法

如果不重写的话就调用父类也就是Enum类的toString()方法，返回常量的name

System.out.println(winter.toString());//WINTER

迭代器遍历

• enum类实现接口

注意：

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

2.但使用enum关键字的枚举类本质仍然是一个类，所以可以实现接口

/**
 * @author 紫英
 * @version 1.0
 * @discription enum实现接口
 */
public class EnumInterface {

    public static void main(String[] args) {
        Music.POPMUSIC.play();
    }
}
interface Iplay {
    public void play();
}
enum Music implements Iplay {
    POPMUSIC;
    @Override
    public void play() {
        System.out.println("lalalalala");
    }
}

注解（Annotation）

 注解后面不需要加“；” 

 

元注解

• @Retention（保留）注解

• @Target

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    /**
     * Returns an array of the kinds of elements an annotation type
     * can be applied to.
     * @return an array of the kinds of elements an annotation type
     * can be applied to
     */
    ElementType[] value();
}

• @Doucumented注解

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

• @Inherited注解

@override注解

用作语法校验：如果写了@override注解，则编译器回去判断你是否真的重写了父类的方法，如果是则编译通过，否则编译报错

//@override的声明
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

@interface 是 注解类

 

@Deprecated注解

 虽然被标注过时但依旧能用

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

标注后会在被调用的元素上加上一个中划线

@SuppressWannings注解

用来抑制编译器警告

作用范围与放的位置有关

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