JAVA程序员必读：基础篇(5)---类和继承

在前面的教程面向对象编程概念的内容中你学习到了面向对象的概念。现在我们来学习如何将这些概念用在JAVA中。在这部分教程中将介绍

创建类

管理继承

执行嵌套类

5.1 创建类
　　这节中将介绍一个更大的类Stack的完整描述，并且描述一个从它继承而来的对象的生命周期的类的所有组件。首先介绍构造函数，然后介绍成员变量和方法。
　　既然我们前面已经介绍了如何创建和使用对象以及怎样将对象从内存中清除，现在该是我们介绍怎样编写类的时候了。这一节中将通过一个执行LIFO（后入先出）堆栈的小例子来介绍类的组件。如图22给处了类以及识别代码的结构：



（图22）
　　堆栈的执行使用了另外的对象，即Vector来存储它的元素。Vector是一个对象的数组，在需要空间的时候它为新对象分配内存空间。这个Stack类是通过使用Vector来存储它的元素的。但是它对Vector限定了LIFO，也就是说，你可以只增加元素并且从堆栈的顶部移出元素。

5.1.1 类的声明
　　图22给出了组成类执行的两个主要组件：类声明和类实体。类声明定义了类的名字以及其它的属性。为Stack类的类声明是相对地简单，它指示了类为public并且它地名字为Stack。
　　图23给出了类声明可能的组件以及描述了它们的目的。必须的组件是class关键字。所有其它的组件是可选的。如果你没有声明这些可选的组件，JAVA编译器就将给出缺省值：没有执行接口的对象的nonpublic、nonabstract、nofinal子类。



（图23）
下面对每个类的组件给出更详细的介绍。
public ：这个public关键字声明了类可以在其它任何的类中使用。
abstract ：声明了这个类不能被实例化。
Final：声明了类不能被继承，即没有子类了。
class NameOfClass ：关键字class指示编译器类的声明以及类的名字是NameOfClass。
extends Super ：这个extends 子句认为Super是类的父类，因此在类的分级结构中插入了类。
implements Interfaces ：为了声明类可执行一个或多个接口，可以使用关键字implement并且在其后面给出由类执行的接口的名字的列表，它们是以逗号分隔的。

5.1.2 类实体
　　类实体是跟在类声明的后面，它是嵌入在大括号{和}中间的。类实体包含了所有实例变量和类变量的声明。另外，类实体还包含了所有实例方法和类方法的声明。

5.1.3 为类提供构造函数
　　类可能包含一个或者多个的构造函数，它提供了从类创建的对象的初始化。
　　所有的JAVA类都有构造函数，它用来对新的对象进行初始化。构造函数与类的名字是相同的。比如，Stack类的构造函数的名字为Stack，而Rectangle类的构造函数的名字为Rectangle，Thread类的构造函数的名字为Thread。下面给出Stack类的构造函数。
public Stack() {
items = new Vector(10);
}
　　JAVA支持对构造函数的重载，这样一个类就可以有多个构造函数，所有的构造函数的名字都是相同的。下面是定义在Stack的另外的构造函数。这个构造函数是根据它的参数来初始化堆栈的大小。
public Stack(int initialSize) {
items = new Vector(initialSize);
}
　　从上面可以看出两个构造函数都有相同的名字，但是它们有不同的参数列表。编译器会根据参数列表的数目以及类型了区分这些构造函数的。典型地，构造函数使用它的参数来初始化新的对象状态。当创建对象的时候，选择构造函数要看看它的参数是否最好反映了你想初始化的新对象。

