Java的枚举,注解和反射(一)

目录

• 枚举
• 什么是枚举？
• 枚举类的实现
• 自定义实现枚举类
• 使用关键字enum定义枚举类
• Enum的常用方法
• 实现接口的枚举类
• 注解
• 注解概述
• 常见的注解
• 总结

枚举

什么是枚举？

枚举的字面意思就是 一一列举出来

在数学和计算机科学理论中，一个集的枚举是列出某些有穷序列集的所有成员的程序，或者是一种特定类型对象的计数。这两种类型经常（但不总是）重叠。是一个被命名的整型常数的集合，枚举在日常生活中很常见，例如表示星期的SUNDAY、MONDAY、TUESDAY、WEDNESDAY、THURSDAY、FRIDAY、SATURDAY就是一个枚举。再比如线程的状态：创建、运行、阻塞、等待、消亡，这也是一个枚举。

在java中的枚举也是类似的：

枚举是在JDK1.5以后引入的。主要用途是：将一组常量组织起来。

当需要定义一组常量的时候就可以使用枚举。枚举的对象是有限的、确定的。

枚举本身就是一个类，其构造方法默认为私有的。

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

枚举类的实现

自定义实现枚举类

jdk1.5之前使用自定义的方式实现枚举类的定义

package enumDemo;
/**
 * user：ypc；
 * date：2021-06-22;
 * time: 18:21;
 * 自定义实现枚举类
 */
public class EnumDemo1 {
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        System.out.println(spring);
    }
}
//自定义实现季节的枚举类
class Season {
    //1.首先要求枚举类是常量，就可以使用 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 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("冬天", "冰天雪地");
    //提供获取枚举的属性的方法
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

使用关键字enum定义枚举类

jdk1.5引入enum关键字

package enumDemo;
import org.junit.Test;
/**
 * user：ypc；
 * date：2021-06-22;
 * time: 18:40;
 * 使用enum关键字来定义枚举类
 */
public class EnumDemo2 {
    @Test
    public void test(){
        SeasonEnum spring = SeasonEnum.SPRING;
        System.out.println(spring);
        //枚举类的父类是
        System.out.println("枚举类的父类是:"+SeasonEnum.class.getSuperclass().getName());
    }
}
enum SeasonEnum{
    //提供当前枚举类的对象，之间使用","隔开，最后一个对象使用";"隔开
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","冰天雪地");

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

Enum的常用方法

package enumDemo;
import org.junit.Test;
/**
 * @author ypc
 * @create 2021-06-22;
 * 枚举类常用的方法
 */
public class EnumDemo3 {
    @Test
    public void test() {
        //toString方法
        System.out.println(SeasonEnum.SPRING.toString());
        System.out.println("****************************");
        //values方法.
        SeasonEnum[] seasonEnums = SeasonEnum.values();
        System.out.println("季节枚举类中的对象:");
        for (SeasonEnum seasonenum : seasonEnums) {
            System.out.println(seasonenum);
        }
        System.out.println("****************************");
        //线程状态中的所有的枚举的对象
        Thread.State[] states = Thread.State.values();
        System.out.println("线程状态枚举类中的对象:");
        for (int i = 0; i < states.length; i++) {
            System.out.println(states[i]);
        }
        System.out.println("****************************");
        //valueOf方法
        SeasonEnum winter = SeasonEnum.valueOf("WINTER");
        System.out.println(winter);
    }
}

实现接口的枚举类

实现接口，在枚举类中实现抽象方法

interface info {
    void show();
}
enum SeasonEnumImplementsInterface1 implements info {
    //提供当前枚举类的对象，之间使用","隔开，最后一个对象使用";"隔开
    SPRING("春天", "春暖花开"),
    SUMMER("夏天", "夏日炎炎"),
    AUTUMN("秋天", "秋高气爽"),
    WINTER("冬天", "冰天雪地");

    private final String seasonName;
    private final String seasonDesc;
    private SeasonEnumImplementsInterface1(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    @Override
    public void show() {
        System.out.println("枚举类实现了接口的抽象方法");
    }
}

让接口的每个枚举对象都实现各自的方法

//枚举的各个对象实现了接口的抽象方法
enum SeasonEnumImplementsInterface2 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 SeasonEnumImplementsInterface2(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
}

public class EnumDemo4 {
    @Test
    public void test1(){
        SeasonEnumImplementsInterface1[] SeasonEnumImplementsInterface1s = SeasonEnumImplementsInterface1.values();
        System.out.println("季节枚举类中的对象:");
        for (SeasonEnumImplementsInterface1 seasonEnumImplementsInterface1:SeasonEnumImplementsInterface1s) {
            System.out.println(seasonEnumImplementsInterface1);
            seasonEnumImplementsInterface1.show();
        }
    }
    @Test
    public void test2(){
        SeasonEnumImplementsInterface2[] SeasonEnumImplementsInterface2s = SeasonEnumImplementsInterface2.values();
        System.out.println("季节枚举类中的对象:");
        for (SeasonEnumImplementsInterface2 seasonEnumImplementsInterface2:SeasonEnumImplementsInterface2s) {
            System.out.println(seasonEnumImplementsInterface2);
            seasonEnumImplementsInterface2.show();
        }
    }
}

注解

注解概述

在Java中，注解(Annotation)引入始于Java5，用来描述Java代码的元信息，通常情况下注解不会直接影响代码的执行，尽管有些注解可以用来做到影响代码执行。
A

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

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

在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。
一定的程度上可以说框架 = 注解 + 反射机制 + 设计模式

常见的注解

1.生成文档相关的注解

2.在编译的时候进行格式的检查

3.跟踪代码的依赖性，实现代替配置文件的功能

package AnnotationDemo;
/**
 * 1.生成文档相关的注解
 * @author ypc
 * @create 2021-06-22;
 */
public class AnnotationDemo1 {
}
class B implements A{
    //2.在编译的时候进行格式的检查
    @Override
    public void test() {
    }
}
interface A{
    void test();
}
/**
 * 3.跟踪代码的依赖性，实现代替配置文件的功能
 * 未使用注解的时候
  
    reg
    service.RegServlet
  
  
    reg
    /reg
  
 使用注解之后：
 @WebServlet("/reg")
 */

总结

本篇文章的上半部分就到这里了，希望对你有所帮助，也希望您能够多多关注脚本之家的更多内容！