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

1. 背景

我們知道，Java中的數(shù)據(jù)類型總體可以分為兩大類，分別是基本類型和引用類型，如下圖所示：

這些不同類型的數(shù)據(jù)，開辟出的內(nèi)存空間大小不同，所以每種類型的取值范圍就不同。 而且給大家舉過例子，不同的數(shù)據(jù)類型之所以取值范圍不同，就好比每種類型都是不同的房型，有大有小，如下圖所示：

所以不同的類型占用的字節(jié)大小不同，取值范圍也不一樣。另外我們還知道，一個變量可以賦值給另一個變量，當(dāng)然前提是他們的類型差不多。那么此時可能就存在一個問題：如果把byte變量賦值給int變量行不行？反之，把int變量賦值給byte行不行？引用類型之間也能互相轉(zhuǎn)換嗎？如果可以的話，會不會出現(xiàn)什么問題？

2. 方式

Java要求=等號左邊和=等號右邊的類型要一致，如果不一致，就需要進(jìn)行數(shù)據(jù)類型轉(zhuǎn)換。 Java中不同的類型之間，在滿足數(shù)據(jù)兼容的條件下可以實現(xiàn)轉(zhuǎn)換。Java的數(shù)據(jù)類型轉(zhuǎn)換，大致有如下幾種轉(zhuǎn)換方案：

• 自動類型轉(zhuǎn)換： 容量小的類型自動轉(zhuǎn)換為容量大的數(shù)據(jù)類型；
• 強制類型轉(zhuǎn)換： 容量大的數(shù)據(jù)類型轉(zhuǎn)換為容量小的數(shù)據(jù)類型；
• 隱含強制類型轉(zhuǎn)換(初始化)： 在變量初始化時，int類型會隱含強制轉(zhuǎn)換成低級別的byte和short類型 ；
• 其他類型轉(zhuǎn)換：包裝類、字符串、基本類型直接的轉(zhuǎn)換。

對基本類型來說，常見的數(shù)據(jù)轉(zhuǎn)換方式包括自動類型和強制類型轉(zhuǎn)換；對引用類型而言，只存在強制類型轉(zhuǎn)換一種形式。

3. 基本原則

我們在進(jìn)行類型轉(zhuǎn)換時，無論自動和強制類型轉(zhuǎn)換，都要遵循如下基本原則：

• 不能對boolean類型進(jìn)行類型轉(zhuǎn)換；
• 不能把對象類型轉(zhuǎn)換成不相關(guān)的類對象；
• 把容量大的類型轉(zhuǎn)換為容量小的類型時，必須使用強制類型轉(zhuǎn)換；
• 類型轉(zhuǎn)換過程中，可能會導(dǎo)致溢出或損失精度；
• 浮點數(shù)到整數(shù)的轉(zhuǎn)換，是通過舍棄小數(shù)得到的，而不是四舍五入。

接下來就通過一些案例，來給大家講講這幾種類型轉(zhuǎn)換都是怎么回事，以及如何實現(xiàn)轉(zhuǎn)換。

二. 自動類型轉(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ù)上圖，給大家提取了基本類型進(jìn)行自動類型轉(zhuǎn)換時的基本規(guī)律，如下：

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

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

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

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

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

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

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

3. 案例

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

/**
 * @author 
 */
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é)果有可能是錯的。

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

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

1. 概念

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

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

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

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

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

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

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

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

3. 案例

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

/**
 * @author 一一哥Sun
 */
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，當(dāng)int強制轉(zhuǎn)換為byte類型時，128就會導(dǎo)致溢出變成-128。
	byte b = (byte)k;
	System.out.println("b="+b);//-128

	//表達(dá)式中進(jìn)行類型轉(zhuǎn)換
	double d2 = 10;
	double d3 = 12;
	int m = (int) (d2 + d3);
	System.out.println("m="+m);
		
	//double+int,小類型和大類型進(jìn)行計算，會進(jìn)行類型提升，最終的結(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)換時 可能會導(dǎo)致溢出或精度的丟失，另外浮點數(shù)到整數(shù)的轉(zhuǎn)換是通過舍棄小數(shù)得到的，而不是四舍五入。 我們可以看下圖的執(zhí)行結(jié)果：

4. 類型提升補充說明

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

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

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

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

1. 概念

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

• 在變量初始化時，整數(shù)的默認(rèn)類型都是int；
• 浮點型小數(shù)的默認(rèn)類型是 double；
• 浮點型不存在隱含強制類型轉(zhuǎn)換的情況，在定義 float 類型時必須在數(shù)字后面跟上 F 或者 f。

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

2. 案例

/**
 * @author
 */
public class TypeDemo04 {
    public static void main(String[] args) {
	// 隱含強制類型轉(zhuǎn)換，初始化時。
	//100默認(rèn)是int類型，
	//雖然int>byte,但Java會把-128到127之間的數(shù)字，隱含強制轉(zhuǎn)換成低級別的byte和short類型，
	//所以不用我們進(jìn)行顯式的強制類型轉(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)字符串，對我們初學(xué)者來說，最常用的一個辦法就是直接在基本類型后面加上一個雙引號""。這種方案最簡單，但實際上效率并不高，在進(jìn)行大量字符串拼接時不建議采用這種方案。當(dāng)然，如果只是個別字符串的拼接，采用這種方案是無所謂的。

/**
 * @author 
 */
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)于包裝類，我們現(xiàn)在暫時先了解一下即可，在后面的章節(jié)中，會細(xì)講。

/**
 * @author 
 */
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)包裝類型

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

/**
 * @author
 */
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);
    }
}

六. 結(jié)語

至此，就把自動類型轉(zhuǎn)換、強制類型轉(zhuǎn)換等類型轉(zhuǎn)換相關(guān)的內(nèi)容講解完畢了，本文的重點有如下這些：

• 自動類型轉(zhuǎn)換的規(guī)律；
• 強制類型轉(zhuǎn)換的規(guī)律；
• 隱含強制類型轉(zhuǎn)換。

以上就是Java數(shù)據(jù)類型實現(xiàn)自動與強制轉(zhuǎn)換的示例代碼的詳細(xì)內(nèi)容，更多關(guān)于Java數(shù)據(jù)類型的自動與強制轉(zhuǎn)換的資料請關(guān)注腳本之家其它相關(guān)文章！

最新評論