枚举和注解

已于 2022-07-02 13:17:18 修改
阅读量511 收藏
点赞数 2
分类专栏： java基础 文章标签： java
于 2021-12-12 22:45:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60766221/article/details/121891034
版权

文章目录

1 先看一个需求

==> 视频链接

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

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;
   }
}

2 分析问题

2.1 创建 Season 对象有如下特点

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

3 解决方案-枚举

  1. 枚举对应英文(enumeration，简写 enum)
  2. 枚举是一组常量的集合
  3. 可以这样理解：枚举属于一种特殊的类，里面只包含一组有限的特定的对象

4 枚举的二种实现方式

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

5 自定义类实现枚举

  1. 不需要提供setXxx 方法，因为枚举对象值通常为只读
  2. 对枚举对象/属性使用 final + static 共同修饰，实现底层优化
  3. 枚举对象名通常使用全部大写【常量的命名规范】
  4. 枚举对象根据需要，也可以有多个属性
public class Enumeration02 {
    public static void main(String[] args) {
        System.out.println(Season.AUTUMN);
        System.out.println(Season.SPRING);
    }
}

//演示字定义枚举实现
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 AUTUMN = new Season("秋天", "凉爽");
    public static final Season SUMMER = 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 + '\'' +
                '}';
    }
}

6 自定义类实现枚举-小结

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

7 enum 关键字实现枚举-快速入门

7.1 说明

使用 enum 来实现前面的枚举案例，体会和自定义类实现枚举不同的地方

  1. 使用关键字 enum 替代 class
  2. public static final Season SPRING = new Season("春天", "温暖") => 直接使用 SPRING("春天", "温暖") 解读： 常量名(实参列表)
  3. 如果有多个常量(对象)， 使用 , 号间隔即可
  4. 如果使用enum 来实现枚举，要求将定义常量对象，写在枚举类的最前面
  5. 如果我们使用的是无参构造器，创建常量对象，则可以省略 ()
public class Enumeration03 {
    public static void main(String[] args) {
        System.out.println(Season2.AUTUMN);
        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 AUTUMN = new Season("秋天", "凉爽");
//    public static final Season SUMMER = new Season("夏天", "炎热");
    //如果使用了enum 来实现枚举类
    //1. 使用关键字 enum 替代 class
    //2. public static final Season SPRING = new Season("春天", "温暖") 直接使用
    //   SPRING("春天", "温暖") 解读 常量名(实参列表)
    //3. 如果有多个常量(对象)， 使用 ,号间隔即可
    //4. 如果使用enum 来实现枚举，要求将定义常量对象，写在前面
    //5. 如果我们使用的是无参构造器，创建常量对象，则可以省略 ()
    SPRING("春天", "温暖"), WINTER("冬天", "寒冷"), AUTUMN("秋天", "凉爽"),
    SUMMER("夏天", "炎热")/*, What()*/;

    private String name;
    private String desc;//描述

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

    }

    private Season2(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 + '\'' +
                '}';
    }
}

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

==> 视频链接

  1. 当我们使用 enum 关键字开发一个枚举类时，默认会继承 Enum 类，而且是一个 final 类【如何证明】使用 javap 工具来反编译
  2. 传统的 public static final Season2 SPRING = new Season2("春天", "温暖"); 简化成 SPRING("春天", "温暖")， 这里必须知道，它调用的是哪个构造器
  3. 如果使用无参构造器 创建 枚举对象，则实参列表和小括号都可以省略
  4. 当有多个枚举对象时，使用 , 间隔，最后有一个分号 ; 结尾
  5. 枚举对象必须放在枚举类的行首

在这里插入图片描述

在这里插入图片描述

8 小练习

题1： 下面代码是否正确, 并说明表示的含义?

enum Gender{ //1min
	BOY , GIRL; //这里其实就是调用 Gender 类的无参构造器
}
  1. 上面语法是 ok
  2. 有一个枚举类 Gender， 没有属性
  3. 有两个枚举对象 BOY，GIRL 使用的无参构造器创建

题2：下面代码输出什么?

