问题总结
关键问题 1 枚举类型到底是不是「原始类型」
课件第一讲 第 43 页「动手动脑」:仔细阅读示例 EnumTest.java,运行它,分析运行结果?你能得到什么结论?你掌握了枚举类型的基本用法了吗?
1.1 实验代码
public class EnumTest {
public static void main(String[] args) {
Size s = Size.SMALL;
Size t = Size.LARGE;
// s 和 t 引用的是不是同一个对象?
System.out.println("s == t : " + (s == t));
// 枚举是原始数据类型吗?
System.out.println("s.getClass().isPrimitive() : " + s.getClass().isPrimitive());
// 从字符串转换回枚举
Size u = Size.valueOf("SMALL");
System.out.println("s == u : " + (s == u));
System.out.println("s.equals(u) : " + s.equals(u));
// 相同的值是不是同一个对象?用对象身份哈希码验证
System.out.println("s 的身份哈希码 : " + System.identityHashCode(s));
System.out.println("u 的身份哈希码 : " + System.identityHashCode(u));
// 列出它的所有值
for (Size value : Size.values()) {
System.out.println("枚举值 : " + value);
}
System.out.println("父类型 : " + Size.SMALL.getClass().getSuperclass().getName());
}
}
enum Size { SMALL, MEDIUM, LARGE }
1.2 运行结果
s == t : false
s.getClass().isPrimitive() : false
s == u : true
s.equals(u) : true
s 的身份哈希码 : 1804094807
u 的身份哈希码 : 1804094807
枚举值 : SMALL
枚举值 : MEDIUM
枚举值 : LARGE
父类型 : java.lang.Enum
(身份哈希码是运行时地址派生的,每次运行数值会变,但两句一定相同。)
1.3 分析
观察点一:s == t 是 false,s == u 是 true。 SMALL 和 LARGE 是两个不同的常量,所以不相等;而 valueOf("SMALL") 还原出来的 u 和我一开始拿到的 s 相等——注意这里用的是 ==,比的是引用而不是内容,结果却是 true,说明它们指向同一个对象。
观察点二:isPrimitive() 返回 false。 getClass() 能拿到 Class 对象这件事本身,就说明枚举变量里装的不是「原始数据」而是一个对象引用。原始类型(int、double 之类)是不能调 getClass() 的。
观察点三:身份哈希码完全相同。 System.identityHashCode 和 hashCode() 不一样,它直接反映对象身份。两句打印出同一个数字,是「s 与 u 是同一个对象」最硬的证据——不是值相等,是同一个。
观察点四:父类型是 java.lang.Enum。 每个枚举类型都隐式继承 java.lang.Enum,而 Java 是单继承,这就解释了为什么 enum Size 后面不能再写 extends。
1.4 结论
- 枚举类型是引用类型,不是原始数据类型;每个枚举常量都是本枚举类的一个实例。
- 相同的枚举常量在内存中只有一个对象,因此 == 和 equals() 的结果完全等价,可以直接用 == 比较,而且更快更安全。
- valueOf(String) 把字符串还原成对应的枚举常量,拿到的是同一个对象,不是新建的。
- values() 返回全部常量的数组,天然支持增强 for 遍历;枚举还可以直接用在 switch 里。
- 枚举隐式继承 java.lang.Enum,不能再继承别的类,但可以实现接口。
关键问题 2 原码、反码、补码——Java 的整数究竟怎么存
课件第一讲 第 50 页「动脑动手」:阅读教材或用搜索引擎弄清楚反码、补码跟原码这几个概念,然后编写示例程序,对正数、负数进行各种位操作,观察输出结果,与手工计算的结果进行比对,看看 Java 中的数是采用上述哪种码表示的。
2.1 实验代码
public class BitCode {
/** 把 int 按 32 位二进制打印,每 8 位空一格,便于和手工计算对照 /
static String bin32(int v) {
StringBuilder sb = new StringBuilder();
for (int i = 31; i >= 0; i--) {
sb.append((v >>> i) & 1);
if (i % 8 == 0 && i != 0) {
sb.append(' ');
}
}
return sb.toString();
}
/* 按「原码」规则手工拼一个负数:符号位 1,其余位填绝对值的二进制 /
static int signMagnitude(int value) {
int mag = Math.abs(value);
int signBit = value < 0 ? 0x80000000 : 0;
return signBit | mag;
}
/* 由原码推反码:负数符号位不变,其余位取反 */
static int onesComplement(int original) {
int signBit = original & 0x80000000;
return signBit | (~original & 0x7FFFFFFF);
}
public static void main(String[] args) {
int p = 5;
int n = -5;
System.out.println("=== 一、正数 5 的三种码 =");
System.out.println("原码 : " + bin32(signMagnitude(p)));
System.out.println("反码 : " + bin32(signMagnitude(p)));
System.out.println("补码 : " + bin32(p));
System.out.println();
System.out.println("= 二、负数 -5 的手工推导 =");
int orig = signMagnitude(n);
int ones = onesComplement(orig);
int twos = ones + 1;
System.out.println("原码 : " + bin32(orig));
System.out.println("反码 : " + bin32(ones));
System.out.println("补码 : " + bin32(twos) + " 十进制 = " + twos);
System.out.println();
System.out.println("= 三、Java 里 -5 实际存的是什么 =");
System.out.println("-5 : " + bin32(n));
System.out.println("手工补码与 Java 实际存储一致吗? " + (twos == n));
System.out.println();
System.out.println("= 四、补码的两个直接推论 =");
System.out.println("~5 = " + (~p) + " 二进制 " + bin32(~p));
System.out.println("~5 + 1 = " + ((~p) + 1) + " 二进制 " + bin32((~p) + 1));
System.out.println("~(-5) + 1 = " + ((~n) + 1));
System.out.println("0 的补码 : " + bin32(0) + " (没有 +0/-0 之分)");
System.out.println();
System.out.println("= 五、位运算符 =");
System.out.println("5 & -1 = " + (5 & -1) + " 二进制 " + bin32(5 & -1));
System.out.println("5 | -1 = " + (5 | -1));
System.out.println("5 ^ -1 = " + (5 ^ -1) + " 二进制 " + bin32(5 ^ -1));
System.out.println("5 ^ 5 = " + (5 ^ 5));
System.out.println();
System.out.println("= 六、右移:算术右移 >> 与逻辑右移 >>> =");
System.out.println("-5 >> 1 = " + (n >> 1) + " 二进制 " + bin32(n >> 1) + " (高位补符号位)");
System.out.println("-5 >>> 1 = " + (n >>> 1) + " 二进制 " + bin32(n >>> 1) + " (高位补 0)");
System.out.println("手工核对 -5 >>> 1 :补码 " + bin32(n) + " 右移一位得 " + bin32(n >>> 1));
System.out.println();
System.out.println("= 七、-1 的补码 =");
System.out.println("-1 : " + bin32(-1));
System.out.println("0xFFFFFFFF = " + (0xFFFFFFFF));
System.out.println("0xFFFFFFFF 转成 int 结果是 -1 吗? " + ((int) 0xFFFFFFFFL == -1));
System.out.println();
System.out.println("= 八、溢出后补码怎么表现 ===");
System.out.println("Integer.MAX_VALUE = " + bin32(Integer.MAX_VALUE));
System.out.println("Integer.MAX_VALUE + 1 = " + bin32(Integer.MAX_VALUE + 1)
+ " = " + (Integer.MAX_VALUE + 1));
System.out.println("Integer.MIN_VALUE = " + bin32(Integer.MIN_VALUE));
System.out.println("Integer.MIN_VALUE - 1 = " + (Integer.MIN_VALUE - 1)
+ " 二进制 " + bin32(Integer.MIN_VALUE - 1));
}
}
2.2 运行结果
=== 一、正数 5 的三种码 ===
原码 : 00000000 00000000 00000000 00000101
反码 : 00000000 00000000 00000000 00000101
补码 : 00000000 00000000 00000000 00000101
=== 二、负数 -5 的手工推导 ===
原码 : 10000000 00000000 00000000 00000101
反码 : 11111111 11111111 11111111 11111010
补码 : 11111111 11111111 11111111 11111011 十进制 = -5
=== 三、Java 里 -5 实际存的是什么 ===
-5 : 11111111 11111111 11111111 11111011
手工补码与 Java 实际存储一致吗? true
=== 四、补码的两个直接推论 ===
~5 = -6 二进制 11111111 11111111 11111111 11111010
~5 + 1 = -5 二进制 11111111 11111111 11111111 11111011
~(-5) + 1 = 5
0 的补码 : 00000000 00000000 00000000 00000000 (没有 +0/-0 之分)
=== 五、位运算符 ===
5 & -1 = 5 二进制 00000000 00000000 00000000 00000101
5 | -1 = -1
5 ^ -1 = -6 二进制 11111111 11111111 11111111 11111010
5 ^ 5 = 0
=== 六、右移:算术右移 >> 与逻辑右移 >>> ===
-5 >> 1 = -3 二进制 11111111 11111111 11111111 11111101 (高位补符号位)
-5 >>> 1 = 2147483645 二进制 01111111 11111111 11111111 11111101 (高位补 0)
手工核对 -5 >>> 1 :补码 11111111 11111111 11111111 11111011 右移一位得 01111111 11111111 11111111 11111101
=== 七、-1 的补码 ===
-1 : 11111111 11111111 11111111 11111111
0xFFFFFFFF = -1
0xFFFFFFFF 转成 int 结果是 -1 吗? true
=== 八、溢出后补码怎么表现 ===
Integer.MAX_VALUE = 01111111 11111111 11111111 11111111
Integer.MAX_VALUE + 1 = 10000000 00000000 00000000 00000000 = -2147483648
Integer.MIN_VALUE = 10000000 00000000 00000000 00000000
Integer.MIN_VALUE - 1 = 2147483647 二进制 01111111 11111111 11111111 11111111
2.3 分析
观察点一:手工推出来的补码和 Java 实际存的位一模一样。 我按「原码 → 反码 → 补码」三步手推 -5,得到 11111111 11111111 11111111 11111011,而直接打印 Java 里 -5 的 32 位,也是这一串。第三段的 一致吗? true 就是这个比对的结论——Java 用补码,既不是原码也不是反码。
观察点二:~x + 1 == -x。 ~5 得到 -6,~5 + 1 得到 -5;反过来 ~(-5) + 1 得到 5。这就是补码的定义式推论:按位取反加一,等于求相反数。这个式子也是硬件上把减法变成加法加一个取反电路的原理。
观察点三:0 只有一种写法。 原码里 0 有两种表示(0000...0 和 1000...0,即 +0 和 −0),补码里只剩 0000...0。少一个编码意味着多出一个可用数值——这也正是补码比原码多表示一个负数(-2^31)的原因。
观察点四:>> 和 >>> 对负数是两个世界。 -5 >> 1 得 -3,高位补的是符号位 1;-5 >>> 1 得 2147483645,高位补 0,等于把这一串位当成无符号数来看。手工核对那行把「补码右移一位」的结果和程序输出放在一起,完全吻合。
观察点五:-1 的补码是 32 个 1,正好等于 0xFFFFFFFF。 所以 (int) 0xFFFFFFFFL 的结果就是 -1——这也是「new String(bytes) 里 0xFF 会变成乱码」之类的现象背后的原因。
2.4 结论
- Java 的整数使用补码表示,实测与手工推导完全一致。
- 正数的原码、反码、补码三者相同;负数补码 = 反码 + 1 = (按位取反)+ 1。
- 由补码可以直接推出:~x + 1 == -x、x ^ x == 0、x & -1 == x、-1 的 32 位全为 1。
-
是算术右移(高位补符号位),>>> 是逻辑右移(高位补 0),对负数结果差异极大。
- 补码统一了加减法(减法可以用加法电路实现),也消除了 ±0 的二义性,这是它被所有现代计算机采用的原因。
- 用位运算时一定记住:操作数按补码的二进制参与运算,负数的高位全是 1。
关键问题 3 同名变量的屏蔽原则
课件第一讲 第 56 页「动脑动手」:Java 变量遵循「同名变量的屏蔽原则」,请课后阅读相关资料弄清楚相关知识,然后自己编写一些测试代码,就像示例一样,有意识地在不同地方定义一些同名变量,看看输出的到底是哪个值。
3.1 实验代码
主实验:
public class ShadowTest {
int value = 10; // 实例成员变量
static int total = 100; // 静态成员变量
void show(int value) {
System.out.println("形参 value : " + value);
System.out.println("this.value(成员) : " + this.value);
System.out.println("ShadowTest.total : " + ShadowTest.total);
}
void innerScope() {
int value = 1;
System.out.println("方法内局部 value : " + value);
System.out.println("this.value(成员) : " + this.value);
// 静态成员变量还可以被局部变量屏蔽吗?用类名找回
int total = 5;
System.out.println("局部 total : " + total);
System.out.println("类名找回 total : " + ShadowTest.total);
}
public static void main(String[] args) {
ShadowTest obj = new ShadowTest();
obj.show(999);
System.out.println();
obj.innerScope();
}
}
反例一(内层块重新声明同名局部变量):
public class ReDeclare {
public static void main(String[] args) {
int a = 1;
{
int a = 2; // 内层块重新声明外层的同名局部变量
System.out.println(a);
}
System.out.println(a);
}
}
反例二(for 头部重新声明同名局部变量):
public class ReDeclareFor {
public static void main(String[] args) {
int i = 0;
for (int i = 0; i < 3; i++) { // for 头部再声明一次同名变量
System.out.println(i);
}
System.out.println(i);
}
}
3.2 运行结果
主实验:
形参 value : 999
this.value(成员) : 10
ShadowTest.total : 100
方法内局部 value : 1
this.value(成员) : 10
局部 total : 5
类名找回 total : 100
反例一的编译结果:
ReDeclare.java:5: 错误: 已在方法 main(String[])中定义了变量 a
int a = 2; // 内层块重新声明外层的同名局部变量
^
1 个错误
反例二的编译结果:
ReDeclareFor.java:4: 错误: 已在方法 main(String[])中定义了变量 i
for (int i = 0; i < 3; i++) { // for 头部再声明一次同名变量
^
1 个错误
3.3 分析
观察点一:直接写变量名,取到的是「离得最近」的那一层。 形参叫 value、成员变量也叫 value,方法体里写 value 拿到的是形参的 999,成员变量被挡住了。局部变量 total = 5 也把静态成员 total 遮住了。
观察点二:被遮住的成员变量可以用 this. 或「类名.」找回。 实测 this.value 依然是成员变量的 10,ShadowTest.total 依然是 100。说明屏蔽的只是「直接写名字」这一条路,成员变量本身没被改变。
观察点三:Java 只允许「局部变量遮住成员变量」,不允许「局部变量之间互相遮挡」。 两个反例分别试了内层代码块和 for 头部,报的都是同一条错误:已在方法 main(String[])中定义了变量 a / i。注意:市面上不少讲变量作用域的资料说「内层块可以重新定义同名变量」,那个说法是错的——实测直接在编译期就被拦住,连字节码都生不出来。
观察点四:报错信息非常直白。 它点明了冲突发生在哪个方法(main)、哪个变量名(a)、哪一行(5:)。看到这条信息就该知道:不是「值被覆盖了」,而是「名字重复了」。
3.4 结论
- 屏蔽只发生在一种情形:局部变量或形参遮住同名的成员变量。
- 被遮住的成员变量用 this.变量名(实例)或 类名.变量名(静态)找回。
- Java 不允许同一个方法内出现两个同名的局部变量,包括内层代码块、for 循环头部与形参,实测报 已在方法 X 中定义了变量 Y。
- 因此「内层块可以重新声明同名变量」是错误说法,写代码时不要照搬。
- 虽然屏蔽是合法的,但它降低可读性。实践建议:形参不要和成员变量重名,不得不同名时统一加 this.。
关键问题 4 double 运算为什么算不对
课件第一讲 第 62 页「动手实验」:请运行以下代码(TestDouble.java),你看到了什么样的输出,意外吗? 课件第一讲 第 64 页:为什么 double 类型的数值进行运算得不到「数学上精确」的结果?请通过互联网查找资料,或者是阅读相关计算机教材,解决这个问题。
4.1 实验代码
public class TestDouble {
public static void main(String[] args) {
System.out.println("0.05 + 0.01 = " + (0.05 + 0.01));
System.out.println("1.0 - 0.42 = " + (1.0 - 0.42));
System.out.println("4.015 * 100 = " + (4.015 * 100));
System.out.println("123.3 / 100 = " + (123.3 / 100));
System.out.println();
System.out.println("=== 单个字面量本身就不精确 =");
System.out.println("0.1 的真实存储值 = " + new java.math.BigDecimal(0.1));
System.out.println("0.1 的字符串写法能表示的值 = " + new java.math.BigDecimal("0.1"));
System.out.println("0.2 的真实存储值 = " + new java.math.BigDecimal(0.2));
System.out.println("0.1 + 0.2 = " + (0.1 + 0.2));
System.out.println("(0.1+0.2) == 0.3 ? " + ((0.1 + 0.2) == 0.3));
System.out.println();
System.out.println("= 用 IEEE 754 拆开看 double 的内部结构 ===");
long bits = Double.doubleToLongBits(0.1);
StringBuilder sb = new StringBuilder();
for (int i = 63; i >= 0; i--) {
sb.append((bits >>> i) & 1);
}
System.out.println("0.1 的 64 位二进制 : " + sb);
System.out.println(" 符号位 1 位 : " + sb.charAt(0));
System.out.println(" 阶码 11 位 : " + sb.substring(1, 12));
System.out.println(" 尾数 52 位 : " + sb.substring(12));
System.out.println("尾数只有 52 位,0.1 的二进制是无限循环小数,必然被截断。");
}
}
4.2 运行结果
0.05 + 0.01 = 0.060000000000000005
1.0 - 0.42 = 0.5800000000000001
4.015 * 100 = 401.49999999999994
123.3 / 100 = 1.2329999999999999
=== 单个字面量本身就不精确 ===
0.1 的真实存储值 = 0.1000000000000000055511151231257827021181583404541015625
0.1 的字符串写法能表示的值 = 0.1
0.2 的真实存储值 = 0.200000000000000011102230246251565404236316680908203125
0.1 + 0.2 = 0.30000000000000004
(0.1+0.2) == 0.3 ? false
=== 用 IEEE 754 拆开看 double 的内部结构 ===
0.1 的 64 位二进制 : 0011111110111001100110011001100110011001100110011001100110011010
符号位 1 位 : 0
阶码 11 位 : 01111111011
尾数 52 位 : 1001100110011001100110011001100110011001100110011010
尾数只有 52 位,0.1 的二进制是无限循环小数,必然被截断。
4.3 分析
观察点一:四则运算全都出现了「尾巴」。 0.05 + 0.01 得到 0.060000000000000005,1.0 - 0.42 得到 0.5800000000000001——这两个结果在数学上应该是干干净净的 0.06 和 0.58。这不是偶尔失误,四行输出全都不准。
观察点二:根子在字面量本身。 用 new BigDecimal(0.1) 把 0.1 这个 double 的真实值挖出来,是 0.1000000000000000055511151231257827021181583404541015625。也就是说,double x = 0.1; 这一句执行完,x 里装的从来就不是 0.1。误差输入进去,再运算,误差就被放大。
观察点三:把 64 位拆开,原因一目了然。 0.1 的位模式被拆成 1 位符号(0)、11 位阶码、52 位尾数。而 0.1 的二进制展开是 0.0001100110011...,无限循环,52 位根本装不下,只能截断。这就是「为什么」的标准答案——不是计算不准,是存不下。
观察点四:(0.1 + 0.2) == 0.3 是 false。 这一行是整段代码里最重要的。它说明「肉眼看起来相等的两个浮点数,用 == 比就是不相等」。任何用 == 判断浮点相等的地方,都可能出现这种莫名其妙的 bug。
4.4 结论
- double / float 遵循 IEEE 754 标准:double 是 1 位符号 + 11 位阶码 + 52 位尾数,float 是 1 + 8 + 23。
- 绝大多数十进制小数无法用有限位二进制精确表示,存进去的就是近似值。
- 因此浮点运算的结果是「最接近的近似值」,位数越多误差越小,但误差不会消失。
- 0.1 + 0.2 != 0.3 不是 Java 的 bug,所有遵循 IEEE 754 的语言(C、Python、JavaScript……)都这样。
- 推论:涉及金额、库存、精确比较的场景,一律不能用 double。
- 判断浮点相等要用「差值小于允许误差」,或者干脆换成 BigDecimal——见问题 6、问题 12。
关键问题 5 方法重载的判定条件
课件第二讲 第 28 页「动手动脑」:请看以下代码,你发现了有什么特殊之处吗?(Demo: MethodOverLoad)
5.1 实验代码
主实验:
public class MethodOverLoad {
// 参数类型不同
public static int square(int x) {
return x * x;
}
public static double square(double y) {
return y * y;
}
// 参数个数不同
public static int square(int x, int times) {
int r = 1;
for (int i = 0; i < times; i++) {
r *= x;
}
return r;
}
// 参数类型顺序不同
public static String join(int a, String b) {
return "先数字后字符串: " + a + b;
}
public static String join(String a, int b) {
return "先字符串后数字: " + a + b;
}
public static void main(String[] args) {
System.out.println("The square of integer 7 is " + square(7));
System.out.println("The square of double 7.5 is " + square(7.5));
System.out.println();
System.out.println("=== 编译器按实参类型挑最合适的那一个 =");
System.out.println("square(7) -> " + square(7) + " (命中 int 版本)");
System.out.println("square(7.5) -> " + square(7.5) + " (命中 double 版本)");
System.out.println("square(7, 3) -> " + square(7, 3) + " (命中两参数版本)");
System.out.println("square((short)7) -> " + square((short) 7) + " (short 自动提升为 int)");
System.out.println("square(7L) -> " + square(7L) + " (long 无法转 int,但能转 double,命中 double 版本)");
System.out.println("square(7.5f) -> " + square(7.5f) + " (float 无法转 int,命中 double 版本)");
System.out.println();
System.out.println("= 参数顺序不同也是重载 =");
System.out.println(join(1, "2"));
System.out.println(join("1", 2));
System.out.println();
System.out.println("= 编译后方法名带上了参数类型签名 ===");
System.out.println("square(int) / square(double) / square(int,int) 在字节码里是三个不同的方法名。");
}
}
反例(只有返回值类型不同):
public class OverloadByReturn {
public static int get() {
return 1;
}
public static double get() { // 只有返回值类型不同
return 1.0;
}
public static void main(String[] args) {
System.out.println(get());
}
}
字节码证据:javap -p -s -cp . MethodOverLoad
Compiled from "MethodOverLoad.java"
public class MethodOverLoad {
public MethodOverLoad();
descriptor: ()V
public static int square(int);
descriptor: (I)I
public static double square(double);
descriptor: (D)D
public static int square(int, int);
descriptor: (II)I
public static java.lang.String join(int, java.lang.String);
descriptor: (ILjava/lang/String;)Ljava/lang/String;
public static java.lang.String join(java.lang.String, int);
descriptor: (Ljava/lang/String;I)Ljava/lang/String;
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
}
5.2 运行结果
主实验:
The square of integer 7 is 49
The square of double 7.5 is 56.25
=== 编译器按实参类型挑最合适的那一个 ===
square(7) -> 49 (命中 int 版本)
square(7.5) -> 56.25 (命中 double 版本)
square(7, 3) -> 343 (命中两参数版本)
square((short)7) -> 49 (short 自动提升为 int)
square(7L) -> 49.0 (long 无法转 int,但能转 double,命中 double 版本)
square(7.5f) -> 56.25 (float 无法转 int,命中 double 版本)
=== 参数顺序不同也是重载 ===
先数字后字符串: 12
先字符串后数字: 12
=== 编译后方法名带上了参数类型签名 ===
square(int) / square(double) / square(int,int) 在字节码里是三个不同的方法名。
反例的编译结果:
OverloadByReturn.java:6: 错误: 已在类 OverloadByReturn中定义了方法 get()
public static double get() { // 只有返回值类型不同
^
1 个错误
5.3 分析
观察点一:两个 square 同名,靠参数类型区分。 square(7) 走 int 版本返回 49,square(7.5) 走 double 版本返回 56.25。调用者不用记两套名字,写 square 就行——这就是重载最直接的价值。
观察点二:重载的三种触发方式实测都成立。 参数类型不同(int / double)、参数个数不同(square(int, int))、参数类型顺序不同(join(int, String) 与 join(String, int)),全部通过编译并正确分派。
观察点三:实参不完全匹配时,编译器会做类型提升挑「最合适」的。 square((short)7) 命中 int 版本(short 能自动提升为 int);square(7L) 没命中 int(long 不能自动窄化成 int),但能提升为 double,所以命中 double 版本,输出 49.0——注意末尾的 .0,这正是走了 double 分支的标志。
观察点四:字节码层面三个方法同名,靠「方法描述符」区分。 javap -s 显示:square(int) 的描述符是 (I)I,square(double) 是 (D)D,square(int,int) 是 (II)I。JVM 判断「是不是同一个方法」用的是「方法名 + 参数描述符」,返回值不在其中。
观察点五:只改返回值类型直接编译不过。 反例里两个 get() 只有返回值不同(int / double),编译报 已在类 OverloadByReturn中定义了方法 get()。这条错误信息本身就是结论:返回值类型不参与重载判定。
5.4 结论
- 构成重载的条件只有一条:方法名相同 + 参数列表不同(类型不同、个数不同、顺序不同,满足其一即可)。
- 返回值类型不参与重载判定,只改返回值是编译错误,实测报 已在类 X 中定义了方法 Y()。
- 形参名不同、访问修饰符不同、抛出的异常不同,都不构成重载。
- 重载是编译期静态绑定:编译器根据实参的静态类型在编译时就选定了目标方法。
- 实参类型不完全匹配时,编译器会按类型提升规则选「最合适」的那个重载,选择结果可能与直觉不同(如 square(7L) 走了 double 版本)。
- 字节码靠方法描述符区分同名方法,所以「重载」在运行期其实是「不同的方法」。
关键问题 6 阶乘为什么会算出负数,以及 BigInteger
课件第二讲 第 42 页:程序错了吗?演示 CalculateN 示例程序中的 BUG ——「阶乘数怎么可能出现负数?」 课件第二讲 第 43~44 页:问题的根源(int 占 32 位,Integer.MAX_VALUE = 2³¹ − 1)。 课件第二讲 第 45 页:处理无限大的整数——Java 提供了 BigInteger 类,支持大整数的加减乘除运算。
6.1 实验代码
第一个实验(int 版,复现 BUG):
public class CalculateN {
/** 课件里的写法:用 int 做递归阶乘 /
public static int calculateN(int n) {
if (n == 1 || n == 0) {
return 1;
}
return n * calculateN(n - 1);
}
public static void main(String[] args) {
System.out.println("=== 一、把 n! 从 1 打到 20,看看什么时候开始不对 =");
System.out.printf("%-4s %-22s %s%n", "n", "int 版 n!", "是否已溢出");
for (int n = 1; n <= 20; n++) {
int v = calculateN(n);
boolean overflow = v < 0 || v / n != calculateN(n - 1);
System.out.printf("%-4d %-22d %s%n", n, v, overflow ? "已经出错" : "正确");
}
System.out.println();
System.out.println("= 二、溢出的分界点 =");
System.out.println("int 能表示的最大值 = " + Integer.MAX_VALUE);
System.out.println("12! = " + calculateN(12) + " (还在范围内)");
System.out.println("13! 数学上 = 6227020800,已经超过 int 上限");
System.out.println("13! 实际算出 = " + calculateN(13));
System.out.println("17! 才第一次变成负数 = " + calculateN(17));
System.out.println("21! 的算出值 = " + calculateN(21) + " (已经没有规律可言)");
System.out.println();
System.out.println("= 三、为什么不能用“看有没有负号”来排查溢出 ===");
System.out.println("13! ~ 16! 的值都是正数,但早就已经错了:");
for (int n = 13; n <= 16; n++) {
System.out.println(" " + n + "! = " + calculateN(n) + " (是正数,但值是错的)");
}
System.out.println("所以“找负号”这种排查手段会漏掉前 4 项。");
}
}
第二个实验(BigInteger 版,当裁判逐项比对):
import java.math.BigInteger;
public class BigIntegerFactorial {
/* 课件里的写法:递归版 BigInteger 阶乘 /
public static BigInteger calculateN2(int n) {
if (n == 1 || n == 0) {
return BigInteger.valueOf(1);
}
return BigInteger.valueOf(n).multiply(calculateN2(n - 1));
}
public static void main(String[] args) {
System.out.println("=== 一、BigInteger 版阶乘:从 1 打到 40 =");
for (int n = 1; n <= 40; n++) {
System.out.printf("%2d! = %s%n", n, calculateN2(n));
}
System.out.println();
System.out.println("= 二、让 BigInteger 当裁判,逐项比对 int 版 =");
System.out.printf("%-4s %-22s %-22s %s%n", "n", "int 版", "BigInteger 版", "一致?");
for (int n = 1; n <= 20; n++) {
int intValue = CalculateN.calculateN(n);
BigInteger exact = BigInteger.valueOf(n).multiply(
n == 1 ? BigInteger.ONE : exactOf(n - 1));
boolean same = BigInteger.valueOf(intValue).equals(exact);
System.out.printf("%-4d %-22d %-22s %s%n", n, intValue, exact, same ? "一致" : "不一致");
}
System.out.println();
System.out.println("= 三、BigInteger 不可变:运算不改变原对象 ===");
BigInteger x = BigInteger.TEN;
x.add(BigInteger.ONE);
System.out.println("执行 x.add(ONE) 之后,x 仍然是 " + x);
System.out.println("必须接住返回值:x = x.add(ONE) 得到 " + x.add(BigInteger.ONE));
}
/* 用小规模循环版拿精确值 */
private static BigInteger exactOf(int n) {
BigInteger r = BigInteger.ONE;
for (int i = 2; i <= n; i++) {
r = r.multiply(BigInteger.valueOf(i));
}
return r;
}
}
6.2 运行结果
第一个实验:
=== 一、把 n! 从 1 打到 20,看看什么时候开始不对 ===
n int 版 n! 是否已溢出
1 1 正确
2 2 正确
3 6 正确
4 24 正确
5 120 正确
6 720 正确
7 5040 正确
8 40320 正确
9 362880 正确
10 3628800 正确
11 39916800 正确
12 479001600 正确
13 1932053504 已经出错
14 1278945280 已经出错
15 2004310016 已经出错
16 2004189184 已经出错
17 -288522240 已经出错
18 -898433024 已经出错
19 109641728 已经出错
20 -2102132736 已经出错
=== 二、溢出的分界点 ===
int 能表示的最大值 = 2147483647
12! = 479001600 (还在范围内)
13! 数学上 = 6227020800,已经超过 int 上限
13! 实际算出 = 1932053504
17! 才第一次变成负数 = -288522240
21! 的算出值 = -1195114496 (已经没有规律可言)
=== 三、为什么不能用“看有没有负号”来排查溢出 ===
13! ~ 16! 的值都是正数,但早就已经错了:
13! = 1932053504 (是正数,但值是错的)
14! = 1278945280 (是正数,但值是错的)
15! = 2004310016 (是正数,但值是错的)
16! = 2004189184 (是正数,但值是错的)
所以“找负号”这种排查手段会漏掉前 4 项。
第二个实验(节选关键段):
=== 一、BigInteger 版阶乘:从 1 打到 40 ===
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
...
13! = 6227020800
14! = 87178291200
15! = 1307674368000
16! = 20922789888000
17! = 355687428096000
18! = 6402373705728000
19! = 121645100408832000
20! = 2432902008176640000
21! = 51090942171709440000
...
40! = 815915283247897734345611269596115894272000000000
=== 二、让 BigInteger 当裁判,逐项比对 int 版 ===
n int 版 BigInteger 版 一致?
1 1 1 一致
2 2 2 一致
...
12 479001600 479001600 一致
13 1932053504 6227020800 不一致
14 1278945280 87178291200 不一致
15 2004310016 1307674368000 不一致
16 2004189184 20922789888000 不一致
17 -288522240 355687428096000 不一致
18 -898433024 6402373705728000 不一致
19 109641728 121645100408832000 不一致
20 -2102132736 2432902008176640000 不一致
=== 三、BigInteger 不可变:运算不改变原对象 ===
执行 x.add(ONE) 之后,x 仍然是 10
必须接住返回值:x = x.add(ONE) 得到 11
6.3 分析
观察点一:错误从 13! 就开始了,但前四项看不出来。 对照表里第一处「不一致」出现在 n=13:int 版给出 1932053504,而正确答案是 6227020800。可 13!、14!、15!、16! 打印出来全都是正数,一眼看上去毫无异常。
观察点二:17! 才第一次出现负号。 17! = -288522240。如果排查手段是「看结果有没有变负」,就会漏掉 13!~16! 这四项——它们早就错了,只是错误的值恰好落在正数区间。
观察点三:根源是 32 位的硬上限。 Integer.MAX_VALUE = 2147483647,而 13! = 6227020800 已经超出。超出的高位被丢掉,剩下的位按补码解释,就成了 1932053504 这样的「乱数」。这个过程不报错、不抛异常,是静默的——所以尤其危险。
观察点四:用 BigInteger 当裁判,溢出点被精确定位。 逐项比对后,第 1~12 项全部「一致」,第 13 项开始全部「不一致」。这个位置和「13! 超过 int 上限」的数学结论完全吻合,证明我们的判断是对的。
观察点五:BigInteger 是不可变类。 x.add(BigInteger.ONE) 执行完之后,x 仍然是 10——因为它返回的是新对象,原对象一个字节都没变。必须写 x = x.add(...) 才能拿到新值。这一点和 String 一样,是初学者很容易忽略的地方。
6.4 结论
- int 只有 32 位,上限 2147483647;long 64 位,上限 9223372036854775807——范围是硬性的。
- 超出范围时结果是静默截断:不报错、不抛异常,只是算出错误的值。
- 阶乘溢出的正确分界点是 13!(而不是「出现负数」的 17!)。靠符号位判断溢出会漏掉前面四项。
- 排查溢出的正确姿势是找一条高精度参照系逐项比对——这里用 BigInteger 的循环版当裁判,一次就定位到了第 13 项。
- 需要任意精度整数用 java.math.BigInteger,需要精确小数用 BigDecimal。
- BigInteger 和 BigDecimal 都是不可变类,所有运算返回新对象,必须用变量接住结果。
- 同类陷阱:n << 1 做「乘 2」、(a + b) / 2 求中点,都可能溢出。求中点应写 a + (b - a) / 2。

浙公网安备 33010602011771号