Java基础全套教程（二）—— 变量、数据类型、运算符

课程前言｜零基础必看：任何编程语言的核心逻辑都离不开存数据、算数据、控流程。本章讲解的变量、常量、数据类型、运算符，就是实现「存数据、算数据」的底层核心，是整个 Java 体系的基石。

如果把编写程序比作盖大楼：变量、数据类型、运算符是砖瓦（基础单元），下一章的流程控制语句是钢筋水泥（逻辑骨架）。只有吃透本章基础，后续的循环、分支、数组、面向对象才能快速上手。

本章知识点偏基础理论，不建议死记硬背、不建议过度钻牛角尖。核心学习思路：看懂规则、动手敲代码、记住坑点、后续实战反复巩固。

老鸟实战建议：零基础学习最大误区是“看懂就跳过、不敲代码、纠结细节”。正确方式：快速过概念、重点记规则、每段案例亲手运行，在实战中解决问题、提升能力。

2.1 计算机进制体系详解

进制是人类和计算机计数的通用规则，核心定义：基数为n，逢n进一。我们生活中默认使用十进制（0-9，逢十进一），而计算机硬件仅能识别两种物理状态，因此底层唯一使用二进制，同时为了简化二进制冗长的书写格式，开发中常使用八进制、十六进制辅助展示。

2.1.1 四大常用进制基础规则

1. 二进制（基数2）：仅包含 0、1 两个数码，逢二进一，计算机底层存储、运算、传输全部使用二进制，无例外。

2. 八进制（基数8）：包含 0-7 八个数码，逢八进一，Java 中八进制字面量以 0 开头。

3. 十进制（基数10）：包含 0-9 十个数码，逢十进一，是我们日常开发、生活默认使用的进制。

4. 十六进制（基数16）：包含 0-9、a-f（A-F）十六个数码，逢十六进一，Java 中以 0x/0X 开头，常用于内存地址、颜色编码、数据简写。

2.1.2 进制底层逻辑与应用场景

计算机所有数据（文字、图片、视频、音频、程序代码）落地到硬件层面，都是二进制 0 和 1 的组合。核心硬件映射关系：高电平=1、低电平=0，通电=1、断电=0，完美适配二进制双状态特性。

拓展认知：除了常用四进制，行业内还有26进制、32进制、36进制、62进制等自定义进制，多用于短链接生成、验证码加密、唯一ID精简等场景，日常开发可借助在线进制工具快速换算，无需手动计算。

在线进制转换工具：https://tool.lu/hexconvert/

2.1.3 0-15 进制完整对照表

0-15是进制转换的基础区间，熟练掌握可快速看懂底层数据编码：

十进制	二进制	八进制	十六进制
0	0	0	0
1	1	1	1
2	10	2	2
3	11	3	3
4	100	4	4
5	101	5	5
6	110	6	6
7	111	7	7
8	1000	10	8
9	1001	11	9
10	1010	12	a
11	1011	13	b
12	1100	14	c
13	1101	15	d
14	1110	16	e
15	1111	17	f

2.1.4 进制手动转换核心算法

1. 十进制整数转二进制：除2取余，逆序拼接

计算逻辑：将十进制数持续除以2，记录每一次的余数，直到商为0，最后将所有余数从最后一个到第一个倒序排列，即为对应二进制结果。

实操案例：十进制 43 转二进制，最终结果：101011

2. 二进制转十进制：按权展开求和

计算逻辑：二进制从右往左，位数从0开始计数，每一位数字 × 2的n次方，将所有结果累加，最终和为对应十进制数。

实操案例：二进制 1101 转十进制 = 1×2³ + 1×2² + 0×2¹ + 1×2⁰ = 13

2.2 Java 注释体系（规范级标准）

注释是用于代码说明、逻辑备注的文本内容，全程不参与编译、不影响程序运行、不会生成class字节码文件。规范的注释是区分新手和职业开发者的重要标准，便于团队协作、代码迭代、后期维护。

2.2.1 三类注释语法与适用场景

1. 单行注释 //：仅作用于当前行，适合单行代码、简单逻辑说明，日常使用频率最高。

2. 多行注释 / */*：可包裹多行文本，适合批量注释代码、大段逻辑说明，不支持嵌套注释。

3. 文档注释 / */**：专属高级注释，可添加作者、版本、功能、参数等标签，可通过工具自动生成项目API文档，多用于类、核心方法、全局常量。

