我们知道，封装将数据和处理数据的代码连接起来。同时，封装也提供另一个重要属性：访问控制（access control ）。通过封装你可以控制程序的哪一部分可以访问类的成员。通过控制访问，可以阻止对象的滥用。例如，通过只允许适当定义的一套方法来访问数据，你能阻止该数据的误用。因此，如果使用得当，可以把类创建一个“黑盒子”，虽然可以使用该类，但是它的内部机制是不公开的，不能修改。但是，本书前面创建的类可能不会完全适合这个目标。例如，考虑在第6章末尾示例的stack类。方法push( ) 和pop() 确实为堆栈提供一个可控制的接口，这是事实，但这个接口并没被强制执行。也就是说，程序的其他部分可以绕过这些方法而直接存取堆栈，这是可能的。当然，如果使用不当，这可能导致麻烦。本节将介绍能精确控制一个类各种各样成员的访问的机制。

一个成员如何被访问取决于修改它的声明的访问指示符（access specifier ）。java 提供一套丰富的访问指示符。存取控制的某些方面主要和继承或包联系在一起（包，package，本质上是一组类）。java 的这些访问控制机制将在以后讨论。现在，让我们从访问控制一个简单的类开始。一旦你理解了访问控制的基本原理，其他部分就比较容易了。

java 的访问指示符有public （公共的，全局的）、private （私有的，局部的）、和protected （受保护的）。java 也定义了一个默认访问级别。指示符protected仅用于继承情况中。下面我们描述其他两个访问指示符。

让我们从定义public 和private 开始。当一个类成员被public 指示符修饰时，该成员可以被你的程序中的任何其他代码访问。当一个类成员被指定为private 时，该成员只能被它的类中的其他成员访问。现在你能理解为什么main( ) 总是被public 指示符修饰。它被在程序外面的代码调用，也就是由java 运行系统调用。如果不使用访问指示符，该类成员的默认访问设置为在它自己的包内为public ，但是在它的包以外不能被存取（包将在以后的章节中讨论）。

到目前为止，我们开发的类的所有成员都使用了默认访问模式，它实质上是public 。然而，这并不是你想要的典型的方式。通常，你想要对类数据成员的访问加以限制，只允许通过方法来访问它。另外，有时你想把一个方法定义为类的一个私有的方法。

访问指示符位于成员类型的其他说明的前面。也就是说，成员声明语句必须以访问指示符开头。下面是一个例子：

public int i;
private double j;

private int mymethod(int a，char b) { // ...

要理解public 和private 对访问的作用，看下面的程序：

/* this program demonstrates the difference between

public and private.

*/

class test {

int a; // default access

public int b; // public access

private int c; // private access

// methods to access c

void setc(int i) { // set c's value

c = i; }

int getc() { // get c's value

return c;
}
}

class accesstest {
public static void main(string args[]) {
test ob = new test();

// these are ok，a and b may be accessed directlyob.a = 10;ob.b = 20;

// this is not ok and will cause an error
// ob.c = 100; // error!

// you must access c through its methodsob.setc(100); // oksystem.out.println("a，b，and c: " + ob.a + " " +

ob.b + " " + ob.getc());
}
}

可以看出，在test 类中，a使用默认访问指示符，在本例中与public 相同。b被显式地指定为public 。成员c被指定为private ，因此它不能被它的类之外的代码访问。所以，在accesstest 类中不能直接使用c。对它的访问只能通过它的public 方法：setc()和getc() 。如果你将下面语句开头的注释符号去掉，

// ob.c = 100; // error!

则由于违规，你不能编译这个程序。为了理解访问控制在实际中的应用，我们来看在第6章末尾所示的stack 类的改进版本。

// this class defines an integer stack that can hold 10 values.
class stack {

/* now，both stck and tos are private. this means that they cannot be accidentally or maliciouslyaltered in a way that would be harmful to the stack.

*/private int stck[] = new int[10]; private int tos;

// initialize top-of-stack
stack() {
tos = -1;
}

// push an item onto the stack void push(int item) {if(tos==9) system.out.println("stack is full."); else

stck[++tos] = item; }// pop an item from the stack
int pop() {

if(tos < 0) { system.out.println("stack underflow."); return 0;

}
else
return stck[tos--];
}
}

在本例中，现在存储堆栈的stck和指向堆栈顶部的下标tos ，都被指定为private 。这意味着除了通过push() 或pop()，它们不能够被访问或改变。例如，将tos 指定为private ，阻止你程序的其他部分无意中将它的值设置为超过stck 数组下标界的值。

下面的程序表明了改进的stack 类。试着删去注释前面的线条来证明stck和tos 成员确实是不能访问的。

class teststack {

public static void main(string args[]) {
stack mystack1 = new stack();
stack mystack2 = new stack();

// push some numbers onto the stack
for(int i=0; i<10; i++) mystack1.push(i);
for(int i=10; i<20; i++) mystack2.push(i);

// pop those numbers off the stack
system.out.println("stack in mystack1:");
for(int i=0; i<10; i++)

system.out.println(mystack1.pop());

system.out.println("stack in mystack2:");
for(int i=0; i<10; i++)
system.out.println(mystack2.pop());

// these statements are not legal
// mystack1.tos = -2;
// mystack2.stck[3] = 100;

}