极客笔记Java 棘手的输出问题
Java棘手的输出问题需要更多的工作来回答，很难。如果我们试图使用常识回答一个具有挑战性的话题，我们会做的不够好，因为这样的问题需要专业的理解。大多数具有挑战性的Java问题基于迷惑性的概念，如循环，多线程，重载，覆盖等。
即使一个问题并不特别具有挑战性，我们有时也会有解决困难的问题。尽管问题的答案很简单，我们有时也会粗心地编写代码。
即使我们不知道解决方案，我们仍然可以使用分析思维来得到答案。本文将讨论一些具有挑战性的Java棘手的输出问题。
常见的Java棘手的输出问题
问题
请考虑以下输出并尝试猜测答案
public class A {
public static void main(String args[]) {
//\u000d System.out.println("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 被打印了四次。
-
错误
答案
输出将是 “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
-
错误
答案
输出将为 “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;
}
- 断言错误
-
堆栈溢出
-
孤立的案例
-
输入/输出错误
-
内存输出错误
答案
输出将是”孤立的案例”。在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 语句会随机选择其中一种情况。
问题
考虑以下代码来给出答案：
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[]，因此它不能容纳整数对象。
问题
考虑这种情况
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
- 它跳过最后一个块
-
这是一个无效的情况
-
最后一个块可能会执行，也可能不会执行
-
JVM退出时，如果发生SecurityException，则最后一个块将执行
-
JVM退出时，如果没有发生SecurityException，则最后一个块将不会执行
回答
正确答案是“JVM退出时，如果没有发生SecurityException，则最后一个块将不会执行”。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]”。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后缀使第一个数变为长字面值，所以计算不会溢出。第二个数被计算为整数并溢出。
问题
评估以下代码并小心给出答案：
class Base{
public static void main(String[] args){
System.out.println("Hello");
}
}
public class Test extends Base{}
- 编译时错误
-
运行时错误
-
编译和运行没有输出
-
编译和运行打印hello
-
在第6行发生错误
答案
输出将是“编译和运行打印hello”。当运行Test类时，main方法继承自Base类并被执行。
结论
熟悉一些常见问题非常重要。通过练习，您可以在回答问题或编写测试代码时感到更自信。虽然可能会问出各种各样的问题，但您可以提前准备好答案，以提高您的Java技能。