Java 基础 枚举

最新推荐文章于 2023-05-05 16:28:08 发布
最新推荐文章于 2023-05-05 16:28:08 发布
阅读量770 收藏 2
点赞数
文章标签： java string class import null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a62258110/article/details/6767806
版权

Java 枚举

--------

枚举的作用

所谓枚举就是规定好了指定的取值范围，所有的内容只能从指定的范围中取得。

使用简单类完成颜色的取值问题：

class Color{
       publicstatic final Color RED = new Color("红色") ;  // 定义第一个对象
       publicstatic final Color GREEN = new Color("绿色") ;     // 定义第一个对象
       publicstatic final Color BLUE = new Color("蓝色") ;       // 定义第一个对象
       privateString name ;
       privateColor(String name){
              this.name= name ;
       }
       publicvoid setName(String name){
              this.name= name ;
       }
       publicString getName(){
              returnthis.name ;
       }
       publicstatic Color getInstance(int i){
              switch(i){
                     case1:{
                            returnRED ;
                     }
                     case2:{
                            returnGREEN ;
                     }
                     case3:{
                            returnBLUE ;
                     }default:{
                            returnnull ;
                     }
              }
       }
};
public class ColorDemo01{
       publicstatic void main(String args[]){
              Colorc1 = Color.RED ; // 取得红色
              System.out.println(c1.getName());      // 输出名字
              Colorc2 = Color.getInstance(3) ;  // 根据编号取得名字
              System.out.println(c2.getName());
       }
};

此时，程序限定了所能取的对象范围，所以达到了枚举的功能，以上是一种枚举的方式。

 

定义一个枚举类型

在JDK1.5之后，引入了一个新的关键字类型——enum，可以直接定义枚举类型，格式如下：

[public] enum 枚举类型名称{

       枚举对象1、枚举对象2……枚举对象n;

}

使用枚举定义三个颜色：

public enum Color{
       RED,GREEN,BLUE;   // 定义三个枚举的类型
};


以后在取得值的时候，只能从这三个内容中取：

public class GetEnumContent{
       publicstatic void main(String args[]){
              Colorc = Color.BLUE ;        // 取出蓝色
              System.out.println(c);
       }
};


因为枚举已经指定好了范围，所以可以使用foreach进行全部的输出，使用“枚举.values()”的形式取得全部的枚举内容：

public class PrintEnum{
       publicstatic void main(String args[]){
              for(Colorc:Color.values()){  // 输出枚举中的全部内容
                     System.out.println(c);  
              }
       }
};


还可以直接将内容在SWITCH语名上使用：

public class SwitchPrintEnum{
       publicstatic void main(String args[]){
              for(Colorc:Color.values()){  // 输出枚举中的全部内容
                     print(c);
              }
       }
       publicstatic void print(Color color){
              switch(color){
                     caseRED:{
                            System.out.println("红颜色") ;
                            break;
                     }
                     caseGREEN:{
                            System.out.println("绿颜色") ;
                            break;
                     }
                     caseBLUE:{
                            System.out.println("蓝颜色") ;
                            break;
                     }
                     default:{
                            System.out.println("未知颜色") ;
                            break;
                     }
              }
       }
};

Enum类与enum关键字

使用enum关键字可以定义一个枚举，实际上此关键字表示的是java.lang.Enum类型，即：使用enum声明的枚举类型，就相当于定义一个类，而此类则默认继承java.lang.Enum类。

此类定义的时候使用了泛型机制，而且实现了Comparable接口及Serializable接口，证明此类型是可以比较，并可以被序列化的。

实例：使用构造方法传递参数

enum Color{
       RED("红色"),GREEN("绿色"),BLUE("兰色") ;
       privateColor(String name){
              this.setName(name);
       }
       privateString name ;                   // 定义name属性
       publicvoid setName(String name){
              this.name= name ;
       }
       publicString getName(){
              returnthis.name ;
       }
}
public class ConstructorEnum{
       publicstatic void main(String args[]){
              for(Colorc:Color.values()){
                     System.out.println(c.ordinal()+ " --> " + c.name()
                            +"(" + c.getName() +")") ;
              }
       }
};

