【2.Java基础】Java常量与变量-从基本类型到类型转换全面掌握

文章目录

【Java基础】Java常量与变量：从基本类型到类型转换全面掌握
- 导入语
- [1 ~> 标识符与关键字](#1 ~> 标识符与关键字)
- - [1.1 标识符](#1.1 标识符)
  - [1.2 关键字](#1.2 关键字)
- [2 ~> 变量------存储数据的容器](#2 ~> 变量——存储数据的容器)
- - [2.1 什么是变量（生活中的类比）](#2.1 什么是变量（生活中的类比）)
  - [2.2 变量的三要素](#2.2 变量的三要素)
  - [2.3 变量声明的几种方式](#2.3 变量声明的几种方式)
  - [2.4 变量的命名推荐规范（驼峰命名法）](#2.4 变量的命名推荐规范（驼峰命名法）)
- [3 ~> 数据类型一览](#3 ~> 数据类型一览)
- - [3.1 Java 中的数据类型分类](#3.1 Java 中的数据类型分类)
  - [3.2 八种基本数据类型速查表](#3.2 八种基本数据类型速查表)
- [4 ~> 整型字面值及变量声明](#4 ~> 整型字面值及变量声明)
- - [4.1 整型的四种写法](#4.1 整型的四种写法)
  - [4.2 long 类型的声明](#4.2 long 类型的声明)
  - [4.3 整型变量赋值常见错误](#4.3 整型变量赋值常见错误)
- [5 ~> 浮点型字面值](#5 ~> 浮点型字面值)
- - [5.1 float 和 double](#5.1 float 和 double)
  - [5.2 浮点数的科学计数法](#5.2 浮点数的科学计数法)
  - [5.3 浮点数案例：精度丢失问题](#5.3 浮点数案例：精度丢失问题)
- [6 ~> 字符型字面值](#6 ~> 字符型字面值)
- - [6.1 char 类型](#6.1 char 类型)
  - [6.2 常用转义字符](#6.2 常用转义字符)
- [7 ~> 布尔类型和字符串的字面值](#7 ~> 布尔类型和字符串的字面值)
- - [7.1 boolean 类型](#7.1 boolean 类型)
  - [7.2 String 类型（初识）](#7.2 String 类型（初识）)
- [8 ~> 常量](#8 ~> 常量)
- - [8.1 什么是常量](#8.1 什么是常量)
  - [8.2 为什么需要常量](#8.2 为什么需要常量)
- [9 ~> 数据类型转换](#9 ~> 数据类型转换)
- - [9.1 为什么需要类型转换](#9.1 为什么需要类型转换)
  - [9.2 自动类型转换（隐式转换）](#9.2 自动类型转换（隐式转换）)
  - [9.3 强制类型转换（显式转换）](#9.3 强制类型转换（显式转换）)
  - [9.4 类型转换经典案例](#9.4 类型转换经典案例)
- [10 ~> 局部变量的存储方式](#10 ~> 局部变量的存储方式)
- - [10.1 变量存在哪](#10.1 变量存在哪)
- [11 ~> 常见编译运行错误](#11 ~> 常见编译运行错误)
- [思考 && 总结](#思考 && 总结)
- 结尾

【Java基础】Java常量与变量：从基本类型到类型转换全面掌握

📖 文章简介： 本文是Java基础核心教程，系统讲解Java中的标识符、关键字、八大基本数据类型（整型/浮点型/字符型/布尔型）、变量的声明与命名规范、常量的定义方式，以及数据类型转换（自动转换与强制转换）的完整规则。全文配有完整代码示例和常见编译错误对照表，适合刚写完HelloWorld、准备深入学习Java语法的初学者。

🎬 个人主页： 源码骑士

❄ 专栏传送门： 《java编程练习题》《全栈开发》

⭐️热衷从源码视角拆解技术底层原理，将复杂架构讲得通俗易懂

🎬 源码骑士的简介：

5年Android Framework系统开发经验，曾主导多项系统级性能优化专项

技术栈覆盖Android系统全链路（Binder/Handler/AMS/WMS/启动流程）及Java后端全家桶（Spring + MyBatis + Redis + Oracle）

累计产出原创技术文章100+篇，文章以流程图为特色，被读者评价为"看一篇胜过啃一周源码"

导入语

如果你已经成功跑通了 HelloWorld，下一步要学的就是变量和数据类型。这部分相当于 Java 语法的"基本词汇量"------有了它你才能开始写真正的程序。很多初学者在这里栽跟头不是因为智商不行，而是被一大堆名词（整型字面值、浮点型、强制转换、自动转换）给吓住了。其实这些概念只需要一点点拆解就能彻底搞懂。

这篇文章只做一件事：把你从 HelloWorld 阶段接出来，用最直白的语言带你过完 Java 常量和变量的全部核心知识，并且让每一种类型的声明和转换你都能自己写出来。

1 ~> 标识符与关键字

1.1 标识符

标识符就是你给变量、方法、类取的名字。 写 Java 代码的过程，本质上就是不停地起名字。

比如下面这段代码中，加粗的部分全是标识符：

java 复制代码

public class HelloWorld {              // HelloWorld ------ 类名
    public static void main(String[] args) {  // main ------ 方法名  args ------ 参数名
        int studentAge = 20;          // studentAge ------ 变量名
        String studentName = "张三";  // studentName ------ 变量名
    }
}

标识符的命名规则（硬性规定，违反就编译报错）：

规则	示例（✅ 正确）	示例（❌ 错误）
由字母、数字、下划线 `_`、美元符 `$` 组成	`age`, `studentName`	`stu-name`（含 `-`）
不能以数字开头	`name1`, `_value`	`1name`（数字开头）
不能是关键字	`myClass`	`class`（Java 关键字）
区分大小写	`age` 和 `Age` 是两个不同的标识符	---

命名没有长度限制，但一般不建议太长。 你写一个 50 个字符的变量名也能编译通过，但谁看了都想打你。

1.2 关键字

关键字是 Java 语言本身保留的词汇，你不能再拿它们来命名。

Java 中的常见关键字（初学先记住这些）：

类别	关键字	初学阶段见到的频率
类型声明	`class`、`interface`、`enum`	⭐⭐⭐
访问修饰符	`public`、`private`、`protected`	⭐⭐⭐⭐⭐
静态/抽象	`static`、`abstract`、`final`	⭐⭐⭐⭐
数据类型	`int`、`double`、`char`、`boolean`、`void`	⭐⭐⭐⭐⭐
控制语句	`if`、`else`、`for`、`while`、`return`	⭐⭐⭐⭐⭐
包和导入	`package`、`import`	⭐⭐⭐⭐

初学阶段不用背全部关键字列表，写代码时如果 IDE 把你起的名字标红了，大概率是撞了关键字。

2 ~> 变量------存储数据的容器

2.1 什么是变量（生活中的类比）

变量就是内存中一块有名字的空间，用来存数据。

你用手机银行查余额：

复制代码

余额 = 1000   （存了一个整数 1000）

下个月发工资了，余额变成 5000------数字变了，但"余额"这个名字没变。这就是变量的本质：名字不变，值可以变。

2.2 变量的三要素

Java 中声明一个变量，必须指定三样东西：

java 复制代码

int  age  =  20;
↑    ↑      ↑
类型  名字   值

要素	说明	示例
数据类型	决定这块内存能存什么（整数？小数？文字？）	`int`
变量名	符合标识符规则的名称	`age`
初始值	一开始放进去的数据	`20`

2.3 变量声明的几种方式

java 复制代码

// 方式一：先声明，再赋值
int age;
age = 20;

// 方式二：声明的同时赋值（最常用）
int score = 95;

// 方式三：一行声明多个同类型变量
int x = 10, y = 20, z = 30;

// 方式四：一行声明，分开赋值（不推荐，可读性差）
int a, b, c;
a = 1;
b = 2;
c = 3;

2.4 变量的命名推荐规范（驼峰命名法）

Java 社区约定俗成的命名风格：

元素	命名风格	示例
变量名	首单词小写，后面单词首字母大写（驼峰）	`studentName`、`maxValue`
类名	每个单词首字母都大写（帕斯卡）	`HelloWorld`、`StudentManager`
常量名	全大写，单词间用下划线	`MAX_VALUE`、`PI`
方法名	跟变量名一样，小驼峰	`getName()`、`setAge()`

不按这个规范写不会报错，但别人看你的代码会皱眉。团队协作时命名规范就是代码的门面。

3 ~> 数据类型一览

3.1 Java 中的数据类型分类

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

bash 复制代码

Java 数据类型
├─ 基本数据类型（八种）
│  ├─ 整型：byte / short / int / long
│  ├─ 浮点型：float / double
│  ├─ 字符型：char
│  └─ 布尔型：boolean
└─ 引用数据类型
   ├─ 类（class）
   ├─ 接口（interface）
   ├─ 数组（array）
   └─ String（字符串）

3.2 八种基本数据类型速查表

类型	大小	取值范围	默认值	示例
`byte`	1字节	-128 ~ 127	0	`byte b = 100;`
`short`	2字节	-32768 ~ 32767	0	`short s = 200;`
`int`	4字节	-21亿 ~ 21亿	0	`int age = 20;`
`long`	8字节	-9e18 ~ 9e18	0L	`long l = 100L;`
`float`	4字节	±3.4e-38 ~ ±3.4e+38	0.0f	`float f = 3.14f;`
`double`	8字节	±1.7e-308 ~ ±1.7e+308	0.0d	`double d = 3.14;`
`char`	2字节	0 ~ 65535（Unicode）	'\u0000'	`char c = 'A';`
`boolean`	1位	`true` / `false`	`false`	`boolean flag = true;`

日常开发中，整数用 int ，小数用 double ，字符用 char ，判断用 boolean。这四个就够了，其他四种（byte/short/long/float）有特定场景才用。

4 ~> 整型字面值及变量声明

4.1 整型的四种写法

Java 中整数默认是 int 类型。下面四种进制都可以用来表示整数：

java 复制代码

int a = 100;        // 十进制（日常写法）
int b = 0144;       // 八进制（以 0 开头）
int c = 0x64;       // 十六进制（以 0x 开头）
int d = 0b01100100; // 二进制（以 0b 开头，JDK 7 以上支持）

// 四个变量值完全相等，都是 100

进制	前缀	构成字符	示例
十进制	无	0-9	`100`
八进制	`0`	0-7	`0144`
十六进制	`0x`	0-9, A-F	`0x64`
二进制	`0b`	0-1	`0b01100100`

4.2 long 类型的声明

声明 long 类型需要在数字后加 L 或 l（推荐大写 L，小写 l 容易看成 1）：

java 复制代码

long population = 8000000000L;  // 超过 int 范围，必须加 L
long normal     = 100L;         // 没超 int 范围，但依然标注 L 更清晰

4.3 整型变量赋值常见错误

java 复制代码

byte b1 = 127;     // ✅ 在 -128~127 范围内，OK
byte b2 = 128;     // ❌ 编译报错：超出 byte 范围

int i1 = 2147483647;   // ✅ int 最大值
int i2 = 2147483648;   // ❌ 编译报错：超出 int 范围

long l1 = 8000000000;  // ❌ 编译报错：数字默认是 int，值本身超出 int 范围
long l2 = 8000000000L; // ✅ 加 L 告诉编译器这是 long

第三条很容易中招： 数字字面值默认是 int 类型，如果写的数字超过了 int 的范围（约 21 亿），编译就直接报错，跟左边写 long 无关。解决方案就是加 L。

5 ~> 浮点型字面值

5.1 float 和 double

Java 中，小数默认是 double 类型。要声明 float 必须加 f 或 F。

java 复制代码

double pi = 3.141592653589793;  // 默认 double，不用加后缀
float  pi2 = 3.14f;             // 必须加 f，否则编译报错

类型	大小	精度（有效数字）	后缀	适用场景
`float`	4字节	约 7 位	`f` / `F`	精度要求不高的场景
`double`	8字节	约 15 位	可不加	日常开发首选

日常编程默认用 double 就行，float 主要用于内存敏感的场景（比如嵌入式开发）。Android 中对内存要求较高，某些场景会用 float，但初学阶段不必纠结。

5.2 浮点数的科学计数法

java 复制代码

double d1 = 1.2e3;   // 1.2 × 10³ = 1200.0
double d2 = 1.2e-3;  // 1.2 × 10⁻³ = 0.0012

5.3 浮点数案例：精度丢失问题

浮点数运算可能会产生精度丢失，这是所有编程语言都有的问题（由 IEEE 754 标准导致）：

java 复制代码

System.out.println(0.1 + 0.2);  // 输出 0.30000000000000004，不是 0.3
System.out.println(1.0 - 0.9);  // 输出 0.09999999999999998，不是 0.1

为什么？ 十进制的小数在二进制中可能是无限循环小数，只能用近似值存储。初学知道这回事就行，后面学 BigDecimal 再解决精确计算的问题。日常开发中这点误差通常不影响使用。

6 ~> 字符型字面值

6.1 char 类型

Java 中 char 占 2 个字节，使用 Unicode 编码，可以表示中文等任何语言字符。

java 复制代码

char c1 = 'A';           // 英文字母
char c2 = '中';          // 中文字符（Java 完全支持）
char c3 = '9';           // 注意：这是字符 '9'，不是数字 9
char c4 = '\n';          // 转义字符：换行符
char c5 = '\u0041';      // Unicode 表示法（'\u0041' = 'A'）

char 使用单引号 ' '，一个 char 只能放一个字符。不要用双引号------那是 String 的地盘。

6.2 常用转义字符

转义字符	含义	常用场景
`\n`	换行	输出多行文本
`\t`	制表符（Tab）	对齐输出
`\\`	反斜杠本身	文件路径
`\'`	单引号	在单引号内表示单引号
`\"`	双引号	在字符串内放双引号

java 复制代码

System.out.println("第一行\n第二行");
// 输出：
// 第一行
// 第二行

System.out.println("文件路径：C:\\Users\\源码骑士");
// 输出：文件路径：C:\Users\源码骑士

7 ~> 布尔类型和字符串的字面值

7.1 boolean 类型

Java 的 boolean 只有两个值：true 和 false。不能像 C 语言那样用 0/1 代替。

java 复制代码

boolean flag1 = true;
boolean flag2 = false;

// ❌ 下面这些在 Java 中都是编译错误：
// boolean x = 1;
// boolean y = 0;

// 常用于条件判断
boolean isStudent = true;
if (isStudent) {
    System.out.println("享受学生优惠");
}

7.2 String 类型（初识）

String 不是基本类型，它是引用类型，但因为它太常用了，初学阶段可以把它当作"能存一串文字的变量类型"来理解。

java 复制代码

String name = "源码骑士";         // 双引号
String empty = "";                // 空字符串（不是 null）
String message = "你好，" + name + "！";  // 用 + 拼接字符串

String 用双引号 " "，char 用单引号 ' '。初学阶段最容易犯的错就是 char c = "A"; ------ 编译直接报错。

8 ~> 常量

8.1 什么是常量

常量就是用 final 关键字修饰的变量，一旦赋值就不能再改。

java 复制代码

final double PI = 3.1415926535;
PI = 3.14;  // ❌ 编译报错：不能给 final 变量重新赋值

对比	变量	常量
声明方式	`int age = 20;`	`final int MAX_AGE = 150;`
值能不能改	✅ 可以多次赋值	❌ 只能赋值一次
命名规范	小驼峰 `studentAge`	全大写 `MAX_AGE`

8.2 为什么需要常量

场景一：避免魔法数字

java 复制代码

// ❌ 没有常量------3.14 是什么？为什么是 3.14？
double area = 3.14 * radius * radius;

// ✅ 有常量------一看就知道 PI 是圆周率
final double PI = 3.1415926535;
double area = PI * radius * radius;

场景二：统一管理可配置的值

java 复制代码

final int MAX_RETRY_COUNT = 3;
final long CONNECT_TIMEOUT = 5000;  // 毫秒
final String DEFAULT_ENCODING = "UTF-8";

把可能改动的值抽成常量集中管理，是编程从"能跑就行"迈向"可维护"的标志。这也是 Framework 层源码中的标准做法。

9 ~> 数据类型转换

9.1 为什么需要类型转换

因为 Java 是强类型语言------每个变量在声明时必须明确类型，不同类型之间不能随便混用。

java 复制代码

int age = 20;
double price = 9.9;

// age + price 的结果是什么类型？int 还是 double？
// 答案：double ------ 这就是自动类型转换
System.out.println(age + price);  // 输出 29.9

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

规则：把小范围的类型赋值给大范围的类型时，自动转换，不会丢失数据。

java 复制代码

byte  →  short  →  int  →  long  →  float  →  double
       ↑
      char

java 复制代码

byte b = 10;
int i = b;          // ✅ byte → int，自动转换，不丢数据

int x = 100;
long y = x;         // ✅ int → long，自动转换

long m = 200L;
float n = m;        // ✅ long → float，自动转换（可能有精度损失）

注意：long（8字节）→ float（4字节）虽然是"大范围→小范围"的字节数变化，但 float 的表示范围更大，所以也是自动转换。不过这个转换可能导致精度损失。

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

规则：把大范围的类型赋值给小范围的类型时，必须手动强制转换，可能丢失数据。

java 复制代码

double pi = 3.14159;
int intPi = (int) pi;     // 强制转换：小数部分被砍掉
System.out.println(intPi); // 输出 3


long bigNum = 130L;
byte smallNum = (byte) bigNum;  // 超过 byte 范围，数据溢出
System.out.println(smallNum);   // 输出 -126（溢出后环绕的结果）

强制转换语法：

java 复制代码

目标类型 变量名 = (目标类型) 原变量;

// 示例
double d = 9.99;
int i = (int) d;  // 9（小数部分截断，不是四舍五入）

9.4 类型转换经典案例

java 复制代码

public class TypeConvertDemo {
    public static void main(String[] args) {
        
        // 案例一：整数除法
        int a = 5;
        int b = 2;
        System.out.println(a / b);       // 输出 2（不是 2.5！整数/整数=整数）
        System.out.println(5.0 / 2);     // 输出 2.5（只要有浮点数参与就是小数除法）
        System.out.println((double)a / b); // 输出 2.5（强制转换其中一个操作数）
        

        // 案例二：byte/short/char 运算时自动提升为 int
        byte x = 10;
        byte y = 20;
        // byte z = x + y;  // ❌ 编译报错：x+y 的结果是 int 类型
        int z = x + y;      // ✅ 必须用 int 接收
        

        // 案例三：char 和 int 的互相转换
        char ch = 'A';
        int code = ch;          // char → int：得到 Unicode 编码 65
        System.out.println(code);
        
        char next = (char)(ch + 1);  // int → char 需要强制转换
        System.out.println(next);    // 输出 'B'
    }
}

10 ~> 局部变量的存储方式

10.1 变量存在哪

当你在方法里声明一个变量时：

java 复制代码

public static void main(String[] args) {
    int age = 20;      // 这个 age 存在哪里？
    String name = "源码骑士";
}

这个 age 和 name 存在 JVM 的**栈内存（Stack）**中。方法执行完，这些变量就自动释放了。

内存区域	存什么	生命周期
栈（Stack）	局部变量、方法参数	方法执行期间，执行完就释放
堆（Heap）	`new` 创建的对象、数组	由 GC 自动回收

初学阶段不需要深究 JVM 内存模型，知道"局部变量在方法执行完就没了"这个概念就够了。后面讲到面向对象时自然会深入理解。

11 ~> 常见编译运行错误

以下是根据教学 PDF 整理的初学阶段最高频的编译/运行错误：

编号	错误现象	错误原因	解决方案
1	`variable age might not have been initialized`	变量只声明没赋值就使用了	声明时赋初始值
2	`incompatible types: possible lossy conversion from double to int`	把大类型赋给小类型没加强制转换	加 `(int)` 或用对应类型接收
3	`integer number too large`	整数超过 int 范围（~21亿）	加 `L` 后缀
4	`unclosed character literal`	char 用了双引号 `"A"`	改成单引号 `'A'`
5	`cannot assign a value to final variable X`	给 final 常量重新赋值	去掉第二次赋值，或去掉 final
6	`bad operand types for binary operator '+'`	不同类型之间运算不兼容	先做类型转换

调试小贴士： 编译报错时，看错误消息的第一个单词和行号，绝大多数问题都能定位到。Java 的编译错误提示非常清晰，比运行时错误好排查一百倍。

思考 && 总结

本文系统讲解了 Java 常量和变量的核心知识，从标识符与关键字到八大基本数据类型再到类型转换，核心要点总结如下：

标识符与关键字： 标识符就是给变量、方法、类起的名字，命名规则是字母数字下划线，不能数字开头，不能是关键字。关键字是 Java 保留的词汇，初学阶段主要记住 public、static、class、int、double、boolean、void、if、for、return 这些。
变量的三要素： 类型 + 名字 + 值。声明方式有四种，推荐"声明同时赋值"（最简洁）。命名遵循小驼峰规范（studentName），类名用大驼峰（HelloWorld）。
八种基本数据类型： 整数用 int，小数用 double，字符用 char（单引号），判断用 boolean。小数默认 double，float 必须加 f 后缀；整数默认 int，long 必须加 L 后缀。byte/short/long/float 四个日常用得少，初学先掌握好 int/double/char/boolean。
常量： 用 final 修饰，一旦赋值不能改。常量命名全大写加下划线。用常量代替"魔法数字"是代码可维护性的基本要求。
数据类型转换： 自动转换是从小范围到大范围（安全，不丢数据）；强制转换是从大范围到小范围（必须写 (类型)，可能丢数据）。整数除法默认得整数，要得小数必须有一个操作数是浮点数。

把上面的代码每一段都敲一遍、跑一遍，用 System.out.println() 亲眼看看输出结果。变量和类型是接下来所有代码的地基，地基打牢了，后面讲条件判断、循环、面向对象的时候才不会反复回来翻答案。

结尾

各位小伙伴，本文的内容到这里就全部结束了，源码骑士在这里再次感谢您的阅读！

源码骑士 --- Android Framework & 全栈开发

👀 关注：跟博主一起从源码视角深耕底层原理，见证每一次成长

❤️ 点赞：让优质内容被更多人看见，让知识传递更有力量

⭐ 收藏：把核心知识点存好，在需要时随时查、随时用

💬 评论：分享你的经验或疑问，评论区一起交流避坑

🔄 一键四连：不要忘记给博主"一键四连"哦！今日源码拆解达成！

🗡️ 寄语：技术之路难免有困惑，但同行的人会让前进更有方向

结语：希望对学习 Java 常量与变量的小伙伴有所帮助，这类知识记不住没关系，多练就熟了。不要忘记给博主"一键四连"哦！

往期回顾：

【1.Java基础】Java初识：从零搭建开发环境到写出第一个HelloWorld

【1.1Java基础】JDK安装常见问题教辅-从踩坑到排雷

【1.2Java基础】Win10环境变量配置详解-从原理到排雷