Java枚举继承和接口实现

Java枚举（enum）详解Java 枚举知识点概念enum的全称为 enumeration，是 JDK 1.5 中引⼊的新特性。

在Java中，被enum关键字修饰的类型就是枚举类型。

形式如下：enum Color { RED, GREEN, BLUE }如果枚举不添加任何⽅法，枚举值默认为从0开始的有序数值。

以 Color 枚举类型举例，它的枚举常量依次为RED：0，GREEN：1，BLUE：2。

枚举的好处：可以将常量组织起来，统⼀进⾏管理。

枚举的典型应⽤场景：错误码、状态机等。

枚举类型的本质尽管enum看起来像是⼀种新的数据类型，事实上，enum是⼀种受限制的类，并且具有⾃⼰的⽅法。

创建enum时，编译器会为你⽣成⼀个相关的类，这个类继承⾃ng.Enum。

ng.Enum类声明public abstract class Enum<E extends Enum<E>>implements Comparable<E>, Serializable { ... }枚举的⽅法在enum中，提供了⼀些基本⽅法：values()：返回 enum 实例的数组，⽽且该数组中的元素严格保持在 enum 中声明时的顺序。

name()：返回实例名。

ordinal()：返回实例声明时的次序，从0开始。

getDeclaringClass()：返回实例所属的 enum 类型。

equals()：判断是否为同⼀个对象。

可以使⽤==来⽐较enum实例。

此外，ng.Enum实现了Comparable和Serializable接⼝，所以也提供compareTo()⽅法。

