尔雅JAVA程序设计_30章节答案(学习通2023题目答案)

点击查看答案

第1章 Java入门

1.1 课程介绍、尔雅Java历史及特点随堂测验

1、程序在当前的设计Java实现中，每个Java源文件编译之后就是章节一个以 为后缀的文件。
A、答案.doc
B、学习.java
C、通题.class
D、目答.exe

2、尔雅Java Application程序中有且只能有一个main方法，程序该方法头的设计书写合法的是 。
A、章节public static void main()
B、答案public static void main(String[] args)
C、学习public static int main(String[] arg)
D、通题public void main(String[] arg )

第1章测验

1、源文件名为HelloWorld.java的Java应用程序如下： public class HelloWorld{ public static void main(String args[]) { System.out.println("Hello World!"); } } 将这个程序的源文件放在C:\Test下，然后在命令行窗口中，进入到C:\Test路径执行如下指令， javac helloWorld.java 将得到（ ）结果。
A、编译出错 。
B、编译成功，生成名为HelloW
C、编译成功，生成名为helloWorld.class的文件
D、找不到名为helloworld.java的文件

2、Java程序中程序运行入口方法main的签名正确的有（ ）。
A、public static void main(String args[])
B、static public void main(String[] args)
C、public void static main(String[] args)
D、public void main(String args[])

3、一个可以独立运行的Java应用程序（ ）。
A、可以有一个或多个main方法
B、最多只能有两个main方法
C、可以有一个或零个main方法
D、只能有一个main方法

4、在Java语言中，不能注释多行内容的符号是（ ）。
A、以//开始的注释
B、以/*开始，*/结束的注释
C、以/**开始，*/结束的注释
D、以上都不能

5、可以被J2SDK中的javadoc.exe识别，并自动从程序中提出注释内容形成程序文档的注释形式是（ ）。
A、以//开始的注释
B、以/*开始，*/结束的注释
C、以/**开始，*/结束的注释
D、以上都不是

6、Java源文件是由若干个书写形式相互独立的类组成。

7、Java源文件中只能有一个类

8、若Java源文件中有多个类，那么至多有一个类可以是public类。

9、若Java源文件中有多个类，那么必须要有一个类是public类。

10、如果Java源文件中只有一个类，这个类必须主类。

11、Java源文件中可以没有主类。

12、每个Java应用程序可以包括许多方法，但必须有且只能有一个_______方法（给出方法名）。

13、开发与运行Java程序需要经过的三个主要步骤为：编辑源程序、 生成字节码文件和解释运行字节码。

第1章作业

1、什么是JDK？什么是JRE? 什么是JVM?（写出英文全称，并简单解释说明）

2、简述Java源程序运行机制（即Java源程序的运行主要分两步分别是什么）。

第2章 基本数据类型与数组

第2章单元测验

1、Java中关于break和continue语句，下面说法错误的有（ ）。
A、continue只能用于循环语句中。
B、break可以用于循环语句中。
C、在循环语句中，break语句将终止循环，而continue是略过当前循环中剩余的语句进入下一次循环。
D、在循环语句中，continue语句将终止循环，而break是略过当前循环中剩余的语句进入下一次循环。

2、byte变量的取值范围是（ ）。
A、0 - 65535
B、-128 – 127
C、-256 – 255
D、0 - 32767

3、在Java语言中，有一些英文单词已有特殊含义和用途，在程序中不得将它们另作它用，这些英文单词称为保留字或( )。
A、变量
B、常量
C、注释
D、关键字

4、如下哪个字符串是Java中的合法自定义标识符？（ ）
A、_fieldname
B、false
C、3number
D、name#id

5、下面哪个语句正确地声明一个整型的二维数组？（ ）
A、int a[][] = new int[][];
B、int a[100][100] = new int[][];
C、int a[][] = new int[][100];
D、int a[][] = new int[100][100];

6、以下语句正确的有 （ ） 。
A、int i = 32;
B、float f = 45.32;
C、double d=3.2;
D、char c=”A”;

7、Java中下列数据类型，必须进行强制转换的是（ ）。
A、float —> int
B、short —> long
C、float —> double
D、int —> char

8、汉字可以出现在自定义标识符中。

9、3.14是float型常量。

10、2e3和3.14E2都是double型常量。

11、int []a; 和 int a[]; 都是正确地声明了一个一维数组a。

12、在Java的基本数据类型中，char型采用Unicode编码方案，无论是中文字符还是英文字符，都是占用一样多字节内存空间，其中每个Unicode码占用（ ）字节内存空间。

13、数组x定义如下：int x[ ][ ]=new int[3][5]，则 x[2].length 的值为（ ）。

14、Java中表达式 1/5 * 5 的计算结果是（ ）。

第3章 运算符、表达式与语句

第3章单元测验

1、下列叙述正确的是（ ）。
A、表达式 (short)10+’B’ 的值是short型数据
B、表达式 ’桃’+’花’ 的值是char型数据
C、表达式 (int)3.25+10.0 的值是int型数据
D、表达式 5.0/2+10 的值是double型数据

2、若有定义：int i=8, j=010; ，下列语句序列执行后，j 的值是( )。 if(i>j) i--; else j--;
A、10
B、9
C、8
D、7

3、对于下列程序，叙述正确的是（ ）。 public class Test { public static void main(String[] args) { int m=10,n=20; if(m<n) System.out.println("hello"); else System.out.println("ok"); System.out.println("你好"); } }
A、程序输出的结果是：hello你好
B、程序输出的结果是：hello
C、程序输出的结果是：ok
D、程序输出的结果是：你好

4、对于下列程序，叙述正确的是（ ）。 public class Test { public static void main(String[] args) { int m=10,n=20; if(m<n) System.out.println("hello"); System.out.println("你好"); else System.out.println("ok"); System.out.println("好的"); } }
A、程序输出的结果是：hello你好
B、程序输出的结果是：ok好的
C、程序输出的结果是：ok
D、出现编译错误。

5、对于下列程序，下列叙述正确的是（ ）。 public class Test { public static void main(String[] args) { int m=100; if(m=100){ System.out.println("hello"); System.out.println("你好"); } else{ System.out.println("ok"); System.out.println("好的"); } } }
A、出现编译错误。
B、程序输出的结果是：ok好的
C、程序输出的结果是：ok
D、程序输出的结果是：hello你好

