我们知道，封装将数据和处理数据的代码连接起来。同时，封装也提供另一个重要属性：访问控制（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;
}
}
尽管由类定义的方法通常提供对数据的访问，但情况并不总是这样。当需要时允许一个实例变量为public 是完全合适的。例如,为简单起见，本书中大多数的简单类在创建时不关心实例变量的存取。然而，在大多数实际应用的类中，你将有必要仅仅允许通过方法来对数据操作。下一章将回到访问控制的话题。你将看到，在继承中访问控制是至关重要的。
xiazhouquan 于 2009-09-03 15:46:30发表:
恩，不错，支持一个，java语言挺有前途的，很火，代码也很美
caolongday 于 2009-09-02 22:40:29发表:
没看明白……