13从零开始学Java之数据类型之间的自动、强制与隐含强制类型转换详解

快来打我* 2024-03-24 09:07 20阅读 0赞

> **作者**：孙玉昌，昵称【 **一一哥**】，另外【 **壹壹哥**】也是我哦  
> CSDN博客专家、万粉博主、阿里云专家博主、掘金优质作者

### 配套项目资料 ###

> [https://github.com/SunLtd/LearnJava][https_github.com_SunLtd_LearnJava]  
> [https://gitee.com/sunyiyi/LearnJava][https_gitee.com_sunyiyi_LearnJava]

--------------------

## 前言 ##

在上一篇文章中，**壹哥**给大家讲解了Java中的数据类型，从此大家就知道了基本类型和引用类型，尤其是8种基本类型的使用和各自特点。但实际上数据类型的使用还有很多更深入的内容，比如数据类型之间的转换，包括自动类型转换和强制类型转换。在今天的文章中，**壹哥**会继续给大家深入地讲解数据类型相关的内容。

\-----------------------------**前戏已做完，精彩即开始**\----------------------------

全文大约【**4000】**字，不说废话，只讲可以让你学到技术、明白原理的纯干货！本文带有丰富案例及配图视频，让你更好的理解和运用文中的技术概念，并可以给你带来具有足够启迪的思考......

## 一. 数据类型转换 ##

### 1. 背景 ###

我们知道，Java中的数据类型总体可以分为两大类，分别是**基本类型和引用类型**，如下图所示：

![fbf6b75ba6844576bf798847e1392b7d.jpeg][]

**这些不同类型的数据，开辟出的内存空间大小不同，所以每种类型的取值范围就不同。**而且**壹哥**给大家举过例子，不同的数据类型之所以取值范围不同，就好比每种类型都是不同的房型，有大有小，如下图所示：

![252665c0c5684930bf4812b9ccc7351c.png][]

所以不同的类型占用的字节大小不同，取值范围也不一样。另外我们还知道，一个变量可以赋值给另一个变量，当然前提是他们的类型差不多。那么此时可能就存在一个问题：如果把byte变量赋值给int变量行不行？反之，把int变量赋值给byte行不行？引用类型之间也能互相转换吗？如果可以的话，会不会出现什么问题？

### 2. 方式 ###

**Java要求=等号左边和=等号右边的类型要一致，如果不一致，就需要进行数据类型转换。**Java中不同的类型之间，**在满足数据兼容的条件下可以实现转换**。Java的数据类型转换，大致有如下几种转换方案：

> **1.自动类型转换：容量小的类型自动转换为容量大的数据类型；**  
> 2. **强制类型转换：容量大的数据类型转换为容量小的数据类型；**  
> 3. **隐含强制类型转换(初始化)：**在变量初始化时，int类型会隐含强制转换成低级别的byte和short类型 **；**  
> 4. **其他类型转换：包装类、字符串、基本类型直接的转换。**

**对基本类型来说，常见的数据转换方式包括自动类型和强制类型转换；对引用类型而言，只存在强制类型转换一种形式。**

### 3. 基本原则 ###

我们在进行类型转换时，无论自动和强制类型转换，都要遵循如下基本原则：

> **1. 不能对boolean类型进行类型转换；**  
> 2. **不能把对象类型转换成不相关的类对象；**  
> 3. **把容量大的类型转换为容量小的类型时，必须使用强制类型转换；**  
> 4. **类型转换过程中，可能会导致溢出或损失精度；**  
> 5. **浮点数到整数的转换，是通过舍弃小数得到的，而不是四舍五入。**

接下来**壹哥**就通过一些案例，来给大家讲讲这几种类型转换都是怎么回事，以及如何实现转换。

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

### 1. 概念 ###

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

### 2. 转换规律(重点) ###

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

![dbe8f44c25c74d769e77bcdb82b3fb0c.png][]

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

> **1.自动类型转换必须满足，转换前数据类型的位数要低于转换后的数据类型；**  
> 2. **当多种数据类型的数据混合运算时，Java首先会自动将所有的数据转换成容量最大的那种数据类型，然后再进行计算；**  
> 3. **byte、short、char这三者之间不会相互转换，他们三者在计算时首先都会转换为 int 类型；**  
> 4. **boolean类型不能与其他任何基本数据类型进行转换；**  
> 5. **当把任意基本数据类型(包括boolean)的值和字符串进行连接运算时，基本数据类型的值会自动转换为字符串类型；**  
> 6. **必须满足转换前的数据类型的位数要低于转换后的数据类型。**

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

### 3. 案例 ###

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

/**
     * @author 一一哥Sun 
     * QQ：2312119590 
     * CSDN、掘金、知乎找我哦
     */
    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是要强制类型转换后的数据类型。

/**
     * @author 一一哥Sun 
     * QQ：2312119590 
     * CSDN、掘金、知乎找我哦
     */
    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
        }
    
    }

