JavaSE核心：面向对象+异常+IO实战指南(适配Java智能体开发---上)
模块一：Java基础语法与面向对象
一、前言
精准对接Java智能体岗位招聘需求，夯实Java基础能力，为后续框架学习、大模型调用及智能体开发打下基础，我制定了学习周期为6个月的学习计划，助力零基础同学获得有计划、有目标的定向学习。整个学习周期包括java智能体所有需要掌握知识，只要大家跟我一起坚持下来，掌握java智能体只能说是易如反掌！！！
首先进行的是JavaSE专项学习计划，大约一个月，我将在每周发表俩份学习记录分享，共八部，这就是传说中的”天龙八部“。本文主要讲解JavaSE核心知识点，摒弃Java相关其余内容，只进行针对性的快速学习。明确学习重点、合理分配时间，确保1个月内完成核心内容的整理与分享，既提升自身技术储备，也为同类学习者提供可参考的学习思路。
现在ai火热所以本文聚焦JavaSE模块一（基础语法与面向对象），详细拆解核心知识点，结合Java智能体开发场景补充实操案例，涵盖封装、继承、多态、异常、IO、泛型等重点内容。
适用人群：在校计算机专业学生、Java初学者、备战秋招Java智能体岗位的开发者
二、Java基础语法
2.1 数据类型与变量
2.1.1 8种基本数据类型详解：范围、默认值、使用场景
-
最小的单位是比特（bit），算取值范围为2的对应类型的比特次方除以二。比如byte有1个字节，4个比特，那么它的范围就是正负2的8次方除以二（正数包括0所以为127）。常用为int、double、boolean。
-
整型
-
浮点型：
-
布尔型：
-
字符型：
2.1.2 基本类型与引用类型的核心区别：存储位置（栈/堆）、默认值、赋值机制
-
下面一张表来说明基本类型与引用类型的核心区别
-
堆和栈是之后用到的内容，简单提到了解即可。
2.1.3 变量定义、初始化与作用域：语法规范、局部变量与成员变量的区别、初始化要求。
-
java语法规范有五条其中需要注意的是第2条，不可以用数字开头（1.由字母、数字、下划线、$ 组成。2.不能以数字开头。3.见名知意（推荐：
age、score、userName）。4.小驼峰命名法（studentName）。5.不能使用 Java 关键字（public、static、class等）） -
局部变量：定义在方法里代码块里，定义的时候需要赋值，作用于当前方法，方法执行完就销毁。
-
成员变量：定义在类里方法外，定义的时候不赋值也可以，作用于整个类，对象回收就消失。
-
Java代码分层图：类包括所有方法，各方法并列，内部有其他代码体。
-
-
以下为代码实例，多动手多实操，多敲代码，自然而然的就加强了。
-
public class VariableTest { // ==================== 成员变量（类里、方法外）==================== // 整数：默认 0 int age; // 字符串：默认 null String name; // 布尔：默认 false boolean flag; // ==================== 成员方法 ==================== public void test() { // ==================== 局部变量（方法里）==================== // 1. 定义局部变量（未赋值） int num; // 2. 局部变量必须赋值才能使用！否则编译报错 // System.out.println(num); // 报错！ // 3. 手动初始化后才能使用 num = 100; System.out.println("局部变量 num = " + num); // 4. 直接定义+初始化 int score = 90; System.out.println("局部变量 score = " + score); } // ==================== 主方法 ==================== public static void main(String[] args) { // 创建对象 VariableTest test = new VariableTest(); // 访问成员变量（不需要手动初始化，有默认值） System.out.println("成员变量 age 默认值：" + test.age); System.out.println("成员变量 name 默认值：" + test.name); System.out.println("成员变量 flag 默认值：" + test.flag); // 调用方法 test.test(); } }
2.1.4 类型转换：自动转换（隐式）与强制转换（显式），注意事项
a.自动类型转换（隐式转换）
自动类型转换是指程序在运行过程中由编译器自动完成，无需手动编写代码，满足条件时会直接进行类型提升。那么需要满足什么条件就可以自动转换呢？那就是两种数据类型彼此兼容或者目标类型的取值范围 > 原类型的取值范围（小赋大）。
byte→short→int→longfloat→doubleint可以自动转换为float/doubleint a = 100; long b = a; // int → long，自动转换 float c = b; // long → float，自动转换 double d = c; // float → double，自动转换
b.强制类型转换（显式转换）
-
当需要把大范围类型赋值给小范围类型时，编译器无法自动完成，必须手动强制转换。（一般情况下不会进行强制类型的转换，只有特殊情况才会用到强制类型转换）。
-
double num1 = 3.14; int num2 = (int) num1; // 强制将 double 转为 int -
需要注意的是强制转换可能造成精度丢失
-
double pi = 3.99; int i = (int) pi; // 结果：i = 3，小数部分直接舍弃，不是四舍五入 -
超出范围的转换会造成数据溢出
-
// 错误示例：int 最大值约 21 亿，强行赋更大值并强转会溢出 int maxInt = Integer.MAX_VALUE; long bigNum = maxInt + 10L; int errorNum = (int) bigNum; // 运行结果：errorNum 变为负数，数据完全错误
2.2 运算符与表达式
-
常用运算符分类详解：算术、关系、逻辑、赋值、三元运算符
-
算术运算符包括以下几个内容，其中重点分为%和++（--）的使用方法。对于%（取余）直接举例子，10%3的结果3余1那面这个式子的结果就是1。
-
-
如果++和--单独使用的话前置和后置完全一样，都是 +1 或 -1，例如5++那么结果就是6也与++5的结果相同。（--同理，所以只讨论++的使用方法）。当参与运算 / 赋值 / 输出时，前置（++i）：先自增 / 自减，再使用。后置（i++）：先使用原值，后自增 / 自减。代码举例：
-
public class OperatorTest { public static void main(String[] args) { // ============ 1. 后置 i++（先使用，后+1） ============ int a = 10; int b = a++; // 先把 a 的值 10 赋给 b，然后 a 再 +1 System.out.println("a++ 演示："); System.out.println("a = " + a); // 11 System.out.println("b = " + b); // 10 （易错点：很多人以为是11） System.out.println("-------------------"); // ============ 2. 前置 ++i（先+1，后使用） ============ int x = 10; int y = ++x; // x 先 +1 变成 11，再赋值给 y System.out.println("++x 演示："); System.out.println("x = " + x); // 11 System.out.println("y = " + y); // 11 System.out.println("-------------------"); // ============ 3. 自减 -- 同理 ============ int m = 5; int n = m--; // 先赋值，后-1 System.out.println("m-- 演示：n = " + n); // 5 System.out.println("++m 演示：n = " + --m); // 先-1=4，再输出 } }输出结果是：
-
关系运算符正常使用，没有需要注意的地方。关系运算符的结果为符合（true）和不符合（false）俩种情况。如下图所示，因为俩个数不相等所以直接输出false。
-
public class test{ public static void main(String [] args){ int a = 10; int b = 20; System.out.println(a == b); } } -
-
逻辑运算符，需要注意的是&&和&的区别（||和|同理），&&当左边为错的情况，右部不进行执行。而&无论通过左边能不能得出结果都会运行&左右俩个判断表达式。
-
-
public class ShortCircuitTest { public static void main(String[] args) { // ============ 1. && 短路：左边false，右边不执行 ============ int a = 1; // false && 任何 → 结果false，右边 a++ 不执行 if (false && (a++ > 0)) { } System.out.println("&& 短路后 a = " + a); // 1（没变，证明右边没执行） System.out.println("-------------------"); // ============ 2. || 短路：左边true，右边不执行 ============ int b = 1; // true || 任何 → 结果true，右边 b++ 不执行 if (true || (b++ > 0)) { } System.out.println("|| 短路后 b = " + b); // 1（没变，证明右边没执行） System.out.println("-------------------"); // ============ 对比：不短路 & | 会执行所有代码 ============ int c = 1; if (false & (c++ > 0)) { } System.out.println("& 不短路 c = " + c); // 2（执行了 c++） } } -
执行后的结果为：
-
赋值运算符
-
-
三元运算符，下图所示代码的阅读顺序为先看等号右边，当右边得到结果后将结果赋值给等号左边❓左边的式子结果如果是true那么就执行：左边的内容，如果是flase就相反。
-
int max = a > b ? a : b; -
2.3 流程控制语句
2.3.1 分支语句：if、if-else、if-else if-else
-
首先介绍if的简单使用。if的意思就是如果它的基本格式如下面代码所示.if后面括号内的条件表达式的结果一定是一个boolean类型的结果，如果是true就会执行大括号内的执行语句。如果是false就会跳过整个语句。如下方的示例，当 成绩大于等于60会输出成绩合格，如果小于60就不会输出东西。
-
// 语法 if (条件表达式) { 执行语句; } // 示例 int score = 80; if (score >= 60) { System.out.println("成绩合格"); } -
这个时候聪明的小伙伴想到了如果不符合不输出东西那么是不是对于判断是否执行增加了难度。没有错，聪明的你提前发现了if-else格式。具体内容如下图所示，当if后面的条件表达式的结果是false的时候就执行else后面大括号里面的内容。下面的示例代码执行如果，age大于等于18就会输出已成年，小于的话就会输出未成年。
-
// 语法 if (条件) { 语句1; } else { 语句2; } // 示例 int age = 18; if (age >= 18) { System.out.println("已成年"); } else { System.out.println("未成年"); } -
但是我们在平时的使用中，也经常遇到不是非A即B的情况，这个时候开动我们聪明的小脑筋就又发现了if-else if-....-else格式。它会从上到下依次对比条件语句，符合哪个就运行哪个下面的语句。，如果都不符合就输出else当中的语句。这样就可以满足大部分的常见场景了，遇到特殊情况我们也可以嵌套if进行解决问题，但是 一般都在3层之下。
-
if (条件1) { 语句1; } else if (条件2) { 语句2; } else { 语句n; } // 示例（成绩等级判断） int score = 85; if (score >= 90) { System.out.println("优秀"); } else if (score >= 80) { System.out.println("良好"); } else if (score >= 60) { System.out.println("及格"); } else { System.out.println("不及格"); } // 输出：良好
2.3.2 选择语句：switch-case（语法、case穿透问题、break的使用）
-
switch 是 Java 中的多分支选择语句，用于根据变量值执行不同逻辑，结构清晰、适合多条件匹配。
-
基本格式：在 switch 中放入变量，通过 case 常量匹配分支，执行完逻辑加 break 跳出，default 处理不匹配情况。
-
使用要点：switch 支持 byte、short、int、char、String、枚举类型，不支持 long、float、double、boolean；case 后必须是常量且不能重复；break 用于防止 case 穿透，漏写会导致多个分支顺序执行；多个 case 共用逻辑时可合理省略 break。
-
switch (表达式) { // 表达式结果只能是指定类型 case 常量值1: 语句体1; break; // 跳出switch，非常重要 case 常量值2: 语句体2; break; ... default: 默认语句体; break; // 最后一个可以省略，但建议写上 }下面是case的穿透问题，在了解整个问题之前需要先了解break的作用，当遇到符合switch当中条件的case语句的时候就会执行：后面对应的代码，最后要以break为结尾用来结束当前的switch，如果没有break的话就会顺序执行下面的语句，一直到全部执行完或者遇到break才会停止。具体的代码如下图所示：（因为漏泄break产生的穿透问题）
-
public class SwitchErrorDemo { public static void main(String[] args) { int num = 1; switch (num) { case 1: System.out.println("星期一"); // 易错点：此处忘记写 break，产生穿透！ case 2: System.out.println("星期二"); case 3: System.out.println("星期三"); break; } } }执行结果：
-
break的正确使用。当遇到特殊使用情况如下面的代码例子，每周前五天都是工作日，所以可以直接让其穿透节省代码。（当然也可以简写为case 1，2，3：）
-
public class SwitchUseDemo { public static void main(String[] args) { int week = 3; switch (week) { case 1: case 2: case 3: case 4: case 5: System.out.println("工作日"); break; case 6: case 7: System.out.println("休息日"); break; } } }
2.3.3 循环语句：for、while、do-while
-
先来一个表格说明一下三种循环的区别。然后分别提供三种循环的例子代码
-
对比项 for 循环 while 循环 do-while 循环 语法结构 for(初始化;条件;更新){ 循环体 } 初始化; while(条件){ 循环体; 更新; } 初始化; do{ 循环体; 更新; }while(条件); 执行顺序 先判断条件，再执行循环体 先判断条件，再执行循环体 先执行一次循环体，再判断条件 循环次数 0 ~ N 次（条件不成立可以一次都不执行） 0 ~ N 次（条件不成立可以一次都不执行） 1 ~ N 次（至少执行一次） 适用场景 明确知道循环次数（如：遍历 1~100、数组遍历） 不知道循环次数，只知道结束条件（如：读取输入、文件读取） 必须先执行一次，再判断是否继续（如：菜单选择、登录验证） 变量作用域 变量仅在循环内有效，更规范 变量在循环外定义，循环内外都能用 变量在循环外定义，循环内外都能用 代码整洁度 结构最紧凑，初始化、条件、更新写在一起 结构松散，变量和循环分离 末尾必须带分号，容易写错 使用频率 最高（开发首选） 中等 较低
for循环：for 循环最适合知道循环次数的场景，把「从哪开始、到哪结束、每次怎么变」都写在小括号里，结构清晰。需要注意小括号里面需要填写三部分内容（定义变量；什么情况下继续进行循环；每次循环如何变）上面代码表示：从 1 开始，只要小于等于 5 就继续循环，每次循环后 i 加 1，所以会输出 1~5。注意每部分内容之间用分号分隔。
public class ForTest {
public static void main(String[] args) {
// 格式：for(初始值; 判断条件; 变化量)
for (int i = 1; i <= 5; i++) {
System.out.println("第" + i + "次循环");
}
}
}while循环：while 循环不知道循环次数，但知道什么时候停止时使用。先定义变量，再写判断条件，条件成立就执行循环体，最后一定要写变化语句，否则会变成死循环。用法简单，但变量、条件、变化是分开写的。
public class WhileTest {
public static void main(String[] args) {
int i = 1; // 先定义初始值
while (i <= 5) { // 判断条件
System.out.println("第" + i + "次循环");
i++; // 每次变化
}
}
}do - while循环：do-while 最大特点是：先执行一次循环体，再判断条件，所以至少会运行一次。先做事情，再判断要不要继续，非常适合菜单、登录这类场景。
public class DoWhileTest {
public static void main(String[] args) {
int i = 1;
do {
// 先执行一次
System.out.println("第" + i + "次循环");
i++;
} while (i <= 5); // 再判断
}
}2.4 基础语法实操Demo（完整代码，学练结合核心）
-
代码功能：简单计算程序+奇偶判断，整合变量、运算符、流程控制的使用（自身先独立编写，调试通过后，然后看我上传的带详细注释的代码）
// 导包：用于接收键盘输入
import java.util.Scanner;
/**
* 综合练习：简单计算器 + 奇偶判断
* 整合知识点：变量、运算符、分支语句、流程控制、键盘输入
*/
public class CalcDemo {
public static void main(String[] args) {
// 1. 创建Scanner对象，用于接收用户输入
Scanner sc = new Scanner(System.in);
// 友好提示
System.out.println("===== Java 综合练习：简单计算 + 奇偶判断 =====");
System.out.println("请按照提示输入数字，程序将自动计算并判断奇偶~\n");
// ===================== 2. 输入第一个数字 =====================
System.out.print("请输入第一个整数：");
int num1 = sc.nextInt(); // 定义变量num1，接收输入值
// ===================== 3. 输入第二个数字 =====================
System.out.print("请输入第二个整数：");
int num2 = sc.nextInt(); // 定义变量num2，接收输入值
System.out.println("---------------------------------------");
// ===================== 4. 算术计算（+ - *）=====================
int sum = num1 + num2; // 和
int sub = num1 - num2; // 差
int mul = num1 * num2; // 积
// 输出计算结果
System.out.println(num1 + " + " + num2 + " = " + sum);
System.out.println(num1 + " - " + num2 + " = " + sub);
System.out.println(num1 + " * " + num2 + " = " + mul);
System.out.println("---------------------------------------");
// ===================== 5. 判断奇偶（使用 % 取模运算符）=====================
// 判断第一个数
System.out.print(num1 + " 是：");
if (num1 % 2 == 0) {
System.out.println("偶数");
} else {
System.out.println("奇数");
}
// 判断第二个数
System.out.print(num2 + " 是：");
if (num2 % 2 == 0) {
System.out.println("偶数");
} else {
System.out.println("奇数");
}
// ===================== 6. 程序结束 =====================
System.out.println("---------------------------------------");
System.out.println("程序执行完毕！");
// 关闭输入流
sc.close();
}
}运行结果：
扩展问题：请修改代码，变为可多次计算不退出，只有达到某个情况才会退出的代码！
汇聚全球AI编程工具，助力开发者即刻编程。
更多推荐
16
0- 0
已为社区贡献3条内容
所有评论(0)