Java数据类型

一、引言

Java是一种强类型的编程语言，Java中可以使用的数据类型分为基本数据类型（Primitive Types）和引用数据类型（Reference Types）两大类。这两类数据在内存管理、默认值、使用场景等方面存在显著差异。

在Java中，所有变量在使用前必须明确声明类型，声明类型后不可隐式转换变量的类型。这种严格性要求程序员在编写代码时明确数据类型，避免意外错误。Java编译器在编译阶段会进行类型匹配验证，可在代码运行前捕捉类型不匹配问题，显著减少运行时错误。不同基本类型之间的转换需显式强制转换。

Java正是通过编译时检查、显式类型声明和严格转换规则，构建了高可靠性的编程环境。这种设计不仅减少了运行时错误，还提升了代码安全性与可维护性，是Java成为企业级应用首选语言的核心原因之一。

二、基本数据类型

Java中定义了8种基本数据类型：byte、short、int、long、float、double、char、boolean。基本数据类型也被称为简单类型，它们可以分为4种：

整型：包括byte、short、int和long，主要用于表示有符号的整数。
浮点型：包括float和double，主要用于表示带小数位的浮点数。
字符型：char，主要用于表示字符集中的符号，比如字母、数字、标点符号等。
布尔型：boolean，主要用于表示true/false值，常用于逻辑判断。

Java虽然是面向对象的编程语言，但Java的基本数据类型并不是面向对象的，主要因为出于效率原因考虑，因为将基本数据类型设计成对象会降低性能，毕竟对象的结构更加复杂。

Java的基本数据类型具有明确的内存占用空间，也就使其具有明确的范围。这使得Java可以在不同的系统和设备上保持可移植性。比如，不管在哪种操作系统的特定平台上，int类型永远都是使用32个二进制位表示具体的整数。

1.整型（存储整数）

在Java中能够使用的整型类型有4种：byte、short、int和long。它们都能够存储一个有符号的（正号或负号）整数，不同的整型类型在内存中占用不同的二进制位数，使得它们能够表示的整数的范围不同，具体见下表：

类型	位数	取值范围	默认值	典型应用场景
`byte`	8	-128 ~ 127	0	文件处理、节省内存
`short`	16	-32768 ~ 32767	0	兼容旧代码、小范围整数
`int`	32	-2^31 ~ 2^31-1（约±21亿）	0	日常整数运算
`long`	64	-2^63 ~ 2^63-1	0L	时间戳、大数据量

byte类型是取值范围最小的整型，它使用8位（1字节）表示有符号的整数，只能在-128~127范围内的取整数值。byte特别适合处理来自网络和文件的数据流和其他基本类型不直接兼容的原始二进制数据。

byte类型变量的声明如下所示：

byte b;// 将变量b的数据类型声明为byte
byte c = 127;// 将变量c的数据类型声明为byte，并同时赋值127

short类型使用16位（2字节）表示有符号的整数，可以在-32768~32767范围内取整数值。相比其他整型类型，short类型的使用率较低。

short类型变量的声明如下所示：

short s;// 将变量s的数据类型声明为short
short t = 2025;// 将变量t的数据类型声明为short，并同时赋值2025

int类型是最常用的整型类型，它使用32位（4字节）表示有符号的整数，取值范围-2^31~2^31-1（约±21亿），基本可以涵盖日常整数运算的范围。在Java程序中，int类型常用于控制循环次数，或者做数组的索引。另外，由于byte类型和short类型会在表达式计算中自动被提升为int类型，所以当需要使用整型类型时，int类型通常是最佳选项。

int类型变量的声明如下所示：

int i;// 将变量i的数据类型声明为int
int j = 1745545182;// 将变量i的数据类型声明为int，并同时赋值1745545182

long类型是最大的整型类型，它使用64位（8字节）表示有符号的整数，取值范围-2^63~2^63-1。当需要处理的整数类型过大无法用int类型保存时，就可以使用long类型。long类型的中保存的数值如果超出int类型的范围，就需要在数值末尾增加大写“L”或小写“l”，由于小写“l”在部分字体显示时与数字1过于接近，所以通常建议使用大写“L”作为后缀。

