TYUTJava阶段测试
第一次
- Java源程序文件的扩展名为（）
答案：.java
解析：在 Java 中，程序员编写的源代码文件通常以.java作为扩展名，例如HelloWorld.java。
- 编译Java源代码（.java）文件的工具为（）
答案：javac
解析：javac是 Java 编译器，用于将.java源文件编译成字节码文件（.class）。例如在命令行中执行javac HelloWorld.java就可以完成编译。
- 执行Java字节码（.class）文件的工具为（）
答案：java
解析：java命令用于执行编译后的.class文件。比如执行java HelloWorld就能运行HelloWorld.class文件。
- main方法是Java Application程序执行的入口点，关于main方法头，哪项是合法的（）
答案：public static void main(String[] args)
解析：这是 Java 中标准的main方法签名。public表示该方法可以被任何类访问；static意味着它属于类而非类的实例；void表示该方法不返回任何值；main是方法名；String[] args是一个字符串数组，用于接收命令行参数。
- 在使用Eclipse开发Java程序之前，必须安装（）
答案：JDK（Java Development Kit）
解析：JDK 包含了 Java 编译器、Java 虚拟机等开发和运行 Java 程序所需的工具和环境，Eclipse 只是一个集成开发环境（IDE），需要依赖 JDK 来编译和运行 Java 程序。
- 对于一个三位的正整数 n，取出它的十位数字k（k为整型）的表达式是（）
答案：(n / 10) % 10
解析：n / 10会将整数n除以 10，去掉个位数字，然后对结果取模 10，就可以得到原来数字的十位数字。
- 现有一个变量声明为boolean aa;下面赋值语句中正确的是（）
答案：aa = true;或者aa = false;
解析：boolean类型的变量只能被赋值为true或false。
- 下列数据类型的精度由高到低的顺序是（）
答案：double > float > long > int > short > byte
解析：double是双精度浮点数，精度最高；float是单精度浮点数；long是长整型；int是整型；short是短整型；byte是字节型，精度最低。
- 以下的选项中能正确表示Java语言中的一个整型常量的是（）
答案：例如123、0x1F（十六进制）、012（八进制）等
解析：Java 中的整型常量可以是十进制、十六进制（以0x开头）、八进制（以0开头）等形式。
- 下面不正确的变量名是（）
答案：例如123abc（不能以数字开头）、class（不能是 Java 关键字）等
解析：Java 变量名必须以字母、下划线（_）或美元符号（$）开头，不能使用 Java 关键字。
- 下面哪个标识符是合法的（D）
答案：例如myVariable、_count、$value等，B 选项：标识符中不能包含+这样的运算符
解析：标识符需以字母、下划线或美元符号开头，后面可以跟字母、数字、下划线或美元符号，且不能是 Java 关键字。 - 指出下列类型转换中正确的是（D）
A 选项：int i=8.3;错误，8.3是double类型（小数默认是double类型 ），将double类型直接赋值给int类型会丢失精度且不符合语法规则，需要强制类型转换，如int i = (int)8.3;。
B 选项：long L=8.4f;错误，8.4f是float类型，不能直接赋值给long类型，需要强制类型转换，如long L = (long)8.4f;。
C 选项：int i=(boolean)8.9;错误，boolean类型和数值类型（如int、double等）之间不能进行类型转换，它们属于不同的数据类型体系。
答案：例如int a = 10; double b = (double)a;（小范围转大范围自动转换，大范围转小范围需强制转换）
解析：当把一个小范围的数据类型赋值给大范围的数据类型时，Java 会自动进行类型转换；反之，则需要使用强制类型转换。 - 已知x和y均为boolean型变量，则x && y的值为true的条件是什么? （）
答案：x和y都为true
解析：&&是逻辑与运算符，只有当两个操作数都为true时，结果才为true。
- 有一个类A，以下为其构造方法的声明，其中正确的是？（B）
答案：public A() {}或public A(int param) {}等
解析：构造方法的名称必须与类名相同，且没有返回类型（包括void）。 - 设有定义float x=3.5f, y=4.6f, z=5.7f；则以下的表达式中，值为true的是（）
A 选项：x>y || x>z，已知x = 3.5f，y = 4.6f，z = 5.7f，x>y为false（因为3.5f < 4.6f），x>z为false（因为3.5f < 5.7f），||是逻辑或运算符，只有当两个操作数都为false时结果才为false，所以该表达式值为false。
B 选项：x!= y，由于x = 3.5f，y = 4.6f，两者不相等，!=是不等于运算符，所以该表达式值为true。
C 选项：x>(y + x)，先计算y + x，即4.6f + 3.5f = 8.1f，而x = 3.5f，显然3.5f < 8.1f，所以该表达式值为false。
D 选项：x<y &&!(x<z)，x<y为true（因为3.5f < 4.6f），x<z为true（因为3.5f < 5.7f），!(x<z)为false，&&是逻辑与运算符，只有当两个操作数都为true时结果才为true，所以该表达式值为false。
- 创建二维数组a[3][4]后，a[0].length的值应该等于（）
答案：4
解析：a[3][4]表示一个有 3 行 4 列的二维数组，a[0]表示第一行，a[0].length就是第一行的元素个数，即列数 4。
- 下列关于数组的使用，不正确的是（）
A 选项：在 Java 中，数组一旦创建，其长度就固定下来，不能再修改，例如int[] arr = new int[5];，这个数组arr的长度就是 5，后续不能改变，该选项说法正确。
B 选项：数组要求其中存放的数据类型一致，比如int[] arr只能存放int类型数据，String[] strArr只能存放String类型数据 ，该选项说法正确。
C 选项：数组下标范围是从 0 开始，最大到 “数组长度 - 1” 。例如长度为 5 的数组，其有效下标是 0、1、2、3、4，而不是到数组长度 5 ，该选项说法错误。
D 选项：Java 数组既可以存放基本数据类型（如int、double等），也可以存放对象类型（如自定义类的对象 ），比如Object[] objArr = new Object[3];可以存放各种对象，该选项说法正确。
答案：例如int[] arr = new int[3]; arr[3] = 10;（数组越界，数组下标从 0 开始，长度为 3 的数组有效下标是 0、1、2）
解析：访问数组元素时，下标不能超出数组的有效范围。 - this在程序中代表的是? （父类）
答案：当前对象的引用
解析：this关键字在类的方法中使用，代表调用该方法的当前对象。
- 下面关于类的结构的说法正确的是？ （）
A 选项：类可以包含多个构造方法，即构造方法重载，通过不同的参数列表来实现不同的初始化逻辑，所以该选项错误。
B 选项：类可以没有属性，在一些情况下，类可能仅用于组织方法，实现特定功能，没有定义属性也是合法的，该选项正确。
C 选项：类不仅可以包含方法，还可以包含属性（成员变量）、构造方法等，所以该选项错误。
D 选项：类除了包含属性，还可以有方法、构造方法等成员，并非只能包含属性，所以该选项错误。
答案：类可以包含成员变量、构造方法和成员方法等。
解析：类是对象的抽象描述，通常由成员变量来描述对象的属性，构造方法用于创建对象，成员方法用于实现对象的行为。 - 定义类头时，不可能用到的关键字是？（static）
答案：例如void（void用于方法返回类型，不能用于类定义）
解析：定义类时常用的关键字有extends 、class、public、private、protected、abstract、final等。 - 下面类的定义中结构正确的是？ （）
A 选项：class A()错误，定义类的语法格式错误，类名后面不应有括号 ，正确格式是class A{}。
B 选项：class 2A错误，类名不能以数字开头，类名应遵循标识符的命名规则，以字母、下划线或美元符号开头 。
C 选项：int class A错误，int是数据类型关键字，不能用于类定义的开头，语法混乱 。
D 选项：public class A正确，public是访问修饰符（可选），用于指定类的访问权限，class是定义类的关键字，A是类名，符合类定义的语法结构 。
解析：类定义应包含类名、成员变量、构造方法和成员方法等，且语法要正确。 - 关于java源文件下列说法正确的是？ （）
A 选项：一个 Java 源文件中只能有一个public修饰的类，并且该public类的类名必须与源文件名相同（包括大小写） 。这是 Java 语法规定，用于规范代码结构和文件管理，该选项正确。
B 选项：一个 Java 源文件中可以有多个缺省（默认访问修饰符，即没有使用public、private、protected修饰 ）的类，所以该选项错误。
C 选项：protected修饰符不能用于修饰顶层类（即类定义在文件最外层，不是嵌套类 ），只能用于修饰类的成员（成员变量、成员方法等），所以不存在一个 Java 源文件中有多个protected修饰的类这种情况，该选项错误。
D 选项：同 C 选项，protected不能用于修饰顶层类，所以该选项错误。 - 下列构造方法的调用方式中，正确的是（）
A 选项：构造方法不能像一般方法那样直接调用。一般方法有明确的方法名用于被调用执行特定功能，而构造方法是和new关键字配合创建对象时使用的，所以该选项错误。
B 选项：构造方法不是由用户直接调用的。用户不能像调用普通成员方法那样去调用构造方法，它是在对象创建过程中被触发执行的，所以该选项错误。
C 选项：在 Java 中，构造方法只能通过new关键字来自动调用 。例如MyClass obj = new MyClass();，在执行new操作时，会自动调用MyClass类的构造方法来初始化对象，该选项正确。
D 选项：构造方法不会自动执行，必须在使用new关键字创建对象时才会被调用执行，如果不创建对象，构造方法不会执行，所以该选项错误。 - 以下哪个接口的定义是正确的？（）
A 选项：接口中的方法默认是抽象的，不能有方法体 。
interface B{ void print(){ };}中print方法有方法体，不符合接口定义规则，所以该选项错误。
B 选项：interface关键字本身就隐含了抽象的概念，不需要再用abstract修饰 。
abstract interface B { void print();}这种写法错误，所以该选项错误。
C 选项：一方面，不需要用abstract修饰interface；
另一方面，接口中方法不能有方法体 。
abstract interface B extends A1,A2 { abstract void print(){ };}存在这两处错误，所以该选项错误。
D 选项：interface B { void print();}符合接口的定义规则，接口名是B，里面定义了一个抽象方法print，方法声明正确，所以该选项正确。
解析：接口中的方法默认是public abstract的，不能有方法体。 - 下列类头定义中，错误的是 ? （A）
A 选项：在 Java 中，定义类时如果使用public修饰符，必须完整写出public class来声明类，public x extends y缺少class关键字，语法错误 。
B 选项：public class x extends y，public为访问修饰符，class是声明类的关键字，Ax是类名，extends y表示继承y类，语法正确。
C 选项：class x extends y implements y1，class声明类，x是类名，extends y表示继承y类，implements y1表示实现y1接口，语法正确。
D 选项：class x是最基本的类声明形式，使用class关键字声明了一个名为x的类，语法正确。
答案：例如public void class MyClass（void不能用于类定义）
解析：类定义使用class关键字，不能使用void等用于方法返回类型的关键字。 - 下列类定义中，不正确的是? （）
A 选项：class x是定义类的基本形式，声明了一个名为x的类，语法正确。
B 选项：class x extends y表示定义一个类x，它继承自类y，符合 Java 中类继承的语法规则。
C 选项：class x implements y1,y2表示类x实现了接口y1和y2，在 Java 中一个类可以实现多个接口，该定义正确。
D 选项：Java 中类只支持单继承，即一个类只能有一个直接父类 。public class x extends X1,X2试图让类x继承两个类X1和X2，不符合 Java 语法规则，所以该选项不正确。
答案：例如在类中定义方法时返回类型和方法名之间有错误的语法，如public void method() { return 1; }（void方法不能有返回值）
解析：类定义中的方法要遵循正确的语法规则，包括返回类型、方法名、参数列表和方法体等。 - 下列叙述正确的是？（C）
A 选项：Java 不允许多继承，即一个类不能同时直接继承多个父类。多继承可能会导致代码的复杂性和冲突等问题，所以该选项错误。
B 选项：在 Java 中，一个类可以实现多个接口 ，通过实现多个接口来让类具备多种不同的行为规范，所以该选项错误。
C 选项：Java 中类只支持单重继承，也就是一个类只能有一个直接父类，通过继承可以复用父类的属性和方法，该选项正确。
D 选项：Java 不允许多继承，不管是普通类还是抽象类，一个类都只能有一个直接父类，所以一个类不能继承多个抽象类，该选项错误。 - 对于try和catch子句的排列方式，下面哪一项是正确的? （）
A 选项：在try - catch结构中，子类异常应该在前，父类异常在后。因为如果父类异常在前，当try块中抛出子类异常时，会被父类异常的catch块捕获，导致后续子类异常特有的处理逻辑无法执行 ，所以该选项正确。
B 选项：若父类异常在前，子类异常在后，会出现上述提到的子类异常被父类异常提前捕获的问题，所以该选项错误。
C 选项：try - catch结构中既可以有子类异常，也可以有父类异常 ，只要按照正确的排列顺序（子类异常在前，父类异常在后 ）即可，所以该选项错误。
D 选项：父类异常和子类异常可以出现在同一个try程序段内，前提是正确安排catch块的顺序，所以该选项错误。
答案：例如在类中定义方法时返回类型和方法名之间有错误的语法，如public void method() { return 1; }（void方法不能有返回值）
解析：类定义中的方法要遵循正确的语法规则，包括返回类型、方法名、参数列表和方法体等。 - 关于异常的定义，下面描述正确的是？（）
- 当方法产生该方法无法确定该如何处理的异常时，应该如何处理? （）
答案：使用throws关键字在方法声明中抛出异常。
解析：throws用于在方法声明中指定该方法可能抛出的异常类型，将异常处理的责任交给调用该方法的代码。 -
请写出下列程序的输出结果
interface A {
int x = 1;
void showX();
}
interface B {
int y = 2;
void showY();
}
class InterfaceTest implements A, B {
int z = 3;
public void showX() {
System.out.println("x=" + x);
}
public void showY() {
System.out.println("y=" + y);
}
public void showMe() {
System.out.println("z=" + (z + x + y));
}
}
public class Class1 {
public static void main(String[] args) {
InterfaceTest myObject = new InterfaceTest();
myObject.showX();
myObject.showY();
myObject.showMe();
}
}
这段 Java 代码定义了两个接口A和B，一个实现了这两个接口的类InterfaceTest，以及包含main方法的类Class1。下面分析代码的执行过程及输出结果：
InterfaceTest对象创建：在main方法中，使用new关键字创建了InterfaceTest类的一个对象myObject。
调用showX方法：调用myObject.showX()时，showX方法会输出接口A中常量x的值。由于接口中的变量默认是public static final的，所以这里输出x=1。
调用showY方法：调用myObject.showY()时，showY方法会输出接口B中常量y的值，输出结果为y=2。
调用showMe方法：调用myObject.showMe()时，showMe方法会输出z + x + y的结果，其中z是InterfaceTest类的实例变量，值为 3；x是接口A的常量，值为 1；y是接口B的常量，值为 2。所以输出结果为z=6。
第二次
1-6
第 1 题
- 答案：D
- 解析：
private static int x=100;虽然是私有静态变量，但在本类内部可以访问和操作。从第 5 行到第 10 行，对x进行了 4 次自增（x++）和 1 次自减（x--）操作 ，100 + 4 - 1 = 102，所以最终输出x=102。
第 2 题
- 答案：B
- 解析：方法重写要求重写方法与被重写方法具有相同的返回值类型、方法名、参数列表，且重写方法不能比被重写方法声明更多的异常（或者声明更少、更具体的异常）。B 选项中方法返回值类型、参数列表与父类方法不同，且抛出了更宽泛的
Exception，不符合重写规则。
第 3 题√
- 答案：C
- 解析：
(x>4)? 99.9:9是三元表达式，x = 4，条件x>4不成立，所以取冒号后面的值9，又因为输出语句中println方法会自动将结果转换为合适类型输出，在 Java 中，整数9作为浮点数输出就是9.0。
第 4 题
- 答案：B
- 解析：在
change方法中，str="test ok";只是改变了方法内部局部变量str的引用指向，不会影响到主方法中str原本指向的字符串对象，所以输出还是good；而ch[0]='g';改变了字符数组ch中第一个元素的值，所以输出gbc。
第 5 题√
- 答案：C
- 解析：
ClassDemo类的构造方法中每次都会执行sum = sum + 5;，第一次实例化demo1时，sum初始值为1，执行构造方法后sum变为6，第二次实例化demo2时，sum基于上次结果6，再执行构造方法变为6 + 5 = 11，所以demo1.sum输出为11。
第 6 题
- 答案：A
- 解析：抽象类中可以有抽象方法和非抽象方法，抽象方法只有声明没有实现。
A 选项public abstract void method(int a);是合法的抽象方法声明；
B 选项value = value + 5;中value未定义，会报错；
C 选项public int method();定义方法没有方法体，在非抽象类中不合法（抽象类中抽象方法需用abstract修饰）；
D 选项抽象方法不能有方法体。
7-16
第 7 题
- 答案：C
- 解析：在 Java 中，创建子类对象时，会先调用父类的无参构造方法（如果没有显示调用父类其他构造方法），再调用子类构造方法。执行
new Child("mike")时，先调用People类的无参构造方法People()输出1，再调用People(String name)输出2，最后调用Child(String name)输出3，所以顺序是123。
第 8 题√
- 答案：D
- 解析：接口只能被
public修饰，
private、protected、private protected都不能用于修饰接口。
接口默认是public abstract，使用public修饰可以明确其对外可见性。
第 9 题√
- 答案：D
- 解析：子类对象可以赋值给父类引用，这是多态的体现。因为
B是A的子类，C是B的子类，所以A a0=new A();、A a1=new B();、A a2=new C();这三行代码在编译和运行时都不会出错，它们都符合继承体系下的引用赋值规则。
第 10 题
- 答案：C
- 解析：
method1()是非静态方法，需要通过对象来调用，不能通过类名A直接调用，会报错；a是A类的实例对象，可以通过a调用非静态方法method1()，也可以调用静态方法method2()；
类名A可以直接调用静态方法method2()。
第 11 题
- 答案：A
- 解析：
num是实例变量，每个对象有独立副本。foo1、foo2、foo3各自的num初始为0，经自增后foo3.num为3。x是静态变量，所有对象共享，static代码块执行一次使x为1，后续多次自增，最终foo3.x为3，所以输出3,3。
第 12 题
- 答案：D
- 解析：接口中
EASY是final修饰的静态常量，值为3。doStuff方法中++s先自增后使用，s初始值为0，自增3次后为3，但EASY是final不能被修改，再次执行++s会导致编译错误，因为对常量重新赋值。
第 13 题
- 答案：C
- 解析：
SubCalc类中重写multiply方法时，int c = super.multiply(a, b);调用父类方法，父类multiply方法返回值类型是int，这里调用语法正确。但SubCalc类中multiply方法返回值类型声明为int，而方法体中没有显式return语句返回计算结果，编译会报错 。
第 14 题√
- 答案：A
- 解析：在 Java 源文件中，正确顺序是
package声明（指定包名，可选），然后是import语句（导入其他包的类，可选），最后是class定义（定义类） 。
第 15 题√
- 答案：B
- 解析：
public static void main方法的标准参数形式是String[] args，也可以写成String args[]，它用于接收命令行传入的参数。
第 16 题
- 答案：B
- 解析：方法重写要求方法名、参数列表、返回值类型相同，且重写方法不能比被重写方法声明更宽泛的异常。A 选项抛出异常比父类方法更宽泛；C 选项参数类型不同；D 选项方法修饰符错误，重写方法不能比父类方法更严格（父类是
public，重写方法不能是private） 。
17-24
第 17 题
- 答案：BDE
- 解析：外层循环
i从0到2，内层循环j从3到0递减。当i = 0，j = 3时，j--后j = 2，continue跳过本次内层循环输出，此时i = 0，j = 2；内层循环继续，j--后j = 1，再次continue；内层循环继续，j--后j = 0，输出i=0 j=0。外层循环i++变为1，内层循环重新开始，j从3开始，j--后j = 2，输出i=1 j=2；内层循环继续，j--后j = 1，continue；内层循环继续，j--后j = 0，continue。外层循环i++变为2，内层循环重新开始，j从3开始，j--后j = 2，continue；内层循环继续，j--后j = 1，continue；内层循环继续，j--后j = 0，continue。
第 18 题
- 答案：B
- 解析：
Base b = new Base();创建Base类对象没问题，但Sub s=(Sub)b;试图将父类对象强制转换为子类对象，而这个父类对象实际不是子类实例，不符合继承关系的类型转换规则，编译时就会报错 。
第 19 题
- 答案：D
- 解析：
abstract和final不能同时修饰类，abstract类需被继承扩展，final类不能被继承；abstract类不能是private，private修饰的类不能被其他类访问和继承；protected和private不能同时修饰成员；public abstract class Car{}是合法的抽象类声明 。
第 20 题
- 答案：C
- 解析：构造方法与类名必须相同，没有返回值且不用
void声明，只能通过new关键字自动调用。构造方法可以有输入参数，用于初始化对象成员变量，所以 C 选项说法错误。
第 21 题
- 答案：3
- 解析：先执行
m1(2,3)，根据m1方法逻辑，2<=3，返回3；再执行fun(3,1)，fun方法返回两参数之和，即3 + 1 = 4。
第 22 题
- 答案：Sub.
- 解析：
Base b = new Sub();是多态的体现，创建的是Sub类对象，调用b.fun()时，根据动态绑定机制，会调用子类Sub重写后的fun方法，所以输出Sub.。
第 23 题
- 答案：
- 经过路程：299.609375 米
- 第 10 次反弹高度：0.09765625 米
- 解析：
- 经过路程：第一次落地经过 100 米；从第一次反弹到第二次落地，经过的路程是100×21×2 米；从第二次反弹到第三次落地，经过的路程是100×(21)2×2 米；以此类推，到第 10 次落地，经过的总路程S=100+2×100×(21)+2×100×(21)2+⋯+2×100×(21)9 。这是一个首项a1=100 ，公比q=21 的等比数列求和问题（除了第一项 100 ），根据等比数列求和公式Sn=1−qa1(1−qn) ，这里n=9 ，先求出后面等比数列和为2×100×1−2121(1−(21)9)=200×(1−(21)9) ，再加上第一项 100，即S=100+200×(1−(21)9)=100+200×(1−5121)=100+200×512511≈299.609375 米。
- 第 10 次反弹高度：根据规律，第n 次反弹高度h=100×(21)n ，当n=10 时，h=100×(21)10=1024100=0.09765625 米。
第 24 题
- 答案：
import java.util.ArrayList;
import java.util.List;public class RemainingPerson {public static void main(String[] args) {int total = 500;List<Integer> people = new ArrayList<>();for (int i = 1; i <= total; i++) {people.add(i);}int index = 0;while (people.size() > 1) {for (int i = 0; i < 2; i++) {index++;if (index == people.size()) {index = 0;}}people.remove(index);if (index == people.size()) {index = 0;}}System.out.println("最后剩下的人是：" + people.get(0));}
}
解析：使用ArrayList 存储人员编号，通过循环模拟报数过程。外层while 循环保证列表中人数大于 1 。内层for 循环两次，每次移动到下一个人（处理循环末尾回到开头情况），然后移除报数为 3 的人，最后输出列表中剩下的唯一编号，即最后剩下的人。