Java 型別轉換 (Type Casting)

型別轉換是將一種資料型別轉換成另一種資料型別。

自動轉換（隱式轉換）

當小範圍型別轉換成大範圍型別時，Java 會自動轉換：

byte → short → int → long → float → double
         ↑
        char

int i = 100;
long l = i;      // int 自動轉換為 long
double d = l;    // long 自動轉換為 double

char c = 'A';
int ascii = c;   // char 自動轉換為 int (65)

System.out.println(l);     // 100
System.out.println(d);     // 100.0
System.out.println(ascii); // 65

強制轉換（顯式轉換）

當大範圍型別轉換成小範圍型別時，需要強制轉換：

double d = 9.78;
int i = (int) d;     // 強制轉換，小數部分被截斷

long l = 100L;
int j = (int) l;     // long 轉換為 int

System.out.println(i);  // 9（不是四捨五入）
System.out.println(j);  // 100

溢位範例

int bigNumber = 130;
byte b = (byte) bigNumber;
System.out.println(b);  // -126（溢位）

// 因為 byte 範圍是 -128 ~ 127
// 130 超出範圍，發生溢位

數字與字串轉換

數字轉字串

int num = 100;
String s1 = String.valueOf(num);       // "100"
String s2 = Integer.toString(num);     // "100"
String s3 = num + "";                  // "100"（字串連接）

double d = 3.14;
String s4 = String.valueOf(d);         // "3.14"
String s5 = Double.toString(d);        // "3.14"

字串轉數字

String s = "100";
int i = Integer.parseInt(s);           // 100
long l = Long.parseLong(s);            // 100

String s2 = "3.14";
double d = Double.parseDouble(s2);     // 3.14
float f = Float.parseFloat(s2);        // 3.14

// 也可以使用 valueOf，回傳包裝類別
Integer num = Integer.valueOf(s);      // Integer 物件

轉換失敗

如果字串格式不正確，會拋出例外：

String invalid = "abc";
// int n = Integer.parseInt(invalid);  // NumberFormatException

String hasSpace = " 100 ";
int n = Integer.parseInt(hasSpace.trim());  // 先去除空白

字元與數字轉換

// 字元轉數字（ASCII/Unicode 值）
char c = 'A';
int ascii = c;           // 65
int ascii2 = (int) c;    // 65（明確轉換）

// 數字轉字元
int code = 66;
char c2 = (char) code;   // 'B'

// 數字字元轉數值
char digit = '5';
int num = digit - '0';   // 5
int num2 = Character.getNumericValue(digit);  // 5

布林值轉換

Java 的布林值無法直接與數字互轉：

boolean b = true;
// int i = (int) b;      // 編譯錯誤

// 需要手動處理
int i = b ? 1 : 0;        // true=1, false=0
boolean b2 = (i != 0);    // 非0為true

字串與布林值

// 布林值轉字串
boolean b = true;
String s = String.valueOf(b);       // "true"
String s2 = Boolean.toString(b);    // "true"

// 字串轉布林值
String s3 = "true";
boolean b2 = Boolean.parseBoolean(s3);  // true

// 只有 "true"（不分大小寫）才會是 true
Boolean.parseBoolean("true");   // true
Boolean.parseBoolean("TRUE");   // true
Boolean.parseBoolean("false");  // false
Boolean.parseBoolean("abc");    // false
Boolean.parseBoolean("1");      // false

運算時的自動型別提升

在運算時，較小的型別會自動提升：

byte a = 10;
byte b = 20;
// byte c = a + b;  // 編譯錯誤，運算結果是 int
int c = a + b;      // 正確

int i = 10;
double d = 3.0;
double result = i + d;  // int 自動提升為 double

long l = 100L;
float f = 2.5f;
float result2 = l + f;  // long 自動提升為 float

型別提升規則：

1. byte、short、char 運算時會先轉成 int
2. 如果有 long，結果是 long
3. 如果有 float，結果是 float
4. 如果有 double，結果是 double