最新Java零基础知识（第四章数据类型）

4. 第四章 数据类型

4.1 章节目标与知识框架

4.1.1 章节目标

本章节的目标是要求大家理解数据类型的作用，八种基本数据类型各是什么，常见数据类

型的取值范围，怎么使用它们声明变量，各数据类型使用时的注意事项，另外要知道在实际开

发中怎么选择合适的数据类型，还有这八种基本数据类型之间的相互转换。

4.1.2 知识框架

4.2 数据类型概述（理解）

在上一章节中我们学习了变量，我们知道任何一个变量都包括三要素，分别是：数据类型、

变量名、值。其中数据类型尤为重要，目前我们已经接触过一种数据类型，那就是表示整数型

的 int。接下来我们一起来学习一下其他的数据类型。

在学习其他数据类型之前我们先来思考一个问题，数据类型在程序中起到什么作用呢？实

际上是这样的，软件的存在主要是进行数据的处理，现实生活中的数据有很多，所以编程语言

对其进行了分门别类，然后就产生了数据类型，不同数据类型的数据会给其分配不同大小的空

间进行存储。也就是说，数据类型作用就是决定程序运行阶段给该变量分配多大的内存空间。

这就是数据类型的主要作用。那么 java 中的数据类型都包括哪些呢？实际上 Java 中的数据类

型就包括两大类，一类是基本数据类型，另一类是引用数据类型（引用数据类型后面学习），

其中，基本数据类型又包括 4 类 8 种：

 第 1 类：整数型（不带小数的数字）：byte,short,int,long

 第 2 类：浮点型（带小数的数字）：float,double

 第 3 类：字符型（文字，单个字符）：char

 第 4 类：布尔型（真和假）：boolean

大家可以看到，在以上的基本数据类型范畴中未发现字符串类型（带双引号的是字符串），

所以，在这里我要告诉大家，Java 中的字符串属于引用数据类型，不属于基本数据类型的范畴。

通过以上的学习，我们知道八种基本数据类型指的是：byte、short、int、long、float、double、

boolean、char。接下来我们来看一下八种基本数据类型的详细信息，请看下表：

通过上表我们可以看出八种基本数据类型中 byte 占用 1 个字节，short 占用 2 个字节，int

占用 4 个字节，long 占用 8 个字节，float 占用 4 个字节，double 占用 8 个字节，boolean 占用

1 个字节，char 占用 2 个字节。那么字节是什么呢，这个大家要知道 1 个字节是 8 个比特位，

那么又有同学问了，1 个比特位是什么，1 个比特位就是一个 1 或 0，或者说 1 个比特位就是

一个二进制位。也就是说 1 个字节是由 8 个 1 和 0 组成的二进制数字串。

接下来我们先普及一下计算机基础知识吧，实际上计算机在任何情况下都只能识别二进

制，什么是二进制呢？计算机毕竟是一台通电的机器，电流只有正极、负极，所以只能表示两

种情况，也就是 1 和 0。对于一串由 1 和 0 组成的数字来说就是二进制，所谓的二进制就是满

2 进 1，请看以下十进制和二进制的对照表：

其实十进制和二进制之间是存在转换规则的，如下所示：

 十进制转换成二进制：比方说十进制数 65 转换成二进制，我们可以使用短除法，65

对 2 整除商 32 余数为 1，把 1 写在旁边，接着 32 对 2 整除商 16 余数为 0，把 0 写在

旁边，用 16 整除 2 商 0 余数为 0，把 0 写在旁边，这样进行下去直至商为 0 时为止。

然后把余数逆序排列就得到了 65 的二进制。如下图所示：

二进制转换成十进制：比方说二进制代码为 1000001 的十进制数是多少呢？可以采用

按权相加的方法，对于二进制代码 1000001 首先从右边第一位起对应 2 的零次方，第

二位对应 2 的 1 次方，以此类推，把相应的数位与权值相乘得到的积相加即可，即 1

