《Java语言程序设计与数据结构（基础篇）》第11版复习题答案——第九章至13章（主要部分）

类和对象

9.3.1：

类为对象定义属性和行为，而对象从类中创建。

9.3.2：

public class ClassName {
​
}

9.3.3：

ClassName objectRefVar;

9.3.4:

new ClassName();

9.4.1：

构造方法是一种特殊的方法。构造方法必须和所在类名字相同，构造方法没有返回值，甚至连void也没有，构造方法是在创建一个对象时由new操作符调用的，构造方法的作用是初始化对象。

9.4.2:

当且仅当类中没有明确定义任何构造方法时才会自动提供默认构造方法。

9.4.3：

a和b都是无构造方法而调用有参构造方法。

9.4.4：

A中是有参构造方法，Test中创建（new）时候缺少参数。

9.5.1：

在java中，数组被看做对象。数组可以包含对象类型的元素。在数组中，数值类型数据域的默认值是0，boolean类型数据域的默认值是false，char类型数据域的默认值是‘\u0000’，对象元素类型数据域的默认值是null。

9.5.2：

操作符（.）用于访问对象的数据域或者调用对象的方法。

9.5.3：

匿名对象是指对象在创建后并不需要引用的对象。是指可以创建一个对象，而并不将它明确地赋予一个变量。

9.5.4：

NullPointException是一种常见的运行时错误，当调用值为null的引用变量上的方法时会发生此类异常。再通过引用变量调用一个方法之前，确保先将对象引用赋值给这个变量。

9.5.5：

a: x() 不是ShowErrors类中的方法。b: 程序可以编译，但运行时错误。因为在执行println语句时c的数据域没有任何引用对象，这个数据域有一个特殊的引用值null。

9.5.6：

false

9.6.1：

可以使用Data类中的无参构造方法为当前的日期和时间创建一个实例，他的getTime（）方法返回自GMT时间1970年1月1日算起至今流逝的时间。

9.6.2：

使用它的构造函数Point2D（x，y）在（x，y）处创建Point2D对象，使用P1.distance（P2）获得p1和p2之间的距离。使用p1.midpoint（p2）获得p1和p2之间的中点。

9.6.3：

Data和Random在java.util包中，Point2D在javafx.geometry包中，System和Math在java.lang包中。

9.7.1：

System.out.println（f.i）；
​
System.out.println（f.s）；
​
f.imethod；
​
f.smethod:
​
System.out.println（F.s）；
​
F.smethod（）；是正确的

9.7.2：

void main之前和int factorIcal之前可以添加static。

因为这两个方法不需要引用任何实例对象或调用Test类中任何实例方法。

9.7.3：

不可以从静态方法中调用或引用一个实例变量，可以从实例方法中调用静态方法或引用一个静态变量。

下面代码错误在method2是一个静态方法，c是一个实例变量，不可以从静态方法中调用或引用一个实例变量。

9.9.1：

私有数据域不能被对象从定义该私有域的类外访问。但是经常会有客户端需要存取，修改数据域。为了访问私有数据域，可以提供一个获取（getter）方法返回数据域的值。为了更新数据域，可以提供一个设置（setter）方法给数据域设置新值。获取方法也称为访问器（accessor），而设置方法称为修改器（mutator）。访问器方法用于检索私有数据值，访问器方法用于更改私有数据值。

访问器方法的命名习惯是：非布尔型： getPropertyName（）；

布尔型为：isPropertyName（）；

修改器的命名习惯是：setPropertyName（dataType propertyValue）；

9.9.2：

防止数据被篡改，使类更易于维护。

9.9.3：

不会有问题，私有数据可以在定义它们的类中被访问。

9.10.1：

Count is 101，times is 0。

9.10.2：

circle1 = 1 circle2 = 2；circle1 = 2 circle2 = 1。

9.10.3：

（a）a[0] = 1 a[1] = 2；

（b）a[0] = 2 a[1] = 1；

（c）e1 = 2 e2 = 1；

（d）t1’s i = 2 t1’s j = 1；t1’s i = 2 t1’s j = 1

9.10.4：

（a）null

（b）1234567

（c）7654321

（d）1234567

9.11.1：

dates[0]为null，所以第五行的代码将导致NullPointerException错误，因为null调用了toString方法。当调用值为null的引用变量上的方法时会发生NullPointerException错误。