5.1.3 为类提供构造函数
　　根据你传递给构造函数参数的数目和类型，编译器可以决定要使用哪个构造函数。下面的代码编译器是认识的，它是使用了单一的整型参数：
new Stack(10);
　　相似地，当你编写下面代码的时候，编译器选择了没有参数的构造函数或者缺省的构造函数：
new Stack();
　　当你编写自己的类的时候，你不必为它提供构造函数。系统会自动提供缺省的构造函数。这个缺省的构造函数不会完成任何事情。因此，如果你想进行一些初始化的时候，你就要为类编写一些构造函数了。
　　下面是Thread的子类的构造函数，它执行动画，设置了一些缺省的数值，比如帧速度、图片的数目然后装载图片。
class AnimationThread extends Thread {
int framesPerSecond;
int numImages;
Image[] images;
AnimationThread(int fps, int num) {
super("AnimationThread");
this.framesPerSecond = fps;
this.numImages = num;
this.images = new Image[numImages];
for (int i = 0; i <= numImages; i++) {
. . .
// 以下转载图片
. . .
}
}
. . .
}

5.1.3 为类提供构造函数
　　实际上构造函数的实体跟方法的实体是相似的，也就是说，它包含了局部变量声明、循环以及其它的语句。但是，AnimationThread构造函数中的第二行你在方法的构造函数是不会看到的：
super("AnimationThread");
　　这一行调用了一个由父类AnimationThread提供的构造函数Thread。这个特定的Thread构造函数有一个String参数，它用来设置Thread的名字。经常，构造函数想利用编写在父类中的初始化代码。实际上，有些类必须调用它们的父类构造函数来使对象正确完成任务。
　　父类的构造函数必须是子类构造函数的第一条语句。对象必须首先执行高层次的初始化。你可以在构造函数生命处通过使用一个访问的指定来指定什么其它对象可以创建类的实例，访问的指示如下：
private：没有其它类可以实例化这个类。这个类可能包含public类方法，这些方法可以构造一个对象并返回，但是其它的类不行。
protected ：只有子类和在相同包中的类可以创建它的实例。
public ：任何类都可以创建它的实例。
没有说明的时候：只有在相同包中的类可以创建它的实例。
　　构造函数提供了一个初始化新对象的方法。初始化实例和类成员提供了对初始化类和由类的新对象进行初始化的方法。

5.1.4 声明成员变量
　　类的状态是由它的成员变量给出的。你可以在类的实体中生命一个类的成员变量。典型地，你可以在声明它的方法之前声明类的变量，虽然这不不是必要的。
classDeclaration {
member variable declarations
method declarations
}
　　这里注意，为了声明变量（类的成员），声明必须在类实体中，而不是在方法的实体中。在方法的实体中声明的变量都是局部变量。
5.1.5 执行方法

　　众所周知，对象的行为是由它的方法来执行的。其它对象通过调用它的方法来访问对象。在这一小节中，我们将一起来为JAVA类编写方法。在JAVA众，你可以在类的实体中定义类的方法，用于执行一些行为。典型地，你可以在类实体中的变量之后声明类的方法，虽然这也不是必须的。
　　图24给出了Stack的push方法的代码。这个方法是一个进栈操作，它将一个Object作为参数，放置到堆栈的顶部然后返回它。



（图24）
　　就象一个类一样，方法也有两个主要部分：方法声明和方法实体。方法声明了方法的所有属性，比如访问等级、返回类型、方法名字以及参数，如图25所示：



（图25）
　　方法实体中有实现方法行为的代码。它包含了执行方法的JAVA指令。
下面介绍一下方法的声明：
　　一个方法的声明包括方法的名字以及返回的类型（指定了由方法返回的数据类型）：
returnType methodName() {
. . .
}
　　这个方法声明是非常基本的。方法有许多其它的属性，比如参数、访问控制等等。
那怎样将信息传递给方法呢？
　　可能，在绝大多数情况下使用的可选方法声明的组件是方法的参数。类似于其它编程语言的函数，JAVA方法接收调用者传递来的参数。这些参数就提供了从方法作用域外部的信息给方法。

