[JAVA编程思想]chap5.1Access Control

1.在包中创建一个类。 在该包之外创建类的实例。

package access.local; 
	public class E01_PackagedClass { 
}

在access / local子目录中创建上述文件。 （确保该文件位于从CLASSPATH位置开始的目录中，然后继续访问/本地。）然后在访问目录中创建以下文件，该目录位于本地目录之上，因此位于access.local包之外：

package access; 

public class E01_ForeignClass { 
	public static void main(String[] args) { 
		new access.local.E01_PackagedClass(); 
	} 
}

2.将“碰撞”部分中的代码片段转换为程序，并验证碰撞确实发生。

package access; 

public class E01_ForeignClass { 
	public static void main(String[] args) { 
		new access.local.E01_PackagedClass(); 
	} 
}

3.创建两个包：debug和debugoff，包含一个带有debug（）方法的相同类。 第一个版本将其String参数显示给控制台，第二个版本不执行任何操作。 使用静态导入行将类导入测试程序，并演示条件编译效果。

4.Show that protected methods have package access but are not public.

package access.local;

public class E04_PackageClass{
	protected static void greeting(){
		System.out.println("Hello client programmer!");
	}
}

public class E04_ConsumerInSamePackage{
	public static void main(String[] agrs){
		E04_PackageClass.greeting();
	}
}

package accsee;

public class E04_ForeignClass{
	public static void main(String[] agrs){
		access.local.E04_PackageClass.greeting();
	}
}

解释编译器为E04_ForeignClass.java生成错误的原因。
将e04_ForeignClass类作为access.local包的一部分会有所不同吗？
解决方案：E04_PackagedClass在其自己的包中，而greeting（）不是公共方法，因此通常在包access.local之外不可用。 如果E04_ForeignClass包含在access.local中，它将与E04_PackagedClass.greeting（）共享相同的包，因此可以访问它。 （参见练习6和9）

5.使用public，private，protected和package-access字段和方法成员创建一个类。 创建此类的对象，并查看在尝试访问所有类成员时获得的编译器消息类型。 请记住，同一目录中的类是“默认”包的一部分。

package access.local; 
public class E05_AccessControl { 
	public int a; 
	private int b; 
	protected int c; 
	int d;    // Package access 
	public void f1() {} 
	private void f2() {} 
	protected void f3() {} 
	void f4() {}    // Package access 
	public static void main(String args[]) { 
		E05_AccessControl test = new E05_AccessControl(); 
 // No problem accessing everything inside 
 // of main() for this class, since main() 
 // is a member and therefore has access: 
		test.a = 1; 
		test.b = 2; 
		test.c = 3; 
		test.d = 4; 
		test.f1(); 
		test.f2(); 
		test.f3(); 
		test.f4(); 
	} 
}

您可以看到main（）是一个成员，因此可以访问所有内容。 如果在同一个包中创建单独的类，则该类无法访问私有成员：

//: access/local/E05_Other.java 
// A separate class in the same package cannot 
// access private elements: 
package access.local; 
public class E05_Other { 
	public E05_Other() { 
		E05_AccessControl test = new E05_AccessControl(); 
		test.a = 1; 
 //! test.b = 2; // Can't access: private 
		test.c = 3; 
		test.d = 4; 
		test.f1(); 
 //! test.f2(); // Can't access: private 
		test.f3(); 
		test.f4(); 
	} 
}

在单独的包中创建类（通过使用package语句或将其放在不同的目录中），它只能访问公共成员：

//: access/E05_Other.java 
// A separate class in the other package cannot 
// access private, protected and package elements: 
package access; 
import access.local.E05_AccessControl; 
public class E05_Other { 
	public E05_Other() { 
		E05_AccessControl test = new E05_AccessControl(); 
		test.a = 1; 
 //! test.b = 2; // Can't access: private 
 //! test.c = 3; // Can't access: protected 
 //! test.d = 4; // Can't access: package 
		test.f1(); 
 //! test.f2(); // Can't access: private 
 //! test.f3(); // Can't access: protected 
 //! test.f4(); // Can't access: package 
	} 
}

6.使用受保护数据创建一个类，使用操作受保护数据的方法创建同一文件中的第二个类。

package access; 
class WithProtected { 
	protected int i; 
} 

public class E06_ProtectedManipulation { 
	public static void main(String args[]) { 
		WithProtected wp = new WithProtected(); 
		wp.i = 47; 
		System.out.println("wp.i = " + wp.i); 
	} 
}

本练习表明，受保护也意味着“包访问”（a.k.a。“友好”）。 您始终可以访问同一包中的受保护字段。 作为进一步的练习，将受保护的方法添加到WithProtected并从E06_ProtectedManipulation中访问它。

7.根据描述访问和Widget的代码片段创建库。 在不属于访问包的类中创建Widget。

package access.e07; 
import access.Widget; 

public class E07_Widget { 
	public static void main(String args[]) { 
		new Widget(); 
	}
} /* Output: 
Making a Widget 
*/

//: access/Widget.java 
package access; 
public class Widget { 
	public Widget() { 
		System.out.println("Making a Widget"); 
	} 
}

8.按照示例Lunch.java的形式，创建一个名为ConnectionManager的类，它管理一组固定的Connection对象。 客户端程序员必须无法创建Connection对象，而只能通过ConnectionManager中的静态方法获取它们。 ConnectionManager用完时会返回空引用。 测试main（）中的类。

import access.connection.*; 

public class E08_ConnectionManager { 
	public static void main(String args[]) { 
		Connection c = ConnectionManager.getConnection(); 
		while(c != null) { 
			System.out.println(c); 
			c.doSomething(); 
			c = ConnectionManager.getConnection(); 
		} 
	} 
}

输出：

Connection 0 
Connection 1 
Connection 2 
Connection 3 
Connection 4 
Connection 5 
Connection 6
Connection 7 
Connection 8 
Connection 9

//: access/connection/Connection.java 
package access.connection; 
public class Connection { 
	private int id = counter++; 
	Connection() {} 
	public String toString() { 
		return "Connection " + id; 
	} 
public void doSomething() {} 
} ///:~ 
//: access/connection/ConnectionManager.java 
package access.connection; 
public class ConnectionManager { 
	private static Connection[] pool = new Connection[10]; 
	static { 
		for(int i = 0; i < pool.length; i++) 
	} 
 // Very simple -- just hands out each one once: 
 public static Connection getConnection() { 
	if(counter < pool.length) 
		return pool[counter++]; 
	return null; 
	} 
}