【Java SE】数据类型与变量

本节学习目标

1. 字面常量
2. 八大基本数据类型
3. 变量定义、使用、注意事项
4. 自动转换、强制转换、类型提升
5. String 字符串简单使用

---

1. 字面常量

常量：程序运行期间值固定不变的量。字面常量就是直接写在代码里的常量值。

public class Demo {
    public static void main(String[] args) {
        System.out.println("hello world!"); //字符串常量
        System.out.println(100);            //整型常量
        System.out.println(3.14);           //浮点数常量
        System.out.println('A');            //字符常量
        System.out.println(true);           //布尔常量
        System.out.println(false);
    }
}

字面常量 6 种分类

1. 字符串常量 ：双引号""包裹，例："123"、"你好Java"
2. 整型常量 ：不带小数点数字，10、1000，默认 int 类型
3. 浮点数常量 ：小数，3.14，默认 double 类型
4. 字符常量 ：单引号''包裹单个字符 ，'A'、'5'
5. 布尔常量 ：只有两个值：true / false
6. 空常量 ：null（后面引用类型再详细讲）

注意：字符串不属于基本类型，属于引用数据类型。

2. 数据类型

Java 数据类型分为两大类：基本数据类型、引用数据类型。

基本数据类型一共四类八种。

表格

数据类型	关键字	内存占用	取值范围	包装类
字节型	byte	1 字节	-128 ~ 127	Byte
短整型	short	2 字节	-32768 ~ 32767	Short
整型	int	4 字节	\(-2^{31} \sim 2^{31}-1\)	Integer
长整型	long	8 字节	\(-2^{63} \sim 2^{63}-1\)	Long
单精度浮点	float	4 字节	IEEE‑754 浮点数	Float
双精度浮点	double	8 字节	IEEE‑754 浮点数	Double
字符型	char	2 字节	0 ~ 65535	Character
布尔型	boolean	没有明确规定	true / false	Boolean

重点记忆规则

1. int永远 4 字节，long永远 8 字节，和操作系统位数无关。
2. 整型、浮点型都是有符号。
3. 整数字面量默认int；小数字面量默认double。

字节小知识： 1 Byte(字节) = 8 bit(比特位) 1KB = 1024B，1MB=1024KB，1GB=1024MB

3. 变量

变量：程序运行中值可以发生改变 的量。数据类型规定变量存储什么种类的数据。

3.1 定义语法

数据类型 变量名 = 初始值;

示例：

int a = 10;
double d = 3.14;
char c = 'A';
boolean b = true;

System.out.println(a);
System.out.println(d);
System.out.println(c);
System.out.println(b);

a = 100; //变量值可以被修改，=是赋值运算符
System.out.println(a);

//同一行定义多个同类型变量
int a1 = 10, a2 = 20, a3 = 30;

⚠️重要：Java 变量使用之前必须赋值，否则编译报错。

3.2 整型变量

int

//定义同时初始化
int a = 10;

//先定义，后赋值
int b;
b = 20;

// int c;
// System.out.println(c); //❌编译报错，没有初始化

//查看int最大最小值
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);

// int d = 12345678901234; //❌超过int范围编译报错

注意：赋值不能超过该类型取值范围，否则溢出。

long 长整型

long b = 10;
long c = 10L; //长整型字面量建议末尾加大写L，不要小写l（和数字1分不清）

System.out.println(Long.MAX_VALUE);
System.out.println(Long.MIN_VALUE);

short

short s = 10;
System.out.println(Short.MAX_VALUE);
System.out.println(Short.MIN_VALUE);

byte

byte by = 10;
System.out.println(Byte.MAX_VALUE);
System.out.println(Byte.MIN_VALUE); //-128~127

思考：为什么要有 byte、short、int、long 多种整型？ 类比衣服尺码，根据数据大小选择合适类型，节约内存。

3.3 浮点型变量

double（优先使用）

double d = 3.14;
System.out.println(d);

👉 坑点 1：int /int 结果仍然 int，直接舍弃小数

int a = 1;
int b = 2;
System.out.println(a / b); //输出 0，不是0.5

//想要小数，要用浮点参与运算
double a2 = 1.0;
double b2 = 2.0;
System.out.println(a2 / b2); //0.5

👉坑点 2：浮点数是近似存储，存在精度误差，遵循 IEEE‑754 标准