9.12.1：

如果类中的所有数据域是私有的基本数据类型，并且类中没有包含任何设置方法，该类不会改变。

9.12.2：

如果类中仅包含私有数据域并且没有设置 set 方法，该类没有不可变，它还必须没有返回一个指向可变数据域的引用的访问器方法。

9.12.3：

可以改变，因为值是数组，数组是引用类型，所以下面的类可以改变。

9.13.1：

i + j is 23；k is 2；j is 0。

9.14.1：

关键字this是一个对象可以用来引用自身的引用名。

9.14.2：

第四行和第五行交换，因为java要求，在构造方法中语句this（arg-list）应在任何其他可执行语句之前出现。

第十行和第十四行都将p = p改为this.p = p。

9.14.3：

Test.id = 45错了；因为id是实例变量，不是静态变量，不可以从类中访问。

面向对象

10.2.1:

没有，Loan类具有返回loanDate的getLoanDate（）方法。LoanDate是Date类的对象。由于日期是可变的，所以是可以更改LoanDate的内容。

10.3.1：

程序清单10-4中的 BMI 类是不可变的。

10.4.1:

类之间常用的关系是关联，聚合，组合和继承关系

10.4.2:

*关联：*是一种常见的二元关系，描述两个类之间的活动

*聚集：*聚集是关联的一种特殊形式，代表两个对象之间的归属关系。聚集对has_a关系进行建模

*组合：*如果聚集对象依赖聚集对象，则为组合。换句话说，被聚集对象不能单独存在。聚集没有共同的生命周期，而组合有共同的生命周期。

10.4.3:

在 UML 中，附加在聚集类上的实心菱形表示它和被聚集类之间具有组合关系；而附加在聚集类上的空心菱形表示它与被聚集类之间具有聚集关系。

10.4.4：

由于聚合和组合关系是以同样的方式使用类来表示，所以我们不会区分它们，并且为了简单而调用这两种组合。

10.7.1：

将基本数据类型合并为或者说包装为对象。包装类没有无参构造方法。所有包装类的实例都是不可变的。

10.7.2：

a. Integer i = new Integer(“23”);成功

b. Integer i = new Integer(23); 成功

c. Integer i = Integer.valueOf(“23”);成功

d. Integer i = Integer.parselnt(“23”, 8); 成功

e. Double d = new Double（）; 不成功

f. Double d = Double.value0f(“23.45”);成功

g. int i =(Integer.valueOf(“23”)).intValue();成功

h. double d «(Double.valueOf(“23.4”)).doubleValue（）;成功

i. int i =(Double.valueOf(“23.4”)).intValueO; 成功

j. String s =(Double.valueOf(“23.4”)).toString（）; 成功

10.7.3:

使用Integer（int）.toString（）将整数转换为字符串，如果要将数字字符串转换成整数，可以使用Integer.parselnt（S）。使用Double(Double).toString()将Double转换成String，如果要将数字字符串转换成Double值，Double,parseDouble(S)。

10.7.4:

输出结果为：

3

-1

10.7.5:

输出结果为：

10

10

16

11

11

17

10.8.1:

a. Integer x = 3 + new Integer(S); 正确

b. Integer x = 3; 正确

c. Double x = 3; 错误

d. Double x = 3.0; 正确

e. int x = new Integer(3); 正确

f. int x = new Integer(3) + new Integer(4); 正确

10.8.2:

输出结果为：

3

-1

10.9.1:

输出结果为：

X is 3

Y is 7

Z is 10

10.10.1:

输出结果为：

True

False

True

True

True

Welcome to HTML

WelcTme tT Java

WelcTme tT Java

WelcTme to Java

W, e, l, c, o, m, e,t,o,J,a,v,a

10.10.2:

String s = “Welcome to Java”更好，因为字符串是一个不可变的类，String类中的任何方法都不能更改字符串的内容。

10.10.3:

输出结果为：

Welcome to Java

Welcabcme tabc Java

10.10.4:

String s2 = s1.replace(‘e’,’E’);

String tokens = “Welcome to Java and HTML”.split(‘ ’);

S1 = tokens[0];

S2 = tokens[1];

10.10.5:

String类中没有可以改变字符串内容的方法。

10.10.6:

s是用new String（）创建的，那么s.length（）是等于0.

10.10.7：

在String类中使用重载的静态值方法。

10.10.8：