6、下列语句序列执行后，k 的值是( )。 int i=10, j=18, k=30; switch( j - i ) { case 8: k++; case 9: k+=2; case 10: k+=3; default: k/=j; }
A、31
B、32
C、2
D、33

7、已知定义：int a[ ]={ 1,2,3,4,5,6,7,8,9,10}; ，为了打印输出数组a的最后一个元素，下面正确的代码是( )。
A、System.out.println(a[10]);
B、System.out.println(a(9));
C、System.out.println(a[a.1ength]);
D、System.Out.println(a[a.1ength-1]);

8、下列叙述中错误的是（ ）。
A、while(表达式)… 语句中“表达式”的值必修是boolean型数据。
B、for(表达式1; 表达式2; 表达式3)… 语句中“表达式2”的值必修是boolean型数据。
C、if(表达式)… 语句中“表达式”的值必修是boolean型数据。
D、switch语句中必修要有default选项。

9、以下语句中由 for 语句构成的循环执行的次数是( )。 for ( int i = 0; true ; i++) ;
A、有语法错，不能执行
B、无限次
C、执行1次
D、一次也不执行

10、设有数组定义：int MyArray[ ] = { 10 , 20 , 30 , 40 , 50 , 60 , 70}; 则执行以下几个语句后的输出结果是( ) 。 int s = 0; for (int i = 0; i < MyArray.length; i++) { if (i % 3 == 2) s += MyArray[i]; } System.out.println(s);

11、public class Ex { public static void main(String args[]) { int x = 5, y = 10; boolean result = x++ > 5 && ++y > 10; System.out.println(result); } } 运行以上程序，输出result的值为( )。

12、public class Ex { public static void main(String args[]) { int x = 5, y = 10; boolean result = x++ > 5 && ++y > 10; System.out.println("x:" + x + ",y:" + y); } } 运行以上程序，输出 y 的值为( )。

第4章 类与对象

4.1 类与对象的概念随堂测验

1、设 A已定义的类名，下列声明类A的对象a1的语句中正确的是（ ）。
A、A a1= new B( );
B、A a1=new A( );
C、int A a1;
D、A a1= A( );

2、下列哪个叙述是正确的（ ）。
A、Java源文件必须含有主类。
B、Java源文件如果含有主类，主类必须是public类。
C、Java应用程序由若干个类所构成，这些类必须在一个源文件中。
D、Java应用程序由若干个类所构成，这些类可以在一个源文件中，也可以分布在若干个源文件中，其中必须有一个源文件含有主类。

3、class _____{ String name; int age; Student(String s, int i) { name=s; age=i; } }

4.2 成员属性与成员方法随堂测验

1、下列方法定义中，不正确的是（ ）。
A、float fun(int a, int b) { return (a-b); }
B、int fun(int a, int b) { return a-b;}
C、int fun(){ char ch='a'; return (int)ch;}
D、int fun(int a, int b) { return 1.2*(a+b);}

2、下列下列哪个叙述是正确的（）。
A、局部变量没有默认值
B、成员变量没有默认值
C、方法的参数的名字可以和方法中声明的局部变量的名字相同
D、成员变量的名字不可以和局部变量的名字相同

3、下列程序的输出结果为（ ）。 class Tom { int x = 8, y; void f() { int x =10; y = x*x; } public static void main(String args[]) { Tom tt = new Tom(); tt.f(); System.out.println(tt.y); } }

4、下列程序执行之后，将会输出( )。 public class Test { public static void main(String[] args) { int salary, nCars, nHouses; salary = 6000; nCars = 0; nHouses = 0; DayDreaming(salary, nCars, nHouses); System.out.println(salary + "," + nCars + "," + nHouses); } static void DayDreaming(int salary, int cars, int houses) { salary = salary * 3; cars += 2; houses++; } }

4.3 特殊方法与类成员随堂测验

1、下面方法中可以作为public void example( ){ ...}的重载方法的是（ ）
A、public void example( ){ ...}
B、public void example( int m ){ ...}
C、public void example2( ){ ...}
D、public int example ( ){ ...}

2、设 i、j、k 为类 x 中定义的 int 型变量，下列类 x 的构造方法中不正确的是( )。
A、x(int m){ ... }
B、x(int m, int n){ ... }
C、void x( int m){ ... }
D、x(int h,int m,int n){ ... }

3、为AB类的一个无形式参数且无返回值的方法method书写方法头，要使用类名AB作为前缀就可以调用该方法（即可以通过类名调用方法method），该方法头的形式为( )。
A、abstract void method( )
B、final void method( )
C、public void method( )
D、static void method( )

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

4.4 this关键字与包随堂测验

1、下列程序的输出结果是（）。 class Tom { int x = 10, y; void f() { int x = 5; y = x + this.x; } public static void main(String args[]) { Tom tt = new Tom(); tt.f(); System.out.println(tt.y); } }

2、下列程序的输出结果为（ ）。 class Point { int x, y; Point() { this(10, 10); } Point(int a, int b) { x = a; y = b; } public static void main(String[] args) { Point pp = new Point(); System.out.println(pp.x + "," + pp.y); } }

3、在当前目录下，创建一个名为 Tools 的包的语句是 。

4、引入java.util包中所有的类的语句是 。

4.5 基本数据类型类与对象数组随堂测验

1、数组x定义如下：int x[ ][ ]=new int[5][8] ，则 x[2].length 的值为 。

2、下列程序的输出结果为（ ）。 public class MainClass { public static void main(String args[]) { int i, s = 0; int num[] = { 11, 22, 33, 44, 55, 66, 77, 88, 99 }; for (i = 0; i < num.length; i++) if (num[i] % 3 == 0) s += num[i]; System.out.println(s); } }

第4章 单元测验

1、下列叙述是正确的是（ ）。
A、成员变量的名字不可以和局部变量的名字相同。
B、方法的参数的名字可以和方法中声明的局部变量的名字相同。
C、成员变量没有默认值。
D、局部变量没有默认值。

