JAVA 枚举

分手后的思念是犯贱 2022-06-03 04:14 245阅读 0赞

# 14. JAVA 枚举(Enum、类集EnumMap&EnumSet 、实现接口、定义抽象方法) ----- 学习笔记 #

http://blog.csdn.net/forfan06/article/details/38847777

转载  2014年08月26日 15:01:51

*  标签：
 *  [enum][] /
 *  [枚举][Link 1] /
 *  [基础知识][Link 2]

## 本章目标: ##

*  了解枚举可以解决哪些技术问题
 *  掌握枚举的定义方式
 *  清楚地掌握enum关键字与Enum类的关系
 *  掌握JDK1.5之后的枚举操作类：EnmuSet、EnumMap
 *  让枚举类实现一个接口或在枚举类中定义抽象方法

枚举是在JDK1.5之后另外一个重要的特性，在枚举中可以限制一个类的对象产生范围，加入了枚举之后Java又对之前的类集进行了扩充，产生了一些新的枚举支持类 --- EnumSet、EnumMap，为枚举的使用提供了方便。

## 14.1 枚举类型简介 ##

在JDK1.5之前，Java有两种方式定义新类型: 类和接口。 对于大部分面向对象编程来说，这两种方法看起来似乎足够了。但是在一些特殊的情况下，这些方法就不适合了。 例如，想定义一个Color类，它只能有Red、Green、Blue3种植，其他的任何值都是非法的，那么JDK1.5之前虽然可以构造这样的代码，但是要做很多的工作，就可能带来各种不安全的问题。而在JDK1.5之后，引入的枚举类型（Enum）就能避免这些问题。

## 14.2 使用简单程序完成枚举的功能 ##

枚举是在JDK1.5之后引入的， 如果在JDK1.5之前完成枚举的功能，则必须依靠类似于以下的程序代码完成。

范例： 使用简单类完成枚举操作

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  class Color\{  
2.      public static final Color RED = new Color("Red");    //定义第一个对象  
3.      public static final Color GREEN = new Color("Green");   //定义第二个对象  
4.      public static final Color BLUE = new Color("Blue");     //定义第三个对象  
5.      private String name;  
6.      private Color(String name)\{  
7.          this.setName(name);  
8.      \}  
9.      public String getName()\{  
10.         return this.name;  
11.     \}  
12.     public void setName(String name)\{  
13.         this.name = name;  
14.     \}  
15.     public static Color getInstance(int i)\{  //等到一个颜色，只能从固定的几个颜色中取得中得  
16.         switch(i)\{  
17.             case 1:\{  
18.                 return RED;  
19.             \}  
20.             case 2:\{  
21.                 return GREEN;  
22.             \}  
23.             case 3:\{  
24.                 return BLUE;  
25.             \}  
26.             default:\{  
27.                 return null;  
28.             \}  
29.         \}  
30.     \}  
31. \}  
32.   
33. public class ColorDemo01\{  
34.     public static void main(String args\[\])\{  
35.         Color c1 = Color.RED;  
36.         System.out.println(c1.getName());  
37.           
38.         Color c2 = Color.getInstance(3);  
39.         System.out.println(c2.getName());  
40.     \}  
41. \}

以上程序将Color类中的构造方法私有化，之后再类中准备了若干个实例化对象，以后如果要取得Color类的实例， 则只能从BLUE、GREEN、RED3个对象中取得，这样就有效地限制了对象的取得范围。

以上使用的Color对象指定的范围，是通过一个个常量对每个对象进行编号的。 也就是说，一个个的对象就相当于用常量表示了。 所以，按照这个思路也可以直接使用一个接口规定出一组常量的范围。

范例： 使用接口表示一组范围

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  package org.forfan06.colordemo;  
2.  public interface Color\{  
3.       public static final int RED = 1;  
4.       public static final int GREEN = 2;  
5.       public static final int BLUE = 3;  
6.  \}

以上表示出的各个颜色是通过接口指定好的常量范围，与之前相比更加简单。但是这样做也会存在另外一个iewenti，如果现在使用如下的代码：

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  package org.forfan06.colordemo;  
2.  public class ColorDemo02\{  
3.       public static void main(String args\[\])\{  
4.            System.out.println(Color.RED + Color.GREEN);  
5.       \}  
6.  \}

两个颜色的常量相加之后形成了“3”，这样的结果看起来会令人非常困惑，操作很不明确。

另外，使用以上这种方法，用户如果想知道到底有多少个颜色可以使用，则实现的代码非常复杂。在JDK1.5之后就有了专门解决这样问题的方法。

## 14.3 定义一个枚举类型 ##

在JDK1.5之后，引入了一个新的关键字类型  ---  enum， 可以直接定义枚举类型。

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  //声明枚举类型  
2.  \[public\] enum 枚举类型名称\{  
3.       枚举对象1, 枚举对象2, ..., 枚举对象n;  
4.  \}

范例： 定义一个Color的枚举类型

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  package org.forfan06.enumdemo;  
2.  public enum Color\{  
3.       RED, GREEN, BLUE;  
4.  \}

以上的Color定义出来的枚举类型，其中包含RED、GREEN、BLUE3个数据。

可以使用  “ 枚举.variable ” 的形式取出枚举中的指定内容。

范例： 取出一个枚举内容

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  package org.forfan06.enumdemo;  
2.  enum Color\{  
3.       RED, GREEN, BLUE;  
4.  \}  
5.    
6.  public class GetEnumContent\{  
7.       public static void main(String args\[\])\{  
8.            Color c = Color.BLUE;  
9.            System.out.println(c);  
10.      \}  
11. \}

运行结果：

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  BLUE

枚举类型的数据也可以使用  “ 枚举.values() ” 的形式，将全部的枚举类型变为对象数组的形式， 之后使用foreach进行输出

范例： 使用foreach输出枚举内容

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  package org.forfan06.enumdemo;  
2.  enum Color\{  
3.       RED, GREEN, BLUE;  
4.  \}  
5.    
6.  public class PrintEnum\{  
7.       public static void main(String args\[\])\{  
8.            for(Color c:Color.values())\{   // 枚举.values()表示得到全部枚举的内容  
9.                 System.out.print(c + "、");   //输出结果： RED、GREEN、BLUE、  
10.           \}  
11.      \}  
12. \}

枚举中的每个类型也可以使用switch进行判断，但是在switch语句中使用枚举类型时，一定不能再每一个枚举类型值得前面加上枚举类型的类名（例如，Color.BLUE），否则编译器会报错！！！！

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  package org.forfan06.enumdemo;  
2.  enum Color\{  
3.       RED, GREEN, BLUE;  
4.  \}  
5.    
6.  public class SwithcPrintDemo\{  
7.       public static void main(String args\[\])\{  
8.            for(Color c:Color.values())\{  
9.                 print(c);  
10.           \}  
11.      \}  
12.   
13.      public static void print(Color color)\{  
14.           switch(color)\{  
15.                case RED:\{  
16.                     System.out.println("RED");  
17.                     break;  
18.                \}  
19.                case GREEN:\{  
20.                     System.out.println("GREEN");  
21.                     break;  
22.                \}  
23.                case BLUE:\{  
24.                     System.out.println("BLUE");  
25.                     break;  
26.                \}  
27.                default:\{  
28.                     System.out.println("Unknown");  
29.                     break;  
30.                \}  
31.           \}  
32.      \}  
33. \}

以上的Color.values()方法表示取得枚举中的全部内容，返回的是一个对象数组，这是枚举本身支持的一个方法，除了这个方法之外， 到底还有哪些方法可以供开发者使用呢？ 要了解这些，就必须深入分析枚举类   --- Enum类

## 14.4 Enum ##

从前面的讲解中可以知道，使用enum关键字可以定义一个枚举，实际上此关键字表示的是java.lang.Enum类型，即使用enum声明的枚举类型就相当于定义了一个类！！而此类默认继承了java.lang.Enum类。

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  //java.lang.Enum类的定义  
2.  public abstract class Enum<E extends Enum<E>> extends Object implements Comparable<E>, java.io.Serializable

Enum类的定义，此类实现了Comparable和Serializable两个接口， 证明了枚举类型可以使用比较器和序列化操作！！！！！！！！！！！

Enum类中包含的方法：

![Center][]

下面来逐步观察这些方法的使用：

###       14.4.1 取得枚举的信息 ###

在枚举类建立完成之后，实际上都会为其调用枚举类中的构造方法，为其赋值。 在Enum类的构造方法中的第一个参数name就是定义的枚举的名称，第二个参数ordinal则会从0开始依次进行编号。

之后可以使用Enum类中提供的name()、ordinal()方法取得名称和编号！！

范例： 验证name()、ordinal()方法

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  package org.forfan06.enumdemo;  
2.  enum Color\{  
3.      RED, GREEN, BLUE;  
4.  \}  
5.    
6.  public class GetEnumInfo\{  
7.      public static void main(String args\[\])\{  
8.          for(Color c:Color.values())\{  
9.              System.out.println(c.ordinal() + "--->" + c.name());  
10.         \}  
11.     \}  
12. \}

