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

本章目标:

了解枚举可以解决哪些技术问题
掌握枚举的定义方式
清楚地掌握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之前完成枚举的功能，则必须依靠类似于以下的程序代码完成。

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

class Color{
public static final Color RED = new Color("Red");    //定义第一个对象
public static final Color GREEN = new Color("Green");   //定义第二个对象
public static final Color BLUE = new Color("Blue");     //定义第三个对象
private String name;
private Color(String name){
this.setName(name);
}
public String getName(){
return this.name;
}
public void setName(String name){
this.name = name;
}
public static Color getInstance(int i){  //等到一个颜色，只能从固定的几个颜色中取得中得
switch(i){
case 1:{
return RED;
}
case 2:{
return GREEN;
}
case 3:{
return BLUE;
}
default:{
return null;
}
}
}
}

public class ColorDemo01{
public static void main(String args[]){
Color c1 = Color.RED;
System.out.println(c1.getName());

Color c2 = Color.getInstance(3);
System.out.println(c2.getName());
}
}

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

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

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

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

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

package org.forfan06.colordemo;
public class ColorDemo02{
public static void main(String args[]){
System.out.println(Color.RED + Color.GREEN);
}
}

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

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

14.3 定义一个枚举类型

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

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

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

package org.forfan06.enumdemo;
public enum Color{
RED, GREEN, BLUE;
}

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

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

范例： 取出一个枚举内容

package org.forfan06.enumdemo;
enum Color{
RED, GREEN, BLUE;
}

public class GetEnumContent{
public static void main(String args[]){
Color c = Color.BLUE;
System.out.println(c);
}
}

运行结果：

BLUE

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

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

package org.forfan06.enumdemo;
enum Color{
RED, GREEN, BLUE;
}

public class PrintEnum{
public static void main(String args[]){
for(Color c:Color.values()){   // 枚举.values()表示得到全部枚举的内容
System.out.print(c + "、");   //输出结果： RED、GREEN、BLUE、
}
}
}

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

package org.forfan06.enumdemo;
enum Color{
RED, GREEN, BLUE;
}

public class SwithcPrintDemo{
public static void main(String args[]){
for(Color c:Color.values()){
print(c);
}
}

public static void print(Color color){
switch(color){
case RED:{
System.out.println("RED");
break;
}
case GREEN:{
System.out.println("GREEN");
break;
}
case BLUE:{
System.out.println("BLUE");
break;
}
default:{
System.out.println("Unknown");
break;
}
}
}
}

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

14.4 Enum

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

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

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

Enum类中包含的方法：



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

14.4.1 取得枚举的信息

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

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

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

package org.forfan06.enumdemo;
enum Color{
RED, GREEN, BLUE;
}

public class GetEnumInfo{
public static void main(String args[]){
for(Color c:Color.values()){
System.out.println(c.ordinal() + "--->" + c.name());
}
}
}

运行结果：

0--->RED
1--->GREEN
2--->BLUE

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

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

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

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

enum Color{
RED("红色"), GREEN("绿色"), BLUE("蓝色");
private Color(String name){
this.setName(name);
}
private String name;
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
}

public class ConstructorEnum{
public static void main(String args[]){
for(Color c:Color.values()){
System.out.println(c.ordinal() + "-->" + c.name() + "(" + c.getName() + ")");
}
}
}

运行结果：

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

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

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

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

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

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

package org.forfan06.enumapidemo;
enum Color{
RED, GREEN, BLUE;
/**
RED("红色"), GREEN("绿色"), BLUE("蓝色");
private Color(String name){
this.setName(name);
}
**/
private String name;
public String getName(){
return this.name;
}

public void setName(String name){
switch(this){
case RED:{    //判断是否为该颜色
if("红色".equals(name)){
this.name = name;      //设置名称
}else{
System.out.println("设置内容错误。");
}
break;
}
case GREEN:{    //判断是否为该颜色
if("绿色".equals(name)){
this.name = name;      //设置名称
}else{
System.out.println("设置内容错误。");
}
break;
}
case BLUE:{    //判断是否为该颜色
if("蓝色".equals(name)){
this.name = name;      //设置名称
}else{
System.out.println("设置内容错误。");
}
break;
}
}
}
/**
public void setName(String name){
this.name = name;
}
**/
}

