• 第十章：枚举类与注解

    目录

    10.1：枚举类的使用

            当需要定义一组常量时，建议使用枚举类（前提：类的对象只有有限个，确定的）

    10.2：注解的使用(Annotation)

            10.2.1：注解概述

            10.2.2：注解的用法

    10.1：枚举类的使用
            当需要定义一组常量时，建议使用枚举类（前提：类的对象只有有限个，确定的）

                    eg：

                            星期：Mondey、.....、Sunday

                            性别：Man、.....、Woman

                            线程状态：创建、就绪、运行、阻塞、死亡

    1. package com.jiayifeng.java;
    2.  
    3. /**
    4.  * author 爱编程的小贾
    5.  * create 2023-09-17 18:25
    6.  *
    7.  * 一：枚举类的使用
    8.  *      1.理解：类的对象只有有限个，确定的，我们称此类为枚举类
    9.  *      2.如果枚举类中只有一个对象，则可以作为单列设计模式的实现方法
    10.  *
    11.  * 二：如何定义枚举类？
    12.  *      1.方式一：jdk5.0之前，自定义枚举类
    13.  *      2.方式二：jdk5.0，可以使用enum关键字定义枚举类
    14.  *
    15.  * 三：Enum类中常用的方法：
    16.  *      values()方法：返回枚举类的对象数组，该方法可以很方便的遍历所有的枚举值
    17.  *      valueOf(String str)方法：可以把一个字符串转换为对应的枚举类对象。
    18.  *      toString()：返回当前枚举类对象常量的名称
    19.  *
    20.  * 四：使用enum关键字定义的枚举类实现接口的情况
    21.  *      情况一：实现接口，在enum类中实现抽象方法
    22.  *      情况二：让枚举类的对象分别实现接口中的抽象方法
    23.  */
    24. public class SeasonTest {
    25.     public static void main(String[] args) {
    26.         Season spring = Season.SPRING;
    27. //        toString()
    28.         System.out.println(spring);//Season{seasonName='春天', seasonDesc='春暖花开'}
    29.     }
    30. }
    31.  
    32. //自定义枚举类
    33. class Season{
    34. //   1.声明对象的属性：private final修饰
    35.     private final String seasonName;
    36.     private final String seasonDesc;
    37.  
    38. //    2.私有化类的构造器,并给对象属性进行赋值(初始化)
    39.     private Season(String seasonName,String seasonDesc){
    40.         this.seasonName = seasonName;
    41.         this.seasonDesc = seasonDesc;
    42.     }
    43.  
    44. //    3.提供当前枚举类的多个对象：public static final
    45.     public static final Season SPRING = new Season("春天","春暖花开");
    46.     public static final Season SUMMER = new Season("夏天","夏日炎炎");
    47.     public static final Season AUTUMN = new Season("秋天","秋高气爽");
    48.     public static final Season WINTER = new Season("冬天","冰天雪地");
    49.  
    50.  
    51. //    4.其它诉求1：获取枚举类对象的属性
    52.     public String getSeasonName() {
    53.         return seasonName;
    54.     }
    55.  
    56.     public String getSeasonDesc() {
    57.         return seasonDesc;
    58.     }
    59.  
    60. //    5.其它诉求2：提供toString()
    61.     @Override
    62.     public String toString() {
    63.         return "Season{" +
    64.                 "seasonName='" + seasonName + '\'' +
    65.                 ", seasonDesc='" + seasonDesc + '\'' +
    66.                 '}';
    67.     }
    68. }
    1. package com.jiayifeng.java;
    2.  
    3. /**
    4.  * author 爱编程的小贾
    5.  * create 2023-09-18 8:14
    6.  *
    7.  * 一：使用enum关键字定义枚举类
    8.  *      1.说明：定义的枚举类默认继承java.lang.Enum类
    9.  */
    10. public class SeasonTest2 {
    11.     public static void main(String[] args) {
    12.         Season1 spring = Season1.SPRING;
    13. //        toString()
    14.         System.out.println(spring);//Season1{seasonName='春天', seasonDesc='春暖花开'}
    15.  
    16.         System.out.println(Season1.class.getSuperclass());//class java.lang.Enum
    17. //        values()
    18.         Season1[] values = Season1.values();
    19.         for(int i = 0;i < values.length;i++) {
    20.             System.out.println(values[i]);
    21.             values[i].show();
    22.         }
    23.             /*
    24.             Season1{seasonName='春天', seasonDesc='春暖花开'}
    25.             春天在哪里？
    26.             Season1{seasonName='夏天', seasonDesc='夏日炎炎'}
    27.             夏天在哪里？
    28.             Season1{seasonName='秋天', seasonDesc='秋高气爽'}
    29.             秋天在哪里？
    30.             Season1{seasonName='冬天', seasonDesc='冰天雪地'}
    31.             冬天在哪里？
    32.              */
    33.         System.out.println("***************************");
    34.         Thread.State[] values1 = Thread.State.values();
    35.         for(int i = 0;i < values.length;i++){
    36.             System.out.println(values1[i]);
    37.             /*
    38.             NEW
    39.             RUNNABLE
    40.             BLOCKED
    41.             WAITING
    42.              */
    43.             System.out.println("************************");
    44. //            valueOf(String objName)：返回枚举类中对象名是objName的对象
    45. //            如果没有objName的枚举类对象，则抛异常：IllegalArgumentException
    46.             Season1 winter = Season1.valueOf("WINTER");
    47.             System.out.println(winter);//Season1{seasonName='冬天', seasonDesc='冰天雪地'}
    48. //            winter.show();//这是一个季节
    49.         }
    50.     }
    51. }
    52.  
    53. interface Info{
    54.     void show();
    55. }
    56. //使用enum关键字定义枚举类
    57. enum Season1 implements Info{
    58.     //   1.提供当前枚举类的对象，多个对象之间用","隔开，末尾对象用";"结束
    59.      SPRING("春天","春暖花开"){
    60.          public void show(){
    61.              System.out.println("春天在哪里？");
    62.          }
    63.     },
    64.      SUMMER("夏天","夏日炎炎"){
    65.          public void show(){
    66.              System.out.println("夏天在哪里？");
    67.          }
    68.      },
    69.      AUTUMN("秋天","秋高气爽"){
    70.          public void show(){
    71.              System.out.println("秋天在哪里？");
    72.          }
    73.      },
    74.      WINTER("冬天","冰天雪地"){
    75.          public void show(){
    76.              System.out.println("冬天在哪里？");
    77.          }
    78.      };
    79.  
    80.  
    81.     //   2.声明对象的属性：private final修饰
    82.     private final String seasonName;
    83.     private final String seasonDesc;
    84.  
    85.     //   3.私有化类的构造器,并给对象属性进行赋值(初始化)
    86.     private Season1(String seasonName,String seasonDesc){
    87.         this.seasonName = seasonName;
    88.         this.seasonDesc = seasonDesc;
    89.     }
    90.  
    91.  
    92.     //   4.其它诉求1：获取枚举类对象的属性
    93.     public String getSeasonName() {
    94.         return seasonName;
    95.     }
    96.  
    97.     public String getSeasonDesc() {
    98.         return seasonDesc;
    99.     }
    100.  
    101.     //   5.其它诉求2：提供toString()
    102.     @Override
    103.     public String toString() {
    104.         return "Season1{" +
    105.                 "seasonName='" + seasonName + '\'' +
    106.                 ", seasonDesc='" + seasonDesc + '\'' +
    107.                 '}';
    108.     }
    109.  
    110.  
    111. //    @Override
    112. //    public void show() {
    113. //        System.out.println("这是一个季节");
    114. //    }
    115. }
    10.2：注解的使用(Annotation)
            10.2.1：注解概述

                    从JDK 5.0开始，Java增加了对元数据(MetaData)的支持，也就是Annotation

                    Annotation其实就是代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过使用Annotation，程序员可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息。代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署

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

                    可以说：框架 = 注解 + 反射 + 设计模式

            10.2.2：注解的用法
    1. package com.jiayifeng.java1;
    2.  
    3. /**
    4.  * author 爱编程的小贾
    5.  * create 2023-09-18 18:13
    6.  *
    7.  * 一：注解的使用
    8.  *      1.理解Annotation
    9.  *
    10.  *      2.Annotation的使用示例
    11.  *          示例一：生成文档相关的注解
    12.  *          示例二：在编译时进行格式检查(JDK内置的三个基本注解)
    13.  *                  @Override：限定重写父类方法，该注解只能用于方法
    14.  *                  @Deprecated：用于表示所修饰的元素(类、方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择
    15.  *                  @SuppressWarnings：抑制编译器警告
    16.  *          示例三：跟踪代码依赖性，实现替代配置文件功能
    17.  *
    18.  *      3.如何自定义注解：参照@SuppressWarnings定义
    19.  *          ①注解声明为：@interface
    20.  *          ②内部定义成员，通常使用value()表示
    21.  *          ③可以指定成员的默认值，使用default定义
    22.  *          ④如果自定义注解没有成员，表明是一个标识作用
    23.  *          ⑤如果注解有成员，在使用注解时，需要指明成员的值
    24.  *          ⑥自定义注解必须配上注解的信息处理流程(使用反射)才有意义
    25.  *          ⑦自定义注解通常都会指明两个元注解：Retention、Target
    26.  *
    27.  *      4.jdk提供的四种元注解
    28.  *          元注解：对现有的注解进行解释说明的注解
    29.  *              Retention：指定所修饰的Annotation的声明周期：SOURCE\CLASS(默认行为)\RUNTIME
    30.  *                  只有声明为RUNTIME生命周期的注解，才能通过反射获取
    31.  *              Target：用于指定被修饰的Annotation能用于修饰哪些程序元素
    32.  *              **********出现的频率较低********************
    33.  *              Documented：表示所修饰的注解在被javadoc解析时，保留下来
    34.  *              Interited：被它修饰的Annotation将具有继承性
    35.  *
    36.  *      5.jdk 8注解的新特性：可重复注解、类型注解
    37.  */
    38. public class AnnotationTest {
    39.     public static void main(String[] args) {
    40.         Person p1 = new Student();
    41.         p1.walk();
    42.     }
    43. }
    44.  
    45. @MyAnnotation("hello")
    46. class Person{
    47.     private String name;
    48.     private int age;
    49.  
    50.     public Person(){
    51.  
    52.     }
    53.  
    54.     public Person(String name, int age) {
    55.         this.name = name;
    56.         this.age = age;
    57.     }
    58.  
    59.     public void walk(){
    60.         System.out.println("人走路");
    61.     }
    62.  
    63.     public void eat(){
    64.         System.out.println("人吃饭");
    65.     }
    66. }
    67.  
    68. interface info{
    69.     void show();
    70. }
    71.  
    72. class Student extends Person implements info{
    73.     @Override
    74.     public void walk() {
    75.         System.out.println("学生走路");
    76.     }
    77.  
    78.     public void show(){
    79.  
    80.     }
    81. }
    1. package com.jiayifeng.java1;
    2.  
    3. import java.lang.annotation.*;
    4.  
    5. import static java.lang.annotation.ElementType.*;
    6. import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
    7.  
    8. /**
    9.  * author 爱编程的小贾
    10.  * create 2023-09-18 18:54
    11.  */
    12. @Inherited
    13. @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
    14. @Retention(RetentionPolicy.RUNTIME)
    15. public @interface MyAnnotation {
    16.     String value();
    17. }
    1. package com.jiayifeng.java1;
    2.  
    3. import java.util.ArrayList;
    4.  
    5. /**
    6.  * author 爱编程的小贾
    7.  * create 2023-09-18 18:45
    8.  */
    9. public class AnnotationTest1 {
    10.     public static void main(String[] args) {
    11.         @SuppressWarnings("unused")
    12.         int num = 10;
    13.  
    14.         @SuppressWarnings({"unused","rawtypes"})
    15.         ArrayList list = new ArrayList();
    16.     }
    17. }
  • 相关阅读:
    【LeetCode】187. 重复的DNA序列
    vue项目启动npm install和npm run serve时出现错误Failed to resolve loader:node-sass
    STN：不规则文本矫正网络的探索
    git stash 问题记录
    kubernetes之Deployment
    Python时间模块之time模块
    单例模式浅析
    关于java.lang.NoSuchMethodException异常解决问题
    2023年9月青少年软件编程（C 语言） 等级考试试卷（六级）
    招生CRM系统|基于Springboot实现培训机构招生CRM管理系统
  • 原文地址：https://blog.csdn.net/weixin_63925896/article/details/132948575