public class EnumExercise01 {
    public static void main(String[] args) {
        Gender2 boy = Gender2.BOY;//OK
        Gender2 boy2 = Gender2.BOY;//OK
        System.out.println(boy);//输出结果: BOY
        //输出BOY , 本质就是调用 Gender2 的父类java.lang.Enum的 toString()
	    /**
	     * Enum 类的源码，看下 toString()方法
	     * 
	     * public String toString() {
	     *        return name;
	     * }
	     */
        System.out.println(boy2 == boy);  //true
    }
}

enum Gender2{ //父类 Enum 的toString
    BOY , GIRL;
}

9 enum 常用方法说明

  1. 使用关键字 enum 时，会隐式继承 Enum 类，这样我们就可以使用 Enum 类相关的方法

  2. 看下源码定义，如下：

public abstract class Enum<E extends Enum<E>>
	implements Comparable<E>, Serializable {
}
方法名详细描述
valueOf传递枚举类型的 Class 对象和枚举常量名称给静态方法 valueOf,会得到与参数匹配的常量
toString得到当前枚举常量的名称。你可以通过重写这个方法来使得到的结果易读。
equals在枚举类型中可以直接使用“==”来比较两个枚举常量是否相等。Enum提供的这个 equals()方法，也是直接使用 “ == ”实现的。它的存在是为了在 Set、List 和 Map 中使用。注意，equals()是不可变的。
hashCodeEnum实现了hashCode() 来和 equals() 保持一致。它也是不可变的。
getDeclaringClass得到枚举常量所属枚举类型的 Class 对象。可以用来判断两个枚举常量是否属于同一个枚举类型。
name得到当前枚举常量的名称。建议优先使用 toString()。
ordinal得到当前枚举常量的次序。
compareTo枚举类型实现了 Compare 接口，这样可以比较两个枚举常量的大小（按声明的顺序排列）
clone枚举类型不能被 Clone。为了防止子类实现克隆方法，Enum实现了一个仅抛出 CloneNotSupportedException 异常的不变 Clone()。

10 enum 常用方法应用实例

  1. toString()：Enum 类已经重写过了，返回的是当前枚举对象名 (常量名)，子类可以重写该方法，用于返回对象的属性信息

  2. name()：返回当前对象名 (常量名)，子类中不能重写

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

  4. values()：返回当前枚举类中所有的常量 (隐藏了，需要通过反编译查看)

  5. valueOf()：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常！执行流程如下：

    ① 根据你输入的 “字符串” 到 对于枚举类的枚举对象去查找
    ② 如果找到了，就返回，如果没有找到，就报错

  6. compareTo()：比较两个枚举常量，比较的就是编号！

public class EnumMethod {
    public static void main(String[] args) {
        //使用Season2 枚举类，来演示各种方法
        Season2 autumn = Season2.AUTUMN;

        //输出枚举对象的名字
        System.out.println(autumn.name());
        //ordinal() 输出的是该枚举对象的次序/编号，从0开始编号
        //AUTUMN 枚举对象是第三个，因此输出 2
        System.out.println(autumn.ordinal());
        //从反编译可以看出 values方法，返回 Season2[]
        //含有定义的所有枚举对象
        Season2[] values = Season2.values();
        System.out.println("===遍历取出枚举对象(增强for)====");
        for (Season2 season: values) {//增强for循环
            System.out.println(season);
        }

        //valueOf：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常
        //执行流程
        //1. 根据你输入的 "AUTUMN" 到 Season2的枚举对象去查找
        //2. 如果找到了，就返回，如果没有找到，就报错
        Season2 autumn1 = Season2.valueOf("AUTUMN");
        System.out.println("autumn1=" + autumn1);
        System.out.println(autumn == autumn1);

        //compareTo：比较两个枚举常量，比较的就是编号
        //解读
        //1. 就是把 Season2.AUTUMN 枚举对象的编号 和 Season2.SUMMER枚举对象的编号比较
        //2. 看看结果
        /*
        public final int compareTo(E o) {

            return self.ordinal - other.ordinal;
        }
        Season2.AUTUMN的编号[2] - Season2.SUMMER的编号[3]
         */
        System.out.println(Season2.AUTUMN.compareTo(Season2.SUMMER));

        //补充了一个增强for
//        int[] nums = {1, 2, 9};
//        //普通的for循环
//        System.out.println("=====普通的for=====");
//        for (int i = 0; i < nums.length; i++) {
//            System.out.println(nums[i]);
//        }
//        System.out.println("=====增强的for=====");
//        //执行流程是 依次从nums数组中取出数据，赋给i, 如果取出完毕，则退出for
//        for(int i : nums) {
//            System.out.println("i=" + i);
//        }
    }
}