2.2.2 全新注释演示案例

/**
 * 计算器简易测试类
 * 功能：演示加减基础运算与三种注释用法
 * @author Java零基础学习者
 * @version 1.0
 * @date 2026.05.12
 */
public class CalculatorDemo {
    public static void main(String[] args) {
        // 定义两个运算操作数
        int num1 = 28;
        int num2 = 12;

        /*
        执行基础数学运算
        包含加法、减法运算演示
        用于新手熟悉变量使用
        */
        int addResult = num1 + num2;
        int subResult = num1 - num2;

        // 控制台输出运算结果
        System.out.println("加法运算结果：" + addResult);
        System.out.println("减法运算结果：" + subResult);
    }
}

2.3 标识符与关键字（编码规范核心）

2.3.1 标识符定义

开发者在代码中自定义的所有名称统称为标识符，包含：类名、变量名、方法名、包名、常量名，是代码中最基础的命名单元。

2.3.2 标识符强制命名规则（必须遵守）

1. 首字符仅限：大小写字母、下划线(_)、美元符号($)，绝对不能以数字开头；

2. 首字符之后可由字母、数字、下划线、美元符号任意组合；

3. 严格区分大小写，name 和 Name 是两个完全不同的标识符；

4. 禁止使用 Java 内置关键字、保留字作为自定义名称。

2.3.3 行业统一编码规范（推荐强制执行）

1. 类名、接口名：大驼峰式，所有单词首字母大写，例：UserInfo、OrderManager、BookService；

2. 变量名、方法名：小驼峰式，首个单词全小写，后续单词首字母大写，例：userAge、getOrderInfo；

3. 常量名：全部大写，单词之间用下划线分隔，例：MAX_USER_NUM、DEFAULT_PASSWORD；

4. 包名：全部小写，多级包名用点分隔，禁止大写和驼峰；

5. 兼容中文命名，但企业开发严禁使用中文标识符，兼容性差、不规范、易报错。

2.3.4 合法与非法标识符实战对比

合法标识符（可正常编译运行）

int userAge = 18;
String _userName = "小明";
double $salary = 5200.5;
boolean isLogin = true;

非法标识符（编译直接报错）

int 3score = 90;     // 数字开头，非法
String user#name;    // 包含特殊符号，非法
double static = 3.14;// 使用关键字，非法

2.3.5 Java 全部关键字认知

Java 内置50个左右关键字，是系统预留、拥有特殊语法功能的单词，开发者无法自定义使用。无需死记，后续学习对应语法会自然掌握。

abstract、assert、boolean、break、byte、case、catch、char、class、const、continue、default、do、double、else、extends、final、finally、float、for、goto、if、implements、import、instanceof、int、interface、long、native、new、null、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while

新手提示：goto、const 是保留字，无实际语法作用，仅为语言兼容预留。

2.4 变量深度解析

2.4.1 变量本质与核心作用

变量是内存中一块可读写的存储空间，地址固定，存储的数据可以随时修改。程序运行时，所有临时数据都通过变量存储、读取、修改，是程序交互数据的核心载体。

Java是强类型语言，声明变量必须指定数据类型，数据类型直接决定变量占用的内存空间大小和数据取值范围。

2.4.2 变量的使用规范

变量使用三步法则：先声明、再初始化、最后使用。局部变量未手动初始化，编译器会直接报错，这是新手高频错误。

// 1. 单独声明变量（仅开辟内存空间，无数据）
String address;
// 2. 变量初始化（给空间赋值）
address = "湖北省武汉市";
// 3. 直接声明并初始化（企业开发推荐写法）
int studentNum = 45;
// 4. 同类型多变量声明
float height, weight;

2.4.3 变量分类、作用域与生命周期

根据声明位置、从属对象、销毁时机，变量分为三类，本章重点掌握局部变量，成员变量、静态变量面向对象阶段深入讲解：

变量类型	声明位置	从属对象	生命周期	初始化特性
局部变量	方法/代码块内部	从属当前方法/代码块	方法执行生效，执行结束立即释放内存	必须手动初始化
成员变量	类内、方法外	从属实例对象	对象创建生效，对象销毁失效	系统自动赋默认值
静态变量	类内、static修饰	从属当前类	类加载生效，项目运行常驻内存	系统自动赋默认值

2.4.4 局部变量正误案例演示