在第二行声明为成员变量，在第五行重新声明为局部变量。局部变量传递给构造函数的字符串是"ABC"，成员变量认为NULL。在第十行的test.Text为NULL，这将在调用toLowerCase（）时导致NullPointerException。

10.10.9：

构造函数错误，应去掉void

10.10.10：

输出结果为：

False

True

A,B;C

A#B#C

A B C

10.10.11：

输出结果为:3

10.11.1：

JDK中引入的StringBuilder类与StringBuffer类似，只是StringBuffer中的更新方法是同步的。

10.11.2：

使用StringBuilder的构造函数为字符串创建字符串缓冲区，并使用StringBuilder类中的toString方法从StringBuilder返回字符串。

10.11.3：

StringBuilder sb = new StringBulider(s);

sb.reverse();

s = sb.toString();

10.11.4：

StringBuilder sb = new StringBulider(s);

sb.delete(4,10);

s = sb.toString();

10.11.5：

字符串和字符串缓冲区都是使用数组来保存字符。创建字符串后，字符串中的数组是固定的。如果缓冲区容量发生变化，则字符串缓冲区中的数组可能会发生变化，为了适应改变，将创建一个新的数组。

10.11.6：

输出结果为：

a)Java is fun

b)JavaHTML

c)Jais funva

d)JHTMLava

e) v

f) 4

g) Jav

h) Ja

i) avaJ

j) JComputera

k) av

l) va

10.10.7：

输出结果为：

Java

Java and HTML

继承与多态

11.2.1：

一个子类是父类的子集，说法是false

11.2.2：

extend。

11.2.3：

某些程序设计语言是允许从几个类派生出一个子类的。这种能力称为多重继承

( multiple inheritance)。但是在 Java 中是不允许多重继承的。一个 Java 类只可能直接继承自一个父类。这种限制称为单一继承（ single inheritance)。

11.3.1：

a）中类的输出结果为：A’s no-arg constructor is invoked ;

b) 创建B类的对象时，首先会构造B类的函数，在该程序内，是构造B类的无参构造函数，但在构造B类前，会首先构造父类A类的无参构造函数，因为A类显式的定义了构造方法，所以没有无参构造方法。

11.3.2：

利用super关键字调用父类的构造方法，super（）或者super（argument)。

11.3.3：

false，如果父类的显式的定义了构造方法，那么在子类构造无参方法前，无法调用父类的无参构造方法。

11.4.1：

false，只能重写父类的可访问的方法

11.4.2：

false，静态方法能被继承，但是不能被重写。

11.4.3：

利用super（）或者super（arguments），而且super语句必须写在第一行。

11.4.4：

利用super.method()或者super.method(args).

11.5.1：

第5行：this.radius = radius;

第21行：super(radius);

第22行：this.length = length;

第27行：super.getArea() * length;

11.5.2：

重载意味着使用同样的名字但是不同的签名来定义多个方法。重写意味着在子类中提供一个对方法的新的实现。

方法重写发生在通过继承而相关的不同类中；方法重载可以发生在同一个类中，也可以发生在由于继承而相关的不同类中。

方法重写具有同样的签名和返回值类型；方法重载具有同样的名字，但是不同的参数列表。

11.5.3：

方法重写。

11.5.4：

这将是一个语法错误。(返回值类型 方法名 参数列表 都相同)

11.5.5：

方法重载。

11.5.6：

它强制编译器检查重写方法的签名，以确保正确定义该方法。

11.8.1：

多态意味着父类的变量可以指向子类对象。方法可以在沿着继承链的多个类中实现。JVM 决定运行时调用哪个方法，这就是动态绑定。

11.8.2：

匹配方法的签名和绑定方法的实现是两个不同的问题。引用变量的声明类型决定了编译时匹配哪个方法。在编译时，编译器会根据参数类型、参数个数和参数顺序找到匹配的方法。

一个方法可能在沿着继承链的多个类中实现java 虚拟机在运行时动态绑定方法的实现，这是由变量的实际类型决定的。

11.8.3：

new int[50]不能赋值给Object[]类型的变量，但是new Integer[50],new String[50]或者new Object[50]可以赋值给Object[]。

11.8.4：

第8行错误，因为int[]不能赋值给Object[].

11.8.5：

输出结果为：

（a）Person Student

（b）Person Person

11.8.6：

