数据结构
网络
关系数据库管理系统 (RDBMS)
操作系统
Java
MS Excel
iOS
HTML
CSS
Android
Python
C 编程
C++
C#
MongoDB
MySQL
Javascript
PHP
物理学
化学
生物学
数学
英语
经济学
心理学
社会学
时尚研究
法学研究Java 棘手输出问题
Java 棘手输出问题很难回答，需要付出更多努力。如果我们试图用常识来回答一个具有挑战性的问题，我们会力不从心，因为这些问题需要专业的理解。大多数具有挑战性的 Java 问题都基于一些令人困惑的概念，例如循环、多线程、重载、重写等。
即使一个问题并不特别具有挑战性，我们有时也会难以解决它。尽管问题的答案很简单，但我们有时会粗心地编写代码。
即使我们不知道解决方案，我们仍然可以使用分析性思维来获得答案。在本文中，我们将讨论一些具有挑战性的 Java 棘手输出问题。
常见 Java 棘手输出问题
问题
考虑以下输出并尝试猜测答案
public class A {
public static void main(String args[]) {
//\u000d System.out.println("hello");
}
}
Hello
hello
HELLO
Error
\u000d
答案
输出将是“hello”。Unicode 字符 \u000d 是回车符，充当换行符。因此，注释行被解释为新的一行代码。
问题
尝试猜测以下输出的答案
String s1 = "Java";
String s2 = "Java";
StringBuilder sb1 = new StringBuilder();
sb1.append("Ja").append("va");
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
System.out.println(sb1.toString() == s1);
System.out.println(sb1.toString().equals(s1));
true 恰好打印一次。
true 恰好打印两次。
true 恰好打印三次。
true 恰好打印四次。
Error
答案
输出将是“true 恰好打印四次”。== 运算符比较两个引用是否指向完全相同的对象，而 equals() 方法检查两个对象的內容是否等效。Java 中的字符串字面量会被驻留，因此 s1 和 s2 指向同一个对象。StringBuilder 会生成一个新的 String 对象，所以 sb1.toString() != s1，但其内容与 s1 相同。
问题
回答以下问题
public class Demo {
public static void main(String args[]) {
System.out.print("a");
try {
System.out.print("b");
throw new IllegalArgumentException();
}
catch (RuntimeException e) {
System.out.print("c");
}
finally {
System.out.print("d");
}
System.out.print("e");
}
}
abe
abce
abde
abcde
抛出未捕获的异常
答案
输出将是“abcde”。即使 try 块中抛出异常，finally 块也将始终执行。
问题
考虑以下问题来猜测答案
public class Test {
public static void main(String args[]) {
int i=20+ +9- -12+ +4- -13+ +19;
System.out.println(i);
}
}
27
33
66
76
77
答案
输出将是“77”。一元加号和减号运算符的优先级高于二元加号和减号运算符，一元加号不会改变其操作数的符号。
问题
考虑以下代码来回答
public class Actors {
Public static void main(String arg[]) {
char[] ca ={0x4e, \u004e, 78};
System.out.println((ca[0] = = ca[1]) + " "+ (ca[0] = = ca[2]));
}
}
false false
true true
false true
true false
Error
答案
输出将是“true true”。字符数组中的所有三个元素都表示相同的数值 (78)，因此比较结果为 true。
问题
以下代码的输出是什么
public class _C {
private static int $;
public static void main(String main[]) {
String a_b;
System.out.print($);
System.out.print(a_b);
}
}
第 4 行编译错误
第 2 行编译错误
第 1 行编译错误
第 5 行编译错误
第 8 行编译错误
答案
输出将是“第 5 行编译错误”。局部变量必须在使用前初始化。
问题
给定代码的答案是什么
switch(x) {
case x>70:
System.out.println("True");
break;
case 65<x<=70:
System.out.println("False");
break;
}
断言错误
堆栈溢出
孤立的 case
IO 错误
内存错误输出
答案
输出将是“孤立的 case”。switch 语句中的 case 标签必须是常量表达式（通常是整数、枚举或字符串字面量），而不是布尔表达式。
问题
考虑以下代码来回答
public class Demo {
static int x=1111;
static {
x=x-- - --x;
}
{
x=x++ + ++x;
}
public static void main(String args[]) {
System.out.println(x);
}
}
2
1110
1109
1
11
答案
输出将是“2”。静态块在实例初始化块之前执行，两个块都会更改 x 的值。
问题
以下代码的输出是什么
import java.lang.Math;
public class Example {
public static void main(String args[]) {
String computerMove;
switch ( (int)(3*Math.random()) ) {
case 0:
computerMove = "Rock";
break;
case 1:
computerMove = "Scissors";
break;
case 2:
computerMove = "Paper";
break;
}
System.out.println("Computer's move is " + computerMove);
}
}
纸
石头
剪刀
语法错误
异常
答案
输出可能是“纸”、“石头”或“剪刀”。switch 语句随机选择三个 case 之一。
问题
考虑以下代码给出答案
public class TestHashMap {
public static void main(String[] args) {
HashMap<String,String> map = new HashMap<String,String>(){
{
put("1", "ONE");
} {
put("2", "TWO");
} {
put("3", "THREE");
}
};
Set<String> keySet = map.keySet();
for (String string : keySet) {
System.out.println(string+" ->"+map.get(string));
}
}
}
不允许在 Java 中使用双大括号初始化。
第一组大括号创建一个新的匿名内部类，第二组大括号创建一个类似于类中静态块的实例初始化。
第二组大括号创建一个新的匿名内部类，第一组大括号创建一个类似于类中静态块的实例初始化。
第一组大括号既没有创建匿名内部类，第二组大括号也没有创建类似于类中静态块的实例初始化。
以上都不是
答案
正确答案是“第一组大括号创建一个新的匿名内部类，第二组大括号创建一个类似于类中静态块的实例初始化”。这种模式被称为双大括号初始化。
问题
编译以下代码后会得到什么？
public class ExceptionDemo {
public static void main(String args[]) {
Object x[] = new String[3];
x[0] = new Integer(0);
}
}
负数组大小异常
数组存储异常
空指针异常
类转换异常
数组索引越界异常
答案
输出将是“数组存储异常”。数组的运行时类型是 String[]，因此它不能保存 Integer 对象。
问题
考虑这种情况
If we put System.exit(0) on try to catch block in such a case Will finally block execute or not? Also specify the reason
它跳过 finally 块。
这是一个无效的情况。
finally 块可能执行也可能不执行。
JVM 以 SecurityException 退出并执行 finally 块。
JVM 以 SecurityException 退出，并且不会执行 finally 块。
答案
正确答案是“JVM 以 SecurityException 退出，并且不会执行 finally 块”。System.exit(0) 会立即终止 JVM，因此 finally 块不会执行。
问题
考虑以下代码给出正确的答案
import java.util.Arrays;
public class SplitString {
public static void main(String args[]) {
String str="Java|Python|Hadoop";
String[] array = str.split("\|");
System.out.println(Arrays.toString(array));
}
}
[Java\Python\Hadoop]
[Java|Python|Hadoop]
[Java\|Python\|Hadoop]
[Java, Python, Hadoop]
答案
输出将是“[Java, Python, Hadoop]”。split() 方法使用正则表达式分割字符串，而 | 是需要转义的元字符。
问题
评估以下语句
long longWithL = 1000*60*60*24*365L; long longWithoutL = 1000*60*60*34*365;
编译时错误
算术异常
31536000000 和 1726327040
3.1536e10 和 1.72632704e9
31536000000L 和 1726327040
答案
正确答案是“31536000000 和 1726327040”。L 后缀使第一个数字成为长整型字面量，因此计算不会溢出。第二个数字作为 int 计算并溢出。
问题
评估以下代码并仔细给出答案
class Base{
public static void main(String[] args){
System.out.println("Hello");
}
}
public class Test extends Base{}
编译时错误
运行时错误
编译并运行，无输出
编译并运行，打印 hello
第 6 行错误
答案
输出将是“编译并运行，打印 hello”。main 方法继承自 Base 类，并在运行 Test 类时执行。
结论
熟悉一些常见问题至关重要。通过练习，您在回答问题或开发测试代码时可能会更有信心。尽管他们可能会问各种问题，但您可以提前准备好答案来提高您的 Java 专业知识。
6000+ 次浏览