实例：利用setter()方法设置内容 

enum Color{
       RED,GREEN,BLUE;
       privateString name ;                   // 定义name属性
       publicvoid setName(String name){
              switch(this){   // 判断操作的是那个枚举对象
                     caseRED:{
                            if("红色".equals(name)){
                                   this.name= name ; // 允许设置名字
                            }else{
                                   System.out.println("设置内容错误。") ;
                            }
                            break;
                     }
                     caseGREEN:{
                            if("绿色".equals(name)){
                                   this.name= name ; // 允许设置名字
                            }else{
                                   System.out.println("设置内容错误。") ;
                            }
                            break;
                     }
                     caseBLUE:{
                            if("蓝色".equals(name)){
                                   this.name= name ; // 允许设置名字
                            }else{
                                   System.out.println("设置内容错误。") ;
                            }
                            break;
                     }
              }
              this.name= name ;
       }
       publicString getName(){
              returnthis.name ;
       }
}
public class SetEnum{
       publicstatic void main(String args[]){
              Colorc = Color.BLUE ; // 得到兰色
              c.setName("兰色") ;      // 名字错误
              c.setName("蓝色") ;      // 名字正确
              System.out.println(c.getName());
       }
};

实例：在枚举中实现排序 

import java.util.Iterator;
import java.util.Set ;
import java.util.TreeSet ;
enum Color{
       RED,GREEN,BLUE;
}
public class ComparableEnum{
       publicstatic void main(String args[]){
              Set<Color>t = new TreeSet<Color>() ;       // 设置类型
              t.add(Color.GREEN);   // 加入绿色
              t.add(Color.RED);        // 加入红色
              t.add(Color.BLUE);             // 加入蓝色
              Iterator<Color>iter = t.iterator() ;
              while(iter.hasNext()){
                     System.out.print(iter.next()+ "、") ;
              }
       }
};

类集对Enum的技持

EnumMap类 实现范例

import java.util.EnumMap ;
import java.util.Map ;
enum Color{
       RED, GREEN , BLUE ;
}
public class EnumMapDemo{
       publicstatic void main(String args[]){
              Map<Color,String>desc = null ;          // 定义Map对象，同时指定类型
              desc= new EnumMap<Color,String>(Color.class) ;    // 实例化EnumMap对象
              desc.put(Color.RED,"红色") ;
              desc.put(Color.GREEN,"绿色") ;
              desc.put(Color.BLUE,"蓝色") ;
              System.out.println("======输出全部的内容======") ;
              for(Colorc:Color.values()){
                     System.out.println(c.name()+ " --> " + desc.get(c)) ;
              }
              System.out.println("======输出全部的键值======") ;
              for(Colorc:desc.keySet()){
                     System.out.print(c.name()+ "、") ;
              }
              System.out.println();
              System.out.println("======输出全部的内容======") ;
              for(Strings:desc.values()){
                     System.out.print(s+ "、") ;
              }
       }
};

EnumSet类

EnumSet是Set接口的子类，所以里面的内容是无法重复的，在使用EnumSet的时候是不能直接使用关键字new为其进行实例化的，所以在此类中提供了很多的静态方法。

实例：将全部的集合设置到EnumSet集合中

import java.util.EnumSet ;
enum Color{
       RED, GREEN , BLUE ;
}
public class EnumSetDemo01{
       publicstatic void main(String args[]){
              EnumSet<Color>es = null ;                // 声明一个EnumSet对象
              System.out.println("========EnumSet.allOf(Color.class) =====") ;
              es= EnumSet.allOf(Color.class) ; // 将枚举的全部类型设置到EnumSet对象之中
              print(es);
       }
       publicstatic void print(EnumSet<Color> temp){ //专门的输出操作
              for(Colorc:temp){        //  循环输出EnumSet中的内容
                     System.out.print(c+ "、") ;
              }
              System.out.println();
       }
};