运行结果：

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  0\--->RED  
2.  1\--->GREEN  
3.  2\--->BLUE

###       14.4.2 为每一个枚举对象属性赋值 ###

1. 通过构造方法为属性赋值

每个枚举类中都有其指定好的若干对象，当然，每一个枚举对象中也可以包含多个属性。而，这些属性也可以通过构造方法为其赋值。

范例： 通过构造方法为枚举属性赋值

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  enum Color\{  
2.      RED("红色"), GREEN("绿色"), BLUE("蓝色");  
3.      private Color(String name)\{  
4.          this.setName(name);  
5.      \}  
6.      private String name;  
7.      public String getName()\{  
8.          return name;  
9.      \}  
10.     public void setName(String name)\{  
11.         this.name = name;  
12.     \}  
13. \}  
14.   
15. public class ConstructorEnum\{  
16.     public static void main(String args\[\])\{  
17.         for(Color c:Color.values())\{  
18.             System.out.println(c.ordinal() + "-->" + c.name() + "(" + c.getName() + ")");  
19.         \}  
20.     \}  
21. \}

运行结果：

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  0\-->RED(红色)  
2.  1\-->GREEN(绿色)  
3.  2\-->BLUE(蓝色)

以上程序代码在定义的Color枚举类中设置了一个name属性，并且通过构造方法设置name属性的内容。因为Color中已经明确地写出了有一个参数的构造方法，所以在声明枚举内容时就必须调用这个构造方法，这样在定义枚举内容时就必须使用如下的语句形式：

RED("红色"), GREEN("绿色"), BLUE("蓝色");

2. 通过setter方法为属性赋值

以上是通过构造方法的方式为属性赋值的， 当然，也可以通过调用setter()方法来为指定的属性赋值。 但是，这样一来就必须明确每一个枚举类的对象，如果操作的对象是RED，则名字应该是“红色”；如果操作的对象是GREEN，则名字应该是“蓝色”等等。

范例： 使用setter()方法设置内容

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  package org.forfan06.enumapidemo;  
2.  enum Color\{  
3.      RED, GREEN, BLUE;  
4.      /\*\* 
5.      RED("红色"), GREEN("绿色"), BLUE("蓝色"); 
6.      private Color(String name)\{  
7.          this.setName(name); 
8.      \} 
9.      \*\*/  
10.     private String name;  
11.     public String getName()\{  
12.         return this.name;  
13.     \}  
14.       
15.     public void setName(String name)\{  
16.         switch(this)\{  
17.             case RED:\{    //判断是否为该颜色  
18.                 if("红色".equals(name))\{      
19.                     this.name = name;      //设置名称  
20.                 \}else\{  
21.                     System.out.println("设置内容错误。");  
22.                 \}  
23.                 break;  
24.             \}  
25.             case GREEN:\{    //判断是否为该颜色  
26.                 if("绿色".equals(name))\{      
27.                     this.name = name;      //设置名称  
28.                 \}else\{  
29.                     System.out.println("设置内容错误。");  
30.                 \}  
31.                 break;  
32.             \}  
33.             case BLUE:\{    //判断是否为该颜色  
34.                 if("蓝色".equals(name))\{      
35.                     this.name = name;      //设置名称  
36.                 \}else\{  
37.                     System.out.println("设置内容错误。");  
38.                 \}  
39.                 break;  
40.             \}  
41.         \}  
42.     \}  
43.     /\*\* 
44.     public void setName(String name)\{  
45.         this.name = name; 
46.     \} 
47.     \*\*/  
48. \}  
49.   
50. public class SetEnum\{  
51.     public static void main(String args\[\])\{  
52.         Color c = Color.BLUE;  
53.         c.setName("兰色");  //设置错误的名字  
54.         c.setName("蓝色");  //设置正确的名字  
55.         System.out.println(c.getName());  
56.         /\*\* 
57.         for(Color c:Color.values())\{  
58.             System.out.println(c.ordinal() + "-->" + c.name() + "(" + c.getName() + ")"); 
59.         \} 
60.         \*\*/  
61.     \}  
62. \}

运行结果：

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  设置内容错误。  
2.  蓝色

从以上代码中，首先通过枚举类取得了里面的一个对象。之后开始为其设置内容，一开始设置了不符合要求的内容，所以会出现“设置内容错误”的提示；而如果设置的内容正确，则可以直接将其赋值给name属性。

如果不想通过   “ 枚举类.对象 ” 的形式取得每一个枚举类的对象， 也可以， 使用Enum类定义的 “ 枚举类.valueOf() ”方法的形式进行调用！！！！

范例： 使用valueOf()方法找到一个枚举对象

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  package org.forfan06.enumapidemo;  
2.  enum Color\{  
3.      RED, GREEN, BLUE;  
4.      /\*\* 
5.      RED("红色"), GREEN("绿色"), BLUE("蓝色"); 
6.      private Color(String name)\{  
7.          this.setName(name); 
8.      \} 
9.      \*\*/  
10.     private String name;  
11.     public String getName()\{  
12.         return this.name;  
13.     \}  
14.       
15.     public void setName(String name)\{  
16.         switch(this)\{  
17.             case RED:\{    //判断是否为该颜色  
18.                 if("红色".equals(name))\{      
19.                     this.name = name;      //设置名称  
20.                 \}else\{  
21.                     System.out.println("设置内容错误。");  
22.                 \}  
23.                 break;  
24.             \}  
25.             case GREEN:\{    //判断是否为该颜色  
26.                 if("绿色".equals(name))\{      
27.                     this.name = name;      //设置名称  
28.                 \}else\{  
29.                     System.out.println("设置内容错误。");  
30.                 \}  
31.                 break;  
32.             \}  
33.             case BLUE:\{    //判断是否为该颜色  
34.                 if("蓝色".equals(name))\{      
35.                     this.name = name;      //设置名称  
36.                 \}else\{  
37.                     System.out.println("设置内容错误。");  
38.                 \}  
39.                 break;  
40.             \}  
41.         \}  
42.     \}  
43.     /\*\* 
44.     public void setName(String name)\{  
45.         this.name = name; 
46.     \} 
47.     \*\*/  
48. \}  
49.   
50. public class ValueOfDemo\{  
51.     public static void main(String args\[\])\{  
52.         //Color c = Color.BLUE;  
53.         Color c = Enum.valueOf(Color.class, "BLUE");  
54.         c.setName("兰色");  //设置错误的名字  
55.         c.setName("蓝色");  //设置正确的名字  
56.         System.out.println(c.getName());  
57.         /\*\* 
58.         for(Color c:Color.values())\{  
59.             System.out.println(c.ordinal() + "-->" + c.name() + "(" + c.getName() + ")"); 
60.         \} 
61.         \*\*/  
62.     \}  
63. \}

以上程序代码，使用valueOf()方法来获取Enum类的一个枚举对象，第一个参数使用了 “  枚举.class ” 的形式，这里是Java的反射机制。 在后面的章节会详细的解释。

###       14.4.3 使用比较器 ###

在Enum类的定义中已经实现好了Comparable接口，所以枚举类的内容本身是可以进行排序的，下面通过TreeSet演示枚举的排序操作

TreeSet类可以直接进行排序（类集部分讲解到过），排序的规则是通过Comparable接口完成的！！！

范例： 验证枚举比较器

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  package org.forfan06.enumapidemo;  
2.  import java.util.Set;  
3.  import java.util.TreeSet;  
4.  import java.util.Iterator;  
5.  enum Color\{  
6.      RED, GREEN, BLUE;  
7.  \}  
8.    
9.  public class ComparableEnum\{  
10.     public static void main(String args\[\])\{  
11.         Set<Color> set = new TreeSet<Color>();  
12.         set.add(Color.GREEN);  
13.         set.add(Color.BLUE);  
14.         set.add(Color.RED);  
15.           
16.         Iterator<Color> iter = set.iterator();  
17.         while(iter.hasNext())\{  
18.             System.out.print(iter.next() + "、");  
19.         \}  
20.     \}  
21. \}

运行结果：

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  RED、GREEN、BLUE、

以上代码块，数据加入的顺序是GREEN、BLUE、RED，但是输出之后的顺序是RED、GREEN、BLUE。说明已经被排序了。是使 用Enum类中的ordinal属性排序的！！！！！！！！！！！

## 14.5 类集对枚举的支持 --- EnumMap、EnumSet ##

在JDK1.5的java.util程序包中提供了两个新的集合操作类: EnumMap、EnumSet类， 这两个类与枚举类型的结合应用可以使以前非常繁琐的程序变得简单方便。

1.  EnumSet类提供了java.util.Set接口的一个特殊实现；
2.  EnumMap类提供了java.util.Map接口的一个特殊实现，该类中的键（key）是一个枚举类型。