×2 0 +0×2 1 +0×2 2 +0×2 3 +0×2 4 +0×2 5 +1×2 6 =65

好了，计算机二进制的小插曲我们就先说到这里，言归正传，接下来我们继续学习八种基

本数据类型。

当我们对二进制有一定的了解之后，来看一下 byte 类型的取值范围，为什么最大值只能取

到 127 呢：首先数字是有正负之分，在二进制位当中最左边的二进制位是符号位，0 表示正数，

1 表示负数，byte 属于字节型，占用空间大小是 1 个字节，1 个字节是 8 个 bit 位，所以 byte

类型最大值是左边一个 0 右边七个 1：01111111，这个二进制位实际上是 2 7 -1，也就是 127。

byte 类型最小值是-128，那么，这也说明 1 个字节最多可以表示 256 种不同的情况（-128 到

127，中间有一个 0，共 256 个不同的数字）。

接下来我再给大家普及一下计算机的容量单位换算：

到这里，我相信各位会去想，我自己的硬盘是多大空间，可以存储多少个二进制位，你可

以算算哦！

对于以上的八种基本数据类型，其中 byte、short、int、long 属于整数型，代表现实世界中

的整数，只不过容量大小不同，细分的话，byte 叫做字节型，short 叫做短整型，int 叫做整型，

long 叫做长整型，在实际的开发中，为了兼顾到开发效率，选择数据类型的时候也不会太斤斤

计较，这四种类型中 int 最为常用。

八种基本数据类型中，除了整数型可表示数字之外，浮点型也可以表示数字，并且浮点型

表示的数字是带有小数的，其中包括 float、double，float 叫做单精度浮点数，double 叫做双精

度浮点数，根据容量大小我们要知道 double 可以表示更精确的数字。在实际的开发中，double

更常用一些。不过对于财务系统来说，涉及到钱的问题，double 的精度也是远远不够的，后期

我们会学到 Java 基础库中的 BigDecimal 类，该类可表示超大精度的数据。比较适合财务系统

的开发。不过，BigDecimal 则不属于基本数据类型的范畴了。

八种基本数据类型中以上六种所描述的都是数字，除了数字之外，还可以表示文字，那就

是基本数据类型 char，char 在 Java 中占用两个字节，一个汉字正好是两个字节，所以 char 类

型完全可以存储一个汉字，char 类型的字面量要求使用半角的单引号括起来，例如：'a'、'A'、

'国'等。char 类型和 short 类型都是占用 2 个字节，所以它们可表示的种类数量是相同的，不过

由于 char 类型表示文字，没有负数这一说，所以相对来说 char 类型可以取到更大的正整数。

通过上表我们也可以看出，short 类型取值范围是[-32768~32767]，而 char 类型取值范围是

[0~65535]，它们可表示的种类数量都是 65536 种，只不过 char 可以取到最大值为 65535。

八种基本数据类型中有数字，还有文字，数字和文字占了七种，还有一种类型叫做布尔型，

关键字是 boolean，这种类型在 Java 语言中只有两个值：true 和 false，没有其他值，用来表示

现实世界中的真和假。布尔类型的数据在实际的开发中，尤其在业务逻辑判断方面起到非常重

要的作用。并且使用较为频繁。布尔类型占用 1 个字节，true 和 false 其实在计算机底层是使

用 1 和 0 来表示的。

通过本小节的学习，大家需要知道八种基本数据类型分别包括哪些，每种类型占用几个字

节，取值范围是怎样的。对于二进制和十进制的转换，大家作为一个了解即可。

4.3 字符编码（理解）

对于以上的八种基本数据类型来说，其中七种类型 byte,short,int,long,float,double,boolean

计算机表示起来是很容易的，因为这七种类型底层直接就是数字，十进制的数字和二进制之间

有固定的转换规则，所以计算机可直接表示和处理。但是大家别忘了，除了以上的七种数据类