double num =1.1;
System.out.println(num * num); //输出1.2100000000000002

double 不能做精确金融计算，金融场景要用BigDecimal。

float

float f = 3.14F; //❗必须加F/f；小数默认double，直接写3.14编译报错

float 精度比较低，实际开发优先用 double。

3.4 char 字符类型

Java char 占 2 字节，使用Unicode 编码，可以存中文。

char c1 = 'A';
char c2 = '1';
char c3 = '帅'; //可以存中文

System.out.println(c1);
System.out.println(c2);
System.out.println(c3);

注意：单引号，里面只能放 1 个字符。本质存的是字符对应的数字编码值。

3.5 boolean 布尔类型

只有两个取值：true(真)、false(假)

boolean flag = true;
flag = false;
System.out.println(flag);

⚠️Java 和 C/C++ 不一样：boolean 和数字不能互相转换！没有非 0 即真。

// System.out.println(true + 1); //编译报错，不能和数字运算

JVM 规范没有规定 boolean 具体占几个字节。

3.6 类型转换

Java 是强类型语言 ，不同类型赋值有严格校验。分为自动类型转换（隐式） 、强制类型转换（显式）。

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

范围小的类型 → 范围大的类型，编译器自动完成，不用写额外代码

int a = 10;
long b = 100L;
b = a; //int自动转long ✔
// a = b; //long不能直接赋值给int，编译报错

float f = 3.14F;
double d = 5.12;
d = f; //float自动转double ✔

强制类型转换（显式转换）

范围大 → 范围小，需要手动写(目标类型)，可能丢失精度、溢出

int a =10;
long b = 100L;
b = a;
a = (int)b; //强制把long转为int

double d = 5.12;
float f = 3.14F;
d = f;
f = (float)d; //double强制转float

byte b2 = (byte)257; //超过byte范围，强制转换发生截断

注意：

1. 小范围转大范围：自动隐式转换
2. 大范围转小范围：必须强制转换，有风险（溢出、精度丢失）
3. 字面常量数字赋值给 byte/short，编译器会自动检查是否越界。
4. 完全不相干类型不能互转，比如boolean不能和数字转换。

3.7 类型提升（运算时）

不同类型混合运算，小范围类型会提升为大范围类型再计算。

规则：

1. int 和 long 运算 → int 提升成 long，结果 long

   int a = 10;
   long b = 20;
   // int c = a + b; //❌ a+b结果是long，不能直接给int
   long d = a + b; //✔

2. byte、short，参与运算时，一律先提升成 int 再计算（CPU 硬件方便，按 4 字节处理）

   byte a = 10;
   byte b = 20;
   // byte c = a + b; //❌ a+b提升为int，int不能直接赋值byte
   byte c = (byte)(a + b); //✔ 强转回来
   System.out.println(c);

✅类型提升总结

1. 混合运算，小范围提升为大范围；
2. byte、short（小于 4 字节）运算，一律提升到 int。

3.8 String 字符串（引用类型，入门了解）

String代表字符串，使用双引号。

public static void main(String[] args) {
    String s1 = "hello";
    String s2 = " world";
    System.out.println(s1 + s2); // + 字符串拼接
}

int 和 String 互相转换

1. int → String

   int num = 10;
   String str1 = num + ""; //方案1，拼接空字符串
   String str2 = String.valueOf(num); //方案2，推荐

2. String → int

   String str = "100";
   int num = Integer.parseInt(str);

注意：如果字符串不是合法数字，运行时报异常。

本篇核心考点总结

1. 8 大基本数据类型，各自字节数、取值范围；记住包装类。
2. 变量使用必须初始化，否则编译报错。
3. long 字面量末尾加大写L；float 小数后面必须加F。
4. char 占 2 字节，支持中文；boolean 只有 true/false，不与数字转换。
5. int 除以 int 结果还是 int，舍弃小数；double 存在精度误差。
6. 自动转换：小范围→大范围；强制转换：大范围→小范围，有溢出风险。
7. byte、short 做算术运算，先提升为 int。
8. +可以做字符串拼接；String 和 int 简单互转方式。

面试小问答 Q：byte b = 130;编译可以通过吗？ A：不能，byte 范围‑128~127，字面量超过范围直接编译报错；byte b = (byte)130;可以编译，运行会发生数值截断。