一、枚举类

1.如何自定义枚举类。枚举类：类的对象是有限个的，确定的。

1.1 私有化类的构造器，保证不能在类的外部创建其对象
1.2 在类的内部创建枚举类的实例。声明为：public static final
1.3 若类有属性，那么属性声明为：private final 。此属性在构造器中赋值。

2.使用enum关键字定义枚举类

2.1其中常用的方法：values() valueOf(String name);
2.2枚举类如何实现接口：①让类实现此接口，类的对象共享同一套接口的抽象方法的实现。②让类的每一个对象都去实现接口的抽象方法，进而通过类的对象调用被重写的抽象方法时，执行的效果不同

public class TestSeason1 {public static void main(String[] args) {Season1 spring = Season1.SPRING;System.out.println(spring);spring.show();System.out.println(spring.getSeasonName());System.out.println();//1.values()Season1[] seasons = Season1.values();for(int i = 0;i < seasons.length;i++){System.out.println(seasons[i]);}//2.valueOf(String name):要求传入的形参name是枚举类对象的名字。//否则，报java.lang.IllegalArgumentException异常String str = "WINTER";Season1 sea = Season1.valueOf(str);System.out.println(sea);System.out.println();Thread.State[] states = Thread.State.values();for(int i = 0;i < states.length;i++){System.out.println(states[i]);}sea.show();}
}
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;}@Overridepublic String toString() {return "Season [seasonName=" + seasonName + ", seasonDesc="+ seasonDesc + "]";}
//  public void show(){//      System.out.println("这是一个季节");
//  }
}

【来源其他博文：】
枚举（enum）类型是Java 5新增的特性，它是一种新的类型，允许用常量来表示特定的数据片断，而且全部都以类型安全的形式来表示。

1、常量的使用
在JDK1.5之前，我们定义常量都是：public static fianl….。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。

public enum Color {    RED, GREEN, BLANK, YELLOW
}

使用：

