什么是Java数据类型转换？

　　一. 数据类型转换

　　其实Java数据类型转换是将一个数据类型的值转换为另一个数据类型的值的过程。Java中的数据类型可以分为两类：基本数据类型和引用数据类型。基本数据类型包括整型、浮点型、字符型、布尔型等，而引用数据类型则包括类、接口、数组等。

　　而在Java中，数据类型的转换可以分为两种：自动类型转换和强制类型转换。自动类型转换指的是在类型转换时，Java编译器自动将一种类型的值转换为另一种类型的值。例如，将一个int类型的值赋给一个long类型的变量，编译器会自动将int类型的值转换为long类型的值。强制类型转换则指的是在类型转换时，需要使用强制转换符进行转换，强制转换符包括小括号加目标类型的方式，例如：(int) 3.14。

　　二. 自动类型转换(隐式转换)

　　1. 概念

　　所谓的自动类型转换，是指在基本类型中，容量小的数据类型可以自动转换为容量大的数据类型。在数据类型兼容的情况下，小转大就是自动类型转换，自动类型转换也被称为隐式类型转换，不需要我们做任何额外的操作。

　　2. 转换规律(重点)

　　根据自动类型转换的定义，8种基本类型之间的自动转换关系如下图所示：

　　根据上图，给大家提取了基本类型进行自动类型转换时的基本规律，如下：

　　1. 自动类型转换必须满足，转换前数据类型的位数要低于转换后的数据类型;

　　2. 当多种数据类型的数据混合运算时，Java首先会自动将所有的数据转换成容量最大的那种数据类型，然后再进行计算;

　　3. byte、short、char这三者之间不会相互转换，他们三者在计算时首先都会转换为 int 类型;

　　4. boolean类型不能与其他任何基本数据类型进行转换;

　　5. 当把任意基本数据类型(包括boolean)的值和字符串进行连接运算时，基本数据类型的值会自动转换为字符串类型;

　　6. 必须满足转换前的数据类型的位数要低于转换后的数据类型。

　　以上这些基本规律，希望各位能够熟练的记住并运用，这是我们开发时的基本功哦。

　　3. 案例

　　为了能让大家更好地理解自动类型转换，给大家设计了如下配套代码案例，你必须手敲几遍哦。