###       14.5.1 EnumMap ###

EnumMap类，是Map接口的子类，所以本身还是以Map的形式进行操作（key --> value）。

如果要使用EnumMap，则首先要创建EnumMap类的实例化对象，在创建此对象时必须指定要操作的枚举类型。

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  //EnumMap类的构造方法  
2.  public EnumMap(Class<K> keyType)

范例：验证EnumMap

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  package org.forfan06.enumcol;  
2.  import java.util.EnumMap;  
3.  import java.util.Map;  
4.  enum Color\{  
5.      RED, GREEN, BLUE;  
6.  \}  
7.    
8.  public class EnumMapDemo\{  
9.      public static void main(String args\[\])\{  
10.         Map<Color, String> desc = null;  
11.         desc = new EnumMap<Color, String>(Color.class);  
12.         desc.put(Color.RED, "红色");  
13.         desc.put(Color.GREEN, "绿色");  
14.         desc.put(Color.BLUE, "蓝色");  
15.         System.out.println("=====输出全部的内容=====");  
16.         for(Color c:Color.values())\{  
17.             System.out.println(c.name() + "-->" + desc.get(c));  
18.         \}  
19.         System.out.println("=====输出全部的键值=====");  
20.         for(Color c:desc.keySet())\{  
21.             System.out.print(c.name() + "、");  
22.         \}  
23.         System.out.println("\\n=====输出全部的内容=====");  
24.         for(String s:desc.values())\{  
25.             System.out.print(s + "、");  
26.         \}  
27.     \}  
28. \}

运行结果：

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  =====输出全部的内容=====  
2.    
3.  RED-->红色  
4.  GREEN-->绿色  
5.  BLUE-->蓝色  
6.  =====输出全部的键值=====  
7.  RED、GREEN、BLUE、  
8.  =====输出全部的内容=====  
9.  红色、绿色、蓝色、

###       14.5.2 EnumSet ###

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

![Center 1][]

（1）范例： 验证EnumSet -- 将全部的集合设置到EnumSet集合中

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  package org.forfan06.enumdemo;  
2.  import java.util.EnumSet;  
3.  enum Color\{  
4.      RED, GREEN, BLUE;  
5.  \}  
6.    
7.  public class EnumSetDemo01\{  
8.      public static void main(String args\[\])\{  
9.          EnumSet<Color> eset = null;  
10.         System.out.println("======EnumSet.allOf(Color.class)=====");  
11.         eset = EnumSet.allOf(Color.class);  
12.           
13.         print(eset);  
14.     \}  
15.       
16.     public static void print(EnumSet<Color> temp)\{  
17.         for(Color c:temp)\{  
18.             System.out.print(c + "、");  
19.         \}  
20.         System.out.println();  
21.     \}  
22. \}

运行结果：

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  ======EnumSet.allOf(Color.class)=====  
2.  RED、GREEN、BLUE、

以上程序使用了EnumSet提供的static方法 allOf()，将一个枚举中的全部内容设置到EnumSet集合中。

（2）范例： 验证EnumSet -- 只设置一个枚举的类型到集合中

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  package org.forfan06.enumdemo;  
2.  import java.util.EnumSet;  
3.  enum Color\{  
4.      RED, GREEN, BLUE;  
5.  \}  
6.    
7.  public class EnumSetDemo02\{  
8.      public static void main(String args\[\])\{  
9.          EnumSet<Color> eset = null;  
10.         //System.out.println("======EnumSet.allOf(Color.class)=====");  
11.         //eset = EnumSet.allOf(Color.class);  
12.         System.out.println("======EnumSet.of(Color.class)=====");  
13.         eset = EnumSet.of(Color.BLUE);  
14.           
15.         print(eset);  
16.     \}  
17.       
18.     public static void print(EnumSet<Color> temp)\{  
19.         for(Color c:temp)\{  
20.             System.out.print(c + "、");  
21.         \}  
22.         System.out.println();  
23.     \}  
24. \}

运行结果：

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  ======EnumSet.of(Color.class)=====  
2.  BLUE、

（3）范例： 验证EnumSet -- 创建只能放入指定枚举类型的集合

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  package org.forfan06.enumdemo;  
2.  import java.util.EnumSet;  
3.  enum Color\{  
4.      RED, GREEN, BLUE;  
5.  \}  
6.    
7.  public class EnumSetDemo03\{  
8.      public static void main(String args\[\])\{  
9.          EnumSet<Color> eset = null;  
10.         //System.out.println("======EnumSet.allOf(Color.class)=====");  
11.         //eset = EnumSet.allOf(Color.class);  
12.         //System.out.println("======EnumSet.of(Color.class)=====");  
13.         //eset = EnumSet.of(Color.BLUE);  
14.         System.out.println("======EnumSet.noneOf(Color.class)=====");  
15.         eset = EnumSet.noneOf(Color.class);  
16.           
17.         eset.add(Color.RED);  
18.         eset.add(Color.BLUE);  
19.           
20.         print(eset);  
21.     \}  
22.       
23.     public static void print(EnumSet<Color> temp)\{  
24.         for(Color c:temp)\{  
25.             System.out.print(c + "、");  
26.         \}  
27.         System.out.println();  
28.     \}  
29. \}

运行结果：

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  ======EnumSet.noneOf(Color.class)=====  
2.  RED、BLUE、

将集合设置成只能增加Color类型的集合，但，并不设置任何的内容到集合中。

（4）范例： 验证EnumSet -- 创建不包含指定元素的集合

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  package org.forfan06.enumdemo;  
2.  import java.util.EnumSet;  
3.  enum Color\{  
4.      RED, GREEN, BLUE;  
5.  \}  
6.    
7.  public class EnumSetDemo04\_01\{  
8.      public static void main(String args\[\])\{  
9.          EnumSet<Color> esetOld = null;  
10.         EnumSet<Color> esetNew = null;  
11.         //System.out.println("======EnumSet.allOf(Color.class)=====");  
12.         //eset = EnumSet.allOf(Color.class);  
13.         //System.out.println("======EnumSet.of(Color.class)=====");  
14.         //eset = EnumSet.of(Color.BLUE);  
15.         esetOld = EnumSet.noneOf(Color.class); //可以加入Color类型的对象  
16.         esetOld.add(Color.RED);  
17.         esetOld.add(Color.BLUE);  
18.           
19.         esetNew = EnumSet.complementOf(esetOld);  //创建一个不包含指定元素的集合  
20.           
21.         System.out.println("======EnumSet.noneOf(Color.class)=====");  
22.         print(esetNew);  
23.     \}  
24.       
25.     public static void print(EnumSet<Color> temp)\{  
26.         for(Color c:temp)\{  
27.             System.out.print(c + "、");  
28.         \}  
29.         System.out.println();  
30.     \}  
31. \}

运行结果：

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  ======EnumSet.noneOf(Color.class)=====  
2.  GREEN、

add()语句的位置影响输出~

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  package org.forfan06.enumdemo;  
2.  import java.util.EnumSet;  
3.  enum Color\{  
4.      RED, GREEN, BLUE;  
5.  \}  
6.    
7.  public class EnumSetDemo04\_02\{  
8.      public static void main(String args\[\])\{  
9.          EnumSet<Color> esetOld = null;  
10.         EnumSet<Color> esetNew = null;  
11.         //System.out.println("======EnumSet.allOf(Color.class)=====");  
12.         //eset = EnumSet.allOf(Color.class);  
13.         //System.out.println("======EnumSet.of(Color.class)=====");  
14.         //eset = EnumSet.of(Color.BLUE);  
15.         esetOld = EnumSet.noneOf(Color.class); //可以加入Color类型的对象  
16.         esetNew = EnumSet.complementOf(esetOld);  //创建一个不包含指定元素的集合  
17.           
18.         esetOld.add(Color.RED);  
19.         esetOld.add(Color.BLUE);  
20.           
21.         System.out.println("======EnumSet.complementOf(Color.class)=====");  
22.         print(esetNew);  
23.         System.out.println("======EnumSet.noneOf(Color.class)=====");  
24.         print(esetOld);  
25.     \}  
26.       
27.     public static void print(EnumSet<Color> temp)\{  
28.         for(Color c:temp)\{  
29.             System.out.print(c + "、");  
30.         \}  
31.         System.out.println();  
32.     \}  
33. \}

此时的运行结果：

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  ======EnumSet.complementOf(Color.class)=====  
2.  RED、GREEN、BLUE、  
3.  ======EnumSet.noneOf(Color.class)=====  
4.  RED、BLUE、

以上程序先通过noneOf()方法创建了一个只能接收Color类型的集合esetOld，然后向其增加了两个元素；

然后，再以esetOld的集合为参考创建了一个新的集合esetNew，esetNew集合中将不包含esetOld中已有的内容。

