一. 數(shù)據(jù)類型轉(zhuǎn)換

　　其實Java數(shù)據(jù)類型轉(zhuǎn)換是將一個數(shù)據(jù)類型的值轉(zhuǎn)換為另一個數(shù)據(jù)類型的值的過程。Java中的數(shù)據(jù)類型可以分為兩類：基本數(shù)據(jù)類型和引用數(shù)據(jù)類型。基本數(shù)據(jù)類型包括整型、浮點型、字符型、布爾型等，而引用數(shù)據(jù)類型則包括類、接口、數(shù)組等。

　　而在Java中，數(shù)據(jù)類型的轉(zhuǎn)換可以分為兩種：自動類型轉(zhuǎn)換和強制類型轉(zhuǎn)換。自動類型轉(zhuǎn)換指的是在類型轉(zhuǎn)換時，Java編譯器自動將一種類型的值轉(zhuǎn)換為另一種類型的值。例如，將一個int類型的值賦給一個long類型的變量，編譯器會自動將int類型的值轉(zhuǎn)換為long類型的值。強制類型轉(zhuǎn)換則指的是在類型轉(zhuǎn)換時，需要使用強制轉(zhuǎn)換符進行轉(zhuǎn)換，強制轉(zhuǎn)換符包括小括號加目標類型的方式，例如：(int) 3.14。

　　二. 自動類型轉(zhuǎn)換(隱式轉(zhuǎn)換)

　　1. 概念

　　所謂的自動類型轉(zhuǎn)換，是指在基本類型中，容量小的數(shù)據(jù)類型可以自動轉(zhuǎn)換為容量大的數(shù)據(jù)類型。在數(shù)據(jù)類型兼容的情況下，小轉(zhuǎn)大就是自動類型轉(zhuǎn)換，自動類型轉(zhuǎn)換也被稱為隱式類型轉(zhuǎn)換，不需要我們做任何額外的操作。

　　2. 轉(zhuǎn)換規(guī)律(重點)

　　根據(jù)自動類型轉(zhuǎn)換的定義，8種基本類型之間的自動轉(zhuǎn)換關(guān)系如下圖所示：

　　根據(jù)上圖，給大家提取了基本類型進行自動類型轉(zhuǎn)換時的基本規(guī)律，如下：

　　1. 自動類型轉(zhuǎn)換必須滿足，轉(zhuǎn)換前數(shù)據(jù)類型的位數(shù)要低于轉(zhuǎn)換后的數(shù)據(jù)類型;

　　2. 當多種數(shù)據(jù)類型的數(shù)據(jù)混合運算時，Java首先會自動將所有的數(shù)據(jù)轉(zhuǎn)換成容量最大的那種數(shù)據(jù)類型，然后再進行計算;

　　3. byte、short、char這三者之間不會相互轉(zhuǎn)換，他們?nèi)咴谟嬎銜r首先都會轉(zhuǎn)換為 int 類型;

　　4. boolean類型不能與其他任何基本數(shù)據(jù)類型進行轉(zhuǎn)換;

　　5. 當把任意基本數(shù)據(jù)類型(包括boolean)的值和字符串進行連接運算時，基本數(shù)據(jù)類型的值會自動轉(zhuǎn)換為字符串類型;

　　6. 必須滿足轉(zhuǎn)換前的數(shù)據(jù)類型的位數(shù)要低于轉(zhuǎn)換后的數(shù)據(jù)類型。

　　以上這些基本規(guī)律，希望各位能夠熟練的記住并運用，這是我們開發(fā)時的基本功哦。

　　3. 案例

　　為了能讓大家更好地理解自動類型轉(zhuǎn)換，給大家設(shè)計了如下配套代碼案例，你必須手敲幾遍哦。

