thinking in java test chapter6练习（1）~（9）以及翻译问题

最新推荐文章于 2022-08-09 22:22:57 发布

歪歪许

最新推荐文章于 2022-08-09 22:22:57 发布

阅读量2.1k

点赞数 1

分类专栏： thinking in java test 文章标签： java

本文链接：https://blog.csdn.net/qq_35396447/article/details/52459758

版权

thinking in java test 专栏收录该内容

36 篇文章 2 订阅

订阅专栏

练习（1）：在某个包中创建一个类，在这个类所处的包外部创建该类的实例。
这里写图片描述
代码如下：

public class testTest6_1 {
    public static void main(String[] args){
        test6_1 example = new test6_1("num1");
        System.out.println(example.getName());
    }
}

public class test6_1 {
    public String name;

    public test6_1(String str){
        name = str;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

当我们在其他包中视图直接创建类test6_1时，代码提示找不到该类。这时就需要用import语句导入test6_1所在的包，然后就可以找到该类。
知识要点：
1，java包机制解决了命名空间问题，同一个包内每个类名不能相同。不同包之间可以有相同名字的类。
2，想要使用其他包的类，有两种做法，一是在类外部用import语句导包，二是在类内部使用时直接指出，比如在其他包的类中使用test6_1，thinkinginjavatest6.test6_1 xxx = new thinkinginjavatest6.test6_1();
既包名.类名 xxx = new 包名.类名

练习（2）:将本节中的代码片段改写成完整的程序，并检校实际发生的冲突。
如图：
这里写图片描述
我们在包thinkinginjavatest6中创建了一个Vector类。

在另一个包的某个测试类中，我们同时导入thinkinginjavatest6包和java.util包。然后在main中输入Vector，此时IDE会提示我们有multiple choise，一个是thinkinginjavatest6包中我们创建的Vector类，一个是java.util包中的Vector类，此时就有了冲突。
当然对于习惯用IDE的人来说，冲突好像不明显，因为往往在我们还没打完Vector这个单词，智能提示就会出来两个Vector供我们选择，后面有关于它们分别来自哪个包。我们这时只要选择一个即可。
当我们选择某个包的Vector类时，类外部的import语句就会高亮，而不相干的import语句不会起作用。
这里写图片描述
当然这时编译器帮我们区分了冲突，如果没有编译器，我们自己手动区别，如下：

做法同直接在类中导入一个包相同。

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

import debug.testdebug;
//import debugoff.*;
import debug.*;


/**
 * Created by lenovo on 2016/9/6.
 */
public class LibTest {
    public static void main(String[] args){
        testdebug testdebug = new testdebug();
        testdebug.debugoff(args);
    }
}

在这里，import语句就像一个开关一样，会影响testDebug.debugoff（）方法的调用结果。
当我们导入debug包，就会输出args，当我们导入debugoff包，就什么都不会输出。

练习（4）：展示protected具有包访问权限，而不是public。
我们知道private的权限是最小的，除了包含该成员的类外，其他任何类都无法访问到它。包括继承该类的子类，也无法访问到。
而public权限是最大的，任何类都可以访问到，当然不同包的类之间默认有包访问权限，所以还需要导包。
有时候我们会有这种需求，希望某个成员可以被该类的子类访问到，但不会被任何其他外部类访问到。这时用public肯定不行。用private也不行，无法被子类访问到。这时就有了protected这个关键字。
它也称为继承访问权限，被它声明的成员可以被子类访问，但不可以被其他任何类访问到。
那么protected有没有包访问权限呢？
我们在上个练习里使用的debug包里添加了一个类。
这里写图片描述
在debug包下的testdebug类里添加了一个方法：

public class testdebug {
    public static void debugoff(String[] str){
        for (String str1 :
                str) {
            System.out.print(str1);
        }
    }
    protected void f(){//测试能否被同包的其他类访问到。
        System.out.println("debug testdebug protected is fangwengdao");
    }
}

public class testtestedebug {
    public static void main(String[] args) {
        testdebug debug1 = new testdebug();
        debug1.f();
    }
}

代码运行结果输出debug testdebug protected is fangwengdao，说明protected声明的成员能被同一包内的其他不相干类访问到。所以protected具有包访问权限。

练习（5）：创建一个带有public,private,protected和包访问权限域以及方法成员的类。创建该类的一个对象，看看在你视图调用所有类成员时，会得到什么类型的编译信息。请注意，处于用一个目录中的所有类都是默认包的一部分。
我们将上一个练习的代码修改一下：

public class testdebug {
    protected void f(){
        int i = 20;
        System.out.println("debug testdebug protected is fangwengdao" + i);
    }

    public void mathodpublic(){
        int i = 5;
        System.out.println("public is fangwengdao" + i);
    }

    private void methodprivate(){
        int i = 10;
        System.out.println("private is fangwengdao" + 10);
    }
}

这里写图片描述
可以看到，可以顺利访问protected和public方法，但private的内容编译器报错，提示我们该成员是private的。访问方法内成员i也出错了。方法成员只在方法内部起作用，出了方法的域就无法被使用，因为在内存上它已经被删除了。

练习（6）：创建一个带有protected数据的类。运用在第一个类中处理protected数据的方法在相同的文件中创建第二个类。
（好吧，我是服了翻译了）英文原版原文如下:
这里写图片描述
像我这种勉强刚过4级的人都知道，这个题应该这样翻：
在同一个文件下创建第二个类，该类拥有一个能操作第一个类中protected数据的方法。
看来以后要少看中文版的书，要以英文原版的为准了。
我们在debug类里添加一个protected数据num 令其等于100.
在同一个包下创建一个新类：

public class manipulatedata {
    testdebug testdebug = new testdebug();
    public void f(){
        testdebug.num ++;
        System.out.println(testdebug.num);
    }
}

运行后控制台输出101。

练习（7）：根据描述access和Widget的代码片段创建类库。在某个不属于access类库的类中创建一个Widget实例。这个其实就是improt的应用，不重复了。

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

public class ConnectionManager {
    public static void main(String[] args){
        Connection connection = ConnectionManager.getConnection();
        Connection connection1 = ConnectionManager.getConnection();
        Connection connection2 = ConnectionManager.getConnection();
        Connection connection3 = ConnectionManager.getConnection();
        Connection connection4 = ConnectionManager.getConnection();
    }
    private static int count = 0;
    private static Connection[] connections = new Connection[]{
                            Connection.get(),
                            Connection.get(),
                            Connection.get()};
    public static Connection getConnection(){
        if (count < 3){
            ConnectionManager.count++;
            return connections[count--];
        } else {
            System.out.println("no more");
            return null;
        }
    }
}

class Connection {
    private Connection(){//构造方法私有，无法被直接通过构造方法创建
        System.out.println("connection is created");
    }
    private static Connection connection;
    public static Connection get(){
        return new Connection();
    }
}