0Pricing
Java Academy · 课时

扩大转换与缩小转换

学习自动扩大转换，以及如何安全地执行显式缩小转换

扩大转换与缩小转换 是 CoddyKit 上的免费 Java Academy 课时。 这是第 2 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Java Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Java Academy 课程共包含 4 节课。

Java 中的类型转换

Java 允许在兼容的类型之间转换值。转换有两个方向：

  • 扩大转换——转换为更大的类型（安全且自动）
  • 缩小转换——转换为更小的类型（有风险，需要显式强制转换）

扩大转换

将值赋给更大的兼容类型时，会自动进行扩大转换。由于目标类型可以表示源类型的所有值，因此不会丢失数据。

扩大转换顺序：byte → short → int → long → float → double

byte b = 42;
short s = b;    // byte → short (widening)
int i = s;      // short → int (widening)
long l = i;     // int → long (widening)
float f = l;    // long → float (widening)
double d = f;   // float → double (widening)

System.out.println(d); // 42.0

缩小转换

缩小转换必须使用强制转换运算符 (type) 显式完成。如果值无法放入目标类型，可能会被截断或损坏。

double price = 99.99;
int wholePart = (int) price; // narrows — decimal truncated
System.out.println(wholePart); // 99 (not rounded!)

long bigNum = 130L;
byte small = (byte) bigNum;  // 130 overflows byte (max 127)
System.out.println(small);   // -126 (unexpected!)

缩小时的溢出

缩小时发生溢出，Java 会使用模运算使值回绕，不会抛出异常。您必须手动防范这种情况。

int million = 1_000_000;
byte narrowed = (byte) million;
System.out.println(narrowed); // 64 (wraps around)

// Safe narrowing: check bounds first
if (million >= Byte.MIN_VALUE && million <= Byte.MAX_VALUE) {
    byte safe = (byte) million;
} else {
    System.out.println("Value doesn't fit in byte!");
}

char 与 int 的转换

char 是表示 Unicode 码点的 16 位无符号整数。它可以自动扩大转换为 int，但从 int 转回 char 时必须显式强制转换。

char letter = 'A';
int code = letter;          // widening: char → int
System.out.println(code);   // 65

int nextCode = code + 1;
char nextLetter = (char) nextCode; // narrowing: int → char
System.out.println(nextLetter);    // B

// Useful for Caesar cipher shifts
char shifted = (char) ('a' + 3);
System.out.println(shifted); // d

浮点数转整数时的截断

将浮点数强制转换为整数时，会向零截断，而不会进行四舍五入。如果需要四舍五入，请使用 Math.round()。

double pos = 3.9;
double neg = -3.9;

System.out.println((int) pos);         // 3 (not 4)
System.out.println((int) neg);         // -3 (not -4)
System.out.println(Math.round(pos));   // 4
System.out.println(Math.round(neg));   // -4

String 转数字

将 String 解析为数字需要使用包装类方法，而不是类型转换。传入非数字字符串会抛出 NumberFormatException。

String input = "42";
int parsed = Integer.parseInt(input);
double parsedD = Double.parseDouble("3.14");

System.out.println(parsed + 1);  // 43
System.out.println(parsedD);     // 3.14

try {
    int bad = Integer.parseInt("abc");
} catch (NumberFormatException e) {
    System.out.println("Not a valid number!");
}

数字转 String

可以使用 String.valueOf()、Integer.toString()，或将字符串与 "" 进行拼接，把数字转换为 String。

int score = 95;
String s1 = String.valueOf(score);    // "95"
String s2 = Integer.toString(score);  // "95"
String s3 = score + "";              // "95" (concat trick)

System.out.println(s1.getClass().getSimpleName()); // String

// Converting to different bases
System.out.println(Integer.toBinaryString(42)); // 101010
System.out.println(Integer.toHexString(255));   // ff

表达式中的类型提升

在算术表达式中，Java 会自动提升操作数的类型：

  • byte、short、char → 运算前提升为 int
  • 如果任一操作数是 long，结果就是 long
  • 如果任一操作数是 float 或 double，结果会采用两者中范围更大的类型
byte x = 10;
byte y = 20;
// byte z = x + y; // compile error! sum is promoted to int
int z = x + y;      // correct

long a = 100L;
float b = 2.5f;
double result = a * b; // long * float → double
System.out.println(result); // 250.0

复合赋值运算符

+=、-=、*= 等复合运算符包含隐式的窄化转换。这让您可以使用简洁的代码处理 byte 和 short 变量。

byte count = 100;
// count = count + 1; // compile error — int result needs cast
count += 1;           // OK — compound op casts automatically
System.out.println(count); // 101

short total = 1000;
total *= 2;  // implicit narrow cast included
System.out.println(total); // 2000

实践：安全解析整数

一个实际开发中常用的模式是：安全地解析用户输入，验证取值范围，然后窄化为所需的确切类型。

public static byte parseAsByte(String input) {
    int value = Integer.parseInt(input); // can throw NumberFormatException
    if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
        throw new IllegalArgumentException(
            "Value " + value + " out of byte range");
    }
    return (byte) value;
}

// Usage
System.out.println(parseAsByte("100")); // 100
System.out.println(parseAsByte("200")); // IllegalArgumentException

快速检查

以下代码的输出是什么？

double d = -7.8;
int i = (int) d;
System.out.println(i);

总结：扩大转换与窄化转换

要点：

  • 扩大转换会自动进行且安全：byte→short→int→long→float→double
  • 窄化转换需要显式类型转换，并且可能丢失数据或导致溢出
  • char 会扩大为 int；int 可以通过类型转换再窄化为 char
  • 浮点数转换为 int 时会向零截断，而不是四舍五入
  • 使用 Integer.parseInt/Double.parseDouble 将 String 转换为数字
  • 复合运算符（+=、*=）包含隐式窄化转换

常见问题解答

「扩大转换与缩小转换」课时是免费的吗？

是的 — 「扩大转换与缩小转换」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Java Academy 课程的其余内容，请升级到 CoddyKit PRO。 Java Academy 课程共包含 4 节课。

「扩大转换与缩小转换」这节课中我会学到什么？

学习自动扩大转换，以及如何安全地执行显式缩小转换 你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Java Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Java Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 2 节课，共 4 节。

「扩大转换与缩小转换」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Java Academy 课中编写并运行代码吗？

能。每节 Java Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. 基本类型与引用类型
  2. 扩大转换与缩小转换
  3. instanceof 运算符
  4. 实际应用中的类型转换
← 返回 Java Academy