之前我们一直在说，程序主要即使数据以及对数据的操作，而为了方便操作数据，高级语言引入了数据类型的概念。Java定义了8中基本数据类型，而类相当于自定义数据类型，通过类的组合和继承可以表示和操作各种事物或者说对象。
除了基本的数据类型和类的概念，还有一些扩展概念，包括接口、抽象类、内部类和枚举。上一章我们提到，继承有其两面性，替代继承的一种方式是使用接口，接口到底是什么呢？此外，介于接口和类之间，还有一个概念：抽象类，它又是什么呢？一个类可以定义在另一个类内部，称为内部类，为什么要有内部类，它到底是什么呢？枚举是一种特殊的数据类型，它有什么用呢？本章就来探讨这些概念，先来看接口。
5.1 接口的本质
在之前的章节中，我们一直在强调数据类型的概念，但 只是将对象看作属于某种数据类型，并按该类型进行操作，在一些情况下，并不能反映对象以及对对象操作的本质。
为什么这么说呢？很多时候，我们实际上关心的，并不是对象的类型，而是对象的 能力，只要能提供这个能力，类型并不重要。我们来看一些生活中的例子。
比如要拍照，很多时候，只要能拍出符合需求的照片就行，至于是用手机拍还是用Pad拍的，或者是用单反相机拍，并不重要，即关心的是对象 是否有拍出照片的能力， 而并不关心对象到底是什么类型，手机、Pad或单反相机都可以。
又如要计算一组数字，只要能计算出正确结果即可，至于是由人心算，用算盘算，用计算器算，用计算机软件算，并不重要，即关心的是对象 是否有计算的能力， 而并不关心对象到底是算盘还是计算器。
再如要将冷水加热，只要能得到热水即可，至于是用电磁炉加热，用燃气灶加热，还是用电热水壶加热，并不重要，即重要的是对象 是否有加热水的能力， 而并不关心对象到底是什么类型。
在这些情况中，类型并不重要，重要的是能力。 那如何表示能力呢？接口。下面就来详细介绍接口，包括其概念、用法、一些细节，以及如何用接口替代继承。
5.2 抽象类
顾名思义，抽象类就是抽象的类。抽象是相对于具体而言，一般而言，具体类有直接对应的对象，而抽象了没有，它表达的是抽象概念， 一般是具体类的比较上层的父类。比如，狗是具体对象，而动物则是抽象概念；殷桃是具体对象，而水果则是抽象概念；正方形是具体对象，而图形则是抽象概念。下面我们通过图形处理中的一些概念来说明Java中的抽象类。
5.2.1 抽象方法和抽象类
之前我们介绍过图形类Shape， 它有一个方法draw()。Shape其实是一个抽象概念，它的draw()方法其实并不知道如何实现，只有子类才知道。这种只有子类才知道如何实现的方法，一般被定义为 抽象方法。
抽象方法是相对于具体方法而言的，具体方法有实现代码，而抽象方法只有声明，没有实现。上节介绍的接口中的方法(非Java 8引入的静态和默认方法)就都是抽象方法。
抽象方法和抽象类都是用abstract这个关键字来声明，语法如下所示：
public abstract class Shape{
//其他代码
public abstract void draw();
}
定义了凑想方法的类必须被声明为抽象类，不过，抽象类可以没有抽象方法。抽象类和具体类一样，可以定义具体方法、实例变量等，它和具体类的核心区别是，抽象类不能创建对象（比如，不能使用new Shape()）,而具体类可以。
抽象类不能创建对象，要创建对象，必须使用它的具体子类。一个类在继承抽象类后，必须实现抽象类中定义的所有抽象方法，除非它自己也声明为抽象类。圆类的实现代码，如下所示：
public class Circle extends Shape{
//其他代码
@Override
public void draw(){
//主体代码
}
}
圆实现了draw()方法。与接口类似，抽象类虽然不能使用new，但可以声明抽象类的变量，引用抽象类具体子类的对象，如下所示：
Shape shape = new Circle();
shape.draw();
shape是抽象类Shape类型的变量，引用了具体子类Circle的对象，调用draw()方法将调用Circle的draw代码。
5.2.2 为什么需要抽象类
抽象方法和抽象类看上去是多余的，对于抽象方法，不知道如何实现，定义一个空方法体不就行了吗？而抽象类不让创建对象，看上去只是增加了一个不必要的限制。
引入抽象方法和抽象类，是Java提供的一种语法工具，对于一些类和方法，引导使用者正确使用它们，减少误用。使用抽象方法而非空方法体，子类就知道它必须要实现该方法，而不可能忽略，若忽略Java编译器就会提示错误。使用抽象类，类的使用者创建对象的时候，就知道必须使用某个具体子类，而不可能误用不完整的父类。
无论是编写程序，还是平时做其他事情，每个人都可能会犯错，减少错误不能只依赖人的优秀素质，还需要一些机制，使得一个普通人都容易把事情做对，而难以把事情做错。抽象类就是Java提供的这样一种机制。
5.2.3 抽象类和接口
抽象类和接口有类似之处：都不能用于创建对象，接口中的方法其实都是抽象方法。如果抽象类中之定义抽象方法，那抽象类和接口就更像了。但抽象类和接口根本上是不同的，接口中不能定义实例变量， 而抽象类可以，一个类可以实现多个接口，但只能继承一个类。
抽象类和接口是配合而非替代关系，它们经常一起使用，接口声明能力，抽象类提供默认实现，实现全部或部分方法，一个接口经常有一个对应的抽象类。 比如，在Java类库中，有：
- Collection接口和对应的AbstractCollection抽象类。
- List接口和对应的AbstractList抽象类。
- Map接口和对应的AbstractMap抽象类。
对于需要实现接口的具体类而言，有两个选择：一个是实现接口，自己实现全部方法；另一个则是继承抽象类，然后根据需要重写方法。
继承的好处是复用代码，只重写需要的部分即可，需要编写的代码比较少，容易实现。不过，如果这个具体类已经有父类了，那就只能选择实现接口了。
我们以一个例子来进一步说明这种配合关系。前面引入了IAdd接口，我们实现一个抽象类AbstractAddr，代码如下：
public abstract class AbstractAdder implements IAdd{
@Override
public void addAll(int[] numbers){
for(int num : numbers){
add(num);
}
}
}
这个抽象类提供了addAll方法的实现，它通过调用add方法来实现，而add方法是一个抽象方法。这样，对于需要实现IAdd接口的类来说，它可以选择直接实现IAdd接口，或者从AbstractAdder类继承，如果继承，只需要实现add方法就可以了。这里，我们让原有的Base类继承AbstractAdder,代码如下所示：
public class Base extends AbstractAdder{
private static final int MAX_NUM = 1000;
private int[] arr = new int[MAX_NUM];
private int count;
@Override
public void add(int number){
if(count < MAX_NUM){
if(count < MAX_NUM){
arr[count++] = number;
}
}
}
}
5.2.4 小结
本节介绍了抽象类，相对于具体类，它用于表达抽象概念，虽然从语法上抽象类不是必需的，但它能使程序更为清晰，可以减少误用。抽象类和接口经常相互配合，接口定义能力，而抽象类提供默认实现，方便子类实现接口。
5.3 内部类的本质
之前我们所说的类都对应于一个独立的Java源文件，但一个类还可以放在另一类的内部，称之为内部类，相对而言，包含它的类称之为外部类。
一般而言，内部类与包含它的外部类有比较密切的关系，而与其他类关系不大，定义在类内部，可以实现对外部完全隐藏，可以有更好的封装性，代码实现上也往往更为简洁。
不过，内部类只是Java编辑器的概念，对于Java虚拟机而言，它是不知道内部类这回事的，每个内部类最后都会被编译为一个独立的类， 生成一个独立的字节码文件。
也就是说，每个内部类其实都可以被替换为一个独立的类。当然，这是单纯就技术实现而言。内部类可以方便地访问外部类的私有变量，可以声明为private从而实现对外完全隐藏，相关代码写在一起，写法也更为简洁，这些都是内部类的好处。
在Java中，根据定义的位置和方式不同，主要有4种内部类。
- 静态内部类。
- 成员内部类。
- 方法内部类。
- 匿名内部类。
其中，方法内部类是在一个方法内定义和使用的；匿名内部类使用范围更小，它们都不能在外部使用；成员内部类和静态内部类可以被外部使用，不过它们都可以被声明为private,这样，外部就不能使用。接下来，我们逐个介绍这些内部类的语法、实现原理以及使用场景。
5.3.1 静态内部类
静态内部类与静态变量和静态方法定义的位置一样，也带有static关键字，只是它定义的是类，下面我们介绍它的语法、实现原理和应用场景。我们看个静态内部类的例子，如代码清单5-3所示。
代码清单5-3 静态内部类示例
public class Outer{
private static int shared = 100;
public static class StaticInner{
public void innerMethod(){
System.out.println("inner " + shared);
}
}
public void test(){
StaticInner si = new StaticInner();
si.innerMethod();
}
}
外部类为Outer，静态内部类为StaticInner，带有static修饰符。语法上，静态内部类除了位置放在其他类内部外，它与一个独立的类差别不大，可以有静态变量、静态方法、成员方法、成员变量、构造方法等。
静态内部类与外部类的联系也不大（与其他内部类相比）。它可以访问外部类的静态变量和方法，如innerMethod直接访问shared变量，但不可以访问实例变量和方法。在类内部，可以直接使用内部静态类，如test()方法所示。
public静态内部类也可以被外部使用，只是需要通过“外部类.静态内部类”的方式使用，如下所示：
Outer.StaticInner si = new Outer.StaticInner();
si.innerMethod();
静态内部类是怎么实现的呢？代码清单5-3所示的代码实际上会生成两个类：一个是Outer，另一个是Outer$StaticInner，代码大概如代码清单5-4所示。
代码清单5-4 静态内部类示例的内部实现
public class Outer{
private static int shared = 100;
public void test(){
Outer$StaticInner si = new Outer$StaticInner();
si.innerMethod();
}
static int access$0(){
return shared;
}
}
public class Outer$StaticInner{
public void innerMethod(){
System.out.println("inner " + Outer.access$0());
}
}
内部类访问了外部类的一个私有静态变量shared，而我们知道私有变量是不能被类外部访问的，Java的解决方法是：自动为Outer生成一个非私有访问方法access$0，它返回这个私有静态变量shared。
静态内部类的使用场景是很多的，如果它与外部类关系密切，且不依赖外部类实例，则可以考虑定义为静态内部类。比如，一个类内部，如果既要计算最大值，又要计算最小值，可以在一次遍历中将最大值和最小值都计算出来，但怎么返回呢？可以定义一个类Pair,包括最大值和最小值，但Pair这个名字太普遍，而且它主要是类内部使用的，就可以定义为一个静态内部类。
我们也可以看一些在Java API中使用静态内部类的例子：
Integer类内部有一个私有静态内部类IntegerCache，用于支持整数的自动装箱。 表示链表的LinkedList类内部有一个私有静态内部类Node，表示链表中的每个节点。 Character类内部有一个public 静态内部类UnicodeBlock，用于表示一个Unicode block。 以上一些类的细节我们在后续章节会再介绍。
5.3.2 成员内部类
与静态内部类相比，成员内部类没有static修饰符，少了一个static修饰符，含义有很大不同，下面我们详细讨论。我们看个成员内部类的例子，如代码清单5-5所示。
代码清单5-5 成员内部类示例
public class Outer{
private int a = 100;
public class Inner{
public void innerMethod(){
System.out.println("outer a " + a);
Outer.this.action();
}
}
private void action(){
System.out.println("action");
}
public void test(){
Inner inner = new Inner();
inner.innerMethod();
}
}
Inner就是成员内部类，与静态内部类不同，除了静态变量和方法，成员内部类还可以直接访问外部类的实例变量和方法，如innerMethod直接访问外部外部类私有实例变量a。成员内部类还可以通过"外部类.this.xxx"的方式引用外部类的实例变量和方法，如Outer.this.action()，这种写法一般在重名的情况下使用，如果没有重名，那么“外部类.this.”是多余的。
在外部类内，使用成员内部类与静态内部类是一样的，直接使用即可，如test()方法所示。与静态内部类不同，成员内部类对象总是与一个外部类对象相连的， 在外部使用时，它不能直接通过new Outer.Inner()的方式创建对象，而是要先将创建一个Outer类对象，代码如下所示：
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.innerMethod();
创建内部类对象的语法是“外部类对象.new 内部类()”，如outer.new Inner()。
与静态内部类不同，成员内部类中不可以定义静态变量和方法(final变量例外，它等同于常量)，下面介绍的方法内部类和匿名内部类也都不可以。Java为什么要有这个规定呢？可以这么理解，这些内部类是与外部实例相连的，不应独立使用，而静态变量和方法作为类型的属性和方法，一般是独立使用的，在内部类中意义不大，而如果内部类确实需要静态变量和方法，那么也可以挪到外部类中。
成员内部类背后是怎么实现的呢？代码清单5-5也会生成两个类：一个是Outer，另一个是Outer$Inner，它们的代码大概如代码清单5-6所示。
代码清单5-6 成员内部类示例的内部实现
public class Outer{
private int a = 100;
private void action(){
System.out.println("action");
}
public void test(){
Outer$Inner inner = new Outer$Inner(this);
inner.innerMethod();
}
static int access$0(Outer outer){
return outer.a;
}
static void access$1(Outer outer){
outer.action();
}
}
public class Outer$Inner{
final Outer outer;
public Outer$Inner(Outer outer){
this.outer = outer;
}
public void innerMethod(){
System.out.println("outer a " + Outer.access$0(outer));
Outer.access$1(outer);
}
}
OuterInner对象时给它传递当前对象，由于内部类访问了外部类的私有变量和方法，外部类Outer生成了两个非私有静态方法：access1用于访问方法action。
成员内部类有哪些应用场景呢？如果内部类与外部类关系密切，需要访问外部类的实例变量或方法，则可以考虑定义为成员内部类。外部类的一些方法的返回值可能是某个接口，为了返回这个接口，外部类方法可能使用内部类实现这个方法，这个内部类可以被设为private，对外完全隐藏。
比如，在Java API的类LinkedList中，它的两个方法listIterator和descendingIterator的返回值都是接口Iterator，调用者可以通过Iterator接口对链表遍历，listIterator和descend-ingIterator内部分别使用了成员内部类ListItr和DescendingIterator，这两个内部类都实现了接口Iterator。关于LinkedList，第9章会详细介绍。
5.3.3 方法内部类
内部类还可以定义在一个方法体中，我们看个例子，如代码清单5-7所示。
代码清单5-7 方法内部类示例
public class Outer{
private int a = 100;
public void test(final int param){
final String str = "hello";
class Inner{
public void innerMethod(){
System.out.println("outer a " + a);
System.out.println("param " + param);
System.out.println("local var " + str);
}
}
Inner inner = new Inner();
inner.innerMethod();
}
}
类Inner定义在外部类方法test中，方法内部类只能在定义的方法内被使用。如果方法是实例方法，则除了静态变量和方法，内部类还可以直接访问外部类的实例变量和方法，如innerMethod直接访问了外部私有变量a。如果方法是静态方法，则方法内部类只能访问外部类的静态变量和方法。方法内部类还可以直接访问方法的参数和方法中的局部变量，不过，这些变量必须被声明为final，如innerMethod直接访问了方法参数param和局部变量str。
方法内部类是怎么实现的呢？对于代码清单5-7，系统生成的两个类代码大概如代码清单5-8所示。
代码清单5-8 方法内部类示例的内部实现
public class Outer{
private int a = 100;
public void test(final int param){
final String str = "hello";
OuterInner inner = new OuterInner(this, param);
inner.innerMethod();
}
static int access$0(Outer outer){
return outer.a;
}
}
public class OuterInner{
Outer outer;
int param;
OuterInner(Outer outer, int param){
this.outer = outer;
this.param = param;
}
public void innerMethod(){
System.out.println("outer a " + Outer.access$0(this.outer));
System.out.println("param " + param);
System.out.println("local var " + "hello");
}
}
与成员内部类类似，OuterInner类也有一个实例变量outer指向外部对象，在构造方法中被初始化，对外部私有实例变量的访问也是通过Outer添加的方法access$0来进行的。
方法内部类可以访问方法中的参数和局部变量，这是通过在构造方法中传递参数来实现的，如OuterInner构造方法中有参数int param，在新建OuterInner对象时，Outer类将方法中的参数传递给了内部类，如OuterInner inner = new OuterInner(this, param); 在上面的代码中，String str并没有被座位参数传递，这是因为它被定义为了常量，在生成的代码中，可以直接使用它的值。
这也解释了为什么方法内部类访问外部方法中的参数和局部变量时，这些变量必须被声明为final，因为实际上，方法内部类操作的并不是外部的变量，而是它自己的实例变量， 只是这些变量的值和外部一样，对这些变量的赋值，并不会改变外部的值，为了避免混淆，所以干脆强制规定必须声明为final。
如果的确需要修改外部的变量，那么可以将变量改为只含该变量的数组，修改数组中的值，如代码清单5-9所示。
代码清单5-9 方法内部类修改外部变量实例
public class Outer{
public void test(){
final String[] str = new String[]{"hello"};
class Inner{
public void innerMethod(){
str[0] = "hello world";
}
}
}
}
str是一个只含一个元素的数组，方法内部类不能修改str本身，但可以修改它的数组元素。
通过前面介绍的语法和原理可以看出，方法内部类可以用成员内部类代替，至于方法参数，也可以作为参数传递给成员内部类。不过，如果类只在某个方法内被使用，使用方法内部类，可以实现更好的封装。
5.3.4 匿名内部类
与前面介绍的内部类不同，匿名内部类没有单独的类定义，它在创建对象的同时定义类，语法如下：
new 父类(参数列表){
//匿名内部类实现部分
}
或者
new 父接口(){
//匿名内部类实现部分
}
匿名内部类是与new关联的，在创建对象的时候定义类，new后面是父类或者父接口，然后是圆括号(),里面可以是传递给父类构造方法的参数，最后是大括号{}, 里面是类的定义。
看个具体的例子，如代码清单5-10所示
代码清单5-10 匿名内部类示例
public class Outer{
public void test(final int x, final int y){
Point p = new Point(2,3){
@Override
public double distance(){
return distance(new Point(x,y));
}
};
System.out.println(p.distance());
}
}
创建Point对象的时候，定义了一个匿名内部类，这个类的父类是Point，创建对象的时候，给父类构造方法传递了参数2和3，重写了distance()方法，在方法中访问了外部方法final参数x和y。
匿名内部类只能被使用一次，用来创建一个对象。它没有名字，没有构造方法，但可以根据参数列表，调用对应的父类构造方法。它可以定义实例变量和方法，可以有初始化代码块，初始化代码块可以起到构造方法的作用，只是构造方法可以有多个，而初始化代码块只能有一份。因为没有构造方法，它自己无法接受参数，如果必须要参数，则应该使用其他内部类。与方法内部类一样，匿名内部类也可以访问外部类的所有变量和方法，可以访问方法中的final参数和局部变量。
匿名内部类是怎么实现的内？每个匿名内部类也都被生成为一个独立的类，只是类的名字以外部类加数字编号，没有有意义的名字。代码清单5-10会产生两个类Outer和Outer$1，代码大概如代码清单5-11所示。
代码清单5-11 匿名内部类示例的内部实现
public class Outer{
public void test(final int x, final int y){
Point p = new Outer$1(this, 2, 3, x, y);
System.out.println(p.distance());
}
}
public class Outer$1 extends Point{
int x2;
int y2;
Outer outer;
Outer$1(Outer outer, int x1, int y1, int x2, int y2){
super(x1, y1);
this.outer = outer;
this.x2 = x2;
this.y2 = y2;
}
@Override
public double distance(){
return distatnce(new Point(this.x2, y2));
}
}
与方法内部类类似，外部实例this、方法参数x和y都作为参数传递给了内部类构造方法。此外，new时的参数2和3也传递给了构造方法，内部类构造方法又将它们传递给了父类构造方法。
匿名内部类能做的，方法内部类都能做。但如果对象只会创建一次，且不需要构造方法来接受参数，则可以使用匿名内部类，这样代码书写上更为简洁。
在调用方法时，很多方法需要一个接口参数，比如Arrays.sort方法，它可以接受一个数组，以及一个Comparator接口的参数，Comparator有一个方法compare用于比较两个对象。比如，要对一个字符串数组不区分大小写排序，可以使用Arrays.sort方法，但需要传递一个实现了Comparator接口的对象，这时就可以使用匿名内部类，代码如下所示：
public void sortIgnoreCase(String[] strs){
Arrays.sort(strs, new Comparator<String>(){
@Override
public int compare(String o1, String o2){
return o1.compareToIgnoreCase(o2);
}
});
}
Comparator后面的<String>与泛型有关，表示比较的对象是字符串类型。匿名内部类还经常用于事件处理程序中，用于响应某个事件，比如一个Button，处理单击事件的代码可能类似如下：
Button bt = new Button();
bt.addActionListener(new ActionListener(){
@Override
public void actionPerformed(ActionEvent e){
//处理事件
}
});
调用addActionListener将事件处理程序注册到Button对象bt中，当事件发生时，会调用actionPerformed方法，并传递事件详情ActionEvent作为参数。
以上Arrays.sort和Button都是针对接口编程的例子，另外，它们也都是一种 回调 的例子。所谓回调时相对于一般的正向调用而言的，平时一般都是正向调用，但Arrays.sort中传递的Comparator对象，它的compare方法并不是在写代码的时候被调用的，而是在Arrays.sort的内部某个地方回过头来调用的。Button的addActionListener中传递的ActionListener对象，它的actionPerformed方法也是一样，是在事件发生的时候回过头来调用的。
将程序分为保持不变的主体框架，和针对具体情况的可变逻辑，通过回调的方式进行协作，是计算机程序的一种常用实践。匿名内部类是实现回调接口的一种简便方式。
至此，关于各种内部类就介绍完了。内部类本质上都会被转换为独立的类，但一般而言，它们可以实现更好的封装，代码实现上也更为简洁。
5.4 枚举的本质
本节探讨Java中的枚举类型。枚举是一种特殊的数据，它的取值是有限的，是可以枚举出来的，比如一年有四季、一周有七天。虽然使用类也可以处理这种数据，但枚举类型更为简洁、安全和方便。下面介绍枚举的使用和实现原理。先介绍基础用法和原理，再介绍典型场景。
5.4.1 基础
定义和使用基本的枚举是比较简单的，我们来看个例子。为表示衣服的尺寸，我们定义了一个枚举类型Size，包括三个尺寸：小、中、大，代码如下：
public enum Size{
SMALL, MEDIUM, LARGE
}
枚举使用enum这个关键字来定义，Size包括三个值，分别表示小、中、大，值一般是大写的字母，多个值之间以逗号分隔。枚举类型可以定义为一个单独的文件，也可以定义在其他类内部。
可以这样使用Size:
Size size = Size.MEDIUM
Size size声明了一个变量size, 它的类型是Size, size = Size.MEDIUM将枚举值MEDIUM赋值给size变量。枚举变量的toString方法返回其字面值，所有枚举类型也都有一个name()方法，返回值与toString()一样，例如
Size size = Size.SMALL;
System.out.println(size.toString());
System.out.println(size.name());
输出都是SMALL。枚举变量可以使用equals和==进行比较，结果是一样的。例如：
Size size = Size.SMALL;
System.out.println(size == Size.SMALL);
System.out.println(size.equals(Size.SMALL));
System.out.println(size == Size.MEDIUM);
上面代码的输出结果为三行，分别是true、true、false。枚举值是有顺序的，可以比较大小。枚举类型都有一个方法int ordinal(), 表示枚举值在声明时的顺序，从0开始，例如，如下代码输出为1：
Size size = Size.MEDIUM;
System.out.println(size.ordinal());
另外，枚举类型都实现了Java API中的Comparable接口，都可以通过方法compareTo与其他枚举值进行比较。比较其实就是比较ordinal的大小，例如，如下代码输出为-1，表示SMALL小于MEDIUM:
Size size = Size.SMALL;
System.out.println(size.compareTo(Size.MEDIUM));
枚举变量还可以用于和其他类型变量一样的地方，如方法参数、类变量、实例变量等。枚举还可以用于switch语句，代码如下所示：
static void onChosen(Size size){
switch(size){
case SMALL:
System.out.println("chosen small"); break;
case MEDIUM:
System.out.println("chosen small"); break;
case LAGRE:
System.out.println("chosen large"); break;
}
}
在switch语句内部，枚举值不能带枚举类型前缀，例如，直接使用SMALL,不能使用Size.SMALL。枚举类型都有一个静态的valueOf(String)方法，可以返回字符串对应的枚举值，例如，以下代码输出为true:
System.out.println(Size.SMALL == Size.valueOf("SMALL"));
枚举类型也都有一个静态的values方法，返回一个包括所有枚举值的数组，顺序与声明时的顺序一致，例如：
for(Size size : Size.values()){
System.out.println(size);
}
屏幕输出为三行，分别为SMALL、MEDIUM、LAGRE。
Java是从Java5才开始支持枚举的，在此之前，一般是在类中定义静态整型变量来实现类似的功能，代码如下所示：
class Size{
public static final int SMALL = 0;
public static final int MEDIUM = 1;
public static final int LAGRE = 1;
}
枚举的好处体现在以下几方面。
- 定义枚举的语法更为简洁。
- 枚举更为安全。一个枚举类型的变量，它的值要么为null, 要么为枚举值之一，不可能为其他值，但使用整型变量，它的值就没办法强制，值可能就是无效的。
- 枚举类型自带很多便利方法（如values、valueOf、toString等），易于使用。
枚举是怎么实现的呢？枚举类型实际上会被Java编译器转换为一个对应的类，这个类继承了Java API中的java.lang.Enum类。Enum类有name和ordinal两个实例变量，在构造方法中需要传递，name()、toString()、ordinal()、compareTo()、equals()方法都是由Enum类根据其实例变量name和ordinal实现的。values和valueOf方法是编译器给每个枚举类型自动添加的，上面的枚举类型Size转换成的普通类大概如代码清单5-12所示。需要说明的是，这只是示意代码，不能直接运行。
代码清单5-12 枚举类Size对应的普通类示意代码
public final class Size extends Enum<Size>{
public static final Size SMALL = new Size("SMALL", 0);
public static final Size MEDIUM = new Size("MEDIUM", 1);
public static final Size LAGRE = new Size("LAGRE", 2);
public static Size[] VALUES = new Size[]{SMALL, MEDIUM, LAGRE};
private Size(String name, int ordinal){
super(name,ordinal);
}
public static Size[] values(){
Size[] values = new Size[VALUES.length];
System.arraycopy(VALUES, 0, values, 0, VALUES.length);
return values;
}
public static Size valueOf(String name){
return Enum.valueOf(Size.class, name);
}
}