public class LocalVarDemo {
    public static void main(String[] args) {
        // 正确写法：初始化后再使用
        int score = 88;
        System.out.println("考试分数：" + score);

        // 错误写法：未初始化直接使用，编译报错
        // int num;
        // System.out.println(num);
    }
}

2.5 常量核心详解

常量是内存中一经赋值、全程不可修改的固定存储空间，用于存储项目中永久不变的数据，例如圆周率、系统默认参数、状态码、最大最小值等。

Java 使用 final 关键字定义常量，企业开发严格遵循「全大写、下划线分隔、见名知意」的命名规范。

2.5.1 常量语法与实战案例

public class ConstantDemo {
    public static void main(String[] args) {
        // 定义系统常量
        final double PI = 3.1415926535;
        final int MAX_STUDENT = 100;
        final String SYSTEM_NAME = "学生管理系统";

        // 使用常量计算圆周长
        double radius = 8;
        double circumference = 2 * PI * radius;
        System.out.println("圆的周长：" + circumference);
        System.out.println("系统最大容纳学生数：" + MAX_STUDENT);

        // 报错：常量不允许二次赋值修改
        // PI = 3.14;
    }
}

核心特点：常量赋值后无法修改，程序运行全程数值固定，安全性高、可读性强。

2.6 Java 八大基本数据类型

Java 数据类型分为基本数据类型和引用数据类型。八大基本数据类型是存储单个数值的基础类型，分为四类：整型、浮点型、字符型、布尔型。引用类型（字符串、数组、对象）后续章节详解。

2.6.1 四类八种基本数据类型总览

1. 整型（存储整数）

类型	字节数	取值范围	使用场景
byte	1	-128 ~ 127	字节流、文件传输、少量整数
short	2	-32768 ~ 32767	兼容老旧项目、节省内存
int	4	-2147483648 ~ 2147483647	日常整型默认首选
long	8	超大整数范围	时间戳、订单号、超大数值
重要规则：Java 整型字面量默认是 int 类型，定义 long 类型超大数值，必须后缀加大写 L，禁止小写l，避免和数字1混淆。

int pageNum = 10;
long timeStamp = 1752500000000L;

2. 浮点型（存储小数）

类型	字节数	精度	使用规范
float	4	7位有效数字	必须后缀 F/f
double	8	15-16位有效数字	浮点型默认首选
致命雷区：浮点型基于二进制存储，存在舍入误差，无法精准表示所有小数，绝对禁止使用 == 比较浮点数！高精度金融计算必须使用 BigDecimal。

float price = 12.9F;
double scoreAvg = 85.65;
double scienceNum = 2.5e2; // 科学计数法 250.0

3. 字符型 char

char 占用2个字节，基于 Unicode 万国码，支持全球所有语言文字、符号，使用单引号包裹单个字符，支持普通字符、Unicode编码、转义字符。

// 普通字符
char word = '天';
char letter = 'B';
// Unicode编码字符
char uniChar = '\u0058'; // 对应大写X
// 常用转义字符
char tab = '\t'; // 制表符
char enter = '\n'; // 换行符

4. 布尔型 boolean

boolean 仅有两个取值：true(真)、false(假)，用于逻辑判断、条件分支，不支持0、1替代，和C语言完全不同。单独使用占4字节，数组中单个元素占1字节。

boolean isSuccess = true;
boolean isFail = false;

if(isSuccess){
    System.out.println("程序执行成功");
}

2.7 数据类型转换

除 boolean 类型外，其余七种基本数据类型可相互转换，分为**自动类型转换（隐式）和强制类型转换（显式）**两种场景。

2.7.1 自动类型转换

核心规则：小容量类型自动兼容大容量类型，无精度丢失、无需手动处理，编译自动完成。

容量从小到大排序：byte < short < char < int < long < float < double

// int自动转为double
int num = 66;
double doubleNum = num;
System.out.println(doubleNum); // 输出66.0

2.7.2 强制类型转换

核心规则：大容量类型强制转为小容量类型，会丢失精度、数据截断，语法：(目标类型) 变量

// 小数强制转整数，直接舍弃小数部分
double num = 5.999;
int intNum = (int) num;
System.out.println(intNum); // 输出5

// 数值溢出案例
int bigValue = 130;
byte smallValue = (byte) bigValue;
System.out.println(smallValue); // 数值溢出，结果异常

2.7.3 数值运算溢出解决方案

整数运算默认以 int 类型计算，超大数值运算会出现溢出报错，解决方案：提前将其中一个数值转为大容量 long 类型，提升整体运算精度。