public class SetEnum{
public static void main(String args[]){
Color c = Color.BLUE;
c.setName("兰色");  //设置错误的名字
c.setName("蓝色");  //设置正确的名字
System.out.println(c.getName());
/**
for(Color c:Color.values()){
System.out.println(c.ordinal() + "-->" + c.name() + "(" + c.getName() + ")");
}
**/
}
}

运行结果：

设置内容错误。
蓝色

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

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

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

package org.forfan06.enumapidemo;
enum Color{
RED, GREEN, BLUE;
/**
RED("红色"), GREEN("绿色"), BLUE("蓝色");
private Color(String name){
this.setName(name);
}
**/
private String name;
public String getName(){
return this.name;
}

public void setName(String name){
switch(this){
case RED:{    //判断是否为该颜色
if("红色".equals(name)){
this.name = name;      //设置名称
}else{
System.out.println("设置内容错误。");
}
break;
}
case GREEN:{    //判断是否为该颜色
if("绿色".equals(name)){
this.name = name;      //设置名称
}else{
System.out.println("设置内容错误。");
}
break;
}
case BLUE:{    //判断是否为该颜色
if("蓝色".equals(name)){
this.name = name;      //设置名称
}else{
System.out.println("设置内容错误。");
}
break;
}
}
}
/**
public void setName(String name){
this.name = name;
}
**/
}

public class ValueOfDemo{
public static void main(String args[]){
//Color c = Color.BLUE;
Color c = Enum.valueOf(Color.class, "BLUE");
c.setName("兰色");  //设置错误的名字
c.setName("蓝色");  //设置正确的名字
System.out.println(c.getName());
/**
for(Color c:Color.values()){
System.out.println(c.ordinal() + "-->" + c.name() + "(" + c.getName() + ")");
}
**/
}
}

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

14.4.3 使用比较器

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

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

范例： 验证枚举比较器

package org.forfan06.enumapidemo;
import java.util.Set;
import java.util.TreeSet;
import java.util.Iterator;
enum Color{
RED, GREEN, BLUE;
}

public class ComparableEnum{
public static void main(String args[]){
Set<Color> set = new TreeSet<Color>();
set.add(Color.GREEN);
set.add(Color.BLUE);
set.add(Color.RED);

Iterator<Color> iter = set.iterator();
while(iter.hasNext()){
System.out.print(iter.next() + "、");
}
}
}

运行结果：

RED、GREEN、BLUE、

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

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

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

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

14.5.1 EnumMap

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

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

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

范例：验证EnumMap

package org.forfan06.enumcol;
import java.util.EnumMap;
import java.util.Map;
enum Color{
RED, GREEN, BLUE;
}

public class EnumMapDemo{
public static void main(String args[]){
Map<Color, String> desc = null;
desc = new EnumMap<Color, String>(Color.class);
desc.put(Color.RED, "红色");
desc.put(Color.GREEN, "绿色");
desc.put(Color.BLUE, "蓝色");
System.out.println("=====输出全部的内容=====");
for(Color c:Color.values()){
System.out.println(c.name() + "-->" + desc.get(c));
}
System.out.println("=====输出全部的键值=====");
for(Color c:desc.keySet()){
System.out.print(c.name() + "、");
}
System.out.println("\n=====输出全部的内容=====");
for(String s:desc.values()){
System.out.print(s + "、");
}
}
}

运行结果：

=====输出全部的内容=====

RED-->红色
GREEN-->绿色
BLUE-->蓝色
=====输出全部的键值=====
RED、GREEN、BLUE、
=====输出全部的内容=====
红色、绿色、蓝色、

14.5.2 EnumSet

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



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

package org.forfan06.enumdemo;
import java.util.EnumSet;
enum Color{
RED, GREEN, BLUE;
}