note: 向参考集合中增加元素的语句add()的位置决定了esetNew里面的元素~~~

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  import java.util.EnumSet;  
2.  enum Color\{  
3.      RED, GREEN, BLUE;  
4.  \}  
5.    
6.  public class EnumSetDemo04\_03\{  
7.      public static void main(String args\[\])\{  
8.          EnumSet<Color> esetOld = null;  
9.          EnumSet<Color> esetNew = null;  
10.         //System.out.println("======EnumSet.allOf(Color.class)=====");  
11.         //eset = EnumSet.allOf(Color.class);  
12.         //System.out.println("======EnumSet.of(Color.class)=====");  
13.         //eset = EnumSet.of(Color.BLUE);  
14.         esetOld = EnumSet.noneOf(Color.class); //可以加入Color类型的对象  
15.         esetOld.add(Color.BLUE);  
16.           
17.         esetNew = EnumSet.complementOf(esetOld);  //创建一个不包含指定元素的集合  
18.           
19.         esetOld.add(Color.RED);  
20.                   
21.         System.out.println("======EnumSet.complementOf(Color.class)=====");  
22.         print(esetNew);  
23.         System.out.println("======EnumSet.Of(Color.class)=====");  
24.         print(esetOld);  
25.     \}  
26.       
27.     public static void print(EnumSet<Color> temp)\{  
28.         for(Color c:temp)\{  
29.             System.out.print(c + "、");  
30.         \}  
31.         System.out.println();  
32.     \}  
33. \}

运行结果：

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  ======EnumSet.complementOf(Color.class)=====  
2.  RED、GREEN、  
3.  ======EnumSet.Of(Color.class)=====  
4.  RED、BLUE、

（5）范例： 验证EnumSet -- 复制已有的内容

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  package org.forfan06.enumdemo;  
2.  import java.util.EnumSet;  
3.  enum Color\{  
4.      RED, GREEN, BLUE;  
5.  \}  
6.    
7.  public class EnumSetDemo05\{  
8.      public static void main(String args\[\])\{  
9.          EnumSet<Color> esetOld = null;  
10.         EnumSet<Color> esetNew = null;  
11.         //System.out.println("======EnumSet.allOf(Color.class)=====");  
12.         //eset = EnumSet.allOf(Color.class);  
13.         //System.out.println("======EnumSet.of(Color.class)=====");  
14.         //eset = EnumSet.of(Color.BLUE);  
15.         esetOld = EnumSet.noneOf(Color.class); //可以加入Color类型的对象  
16.         esetOld.add(Color.BLUE);  
17.         esetOld.add(Color.RED);  
18.         esetNew = EnumSet.copyOf(esetOld);  //创建一个不包含指定元素的集合  
19.                   
20.         System.out.println("======EnumSet.complementOf(Color.class)=====");  
21.         print(esetNew);  
22.         System.out.println("======EnumSet.copyOf(Color.class)=====");  
23.         print(esetOld);  
24.     \}  
25.       
26.     public static void print(EnumSet<Color> temp)\{  
27.         for(Color c:temp)\{  
28.             System.out.print(c + "、");  
29.         \}  
30.         System.out.println();  
31.     \}  
32. \}

运行结果：

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  ======EnumSet.complementOf(Color.class)=====  
2.  RED、BLUE、  
3.  ======EnumSet.copyOf(Color.class)=====  
4.  RED、BLUE、

## 14.6 枚举类实现接口 ##

枚举类也可以实现一个接口，但是，因为接口中会存在抽象方法，所以枚举类中的**每个对象都必须分别实现此抽象方法**。

范例： 枚举类实现一个接口

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  package org.forfan06.enumdemo;  
2.  interface Print\{  
3.      public String getColor();  
4.  \}  
5.  enum Color implements Print\{  
6.      RED\{  
7.          public String getColor()\{  
8.              return "红色";  
9.          \}  
10.     \},  
11.     GREEN\{  
12.         public String getColor()\{  
13.             return "绿色";  
14.         \}  
15.     \},  
16.     BLUE\{  
17.         public String getColor()\{  
18.             return "蓝色";  
19.         \}  
20.     \};  
21. \}  
22.   
23. public class EnumeImplementsInterfaceDemo\{  
24.     public static void main(String args\[\])\{  
25.         for(Color c:Color.values())\{  
26.             System.out.print(c.getColor() + "、");  
27.         \}  
28.     \}  
29. \}

运行结果：

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  红色、绿色、蓝色、

\*\*\*\*\*枚举类在实现一个接口之后，就必须对枚举类中的每个对象分别实现接口中的抽象方法\*\*\*\*\*

## 14.7 枚举类定义抽象方法 ##

枚举类除了可以实现接口之外（每个枚举对象都必须分别实现接口中的抽象方法）， 还可以在枚举类中定义抽象方法，这样每个枚举的对象只要分别实现了抽象方法即可。

范例： 在枚举类中定义抽象方法

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  enum Color\{  
2.      RED\{  
3.          public String getColor()\{  
4.              return "红色";  
5.          \}  
6.      \},  
7.      GREEN\{  
8.          public String getColor()\{  
9.              return "绿色";  
10.         \}  
11.     \},  
12.     BLUE\{  
13.         public String getColor()\{  
14.             return "蓝色";  
15.         \}  
16.     \};  
17.     public abstract String getColor();  
18. \}  
19.   
20. public class AbstractEnumDemo\{  
21.     public static void main(String args\[\])\{  
22.         for(Color c:Color.values())\{  
23.             System.out.print(c.getColor() + "、");  
24.         \}  
25.     \}  
26. \}

运行结果：

**\[java\]** [ view plain][view plain] [ copy][view plain]

1.  红色、绿色、蓝色、

**追问： 此时枚举类Color为什么可以不用abstract关键字来修饰呢？？？？？？？？？？？？？**

## 14.8 本章要点 ##

1.  **在程序中可以使一个枚举来指定对象的取值范围**
2.  **在Java中使用enum关键字定义一个枚举类， 每个枚举类都是继承Enum类**
3.  **在枚举中可以通过values()方法取得枚举中的全部内容**
4.  **在枚举类中可以定义构造方法，但是在设置枚举范围时必须显式地调用构造方法**
5.  **所有的枚举类都可以直接使用Comparable进行排序，因为Enum类实现了Comparable接口**
6.  **Java类集中提供了枚举的支持类EnumMap、EnumSet两个类** 
7.  **一个枚举类可以实现一个接口或在类中定义抽象方法；但是，每个枚举对象都必须分别实现全部的抽象方法**

## 14.9 习题 ##

1.  定义一个品牌电脑的枚举类，其中只有固定的几个电脑品牌
2.  定义一个Person类，其中包含姓名、年龄、生日、性别的属性，其中性别只能是“男”或“女”

## 14.10 参考资料    ##