5.1.6 控制对类成员的访问
　　当我们声明JAVA类成员的时候，我们可以允许或者不允许其它类型的对象通过访问指示来访问这些成员。
　　其中一个是，类可以保护它们的成员变量和方法受其它对象的访问。也许你会问这很重要吗？是的。假如你编写一个类，它是对数据进行查询，而这个数据库包含了公司的各种秘密信息，所以就有必须进行保护。
　　在JAVA中，你可以在声明类变量和方法的时候，使用访问指示来保护它们。JAVA语言支持对成员变量和方法的四个访问等级：private、 protected、 public以及留着不指定的等级。
下面的表给出来每一种访问指示的访问等级：

访问指示	类	子类	包	所有
Private	X
Protected	X	X*	X
Public	X	X	X	X
Package	X		X

　　第一列给出了是否类本身可以访问它的成员。从上表可以知道，类总是可以访问它自己的成员。第二列给出是否类的子类可以访问它的成员；第三列给出是否在相同包中的类可以访问成员。第四列给出是否所有的类可以访问成员。
　　这里注意在Protected/子类交叉的地方有一个'*'，这个是特殊的访问情况，后面的教程会给出详细的介绍

5.1.6 控制对类成员的访问
下面对各种访问等级详细说明：

Private

　　绝大多数代用限制性的访问等级是private。Private成员只能被它所定义的类所访问。如果外部访问这个变量就将导致前后矛盾的状态。或者如果private的方法被外部类所调用，就会使得运行的程序或者对象的状态处于不良的状态。Private成员就象一些不可告人的秘密。
　　为了声明一个private成员，只需在声明的时候加入private关键字即可。下面的类包含了一个private成员变量和一个Private方法：
class Alpha {
private int iamprivate;
private void privateMethod() {
System.out.println("privateMethod");
}
}
　　这个Alpha类型的对象可以检查或者修改imaprivate变量以及可以调用privateMethod方法，但是其它类型的对象就不行，比如，以下的Beta类就不能访问iamprivate变量或者调用privateMethod，因为Beta不是Alpha类型的：
class Beta {
void accessMethod() {
Alpha a = new Alpha();
a.iamprivate = 10; // 非法
a.privateMethod(); // 非法
}
}

5.1.6 控制对类成员的访问

Private

　　当一个类试图访问一个它不能访问的成员变量的时候，编译器就会打印出错误信息（如下）病拒绝继续编译程序：
Beta.java:9: Variable iamprivate in class Alpha not
accessible from class Beta. //在Alpha类中的imaprivate变量不能从Beta类中进行访问
a.iamprivate = 10; // 非法
^
1 error //一个错误
　　同时，如果你的程序试图访问一个不能访问的方法，就将导致如下的编译器错误：
Beta.java:12: No method matching privateMethod()
found in class Alpha. //在Alapha类中没有匹配的方法privateMethod()
a.privateMethod(); // 非法
1 error //一个错误
　　JAVA的新手可能会问是否一个Alpha对象可以访问另外一个Alpha对象的private成员。下面给出具体例子来进行解释。假如Alpha类包含了一个实例方法，它比较当前的Alpha对象(this)以及另外一个对象的iamprivate变量：
class Alpha {
private int iamprivate;
boolean isEqualTo(Alpha anotherAlpha) {
if (this.iamprivate == anotherAlpha.iamprivate)
return true;
else
return false;
}
}
　　结果是相当的合法。所以，相同类型的对象可以访问其它的private成员。这是因为访问限制只是在类别层次（类的所有实例）而不是在对象层次（类的特定实例）上。

5.1.6 控制对类成员的访问
（2）Protected