public class B {public static void main(String[] args) {System.out.println( isRed( Color.BLANK ) ) ;  //结果： falseSystem.out.println( isRed( Color.RED ) ) ;    //结果： true}static boolean isRed( Color color ){if ( Color.RED.equals( color )) {return true ;}return false ;}
}

或者 switch 的使用:

public class B {public static void main(String[] args) {showColor( Color.RED );}static void showColor(Color color){switch ( color ) {case BLANK:System.out.println( color );break;case RED :System.out.println( color );break;default:System.out.println( color );break;}        }
}

2、自定义函数

public enum Color {   RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);   private String name ;private int index ;  private Color( String name , int index ){this.name = name ;this.index = index ;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getIndex() {return index;}public void setIndex(int index) {this.index = index;}
}

使用：

public class B {public static void main(String[] args) {//输出某一枚举的值System.out.println( Color.RED.getName() );System.out.println( Color.RED.getIndex() );//遍历所有的枚举for( Color color : Color.values()){System.out.println( color + "  name: " + color.getName() + "  index: " + color.getIndex() );}}
}

结果：
红色
1
RED name: 红色 index: 1
GREEN name: 绿色 index: 2
BLANK name: 白色 index: 3
YELLO name: 黄色 index: 4

===================================

我们现在来深入了解下枚举。
先参考几篇文章：

①深入理解Java枚举类型(enum)
②Java 中的枚举 (enum)

在①中这样讲到。如下代码：

public class EnumDemo {public static void main(String[] args){//直接引用Day day =Day.MONDAY;}
}
//定义枚举类型
enum Day {MONDAY, TUESDAY, WEDNESDAY,THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

反编译可以看到，是这样的：

//反编译Day.class
final class Day extends Enum
{//编译器为我们添加的静态的values()方法public static Day[] values(){return (Day[])$VALUES.clone();}//编译器为我们添加的静态的valueOf()方法，注意间接调用了Enum也类的valueOf方法public static Day valueOf(String s){return (Day)Enum.valueOf(com/zejian/enumdemo/Day, s);}//私有构造函数private Day(String s, int i){super(s, i);}//前面定义的7种枚举实例public static final Day MONDAY;public static final Day TUESDAY;public static final Day WEDNESDAY;public static final Day THURSDAY;public static final Day FRIDAY;public static final Day SATURDAY;public static final Day SUNDAY;private static final Day $VALUES[];static {    //实例化枚举实例MONDAY = new Day("MONDAY", 0);TUESDAY = new Day("TUESDAY", 1);WEDNESDAY = new Day("WEDNESDAY", 2);THURSDAY = new Day("THURSDAY", 3);FRIDAY = new Day("FRIDAY", 4);SATURDAY = new Day("SATURDAY", 5);SUNDAY = new Day("SUNDAY", 6);$VALUES = (new Day[] {MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY});}
}

从反编译的代码可以看出编译器确实帮助我们生成了一个Day类(注意该类是final类型的，将无法被继承)而且该类继承自java.lang.Enum类，该类是一个抽象类(稍后我们会分析该类中的主要方法)，除此之外，编译器还帮助我们生成了7个Day类型的实例对象分别对应枚举中定义的7个日期，这也充分说明了我们前面使用关键字enum定义的Day类型中的每种日期枚举常量也是实实在在的Day实例对象，只不过代表的内容不一样而已。

现在能明白：使用关键字enum定义的枚举类型，在编译期后，将转换成为一个实实在在的类，而在该类中，会存在每个在枚举类型中定义好变量的对应实例对象，如上述的MONDAY枚举类型对应public static final Day MONDAY;，同时编译器会为该类创建两个方法，分别是values()和valueOf()。

所以最前面的关于季节的代码：

public class Season1Demo{public static void main(String[] args) {Season spring = Season.WINTER;spring.show();Season.SPRING.show();Season.AUTUMN.show();}
}interface Info {void show();
}// 枚举类
enum Season implements Info {SPRING("spring", "春暖花开") {
//      public void show() {//          System.out.println("春天在哪里？");
//      }},SUMMER("summer", "夏日炎炎") {//该实例重写了 show 方法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 Season(String seasonName, String seasonDesc) {this.seasonName = seasonName;this.seasonDesc = seasonDesc;}public String getSeasonName() {return seasonName;}public String getSeasonDesc() {return seasonDesc;}@Overridepublic String toString() {return "Season [seasonName=" + seasonName + ", seasonDesc=" + seasonDesc + "]";}public void show(){System.out.println("这是一个季节");}
}

结果：

冬天里的一把火
这是一个季节
秋天是用来分手的季节

我个人小结：枚举Season最后转换成了Season类（继承了Enum类），然后在该类中定义好了类型为Season的成员变量SPRING、SUMMER、AUTUMN、WINTER并实例化。
在引用另外看到的篇文章写道的：

enum这个关键字，可以理解为跟class差不多，这也个单独的类。可以看到，上面的例子里面有属性，有构造方法，有getter，也可以有setter，但是一般都是构造传参数。还有其他自定义方法。那么在这些东西前面的，以逗号隔开的，最后以分号结尾的，这部分叫做，这个枚举的实例。也可以理解为，class new 出来的实例对象。这下就好理解了。只是，class，new对象，可以自己随便new，想几个就几个，而这个enum关键字，他就不行，他的实例对象，只能在这个enum里面体现。也就是说，他对应的实例是有限的。这也就是枚举的好处了，限制了某些东西的范围，举个栗子：一年四季，只能有春夏秋冬，你要是字符串表示的话，那就海了去了，但是，要用枚举类型的话，你在enum的大括号里面把所有的选项，全列出来，那么这个季节的属性，对应的值，只能在里面挑。不能有其他的。

所以：

SPRING("spring", "春暖花开") {public void show() {System.out.println("春天在哪里？");}},

该代码相当就是new出了Season对象并实例化，该如果这里没写show()方法则调用的Season实现的show()方法，但这里重新定义了，相当于覆盖了show()方法。

再看一个例子（包含抽象方法的枚举类）：

定义一个 Operation 枚举类，有4个枚举值PLUS、MINUS、TIMES、DIVIDE，分别代表加、减、乘、除，该枚举类有一个 calculate() 方法，用于完成计算。

public enum Operation {// 用于执行加法运算PLUS { // 花括号部分其实是一个匿名内部子类@Overridepublic double calculate(double x, double y) {return x + y;}},// 用于执行减法运算MINUS { // 花括号部分其实是一个匿名内部子类@Overridepublic double calculate(double x, double y) {// TODO Auto-generated method stubreturn x - y;}},// 用于执行乘法运算TIMES { // 花括号部分其实是一个匿名内部子类@Overridepublic double calculate(double x, double y) {return x * y;}},// 用于执行除法运算DIVIDE { // 花括号部分其实是一个匿名内部子类@Overridepublic double calculate(double x, double y) {return x / y;}};//为该枚举类定义一个抽象方法，枚举类中所有的枚举值都必须实现这个方法public abstract double calculate(double x, double y);
}

从上可以看出，掌握、理解枚举，重要要知道枚举、和枚举变量的实质是什么。
枚举最后转换就是一个特殊的类，其中的枚举变量就是实例化对象。可以就这么看：

public class HelloDemo2 {public static void main(String[] args) {Season1 SPRING = new Season1("spring", "春暖花开") {public void show() {System.out.println("春天在哪里？");};};SPRING.show();}
}interface Info1{void show();
}class Season1 implements Info1{private  String seasonName;private  String seasonDesc;public Season1(String seasonName, String seasonDesc) {this.seasonName = seasonName;this.seasonDesc = seasonDesc;}@Overridepublic void show() {System.out.println("这是一个季节");}
}

二、注解Annotation

1.JDK提供的常用的三个注解

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

2.如何自定义注解
以SuppressWarnings为例进行创建即可

3.元注解：可以对已有的注解进行解释说明。

Retention: SOURCE CLASS RUNTIME
Target:
Documented:javadoc
Inherited

第九章：Java_枚举类和注解相关推荐

Java_比较器枚举类和注解集合泛型
文章目录 Java_比较器 Java_自然排序:java.lang.Comparable Java_Comparable的实现 Java_定制排序java.util.Comparator Java_S ...
学妹问我Java枚举类与注解，我直接用这个搞定她！
很多人问我学妹长什么样,不多说上图吧! 学妹问我Java枚举类与注解,我直接一篇文章搞定! 一.枚举类 ① 自定义枚举类 ② enum关键字定义枚举类 ③ enum 枚举类的方法 ④ enum 枚举 ...
Java查漏补缺（08）关键字:static、单例设计模式、理解main方法、类的成员之四:代码块、final关键字、抽象类、接口、内部类、枚举类、注解、包装类
Java查漏补缺(08)关键字:static.单例设计模式.理解main方法.类的成员之四:代码块.final关键字.抽象类.接口.内部类.枚举类.注解.包装类本章专题与脉络 1. 关键字:stat ...
新星计划Day2【JavaSE】枚举类与注解
新星计划Day2[JavaSE] 枚举类与注解
java6：枚举类和注解
一.枚举类和注解的整体框架 1.枚举类框架 2.注解框架 3.枚举类整体知识 /* 1.枚举类的第一种定义定义私有化属性和私有化构造器提供静态常量对象 2.enum定义枚举类定义私有化属性和私有 ...
Java枚举类和注解
文章目录枚举类和注解枚举类的使用枚举类的说明: 如何自定义枚举类?步骤: jdk 5.0 新增使用enum定义枚举类.步骤: 使用enum定义枚举类之后,枚举类常用方法:(继承于java.lan ...
Java枚举类与注解——一篇文章读懂枚举类与注解
文章目录一.枚举类 ① 自定义枚举类 ② enum关键字定义枚举类 ③ enum 枚举类的方法 ④ enum 枚举类实现接口二.注解 ① 生成文档相关注解 ②注解在编译时进行格式检查 ③注解跟踪代 ...
第十三章枚举类和注解
目录 13.1.枚举类 13.1.1.概述 13.1.2.自定义枚举类 13.1.2.1.第一版 13.1.2.2.第二版 13.1.2.3.第三版 13.1.2.4.测试方法 13.1.3.系统的枚 ...
java 枚举注解_Java枚举类和注解梳理
1. 枚举类 1. 枚举类的使用枚举类的理解:类的对象只有有限个,确定的.我们称此类为枚举类. 当需要定义一组常量时,强烈建议使用枚举类. 如果枚举类中只有一个对象,则可以作为单例模式的实现方式. ...

第九章：Java_枚举类和注解

一、枚举类

二、注解Annotation

第九章：Java_枚举类和注解相关推荐

最新文章

热门文章