long类型变量的声明如下所示：

long l;// 将变量l的数据类型声明为long
long m = 1745545182550L;// 将变量m的数据类型声明为long，并同时赋值1745545182550

2.浮点型（存储浮点数）

在Java中能够使用的浮点型类型有2种：float和double。它们用于存储在计算需要小数精度的表达式时使用的浮点数。Java实现了IEEE-754标准机的浮点类型和操作符。这两种不同的浮点型类型在内存中占用不同的二进制位数，使得它们能够表示的浮点数的精度范围不同，具体见下表：

类型	位数	取值范围	默认值	典型应用场景
`float`	32	1.4E-45~3.4028235E38（6-7位有效数）	0.0F	低精度浮点数运算
`double`	64	4.9E-324~1.7976931348623157E308（15位有效数）	0.0D	科学计算、默认的浮点型类型

float类型使用32位（4字节）存储单精度浮点数，通常在需要使用小数计算且精度要求不高的场合使用。类似long类型，float类型的数值在保存时需要使用大写“F”或小写“f”作为后缀。

float类型变量的声明如下所示：

float f;// 将变量f的数据类型声明为float
float g = 3.141593F;// 将变量g的数据类型声明为float，并同时赋值3.141593

注意使用float类型时，由于占用空间较小，使得计算效率较高，但如果操作的数值过大或者过小，就会损失浮点数的精度，导致计算结果偏差过大。

double类型使用64位（8字节）存储双精度浮点数，是Java中使用频率最高的浮点型类型，大部分Java中预定义的方法返回浮点数时，都使用的double类型。虽然double类型相比float类型占用空间更大，如果需要在多次运算中保持浮点数的精度，或者处理非常大的小数时，double类型更具优势。

double类型变量的声明如下所示：

double d;// 将变量d的数据类型声明为double
double e = 3.14159265358979;// 将变量e的数据类型声明为double，并同时赋值3.14159265358979

3.字符型（存储单个字符）

在Java中使用char类型保存单个字符。Java的设计初衷是允许程序员编写在世界范围内均可运行的程序，而Unicode为了解决传统的字符编码方案的局限，它为全世界每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求，所以Java对Unicode的支持就成为其语言设计的核心特性之一。Java的char类型是16位无符号整数，取值范围为0~65535，可以直接存储单个字符、ASCII码或Unicode编码。

char类型变量的声明如下所示：

char c;// 将变量c的数据类型声明为char
char c1 = 'A';// 将变量c1的数据类型声明为char，并同时赋值直接字符'A'
char c2 = 65; // 将变量c1的数据类型声明为char，并同时赋值直接字符'A'的ASCII码
char c3 = '\u0041';// 将变量c1的数据类型声明为char，并同时赋值直接字符'A'的Unicode编码

4.布尔型（存储逻辑值）

在Java中使用boolean类型保存逻辑值，它只能保存两个逻辑值true和false其中的一个，所有关系操作符和逻辑操作符都返回boolean类型的值。

boolean类型变量的声明如下所示：

boolean b;// 将变量b的数据类型声明为boolean
boolean b1 = true;// 将变量b1的数据类型声明为boolean，并同时赋值true
boolean b2 = false;// 将变量b2的数据类型声明为boolean，并同时赋值false

5.基本数据类型的字面量

在Java中，字面量是直接在源代码中表示的固定值，无需通过计算或转换即可使用。字面量主要用于初始化变量、参与表达式运算或定义常量，是程序中数据的基础表示形式。下面依次介绍几种基本数据类型的字面量。

(1).整型字面量

整型是最常用的数据类型，所有整数值都是整型字面量。除了现实世界常用的十进制整数值之外，Java还支持其他进制的整数值作为整型字面量。具体表示方式如下：