int totalNum = 999999999;
int count = 10;
// 错误：int运算溢出
// long result = totalNum * count;
// 正确：强制提升类型，避免溢出
long result = totalNum * (long)count;
System.out.println("计算结果：" + result);

2.8 Java 运算符全解

运算符是用于操作变量、完成数据运算和逻辑判断的核心工具，所有业务计算、条件筛选、数据处理都依赖运算符实现。

2.8.1 算术运算符

二元运算符：+、-、*、/、%（取模/取余）

一元运算符：++自增、–自减

核心规则：整数相除只保留整数位，取模结果符号跟随左侧数值，自增分先赋值后自增、先自增后赋值。

int a = 8;
int b = 3;
System.out.println(a / b); // 2 整数相除取整
System.out.println(a % b); // 2 取余

// 自增运算
int m = 5;
int n = m++; // 先赋值，n=5，m=6
int p = ++m; // 先自增，m=7，p=7

2.8.2 扩展赋值运算符

包含：+=、-=、*=、/=、%=，底层自带强制类型转换，代码简洁高效，企业开发高频使用。

int num = 20;
num += 10; // 等价于 num = num + 10
num *= 2 + 3; // 等价于 num = num * (2+3)

2.8.3 关系运算符

包含：>、<、>=、<=、==、!=，运算结果统一为 boolean 类型。

核心区分：= 是赋值运算符，== 是相等判断运算符，新手极易写错！

2.8.4 逻辑运算符

用于拼接多个条件，操作数和结果均为布尔值：&、&&、|、||、!、^

重点：**短路与&&、短路或||**具备短路特性，可提升效率、避免运算异常，开发优先使用。

// 短路与：左侧为false，右侧不执行，不会报错
boolean flag = 20 < 10 && 100 / 0 == 0;

2.8.5 位运算符

基于二进制位运算，运算效率极高，底层框架源码大量使用：~、&、|、^、<<、>>

快捷技巧：左移一位 ≈ 乘以2，右移一位 ≈ 除以2取整

2.8.6 三元运算符（条件运算符）

Java 唯一三元运算符，语法简洁，替代简单if-else分支：布尔表达式 ? 结果1 : 结果2

int age = 22;
String ageType = age >= 18 ? "成年人" : "未成年人";
System.out.println(ageType);

2.8.7 运算符优先级

无需死记硬背所有优先级，复杂表达式一律使用小括号区分运算顺序，保证代码可读性和运算准确性。核心优先级：括号 > 一元运算 > 算术运算 > 关系运算 > 逻辑运算 > 三元运算 > 赋值运算。

2.9 Scanner 键盘交互式编程

Scanner 是 Java 内置工具类，用于实现程序与用户的动态交互，可接收用户键盘输入的字符串、整数、小数，打破固定代码写死数据的局限，是入门交互编程必备技能。

2.9.1 全新实战案例

// 导入扫描器工具类
import java.util.Scanner;

public class ScannerInputDemo {
    public static void main(String[] args) {
        // 创建扫描器对象
        Scanner sc = new Scanner(System.in);

        // 接收用户输入的学生成绩信息
        System.out.print("请输入学生姓名：");
        String name = sc.next();

        System.out.print("请输入语文成绩：");
        double chinese = sc.nextDouble();

        System.out.print("请输入数学成绩：");
        double math = sc.nextDouble();

        // 计算平均分
        double avg = (chinese + math) / 2;
        System.out.println("=====成绩统计结果=====");
        System.out.println("学生：" + name);
        System.out.println("平均分：" + avg);

        // 关闭资源
        sc.close();
    }
}

2.10 本章重难点总结

1. 计算机底层基于二进制运算，掌握基础进制转换规则，会用工具即可；

2. 三类注释各司其职，规范注释是职业开发的基本素养；

3. 标识符严格遵守命名规则和驼峰规范，杜绝关键字、非法字符、数字开头；

4. 变量分三类，局部变量必须手动初始化，final 常量赋值后不可修改；

5. 八大基本类型区分内存大小、取值范围，浮点型禁止等值比较，长整型必须加L；

6. 数据转换分自动、强制，重点规避数值溢出、精度丢失问题；

7. 熟练掌握各类运算符，优先使用短路逻辑运算符，复杂运算用括号明确优先级；

8. 熟练使用 Scanner 实现键盘录入，实现程序动态数据交互。