　　protected允许类本身、子类以及在相同包中的类访问这个成员。在允许类的子类访问而杜绝其它不相关的类的访问的时候，可以使用protected访问等级。Protected成员就象家庭秘密，家里人知道无所谓，但是就不让外人知道，不是有“家臭不可外扬”一说吗？，虽然这里不是什么“家臭”，但它是受protected的成员。
　　为了声明一个protected成员，使用关键字protected。首先，让我们看看protected是怎样影响在相同包内的类的。假如上面的那个Alpha类现在被定义在一个（package）包Greek内，它有一个protected成员变量和一个protected方法：
package Greek;
public class Alpha {
protected int iamprotected;
protected void protectedMethod() {
System.out.println("protectedMethod");
}
}
　　现在，假设类Gamma也声明为Greek包的一个成员（不是Alpha的子类）。Gamma类可以合法访问Alpha对象的iamprotected成员变量并且可以合法调用它的protectedMethod：
package Greek;
class Gamma {
void accessMethod() {
Alpha a = new Alpha();
a.iamprotected = 10; // 合法
a.protectedMethod(); // 合法
}
}

5.1.6 控制对类成员的访问
（2）Protected

　　下面我们来研究一下protected是怎样影响Alpha的子类的访问的：
　　首先介绍一个新的类Delta，它是来由Alpha继承而来的，但是它处在不同的包中，即Latin。这个Delta类可以访问iamproted和protectedMethod，不仅可以访问Delta类的对象而且可以访问它的子类。Delta类不能访问Alpha类型的对象中的iamprotected或者protectedMethod。在下面代码中的accessMethod试图访问在Alpha类型对象中的imaprotected成员变量，它是不合法的，而访问Delta类型对象则是合法的。相似地，accessMethod 试图调用Alpha对象的protectedMethod也是合法的：
package Latin;
import Greek.*;
class Delta extends Alpha {
void accessMethod(Alpha a, Delta d) {
a.iamprotected = 10; // 非法
d.iamprotected = 10; // 合法
a.protectedMethod(); // 非法
d.protectedMethod(); // 合法
}
}
　　综上所述，如果一个类是里面包含protected成员的类的子类或者它们处在同一个包中，那么这个类就可以访问protected成员了。

5.1.6 控制对类成员的访问
（3）Public

　　最简单的访问指示是public。在任何类中、任何包中都可以访问了的public成员。只有在外部对象使用的时候不会产生不良的结果的时候，才声明为public成员。为了声明一个public成员，你可以使用public关键字，如下：
package Greek;
public class Alpha {
public int iampublic;
public void publicMethod() {
System.out.println("publicMethod");
}
}
　　现在，让我们重新编写Beta类再将它放置到不同的包中，并且要确保它跟Alpha毫无关系：
package Roman;
import Greek.*;
class Beta {
void accessMethod() {
Alpha a = new Alpha();
a.iampublic = 10; // legal
a.publicMethod(); // legal
}
}
　　从上面的代码段你可以看出，Beta可以合法地检查和修改在Alpha类中地iampublic变量并且可以合法地调用publicMethod。

5.1.6 控制对类成员的访问
（4）Package

　　如果你不显性设置成员访问其它级别的成员的时候，使用package访问级。这个访问级允许在相同包中的类访问成员。访问的级别是假设在相同包中的类是互相信任的朋友。比如 ，以下修改过的Alpha类声明了一个单一包访问的成员变量和方法。Alpha处在Greek包中：
package Greek;
class Alpha {
int iampackage;
void packageMethod() {
System.out.println("packageMethod");
}
}
　　这个Alpha类同时可以访问iampackage和packageMethod。另外，所有定义在和Alpha相同的类也可以访问iampackage和packageMethod。假如Alpha和Beta都是定义为Greek包的一部分：
package Greek;
class Beta {
void accessMethod() {
Alpha a = new Alpha();
a.iampackage = 10; // 合法
a.packageMethod(); // 合法
}
}
　　如上所述，Beta可以合法访问iampackage和packageMethod。

5.1.7 理解实例和类成员

