一、数据类型：Java 的 “数据分类标准”
1.1 数据类型总览
- 介绍：Java 数据类型分为基本数据类型（直接存储数据值）和引用数据类型（存储对象内存地址），两者内存存储方式不同，决定了使用场景的差异。
- 作用：通过明确数据类型，约束变量存储的数据格式，避免数据混乱，同时优化内存占用（如用byte存储小范围整数，比int更省内存）。
- 核心点总结：
- 基本类型是 Java 语法的 “基础数据单元”，引用类型是基于基本类型构建的复杂数据结构；
- 基本类型的取值范围和字节数是固定的，需根据数据大小选择合适类型（如存储 “年龄” 用byte，存储 “身份证号” 用long）。
1.2 基本数据类型（4 类 8 种）
- 介绍：按功能分为整型、浮点型、字符型、布尔型，共 8 种具体类型，每种类型有固定的字节数和取值范围。
- 作用：满足不同场景下的数据存储需求（如整数用整型，小数用浮点型，逻辑判断用布尔型）。
- 使用方式代码与详情：
public static void main(String[] args) {
// 1. 整型（存储整数）
byte age = 25; // 1字节，范围：-128~127（适合小范围整数）
short height = 175; // 2字节，范围：-32768~32767
int score = 95; // 4字节，范围：-2³¹~2³¹-1（整数默认类型）
long id = 1234567890123L; // 8字节，范围：-2⁶³~2⁶³-1（需加L后缀）
// 2. 浮点型（存储小数）
float weight = 62.5f; // 4字节，单精度（需加f后缀）
double pi = 3.1415926; // 8字节，双精度（小数默认类型，精度更高）
// 3. 字符型（存储单个字符）
char gender = '男'; // 2字节，范围：0~65535（支持中文）
char letter = 'A'; // 对应ASCII码65
// 4. 布尔型（存储逻辑值）
boolean isPass = true; // 1字节，仅true/false两个值（用于判断）
// 输出验证
System.out.println("年龄：" + age);
System.out.println("圆周率：" + pi);
System.out.println("是否及格：" + isPass);
}
}
- 整型中int是默认类型，long需加L后缀（小写l易与1混淆，不推荐）；浮点型中double是默认类型，float需加f后缀；
- char类型本质是数值类型，可直接参与运算（如'A' + 1结果为 66，对应'B'）；
- boolean类型不能用 0/1 代替false/true，仅能存储逻辑值。
1.3 引用数据类型（以 String 为例）
- 介绍：String 是 Java 专门处理字符串的引用类型，字符串是 “多个字符的组合”，需用双引号包裹（如"Hello"）。
- 作用：存储文本信息（如用户名、地址），提供丰富的字符串处理方法（如截取、替换、判断相等）。
- 使用方式代码：
public static void main(String[] args) {
// 方式1：简化写法（推荐），字符串常量池存储（相同内容仅存一份，省内存）
String name1 = "Java编程";
String name2 = "Java编程";
}
二、类型转换：解决 “数据类型不匹配” 问题
2.1 自动类型转换（隐式转换）
- 介绍：当 “小范围类型数据” 赋值给 “大范围类型变量” 时，Java 自动完成转换，无需手动干预（如byte→int）。
- 作用：避免简单赋值场景的语法错误，简化代码编写（如无需手动转换byte到int）。
- 使用方式代码：
public static void main(String[] args) {
byte a = 10; // 小范围（1字节）
int b = a; // 自动转换：byte→int（4字节），无需手动处理
double c = b; // 自动转换：int→double（8字节）
System.out.println("b = " + b); // 10
System.out.println("c = " + c); // 10.0
// char与int的自动转换（char范围0~65535，int范围更大）
char ch = 'A';
int chValue = ch; // 自动转换：char→int，值为65
System.out.println("'A'对应的ASCII码：" + chValue);
}
- 自动转换的前提是 “小范围→大范围”，常见顺序：byte→short→int→long→float→double、char→int；
- char类型可自动转换为int（因char的取值范围在int的正区间内），但byte不能自动转换为char（byte有负值）。
2.2 表达式中的自动类型提升
- 介绍：在算术表达式中，所有变量会先提升到 “表达式中的最高类型”，再参与运算，结果类型与最高类型一致。
- 作用：避免运算过程中的数据溢出，保证运算精度（如byte参与运算时先转int，避免字节级运算溢出）。
- 使用方式代码：
public static void main(String[] args) {
// 示例1：byte+short→int
byte a = 5;
short b = 10;
// int c = a + b; // 正确：a和b先转int，结果为int
// byte d = a + b; // 错误：结果是int，不能直接赋值给byte
// 示例2：int+double→double
int num1 = 3;
double num2 = 2.5;
double result = num1 + num2; // 正确：num1先转double，结果为double
System.out.println("3 + 2.5 = " + result); // 5.5
// 示例3：char+int→int
char ch = 'a'; // ASCII码97
int sum = ch + 3; // ch先转int，结果为100（对应'd'）
System.out.println("'a' + 3 = " + sum + "（对应字符'd'）");
}
- 表达式提升的关键规则：byte/short/char参与运算时，先自动转为int；其他类型按 “范围从低到高” 提升到最高类型；
- 若需将表达式结果赋值给小范围类型，需手动强制转换（如byte d = (byte)(a + b)），但需注意数据溢出风险。
2.3 强制类型转换（显式转换）
- 介绍：当 “大范围类型数据” 赋值给 “小范围类型变量” 时，需手动指定目标类型（如double→int），可能导致精度损失或数据溢出。
- 作用：在明确数据范围可控的场景下，实现 “大范围→小范围” 的转换（如将double小数转为int整数）。
- 使用方式代码：
public static void main(String[] args) {
// 示例1：double→int（精度损失）
double price = 98.9;
int pay = (int) price; // 强制转换：丢弃小数部分，结果为98
System.out.println("支付金额（整数）：" + pay);
// 示例2：int→byte（数据溢出风险）
int num1 = 150; // int范围：-2147483648~2147483647
byte num2 = (byte) num1; // byte范围：-128~127，150超出范围，结果为-106（溢出）
System.out.println("int 150强制转为byte：" + num2);
// 示例3：表达式结果强制转换
int a = 10;
int b = 3;
double avg1 = a / b; // 3.0（int/int=int，再自动转double）
double avg2 = (double)a / b; // 3.333...（a先转double，结果为double）
System.out.println("10/3（int运算）：" + avg1);
System.out.println("10/3（强制转double）：" + avg2);
}
- 强制转换语法：目标类型 变量名 = (目标类型) 待转换数据;，括号不可省略；
- 风险提示：浮点型转整型会 “直接丢弃小数”（非四舍五入），若源数据超出目标类型范围，会导致数据溢出（结果为异常值），需谨慎使用；
- 优化建议：转换前可先判断数据范围（如if (num1 <= 127 && num1 >= -128)），避免溢出。
三、运算符：Java 的 “计算与判断工具”
3.1 算术运算符
- 介绍：用于实现基本的算术运算（加、减、乘、除、取余），其中+还可用于字符串连接。
- 作用：处理数值计算（如求总和、平均值）和字符串拼接（如拼接用户信息）。
- 使用方式代码：
public static void main(String[] args) {
// 1. 基本算术运算
int a = 10;
int b = 3;
System.out.println("a + b = " + (a + b)); // 13
System.out.println("a - b = " + (a - b)); // 7
System.out.println("a * b = " + (a * b)); // 30
System.out.println("a / b = " + (a / b)); // 3（整数相除，丢弃小数）
System.out.println("a % b = " + (a % b)); // 1（取余，结果符号与被除数一致）
// 2. 字符串连接（+两边有字符串则为连接符）
String name = "张三";
int age = 20;
System.out.println("姓名：" + name + "，年龄：" + age); // 姓名：张三，年龄：20
// 3. 数值拆分（取余+除法）
int num = 789;
int ge = num % 10; // 个位：9
int shi = num / 10 % 10; // 十位：8
int bai = num / 100; // 百位：7
System.out.println("三位数" + num + "拆分：百位" + bai + "，十位" + shi + "，个位" + ge);
}
- 整数相除（/）结果为整数，若需小数结果，需将其中一个操作数转为浮点型（如(double)a / b）；
- 取余（%）的结果符号与 “被除数” 一致（如-10 % 3 = -1，10 % -3 = 1）；
- +的双重作用：两边都是数值则为加法，有一个是字符串则为连接（如1 + "2" = "12"，而非3）。
3.2 自增自减运算符（++/--）
- 介绍：用于对变量值 “加 1”（++）或 “减 1”（--），分为 “前缀”（先变后用）和 “后缀”（先用后变）两种用法。
- 作用：简化变量自增 / 自减的代码（如i = i + 1可简写为i++），常用于循环变量更新。
- 使用方式代码：
public static void main(String[] args) {
// 1. 后缀自增（先用后变）
int num1 = 5;
System.out.println("num1++ = " + num1++); // 5（先输出5，再num1=6）
System.out.println("num1 = " + num1); // 6
// 2. 前缀自增（先变后用）
int num2 = 5;
System.out.println("++num2 = " + ++num2); // 6（先num2=6，再输出6）
System.out.println("num2 = " + num2); // 6
// 3. 自减示例（与自增逻辑一致）
int num3 = 5;
System.out.println("num3-- = " + num3--); // 5（先用后变，num3=4）
System.out.println("--num3 = " + --num3); // 3（先变后用，num3=3）
}
- 核心区别：后缀（变量++）是 “先使用变量当前值，再更新变量”；前缀（++变量）是 “先更新变量，再使用变量新值”；
- 注意事项：++/--只能用于变量（如5++错误），且不建议在复杂表达式中使用（如a = b++ + ++b，结果易混淆）。
3.3 赋值运算符
- 介绍：用于给变量赋值，分为 “基本赋值”（=）和 “复合赋值”（+=、-=等），复合赋值会自动进行强制转换。
- 作用：简化变量更新的代码（如a = a + 3可简写为a += 3），同时避免类型转换错误。
- 使用方式代码：
public static void main(String[] args) {
// 1. 基本赋值（=）
int x = 10;
System.out.println("x = " + x); // 10
// 2. 复合赋值（自动强制转换）
byte y = 5;
y += 3; // 等价于 y = (byte)(y + 3)，自动强制转换，避免错误
// y = y + 3; // 错误：y+3是int，不能直接赋值给byte
System.out.println("y += 3 后：" + y); // 8
int z = 20;
z -= 5; // 等价于 z = z - 5 → 15
z *= 2; // 等价于 z = z * 2 → 30
z /= 4; // 等价于 z = z / 4 → 7（整数相除）
z %= 3; // 等价于 z = z % 3 → 1
System.out.println("z经过一系列操作后：" + z); // 1
}
- 复合赋值运算符（+=、-=、*=、/=、%=）的优势：自动对结果进行强制转换，适合小范围类型变量更新；
- 基本赋值（=）的右结合性：如a = b = c = 5，从右到左执行，最终a、b、c均为 5。
3.4 关系运算符
- 介绍：用于判断两个数据的关系（大小、相等），结果仅为true（成立）或false（不成立），常用于分支和循环的条件判断。
- 作用：构建条件表达式（如score >= 60判断是否及格），控制程序流程。
- 使用方式代码：
public static void main(String[] args) {
int score = 85;
int passLine = 60;
// 关系运算结果为boolean
System.out.println("score > passLine：" + (score > passLine)); // true
System.out.println("score >= 90：" + (score >= 90)); // false
System.out.println("score == passLine：" + (score == passLine)); // false
System.out.println("score != passLine：" + (score != passLine)); // true
// 结合分支使用
if (score >= passLine) {
System.out.println("考试及格");
} else {
System.out.println("考试不及格");
}
// 注意：判断相等用==，不能用=（=是赋值）
int a = 5;
int b = 5;
// if (a = b) { ... } // 错误：a = b是赋值，结果为5（int），不能作为条件
if (a == b) {
System.out.println("a和b相等");
}
}
- 关系运算符的结果是boolean类型，只能用于条件判断（如if、while的条件）；
- 易错点：判断 “相等” 用==，单个=是赋值运算符（如if (a = b)是语法错误，因赋值结果是数值，非boolean）；
- 描述区间需用&&连接两个关系表达式（如score >= 60 && score <= 100，不能写60 <= score <= 100）。
3.5 逻辑运算符（处理 boolean 值）
- 介绍：用于对boolean类型的结果进行逻辑运算（与、或、非、异或），其中&&和||具有 “短路特性”。
- 作用：组合多个条件表达式（如 “年龄≥18 且身份证有效”），实现复杂逻辑判断。
- 使用方式代码：
public static void main(String[] args) {
int age = 20;
boolean hasId = true;
// 1. 逻辑与（&&）：两边都为true，结果才为true（短路：左边false则右边不执行）
boolean canVote = age >= 18 && hasId;
System.out.println("是否能投票：" + canVote); // true
// 2. 逻辑或（||）：两边有一个为true，结果就为true（短路：左边true则右边不执行）
boolean isAdult = age >= 18 || hasId;
System.out.println("是否成年：" + isAdult); // true
// 3. 逻辑非（!）：取反（true→false，false→true）
boolean isMinor = !isAdult;
System.out.println("是否未成年：" + isMinor); // false
// 4. 短路特性演示
int num = 5;
// &&短路：左边false，右边num++不执行，num仍为5
boolean flag1 = (num > 10) && (num++ > 0);
System.out.println("flag1 = " + flag1 + "，num = " + num); // false，5
// ||短路：左边true，右边num++不执行，num仍为5
boolean flag2 = (num < 10) || (num++ > 0);
System.out.println("flag2 = " + flag2 + "，num = " + num); // true，5
}
- 短路特性是&&和||的关键：&&左边为false时，右边表达式不执行；||左边为true时，右边表达式不执行（可提高效率，避免无效运算）；
- 逻辑非（!）是单目运算符，仅需一个操作数（如!hasId）；逻辑异或（^）较少用，规则是 “两边不同为true，相同为false”。
3.6 三元运算符
- 介绍：由 “条件表达式” 和 “两个结果值” 组成，是简化if-else的语法，格式为条件 ? 值1 : 值2。
- 作用：在 “二选一” 场景下简化代码（如 “判断及格与否，返回对应评语”），比if-else更简洁。
- 使用方式代码：
public static void main(String[] args) {
// 示例1：判断成绩是否及格，返回评语
int score = 75;
String result = score >= 60 ? "及格" : "不及格";
System.out.println("成绩评定：" + result); // 及格
// 示例2：求两个数的最大值
int num1 = 20;
int num2 = 35;
int max = num1 > num2 ? num1 : num2;
System.out.println(num1 + "和" + num2 + "的最大值：" + max); // 35
// 示例3：嵌套使用（不推荐，可读性低，复杂场景用if-else）
int score2 = 92;
String grade = score2 >= 90 ? "优秀" : (score2 >= 80 ? "良好" : "及格");
System.out.println("成绩等级：" + grade); // 优秀
}
- 执行逻辑：先判断条件，条件为true返回值1，为false返回值2；
- 语法要求：值1和值2必须为同一类型（或可自动转换为同一类型），如score >= 60 ? "及格" : 0是错误的（字符串与整数类型不匹配）；
- 使用建议：简单二选一场景用三元运算符，复杂逻辑（如嵌套超过 2 层）用if-else，保证代码可读性。
四、键盘录入：实现 “用户交互”
4.1 Scanner 类的作用与使用步骤
- 介绍：java.util.Scanner是 Java 提供的键盘录入工具类，用于获取用户从键盘输入的字符串、整数、小数等数据。
- 作用：实现程序与用户的交互（如让用户输入用户名、年龄），为动态数据处理提供输入支持。
- 使用方式代码（完整步骤）：
// 步骤1：导入Scanner类（JDK11+可省略，IDEA自动导入）
import java.util.Scanner;
public class ScannerDemo {
public static void main(String[] args) {
// 步骤2：创建Scanner对象（System.in表示从键盘输入）
Scanner sc = new Scanner(System.in);
// 步骤3：提示用户输入（提升用户体验，可选）
System.out.print("请输入您的姓名：");
// 步骤4：获取输入的字符串（next()：获取空格前的内容）
String name = sc.next();
System.out.print("请输入您的年龄：");
// 获取输入的整数
int age = sc.nextInt();
System.out.print("请输入您的身高（米）：");
// 获取输入的小数
double height = sc.nextDouble();
// 步骤5：使用输入的数据
System.out.println("\n=== 用户信息 ===");
System.out.println("姓名：" + name);
System.out.println("年龄：" + age + "岁");
System.out.println("身高：" + height + "米");
// 步骤6：关闭Scanner（释放资源，可选但推荐）
sc.close();
}
}
- 核心步骤：导包→创建对象→获取输入→使用数据→关闭对象；
- 常用获取方法：next()（字符串，空格截断）、nextInt()（整数）、nextDouble()（小数）、nextLine()（整行字符串，含空格）；
- 注意事项：nextInt()/nextDouble()后若直接用nextLine()，会读取到 “换行符”，需先调用sc.nextLine()清空换行符（如sc.nextInt(); sc.nextLine(); String addr = sc.nextLine();）。
五、常见错误与解决方案
浙公网安备 33010602011771号