我们知道，封装将数据和处理数据的代码连接起来。同时，封装也提供另一个重要属性：访问控制。通过封装你可以控制程序的哪一部分可以访问类的成员。
通过控制访问，可以阻止对象的滥用。例如，通过只允许适当定义的一套方法来访问数据，你能阻止该数据的误用。因此，如果使用得当，可以把类创建一个“黑盒子”，虽然可以使用该类，但是它的内部机制是不公开的，不能修改。但是，本书前面创建的类可能不会完全适合这个目标。
例如，方法push( )和pop()确实为堆栈提供一个可控制的接口，这是事实，但这个接口并没被强制执行。也就是说，程序的其他部分可以绕过这些方法而直接存取堆栈，这是可能的。当然，如果使用不当，这可能导致麻烦。本节将介绍能精确控制一个类各种各样成员的访问的机制。
一个成员如何被访问取决于修改它的声明的访问指示符。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 directly
ob.a = 10;
ob.b = 20;
// This is not OK and will cause an error
// ob.c = 100; // Error!
// You must access c through its methods
ob.setc(100); // OK
System.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!
则由于违规，你不能编译这个程序。
// 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 maliciously
altered 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;
}
}
尽管由类定义的方法通常提供对数据的访问，但情况并不总是这样。当需要时允许一个实例变量为public是完全合适的。
例如,为简单起见，本书中大多数的简单类在创建时不关心实例变量的存取。然而，在大多数实际应用的类中，你将有必要仅仅允许通过方法来对数据操作。