进制	示例	说明
十进制	10、-5	日常以10位基数描述的整数
二进制	0b1010（表示十进制的10）	以0b或0B开头
八进制	012（表示十进制的10）	以0开头
十六进制	0xA（表示十进制的10）	以0x或0X开头

整型字面量在Java中默认用于创建int类型，当用整型字面量创建其他类型的整型类型时，需要注意：

将整型字面量赋值给byte类型或short类型时，由于这两种整型类型占用的空间比int类型少，如果整型字面量刚好位于byte类型或short类型的取值范围，就可以正常使用不会有问题。
将整型字面量赋值给long类型时，由于long类型占用的空间比int大，如果整型字面量刚好位于int类型的取值范围，可以省略整型字面量末尾的标识（大写“L”或小写“l”），如果整型字面量超出int类型的取值范围，就必须在整型字面量末尾使用标识（大写“L”或小写“l”）明确表示该整型字面量是long类型的。

(2).浮点型字面量

浮点型用于保存具有小数部分的十进制数值，在Java中可以使用标准记数法或者科学记数法表示浮点数。标准记数法是日常生活中最常见的记数法，由整数部分、小数部分和它们之间的小数点组成，如：3.14、0.333、12.27等。科学记数法也称指数记数法，是一种记录或标志数的科学表示法，在数学中，它把一个数表示成a与10的n次幂相乘的形式（1≤|a|<10，a为实数且不为分数形式，n为整数），常用于表示由于太大或太小而不方便用标准记数法表示的数。在Java中，a部分使用标准记数法表示，10的n次幂部分使用大写E（或小写e）后跟上一个十进制整数（表示10的幂），如314159E-5、5.67e11、-6.32E+23等。

浮点型字面量在Java中默认用于创建double类型，当用浮点型字面量创建float类型时，需要在浮点型字面量末尾添加大写F（或小写f）后缀。

虽然也可以在浮点型字面量末尾添加大写D（或小写d）后缀表示使用浮点型字面量创建double类型，但由于浮点型字面量默认就是double类型，所以这样做是多余的。

在Java中还有一种很少用的十六进制浮点型字面量，这种浮点型字面量使用与科学记数法类似的方式表示，不过a部分是一个十六进制数，其后使用大写P（或小写p），再接上一个二进制指数（表示2的幂），如0x12.2P2，0x12.2为十六进制数（转十进制数18.125），P后的2表示2的2次幂（4），所以0x12.2P2代表72.5（18.125乘以4）。

(3).布尔型字面量

布尔型用于保存逻辑值，逻辑值只有true和false两个，所以布尔型字面量只有true和false。在Java中，布尔型字面量只能赋值给声明为布尔型的变量。

在Java中，布尔型不能转换为其他基本数据类型，所以字面量true不能用1代替，字面量false也不能用0代替。

(4).字符型字面量

字符型用于保存单个字符，Java中采用Unicode字符集表示单个字符，所以字符型字面量大部分都可以转换成十六进制的非负整数，并且还可以使用部分操作符进行操作，只要操作结果还是一个十六进制的非负整数即可。在Java中，字符型字面量使用一对单引号包含的字符来表示，如'a'、'汉'、'한'等。对于一些不能直接输入的字符，还可以用转义字符（\）结合一个或多个指定字符组成转义序列进行表示，如'\n'、'\r'、'\t'等。Java还支持使用八进制或十六进制直接表示字符时，对于八进制表示法，可以在转义字符（\）后接三个数字的八进制数，如'\141'表示字符'a'；对于十六进制表示法，可以在转义字符（\）后接u，再接4位的十六进制数，如'\u0061'表示字符'a'，\u2c49'表示字符'汉'，'\ud55c'表示'한'。具体表示方式如下：

