基本数据类型

Java 是一种强类型语言，要求在声明变量时必须指定其数据类型。Java 数据类型分为两大类：基本数据类型和引用数据类型。本章主要介绍基本数据类型。

数据类型概述

Java 中的数据类型体系如下：

基本数据类型（primitive types）

• 整数类型：byte、short、int、long
• 浮点类型：float、double
• 字符类型：char
• 布尔类型：boolean

引用数据类型（reference types）

• 类（class）
• 接口（interface）
• 数组（array）

整数类型

整数类型用于表示没有小数部分的数字。Java 提供了四种整数类型，它们的取值范围和内存占用各不相同。

整数类型比较

数据类型	内存占用	取值范围	默认值
byte	1字节	-128 到 127	0
short	2字节	-32768 到 32767	0
int	4字节	-2^31 到 2^31-1	0
long	8字节	-2^63 到 2^63-1	0L

int 类型

int 是 Java 中最常用的整数类型，适合大多数整数计算场景。

int number = 100;
int sum = 50 + 50;
int negative = -20;
int hexValue = 0xFF; // 十六进制表示，等于255
int binaryValue = 0b1010; // 二进制表示，等于10

long 类型

当需要表示超出 int 范围的整数时，应使用 long 类型。注意，long 类型的字面量需要以大写或小写字母 L 结尾。

long largeNumber = 10000000000L; // 注意必须添加 L 后缀
long anotherLarge = 9223372036854775807L; // long 的最大值

byte 类型

byte 类型占用空间小，适用于需要节省内存的场景，如处理字节流数据。

byte b = 127; // byte 的最大值
byte negativeByte = -128; // byte 的最小值
byte result = (byte)(b + 1); // 注意需要强制类型转换

short 类型

short 类型在一些特殊场景下使用，如内存受限的环境。

short s = 32767; // short 的最大值

浮点类型

浮点类型用于表示有小数部分的数字。Java 提供了两种浮点类型。

浮点类型比较

数据类型	内存占用	精度	默认值
float	4字节	单精度（约7位有效数字）	0.0f
double	8字节	双精度（约15位有效数字）	0.0d

double 类型

double 是 Java 中默认的浮点类型，提供更高的精度。

double pi = 3.14159265359;
double scientific = 1.23e-4; // 科学计数法，表示0.000123
double defaultDouble = 10.5; // 默认是 double 类型

float 类型

float 类型占用更少的内存，但精度较低。使用 float 类型的字面量时，需要以 F 或 f 结尾。

float f1 = 3.14f;
float f2 = 0.0000001f;

浮点数的精度问题

浮点数在计算机中是以二进制形式存储的，因此可能存在精度损失。

// 精度问题示例
System.out.println(0.1 + 0.2); // 输出 0.30000000000000004，而不是 0.3

// 比较浮点数时应该使用差值小于某个很小的值
boolean equals = Math.abs(0.1 + 0.2 - 0.3) < 1e-10;
System.out.println(equals); // true

字符类型

char 类型用于表示单个字符，占用 2 个字节，可以表示 Unicode 字符集中的字符。

字符字面量

char letter = 'A';
char digit = '5';
char special = '#';
char unicode = '\u0041'; // Unicode 表示，对应 'A'

转义字符

转义字符	含义
\n	换行符
\t	制表符
\	反斜杠
'	单引号
"	双引号
\r	回车符
\b	退格符
\f	换页符

char newline = '\n';
char tab = '\t';
char backslash = '\\';
char quote = '\'';

char 与数值的转换

char 类型可以与整数类型相互转换，以表示字符的 ASCII 码或 Unicode 值。

char c = 'A';
int ascii = c; // 将字符转换为 ASCII 码，ascii = 65

int code = 97;
char lowercase = (char) code; // 将 ASCII 码转换为字符，lowercase = 'a'

布尔类型

boolean 类型只有两个值：true 和 false，用于表示逻辑真或假。

boolean isActive = true;
boolean isComplete = false;

// 布尔表达式
boolean isAdult = age >= 18;
boolean isValid = username != null && !username.isEmpty();

布尔类型的使用场景

• 条件判断（if 语句、while 循环等）
• 控制程序流程
• 状态标记

// 条件判断
if (isActive) {
    System.out.println("账户已激活");
}

// 循环控制
while (!isComplete) {
    // 执行任务
    isComplete = checkCompletion();
}

类型转换

Java 中，当不同类型的变量混合使用时，会发生类型转换。类型转换分为两种：自动类型转换和强制类型转换。

自动类型转换（隐式转换）

当从较低精度的类型转换为较高精度的类型时，Java 会自动进行类型转换，不会有精度损失。