输出结果为：B’s constructor is invoked A’s constructor is invoked

在调用new A（3）时，将调用对象的默认构造函数，再执行B的构造函数中的任何语句前调用对象的构造函数。

11.8.7：

输出结果为：

I from A is 40；

I from A is 60;

I from B is 60;

11.9.1：

True :总可以将子类实例转换为父类；

False ：父类的实例不一定都可以转换成子类。

11.9.2：

a. ,

(circle instanceof GeometricObject) true

(object instanceof GeometricObject) true

(circle instanceof Circle) true

(object instanceof Circle) false

b. 下面的语句能够成功编译吗？

Circle circle = new Circle(5); 可以成功编译

GeometricObject object = circle;

c. 下面的语句能够成功编译吗？ 不能成功编译

GeometricObject object = new GeometricObjectO;

Circle circle = (Circle)object;

11.9.3：

A）true

B）false

C）true

D）true

E）false

F）true

G）true

H）false

I）可以 ； 不可以

J）可以 ； 不可以

K）不合法

L）不合法

M）合法

11.9.4：

语句Object apple = (Apple)fruit;会导致ClassCastingException错误。

11.10.1：

是的，每一个对象都有toString方法和equals方法，因为他们来自Object类，并且他们也是java类所可以访问的，重写这些方法合适。

11.11.1：

输出结果为：

a）False b）True

11.11.2：

A) ArrayList<Double> list = new ArrayList ();

B) list.add(object);

C) list.add(0, object);

D) list.size();

E) list.remove(object);

F) list.remove(list.size() - 1);

G) list.contains(object);

H) list.get(index)

11.11.3：

list.add(new java.util.DateO);错误，因为你创建的是字符串数组，而不是Date类型的数组；

list.set(3,“Dallas”)；System.out println(list.get(3)); 语句错误，因为无法找到下标为3的数组元素。

11.11.4：

调用一次list.remove(“Dallas”)后的列表为{“Dallas”，“Houston”，“Dallas”}，

修改列表，使得删除所有具有值“Dallas”。

for (int I = 0; I < list.size(); i++){

if (list.remove(“Dallas”))

i–-;

}

11.11.5：

因为ArrayList类有两种重载方法，分别是remove（index）和remove（object），所以list.remove(1)表示去除下标为1的元素，所以结果为[2, 3]

11.11.6：

是double型的数据，所有改为list.add(1.0);

11.12.1：

改为：

Integer[] array = {3, 5, 95, 4, 15, 34, 3, 6, 5};
ArrayList<Integer> list = new ArrayList<> (Arrays.asList(array));

11.12.2：

改为：

Integer[] array = {3, 5, 95, 4, 15, 34, 3, 6, 5};
System.out.println(java.util.Collections.max(Arrays.asList(array)));

11.14.1：

default修饰符

11.14.2:

protected修饰符

11.14.3:

可以； 不可以； 可以

11.14.4:

不可以； 不可以； 可以

11.15.1:

使用final关键字。

11.15.2:

a)true

b)false

c)true

d)true

e)false

f)false

异常处理和文本IO

12.2.1：

它能使方法抛出一个异常给它的调用者，并由调用者处理该异常。如果没有这个能力，那么被调用的方法就必须自己处理异常或者终止该程序。被调用的方法通常不知道在出错的情况下该做些什么，这是库方法的一般情况。库方法可以检测出错误，但是只有调用者才知道出现错误时需要做些什么。

异常处理最根本的优势就是将检测错误（由被调用的方法完成）从处理错误（由调用方法完成）中分离出来。

12.2.2：

第一条语句：System.out.println(1 / 0)；会抛出异常。

第二条语句：System.out.println(1.0/ 0)；不会抛出异常。

因为Java在处理表达式计算时，默认对整数型0转型成0.0，而浮点数在计算机内是无法绝对精确的表示的，因此这个0.0在计算机内部只是一个接近0的极小浮点值而已，所以很容易的可以想出为什么输出Infinity。

同样的取模运算%也存在这个问题。

12.2.3：

将Long.MAX_VALUE加上1会超出long值的范围，但是当前的java没有把这种情况报告为例外，故不会抛出异常。

12.2.4：

出现异常时，JVM会抛出异常，如果需要捕获异常，可以编写try-catch语句。

12.2.5：

如果value = 30，则输出结果为：

Value is too small

Continue after the catch block