转义序列	说明	描述
`\ddd`	八进制字符	表示一个八进制字符
`\uxxxx`	十六进制字符	表示一个Unicode字符
`\n`	换行符	表示新的一行（换行）
`\r`	回车符	表示回车（回到一行的开始）
`\t`	制表符	表示一个制表符（通常用于对齐文本）
`\f`	换页符	表示回车（回到一行的开始）
`\b`	退格符	表示退格，将光标移到前一位置
`\"`	双引号	表示双引号字符（`"`）。在字符串中直接使用双引号时，需要用反斜杠进行转义
`\'`	单引号	表示单引号字符（`'`）。在字符串中直接使用单引号时，需要用反斜杠进行转义
`\\`	反斜杠	表示反斜杠字符（`\`）。在字符串中直接使用反斜杠时，需要使用两个反斜杠（`\\`）来表示一个反斜杠(`\`)

注意，字符型字面量都使用一对单引号包含的字符来表示，千万不能将单引号写成双引号。在Java中，字符串字面量使用一对双引号包含的若干字符来表示，如："Java"、"编程语言"、"Hello World"等。字符型字面量可以替换字符串字面量中的单个字符，但需要注意的是Java中没有定义徐行的转义字符，所以字符串字面量的开头和结尾必须位于同一行中。另外，不同于其他语言中的字符串通常以字符数组实现，在Java中字符串是引用数据类型。

(5).字面量中的下划线

从Java 7开始，在字面量中引入了下划线（_），主要用于提升代码可读性。

分隔长数字：通过下划线将数字按逻辑分组，例如千分位，使数值更易读。

int decimal = 1_000_000; // 十进制千分位
long creditCard = 1234_5678_9012_3456L; // 十进制千分位

分隔其他进制：按字节或半字节分隔，增强二进制、八进制、十六进制数值的可读性。

int binary = 0b1010_1010;     // 二进制
int octal = 0123_4567;        // 八进制
int hex = 0xAB_CD_EF;         // 十六进制

科学计数法与浮点数：分隔浮点数或科学计数法的整数/小数部分。

double pi = 3.141_592_653_589;     // 在小数部分插入下划线
float earthRadius = 6_371.0F;     // 在整数部分插入下划线
double avogadro = 6.022_140_857E23; // 科学计数法中插入下划线

在字面量中使用下划线要注意以下使用规则：

允许的位置：
- 数字之间（整数、浮点数、二进制、十六进制等）。
- 可连续使用多个下划线（如5______2），但不推。
禁止的位置
- 数字开头或结尾（如_1000或1000_）。
- 小数点前后（如3_.14或3._14）。
- 进制前缀（如0x、0b）或类型后缀（如 L、F）附近（如 0x_52 或 123_L）。
- 科学计数法字母E前后之后（如 6.23E1_0）。

三、引用数据类型

在 Java 中，引用数据类型是面向对象编程的核心，用于表示复杂数据结构。与基本数据类型直接存储数值不同，引用数据类型存储的是对象在堆内存中的地址引用，主要包括类、接口和数组三类。

引用数据类型变量本身存储在栈内存，保存对象的堆内存地址，对象实际数据存储在堆内存，通过引用间接访问。引用数据类型的默认值为null，使用未初始化的引用会抛出空指针异常NullPointerException。

Java中的引用数据类型与基本数据类型的具体区别如下：

特性	基本数据类型	引用数据类型
存储内容	实际数值	对象的内存地址
内存位置	栈内存	变量在栈，对象在堆
默认值	按具体类型区分	`null`
传递方式	值传递（复制数值）	引用传递（复制地址）
内存占用	固定大小	动态分配（取决于对象复杂度）
操作效率	高	较低（需间接访问堆数据）
垃圾回收	无	自动回收

四、数据类型转换

在Java中，数据类型转换是一个常见的操作，它允许程序员将某种类型的值赋给另一种类型的变量。Java支持两种数据类型类型转换的方式：自动类型转换和强制类型转换。

1.自动数据类型转换

自动数据类型转换也称为隐式转换，当数据类型转换时满足以下条件，那么Java就会将数据类型自动进行转换。

目标类型和源类型是兼容的
目标类型的占用空间大于源类型

当满足上述两个条件时，Java就会自动进行数据类型转换，这种转换被称为扩宽转换（Widening Conversion）。扩宽转换对所有的数值类型（整型和浮点型）都是相互兼容的，那么数值类型的数据是否能够进行扩宽转换，就只需要考虑数据类型的占用空间了。例如，int类型占用32位（4字节），long类型占用64位（8字节），那么将int类型的数据转换为long类型，long类型总是有足够的空间保存int类型的数据，所以Java就会自动进行数据类型转换。

对于基本数据类型，以下是常见的数据类型转换，箭头表示转换的方向：

整数类型：byte → short → int → long → float → double
浮点类型：float → double
字符类型：char → int（转换为Unicode码值）

注意，不存在数值类型到char或boolean类型的自动转换，不存在boolean类型到其他类型的自动转换。

扩宽转换还有一种形式，即混合操作提升，如果操作数中存在占用空间较大的数据类型，结果自动提升为该数据类型。例如，byte、short和char参与算术操作时自动提升为int。

下面的示例展示了Java中的自动数据类型转换。

public class AutoCasting {

	public static void main(String[] args) {
		// 1. 整数类型从小到大的自动转换
		byte byteVal = 100;
		short shortVal = byteVal; // byte → short
		int intVal = shortVal; // short → int
		long longVal = intVal; // int → long
		float floatVal = longVal; // long → float（可能损失精度）
		double doubleVal = floatVal; // float → double

		System.out.println("byte → short → int → long → float → double:");
		System.out.println("byteVal: " + byteVal + " → shortVal: " + shortVal);
		System.out.println("intVal: " + intVal + " → longVal: " + longVal);
		System.out.println("floatVal: " + floatVal + " → doubleVal: " + doubleVal);

		// 2. 字符类型自动转换为整数（Unicode码）
		char charVal = '汉';
		int charToInt = charVal; // char → int（输出27721）
		System.out.println("\nchar '汉' → int: " + charToInt);

		// 3. 运算时自动提升到操作数中最大的类型
		byte a = 10;
		short b = 20;
		int c = 30;
		long d = 40L;
		float e = 5.5f;
		double f = 6.6;

		// 示例1：byte + short → int
		int result1 = a + b;
		System.out.println("\nbyte + short → int: " + result1); // 输出30

		// 示例2：int + long → long
		long result2 = c + d;
		System.out.println("int + long → long: " + result2); // 输出70

		// 示例3：long + float → float
		float result3 = d + e;
		System.out.println("long + float → float: " + result3); // 输出45.5

		// 示例4：float + double → double
		double result4 = e + f;
		System.out.println("float + double → double: " + result4); // 输出12.1
	}
}

程序执行后的结果如下：

byte → short → int → long → float → double:
byteVal: 100 → shortVal: 100
intVal: 100 → longVal: 100
floatVal: 100.0 → doubleVal: 100.0

char '汉' → int: 27721

byte + short → int: 30
int + long → long: 70
long + float → float: 45.5
float + double → double: 12.1

2.强制数据类型转换

强制数据类型转换也称为显式转换，因为这种数据类型转换需要使用类型转换操作符明确告诉Java需要进行该数据类型转换。强制数据类型转换的一般形式如下：

(target-Data-Type)value

其中，括号中的target-Data-Type指定需要将括号后的value转换成哪种数据类型，value可以是保存了具体数据的变量，也可以是某个具体的值。

在整型类型中，如果需要将内存空间较大的数据类型转换为内容空间较小的数据类型，就需要使用强制数据类型转换，这种转换也被称为缩窄转换（Narrowing Conversion）。例如，int类型占用32位（4字节），long类型占用64位（8字节），那么将long类型的数据转换为int类型，int类型没有足够的空间保存long类型的数据，所以就必须进行缩窄转换。缩窄转换最常见的后果就是数据溢出，因为原整型数据中的值过大，超出目标整型类型的取值范围，这时原整型数据将按照目标整型类型的取值范围为模减少。

另外，如果将浮点型类型强制转换为整型类型，Java总会对浮点型类型中的浮点数进行截尾，即舍弃浮点数的小数部分。