1.  Java枚举类型enum的使用：  [ http://blog.csdn.net/wgw335363240/article/details/6359614][http_blog.csdn.net_wgw335363240_article_details_6359614]
2.  JAVA枚举类型 ：  [ http://www.cnblogs.com/Fskjb/archive/2009/08/03/1537917.html][http_www.cnblogs.com_Fskjb_archive_2009_08_03_1537917.html]
3.  详细介绍java中的枚举类型： [ http://developer.51cto.com/art/201107/275031.htm][http_developer.51cto.com_art_201107_275031.htm]
4.  java枚举类型入门： [ http://developer.51cto.com/art/201106/266503.htm][http_developer.51cto.com_art_201106_266503.htm]

[![3_zxl2016.jpg][] ][3_zxl2016.jpg_]

### 相关文章推荐 ###

## [Java 带有抽象方法的枚举类][Java] ##

public class Demo\{public static void main(String\[\] args)\{System.out.println(Grade.A.getValue...

*  [![u010078400][]][u010078400 1]
 *  [u010078400][u010078400 1]
 *  2014年05月29日 15:20
 *  1459

## [对LevelDB的“升级版”存储引擎RocksDB的调研成果][LevelDB_RocksDB] ##

Google的leveldb是个很优秀的存储引擎，但还是有一些不尽人意的地方，比如leveldb不支持多线程合并，对key范围查找的支持还很简单，未做优化措施，等等。而Facebook的RocksDB...

*  [![lanxuezaipiao][]][lanxuezaipiao 1]
 *  [lanxuezaipiao][lanxuezaipiao 1]
 *  2014年07月28日 13:51
 *  12268

![0f000D9ndibo5sRkQlDgGs.jpg][] ![Image 1][]

## 做了这件事后，这位程序员月薪从15k变身30k！ ##

闲下来的时候，程序员为了个人成长，和培养核心价值，该怎么规划和学习呢...

## [java中的实现接口和含有抽象方法的枚举类][java] ##

含有抽象方法的枚举类型：public enum Operator \{/\*PLUS , MINUS , TIMES , DIVIDE;double eval(double x , dou...

*  [![rylq56m9][]][rylq56m9 1]
 *  [rylq56m9][rylq56m9 1]
 *  2013年07月23日 19:44
 *  564

## [JDK5.0新特性：枚举类型enum、枚举集合EnumSet、枚举映射EnumMap][JDK5.0_enum_EnumSet_EnumMap] ##

java.lang.Object java.lang.Enum一、枚举特性：1、枚举类型enum和类class、接口interface的级别是一样的，关键字enum；2、定义的每个枚举类型...

*  [![lpp1234567][]][lpp1234567 1]
 *  [lpp1234567][lpp1234567 1]
 *  2014年03月11日 16:44
 *  379

## [【Java学习笔记】接口 抽象类 抽象方法][Java_ _] ##

一 接口1.不允许多重继承类，可以多重继承接口，继承的多个接口之间用逗号分开。2.接口中定义的常量默认为public, static,and final 。定义的方法都默认是public的...

*  [![qingtian12138][]][qingtian12138 1]
 *  [qingtian12138][qingtian12138 1]
 *  2017年03月09日 14:20
 *  87

![0f0000I31l-9etjhMNwGLf.jpg][] ![Image 1][]

## 程序员跨越式成长指南 ##

完成第一次跨越，你会成为具有一技之长的开发者，月薪可能翻上几番； 完成第二次跨越，你将成为拥有局部优势或行业优势的专业人士，获得个人内在价值的有效提升和外在收入的大幅跃迁……

## [Java中的枚举——EnumMap与EnumSet][Java_EnumMap_EnumSet] ##

为了更好的支持枚举类型，java.util中添加了两个新类：EnumMap和EnumSet。使用它们可以更高效的操作枚举类型。下面我一一介绍给你：    EnumMap是专门为枚举类型量身定做的M...

*  [![u012927198][]][u012927198 1]
 *  [u012927198][u012927198 1]
 *  2015年04月10日 14:09
 *  1005

## [说说Java中的枚举——EnumMap与EnumSet][Java_EnumMap_EnumSet 1] ##

*  [![weidawei0609][]][weidawei0609 1]
 *  [weidawei0609][weidawei0609 1]
 *  2012年03月02日 09:56
 *  697

## [java基础加强--实现带有抽象方法的枚举][java_--] ##

在学枚举的时候，看到这样定义枚举感到很奇怪。public enum WeekDay \{SUN,MON,TUE,WED,THI,FRI,SAT\}感觉像一个类，但又不是类。。想...

*  [![congwiny][]][congwiny 1]
 *  [congwiny][congwiny 1]
 *  2014年02月01日 18:04
 *  2354

## [java包 + 接口的定义与实现接口抽象方法 + 并发视频][java_ _ _ _] ##

1.包的概念包（package）是Java提供的一种区别类的名字空间的机制，是类的组织方式，是一组相关类和接口的集合，它提供了访问权限和命名的管理机制。Java中提供的包主要有以下3种用途:...

*  [![u013321328][]][u013321328 1]
 *  [u013321328][u013321328 1]
 *  2015年01月10日 09:52
 *  767

## [Java中接口的定义与实现接口抽象方法][Java 1] ##

//如果抽象类的类体里的方法全部都是抽象方法,可以把这个类定义为接口//换言之,类体里全部都是抽象方法,可以把这个类定义为接口.interface Runer//接口的定义,接口里只包含常量和抽象...

*  [![StellaAh][]][StellaAh 1]
 *  [StellaAh][StellaAh 1]
 *  2011年08月26日 11:41
 *  22723

## [【枚举】\_类集对Enum的支持笔记][Enum] ##

【枚举】\_类集对Enum的支持笔记分类： Java【枚举】\_类集对Enum的支持笔记本章目标：掌握EnumMap类的使用掌握EnumSet类的使用3、具...

*  [![geili\_178][geili_178]][geili_178_geili_178]
 *  [geili\_178][geili_178_geili_178]
 *  2014年10月01日 23:40
 *  184

## [Java enum enumset enummap的详解（记性不好就多动笔）][Java enum enumset enummap] ##

文章出处：http://www.cnblogs.com/happyPawpaw/archive/2013/04/09/3009553.htmlJava enum的用法详解...

*  [![firefoxwyw][]][firefoxwyw 1]
 *  [firefoxwyw][firefoxwyw 1]
 *  2015年07月23日 11:14
 *  260

## [熟练使用java的Enum、EnumSet、EnumMap][java_Enum_EnumSet_EnumMap] ##

对java枚举一直没有系统学习过，之前就是用枚举来替代接口中的常量，今天看到同事写的一段代码使用了EnumSet，不是特别熟悉。于是重新学习了Enum、EnumSet、EnumMap。...

*  [![aitangyong][]][aitangyong 1]
 *  [aitangyong][aitangyong 1]
 *  2017年02月06日 19:56
 *  628

## [JAVA 8新特性 允许接口定义非抽象方法 快速入门案例][JAVA 8_ _] ##

JavaSE8.0出来也蛮久了网上也蛮多案例和教程 但大多数都写的比较复杂  而且更新的新特性也不是很齐全。本案例是根据甲骨文官方的Demo进行修改的授人以鱼不如授人以渔，学习方式其...

*  [![austral][]][austral 1]
 *  [austral][austral 1]
 *  2016年11月29日 23:51
 *  846

## [java学习笔记7--抽象类与抽象方法][java_7--] ##

接着前面的学习:java学习笔记6--类的继承、Object类java学习笔记5--类的方法 java学习笔记4--类与对象的基本概念（2）java学习笔记3--类与对象的基本概念（1...

*  [![GarfieldEr007][]][GarfieldEr007 1]
 *  [GarfieldEr007][GarfieldEr007 1]
 *  2016年03月21日 21:45
 *  414

## [java学习笔记7--抽象类与抽象方法][java_7-- 1] ##

原作链接 作者：archimedes1、终结类与终结方法被final修饰符修饰的类和方法，终结类不能被继承，终结方法不能被当前类的子类重写终结类的特点:不能有派生类终结类存在的理由:...

*  [![u012491166][]][u012491166 1]
 *  [u012491166][u012491166 1]
 *  2014年12月10日 09:12
 *  433

## [java学习笔记之 --------枚举（enum）][java_ --------_enum] ##

enum枚举类型是JAVA SE 5.0 以后的版本新定义出来的， 在此版本之前，有个常用的方法来做枚举类，  这个是视频中学到的。。。class WeekDay\{public stat...

*  [![yzldw333][]][yzldw333 1]
 *  [yzldw333][yzldw333 1]
 *  2013年03月14日 17:45
 *  1891

## [java学习笔记之枚举类enum（转载）][java_enum] ##

原文链接：http://www.cnblogs.com/hemingwang0902/archive/2011/12/29/2306263.htmljava enum(枚举)使用详解 + 总结enu...

*  [![tjkj10][]][tjkj10 1]
 *  [tjkj10][tjkj10 1]
 *  2016年02月12日 00:34
 *  190

[![unkonw.svg][]][unkonw.svg 1]

## [java xxcy\\day01\\重点笔记\\抽象方法.java][unkonw.svg 1] ##

*  2013年12月31日 22:37
 *  3KB
 *  [下载][unkonw.svg 1]

## [java之枚举类 Enum学习笔记][java_ Enum] ##

某些情况下，一个类的对象是有限并且固定的，比如季节类，只有四个对象。这种实例有限并且固定的类，为枚举类。如何手动实现一个枚举类？规则如下：     （1）通过private将构...

*  [![Genius\_zz][Genius_zz]][Genius_zz_Genius_zz]
 *  [Genius\_zz][Genius_zz_Genius_zz]
 *  2016年09月26日 15:57
 *  288

## [抽象方法模式--认真学习笔记][--] ##

案例分析：随着社会的不断发展，制造商品的工厂也越来越多，虽然ji

*  [![u012427937][]][u012427937 1]
 *  [u012427937][u012427937 1]
 *  2014年06月27日 08:00
 *  262

## [13. Java类集 Part 2(Map接口、SortedMap接口、集合工具类Collection、Stack类、属性类Properties) ----- 学习笔记][13. Java_ Part 2_Map_SortedMap_Collection_Stack_Properties_ -----] ##

13.7  Map接口      13.7.1

*  [![forfan06][]][forfan06 1]
 *  [forfan06][forfan06 1]
 *  2014年08月18日 16:25
 *  1135

## [枚举 \_类集对Enum的支持][_Enum] ##

1、掌握 EnumMap 类的使用2、掌握 EnumSet 类的使用1、EmumMpapublic class EnumMapEnum,V>extends AbstractMa...

*  [![hanshileiai][]][hanshileiai 1]
 *  [hanshileiai][hanshileiai 1]
 *  2011年09月14日 18:58
 *  736

## [C++学习笔记4－－静态属性 静态方法 虚方法 抽象方法 多态性 析构函数 运算符重载 多继承 虚继承][C_4_ _ _ _ _ _ _ _] ##

静态属性和静态方法

*  [![yglskfjmp][]][yglskfjmp 1]
 *  [yglskfjmp][yglskfjmp 1]
 *  2014年06月02日 18:58
 *  357

[![zip.svg][]][zip.svg 1]

## [java 使用抽象方法实现的支票夹][zip.svg 1] ##

*  2010年06月21日 14:45
 *  60KB
 *  [下载][zip.svg 1]

## [黑马程序员——枚举的原理及枚举构造方法调用，抽象方法实现等等介绍][Link 3] ##

\----------------------    android培训    java培训   期待与您交流！    ----------------------               ...

*  [![wjw\_java][wjw_java]][wjw_java_wjw_java]
 *  [wjw\_java][wjw_java_wjw_java]
 *  2012年09月14日 00:55
 *  673

## [【幻化万千戏红尘】qianfengDay09-java基础学习：接口，抽象类，抽象方法，多态，instanceof][qianfengDay09-java_instanceof] ##

课程回顾： 访问修饰符private--->default--->protected---->public 重写：子类中1、访问修饰符不能比父类的更严格2、静态/非静态、返回值类型、方法...

*  [![u013742672][]][u013742672 1]
 *  [u013742672][u013742672 1]
 *  2016年07月21日 17:12
 *  171

## [JDK1.5新特性之枚举中的构造函数及抽象方法][JDK1.5] ##

事实上，enum声明定义的类型就是yiegele

*  [![lzm1340458776][]][lzm1340458776 1]
 *  [lzm1340458776][lzm1340458776 1]
 *  2014年05月09日 20:19
 *  543

## [黑马程序员-我的入学笔记5-类的补充(抽象方法和接口)][-_5-] ##

\---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ---------------------- 看了抽象方法和接口的基础,只...

*  [![u011770456][]][u011770456 1]
 *  [u011770456][u011770456 1]
 *  2013年09月19日 03:38
 *  409

[![doc.svg][]][doc.svg 1]

## [C\#期末总复习 C\#语言基础和程序结构 数据类型：数组、结构和枚举 运算符、表达式和结构化程序 类的构造方法，继承，接口和抽象类 委托与事件 WindowsForm应用程序 XML操作等][doc.svg 1] ##

*  2010年07月26日 11:45
 *  409KB
 *  [下载][doc.svg 1]

## [JAVA进阶之旅（一）——增强for循环，基本数据类型的自动拆箱与装箱，享元设计模式,枚举的概述，枚举的应用，枚举的构造方法，枚举的抽象方法][JAVA_for] ##

JAVA进阶之旅（一）——增强for循环，基本数据类型的自动拆箱与装箱，享元设计模式,枚举的概述，枚举的应用，枚举的构造方法，枚举的抽象方法 学完我们的java之旅，其实收获还是很多的，但是依然还...

*  [![qq\_26787115][qq_26787115]][qq_26787115_qq_26787115]
 *  [qq\_26787115][qq_26787115_qq_26787115]
 *  2016年09月25日 18:32
 *  1410

## [Enum、EnumMap、EnumSet的用法讲解][Enum_EnumMap_EnumSet] ##

今天在工作中遇到这样一个问题，要在前台页面上渲染出来所有的枚举元素，但是前台页面用的是Velocity，所以需要把枚举元素放到Map里，然后在前台进行渲染。这里不能一个一个的取出枚举元素来put的，就...

*  [![zknxx][]][zknxx 1]
 *  [zknxx][zknxx 1]
 *  2016年07月11日 23:47
 *  7498

## [在Ubuntu为Android硬件抽象层（HAL）模块编写JNI方法提供Java访问硬件服务接口（老罗学习笔记4）][Ubuntu_Android_HAL_JNI_Java_4] ##

在Ubuntu为Android硬件抽象层（HAL）模块编写JNI方法提供Java访问硬件服务接口（老罗学习笔记）...

*  [![CPJ\_phone][CPJ_phone]][CPJ_phone_CPJ_phone]
 *  [CPJ\_phone][CPJ_phone_CPJ_phone]
 *  2015年04月14日 11:23
 *  938

## [python3学习笔记:枚举enum][python3_enum] ##

1. 枚举的定义首先，定义枚举要导入enum模块。枚举定义用class关键字，继承Enum类。用于定义枚举的class和定义类的class是有区别【下一篇博文继续分享】。　　示例代码:from e...

*  [![xionghuixionghui][]][xionghuixionghui 1]
 *  [xionghuixionghui][xionghuixionghui 1]
 *  2017年03月26日 16:33
 *  1857

[![docx.svg][]][docx.svg 1]

## [java enum 枚举 学习资料][docx.svg 1] ##

*  2013年05月13日 11:28
 *  27KB
 *  [下载][docx.svg 1]

## [JAVA学习笔记13：IO&类集][JAVA_13_IO] ##

完成一个学生管理程序，使用学号作为键添加5个学生对象，并可以将全部的信息保存在文件中，可以实现对学生信息的学号查找、输出全部学生信息的功能。...

*  [![zengqingmei][]][zengqingmei 1]
 *  [zengqingmei][zengqingmei 1]
 *  2016年08月28日 04:26
 *  356

## [Java抽象类和抽象方法、接口][Java 2] ##

一、抽象类、抽象方法1、抽象类抽象方法就是以abstract修饰的方法，这种方法只声明返回的数据类型、方法名称和参数，没有方法体，也就是说抽象方法只需要声明而不需要实现。 1. 被abstract...

*  [![dudu\_rong][dudu_rong]][dudu_rong_dudu_rong]
 *  [dudu\_rong][dudu_rong_dudu_rong]
 *  2017年03月26日 12:34
 *  293

## [JAVA 抽象类 抽象方法 接口][JAVA _ _] ##

抽象类不应该被实例化的类，不能被new出来，有一种抽象的意义例：Animal-->bird--->nightinggaleAnimal类如果被初始化是什么样子的？没有意义于...

*  [![wangxiaojingo][]][wangxiaojingo 1]
 *  [wangxiaojingo][wangxiaojingo 1]
 *  2013年05月14日 18:48
 *  575

## [随堂笔记7.29：对象，接口，构造方法，引用数据类型，抽象类，抽象方法-------1][7.29_-------1] ##

1创建对象//创建对象，会调用构造方法 //类中如果没有声明构造方法时会默认生成无参构造方法。2.构造方法//初始化类当中的所有属性 //未赋值的属性为默认值，引用对象为null，bolean为f...

*  [![sinat\_35541927][sinat_35541927]][sinat_35541927_sinat_35541927]
 *  [sinat\_35541927][sinat_35541927_sinat_35541927]
 *  2016年07月29日 20:00
 *  154

## [java(8)类集/枚举][java_8] ##

JAVA类集1.认识类集类集的作用类集实际上就是一个动态的对象数组，与一般的对象数组不同，类集中的对象内容可以任意扩充类集的特征这种框架是高性能的框架必须允许不同类型的...

*  [![zhangzh000][]][zhangzh000 1]
 *  [zhangzh000][zhangzh000 1]
 *  2015年02月26日 23:02
 *  1495

## [抽象类、抽象方法、接口的区别及实现][Link 4] ##

一、抽象类、抽象方法抽象方法：类的成员方法，只有声明，没有实现，把实现交给子类。抽象类：含有抽象方法的类。1.有抽象方法的类一定是抽象类，但抽象类里可以没有抽象方法（当然也...

*  [![aionbo][]][aionbo 1]
 *  [aionbo][aionbo 1]
 *  2016年10月17日 11:49
 *  676

[![doc.svg][]][doc.svg 2]

## [使用抽象方法实现多态][doc.svg 2] ##

*  2009年04月22日 17:02
 *  66KB
 *  [下载][doc.svg 2]

[![unkonw.svg][]][unkonw.svg 2]

## [继承类实现抽象方法雇员资料管理][unkonw.svg 2] ##

*  2009年12月08日 21:45
 *  11KB
 *  [下载][unkonw.svg 2]

## [Java学习系列(五)Java面向对象之抽象类、接口、内部类、枚举类详解][Java_Java] ##

抽象类、接口常常与设计模式紧密相连。掌握抽象类、接口等其实很简单。下面以说明+实例的方式来讲，这样更容易理解。抽象类先看一个关键字“abstract”，我们知道它是抽象的意思。所谓抽象...

*  [![xuxu198899223][]][xuxu198899223 1]
 *  [xuxu198899223][xuxu198899223 1]
 *  2014年04月25日 11:17
 *  483

## [Java学习系列(五)Java面向对象之抽象类、接口、内部类、枚举类详解][Java_Java 1] ##

抽象类、接口常常与设计模式紧密相连。掌握抽象类、接口等其实很简单。下面以说明+实例的方式来讲，这样更容易理解。抽象类先看一个关键字“abstract”，我们知道它是抽象的意思。所谓抽象，说的直白一...

*  [![JAVE\_LOVER][JAVE_LOVER]][JAVE_LOVER_JAVE_LOVER]
 *  [JAVE\_LOVER][JAVE_LOVER_JAVE_LOVER]
 *  2013年09月24日 16:00
 *  2151

## [【Java类集】\_Map接口笔记（实例亲测）][Java_Map] ##

【Java类集】\_Map接口笔记掌握Map接口与Collection接口不同掌握Map与Map.Entry接口的关系掌握Map接口的常用子类：HashMap、HashTable、Tre...

*  [![e421083458][]][e421083458 1]
 *  [e421083458][e421083458 1]
 *  2013年01月25日 16:14
 *  2360

[![txt.svg][]][txt.svg 1]

## [mybatis Enum自定义EnumTypeHandler(自定义枚举处理器)][txt.svg 1] ##

*  2013年06月24日 19:06
 *  6KB
 *  [下载][txt.svg 1]

[![unkonw.svg][]][unkonw.svg 3]

## [enum枚举的方法][unkonw.svg 3] ##

*  2015年03月16日 21:41
 *  723B
 *  [下载][unkonw.svg 3]

## [java 几种常用的枚举(Enum)方法][java _Enum] ##

最近枚举类型用的比较频繁DK1.5引入了新的类型——枚举。在Java中它虽然算个“小”功能，却给我的开发带来了“大”方便。用法一：常量在JDK1.5之前，我们定义常量都是：...

*  [![oypj2010][]][oypj2010 1]
 *  [oypj2010][oypj2010 1]
 *  2012年08月30日 15:28
 *  8702

## [java枚举类Enum方法简介(valueof,value,ordinal)][java_Enum_valueof_value_ordinal] ##

Enum作为Sun全新引进的一个关键字，看起来很象是特殊的class,   它也可以有自己的变量，可以定义自己的方法，可以实现一个或者多个接口。   当我们在声明一个enum类型时，我们应该注意到en...

*  [![congqingbin][]][congqingbin 1]
 *  [congqingbin][congqingbin 1]
 *  2012年04月28日 14:42
 *  67903

[![unkonw.svg][]][unkonw.svg 4]

## [java Enum EnumMap 简单例子][unkonw.svg 4] ##

*  2014年08月15日 10:25
 *  1KB
 *  [下载][unkonw.svg 4]

## [java学习笔记8——抽象类和接口][java_8 1] ##

对于java这种面向对象的编程语言来说，抽象是他的特点。接下来通过两种形式来体现java的oop（Object Oriented Programming）：抽象类和接口。...

*  [![u010935199][]][u010935199 1]
 *  [u010935199][u010935199 1]
 *  2017年04月07日 15:58
 *  226

## [【学习笔记】Java抽象类和接口的一些总结][Java 3] ##

今天重温了一遍Java抽象类和接口的一些知识，在这里总结一下，如有不足望指出。...

*  [![ricardo\_][ricardo]][ricardo_ricardo]
 *  [ricardo\_][ricardo_ricardo]
 *  2016年03月25日 15:22
 *  173

[enum]: http://so.csdn.net/so/search/s.do?q=enum&t=blog
[Link 1]: http://so.csdn.net/so/search/s.do?q=枚举&t=blog
[Link 2]: http://so.csdn.net/so/search/s.do?q=基础知识&t=blog
[view plain]: http://blog.csdn.net/forfan06/article/details/38847777#
[Center]: /images/20220603/b4bd87b418a04fffab577a01f95d688d.png
[Center 1]: /images/20220603/9ab075ad12824d0a9c353e611a5b1dd4.png
[http_blog.csdn.net_wgw335363240_article_details_6359614]: http://blog.csdn.net/wgw335363240/article/details/6359614
[http_www.cnblogs.com_Fskjb_archive_2009_08_03_1537917.html]: http://www.cnblogs.com/Fskjb/archive/2009/08/03/1537917.html
[http_developer.51cto.com_art_201107_275031.htm]: http://developer.51cto.com/art/201107/275031.htm
[http_developer.51cto.com_art_201106_266503.htm]: http://developer.51cto.com/art/201106/266503.htm
[3_zxl2016.jpg]: /images/20220603/840abdc3ccce4eeaa5b0d6ebe1b494f4.png
[3_zxl2016.jpg_]: http://my.csdn.net/zxl2016
[Java]: http://blog.csdn.net/u010078400/article/details/27533953
[u010078400]: /images/20220603/9568a028d399401d9e74231f2c6daf29.png
[u010078400 1]: http://blog.csdn.net/u010078400
[LevelDB_RocksDB]: http://blog.csdn.net/lanxuezaipiao/article/details/38228237
[lanxuezaipiao]: /images/20220603/a45c16fa8189418780deda2a12ab700b.png
[lanxuezaipiao 1]: http://blog.csdn.net/lanxuezaipiao
[0f000D9ndibo5sRkQlDgGs.jpg]: http://ubmcmm.baidustatic.com/media/v1/0f000D9ndibo5sRkQlDgGs.jpg
[Image 1]: 
[java]: http://blog.csdn.net/rylq56m9/article/details/9427343
[rylq56m9]: /images/20220603/038edc4d936b40858364030f89f398c8.png
[rylq56m9 1]: http://blog.csdn.net/rylq56m9
[JDK5.0_enum_EnumSet_EnumMap]: http://blog.csdn.net/lpp1234567/article/details/21011697
[lpp1234567]: /images/20220603/5830e59ac6c04f29ba8970495786de62.png
[lpp1234567 1]: http://blog.csdn.net/lpp1234567
[Java_ _]: http://blog.csdn.net/qingtian12138/article/details/60959465
[qingtian12138]: /images/20220603/e582bc6f626a4e03ab39edc040591b82.png
[qingtian12138 1]: http://blog.csdn.net/qingtian12138
[0f0000I31l-9etjhMNwGLf.jpg]: http://ubmcmm.baidustatic.com/media/v1/0f0000I31l-9etjhMNwGLf.jpg
[Java_EnumMap_EnumSet]: http://blog.csdn.net/u012927198/article/details/44978821
[u012927198]: /images/20220603/828c965632324d2da092b579c7a8631c.png
[u012927198 1]: http://blog.csdn.net/u012927198
[Java_EnumMap_EnumSet 1]: http://blog.csdn.net/weidawei0609/article/details/7311335
[weidawei0609]: /images/20220603/4c91a32582414ebfa740a04f72b2c67d.png
[weidawei0609 1]: http://blog.csdn.net/weidawei0609
[java_--]: http://blog.csdn.net/congwiny/article/details/18894641
[congwiny]: /images/20220603/f3d908df59e849869be0a7af5cd4d8e3.png
[congwiny 1]: http://blog.csdn.net/congwiny
[java_ _ _ _]: http://blog.csdn.net/u013321328/article/details/42580953
[u013321328]: /images/20220603/32678bb588ec4b438570f1a479e8de89.png
[u013321328 1]: http://blog.csdn.net/u013321328
[Java 1]: http://blog.csdn.net/StellaAh/article/details/6721423
[StellaAh]: /images/20220603/3977d836fb1a486a9d71e50c8e6dff2c.png
[StellaAh 1]: http://blog.csdn.net/StellaAh
[Enum]: /images/20220603/0fb95f33d3104b90928b37bea37afd74.png/article/details/39724057
[geili_178]: http://avatar.csdn.net/9/E/D/3_geili_178.jpg
[geili_178_geili_178]: /images/20220603/0fb95f33d3104b90928b37bea37afd74.png
[Java enum enumset enummap]: http://blog.csdn.net/firefoxwyw/article/details/47019209
[firefoxwyw]: /images/20220603/14d97ee92bf2417db69e012e981a57b8.png
[firefoxwyw 1]: http://blog.csdn.net/firefoxwyw
[java_Enum_EnumSet_EnumMap]: http://blog.csdn.net/aitangyong/article/details/54896269
[aitangyong]: /images/20220603/4386e79f8a73467f9d9076a5c89d2cdd.png
[aitangyong 1]: http://blog.csdn.net/aitangyong
[JAVA 8_ _]: http://blog.csdn.net/austral/article/details/53402476
[austral]: /images/20220603/34553e76f79d4bfaadf03e370f03819b.png
[austral 1]: http://blog.csdn.net/austral
[java_7--]: http://blog.csdn.net/GarfieldEr007/article/details/50950563
[GarfieldEr007]: /images/20220603/56bbc6f47db644d19076989c57ee8fe0.png
[GarfieldEr007 1]: http://blog.csdn.net/GarfieldEr007
[java_7-- 1]: http://blog.csdn.net/u012491166/article/details/41842129
[u012491166]: /images/20220603/49d1f17bcdd643549dc6d8e5c6341adc.png
[u012491166 1]: http://blog.csdn.net/u012491166
[java_ --------_enum]: http://blog.csdn.net/yzldw333/article/details/8672547
[yzldw333]: /images/20220603/9fa0588625d74668b37547e8923de75d.png
[yzldw333 1]: http://blog.csdn.net/yzldw333
[java_enum]: http://blog.csdn.net/tjkj10/article/details/50652654
[tjkj10]: /images/20220603/af6f7ac827a94fd6a2923171e9643256.png
[tjkj10 1]: http://blog.csdn.net/tjkj10
[unkonw.svg]: /images/20220603/73ed7cc82510411b92ff39e929ea9d83.png
[unkonw.svg 1]: http://download.csdn.net/download/u013345699/6794383
[java_ Enum]: /images/20220603/6cd94eba732f478cafd3eabf8c8ec8c7.png/article/details/52671061
[Genius_zz]: http://avatar.csdn.net/0/8/C/3_genius_zz.jpg
[Genius_zz_Genius_zz]: /images/20220603/6cd94eba732f478cafd3eabf8c8ec8c7.png
[--]: http://blog.csdn.net/u012427937/article/details/35198025
[u012427937]: /images/20220603/6de48d7c0203485db8a19ac186b8e1e7.png
[u012427937 1]: http://blog.csdn.net/u012427937
[13. Java_ Part 2_Map_SortedMap_Collection_Stack_Properties_ -----]: http://blog.csdn.net/forfan06/article/details/38662343
[forfan06]: /images/20220603/30aa6fd3a9fc436a846a5bd1a12a2660.png
[forfan06 1]: http://blog.csdn.net/forfan06
[_Enum]: http://blog.csdn.net/hanshileiai/article/details/6775412
[hanshileiai]: /images/20220603/ad2fdfe3fe264ac78e2d5e73d7e31af3.png
[hanshileiai 1]: http://blog.csdn.net/hanshileiai
[C_4_ _ _ _ _ _ _ _]: http://blog.csdn.net/yglskfjmp/article/details/28122791
[yglskfjmp]: /images/20220603/3f4038d7e55a4a2686b9a2dcbd1c3ca9.png
[yglskfjmp 1]: http://blog.csdn.net/yglskfjmp
[zip.svg]: /images/20220603/e8069a25e236463985521b1627805605.png
[zip.svg 1]: http://download.csdn.net/download/runxia66/2471753
[Link 3]: /images/20220603/17b6a07fba374eb9b4ff0379b3b9c9eb.png/article/details/7977253
[wjw_java]: http://avatar.csdn.net/C/8/9/3_wjw_java.jpg
[wjw_java_wjw_java]: /images/20220603/17b6a07fba374eb9b4ff0379b3b9c9eb.png
[qianfengDay09-java_instanceof]: http://blog.csdn.net/u013742672/article/details/51984745
[u013742672]: /images/20220603/880541ccd8f84199806251d454eaf01f.png
[u013742672 1]: http://blog.csdn.net/u013742672
[JDK1.5]: http://blog.csdn.net/lzm1340458776/article/details/25423371
[lzm1340458776]: /images/20220603/4f25d4ecb18648659b159fe19f7ee402.png
[lzm1340458776 1]: http://blog.csdn.net/lzm1340458776
[-_5-]: http://blog.csdn.net/u011770456/article/details/11824177
[u011770456]: /images/20220603/edd8eadd94a44e52b8d6cdfdd758c3fa.png
[u011770456 1]: http://blog.csdn.net/u011770456
[doc.svg]: /images/20220603/5fb0227c0d3a40fd82cc14c333405ae4.png
[doc.svg 1]: http://download.csdn.net/download/bubble0531/2573895
[JAVA_for]: /images/20220603/635f108a208d4b448f89ecbc9cfcfdad.png/article/details/52663429
[qq_26787115]: http://avatar.csdn.net/D/1/8/3_qq_26787115.jpg
[qq_26787115_qq_26787115]: /images/20220603/635f108a208d4b448f89ecbc9cfcfdad.png
[Enum_EnumMap_EnumSet]: http://blog.csdn.net/zknxx/article/details/51884536
[zknxx]: /images/20220603/9126ff0d116b4f24995f7aa286dd64d2.png
[zknxx 1]: http://blog.csdn.net/zknxx
[Ubuntu_Android_HAL_JNI_Java_4]: /images/20220603/0b6d3179929045e69d3faeeae5769730.png/article/details/45039583
[CPJ_phone]: http://avatar.csdn.net/8/8/9/3_cpj_phone.jpg
[CPJ_phone_CPJ_phone]: /images/20220603/0b6d3179929045e69d3faeeae5769730.png
[python3_enum]: http://blog.csdn.net/xionghuixionghui/article/details/66476601
[xionghuixionghui]: /images/20220603/7a32d9a597174814b2ff1c52fa200f12.png
[xionghuixionghui 1]: http://blog.csdn.net/xionghuixionghui
[docx.svg]: /images/20220603/5e90eb666d7c4b08ade59999b9d8f266.png
[docx.svg 1]: http://download.csdn.net/download/gu_ao/5366105
[JAVA_13_IO]: http://blog.csdn.net/zengqingmei/article/details/52343431
[zengqingmei]: /images/20220603/00a224031a24470d8edad85f64f23431.png
[zengqingmei 1]: http://blog.csdn.net/zengqingmei
[Java 2]: /images/20220603/6f7f1395ce894b7187dcb77b028f952e.png/article/details/66473477
[dudu_rong]: http://avatar.csdn.net/0/F/9/3_dudu_rong.jpg
[dudu_rong_dudu_rong]: /images/20220603/6f7f1395ce894b7187dcb77b028f952e.png
[JAVA _ _]: http://blog.csdn.net/wangxiaojingo/article/details/8927145
[wangxiaojingo]: /images/20220603/d09f68e27d49424cb199081e036f17a2.png
[wangxiaojingo 1]: http://blog.csdn.net/wangxiaojingo
[7.29_-------1]: /images/20220603/1583214a72e648f18cd30f63db418a23.png/article/details/52068206
[sinat_35541927]: http://avatar.csdn.net/3/8/3/3_sinat_35541927.jpg
[sinat_35541927_sinat_35541927]: /images/20220603/1583214a72e648f18cd30f63db418a23.png
[java_8]: http://blog.csdn.net/zhangzh000/article/details/43957727
[zhangzh000]: /images/20220603/568d3f7566a74bb08fe3be19eb0dff37.png
[zhangzh000 1]: http://blog.csdn.net/zhangzh000
[Link 4]: http://blog.csdn.net/aionbo/article/details/52837528
[aionbo]: /images/20220603/1fa97692fa794962990c387ed9914876.png
[aionbo 1]: http://blog.csdn.net/aionbo
[doc.svg 2]: http://download.csdn.net/download/malin_yanan/1237045
[unkonw.svg 2]: http://download.csdn.net/download/lisan314/1884515
[Java_Java]: http://blog.csdn.net/xuxu198899223/article/details/24460907
[xuxu198899223]: /images/20220603/7ea4a7d05d544b60a3ce2ac93e1a959f.png
[xuxu198899223 1]: http://blog.csdn.net/xuxu198899223
[Java_Java 1]: /images/20220603/91f6e52a293c4128b1d2f517f287efe1.png/article/details/11971455
[JAVE_LOVER]: http://avatar.csdn.net/8/F/3/3_jave_lover.jpg
[JAVE_LOVER_JAVE_LOVER]: /images/20220603/91f6e52a293c4128b1d2f517f287efe1.png
[Java_Map]: http://blog.csdn.net/e421083458/article/details/8542536
[e421083458]: /images/20220603/d34220b9eda241458f5e78bfe317cfbf.png
[e421083458 1]: http://blog.csdn.net/e421083458
[txt.svg]: /images/20220603/1faebd7b8d974676a0f61af6b9d47c7c.png
[txt.svg 1]: http://download.csdn.net/download/yaketony/5642633
[unkonw.svg 3]: http://download.csdn.net/download/u013387780/8506721
[java _Enum]: http://blog.csdn.net/oypj2010/article/details/7925451
[oypj2010]: /images/20220603/1e555e7d15d74f59a75ce94086621c56.png
[oypj2010 1]: http://blog.csdn.net/oypj2010
[java_Enum_valueof_value_ordinal]: http://blog.csdn.net/congqingbin/article/details/7520137
[congqingbin]: /images/20220603/f3d1341a81e74c3c8ba9d65d2dd9455d.png
[congqingbin 1]: http://blog.csdn.net/congqingbin
[unkonw.svg 4]: http://download.csdn.net/download/u013973109/7759061
[java_8 1]: http://blog.csdn.net/u010935199/article/details/69568245
[u010935199]: /images/20220603/850104789f004c66b37285833f994b89.png
[u010935199 1]: http://blog.csdn.net/u010935199
[Java 3]: /images/20220603/50d6f15903d242b692e69cb750811ef6.png/article/details/50980494
[ricardo]: http://avatar.csdn.net/C/E/6/3_ricardo_.jpg
[ricardo_ricardo]: /images/20220603/50d6f15903d242b692e69cb750811ef6.png