型之外，还有一种类型叫做字符型 char，这个对于计算机来说表示起来就不是那么容易了，因

为字符毕竟是现实世界当中的文字，而文字每个国家又是不同的，计算机是如何表示文字的

呢？

实际上，起初的时候计算机只支持数字，因为计算机最初就是为了科学计算，随着计算机

的发展，为了让计算机起到更大的作用，因此我们需要让计算机支持现实世界当中的文字，一

些标准制定的协会就制定了字符编码（字符集），字符编码其实就是一张对照表，在这个对照

表上描述了某个文字与二进制之间的对应关系

最初的时候美国标准协会制定了 ASCII 码，ASCII（American Standard Code for Information

Interchange：美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统，主要用于显示现

代英语和其他西欧语言。它是现今最通用的信息交换标准，并等同于国际标准 ISO/IEC 646。

ASCII 码采用 1 个字节编码，1 个字节可以表示 256 种不同的形式（前面说过了），对于英文

来说这个足够了，因为英文单词就是由 26 个英文字母拼凑而成，大小写全部才 52 个，再加上

数字和标点符号也不会超过 256 个。但 ASCII 码对于中文来说那就不够了，因为汉字不止 256

个。

常见的 ASCII 码需要大家能够记住几个，在 ASCII 码中规定'a'对应 97，'b'对应 98，以此

类推，'A'对应 65，'B'对应 66，以此类推，'0'字符对应 48，'1'字符对应 49，以此类推，这些常

见的编码还是需要大家记住的。

在字符编码当中，有这样两个常见的术语需要大家了解一下：编码和解码，它们都是什么，

我们拿字符'a'来解释一下：'a'是 97，97 对应的二进制是 01100001，那么从'a'到二进制 01100001

的转换过程称为编码，从二进制 01100001 到'a'的转换过程称为解码。大家一定要注意：编码

和解码要采用同一种字符编码方式（要采用同一个对照表），不然会出现乱码。这也是乱码出

现的本质原因。

随着计算机的不断发展，为了让计算机支持更多国家的语言，国际标准组织又制定了

ISO-8859-1 字符集，又被称为 latin-1，向上兼容 ASCII 码，仍不支持中文，主要支持西欧语言。

再后来，计算机慢慢的开始支持简体中文、繁体中文、日本语、朝鲜语等，其中支持简体中文

的字符集包括：GB2312 、GBK 、GB18030，它们的容量大小不同，其中 GB2312 < GBK <

GB18030。支持繁体中文的是大五码 Big5 等。后来，在上世纪 90 年代初，国际组织制定了一

种字符编码方式，叫做 Unicode 编码，这种编码方式统一了全球所有国家的文字，具体的实现

包括：UTF-8，UTF-16，UTF-32 等。

Java 为了国际化，为了支持所有国家的语言，所以 Java 采用的编码方式为 Unicode 编码。

例如字符'中'对应的 Unicode 码是'\u4e2d'。在实际开发中几乎所有的团队都会使用 Unicode 编

码方式，因为这种方式更通用，兼容性更好。

通过本小节的学习，大家需要理解字符编码是什么，有什么作用，常见的 ASCII 码要知道

一些，另外要理解什么是编码，什么是解码，要知道编码和解码采用的字符编码方式不同时会

出现乱码，还要知道国际通用的编码方式为 ISO-8859-1，支持简体中文的编码方式包括

GB2312、GBK、GB18030，而 Java 采用 unicode 编码，目前在实际的开发中大部分团队都会

选择 UTF-8 的编码方式。

4.4 数据类型详解

以上我们对数据类型有初步的了解之后，我们来详细的学习一下每一种数据类型

4.4.1 字符型详解（理解）

字符型 char 在 Java 语言中占用 2 个字节，char 类型的字面量必须使用半角的单引号括起

