枚举类和注解

最新推荐文章于 2023-02-06 21:54:40 发布

愤怒的potato

最新推荐文章于 2023-02-06 21:54:40 发布

阅读量468

点赞数

分类专栏： Java学习文章标签： java 枚举类

本文链接：https://blog.csdn.net/thewindking/article/details/113155713

版权

Java学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

枚举类

枚举用于类的对象个数有限且确定，例如：

性别：男，女

星期：星期一，星期二，、、、

季节：春、夏、秋、冬

、、、、、

当需要定义一组常量时，强烈建议使用枚举类

如果枚举类只有一个对象，则可以作为单利模式的实现方式

创建方法

如何定义枚举类
方式一：JDK 5.0之前，自定义枚举类
方拾二：JDK 5.0之后可以用enum关键字定义枚举类

方法一、自定义枚举类

public class SeasonTest {
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        System.out.println(spring);
    }
}
//自定义枚举类
class Season{
    //1,声明Season对象的属性:属性为常量，需用private final定义
    private final String seasonName;
    private final String seasonDesc;

    //2，私有化类的构造器,并给对象属性赋值
    private Season(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //3, 提供当前枚举类的多个对象,作为常量且不可变，故应该用public static final修饰
    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("冬天","冰天雪地");

    //4.其他诉求,获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }
    //4, 其他诉求，提供toString()
    //该类继承于object类，toString（）方法返回的是地址，故可以按需重写tostring（）方法

    @Override
    public String toString() {//重写toString（）方法
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

方法二、enum关键字实现枚举类

package javaSE.Enum;

/**
 * 使用enum关键字定义枚举类
 * 说明：定义的枚举类默认继承于java.lang.Enumle。其toString（）方法返回的
 * 是枚举类中的对象变量名可虫子额toString（）方法打印需要的内容
 */
public class SeasonTest1 {
    public static void main(String[] args) {
        Season1 spring = Season1.SPRING;
        System.out.println(spring);

    }
}

//自定义枚举类
enum  Season1{

    //1， 提供枚举类的对象
    SPRING ("春天","春暖花开"),
    SUMMER ("夏天","夏日炎炎"),
    AUTUMN ("秋天","秋高气爽"),
    WINTER ("冬天","冰天雪地");
    //enum实现枚举，对象放在最开始，且不同对象之间用逗号隔开且最后用分号

    //2,声明Season对象的属性:属性为常量，需用private final定义
    private final String seasonName;
    private final String seasonDesc;

    //3，私有化类的构造器,并给对象属性赋值
    private Season1(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }



    //4.其他诉求,获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }
    //4, 其他诉求，提供toString()

     @Override
    public String toString() {//重写toString（）方法
        return "Season1{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

enum类的主要方法

values()方法：返回枚举类型的对象数组，该方法可以很方便的遍历枚举值

valueof(String str)：可以把一个字符串转为对应的枚举对象，要求字符串必须是枚举类对象的“名字”，如果不是会有运行时异常

toString()：返回当前枚举类对象常量的名字

package javaSE.Enum;

/**
 * 使用enum关键字定义枚举类
 * 说明：定义的枚举类默认继承于java.lang.Enumle。其toString（）方法返回的
 * 是枚举类中的对象变量名可虫子额toString（）方法打印需要的内容
 */
public class SeasonTest1 {
    public static void main(String[] args) {
        Season1 spring = Season1.SPRING;
        //tostring()
        System.out.println(spring);
        System.out.println("************************");

        //values();
        Season1[] values = Season1.values();
        for (int i = 0; i < values.length; i++) {
            System.out.println(values[i]);
        }

        System.out.println("************************");
        Thread.State[] values1 = Thread.State.values();
        for (int i = 0; i < values1.length; i++) {
            System.out.println(values1[i]);
        }

        System.out.println("************************");
        //valueof(string str);返回一个枚举对象名是str的对象
        //如果没有str的枚举类对象会抛出IllegalArgumentException异常

        Season1 winter = Season1.valueOf("WINTER");
        System.out.println(winter);

    }
}

//自定义枚举类
enum  Season1{

    //1， 提供枚举类的对象
    SPRING ("春天","春暖花开"),
    SUMMER ("夏天","夏日炎炎"),
    AUTUMN ("秋天","秋高气爽"),
    WINTER ("冬天","冰天雪地");
    //enum实现枚举，对象放在最开始，且不同对象之间用逗号隔开且最后用分号

    //2,声明Season对象的属性:属性为常量，需用private final定义
    private final String seasonName;
    private final String seasonDesc;

    //3，私有化类的构造器,并给对象属性赋值
    private Season1(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }



    //4.其他诉求,获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }
    //4, 其他诉求，提供toString()

//     @Override
//    public String toString() {//重写toString（）方法
//        return "Season1{" +
//                "seasonName='" + seasonName + '\'' +
//                ", seasonDesc='" + seasonDesc + '\'' +
//                '}';
//    }
}

使用enum关键字实现的枚举类实现接口的情况

情况一

和普通类实现接口一样，在enum类中实现抽象方法

interface Info{
    void show ();
}

//自定义枚举类
enum  Season1 implements Info{
    
    SPRING ("春天","春暖花开"),
    SUMMER ("夏天","夏日炎炎"),
    AUTUMN ("秋天","秋高气爽"),
    WINTER ("冬天","冰天雪地");
    
    private final String seasonName;
    private final String seasonDesc;
    
    private Season1(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }
   

    @Override
    public void show() {
        System.out.println("这是一个季节");
    }
}

情况二

情况一中每一个枚举类对象调用接口实现方法所执行的步骤都相同，如果想让每一个枚举类对象调用接口实现对象时执行不同的操作，则可以让每一个对象都实现一下该接口方法，如下

interface Info{
    void show ();
}

//自定义枚举类
enum  Season1 implements Info{

    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("大约在冬季");
        }
    };

    private final String seasonName;
    private final String seasonDesc;

    private Season1(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }
}

注解

概述

	从JDK 5.0开始，java增加了对元数据（MetaData）的支持，也就是Annotation（注解）

Annotation其实就是代码里的特殊标记，程序员可以通过Annotation在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息。

Annotation可以像修饰符一样使用，可用于修饰包、类、构造器、方法、成员变量、参数、局部变量的声明，这些信息被保存在Annotation的“name = value”对中。

示例一、生成相关文档的注解

@author

@version

@see;参考主题，也是相关主题

@since；从那个版本开始增加

@param；对方法中的参数的说明，如果没有参数就不能写

@return对方法返回值的说明，如果返回值是void就不能写

@exception；对方法抛出的异常进行说明，如果方法没有用throw显示抛出异常就不能写

其中

@param、@return、@exception只能用在方法中

@param格式要求： @param形参名形参类型形参说明

@return格式要求： @return 返回值类型返回值说明

@exception的格式要求：@exception 异常类型异常说明

@param和@exception可以并列多个

示例二、在编译时进行格式检查（JDK内置的三个基本注解）

@Override；限定重写父类方法，该注解只用于方法

@Deprecated;用于表示所修饰元素（类、方法等）已过时，通常是因为所修饰的结构危险或存在更好的选择

@SupressWarnings；抑制编译器警告

示例三，跟踪代码的依赖性，实现替代配置文件功能

自定义注解

自定义注解必须配上注解的信息处理流程(使用反射)才有意义

在这里插入图片描述

package javaSE.Annotation;

/**
 * 自定义注解
 *  注解生命为 @interface
 *  内部定义成员，通常使用value使用
 *  可以指定成员的默认值，使用default定义
 *  如果自定义注解没有成员，表明是一个标识作用
 *
 * @Author: Thewind
 * @Date: 2021/1/25 22:22
 */
public @interface MyAnnotation {

    // String value();
    // 此方法设置默认值，其调用方法为 @MyAnnotation(value = " hello")


    String value() default "hello";
    //此方法设置了默认值，其调用方法为@MyAnnotation()
    //但是也可以使用@MyAnnotation(value = " 其他值")

}

JDK中的元注解

JDK的元Annotation是用于修饰其他的Annotation定义

JDK 5.0提供了4个标准的meta-annotation类型，分别是

Retention

Target

Documented

Inherited

自定义注解时通常会指明两个元注解，@Retention和@Target

Retention

指定所修饰的Annotationd的生命周期，

在这里插入图片描述

Target

用于指示被修饰的Annotation 能用于修饰那些程序元素

//使用方法 @Target(ElementType.常量)
//或者@Target({常量,常量,常量,.....})


//ElementType类的定义
public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,

    /** Field declaration (includes enum constants) */
    FIELD,

    /** Method declaration */
    METHOD,

    /** Formal parameter declaration */
    PARAMETER,

    /** Constructor declaration */
    CONSTRUCTOR,

    /** Local variable declaration */
    LOCAL_VARIABLE,

    /** Annotation type declaration */
    ANNOTATION_TYPE,

    /** Package declaration */
    PACKAGE,

    /**
     * Type parameter declaration
     *
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * Use of a type
     *
     * @since 1.8
     */
    TYPE_USE
}

Documented

用于指定所修饰的Annotation注解将被javaDoc解析时会被保留下来

注意：定义为Documented 的注解必须设置Retention为RUNTIME

Inherited

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

通过反射获取注解信息

反射章节再具体介绍

JDK 8 中注解的新特性

可重复注解

注解可重复注解多次

说明：MyAnnotations,和MyAnnotation是自定义注解类

1，在MyAnnotation 上声明 @Repeatable，成员值为MyAnnotation.class

2，MyAnnotation的 Target和Retention和MyAnnotations相同

类型注解

在这里插入图片描述

愤怒的potato

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
枚举类和注解

枚举类枚举用于类的对象个数有限且确定，例如：性别：男，女星期：星期一，星期二，、、、季节：春、夏、秋、冬、、、、、当需要定义一组常量时，强烈建议使用枚举类如果枚举类只有一个对象，则可以作为单利模式的实现方式创建方法如何定义枚举类方式一：JDK 5.0之前，自定义枚举类方拾二：JDK 5.0之后可以用enum关键字定义枚举类方法一、自定义枚举类public class SeasonTest { public static void main(Str
复制链接

扫一扫