主题
Java变量、数据类型转换与运算符完全指南
目录
一、核心知识点
1. 常量
1.1 概述
在代码运行过程中，值不会发生改变的数据，也叫"字面值"。
1.2 分类
| 常量类型 | 表示方式 | 示例 | 说明 |
|---|---|---|---|
| 整数常量 | 直接写数字 | 10, -100, 0 | 所有整数 |
| 小数常量 | 带小数点 | 2.5, 3.14, 0.0 | 所有小数 |
| 字符常量 | 单引号'' | 'a', '中', ' ' | 单引号中必须有且只能有一个内容 |
| 字符串常量 | 双引号"" | "hello", "Java", "" | 双引号中可以写任意内容 |
| 布尔常量 | 直接写 | true, false | 用于判断 |
| 空常量 | null | null | 代表数据不存在，不能直接使用 |
1.3 重要注意事项
除法运算规则：
- 除号前后都是整数：结果只取整数部分，小数点直接舍去
- 除号前后有一个是小数：结果是正常小数
java
System.out.println(10/3); // 输出: 3
System.out.println(10.0/3); // 输出: 3.33333333333333351.4 转义字符
| 转义字符 | 说明 |
|---|---|
\n | 换行 |
\t | 制表符（Tab） |
\\ | 表示一个反斜杠 |
\" | 表示一个双引号 |
\' | 表示一个单引号 |
java
System.out.println("hello\nworld"); // 换行输出
System.out.println("hello\tworld"); // 带Tab输出
String path = "F:\\jdk\\bin"; // 表示路径2. 变量
2.1 概述
在代码运行过程中，值会随着不同情况随时发生改变的数据。
2.2 定义格式
java
// 格式1：定义单个变量
数据类型 变量名 = 值;
// 格式2：定义多个相同类型的变量
数据类型 变量名1 = 值1, 变量名2 = 值2;2.3 Java数据类型
基本数据类型（4类8种）：
| 类型 | 关键字 | 内存占用 | 取值范围 | 默认值 |
|---|---|---|---|---|
| 字节型 | byte | 1字节 | -128 至 127 | 0 |
| 短整型 | short | 2字节 | -32768 至 32767 | 0 |
| 整型 | int | 4字节 | -2³¹ 至 2³¹-1（约±21亿） | 0 |
| 长整型 | long | 8字节 | -2⁶³ 至 2⁶³-1（19位数字） | 0L |
| 单精度浮点数 | float | 4字节 | 1.4013E-45 至 3.4028E+38 | 0.0F |
| 双精度浮点数 | double | 8字节 | 4.9E-324 至 1.7977E+308 | 0.0 |
| 字符型 | char | 2字节 | 0 至 2¹⁶-1 | '\u0000' |
| 布尔型 | boolean | 1字节 | true, false | false |
引用数据类型：
- 类（class）
- 数组（array）
- 接口（interface）
- 枚举（enum）
- 注解（@interface）
- Record类
重要说明：
String属于类，是引用类型- 整数默认类型：
int - 小数默认类型：
double - 给
long赋值建议加L：long num = 100L; - 给
float赋值必须加F：float num = 10.5F;
2.4 取值范围排序（从小到大）
byte, short, char → int → long → float → double2.5 变量使用注意事项
- 同一作用域内不能定义重名变量
java
int i = 10;
// int i = 20; // 错误：重复定义
i = 20; // 正确：重新赋值- 不同作用域的访问规则
- 小作用域可以访问大作用域的变量
- 大作用域不能直接访问小作用域的变量
java
int i = 10;
{
int j = 100;
System.out.println(i); // 正确：可以访问外层变量
}
// System.out.println(j); // 错误：无法访问内层变量- 变量必须初始化才能使用
java
int x;
// System.out.println(x); // 错误：未初始化3. 标识符
3.1 概述
给类、变量、方法取的名字。
3.2 命名规则
硬性规定：
- 标识符不能是关键字
- 可以包含字母、数字、
_和$ - 不能以数字开头
- 区分大小写
软性建议：
- 类名：大驼峰式（每个单词首字母大写）
- 示例：
HelloWorld,StudentManager
- 示例：
- 方法名、变量名：小驼峰式（从第二个单词开始首字母大写）
- 示例：
maxAge,getStudentName
- 示例：
4. 数据类型转换
4.1 自动类型转换（小转大）
发生时机：
- 取值范围大的类型 变量名 = 取值范围小的类型
- 取值范围大的类型和取值范围小的类型做运算
java
// 示例1：小转大
long num1 = 100; // int → long
// 示例2：运算时自动转换
int a = 10;
double b = 2.5;
double sum = a + b; // int + double → double4.2 强制类型转换（大转小）
格式：
java
取值范围小的类型 变量名 = (取值范围小的类型)取值范围大的类型;示例：
java
int a = (int)2.5; // double → int，结果为24.3 强转注意事项
- 精度损失和数据溢出
java
int num = (int)10000000000L; // 溢出，结果：1410065408
int a = (int)2.9; // 精度损失，结果：2- byte和short的特殊情况
java
// 字面值不超范围，JVM自动强转
byte b1 = 10; // 正确
// 变量参与运算，需要手动强转
byte b2 = 10;
byte result = (byte)(b2 + 1); // 必须强转- char类型运算
java
char c = 'a';
System.out.println(c + 0); // 输出：97（ASCII码）
System.out.println('中' + 0); // 输出：20013（Unicode码）- 浮点数精度问题
java
// float和double不要直接做运算，会出现精度损失
float f = 0.1F;
double d = 0.1;
System.out.println(f == d); // false，精度不同5. 运算符
5.1 算术运算符
| 符号 | 说明 | 示例 |
|---|---|---|
+ | 加法 | 10 + 3 = 13 |
- | 减法 | 10 - 3 = 7 |
* | 乘法 | 10 * 3 = 30 |
/ | 除法 | 10 / 3 = 3 |
% | 取余 | 10 % 3 = 1 |
+的特殊用法：字符串拼接
java
int a = 10, b = 3;
System.out.println(a + b + ""); // "13"
System.out.println("" + a + b); // "103"
System.out.println("" + (a + b)); // "13"
System.out.println("结果：" + a); // "结果：10"5.2 自增自减运算符
| 格式 | 说明 |
|---|---|
变量++ | 先使用原值，再+1 |
++变量 | 先+1，再使用新值 |
变量-- | 先使用原值，再-1 |
--变量 | 先-1，再使用新值 |
使用规则：
- 单独使用：符号在前在后都一样，都是先运算
- 混合使用：
- 符号在前：先运算，再使用运算后的值
- 符号在后：先使用原值，再运算
java
int i = 10;
i++; // 单独使用，i变为11
int j = 10;
int result = ++j; // 混合使用，先+1再赋值，result=11, j=11
int k = 10;
int res = k++; // 混合使用，先赋值再+1，res=10, k=11开发建议：只使用单独使用的方式，避免混淆
5.3 赋值运算符
| 符号 | 说明 | 示例 |
|---|---|---|
= | 基本赋值 | int a = 10; |
+= | 加后赋值 | a += 3; 等价于 a = a + 3; |
-= | 减后赋值 | a -= 3; 等价于 a = a - 3; |
*= | 乘后赋值 | a *= 3; 等价于 a = a * 3; |
/= | 除后赋值 | a /= 3; 等价于 a = a / 3; |
%= | 取余后赋值 | a %= 3; 等价于 a = a % 3; |
重要特性：复合赋值运算符会自动强转
java
byte b = 10;
b += 1; // 等价于 b = (byte)(b + 1); 自动强转
System.out.println(b); // 输出：115.4 关系运算符（比较运算符）
| 符号 | 说明 | 示例 |
|---|---|---|
== | 判断是否相等 | 10 == 10 → true |
> | 判断是否大于 | 10 > 5 → true |
< | 判断是否小于 | 10 < 5 → false |
>= | 判断是否大于等于 | 10 >= 10 → true |
<= | 判断是否小于等于 | 10 <= 5 → false |
!= | 判断是否不相等 | 10 != 5 → true |
结果：都是boolean类型（true或false）
5.5 逻辑运算符
| 符号 | 说明 | 示例 |
|---|---|---|
&& | 与（并且） | 有假则假，全真才真 |
|| | 或（或者） | 有真则真，全假才假 |
! | 非（取反） | !true → false |
^ | 异或 | 相同为false，不同为true |
短路效果：
&&：如果前面为false，后面不判断||：如果前面为true，后面不判断
java
int a = 10, b = 20;
boolean result = ++a > 100 && ++b > 100;
// a=11, b=20（短路，b没有自增）实际应用：
java
int score = 60;
boolean valid = score >= 0 && score <= 100; // 判断分数是否在0-100之间5.6 三元运算符
格式：
java
boolean表达式 ? 表达式1 : 表达式2执行流程：
- 先判断boolean表达式
- 如果为true，执行表达式1
- 如果为false，执行表达式2
示例：
java
int a = 10, b = 20;
int max = a > b ? a : b; // 取最大值，结果：20
int score = 75;
String result = score >= 60 ? "及格" : "不及格"; // 结果："及格"
int week = 0;
System.out.println("周" + (week == 0 ? "日" : week)); // 处理周日特殊情况二、重点难点
1. 数据类型选择原则
| 场景 | 推荐类型 | 原因 |
|---|---|---|
| 整数 | int | 默认类型，范围够用 |
| 大整数 | long | 超过int范围时使用 |
| 小数 | double | 默认类型，精度更高 |
| 单字符 | char | 专门存储单个字符 |
| 判断 | boolean | 逻辑判断 |
| 字符串 | String | 多个字符 |
2. 类型转换核心规则
自动转换（隐式）：
byte, short, char → int → long → float → double强制转换（显式）：
- 可能损失精度
- 可能数据溢出
- 语法：
(目标类型)值
3. 运算符优先级（从高到低）
()小括号++--自增自减*/%乘除取余+-加减<<>>>>>位移<><=>=比较==!=相等判断&按位与^按位异或|按位或&&逻辑与||逻辑或?:三元运算符=+=-=赋值
建议：使用小括号明确优先级，避免混淆
4. 常见陷阱
陷阱1：整数除法
java
int a = 10, b = 3;
double result = a / b; // 结果：3.0，不是3.333...
// 正确写法：
double result = a * 1.0 / b; // 结果：3.333...陷阱2：自增自减混合使用
java
int i = 10;
i = i++; // 结果：10（先赋值再自增，自增后的值丢失）陷阱3：浮点数精度
java
double d1 = 0.1;
double d2 = 0.2;
System.out.println(d1 + d2); // 输出：0.30000000000000004陷阱4：byte/short运算
java
byte b1 = 10, b2 = 20;
byte b3 = b1 + b2; // 错误：需要强转
byte b3 = (byte)(b1 + b2); // 正确三、常见面试题
基础题 ⭐
1. Java的基本数据类型有哪些？String是基本数据类型吗？
答案： Java的基本数据类型有8种：
- 整型：byte, short, int, long
- 浮点型：float, double
- 字符型：char
- 布尔型：boolean
String不是基本数据类型，它是引用类型，属于类。
2. float f = 3.4; 是否正确？
答案： 不正确。3.4默认是double类型，不能直接赋值给float变量。
正确写法：
java
float f = 3.4F; // 或
float f = 3.4f;3. char型变量中是否可以存储一个汉字？
答案： 可以。char类型占2个字节，采用Unicode编码，可以存储一个汉字。
java
char c = '中';
System.out.println(c); // 输出：中4. 表达式 15/2*2 的值是多少？
答案： 结果是14。
解析：
java
15 / 2 = 7 // 整数除法，结果为7
7 * 2 = 14 // 最终结果进阶题 ⭐⭐
5. 下面代码的输出结果是什么？
java
int i = 1;
i *= 0.2;
System.out.println("i=" + i);答案： 输出：i=0
解析：
i *= 0.2等价于i = (int)(i * 0.2)1 * 0.2 = 0.2- 强制转换为int：
(int)0.2 = 0 - 复合赋值运算符会自动强转
6. 下面代码的输出结果是什么？
java
int a = 8, b = 3;
System.out.println(a >>> b);
System.out.println(a >>> b | 2);答案：
1
3解析：
a >>> b：8右移3位（无符号右移）- 8的二进制：0000 1000
- 右移3位：0000 0001 → 1
a >>> b | 2：1或2- 1的二进制：0001
- 2的二进制：0010
- 按位或：0011 → 3
7. 如何判断一个年份是否是闰年？
答案：
java
int year = 2024;
boolean isLeapYear = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
System.out.println(year + (isLeapYear ? "是闰年" : "不是闰年"));闰年判断标准：
- 能被4整除，但不能被100整除
- 或者能被400整除
8. 下面代码的输出结果是什么？
java
int i = 1;
int j = 5;
j *= i++ + j++;
System.out.println("i=" + i);
System.out.println("j=" + j);答案：
i=2
j=30解析：
i++：先使用i的值1，然后i变为2j++：先使用j的值5，然后j变为6i++ + j++= 1 + 5 = 6j *= 6→j = 6 * 6 = 30（注意此时j已经是6了）
高级题 ⭐⭐⭐
9. 为什么浮点数运算会有精度问题？如何解决？
答案：
原因： float和double采用IEEE 754标准，使用二进制浮点数表示，无法精确表示某些十进制小数。
示例：
java
System.out.println(0.1 + 0.2); // 0.30000000000000004
System.out.println(1.0 - 0.9); // 0.09999999999999998解决方案：
- 使用BigDecimal类
java
import java.math.BigDecimal;
BigDecimal bd1 = new BigDecimal("0.1");
BigDecimal bd2 = new BigDecimal("0.2");
BigDecimal result = bd1.add(bd2);
System.out.println(result); // 0.3- 使用整数运算（先乘后除）
java
int a = 10; // 代表0.10元
int b = 20; // 代表0.20元
int sum = a + b; // 30，代表0.30元10. byte b = 10; b = b + 1; 和 b += 1; 有什么区别？
答案：
区别：
java
byte b = 10;
b = b + 1; // 编译错误：需要强转
b += 1; // 正确：自动强转原因：
b + 1：byte会自动提升为int，结果是int类型，不能直接赋值给byteb += 1：复合赋值运算符会自动进行强制类型转换，等价于b = (byte)(b + 1)
正确写法：
java
byte b = 10;
b = (byte)(b + 1); // 手动强转
b += 1; // 自动强转11. 如何交换两个变量的值？有哪些方法？
答案：
方法1：使用第三方变量（推荐）
java
int a = 10, b = 20;
int temp = a;
a = b;
b = temp;方法2：使用加减法（可能溢出）
java
int a = 10, b = 20;
a = a + b; // a = 30
b = a - b; // b = 10
a = a - b; // a = 20方法3：使用异或运算（面试常考）
java
int a = 10, b = 20;
a = a ^ b; // a = 30
b = a ^ b; // b = 10
a = a ^ b; // a = 20方法4：使用三元运算符（不推荐，可读性差）
java
int a = 10, b = 20;
a = a + b - (b = a);12. & 和 && 有什么区别？
答案：
| 对比项 | & | && |
|---|---|---|
| 名称 | 逻辑与/按位与 | 短路与 |
| 短路效果 | 无 | 有 |
| 执行方式 | 两边都会判断 | 前面为false，后面不判断 |
| 使用场景 | 位运算 | 逻辑判断（推荐） |
示例：
java
int a = 10, b = 20;
// 使用 &
boolean r1 = (a > 100) & (b++ > 10);
System.out.println(b); // 21，b自增了
// 使用 &&
int c = 10, d = 20;
boolean r2 = (c > 100) && (d++ > 10);
System.out.println(d); // 20，短路，d没有自增开发建议：逻辑判断时使用 && 和 ||
四、实用代码片段
1. 变量定义与输出
java
public class PersonInfo {
public static void main(String[] args) {
String name = "张三";
char gender = '男';
int age = 25;
double height = 1.75;
double weight = 70.5;
System.out.println("姓名：" + name);
System.out.println("性别：" + gender);
System.out.println("年龄：" + age);
System.out.println("身高：" + height + "米");
System.out.println("体重：" + weight + "公斤");
}
}2. 数据类型转换示例
java
public class TypeConversion {
public static void main(String[] args) {
// 自动类型转换
int intValue = 100;
long longValue = intValue; // int → long
double doubleValue = longValue; // long → double
// 强制类型转换
double d = 3.9;
int i = (int)d; // 结果：3，精度损失
// byte和short的特殊情况
byte b1 = 10; // 字面值，自动强转
byte b2 = 20;
byte b3 = (byte)(b1 + b2); // 变量运算，手动强转
// char运算
char c = 'A';
System.out.println(c + 0); // 输出：65
System.out.println((char)(c + 32)); // 输出：a
}
}3. 运算符综合应用
java
public class OperatorDemo {
public static void main(String[] args) {
int a = 10, b = 3;
// 算术运算
System.out.println("加法：" + (a + b));
System.out.println("减法：" + (a - b));
System.out.println("乘法：" + (a * b));
System.out.println("除法：" + (a / b));
System.out.println("取余：" + (a % b));
// 自增自减
int i = 10;
i++;
System.out.println("i++后：" + i); // 11
// 三元运算符：求最大值
int max = a > b ? a : b;
System.out.println("最大值：" + max);
// 逻辑运算：判断分数是否有效
int score = 85;
boolean isValid = score >= 0 && score <= 100;
System.out.println("分数有效：" + isValid);
}
}4. 实际应用案例
案例1：计算天数和小时数
java
public class DayHourCalculator {
public static void main(String[] args) {
int totalHours = 89;
int days = totalHours / 24;
int hours = totalHours % 24;
System.out.println(totalHours + "小时 = " + days + "天" + hours + "小时");
// 输出：89小时 = 3天17小时
}
}案例2：计算100天后是周几
java
public class WeekCalculator {
public static void main(String[] args) {
int today = 2; // 今天是周二
int futureDays = 100;
int futureWeek = (today + futureDays) % 7;
String weekDay = futureWeek == 0 ? "日" : String.valueOf(futureWeek);
System.out.println("今天是周" + today + "，" + futureDays + "天后是周" + weekDay);
// 输出：今天是周2，100天后是周4
}
}案例3：求三个数的最大值
java
public class MaxOfThree {
public static void main(String[] args) {
int x = 3, y = 4, z = 1;
// 方法1：嵌套三元运算符
int max = (x > y ? x : y) > z ? (x > y ? x : y) : z;
System.out.println("最大值：" + max);
// 方法2：分步比较（推荐）
int max2 = x > y ? x : y;
max2 = max2 > z ? max2 : z;
System.out.println("最大值：" + max2);
}
}案例4：判断闰年
java
public class LeapYear {
public static void main(String[] args) {
int year = 2024;
boolean isLeap = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
System.out.println(year + (isLeap ? "是闰年" : "不是闰年"));
// 输出：2024是闰年
}
}案例5：华氏温度转摄氏温度
java
public class TemperatureConverter {
public static void main(String[] args) {
double fahrenheit = 80.0;
double celsius = (fahrenheit - 32) / 1.8;
System.out.println("华氏温度：" + fahrenheit + "°F");
System.out.println("摄氏温度：" + celsius + "°C");
// 输出：摄氏温度：26.666666666666668°C
}
}五、经典练习题
基础题
练习1：输出各种常量
要求： 输出字符串、字符、整数、小数、布尔类型常量
java
public class Test1 {
public static void main(String[] args) {
// 字符串常量
System.out.println("善学如春起之苗");
System.out.println("不见其增，日有所长");
// 字符常量
System.out.println('J');
System.out.println('A');
System.out.println('V');
System.out.println('A');
// 整数常量
System.out.println(100);
System.out.println(-200);
// 小数常量
System.out.println(3.14);
System.out.println(-9.8);
// 布尔常量
System.out.println(true);
System.out.println(false);
}
}练习2：定义各种类型的变量
要求： 定义byte、short、int、long、float、double、char、boolean类型变量并输出
java
public class Test2 {
public static void main(String[] args) {
byte byteVar = 127;
short shortVar = 30000;
int intVar = 100000;
long longVar = 10000000000L;
float floatVar = 3.14F;
double doubleVar = 3.141592653;
char charVar = 'A';
boolean booleanVar = true;
System.out.println("byte: " + byteVar);
System.out.println("short: " + shortVar);
System.out.println("int: " + intVar);
System.out.println("long: " + longVar);
System.out.println("float: " + floatVar);
System.out.println("double: " + doubleVar);
System.out.println("char: " + charVar);
System.out.println("boolean: " + booleanVar);
}
}练习3：交换两个变量的值
要求： 使用第三方变量交换两个整数变量的值
java
public class Test3 {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("交换前：a=" + a + ", b=" + b);
int temp = a;
a = b;
b = temp;
System.out.println("交换后：a=" + a + ", b=" + b);
}
}练习4：四则运算
要求： 计算两个整数的和、差、积、商
java
public class Test4 {
public static void main(String[] args) {
int x = 100;
int y = 200;
System.out.println("x + y = " + (x + y));
System.out.println("x - y = " + (x - y));
System.out.println("x * y = " + (x * y));
System.out.println("x / y = " + (x / y));
}
}进阶题
练习5：类型转换练习
要求： 理解byte、short、char类型运算时的类型转换
java
public class Test5 {
public static void main(String[] args) {
// byte运算
byte b1 = 10, b2 = 20;
byte b3 = (byte)(b1 + b2); // 需要强转
System.out.println("byte相加：" + b3);
// short运算
short s1 = 1000, s2 = 2000;
short s3 = (short)(s1 + s2); // 需要强转
System.out.println("short相加：" + s3);
// char运算
char c = 'a';
int i = 30;
int result = c - i; // char自动提升为int
System.out.println("char减int：" + result); // 97 - 30 = 67
}
}练习6：判断奇偶数
要求： 使用三元运算符判断一个数是奇数还是偶数
java
public class Test6 {
public static void main(String[] args) {
int num1 = 10;
int num2 = 11;
System.out.println(num1 + "是偶数？" + (num1 % 2 == 0));
System.out.println(num2 + "是奇数？" + (num2 % 2 != 0));
// 使用三元运算符
String result1 = num1 % 2 == 0 ? "偶数" : "奇数";
String result2 = num2 % 2 == 0 ? "偶数" : "奇数";
System.out.println(num1 + "是" + result1);
System.out.println(num2 + "是" + result2);
}
}练习7：计算天数和剩余小时
要求： 输入总小时数，计算是多少天零多少小时
java
public class Test7 {
public static void main(String[] args) {
int hours = 89;
int days = hours / 24;
int remainingHours = hours % 24;
System.out.println(hours + "小时 = " + days + "天" + remainingHours + "小时");
}
}练习8：计算未来周几
要求： 今天是周2，计算100天后是周几
java
public class Test8 {
public static void main(String[] args) {
int today = 2;
int futureDays = 100;
int futureWeek = (today + futureDays) % 7;
// 处理周日的特殊情况
String weekDay = futureWeek == 0 ? "日" : String.valueOf(futureWeek);
System.out.println("今天是周" + today + "，" + futureDays + "天后是周" + weekDay);
}
}练习9：求三个数的最大值
要求： 使用三元运算符求三个整数中的最大值
java
public class Test9 {
public static void main(String[] args) {
int x = 3, y = 4, z = 1;
// 先比较x和y，得到较大值
int max = x > y ? x : y;
// 再与z比较
max = max > z ? max : z;
System.out.println(x + ", " + y + ", " + z + "中的最大值是：" + max);
}
}练习10：判断闰年
要求： 判断给定年份是否是闰年
java
public class Test10 {
public static void main(String[] args) {
int year = 2024;
boolean isLeapYear = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
System.out.println(year + (isLeapYear ? "是闰年" : "不是闰年"));
}
}挑战题
练习11：温度转换
要求： 将华氏温度转换为摄氏温度 公式：C = (F - 32) / 1.8
java
public class Test11 {
public static void main(String[] args) {
double fahrenheit = 80.0;
double celsius = (fahrenheit - 32) / 1.8;
System.out.println("华氏温度：" + fahrenheit + "°F");
System.out.println("摄氏温度：" + String.format("%.2f", celsius) + "°C");
}
}练习12：复杂运算
要求： 分析下面代码的输出结果
java
public class Test12 {
public static void main(String[] args) {
int i = 1;
int j = 5;
j *= i++ + j++;
System.out.println("i = " + i); // i = 2
System.out.println("j = " + j); // j = 30
}
}解析：
i++：先使用i的值1，然后i变为2j++：先使用j的值5，然后j变为6i++ + j++= 1 + 5 = 6j *= 6→j = 6 * 6 = 30（注意此时j已经是6了）
六、学习建议
1. 学习路径
Day 1-2: 基础语法
├── 常量与变量
├── 数据类型
├── 标识符命名
├── 类型转换
└── 运算符
Day 3-4: 流程控制 [下一章预告]
├── if-else语句
├── switch语句
├── for循环
├── while循环
└── do-while循环2. 重点记忆内容
必须背诵：
- 8种基本数据类型及其取值范围
- 数据类型转换规则（小→大自动，大→小强转）
- 运算符优先级
- 标识符命名规则
必须理解：
- 变量的作用域
- 自增自减的使用
- 短路逻辑运算符
- 三元运算符的执行流程
3. 常见错误避免
| 错误类型 | 错误示例 | 正确写法 |
|---|---|---|
| float未加F | float f = 3.4; | float f = 3.4F; |
| long未加L | long l = 10000000000; | long l = 10000000000L; |
| byte运算未强转 | byte b = b1 + b2; | byte b = (byte)(b1 + b2); |
| 变量未初始化 | int x; System.out.println(x); | int x = 0; System.out.println(x); |
| 整数除法错误 | double d = 10 / 3; | double d = 10.0 / 3; |
4. 练习建议
基础练习（必须完成）：
- 定义各种类型的变量
- 进行类型转换操作
- 使用各种运算符
- 完成day01和day02的所有基础题目
进阶练习（推荐完成）：
- 分析复杂表达式的执行过程
- 编写实际应用案例
- 尝试优化代码
面试准备：
- 理解每个知识点的原理
- 能够清晰解释常见面试题
- 能够举一反三
5. 调试技巧
使用输出语句调试：
java
int a = 10, b = 20;
System.out.println("a = " + a + ", b = " + b);
System.out.println("a + b = " + (a + b));分步验证：
java
// 复杂表达式分步计算
int result = a + b * c - d / e;
// 拆分为：
int temp1 = b * c;
int temp2 = d / e;
int result = a + temp1 - temp2;
System.out.println("temp1=" + temp1 + ", temp2=" + temp2 + ", result=" + result);6. 编码规范
命名规范：
- 类名：大驼峰
StudentManager - 变量名：小驼峰
maxAge - 常量名：全大写+下划线
MAX_VALUE
代码规范：
- 一行只写一条语句
- 使用缩进保持代码层次清晰
- 适当添加注释
- 运算符两侧加空格
示例：
java
public class GoodExample {
public static void main(String[] args) {
// 定义变量
int maxAge = 100;
double avgScore = 85.5;
// 计算结果
int result = maxAge + 10;
// 输出结果
System.out.println("结果：" + result);
}
}7. 扩展学习方向
基于当前进度，下一阶段学习：
- 流程控制语句（if-else, switch, 循环）
- 数组的使用
- 方法的定义和调用
深入学习建议：
- 理解Java内存模型（栈、堆）
- 学习包装类（Integer, Double等）
- 了解自动装箱和拆箱
附录：快速参考表
数据类型速查表
| 类型 | 字节 | 位数 | 取值范围 | 默认值 |
|---|---|---|---|---|
| byte | 1 | 8 | -128 ~ 127 | 0 |
| short | 2 | 16 | -32768 ~ 32767 | 0 |
| int | 4 | 32 | -2³¹ ~ 2³¹-1 | 0 |
| long | 8 | 64 | -2⁶³ ~ 2⁶³-1 | 0L |
| float | 4 | 32 | ±3.4E38 | 0.0F |
| double | 8 | 64 | ±1.7E308 | 0.0 |
| char | 2 | 16 | 0 ~ 65535 | '\u0000' |
| boolean | 1 | 8 | true/false | false |
运算符速查表
| 类型 | 运算符 | 说明 |
|---|---|---|
| 算术 | + - * / % | 加减乘除取余 |
| 自增自减 | ++ -- | 自增自减 |
| 赋值 | = += -= *= /= %= | 赋值运算 |
| 关系 | == != > < >= <= | 比较运算 |
| 逻辑 | && || ! ^ | 逻辑运算 |
| 三元 | ? : | 条件运算 |
ASCII码表（常用）
| 字符 | ASCII值 |
|---|---|
| '0' - '9' | 48 - 57 |
| 'A' - 'Z' | 65 - 90 |
| 'a' - 'z' | 97 - 122 |
| '\n' | 10 |
| '\t' | 9 |
| ' ' | 32 |