中国大学Java程序设计_33期末答案(mooc2023课后作业答案)

分类：高中问答发布于：2024-06-02 16:52:28ė16549次浏览634条评论

中国大学Java程序设计_33期末答案(mooc2023课后作业答案)

第1章绪论

1.1 Java的中国作业起源、发展和现状随堂测验

1、大学答案答案Java之父是程序（）。

2、设计目前，期末Java有三个体系，课后分别是中国作业（）、 Java EE和Java ME。大学答案答案

1.2 Java的程序特点随堂测验

1、Java的设计内存管理是由（）自动完成的，解放了程序员大量的期末精力和工作量。

2、课后面向对象有三个特征，中国作业分别是大学答案答案：封装、继承和（）。程序

1.3 Java运行平台随堂测验

1、在jdk中，如果Java源程序中有多个类，则这个源程序的文件名必须是主类的名字。（）

2、如果Java源程序和jdk的安装路径不一样，为了确保程序的正确编译和运行，需要配置（）变量。

1.4 Java程序开发随堂测验

1、Java源程序的扩展名为（）。

2、在jdk中，如果Java源程序中有多个类，可以都不是public类。但是，如果要有public类，则只能有（）个类是public类。

1.5 数据的输入和输出随堂测验

1、Scanner类的对象可以从键盘上接收char类型的数据。（）

2、System.out.print(...)方法和System.out.println(...)方法在输出内容时作用相同。（）

3、Java源程序中的main方法中的参数作用是（）。

4、Java提供了一个专门从键盘上接收数据的类，该类的名称是（）。

1.6 Java APIs随堂测验

1、在Java APIs中，如果查询一个类，可以通过该类所在的包来检索，也可以通过（）检索。

第1章单元测验

1、在jdk中，（）。
A、源程序中只能有一个主类
B、源程序中可以有多个public类
C、源程序中必须有public类
D、源程序的文件名必须是主类的名字

2、在jdk中（也就是直接在MS-DOS界面中编译和运行Java源程序），如果源程序中有public类，（）。
A、可以有多个public类
B、只能有一个public类
C、public类必须是包含main方法的主类
D、所有类必须都是public类

3、在eclipse中，一个Project的bin文件夹中，存放（）。
A、Java源程序
B、Java源程序编译之后的字节码文件
C、Java源程序和字节码文件
D、以上都不对

4、Java语言具有“一旦写成，处处可用”（write once,run anywhere）的平台无关性，是因为Java源程序被编译之后生成的.class字节码文件在各种操作系统下都是通用的，都可以被安装在特定操作系统的Java解释器正确地解释运行。（）

5、Java中内存的开辟和释放是由程序员通过指针操作的。（）

6、假设有Scanner类的对象reader，则使用reader从键盘上接收字符串时，reader.nextLine()和reader.next()的作用是相同的。（）

7、Java源程序经过编译之后会产生扩展名为.class的字节码文件，字节码文件是机器码。（）

8、Java源程序经过编译之后会产生扩展名为.class的字节码文件，之后通过java命令运行时，字节码会一次性加到内存中。（）?

9、Java语言最初命名为（）。

10、面向对象有三个特性，分别是封装、（）和多态。