　　Java类可以包括两种类型的成员：实例成员和类成员。这一小节将向你介绍如何生命这两种成员以及如何使用它们。
你可以如下来声明一个成员变量，如Myclass中的aFloat：
class MyClass {
float aFloat;
}
　　你声明了一个实例变量。每次你创建类的实例的时候，系统就会为这个实例创建一个类实例的副本。你可以对象中访问对象的实例变量。
　　实例变量跟类变量是有区别的。系统为每个类分配类变量而不管类创建的实例有多少。当第一次调用类的时候，系统为类变量分配内存。所有的实例共享了类的类变量的相同副本。你可以通过一个实例或者类本身来访问类变量。
　　方法是相似的，类有实例方法和类方法。实例方法是对当前对象实例变量进行操作的，而且访问类变量。另外一个方面，类方法不能访问定义在类中的实例变量，除非它们创建了一个新的对象以及通过对象访问它们。同时，类方法可以在类中被调用，你不必一个实例来调用一个类方法。
　　缺省地，除非其它指定，定义在类中地成员是实例成员。定义在下面的类有一个实例变量（整型数x）以及两个实例方法（x和setX，是让其它对象来设置和查询x的数值的）：
class AnIntegerNamedX {
int x;
public int x() {
return x;
}
public void setX(int newX) {
x = newX;
}
}
　　每次你从类实例化新对象的时候，你就得到了类实例变量的一个新副本。这些副本跟新对象是联系在一起的。因此，每次你实例化一个新AnIntegerNamedX对象的时候，你就得到了一个和AnintegerNamedX对象有联系的x的新副本。

5.1.7 理解实例和类成员

　　类的所有实例共享了一个实例方法的相同实现。AnIntegerNamedX的所有实例共享了x和setX的相同实现。这里注意两个方法x和setX都引用了对象的实例变量x。但是你可能会问“如果AnIntegerNamedX的所有实例共享了x和setX的相同实现，这不会模棱两可吗？”，答案当然是：不是。在实例方法中，实例变量的名字是引用了当前对象的实例变量。因此，在x和setX中x就等价于这个x，不会产生模棱两可的情况。
　　AnIntegerNamedX外部的对象如果想访问x，必须通过AnIntegerNamedX的一个特定实例来实现。假如下面的代码段是在其它对象的方法中，它包含了两种不同AnIntegerNamedX类型的对象，并且设置x为不同的数值，然后显示出来：
. . .
AnIntegerNamedX myX = new AnIntegerNamedX();
AnIntegerNamedX anotherX = new AnIntegerNamedX();
myX.setX(1);
anotherX.x = 2;
System.out.println("myX.x = " + myX.x());
System.out.println("anotherX.x = " + anotherX.x());
. . .
　　这里值得注意，代码使用setX来设置myX的x数值，而直接赋值给anotherX.x。不管用哪种方法，代码是操作了两种不同的x的副本：一个是包含在myX对象中，另外一个是包含在anotherX对象中。它们的输出为：
myX.x = 1
anotherX.x = 2
　　上面的例子说明了类AnIntegerNamedX的每一个实例都有它自己的实例变量x的副本并且每个x都有不同的数值。
　　当声明一个成员变量的时候，你可以指定变量是一个类变量而不是一个实例变量。相似地，你可以指定一个方法为类方法而不是一个实例方法。第一次调用变量定义的类的时候，系统就会为类变量创建一个副本。类的所有实例共享了类变量的相同副本。类方法只能操作类变量，它们不能访问定义在类中的实例变量。

5.1.7 理解实例和类成员

　　为了指定成员变量是一个类变量，你可以使用static关键字。比如，让我们来修改以下AnIntegerNamedX类让x变量成为一个类变量：
class AnIntegerNamedX {
static int x;
public int x() {
return x;
}
public void setX(int newX) {
x = newX;
}
}
结果输出为：
myX.x = 2
anotherX.x = 2
　　结果输出相同是因为x现在是一个类变量了，因此就只有一个变量的副本了，它被AnIntegerNamedX的所有实例所共享，包括myX和anotherX。当你在任一个实例中调用setX的时候，你就改变了AnIntergerNamedX所有实例的数值。
　　当定义一个方法的时候，你可以指定方法为类方法而不是实例方法。类方法只能操作类变量而不能访问定义在类中的实例变量。

