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;
}
}