来，取值范围为[0-65535]，char 和 short 都占用 2 个字节，但是 char 可以取到更大的正整数，

因为 char 类型没有负数。

Java 语言中的 char 类型变量可以容纳一个汉字。请看以下程序：

我们对以上的程序编译并运行，请看下图结果：

我们可以看到 Java 中的 char 类型确实可以存储一个汉字。我们再来看以下程序，假设字

符我们采用双引号括起来会怎样：

我们对以上的程序进行编译，请看下图编译结果

我们看到编译器报错了，并且提示的错误信息是“不兼容的类型”，这是因为双引号括起

来不是 char 类型，而是 String 类型，其实 String 类型就是 Java 中的字符串类型，但大家要知

道字符串不属于基本数据类型，而是引用数据类型。所以类型不兼容。接下来我们来测试一下

两个或多个字符是否可以使用单引号括起来，请看以下代码：

我们对以上的程序进行编译，请看下图编译结果：

我们可以看出，编译器报错了，错误信息是“未结束的字符文字”，这是因为Java 中有规

定，字符型只能是单个字符，当编译器检测到'ab'的时候，左边以单引号开始，继续检测到 a

字符，然后编译器会继续检查下一个字符是否为另一半单引号，结果不是，而是 b，所以编译

器报错了。这也说明了 Java 中的字符只能是单个字符，不能是多个字符。

接下来，我们再来看一看关于转义字符，转义字符指用一些普通的字符组合代表一些特殊

的字符，由于组合用的字符改变了原意,称为转义字符。Java 中的转义字符以 \ 开始，常见的

转义字符有：\t、\n、\u、\\、\'，\"，其中\t 代表制表符，\n 是换行符，\\表示一个普通的\字符，

\'表示一个普通的'，\"表示一个普通的"。请看以下代码：

我们对以上的程序进行编译并运行，请看下图结果：

对于以上程序，表面看起来'\t'是由两个字符构成，按说应该编译报错，因为它毕竟是两个

字符组成的字符串，可是最终的结果编译通过了，并且正常运行了，这说明了'\t'表示 1 个字符，

所以\具有转义功能，根据以上输出结果可以看出\t 是制表符（abc 和 def 之间的空白就是制表

符）。接下来我们来看一看其它的转义字符。请看以下程序：

我们对以上的程序进行编译并运行，请看下图运行结果：

通过以上代码的测试，hello 和 world 之间换行了，所以\n 代表一个换行符。

对于以上代码的第 4 行 '\'' 来说，这里的 \ 是不能去掉的，如果去掉之后代码就变成了'''，

那么此时编译器会报错，因为单引号'在 Java 中有特殊含义，在这个'''代码当中第一个单引号'

会主动和第二个单引号'配对，此时最后的单引号'就是多余的了，不符合 Java 的语法，所以会

导致编译错误，如果这个时候在第二个单引号'前面添加 \ 进行转义，代码是'\''，那么此时第

二个单引号 \' 就是一个不具备特殊含义的普通单引号字符，这个时候第一个单引号'会和最后

一个单引号'配对。编译和运行就正常了。

对于以上代码第 6 行来说和第 4 行的原理是相同的，代码 \" 表示普通的双引号字符。

对于第 5 行代码来说，代码 \\ 联合起来表示一个普通的 \ 字符，在 Java 中 1 个 \ 字符

不是普通的 \ 字符，具有特殊的作用就是转义，我们想让其变成一个普通的 \ 字符需要使用

两个 \ 来表示，代码 \\ 中，第一个 \ 具有转义功能，第一个 \ 将第二个 \ 转换成普通的 \ 字

符，以此类推，如果代码是 \\\\ 这样，则表示结果是 \\。

对于第 7 行代码来说，如果代码修改为'u4e2d'必然报错，因为 u4e2d 在这个时候是一个普

通的字符串，字符串是不能使用单引号括起来的，如果在 u 字符前添加转义字符 \ 则表示的