如果value = 50，则输出结果为：

Continue after the catch block

12.2.6：

输出结果为：

a)0 1

b)0

12.3.1：

Throwable 类是所有异常类的根。所有的 Java 异常类都直接或者间接地继承自Throwable。这些异常类可以分为三种主要类型：系统错误Error、异常Exception和运行时异常RuntimeException。

12.3.2：

将抛出异常名为：

a）ArithmeticException

b）IndexOutOfBoundsException

c）IndexOutOfBoundsException

d）ClassCastException

e）NullPointerException

f）No exception

12.3.3:

*必检异常：*除RuntimeException和Error及其子类的异常都是必检异常。编译器会强制程序员必须捕获处理或者继续抛出

*免检异常：*RuntimeException和Error及其子类都是免检异常。

12.4.1：

声明异常的目的是告诉java运行时系统可能会出现的异常情况，可以在方法声明中使用抛出关键字声明异常，可以声明多个异常，用逗号隔开。

12.4.2:

使用方法中抛出语句抛出异常，即throw（exceptionName），不可以在throw语句中抛出多个异常。

throw语句抛出的不是异常类，而是一个异常实例，而且每次只能抛出一个异常实例。

12.4.3：

关键字throw是抛出异常的关键字，关键字throws是声明异常的关键字。

12.4.4：

1）不会执行statement3.

2）不会执行statement4，因为try语句执行完后程序就结束了。

3）会执行statement4.

12.4.5：

显示：RuntimeException

12.4.6：

显示：ArithmeticException

12.4.7：

显示：RuntimeException in method()

After the method call

12.4.8：

getMessage()在Throwable类中被定义，以返回描述异常的字符串。

12.4.9：

若要向控制台显示跟踪信息，可以执行的操作。

12.4.10：

没有异常发生时，try-catch 块的存在不会引起额外的系统开销。

12.4.11：

代码修改为：

 public void m(int value) throws Exception{
​
    if(value < 40)
​
    throw new Exception(“value is too small”);
}

12.5.1：

a. statement1、2、3、5、6、7。

b. statement1、4、5、6、7。

c. statement1、5。

d. statement1。

12.6.1：

该方法是正确的，但是有一点，不要把异常处理用作简单的逻辑测试。

public static Boolean isNumeric(String token) {
​
    for (int I = 0; I < token.length(); i++) {
​
        if (!(token.chatAt(i) >= ‘0’&& token.chatAt(i) <= ‘9’)) {
            return false;
        }
    }
return true;
}

12.7.1：

a.如果没有异常发生，会执行语句 statement4,也会执行语句 statement5。

b.如果异常类型是 Exceptionl，会执行 statement4，也会执行 statement5.

c.如果异常类型是 Exception2，会执行 statement4 ，不会执行 statement5。

d.如果异常类型不是 Exceptionl以及 Exception2 类型的，那么会执行 statement4 ，不会执行 statement5 。

12.8.1：

输出结果为：

java.lang.Exception: New info from methodl
​
at ChainedExceptionDemo.methodlfChainedExceptionDemo.java:16)
​
at ChainedExceptionDemo.main(ChainedExceptionDemo.java:4)

12.9.1:

通过继承java.lang.Exception类来定义异常类。

12.9.2：

输出结果为：

Exception in method（）

Exception in main

12.10.1：

在 Windows 中目录的分隔符是反斜杠（‘\’)。但是在 Java 中，反斜杠是一个特殊的字符，应该写成'/'或“\\"的形式，故改为：new File（“c：/book/test.dat”）;

12.10.2:

创建一个file对象，利用file.exists()表示文件是否存在,file.delete()表示删除文件,file.renameTo(File)表示重命名文件名，使用file.length()表示获得文件的大小。

12.10.3:

不能使用File类进行输入/输出，File类可用于获取文件的属性和操作文件；

不是创建一个 File 对象就是在磁盘上创建一个文件。

12.11.1:

创建对象

 PrintWriter output = new PrintWriter(FileName);

以向文件写数据。此语句可能引发异常，java迫使你编写代码来处理异常，处理它的一种方法是在方法声明中声明抛出异常。

如果不调用close（）方法，则可能无法正确保存数据。

12.11.2:

输出结果为：

amount is 32.320000 3.232000e+01

amount is 32.3200 3.2320e+01

False

Java

12.11.3:

public class Test {
​
    public static void main (String[] args) throws Exception {
        
        try(java.io.PrintWriter output = new java.io.PrintWriter(“temp.txt”)) {
            output.printf(“amount is %f %e\r\n”, 32.32, 32.32);
            output.pr1ntf(“amount 1s %5.4f %5.4e\r\n, 32.32,32.32);
            output.printf(”%6b\r\n",(1 > 2));
            output.printf(“%6s\r\n”,“java”);
            output.close();
        }
    }
}

12.11.4:

 Scanner input = new Scanner(FileName);

从文件读取数据。Main方法中的语句可能会引发异常，java你迫使编写代码来处理异常，处理异常的一种方法就是在方法声明中声明抛出异常。

如果不调用close（）方法，则可能无法正确保存数据。

12.11.5:

如果试图对一个不存在的文件创建 Scanner，程序将会出现异常；如果试图对一个已经存在的文件创建 PrintWriter，则现有的文件内容将消失。

12.11.6:

不同平台上的行分隔符不同，windows平台上的行分隔符是\n.

12.11.7:

intValue = 45; doubleValue = 57.8; line = ‘’‘7’‘8’‘9’。

12.11.8:

intValue = 45; doubleValue = 57.8; line = ''。

12.12.1:

创建一个URL对象，并使用行动Scanner（url.openStream()）创建一个Scanner对象，用于读取URL流中的数据。

12.13.1:

有可能包含重复的URL。假设链接1不在listOfTraverseURL中，但它可能在一个页面中出现不止一次。这样的重复链接1将添加到listOfPendingURL中。

抽象类与接口

13.2.1：

e和f是合法的抽象类。

13.2.1：

其好处是适用于通用编程，GeometricObject类型的变量在编译时使用getArea（）和getPerimeter（）方法。

13.2.1：

输出结果为：

True
True
False
False
True

13.3.1：

在运行时，java虚拟机将尝试将numberRef转换为Double对象，但是numberRef是Integer的一个实例，而不是Double。

13.3.2：

数组numberArray是Integer对象的数组，而非Double对象的数组

13.3.3：

输出结果：3 3.0

13.3.4：

会出现语法错误，x没有compareTo方法。

13.3.5：

会出现语法错误，因为成员操作符在对象转换操作符之前完成。

13.4.1：

不能，Calendar是一个抽象类。

13.4.2：

Calendar方法中的add方法是抽象的。

13.4.3：

使用GregorianCalendar类的构造函数来创建Calendar对象。

13.4.4：

c.get(Calendar.YEAR)

c.get(Calendar.MONTH)

c.get(Calendar.DAY_OF_MONTH)

c.get(Calendar.HOUR)

c.get(Calendar.MINUTE)

c.get(Calendar.SECOND)

13.5.1：

不能。

13.5.1：

可以。

13.5.3：

d是正确的接口。

13.5.4：

所以定义在接口的方法必须为public的，当类实现接口时，方法必须声明为public，能见度不能降低，故在void m1（）前加上public。

13.6.1：

true

13.6.2：

第一个：public int compareTo （String o）

13.6.3：

不能，因为n1是Integer对象，其compareTo方法需要Integer参数，但n2被声明为Object对象，编译器将引发错误。

13.6.4：

通过实现可比较的接口，可以将类的对象传递给需要比较类型的方法。

13.6.5：

Person类没有实现Comparable接口，所以Person对象无法通过sort方法比较。

13.7.1：

如果一个对象的类没有实现 java.lang.Cloneable , 不可以调用 clone() 方法来克隆这个对象；Date类实现了Cloneable接口。

13.7.2：

语法错误。

13.7.3：

输出结果为：

True
False
True

13.7.4：

输出结果为：

True
False
List is [New York, Atlanta]
List1 is [New York, Atlanta]
List2.get(0) is New York
List2.size() is 1

13.7.5：

语法错误，因为clone（）在对象中受到保护，要启用clone（）可以执行两件事：

（1）为要克隆的对象覆盖类中的clone（）；

（2）为类实现java.lang.Cloneable。

13.7.6:

false

版权声明：本文为CSDN博主「王陈锋」的原创文章笔者做了整体美化和部分纠正，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：《Java语言程序设计与数据结构（基础篇）》第11版复习题答案_王陈锋的博客-CSDN博客_java语言程序设计 基础篇 答案