public class EnumSetDemo01{
public static void main(String args[]){
EnumSet<Color> eset = null;
System.out.println("======EnumSet.allOf(Color.class)=====");
eset = EnumSet.allOf(Color.class);

print(eset);
}

public static void print(EnumSet<Color> temp){
for(Color c:temp){
System.out.print(c + "、");
}
System.out.println();
}
}

运行结果：

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

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

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

package org.forfan06.enumdemo;
import java.util.EnumSet;
enum Color{
RED, GREEN, BLUE;
}

public class EnumSetDemo02{
public static void main(String args[]){
EnumSet<Color> eset = null;
//System.out.println("======EnumSet.allOf(Color.class)=====");
//eset = EnumSet.allOf(Color.class);
System.out.println("======EnumSet.of(Color.class)=====");
eset = EnumSet.of(Color.BLUE);

print(eset);
}

public static void print(EnumSet<Color> temp){
for(Color c:temp){
System.out.print(c + "、");
}
System.out.println();
}
}

运行结果：

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

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

package org.forfan06.enumdemo;
import java.util.EnumSet;
enum Color{
RED, GREEN, BLUE;
}

public class EnumSetDemo03{
public static void main(String args[]){
EnumSet<Color> eset = null;
//System.out.println("======EnumSet.allOf(Color.class)=====");
//eset = EnumSet.allOf(Color.class);
//System.out.println("======EnumSet.of(Color.class)=====");
//eset = EnumSet.of(Color.BLUE);
System.out.println("======EnumSet.noneOf(Color.class)=====");
eset = EnumSet.noneOf(Color.class);

eset.add(Color.RED);
eset.add(Color.BLUE);

print(eset);
}

public static void print(EnumSet<Color> temp){
for(Color c:temp){
System.out.print(c + "、");
}
System.out.println();
}
}

运行结果：

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

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

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

package org.forfan06.enumdemo;
import java.util.EnumSet;
enum Color{
RED, GREEN, BLUE;
}

public class EnumSetDemo04_01{
public static void main(String args[]){
EnumSet<Color> esetOld = null;
EnumSet<Color> esetNew = null;
//System.out.println("======EnumSet.allOf(Color.class)=====");
//eset = EnumSet.allOf(Color.class);
//System.out.println("======EnumSet.of(Color.class)=====");
//eset = EnumSet.of(Color.BLUE);
esetOld = EnumSet.noneOf(Color.class); //可以加入Color类型的对象
esetOld.add(Color.RED);
esetOld.add(Color.BLUE);

esetNew = EnumSet.complementOf(esetOld);  //创建一个不包含指定元素的集合

System.out.println("======EnumSet.noneOf(Color.class)=====");
print(esetNew);
}

public static void print(EnumSet<Color> temp){
for(Color c:temp){
System.out.print(c + "、");
}
System.out.println();
}
}

运行结果：

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

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

package org.forfan06.enumdemo;
import java.util.EnumSet;
enum Color{
RED, GREEN, BLUE;
}

public class EnumSetDemo04_02{
public static void main(String args[]){
EnumSet<Color> esetOld = null;
EnumSet<Color> esetNew = null;
//System.out.println("======EnumSet.allOf(Color.class)=====");
//eset = EnumSet.allOf(Color.class);
//System.out.println("======EnumSet.of(Color.class)=====");
//eset = EnumSet.of(Color.BLUE);
esetOld = EnumSet.noneOf(Color.class); //可以加入Color类型的对象
esetNew = EnumSet.complementOf(esetOld);  //创建一个不包含指定元素的集合

esetOld.add(Color.RED);
esetOld.add(Color.BLUE);

System.out.println("======EnumSet.complementOf(Color.class)=====");
print(esetNew);
System.out.println("======EnumSet.noneOf(Color.class)=====");
print(esetOld);
}

public static void print(EnumSet<Color> temp){
for(Color c:temp){
System.out.print(c + "、");
}
System.out.println();
}
}

此时的运行结果：