含义就不同了，\u 转义之后表示后面的 4e2d 是一个 unicode 码，根据 unicode 字符集可以查询

到汉字'中'的 unicode 码就是 4e2d，所以最终输出结果是汉字'中'。

综上所述，\n 表示换行符，\'表示普通的单引号字符，\\表示一个普通的\字符，\"表示一个

普通的双引号字符，\u 后面的十六进制是文字的 unicode 编码。

通过本小节的学习，我们需要掌握的是，在 Java 语言中，字符 char 类型的数据只能使用

单引号括起来，并且在 Java 语言中 char 类型完全可以存储一个汉字，另外还需要知道在 Java

语言中 \ 具有转义功能，常见的转义字符要知道代表什么含义

最后再给大家留两行代码，思考一下它的运行结果，在后面我们再详细讲解该内容，请看

以下代码：

我们对以上的程序进行编译并运行，请看下图运行结果：

在这里我简单提示一下，以上程序中的“+”运算符起到的作用是求和并不是字符串连接

运算，剩下的大家思考一下吧，后面我们再看。

4.4.2 整数型详解（理解）

整数型数据在 java 中有 4 种表示方式，分别是十进制、八进制、十六进制、二进制。不过

要注意的是二进制写法是在 Java7 中引入的，对于 Java7 之前的版本不支持该语法。默认为十

进制，以 0 开始表示八进制，以 0x 开始表示十六进制，以 0b 开始表示二进制。十进制、八进

制、十六进制有什么区别，请看：

 十进制：0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17...

 八进制：0,1,2,3,4,5,6,7,10,11,12,13,14,15,16,17,20,21...

 十六进制：0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f,10,11...

接下来我们在代码中试验一下以上的几种写法，请看以下代码：

我们对以上的程序进行编译并运行，请看下图运行结果：

通过测试确实可以看到八进制 10 是 8，十六进制的 10 是 16，二进制的 10 是 2。在实际的

开发中大部分还是直接使用十进制的方式，因为十进制对于我们来说更直观，程序的可读性会

更好一些。

在 java 语言当中，整数型字面量被当做 int 类型处理，也就是说在程序中只要遇到整数型

的数字，该数字会默认被当做 int 类型来处理，如果想表示 long 类型则需要在字面量后面添加

L/l，建议大写 L，因为小写 l 和 1 不好区分。请看以下程序

在以上的代码中 int a = 10;表示声明一个 int 类型的变量 a，然后给 a 变量赋值 10，其中 10

是一个整数型字面值，根据以上规则，10 默认被当做 int 类型来处理，那么 int a = 10;就表示

int 类型的字面量 10 赋值给 int 类型的变量 a，这个过程是不存在类型转换的。

另外在以上代码中 long b = 10L;表示声明一个 long 类型的变量 b，然后给 b 变量赋值 10L，

由于 10 后面添加有 L，则编译器会将 10L 当做 long 类型来处理，long 类型的字面量 10L 赋值

给 long 类型的变量 b，这个过程也是不存在类型转换的。

接下来我们在以上代码的基础之上继续编写，请看以下代码：

我们可以看到在第 5 行新增了一行代码：long c = 10;，这行代码是什么原理呢？我们先来

编译，看看是否符合 Java 的语法规则，请看下图编译结果：

接下来我们再运行一下，请看下图运行结果：

通过以上的测试我们可以看到 long c = 10;这种编写方式符合语法规则，并且也可以正常运

行，我们来分析一下，10 是整数型字面量，按照以上规则，Java 中会将 10 默认当做 int 类型

处理，而 c 变量是 long 类型，int 类型可以赋值给 long 类型的变量吗？答案是可以的，因为我

们已经测试过了。这是因为 int 占用 4 个字节，而 long 占用 8 个字节，在 Java 中小容量可以

直接赋值给大容量，这个过程被称为自动类型转换。

接下来我们对以上代码继续编写，请看以下代码