#### 大家要注意： ####

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

![f6403de13c94492a92470cda763d28e0.png][]

### 4. 类型提升补充说明 ###

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

/**
     * @author 一一哥Sun 
     * QQ：2312119590 
     * CSDN、掘金、知乎找我哦
     */
    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);
        }
    
    }

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

![8e52bfc9ffc24fcaa9889aa0c3671104.png][]

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

### 1. 概念 ###

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

> **在变量初始化时，整数的默认类型都是int；**  
> **浮点型小数的默认类型是 double；**  
> **浮点型不存在隐含强制类型转换的情况，在定义 float 类型时必须在数字后面跟上 F 或者 f。**

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

### 2. 案例 ###

/**
     * @author 一一哥Sun 
     * QQ：2312119590 
     * CSDN、掘金、知乎找我哦
     */
    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;
        }
    
    }

![c07098cd5e444ee79f2d98835b4d4151.png][]

## 五. **其他类型转换** ##

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

### 1. 基本类型转字符串 ###

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

/**
     * @author 一一哥Sun 
     * QQ：2312119590 
     * CSDN、掘金、知乎找我哦
     */
    public class TypeDemo04 {
    
        public static void main(String[] args) {
            //1.基本类型转字符串
            //变量+""，会自动转换String类型
            int x = 111;
            String s1 = x + "";
            System.out.println("s1=" + s1);
        }
    
    }

### 2. 包装类型转字符串 ###

关于包装类，我们现在暂时先了解一下即可，在后面的章节中，**壹哥**会细讲。

/**
     * @author 一一哥Sun 
     * QQ：2312119590 
     * CSDN、掘金、知乎找我哦
     */
    public class TypeDemo04 {
    
        public static void main(String[] args) {
            //2.包装类型转字符串
            Double d = 1000.0;
            String str = d.toString();
            System.out.println("str=" + str);
        }
    
    }

### 3. 字符串转包装类型 ###

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

/**
     * @author 一一哥Sun 
     * QQ：2312119590 
     * CSDN、掘金、知乎找我哦
     */
    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);
        }
    
    }

另外关于基本类型和包装类之间的转换，**壹哥**会在以后再讲解。

\-----------------------------**正片已结束，来根事后烟**\----------------------------

## 六. 结语 ##

至此，**壹哥**就把自动类型转换、强制类型转换等类型转换相关的内容讲解完毕了，本文的重点有如下这些：

> **1. 自动类型转换的规律；**  
> 2. **强制类型转换的规律；**  
> 3. **隐含强制类型转换。**

现在这些重点内容你都学会了吗？另外如果你独自学习觉得有很多困难，可以加入**壹哥**的学习互助群，大家一起交流学习。

## 七. 配套视频 ##

如果你不习惯阅读技术文章，或是对文中的技术概念不能很好地理解，可以来看看**壹哥**帮你筛选出的视频教程。**与本文配套的Java学习视频，链接如下：**

[https://player.bilibili.com/player.html?bvid=BV1FK4y1x7Ny&p=11&page=11][https_player.bilibili.com_player.html_bvid_BV1FK4y1x7Ny_p_11_page_11]

## 八. 今日作业 ##

### 1. 第一题 ###

请问 byte b = 3; b = b +4;这样的代码有没有问题？

### 2. 第二题 ###

请问 byte b = 5; short s = 3; short t = s + b; 能不能编译通过？评论区告诉我吧

[https_github.com_SunLtd_LearnJava]: https://github.com/SunLtd/LearnJava
[https_gitee.com_sunyiyi_LearnJava]: https://gitee.com/sunyiyi/LearnJava
[fbf6b75ba6844576bf798847e1392b7d.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/5624e8be04884f1db302689c38d2e4f3.png
[252665c0c5684930bf4812b9ccc7351c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/8d0217e96b7644b9b73f5ea039d3bef7.png
[dbe8f44c25c74d769e77bcdb82b3fb0c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/43a7942c8e5d497180ade2be28548a33.png
[f6403de13c94492a92470cda763d28e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/5c69baab8f954acf92521802c20a352e.png
[8e52bfc9ffc24fcaa9889aa0c3671104.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/5dc456c5b42049da961f9e4509dd409e.png
[c07098cd5e444ee79f2d98835b4d4151.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/b41ea0572dfa4362a9afa293169cd0dc.png
[https_player.bilibili.com_player.html_bvid_BV1FK4y1x7Ny_p_11_page_11]: https://player.bilibili.com/player.html?bvid=BV1FK4y1x7Ny&p=11&page=11