5.1.7 理解实例和类成员

　　为了指定方法为一个类方法，你可以在方法声明的地方使用static关键字。现在我们改变一下AnIntegerNamedX类，比如它的成员变量x为实例变量，以及它的两个方法为类方法：
class AnIntegerNamedX {
int x;
static public int x() {
return x;
}
static public void setX(int newX) {
x = newX;
}
}
当我们编译这个修改过的AnInterNamedX的时候，编译器就给出以下的错误：
AnIntegerNamedX.java:4: Can't make a static reference to
nonstatic variable x in class AnIntegerNamedX.
return x;
^
　　出现这个错误的原因是类方法不能访问实例变量，除非方法首先创建AnIntergerNamedX的实例并且通过它来访问变量。
下面再修改AnIntegerNamedX，使x变量为一个类变量：
class AnIntegerNamedX {
static int x;
static public int x() {
return x;
}
static public void setX(int newX) {
x = newX;
}
}
　　现在类就可以编译了，它是在创建AnIntegerNamedX两个实例之前设置了它们的x数值并打印出来：
myX.x = 2
anotherX.x = 2
　　实例成员和类成员之间的另外不同点是类成员可以在类本身中访问。你不必实例化一个类来访问类成员。下面再对上面的代码进行修改：
. . .
AnIntegerNamedX.setX(1);
System.out.println("AnIntegerNamedX.x = " + AnIntegerNamedX.x());
. . .
　　这里注意你不再需要创建myX和anotherX。你可以直接从AnIntegerNamedX中设置x并检索x。而你不能这样来处理实例成员，你可以从对象中只调用实例方法。你可以从类的实例或者从类本身访问类变量和方法。

5.1.7.1初始化实例和类成员

你可以使用static初始化程序和实例初始化程序在你在类很中声明它们的时候，来为类和实例成员提供初始数值：
class BedAndBreakfast {
static final int MAX_CAPACITY = 10;
boolean full = false;
}
但是，这种初始化的形式有以下的限制：

初始化程序只可以执行初始化，这可以通过赋值语句来表达。

初始化程序不能调用任何导致异常的方法。

如果初始化程序调用一个产生异常的方法，就不能进行错误恢复了。

如果你有些初始化不能在初始化程序中完成，因为上面的这些限制，你就不得不在其它地方放置初始化代码。为了初始化类成员，在一个static初始化块中放置初始化代码。为了初始化实例成员就在构造函数中放置初始化代码。

5.1.7.2 使用static初始化块
下面是一个static初始化块的例子，如图26所示：



（图26）

这里注意，errorStrings资源束必须在static初始化块中进行初始化。这是因为错误恢复必须在束备有找到的时候才进行。同时，errorString是一个类成员，它对于构造函数中的初始化没有什么用。如前面的例子所述的，一个static初始化块是以static关键字开始的，它是一个利用大括号{和}嵌入的普通JAVA代码。
类可以有许多初始化块，并且可以出现在类实体的任何地方。系统保证static初始化块和static初始化程序按出现在源代码中的顺序被调用。

5.1.7.3 初始化块实例变量

　　如果你想初始化实例变量并且不能在初始化块中进行初始化的时候，你可以来类的构造函数中进行初始化。假如erroeStrings束是一个实例变量而不是一个类变量，你可以使用下面的代码来进行初始化：
import java.util.ResourceBundle;
class Errors {
ResourceBundle errorStrings;
Errors() {
try {
errorStrings = ResourceBundle.
getBundle("ErrorStrings");
} catch (java.util.MissingResourceException e) {
// 这里是错误恢复代码
}
}
}
初始化errorStrings的代码现在处在类的构造函数中。

5.1.7.3 初始化块实例变量