我们可以看到在第 7 行新增了一行代码：int d = c;，我们先对以上代码进行编译，请看以

下编译结果

我们可以看到编译器报错了，也就是以上编写方式不符合 Java 语法规则，我们来看一看为

什么，首先我们看到错误提示信息是：不兼容的类型，从 long 转换到 int 可能会有损失。这是

因为 c 变量是 long 类型占用 8 个字节，而负责接收的 d 变量是 int 类型占用 4 个字节，很明显

是大容量转换成小容量，好比一大玻璃杯中的水倒向小玻璃杯，最终的结果可能会使水溢出，

因为小玻璃杯可能放不下。编译器检测到这种情况的时候就不会自作主张了，需要程序员来指

定，因为数据的损失需要程序员知晓，毕竟数据损失是一件很严重的事情，而编译器自身是不

会负责的，于是 Java 中规定大容量如果需要转换成小容量，则程序员必须手动添加强制类型

转换符才能编译通过，这个过程我们称为强制类型转换。我们对以上代码进行修改，请看以下

修改之后的代码：

我们可以看到将第 7 行的代码修改为：int d = (int)c;，这就是强制类型转换，语法格式是在

需要强转的数据前添加小括号，小括号中写上要转换的类型，我们对以上的程序编译并运行，

请看下图结果：

通过以上的测试我们得出这样一条结论：一个数据在赋值给一个变量的时候存在三种不同

的情况，第一种情况是类型一致，不存在类型转换；第二种情况是小容量可以自动赋值给大容

量，称为自动类型转换；第三种情况是大容量不能直接赋值给小容量，大容量如果一定要赋值

给小容量的话，必须添加强制类型转换符进行强制类型转换操作。不过需要注意的是，强制类

型转换在使用的时候一定要谨慎，因为可能会导致精度损失，因为大杯水倒入小杯中，可能会

导致水的溢出，不过这也不全都是，也可能精度不会损失，如果大杯中的水很少，这个时候倒

入小杯中也可能是不溢出的。就像以上的运行结果，虽然进行了强制类型转换，但并没有损失

精度。接下来我们一起来看看精度损失是什么情况，请看以下代码：

我们可以看到在以上代码中，int 类型的变量 a 强转为 byte 类型，我们对以上代码进行编

译并运行，请看下图运行结果：

4 个字节的 int 类型 300 强转为 1 个字节的 byte 类型，最终的结果是 44，为什么呢？这是

因为首先 int 类型的 300 对应的二进制码是：00000000 00000000 00000001 00101100，强制类

型转换的时候会变成 1 个字节，这个时候底层是将前 3 个字节砍掉了，也就是最后的二进制码

是：00101100，这个二进制码对应的是 44。所以精度损失之后的结果就是 44 了。接下来我们

再来看一下精度损失之后成为负数的情况，请看以下代码：

我们对以上的代码进行编译和运行，请看下图结果：

为什么以上的运行结果是-106 呢？这是因为计算机在任何情况下都是采用二进制补码的

形式存储数据的（为什么采用二进制补码形式存储数据，这里就不再赘述了，不做学术研究）。

计算机二进制编码方式包括原码、反码、补码。对于正数来说原码、反码、补码是同一个。对

于负数来说呢？负数的反码是在其原码的基础上, 符号位不变，其余各个位取反，例如：-15

的原码是：10001111，-15 反码是：11110000。负数的补码是其反码再加 1。例如：-15 的补码

是 11110000 加 1：11110001。换句话说-15 最终在计算机上会采用 11110001 二进制来表示。

我们再来看看以上的程序：int a = 150。4 个字节的 150 对应的二进制是：00000000 00000000

00000000 10010110，强转时前 3 个字节砍掉，最终计算机存储的二进制为：10010110，我们

之前说过最终存储在计算机中的是二进制补码形式，也就是说 10010110 现在是二进制补码形

