1、关于Java编译,下面哪一个正确()
A、Java程序经编译后产生机器码
B、Java程序经编译后会生产字节码
C、Java程序经编译后会产生 DLL 文件
D、以上都不正确
参考答案
答案:B
分析:
- java 源码代码经编译后会生成 .class 字节码,通过 JVM 翻译成机器码去执行
- DLL 文件是 C/C++ 语言编译的动态链接库
2、关于构造方法,下列说法正确的是()
A、类中的构造方法不可省略
B、构造方法可以与类同名,但方法不能与类同名
C、构造方法在一个对象被 new 时执行
D、一个类只能定义一个构造方法
参考答案
答案:C
分析:
- Java 类中不写构造方法,编译器会默认提供一个无参构造
- 方法名可以与类名相同,但不符合命名规范,类名首字母建议大写,方法名建议首字母小写
- 一个类中可以定义多个构造方法,这就是构造方法的重载
3、Java接口方法的修饰符可以是()
A、private
B、protected
C、abstract
D、final
参考答案
答案:C
分析:
- 接口中的访问权限修饰符只能是 public 或 default
- 接口中的方法必须要实现类实现,所以不能使用 final
- 接口中所有的方法默认都是 abstract,通常 abstract 省略不写
4、以下代码将输出()
A、不能通过编译
B、通过编译,输出A
C、通过编译,输出AA
D、通过编译,输出AAA
public class AA extends A{
public AA(){
System.out.print("AA");
}
public static void main(String[] args) {
AA aa = new AA();
}
}
class A {
public A(){
System.out.print("A");
}
}
参考答案
答案:D
分析:
创建子类对象,先执行父类的构造方法,再执行子类的构造方法
5、关于关键字的使用说法错误的是()
A、static 方法能处理非 static 的属性
B、abstract 方法必须在 abstract 类中
C、abstract 类中可以有 private 的成员
D、abstract 不能与 final 并列修饰同一个类
参考答案
答案:A
分析:
- 加载 class 时首先完成 static 方法装载,非 static 属性和方法还没有完成初始化,所以不能调用。
6、关于内存回收正确的是()
A、内存回收程序负责释放无用内存
B、必须创建一个线程来释放内存
C、内存回收程序可以在指定的时间释放内存对象
D、内存回收程序允许程序员直接释放内存
参考答案
答案:A
分析:
- 内存由 JVM 负责释放
- 程序员无法直接释放内存
- 垃圾回收时间不确定
7、哪些标识符合法?
A、class
B、$change
C、1 nil
D、_sysl_111
参考答案
答案:BD
分析:
标识符的命令规范
- 可以包含字母、数字、下划线、$
- 不能以数字开头
- 不能是 Java 关键字
8、说法正确的是()
A、java.lang.Runnable 是接口
B、java.lang.Cloneable 是类
C、Double 对象在 java.lang 包中
D、Double a = 1.0 是正确的java语句
参考答案
答案:ACD
分析:
- java.lang.Cloneable 是接口
9、定义一个Java类,可被所有类访问,申明正确的是()
A、public class A extends Object
B、class A extends Object
C、protected class A
D、public class A
参考答案
答案:AD
分析:
- 无权限修饰符的类,只能在同包中访问,所以 B 不正确
- 类的访问权限修饰符只能是 public 和 default,所以 C 不正确
10、Java中关于继承,错误的是()
A、当实例化子类时会递归调用父类中的构造方法
B、父类更具通用性,子类更具体
C、继承存在着传递性
D、继承允许一个子类继承多个父类
参考答案
答案:D
分析:
Java是单继承的,一个类只能继承一个父类。
11、下列运算符合法的是()
A、<>
B、&&
C、if
D、=
参考答案
答案:BD
分析:
- <> 在某些语言中表示不等于,但 Java中 不能这么使用
- && 是逻辑运算符中的短路与
- if 是条件判断符号,不是运算符
- = 是赋值运算符
12、打印值是多少?
A、-1
B、0
C、1
D、死循环
public class TestDoWhile {
public static void main(String[] args) {
int a = 0;
int b = 0;
do{
--b;
a = a - 1;
} while (b > 0);
System.out.println(b);
}
}
参考答案
答案:A
分析:
- do while 循环是先执行后判断
- 代码先执行 --b 操作,b = -1
- 之后执行 a=a-1,a 为 -1
- 然后判断 b 是否大于 0 ,条件不成立,退出循环
b 输出 -1
13、关于抽象,正确的是()
A、abstract 修饰符可修饰字段、方法和类
B、声明抽象方法不可写出大括号
C、声明抽象方法,大括号可有可无
D、抽象方法的 body 部分必须用一对大括号包住
参考答案
答案:B
分析:
- abstract 只能修饰方法和类,不能修饰字段
- 抽象方法不能有方法体,即没有括号
14、正确的是()
A、实例方法可直接调用超类的实例方法
B、实例方法可直接调用超类的类方法
C、实例方法可直接调用本类的类方法
D、实例方法可直接调用其他类的实例方法
参考答案
答案:C
分析:
- 子类无法调用超类的私方法
- 调用其他类的方法,要看方法的修饰符、两个类的关系和包路径
15、正确的是()
A、环境变量可在编译 source code 时指定
B、在编译程序时,所指定的环境变置不包括 class path
C、javac —次可同时编译数个 Java 源文件
D、javac.exe 能指定编译结果要置于哪个目录
参考答案
答案:CD
分析:
- java_home 无法再编译时指定,最多在命令行,让操作系统直接找到可执行程序
- 编译程序时,环境变量包括 java_home 和 class path
- javac.exe -d 参数可指定生成类文件的位置
16、错误的是()
A、数组属于一种基本数据类型
B、数组是—种对象
C、int num[]=(1,2,3,4)
D、数组的长度可以任意改变
参考答案
答案:ACD
分析:
- Java中的基本数据类型有 8 种,没有数组
- C、语法错误,应该用 {}
- D、数组的长度一旦确定就不能修改
17、哪些不能修饰 interface
A、public
B、private
C、protected
D、static
参考答案
答案:BCD
分析:
- 只有 public、abstract和默认的 3 种修饰符能够修饰 interface
正确的是()
A、call by value 不会改变实际参数的数值
B、call by reference 能改变实际参数的参考地址
C、call by reference 不能改变实际参数的参考地址
D、call by reference 能改变实际参数的内容
参考答案
答案:ACD
分析:
- 首先了解下 Java 中参数的传递有两种
- call by value:传递的是具体的值,基础数据类型就是这种类型
- call by reference:传递的是对象的引用,即对象的存储地址
- call by value 不能改变实参的数值
- call by reference 不能改变实参的参考地址,但可以访问和改变地址中的内容
18、存在i+1< i的数吗?为什么?
存在,如 Integer.MAX_VALUE
public class TestMaxValueAddOne {
public static void main(String[] args) {
int i = Integer.MAX_VALUE;
System.out.println(i+1<i);
System.out.println(i+1);
}
}
打印
true
-2147483648
19、声明合法的是()
A、long l = 1234
B、int i = 1234L
C、float f = 12.34
D、double d = 12.34
参考答案
答案:AD
分析:
- int 类型申明不需要在值后面加字母,如 int = 4
- float 类型申明需要在值后面加字母 f 或 F,如 float f = 12.34f
20、下面打印结果是?
int i = 5;
switch (i) {
default:
System.out.println("default");
case 0:
System.out.println(0);
break;
case 1:
System.out.println(1);
break;
case 2:
System.out.println(2);
break;
}
参考答案
default
0
解析:
- default 语句块没有使用 break,穿透到 case 0
21、解释以下正则表达式的含义
\d
\D
\s
.
*
?
|
+
[0-9]{2}
参考答案
- \d 匹配一个数字字符,等价于[0-9]
- \D 匹配一个非数字字符,等价于[^0-9]
- \s 匹配任何空白字符,包括空格、制表符、换页符等,等价于 [ \f\n\r\t\v]
- . 匹配除换行符 \n 之外的任何单字符,匹配 . 字符需要转译,使用 .
- *匹配前面的子表达式零或多次,匹配 * 字符,需要转译使用 *
- ? 匹配前面子表达式零或一次,或表示指明表达式为非贪婪模式的限定符。匹配 ? 字符,需要转译使用 ?
- | 将两个匹配条件进行逻辑 或 运算
- +匹配前面的子表达式一次或多次,要匹配 + 字符需要转译,使用 +
- [0-9]{6} 匹配连续6个0-9之间的数字
22/当输入为2的时候返回值是
public static int cal(int i) {
int result = 0;
switch (i) {
case 1:
result = result + i;
case 2:
result = result + i * 2;
case 3:
result = result + i * 3;
}
return result;
}
参考答案
- case 语句缺少 break;
返回值是 10
23、System.out.println(‘a’+1);的结果是
答案
- 打印 98
分析:
- ‘a’ 是 char 型;1 是 int 型
int 与 char 相加,char 会被强转为 int 型,char 的 ASCII 码值是 97,加一起等于 98
24、下面两段代码的区别是?
short s1 = 1; s1 = s1 + 1;
short s1 = 1; s1 += 1;
答案
- 第一段编译报错,s1 + 1自动升级为 int 型,int 型赋值给 s1,需要手动强转
- 第二段隐含类型强转,不会报错
25、打印结果是什么
public class TestConstructorPrint {
public static void main(String[] args) {
Parent parent = new Child();
parent = new Child();
}
}
class Parent {
static {
System.out.print("1");
}
public Parent() {
System.out.print("2");
}
}
class Child extends Parent {
static {
System.out.print("3");
}
public Child() {
System.out.print("4");
}
}
参考答案
打印:132424
创建对象时构造器的调用顺序
- 递归初始化父类静态成员和静态代码块,上层优先
- 初始化本类静态成员和静态代码块
- 递归父类构造器,上层优先
- 调用自身构造器
26、下面代码的输出是?
public class TestExchange {
String str = new String("1");
char[] arr = { 'a', 'b', 'c' };
public static void main(String[] args) {
TestExchange te = new TestExchange();
te.exchange(te.str, te.arr);
System.out.print(te.str + " ");
System.out.print(te.arr);
}
public void exchange(String str, char arr[]) {
str = "2";
arr[0] = 'd';
}
}
参考答案
输出
1 dbc
分析:
te 对象的 str 属性被 exchange 方法处理过之后,仍然指向字符串常量缓冲区 “1”
arr 属性是个数组,在 exchange 方法中,数组的内部第一个位置的值被修改,是生效的。如果加上 arr = new char[0]; 这段,输出值不会改变,原理同上。
27、关于String[] strArr=new String[10];正确的是()
A、strArr[10] 为 “”
B、strArr[0] 为未定义
C、strArr[9] 为 null
D、strArr.length 为 10
参考答案
答案:CD
分析:
- 引用数据类型的默认值为 null
- strArr.length 为数组的长度 10
28、写一个方法实现String类的replaceAll方法
参考答案
String 的 replaceAll 是基于正则表达式实现的,借助 JDK 中正则表达式实现。
import java.util.regex.Pattern;
public class TestReplaceAll {
public static void main(String[] args) {
String s = "01234abcd";
System.out.println(replaceAll(s, "[a-z]", "CX"));
}
public static String replaceAll(String s, String regex, String replacement) {
return Pattern.compile(regex).matcher(s).replaceAll(replacement);
}
}