实例：只设置一个内容到集合 

import java.util.EnumSet ;
enum Color{
       RED, GREEN , BLUE ;
}
public class EnumSetDemo02{
       publicstatic void main(String args[]){
              EnumSet<Color>es = null ;                // 声明一个EnumSet对象
              System.out.println("========EnumSet.of(Color.BLUE) =====") ;
              es= EnumSet.of(Color.BLUE) ;   // 将枚举的全部类型设置到EnumSet对象之中
              print(es);
       }
       publicstatic void print(EnumSet<Color> temp){ //专门的输出操作
              for(Colorc:temp){        //  循环输出EnumSet中的内容
                     System.out.print(c+ "、") ;
              }
              System.out.println();
       }
};

实例：拷贝集合内容 

import java.util.EnumSet ;
enum Color{
       RED, GREEN , BLUE ;
}
public class EnumSetDemo05{
       publicstatic void main(String args[]){
              EnumSet<Color>esOld = null ;                  // 声明一个EnumSet对象
              EnumSet<Color>esNew = null ;
              System.out.println("========EnumSet.copyOf(Color.class) =====") ;
              esOld= EnumSet.noneOf(Color.class) ;       // 将枚举的全部类型设置到EnumSet对象之中
              esOld.add(Color.RED) ; // 增加内容
              esOld.add(Color.GREEN);   // 增加内容
              esNew= EnumSet.copyOf(esOld) ;      // 从已有的集合拷贝过来
              print(esNew);
       }
       publicstatic void print(EnumSet<Color> temp){ //专门的输出操作
              for(Colorc:temp){        //  循环输出EnumSet中的内容
                     System.out.print(c+ "、") ;
              }
              System.out.println();
       }
};

枚举的其他应用

枚举类型可以跟普通的类一样实现一个接口，但是实现接品的时候要求枚举中的每一个对象都必须单独覆写接口中的抽象方法：

enum Color implements Print{
       RED{
              publicString getColor(){
                     return"红色" ;
              }
       },GREEN{
              publicString getColor(){
                     return"绿色" ;
              }
       },BLUE{
              publicString getColor(){
                     return"蓝色" ;
              }
       };
       publicabstract String getColor() ;
}
public class AbstractMethodEnum{
       publicstatic void main(String args[]){
              for(Colorc:Color.values()){
                     System.out.print(c.getColor()+ "、") ;
              }
       }
};

还可以直接在枚举中定义抽象方法，但是要求枚举中的每个对象都分别实现此抽象方法： 