式，我们通过补码推出原码，负数的补码是反码+1，所以 10010110 减 1 就是反码 10010101，

反码的符号位不变，其余位取反就能得出原码：11101010，而这个值就是-106。对于以上原理

大家了解即可，在实际的开发中很少使用。

接下来我们再来看一段程序，分析以下程序错在哪里，为什么以及怎么解决？

我们对以上的程序进行编译，请看下图结果：

我们可以看到，编译报错了，为什么呢？原因是：java 程序见到 2147483648 这个整数的

时候，默认将其当做 int 类型来处理，但这个数字本身已经超出了 int 类型的取值范围（int 类

型最大值是 2147483647），所以编译报错了，注意：这里编译报错的原因并不是说 long 类型

存不下，long 类型的变量完全可以存储这个数字，以上程序出现的错误是在赋值之前，还没有

进行到赋值运算，数字本身已经超出 int 类型范围，自己崩掉了。怎么解决以上的问题呢？其

实很简单，我们只要让 java 程序认为 2147483648 是一个 long 类型的数据就行了，也就是说在

该数字后面添加 L 问题就解决了（long num = 2147483648L;）。

接下来，一起来看一下以下程序是否可以编译通过，请看代码：

我们来分析一下以上的代码：byte b = 1;，1 是整数型字面量，在 java 中默认被当做 int 类

型来处理，int 类型占用 4 个字节，b 变量是 byte 类型占用 1 个字节，根据上面所学，大容量

无法直接赋值给小容量，要想赋值需要进行强制类型转换，这里没有强转，所以按理说编译是

报错的，接下来我们来看一下编译结果，请看下图：

编译结果让我们意外了，编译通过了，这是为什么呢？我来给大家解释一下，这是因为在

java 语言有这样一条规定，大家记住就行了，如果当一个整数型字面量没有超出 byte 类型取

值范围时，可以直接赋值给 byte 类型变量。那么如果整数型字面量超出 byte 类型取值范围会

怎样呢？我们来测试一下，请看以下代码：

我们对以上的代码进行编译，请看下图编译结果：

我们可以看到编译报错了，错误信息是第 7 行：不兼容的类型，从 int 转换到 byte 可能会

有损失。对于以上程序的第 5 行并没有报错。针对这个错误信息我们之前在学习强制类型转换

的时候接触过，也就是说以上程序要想编译通过必须进行强制类型转换，请看以下代码：

我们对以上的程序进行编译并运行，请看下图结果：

我们通过测试结果可以看出程序正常编译并运行了，这也印证了我们上面所说：当整数型

字面量没有超出 byte 类型取值范围时，可以直接赋值。不过，如果超出了 byte 类型的取值范

围，在使用时必须进行强制类型转换。但需要注意的是强制类型转换会导致精度的损失，例如

以上代码中 int 类型的 128 强转为 byte 之后结果是-128（这是因为计算机以二进制补码形式存

储数字），还是要谨慎使用。

其实除了 byte 类型有这样的规则之外，short 和 char 也具有同样的规则，接下来我们先对

short 进行测试，代码如下所示：

我们对以上的代码进行编译，请看下图编译结果：

通过以上的结果可以看出第 3 行代码编译通过了，但是第 5 行编译报错了，这是因为 short

类型最大值是 32767。对于第 5 行的 32768 已经超出了 short 类型取值范围，同样如果要使用

的话需要进行强制类型转换，这里就不再演示了。接下来我们再来看一看 char 类型，char 同

样满足以上规则，当没有超出 char 类型取值范围时，可以直接赋值，请看以下代码：

我们对以上的程序进行编译并运行，请看下图结果

通过以上的测试可以看出当没有超出 char 类型取值范围的时候，整数型字面量是可以直接

赋值给 char 类型变量的，但结果为什么会是字符 a 和 b 呢？这是因为程序 char c1 = 97;在实际

