基本數據類型的類型轉換

強制類型轉換

float b = 1.5;  // 編譯出錯 Type mismatch: cannot convert from double to float，1.5默認是一個double型，不能自動轉換為float類型
float b2 = (float) 1.5;  //  編譯正確。進行強制類型轉換
float b3 = 1.5f;  //  編譯正確。直接用一個float類型的數值給b3初始化

double d = 0;
float f = (float) d;
int i2 = (int) f;
long l = (long) f;//註意，雖然long有64位，而float只有32位，但float->>long時也需要強制類型轉換
 

System.out.println((byte) 127 + "   " + (byte) 128 + "   " + (byte) 255 + "   " + (byte) 256); //127   -128   -1   0

隱式類型轉換

byte b1 = 3;      //編譯正確。如果此int型數值在數值類型byte的範圍內，則jvm會自動進行一次隱式類型轉換，將此int型數值轉換成byte類型
byte b2 = 1000;  //編譯出錯 Type mismatch: cannot convert from int to byte，註意，錯誤的原因是"在隱式類型轉換後發現超出了byte邊界"，所以jvm就不進行"隱式類型轉換"了
byte b3 = (byte) 1000;  //  編譯正確。進行強制類型轉換

byte p = 3; // 編譯正確：int到byte編譯過程中發生了【隱式類型轉換】
int a = 3;
byte b = a; // 編譯出錯：cannot convert from int to byte。
byte c = (byte) a; // 編譯正確。強制類型轉換

自動類型提升

float f = 5;//編譯正確。整數默認是int類型，此時直接發生了【自動類型提升】
double d = 1.5f;//編譯正確。float類型的浮點數賦值給double類型，此時直接發生了【自動類型提升】
long l = ‘a‘;//編譯正確。字符‘a‘被當做int類型的97後賦值給long類型，此時直接發生了【自動類型提升】

long l_maxInt = 21474_83647;//編譯正確。
long l_bigerThanMaxInt = 21474_83648;//編譯出錯:The literal ** of type int is out of range。由於數值**【超過了int類型的範圍】，故而其自身已經編譯出錯
long l_endWithL = 21474_83648L;//編譯正確。如果一個整數以字母L或l結尾，則其類型為long類型；否則為默認的int類型

int i_outOfRange = Integer.MAX_VALUE + 1;//編譯正確。雖然結果溢出，但是程序沒有任何問題，所以需要開發中自己留意溢出問題

不能 byte->char，char->short

byte b = 3;
char c1=b;//編譯錯誤：Type mismatch: cannot convert from byte to char
char c2 = ‘a‘;
short s1 = c2;//編譯錯誤：Type mismatch: cannot convert from char to short
short s2 = b;//編譯正確。自動類型提升

自動類型提升規則

• 所有的byte型、short型和char型將被提升到int型(例外：final修飾的short、char變量相加後不會被自動提升)
  
• 如果一個操作數是long型，計算結果就是long型
  
• 如果一個操作數是float型，計算結果就是float型
  
• 如果一個操作數是double型，計算結果就是double型
  

• 如果兩個操作數其中有一個是double類型，另一個操作就會轉換為double類型。
  
• 否則，如果其中一個操作數是float類型，另一個將會轉換為float類型。
  
• 否則，如果其中一個操作數是long類型，另一個會轉換為long類型。
  
• 否則，兩個操作數都轉換為int類型

byte b = 50;
char c = ‘a‘;
short s = 1024;
int i = 50000;
float f = 5.67f;
double d = 0.1234;
double result = (f * b) + (i / c) - (d * s);
System.out.println("(f * b)=" + (f * b) + "  (i / c)=" + (i / c) + "  (d * s)=" + (d * s) + "  result=" + result);
//(f * b)=283.5  (i / c)=515  (d * s)=126.3616  result=672.1384
//第一個表達式 f * b 中，b被提升為float類型，該子表達式的結果也提升為float類型。
//第二個表達式 i / c 中，變量c被提升為int類型，該子表達式的結果提升為int類型。
//第三個表達式 d * s 中，變量s被提升為double類型，該子表達式的結果提升為double型。
//最後，這三個結果類型分別是float，int和double類型，想減後該表達式的最後的結果就是double類型。

自動類型提升後的精度問題

float f = Integer.MAX_VALUE;
System.out.println(Integer.MAX_VALUE + "  " + f);//21474_83647  2.1474_8365E9(吶，被"消尾"了，已經由"精確值"變成了"近似值")

再來一個經典案例

byte b = 0, b1 = 1, b2 = 2;//【隱式類型轉換】
b = b1 + b2; //編譯出錯，Type mismatch: cannot convert from int to byte。進行 b1 + b2 運算時會先將b1和b2【自動類型提升】成為int，運算結果也是int，賦給byte類型的b1時需要強制轉換（向下轉型）
b = b + 0;//編譯出錯，同上面的錯誤一樣，運算時會先將b【自動類型提升】成為int，運算結果也是int
b = (byte) (b1 + b2);//編譯正確。【強制類型轉換】
b += b2; //編譯正確。【自加】沒有自增類型提升問題。編譯器在編譯的時候自動進行了強轉，相當於 b = (byte) (b + b2)

//一個奇葩的情況
final byte b3 = 3, b4 = 4;
b = b3 + b4;//編譯正確。有【final】修飾的變量相加後【不會被自動提升】為int類型

//一個更奇葩的情況
final byte b6 = Byte.MAX_VALUE, b7 = 0, b8 = 1;
b = b6 + b7;//編譯正確。
b = b6 + b8;//編譯出錯，Type mismatch: cannot convert from int to byte。註意，錯誤的原因和【long l = 21474_83648】一樣，是因為由於數值**【超過了byte類型的範圍】，故而其自身已經編譯出錯，而不是因為需要強制轉換（向下轉型）
b = 128;//編譯出錯，但是這裏出錯的原因我感覺和上面的原因是不一樣的
b = (byte) (b6 + b8);//編譯正確。強制轉換後肯定沒問題啦！

【類型轉換】 隱式轉換 自動提升 強制轉換