10.1 练习

  1. 声明 Week 枚举类，其中包含星期一至星期日的定义； MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
  2. 使用 values 返回所有的枚举数组，并遍历，输出下图效果
    在这里插入图片描述

public class EnumExercise02 {
    public static void main(String[] args) {
        //获取到所有的枚举对象， 即数组
        Week[] weeks = Week.values();
        //遍历，使用增强for
        System.out.println("===所有星期的信息如下===");
        for (Week week : weeks) {
            System.out.println(week);
        }
    }
}

/*
声明Week枚举类，其中包含星期一至星期日的定义；
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
使用values 返回所有的枚举数组, 并遍历 , 输出左图效果

 */

enum Week   {
    //定义Week的枚举对象
    MONDAY("星期一"), TUESDAY("星期二"), WEDNESDAY("星期三"), THURSDAY("星期四"),
    FRIDAY("星期五"), SATURDAY("星期六"), SUNDAY("星期日");
    private String name;

    private Week(String name) {//构造器
        this.name = name;
    }

    @Override
    public String toString() {
        return name;
    }
}

11 enum 实现接口

  1. 使用 enum 关键字后，就不能再继承其它类了，因为 enum 会隐式继承 Enum，而Java 是单继承机制
  2. 枚举类和普通类一样，可以实现接口，如下形式
enum 类名 implements 接口 1，接口 2{}

public class EnumDetail {
    public static void main(String[] args) {
        Music.CLASSICMUSIC.playing();
    }
}
class A {

}

//1.使用enum关键字后，就不能再继承其它类了，因为enum会隐式继承Enum，而Java是单继承机制
//enum Season3 extends A {
//
//}
//2.enum实现的枚举类，仍然是一个类，所以还是可以实现接口的.
interface IPlaying {
    public void playing();
}
enum Music implements IPlaying {
    CLASSICMUSIC;
    @Override
    public void playing() {
        System.out.println("播放好听的音乐...");
    }
}

12 注解的理解

==> 视频链接

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

13 基本的 Annotation 介绍

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

  2. 三个基本的 Annotation:

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

14 基本的 Annotation 应用案例

14.1 @Override 注解的案例

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

    }
}
class Father{//父类

    public void fly(){
        int i = 0;
        System.out.println("Father fly...");
    }
    public void say(){}

}

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() {}
}

14.1.1 @Override 注解使用说明

  1. @Override 表示指定重写父类的方法 (从编译层面验证 ) ，如果上面案例中 父类没有 fly() 方法，则会报错
  2. 如果不写 @Override 注解，而父类仍有 public void fly() {} ，仍然构成重写
  3. @Override 只能修饰方法，不能修饰其他类、包、属性等等
  4. 查看 @Override 注解源码为 @Target(ElementType.METHOD) ，说明只能修饰方法
  5. @Target 是修饰注解的注解，称为 元注解

14.2 @Deprecated 注解的案例

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

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, PARAMETER, TYPE})
public @interface Deprecated {
}
 */
@Deprecated
class A {
    @Deprecated
    public int n1 = 10;
    @Deprecated
    public void hi(){

    }
}

14.2.1 @Deprecated 注解说明

  1. 用于表示某个程序元素 (类，方法等) 已过时
  2. 可以修饰方法，类，字段，包，参数 等等
  3. 源码：
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}
  1. @Deprecated 的作用可以做到新旧版本的兼容和过渡

14.3 @SuppressWarnings 注解的案例

@SuppressWarnings：抑制编译器警告