======EnumSet.complementOf(Color.class)=====
RED、GREEN、BLUE、
======EnumSet.noneOf(Color.class)=====
RED、BLUE、

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

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

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

import java.util.EnumSet;
enum Color{
RED, GREEN, BLUE;
}

public class EnumSetDemo04_03{
public static void main(String args[]){
EnumSet<Color> esetOld = null;
EnumSet<Color> esetNew = null;
//System.out.println("======EnumSet.allOf(Color.class)=====");
//eset = EnumSet.allOf(Color.class);
//System.out.println("======EnumSet.of(Color.class)=====");
//eset = EnumSet.of(Color.BLUE);
esetOld = EnumSet.noneOf(Color.class); //可以加入Color类型的对象
esetOld.add(Color.BLUE);

esetNew = EnumSet.complementOf(esetOld);  //创建一个不包含指定元素的集合

esetOld.add(Color.RED);

System.out.println("======EnumSet.complementOf(Color.class)=====");
print(esetNew);
System.out.println("======EnumSet.Of(Color.class)=====");
print(esetOld);
}

public static void print(EnumSet<Color> temp){
for(Color c:temp){
System.out.print(c + "、");
}
System.out.println();
}
}

运行结果：

======EnumSet.complementOf(Color.class)=====
RED、GREEN、
======EnumSet.Of(Color.class)=====
RED、BLUE、

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

package org.forfan06.enumdemo;
import java.util.EnumSet;
enum Color{
RED, GREEN, BLUE;
}

public class EnumSetDemo05{
public static void main(String args[]){
EnumSet<Color> esetOld = null;
EnumSet<Color> esetNew = null;
//System.out.println("======EnumSet.allOf(Color.class)=====");
//eset = EnumSet.allOf(Color.class);
//System.out.println("======EnumSet.of(Color.class)=====");
//eset = EnumSet.of(Color.BLUE);
esetOld = EnumSet.noneOf(Color.class); //可以加入Color类型的对象
esetOld.add(Color.BLUE);
esetOld.add(Color.RED);
esetNew = EnumSet.copyOf(esetOld);  //创建一个不包含指定元素的集合

System.out.println("======EnumSet.complementOf(Color.class)=====");
print(esetNew);
System.out.println("======EnumSet.copyOf(Color.class)=====");
print(esetOld);
}

public static void print(EnumSet<Color> temp){
for(Color c:temp){
System.out.print(c + "、");
}
System.out.println();
}
}

运行结果：

======EnumSet.complementOf(Color.class)=====
RED、BLUE、
======EnumSet.copyOf(Color.class)=====
RED、BLUE、

14.6 枚举类实现接口

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

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

package org.forfan06.enumdemo;
interface Print{
public String getColor();
}
enum Color implements Print{
RED{
public String getColor(){
return "红色";
}
},
GREEN{
public String getColor(){
return "绿色";
}
},
BLUE{
public String getColor(){
return "蓝色";
}
};
}

public class EnumeImplementsInterfaceDemo{
public static void main(String args[]){
for(Color c:Color.values()){
System.out.print(c.getColor() + "、");
}
}
}

运行结果：

红色、绿色、蓝色、

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

14.7 枚举类定义抽象方法

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

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

enum Color{
RED{
public String getColor(){
return "红色";
}
},
GREEN{
public String getColor(){
return "绿色";
}
},
BLUE{
public String getColor(){
return "蓝色";
}
};
public abstract String getColor();
}

public class AbstractEnumDemo{
public static void main(String args[]){
for(Color c:Color.values()){
System.out.print(c.getColor() + "、");
}
}
}

运行结果：

红色、绿色、蓝色、

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

14.8 本章要点

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

14.9 习题

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

14.10 参考资料

Java枚举类型enum的使用： http://blog.csdn.net/wgw335363240/article/details/6359614 JAVA枚举类型 ： http://www.cnblogs.com/Fskjb/archive/2009/08/03/1537917.html 详细介绍java中的枚举类型： http://developer.51cto.com/art/201107/275031.htm java枚举类型入门： http://developer.51cto.com/art/201106/266503.htm