　　有时候，类包含了许多构造函数，并且每个构造函数允许调用者为新对象的不同实例变量提供不同的初始数值。比如，java.awt.Rectangle就有三个构造函数：
Rectangle();
Rectangle(int width, int height);
Rectangle(int x, int y, int width, int height);
　　没有参数的构造函数没有让调用者提供初始数值，而另外的两个构造函数让用户设置初始数值（大小与原点）。然而，所有的实例变量都必须初始化。在本例子中，构造函数完成了这些初始化工作。比如以上的这三个构造函数是这样初始化的：
Rectangle() {
this(0,0,0,0);
}
Rectangle(int width, int height) {
this(0,0,width,height);
}
Rectangle(int x, int y, int width, int height) {
this.x = x;
this.y = y;
this.width = width;
this.height = height;
}
　　Java语言支持实例初始化块，但是它不能用在无记录类（不能声明构造函数）中。使用构造函数比较好的原因有：

所有的初始化代码放置在一起，这样使得代码更容易维护和阅读。

缺省值可以显性地处理。

　　程序员广泛使用构造函数，即使JAVA的新手也是一样。而实例初始化程序可能导致有些程序员对代码的阅读感到困难。

5.2 管理继承
　　回顾前面的教程，extends子句声明了你的类是其它类的子类。你可以为你的类指定为父类（JAVA不支持多个类支持），即使你从你的声明中去掉extends子句，你的类也可以为父类。所以，在JAVA中的每个类都有一个或者只有一个直接的父类。
　　如图27所示，是一个最顶端的类，所有的类都是从这个类继承而来的，这个Object类是定义在java.lang。



（图27）
　　这个Object类定义和执行了在JAVA系统需要的所有类的行为。它是所有类的父类。

5.3 执行嵌套类
　　JAVA编程语言可以让你在另外一个类中定义一个一个类，即嵌套类。内部的内就是典型的嵌套类。
JAVA可以让你定义一个类作为另外一个类的成员，比如：
class EnclosingClass{
. . .
class ANestedClass {
. . .
}
}
　　你可以使用嵌套类来放映并且强制两个类之间的关系。当嵌套类只有在嵌入以后才有意义的时候或者当它依靠于嵌入类的函数的实话，你应该在另外一个类定义一个类，即使用嵌套类。比如，文本鼠标只有在特定文本组件中的时候才有意义。
　　作为圈入类的一个成员，嵌套类有一个特权：它可以毫无限制地访问圈入类地成员，即使它们定义为private。但是这个特权不是真正特殊的，它跟private以及其它访问指示是一致的。访问指示限制了对圈入类外部成员的访问。嵌套类是处在圈入类中的，这样它就可以访问圈入类的成员。
　　象其它成员一样，嵌套类可以声明为static。一个static嵌套类称为static嵌套类。非static嵌套类称为内部类。下面给出例子：
class EnclosingClass{
. . .
static class AStaticNestedClass {
. . .
}
class InnerClass {
. . .
}
}
当利用static方法和变量的时候，一个static嵌套类就跟圈入类联系在一起了。跟类成员一样，static圈套类不能直接引用定义在圈入类中的实例变量或者方法，只有通过对象的引用来使用它们。当利用实例方法和变量的时候，内部类就跟圈入类的实例联系在一起，并且可以直接访问对象的实例变量和方法。同时，因为内部类跟实例联系在一起，它不能定义任何的static成员。
　　为了帮助区分嵌入类和内部类，这里建议用以下的方法来思考。嵌入类是在两个类之间放映语法关系，也就是说，一个类的代码出现在另外一个类的代码中。相比之下，内部类是放映两个类实例之间的关系，举例如下：
class EnclosingClass {
. . .
class InnerClass {
. . .
}
}
如图28所示给出了这两个类之间的关系。



（图28）

　　你可以会在JAVA API中遇到这两个类并需要使用它。但是绝大多数你编写的嵌套类将是内部类。