@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
    //(2) 该注解类有数组 String[] values() 设置一个数组比如 {"rawtypes", "unchecked", "unused"}
    /*
        @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
            @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() {
//        @SuppressWarnings({"rawtypes"})
        List list = new ArrayList();


        list.add("jack");
        list.add("tom");
        list.add("mary");
//        @SuppressWarnings({"unused"})
        int i;
        System.out.println(list.get(1));
    }
}

15 JDK 的元 Annotation(元注解)

15.1 元注解的基本介绍

  1. JDK 的元 Annotation 用于修饰其他 Annotation元注解
  2. 学习框架时，手动实现底层机制时会用到，看源码时，可以知道他是干什么

15.2 元注解的种类

  1. @Retention ：指定注解的作用范围，三种 SOURCE, CLASS, RUNTIME
  2. @Target ：指定注解可以在哪些地方使用
  3. @Documented ：指定该注解是否会在 javadoc 体现
  4. @Inherited ：子类会继承父类注解

15.3 @Retention 注解

  1. 只能用于修饰一个 Annotation 定义，用于指定该 Annotation 可以保留多长时间

  2. @Rentention 包含一个 RetentionPolicy 类型的成员变量，使用 @Rentention 时必须为该 value 成员变量指定值

  3. @Retention 的三种值：

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

  4. 看下 @Override 注解源码：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}
  1. @Override 源码说明：Override 的作用域在 SOURCE ，当编译器编译时生效，不会写入到 .class文件 ，也不会再 runtime (运行时) 生效

15.4 @Target

  1. @Target 用于修饰 Annotation 定义，用于指定被修饰的 Annotation 能用于修饰哪些程序元素
  2. @Target 包含一个名为 value 的成员变量
  3. @Target 源码说明
@Documented
@Retention(RetentionPolicy.RUNTIME) //它的作用范围是 RUNTIME
@Target(ElementType.ANNOTATION_TYPE) //这里的 ANNOTATION_TYPE 说明 @Target只能修饰注解
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(); //可以简单看一下ElementType 的取值 //通过Enum 比如: TYPE等
}

15.5 @Documented

  1. @Documented ：用于指定被该元注解修饰的 Annotation 类将被 javadoc 工具提取成文档，即在生成文档时，可以看到该注解
  2. 说明：定义为 Documented的注解必须设置 Retention值为 RUNTIME
  3. 看个案例：
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated { //一个 Deprecated 注解@Documented，则javadoc会看到
}
  1. 源码：
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Documented {
}

15.6 @Inherited 注解

  1. 被 @Inherited 修饰的 Annotation 将具有继承性
  2. 如果某个类使用的被 @Inherited 修饰的 Annotation ，则其子类将自动具有该注解
  3. 使用较少，了解即可~~

16 本章作业

==> 视频链接

创建一个Color枚举类

  1. 有 RED,BLUE,BLACK,YELLOW,GREEN 这个五个枚举值/对象；
  2. Color有三个属性redValue，greenValue，blueValue
  3. 创建构造方法，参数包括这三个属性
  4. 每个枚举值都要给这三个属性赋值，三个属性对应的值分别是 red: 255,0,0 ，blue: 0,0,255 ，black: 0,0,0 yellow: 255,255,0 green: 0,255,0
  5. 定义接口，里面有方法show，要求Color实现该接口
  6. show方法中显示三属性的值
  7. 将枚举对象在switch语句中匹配使用
public class Homework {
    public static void main(String[] args) {
        //演示一下枚举值的switch使用
        Color green = Color.GREEN;
        green.show();
        //比较一下
        //switch () 中，放入枚举对象
        //在每个case 后，直接写上在枚举类中，定义的枚举对象即可
        switch (green) {
            case YELLOW:
                System.out.println("匹配到黄色");
                break;
            case BLACK:
                System.out.println("匹配到黑色");
                break;
            default:
                System.out.println("没有匹配到..");
        }
    }
}

/*
枚举类
创建一个Color枚举类
1.有 RED,BLUE,BLACK,YELLOW,GREEN这个五个枚举值/对象；
2.Color有三个属性redValue，greenValue，blueValue，
3.创建构造方法，参数包括这三个属性，
4.每个枚举值都要给这三个属性赋值，三个属性对应的值分别是
red：255,0,0  blue:0,0,255  black:0,0,0  yellow:255,255,0  green:0,255,0
5.定义接口，里面有方法show，要求Color实现该接口
6.show方法中显示三属性的值
7. 将枚举对象在switch语句中匹配使用

 */
interface IMyInterface {
    public void show();
}