转换规则：byte → short → int → long → float → double

byte b = 100;
short s = b; // 自动转换：byte -> short
int i = s;   // 自动转换：short -> int
long l = i;  // 自动转换：int -> long
float f = l; // 自动转换：long -> float
double d = f; // 自动转换：float -> double

强制类型转换

当从较高精度的类型转换为较低精度的类型时，需要使用强制类型转换。这种转换可能会导致精度损失或数据溢出。

语法：(目标类型) 表达式

int i = 100;
byte b = (byte) i; // 强制转换：int -> byte

long l = 10000000000L;
int i2 = (int) l; // 强制转换：long -> int，可能导致溢出

double d = 3.14;
int i3 = (int) d; // 强制转换：double -> int，截断小数部分

类型转换的注意事项

1. 布尔类型不能与其他类型进行转换
2. 强制类型转换可能导致精度损失或数据溢出
3. char 类型可以与整数类型相互转换，但需要注意 Unicode 值的范围
4. 当表达式中包含不同类型的数据时，会自动提升到最高精度的类型

// 表达式中的类型提升
int i = 5;
double d = 2.5;
double result = i + d; // i 被提升为 double，结果是 7.5

// 计算整数除法时需要注意
int a = 5;
int b = 2;
double division = (double) a / b; // 转换为 double 后再除法，结果是 2.5

变量和常量

变量声明

在 Java 中，声明变量的语法为：数据类型 变量名 = 初始值;

// 声明并初始化变量
int age = 25;
String name = "Java";
double salary;

// 先声明后初始化
salary = 5000.0;

// 多个同类型变量的声明
int x = 10, y = 20, z = 30;

变量命名规范

1. 变量名应该有意义，能反映变量的用途
2. 变量名应使用小驼峰命名法（camelCase）
3. 不能使用 Java 关键字作为变量名
4. 首字符可以是字母、下划线(_)或美元符号($)，但不能是数字

// 良好的变量命名
int studentAge;
String userName;
boolean isActive;

// 避免的命名方式
int a; // 不具描述性
int StudentAge; // 不符合小驼峰
int class; // 关键字
int 1number; // 以数字开头

常量

常量是指在程序运行过程中其值不能被改变的变量。在 Java 中，使用 final 关键字来声明常量。

// 声明常量
final double PI = 3.14159;
final int MAX_SIZE = 100;
final String COMPANY_NAME = "TechCorp";

常量命名规范：

• 通常使用全大写字母
• 单词之间用下划线分隔

基本数据类型的包装类

Java 为每种基本数据类型提供了对应的包装类，以便在需要对象的场合使用。

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

包装类的使用

// 装箱：基本类型转换为包装类
Integer num1 = Integer.valueOf(100); // 手动装箱
Integer num2 = 200; // 自动装箱（Java 5 及以上）

// 拆箱：包装类转换为基本类型
int value1 = num1.intValue(); // 手动拆箱
int value2 = num2; // 自动拆箱（Java 5 及以上）

// 字符串转换为基本类型
int intValue = Integer.parseInt("123");
double doubleValue = Double.parseDouble("3.14");
boolean boolValue = Boolean.parseBoolean("true");

// 基本类型转换为字符串
String str1 = Integer.toString(100);
String str2 = String.valueOf(3.14);
String str3 = 5 + "";

常见错误与注意事项

1. 未初始化变量：使用未初始化的变量会导致编译错误

   int number; // 只声明未初始化
   System.out.println(number); // 编译错误

2. 类型不匹配：将不兼容的类型赋值给变量

   int i = "hello"; // 编译错误

3. 整数溢出：超出数据类型的取值范围

   int maxInt = 2147483647; // int 的最大值
   int overflow = maxInt + 1; // 溢出，结果为 -2147483648

4. 浮点数精度问题：直接使用 == 比较浮点数可能不准确

   double a = 0.1 + 0.2;
   double b = 0.3;
   System.out.println(a == b); // 输出 false

5. 包装类的空指针异常：自动拆箱时如果包装类为 null，会抛出 NullPointerException

   Integer num = null;
   int value = num; // 抛出 NullPointerException

小结

• Java 提供了 8 种基本数据类型：byte、short、int、long、float、double、char、boolean
• 不同的数据类型有不同的内存占用和取值范围，应根据实际需求选择合适的类型
• 类型转换分为自动转换和强制转换，强制转换可能导致精度损失
• 变量是程序中的基本存储单元，需要先声明后使用
• 常量是值不变的变量，使用 final 关键字声明
• 包装类允许在需要对象的场合使用基本数据类型

掌握基本数据类型及其使用方法是 Java 编程的基础，选择合适的数据类型可以提高程序的性能和准确性。