枚举和注解

最新推荐文章于 2024-06-14 15:02:13 发布

大刀爱敲代码

最新推荐文章于 2024-06-14 15:02:13 发布

阅读量42

点赞数

分类专栏： java基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_64044840/article/details/128230191

版权

java基础专栏收录该内容

27 篇文章 0 订阅

订阅专栏

文章目录

枚举
注解（idea）
- Annotation
- 元注解（了解即可）

枚举

枚举的引出

public class Enumeration01 {
    public static void main(String[] args) {
        Season season1 = new Season("春天", "温暖");
        Season season2 = new Season("夏天", "炎热");
        Season season3 = new Season("秋天", "凉爽");
        Season season4 = 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;
    }
}

枚举：enumeration，简写：enum
枚举是一组常量的集合
- 可以这样理解：枚举属于一种特殊的类，里面只包含一组有限的特定的对象
枚举的两种实现方式：

自定义类实现枚举

           - 注意事项：
           - 不需要提供setXxx方法，因为枚举对象值通常为只读
           - 对枚举对象/属性使用final+ static 共同修饰，实现底层优化
           - 枚举对象名通常使用全部大写，是常量的命名规范（final修饰的内容推荐都要大写）

对枚举引出的改进：

public class Enumeration02 {
    public static void main(String[] args) {
        System.out.println(Season1.SPRING);
        System.out.println(Season1.SUMMER);
        System.out.println(Season1.AUTUMN);
        System.out.println(Season1.WINTER);

    }
}

