精华内容
下载资源
问答
  • Java 枚举和注解总结
    2021-03-04 04:13:09

    Java 枚举和注解总结

    枚举

    没有枚举前我们基本上常量来定义值:

    public interface Color{

    public static final int GREEN = 0;

    public static final int RED = 1;

    ....

    ....

    ....

    }

    如果有了枚举后我们会怎样了?

    public enum Color{

    GREEN,RED,BLACk,.......

    }

    代码是不是就清晰很多了?而且使用的时候输出的值我们是可以使用GREEN,是不是可以很明白的知道是什么颜色?

    枚举的创建

    枚举是继承自Enum,使用enum关键字。

    枚举的使用场景

    枚举适合在固定的常量下使用,比如四季,月份,星期;这种基本公认的而且不会有改变的场景下使用。

    编译器中的枚举

    编译器默认帮我们实现了很多枚举中的方法,比如equals(),hashCode(),toString,values(),valueOf(String)等。这些都是编译器帮我们做的。

    枚举中的注意事项

    不能使用static,final修饰枚举,因为它是隐式的final类型的;

    因为是final类型,所以我们也就知道它是不能被继承的;

    从Enum继承的clone是final类型的,枚举是不能重写clone方法的,并且Enum里面的clone方法直接抛出异常,所以enum是不能被clone的;

    enum中的ordinal是强依赖于枚举实例的定义顺序的,所以用ordinal来做判断顺序是不推荐的,因为只要在非最后加入实例,那么就会改变整体的顺序;如果是需要顺序可以自定义属性。

    注解

    注解出现前

    注解的作用我理解为就是用来约定一些数据定义,让我们可以在某个属性或者某个地方做个标记。在注解出现前能做这个的应该是XML,我们通常在xml中定义类或者属性的相关配置。而有了注解我们可以在代码中直接定义了。

    注解的分类

    定义注解的注解,元注解:@Rentation,@Target,@Document,@Inherited

    jdk内置注解:@Override,@Deprecated...

    自定义的注解

    spring等外部注解

    作用场景:

    @Rentation:Source,Class,Runtime

    作用目标域:

    @Target:Construct,Field,Local_variable,method,package,paramter,type

    注解的定义

    注解的定义使用@interface关键字,并且使用元注解进行标注:

    @Rentation(Rentation.Runtime)

    @Target(ElementType.Field)

    public @interface XxAnotation{

    String values() default "";

    }

    注解属性

    注解里面的属性只能使用以下6种类型来定义:

    1. 所有的基本类型;

    2. String

    3. Class

    4. enum

    5. Annotation

    6. 以上类型的数组类型

    注解不允许使用基本类型的包装类来定义里面的注解属性。注解里面的属性都是使用方法的方式来定义的。有点类似接口方法。

    注解的属性需要注意一下几点:

    要么具有默认值,要么在使用注解的时候提供属性的值;

    非基本类型的元素,默认值不能为null;

    如果只有一个属性,那么可以设置为value,在使用注解的时候就可以直接赋值;@XxAnotation("ok")

    ps:注解是不能继承的。

    注解处理器

    我们定义了注解,设置了元素值。那么就必须要有一个处理器来进行注解处理。这个可以看看之前的Java 特殊字段脱敏,我们可以使用反射来获取注解定义的值,然后进行业务处理。

    更多相关内容
  • Java 枚举&注解

    2021-03-09 20:00:21
    枚举类如何自定义枚举类JDK1.5之前需要自定义枚举类JDK 1.5 新增的 enum 关键字用于定义枚举类若枚举只有一个成员, 则可以作为一种单例模式的实现方式//枚举类class Season{//1.提供类的属性,声明为private final...

    枚举类

    如何自定义枚举类

    JDK1.5之前需要自定义枚举类

    JDK 1.5 新增的 enum 关键字用于定义枚举类

    若枚举只有一个成员, 则可以作为一种单例模式的实现方式

    //枚举类

    class Season{

    //1.提供类的属性,声明为private final

    private final String seasonName;

    private final String seasonDesc;

    //2.声明为final的属性,在构造器中初始化。

    private Season(String seasonName,String seasonDesc){

    this.seasonName = seasonName;

    this.seasonDesc = seasonDesc;

    }

    //3.通过公共的方法来调用属性

    public String getSeasonName() {

    return seasonName;

    }

    public String getSeasonDesc() {

    return seasonDesc;

    }

    //4.创建枚举类的对象:将类的对象声明public static final

    public static final Season SPRING = new Season("spring", "春暖花开");

    public static final Season SUMMER = new Season("summer", "夏日炎炎");

    public static final Season AUTUMN = new Season("autumn", "秋高气爽");

    public static final Season WINTER = new Season("winter", "白雪皑皑");

    @Override

    public String toString() {

    return "Season [seasonName=" + seasonName + ", seasonDesc="

    + seasonDesc + "]";

    }

    public void show(){

    System.out.println("这是一个季节");

    }

    }

    Enum枚举类

    必须在枚举类的第一行声明枚举类对象。

    枚举类和普通类的区别:

    使用 enum 定义的枚举类默认继承了 java.lang.Enum 类

    枚举类的构造器只能使用 private 访问控制符

    枚举类的所有实例必须在枚举类中显式列出(, 分隔    ; 结尾). 列出的实例系统会自动添加 public static final 修饰

    interface Info{

    void show();

    }

    //枚举类

    enum Season1 implements Info{

    SPRING("spring", "春暖花开"){

    public void show(){

    System.out.println("春天在哪里?");

    }

    },

    SUMMER("summer", "夏日炎炎"){

    public void show(){

    System.out.println("生如夏花");

    }

    },

    AUTUMN("autumn", "秋高气爽"){

    public void show(){

    System.out.println("秋天是用来分手的季节");

    }

    },

    WINTER("winter", "白雪皑皑"){

    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;

    }

    @Override

    public String toString() {

    return "Season [seasonName=" + seasonName + ", seasonDesc="

    + seasonDesc + "]";

    }

    }

    枚举类的主要方法:

    values()方法:返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。

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

    如何让枚举类实现接口:可以让不同的枚举类的对象调用被重写的抽象方法,执行的效果不同。(相当于让每个对象重写抽象方法)

    注解Annotation

    Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理. 通过使用 Annotation, 程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息.

    基本的 Annotation

    @Override: 限定重写父类方法, 该注释只能用于方法

    @Deprecated: 用于表示某个程序元素(类, 方法等)已过时

    @SuppressWarnings: 抑制编译器警告

    自定义 Annotation

    定义新的 Annotation 类型使用 @interface 关键字

    Annotation 的成员变量在 Annotation 定义中以无参数方法的形式来声明. 其方法名和返回值定义了该成员的名字和类型.

    可以在定义 Annotation 的成员变量时为其指定初始值, 指定成员变量的初始值可使用 default 关键字

    public @interface MyAnnotation{

    String name() default “atguigu";

    }

    没有成员定义的 Annotation 称为标记; 包含成员变量的 Annotation 称为元数据 Annotation

    元注解

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

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

    RetentionPolicy.SOURCE: 编译器直接丢弃这种策略的注释

    RetentionPolicy.CLASS: 编译器将把注释记录在 class 文件中. 当运行 Java 程序时, JVM 不会保留注解。 这是默认值

    RetentionPolicy.RUNTIME:编译器将把注释记录在 class 文件中. 当运行 Java 程序时, JVM 会保留注释. 程序可以通过反射获取该注释

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

    @Documented: 用于指定被该元 Annotation 修饰的 Annotation 类将被 javadoc 工具提取成文档.

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

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

    实际应用中,使用较少

    展开全文
  • Java枚举类和注解

    2021-03-06 23:28:51
    我们称此类为枚举类当需要定义一组常量时,强烈建议使用枚举枚举类的实现:JDK 5.0以前需要自定义JDK 5.0后新增enum关键字用于定义枚举类如果枚举类中只一个对象,则可以作为单例模式的实现方式。枚举类的属性:...

    一、枚举类的使用

    1. 枚举类的说明:

    枚举类的理解:类的对象只有有限个,确定的。我们称此类为枚举类

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

    枚举类的实现:

    JDK 5.0以前需要自定义

    JDK 5.0后新增enum关键字用于定义枚举类

    如果枚举类中只一个对象,则可以作为单例模式的实现方式。

    枚举类的属性:

    枚举类对象的属性不应允许被改动,所以应该使用 private final 修饰 枚举类的使用 private final修饰的属性应该在构造器中为其赋值 若枚举类显式的定义了带参数的构造器,则在列出枚举值时也必须对应的传入参数

    2. 如何自定义枚举类?

    步骤:

    私有化构造器,保证不能在类的外部创建其对象;

    在类的内部创建枚举类的实例。声明为:public static final;

    因为要通过类来调取使用,静态在类里面了,不动了,所以需要 public static

    又不允许改变,所以为 final。

    这个枚举类里面有好几个对象,每个对象相当于是一个常量

    如果这个类只有一个对象,那么可以看成是一个单例模式

    对象如果有实例变量,应该声明为private final,并在构造器中初始化;

    代码示例:

    //自定义枚举类

    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.其他诉求1:获取枚举类对象的属性

    public String getSeasonName() {

    return seasonName;

    }

    public String getSeasonDesc() {

    return seasonDesc;

    }

    //4.其他诉求1:提供toString()

    @Override

    public String toString() {

    return "Season{" +

    "seasonName='" + seasonName + '\'' +

    ", seasonDesc='" + seasonDesc + '\'' +

    '}';

    }

    }

    3. JDK 5.0 新增使用enum定义枚举类。

    使用说明:

    使用enum定义的枚举类默认继承了java.lang.Enum类,因此不能再继承其他类

    枚举类的构造器只能使用private权限修饰符

    枚举类的所有实例必须在枚举类中显式列出(“,”分隔“;”结尾)。列出的实例系统会自动添加public static final修饰

    必须在枚举类的第一行声明枚举类对象

    代码示例:

    //使用enum关键字枚举类

    enum Season1 {

    //1.提供当前枚举类的对象,多个对象之间用","隔开,末尾对象";"结束

    SPRING("春天","春暖花开"),

    SUMMER("夏天","夏日炎炎"),

    AUTUMN("秋天","秋高气爽"),

    WINTER("冬天","冰天雪地");

    //2.声明Season对象的属性:private final修饰

    private final String seasonName;

    private final String seasonDesc;

    //2.私化类的构造器,并给对象属性赋值

    private Season1(String seasonName,String seasonDesc){

    this.seasonName = seasonName;

    this.seasonDesc = seasonDesc;

    }

    //4.其他诉求1:获取枚举类对象的属性

    public String getSeasonName() {

    return seasonName;

    }

    public String getSeasonDesc() {

    return seasonDesc;

    }

    }

    Enum类的常用方法:

    values()方法:返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。

    valueOf(String str):可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”.如不是,会有运行时异常IllegalArgumentException

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

    代码示例:

    Season1 summer = Season1.SUMMER;

    //toString():返回枚举类对象的名称

    System.out.println(summer.toString());

    // System.out.println(Season1.class.getSuperclass());

    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]);

    }

    //valueOf(String objName):返回枚举类中对象名是objName的对象。

    Season1 winter = Season1.valueOf("WINTER");

    //如果没objName的枚举类对象,则抛异常:IllegalArgumentException

    // Season1 winter = Season1.valueOf("WINTER1");

    System.out.println(winter);

    用Enum类定义的枚举类对象分别实现接口:

    使用说明:

    和普通Java类一样,枚举类可以实现一个或多个接口

    若每个枚举值在调用实现的接口方法呈现相同的行为方式,则只要统一实现该方法即可。

    若需要每个枚举值在调用实现的接口方法呈现出不同的行为方式,则可以让每个枚举值分别来实现该方法

    代码示例:

    interface Info{

    void show();

    }

    //使用enum关键字枚举类

    enum Season1 implements Info{

    //1.提供当前枚举类的对象,多个对象之间用","隔开,末尾对象";"结束

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

    }

    };

    }

    二、注解的使用

    1. 注解的理解

    jdk 5.0 新增的功能

    Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。通过使用 Annotation,程序员可以在不改变原逻辑的情况下, 在源文件中嵌入一些补充信息。

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

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

    框架 = 注解 + 反射机制 + 设计模式

    2. 注解的使用示例

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

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

    @author标明开发该类模块的作者,多个作者之间使用,分割

    @version标明该类模块的版本

    @see参考转向,也就是相关主题

    @since从哪个版本开始增加的

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

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

    @exception对方法可能抛出的异常进行说明,如果方法没有用 throws显式抛出的异常就不能写

    其中

    @param、@return和@exception这三个标记都是只用于方法的。

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

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

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

    @param和@exception可以并列多个

    代码示例:

    /**

    * @author nemo

    * @project_name JavaSenior

    * @package_name com.nemo.java

    * @create 2020-04-26 10:58

    */

    public class AnnotationTest {

    /**

    *程序的主方法

    * @param args 传入命令行参数

    */

    public static void main(String[] args) {

    }

    /**

    * 求圆形面积

    * @param radius 所求面积的半径

    * @return 面积值

    */

    public static double getArea(double radius){

    return Math.PI * radius * radius;

    }

    }

    示例二:在编译时进行格式检查(JDK内置的个基本注解)

    @Override: 限定重写父类方法, 该注解只能用于方法

    @Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择

    @SuppressWarnings: 抑制编译器警告

    代码示例:

    public class AnnotationTest{

    public static void mian (String [] args){

    @SuppressWarning("unused")

    int a = 0;

    }

    @Deprecated

    public void print(){

    System.out.print("过时的方法");

    }

    @Override

    public String toString(){

    return "重写的toString方法";

    }

    }

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

    在使用Spring框架时会大量用到注解驱动开发。

    3. 如何自定义注解

    参照@SuppressWarnings定义

    注解声明为:@interface

    内部定义成员,通常使用无参无异常方法value()表示

    如果成员只有一个,那么这个成员必须取名为value(),使用时可以忽略成员名和赋值号(=)。

    理解:为什么要使用无参无异常方法呢,我认为那是因为,如果使用变量来进行存储的话,在接口中,属性变量会变为常量,占取空间;

    而我们这个注解又不是那么的需要这个属性(占空间),只是在属性调用到的时候起作用。

    需要在调用的时候才起作用,那肯定是方法比较符合条件了。

    记忆:这个注解的使用方式比较类似于方法,如@Params(...),所以里面的注解实现也都用方法value()表示。

    可以指定成员的默认值,使用default定义

    如果自定义注解没成员,表明是一个标识作用。

    说明:

    如果注解有成员,在使用注解时,需要指明成员的值。

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

    自定义注解通过都会指明两个元注解:@Retention、@Target

    代码举例:

    @Inherited

    @Repeatable(MyAnnotations.class)

    @Retention(RetentionPolicy.RUNTIME)

    @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_PARAMETER,TYPE_USE})

    public @interface MyAnnotation {

    String value() default "hello";

    }

    4. 元注解:

    对现有的注解进行解释说明的注解。

    JDK 5.0 提供的4种元注解:

    @Retention:指定所修饰的 Annotation 的生命周期:SOURCE\CLASS(默认行为)\RUNTIME。

    source:注解只保留在源文件,当Java文件编译成class文件的时候,注解被遗弃;被编译器忽略

    class:注解被保留到class文件,但jvm加载class文件时候被遗弃,这是默认的生命周期

    runtime:注解不仅被保存到class文件中,jvm加载class文件之后,仍然存在

    这3个生命周期分别对应于:Java源文件(.java文件) ---> .class文件 ---> 内存中的字节码。

    只有声明为RUNTIME生命周期的注解,才能通过反射获取。

    那怎么来选择合适的注解生命周期呢?

    首先要明确生命周期长度 SOURCE < CLASS < RUNTIME ,所以前者能作用的地方后者一定也能作用。一般如果需要在运行时去动态获取注解信息,那只能用 RUNTIME 注解;如果要在编译时进行一些预处理操作,比如生成一些辅助代码(如 ButterKnife),就用 CLASS注解;如果只是做一些检查性的操作,比如 @Override 和 @SuppressWarnings,则可选用 SOURCE 注解。

    @Target:用于指定被修饰的 Annotation 能用于修饰哪些程序元素

    25507dea32d3d75b829425f939c0283d.png

    @Documented:表示所修饰的注解在被javadoc解析时,保留下来。

    @Inherited:被它修饰的 Annotation 将具继承性。

    类比:元数据的概念:String name = "Tom";对现有数据的修饰

    5. 如何获取注解信息:

    通过发射来进行获取、调用。

    前提:要求此注解的元注解Retention中声明的生命周期状态为:RUNTIME.

    6. JDK 8.0中注解的新特性:

    可重复注解、类型注解

    6.1 可重复注解:

    在MyAnnotation上声明@Repeatable,成员值为MyAnnotations.class

    MyAnnotation的@Target和@Retention等元注解与MyAnnotations相同。

    6.2 类型注解:

    ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中(如:泛型声明。)

    ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。

    展开全文
  • Java笔记---枚举类和注解一、枚举类自定义枚举类方式一:JDK5.0之前自定义枚举类class Seasons {//1. 声明Seasons对象的属性private final String SeasonName;private final String SeasonDescrp;//2. 私有化类的...

    Java笔记---枚举类和注解

    一、枚举类

    自定义枚举类

    方式一:JDK5.0之前自定义枚举类

    class Seasons {

    //1. 声明Seasons对象的属性

    private final String SeasonName;

    private final String SeasonDescrp;

    //2. 私有化类的构造器, 并给对象赋值初始化

    private Seasons(String SeasonName, String SeasonDescrp) {

    this.SeasonDescrp = SeasonDescrp;

    this.SeasonName = SeasonName;

    }

    //3. 提供当前枚举类的多个对象 public static final "枚举类的名字"

    public static final Seasons SPRING = new Seasons("SPRING", "春天");

    public static final Seasons SUMMER = new Seasons("SUMMER", "夏天");

    public static final Seasons AUTUMN = new Seasons("AUTUMN", "秋天");

    public static final Seasons WINTER = new Seasons("WINTER", "冬天");

    //4. 获取枚举类对象的属性

    public String getSeasonName() {

    return SeasonName;

    }

    public String getSeasonDescrp() {

    return SeasonDescrp;

    }

    @Override

    public String toString() {

    return "Seasons{" +

    "SeasonName='" + SeasonName + '\'' +

    ", SeasonDescrp='" + SeasonDescrp + '\'' +

    '}';

    }

    }

    调用这个类:

    public class TestEnum {

    public static void main(String[] args) {

    Seasons spring = Seasons.SPRING;

    System.out.println(spring);

    }

    }

    Seasons{ SeasonName='SPRING', SeasonDescrp='春天'}

    以上为该自定义枚举类的输出结果

    方式二:JDK5.0之后引入关键字enum定义枚举类

    enum Season {

    //多个对象之间用逗号,最后一个对象用分号结束

    SPRING("SPRING", "春天"),

    SUMMER("SUMMER", "夏天"),

    AUTUMN("AUTUMN", "秋天"),

    WINTER("WINTER", "冬天");

    //下面的声明和方式一并无多大差别

    //1. 声明Seasons对象的属性

    private final String SeasonName;

    private final String SeasonDescrp;

    //2. 私有化类的构造器, 并给对象赋值初始化

    private Season(String SeasonName, String SeasonDescrp) {

    this.SeasonDescrp = SeasonDescrp;

    this.SeasonName = SeasonName;

    }

    }

    那么,枚举类为何没有重写toString()方法呢?

    public class TestEnum {

    public static void main(String[] args) {

    Season spring = Season.SPRING;

    System.out.println(spring);

    System.out.println(Season.class.getSuperClass());

    }

    }

    SPRING

    class java.lang.Enum

    以上呢就是输出结果了!可见,这个类中的toString()方法已经再Enmu类中重写过了

    Enum类中的常用方法

    values():返回枚举类型的对象数组。该方法可以很便利的遍历所有枚举值。

    valuesOf(String objName):根据提供的objName,返回一个对象名是objName的枚举类型的对象

    toString():返回当前常量的名称

    public class TestEnum {

    public static void main(String[] args) {

    Season spring = Season.SPRING;

    //toString()方法

    System.out.println(spring);

    //values()方法

    Season[] values = Season.values();

    for (Season temp : values) {

    System.out.println(temp);

    }

    System.out.println(Season.class.getSuperClass());

    //valueOf(String objName)

    //如果找不到与objName同名的对象时候,会抛出一个异常IllegalArgumentException

    Season winter = Season.valueOf("WINTER");

    System.out.println(winter);

    }

    }

    使用enum关键字定义的枚举类实现接口

    情况一:实现接口。再enum类中实现接口

    interface Info {

    //显示对象的名字

    void show();

    }

    enum Season implements Info {

    //多个对象之间用逗号,最后一个对象用分号结束

    SPRING("SPRING", "春天"),

    SUMMER("SUMMER", "夏天"),

    AUTUMN("AUTUMN", "秋天"),

    WINTER("WINTER", "冬天");

    //1. 声明Seasons对象的属性

    private final String SeasonName;

    private final String SeasonDescrp;

    //2. 私有化类的构造器, 并给对象赋值初始化

    private Season(String SeasonName, String SeasonDescrp) {

    this.SeasonDescrp = SeasonDescrp;

    this.SeasonName = SeasonName;

    }

    @Override

    public void show() {

    System.out.println("这是一个季节");

    }

    }

    情况二:让枚举类的对象,分别实现接口中的方法

    interface Info {

    //显示对象的名字

    void show();

    }

    enum Season implements Info {

    //多个对象之间用逗号,最后一个对象用分号结束

    SPRING("SPRING", "春天"){

    @Override

    public void show() {

    //春天的方法

    }

    },

    SUMMER("SUMMER", "夏天") {

    @Override

    public void show() { }

    },

    AUTUMN("AUTUMN", "秋天") {

    @Override

    public void show() { }

    },

    WINTER("WINTER", "冬天") {

    @Override

    public void show() { }

    };

    //1. 声明Seasons对象的属性

    private final String SeasonName;

    private final String SeasonDescrp;

    //2. 私有化类的构造器, 并给对象赋值初始化

    private Season(String SeasonName, String SeasonDescrp) {

    this.SeasonDescrp = SeasonDescrp;

    this.SeasonName = SeasonName;

    }

    }

    让每一个对象实现一次接口方法,使得每个对象有不同的动作。

    二、注解

    Annotation是在代码里的特殊标记这些标记可以在编译时,类加载时被读取,并作出相应的处理。不改变原有逻辑的情况下,在程序中添加一些补充信息。

    应用

    应用一:在生成文档中使用注解(javadoc)

    @author @param @return @version 等等。

    应用二:编译时进行格式检查(JDK内置的三个注解)

    @Override 表示限定重写父类方法,该注解只能用于方法

    @Deprecated 表示所修饰的怨妇已经过时。通常是因为所修饰的结构危险或者存在更好的选择

    @SuppressWarnings 抑制编译器警告

    class Person {

    public void walk() {

    System.out.println("人走路");

    }

    //下面的用于标记,这个方法已经过时了

    @Deprecated

    public void eat() {

    System.out.println("人吃饭");

    }

    }

    interface Info {

    void show();

    }

    class Student extends Person implements Info {

    //标记用于重写父类中的方法,以及实现接口中的方法

    @Override

    public void walk() { System.out.println("学生走路"); }

    @Override

    public void show() { System.out.println("我是学生"); }

    public static main(String[] args) {

    //在代码中,创建的变量未使用会有警告Waring

    //这里的unused就是表示忽略,没使用这个警告的

    @SuppressWarnings("unused")

    int num = 100;

    //System.out.println(num);

    //下面的这种"rawtypes"适用于使用泛型的时候并没有选取类型的警告

    @SuppressWarnings({"unused", "rawtypes"})

    ArrayList list = new ArrayList();

    }

    }

    应用三:跟踪代码依赖性,实现代替配置文件功能

    Servlet3.0提供了注解,使得不需要在web.xml文件中进行Servlet的部署

    EnumAndAnnotation-Annotation-1.png

    自定义注解

    自定义新注解使用 @interface 关键字

    定义 Annotation 成员变量时,以 无参数方法 的形式来声明。

    只有一个参数成员,建议使用value命名

    如果注解没有成员表明是一个标识作用

    使用注解的时候,需要设定一个值,如果已经有了默认值值,那么,就可以不用手写默认值了。

    自定义的注解,需要配上信息处理流程(使用反射)才有意义。

    通常会指明两个元注解,@Retention 和 @Target

    public @interface CustomAnnotation {

    //只有一个值的话值的名字叫做value就很好

    //String value();

    //当然也可以使用default设置为默认值

    String value() default "Hello";

    }

    JDK中的元注解

    元注解:对于现有注解进行修饰的注解。

    JDK5.0 提供了4个标准的元注解(meta-annotation)类型:

    Retention:指明所有修饰的 Annotation 的生命周期,其中包含了一个RetentionPolicy类型的成员变量。

    相关的Java SE API

    EnumAndAnnotation-Annotation-2.png

    从上面可以看出只有 RUNTIME 才可以使用反射

    Target:用于修饰 Annotation 的定义,用于 指定 被修饰的 Annotation 能用于修饰那些程序元素

    相关的Java SE API

    EnumAndAnnotation-Annotation-3.png

    Documented:用于指定被该元注解修饰的 Annotation 类将会被javadoc提取为相应的文档,默认情况下Javadoc是不包括注解的

    Inherited:被它修饰的 Annotation 将具有继承性。如果某个类使用了被@Inherited标记的Annotation那么子类中也会继承父类中的,这个Annotation。

    通过反射获取注解信息

    JDK8 中注解的新特性

    可重复注解

    //JDK8.0之前想要使用重复注解的方法

    public @interface MyAnnotations {

    MyAnnotation[] value();

    }

    public @interface MyAnnotation {

    String[] value();

    }

    @MyAnnotations({

    @MyAnnotation(value = "hello"),

    @MyAnnotation(value = "hi")

    })

    class Person {

    public void walk() {

    System.out.println("人走路");

    }

    //下面的用于标记,这个方法已经过时了

    @Deprecated

    public void eat() {

    System.out.println("人吃饭");

    }

    }

    在MyAnnotation上声明@Repeatable,成员值为MyAnnotations.class

    MyAnnotation的Target和Retention与MyAnnotations相同

    //这个是目标注解

    import java.lang.annotation.*;

    //使用注解@Rpeatable与这个注解的容器注解产生关联

    @Repeatable(MyAnnotations.class)

    @Retention(RetentionPolicy.RUNTIME)

    public @interface MyAnnotation {

    String value() default "hello";

    }

    //这个是目标注解的容器注解

    import java.lang.annotation.*;

    @Retention(RetentionPolicy.RUNTIME)

    public @interface MyAnnotations {

    MyAnnotation[] value();

    }

    //这是使用

    @MyAnnotation("Hello")

    @MyAnnotation("hi")

    class Person {

    public void walk() {

    System.out.println("人走路");

    }

    //下面的用于标记,这个方法已经过时了

    @Deprecated

    public void eat() {

    System.out.println("人吃饭");

    }

    }

    通过上下的比较,可以发现,JDK8的新特性是对原来注解嵌套的简化。

    展开全文
  • Java枚举类型的妙用

    2021-04-22 19:19:35
    在这种情况下,对于初级程序员可能就会这样定义这里每一个数字代表一个订单状态,这样设计虽然也能满足需求,但是会存在一些问题:如果开发没有很好的注释,那么可能开发一段时间后你自己就忘了订单状态的含义如果...
  • 一、枚举类的使用: 1.枚举类的理解:类的对象只有有限个,确定的。我们称此为枚举类 2.当需要定义一组常量时,强烈建议使用枚举类。 3.如果枚举类中只有一个对象,则可以作为单例模式的实现方式。 二、如何定义枚举...
  • Java-枚举类和注解

    2020-08-31 09:19:51
    枚举类与注解 什么叫枚举类? 方式一示例:自定义枚举类 public class sesontest { public static void main(String[] args) { Season spring = Season.SPRING; System.out.println(spring); Season...
  • java中的枚举类与注解

    千次阅读 2020-05-01 21:12:59
    java中的枚举类与注解一、枚举类的使用1、 自定义枚举类2、使用enum定义枚举类二、注解(Annotation)1、概述2、常见的Annotation示例3、 自定义 Annotation4、JDK中的元注解1、@Retention2、@Target3、@Documented和@...
  • 我正在使用Spring 4,我有一个枚举声明…public static enum MY_ENUMS {A(1, "enum1"),B(2, "enum2");private final int key;private final String name;MY_ENUMS(int key, String name) {this.key = key;this.name =...
  • 如何从Java中的常量提供枚举值的注释我无法使用从常量中取得的Enum作为注释中的参数。 我得到这个编译错误:“注释属性[属性]的值必须是一个枚举常量expression式”。这是Enum代码的简化版本:public enum MyEnum { ...
  • java枚举接口

    2021-03-04 02:42:08
    java中的枚举类枚举类(enum),与class和interface关键字地位相同。枚举类是一个特殊的类,可以有自己的成员变量、方法、构造器,可以实现一个或...文章云栖-lxl2015-03-06458浏览量Java枚举Java枚举有如下特点:枚举...
  • Java 枚举和注解

    2020-12-29 09:41:52
    枚举关键字enum 值固定时使用枚举枚举只有一个成员, 则可以作为一种单例模式的实现方式. 枚举类对象的属性不应允许被改动, 所以应该使用 private final 修饰
  • 主要介绍了Java枚举详解及使用实例(涵盖了所有典型用法),本文直接给出实例代码,代码中包含详细注释,需要的朋友可以参考下
  • java注释引用另一个类或者枚举 @Data @ApiModel(value = "Pagination", description = "分页") public class Pagination<T> { /** * @see ExecStatusEnum */ @ApiModelProperty(value = "总行数", ...
  • 实现逻辑为 枚举类的按照接口实现枚举的方法,因为我需要两级嵌套枚举,所以使用下面的方法实现,如果只要分组也可以直接使用接口的实现方式,那个下次在写 import ...
  • Java 枚举(enum) 详解7种常见的用法

    万次阅读 多人点赞 2016-08-11 11:14:45
    JDK1.5引入了新的类型——枚举。在Java中它虽然算个“小”功能,却给我的开发带来了“大”方便。 大师兄我【大师兄】又加上自己的理解,来帮助各位理解一下。 用法一:常量 在JDK1.5之前,我们定义常量都是:...
  • Java枚举类与注解

    2021-09-29 13:38:54
    枚举类与注解1.1 枚举类1.1.1 枚举类的使用1.1.2 如何定义枚举类1.1.3 enum类中的常用方法1.1.4 使用enum关键字定义的枚举类实现接口的情况1.2 注解(Annotation)1.2.11.2.2 1. 枚举类与注解 1.1 枚举类 1.1.1 枚举...
  • Java枚举定义

    2021-03-06 22:47:28
    这意味着枚举的类型参数必须从枚举中派生,枚举本身具有相同的类型参数。这怎么可能发生?通过使类型参数为新类型本身。因此,如果我有一个名为StatusCode的枚举,它将等效于:public class StatusCode extends Enum...
  • 枚举对象注释 本文是我们名为“ 高级Java ”的学院课程的一部分。 本课程旨在帮助您最有效地使用Java。 它讨论了高级主题,包括对象创建,并发,序列化,反射等。 它将指导您完成Java掌握的旅程! 在这里查看 ! ...
  • java基础——枚举注解

    2021-10-02 19:38:42
    文章目录java基础1.enum枚举(enumerate)2.注解3.jdk的元Annotation(元注解,了解) 1.enum枚举(enumerate) (1)枚举是一组常量的集合 (2)枚举属于一种特殊的类,里面只包含一组有限的特定对象 (3)枚举的...
  • 深入理解Java枚举一、什么是枚举1.1 什么是枚举?至于枚举,我们先拿生活中的枚举来入手,然后再引申Java中的枚举,其实它们的意义很相似。谈到生活中的枚举,假如我们在玩掷骰子的游戏,在我们手中有两个骰子,要求...
  • Java 枚举(1): 详解7种常见的用法

    万次阅读 多人点赞 2021-01-31 22:55:04
    /** * Java枚举用法测试 * * Created by lxk on 2016/12/15 */ public class EnumTest { public static void main(String[] args) { forEnum(); useEnumInJava(); } /** * 循环枚举,输出ordinal属性;若枚举有内部...
  • 我无法使用从常量中获取的枚举作为注释中的参数。我收到此编译错误:"注释属性[attribute]的值必须是枚举常量表达式"。这是枚举代码的简化版本:public enum MyEnum {APPLE, ORANGE}对于注释:@Retention...
  • 我们使用Jackson1.9.1对与Java对象之间的...但是,尝试将JSON字符串反序列化为Java枚举时遇到问题。JSON字符串的序列化方式如下:"wt":{"wt":100.5,"unit":{"LBS":3}}wt的Java类型如下所示:public class Weight {...
  • JAVA枚举操作(获取值,转map集合)

    千次阅读 2020-12-20 00:54:45
    JAVA枚举相对来说比.NET的枚举功能强大,感觉就像是一种简化版的类对象,可以有构造方法,可以重载,可以继承接口等等,但不能继承类,JAVA枚举在实际开发中应用相当频繁,以下几个封装方法在实际开发中可能用到,...
  • Java枚举与注解

    2021-02-26 11:28:25
    一、枚举类package com.study.java;/*** 一、枚举类的使用* 1.枚举类的理解:类的对象只有有限个,确定的,我们称此类为枚举类* 2.当需要定义一组常量时,建议使用枚举类* 3.如果枚举类只有一个对象,可以作为单例...
  • 从字节码指令分析Java枚举类的运行过程。 目录 一、创建的枚举类 二、反编译字节码 1)getCode()方法分析 2)setCode()方法分析 三、枚举常量给枚举类成员变量赋值过程分析 一、创建的枚举类 public enum ...
  • 1.枚举类注:JDK1.5之前需要自定义枚举类JDK 1.5 新增的 enum 关键字用于定义枚举类若枚举只有一个成员, 则可以作为一种单例模式的实现方式1.枚举类的属性1、枚举类对象的属性不应允许被改动, 所以应该使用 private ...
  • public 开始尝试通过Enum的内置方法valueOf()获取,使用报错:public 输出:Exception 我们打开valueOf源码看看他是通过什么值获取,方法注释需要通过与声明枚举类型的标识完全匹配,就是说我要通过"SPRING"字符串来...
  • Java枚举类使用Lombok

    千次阅读 2020-06-12 14:33:31
    枚举类是一个特殊的常量类,由于其特殊的设计,具有简洁性、安全性以及便捷性,在开发中被普遍使用。本文简单介绍一下如何使用Lombok进行枚举类定义。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 51,640
精华内容 20,656
关键字:

java 枚举注释

java 订阅