例：展⽰enum的基本⽅法public class EnumMethodDemo {enum Color {RED, GREEN, BLUE;}enum Size {BIG, MIDDLE, SMALL;}public static void main(String args[]) {System.out.println("=========== Print all Color ===========");for (Color c : Color.values()) {System.out.println(c + " ordinal: " + c.ordinal());}System.out.println("=========== Print all Size ===========");for (Size s : Size.values()) {System.out.println(s + " ordinal: " + s.ordinal());}Color green = Color.GREEN;System.out.println(<span class="hljs-string">"green name(): "</span> + ());System.out.println(<span class="hljs-string">"green getDeclaringClass(): "</span> + green.getDeclaringClass());System.out.println(<span class="hljs-string">"green hashCode(): "</span> + green.hashCode());System.out.println(<span class="hljs-string">"green compareTo Color.GREEN: "</span> + pareTo(Color.GREEN));System.out.println(<span class="hljs-string">"green equals Color.GREEN: "</span> + green.equals(Color.GREEN));System.out.println(<span class="hljs-string">"green equals Size.MIDDLE: "</span> + green.equals(Size.MIDDLE));System.out.println(<span class="hljs-string">"green equals 1: "</span> + green.equals(<span class="hljs-number">1</span>));System.out.format(<span class="hljs-string">"green == Color.BLUE: %b\n"</span>, green == Color.BLUE);}输出=========== Print all Color ===========RED ordinal: 0GREEN ordinal: 1BLUE ordinal: 2=========== Print all Size ===========BIG ordinal: 0MIDDLE ordinal: 1SMALL ordinal: 2green name(): GREENgreen getDeclaringClass(): class org.zp.javase.enumeration.EnumDemo$Colorgreen hashCode(): 460141958green compareTo Color.GREEN: 0green equals Color.GREEN: truegreen equals Size.MIDDLE: falsegreen equals 1: falsegreen == Color.BLUE: false枚举的特性枚举的特性，归结起来就是⼀句话：除了不能继承，基本上可以将enum看做⼀个常规的类。

java,enum(枚举)使用详解+,总结 enum枚举javaenum的全称为enumeration，是jdk1.5中引入的新特性，存放在ng包中。

下面是我在使用enum过程中的一些经验和总结。

完整的接口定义常量语法（定义）建立枚举类型必须采用enum关键字，暗含了所建立的类型都就是ng.enum类的子类（ng.enum就是一个抽象类）。

枚举类型合乎通用型模式classenum这段代码实际上调用了7次enum(stringname,intordinal)：结点、switch等常用操作方式对enum进行遍历和switch的操作示例代码：输入结果：enum对象的常用方法介绍intcompareto(eo)比较此枚举与指定对象的顺序。

classgetdeclaringclass()返回与此枚举常量的枚举类型相对应的class对象。

stringname()返回此枚举常量的名称，在其枚举声明中对其进行声明。

intordinal()返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。

stringtostring()返回枚举常量的名称，它包含在声明中。

static输出结果：给enum自定义属性和方法给enum对象加一下value的属性和getvalue()的方法：输入结果：enumset，enummap的应用原理分析enum的语法结构尽管和class的语法不一样，但是经过编译器编译之后产生的是一个class文件。

该class文件经过反编译可以看到实际上是生成了一个类，该类继承了ng.enum。

enumtest经过反编译(javapcohmw.test.enumtest命令)之后得到的内容如下：所以，实际上enum就是一个class，只不过java编译器帮忙我们搞了语法的解析和编程而已。

总结可以把enum看作就是一个普通的class，它们都可以定义一些属性和方法，不同之处就是：enum无法采用extends关键字承继其他类，因为enum已经承继了ng.enum （java就是单一承继）。

1. 概述在Java编程中，接口是一种重要的编程工具，它允许定义一组方法，但不提供方法的具体实现。

在实际应用中，我们常常会遇到需要接口返回集合中的枚举的情况。

本文将探讨在Java中如何实现接口返回集合中的枚举。

2. Java中的接口在Java中，接口是一种抽象类型，它可以包含方法的声明但不能包含方法的具体实现。

接口可以被类实现，一个类可以实现多个接口。

在接口中定义的方法需要由实现类来具体实现，通过实现接口，可以实现代码的重用和多态的特性。

3. 集合和枚举在Java中，集合是一种用于存储对象的容器，常用的集合类包括List、Set、Map等。

而枚举（Enumeration）是一种特殊的数据类型，它是一种包含一组常量的数据类型，枚举常用于定义一组相关的常量，比如颜色、星期几等。

4. 接口返回集合中的枚举在实际应用中，我们经常会遇到需要接口返回集合中的枚举的情况。

我们有一个接口定义了获取用户列表的方法，而用户有多种状态，比如启用、禁用、删除等，我们希望接口返回一个包含用户状态枚举的集合。

5. 实现方式实现接口返回集合中的枚举可以通过以下几种方式实现：5.1 定义枚举类型我们可以在接口中定义一个枚举类型，用于表示用户的状态，然后在实现类中将枚举类型添加到集合中并返回。

5.2 使用集合类我们也可以直接使用集合类（如List）来存储枚举类型，然后在实现类中将枚举类型添加到集合中并返回。

5.3 使用Stream流Java 8引入了Stream流的概念，我们可以使用Stream流来生成包含枚举类型的集合，并返回给调用方。

6. 示例代码下面是一个示例代码，演示了如何在接口中返回集合中的枚举：```java// 定义用户状态枚举public enum UserStatus {ENABLED, DISABLED, DELETED;// 定义用户服务接口public interface UserService {List<UserStatus> listUserStatus();}// 实现用户服务接口public class UserServiceImpl implements UserService {Overridepublic List<UserStatus> listUserStatus() {List<UserStatus> userStatusList = new ArrayList<>();userStatusList.add(UserStatus.ENABLED);userStatusList.add(UserStatus.DISABLED);userStatusList.add(UserStatus.DELETED);return userStatusList;}}```7. 总结通过本文的介绍，我们了解了在Java中如何实现接口返回集合中的枚举。

java 枚举类继承Java举类是一种特殊的类，它允许开发者通过定义一系列类常量的方式来定义新的类型。

它的核心思想是允许创建和使用有限数量的常量，从而在代码中更好地处理受限的资源，例如一系列固定的状态。

同时，Java举还允许程序员实现枚举类的继承。

枚举类的继承有其特殊性，它与普通类的继承有所不同。

例如，在枚举类中，只有定义的基本枚举常量才能被实例化为枚举类型，而不能实例化继承枚举类的子类。

Java许枚举类继承，但仅限于继承抽象枚举类（abstract enum），因此，当创建一个抽象枚举时，它本身可以被继承，而不能直接实例化枚举对象。

要实现枚举类的继承，首先必须创建一个抽象的枚举类，然后再继承它。

例如，可以定义一个抽象的枚举类，来表示一组基本的枚举常量：public abstract enum abstractEnum {ONE, TWO, THREE}然后，可以创建一个继承抽象枚举的子类：public enum MyEnum extends abstractEnum {FOUR, FIVE, SIX}上面的代码将抽象枚举类 abstractEnum承到子类 MyEnum 中，这样，MyEnum 中就可以定义更多属性常量，如 FOUR、FIVE 、SIX。

此外，子类 MyEnum 中定义的常量也会被继承到 abstractEnum中，因此 abstractEnum有四个常量，分别为 ONE、TWO、THREE FOUR 、FIVE 、SIX。

实现枚举类的继承非常有用，可以帮助我们通过分组定义有限的特定值，从而减少重复定义常量的工作量，并且可以更好地管理常量组，使程序更容易维护和扩展。

总之，Java举类允许继承，这是一种特殊的继承，它可以为程序员创建一组有限的常量，帮助他们更好地管理受限资源，如同一组固定的状态值一样。

但是，需要注意，只有抽象枚举类才能被继承，而不能实例化枚举对象；此外，实现枚举类的继承可以更好的管理常量组，从而节省工作量，增强程序可维护性和可扩展性。

java中常见的字符串转枚举的方法Java中常见的字符串转枚举的方法引言：在Java开发中，经常会遇到将字符串转换为枚举类型的需求。

枚举类型是一种有限的、离散的取值集合，它可以为代码中的常量提供一种类型安全的表示。

本文将介绍Java中常见的字符串转枚举的方法，并给出相应的示例代码。

一、使用valueOf方法Java中的枚举类型都继承自Enum类，Enum类提供了一个valueOf方法，可以将指定的字符串转换为对应的枚举常量。

该方法的实现机制是根据枚举类型中定义的常量名称来进行匹配。

示例代码：```javaenum Color {RED, GREEN, BLUE;}public class EnumExample {public static void main(String[] args) {String colorStr = "RED";Color color = Color.valueOf(colorStr);System.out.println(color); // 输出：RED}}```二、使用Enum.valueOf方法除了使用枚举类型的valueOf方法，还可以使用Enum类的valueOf方法来实现字符串到枚举的转换。

这两种方法的效果是一样的，只是调用方式略有不同。

示例代码：```javaenum Color {RED, GREEN, BLUE;}public class EnumExample {public static void main(String[] args) {String colorStr = "GREEN";Color color = Enum.valueOf(Color.class, colorStr);System.out.println(color); // 输出：GREEN}}```三、使用自定义的转换方法如果枚举类型中的常量名称与字符串不完全匹配，或者需要进行一些额外的处理，可以自定义一个转换方法来实现字符串到枚举的转换。

[Java核⼼技术]五-继承（枚举类）Java枚举类型(enum)枚举类型都是继承了Enum类（是⼀个抽象类）的⼀个类，我们可以向enum类中添加⽅法和变量等。

编译再反编译可以看到枚举类型对应的类的内容。

每个枚举常量都对应⼀个Enum类的实例。

例⼦public enum Day2 {MONDAY("星期⼀"),TUESDAY("星期⼆"),WEDNESDAY("星期三"),THURSDAY("星期四"),FRIDAY("星期五"),SATURDAY("星期六"),SUNDAY("星期⽇");//逗号分隔，分号结束private String desc;/*** 私有构造,防⽌被外部调⽤* @param desc*/private Day2(String desc){this.desc=desc;}public String getDesc(){return desc;}}我们所写的构造函数只能被编译器调⽤，事实上，MONDAY("星期⼀")表明了会调⽤构造函数private Day2(String desc){this.desc=desc;}并为实例MONDAY的属性desc赋值"星期⼀".很好的参考⽂章，可以仔细阅读：抽象类抽象类和抽象⽅法⽤abstract关键字修饰。

抽象类不⼀定有抽象⽅法，有抽象⽅法的类⼀定是抽象类或者是接⼝。

⼀个抽象类如果没有抽象⽅法，是可以定义为抽象类的，这么做的⽬的只有⼀个，就是不让其他类创建本类对象，交给⼦类完成。

抽象类不能实例化。

抽象类的⼦类：要么是抽象类，要么重写抽象类中的所有抽象⽅法。

java enum深入讲解一、什么是Java枚举类型Java枚举类型是一种特殊的数据类型，它允许我们定义一个有限个数的常量，并将这些常量作为一个独立的数据类型来使用。

Java枚举类型在JDK1.5中被引入，它可以用来代替传统的int或String等基本数据类型。

二、Java枚举类型的定义方式Java枚举类型的定义方式非常简单，只需要使用关键字enum即可。

例如：```public enum Color {RED, GREEN, BLUE;}```上面这个例子定义了一个名为Color的枚举类型，它包含了三个常量：RED、GREEN和BLUE。

这些常量都是Color类型的实例。

三、Java枚举类型的特点1. Java枚举类型是一种特殊的类，因此它可以拥有属性和方法。

2. Java枚举类型中定义的常量都是该类的实例，并且只能通过该类访问。

3. Java枚举类型中定义的常量不能被修改。

4. Java枚举类型中可以使用switch语句进行匹配。

5. Java枚举类型可以实现接口。

四、Java枚举类型中常用方法1. values()方法：返回该枚举类中所有常量值组成的数组。

2. valueOf()方法：根据给定字符串返回对应的枚举常量。

3. name()方法：返回该枚举常量的名称。

4. ordinal()方法：返回该枚举常量在枚举类中的索引位置。

五、Java枚举类型中的构造函数Java枚举类型中的构造函数默认为私有，因此不能被外部调用。

如果需要给每个枚举常量设置属性值，则可以使用带参构造函数。

例如：```public enum Color {RED("红色"), GREEN("绿色"), BLUE("蓝色");private String desc;private Color(String desc) {this.desc = desc;}public String getDesc() {return desc;}}```上面这个例子中，我们给每个枚举常量都设置了一个描述信息，并提供了一个getDesc()方法来获取该描述信息。

java 枚举类继承java枚举类继承是指一种使用Java编程语言定义的枚举类可以继承另一个枚举类，从而在枚举类中添加其它枚举常量值。

使用枚举类继承可以实现多维度枚举类型，比如从一个基础枚举类型上衍生出新的枚举类型，以及定义新的枚举值。

在Java语言中，枚举类继承是基于类的继承机制实现，因此，一个枚举类型可以被另一个枚举类型所继承，并且继承枚举类可以重新定义其它枚举常量值。

首先，通过定义子类，可以在枚举类中声明其它枚举常量：public enum ParentEnum {VALUE1, VALUE2;}public enum ChildEnum extends ParentEnum {VALUE3;}这里，定义了一个ParentEnum枚举类，其中定义了VALUE1和VALUE2两个枚举常量；而ChildEnum枚举类继承了ParentEnum，并且定义了一个新的枚举常量VALUE3。

其次，可以使用类型安全的枚举类型，从而实现同一个枚举类中存在多种类型枚举常量：public enum ParentEnum {VALUE1(1), VALUE2(2);private int value;public int getValue(){return value;}ParentEnum(int value){this.value=value;}}public enum ChildEnum extends ParentEnum {VALUE3(3);ChildEnum(int value){super(value);}}借助上述代码实现的枚举类继承，可以在同一个枚举中，定义不同类型的枚举常量：VALUE1、VALUE2和VALUE3。

此外，java枚举类继承还可以实现重载构造函数，以及定义实例方法，方法可以根据枚举常量值进行条件判断：public enum ParentEnum {VALUE1(1), VALUE2(2);private int value;public int getValue(){return value;}ParentEnum(int value){this.value=value;}public boolean isVALUE1(){return VALUE1.equals(this);}public boolean isVALUE2(){return VALUE2.equals(this);}}public enum ChildEnum extends ParentEnum {VALUE3(3);ChildEnum(int value){super(value);}public boolean isVALUE3(){return VALUE3.equals(this);}}定义重载构造函数和实例方法，可以使得枚举类型更加灵活，并能够实现更复杂的业务逻辑。

详解Java枚举类型enum及其使用详解Java枚举类型enum及其使用Java 中的枚举类型采用关键字enum 来定义，从jdk1.5才有的新类型，所有的枚举类型都是继承自Enum 类型。

以下是店铺搜索整理的关于Java枚举类型enum详解及其使用，,需要的朋友可以参考本文!想了解更多相关信息请持续关注我们店铺!要了解枚举类型，建议大家先打开jdk 中的Enum 类简单读一下，这个类里面定义了很多protected 方法，比如构造函数，如果要使用这些方法我们可以把枚举类型定义到当前类中。

每个枚举类型，都有自己的名字和顺序，当我们输出一个枚举类型的时候，会输入枚举类型的name ，具体可以参考下面的例子。

一、通常定义常量方法我们通常利用public final static 方法定义的代码如下，分别用1 表示红灯，3 表示绿灯，2 表示黄灯。

package com.csdn.myEnum;public class Light {/* 红灯 */public final static int RED =1;/* 绿灯 */public final static int GREEN =3;/* 黄灯 */public final static int YELLOW =2;}二、枚举类型定义常量方法枚举类型的简单定义方法如下，我们似乎没办法定义每个枚举类型的值。

比如我们定义红灯、绿灯和黄灯的代码可能如下：public enum Light {RED , GREEN , YELLOW ;}我们只能够表示出红灯、绿灯和黄灯，但是具体的值我们没办法表示出来。

别急，既然枚举类型提供了构造函数，我们可以通过构造函数和覆写toString 方法来实现。

首先给Light 枚举类型增加构造方法，然后每个枚举类型的值通过构造函数传入对应的参数，同时覆写toString 方法，在该方法中返回从构造函数中传入的参数，改造后的'代码如下：public enum Light {// 利用构造函数传参RED (1), GREEN (3), YELLOW (2);// 定义私有变量private int nCode ;// 构造函数，枚举类型只能为私有private Light( int _nCode) {this . nCode = _nCode;}@Overridepublic String toString() {return String.valueOf ( this . nCode );}}三、完整示例代码枚举类型的完整演示代码如下：package com.csdn.myEnum;import java.util.EnumMap;import java.util.EnumSet;public class LightT est {// 1. 定义枚举类型public enum Light {// 利用构造函数传参RED (1), GREEN (3), YELLOW (2);// 定义私有变量private int nCode ;// 构造函数，枚举类型只能为私有private Light( int _nCode) {this . nCode = _nCode;}@Overridepublic String toString() {return String.valueOf ( this . nCode );}}/*** @param args*/public static void main(String[] args ) {// 1. 遍历枚举类型System. out .println( " 演示枚举类型的遍历 ......" ); testTraversalEnum ();// 2. 演示 EnumMap 对象的使用System. out .println( " 演示 EnmuMap 对象的使用和遍历 ....." ); testEnumMap ();// 3. 演示 EnmuSet 的使用System. out .println( " 演示 EnmuSet 对象的使用和遍历 ....." ); testEnumSet ();}/*** 演示枚举类型的遍历*/private static void testTraversalEnum() {Light[] allLight = Light.values ();for (Light aLight : allLight) {System. out .println( " 当前灯 name ： " + ());System. out .println( " 当前灯 ordinal ： " + aLight.ordinal());System. out .println( " 当前灯： " + aLight);}}/*** 演示 EnumMap 的使用， EnumMap 跟 HashMap 的使用差不多，只不过 key 要是枚举类型*/private static void testEnumMap() {// 1. 演示定义 EnumMap 对象， EnumMap 对象的构造函数需要参数传入 , 默认是key 的类的类型EnumMap currEnumMap = new EnumMap(Light. class );currEnumMap.put(Light. RED , " 红灯 " );currEnumMap.put(Light. GREEN , " 绿灯 " );currEnumMap.put(Light. YELLOW , " 黄灯 " );// 2. 遍历对象for (Light aLight : Light.values ()) {System. out .println( "[key=" + () + ",value="+ currEnumMap.get(aLight) + "]" );}}/*** 演示 EnumSet 如何使用， EnumSet 是一个抽象类，获取一个类型的枚举类型内容* 可以使用 allOf 方法*/private static void testEnumSet() {EnumSet currEnumSet = EnumSet.allOf (Light. class );for (Light aLightSetElement : currEnumSet) {System. out .println( " 当前EnumSet 中数据为：" + aLightSetElement);}}}执行结果如下：演示枚举类型的遍历 ......当前灯 name ： RED当前灯 ordinal ： 0当前灯： 1当前灯 name ： GREEN当前灯 ordinal ： 1当前灯： 3当前灯 name ： YELLOW当前灯 ordinal ： 2当前灯： 2演示 EnmuMap 对象的使用和遍历 .....[key=RED,value= 红灯 ][key=GREEN,value= 绿灯 ][key=YELLOW,value= 黄灯 ]演示 EnmuSet 对象的使用和遍历 .....当前 EnumSet 中数据为： 1当前 EnumSet 中数据为： 3当前 EnumSet 中数据为： 2四、通常定义常量方法和枚举定义常量方法区别以下内容可能有些无聊，但绝对值得一窥1. 代码：public class State {public static final int ON = 1;public static final Int OFF= 0;}有什么不好了，大家都这样用了很长时间了，没什么问题啊。