执行的时候存在隐式的类型转换，会自动将 int 转换成 char，由于 char 最终是一个字符，而 97

正好是字符 a 的 ASCII 码，所以最终结果是字符 a 和 b。那么如果超出 char 类型取值范围会怎

样呢（char 最大值是 65535）？请看以下代码：

我们对以上代码进行编译，请看下图编译结果：

通过以上测试我们同样看到一旦超出 char 类型取值范围时就不能直接赋值了，要修改以上

的错误也是需要进行强制类型转换操作，这里就不再演示了。

综上所述，大家记住一个结论：当一个整数型的字面量没有超出 byte,short,char 的取值范

围，可以将该字面量直接赋值给byte,short,char 类型的变量，如果超出范围则需要添加强制类

型转换符。

通过本小节的学习，我们需要掌握以下几个内容：第一，Java 中的整数型字面量有四种表

示方式，但最常用的还是十进制；第二，整数型字面量被当做 int 处理，如果想当做 long 处理，

需要在后面添加 L 或 l；第三，小容量转换为大容量被称为自动类型转换；第四，大容量转换

成小容量称为强制类型转换，强转时需要添加强制类型转换符，但要注意强转可能损失精度；

第五，当整数型字面量没有超出byte、short、char 的取值范围，可直接赋值。

4.4.3 布尔型详解（理解）

在 Java 语言中布尔类型的值只包括 true 和 false，没有其他值，不包括 1 和 0，布尔类型的

数据在开发中主要使用在逻辑判断方面，例如：如果外面在下雨，我出门带一把雨伞。如果明

天休息，咱们就一起出去玩耍吧。请看一段程序（以下程序中使用了控制语句，后面会详细讲，

先大概了解一下）：

我们对以上程序进行编译并运行，请看下图运行结果

接下来对以上程序进行一个简单的解释：其中第 3 行代码表示定义一个布尔类型的变量

isRain 来表示是否下雨了，给其赋值 true，以下的判断逻辑是如果 isRain 为 true 则输出"外面

下雨了，出门要带一把雨伞哦！"，反之则输出"外面天气晴朗，走起吧！"。第 9 行代码表示

定义一个布尔类型的变量 sex 来表示性别，判断逻辑是如果 sex 为 true 则输出"哥们你好"，反

之则输出"姐们你好"。

接下来，我们再来看一段代码，布尔类型变量的值是否可以使用 1 和 0：

我们对以上的程序进行编译，请看下图结果：

通过以上的测试结果可以看出，在 Java 中布尔类型的变量值不能使用 1 和 0，只能使用 true

和 false。

通过本小节的学习，大家需要掌握的是在 Java 语言中 boolean 类型的数据只有两个值，分

别是 true 和 false，没有其他值，并且 boolean 类型在开发中主要使用在逻辑判断方面。

4.4.4 浮点型详解（理解）

浮点型数据实际上在内存中存储的时候大部分情况下都是存储了数据的近似值，为什么

呢？这是因为在现实世界中存在无穷的数据，例如：3.333333333333333333..，数据是无穷的，

但是内存是有限的，所以只能存储近似值，float 单精度占 4 个字节，double 双精度占 8 个字节，

相对来说 double 精度要高一些。由于浮点型数据存储的是近似值，所以一般判断两个浮点型

数据是否相等的操作很少。

在 java 语言中有这样的一条规定：只要是浮点型的字面量，例如 1.0、3.14 等默认会被当

做 double 类型来处理，如果想让程序将其当做 float 类型来处理，需要在字面量后面添加 f/F。

请看以下代码：

编译报错了：

为什么会编译报错呢？那是因为 3.0 默认被当做 double 类型来处理，占用 8 个字节，前面

的 f 变量是 float 类型占用 4 个字节，大容量无法直接赋值给小容量。怎么修改呢？请看代码：

原文地址：https://blog.csdn.net/m0_61840987/article/details/143724709

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！