//
演示自定义枚举
class Season1{
    private String name;
    private String desc;

//    定义了四个对象，固定，且只读不修改
    public final static Season1 SPRING = new Season1("春天", "温暖");
    public final static Season1 SUMMER = new Season1("夏天", "炎热");
    public final static Season1 AUTUMN = new Season1("秋天", "凉爽");
    public final static Season1 WINTER = new Season1("冬天", "寒冷");
//    1.把构造器私有化，目的是防止对象被直接new
//    2.去掉setXX方法，防止属性被修改
//    3.在Season1 内部，直接创建固定的对象
//    4.优化：可以加入final 修饰符
    private Season1(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 "Season1{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

对自定义类实现枚举总结
- 1）构造器私有化
- 2）本类内部创建一组对象
- 3）对外暴露对象（通过为对象添加public final static修饰符）
- 4）可以提供get方法，但不要提供set方法

使用enum关键字实现枚举

使用关键字enum来替代class
public final static Season2 SPRING = new Season2(“春天”, “温暖”)等价于SPRING(“春天”, “温暖”) -----》
常量名(实参列表)
如果有多个常量（对象）,使用，间隔就好
如果使用enum来实现枚举，要将定义常量对象放在前面

public class Enumeration03 {
    public static void main(String[] args) {
        System.out.println(Season2.SPRING);
        System.out.println(Season2.SUMMER);
    }
}

//演示使用enum关键字来实现枚举
enum Season2{

    //    定义了四个对象，固定
//    public final static Season2 SPRING = new Season2("春天", "温暖");
//    public final static Season2 SUMMER = new Season2("夏天", "炎热");
//    public final static Season2 AUTUMN = new Season2("秋天", "凉爽");
//    public final static Season2 WINTER = new Season2("冬天", "寒冷");


//    如果使用enum来实现枚举
//    1.使用关键字enum来替代class
//    2.public final static Season2 SPRING = new Season2("春天", "温暖");=等价于
//    SPRING("春天", "温暖")  =》常量名(实参列表)
//    3.如果有多个常量（对象）,使用，间隔就好
//    4.如果使用enum来实现枚举，要将定义常量对象放在前面
    SPRING("春天", "温暖"),SUMMER("夏天", "炎热");


    private String name;
    private String desc;

    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 "Season2{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

对上面类Season2的反编译

D:\idea java lianxi\hello3\out\production\hello3\com\dadao\enum_>javap  Season2.class
Compiled from "Enumeration03.java"
final class com.dadao.enum_.Season2 extends java.lang.Enum<com.dadao.enum_.Season2> {
  public static final com.dadao.enum_.Season2 SPRING;
  public static final com.dadao.enum_.Season2 SUMMER;
  public static com.dadao.enum_.Season2[] values();
  public static com.dadao.enum_.Season2 valueOf(java.lang.String);
  public java.lang.String getName();
  public java.lang.String getDesc();
  public java.lang.String toString();
  static {};
}

hello.java-----------(javac（编译）)----------->hello.class
hello.java<----------(javap（反编译）)-----------hello.class

使用enum关键字实现枚举的注意事项
1）当我们使用enum关键字来创建一个枚举类时，默认会继承Enum类，而且是一个final类（上面的javap反编译）不能再继承其他类了，因为java是单继承机制
2）传统的public final static Season2 SPRING = new Season2(“春天”, “温暖”);可以简化成SPRING(“春天”, “温暖”)，这里必须知道它是调用哪个构造器。
3）如果使用无参构造器创建枚举对象，则小括号都可以省略（即SPRING();------》SPRING）
4）当有多个枚举对象时，使用逗号间隔，最后一个用分号结尾
5）枚举对象必须放在枚举类的首行。

Enum常用方法

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

public class    EnumerationMethod01 {
    public static void main(String[] args) {
        Season2 summer = Season2.SUMMER;
//         输出枚举对象的名字
        System.out.println(summer.name());
//        输出该枚举对象的次序/编号，次序是从0开始的
//        summer 枚举对象是第2个，所以输出1；
        System.out.println(summer.ordinal());
//         从反编译javap  可以看到 values()方法，返回数组
//        values(); 含有定义的所有枚举对象
        Season2[] values=Season2.values();
        System.out.println("====遍历输出====");
        for (Season2 i: values) {//增强for循环
            System.out.println(i);
        }

//       valueOf方法：将字符串转换成枚举对象，要求字符串必须为已有的常量，否则会报错

//        执行流程：
//           1.根据输入的“SUMMER 到Season2 的枚举对象去查找
//           2.如果找到了，就返回 ，如果没有找到，就报错
        Season2 summer1 = Season2.valueOf("SUMMER");
        System.out.println("summer1="+summer1);
        System.out.println(summer==summer1);

//      compareTo:  比较两个枚举对象,比较的是编号
//        下面是Season2.SUMMER的编号-Season2.SPRING的编号
        System.out.println(Season2.SUMMER.compareTo(Season2.SPRING));

    }
}

注解（idea）

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

Annotation

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

1）@Override：限定某个方法，是在重写父类方法的时候使用的，该注解只能用于该方法（注意：重写方法时，如果写了@Override注解，编译器就会去检查该方法是否真的重写了父类的方法，如果的确重写了，则编译通过，如果没有构成重写，则编译错误；没有写的话，其实也还是重写了父类的方法）

解读：如果发现@interface，表示是一个注解类


@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {

}

Override使用说明：
  （1）@Override表示指定重写父类的方法（从编译层面验证），如果父类没有子类重写的方法，则会报错
  （2）如果不写@Override注解，而父类仍有子类要重写的那个方法（子类写该方法时没有写@Override注解），仍然构成重写
  （3）@Override只能修饰方法，不能修饰其他类，包，属性等等
  （4）查看@Override注解源码为@Target(ElementType.METHOD)，说明只能修饰方法
  （5）@Target是修饰注解的注释，称为元注解

2）@Deprecated：用于表示某个程序元素（类，方法等等）已过时（可以作版本升级的过渡使用）

public class Deprecated_ {
    public static void main(String[] args) {
        A a = new A();
    }
}
//1. @Deprecated 修饰某个元素，表示该元素已经过时
//2. 即不再推荐使用，但仍然可以使用
@Deprecated
class A{
    public int n1=10;
    public void hi(){

    }
}

@Deprecated的源码：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}

使用说明：
1）用于表示某个程序元素（类，方法等）已过时
2）可以修饰方法，类，字段，包，参数等等
3）@Deprecated可以作新旧版本的兼容和过渡

3）@SuppressWarnings：用来抑制编译器的警告
语法：

关于@SuppressWarnings({" "})的作用范围：和你放的位置有关
@SuppressWarnings({" "});
在{" "}写入你希望抑制（不显示）的警告信息

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，抑制与未用的程式码及停用的程式码相关的警告

SuppressWarnings源码：

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
    /**
     * The set of warnings that are to be suppressed by the compiler in the
     * annotated element.  Duplicate names are permitted.  The second and
     * successive occurrences of a name are ignored.  The presence of
     * unrecognized warning names is <i>not</i> an error: Compilers must
     * ignore any warning names they do not recognize.  They are, however,
     * free to emit a warning if an annotation contains an unrecognized
     * warning name.
     *
     * <p> The string {@code "unchecked"} is used to suppress
     * unchecked warnings. Compiler vendors should document the
     * additional warning names they support in conjunction with this
     * annotation type. They are encouraged to cooperate to ensure
     * that the same names work across multiple compilers.
     * @return the set of warnings to be suppressed
     */
    String[] value();
}

元注解（了解即可）

元注解的种类
1）Retention：指定注解的作用范围，三种：SOURCE、CLASS、RUNTIME
2）Target：指定注解可以在哪些地方使用
3）Documented：指定该注解是否会在javadoc体现
4）Inherited：子类会继承父类注解
Retention注解：
1）说明：只能修饰一个Annotation定义，用于指定该Annotation可以保留多长时间，@Retention包含一个RetentionPolicy类型的成员变量，使用@Retention时必须为该value成员变量指定值：
2）@Retention的三种值：

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

Documented注解
1）说明：用于指定被改元Annotation修饰的Annotation类将被javadoc工具提取成文档，即当生成文档时，可以看到注解（注意：定义为Documented的注解必须设置为Retention值为RUNTIME
Inherited注解
1）被它修饰的Annotation将具有继承性。如果某个类使用了被@Inherited修饰的Annotation，则其子类将自动具有该注解。
总结：元注解本身作用不大，了解即可。