java编程思想第4版 第六章习题

练习1：

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

//创建的包
package TestPackage;

public class TestFirstClass {
    public TestFirstClass() {
        System.out.println("create TestFirstClass");
    }
}

//包外调用
import TestPackage.TestFirstClass;

public class TestConstructor {
    public static void main(String[] args) {
        TestFirstClass testFirstClass = new TestFirstClass();
    }
}

输出

create TestFirstClass

练习2：

将本节中的代码片段改写为完整的程序，并校验实际所发生的冲突（不同包名中含有相同的类，调用时出现冲突，需要写完整的包名）
代码

//新创建的Ve
package TestPackage;

public class Vector {
    public Vector() {
        System.out.println("this is my Vector");
    }
}

//包外调用
import TestPackage.*;
//使用导包导入特定的类会优先选择导入的类
//import TestPackage.Vector;

//import java.util.*;

public class TestConstructor {

    public static void main(String[] args) {
        Vector myVector = new Vector();
        //创建了java.util的Vector，如果用import导包将会报错
        java.util.Vector vector = new java.util.Vector();
        System.out.println("create java.util.Vector:" + vector + "");
    }
}

输出

this is my Vector
create java.util.Vector:[]

练习3：

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

package debug;

//测试代码
public class TestDebug {
    public TestDebug() {
        System.out.println("I am from debug");
    }

    public static void debug() {
        System.out.println("do a debug");
    }
}

import static debug.TestDebug.*;
public class TestConstructor {

    public static void main(String[] args) {
        debug();
    }
}

输出

do a debug

代码

package debugOff;

public class TestDebug {
    public TestDebug() {
        System.out.println("I am from debugOff");
    }

    //do nothing
    public static void debug() {

    }
}

import static debugOff.TestDebug.*;
public class TestConstructor {

    public static void main(String[] args) {
        debug();
    }
}

输出

练习4：

展示protected方法具有包内访问权限，但不是public。

代码

package debugOff;

public class TestDebug {
    public TestDebug() {
        System.out.println("I am from debugOff");
    }

    //do nothing
    public static void debug() {

    }

    protected static void testMethod() {
        System.out.println("this is a test");
    }
}

package debugOff;
import static debugOff.TestDebug.*;

public class TestOtherClass {

    public static void main(String[] args) {
        //正常运行
        testMethod();
    }
}

import static debugOff.TestDebug.*;
public class TestConstructor {

    public static void main(String[] args) {
        //编译报错
//        testMethod();
    }
}

练习5：

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

package debugOff;

public class TestDebug {
    public TestDebug() {
        System.out.println("I am from debugOff");
    }

    //do nothing
    public static void debug() {
        System.out.println("public");
    }

    protected static void testMethod() {
        System.out.println("protected");
    }

    static void testMethod2(){
        System.out.println("default");
    }

    private static void testMethod3(){
        System.out.println("private");
    }
}

package debugOff;
import static debugOff.TestDebug.*;

public class TestOtherClass {

    public static void main(String[] args) {
        //正常运行
        debug();
        testMethod();
        testMethod2();
        //不可调用
//        testMethod3();
    }
}

练习6：

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

package testPackage;

public class ProtectedSong {

    protected static String song = "版权歌曲";

    protected void out() {
        System.out.println(song);
    }
}

package testPackage;

public class TheOtherClass {

    public void getSong(){
        ProtectedSong song = new ProtectedSong();
        song.out();
    }

    public static void main(String[] args) {
        TheOtherClass theOtherClass = new TheOtherClass();
        theOtherClass.getSong();
    }
}

输出

版权歌曲

练习7：

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

package testPackage;

public class TestClass {
    public TestClass() {
        System.out.println("TestClass");
    }
}

import testPackage.TestClass;

public class TestConstructor {

    public static void main(String[] args) {
        TestClass testClass = new TestClass();
    }
}

输出

TestClass

练习8：

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

代码

import java.util.Arrays;

public class ConnectionManager {

    private static Connection[] connections = new Connection[]{new Connection(0), new Connection(1), new Connection(2), new Connection(4), new Connection(5)};

    public static Connection getConnection() {
        if (connections.length > 0) {
            Connection connection = connections[connections.length - 1];
            connections = Arrays.copyOf(connections, connections.length - 1);
            System.out.println("I am " + connection.no);
            return connection;
        }
        System.out.println("over");
        return null;
    }

    public static class Connection {
        private final int no;

        private Connection(int i) {
            this.no = i;
        }
    }
}

public class TestConstructor {

    public static void main(String[] args) {
        while (true) {
            ConnectionManager.Connection connection = ConnectionManager.getConnection();
            if (connection == null) {
                break;
            }
        }
    }
}

输出

I am 5
I am 4
I am 2
I am 1
I am 0
over

练习9：

编写下面的代码

代码

package access.local;

class PackagedClass {
    public PackagedClass() {
        System.out.print("create a package class");
    }
}

package access.local;

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

package access.foreign;
//import access.local.PackagedClass;

public class ForeignMain {
    public static void main(String[] args) {
        //报错，只能包内访问
//        PackagedClass packagedClass = new PackagedClass();
    }
}