2、给出如下代码：class Test{ private int m; 　　public static void fun( ) { 　　　　// some code... 　　} } 如何使成员变量m 在方法fun( )中直接访问? ( )
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

3、下列说法正确的是（ ）。
A、不需要定义类，就能创建对象。
B、对象中必须有属性和方法。
C、属性可以是基本数据类型的变量，也可以是一个对象。
D、属性必须是基本数据类型的变量。

4、以下关于Java中类的构造方法的说法中，错误的是（ ）。
A、构造方法必须与其所属类同名。
B、构造方法可以用new运算符调用（系统自动调用）。
C、一个类只能有一个构造方法。
D、构造方法只能有形参，而没有返回值。

5、下面哪个方法可以作为方法 public void example(int m) 的重载方法？（ ） public void example(int m){ //... }
A、public void example(float m){ ...}
B、public void example(int x){ ...}
C、public void example2( ){ ...}
D、public int example ( ){ ...}

6、下列叙述中说法正确的是（ ）。
A、类中必须先声明成员变量，然后再定义方法。
B、类中成员变量的声明和方法的定义可以交叉进行。
C、类中必须先定义构造方法，才可以定义其他方法。
D、类中必须先定义实例变量，才可以定义static变量。

7、下列程序执行之后，将会输出( )。注意：程序中的符号为英文状态下的符号（如逗号和分号）。 public class Counter { int myCount =100; static int ourCount =500; void increment() { myCount++; ourCount++; } public static void main(String[] args) { Counter counter1 = new Counter(); Counter counter2 = new Counter(); counter1.increment(); counter1.increment(); System.out.print(counter1.myCount+","+counter1.ourCount+","); counter2.increment(); System.out.print(counter2.myCount+","+counter2.ourCount); } }

8、指出下列程序运行的结果 ( )。注意：输出结果中符号为英文状态下的符号。 public class DayDreaming { public static void main(String[] args) { double[ ] salary = { 6000}; int[ ] nCarsHouses = { 0,0}; DayDreaming(salary, nCarsHouses); System.out.print(salary[0]+ "," + nCarsHouses[0]); System.out.println("," + nCarsHouses[1]); } static void DayDreaming(double[] salary, int[] nCarsHouses) { salary[0] = salary[0] * 3; nCarsHouses[0] += 2; nCarsHouses[1] ++; } }

9、请写出下述程序的输出结果（ ）。 class Counter { int i = 0; } public class Reference { public void plus(int i) { i++; } public void plus(Counter c) { c.i++; } public void create(Counter c) { c = new Counter(); c.i++; } public static void main(String[] args) { int i = 0; Reference r = new Reference(); Counter c1 = new Counter(); Counter c2 = new Counter(); r.plus(i); System.out.print(i); r.plus(c1); System.out.print(c1.i); r.create(c2); System.out.print(c2.i); } }

10、请写出下述程序的输出结果（ ） public class Main { public static void main(String[] args) { int a[] = { 0, 0, 0, 0, 0, 0 }; calculate(a); for (int x : a) System.out.print(x); } static void calculate(int x[]) { for (int i = 1; i < x.length; i++) x[i] = x[i-1] + 1; } }

第4章 单元作业

1、设计一个Point（二维图中的点）类。

2、设计一个圆形的类即Circle类。

3、设计一个雇员Employee类

第5章 子类与继承

第5章单元测验

1、下列叙述正确的是（ ）。
A、子类继承父类的构造方法。
B、abstract类的子类必须是非abstract类。
C、子类继承的方法只能操作子类继承和隐藏的成员变量。
D、子类重写或新增的方法也能直接操作被子类隐藏的成员变量。

2、下列叙述正确的是（ ）。
A、final类可以有子类。
B、不可以同时用final和abstract修饰同一个方法。
C、abstract类中只可以有abstract方法。
D、abstract类中可以有非abstract方法，但该方法不可以用final修饰。

3、对于一个Person类，下列叙述是错误的是（ ）。
A、若Person是非final类，则它可以有多个子类。
B、类声明class Person 与class Person extends Object是等价的。
C、除了Object类，任何一个类有且仅有一个父类。
D、用户在定义子类Person时，可以给子类Person指定多个父类。

4、下列叙述正确的是（ ）。
A、子类不可以定义和父类同名的方法。
B、子类不可以声明和父类同名的成员变量。
C、子类继承父类的构造方法。
D、若在子类中想使用被子类隐藏的成员变量或方法就需要使用关键字super。

5、对于下例代码，下面叙述正确的是（ ）。 class Person { Person(int m){ } } class Student extends Person { }
A、可以用Person类的无参数构造方法创建对象：new Person()。
B、可以用Student类的无参数构造方法创建对象：new Student()。
C、代码无法通过编译。
D、Person类不能创建对象。

6、下列叙述正确的是（ ）。
A、子类重写父类的方法时，不允许降低方法的访问权限，但可以提高访问权限。
B、子类在方法重写时，可以把父类的public方法重写为protected方法。
C、子类在方法重写时，可以把父类的public方法重写为private方法。
D、如果子类为非抽象类，也允许子类将父类的抽象方法可以不实现。

7、下列叙述是错误的是（ ）。
A、若一个抽象类是某个抽象类的子类，那么它必须将父类抽象方法重写为非抽象方法。
B、子类对象的上转型对象不能操作子类新增的成员变量（失去了部分属性），不能调用子类新增的方法。
C、子类对象的上转型对象可以访问子类继承或隐藏的成员变量。
D、抽象类声明的对象可以成为子类对象的上转型对象。

8、编译并运行下面的程序，运行结果为（ 　）。 public class A { public static void main(String[] args) { A a = new B(); a.test(); } void test() { System.out.print("A"); } } class B extends A { void test() { super.test(); System.out.println("B"); } }

9、编译并运行下面的程序，运行结果为（ 　）。 public class Main { public static void main(String[] args) { AA obj = new BB(); System.out.println(obj.f(4, 6)); } } class AA { double f(double x, double y) { return x * y; } } class BB extends AA { double f(double x, double y) { return x + y; } }

10、编译并运行下面的程序，运行结果为（ 　）。 public class Main{ public static void main(String[] args) { Robot002 robot = new Robot002(); } } class Robot001 { Robot001( ) { System.out.print("001R"); } Robot001(int k) { System.out.print("001R"+k); } } class Robot002 extends Robot001 { Robot002() { super(3); System.out.print("002R"); } }

11、编译并运行下面的程序，运行结果为（ 　）。 public class Main { public static void main(String[] args) { Child kid1 = new Child1(), kid2 = new Child2(); kid1.say(); kid2.say(); } } class Child { public void say() { System.out.print("Hi!"); } } class Child1 extends Child { public void say() { System.out.print("Bingo!"); } } class Child2 extends Child { public void say() { System.out.print("OK!"); } }

第5章单元作业

1、设计一个动物声音“模拟器”，希望模拟器可以模拟许多动物的叫声，主要包括了抽象类Animal及其4个子类、模拟器类Simulator、和主类Main的设计。

2、设计一个几何图形的面积计算器，希望这个计算器可以计算圆、三角形和矩形等图形的面积，主要包括了抽象类Shape与其2个子类、面积计算器类Calculator、以及主类Main的设计。

第6章 Java的接口

第6章单元测验

1、以下关于继承的叙述正确的是（ ）。
A、在Java中一个类只能实现一个接口
B、在Java中类只允许单一继承
C、在Java中一个类不能同时继承一个类和实现一个接口
D、在Java中接口只允许单一继承

2、在Java中，下列叙述正确的是（ ）。
A、一个类最多可以实现两个接口。
B、允许接口中只有一个抽象方法。
C、若一个非抽象类实现某个接口，则它可以只重写接口中的部分方法。
D、若一个抽象类实现某个接口，则它必须要重写接口中的全部方法。

3、对于下列Com接口，叙述正确的是（ ）。 interface Com{ int MAX=100; int fun(); }
A、Com是一个public接口
B、编译器认为int fun(); 就是 abstract int fun();
C、编译器认为 int MAX=100; 就是public final int MAX=100;
D、编译器认为 int MAX=100; 就是public static final int MAX=100;

4、对于下列代码，叙述正确的是（ ）。 interface Com{ int MAX=100; public void stop(); protected void start(); abstract void pause(); }
A、int MAX=100; 会导致编译出错。
B、public void stop(); 会导致编译出错。
C、protected void start(); 会导致编译出错。
D、abstract void pause(); 会导致编译出错。

5、在Java中，下列叙述错误的是（ ）。
A、能用protected修饰接口。
B、不能用final 修饰接口。
C、可以用接口名直接访问接口中的常量。
D、若一个非抽象类实现某个接口，该类必须重写接口中的全部抽象方法。

6、在Java中，下列叙述错误的是（ ）。
A、interface Com2 extends Com1 意思是Com2是Com1的子接口。
B、类声明 class A implements Printable,Addable 意思是A类实现Printable和Addable接口。
C、类声明 class B extends A implements Com 意思是B类是A类的子类，父类A实现Com接口。
D、类声明 class B extends A implements Com 意思是B类是A类的子类，同时实现Com接口。

7、在Java中，下列叙述错误的是（ ）。
A、可以把一个int数据赋值为接口变量。
B、接口也是Java中一种重要数据类型，用接口声明的变量称作接口变量。
C、子接口将继承父接口中全部方法和常量。
D、一个类声明实现一个接口，但没有重写接口中的所有方法，那么这个类必须是抽象类。

8、在Java中，下列叙述错误的是（ ）。
A、接口中只可以有常量，不能有变量。
B、抽象类中既可有常量，也可以有变量。
C、接口的方法可以用private或protected修饰。
D、把实现某一接口的类创建的对象的引用赋值给该接口变量，则该接口变量就可以调用被类实现的接口方法。

9、下列程序执行之后，将会输出（ ）。interface Com{ int Max=800; int on(); } class A implements Com{ public int on(){ return Com.Max; } } public class Ex { public static void main(String args[]) { Com com=new A(); int m=com.on(); System.out.printf("%d",m); } }

10、下列程序执行之后，将会输出（ ）。interface Com{ int computer(int a,int b); } class A implements Com{ public int computer(int a,int b){ return a+b; } } class B implements Com{ public int computer(int a,int b){ return a*b; } } class Person{ Com com; int getResult(int a,int b){ return com.computer(a, b); } } public class Ex { public static void main(String args[]) { Person p=new Person(); p.com=new A(); int m=p.getResult(21,10); p.com=new B(); int n=p.getResult(21,10); System.out.printf("%d,%d",m,n); } }

第6章单元作业

1、利用接口做参数，写个计算器，能完成加减乘除运算。

2、设计3个接口、一个圆柱体类Cylinder，及一个主类Main。

第7章 内部类与异常类

第7章单元测验

1、已知如下代码：public class Test{ public static void main ( String arg[] ) { long a[] = new long[6]; System.out.println ( a[6] ); } }
A、程序输出 null
B、程序输出 0
C、因为long[ ] 数组声明不正确，程序不能被编译
D、程序被编译，但在运行时将抛出一个ArrayIndexOutOfBoundsException异常

2、关于以下程序段的说明正确的是 （ ）public class Test { public static void main(String args[]) { try { int x[] = new int[-5]; System.out.println("此行将无法被执行!"); } catch (NegativeArraySizeException e) { System.out.println("exception: 数组下标不能为负数。"); } } }
A、编译通过，输出： 此行将无法被执行!
B、编译通过，输出： 此行将无法被执行! exception: 数组下标不能为负数。
C、编译通过，输出： exception: 数组下标不能为负数。
D、编译不能通过

3、下列关于抛出异常的描述中，错误的一项是( )。
A、任何从Throwable派生的类都可以用throw语句抛出
B、Exception和Error是Throwable的直接派生类
C、try语句块中的异常抛出点后的代码在抛出异常后不再执行
D、Exception代表系统严重错误，一般程序不处理这类错误

4、编译下列E.java得到 E$1.class、E.class、HelloMachine.class、SpeakHello.class字节码文件，下列叙述正确的是（ ）。interface SpeakHello { void speak(); } class HelloMachine { public void turnOn(SpeakHello hello) { hello.speak(); } } public class E{ public static void main(String args[]) { HelloMachine machine = new HelloMachine(); machine.turnOn( new SpeakHello(){ public void speak() { System.out.println("Welcome!"); } }); } }
A、E$1.class是接口匿名类的字节码文件（编译器给匿名类的名字是E$1）。
B、E.class是接口匿名类的字节码文件。
C、HelloMachine.class是接口匿名类的字节码文件。
D、SpeakHello.class是接口匿名类的字节码文件。

5、下列哪个叙述是错误的？（ ）。
A、内部类的外嵌类的成员变量在内部类仍然有效。
B、内部类中的方法也可以调用外嵌类中的方法。
C、内部类的类体中可以声明类变量（static变量）。
D、外嵌类的类体中可以用内部类声明对象，作为外嵌类的成员。

6、下列哪个叙述是错误的？（ ）。
A、try~catch语句可以由几个catch语句组成，分别处理发生的相应异常。
B、一个方法在声明时可以使用throws关键字声明要产生的若干个异常。
C、一个方法在声明时可以使用throw关键字声明要产生的若干个异常。
D、throw的作用就是抛出异常，位于方法中，与throws是不同的关键字。

7、写出以下程序的运行结果( )。public class TryCatchFinally { static void Proc(int sel) { try { if (sel == 0) { System.out.println("no Exception "); return; } else if (sel == 1) { int i = 0; int j = 4 / i; } } catch (ArithmeticException e) { System.out.println("Catch "); } catch (Exception e) { System.out.println("Will not be executed"); } finally { System.out.println("finally"); } } public static void main(String args[]) { Proc(0); Proc(1); } }

8、阅读以下程序，写出输出结果：( )。 public class Main { public static void main(String[] args) { try { method(); } catch (NullPointerException e) { System.out.print("G"); } catch (Exception e) { System.out.print("A"); } finally { System.out.print("B"); } } static void method() { try { wrench(); System.out.print("C"); } catch (ArithmeticException e) { System.out.print("D"); } finally { System.out.print("E"); } System.out.print("F"); } static void wrench() { throw new NullPointerException(); } }

9、写出以下程序的运行结果 ( )。 class Outer { private class Inner { public void show() { System.out.println("Secret!"); } } public Inner getInner() { return new Inner(); } public static void main(String[] args) { Outer outer = new Outer(); Outer.Inner inner = outer.getInner(); inner.show(); } }

10、写出以下程序的运行结果( )。interface IDemo { void demoMethod(); } public class MyDemo { public void test(IDemo demo) { System.out.println("test method:"); demo.demoMethod(); } public static void main(String[] args) { MyDemo md = new MyDemo(); /*这里使用匿名内部类的方式将接口对象作为参数传递到test方法中去了*/ md.test(new IDemo() { public void demoMethod() { System.out.println("implement method"); } }); } }

第8章 常用实用类

第8章单元测验

1、下列叙述错误的是（ ）。
A、String类是final类，不可以有子类。
B、表达式"This is a pen".contains(“pen”)的值为true。
C、”abc”==”abc”表达式的值为true。
D、”abc”.equals(”Abc”) 的值为true。

2、下列哪个叙述是错误的？（ ）
A、"9dog".matches("\\ddog")的值是true。
B、"12hello567".replaceAll("[123456789]+","@")返回的字符串是@hello@。
C、"RedBird".indexOf("Bird")的值是3。
D、"Bird".compareTo("Bird fly")的值是正数。

3、下面程序段的运行结果是（）String str1="hello"; String str2=new String("hello"); System.out.println(str1==str2);
A、true
B、false
C、hello
D、he

4、对于如下代码，下列哪个叙述是正确的（ ） public class E{ public static void main(String[] args){ String strOne="bird"; String strTwo=strOne; strOne="fly"; System.out.println(strTwo); } }
A、程序编译出现错误。
B、程序的输出结果是bird。
C、程序的输出结果是fly。
D、程序的输出结果是null。

5、对于如下代码，下列哪个叙述是正确的（ ）public class E { public static void main (String args[]) { String s1 = args[1]; String s2 = args[2]; String s3 = args[3]; System.out.println(s3); } }
A、程序出现编译错误。
B、无编译错误，在命令行执行程序：“java E I love this game”，程序输出this。
C、无编译错误，在命令行执行程序：“java E let us go”，程序无运行异常。
D、无编译错误，在命令行执行程序：“java E 0 1 2 3 4 5 6 7 8 9”程序输出3。

6、给定以下代码，程序的运行结果是 （）public class Example { String str = new String("good"); char[] ch = { 'a', 'b', 'c' }; public static void main(String[] args) { Example ex = new Example(); ex.change(ex.str, ex.ch); System.out.print(ex.str + "and"); System.out.print(ex.ch); } public void change(String str, char ch[]) { str = "test ok"; ch[0] = 'g'; } }

7、下面程序的运行结果是（） public class Example { public static void main(String[] args) { String s1 = new String("Hello"); String s2 = new String("Hello"); System.out.print(s1 == s2); String s3 = "Hello"; String s4 = "Hello"; System.out.print(s3 == s4); s1 = s3; s2 = s4; System.out.print(s1 == s2); } }

8、给定以下代码，程序的运行结果是 （）public class Test { public static void main(String[] args) { String result = reverse("happy"); System.out.println(result); } public static String reverse(String str) { StringBuilder result = new StringBuilder(""); char[] chArra = str.toCharArray(); for (int i = chArra.length - 1; i >= 0; i--) { char ch = chArra[i]; result.append(ch); } return result.toString(); } }

9、给定以下代码，程序的运行结果是 （）public class Test { public static void main(String[] args) { String a = "Programming"; String b = new String("Programming"); String c = "Program" + "ming"; System.out.println(a == b); System.out.println(a == c); System.out.println(a.equals(b)); System.out.println(a.equals(c)); } }

10、请说出E类中标注的【代码】，的输出结果。public class E { public static void main (String args[ ]) { String regex = "\\djava\\w{ 1,}" ; String str1 = "88javaookk"; String str2 = "9javaHello"; if(str1.matches(regex)) { System.out.println(str1); } if(str2.matches(regex)) { System.out.println(str2); //【代码】 } } }

第9章 组件及事件处理

第9单元测验

1、下列叙述不正确的是（ ）。
A、JButton对象可以使用 addActionLister(ActionListener ls) 方法将没有实现ActionListener接口的类的实例注册为自己的监视器。
B、监视WindowEvent事件的监视器必须实现WindowListener接口。
C、窗口可以调用setTitle(String s)方法设置窗口的标题。
D、JFrame创建的窗口默认是不可见的。

2、JFrame类的对象的默认布局管理器是（ ）布局管理器。

3、处理鼠标拖动触发的MouseEvent事件需使用（ ）接口。

4、JPanel的默认布局管理器是（ ）布局管理器。

第10章 输入输出流

第10章单元测验

1、为了向文件 hello.txt 尾加数据，下列正确创建指向 hello.txt 的流的语句段是（ ）。
A、try { OutputStream out = new FileOutputStream ("hello.txt"); }catch(IOException e){ }
B、try { OutputStream out = new FileOutputStream ("hello.txt",true); }catch(IOException e){ }
C、try { OutputStream out = new FileOutputStream ("hello.txt",false); }catch(IOException e){ }
D、try { OutputStream out = new OutputStream ("hello.txt",true); }catch(IOException e){ }

2、为了提高写性能，可以采用什么流？（ ）
A、DataInputStream
B、DataOutputStream
C、BufferedInputStream
D、BufferedOutputStream

3、下面语句的功能是( )。 RandomAccessFile raf = new RandomAccessFile("a.txt","rw" );
A、打开当前目录下的文件a.txt，但只能向文件写入数据，不能从文件读取数据。
B、打开当前目录下的文件a.txt，但不能向文件写入数据，只能从文件读取数据。
C、打开当前目录下的文件a.txt，既可以向文件写数据，也可以从文件读数据。
D、以上说法都不对

4、构造BufferedInputStream的合适参数是哪一个? ( )
A、FileInputStream
B、BufferedOutputStream
C、File
D、FileOutputStream

5、下面的程序段创建了BufferedReader类的对象in，以便读取本机c盘my文件夹下的文件book.txt，File 构造函数中正确的路径和文件名的表示是( )。 File f = new File( ); //空格处为填代码处 FileReader fr = new FileReader(f); BufferedReader in = new BufferedReader(fr);
A、"./book.txt"
B、"../my/book.txt"
C、"c:\\my\\book.txt"
D、"c:\my\book.txt"

6、使用对象输入输出流实现对象序列化可以直接存取对象。

7、所有的文件输入／输出流都继承于InputStream类/OutputStream类。

8、流主要由四个抽象类组成：InputStream、OutputStream、Reader 和 Writer。

9、文件类 是java.io中的一个重要的非流类，里面封装了对文件系统进行操作的功能。

10、如果准备按字节读取一个文件的内容，应当使用 流 （FileInputStream流 / FileReader流）。

11、File类中定义了 方法来判断一个文件是否存在。（写出方法名称）

第11章 JDBC数据库编程

第11章单元测验

1、Java中，JDBC是指( )。
A、Java程序与数据库连接的一种机制。
B、Java程序与浏览器交互的一种机制。
C、Java类库名称。
D、Java类编译程序。

2、JDBC中，用于表示数据库连接的对象是（ ）类的对象。
A、PreparedStatement
B、DriverManager
C、Connection
D、Statement

3、如果由PreparedStatement对象pst为下列对应的预编译SQL的第三个问号赋值，那么正确的选项是（ ）。 UPDATE emp SET ename=?, job=?, salary=? WHERE empno=?
A、pst.setFloat("3",2000);
B、pst.setFloat(3,2000);
C、pst.setFloat("salary",2000);
D、pst.setString("salary","2000");

4、以下描述正确的是 ( )
A、CallableStatement是PreparedStatement的父接口
B、PreparedStatement是CallableStatement的父接口
C、CallableStatement是Statement的父接口
D、PreparedStatement是Statement的父接口

5、获取ResutlSet对象rst的第一行数据，以下可以实现该功能的语句是 ( )
A、rst.hashNext();
B、rst.next();
C、rst.first();
D、rst.nextRow();

6、以下负责建立与数据库连接的是 ( )
A、Statement
B、PreparedStatement
C、ResultSet
D、DriverManager

7、在Java中，JDBC API 定义了一组用于与数据库进行通信的接口和类，它们包括在（ ）包中。
A、java.lang
B、java.util
C、java.sql
D、java.math

8、（ ）对象是executeQuery()方法的返回值，它被称为结果集，它代表符合SQL语句条件的所有行，并且它通过一套getXXX方法（这些get方法可以访问当前行中的不同列）提供了对这些行中数据的访问。

第12章Java多线程机制

第12章单元测验

1、下列哪个叙述是错误的（ ）。
A、如果两个线程需要调用同一个同步方法，那么一个线程调用该同步方法时，另一个线程必须等待。
B、线程新建后，不调用 start( ) 方法也有机会获得CPU资源.
C、默认情况下，所有线程的优先级都是5级。
D、线程是一个程序的单个执行流。

2、下列有关线程的叙述中正确的一项是（ ）。
A、一旦一个线程被创建，它就立即开始运行。
B、使用start() 方法可以使一个线程成为可运行的，但是它不一定立即开始运行。
C、当一个线程因为抢占机制而停止运行时，它被放在可运行队列的前面。
D、新建的线程调用start()方法就能立即进入运行状态。

3、对于下列程序，叙述正确的是（ ）。public class E { public static void main(String args[]) { Target target =new Target(); Thread thread =new Thread(target); thread.start(); } } class Target implements Runnable{ public void run(){ System.out.println("ok"); } }
A、JVM认为这个应用程序共有两个线程。
B、JVM认为这个应用程序只有一个主线程。
C、JVM认为这个应用程序只有一个thread线程。
D、thread的优先级是10级。

4、下代码创建一个新线程并启动线程，问:四个选项中可以保证正确代码创建target对象，并能编译正确的是（ ） public static void main(String[] args) { Runnable target=new MyRunnable( ); Thread myThread=new Thread(target); }
A、public class MyRunnable extends Runnable { public void run( ) { } }
B、public class MyRunnable extends Runnable { void run( ) { } }
C、public class MyRunnable implements Runnable { public void run( ) { } }
D、public class MyRunnable implements Runnable { void run( ) { } }

5、处于运行状态的线程在某些情况下，如执行了sleep()方法，或等待I/O设备等资源，将让出CPU并暂时停止自己的运行，进入（ ）状态

6、处于新建状态的线程被启动后，将进入线程队列排队等待CPU，此时它已具备了运行条件，一旦轮到享用CPU资源就可以获得执行机会。上述线程是处于（ ）状态。

7、在Java中编写实现多线程应用有两种途径：一种是继承Thread类创建线程，另一种是实现 （ ）接口创建线程。

8、Java中，多线程访问某个共享资源可能出现线程安全问题，此时可以使用（ ）关键字来实现线程同步（如同步方法或同步块），从而避免安全问题出现，但会影响性能，甚至出现死锁。

9、在线程通信中，可以调用wait()、notify()、notifyAll()三个方法实现线程通信，这三个方法都是（ ）类提供的public方法，所以任何类都具有这三个方法。

10、在线程通信中，调用（ ）方法可以是当前线程处于等待状态，而为了唤醒一个等待的线程，需要调用的方法是notify()/notifyAll()。（写出方法名）

第13章泛型与集合框架

第13章单元测验

1、在Java中,下列集合类型可以存储无序、不重复的数据的是（ ）。
A、ArrayList
B、LinkedList
C、TreeSet
D、HashSet

2、以下代码的执行结果是（ ）。Set<String> s=new HashSet<String>(); s.add("abc"); s.add("abc"); s.add("abcd"); s.add("ABC"); System.out.println(s.size());
A、1
B、2
C、3
D、4

3、Java集合中的Set接口和List接口都是从Collection接口派生出来的。

4、数组和集合中的元素可以是任何数据类型，包括基本类型和引用类型。

5、如下Java代码，输出的运行结果是（ ）。 import java.util.*; public class E { public static void main(String args[]) { LinkedList< Integer> list=new LinkedList< Integer>(); for(int k=1;k<=10;k++) { list.add(new Integer(k)); } list.remove(5); list.remove(5); Integer m=list.get(5); System.out.println(m.intValue()); } }

Java程序设计期末测验

Java程序设计期末测验——客观题

1、以下关于继承的叙述正确的是（ ）。
A、在Java中一个类只能实现一个接口
B、在Java中类只允许单一继承
C、在Java中一个类不能同时继承一个类和实现一个接口
D、在Java中接口只允许单一继承

2、已知如下代码，其执行结果是什么（ ） public class Test { public static void main(String[] args) { String s1 = "Running"; String s2 = new String("Running"); System.out.print(s1 == s2); String s3 = "Run"+"ning"; System.out.print(s1 == s3); System.out.print(s2 == s3); } }
A、false true true
B、true false true
C、true true false
D、fasle true false

3、Java程序中，main方法的格式正确的是 ( )
A、static void main (String[] args){ }
B、public void main(String[] args){ }
C、public static void main(){ }
D、public static void main(String[] s){ }

4、下列语句序列执行后，x 和 y 的值分别是( )。 int x = 8, y = 010; if (x > y) x--; else y--; System.out.println(x+","+y);
A、7,10
B、8,9
C、7,8
D、8,7

5、用于定义类成员的访问控制权的一组关键字是( )。
A、class, float, double, public
B、float, boolean, int, long
C、char, extends, float, double
D、public, private, protected

6、在Java中，下列叙述正确的是（ ）。
A、子类重写父类的方法时，不允许降低方法的访问权限，但可以提高访问权限。
B、子类在方法重写时，可以把父类的public方法重写为private方法。
C、子类在方法重写时，可以把父类的public方法重写为protected方法。
D、如果子类为非抽象类，也允许子类将父类的抽象方法可以不实现。

7、关于构造方法，下列说法不正确的是( )
A、构造方法不可以进行方法重载
B、构造方法用来初始化该类的一个新的对象
C、构造方法具有和类名相同的名称
D、构造方法不返回任何数据类型

8、若 Com1、Com2 为已定义的接口，以下接口定义中没有语法错误的是（ ）
A、interface B extends Com1,Com2 { void show();}
B、interface B extends Com1,Com2 { void show(){ } }
C、abstract interface B extends Com1,Com2 { void show(); }
D、abstract interface B extends Com1,Com2 { abstract void show(){ }}

9、以下描述正确的是( )
A、CallableStatement是PreparedStatement的父接口
B、PreparedStatement是CallableStatement的父接口
C、PreparedStatement是CallableStatement的父接口
D、PreparedStatement是Statement的父接口

10、以下程序的输出结果为( )(注：输出结果中的符号如逗号等均是半角状态下的符号）。 interface Com { int computer(int a, int b); } class A implements Com { public int computer(int a, int b) { return a + b; } } class B implements Com { public int computer(int a, int b) { return a - b; } } class Person { int getResult(Com com,int a, int b) { return com.computer(a, b); } } public class Main { public static void main(String args[]) { Person p=new Person(); Com com=new A(); int m=p.getResult(com,10,45); com=new B(); int n=p.getResult(com,10,45); System.out.println(m+","+n); } }

11、以下程序的输出结果为（ ）。 class Father { void print() { System.out.print("Father"); } } class Son extends Father { void print() { super.print(); System.out.println("Son"); } } class Main{ public static void main(String[] args) { Father a = new Son(); a.print(); } }

12、以下程序的输出结果为（ ）。 class RCat001 { RCat001( ) { System.out.print("RC001"); } RCat001(String v) { System.out.print("RC001"+v); } } class RCat002 extends RCat001 { RCat002( ) { super(); System.out.println("RC002"); } RCat002(String v2) { super(); System.out.println("RC002"+v2); } RCat002(String v1,String v2) { super(v1); System.out.println("RC002"+v2); } } public class Main{ public static void main(String[] args) { RCat002 r21 = new RCat002("v03"); RCat002 r22 = new RCat002("v01","v05"); } }

13、以下程序的运行结果为（ ）。（注：输出结果中的符号如逗号等均是半角状态下的符号） class Apple { int n1 = 0; static int n2 = 0; void fun(int n3) { n1++; n2++; n3++; System.out.println(n1+","+n2+","+n3); } } public class Main { public static void main(String[] args) { Apple apple1 = new Apple(); apple1.fun(1); Apple apple2 = new Apple(); apple2.fun(1); apple2.fun(1); } }

14、以下程序的运行结果为（ ）。 class EX { static void Proc(int sel) { try { if (sel == 0) { System.out.println("NoException"); } else if (sel == 1) { int a = 0; int b = 9 / a; } } catch (ArithmeticException e) { System.out.println("Catch1"); return; } catch (Exception e) { System.out.println("Catch2"); return; } finally { System.out.println("finally"); } System.out.println("End"); } } class Test { public static void main(String args[]) { EX.Proc(0); EX.Proc(1); } }

15、下列语句序列执行后，s 的值是( )。 int a = 309, s = 0; switch (a % 10) { case 8: s++; case 9: s++; case 10: s+= 3; break; default: s/= 2; }

Java程序设计期末测验——编程题

1、从抽象类Shape类扩展出一个圆形类Circle

学习通JAVA程序设计_30：Java多线程初步

Java多线程是Java语言的一项重要特性，它可以使程序同时运行多个任务，提高程序的运行效率和并发能力。本篇文章将介绍Java多线程的概念、实现方式、线程同步、线程间通信等基础知识。

一、Java多线程概述

Java多线程是指在同一程序中同时执行多个线程，每个线程都是独立的单元，具有自己的执行路径、栈、局部变量等。多线程可以提高程序的运行效率，特别是在多核CPU的情况下，还可以提高程序的并发能力。

Java多线程是通过java.lang.Thread类和java.lang.Runnable接口来实现的。Thread类表示一个线程，而Runnable接口则表示一个任务。可以使用Thread类的构造方法创建一个线程，然后将一个Runnable对象作为参数传递给Thread构造方法，从而将一个任务绑定到一个线程上。

二、Java多线程实现方式

Java多线程的实现方式有两种：继承Thread类和实现Runnable接口。

1. 继承Thread类

继承Thread类是最简单的方式，只需重写Thread类的run()方法即可定义一个线程。例如：

<pre>class MyThread extends Thread {     public void run() {         // 线程执行的代码    }}>

创建线程的代码如下：

<pre>MyThread t = new MyThread();t.start(); // 启动线程>

注意，start()方法是启动线程的方法，它会自动调用run()方法。如果直接调用run()方法，则不会启动新线程，而是在当前线程中执行run()方法。

2. 实现Runnable接口

实现Runnable接口是比较灵活的方式，可以避免由于Java的单继承限制而无法同时继承其他类的问题。例如：

<pre>class MyTask implements Runnable {     public void run() {         // 任务执行的代码    }}>

创建线程的代码如下：

<pre>MyTask task = new MyTask();Thread t = new Thread(task);t.start(); // 启动线程>

也可以使用匿名内部类的方式定义Runnable对象：

<pre>Runnable task = new Runnable() {     public void run() {         // 任务执行的代码    }};Thread t = new Thread(task);t.start(); // 启动线程>

三、线程同步

线程同步是指多个线程访问共享资源时的同步机制，目的是避免数据的不一致性和并发错误。Java提供了两种机制来实现线程同步：synchronized关键字和java.util.concurrent包中的锁机制。

1. synchronized关键字

synchronized关键字可以用来修饰方法或代码块，用来实现方法或代码块的同步。当一个线程进入synchronized方法或代码块时，它会自动获取当前对象的锁，其他线程需要等待当前线程释放锁之后才能继续执行。例如：

<pre>class Counter {     private int count = 0;    public synchronized void increment() {         count++;    }    public synchronized void decrement() {         count--;    }    public synchronized int getCount() {         return count;    }}>

这个例子中，Counter类中的所有方法都被synchronized关键字修饰，因此它们都是线程安全的。

2. 锁机制

Java中提供了ReentrantLock和ReadWriteLock两种锁机制，可以更灵活地实现线程同步。例如：

<pre>import java.util.concurrent.locks.*;class Counter {     private int count = 0;    private Lock lock = new ReentrantLock(); // 创建可重入锁    public void increment() {         lock.lock(); // 获取锁        try {             count++;        } finally {             lock.unlock(); // 释放锁        }    }    public void decrement() {         lock.lock();        try {             count--;        } finally {             lock.unlock();        }    }    public int getCount() {         lock.lock();        try {             return count;        } finally {             lock.unlock();        }    }}>

四、线程间通信

线程间通信是指多个线程之间通过共享变量来进行信息交换和协调工作的过程。Java提供了wait()、notify()和notifyAll()三个方法来实现线程间通信。

1. wait()方法

wait()方法可以使当前线程进入等待状态，并释放当前对象的锁。等待其他线程调用notify()或notifyAll()方法来唤醒它。例如：

<pre>class Worker {     public synchronized void work() {         while (!finished) {             try {                 wait(); // 等待通知            } catch (InterruptedException e) {                 e.printStackTrace();            }        }        // 执行任务    }    public synchronized void finish() {         finished = true; // 修改共享变量        notifyAll(); // 通知所有等待的线程    }    private boolean finished = false;}>

这个例子中，Worker类中的work()方法会进入等待状态，直到其他线程调用finish()方法并修改finished变量为true，然后调用notifyAll()方法通知所有等待的线程。

2. notify()和notifyAll()方法

notify()方法会随机唤醒一个等待的线程，而notifyAll()方法会唤醒所有等待的线程。例如：

<pre>class Consumer {     public synchronized void consume() {         while (!available) {             try {                 wait(); // 等待通知            } catch (InterruptedException e) {                 e.printStackTrace();            }        }        // 消费产品        available = false;        notify(); // 通知生产者    }    public synchronized void produce() {         while (available) {             try {                 wait(); // 等待通知            } catch (InterruptedException e) {                 e.printStackTrace();            }        }        // 生产产品        available = true;        notify(); // 通知消费者    }    private boolean available = false;}>

这个例子中，Consumer类中的consume()方法会等待通知，直到生产者调用produce()方法来生产产品并通知消费者，然后消费者才能消费产品。生产者在生产完产品后也要等待消费者消费完产品后再继续生产。

五、总结

Java多线程是Java语言的一项重要特性，它可以提高程序的运行效率和并发能力。本篇文章介绍了Java多线程的概念、实现方式、线程同步、线程间通信等基础知识。要注意线程安全和线程同步的问题，避免数据的不一致和并发错误。