interface Print{
       publicString getColor() ;
}
enum Color implements Print{
       RED{
              publicString getColor(){
                     return"红色" ;
              }
       },GREEN{
              publicString getColor(){
                     return"绿色" ;
              }
       },BLUE{
              publicString getColor(){
                     return"蓝色" ;
              }
       };
}
public class InterfaceEnumDemo{
       publicstatic void main(String args[]){
              for(Colorc:Color.values()){
                     System.out.print(c.getColor()+ "、") ;
              }
       }
};
曹文涛
关注
Java学习笔记-枚举(enum)
2301_76198735的博客
01-28 151
Java学习笔记-枚举(enum)
Java基础-枚举
youchitang的博客
06-28 189
Enum:枚举类 1、使用 enum 关键字定义枚举类 一、枚举类的使用 1、枚举类的理解：类的对象只有有限个，确定的。我们称此类未枚举类。 2、当需要定义一组常量时，强烈建议使用枚举类。 3、如果枚举类中只有一个对象，则可以作为单例模式的实现方式。 jdk 5.0后，可以使用enum关键字定义枚举类。（推荐使用，比较便捷） public class SeasonTest1{ public static void main(String[] args) { Season summer
JAVA 枚举
zxl2016的博客
12-18 352
14. JAVA 枚举(Enum、类集EnumMap&EnumSet 、实现接口、定义抽象方法) ----- 学习笔记 http://blog.csdn.net/forfan06/article/details/38847777 转载 2014年08月26日 15:01:51 标签：enum /枚举 /基础知识 本章目标: 了解
枚举类型的定义
热门推荐
开心小肉妞的天空
11-12 5万+
在程序设计中，有时会用到由若干个有限数据元素组成的集合，如一周内的星期一到星期日七个数据元素组成的集合，由三种颜色红、黄、绿组成的集合，一个工作班组内十个职工组成的集合等等，程序中某个变量取值仅限于集合中的元素。此时，可将这些数据集合定义为枚举类型。因此，枚举类型是某类数据可能取值的集合，如一周内星期可能取值的集合为：　　{ Sun,Mon,Tue,Wed,Thu,Fri,Sat}　　该集合可定义
java中枚举类型使用详解
兴趣是最好的老师，勤能补拙
05-05 2506
在Java中，枚举类型（Enumeration）是一种特殊的数据类型，它允许程序员定义一个有限的、可枚举的数据集。枚举类型的定义通常在类的内部，在类的外部使用。
JAVA —— 枚举（Enum）
黄坤的博客
06-30 193
1.枚举是一个特殊的类，一般用来表示一组特殊的常量 //枚举是一个特殊的类，一般用来表示一组特殊的常量 enum Color { //定义颜色常量：红色、绿色、蓝色 RED, GREEN, BLUE; } 2.使用枚举类 //使用枚举类 class useEnum { public static void main(String[] args) { Color color = Color.RED; System.out.println(color)
Java基础之Java枚举
bieber007的博客
11-05 4018
絮叨 昨天刚好有遇到一个枚举的小问题，然后发现自己并不是那么熟悉它，然后在开发中，枚举用的特别多，所以有了今天的文章。 什么是枚举 Java中的枚举是一种类型，顾名思义：就是一个一个列举出来。所以它一般都是表示一个有限的集合类型，它是一种类型，在维基百科中给出的定义是： 在数学和计算机科学理论中，一个集的枚举是列出某些有穷序列集的所有成员的程序，或者是一种特定类型对象的计数。这两种类型经常（但不总是）重叠.。枚举是一个被命名的整型常数的集合，枚举在日常生活中很常见，例如表示星期的SUNDAY、MO
Java 基础枚举.pdf
最新发布
07-26
Java 枚举是一种特殊的类，用于定义一组固定的常量，这些常量代表特定的值或状态。枚举在编程中非常有用，特别是在处理有限数量的选项时，如颜色、星期几、季节等。通过使用枚举，我们可以确保代码的健壮性，避免因...
Java基础——枚举 （详解）
x1113162924的博客
08-16 5万+
Java中的枚举是一种类型，顾名思义：就是一个一个列举出来。所以它一般都是表示一个有限的集合类型，它是一种类型，在维基百科中给出的定义是：
【后端】java基础（5.6）java高级基础之枚举
03-29
java中除了类和接口，还有一个类型叫做枚举（enum），它出现得比较晚，在JDk1.5之后才出，因此对我们来说并不常用，但是它的作用还是不小。 创建的时候前面和创建类、接口一样，在new之后，我们选择enum即可。表面上...
Java基础——枚举与注解
lt_xiaodou的博客
07-30 965
枚举类类的对象只有有限个，确定的。当需要定义一组常量时，强烈建议使用枚举类。如果枚举类中只有一个对象，则可以作为单例模式的实现。使用enum定义的枚举类默认继承了java.lang.Enum类，因此不能再继承其他类。从JDK5.0开始，Java增加了对元数据（MetaData）的支持，也就是Annotation（注解）。Annotation其实就是代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。代码示例5}69}10。...
java 序列化 枚举_java基础-枚举序列化
weixin_39622568的博客
02-12 1045
枚举编译创建一个类：FruitEnum继承自java.lang.Enum定义的枚举被声明为public static final类型常量FruitEnum$VALUES数组，保存常量APPLE和ORANGE创建两个对象，常量引用这个两个对象两个静态方法：values()拷贝一份数组valueOf(String)，调用java.lang.Enum中的valueOf注意：这里的valueOf(Stri...
C++学习笔记 --- 枚举常量
【昆山人在上海】
10-18 824
一个枚举常量中包括一组相关的标识符，其中，每个标识符都对应一个整型值。 enum Colors {red, green, blue}; 大括号中的第一个标识符red对应数值0，第二个对应1，依次类推。 每个标识符都必须唯一，不能使用保留关键字以及这个域中的其他任何标识符。
第三十七节 java学习——color类
语帆的专栏
01-03 2万+
color类是用来封装颜色的，使用color对象较为简单的方法是直接使用color类提供的预定义的颜色。像红色color.red，橙色color.orange等，也可以使用RGB颜色模式进行定义。所谓RGB颜色模式是使用三基色：红，绿，蓝，通过三种颜色的调整得到其他各种颜色，这三种基色的范围为0—255. color还有一个构造函数，它构造的color对象用于是否透明显示颜色。 public
java枚举类型
u012810309的专栏
07-31 603
1.定义一个Color的枚举类型 enum Color{ RED,GREEN,BLUE; } 2.取出一个枚举类型 public static void main(String[] args) { Color c=Color.RED; System.out.println(c); } 打印结果为RED 3.使用foreach输出枚举内容 for(Color c1:Co
Java 枚举(enum)
奇迹
11-16 222
Java 枚举是一个特殊的类，一般表示一组常量，比如一年的 4 个季节，一个年的 12 个月份，一个星期的 7 天，方向有东南西北等。 Java 枚举类使用 enum 关键字来定义，各个常量使用逗号 , 来分割。 //例如定义一个颜色的枚举类。 enum Color { RED, GREEN, BLUE; } 以上枚举类 Color 颜色常量有 RED, GREEN, BLUE，分别表示红色，绿色，蓝色。 //实例 enum Color { RED, GREEN, BLUE; }
Java enum的用法详解
sinat_17584759的专栏
07-03 122
Java中枚举实现的分析：     示例：  public static enum SEVERITY{ INFO,WARN,ERROR }    enum很像特殊的class，实际上enum声明定义的类型就是一个类。 而这些类都是类库中Enum类的子类（java.lang.Enum&lt;E&gt;）。它们继承了这个Enum中的许多有用的方法。我们对代码编译之后发...
Java（enum）枚举用法详解
茅坤宝骏氹的博客
06-04 5052
转载自 Java（enum）枚举用法详解本篇文章主要介绍了Java 枚举用法详解，枚举的好处：可以将常量组织起来，统一进行管理。有兴趣的可以一起来了解一下。概念enum的全称为 enumeration， 是 JDK 1.5 中引入的新特性。在Java中，被 enum 关键字修饰的类型就是枚举类型。形式如下：enum Color { RED, GREEN, BLUE }如果枚举不添加任何方法，枚举值...
java枚举
weixin_45032957的博客
09-04 142
枚举在java里也算个老生长谈的内容了，每当遇到一组需要类举的数据时我们都会自然而然地使用枚举类型： public enum Color { RED, GREEN, BLUE, YELLOW; public static void main(String[] args) { Color red = Color.RED; Color redAnother = Color.RED; Color blue = Color.BLUE; System.out.println(red.
Java基础：枚举与Vector示例讲解
本资源是一份针对Java基础的PPT教程，主要讲解了Java语言的枚举类型以及相关概念。首先，作者通过一个简单的例子引入枚举，展示了如何在Java中使用` Enumeration`接口来遍历集合，如`Vector`。代码中创建了一个包含...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值