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

1. 背景

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

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

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

2. 方式

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

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

對(duì)基本類型來(lái)說(shuō)，常見(jiàn)的數(shù)據(jù)轉(zhuǎn)換方式包括自動(dòng)類型和強(qiáng)制類型轉(zhuǎn)換；對(duì)引用類型而言，只存在強(qiáng)制類型轉(zhuǎn)換一種形式。

3. 基本原則

我們?cè)谶M(jìn)行類型轉(zhuǎn)換時(shí)，無(wú)論自動(dòng)和強(qiáng)制類型轉(zhuǎn)換，都要遵循如下基本原則：

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

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

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

1. 概念

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

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

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

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

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

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

byte、short、char這三者之間不會(huì)相互轉(zhuǎn)換，他們?nèi)咴谟?jì)算時(shí)首先都會(huì)轉(zhuǎn)換為 int 類型；

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

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

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

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

3. 案例

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

/**
 * @author 
 */
public class TypeDemo04 {
    public static void main(String[] args) {
	// 自動(dòng)類型轉(zhuǎn)換:小轉(zhuǎn)大，自動(dòng)轉(zhuǎn)換，啥也不用做

	// 1.byte-->short,可以
	byte b = 19;
	short s = b;
	// short-->byte，不可以自動(dòng)轉(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,不可以自動(dòng)轉(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,不可以自動(dòng)轉(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,不可以自動(dòng)轉(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,不可以自動(dòng)轉(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,不可以自動(dòng)轉(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,不可以自動(dòng)轉(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,不可以自動(dòng)轉(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,不可自動(dòng)轉(zhuǎn)換:Type mismatch: cannot convert from double to float
	// f2 = d3;
    }
}

我們要注意， 超出范圍的強(qiáng)制轉(zhuǎn)型會(huì)得到錯(cuò)誤的結(jié)果。因?yàn)檗D(zhuǎn)型時(shí) int 的兩個(gè)高位字節(jié)直接被扔掉，僅保留了低位的兩個(gè)字節(jié)，因此強(qiáng)制轉(zhuǎn)型的結(jié)果有可能是錯(cuò)的。

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

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

1. 概念

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

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

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

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

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

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

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

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

3. 案例

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

/**
 * @author 一一哥Sun
 */
public class TypeDemo04 {

    public static void main(String[] args) {
	// 強(qiáng)制類型轉(zhuǎn)換:大轉(zhuǎn)小。
	double d1 = 100;
        
	//double-->int,大轉(zhuǎn)小,d1類型為double,i類型為int,需強(qiáng)制轉(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)小，精度可能會(huì)丟失
	int k =128;   
	//byte類型是8位，最大值為127，當(dāng)int強(qiáng)制轉(zhuǎn)換為byte類型時(shí)，128就會(huì)導(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ì)算，會(huì)進(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);
		
	//浮點(diǎn)數(shù)到整數(shù)的轉(zhuǎn)換，是通過(guò)舍棄小數(shù)得到的，而不是四舍五入
	int x=(int)55.9;//55
	int y=(int)-28.89f;
	System.out.println("x="+x+",y="+y);//-28
    }

}

大家要注意：

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

4. 類型提升補(bǔ)充說(shuō)明

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

/**
 * @author
 */
public class TypeDemo04 {
    public static void main(String[] args) {
	//強(qiáng)制類型轉(zhuǎn)換:大轉(zhuǎn)小
        //類型提升
        //double+int,小類型和大類型進(jìn)行計(jì)算，會(huì)進(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);
    }
}

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

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

1. 概念

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

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

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

2. 案例

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

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

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

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

基本類型轉(zhuǎn)字符串，對(duì)我們初學(xué)者來(lái)說(shuō)，最常用的一個(gè)辦法就是直接在基本類型后面加上一個(gè)雙引號(hào)""。這種方案最簡(jiǎn)單，但實(shí)際上效率并不高，在進(jìn)行大量字符串拼接時(shí)不建議采用這種方案。當(dāng)然，如果只是個(gè)別字符串的拼接，采用這種方案是無(wú)所謂的。

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

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

關(guān)于包裝類，我們現(xiàn)在暫時(shí)先了解一下即可，在后面的章節(jié)中，會(huì)細(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)包裝類型

該案例大家也是先簡(jiǎn)單了解即可，后面我們?cè)偌?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é)語(yǔ)

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

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

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

最新評(píng)論