11、在Java源程序中，main方法中参数的类型是（）。(写出类型的英文名称）

12、Scanner类在（）包中。

第1章单元作业

1、对于以下源代码，请问：在不修改任何代码的情况下，（1）在jdk中应该怎样命名？（2）编译命令怎么写？（3）运行命令怎么写？ public class A { void f() { System.out.println("I love Java as much as I love coffee."); } } class Hello { public static void main(String args[]) { System.out.println("Hello, it is very glad to learn Java."); A a=new A(); a.f(); } }

2、对于以下源代码，在eclipse中，应该修改哪些内容，才能正确命名？ public class A { void f() { System.out.println("I love Java as much as I love coffee."); } } class Hello { public static void main(String args[]) { System.out.println("Hello, it is very glad to learn Java."); A a=new A(); a.f(); } }

第2章 Java语言基础

2.1 基本语言符号随堂测验

1、以下标识符正确的是（）。
A、a+b
B、2a$
C、_2.a
D、For

2、关键字可以是大写的。（）

3、Java语言的标识符是由（）、数字、下划线和美元符号组成。

4、Java语言中的注释包括单行注释、多行注释和（）。

5、Java语言中的文档注释以（）开始，以*/结束。

2.2 数据类型和变量随堂测验

1、以下选项中，（）不是Java语言的基本数据类型。
A、整型
B、字符型
C、布尔类型
D、字符串类型

2、Java中存在无符号整数。（）

3、字符型的精度高于短整型。（）

4、数据类型的转换，分为自动类型转换和（）。

5、int a=268; byte m=(byte)a; 请问m=( )。

6、Java中的数据类型包括基本数据类型和（）数据类型。

2.3 运算符与表达式随堂测验

1、int a=1,b=2,c=6,d=6; boolean m=true,n=true; 则执行表达式（m=a>b）||（n=c>d）之后，n和表达式的值分别为（）。
A、true,false
B、true,true
C、false,true
D、false,false

2、int a; a=2++; 此时，a的值为3。（）

3、各个关系运算符的优先级相同。（）

4、int a,b=2; a=b++; a=( )

5、2/5的结果是（）。

6、int a=2; a<<1;a的值为（）。

2.4 Java语句随堂测验

1、在分支结构中，if后面的括号里的值可以是（）。
A、整数类型
B、浮点数类型
C、布尔类型
D、字符类型

2、int i,sum=0;则执行以下语句，sum的值是（）。 for(i=1;i<=3;sum+=1) sum+=i;
A、6
B、3
C、0
D、sum的值无法计算

3、int i,sum=0;则执行以下语句，sum的值是（）。 for(i=1;i<=3;i++) { if(i==2) continue; sum+=i; }
A、1
B、2
C、3
D、4

4、在Java语言中，语句后面可以不加分号。（）

5、在分支结构中，在没有if的情况下，else可以单独存在。（）

2.5 Java数组随堂测验

1、在Java语言中，创建一个长度为6的一维整型数组a，语句是（）。
A、int a[6];
B、int [6] a;
C、int a[ ]=new int[6];
D、int a[ ]=int[6];

2、在Java语言中，二维数组中的每一个一维数组（或者称为每一行）的长度必须相同。（）

第2章单元测验

1、以下选项中，（）是错误的标识符。
A、_int
B、a_6b$
C、thread1
D、instanceof

2、int a=1,b=2,c=6,d=6; boolean m=true,n=true;则执行表达式(m=a>b)&&(n=c>d)之后，n和表达式的值分别为（）。
A、true,false
B、true,true
C、false,true
D、false,false

3、int w=1,x=2,y=3,z=4;则表达式w>x?w:y
A、4
B、3
C、2
D、1

4、在Java源程序中，有以下语句： int a=2; if(a=2) System.out.println("Hello"); else System.out.println("Welcome"); 源程序的运行结果为（）。
A、Hello
B、Welcome
C、Hello Welcome
D、程序错误

5、在Java语言中，switch后面的括号里不可以是（）类型的值。
A、byte
B、int
C、String
D、long

6、若i为整型变量，则以下循环体内的语句被执行了（）次。 for(i=2;i==0;) System.out.printf("%d",i--);
A、0
B、1
C、2
D、无限次

7、int[ ][ ]a=new int[2][3];则a.length的值为（）。
A、2
B、3
C、5
D、6

8、byte b; int n=6;以下赋值语句错误的是（）。
A、b=3;
B、b=(byte)3;
C、b=n;
D、b=(byte)n;

9、boolean类型的精度高于其他基本数据类型。（）

10、byte a=200; 这条语句是对的。（）

11、数值2000可以存储在引用类型的变量中。（）

12、1/4的结果是0.25。（）

13、逻辑与和逻辑或的优先级相同。（）

14、int a[ ]={ 1,2,3,4,5,6}; 和int a[ ]=new int[6];的作用是不同的。（）

15、short s=6; char c='a'；请问：s+c是什么数据类型？（）要求：填写数据类型对应的关键字。

16、在jdk中，可以使用（）命令将文档注释提取出来，形成帮助文档。

17、文档注释内置了一些以（）开头的关键字，用来表示特定的含义。

18、int a=2; 如果使用移位运算将变量a的值变为8，请写出移位表达式（）。

19、int a={ 10,20,30},b={ 40,50,}; a=b; a[0]=（）。

20、int a[ ][ ]=new int[2][ ]; 如果让数组a的第一行存放2个数据，接下来的语句是（）。

第2章单元作业

1、有三位同学的成绩（double类型），如下所示：第1位同学：85, 90, 96 第2位同学：90, 85 第3位同学：90, 90, 80, 95 （1）编写Java源程序，将上述同学的成绩放在一个二维数组，并且输出数组的内容。要求：用初始化的方法为数组赋值。（2）编写Java源程序，将上述同学的成绩放在一个二维数组，并且输出数组的内容。要求：用new关键字创建数组之后再赋值。

2、从键盘上输入若干同学的成绩（double类型），将其存放在一个成绩数组中，之后，将数组中的成绩输出出来。要求：输出数组中的成绩时使用foreach循环。

第3章 Java的面向对象特征

3.1 面向对象概述随堂测验

1、面向对象的语言有三个特征：（）、继承和多态。

2、封装是指将数据的（）和对数据的操作集成在一起。

3.2 类和对象随堂测验

1、一个类中，（）。
A、可以不显式地给出构造方法
B、只能有一个构造方法
C、必须有多个构造方法
D、不需要构造方法

2、构造方法可以有返回类型。（）

3、有语句final int MAX=100;则源程序运行过程中，MAX的值可以改变。（）

4、类名可以通过运算符“.”访问静态变量和静态方法。（）

5、class Square { double side; Square(double side) { this.side=side; } double computeArea() { return side*side; } } 上述类声明中，关键字this可以省略。（）

6、一个类中，静态变量用关键字（）修饰。

3.3 继承与多态随堂测验

1、表示类继承的关键字是（）。
A、inherit
B、succeed
C、extends
D、develop

2、子类可以继承父类的构造方法。（）

3、Java语言中，一个父类只能有一个子类。（）

4、class A { public int f(int x,int y) { return x+y; } } class B extends A { public int f(byte x,int y) { return x*y; } } 子类B的对象只能调用子类中的f方法。（）

3.4 访问权限随堂测验

1、一个类的声明中，关键字class前面可以加如下（）访问控制权限。
A、public
B、protected
C、default（可以省略）
D、private

2、包声明语句可以放在源程序的任何位置。（）

3、构造方法的访问控制权限受类的访问控制权限的影响。（）

4、以下两个类在同一个Java源程序中， Class Adder { private int x; private int increase(int basic) { return basic+x; } } Class User { void use(int input) { Adder adder=new Adder(); int result=adder.increase(6); } } 红色的语句是不合法的。（）

5、有两个Java源程序文件，其中，第一个文件中的源代码如下所示。 package yours; class Adder { protected int x; int y; protected int increase(int basic) { return basic+x; } } 第二个文件中的源代码如下所示。 package other; import yours; class Unknown { Adder a=new Adder(); a.increase(3); } 红色的语句是合法的。（）

6、引用其他包中的类需要使用关键字（）。

第3章单元测验

1、构造方法的名字（）。
A、可以由用户按照标识符的规范随意命名
B、必须和类中的一个方法的名字相同
C、必须与类名相同
D、是Java保留的关键字

2、class A { public int f(int x,int y) { return x+y; } } class B extends A { public int f(byte x,int y) { return x*y; } } 则子类中的f方法和父类中的f方法（）。
A、是重写关系
B、是重载（过载）关系
C、完全相同
D、是错误的

3、引用其他包中的类需要使用关键字（）。
A、quote
B、cite
C、appoint
D、import

4、1: class Super{ 2: public int getValue() { return 2019;} 3: } 4: public class Sub extends Super{ 5: 6:} 下列选项中，（）放在第5行会引起编译错误？
A、public int getValue() { return 2016;}
B、public void getValue() { }
C、public void getValue(int a) { }
D、public double getValue(double a,double b) { return a+b}

5、给出如下源代码，如何使成员变量m被方法fun()直接访问？（） class Test { private int m; public static void fun() { //some code... } }
A、将 private int m;改为 protected int m;
B、将 private int m;改为 public int m;
C、将 private int m;改为 static int m;
D、将 private int m;改为 int m;

6、public class Test { public static void main(String[ ] args) { int result =???; System.out.println(result); } public static int operate(double a, int b) { return 10*(int)(a+b); } public static int operate(int a, double b) { return 100*(int)(a+b); } public static int operate(double a, double b) { return 1000*(int)(a+b); } } ???处填入（）时，编译程序会出错。
A、operate (3, 5)
B、operate (3.0, 5)
C、operate (3, 5.0)
D、operate (3.0, 5.0)

7、1： class Super{ 2： public float getNum( ) { return 6.0f;} 3： } 4： public class Sub extends Super 5： { 6： 7： } 以下选项中，（）放在第6行会引起编译错误。
A、public float getNum( ) { return 4.0f;}
B、public void getNum( ) { }
C、public void getNum(double d) { }
D、public double getNum(double d) { return 6.0+d;}

8、Java语言中，包实际就是（）。
A、Java提供的基础类库
B、用户自己编写的类库
C、字节码文件
D、文件夹

9、请选择一个正确答案，（）。
A、如果源文件中存在package语句，则必须放在所有非注释语句之前
B、private成员变量和方法可以被同一包中的所有类访问
C、类的访问控制权限有4种
D、构造方法的访问控制权限必须是public

10、静态方法可以访问（）。
A、非静态变量（实例变量）
B、静态变量
C、非静态方法（实例方法）
D、静态方法

11、class Square { double side; Square(double side) { this.side=side; } double computeArea() { return side*side; } } Square 正方形=new Square(10.0); 在这个例子中，（）。
A、this可以省略
B、创建类对象的语句Square 正方形=new Square(10.0);执行时，this代表当前对象“正方形”
C、this不代表任何内容
D、this不能省略

12、class Square { double side; Square(double side) { this.side=side; } double computeArea() { return side*side; } } 有了上述类声明，类对象的创建语句Square 正方形=new Square();是正确的。（）

13、构造方法不可以被类对象用运算符“.”调用。（）

14、一个类声明了对象之后，这个对象就可以调用该类的成员变量和成员方法了。（）

15、类名不能通过运算符“.”访问类的实例变量。（）

16、Java语言中，一个子类只能有一个直接父类。（）

17、有一个类A的声明，如下所示 class A { //省略成员变量和成员方法的声明 } 类A没有父类。（）

18、一个final类可以被其他类继承。（）

19、子类不能重写父类的final成员方法。（）

20、子类不能继承父类的私有（private）成员变量和成员方法。（）

21、数据的属性在类中被称为（），对数据的操作在类中被称为成员方法。

22、一个类的成员变量如果被关键字final修饰，称它为（），习惯用大写字母表示。

23、calss A { int a; int increase(int basic) { return basic+a; } } class B extends A { int a,b; int add() { return ( )+b; } } 在子类B的return后面的括号中，如果要使用父类A的成员变量a，其中的内容是（）。

24、Class Adder { private int x; public Adder(int a) { x=a; } private int increase(int basic) { return basic+x; } } Adder类的构造方法的访问控制权限是（）。（写表示访问控制权限的关键字）

25、在一个Java源程序中，如果要引入java.util包中的所有类，引入语句是（）。

第3章单元作业

1、假设学生的属性包括学号（int类型）、姓名（String类型）、数学成绩（double类型）和计算机成绩（double类型），要求：（1）声明学生类Student，其中包括上述要求的成员变量和构造方法，还要有一个void print()方法，功能是输出成员变量（4个成员变量）的信息。（2）声明学生类Student的子类，也就是研究生类PostGraduate，其中，研究生类继承了父类的学号、姓名、数学成绩和计算机成绩，此外，研究生类还有自己的两个新属性导师姓名（String类型）和研究方向（String类型）。还有，研究生类要重写父类的void print()方法，功能是输出成员变量（6个成员变量）的信息。（想一想研究生的构造方法怎么写，提示，从父类继承的成员变量可以在子类的构造方法中使用super关键字。）（3）声明主类，在主方法main中，创建一个Student类的对象，从键盘上输入其属性信息，并且通过其print方法输出这些信息；创建一个PostGraduate类的对象，从键盘上输入其属性信息，并且通过其print方法输出这些信息。以上要求的内容可以放在同一个源程序中，也可以放在不同的源程序中（放在不同的源程序的情况需要注意包的声明和引用）。同学们做这次作业的时候，在声明类的时候，需要按照以下说明的规则来做：（1）在声明类的时候，如果类中有成员变量，一般不建议创建了类对象之后，通过运算符“.”去调用成员变量，最好是通过函数间接地使用成员变量。（当然，咱们的讲课视频中为了举例简单，还是用了运算符“.”去调用成员变量。）（2）所以，对于每一个成员变量，最好都为其设置两个方法，一个是set方法，功能是通过这个方法修改成员变量的值，另一个是get方法，功能是通过这个方法获取成员变量的值。（3）例如，以下有类A的声明，它有两个int类型的成员变量x和y，则类A的声明如下，注意观察，对于每一个成员变量的set和get方法，以及它们的参数类型和方法的返回类型，还有print方法中，输出成员变量的值时，也是通过函数获取值： class A { int x,y； A(int x,int y) { this.x=x; this.y=y; } void setX(int a) { x=a; } int getX() { return x; } void setY(int b) { y=b; } int getY() { return y; } void print() { System.out.println("x的值为"+this.getX()+"y的值为"+this.getY()); } }

第4章类的高级特性

4.1 对象的上转型、抽象类和最终类随堂测验

1、上转型对象和父类对象的功能相同。（）

2、抽象类中可以没有抽象方法。（）

3、抽象类的子类不能再是抽象类。（）

4、final类不可以被继承。（）

4.2 接口、内部类、匿名类随堂测验

1、一个接口（）。
A、可以实现其他接口
B、只能被一个类实现
C、可以继承其他接口
D、可以被多个类实现

2、一个类可以同时实现多个接口。（）

3、匿名类不可以声明类对象。( )

4、声明接口时，需要使用关键字（）。

5、在一个类中声明的类，称为（）。

6、以下内容在同一个源程序中： abstract class A { abstract int num(); } class TestA { public static void f(A t) { System.out.println(t.num()); } public static void main(String[] args) { f( new A() { int num() { return 20; } } ); } } 程序运行的结果是输出（）。

第4章单元测验

1、abstract class A { int x; int add() { return x+1; } public abstract int decrease(); } class B extends A { public int decrease() { return x-1; } } 则下列选项正确的是（）。
A、A a=new A();
B、B b=new A();
C、A a=new B();
D、B b=(B)(new A());

2、以下与接口有关的说法，正确的是（）。
A、接口中只能有抽象方法
B、接口A和接口B中的方法名可以相同
C、接口和抽象类唯一的不同就是，接口比抽象类更抽象
D、一个类不能同时实现多个接口

3、以下内容在同一个源程序中： interface A { int add(); } class B implements A { int x,y; B(int x,int y) { this.x=x; this.y=y; } int add() { return x+y; } } public class C { public static void main(String[] args) { B b=new B(10,20); int result=b.add(); System.out.println(b.x); System.out.println(b.y); System.out.println(result); } } 对于这个源程序，以下选项正确的是（）。
A、程序输出b.x的值为0
B、程序输出b.y的值为0
C、程序输出的result的值为30
D、上述源程序编译不通过

4、假设A是接口，B和C是类，以下选项不正确的是（）。
A、class C extends A { //省略代码 }
B、class C implements A { //省略代码 }
C、class C extends B { //省略代码 }
D、class C extends B implements A { //省略代码 }

5、以下说法正确的是（）。
A、一个接口可以实现另外一个接口
B、接口之间可以继承，属于单继承机制
C、一个接口可以同时继承多个接口
D、接口之间不能继承

6、以下内容在同一个源程序中： class A { int a; A(int a) { this.a=a; } int add() { return a+10; } } class TestA { public static void f(A t) { System.out.println(t.add()); } public static void main(String[] args) { f( new A() { int add() { return a+20; } } ); } } 则（）。
A、程序的运行结果为输出0
B、程序的运行结果为输出10
C、程序的运行结果为输出20
D、程序不能编译通过

7、类A的声明如下所示： abstract class A { int x; int add() { return x+1; } public abstract int decrease(); } 则类对象的创建语句A a=new A(); 是正确的。（）

8、抽象类可以是final类。（）

9、抽象类可以声明对象。（）

10、一个类可以在继承父类的同时实现接口。（）

11、一个类对接口的实现机制属于类继承机制。（）

12、抽象类不能实现接口。（）

13、抽象类声明的对象不能作为上转型对象。（）

14、内部类的类体中不可以声明类变量和类方法。（）

15、一个类实现接口时，需要使用关键字（）。

第4章单元作业

1、有一个抽象类ObjectVolume，如下所示： abstract class ObjectVolume { abstract double getVolume(); //返回物体的体积 } （1）编写球体类，立方体类和圆柱体类，它们是抽象类ObjectVolume的子类。（提示：想一想，这些子类除了要实现父类的抽象方法，也就是计算各自的体积之外，这些子类各自的成员变量什么？）（2）编写一个public类，其中包含main方法和static void get(ObjectVolume obj)方法（可以看到，get方法的形参是抽象类ObjectVolume声明的对象）。（3）在main方法中，从键盘上输入1（表示球体）、2（表示立方体）、3（表示圆柱体）时，调用get方法可以分别得到球体、立方体、圆柱体的体积。（提示：调用get方法时，实参应该是各个子类对象，这时，实参子类对象传给形参抽象父类对象，则抽象父类对象就是上转型向对象，想一想，为了得到物体的体积，get方法中的语句应该是什么？）

2、有一个接口UnitPrice，如下所示： interface UnitPrice { public double unitprice( ); //返回商品的单价 } （1）编写电视机类、计算机类和手机类来实现接口UnitPrice。（提示：各个类在实现接口时，在unitprice方法中，只需返回商品的单价，也就是double类型的常量即可。）（2）编写一个公共类，其中包含main方法和static double get(UnitPrice u)方法。（可以看到，get方法的形参是接口UnitPrice声明的接口变量，而且，get方法的返回类型是double，所以该方法中要有return语句返回对应类型的内容。）（3）在main方法中，从键盘上输入电视、计算机和手机的销售个数，调用get方法可以分别得到商店各个商品的单价，之后商品的总销售额。。（提示：调用get方法时，实参应该是各个类对象，这时，实参类对象传给形参接口变量，想一想，为了得到商品的单价，get方法中，形参会做什么呢？）

第5章常用类

5.1 基本数据类型的封装类随堂测验

1、以下选项中，（）是自动装箱。
A、double a=6.0;
B、Double a=new Double("6.0");
C、Double a=6.0;
D、double a=new Double(6.0);

2、Integer a=new Integer(5); System.out.println(a); 在上述输出语句中，a后面省略了（）。
A、intValue()
B、valueOf("5")
C、parseInt("5")
D、toString()

3、Byte by=new Byte(5);这条语句是正确的。（）

4、基本数据类型int的封装类是（）。

5、整型封装类中，代表整数的最大值的静态常量是（）。

6、基本数据类型boolean的封装类是（）。

5.2 Object类随堂测验

1、class A { int x; int add() { return x+1; } } A a=new A(); A b=new A(); 如果要比较a和b中的值是否相等，可以使用（）。
A、a=b;
B、a==b;
C、a.equals(b);
D、b=a;

2、class A { //省略代码 } 类A没有父类。（）。

3、Object类中，有的方法的访问控制权限是default或者private。（）

5.3 字符串类随堂测验

1、String str="like"; 则str.compareTo("lake")的值（）。
A、大于0
B、小于0
C、等于0
D、不能比较

2、String类不可以被继承。（）

3、String s1,s2; s1="Hello!"; s2="Hello!"; 则s1==s2的值为true。（）

4、String s1,s2; s1=new String("Hello!"); s2=new String("Hello!"); 则s1==s2的值为true。（）

5、StringBuffer str=new StringBuffer("I like apple!"); str.delete(7,12); str.insert(7,"grape"); 则str所指向字符串的内容是（）。

5.4 Math类随堂测验

1、Math类在（）包中。
A、java.util
B、java.lang
C、java.io
D、java.math

2、生成一个[1,100]之间的随机整数，以下选项正确的是（）。
A、int a=(int)(Math.random()*100)+1;
B、int a=(int)(Math.random()*100);
C、int a=(int)(Math.random()*99)+1;
D、int a=(int)(Math.random()*99);

3、Math类可以被继承。（）

5.5 BigInteger类随堂测验

1、大整数类BigInteger在（）包中。
A、java.lang
B、java.math
C、java.util
D、java.io

2、大整数类BigInteger中的compareTo方法是（）。
A、重写了Object类的compareTo方法
B、大整数类自己的新方法
C、实现了Comparable接口中的compareTo方法
D、和Object类中的compareTo方法构成重载

5.6 LinkedList 泛型类随堂测验

1、LinkedList泛型类对象a获取链表中的节点个数，可以使用（）。
A、a.length()
B、a.number()
C、a.size()
D、a.amount()

2、LinkedList泛型类在（）包中。

5.7 TreeSet 泛型类随堂测验

1、tree.add(6); tree.add(1); tree.add(1); 则遍历树集tree之后，可以输出1,1,6。（）

2、TreeSet泛型类在（）包中。

5.8 TreeMap 泛型类随堂测验

1、泛型类对象可以通过调用add方法增加节点。（）

2、泛型类在java.lang包中。（）

第5章单元测验

1、以下选项中，（）不是基本数据类型的封装类。
A、Integer
B、Char
C、Long
D、Double

2、以下选项中，（）是自动拆箱。
A、int a=6;
B、Integer a=new Integer("6");
C、Integer a=6;
D、int a=new Integer("6");

3、以下选项中，不正确的是（）。
A、Float a=new Float("5.0");
B、Float a=Float.valueOf("5.0");
C、Float a=5.0f;
D、Float a=5.0;

4、class A { int x; int add() { return x+1; } } A a=new A(); System.out.println(a); 则程序的运行结果是（）。
A、0
B、1
C、地址
D、什么也不输出

5、String s1,s2; s1=new String("Hello!"); s2=new String("Hello!"); 如果要比较s1和s2指向字符串的内容是否相等，可以使用（）。
A、s1==s2
B、s1=s2
C、s1.equals(s2)
D、s2=s1

6、StringBuffer str=new StringBuffer("abc"); 如果让str指向的字符串变为“abcdef”，以下选项中，能够完成任务的是（）。
A、str.insert(2,"def");
B、str.add("def");
C、str.append("def");
D、str指向的内容不能改变

7、生成一个[1,6]之间的随机整数，以下选项中，正确的是（）。
A、int a=(int)(Math.random()*6);
B、int a=(int)(Math.random()*5);
C、int a=(int)(Math.random()*6)+1;
D、int a=(int)(Math.random()*5)+1;

8、BigInteger a=new BigInteger("123456789123456789");则a.toString()的值是（）。
A、地址
B、字符串
C、整数
D、大整数

9、Integer a=new Integer(5); 把a对象转换为基本数据类型int的值，以下选项正确的是（）。
A、int i=5;
B、int i=a.intValue();
C、int i=a.toString();
D、int i=a;

10、class A { int x,y; int add() { return x+1; } public boolean equals(Object obj) { A that=(A)obj; if (this.x==that.x) return true; return false; } } A a=new A(); A b=new A(); a.x=6; a.y=10; b.x=6; b.y=9; 以下选项中，结果为true的是（）。
A、a.x==b.x
B、a.y==b.y
C、a.equals(b)
D、a==b

11、泛型类中，泛型E（）。
A、可以是类名
B、可以是接口名
C、可以是基本数据类型名
D、可以是任何类型

12、Integer i=5;这条语句是错误的，不能把一个数值赋给一个类对象，类型不匹配。（）

13、System.out.println(Integer.parseInt("apple")); 则输出的内容是apple。（）

14、class A { int x; int add() { return x+1; } public boolean equals(Object obj) { A that=(A)obj; if (this.x==that.x) return true; return false; } } 在上述源代码中，equals方法是类A自己新创的方法。（）

15、String类中的方法可以被子类重写。（）

16、String s1,s2; s1="Hello!"; s2="Hello!"; 则s1==s2比较s1和s2指向字符串的内容是否相等。（）

17、Math类是final类，不能被继承。（）

18、Math类的方法都是静态的，使用类名可以直接调用，为用户提供方便。（）

19、BigInteger a=new BigInteger("s00123456789123456789"); 这条语句可以创建一个大整数类对象a。（）

20、 //之后借助Iterator泛型类遍历书集tree。（）

21、class A { int x; int add() { return x+1; } } 可以用A代替泛型类中的E创建树集对象。（）

22、泛型类对象可以通过调用put方法增加节点。（）

23、假设有类A，如果用类A代替泛型类中的泛型K，则A必须实现Comparable接口中的compareTo方法。

24、封装类Doule可以直接拿来代替泛型类中的K。（）

25、基本数据类型char的封装类是（）。

26、整型封装类中，代表整数最小值的静态常量是（）。

27、String s1="The cherry is decilious."; String s2=s1.substring(4,9); 则s2指向的字符串的内容为（）。

28、 =new ( );

29、泛型类对象可以借助（）泛型类来提高遍历链表的效率。

30、字符串分析器的类名是（）。

第5章单元作业

1、编写一个类，该类的功能是可以根据给定的字符串（字符串的内容可以是中文，也可以是英文，字符串中单词之间可以有空格，也可以没有空格）和子串，计算出字符串中包含多少个子串。（要求：使用String类的方法。）程序可以使用下面的框架： import java.util.Scanner; class CountSubString { //【变量声明】 //方法实现 void countSubString(String s, String substring) //s代表整个字符串，substring代表子串 { //【代码】 } } public class CountString { public static void main(String args[]) { Scanner reader=new Scanner(System.in); System.out.println("请输入字符串："); String s=reader.nextLine(); System.out.println("请输入你要检索的子串："); String substring=reader.nextLine(); CountSubString a=new CountSubString(); a.countSubString(s, substring); } } 例如，可以输入字符串“I like apple. The apple is decilious. Do you like apple?”和子串“apple”，程序的运行结果应该是检索到3个apple。再例如，可以输入字符串“Ilikeapple.Theappleisdecilious.Doyoulikeapple?”和子串“apple”，程序的运行结果应该是检索到3个apple。再例如，可以输入字符串"我喜欢苹果。苹果很美味。你喜欢苹果吗？"和子串"苹果"，程序的运行结果应该是检索到3个“苹果”。

第6章异常处理

6.1 异常的概念随堂测验

1、有以下程序源代码 public class TestException { public static double calculateArea(double a, double b, double c) { double p = (a+b+c)/2; return Math.sqrt(p*(p-a)*(p-b)*(p-c)); } public static void main(String[] args) { double a = Double.parseDouble(args[0]); double b = Double.parseDouble(args[1]); double c = Double.parseDouble(args[2]); double s = calculateArea(a, b, c); System.out.println("边长为"+a+","+b+","+c+"的三角形面积是"+s); } } 编译源程序之后，如果运行命令是java TestException 3 a.4，则系统会报出（）。
A、ArrayIndexOutOfBoundsException
B、NumberFormatException
C、InputMismatchException
D、Exception

2、Java中的各种异常不属于类。（）

6.2 系统定义的异常类及其层次随堂测验

1、异常类报出异常时，不会显示异常发生的位置。（）

2、Error代表严重错误，一般不由程序进行处理。（）

3、所有异常类的父类是（）。（请写出类名。）

6.3 异常处理随堂测验

1、捕获异常时，try语句块后面只能有一个catch块。（）

2、finally语句块是必须存在的。（）

3、异常处理的方式通常包括两种，一种是捕获异常，另外一种是（）异常。

4、如果一个方法会产生异常，需要在方法的声明后面使用关键字（）抛出异常。

6.4 自定义异常随堂测验

1、有以下自定义异常类TriangleUnequationException的声明： class TriangleUnequationException extends Exception { String name; public TriangleUnequationException(String str) { name = str; } public String toString() { return name; } } 其中，方法public String toString()是（）。
A、TriangleUnequationException类对父类Exception中方法的重写
B、TriangleUnequationException类对Object类中方法的重写
C、TriangleUnequationException类对Throwable类中方法的重写
D、TriangleUnequationException类自己的新方法

2、Java提供的异常类可以处理所有的异常情况。（）

第6章单元测验

1、有以下程序源代码 public class TestException { public static double calculateArea(double a, double b, double c) { double p = (a+b+c)/2; return Math.sqrt(p*(p-a)*(p-b)*(p-c)); } public static void main(String[] args) { double a = Double.parseDouble(args[0]); double b = Double.parseDouble(args[1]); double c = Double.parseDouble(args[2]); double s = calculateArea(a, b, c); System.out.println("边长为"+a+","+b+","+c+"的三角形面积是"+s); } } 编译源程序之后，如果运行命令是java TestException，则系统会报出（）。
A、ArrayIndexOutOfBoundsException
B、NumberFormatException
C、InputMismatchException
D、Exception

2、Scanner reader=new Scanner(System.in); int a=reader.nextInt(); 如果从键盘上输入12w，会报出（）。
A、NumberFormatException
B、InputMismatchException
C、Error
D、Exception

3、有以下程序源代码： public class TestException { public static void main(String[] args) { double a = Double.parseDouble(args[0]); //省略代码 } } 如果从键盘上输入“apple”，会报出（）。
A、NumberFormatException
B、InputMismatchException
C、Exception
D、不会报出异常

4、Java提供的所有异常类的父类是Thrownable。（）

5、捕获异常时，try语句块后面的若干catch块中的异常如果没有继承关系，各个catch块的先后顺序可以随意安排。（）

6、有以下程序源代码： //假设已经有异常类TriangleMinusLengthException和TriangleUnequationException。 public class TestSelfException { public static double calculateArea(double a, double b, double c) throws TriangleMinusLengthException, TriangleUnequationException { if (a<0 || b<0 || c<0) throw new TriangleMinusLengthException("负边长异常"); if (a+b<c || a+c<b || b+c<a) throw new TriangleUnequationException("不满足三角不等式异常"); double p = (a+b+c)/2; return Math.sqrt(p*(p-a)*(p-b)*(p-c)); } public static void main(String[] args) { double a = 3, b = 4, c = 5; double e = -4, f = 2, g =10000; try{ double area = calculateArea(a,b,c); System.out.println("面积：" + area); area = calculateArea(e, f, g); System.out.println("面积：" + area); }catch(TriangleMinusLengthException me){ System.out.println("边长为负，请改正"); }catch(TriangleUnequationException ue){ System.out.println("边长不满足三角不等式，请改正！"); } } } 上述语句中，红色显示的函数调用语句执行时，两个catch块都能捕获到相应的异常。（）

7、finally块可以和catch块互换位置。（）

8、捕获异常时，try语句块后面的若干catch块的安排要遵循（）的原则。

9、如果一个方法存在一个或者多个异常，在这个方法的方法体中，需要使用关键字（）声明对应的异常。

10、异常类NumberFormatException的直接父类是（）。

第6章单元作业

1、作业要求如下：（1）编写一个类TestAllException，其中包含主方法main和计算矩形面积的方法calculateArea。（2）在main方法中，从键盘上接收矩形的长和宽，调用方法calculateArea计算并且返回矩形的面积，之后在main方法中输出矩形的面积。（3）思考一下，在这个任务中，有什么异常是系统无法给定，需要自定义的？请自定义这种异常类，并且在方法calculateArea中声明和抛出。（4）在main方法中，使用try-catch结构捕获所有可能的异常。可以参考如下程序框架： //包引用语句 //自定义异常类的声明 public class TestAllException { public static double calculateArea(double a, double b) throws ...（...表示自定义异常类） { //判断什么时候声明异常 //计算并且返回矩形面积 } public static void main(String[] args) { //从键盘上接收矩形的长和宽 //调用方法calculateArea //输出矩形面积 //对于上述操作，注意捕获可能出现的异常 } }

第7章输入/输出流

7.1 流的概念和分类随堂测验

1、Java中的输入流是双向的通道。（）

2、如果按照流的方向分类，可以将流分为输入流和（）。

7.2 File类与文件信息随堂测验

1、File类的对象不可以（）。
A、创建文件
B、获取文件读写权限
C、获取文件内容的长度
D、读写文件

2、如果要获取指定路径下的所有文件，File类的对象可以调用（）。
A、public String[] list()
B、public File[] listFiles()?
C、public String[] list(FilenameFileter obj)
D、public File[] listFiles(FilenameFileter obj)

3、File类创建的对象可以对文件中的内容进行读写。（）

4、File类的对象只能指向一个具体的文件，不能指向一个路径。（）

5、File类在（）包中。

7.3 文件字节流随堂测验

1、//省略源代码 try{ FileInputStream in = new FileInputStream("lianxi.txt") int a; while((a=in.read())!=-1) { System.out.print((char)a); } in.close(); } catch(IOException ioe){ System.out.println("输入输出错误！"); } //省略源代码在上述源代码中，如果lianxi.txt不存在，则（）。
A、in对象会自动创建该文件
B、in对象会从其他文件中读取内容
C、程序能够编译通过
D、程序会报出“输入输出错误！”

2、文件字节流和文件字符流只能顺序读写文件。（）

3、文件输入流的源是（），目的地是内存。

4、文件字节流以（）为单位读写文件。

5、FileInputStream in = new FileInputStream("lianxi.txt")；假设文件lianxi.txt已经存在，则in对象调用public int read(byte[] b)方法时，从文件中读取的内容存放在（）中。

7.4 文件字符流随堂测验

1、FileWriter out =new FileWriter("lianxi.txt"); 如果lianxi.txt中原来已有内容，则out对象往该文件中写内容时，（）。
A、会在文件原有内容之后继续写新内容
B、覆盖原有内容
C、在文件中的指定位置写新内容
D、无法写内容

2、//省略源代码 File f = new File("data\\lianxi.txt"); try{ FileWriter out=new FileWriter(f,true); Scanner reader=new Scanner(System.in); String s=""; System.out.println("请输入内容："); s=reader.nextLie(); while(!s.equals("finish")) { out.write(s); out.write((int)'\r'); out.write((int)'\n'); s=reader.nextLine(); } reader.close(); out.close(); } catch(IOException ioe){ System.out.println("输入输出错误！"); } //省略源代码以下选项正确的是（）。
A、lianxi.txt不存在时会报错
B、如果lianxi.txt已经存在，out对象写文件时，新内容会覆盖原有内容
C、data文件夹不存在时会报错
D、如果lianxi.txt已经存在，out对象写文件时，可以在任意位置写内容

3、文件字符输入流的类名是（）。

7.5 字符缓冲流随堂测验

1、BufferedReader类读取一行数据的方法是（）。
A、public String readLine()
B、public String newLine()
C、public String nextLine()
D、public String next()

2、BufferedReader类的对象可以直接从文件中读取内容。（）

3、字符缓冲输出流的类名是（）。

7.6 对象流随堂测验

1、对象流可以直接读写文件。（）

2、假设已有类A，如果使用对象输出流将类A的对象信息写到目的地，则该类要实现（）接口。（写出接口的英文名字）

7.7 随机读写流随堂测验

1、RandomAccessFile raf = new RandomAccessFile("D:\\data\\random.txt", "rw"); 则raf既可以读取random.txt中的内容，又可以向该文件中写内容。（）

2、文件随机读写流类的类名是（）。

第7章章节测验

1、File a=new File("D:\\data\lianxi.txt"); 如果D盘中没有data文件夹，也没有lianxi.txt，则执行a.createNewFile();程序会（）。
A、在D盘中创建data文件夹
B、在D盘中创建lianxi.txt
C、在D盘中创建data文件夹，并且在data文件夹中创建lianxi.txt
D、报出IOException

2、若某个Java源程序中有语句File a=new File("lianxi.txt"); 如果lianxi.txt已经存在，在eclipse中，该文件（）。
A、和Java源程序在同一路径下
B、和src文件夹在同一路径下
C、可以存放在任意路径下
D、因为没有给定盘符信息，无法存放

3、//省略源代码 try{ FileOutputStream out = new FileOutputStream("lianxi.txt")； //使用out对象写文件，省略源代码 out.close(); } catch(IOException ioe){ System.out.println("输入输出错误！"); } //省略源代码在上述源代码中，如果lianxi.txt不存在，则（）。
A、程序会自动创建该文件
B、out对象会往其他文件中写内容
C、程序不能编译通过
D、程序会报出“输入输出错误！”

4、//省略源代码 try{ FileInputStream in = new FileInputStream("lianxi.txt")； int a; while((a=in.read())!=-1) { System.out.print((char)a); } in.close(); } catch(IOException ioe){ System.out.println("输入输出错误！"); } //省略源代码在上述源代码中，如果lianxi.txt中的内容是“好好学习”，则（）。
A、程序会输出“好好学习”
B、程序编译不通过
C、程序会报出“输入输出错误”
D、程序能输出内容，但是不是“好好学习”

5、//省略源代码 try{ FileReader in = new FileReader("lianxi.txt")； int a; while((a=in.read())!=-1) { System.out.print((char)a); } in.close(); } catch(IOException ioe){ System.out.println("输入输出错误！"); } //省略源代码在上述源代码中，如果lianxi.txt中的内容是“好好学习”，则（）。
A、程序会输出“好好学习”
B、程序编译不能通过
C、程序会报出“输入输出错误”
D、程序会输出内容，但是不是“好好学习”

6、FileWriter out=new FileWriter("lianxi.txt",true); 如果lianxi.txt中原来已有内容，则out对象往该文件中写内容时，（）。
A、会在原有内容之后继续写新内容
B、新内容覆盖原有内容
C、可以在文件中的任意位置写新内容
D、无法写内容

7、文件随机读写流类在（）包中。
A、java.lang
B、java.util
C、java.io
D、java.awt

8、RandomAccessFile raf=new RandomAccessFile("random.txt","r");则（）。
A、raf对象可以读取random.txt中的内容
B、raf对象可以往random.txt中写内容
C、raf对象既可以读取random.txt中的内容，也可以往该文件中写内容
D、raf对象只能顺序读写文件中的内容

9、File类的对象可以（）。
A、指向一个文件
B、指向一个路径
C、读写文件
D、获取文件是否可读或者可写

10、Java中的输出流是单向的通道。（）

11、FileWriter out=new FileWriter("lianxi.txt"); 如果要往lianxi.txt中写一个字符'w'，可以使用out.write('w');语句。（）

12、FileWriter out=new FileWriter("lianxi.txt"); 如果要将"I like apple."中的"apple"写到lianxi.txt中，可以使用out.write("I like apple.",9,5);语句。（）

13、BufferedWriter类的对象可以直接往文件中写内容。（）

14、File类的对象使用public File[] listFiles(FilenameFilter obj)方法之前，必须有一个类先去实现（）接口。（写出接口名）

15、文件输出流的源是内存，目的地是（）。

16、文件字符流以（）为单位读写文件。

17、FileOutputStream out = new FileOutputStream("lianxi.txt")；则out对象调用public void write(byte[] b)方法时，将（）中的内容写到文件中。

18、文件字符输出流的类名是（）。

19、字符缓冲输入流的类名是（）。

20、如果按照流的基本数据单位的大小来分类，可以将流分为字节流和（）。

第7章章节作业

1、编写一个Java源程序，其中包含：编写一个包含主方法main的公共类（访问权限为public的类），主方法main中完成的任务是：（1）从键盘上输入两个文件的路径名及其文件名。（2）从键盘上输入若干学生的信息（姓名，数学成绩，计算机成绩，各项之间用空格隔开），以finish结束，将这些学生的信息写入第一个文件。（3）将第一个文件作为输入流的源，找出姓“张”的学生，将他们的信息写入第二个文件。

第8章图形用户界面

8.1 图形用户界面概述随堂测验

1、以下（）不是图形用户界面的要素。
A、容器
B、字体格式
C、组件
D、监听处理机制

2、java.awt包中的组件称为（）。

8.2 窗体类JFrame随堂测验

1、窗体默认是可见的。（）

2、JFrame类在（）包中。

8.3 布局管理器随堂测验

1、窗体的默认布局是（）。
A、FlowLayout
B、GridLayout
C、BorderLayout
D、Box

2、JFrame类的setBounds方法的参数中，（）。
A、前两个参数设置窗体的大小
B、前两个参数设置窗体的初始位置
C、后两个参数设置窗体的大小
D、后两个参数设置窗体的初始位置

3、在设置了GridLayout布局的容器中，每个格子平均占据整个容器空间。（）

4、在分隔窗格中，分隔线的位置是固定的。（）

5、FlowLayout类在（）包中。

6、Box类在（）包中。

7、JScrollPane类在（）包中。

8.4 文本组件与ActionEvent事件随堂测验

1、ActionEvent类在（）包中。
A、java.awt
B、javax.swing
C、java.awt.event
D、java.lang

2、文本框对象通过（）方法获取其中的内容。

3、密码框对象通过（）方法获取其中的密码。

8.5 按钮与标签组件随堂测验

1、在按钮上只能显示文本。（）

2、在按钮上可以显示图标。（）

3、在图形用户界面中，用户可以在标签上输入文本。（）

8.6 复选框与单选按钮随堂测验

1、勾选复选框时会触发ItemEvent事件。（）

2、复选框的类名是（）。

3、ButtonGroup类在（）包中。

第8章单元测验

1、设置了FlowLayout布局的容器中，组件的（）。
A、大小不随窗体的大小而改变
B、位置不随窗体的大小而改变
C、大小和位置都不随窗体的大小而改变
D、大小和位置都随窗体的大小而改变

2、JFrame f=new JFrame(); f.setLayout(new FlowLayout()); 则添加到窗体f中的组件的对齐方式为（）。
A、居左对齐
B、居中对齐
C、居右对齐
D、根据具体情况而定

3、在设置了BorderLayout布局的容器中，以下选项正确的是（）。
A、每个区域中组件的大小不随窗体大小而改变
B、每个区域中的组件会充满该区域
C、如果一个区域没有放置组件，其他区域不会侵占该区域
D、每个区域中组件的位置随窗体的大小而改变

4、某个容器设置了2行3列的GridLayout布局，如果往容器中添加8个组件，则以下选项正确的是（）。
A、有两个组件无法添加
B、容器中的格子会自动扩充为3行3列
C、容器中的格子会自动扩充为2行4列
D、容器中的第6个格子中会放置3个组件

5、列型盒子中的组件，（）。
A、左沿在同一垂直线上
B、右沿在同一垂直线上
C、中轴线在同一垂直线上
D、组件的位置随具体情况而定

6、JPanel类对象的默认布局是（）。
A、FlowLayout布局
B、BorderLayout布局
C、GridLayout布局
D、Box

7、在设置了BorderLayout布局的容器中，如果往北区添加5个按钮，而且这5个按钮按钮都要可见，以下选项正确的是（）。
A、直接添加即可
B、借助于中间面板
C、无法完成任务
D、北区会自动调整，接纳所有按钮

8、JTextField类的对象添加监听器时，需要调用的方法名是（）。
A、add
B、addActionListener
C、addItemListener
D、actionPerformed

9、在文本框中按回车键，会触发（）事件。
A、ItemEvent
B、ActionEvent
C、MouseEvent
D、AWTEvent

10、复选框触发（）事件。
A、ItemEvent
B、ActionEvent
C、MouseEvent
D、AWTEvent

11、可以把窗体放到其他容器中。（）

12、窗体默认可以调整大小。（）

13、中间容器不能更改自己的默认布局。（）

14、分隔窗格中只能放置两个组件。（）

15、JScrollPane类的容器只能产生水平滚动条。（）

16、JTextField t=new JTextField(); 将t放置在设置了FlowLayout布局的容器中时，用户可以看到一个有一定宽度的文本框。（）

17、JTextField t=new JTextField(); 将t放置在窗体的北区，t会自动充满北区。（）

18、JTextField类和JTextArea类的对象没有区别。（）

19、在按钮上，文本和图标可以同时存在。（）

20、取消勾选复选框时，不会触发事件。（）

21、javax.swing包中的组件称为（）。

22、在设置了GridLayout布局的容器中，放置组件时，（）为主序。

23、密码框的类名是（）。

24、单选按钮的类名是（）。

25、为了把若干个单选按钮归为一组，实现单选功能，需要用到（）类。

第8章单元作业

1、实验说明和要求请见附件！

第9章多线程

9.1 线程的概念随堂测验

1、一个进程中只包含一个线程。（）

2、Java提供的线程类的类名是（）。

9.2 线程的生命周期随堂测验

1、创建线程时，可以通过继承Thread类来创建线程子类对象，也可以通过实现了（）接口的类对象作为Thread类的构造方法的参数，创建线程类对象。

9.3 创建线程随堂测验

1、class SubThread extends Thread{ public void run(){ for (int i=1; i<=20; i++) System.out.print("次" + i + ", "); } } 上述语句中的run()方法是SubThread类的新方法。（）

2、class SubThread extends Thread{ public void run(){ for (int i=1; i<=20; i++) System.out.print("次" + i + ", "); } } public class TestExtendsThread{ public static void main(String[] args){ SubThread sub = new SubThread(); sub.start(); for (int i=1; i<=20; i++) System.out.print("主" + i + ", "); } } 线程sub获得cpu使用权时，会执行SunThread类中的run()方法。（）

9.4 线程的常用方法随堂测验

1、Thread类的sleep方法是静态方法。（）

2、Thread类的isAlive()方法可以被子类重写。（）

9.5 线程同步随堂测验

1、正在使用同步方法的线程可以调用wait()方法主动让出cpu的使用权。（）

2、线程同步的关键字是（）。

9.6 线程联合和守护线程随堂测验

1、线程a需要联合线程b时，正确的语句是（）。
A、a.join();
B、b.join();
C、Thread.join();
D、join();

2、守护线程不属于Thread类。（）

第9章单元测验

1、Thread类在（）包中。
A、java.util
B、java.lang
C、java.awt
D、java.io

2、启动线程时，需要调用（）方法。
A、start()
B、run()
C、currentThread()
D、join()

3、Runnable接口在（）包中。
A、java.util
B、java.awt
C、java.lang
D、java.io

4、Thread类的sleep方法会抛出（）异常。
A、IOException
B、InterruptedException
C、EOFException
D、SecurityException

5、线程a吵醒线程b时，正确的语句是（）。
A、a.interrupt();
B、b.interrupt();
C、Thread.interrupt();
D、interrupt();

6、以下选项中，（）属于线程中断状态。
A、JVM将cpu的使用权从当前线程切换给其他线程
B、线程执行了休眠方法
C、线程执行了wait()方法
D、线程在运行期间，执行了一些阻塞线程的操作

7、class SubThread extends Thread{ public void run(){ for (int i=1; i<=20; i++) System.out.print("次" + i + ", "); } } public class TestExtendsThread{ public static void main(String[] args){ SubThread sub = new SubThread(); sub.start(); for (int i=1; i<=20; i++) System.out.print("主" + i + ", "); } } 上述语句中，sub.start()；可以省略。（）

8、class SubThread extends Thread{ public void run(){ for (int i=1; i<=20; i++) { System.out.print("次" + i + ", "); Thread.sleep(1000); } } } 上述线程子类的声明是正确的。（）

9、某个线程正在使用同步方法时，JVM不会把cpu的时间片分配给其他也要使用同步方法的线程。（）

10、Thread类的使用wait()方法不会抛出异常。（）

11、Thread类的使用wait()方法必须在同步方法中使用。（）

12、Thread类的join()方法会抛出InterruptedException异常。（）

13、一个线程联合另外一个线程的操作总是能成功。（）

14、如果守护线程的任务是无限循环，则其他线程消亡之后，守护线程会一直执行下去。（）

15、Runnable接口中的抽象方法是（）。

16、class RunClass implements Runnable{ （） void run(){ for (int i=1; i<=20; i++) System.out.print("次" + i + ", "); } } 上述语句中，括号里应该填写（）。

17、获取当前正在使用cpu资源的线程对象的语句是（）。

18、被synchronized修饰的方法称为（）。

第10章 Java网络程序设计

第10章单元测验

1、在Java的Socket通信机制的有连接的通信方式中，服务器端和客户端分别需要打开输入流和输出流通道。（）。

2、ServerSocket类创建的对象是客户端对象。（）

3、在Java的Socket通信机制的无连接的通信方式中，服务器端和客户端分别需要打开输入流和输出流通道。（）。

4、URL类在（）包中。

5、URL俗称（）。

6、InetAddress类在（）包中。

7、端口号的取值范围是0~（）。

8、DatagramSocket类在（）包中。

第11章正则表达式

第11章单元测试

1、对于需求“哪个单词中同时含有i和u两个字母，且u在i之前”，讲课内容中（11.1节）先用String类的方法indexOf()实现这一目的（参见11.1节的类TestSearchTwo），但逻辑复杂且不严谨。下列哪个选项符合要求，但不能被类TestSearchTwo中的方法识别？（）
A、guidance
B、picturing
C、unanimously
D、uninterrupted

2、含有字母组合ui的单词的正则表达式表示是（）。
A、"ui"
B、"ui\\w*"
C、"\\w*ui\\w*"
D、"\\w*u\\w*i\\w*"

3、同时含有前缀“re”、词根“duc”和后缀“able”的单词的正则表达式是（）。
A、"re//w*duc//w*able"
B、"//w*re//w*duc//w*able//w*"
C、"//w*re//w*duc//w*able"
D、"re//w*duc//w*able//w*"

4、对于语句： boolean flag = Pattern.matches(patternString, word); 下列说法正确的是（）。
A、使用这个方法不需要建立Pattern的对象
B、这个方法会对patternString有改动
C、这个方法对word有改动
D、匹配的中间结果会被保存下来

5、对于语句： Pattern pattern = Pattern.compile(patternString); 下列说法错误的是（）。
A、如果查找模式串patternString，则pattern中保存的信息是完整的，不需要模式串patternString的再次参与
B、利用pattern查找patternString，会比直接用Pattern.matches(PatternString, word)的效率有所提升
C、pattern是patternString信息的整理
D、使用预编译方式匹配模式串，不但效率有提升，而且节省内存

6、对于语句： Pattern pattern = Pattern.compile(patternString); 关于其中的参数patternString，正确的描述是（）。
A、patternString必须是普通字符串
B、patternString既可以是普通字符串又可以是正则表达式字符串
C、patternString不能是长度为0的字符串
D、patternString必须是正则表达式，否则方法compile( )可能无法正确进行工作

7、Java中判断一个字符串是否是由单独一个反斜杠构成，正确的正则表达式表示是（）。
A、"\"
B、"\\"
C、"\\\"
D、"\\\\"

8、要查找一个单词中是否含有小写字母x，下列哪个选项中的正则表达式是正确的？（）
A、"//w*x?//w*"
B、"x+"
C、"x{ 1,}"
D、"//w*x//w*"

9、判断一个非空字符串中没有空白符的正则表达式，正确的是（）。
A、"\\s{ 1,}"
B、"\\S{ 1,}"
C、"\\s+"
D、"\\S*"

10、去掉字符串str中所有空白符的语句哪个是错误的？（）
A、str = str.replaceAll("\\s*", "");
B、st