　　public class TypeDemo04 { public static void main(String[] args) { // 自动类型转换:小转大，自动转换，啥也不用做 // 1.byte-->short,可以 byte b = 19; short s = b; // short-->byte，不可以自动转换：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,不可以自动转换: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,不可以自动转换:Type mismatch: cannot convert from char to int // char c2=j; // 4.int-->long,可以 long x = i; System.out.println("x=" + x); // long-->int,不可以自动转换:Type mismatch: cannot convert from int to long // j = x; // 5.int-->float,可以 float f1 = i; System.out.println("f1=" + f1); // float-->int,不可以自动转换:Type mismatch: cannot convert from float to int // j = f1; // 6.int-->double,可以 double d1 = i; System.out.println("d1=" + d1); // double-->int,不可以自动转换:Type mismatch: cannot convert from double to int // j = d1; // 7. long-->float，可以 float f2 = x; System.out.println("f2=" + f2); // float-->long,不可以自动转换:Type mismatch: cannot convert from float to long // x = f2; // 8. long-->double，可以 double d2 = x; System.out.println("d2=" + d2); // double-->long,不可以自动转换:Type mismatch: cannot convert from double to long // x = d2; // 9. float-->double，可以 double d3 = f1; System.out.println("d3=" + d3); // double-->float,不可以自动转换:Type mismatch: cannot convert from double to float // f2 = d3; }}

　　我们要注意，超出范围的强制转型会得到错误的结果。因为转型时int的两个高位字节直接被扔掉，仅保留了低位的两个字节，因此强制转型的结果有可能是错的。

　　对于以上案例，希望大家动手敲起来，这些代码虽然看着简单，但只有你自己亲手练习了，你才能理解得更深刻。纸上得来终觉浅，绝知此事要躬行!

　　三. 强制类型转换(显式转换)

　　1. 概念

　　所谓的强制类型转换，其实是自动类型转换的逆过程，在数据类型兼容的情况下，将容量大的数据类型转换为容量小的数据类型。强制类型转换也被称为显式类型转换，需要我们显式地进行转换操作，必须在=等号后面的类型前加上强制()转换符，并且有可能会造成数据精度的降低或溢出。

　　2. 转换规律

　　强制类型转换时，也具有一定的规律，但是这个规律比较简单。

　　1. 进行转换的数据类型必须是兼容的;

　　2. 通常，字符串不能直接转换为基本类型;

　　3. 通过基本类型对应的包装类，可以把字符串类型的数值转换成对应的基本类型。如String s = “100”; int i = Integer.parseInt(s);

　　4. boolean类型不可以转换成其他数据类型。

　　为了让大家更好地理解这些规律，还是给大家设计一些代码案例，往下看吧。

　　3. 案例

　　强制类型转换格式：(type)value其中type是要强制类型转换后的数据类型。

　　public class TypeDemo04 { public static void main(String[] args) { // 强制类型转换:大转小。 double d1 = 100; // double-->int，大转小，d1的类型为double,i的类型为int,需要强制转换,类型前添加(要转换成的类型)。 int i = (int) d1; System.out.println("i=" + i); //int-->char,大转小 int j = 97; char c1 = (char) j; System.out.println("c1="+c1); //int-->byte，大转小，精度可能会丢失 int k =128; //byte类型是8位，最大值为127，当int强制转换为byte类型时，128就会导致溢出变成-128。 byte b = (byte)k; System.out.println("b="+b);//-128 //表达式中进行类型转换 double d2 = 10; double d3 = 12; int m = (int) (d2 + d3); System.out.println("m="+m); //double+int,小类型和大类型进行计算，会进行类型提升，最终的结果变成大类型。 //Type mismatch: cannot convert from double to int //int n = d2 + k; int n = (int)d2 + k; System.out.println("n="+n); //浮点数到整数的转换，是通过舍弃小数得到的，而不是四舍五入 int x=(int)55.9;//55 int y=(int)-28.89f; System.out.println("x="+x+",y="+y);//-28 }}

　　大家要注意：

　　类型转换时可能会导致溢出或精度的丢失，另外浮点数到整数的转换是通过舍弃小数得到的，而不是四舍五入。我们可以看下图的执行结果：

　　4. 类型提升补充说明

　　在上面强制转换时，如果涉及到不同数据类型之间的数学运算，比如+、-、*、/等操作，大家要注意：小类型的数据和大类型的数据进行计算时，会自动进行类型提升，最终的结果变成大类型!关于这一块的内容，大家暂时先了解这么多，后面讲运算符时我再细说。

　　public class TypeDemo04 { public static void main(String[] args) { // 强制类型转换:大转小 //类型提升 //double+int,小类型和大类型进行计算，会进行类型提升，最终的结果变成大类型。 //Type mismatch: cannot convert from double to int //int m = d2 + k; int m = (int)d2 + k; System.out.println("m="+m); }}

　　类型自动提升后，如果不进行强制类型转换，也是会出现如下异常：

　　四. 隐含强制类型转换(初始化)

　　1. 概念

　　首先我们要知道这样的基本原则：

　　● 在变量初始化时，整数的默认类型都是int;

　　● 浮点型小数的默认类型是 double;

　　● 浮点型不存在隐含强制类型转换的情况，在定义 float 类型时必须在数字后面跟上 F 或者 f。

　　在 byte b = 100; 这句代码中，100 默认就是 int 类型!虽然100默认是int类型，但Java会把100隐含地强制转换成低级别的 byte 和 short 类型，所以不用我们进行显式的强制类型转换。也就是说，Java会把-128到127之间的int类型数据，都隐含地强制转换成低级别的byte和short类型。

　　2. 案例

　　public class TypeDemo04 { public static void main(String[] args) { // 隐含强制类型转换，初始化时。 //100默认是int类型， //虽然int>byte,但Java会把-128到127之间的数字，隐含强制转换成低级别的byte和short类型， //所以不用我们进行显式的强制类型转换。 byte b = 100; System.out.println("b=" + b); //b2=-129，b2=128都会报错，Type mismatch: cannot convert from int to byte。 //byte b2 = -129; }}

　　五. 其他类型转换

　　关于其他类型之间的转换，主要包括基本类型与字符串、基本类型与包装类、字符串与包装类、包装类与字符串之间的转换。接下来，壹哥再通过几个案例给大家展示一下它们的用法。

　　1. 基本类型转字符串

　　基本类型转字符串，对我们初学者来说，最常用的一个办法就是直接在基本类型后面加上一个双引号""。这种方案最简单，但实际上效率并不高，在进行大量字符串拼接时不建议采用这种方案。当然，如果只是个别字符串的拼接，采用这种方案是无所谓的。

　　public class TypeDemo04 { public static void main(String[] args) { //1.基本类型转字符串 //变量+""，会自动转换String类型 int x = 111; String s1 = x + ""; System.out.println("s1=" + s1); }}

　　2. 包装类型转字符串

　　关于包装类，对于刚入门的朋友，我们现在暂时先了解一下即可：毕竟知识还是得一步一步消化的。

　　public class TypeDemo04 { public static void main(String[] args) { //2.包装类型转字符串 Double d = 1000.0; String str = d.toString(); System.out.println("str=" + str); }}

　　3. 字符串转包装类型

　　该案例大家也是先简单了解即可，后面我们再细讲。

　　public class TypeDemo04 { public static void main(String[] args) { //3.字符串转包装类 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); }}

　　刚入门到的朋友们，不要光看哦!一定要动手敲一敲!!!!