enum Color implements IMyInterface {
    RED(255, 0, 0), BLUE(0, 0, 255), BLACK(0, 0, 0), YELLOW(255, 255, 0), GREEN(0, 255, 0);
    private int redValue;
    private int greenValue;
    private int blueValue;

    Color(int redValue, int greenValue, int blueValue) {
        this.redValue = redValue;
        this.greenValue = greenValue;
        this.blueValue = blueValue;
    }

    @Override
    public void show() {
        System.out.println("属性值为" + redValue + "," + greenValue + "," + blueValue);
    }
}
要学就学灰太狼
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Java枚举类的使用与注解
01-20
一、枚举类的使用： 1.枚举类的理解：类的对象只有有限个，确定的。我们称此为枚举类 2.当需要定义一组常量时，强烈建议使用枚举类。...五、注解(Annotation)概述 二、常见的Annotation 示例： 六、JDK中的元
通过提问ChatGPT来解决枚举和注解等需求问题
02-17
第11章枚举和注解 11.1先看一个需求 11.2分析问题 11.2.1创建Season对象有如下 特点 11.3解决方案-枚举 11.4枚举的二种实现方式 11.5自定义类实现枚举-应用案例 11.6自定义类实现枚举-小结 11.6.1小结 11.7e num...
枚举，注解
苏蔡的专栏
12-07 343
枚举enum其实是一个完整的类，它允许添加任意的方法和字段，以及实现接口等。enum类型的对象可以直接比较，也可以被序列化，在序列化过程中不允许对enum类型进行修改。 1.简单的枚举常量public enum WeekDays { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDY, SATURDAY, SUNDAY }2. 向枚举中添加属性publi
枚举 注解
weixin_46721333的博客
06-26 169
10.1 枚举类的使用 主要内容:  如何自定义枚举类  如何使用关键字enum定义枚举类  Enum类的主要方法  实现接口的枚举类10.1.1 枚举类的使用：入门  类的对象只有有限个，确定的。举例如下：  星期：Monday(星期一)、......、Sunday(星期天)  性别：Man(男)、Woman(女)  季节：Spring(春节)......Winter(冬天)  支付方式：Cash（现金）、WeChatPay（微信）、Alipay(
枚举、注解
ieno_的博客
03-16 218
枚举（enumeration，简写enum） 1.枚举是一组常量的集合 2.可以这样理解：枚举属于一种特殊的类，里面只包含一组有限的特定的对象 实现方式： 1.自定义类实现枚举 2.使用enum关键字实现枚举 一、自定义类实现枚举 1.不需要提供setXXX方法，因为枚举对象只通常为只读； 2.对枚举对象/属性使用 final + static 共同修饰， 实现底层优化； 3.枚举对象名通常使用全部大写，常量的命名规范； 4.枚举对象根据需要，也可以有多个属性 public class Enumeratio
枚举注解
诺诺诺诺诺诺诺诺的博客
03-16 1400
Enum in Android 枚举Enum在java中是一个完整的类. 而枚举中的每一个值在枚举类中都是一个对象. 所以在我们使用时枚举的值将比整数常量消耗更多的内存. 当我们使用枚举在安卓应用中, 如果我们的程序本身内存消耗就比较大,或者是一个游戏的应用程序. 那么我们最好使用常量来替代枚举。可是使用了常量代替后又不能限制取值了。  Android 支持注解库中有一些好用的annotatio...
Java 第二阶段建立编程思想 【枚举和注解】---- 代码
07-29
Java 第二阶段建立编程思想 【枚举和注解】---- 代码 Java 第二阶段建立编程思想 【枚举和注解】---- 代码 Java 第二阶段建立编程思想 【枚举和注解】---- 代码 Java 第二阶段建立编程思想 【枚举和注解】---- 代码 ...
【Java基础笔记】枚举和注解.docx
10-25
【Java基础笔记】枚举和注解.docx
day18-xml、枚举和注解.zip
09-12
day18-xml、枚举和注解
枚举类&注解
TANGWENYU_的博客
10-09 499
枚举类&注解 文章目录一、什么是枚举？1.枚举的实现自定义枚举实现enum关键字实现enum常用方法enum类实现接口二、注解1.三个基本的Annotation2.四种元注解 一、什么是枚举？ 枚：一个一个。 举：举例。 枚举类（enumertation,简写：enum）：把具体的对象一个一个举例出来的类。 枚举是一组常量的集合，枚举属于一种特殊的类，里面只包含一组有限的特定的对象。 1.枚举的实现 自定义枚举实现 1.将构造器私有化，目的：防止直接 new 2.去掉setXXX方法，防止属性被修改
枚举类和注解
J的博客
02-02 626
介绍枚举类和注解
枚举和注解（Enum and Annotation）
一只程序狗的学习笔记
08-15 2629
Java 1.5发行版本新增了两个引用类型家族：枚举类型（Enumerate类）和注解类型（Annotation接口）。
十二：枚举与注解
热门推荐
本人主攻Java，希望自己能成为出色的程序员。
02-06 1万+
跳转到总目录 文章目录01、枚举类的使用1.1、枚举类的理解1.2、自定义枚举类1.3、使用enum关键字定义枚举类1.4、Enum类中的常用方法1.5、使用enum关键字定义的枚举类实现接口02、注解的使用2.1、注解的理解2.2、Annotation的使用示例2.3、如何自定义注解2.4、jdk中4个基本的元注解的使用12.5、jdk中4个基本的元注解的使用22.6、利用反射获取注解信息2.7、jdk8新特性：可重复注解2.8、jdk8新特性：类型注解 01、枚举类的使用 1.1、枚举类的理解 类的对
效率编程 之「枚举和注解」
CG国斌的博客
06-06 1095
温馨提示：本系列博文（含示例代码）已经同步到 GitHub，地址为「java-skills」，欢迎感兴趣的童鞋Star、Fork，纠错。 第 1 条：用enum代替int常量 枚举类型是指由一组固定的常量组成合法值的类型，例如人的性别、中国的省份名称等。在 Java 1.5 发行版之前，表示枚举类的常用模式是声明一组具名的int常量，每个类型成员一个常量： public cl...
java基础——枚举注解
上邪的博客
10-02 1071
java基础 笔记的都是需要背诵的零散知识点，以顺序的方式组织 文章目录java基础1.enum枚举（enumerate）2.注解3.jdk的元Annotation（元注解，了解） 1.enum枚举（enumerate） （1）枚举是一组常量的集合 （2）枚举属于一种特殊的类，里面只包含一组有限的特定对象 （3）枚举的两种实现方式： 自定义类实现枚举 使用enum关键字实现枚举 （4）自定义类实现枚举： 不需要提供setXxx方法，因为枚举对象值通常为只读. 对枚举对象/属性使用final
枚举与注解的使用说明
跟小白一起学编程！
09-25 765
枚举类与注解枚举类枚举类的理解如何定义枚举类？方式一、自定义枚举类步骤案例方式二、使用 enum 关键字定义枚举类使用说明Enum 类常用方法Enum 类的主要方法步骤案例实现接口的枚举类使用 enum 关键字定义的枚举类实现接口的情况案例注解理解常见的 Annotation一：生成文档相关的注解说明案例二：在编译时进行格式检查(JDK内置的三个基本注解)案例三：跟踪代码依赖性，实现替代配置文件功能自定义 Annotation（注解）参照 @SuppressWarnings 注解进行定义@SuppressW
Annotation & Enum ：Java中注解和枚举的使用
DrifterJ's Stash
08-06 1万+
Java从5.0推出了很多新的东西，其中包含了标题所示两大利器。现在开始分别介绍一下： 【Annotation】 注解，用于为一些信息添加额外解释信息时使用，类似元数据的概念，用于描述数据的数据。这个东西在设计基础性框架的时候非常有用，你可以通过定义一些注解，让应用层程序员能够将自己的代码嵌入并运行在你的框架中。当没有Annotation的时候，框架通常需要应用层开发人员写配置文件，有了这个，
Java 枚举类型 注解
最新发布
04-18
枚举类型注解在实际开发中的作用非常重要，它可以帮助开发者更好地描述和控制枚举类型的行为。例如，我们可以在枚举类型注解中添加自定义的属性，用于描述枚举类型的一些特定信息，从而更好地理解和使用该枚举类型。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

要学就学灰太狼

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

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

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

打赏作者

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

抵扣说明：

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

余额充值