thinking in Java 练习（访问权限控制）

练习一：在某个包中创建一个类，在这个类所处的包的外部创建该类的一个实例。

package access.mypackage;
/**
 * Mypackage
 * D:\java代码\9_19\access\mypackage
 */
public class Mypackage {

    public Mypackage(){
        System.out.println("hello");
    }
}

import access.mypackage.Mypackage;
/**
 * Unpackage
 * D:\java代码\9_19
 */
public class Unpackage {

    public static void main(String[] args) {
        Mypackage m=new Mypackage();
    }
}

练习二：创建两个包:debug和debugoff，它们都包含一个相同的类， 该类有一个debug()方法。第一个版本显示发送给控制台的String参数， 而第二个版本什么也不做。使用静态import语句将该类导入一个测试程序中，并示范条件编译效果

/**
 * Test2
 */
public class Test2 {

    public static void main(String[] args) {
        access.debug.Debug.debug("hello");
        access.debugoff.Debug.debug("haha");
    }
}

package access.debug;
/**
 * Debug
 */
public class Debug {

    public static void debug(String s){
        System.out.println(s+" 555");
    }
}

package access.debugoff;
/**
 * Debug
 */
public class Debug {

    public static void debug(String s){
    }
}

打印结果：hello 555

练习三：展示protected方法具有包访问权限，但不是public。
具有包访问权限：

public class Cookie {
    public Cookie() {
		System.out.println("Cookie contstructor");
	}
	protected void bite() { System.out.println("bite"); }
}

public class CookieMonster {
	public static void main(String[] args) {
		Cookie x = new Cookie();
		x.bite(); // package access to protected method
	}	
}

结果Cookie contstructor bite

但不是public

import access.cookie2.Cookie;
/**
 * CookieThief
 */
public class CookieThief {

    public static void main(String[] args) {
        Cookie x=new Cookie();
        //！ x.bite();//无法访问public
    }
}

练习四：创建一个带有public，private，protected和包访问权限域以及方法成员的类。创建该类的一个对象，看看在你试图调用所有类成员时，会得到什么类型的编译消息。请注意，处于同一目录中的所有类都是默认包的一部分。

public class FourWays {

    int a=0;
    public int b=1;
    protected int c=2;
    private int d=3;
    FourWays(){
        System.out.println("forways constructor");
    }
    void showa(){
        System.out.println(a);
    }
    public void showb(){
        System.out.println(b);
    }
    protected void showc(){
        System.out.println(c);
    }
    private void showd(){
        System.out.println(d);
    }
}

public class AccessTest {

    public static void main(String[] args) {
        FourWays fw=new FourWays();
        fw.showa();
        fw.showb();
        fw.showc();
        fw.a=10;
        fw.b=20;
        fw.c=30;
        fw.showa();
        fw.showb();
        fw.showc();
    }
}

结果：

forways constructor
0
1
2
10
20
30

练习五：创建一个带有protected数据的类。运用在第一个类中处理protected数据的方法在相同的文件中创建第二个类。

class SomeDate{
    protected int a=13;
}
class DateChanger{
    static void change(SomeDate sd,int i){
        sd.a=i;
    }
}

/**
 * ProtectedDate
 */
public class ProtectedDate {

    public static void main(String[] args) {
        SomeDate x=new SomeDate();
        System.out.println(x.a);
        DateChanger.change(x, 99);
        System.out.println(x.a);
    }
}

练习六：根据描述access和Widget的代码片段创建类库。在某个不属于access类库的类中创建一个Widget实例。

import access.*;
/**
 * MakeWidget
 * D:\java代码\9_19(2)
 */
public class MakeWidget {

    public static void main(String[] args) {
        Wiget w=new Wiget();
    }
}

package access;
/**
 * Wiget
 * D:\java代码\9_19(2)\access
 */
public class Wiget {

    public Wiget(){
        System.out.println("Widget()");
    }
}

练习7：效仿示例Luch.java的形式，创建一个名为ConnectionManager的类，该类管理一个元素为Connection对象的固定数组。客户端程序员不能直接创建Connection对象，而只能通过ConnectionManager中的某个static 方法来获取它们。当ConnectionManager之中不再有对象时，它会返回null引用。在main()之中检测这些类。

class Connection{
    private static int count=0;
    private int i=0;
    private Connection(){
        System.out.println("connection()");
    }
    //允许通过创建静态方法
    static Connection makeConnection(){
        count++;
        return new Connection();
    }
    public static int houMany(){
        return count;
    }
    public String toString(){
        return ("connection "+count);
    }
}
/**
 * ConnectionManager2
 */
public class ConnectionManager2 {

    static int howManyLeft=3;
    static Connection[] ca=new Connection[3];
    {
        for(Connection x:ca){
            x=Connection.makeConnection();
        }
    }
    public static Connection getConnection(){
        if(howManyLeft>0){
            return ca[--howManyLeft];
        }
        else{
            System.out.println("no more connection");
            return null;
        }
    }
    public static void main(String[] args) {
        ConnectionManager2 cm=new ConnectionManager2();
        System.out.println(cm.howManyLeft);
        cm.getConnection();
        System.out.println(howManyLeft);
        cm.getConnection();
        System.out.println(howManyLeft);
        cm.getConnection();
        System.out.println(cm.getConnection());
        System.out.println(howManyLeft);

    }
}

结果：

connection()
3
2
1
no more connection
null
0

练习8：在access/local目录下编写以下文件：

//  access/local/PackagedClass.java
package access.local:

class PackagedClass{
	public PackagedClass(){
		Sysout.out.println("creating a packaged class");
	}
}

然后在accless/local之外的另一个目录中创建下列文件

// access/foreign/Foreign.java
package access.foreign;
import access.local.*;

public class Foreign{
	public static void main(String[] args){
		PackagedClass pc=new PackagedClass();
	}
}

解释一下为很么编译器会产生错误。
编译器会产生错误的原因，PackagedClass具有包访问权限，在该包外的其他类无法访问
如果将Foreign放入access.local包之中，因为在一个包，就可以访问