　　public class TypeDemo04 { public static void main(String[] args) { // 自動類型轉(zhuǎn)換:小轉(zhuǎn)大，自動轉(zhuǎn)換，啥也不用做 // 1.byte-->short,可以 byte b = 19; short s = b; // short-->byte，不可以自動轉(zhuǎn)換：Type mismatch: cannot convert from short to byte // byte b2=s; System.out.println("s=" + s); // 2.short-->int,可以 int i = s; System.out.println("i=" + i); // int-->short,不可以自動轉(zhuǎn)換:Type mismatch: cannot convert from int to short // short s2=i; // 3.char-->int,可以 char c = 'a'; int j = c; System.out.println("j=" + j); // int-->char,不可以自動轉(zhuǎn)換:Type mismatch: cannot convert from char to int // char c2=j; // 4.int-->long,可以 long x = i; System.out.println("x=" + x); // long-->int,不可以自動轉(zhuǎn)換:Type mismatch: cannot convert from int to long // j = x; // 5.int-->float,可以 float f1 = i; System.out.println("f1=" + f1); // float-->int,不可以自動轉(zhuǎn)換:Type mismatch: cannot convert from float to int // j = f1; // 6.int-->double,可以 double d1 = i; System.out.println("d1=" + d1); // double-->int,不可以自動轉(zhuǎn)換:Type mismatch: cannot convert from double to int // j = d1; // 7. long-->float，可以 float f2 = x; System.out.println("f2=" + f2); // float-->long,不可以自動轉(zhuǎn)換:Type mismatch: cannot convert from float to long // x = f2; // 8. long-->double，可以 double d2 = x; System.out.println("d2=" + d2); // double-->long,不可以自動轉(zhuǎn)換:Type mismatch: cannot convert from double to long // x = d2; // 9. float-->double，可以 double d3 = f1; System.out.println("d3=" + d3); // double-->float,不可以自動轉(zhuǎn)換:Type mismatch: cannot convert from double to float // f2 = d3; }}

　　我們要注意，超出范圍的強制轉(zhuǎn)型會得到錯誤的結(jié)果。因為轉(zhuǎn)型時int的兩個高位字節(jié)直接被扔掉，僅保留了低位的兩個字節(jié)，因此強制轉(zhuǎn)型的結(jié)果有可能是錯的。

　　對于以上案例，希望大家動手敲起來，這些代碼雖然看著簡單，但只有你自己親手練習了，你才能理解得更深刻。紙上得來終覺淺，絕知此事要躬行!

　　三. 強制類型轉(zhuǎn)換(顯式轉(zhuǎn)換)

　　1. 概念

　　所謂的強制類型轉(zhuǎn)換，其實是自動類型轉(zhuǎn)換的逆過程，在數(shù)據(jù)類型兼容的情況下，將容量大的數(shù)據(jù)類型轉(zhuǎn)換為容量小的數(shù)據(jù)類型。強制類型轉(zhuǎn)換也被稱為顯式類型轉(zhuǎn)換，需要我們顯式地進行轉(zhuǎn)換操作，必須在=等號后面的類型前加上強制()轉(zhuǎn)換符，并且有可能會造成數(shù)據(jù)精度的降低或溢出。

　　2. 轉(zhuǎn)換規(guī)律

　　強制類型轉(zhuǎn)換時，也具有一定的規(guī)律，但是這個規(guī)律比較簡單。

　　1. 進行轉(zhuǎn)換的數(shù)據(jù)類型必須是兼容的;

　　2. 通常，字符串不能直接轉(zhuǎn)換為基本類型;

　　3. 通過基本類型對應(yīng)的包裝類，可以把字符串類型的數(shù)值轉(zhuǎn)換成對應(yīng)的基本類型。如String s = “100”; int i = Integer.parseInt(s);

　　4. boolean類型不可以轉(zhuǎn)換成其他數(shù)據(jù)類型。

　　為了讓大家更好地理解這些規(guī)律，還是給大家設(shè)計一些代碼案例，往下看吧。

　　3. 案例

　　強制類型轉(zhuǎn)換格式：(type)value其中type是要強制類型轉(zhuǎn)換后的數(shù)據(jù)類型。

　　public class TypeDemo04 { public static void main(String[] args) { // 強制類型轉(zhuǎn)換:大轉(zhuǎn)小。 double d1 = 100; // double-->int，大轉(zhuǎn)小，d1的類型為double,i的類型為int,需要強制轉(zhuǎn)換,類型前添加(要轉(zhuǎn)換成的類型)。 int i = (int) d1; System.out.println("i=" + i); //int-->char,大轉(zhuǎn)小 int j = 97; char c1 = (char) j; System.out.println("c1="+c1); //int-->byte，大轉(zhuǎn)小，精度可能會丟失 int k =128; //byte類型是8位，最大值為127，當int強制轉(zhuǎn)換為byte類型時，128就會導致溢出變成-128。 byte b = (byte)k; System.out.println("b="+b);//-128 //表達式中進行類型轉(zhuǎn)換 double d2 = 10; double d3 = 12; int m = (int) (d2 + d3); System.out.println("m="+m); //double+int,小類型和大類型進行計算，會進行類型提升，最終的結(jié)果變成大類型。 //Type mismatch: cannot convert from double to int //int n = d2 + k; int n = (int)d2 + k; System.out.println("n="+n); //浮點數(shù)到整數(shù)的轉(zhuǎn)換，是通過舍棄小數(shù)得到的，而不是四舍五入 int x=(int)55.9;//55 int y=(int)-28.89f; System.out.println("x="+x+",y="+y);//-28 }}

　　大家要注意：

　　類型轉(zhuǎn)換時可能會導致溢出或精度的丟失，另外浮點數(shù)到整數(shù)的轉(zhuǎn)換是通過舍棄小數(shù)得到的，而不是四舍五入。我們可以看下圖的執(zhí)行結(jié)果：

　　4. 類型提升補充說明

　　在上面強制轉(zhuǎn)換時，如果涉及到不同數(shù)據(jù)類型之間的數(shù)學運算，比如+、-、*、/等操作，大家要注意：小類型的數(shù)據(jù)和大類型的數(shù)據(jù)進行計算時，會自動進行類型提升，最終的結(jié)果變成大類型!關(guān)于這一塊的內(nèi)容，大家暫時先了解這么多，后面講運算符時我再細說。

　　public class TypeDemo04 { public static void main(String[] args) { // 強制類型轉(zhuǎn)換:大轉(zhuǎn)小 //類型提升 //double+int,小類型和大類型進行計算，會進行類型提升，最終的結(jié)果變成大類型。 //Type mismatch: cannot convert from double to int //int m = d2 + k; int m = (int)d2 + k; System.out.println("m="+m); }}

　　類型自動提升后，如果不進行強制類型轉(zhuǎn)換，也是會出現(xiàn)如下異常：

　　四. 隱含強制類型轉(zhuǎn)換(初始化)

　　1. 概念

　　首先我們要知道這樣的基本原則：

　　● 在變量初始化時，整數(shù)的默認類型都是int;

　　● 浮點型小數(shù)的默認類型是 double;

　　● 浮點型不存在隱含強制類型轉(zhuǎn)換的情況，在定義 float 類型時必須在數(shù)字后面跟上 F 或者 f。

　　在 byte b = 100; 這句代碼中，100 默認就是 int 類型!雖然100默認是int類型，但Java會把100隱含地強制轉(zhuǎn)換成低級別的 byte 和 short 類型，所以不用我們進行顯式的強制類型轉(zhuǎn)換。也就是說，Java會把-128到127之間的int類型數(shù)據(jù)，都隱含地強制轉(zhuǎn)換成低級別的byte和short類型。

　　2. 案例

　　public class TypeDemo04 { public static void main(String[] args) { // 隱含強制類型轉(zhuǎn)換，初始化時。 //100默認是int類型， //雖然int>byte,但Java會把-128到127之間的數(shù)字，隱含強制轉(zhuǎn)換成低級別的byte和short類型， //所以不用我們進行顯式的強制類型轉(zhuǎn)換。 byte b = 100; System.out.println("b=" + b); //b2=-129，b2=128都會報錯，Type mismatch: cannot convert from int to byte。 //byte b2 = -129; }}

　　五. 其他類型轉(zhuǎn)換

　　關(guān)于其他類型之間的轉(zhuǎn)換，主要包括基本類型與字符串、基本類型與包裝類、字符串與包裝類、包裝類與字符串之間的轉(zhuǎn)換。接下來，壹哥再通過幾個案例給大家展示一下它們的用法。

　　1. 基本類型轉(zhuǎn)字符串

　　基本類型轉(zhuǎn)字符串，對我們初學者來說，最常用的一個辦法就是直接在基本類型后面加上一個雙引號""。這種方案最簡單，但實際上效率并不高，在進行大量字符串拼接時不建議采用這種方案。當然，如果只是個別字符串的拼接，采用這種方案是無所謂的。

　　public class TypeDemo04 { public static void main(String[] args) { //1.基本類型轉(zhuǎn)字符串 //變量+""，會自動轉(zhuǎn)換String類型 int x = 111; String s1 = x + ""; System.out.println("s1=" + s1); }}

　　2. 包裝類型轉(zhuǎn)字符串

　　關(guān)于包裝類，對于剛?cè)腴T的朋友，我們現(xiàn)在暫時先了解一下即可：畢竟知識還是得一步一步消化的。

　　public class TypeDemo04 { public static void main(String[] args) { //2.包裝類型轉(zhuǎn)字符串 Double d = 1000.0; String str = d.toString(); System.out.println("str=" + str); }}

　　3. 字符串轉(zhuǎn)包裝類型

　　該案例大家也是先簡單了解即可，后面我們再細講。

　　public class TypeDemo04 { public static void main(String[] args) { //3.字符串轉(zhuǎn)包裝類 Double d2 = Double.parseDouble("11.1"); Double d3 = Double.valueOf("11.1"); System.out.println("d2=" + d2 + ",d3=" + d3); int i = Integer.parseInt("100"); Integer j = Integer.valueOf("200"); System.out.println("i=" + i + ",j=" + j); }}

　　剛?cè)腴T到的朋友們，不要光看哦!一定要動手敲一敲!!!!