经过一段时间的筹备，Cyber先锋社（Cyber Pioneer Club） 的官方博客今天正式创建并与大家见面！
Cyber先锋社是一支专注于网络安全与信息技术的学生技术社团。此前我们的动态散落在群通知和公众号里，从今天起，这个博客将成为社团的官方阵地——社团动态、活动通知、技术文章都会第一时间在这里发布，欢迎收藏我们的地址。
结合社团一直以来的活动方向，博客初期将围绕以下栏目更新：
如果你对网络安全、黑客技术充满好奇，想找到一群志同道合的技术伙伴——欢迎加入 Cyber先锋社！零基础也没关系，热情和坚持最重要。可以通过 关于页面 上的联系方式找到我们。
本站基于 Astro + Firefly 主题构建，源码托管在 GitHub，欢迎 Star 与共建。
这是本站的第一篇文章。博客刚起步，内容会逐步丰富，未来无限可能。
C++ 是一门”越学越值钱”的语言：操作系统、游戏引擎、数据库、高性能计算、嵌入式设备的底层几乎都由 C++ 驱动。它直接操作内存、贴近硬件，运行效率极高；同时现代 C++（11/17/20 标准）也提供了大量便利特性。
学 C++ 的过程能让你真正理解计算机是怎么工作的——这也是为什么很多高校把 C++ 作为第一门语言。相比 Python，它更严格，但也更锻炼基本功。
开始前先建立一个关键概念：
| Python | C++ | |
|---|---|---|
| 执行方式 | 解释器逐行执行 | 先编译成机器码，再运行 |
| 源文件 | .py | .cpp / .cc |
| 类型检查 | 运行时 | 编译时（更严格） |
| 运行速度 | 较慢 | 极快 |
写好的 C++ 代码不能直接运行，要经过 预处理 → 编译 → 汇编 → 链接 四步生成可执行文件。入门阶段不需要深究细节，只需知道：编辑器写代码，编译器造程序。
1pacman -S mingw-w64-ucrt-x86_64-gccC:\msys64\ucrt64\bin 加入系统 PATH1g++ --version推荐搭配 VS Code + C/C++ 扩展使用。也可以直接安装 Visual Studio Community（一体化但体积大）。
1xcode-select --install # 安装命令行工具（含 clang++）2clang++ --version1sudo apt update && sudo apt install build-essential2g++ --version新建 hello.cpp：
1#include <iostream> // 引入输入输出库2
3int main() { // main 函数：程序的入口4 std::cout << "Hello, Cyber先锋社!" << std::endl;5 return 0; // 返回 0 表示程序正常结束6}编译并运行：
1g++ hello.cpp -o hello # 编译，-o 指定输出文件名2./hello # 运行3Hello, Cyber先锋社!逐行解读：
#include <iostream>：预处理指令，引入标准输入输出流库int main()：每个 C++ 程序都从 main 函数开始执行，int 表示它返回一个整数std::cout：标准输出流对象，<< 把内容”流向”屏幕std::endl：换行符（并刷新缓冲区）return 0：向操作系统报告程序成功执行C++ 是静态类型语言，变量必须先声明类型：
1#include <iostream>2#include <string>3
4int main() {5 int age = 18; // 整数（通常 4 字节）6 double height = 1.75; // 双精度浮点数（8 字节）7 char grade = 'A'; // 单个字符，用单引号8 bool is_member = true; // 布尔值9 std::string name = "小明"; // 字符串（需 #include <string>）10
11 std::cout << "姓名: " << name << std::endl;12 std::cout << "年龄: " << age << std::endl;13 std::cout << "身高: " << height << std::endl;14 return 0;15}| 类型 | 字节 | 范围/说明 |
|---|---|---|
int | 4 | 约 ±21 亿 |
long long | 8 | 约 ±9.2×10¹⁸ |
double | 8 | 15~16 位有效数字 |
char | 1 | 单字符 |
bool | 1 | true / false |
std::string | 动态 | 任意长度文本 |
用 sizeof(类型) 可以查看字节数，如 std::cout << sizeof(int)。理解内存大小是 C++ 的基本功。
1#include <iostream>2#include <string>3
4int main() {5 std::string name;6 int age;7
8 std::cout << "输入你的姓名: ";9 std::cin >> name; // 从键盘读取10
11 std::cout << "输入你的年龄: ";12 std::cin >> age;13
14 std::cout << name << " 明年 " << age + 1 << " 岁" << std::endl;15 return 0;16}std::cin 与 std::cout 方向相反：>> 把输入”流入”变量。
每次写 std:: 很啰嗦，可以在文件开头声明：
1#include <iostream>2using namespace std; // 之后直接写 cout / cin / endl3
4int main() {5 cout << "简洁多了!" << endl;6 return 0;7}using namespace std 在大型工程中可能引发命名冲突，教学代码中用没问题，工程实践中建议保留 std:: 前缀或局部使用。
endl 与 \n 的用法3.14159 * r * r）cin 读入两个整数，输出它们的和、差、积g++ 源文件 -o 可执行文件 → ./可执行文件main 函数，return 0 表示正常结束int / double / char / bool / std::string 是五大基础类型std::cout << 输出、std::cin >> 输入，using namespace std 可简化书写下一篇：分支与循环 + vector 容器入门——写出真正有逻辑的程序。
本系列为 Cyber先锋社原创教程，参考业界通用知识体系编写。
上一篇搭好了环境、跑通了第一个程序。本篇把 C++ 的语法地基打牢：注释、变量细节、全部运算符与类型转换。C++ 是强类型语言，这些规则比 Python 严格得多，理解它们能少走很多弯路。
1// 单行注释：解释"为什么"而不是"是什么"2
3/*4 多行注释5 常用于文件头说明、暂时禁用大段代码6*/7
8/**9 * 文档注释（Doxygen 风格）10 * @brief 计算两数之和11 * @param a 加数12 * @param b 被加数13 * @return 和14 */15int add(int a, int b) {16 return a + b;17}1int a = 10; // 传统 C 风格（拷贝初始化）2int b(20); // 直接初始化3int c{30}; // 列表初始化（C++11，现代推荐）4
5// 列表初始化的杀手锏：禁止窄化转换（丢失精度直接报错）6int x{3.14}; // ❌ 编译错误！double → int 会丢失7int y = 3.14; // ⚠ 编译器仅警告，y = 3（静默截断）1int n; // ⚠ 值是随机的（栈上残留数据）！2std::cout << n; // 可能输出任何数3
4int m{}; // ✅ 值初始化为 0军规：定义变量时永远给初值，尤其是之后要累加的计数器。
1const double PI = 3.14159; // 运行时常量：定义后不可修改2PI = 3.14; // ❌ 编译错误3
4// 编译期常量（C++11）：值必须在编译期可计算，性能更好5constexpr int MAX_SIZE = 100;6constexpr double AREA = PI * 2; // ✓ 由编译期常量组合而来7
8int arr[MAX_SIZE]; // 数组大小需要编译期常量 ✓1typedef unsigned long ulong_t; // 传统写法2using score_t = double; // C++11 别名声明（推荐，更清晰）3
4score_t math = 95.5;5ulong_t big = 100000UL;1auto i = 42; // int2auto d = 3.14; // double3auto s = std::string("hi"); // std::string4auto v = std::vector<int>{1, 2, 3}; // 配合 STL 极大减少书写5
6// auto 用于复杂类型（迭代器）是真香现场：7std::vector<int> nums{1, 2, 3};8std::vector<int>::iterator it1 = nums.begin(); // 啰嗦9auto it2 = nums.begin(); // 优雅auto 是”让编译器推断类型”，不是”动态类型”——推断完成后类型就固定了，且 auto 变量必须有初始化。
1#include <iostream>2int main() {3 int a = 10, b = 3;4
5 std::cout << a + b << "\n"; // 136 std::cout << a - b << "\n"; // 77 std::cout << a * b << "\n"; // 308 std::cout << a / b << "\n"; // 3 ⚠ 整数除法，小数被截断！9 std::cout << a % b << "\n"; // 1 取模（两侧必须是整数）10 std::cout << 10.0 / 3 << "\n"; // 3.33333 有一侧是浮点就是浮点除法11
12 // ⚠⚠ 整数除法是 C++ 第一大坑：13 std::cout << 7 / 2 << "\n"; // 314 std::cout << -7 / 2 << "\n"; // -3（C++11 起向零取整）15 std::cout << 7 % -2 << "\n"; // 1（商向零取整，余数符号跟被除数）16
17 // 后缀/前缀 自增自减18 int i = 5;19 std::cout << i++ << "\n"; // 5（先用后加）20 std::cout << ++i << "\n"; // 7（先加后用）21 return 0;22}整数溢出（了解但重要）：
1int big = 2147483647; // int 最大值2big = big + 1; // 溢出！值回绕成 -2147483648（未定义行为的常见形式）3// 大数运算用 long long，检测用 <limits>4#include <limits>5std::cout << std::numeric_limits<int>::max() << "\n";1int a = 5, b = 10;2
3std::cout << (a > b) << "\n"; // 0 ⚠ 布尔值输出是 1/04std::cout << (a == b) << "\n"; // 05std::cout << std::boolalpha; // 切换为 true/false 输出6std::cout << (a < b) << "\n"; // true7
8// 逻辑：&& 且 || 或 ! 非9int age = 20;10bool has_id = true;11std::cout << (age >= 18 && has_id) << "\n"; // true12std::cout << !has_id << "\n"; // falseC++ 的布尔本质是 int（0 为假，非 0 为真）。经典错误：if (x = 5) 把比较写成赋值——条件永远为真，部分编译器加 -Wall 才会警告。
短路求值与 Python 一致：&& 左假右不算，|| 左真右不算。
1unsigned a = 0b1010; // 10（C++14 二进制字面量）2
3std::cout << (a & 0b0110) << "\n"; // 2 按位与4std::cout << (a | 0b0101) << "\n"; // 15 按位或5std::cout << (a ^ 0b1111) << "\n"; // 5 异或6std::cout << (~a) << "\n"; // 按位取反（含符号位）7std::cout << (a << 2) << "\n"; // 40 左移 = ×48std::cout << (a >> 1) << "\n"; // 5 右移 = ÷29
10// 实用技：11bool is_odd = a & 1; // 判奇偶12int half = a >> 1; // 快速除2（现代编译器会自动优化，写 / 2 更清晰）1int x = 10;2x += 5; // 153x -= 3; // 124x *= 2; // 245x /= 5; // 46x %= 3; // 17x <<= 2; // 4（位运算也有复合赋值）8
9int a, b, c;10a = (b = 1, c = 2, b + c); // 逗号表达式：依次求值取最后结果，a = 3（少用，可读性差）1int age = 20;2std::string s = (age >= 18) ? "成年" : "未成年";3
4std::cout << sizeof(int) << "\n"; // 4 字节5std::cout << sizeof(double) << "\n"; // 86std::cout << sizeof("hello") << "\n"; // 6（含 '\0'）7int arr[]{1, 2, 3};8std::cout << sizeof(arr) / sizeof(arr[0]); // 3 —— C 风格数组求长度1int i = 42;2double d = i; // ✓ int → double（安全提升）3int j = 3.99; // ⚠ double → int（窄化，j = 3）4
5char c = 'A';6std::cout << c + 1 << "\n"; // 66（char 提升为 int 参与运算）7std::cout << char(c + 1); // 'B'1double pi = 3.14;2
3// C 风格（能用但不推荐——一刀切，语义不明）4int a = (int)pi;5int b = int(pi);6
7// C++ 四种具名 cast：8int c1 = static_cast<int>(pi); // ① static_cast：常规数值转换（90%场景用它）9// ② dynamic_cast：继承体系安全向下转型（第十篇）10// ③ const_cast：去除 const（几乎不用）11// ④ reinterpret_cast：位模式重解释（底层操作，慎用）现代 C++ 建议：数值转换统一 static_cast<T>(x)，一眼看懂意图、便于搜索。
1#include <string>2
3int n = std::stoi("42"); // string → int4double d = std::stod("3.14"); // string → double5long l = std::stol("100000");6
7std::string s1 = std::to_string(42); // int → string8std::string s2 = std::to_string(3.14); // "3.140000"1#include <iostream>2#include <limits>3
4int main() {5 int n;6 std::cout << "输入一个数: ";7 while (!(std::cin >> n)) { // 输入失败（如输入字母）8 std::cin.clear(); // 清除错误标志9 std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 丢弃坏输入10 std::cout << "无效输入，请重新输入: ";11 }12 std::cout << "你输入了 " << n << "\n";13 return 0;14}这段”输入校验循环”是 C++ 命令行程序的标准配件，值得整段背下来。
体重/身高²，保留 1 位小数（std::fixed + std::setprecision(1)，需 <iomanip>）^）7/2*2 等于几？7.0/2*2 呢？先笔算再上机验证{} 值初始化最安全（禁窄化）；变量定义必给初值const 运行期常量、constexpr 编译期常量；using 别名优于 typedefauto 让编译器推断类型，配 STL 神器i++ vs ++i、= 与 == 是三大新手坑static_cast；字符串数值互转用 stoi/to_string下一篇：流程控制——分支、循环与 C++ 特有的范围 for。
本系列为 Cyber先锋社原创教程。整数除法与类型转换请亲手验证每个示例。
程序的三种结构：顺序、分支、循环。本篇讲全 C++ 的流程控制语法，与 Python 对比着学效率最高——逻辑相同，只是换了”语法外壳”。
1#include <iostream>2int main() {3 int score;4 std::cout << "输入成绩: ";5 std::cin >> score;6
7 if (score >= 90) {8 std::cout << "优秀\n";9 } else if (score >= 80) {10 std::cout << "良好\n";11 } else if (score >= 60) {12 std::cout << "及格\n";13 } else {14 std::cout << "不及格\n";15 }16 return 0;17}与 Python 的差异：条件必须带圆括号、代码块用花括号、else if 中间有空格。
当条件是”一个变量等于哪些值”时，switch 比 if 链清晰：
1#include <iostream>2int main() {3 char op;4 double a, b;5 std::cout << "输入: 数 运算符 数（如 3 + 4）: ";6 std::cin >> a >> op >> b;7
8 switch (op) {9 case '+':10 std::cout << a + b << "\n";11 break; // ⚠ 不写 break 会"贯穿"到下一分支！12 case '-':13 std::cout << a - b << "\n";14 break;15 case '*':16 std::cout << a * b << "\n";17 break;18 case '/':19 if (b != 0) std::cout << a / b << "\n";20 else std::cout << "除数不能为0\n";21 break;22 default: // 兜底分支23 std::cout << "不支持的运算符\n";24 }25 return 0;26}switch 的规矩：case 值必须是整数或枚举常量（不能是 double、不能是字符串）；每个分支末尾写 break，除非刻意利用贯穿。
忘 break 是 switch 第一大坑：
1int x = 1;2switch (x) {3 case 1: std::cout << "一"; // 输出"一二"——贯穿了！4 case 2: std::cout << "二"; break;5}1int a = 10, b = 20;2int max_val = (a > b) ? a : b;1#include <iostream>2int main() {3 int n, sum = 0;4 std::cout << "输入 n: ";5 std::cin >> n;6
7 int i = 1;8 while (i <= n) {9 sum += i;10 ++i; // 别忘了推进条件11 }12 std::cout << "1~" << n << " 的和是 " << sum << "\n";13 return 0;14}1int choice;2do {3 std::cout << "1.开始 2.设置 0.退出\n请选择: ";4 std::cin >> choice;5 // 处理 choice...6} while (choice != 0); // 注意末尾分号7
8// 至少执行一次——天然适合"菜单系统"1// 打印 1~10 的平方2for (int i = 1; i <= 10; ++i) {3 std::cout << i << "²= " << i * i << "\n";4}5
6// 死循环的两种写法7for (;;) { /* ... */ }8while (true) { /* ... */ }9
10// for 的三个部分都可空：分号不能省11int i = 0;12for (; i < 5;) {13 std::cout << i << " ";14 ++i;15}1#include <iostream>2#include <vector>3#include <string>4
5int main() {6 int arr[]{10, 20, 30, 40};7 for (int x : arr) // 遍历数组8 std::cout << x << " "; // 10 20 30 409 std::cout << "\n";10
11 std::vector<std::string> langs{"C++", "Python", "Java"};12 for (const auto& lang : langs) // 只读遍历用 const auto&（免拷贝）13 std::cout << lang << " ";14 std::cout << "\n";15
16 std::string s = "Cyber";17 for (char c : s) // 遍历字符串18 std::cout << c << "-";19 return 0;20}遍历三姿势：
| 写法 | 语义 | 适用 |
|---|---|---|
for (auto x : c) | 拷贝每个元素 | 小对象/基本类型 |
for (auto& x : c) | 引用，可修改元素 | 要改内容 |
for (const auto& x : c) | 只读引用，零拷贝 | 大对象只读（默认选它） |
1// break：终止所在层循环2for (int i = 1; i <= 100; ++i) {3 if (i * i > 500) {4 std::cout << "第一个平方超500的是 " << i << "\n";5 break;6 }7}8
9// continue：跳过本次10for (int i = 1; i <= 20; ++i) {11 if (i % 3 == 0) continue; // 跳过 3 的倍数12 std::cout << i << " "; // 1 2 4 5 7 8 ...13}C++ 没有 Python 的”循环 else”，等价逻辑用一个标志变量实现。
1for (int i = 1; i <= 9; ++i) {2 for (int j = 1; j <= i; ++j) {3 printf("%d×%d=%-4d", j, i, i * j); // %-4d 左对齐宽44 }5 std::cout << "\n";6}1#include <iostream>2#include <cmath>3
4bool is_prime(int n) { // bool 函数，第五篇详讲5 if (n < 2) return false;6 for (int i = 2; i <= std::sqrt(n); ++i) {7 if (n % i == 0) return false;8 }9 return true;10}11
12int main() {13 int n;14 std::cin >> n;15 std::cout << n << (is_prime(n) ? " 是" : " 不是") << "质数\n";16}1// 金字塔（5行）2int rows = 5;3for (int i = 1; i <= rows; ++i) {4 for (int s = 0; s < rows - i; ++s) std::cout << " "; // 左侧空格5 for (int j = 0; j < 2 * i - 1; ++j) std::cout << "*"; // 星号6 std::cout << "\n";7}8// *9// ***10// *****11// *******12// *********1#include <iostream>2#include <cstdlib> // rand/srand3#include <ctime>4
5int main() {6 std::srand(std::time(nullptr)); // 播种子7 int answer = std::rand() % 100 + 1; // 1~1008 int guess, tries = 0;9
10 do {11 std::cout << "猜(1-100): ";12 if (!(std::cin >> guess)) { // 输入校验（上篇）13 std::cin.clear();14 std::cin.ignore(10000, '\n');15 std::cout << "请输入数字！\n";16 continue;17 }18 ++tries;19 if (guess < answer) std::cout << "小了\n";20 else if (guess > answer) std::cout << "大了\n";21 else std::cout << "对了！用了 " << tries << " 次\n";22 } while (guess != answer);23 return 0;24}1for (int i = 1; i <= 30; ++i) {2 if (i % 15 == 0) std::cout << "FizzBuzz ";3 else if (i % 3 == 0) std::cout << "Fizz ";4 else if (i % 5 == 0) std::cout << "Buzz ";5 else std::cout << i << " ";6}1 // C++ 保留了 goto，但现代编码规范一律禁用——破坏结构化、难以追踪2 goto end;3 std::cout << "这行被跳过";4end:5 return 0;唯一”合理”场景是多层嵌套循环的一次性跳出，但那也该用函数 + return 重构。
std::vector<int>{3,7,1,9,4} 的最大值、最小值与平均值const auto& 是遍历容器的默认姿势下一篇：函数——定义、声明、重载与默认参数，C++ 的函数比 Python 讲究得多。
本系列为 Cyber先锋社原创教程。五个经典练习建议全部独立敲一遍，比看十遍教程有效。
C++ 的函数体系比 Python 严格也强大：函数必须先声明后使用、参数传递方式直接决定性能与语义、还有重载与默认参数两大利器。本篇一次讲透，这是 C++ 分水岭之一。
编译器从上往下读文件，调用函数前必须”见过”它。大项目里函数分散在多文件，靠**声明（原型）**解决：
1// 函数声明（原型）：告诉编译器"有这个函数，长这样"2double calc_bmi(double weight, double height);3
4int main() {5 std::cout << calc_bmi(70, 1.75); // ✓ 编译器已认识它6 return 0;7}8
9// 函数定义：真正实现10double calc_bmi(double weight, double height) {11 return weight / (height * height);12}声明与定义的区别：声明是”预告”（无函数体），定义是”实现”。声明可多次，定义只能一次。
1// ===== math_utils.h（头文件：放声明）=====2#ifndef MATH_UTILS_H // 包含保护：防止重复包含3#define MATH_UTILS_H4
5double calc_bmi(double weight, double height);6bool is_prime(int n);7
8#endif1// ===== math_utils.cpp（源文件：放定义）=====2#include "math_utils.h" // 自己的头文件用 ""3
4double calc_bmi(double weight, double height) {5 return weight / (height * height);6}7
8bool is_prime(int n) {9 if (n < 2) return false;10 for (int i = 2; i * i <= n; ++i)11 if (n % i == 0) return false;12 return true;13}1// ===== main.cpp =====2#include <iostream>3#include "math_utils.h" // 用谁的头文件就 include 谁4
5int main() {6 std::cout << calc_bmi(70, 1.75) << "\n";7}编译：g++ main.cpp math_utils.cpp -o app（所有 cpp 都要参与编译）。
1void try_change(int x) { // x 是实参的副本2 x = 100;3}4
5int main() {6 int n = 5;7 try_change(n);8 std::cout << n; // 5 —— 原值不变9}1void actually_change(int& x) { // x 是 n 的别名2 x = 100;3}4
5int main() {6 int n = 5;7 actually_change(n);8 std::cout << n; // 100 ✓ 改的是原值9}引用的经典用途 1：多返回值（出参）
1// 同时返回商和余数2void divmod(int a, int b, int& quotient, int& remainder) {3 quotient = a / b;4 remainder = a % b;5}6
7int main() {8 int q, r;9 divmod(17, 5, q, r);10 std::cout << q << " 余 " << r; // 3 余 211}1#include <string>2
3// 值传递会拷贝整个字符串（浪费）；const& 既不拷贝又不可改4void print_banner(const std::string& text) {5 std::cout << "==== " << text << " ====\n";6}参数传递决策表：
| 参数类型 | 写法 | 场景 |
|---|---|---|
| 小对象（int/double/指针） | 值传递 T x | 默认 |
| 要修改实参 | 引用 T& x | 出参、原地修改 |
| 大对象只读（string/vector） | const T& x | 默认 |
| 可能为空/要改指向 | 指针 T* x（第六篇） | C 风格接口 |
1double power(double base, int exp = 2); // 声明处给默认值2
3int main() {4 std::cout << power(3) << "\n"; // 9（用默认 exp=2）5 std::cout << power(3, 3) << "\n"; // 276}7
8double power(double base, int exp) {9 double result = 1;10 for (int i = 0; i < exp; ++i) result *= base;11 return result;12}规矩：默认参数必须从右往左连续给——f(int a, int b=1, int c=2) ✓，f(int a=1, int b) ❌。声明与定义分离时，默认值只能写在声明里。
同名函数、参数不同（个数或类型），编译器按实参自动匹配：
1#include <iostream>2#include <string>3
4int max_of(int a, int b) { return a > b ? a : b; }5double max_of(double a, double b) { return a > b ? a : b; }6int max_of(int a, int b, int c) { return max_of(max_of(a, b), c); }7std::string max_of(const std::string& a, const std::string& b) { return a > b ? a : b; }8
9int main() {10 std::cout << max_of(3, 7) << "\n"; // int 版 → 711 std::cout << max_of(3.14, 2.71) << "\n"; // double 版 → 3.1412 std::cout << max_of(1, 9, 4) << "\n"; // 三参版 → 913 std::cout << max_of("apple", "banana") << "\n"; // string 版 → banana14}重载只看参数，不看返回值——int f() 与 double f() 不构成重载，直接编译错误。
Python 没有重载（用默认参数模拟），这是 C++ 的”编译期多态”。
1#include <iostream>2
3unsigned long long factorial(int n) {4 if (n <= 1) return 1; // 基线5 return n * factorial(n - 1); // 递推6}7
8// 输出斐波那契第 n 项（递归版——直观但慢）9long long fib(int n) {10 if (n < 2) return n;11 return fib(n - 1) + fib(n - 2);12}13
14int main() {15 for (int i = 1; i <= 10; ++i)16 std::cout << factorial(i) << " ";17 std::cout << "\n";18 std::cout << fib(40) << "\n"; // 102334155（已经要跑一会儿了）19}注意 unsigned long long：20! 已超 int 范围，选对类型是 C++ 的日常。
1#include <iostream>2
3int g = 100; // 全局变量（尽量少用）4
5void demo() {6 int local = 1; // 局部：函数结束销毁7 static int count = 0; // 静态局部：只初始化一次，函数间保留8 ++count;9 std::cout << "local=" << local++ << " count=" << count << "\n";10}11
12int main() {13 demo(); // local=1 count=114 demo(); // local=1 count=2（local 每次重建，count 保留！）15 {16 int block_var = 42; // 块作用域17 }18 // std::cout << block_var; // ❌ 出块即亡19}static 局部变量 = “只属于这个函数的全局变量”，常用于调用计数、缓存。
1// inline：建议编译器把函数体直接展开到调用处（省调用开销）2// 现代编译器很聪明，inline 更多语义是"允许多文件安全定义"3inline int square(int x) { return x * x; }4
5// constexpr 函数（C++11/14）：可在编译期求值6constexpr int cube(int x) { return x * x * x; }7
8int arr[cube(3)]; // ✓ 27 作为编译期数组大小9constexpr int c = cube(4); // 编译期计算出 64综合本篇知识（声明分离、引用出参、重载、默认参数）：
1#include <iostream>2#include <iomanip>3
4// ===== salary.h 的声明部分（这里合并演示）=====5double calc_tax(double taxable); // 按超额累进6void split_salary(double gross, double& net, double& tax); // 出参7
8// ===== 实现 =====9double calc_tax(double taxable) {10 // 简化版超额累进（月度，免征额已扣除）11 if (taxable <= 0) return 0;12 if (taxable <= 3000) return taxable * 0.03;13 if (taxable <= 12000) return 3000 * 0.03 + (taxable - 3000) * 0.10;14 return 3000 * 0.03 + 9000 * 0.10 + (taxable - 12000) * 0.20;15}16
17void split_salary(double gross, double& net, double& tax) {18 tax = calc_tax(gross - 5000.0); // 免征额 500019 net = gross - tax;20}21
22int main() {23 double gross;24 std::cout << std::fixed << std::setprecision(2);25 while (true) {26 std::cout << "\n输入税前月薪（0退出）: ";27 if (!(std::cin >> gross)) break;28 if (gross <= 0) break;29
30 double net, tax;31 split_salary(gross, net, tax);32 std::cout << "税前: " << gross << "\n税额: " << tax33 << "\n到手: " << net << "\n";34 }35}swap(int&, int&) 验证引用交换；再写值传递版对比为什么不行area：正方形（1 参）、长方形（2 参）、圆（半径，double 参）void stats(const std::vector<int>& v, double& avg, int& max_v, int& min_v) 一次算三个统计量print_digits(1234) 输出 4 3 2 1T& 可修改实参、const T& 大对象只读零拷贝下一篇：数组与 std::string/vector 三剑客——C++ 数据容器的正确打开方式。
本系列为 Cyber先锋社原创教程。“声明放头文件”是多文件编程的第一课，练习 5 必做。
存”一堆数据”的三个层次：C 数组（原始、固定大小）、std::vector（动态数组，现代首选）、std::string（字符串专用容器）。重点放在后两者——现代 C++ 的原则是”能用 vector 不用数组，能用 string 不用 char*”。
1#include <iostream>2
3int main() {4 int scores[5] = {90, 85, 78, 92, 66}; // 定义即初始化5 int zeros[10] = {}; // 全部初始化为 06 int partial[5] = {1, 2}; // {1,2,0,0,0} 其余补 07
8 // 访问与修改（下标从 0 开始）9 scores[0] = 95;10 std::cout << scores[4] << "\n"; // 6611
12 // 数组大小（仅对"本作用域数组"有效）13 int n = sizeof(scores) / sizeof(scores[0]); // 514
15 // 遍历16 for (int i = 0; i < n; ++i)17 std::cout << scores[i] << " ";18 std::cout << "\n";19
20 for (int x : scores) // 范围 for 更优雅21 std::cout << x << " ";22 return 0;23}数组的两大天生局限：
int arr[n]（n 是变量）不是标准 C++（部分编译器扩展支持）1void print_arr(int arr[], int size) { // 数组参数必须附带长度2 // sizeof(arr) 在这里是指针大小（8），不是数组大小！3 for (int i = 0; i < size; ++i)4 std::cout << arr[i] << " ";5}数组不检查越界：scores[100] 编译运行都不报错，直接读写非法内存——未定义行为，可能是乱码、崩溃或安全漏洞。这是 C/C++ 缓冲区溢出漏洞的根源。
1int matrix[3][4] = {2 {1, 2, 3, 4},3 {5, 6, 7, 8},4 {9, 10, 11, 12},5};6
7int rows = 3, cols = 4;8for (int i = 0; i < rows; ++i) {9 for (int j = 0; j < cols; ++j)10 std::cout << matrix[i][j] << "\t";11 std::cout << "\n";12}13
14// 打擂台找最大值及其位置15int max_v = matrix[0][0], mi = 0, mj = 0;16for (int i = 0; i < rows; ++i)17 for (int j = 0; j < cols; ++j)18 if (matrix[i][j] > max_v) {19 max_v = matrix[i][j]; mi = i; mj = j;20 }21std::cout << "最大 " << max_v << " 在 (" << mi << "," << mj << ")\n";1#include <vector>2#include <iostream>3
4int main() {5 std::vector<int> v1; // 空6 std::vector<int> v2(5); // {0,0,0,0,0}7 std::vector<int> v3(5, 7); // {7,7,7,7,7}8 std::vector<int> v4 = {1, 2, 3, 4}; // 列表初始化9 std::vector<std::string> names{"小明", "小红"};10
11 std::cout << v4.size() << "\n"; // 4 元素数12 std::cout << v4.empty() << "\n"; // 0 是否为空13
14 v4[0] = 100; // 修改（同样不查越界）15 std::cout << v4.at(1) << "\n"; // 2 at() 会检查越界并抛异常16 std::cout << v4.front() << " " << v4.back() << "\n"; // 100 417 return 0;18}1std::vector<int> v = {2, 3};2
3v.push_back(4); // 尾部追加：{2,3,4} —— 最高频操作4v.insert(v.begin(), 1); // 头部插入：{1,2,3,4}5v.insert(v.begin() + 2, 99); // 指定位置：{1,2,99,3,4}6
7v.pop_back(); // 删除尾部：{1,2,99,3}8v.erase(v.begin() + 2); // 删除指定位置：{1,2,3}9v.erase(v.begin(), v.begin() + 2); // 删除区间：{3}10
11v.clear(); // 清空：{}性能提示：push_back 尾部均摊 O(1)；insert/erase 中间是 O(n)——频繁中间插删的场景后续用 list（进阶）。
1std::vector<int> v = {5, 3, 8, 1, 9};2
3// ① 下标循环（需要下标时）4for (std::size_t i = 0; i < v.size(); ++i) // size() 返回无符号 size_t5 std::cout << v[i] << " ";6
7// ② 范围 for 只读8for (const auto& x : v) std::cout << x << " ";9
10// ③ 范围 for 修改11for (auto& x : v) x *= 2; // 全部翻倍12
13// 已知量小或有符号运算时，int i 配 static_cast：14for (int i = 0; i < static_cast<int>(v.size()); ++i) { /* ... */ }1std::vector<int> v;2for (int i = 1; i <= 100; ++i)3 v.push_back(i * i); // 数组做不到的"边跑边长"4std::cout << v.size(); // 1001#include <algorithm>2
3std::vector<int> v = {5, 3, 8, 1, 9};4
5std::sort(v.begin(), v.end()); // 升序 {1,3,5,8,9}6std::sort(v.begin(), v.end(), std::greater<int>()); // 降序7
8auto it = std::find(v.begin(), v.end(), 8); // 查找，返回迭代器9if (it != v.end())10 std::cout << "找到，下标 " << (it - v.begin()) << "\n";11
12// 排序复杂数据（lambda 第四篇提过，第十篇详讲）13std::vector<std::pair<std::string, int>> st{{"小明",90},{"小红",92}};14std::sort(st.begin(), st.end(),15 [](const auto& a, const auto& b) { return a.second > b.second; });1#include <string>2
3std::string s1 = "hello";4std::string s2("world");5std::string s3(5, 'a'); // "aaaaa" 重复字符6std::string s4 = s1 + " " + s2; // "hello world"（+ 随便拼）7s4 += "!"; // 追加8
9// 数值拼接需先转换（第二篇）：10int age = 18;11std::string info = "年龄: " + std::to_string(age);1std::string s = "CyberPioneer";2
3std::cout << s.size() << "\n"; // 12（size 与 length 等价）4std::cout << s[0] << s.back() << "\n"; // Cr5s[0] = 'c'; // ✓ 可修改（不同于 Python！）6
7// 子串：substr(起点, 长度)8std::cout << s.substr(0, 5) << "\n"; // cyber9std::cout << s.substr(5) << "\n"; // Pioneer（到结尾）10
11// 查找：find 找不到返回 string::npos12if (s.find("Pioneer") != std::string::npos)13 std::cout << "包含 Pioneer，位置 " << s.find("Pioneer") << "\n";14
15// 修改16std::string t = " hi ";17std::cout << "|" << t.substr(1, 2) << "|\n"; // 手动去空格（无现成 strip）18
19std::string u = "a,b,c";20// 按","分割（STL 惯用法，sstream 第十一篇还会见）21#include <sstream>22std::vector<std::string> parts;23std::stringstream ss(u);24std::string item;25while (std::getline(ss, item, ','))26 parts.push_back(item); // {"a","b","c"}1std::string a = "apple", b = "banana";2if (a == b) std::cout << "相等";3if (a < b) std::cout << "a 在前"; // 字典序，直接用比较运算符4int r = a.compare(b); // <0 / 0 / >0，与 strcmp 类似1std::string cpp_s = "hello";2const char* c_s = cpp_s.c_str(); // string → C 串（用于旧接口/printf）3
4std::string back = c_s; // C 串 → string 直接构造| 维度 | C 数组 | std::vector |
|---|---|---|
| 大小 | 编译期固定 | 运行期动态 |
| 越界检查 | 无（UB） | at() 有 |
| 自带长度 | 否 | size() |
| 传参 | 退化指针+手动传长度 | 直接传引用 |
| 性能 | 裸奔最快 | 同量级（多了薄封装） |
结论：日常一律 vector；只有”大小确定且追求极致”（嵌入式、竞赛固定槽位）用数组。多维场景用 std::vector<std::vector<int>>。
1#include <iostream>2#include <vector>3#include <string>4#include <algorithm>5#include <iomanip>6
7int main() {8 std::vector<std::pair<std::string, int>> students = {9 {"小明", 90}, {"小红", 85}, {"小刚", 92}, {"小美", 66},10 };11
12 // 按成绩降序13 std::sort(students.begin(), students.end(),14 [](const auto& a, const auto& b) { return a.second > b.second; });15
16 // 统计17 int total = 0;18 std::vector<int> scores;19 for (const auto& [name, score] : students) { // 结构化绑定（C++17）20 total += score;21 scores.push_back(score);22 }23
24 std::cout << std::fixed << std::setprecision(1);25 std::cout << "平均分: " << total * 1.0 / students.size() << "\n";26 std::cout << "最高: " << scores.front() << " 最低: " << scores.back() << "\n";27
28 // 挂科名单29 std::cout << "挂科: ";30 for (const auto& [name, score] : students)31 if (score < 60) std::cout << name << " ";32 std::cout << "\n";33
34 // 前三名35 for (int i = 0; i < 3 && i < static_cast<int>(students.size()); ++i)36 std::cout << "No." << i + 1 << " " << students[i].first37 << " " << students[i].second << "\n";38}{5,2,8,1} 升序（双重循环打擂台）std::unique + erase 三连（查文档实现）"the quick brown fox" → 3 5 5 3（stringstream 分割）std::vector<std::vector<int>>(9, std::vector<int>(9)) 填充并打印<algorithm> 的 sort/findstring::npos 判断下一篇：指针与引用——C++ 的深水区，也是它强大的根源。
本系列为 Cyber先锋社原创教程。vector 的每个方法都敲一遍，后面 STL 篇会轻松很多。
指针是 C++ 的分水岭：理解了它，才算真正理解”程序如何在内存中运行”。本篇从内存模型讲起，覆盖裸指针、动态内存、引用对比与智能指针入门。请逐个示例亲手运行——这一篇没有捷径。
1int age = 18;这行代码发生的事：程序在栈内存里划出 4 字节，存入 18，并把这块空间标记为 age。
每块内存都有编号——地址（一串十六进制数）。& 取地址运算符可以拿到它：
1#include <iostream>2int main() {3 int age = 18;4 std::cout << &age << "\n"; // 0x7ffee4c0a8bc（每次运行可能不同）5 std::cout << sizeof(age); // 4 字节6}类比：内存是一整条街的房间，变量是房间里的住户，地址是门牌号。
1int age = 18;2int* p = &age; // p 是指针，存的是 age 的地址3
4std::cout << p << "\n"; // 地址：0x7ffee4c0a8bc5std::cout << *p << "\n"; // 18：* 解引用——顺着地址找到值6std::cout << &p << "\n"; // p 自己的地址（指针也是变量）7
8*p = 20; // 通过地址改写 age！9std::cout << age << "\n"; // 20两个符号记牢：
&x：取 x 的地址*p：顺 p 存的地址取值（或写入）1int* p1, p2; // ⚠ 坑：p1 是指针，p2 是 int！2int *p3, *p4; // 两个都是指针1int* p = nullptr; // C++11 空指针（替代 NULL 与 0）2
3if (p != nullptr) {4 std::cout << *p; // 用前判空5}6// *p; // ❌ 解引用空指针 = 段错误（Segfault），程序崩溃永远不要解引用空指针或未初始化的指针（野指针）。现代写法：定义指针就初始化（给值或给 nullptr）。
C 风格的”修改实参”方式（C++ 更推荐引用，但必须会读）：
1void swap(int* a, int* b) { // 接收地址2 int t = *a; // 通过地址取值3 *a = *b; // 通过地址写值4 *b = t;5}6
7int main() {8 int x = 1, y = 2;9 swap(&x, &y); // 传地址10 std::cout << x << "," << y; // 2,111}数组名本质是”首元素地址”：
1int arr[] = {10, 20, 30, 40};2int* p = arr; // 等价于 &arr[0]3
4std::cout << *p << "\n"; // 105std::cout << *(p + 1) << "\n"; // 20：指针算术，+1 移动一个 int6std::cout << p[2] << "\n"; // 30：指针也能用下标（等价 *(p+2)）7
8// 遍历9for (int* q = arr; q != arr + 4; ++q)10 std::cout << *q << " ";指针算术：p + 1 移动的字节数 = 指向类型的大小（int* 移 4 字节，double* 移 8 字节）。
栈上的变量函数结束自动销毁；堆内存由你手动管理——能跨函数存活、大小运行期决定。
1// 单个变量2int* p = new int(42); // 堆上开 4 字节，初始化 423std::cout << *p << "\n";4delete p; // 手动释放！5p = nullptr; // 置空好习惯6
7// 动态数组（大小可以是变量！）8int n;9std::cin >> n;10int* arr = new int[n]{}; // n 个 int 全 011for (int i = 0; i < n; ++i) arr[i] = i * i;12delete[] arr; // 数组用 delete[]两条铁律：
new 必须对应一个 delete（数组 delete[]）delete 后指针置 nullptr，防止”悬空指针”再次使用1void leak() {2 int* p = new int(100);3 // 函数结束，p 这个"门牌号"没了，但堆上 4 字节还占着——永远无法释放4} // 💥 内存泄漏5
6void worse() {7 int* p = new int(1);8 p = new int(2); // 第一个内存块地址丢失，泄漏！9 delete p;10}长期运行的服务（服务器程序）泄漏累积会耗尽内存——这是裸 new/delete 逐渐被弃用的原因。
| 维度 | 引用 int& r = x | 指针 int* p = &x |
|---|---|---|
| 本质 | 变量的别名 | 存地址的变量 |
| 初始化 | 必须初始化，不可换绑 | 可空、可改指向 |
| 空值 | 不存在 | nullptr |
| 用法 | 直接当原变量用 | 需 * 解引用 |
| 安全性 | 高 | 低（野指针/泄漏） |
1int x = 10;2
3int& r = x; // r 就是 x 的第二个名字4r = 99; // x 变 995// int& bad; // ❌ 引用必须初始化6
7int* p = &x; // p 指向 x8p = nullptr; // ✓ 指针可以为空9int y = 5;10p = &y; // ✓ 指针可换指向选择：能用引用就用引用（安全简洁）；需要”可能为空”或”改指向”才用指针。
C++11 用智能指针把 new/delete 交给对象自动管理——RAII：资源获取即初始化，析构自动释放。
1#include <memory>2#include <iostream>3
4int main() {5 // make_unique 创建（C++14）6 std::unique_ptr<int> p = std::make_unique<int>(42);7
8 std::cout << *p << "\n"; // 像普通指针一样用9 // 离开作用域自动 delete，无需也无法手动 delete10
11 // auto q = p; // ❌ unique 不可拷贝（独占）12 auto q = std::move(p); // ✓ 只能转移所有权（p 变空）13 if (!p) std::cout << "p 已交出\n";14 std::cout << *q << "\n";15} // q 析构 → 自动释放内存1#include <memory>2
3auto a = std::make_shared<int>(100); // 引用计数 = 14{5 auto b = a; // 计数 = 2，可以拷贝6 std::cout << *b << "\n";7} // b 销毁，计数 = 18std::cout << a.use_count() << "\n"; // 19// a 销毁时计数归零 → 内存自动释放选型：默认 unique_ptr；确实多方持有才 shared_ptr。
1#include <iostream>2
3struct Node { // 结构体第八篇详讲，先看用法4 int data;5 Node* next; // 指向下一个节点——链表的骨架6};7
8int main() {9 // 用 new 造三个节点10 Node* head = new Node{1, nullptr};11 head->next = new Node{2, nullptr}; // -> 通过指针访问成员12 head->next->next = new Node{3, nullptr};13
14 // 遍历15 for (Node* cur = head; cur != nullptr; cur = cur->next)16 std::cout << cur->data << " -> ";17 std::cout << "null\n";18
19 // 逐个释放（防泄漏）20 Node* cur = head;21 while (cur != nullptr) {22 Node* next = cur->next; // 先记住下一个23 delete cur; // 再释放当前24 cur = next;25 }26}这个例子同时展示了：堆分配、-> 运算符、指针串联结构、手动释放顺序。以后用 std::unique_ptr<Node> next 重写它，就是现代 C++ 风格。
int* find_max(int* arr, int n) 返回最大元素的地址（不是值）double 数组存 10 个成绩，输出平均分后正确 deletestd::unique_ptr<int[]> arr{new int[5]{}}），体会自动释放int* p = new int(5); delete p; std::cout << *p; 会发生什么？（悬空指针，未定义行为——说说为什么不能这么写）& 取地址、*p 解引用；指针存地址，是”携带门牌号的变量”-> 是”指针访问成员”的语法糖下一篇：结构体与枚举——把相关数据打包成自定义类型。
本系列为 Cyber先锋社原创教程。指针是 C++ 的门槛也是魅力：内存模型想通了，后面豁然开朗。
int/double/string 只能描述”单点信息”，现实实体往往是”一组信息”：学生有姓名+年龄+成绩，坐标有 x+y。结构体（struct） 让你自定义”打包类型”；枚举（enum） 让你定义”取值受限”的类型。它们是迈向面向对象（第九篇）前的最后一级台阶。
1#include <iostream>2#include <string>3
4// 定义新类型（习惯放 main 前或头文件）5struct Student {6 std::string name; // 成员变量7 int age;8 double score;9}; // ⚠ 别忘了分号！10
11int main() {12 // 创建与初始化（三种方式）13 Student s1 = {"小明", 18, 90.5}; // 顺序初始化14 Student s2{.name="小红", .age=17}; // 指示符初始化（C++20）15 Student s3; // 未初始化（成员值随机！）16
17 // 成员访问：点运算符18 s3.name = "小刚";19 s3.age = 19;20 s3.score = 88;21
22 std::cout << s1.name << " " << s1.score << "\n";23 std::cout << s2.name << " " << s2.score << "\n"; // 0（缺省补零）24 return 0;25}1Student s = {"小明", 18, 90.5};2Student* p = &s;3
4std::cout << (*p).name << "\n"; // 括号版（* 优先级低于 .）5std::cout << p->name << "\n"; // 箭头版（完全等价，推荐）6p->score = 95; // 通过指针修改成员规则：对象/引用用 .，指针用 ->。
1struct Date {2 int year, month, day;3};4
5struct Event {6 std::string title;7 Date date; // 结构体作成员8 struct Place { // 内嵌定义9 std::string building;10 int room;11 } place;12};13
14Event e;15e.title = "C++ 分享会";16e.date = {2026, 10, 29};17e.place.building = "信息楼";18e.place.room = 301;19
20std::cout << e.title << " @ " << e.place.building21 << e.place.room << "室\n";1#include <vector>2#include <algorithm>3
4std::vector<Student> students = {5 {"小明", 18, 90}, {"小红", 17, 85}, {"小刚", 19, 92},6};7
8// 遍历9for (const auto& s : students)10 std::cout << s.name << " " << s.score << "\n";11
12// 按分数降序（结构化绑定 + lambda）13std::sort(students.begin(), students.end(),14 [](const Student& a, const Student& b) { return a.score > b.score; });15
16// 找最高分17auto best = *std::max_element(students.begin(), students.end(),18 [](const Student& a, const Student& b) { return a.score < b.score; });19std::cout << "第一名: " << best.name << "\n";1// 大结构体只读：const& 零拷贝2void print_student(const Student& s) {3 std::cout << s.name << "," << s.age << "岁," << s.score << "分\n";4}5
6// 要修改：引用7void birthday(Student& s) {8 ++s.age;9}10
11// 值传递会整体拷贝（string/vector 都复制一遍）——大结构体别这么传1struct Point {2 double x, y;3
4 // 成员函数（第九篇正式讲）5 double dist() const { return std::sqrt(x*x + y*y); }6};完整的运算符重载（operator<、operator==）在第十篇面向对象展开。
1enum Color { RED, GREEN, BLUE }; // 默认值 0,1,22
3Color c = GREEN;4std::cout << c << "\n"; // 1（本质是 int）5
6if (c == GREEN) std::cout << "绿色\n";7
8enum Level { LOW, MID = 5, HIGH }; // 可指定值：0,5,6坑：枚举名裸露在全局，两个 enum 有同名成员就冲突：
1enum TrafficLight { RED, YELLOW, GREEN }; // ❌ RED/GREEN 与 Color 重复定义！1enum class Status { Idle, Running, Error };2enum class Color2 { Red, Green }; // 同名不冲突：有作用域3
4Status s = Status::Running; // 必须带作用域 Status::5
6if (s == Status::Running)7 std::cout << "运行中\n";8
9// int n = s; // ❌ 不隐式转 int（类型安全）10int n = static_cast<int>(s); // 显式转换 ✓11
12// 指定底层类型13enum class Priority : char { Low = 'L', Mid = 'M', High = 'H' };enum class 三大优点：作用域隔离（不污染全局）、不隐式转 int（防误比较）、可指定底层类型。新代码一律 enum class。
1enum class OrderState { Created, Paid, Shipped, Done, Cancelled };2
3void handle(OrderState state) {4 switch (state) {5 case OrderState::Created: std::cout << "待支付\n"; break;6 case OrderState::Paid: std::cout << "已支付，备货中\n"; break;7 case OrderState::Shipped: std::cout << "运输中\n"; break;8 case OrderState::Done: std::cout << "已完成\n"; break;9 case OrderState::Cancelled:std::cout << "已取消\n"; break;10 // ⚠ 开了 -Wall 编译选项时，漏分支会警告——enum+switch 的安全网11 }12}1// union：所有成员共享同一块内存（省空间，底层开发用）2union Packet {3 uint32_t raw; // 4 字节4 struct { uint8_t b0,b1,b2,b3; } bytes; // 也是 4 字节，与 raw 重叠5};6
7Packet p;8p.raw = 0x11223344;9std::cout << std::hex << (int)p.bytes.b0 << "\n"; // 44（小端序）应用场景：硬件寄存器、网络协议解析。日常业务开发用得少，知道即可。
1#include <iostream>2#include <vector>3#include <string>4#include <algorithm>5#include <iomanip>6
7enum class BookState { Available, Borrowed, Lost };8
9struct Book {10 std::string isbn;11 std::string title;12 BookState state;13
14 std::string state_str() const { // const 成员函数15 switch (state) {16 case BookState::Available: return "在架";17 case BookState::Borrowed: return "借出";18 case BookState::Lost: return "遗失";19 }20 return "?";21 }22};23
24struct Library {25 std::vector<Book> books;26
27 void add(const std::string& isbn, const std::string& title) {28 books.push_back({isbn, title, BookState::Available});29 }30
31 bool borrow(const std::string& isbn) {32 for (auto& b : books)33 if (b.isbn == isbn && b.state == BookState::Available) {34 b.state = BookState::Borrowed;35 return true;36 }37 return false;38 }39
40 void report() const {41 int avail = 0;42 for (const auto& b : books)43 if (b.state == BookState::Available) ++avail;44 std::cout << "共 " << books.size() << " 本，在架 " << avail << " 本\n";45
46 for (const auto& b : books)47 std::cout << std::left << std::setw(14) << b.isbn48 << std::setw(16) << b.title49 << b.state_str() << "\n";50 }51};52
53int main() {54 Library lib;55 lib.add("978-7-111", "C++ Primer");56 lib.add("978-7-115", "算法导论");57 lib.add("978-7-121", "深入理解计算机系统");58
59 lib.borrow("978-7-111");60 lib.borrow("不存在的ISBN");61 lib.report();62}这个案例在第十篇会用 class + 封装重写，对比着看能体会 struct→class 的演进。
Rectangle{width, height} + 函数 double area(const Rectangle&)，输入尺寸输出面积周长Student{name, scores: vector<double>}，写函数计算每人平均分并输出最高的姓名Vec2{x,y} 并写 add/sub/dot 三个函数（const 引用传参），实现向量加减与点积.、指针用 -> 访问成员；结构体可嵌套const&、要改 &；配 vector/sort 食用最佳下一篇：面向对象（上）——类、构造析构、封装。
本系列为 Cyber先锋社原创教程。图书管理案例先自己扩展”还书”功能，第十篇再见证它的进化。
C++ 是”多范式语言”，但面向对象（OOP） 是它组织大型工程的主力方式。本篇讲 OOP 三大特性中的封装：把数据与操作绑定、对外隐藏细节。构造/析构/拷贝这”三巨头”是 C++ 面试与实战的高频考点。
1class BankAccount {2private: // 私有：只有类自己的成员函数能访问3 std::string owner;4 double balance;5
6public: // 公开：外部的接口7 // 构造函数8 BankAccount(const std::string& name, double init_balance = 0)9 : owner(name), balance(init_balance) { // 初始化列表10 }11
12 // 成员函数（方法）13 void deposit(double amount) {14 if (amount <= 0) return;15 balance += amount;16 }17
18 bool withdraw(double amount) {19 if (amount > balance) return false;20 balance -= amount;21 return true;22 }23
24 double get_balance() const { return balance; } // const：承诺不修改成员25};26
27int main() {28 BankAccount acc("小明", 100);29 acc.deposit(50);30 acc.withdraw(30);31 std::cout << acc.get_balance() << "\n"; // 12032
33 // acc.balance = -999; // ❌ private，外部禁止直接改——封装的意义！34}class 与 struct 的唯一区别：默认访问权限——class 默认 private，struct 默认 public。习惯：纯数据用 struct，带行为用 class。
封装的价值：balance 不能被外部直接改成负数——所有修改必须经过 deposit/withdraw 的校验，不变量（余额非负）由类自己守护。
| 关键字 | 谁能访问 |
|---|---|
private | 本类的成员函数（默认） |
protected | 本类 + 子类（第九篇） |
public | 任何人 |
1class Date {2 int y, m, d;3public:4 Date() : y(2026), m(1), d(1) {} // 默认构造5 Date(int y, int m, int d) : y(y), m(m), d(d) {} // 三参构造6 explicit Date(int days) { // 单参构造加 explicit（见下）7 y = days / 365 + 1970; m = 1; d = 1;8 }9};10
11Date a; // 默认构造（注意：不带括号！）12Date b{2026, 10, 29};13Date c = Date(2026, 10, 29);14// Date d(); // ⚠ 经典陷阱：这是函数声明，不是构造对象！1void print(const Date& d);2
3// 若 Date(int) 不加 explicit：4// print(12345); // 会被悄悄转换成 Date——意外行为！5// 加了 explicit 后必须显式：print(Date(12345));军规：单参构造一律加 explicit。
1class Widget {2public:3 Widget() : Widget(0, 0) {} // 委托给另一个构造4 Widget(int x, int y) : x_(x), y_(y) {}5 Widget(const Widget&) = default; // 让编译器生成默认版本6private:7 int x_, y_;8};对象销毁时自动调用，名字是 ~类名，负责清理资源：
1#include <iostream>2
3class FileLogger {4 FILE* fp;5public:6 FileLogger(const char* path) {7 fp = fopen(path, "a");8 std::cout << "[打开日志]\n";9 }10
11 void log(const char* msg) {12 if (fp) fprintf(fp, "%s\n", msg);13 }14
15 ~FileLogger() { // 析构：对象生命周期结束时自动调用16 if (fp) fclose(fp);17 std::cout << "[关闭日志]\n";18 }19};20
21void demo() {22 FileLogger logger("app.log"); // 栈对象：demo 结束自动析构23 logger.log("hello");24} // 打印 [关闭日志]——这就是 RAII！25
26int main() { demo(); std::cout << "demo 之后\n"; }27// 输出顺序：[打开日志] [关闭日志] demo 之后RAII（资源获取即初始化）：资源在构造函数获取、析构函数释放——智能指针、锁、文件句柄都靠它。C++ 程序员最重要的习惯：把资源包进对象，交给析构函数管理。
1class Buffer {2 int* data;3 size_t size;4public:5 Buffer(size_t n) : data(new int[n]{}), size(n) {}6
7 // 拷贝构造：用旧对象构造新对象8 Buffer(const Buffer& other)9 : data(new int[other.size]), size(other.size) {10 std::copy(other.data, other.data + size, data); // 深拷贝！11 std::cout << "拷贝构造\n";12 }13
14 // 拷贝赋值：旧对象 = 旧对象15 Buffer& operator=(const Buffer& other) {16 if (this != &other) { // 防自赋值 a = a17 delete[] data; // 先释放旧资源18 size = other.size;19 data = new int[size];20 std::copy(other.data, other.data + size, data);21 }22 return *this; // 返回自身支持链式 a=b=c23 }24
25 ~Buffer() { delete[] data; } // 三巨头之三26};27
28Buffer a(10);29Buffer b = a; // 拷贝构造（定义时初始化）30Buffer c(5);31c = a; // 拷贝赋值（已存在对象赋值）若不写拷贝构造，编译器生成逐成员浅拷贝——指针成员只拷贝地址：
1// 假设 Buffer 没写拷贝构造：2Buffer b = a; // b.data 与 a.data 指向同一块内存！3// 析构时：a、b 各 delete 同一块内存 → 💥 双重释放，程序崩溃规则：类持有裸资源（指针/文件句柄）就必须遵循三法则：自定义析构、拷贝构造、拷贝赋值（或全部 = delete 禁止拷贝）。
深拷贝大 Buffer 很浪费，C++11 引入移动：Buffer d = std::move(a); 直接”偷”走 a 的资源不复制。进阶内容，此处知道有这回事即可。
1class Counter {2public:3 Counter() { ++count_; }4 static int get_count() { return count_; } // 静态成员函数：无 this5private:6 static int count_; // 静态成员变量：所有对象共享一份7};8int Counter::count_ = 0; // ⚠ 类外定义（C++17 可 inline static int count_ = 0;）9
10Counter a, b, c;11std::cout << Counter::get_count(); // 3（用类名调用，不需要对象）每个成员函数都隐含 this（指向当前对象的指针）：
1class Chain {2 int value;3public:4 Chain& add(int x) { // 返回 *this 实现链式调用5 value += x;6 return *this;7 }8};9
10Chain c;11c.add(1).add(2).add(3); // 链式：value = 61class Temp {2 mutable int access_count = 0; // mutable：const 函数里也可改3 double celsius_ = 25.0;4public:5 double fahrenheit() const { // const 成员函数：保证不改成员6 ++access_count; // ✓ mutable 例外7 return celsius_ * 9 / 5 + 32;8 }9};10
11const Temp t; // const 对象只能调用 const 成员函数12t.fahrenheit(); // ✓规则：不修改成员的函数一律标 const——否则 const 对象/引用调不了它，STL 里会到处报错。
1#include <vector>2#include <stdexcept>3#include <iomanip>4#include <iostream>5
6class Matrix {7public:8 Matrix(size_t rows, size_t cols, double init = 0)9 : rows_(rows), cols_(cols), data_(rows * cols, init) {}10
11 double& at(size_t r, size_t c) { // 可写访问（带越界检查）12 check(r, c);13 return data_[r * cols_ + c];14 }15 double at(size_t r, size_t c) const { // 只读访问（重载）16 check(r, c);17 return data_[r * cols_ + c];18 }19
20 size_t rows() const { return rows_; }21 size_t cols() const { return cols_; }22
23 Matrix operator*(const Matrix& rhs) const { // 运算符重载：矩阵乘法24 if (cols_ != rhs.rows_)25 throw std::invalid_argument("尺寸不匹配");26 Matrix result(rows_, rhs.cols_);27 for (size_t i = 0; i < rows_; ++i)28 for (size_t k = 0; k < cols_; ++k)29 for (size_t j = 0; j < rhs.cols_; ++j)30 result.at(i, j) += at(i, k) * rhs.at(k, j);31 return result;32 }33
34 void print() const {35 for (size_t i = 0; i < rows_; ++i) {36 for (size_t j = 0; j < cols_; ++j)37 std::cout << std::setw(8) << at(i, j);38 std::cout << "\n";39 }40 }41
42private:43 void check(size_t r, size_t c) const {44 if (r >= rows_ || c >= cols_)45 throw std::out_of_range("矩阵下标越界");46 }47 size_t rows_, cols_;48 std::vector<double> data_;49};50
51int main() {52 Matrix a(2, 3, 1.0);53 Matrix b(3, 2, 2.0);54 Matrix c = a * b; // 6 = 全1×全255 c.print();56}用到的本篇知识：构造初始化列表、private 封装、const 成员函数重载、运算符重载、异常（第十一篇详讲）。
Fraction（分数类）：私有分子分母、reduce() 约分、operator+、print()，保证分母永不为 0GameStats 类：static 成员统计总局数与总尝试次数Timer 类：构造记录时间、析构时打印存活时长（RAII 计时器，函数性能粗测神器）Stack 类（基于 vector）：push/pop/top/empty/size，pop 空栈时抛异常int* 的类必须遵守~T() 自动释放资源——RAII 是 C++ 的核心习惯下一篇：面向对象（下）——继承、多态与虚函数，OOP 的另一半拼图。
本系列为 Cyber先锋社原创教程。三法则与 RAII 是 C++ 区别于其他语言的核心概念，值得反复咀嚼。
OOP 三大特性的另外两个：继承（代码复用的层级体系）与多态（同一接口、不同行为）。虚函数是 C++ 多态的核心机制，也是面试必考。本篇讲透它的语法与原理。
1#include <iostream>2#include <string>3
4// 基类（父类）5class Animal {6public:7 Animal(const std::string& name) : name_(name) {}8 void eat() const { std::cout << name_ << "在吃东西\n"; }9protected: // 子类可访问，外部不行10 std::string name_;11};12
13// 派生类（子类）：public 继承表示"是一个"关系14class Dog : public Animal {15public:16 Dog(const std::string& name, const std::string& breed)17 : Animal(name), breed_(breed) {} // ⚠ 先调基类构造18 void fetch() const { std::cout << name_ << "去捡球\n"; } // 直接用 protected 成员19private:20 std::string breed_;21};22
23class Cat : public Animal {24public:25 Cat(const std::string& name) : Animal(name) {}26 void scratch() const { std::cout << name_ << "在磨爪\n"; }27};28
29int main() {30 Dog d("旺财", "柴犬");31 d.eat(); // 继承来的32 d.fetch(); // 自己的33 Cat c("咪咪");34 c.eat();35}三种继承方式（99% 场景用 public 继承）：
| 继承方式 | 基类 public 成员在子类中变为 | 基类 protected | 基类 private |
|---|---|---|---|
public 继承 | public | protected | 不可访问 |
protected 继承 | protected | protected | 不可访问 |
private 继承 | private | private | 不可访问 |
1// 构造：基类先构造，再派生类2// 析构：派生类先析构，再基类（完全相反，像穿脱衣服）3class Base {4public:5 Base() { std::cout << "Base构造\n"; }6 ~Base() { std::cout << "Base析构\n"; }7};8class Derived : public Base {9public:10 Derived() { std::cout << "Derived构造\n"; }11 ~Derived() { std::cout << "Derived析构\n"; }12};13// Derived d; 输出：14// Base构造 → Derived构造 → Derived析构 → Base析构1Animal* a = new Dog("旺财"); // 基类指针指向子类对象（合法）现在想让每个动物”叫出自己的声音”：
1class Animal {2public:3 void speak() const { // ❌ 普通成员函数4 std::cout << name_ << "在发声\n";5 }6};7class Dog : public Animal {8public:9 void speak() const { // 隐藏（不是重写！）10 std::cout << name_ << "汪汪！\n";11 }12};13
14Animal* a = new Dog("旺财");15a->speak(); // 输出"旺财在发声"——调的是基类版本！普通函数调用在编译期按指针类型绑定（静态绑定），所以永远调 Animal 的版本。
1class Animal {2public:3 Animal(const std::string& name) : name_(name) {}4 virtual ~Animal() = default; // ⚠ 虚析构（后面讲为什么）5
6 virtual void speak() const { // virtual 声明为虚函数7 std::cout << name_ << "在发声\n";8 }9protected:10 std::string name_;11};12
13class Dog : public Animal {14public:15 Dog(const std::string& n) : Animal(n) {}16 void speak() const override { // override 显式标记重写（C++11）17 std::cout << name_ << "汪汪！\n";18 }19};20
21class Cat : public Animal {22public:23 Cat(const std::string& n) : Animal(n) {}24 void speak() const override {25 std::cout << name_ << "喵～\n";26 }27};28
29int main() {30 Animal* zoo[] = {new Dog("旺财"), new Cat("咪咪")};31
32 for (Animal* a : zoo)33 a->speak(); // ✅ 汪汪！/ 喵～ 运行期按真实类型绑定！34
35 for (Animal* a : zoo)36 delete a; // 虚析构保证正确释放子类部分37}多态成立的三个条件：基类函数是 virtual、子类 override 重写、通过基类指针或引用调用。
override 关键字让编译器帮你检查签名是否真的重写成功（拼错函数名会直接报错）——重写必写 override。
每个含虚函数的类都有一张虚函数表（vtable），对象头部存指向 vtable 的指针（vptr）：
1Animal* a → [vptr] → Animal::vtable [ &Animal::speak ]2Dog 对象 → [vptr] → Dog::vtable [ &Dog::speak ] ← Dog 覆盖了槽位3
4调用 a->speak() 编译为：a->vptr->speak槽位() ← 运行期查表代价：每对象多 8 字节指针 + 一次间接跳转。所以”不需要多态就别加 virtual”。
1class Shape { // 抽象类：含纯虚函数，不能实例化2public:3 virtual double area() const = 0; // = 0 纯虚：子类必须实现4 virtual ~Shape() = default;5
6 // 可以有普通成员与实现7 void describe() const {8 std::cout << "面积 = " << area() << "\n"; // 调用延迟到子类9 }10};11
12class Circle : public Shape {13 double r;14public:15 explicit Circle(double r) : r(r) {}16 double area() const override { return 3.14159 * r * r; }17};18
19class Rect : public Shape {20 double w, h;21public:22 Rect(double w, double h) : w(w), h(h) {}23 double area() const override { return w * h; }24};25
26// Shape s; // ❌ 抽象类不能造对象27// Shape* p = new Shape; // ❌ 同上28
29int main() {30 Shape* shapes[] = {new Circle(2), new Rect(3, 4)};31 double total = 0;32 for (auto* s : shapes) {33 s->describe(); // 多态：各算各的面积34 total += s->area();35 }36 std::cout << "总面积 " << total << "\n";37}抽象类 = 接口契约：规定”所有 Shape 必须会算面积”，实现交给子类。纯虚析构除外，接口类通常只含纯虚函数。
1class BadBase {2public:3 ~BadBase() { std::cout << "~BadBase\n"; } // ❌ 非虚析构4};5class BadDerived : public BadBase {6 int* big_;7public:8 BadDerived() : big_(new int[1000]) {}9 ~BadDerived() { delete[] big_; std::cout << "~BadDerived\n"; }10};11
12int main() {13 BadBase* p = new BadDerived();14 delete p; // ⚠ 只输出 ~BadBase！子类析构没执行 → big_ 泄漏 4000 字节15}修正：基类析构函数声明为 virtual ~Base() = default;。军规：只要类会被继承且通过基类指针删除，析构必须是 virtual。
1class Locked : public Base {2public:3 void speak() const final; // final：禁止后代再重写4};5// class Sub : public Locked {}; // 也可 final 整个类：禁止再继承6
7// 运行期类型识别 dynamic_cast（向下转型，需多态类型）8Animal* a = new Dog("旺财");9if (Dog* d = dynamic_cast<Dog*>(a)) { // 成功返回指针，失败返回 nullptr10 d->fetch();11}12
13// typeid 拿到真实类型名14#include <typeinfo>15std::cout << typeid(*a).name(); // 3Dog（名字修饰因编译器而异）综合继承+多态+虚析构+抽象类：
1#include <iostream>2#include <memory>3#include <vector>4#include <string>5#include <random>6
7class Character { // 抽象基类8public:9 Character(std::string name, int hp, int atk)10 : name_(std::move(name)), hp_(hp), atk_(atk) {}11 virtual ~Character() = default;12
13 virtual void attack(Character& target) const = 0; // 纯虚：每种角色攻击方式不同14 virtual void take_damage(int dmg) {15 hp_ -= dmg;16 std::cout << " " << name_ << " 受到 " << dmg17 << " 伤害（剩 " << (hp_ > 0 ? hp_ : 0) << "）\n";18 }19
20 bool alive() const { return hp_ > 0; }21 const std::string& name() const { return name_; }22 int atk() const { return atk_; }23
24protected:25 std::string name_;26 int hp_, atk_;27};28
29class Warrior : public Character { // 战士：稳定输出30public:31 Warrior(const std::string& n) : Character(n, 120, 15) {}32 void attack(Character& t) const override {33 std::cout << name_ << " 挥剑攻击 " << t.name() << "！\n";34 t.take_damage(atk());35 }36};37
38class Mage : public Character { // 法师：30% 概率暴击39public:40 Mage(const std::string& n) : Character(n, 80, 25) {}41 void attack(Character& t) const override {42 static std::mt19937 rng{std::random_device{}()};43 bool crit = std::uniform_int_distribution<>(1, 10)(rng) <= 3;44 int dmg = atk() * (crit ? 2 : 1);45 std::cout << name_ << (crit ? " 释放暴击火球！" : " 释放火球") << "\n";46 t.take_damage(dmg);47 }48};49
50int main() {51 // 智能指针数组管理多态对象52 std::vector<std::unique_ptr<Character>> team = {53 std::make_unique<Warrior>("勇者"),54 std::make_unique<Mage>("大法师"),55 };56 Character* monster = new Warrior("哥布林王");57
58 int round = 1;59 while (monster->alive() &&60 std::any_of(team.begin(), team.end(),61 [](auto& c) { return c->alive(); })) {62 std::cout << "—— 回合 " << round++ << " ——\n";63 for (auto& c : team)64 if (c->alive() && monster->alive())65 c->attack(*monster); // 多态调用66 if (monster->alive())67 monster->attack(*team[0]);68 }69 std::cout << (monster->alive() ? "团灭……" : "胜利！") << "\n";70 delete monster;71}新增”刺客""治疗者”只需继承 Character 实现 attack——对扩展开放，对修改关闭，这就是多态的工程价值。
1// 继承："是一个"（Dog 是 Animal）——强耦合2// 组合："有一个"（Car 有 Engine）——灵活3class Engine { public: void start() {} };4class Car {5 Engine engine_; // 组合6public:7 void start() { engine_.start(); } // 委托8};经验法则：能用组合就用组合，“is-a”关系明确才用继承。
Triangle（三边长，海伦公式）与 SquareEmployee 抽象类 + Manager/Sales：月薪计算方式不同（虚函数 salary()），打印全员工资heal(Character&) 接口与 Priest 职业实现治疗= 0 定义纯虚 → 抽象类不可实例化，作接口契约下一篇：运算符重载与友元——让自定义类型像内置类型一样自然运算。
本系列为 Cyber先锋社原创教程。RPG 案例的扩展性实验（加职业不动主逻辑）是多态最好的注脚。
a + b、cout << obj、obj[i]——内置类型天然支持这些运算，自定义类型也可以。运算符重载让 Money + Money、Vector * Matrix 写起来像数学公式。这是 C++ 区别于多数语言的特性，用好了代码优雅，用滥了灾难现场。
1✅ 可重载：+ - * / % == != < > += -= << >> && || ! [] () -> new...2❌ 不可重载：:: . .* sizeof typeid ?:（三目） .*两条硬规则：
int + int）心法：重载后的行为要符合直觉——+ 就该是加法语义。把 + 重载成减法，同事会杀人。
1class Money {2 long cents_; // 用"分"存，避免浮点误差3public:4 // 成员函数版：左操作数必须是本类5 Money operator+(const Money& rhs) const {6 return Money(cents_ + rhs.cents_);7 }8};9
10// 非成员版（常配友元）：左操作数可以是其他类型11Money operator-(const Money& a, const Money& b);12std::ostream& operator<<(std::ostream&, const Money&); // 流运算符必须非成员选择：会修改左操作数（+=、=、[]）用成员；对称双目（+、==）与流运算符用非成员。
1#include <iostream>2#include <numeric> // std::gcd3
4class Fraction {5 long num_, den_; // 分子/分母6
7 void reduce() { // 内部工具：约分并规范化符号8 long g = std::gcd(num_, den_);9 if (g != 0) { num_ /= g; den_ /= g; }10 if (den_ < 0) { num_ = -num_; den_ = -den_; } // 分母保持正11 }12
13public:14 Fraction(long n, long d = 1) : num_(n), den_(d) {15 if (d == 0) throw std::invalid_argument("分母为零");16 reduce();17 }18
19 // —— 算术：返回新对象，const ——20 Fraction operator+(const Fraction& r) const {21 return Fraction(num_ * r.den_ + r.num_ * den_, den_ * r.den_);22 }23 Fraction operator-(const Fraction& r) const {24 return Fraction(num_ * r.den_ - r.num_ * den_, den_ * r.den_);25 }26 Fraction operator*(const Fraction& r) const {27 return Fraction(num_ * r.num_, den_ * r.den_);28 }29 Fraction operator/(const Fraction& r) const {30 if (r.num_ == 0) throw std::invalid_argument("除以零");31 return Fraction(num_ * r.den_, den_ * r.num_);32 }33
34 // —— 复合赋值：修改自身，返回 *this 引用 ——35 Fraction& operator+=(const Fraction& r) {36 return *this = *this + r; // 复用 operator+37 }38
39 // —— 比较：写成一对，其余用逻辑推导 ——40 bool operator==(const Fraction& r) const {41 return num_ == r.num_ && den_ == r.den_; // 已约分，直接比42 }43 bool operator<(const Fraction& r) const {44 return num_ * r.den_ < r.num_ * den_;45 }46
47 double value() const { return double(num_) / den_; }48 long num() const { return num_; }49 long den() const { return den_; }50};51
52// 非成员：流输出53std::ostream& operator<<(std::ostream& os, const Fraction& f) {54 if (f.den() == 1) return os << f.num();55 return os << f.num() << "/" << f.den();56}57
58int main() {59 Fraction a(1, 2), b(3, 4);60
61 std::cout << a << " + " << b << " = " << a + b << "\n"; // 5/462 std::cout << a << " * " << b << " = " << a * b << "\n"; // 3/863 std::cout << a << " - " << b << " = " << a - b << "\n"; // -1/464 std::cout << (a < b ? "a<b" : "a>=b") << "\n";65
66 Fraction c(2, 4); // 自动约分成 1/267 std::cout << c << "\n"; // 1/268}省力技巧（C++20 <=>）：三路比较一行顶六行：
1// C++20：自动生成 == != < <= > >=2auto operator<=>(const Fraction&) const = default; // 需成员逐一可比较1// << 必须是非成员（左操作数是 ostream，不是我们的类）2std::ostream& operator<<(std::ostream& os, const Fraction& f) {3 return os << f.num() << "/" << f.den(); // 返回 os 引用 → 支持链式4}5
6// >> 输入版7std::istream& operator>>(std::istream& is, Fraction& f) {8 long n, d;9 char slash;10 if (is >> n >> slash >> d && slash == '/')11 f = Fraction(n, d); // 输入合法才更新12 else13 is.setstate(std::ios::failbit); // 标记失败14 return is;15}16// 用法：std::cout << a << " " << b << "\n"; 链式全靠返回 os1class IntArray {2 std::vector<int> data_;3public:4 explicit IntArray(size_t n) : data_(n) {}5
6 int& operator[](size_t i) { return data_.at(i); } // 可写版本7 const int& operator[](size_t i) const { return data_.at(i); } // 只读版本8
9 size_t size() const { return data_.size(); }10};11
12IntArray arr(5);13arr[0] = 42; // 调可写版14std::cout << arr[0]; // 调只读版（const 场景）1class Multiplier { // "行为像函数的对象"2 int factor_;3public:4 explicit Multiplier(int f) : factor_(f) {}5 int operator()(int x) const { // 重载调用运算符6 return x * factor_;7 }8};9
10Multiplier triple(3);11std::cout << triple(10); // 30——像调用函数一样使用对象12
13// STL 中 lambda 本质就是编译器生成的仿函数类！14auto quadruple = [](int x) { return x * 4; };1class Fraction {2 // ...3public:4 explicit operator double() const { // 显式转 double5 return double(num_) / den_;6 }7};8
9Fraction f(1, 2);10double d = static_cast<double>(f); // ✓ 显式转换11// double e = f; // ❌ explicit 禁止隐式转换（防意外）1class BankAccount {2 friend std::ostream& operator<<(std::ostream&, const BankAccount&);3 // ↑ 声明这个函数是"朋友"：允许它访问我的 private4
5private:6 std::string owner_;7 double balance_;8
9public:10 BankAccount(std::string o, double b) : owner_(std::move(o)), balance_(b) {}11};12
13// 友元函数不是成员函数，但能访问私有成员14std::ostream& operator<<(std::ostream& os, const BankAccount& acc) {15 return os << acc.owner_ << ": ¥" << acc.balance_; // ✓ 访问 private16}17
18int main() {19 BankAccount a("小明", 100.5);20 std::cout << a << "\n"; // 小明: ¥100.521}1class Matrix;2class MatrixIterator {3 friend class Matrix; // Matrix 的所有成员函数都可访问我的私有4 // ...5};友元三原则：friend 是”授予”而非”索取”（类自己声明谁是我朋友）；友元破坏封装，能不用就不用；合法场景：运算符重载、紧密协作的类对（Container 与它的 Iterator）。
友元不被继承、不是双向的、不传递。
| 场景 | 建议 |
|---|---|
| 数学类型（向量/分数/矩阵/复数） | ✅ 重载 + - * /，天然合适 |
| 逻辑比较（排序、去重需要） | ✅ < ==（配 STL 容器） |
| 输出调试 | ✅ << |
&& ` | |
逗号 ，、取地址 & | ❌ 语义迷惑，别碰 |
为了少打字把 + 当”追加”用于文件/网络 | ⚠ 语义存疑，用命名方法 append 更清晰 |
1#include <iostream>2#include <cmath>3
4class Vec2 {5 double x_, y_;6public:7 Vec2(double x = 0, double y = 0) : x_(x), y_(y) {}8
9 Vec2 operator+(const Vec2& r) const { return {x_ + r.x_, y_ + r.y_}; }10 Vec2 operator-(const Vec2& r) const { return {x_ - r.x_, y_ - r.y_}; }11 Vec2 operator*(double k) const { return {x_ * k, y_ * k}; } // 数乘12 Vec2 operator-() const { return {-x_, -y_}; } // 取负13
14 bool operator==(const Vec2& r) const { return x_==r.x_ && y_==r.y_; }15
16 double dot(const Vec2& r) const { return x_ * r.x_ + y_ * r.y_; }17 double length() const { return std::sqrt(dot(*this)); } // 复用 dot18
19 double& operator[](size_t i) { return i == 0 ? x_ : y_; } // v[0]/v[1]20
21 friend std::ostream& operator<<(std::ostream& os, const Vec2& v) {22 return os << "(" << v.x_ << ", " << v.y_ << ")";23 }24};25
26Vec2 operator*(double k, const Vec2& v) { return v * k; } // 3*v 也成立27
28int main() {29 Vec2 a(1, 2), b(3, 4);30
31 std::cout << "a=" << a << " b=" << b << "\n";32 std::cout << "a+b=" << a + b << "\n"; // (4, 6)33 std::cout << "a·b=" << a.dot(b) << "\n"; // 1134 std::cout << "|b|=" << b.length() << "\n"; // 535 std::cout << "3a=" << 3 * a << "\n"; // (3, 6)36
37 Vec2 c = a + b * 2; // 数学式表达式38 std::cout << c[0] << "," << c[1] << "\n"; // 7,1039}>= <= > !=（用 < 和 == 组合实现）Temperature 类：内部存摄氏，operator+、转华氏方法、<< 输出两种温标Str 简易字符串类：operator+ 拼接、operator[] 访问、operator== 比较Accumulator 仿函数：每次 () 调用累加并返回累计值（对比第六篇闭包计数器）operator<< 不能是成员函数？为什么 operator+= 通常是成员而 operator+ 常是非成员？&&/|| 别重载（失短路）+= = [] ()），对称与流用非成员（+ == << >>）*this&<< 返回 ostream 引用支撑链式；C++20 <=> 一行生成全套比较operator() 是 lambda 的本质下一篇：STL 标准模板库总览——容器、迭代器与算法的完整武器库。
本系列为 Cyber先锋社原创教程。Fraction 与 Vec2 是面试白板题常客，建议默写一遍。
STL（Standard Template Library） 是 C++ 自带的”兵器库”：6+ 种容器、几十个算法、通用迭代器粘合两者。学完本篇，你写 C++ 的效率会翻倍——不再手写链表、排序、查找，组合现成部件即可。
1STL 三大件：2├── 容器（Containers）：存数据 vector / list / map / set ...3├── 迭代器（Iterators）：胶水 统一遍历所有容器的方式4└── 算法（Algorithms）：处理数据 sort / find / count / accumulate ...5+ 仿函数 & lambda：算法的"策略参数"头文件速记：容器各有头（<vector> <map>…），算法统一 <algorithm>，数值算法 <numeric>。
1#include <vector>2
3std::vector<int> v{3, 1, 4};4v.push_back(5);5v.reserve(100); // 预留容量，避免反复扩容拷贝6std::cout << v.capacity() << " " << v.size(); // 100 41#include <deque>2
3std::deque<int> dq{2, 3};4dq.push_front(1); // 头部 O(1)！5dq.push_back(4); // {1,2,3,4}6dq.pop_front(); // {2,3,4}vs vector：头插头删 O(1)，但内存不连续（缓存稍差）。需要双端操作选它。
1#include <list>2
3std::list<int> lst{1, 2, 4};4auto it = std::next(lst.begin()); // 指向 25lst.insert(it, 3); // {1,2→3,4} 任意位置 O(1)6lst.remove(2); // 按值删7lst.sort(); // list 自带 sort（std::sort 不支持它）8lst.splice(lst.end(), another_list); // O(1) 拼接另一链表list 的取舍：中间插删 O(1) 但不支持随机访问 [i]（要 O(n) 走链）、缓存不友好。90% 场景 vector 更快——包括”中间插删”（vector 移动内存飞快），实测再说。
| vector | deque | list | |
|---|---|---|---|
| 随机访问 | O(1) | O(1) | O(n) |
| 头插删 | O(n) | O(1) | O(1) |
| 中间插删 | O(n) | O(n) | O(1)（有迭代器） |
| 内存 | 连续 | 分块 | 节点散布 |
| 默认选择 | ⭐ | 双端需求 | 特殊链表需求 |
1#include <map>2#include <string>3
4std::map<std::string, int> ages;5
6// 插入三种方式7ages["小明"] = 18; // 不存在则插入，存在则覆盖8ages.insert({"小红", 17});9ages.emplace("小刚", 19); // 原地构造（推荐）10
11// 安全访问：at 越界抛异常，[] 越界会"悄悄创建"！12try { ages.at("不存在"); } catch (const std::out_of_range&) { }13int cnt = ages.count("小明"); // 0 或 114// ages["不存在的键"]; // ⚠ 危险：会插入默认值！15
16// 遍历（按键自动排序）17for (const auto& [name, age] : ages) // 结构化绑定18 std::cout << name << " " << age << "\n";19
20// 查找21if (auto it = ages.find("小明"); it != ages.end())22 std::cout << it->second << "\n";map::operator[] 对不存在的键会插入默认值——只读查询场景永远用 find 或 count，这是 map 的第一大坑。
1#include <set>2
3std::set<int> s{3, 1, 4, 1, 5}; // {1,3,4,5} 自动去重排序4s.insert(2);5s.erase(1);6
7if (s.count(3)) std::cout << "3 在集合\n";8std::cout << s.size(); // 41#include <unordered_map>2
3std::unordered_map<std::string, int> fast;4fast["apple"] = 5;5// 接口与 map 完全一致！区别在实现：6// map 红黑树 查找 O(log n) 键有序遍历7// unordered 哈希表 查找 O(1) 均摊 遍历无序选型：需要有序遍历/范围查询用 map/set；纯查找用 unordered（更快，日常默认）。
允许重复键：std::multimap<std::string, int> 一个键多个值（如一个学生多门课成绩）。
1std::vector<int> v{1,2,3};2std::map<std::string,int> m{{"a",1}};3
4for (auto it = v.begin(); it != v.end(); ++it)5 std::cout << *it;6
7for (const auto& [k, val] : m) // 范围 for 底层就是迭代器8 std::cout << k << val;1std::vector<int> v{10, 20, 30, 40, 50};2
3auto it = v.begin();4std::advance(it, 2); // 前进 2 → 指向 305int d = std::distance(v.begin(), it); // 26auto it2 = std::next(v.begin()); // 第二个（原迭代器不动）7auto it3 = std::prev(v.end()); // 最后一个8
9// ⚠ 迭代器失效头号场景：边遍历边删10// for (auto it = v.begin(); it != v.end(); ++it)11// if (*it % 2) v.erase(it); // ❌ erase 后 it 失效！12
13// ✅ 正确姿势：用 erase 的返回值14for (auto it = v.begin(); it != v.end(); )15 if (*it % 2 != 0) it = v.erase(it); // erase 返回下一个有效迭代器16 else ++it;1#include <algorithm>2#include <numeric>3
4std::vector<int> v{3, 1, 4, 1, 5, 9, 2, 6};5
6std::find(v.begin(), v.end(), 5); // 找值，end()=没找到7std::count(v.begin(), v.end(), 1); // 28std::accumulate(v.begin(), v.end(), 0); // 31 求和（<numeric>）9std::max_element(v.begin(), v.end()); // 指向 9 的迭代器10std::minmax_element(v.begin(), v.end()); // pair<min_it, max_it>11
12// 条件版13auto cnt_even = std::count_if(v.begin(), v.end(),14 [](int x){ return x % 2 == 0; });15auto it_big = std::find_if(v.begin(), v.end(),16 [](int x){ return x > 5; });1std::sort(v.begin(), v.end()); // 升序2std::sort(v.begin(), v.end(), std::greater<int>()); // 降序3std::stable_sort(...); // 稳定（相等保持原序）4std::partial_sort(v.begin(), v.begin()+3, v.end()); // 只排前 35
6std::reverse(v.begin(), v.end());7std::transform(v.begin(), v.end(), v.begin(), // 原地变换8 [](int x){ return x * x; });9
10std::vector<int> dst(v.size());11std::copy(v.begin(), v.end(), dst.begin());1// remove 只把"要删的"挪到末尾，返回新逻辑末尾——容器 size 不变！2auto new_end = std::remove_if(v.begin(), v.end(),3 [](int x){ return x < 3; });4v.erase(new_end, v.end()); // 真正删除（erase-remove 惯用法）1std::sort(v.begin(), v.end());2bool found = std::binary_search(v.begin(), v.end(), 5); // 是否存在3auto lb = std::lower_bound(v.begin(), v.end(), 5); // 第一个 >= 54auto ub = std::upper_bound(v.begin(), v.end(), 5); // 第一个 > 55std::cout << ub - lb << "\n"; // 值 5 的个数1#include <map>2#include <sstream>3#include <iostream>4#include <vector>5#include <algorithm>6
7int main() {8 std::string text = "the quick the lazy the dog and the end";9 std::map<std::string, int> freq;10
11 std::istringstream ss(text);12 std::string word;13 while (ss >> word) ++freq[word]; // 一行完成计数！14
15 // 按次数降序输出：搬进 vector 排序16 std::vector<std::pair<std::string, int>> items(freq.begin(), freq.end());17 std::sort(items.begin(), items.end(),18 [](const auto& a, const auto& b){ return a.second > b.second; });19
20 for (const auto& [w, c] : items)21 std::cout << w << ": " << c << "\n";22}1struct Record { std::string name; int score; };2
3int main() {4 std::vector<Record> records = {5 {"小明", 90}, {"小红", 85}, {"小刚", 92}, {"小红", 88}, // 小红两次6 };7
8 // 1. 总分与平均（accumulate + lambda 初始化值注意类型）9 int total = std::accumulate(records.begin(), records.end(), 0,10 [](int sum, const Record& r){ return sum + r.score; });11 std::cout << "平均 " << total / double(records.size()) << "\n";12
13 // 2. 每人最高分（map<string,int>）14 std::map<std::string, int> best;15 for (const auto& r : records)16 best[r.name] = std::max(best[r.name], r.score); // 默认 0 起步17
18 // 3. 排名（拷贝+排序，不破坏原序）19 auto ranked = records;20 std::sort(ranked.begin(), ranked.end(),21 [](const Record& a, const Record& b){ return a.score > b.score; });22
23 // 4. 及格人数24 auto passed = std::count_if(records.begin(), records.end(),25 [](const Record& r){ return r.score >= 60; });26}| 需求 | 容器 |
|---|---|
| 动态数组（默认） | vector |
| 双端频繁插删 | deque |
| 键值查找（默认） | unordered_map |
| 键值 + 有序遍历 | map |
| 去重集合（默认） | unordered_set |
| 有序集合/排行 | set |
| 一键多值 | multimap / unordered_map<K, vector<V>> |
| 优先队列（堆） | priority_queue（进阶了解） |
map<char,int> 统计字符串各字符出现次数，输出出现最多的字符vector<string> + sort + unique + eraseerase-remove 惯用法删除 vector 中所有负数accumulate 计算字符串向量所有元素的总长度map[] 会插入默认值，只读用 find/count下一篇：异常处理与文件 IO——系列的收官与综合实战。
本系列为 Cyber先锋社原创教程。STL 的熟练度 = C++ 的日常生产力，练习 5 的库存系统务必完整实现。
最后两块拼图：异常处理（出错不崩）与文件 IO（数据持久化），随后用一个综合项目收官全系列——做一个支持增删改查、文件持久化的通讯录管理系统。
1#include <iostream>2#include <stdexcept>3
4double safe_divide(double a, double b) {5 if (b == 0)6 throw std::invalid_argument("除数不能为零"); // 抛出异常对象7 return a / b;8}9
10int main() {11 try {12 std::cout << safe_divide(10, 2) << "\n"; // 513 std::cout << safe_divide(1, 0) << "\n"; // 这里抛出14 std::cout << "永远执行不到\n";15 }16 catch (const std::invalid_argument& e) { // 按类型捕获17 std::cout << "参数错误: " << e.what() << "\n";18 }19 catch (const std::exception& e) { // 基类兜底（顺序：子类在前！）20 std::cout << "其他异常: " << e.what() << "\n";21 }22 catch (...) { // 万能兜底23 std::cout << "未知异常\n";24 }25}与 Python 的差异：C++ 用对象抛出（不是字符串）、按类型匹配 catch、catch 顺序敏感（子类必须放基类前面）。
1std::exception ← 所有标准异常的基类2├── logic_error ← 程序逻辑错误（可预防）3│ ├── invalid_argument 参数非法4│ ├── out_of_range 下标越界（vector::at 抛的就是它）5│ └── length_error 超长6└── runtime_error ← 运行期才能发现7 ├── overflow_error 算术上溢8 ├── underflow_error 下溢9 └── range_error 值域错误10
11另有：bad_alloc（new 失败，<new>）、bad_cast（<typeinfo>）1#include <stdexcept>2#include <string>3
4class InsufficientFundsError : public std::runtime_error {5 double shortfall_;6public:7 explicit InsufficientFundsError(double shortfall)8 : std::runtime_error("余额不足，还差 " + std::to_string(shortfall) + " 元")9 , shortfall_(shortfall) {}10
11 double shortfall() const { return shortfall_; } // 附带业务数据12};13
14void withdraw(double balance, double amount) {15 if (amount > balance)16 throw InsufficientFundsError(amount - balance);17 // ...18}19
20int main() {21 try { withdraw(100, 150); }22 catch (const InsufficientFundsError& e) {23 std::cout << e.what() << "\n"; // 余额不足，还差 50.000000 元24 std::cout << "缺口: " << e.shortfall(); // 附带数据25 }26}1// noexcept 承诺"此函数不抛异常"——编译器可优化，违诺直接 std::terminate2void pure_compute(int x) noexcept { /* 不抛任何东西 */ }3
4// 异常抛出时的"栈展开"：沿途所有局部对象析构函数被依次调用5// → RAII 对象在异常路径同样安全释放（这就是 RAII 伟大的原因）6void demo() {7 FileLogger log("app.log"); // 第八篇的 RAII 类8 throw std::runtime_error("boom");9} // log 的析构依然执行，文件被正确关闭！异常安全军规：资源交给 RAII 对象管理，异常来了自动清理；不要在析构函数里抛异常。
1#include <fstream>2#include <iostream>3#include <string>4
5int main() {6 // —— 写文件（ofstream）——7 std::ofstream out("diary.txt"); // 默认覆盖模式8 if (!out) { // 检查打开是否成功！9 std::cerr << "无法创建文件\n";10 return 1;11 }12 out << "2026-10-29 学完 C++ 文件IO\n";13 out << "今天写了 " << 3 << " 个模块\n";14 out.close(); // 可显式关，析构也会关15
16 // 追加模式17 std::ofstream append("diary.txt", std::ios::app);18 append << "追加一行\n";19
20 // —— 读文件（ifstream）——21 std::ifstream in("diary.txt");22 if (!in) { std::cerr << "文件不存在\n"; return 1; }23
24 std::string line;25 while (std::getline(in, line)) // 逐行读（自动去 \n）26 std::cout << "> " << line << "\n";27
28 // 第二种：流提取（按空格分词）29 std::ifstream in2("diary.txt");30 std::string word;31 while (in2 >> word)32 std::cout << word << "\n";33}| 模式 | 含义 |
|---|---|
std::ios::in | 读 |
std::ios::out | 写（截断） |
std::ios::app | 追加 |
std::ios::ate | 打开即定位到末尾 |
std::ios::binary | 二进制模式 |
1std::ifstream f("data.txt");2if (!f.is_open()) { /* 打不开 */ }3if (f.eof()) { /* 读到文件尾 */ }4f.clear(); // 清除错误状态（重读前）1#include <sstream>2
3// 字符串 → 数值：split 一行 CSV4std::string line = "小明,18,90.5";5std::stringstream ss(line);6std::string name; int age; double score;7std::getline(ss, name, ',');8ss >> age; ss.ignore(1, ','); // 跳过逗号9ss >> score;10
11// 数值 → 字符串（to_string 之外的格式化方式）12std::ostringstream os;13os << "成绩: " << std::fixed << std::setprecision(1) << score;14std::string result = os.str();全系列知识集大成：struct + vector + STL 算法 + 异常 + 文件持久化 + 菜单循环。
1// ===== contacts.cpp 完整可编译运行 =====2// g++ contacts.cpp -o contacts -std=c++173#include <iostream>4#include <fstream>5#include <sstream>6#include <vector>7#include <string>8#include <algorithm>9#include <iomanip>10
11struct Contact {12 std::string name;13 std::string phone;14 std::string group; // 分组：朋友/家人/同学...15};16
17class ContactBook {18 std::vector<Contact> data_;19 const std::string path_ = "contacts.txt";20
21public:22 class ContactError : public std::runtime_error {23 public: using std::runtime_error::runtime_error;24 };25
26 ContactBook() { load(); }27 ~ContactBook() { save(); }28
29 void add(const std::string& name, const std::string& phone,30 const std::string& group) {31 if (name.empty()) throw ContactError("姓名不能为空");32 if (find(name)) throw ContactError("联系人已存在: " + name);33 data_.push_back({name, phone, group});34 }35
36 bool remove(const std::string& name) {37 auto it = std::remove_if(data_.begin(), data_.end(),38 [&](const Contact& c){ return c.name == name; });39 if (it == data_.end()) return false;40 data_.erase(it, data_.end()); // erase-remove 惯用法41 return true;42 }43
44 const Contact* find(const std::string& name) const {45 auto it = std::find_if(data_.begin(), data_.end(),46 [&](const Contact& c){ return c.name == name; });47 return it == data_.end() ? nullptr : &*it;48 }49
50 void list_by_group() const { // 分组有序输出51 std::map<std::string, std::vector<std::string>> groups;52 for (const auto& c : data_)53 groups[c.group].push_back(c.name + " (" + c.phone + ")");54
55 for (const auto& [g, names] : groups) {56 std::cout << "【" << g << "】\n";57 for (const auto& n : names) std::cout << " " << n << "\n";58 }59 }60
61 void search(const std::string& keyword) const { // 模糊查找62 std::cout << "搜索 \"" << keyword << "\":\n";63 for (const auto& c : data_)64 if (c.name.find(keyword) != std::string::npos ||65 c.phone.find(keyword) != std::string::npos)66 std::cout << " " << c.name << " " << c.phone67 << " [" << c.group << "]\n";68 }69
70 size_t size() const { return data_.size(); }71
72private:73 void load() { // 每行: name,phone,group74 std::ifstream in(path_);75 if (!in) return;76 std::string line;77 while (std::getline(in, line)) {78 std::stringstream ss(line);79 std::string n, p, g;80 if (std::getline(ss, n, ',') &&81 std::getline(ss, p, ',') &&82 std::getline(ss, g))83 data_.push_back({n, p, g});84 }85 }86 void save() const {87 std::ofstream out(path_); // 覆盖重写88 for (const auto& c : data_)89 out << c.name << "," << c.phone << "," << c.group << "\n";90 }91};92
93int main() {94 ContactBook book;95
96 std::cout << "=== 通讯录 ===\n"97 << "add 名字 电话 分组 | del 名字 | find 名字 | "98 "search 关键词 | list | quit\n";99
100 std::string cmd;101 while (true) {102 std::cout << "\n> ";103 if (!(std::cin >> cmd)) break;104
105 try {106 if (cmd == "quit") break;107 else if (cmd == "add") {108 std::string n, p, g;109 std::cin >> n >> p >> g;110 book.add(n, p, g);111 std::cout << "✅ 已添加 " << n << "（共 " << book.size() << " 人）\n";112 }113 else if (cmd == "del") {114 std::string n; std::cin >> n;115 std::cout << (book.remove(n) ? "🗑 已删除" : "没找到") << "\n";116 }117 else if (cmd == "find") {118 std::string n; std::cin >> n;119 const Contact* c = book.find(n);120 if (c) std::cout << c->name << " " << c->phone121 << " [" << c->group << "]\n";122 else std::cout << "没找到\n";123 }124 else if (cmd == "search") { std::string k; std::cin >> k; book.search(k); }125 else if (cmd == "list") { book.list_by_group(); }126 else std::cout << "未知命令\n";127 }128 catch (const ContactBook::ContactError& e) {129 std::cout << "❌ " << e.what() << "\n";130 }131 }132 std::cout << "数据已保存，再见！\n"; // 析构也会 save133}用到的知识点清单：struct、class 封装、vector + 算法（find_if/remove_if）、map 分组、异常（自定义 + try/catch）、文件读写（ifstream/ofstream）、stringstream 解析、RAII（析构自动保存）。
运行演示：
1> add 小明 138xxxx 同学2✅ 已添加 小明（共 1 人）3> add 小红 139xxxx 家人4✅ 已添加 小红（共 2 人）5> add 小明 137xxxx 朋友6❌ 联系人已存在: 小明7> list8【同学】9 小明 (138xxxx)10【家人】11 小红 (139xxxx)12> quit13数据已保存，再见！| 篇 | 主题 | 关键收获 |
|---|---|---|
| 1 | 环境与第一个程序 | g++ 编译流程、main、cout/cin |
| 2 | 语法与运算符 | 七类运算、类型转换、cin 校验 |
| 3 | 流程控制 | switch/循环/范围 for/经典练习 |
| 4 | 函数 | 声明定义分离、三种传参、重载、默认参数 |
| 5 | 数组与字符串 | 数组局限、vector/string 全家桶 |
| 6 | 指针与引用 | 内存模型、new/delete、智能指针 |
| 7 | 结构体与枚举 | 自定义类型、enum class |
| 8 | 面向对象（上） | 封装、构造析构、三法则、RAII |
| 9 | 面向对象（下） | 继承、虚函数多态、抽象类、虚析构 |
| 10 | 运算符重载 | 算术/流/下标重载、友元 |
| 11 | STL | 容器选型、迭代器、算法库 |
| 12 | 异常/IO/实战（本篇） | try/catch、文件流、综合项目 |
下一步：数据结构与算法（用 C++ 实现一遍链表/栈/队列/树）、或挑战小型项目（JSON 解析器、简易 HTTP 服务器、贪吃蛇）。做出作品欢迎投稿本站！
GuessGame 类，含 play() 与统计功能本系列为 Cyber先锋社原创教程，共 12 篇完结。欢迎在留言板晒出你的毕业设计！
“一次编写，到处运行”（Write Once, Run Anywhere）是 Java 的招牌。它能做到这一点，靠的是 JVM（Java 虚拟机）：Java 源代码先编译成”字节码”（.class 文件），再由各平台的 JVM 执行——同一个字节码能在 Windows、macOS、Linux 上运行。
Java 是企业级开发的主力语言：银行系统、安卓 App、大型电商后端、大数据生态（Hadoop/Spark 均为 Java 系）都有它的身影。岗位多、生态成熟，是就业市场的常青树。
初学必懂的三层概念：
1JDK（开发工具包）2 ├── JRE（运行环境）3 │ ├── JVM（虚拟机：真正执行字节码）4 │ └── 核心类库5 ├── javac（编译器）6 └── 其他开发工具Windows/macOS：从 Adoptium（Eclipse Temurin 发行版）下载安装包，一路下一步。
Linux（Ubuntu/Debian）：
1sudo apt update && sudo apt install openjdk-21-jdk1java -version # 运行环境版本2javac -version # 编译器版本两个命令都有输出即安装成功。
Java 开发的事实标准 IDE 是 IntelliJ IDEA（JetBrains 出品）：
新手完全可以用 Community 社区版起步，功能足够写完整个入门系列。
新建 Hello.java（文件名必须与类名一致，这是 Java 的硬规矩）：
1public class Hello {2 public static void main(String[] args) {3 System.out.println("Hello, Cyber先锋社!");4 }5}编译运行：
1javac Hello.java # 生成 Hello.class 字节码2java Hello # JVM 执行（注意不带 .class 后缀）3Hello, Cyber先锋社!在 IDEA 里只需右键 → Run，IDE 会自动完成编译执行。
解剖这个程序：
| 部分 | 含义 |
|---|---|
public class Hello | 定义一个公开类，类名与文件名一致 |
public static void main(String[] args) | 主方法：程序入口，格式固定照抄 |
System.out.println(...) | 向控制台输出一行内容 |
; | 每条语句以分号结尾 |
Java 对大小写极其敏感：System 写成 system 直接报错。main 方法的签名必须一字不差。
Java 同样是静态类型语言，且区分基本类型与引用类型：
1public class Types {2 public static void main(String[] args) {3 // 基本类型（8 种，入门先掌握这几种）4 int age = 18; // 整数5 long views = 10000000000L; // 长整数（注意 L 后缀）6 double price = 9.9; // 双精度浮点7 char grade = 'A'; // 单字符，单引号8 boolean passed = true; // 布尔值9
10 // 引用类型：字符串（双引号）11 String name = "小明";12
13 // var 关键字（Java 10+）：编译器自动推断类型14 var message = "类型推断";15
16 System.out.println(name + " " + age + " 岁");17 System.out.printf("价格: %.2f 元%n", price); // 格式化输出18 }19}| 类型 | 字节 | 说明 |
|---|---|---|
byte | 1 | 小整数 ±128 |
int | 4 | 常用整数 ±21 亿 |
long | 8 | 大整数，字面量加 L |
double | 8 | 常用小数 |
char | 2 | 单字符（Unicode） |
boolean | — | true / false |
1int a = 10;2double b = a; // 自动转换（小 → 大，安全）3
4double pi = 3.99;5int c = (int) pi; // 强制转换（大 → 小，截断小数），c = 3Java 读键盘输入用 Scanner 类：
1import java.util.Scanner; // 导包2
3public class InputDemo {4 public static void main(String[] args) {5 Scanner sc = new Scanner(System.in);6
7 System.out.print("输入你的名字: ");8 String name = sc.next(); // 读一个词9
10 System.out.print("输入你的年龄: ");11 int age = sc.nextInt(); // 读一个整数12
13 System.out.println(name + " 明年 " + (age + 1) + " 岁");14 sc.close();15 }16}学到这里可以横向看看三姐妹的差异：
| 特性 | Python | C++ | Java |
|---|---|---|---|
| 执行方式 | 解释执行 | 编译为机器码 | 编译为字节码 + JVM |
| 类型系统 | 动态 | 静态 | 静态 |
| 语法复杂度 | 最低 | 最高 | 中等 |
| 典型用途 | AI、脚本、数据 | 游戏、系统、嵌入式 | 企业后端、安卓 |
| 入门友好度 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ |
Scanner 读入长和宽，输出矩形面积与周长printf 的 %.2f）javac 编译 → java 运行；IDEA 可以一键搞定public 类名一致；main 方法是固定入口String 引用类型；var 可自动推断Scanner 处理键盘输入，用完记得 close()下一篇：流程控制与方法——把逻辑组织成可复用的积木。
本系列为 Cyber先锋社原创教程，参考业界通用知识体系编写。
上一篇跑通了第一个程序，本篇夯实 Java 语法地基：类型系统、运算符、输入输出。Java 是强类型语言的典范——类型规则比 Python 严、比 C++ 更”啰嗦”但更统一。
1// 单行注释2
3/* 多行注释 */4
5/**6 * 文档注释（javadoc）：IDE 悬停提示、官方文档都靠它7 * @param a 加数8 * @return 两数之和9 */10public static int add(int a, int b) { return a + b; }Java 命名惯例（社区铁律）：
| 元素 | 规范 | 示例 |
|---|---|---|
| 类名 | 大驼峰 | StudentManager |
| 方法/变量 | 小驼峰 | calcAverage、maxScore |
| 常量 | 全大写下划线 | MAX_SIZE |
| 包名 | 全小写 | com.club.utils |
1public class Types {2 public static void main(String[] args) {3 // 整数家族4 byte b = 127; // 1字节 ±1285 short s = 32000; // 2字节6 int i = 2147483647; // 4字节（默认整数字面量类型）7 long big = 10000000000L; // 8字节（注意 L 后缀！）8
9 // 浮点家族10 float f = 3.14f; // 4字节（注意 f 后缀！）11 double d = 3.14159265358979; // 8字节（默认小数字面量类型）12
13 // 其他14 char c = 'A'; // 2字节 Unicode 单字符15 char chinese = '先'; // ✓ 中文也是 char16 boolean ok = true; // true/false（不是 1/0！）17
18 // 类型大小永不变（跨平台一致，这是 Java 的卖点）19 System.out.println(Integer.SIZE / 8); // 4 字节20 }21}与 C++ 不同：Java 的 boolean 不是整数，if (1) 直接编译错误；char 是 16 位 Unicode。
1var name = "小明"; // String2var age = 18; // int3var scores = new int[]{90, 85}; // int[]4// var x; // ❌ 必须初始化5// var 只能用于局部变量，不能用于字段和参数1public class Config {2 public static final double TAX_RATE = 0.13; // 类级常量：final + static3 public static final int MAX_RETRY = 3;4}5
6final int LOCAL_MAX = 100; // 局部常量：赋值后不可改7// LOCAL_MAX = 200; // ❌ 编译错误1public class Demo {2 static int a; // 03 static double d; // 0.04 static boolean flag; // false5 static String s; // null（引用类型默认 null）6 // ⚠ 局部变量没有默认值，未初始化直接用 → 编译错误7}1int i = 100;2long l = i; // ✓ int → long3double d = l; // ✓ long → double4double d2 = 10; // ✓ int 字面量直接给 double5
6char c = 'A';7int code = c; // ✓ 651double pi = 3.99;2int truncated = (int) pi; // 3（直接截断，不是四舍五入！）3
4long big = 10000000000L;5int overflow = (int) big; // 1410065408（高位截断，结果诡异）6
7// 经典陷阱：两个 int 相除8System.out.println(7 / 2); // 3（int 除法！）9System.out.println(7 / 2.0); // 3.5（一侧 double 则 double）10System.out.println((double) 7 / 2); // 3.5（先转再除）1int max = Integer.MAX_VALUE;2System.out.println(max + 1); // -2147483648（静默回绕！C++ 是未定义，Java 规定为回绕）3
4long safe = (long) max + 1; // ✓ 先升格再运算5// 大数运算用 long，再大用 java.math.BigInteger1int a = 10, b = 3;2
3System.out.println(a + b); // 134System.out.println(a - b); // 75System.out.println(a * b); // 306System.out.println(a / b); // 3 整除截断7System.out.println(a % b); // 1 取模（Java 的 % 可用于负数与浮点）8System.out.println(-7 % 3); // -1（余数符号跟被除数）9System.out.println(7.5 % 2); // 1.5（浮点取模合法！C++ 不行）10
11// ++ 与 --12int i = 5;13System.out.println(i++); // 5 先用后加14System.out.println(++i); // 7 先加后用1int a = 5, b = 10;2
3System.out.println(a > b); // false4
5// 逻辑运算符：& && | || !6boolean r1 = (a > 0) && (b > 0); // 短路与（推荐日常用）7boolean r2 = (a > 0) & (b > 0); // 非短路与（两边都算，位运算语义）8boolean r3 = (a > 0) || (b < 0); // 短路或9
10// ⚠ 经典面试点：短路与否影响副作用11int x = 0;12boolean r = (x != 0) && (++x > 0); // 左边 false，右边不执行13System.out.println(x); // 014
15// Java 特有：异或 ^16System.out.println(true ^ false); // true1int a = 0b1010;2
3System.out.println(a & 0b0110); // 24System.out.println(a | 0b0101); // 155System.out.println(a ^ 0b1111); // 56System.out.println(~a); // -117System.out.println(a << 2); // 408System.out.println(a >> 1); // 5 算术右移（补符号位）9System.out.println(-8 >>> 1); // 2147483644 逻辑右移（Java 特有 >>>，补 0）1int age = 20;2String status = age >= 18 ? "成年" : "未成年";3
4// instanceof：判断引用类型（面向对象篇重用）5Object obj = "hello";6if (obj instanceof String) {7 System.out.println("长度: " + ((String) obj).length());8}9
10// Java 16+ 模式匹配版（免强转）11if (obj instanceof String s) {12 System.out.println("长度: " + s.length());13}! > 算术 > 比较 > & > ^ > | > && > || > 三元 > 赋值。拿不准就加括号。
1import java.util.Scanner;2
3public class Input {4 public static void main(String[] args) {5 Scanner sc = new Scanner(System.in);6
7 System.out.print("姓名: ");8 String name = sc.next(); // 读一个词9
10 sc.nextLine(); // ⚠ 清掉残留换行（经典坑）11
12 System.out.print("整行介绍: ");13 String intro = sc.nextLine(); // 读整行14
15 System.out.print("年龄: ");16 if (sc.hasNextInt()) { // 先判断再读（防崩）17 int age = sc.nextInt();18 System.out.printf("%s，%d岁%n", name, age);19 } else {20 System.out.println("年龄必须是数字");21 }22
23 System.out.print("成绩(double): ");24 double score = sc.nextDouble();25 sc.close();26 }27}next 与 nextLine 混用坑：nextInt() 不消耗行尾换行符，之后紧跟 nextLine() 会读到空串——中间补一次 sc.nextLine() 冲掉。
1double price = 9.87654;2int n = 42;3
4System.out.printf("两位小数: %.2f%n", price); // 9.885System.out.printf("宽度10右对齐: [%10.2f]%n", price);6System.out.printf("宽度10左对齐: [%-10.2f]%n", price);7System.out.printf("补零: %08d%n", n); // 000000428System.out.printf("千分位: %,d%n", 1234567890); // 1,234,567,8909System.out.printf("百分比: %.1f%%%n", 0.856); // 85.6%10System.out.printf("类型: %s / %d / %b / %c%n", "文本", 1, true, 'A');11
12// %n 是跨平台换行符；String.format 同款语法返回字符串13String s = String.format("排名 No.%03d", 7);1System.out.println(Math.abs(-5)); // 52System.out.println(Math.max(3, 7)); // 73System.out.println(Math.min(3, 7)); // 34System.out.println(Math.sqrt(16)); // 4.05System.out.println(Math.pow(2, 10)); // 1024.06System.out.println(Math.round(3.5)); // 4（四舍五入，区别于强转截断）7System.out.println(Math.ceil(3.1)); // 4.0 向上8System.out.println(Math.floor(3.9)); // 3.0 向下9System.out.println(Math.random()); // [0,1) 随机1// 1. 整数除法2System.out.println((1 + 2) / 2); // 1 不是 1.53
4// 2. char 参与算术5char c = 'A';6System.out.println(c + 1); // 66（int）7System.out.println((char)(c + 1)); // B8
9// 3. = 与 ==（编译器会拦大部分，但 boolean 变量场景要小心）10boolean done = false;11if (done = true) { } // ⚠ 合法但几乎必是 bug12
13// 4. 负数取模14System.out.println(-10 % 3); // -1（跟被除数）15
16// 5. float 精度（金额别用 float/double！）17System.out.println(0.1 + 0.2 == 0.3); // false18// 金额用 long 存"分"，或 java.math.BigDecimalX天X小时X分X秒(char)('a' + 3) 输出什么？写循环打印 a-z（char 与 int 的关系）int 逆序输出各位数字（12345 → 5 4 3 2 1；循环 + % /）long 加 L、float 加 f；boolean 不是整数&&/|| 短路；>>> 是 Java 特有逻辑右移下一篇：流程控制——分支、循环与 Java 的 switch 表达式。
本系列为 Cyber先锋社原创教程。类型转换的每个例子请上机验证，坑见一次胜过听十次。
Java 的流程控制与 C/C++ 同源，但更安全（编译器更严格），且 Java 14+ 引入了现代的 switch 表达式。本篇全覆盖，含经典练习。
1import java.util.Scanner;2
3public class Grade {4 public static void main(String[] args) {5 Scanner sc = new Scanner(System.in);6 int score = sc.nextInt();7
8 if (score >= 90) {9 System.out.println("优秀");10 } else if (score >= 80) {11 System.out.println("良好");12 } else if (score >= 60) {13 System.out.println("及格");14 } else {15 System.out.println("不及格");16 }17 }18}与 C++ 唯一显著差异：Java 条件必须是 boolean——if (score = 90) 这种笔误直接编译错误（比 C++ 安全）。
1public class Calculator {2 public static void main(String[] args) {3 char op = '+';4 int a = 3, b = 4;5
6 switch (op) {7 case '+':8 System.out.println(a + b);9 break; // ⚠ 照样会贯穿！10 case '-':11 System.out.println(a - b);12 break;13 case '*':14 case 'x': // 多标签共享分支15 System.out.println(a * b);16 break;17 default:18 System.out.println("不支持");19 }20 }21}switch 支持的类型：byte/short/char/int、String（Java 7+！）、枚举。不支持 long、double、float。
箭头语法：不贯穿、不用 break、可直接返回值：
1public class Week {2 public static void main(String[] args) {3 int day = 6;4
5 // ① 箭头分支（无贯穿烦恼）6 String type = switch (day) {7 case 1, 2, 3, 4, 5 -> "工作日";8 case 6, 7 -> "周末";9 default -> "非法日期"; // 必须穷尽！有 default 才编译通过10 };11 System.out.println(type); // 周末12
13 // ② 带代码块的分支（yield 返回值）14 String detail = switch (day) {15 case 6, 7 -> {16 String name = (day == 6) ? "周六" : "周日";17 yield name + "休息"; // yield 产出值18 }19 default -> "上班";20 };21 System.out.println(detail);22 }23}新语法三大优点：不贯穿、强制穷尽（编译器查漏）、能当表达式赋值。新代码一律用它。
1int a = 10, b = 20;2int max = a > b ? a : b;1// 1~100 求和2int sum = 0, i = 1;3while (i <= 100) {4 sum += i;5 i++;6}7System.out.println(sum); // 50508
9// do-while：至少执行一次（菜单场景）10int choice;11do {12 System.out.println("1.开始 0.退出");13 // choice = 读入...14 choice = 0; // 演示用15} while (choice != 0);1for (int i = 1; i <= 9; i++) {2 System.out.printf("%d ", i * i);3}4
5// 多变量版本6for (int i = 0, j = 10; i < j; i++, j--) {7 System.out.println(i + " " + j);8}9
10// 死循环11for (;;) { }12while (true) { }1int[] nums = {10, 20, 30};2for (int n : nums) {3 System.out.println(n);4}5
6String[] langs = {"Java", "Python", "C++"};7for (String lang : langs) {8 System.out.println(lang);9}限制：拿不到下标、遍历中不能修改数组元素（只读便利）。
1// 常规：作用于本层2for (int i = 0; i < 10; i++) {3 if (i == 5) break; // 0~44 if (i % 2 == 0) continue; // 跳过偶数5 System.out.println(i);6}7
8// Java 特色：标签跳转（直接跳出多层循环，goto 的安全版）9outer:10for (int i = 1; i <= 9; i++) {11 for (int j = 1; j <= 9; j++) {12 if (i * j > 30) {13 break outer; // 一口气跳出两层！14 }15 System.out.printf("%d×%d=%d ", i, j, i * j);16 }17 System.out.println();18}19
20// continue outer：跳到外层下一轮标签语法是 Java 对”多层循环跳出”的正规解（C++ 只能用标志变量或 goto）。
1for (int i = 1; i <= 9; i++) {2 for (int j = 1; j <= i; j++) {3 System.out.printf("%d×%d=%-4d", j, i, i * j);4 }5 System.out.println();6}1static boolean isPrime(int n) {2 if (n < 2) return false;3 for (int i = 2; (long) i * i <= n; i++) { // i*i 防溢出用 long 比4 if (n % i == 0) return false;5 }6 return true;7}8
9public static void main(String[] args) {10 int count = 0;11 for (int n = 2; n < 100; n++) {12 if (isPrime(n)) {13 System.out.printf("%d ", n);14 count++;15 }16 }17 System.out.println("\n共 " + count + " 个");18}1for (int n = 100; n < 1000; n++) {2 int a = n / 100, b = n / 10 % 10, c = n % 10;3 if (a*a*a + b*b*b + c*c*c == n)4 System.out.println(n); // 153 370 371 4075}1int n = 5; // 菱形半径2for (int i = -n; i <= n; i++) {3 int row = n - Math.abs(i); // 当前行星数半径4 for (int s = 0; s < Math.abs(i); s++) System.out.print(" ");5 for (int j = 0; j < 2 * row + 1; j++) System.out.print("*");6 System.out.println();7}1import java.util.Random;2import java.util.Scanner;3
4public class Guess {5 public static void main(String[] args) {6 Random rand = new Random();7 int answer = rand.nextInt(100) + 1; // 1~1008 Scanner sc = new Scanner(System.in);9 int tries = 0;10
11 while (true) {12 System.out.print("猜(1-100): ");13 if (!sc.hasNextInt()) { // 输入校验14 System.out.println("请输入数字！" + sc.next() + " 被忽略");15 continue;16 }17 int guess = sc.nextInt();18 tries++;19
20 if (guess < answer) System.out.println("小了");21 else if (guess > answer) System.out.println("大了");22 else {23 System.out.println("对了！用了 " + tries + " 次");24 break;25 }26 }27 }28}1// 方式1：Random 类（推荐）2import java.util.Random;3Random rand = new Random();4int n = rand.nextInt(100) + 1; // 1~1005double d = rand.nextDouble(); // [0,1)6boolean b = rand.nextBoolean();7
8// 方式2：Math.random()9int m = (int)(Math.random() * 100) + 1;10
11// 固定种子 → 可复现（测试用）12Random seeded = new Random(42);(y%4==0&&y%100!=0)||y%400==0）下一篇：方法与数组——Java 版的函数与第一批容器。
本系列为 Cyber先锋社原创教程。五个经典练习独立完成后再看参考，效果翻倍。
Java 的函数叫方法（method），必须定义在类里；数组是 Java 最原始的容器。本篇讲透两者的规则与工具，为面向对象做准备。
1public class MathUtils {2
3 // 修饰符 返回类型 方法名(参数列表)4 public static int add(int a, int b) {5 return a + b;6 }7
8 // 无返回值用 void9 public static void printLine(int n) {10 for (int i = 0; i < n; i++) System.out.print("-");11 System.out.println();12 // void 方法可单独 return 提前结束13 }14
15 public static void main(String[] args) {16 int sum = add(3, 4); // 类内调用静态方法可省类名17 MathUtils.add(1, 2);18 printLine(20);19 }20}方法签名 = 方法名 + 参数列表（返回值不算）。static 意义在面向对象篇详讲，本系列目前统一加。
Java 只有值传递——传基本类型是拷贝值，传引用类型是拷贝”地址值”：
1static void tryChange(int x) { x = 100; } // 改副本，无效2
3static void changeElement(int[] arr) { arr[0] = 100; } // 通过地址改内容，有效！4
5static void changeRef(int[] arr) { arr = new int[]{9}; } // 改的是地址副本，无效6
7public static void main(String[] args) {8 int n = 5;9 tryChange(n);10 System.out.println(n); // 511
12 int[] a = {1, 2, 3};13 changeElement(a);14 System.out.println(a[0]); // 100（内容被改）15
16 int[] b = {1};17 changeRef(b);18 System.out.println(b[0]); // 1（b 还是指向原数组）19}类比：引用类型传的是”门牌号复印件”——拿着复印件能进屋搬东西（改内容），但把复印件改成新地址不影响你手里的原件（改指向）。
1public static int max(int a, int b) { return a > b ? a : b; }2public static double max(double a, double b) { return a > b ? a : b; }3public static int max(int a, int b, int c) { return max(max(a, b), c); }4
5max(3, 7); // int 版6max(3.5, 2.5); // double 版7max(1, 9, 4); // 三参版重载规则：参数个数/类型/顺序不同即可；仅返回值不同不行。JDK 的 System.out.println 有 10 个重载——这就是重载的日常。
1// 类型... 名字 = 语法糖，本质是数组2public static int sum(int... nums) {3 int total = 0;4 for (int n : nums) total += n;5 return total;6}7
8sum(); // 09sum(1, 2); // 310sum(new int[]{1,2,3}); // 6（直接传数组也行）11
12// ⚠ 可变参数必须是最后一个参数13public static void log(String level, Object... args) { }1public static long factorial(int n) {2 if (n <= 1) return 1;3 return n * factorial(n - 1);4}5// factorial(20) 已接近 long 上限（选对类型！）1// 静态初始化（定长不可变！）2int[] scores = {90, 85, 78, 92, 66};3int[] primes = new int[]{2, 3, 5, 7};4
5// 动态初始化（定容，默认值填充）6int[] nums = new int[5]; // {0,0,0,0,0}7String[] names = new String[3]; // {null, null, null}8
9// 长度是属性（不是方法！）10System.out.println(scores.length); // 511
12// C 风格声明 int scores[] 也合法，但不推荐Java 数组长度固定、越界访问抛 ArrayIndexOutOfBoundsException（运行期异常，比 C++ 裸数组安全）。要动态长度用 ArrayList（第六篇集合）。
1int[] v = {3, 1, 4, 1, 5};2
3// ① 经典下标4for (int i = 0; i < v.length; i++)5 System.out.println(i + ": " + v[i]);6
7// ② 增强 for8for (int n : v)9 System.out.println(n);10
11// ③ 带索引的函数式（Java 8+，尝鲜）12java.util.Arrays.stream(v)13 .forEach(n -> System.out.println(n));14
15// 求 max/min/sum16int max = v[0];17for (int n : v) if (n > max) max = n;18
19int sum = 0;20for (int n : v) sum += n;21System.out.printf("max=%d avg=%.1f%n", max, sum / (double) v.length);1import java.util.Arrays;2
3int[] v = {5, 3, 8, 1, 9};4
5// 打印（toString 解决"打印数组显示乱码地址"问题）6System.out.println(Arrays.toString(v)); // [5, 3, 8, 1, 9]7
8// 排序（原地）9Arrays.sort(v); // [1, 3, 5, 8, 9]10
11// 查找（必须先有序！返回下标，-1 = 没找到）12int idx = Arrays.binarySearch(v, 8); // 313
14// 填充15int[] filled = new int[5];16Arrays.fill(filled, 7); // [7,7,7,7,7]17
18// 拷贝（真正的复制，不是引用）19int[] copy = Arrays.copyOf(v, v.length);20int[] part = Arrays.copyOfRange(v, 1, 4); // 下标 [1,4) 的子数组21
22// 比较（内容比较，== 比较的是地址！）23int[] a = {1, 2};24int[] b = {1, 2};25System.out.println(a == b); // false（两个对象）26System.out.println(Arrays.equals(a, b)); // true（内容相等）1int[][] matrix = {2 {1, 2, 3},3 {4, 5, 6},4 {7, 8, 9},5};6
7System.out.println(matrix.length); // 3（行数）8System.out.println(matrix[0].length); // 3（列数）9
10// 遍历求和11int total = 0;12for (int i = 0; i < matrix.length; i++)13 for (int j = 0; j < matrix[i].length; j++)14 total += matrix[i][j];15
16// 不规则数组（每行长度可以不同——Java 数组本质是"数组的数组"）17int[][] ragged = new int[3][];18ragged[0] = new int[1];19ragged[1] = new int[2];20ragged[2] = new int[3];21
22// 打印二维：deepToString23System.out.println(Arrays.deepToString(matrix));1public class ArgsDemo {2 public static void main(String[] args) {3 // java ArgsDemo hello 424 for (String arg : args)5 System.out.println(arg); // hello \n 426 // args 是命令行参数数组（不含类名）7 }8}1import java.util.Arrays;2
3public class ScoreAnalyzer {4 static int max(int[] a) {5 int m = a[0];6 for (int x : a) if (x > m) m = x;7 return m;8 }9
10 static double average(int[] a) {11 int s = 0;12 for (int x : a) s += x;13 return s / (double) a.length;14 }15
16 public static void main(String[] args) {17 int[] scores = {90, 85, 78, 92, 66, 88, 73};18
19 int[] sorted = scores.clone(); // 复制后排，不破坏原序20 Arrays.sort(sorted);21
22 System.out.println("原始: " + Arrays.toString(scores));23 System.out.println("排序: " + Arrays.toString(sorted));24 System.out.printf("最高 %d 最低 %d 平均 %.1f%n",25 max(scores), sorted[0], average(scores));26 System.out.println("中位数: " +27 (sorted.length % 2 == 128 ? sorted[sorted.length / 2]29 : (sorted[sorted.length/2 - 1] + sorted[sorted.length/2]) / 2.0));30
31 // 高于平均分的比例32 double avg = average(scores);33 long above = Arrays.stream(scores).filter(x -> x > avg).count();34 System.out.println("高于平均: " + above + " 人");35 }36}1public class Transpose {2 public static void main(String[] args) {3 int[][] m = {{1, 2, 3}, {4, 5, 6}};4
5 int[][] t = new int[m[0].length][m.length];6 for (int i = 0; i < m.length; i++)7 for (int j = 0; j < m[0].length; j++)8 t[j][i] = m[i][j];9
10 System.out.println(Arrays.deepToString(t));11 // [[1, 4], [2, 5], [3, 6]]12 }13}area：圆（半径）、长方形（宽高）、三角形（三边海伦公式）static void reverse(int[] arr) 原地反转数组（双指针交换，不用新数组）static int[] merge(int[] a, int[] b)：合并两个有序数组为有序数组（归并思想）int... 本质数组，必须放最后下一篇：面向对象（上）——类、对象、构造方法与封装。
本系列为 Cyber先锋社原创教程。“值传递本质”的三个实验请务必亲手跑一遍。
Java 是纯面向对象语言——一切代码都在类里。本篇讲 OOP 第一支柱封装：类的设计规范、构造方法、this、static 与包管理。Java 的 OOP 比 C++ 更”强制”也更统一。
1public class Student {2 // 成员变量（字段）—— 对象的属性3 private String name;4 private int age;5 private double score;6
7 // 构造方法 —— 创建对象的入口8 public Student(String name, int age, double score) {9 this.name = name; // this.name 是字段，name 是参数10 this.age = age;11 this.score = score;12 }13
14 // 无参构造（重载）15 public Student() {16 this("未命名", 0, 0); // this(...) 调用另一个构造17 }18
19 // getter / setter —— 封装的对外接口20 public String getName() { return name; }21
22 public void setAge(int age) {23 if (age < 0 || age > 150) { // setter 里做校验！24 throw new IllegalArgumentException("年龄非法: " + age);25 }26 this.age = age;27 }28 public int getAge() { return age; }29
30 public double getScore() { return score; }31
32 // 成员方法 —— 对象的行为33 public void study(String course) {34 System.out.println(name + " 正在学习 " + course);35 }36
37 public String introduce() {38 return String.format("我是%s，%d岁，成绩%.1f", name, age, score);39 }40}1public class Main {2 public static void main(String[] args) {3 Student ming = new Student("小明", 18, 90.5); // new 创建对象4 Student anon = new Student();5
6 ming.study("Java");7 System.out.println(ming.introduce());8 System.out.println(anon.introduce());9
10 ming.setAge(19); // ✓ 走 setter 校验11 // ming.setAge(-1); // 抛 IllegalArgumentException —— 封装的价值12 }13}对象内存图（理解关键）：new 在堆里开辟对象空间，变量 ming 存的是它的引用（地址）；多个变量可引用同一对象。
1Student a = new Student("小明", 18, 90);2Student b = a; // b 和 a 指向同一个对象！3b.setAge(20);4System.out.println(a.getAge()); // 205System.out.println(a == b); // true（同一地址）字段私有 + 公有 getter/setter + 无参构造——行业通用的数据类写法，IDE 与框架都认这个约定（IDEA 里 Alt+Insert 一键生成）。
1public class Account {2 private String owner;3 private double balance;4
5 public Account(String owner) {6 this.owner = owner; // ① 区分字段与同名参数7 }8
9 public Account(String owner, double balance) {10 this(owner); // ② this(...) 调用兄弟构造（必须第一行）11 this.balance = balance;12 }13
14 public Account deposit(double amount) {15 if (amount > 0) this.balance += amount;16 return this; // ③ 返回自身 → 链式调用17 }18}19
20new Account("小明", 100).deposit(50).deposit(30);1// 反例：字段公开2public class Bad {3 public double balance; // 任何代码都能写 account.balance = -9994}5
6// 正例：私有字段 + 校验入口7public class Good {8 private double balance; // 外部不可见9
10 public void deposit(double amount) {11 if (amount <= 0) throw new IllegalArgumentException("金额必须为正");12 balance += amount; // 修改必经校验13 }14 public double getBalance() { return balance; }15}封装心法：字段全部 private，外界只通过方法访问——所有修改必须经过你的检查，不变量（余额非负）由类自己守护。
1public class GameCharacter {2 // 静态字段：全类共享一份（不属于任何对象）3 private static int createdCount = 0;4 static final int MAX_LEVEL = 99; // 静态常量5
6 // 实例字段：每个对象一份7 private String name;8 private int level;9
10 public GameCharacter(String name) {11 this.name = name;12 this.level = 1;13 createdCount++; // 每创建一个 +114 }15
16 // 静态方法：属于类，没有 this（不能访问实例成员！）17 public static int getCreatedCount() {18 // System.out.println(this.name); // ❌ 编译错误，静态无 this19 return createdCount;20 }21
22 public static void main(String[] args) {23 new GameCharacter("勇者");24 new GameCharacter("法师");25
26 System.out.println(GameCharacter.getCreatedCount()); // 2（用类名调）27 System.out.println(GameCharacter.MAX_LEVEL);28 }29}静态 vs 实例决策：跟着对象走的（名字、等级）→ 实例成员；全类共享/统计/常量/工具方法 → 静态成员。
main 为什么是 static：程序启动时还没有任何对象，JVM 只能用类名调起入口。
1// 文件 src/com/club/utils/MathUtils.java2package com.club.utils; // 第一行声明包（对应目录结构）3
4public class MathUtils {5 public static boolean isPrime(int n) { /* ... */ return true; }6}7
8// 使用方9import com.club.utils.MathUtils; // 导入10
11public class Main {12 public static void main(String[] args) {13 MathUtils.isPrime(7);14 }15}IDEA 建 com.club.utils 包，把类放进去即可自动管理。
| 修饰符 | 本类 | 同包 | 子类 | 其他包 |
|---|---|---|---|---|
private | ✓ | |||
| （默认，不写） | ✓ | ✓ | ||
protected | ✓ | ✓ | ✓ | |
public | ✓ | ✓ | ✓ | ✓ |
实用建议：字段 private；方法按需要 public；仅供包内协作的用默认/protected。
1import java.util.ArrayList;2import java.util.List;3
4public class Library {5 // ===== 内部数据类 =====6 private static class Book {7 private final String isbn;8 private final String title;9 private boolean borrowed;10
11 Book(String isbn, String title) {12 this.isbn = isbn;13 this.title = title;14 }15 String getTitle() { return title; }16 String getIsbn() { return isbn; }17 boolean isBorrowed() { return borrowed; }18 }19
20 // ===== 业务异常 =====21 public static class LibraryException extends RuntimeException {22 LibraryException(String msg) { super(msg); }23 }24
25 // ===== 状态封装在 Library 内 =====26 private final List<Book> books = new ArrayList<>();27
28 public void addBook(String isbn, String title) {29 if (findBook(isbn) != null)30 throw new LibraryException("ISBN 已存在: " + isbn);31 books.add(new Book(isbn, title));32 }33
34 public void borrow(String isbn) {35 Book b = requireBook(isbn);36 if (b.borrowed)37 throw new LibraryException("《" + b.getTitle() + "》已借出");38 b.borrowed = true;39 }40
41 public void giveBack(String isbn) {42 requireBook(isbn).borrowed = false;43 }44
45 public void listAll() {46 System.out.println("—— 馆藏 " + books.size() + " 本 ——");47 for (Book b : books)48 System.out.printf("%-14s %-20s %s%n",49 b.getIsbn(), b.getTitle(),50 b.isBorrowed() ? "[借出]" : "[在架]");51 }52
53 private Book findBook(String isbn) { // 私有工具方法54 for (Book b : books)55 if (b.getIsbn().equals(isbn)) return b;56 return null;57 }58
59 private Book requireBook(String isbn) {60 Book b = findBook(isbn);61 if (b == null) throw new LibraryException("无此书: " + isbn);62 return b;63 }64
65 public static void main(String[] args) {66 Library lib = new Library();67 lib.addBook("978-7-111", "Java 核心技术");68 lib.addBook("978-7-115", "算法（第4版）");69
70 lib.borrow("978-7-111");71 lib.listAll();72
73 try {74 lib.borrow("978-7-111"); // 重复借75 } catch (LibraryException e) {76 System.out.println("❌ " + e.getMessage());77 }78 lib.giveBack("978-7-111");79 lib.listAll();80 }81}设计观察：Book 是 private static 内部类（外界无需知道它的存在）、books 私有（只能通过借/还改变状态）、所有业务错误抛统一异常——这就是封装的完整形态。ArrayList 细节下下篇讲。
Rectangle JavaBean：私有宽高 + getter/setter（负数抛异常）+ area()/perimeter()Counter 类：静态字段统计创建的对象数、实例方法 id() 返回自己的序号BankAccount：私有余额，deposit/withdraw（不足抛异常）、静态方法统计总账户数与总存款com.club.shape 包放 Shape 类、com.club.main 包写 Main 调用（练习 package/import）compareTo 风格方法 betterThan(Student other) 按成绩比较，main 里造 3 个对象找学霸== 比地址、内容比较用 equals（第七篇详讲）下一篇：面向对象（下）——继承、多态、接口与抽象类，Java OOP 的完全体。
本系列为 Cyber先锋社原创教程。IDEA 的 Alt+Insert（生成 getter/setter/构造）先练熟，生产力 ×10。
OOP 剩余两大支柱继承与多态，以及 Java 的招牌——接口。Spring 等主流框架的根基全在本篇。学完后你能读懂 JDK 源码结构和绝大多数 Java 项目的类设计。
1// 父类2class Animal {3 protected String name; // protected：子类可用4
5 public Animal(String name) {6 this.name = name;7 }8
9 public void eat() {10 System.out.println(name + " 在吃东西");11 }12}13
14// 子类：Java 单继承（一个类只能 extends 一个父类）15class Dog extends Animal {16 private String breed;17
18 public Dog(String name, String breed) {19 super(name); // ⚠ 必须第一行：调用父类构造20 this.breed = breed;21 }22
23 public void fetch() { // 子类新增方法24 System.out.println(name + " 去捡球");25 }26}27
28Dog d = new Dog("旺财", "柴犬");29d.eat(); // 继承的30d.fetch(); // 自己的构造顺序：父类构造先执行（super）→ 子类构造。不写 super(…) 时编译器默认补 super()（父类必须有无参构造，否则报错）。
1class Cat extends Animal {2 public Cat(String name) { super(name); }3
4 @Override // 注解：让编译器检查重写合法性5 public void eat() { // 方法签名与父类完全一致6 System.out.println(name + "：吃小鱼干");7 }8}重写规则（两同两小一大）：
@Override 必写——拼写错误、签名不匹配时编译器立刻报错。
1Animal a1 = new Dog("旺财", "柴犬"); // 向上转型：子对象当父类型用2Animal a2 = new Cat("咪咪");3
4a1.eat(); // ？——调用谁的 eat？5a2.eat();6// 输出：旺财 在吃东西 / 咪咪：吃小鱼干7// dog 覆写了 eat → 运行期按真实对象类型绑定！8// a1.fetch(); ❌ 编译错误：Animal 类型看不见 Dog 特有方法多态三条件：继承体系 + 方法重写 + 父类引用指向子类对象。
编译看左、运行看右：能调什么方法由引用类型（左边）决定，实际执行哪个版本由对象类型（右边）决定。
1public class Zoo {2 public static void feedAll(Animal[] animals) { // 一个方法管所有动物3 for (Animal a : animals) {4 a.eat(); // 各自动态绑定5 }6 }7
8 public static void main(String[] args) {9 feedAll(new Animal[]{10 new Dog("旺财", "柴犬"),11 new Cat("咪咪"),12 new Animal("神秘生物"),13 });14 }15}新增 Bird 子类？feedAll 一行不改——开闭原则。
1Animal a = new Dog("旺财", "柴犬");2
3if (a instanceof Dog) { // 先判断再转（否则 ClassCastException）4 Dog d = (Dog) a; // 向下转型：恢复子类能力5 d.fetch();6}7
8// Java 16+ 模式匹配（一步到位）9if (a instanceof Dog d) {10 d.fetch(); // d 已就绪11}1abstract class Shape { // abstract 类不能 new2 protected String name;3
4 protected Shape(String name) { this.name = name; }5
6 public abstract double area(); // 抽象方法：无实现，子类必须实现7
8 public void describe() { // 普通方法：可复用9 System.out.printf("%s 的面积 = %.2f%n", name, area()); // 多态调用10 }11}12
13class Circle extends Shape {14 private final double r;15 public Circle(double r) { super("圆"); this.r = r; }16
17 @Override18 public double area() { return Math.PI * r * r; }19}20
21class Rect extends Shape {22 private final double w, h;23 public Rect(double w, double h) { super("矩形"); this.w = w; this.h = h; }24
25 @Override26 public double area() { return w * h; }27}28
29// Shape s = new Shape("x"); ❌ 抽象类不能实例化30Shape s = new Circle(2);31s.describe();抽象类定位：模板/半成品——提取公共部分（字段、实现），强制子类完成”填空”（抽象方法）。
1// 接口：纯契约（方法默认 public abstract）2interface Comparable2<T> {3 int compareTo(T other); // 抽象方法4}5
6interface Swimmer {7 void swim();8
9 // Java 8+ 允许默认方法（有实现！）10 default void swimFast() {11 System.out.println("加速游动");12 }13
14 // Java 8+ 静态方法15 static void info() {16 System.out.println("游泳接口 v1.0");17 }18}19
20interface Walker {21 void walk();22}23
24// 类可实现多个接口（多继承能力的替代品！）25class Duck implements Swimmer, Walker {26 @Override27 public void swim() { System.out.println("鸭子划水"); }28 @Override29 public void walk() { System.out.println("鸭子摇摆走"); }30}31
32Duck d = new Duck();33d.swim(); d.walk(); d.swimFast(); // 默认方法直接用34Swimmer.info(); // 静态方法接口名调| 维度 | 抽象类 | 接口 |
|---|---|---|
| 关键词 | extends 单继承 | implements 多实现 |
| 字段 | 任意 | 只能 public static final 常量 |
| 构造方法 | 有 | 无 |
| 方法 | 抽象+具体 | 抽象+default+static |
| 语义 | “是什么”（is-a，模板） | “能做什么”（can-do，能力） |
经验：定义”身份与模板”用抽象类（Animal）；定义”能力”用接口（Comparable、Runnable、Swimmer）——类可以同时是动物并能游泳能跑。
1interface Storage {2 void save(String key, String value);3 String load(String key);4}5
6class MemoryStorage implements Storage {7 private final java.util.Map<String, String> data = new java.util.HashMap<>();8 public void save(String k, String v) { data.put(k, v); }9 public String load(String k) { return data.get(k); }10}11
12class FileStorage implements Storage { // 换个实现...13 public void save(String k, String v) { /* 写文件 */ }14 public String load(String k) { return null; }15}16
17// 使用方只依赖接口——实现随换随用（这就是"解耦"）18public class App {19 private final Storage storage; // 面向接口20
21 public App(Storage storage) { // 构造注入（Spring 核心思想雏形）22 this.storage = storage;23 }24
25 public void run() {26 storage.save("token", "abc123");27 System.out.println(storage.load("token"));28 }29
30 public static void main(String[] args) {31 new App(new MemoryStorage()).run(); // 内存版32 new App(new FileStorage()).run(); // 文件版——App 一行不改33 }34}所有类隐式继承 Object，三个方法必须会改写：
1class Money {2 private final long cents;3
4 Money(long cents) { this.cents = cents; }5
6 // 1. equals：内容比较（== 才是引用比较）7 @Override8 public boolean equals(Object o) {9 if (this == o) return true; // 同一对象10 if (!(o instanceof Money)) return false; // 类型检查11 return cents == ((Money) o).cents;12 }13
14 // 2. hashCode：equals 相等 → hashCode 必须相等（HashMap 约定）15 @Override16 public int hashCode() { return Long.hashCode(cents); }17
18 // 3. toString：打印友好19 @Override20 public String toString() { return "¥" + cents / 100.0; }21}22
23Money a = new Money(1050), b = new Money(1050);24System.out.println(a.equals(b)); // true25System.out.println(a); // ¥10.526// IDEA：Alt+Insert 一键生成三者，日常用工具生成只重写 equals 不重写 hashCode 是大坑——HashMap/HashSet 会”找不到”相等的对象。永远两个一起改。
1final class Sealed { } // final 类：禁止继承（如 String）2// class Sub extends Sealed {} ❌3
4class Tool {5 public final void spec() { } // final 方法：禁止重写6 public static void main(String[] args) {7 final int X = 10; // final 变量：常量8 }9}1import java.util.List;2
3interface Area {4 double area();5 // 接口 default 提供组合逻辑6 default double areaDifference(Area other) {7 return this.area() - other.area();8 }9}10
11class Circle2 implements Area {12 private final double r;13 Circle2(double r) { this.r = r; }14 @Override public double area() { return Math.PI * r * r; }15 @Override public String toString() { return String.format("圆(r=%.1f)", r); }16}17
18class Square implements Area {19 private final double side;20 Square(double side) { this.side = side; }21 @Override public double area() { return side * side; }22 @Override public String toString() { return String.format("正方形(边%.1f)", side); }23}24
25public class Shapes {26 public static void main(String[] args) {27 List<Area> shapes = List.of(new Circle2(2), new Square(3));28
29 double total = 0;30 Area biggest = shapes.get(0);31 for (Area s : shapes) {32 System.out.printf("%s = %.2f%n", s, s.area());33 total += s.area();34 if (s.area() > biggest.area()) biggest = s;35 }36 System.out.printf("总面积 %.2f，最大的是 %s%n", total, biggest);37 System.out.printf("圆比正方形大 %.2f%n",38 shapes.get(0).areaDifference(shapes.get(1)));39 }40}Employee 抽象类 + Manager（底薪+提成）/Sales（底薪+件数）重写 salary()Flyable/Swimmable，类 Duck 实现两个、Plane 只实现飞行，用多态数组演示Point 类：正确重写 equals/hashCode/toString，放入 HashSet 验证去重Comparator<T> 实现”按成绩降序”比较器（第六篇预告集合排序）下一篇：常用类库——String 深入、包装类、日期时间与数学工具。
本系列为 Cyber先锋社原创教程。接口优先的思维方式是读懂 Spring 全家源码的钥匙。
日常 Java 开发 80% 的时间在和字符串、包装类、日期打交道。本篇把 JDK 自带的核心类库讲透——特别是那些”面试必考、实战必踩”的坑。
1String s = "hello";2s.toUpperCase(); // 产生新对象 "HELLO"3System.out.println(s); // hello——原串纹丝不动！4
5s = s.toUpperCase(); // ✓ 必须接住返回值String 内部的字符数组是 final 的——任何”修改”操作都返回新对象。好处：线程安全、可作 HashMap 的键、字符串常量池可复用。
1// 字面量赋值：进常量池，同字面量共享一个对象2String a = "hello";3String b = "hello";4System.out.println(a == b); // true（常量池同一对象）5
6// new 出来的：堆里新对象7String c = new String("hello");8System.out.println(a == c); // false（地址不同！）9System.out.println(a.equals(c)); // true（内容相同）10
11// 拼接陷阱：编译期能确定的进池，运行期拼接产生新对象12String d = "hel" + "lo"; // 编译期合并13System.out.println(a == d); // true14
15String part = "lo";16String e = "hel" + part; // 运行期拼接17System.out.println(a == e); // false！18System.out.println(a == e.intern());// true（intern 取常量池版本）铁律：字符串内容比较永远用 equals，== 只用来判断”是不是同一个对象”。
1String s = " Hello, Java World ";2
3System.out.println(s.length()); // 204System.out.println(s.trim()); // 去两端空白 "Hello, Java World"5System.out.println(s.strip()); // Java 11+（还能处理全角空格）6
7System.out.println(s.charAt(1)); // 'H'8System.out.println(s.indexOf("Java")); // 89System.out.println(s.contains("Java")); // true10System.out.println(s.startsWith(" He")); // true11System.out.println(s.endsWith(" ")); // true12
13System.out.println(s.substring(8, 12)); // "Java"（含头不含尾）14System.out.println(s.replace("Java", "Python"));15System.out.println("a,b,c".split(",").length); // 316System.out.println("ab".repeat(3)); // ababab（Java 11+）17
18System.out.println("abc".toUpperCase());19System.out.println("ABC".toLowerCase());20System.out.println("".isEmpty()); // true21System.out.println(" ".isBlank()); // true（Java 11+ 纯空白）22System.out.println(String.join("-", "2026", "10", "29")); // 2026-10-2923
24// 文本块（Java 15+）：多行字符串25String json = """26 {27 "name": "小明",28 "age": 1829 }""";1String input = /* 可能为 null */ null;2
3// ❌ if (input.equals("")) → NPE 空指针4// ✅ 常量放前面 / 先判 null5if (input == null || input.isEmpty()) { }6if (input != null && "yes".equals(input)) { } // 常量在前防 NPE1// ❌ 循环里 + 拼接：每次循环产生新 String 对象，O(n²)2String result = "";3for (int i = 0; i < 10000; i++) {4 result += i;5}6
7// ✅ StringBuilder：内部可变字符数组，O(n)8StringBuilder sb = new StringBuilder();9for (int i = 0; i < 10000; i++) {10 sb.append(i);11}12String fast = sb.toString();13
14sb.append("-").append(42).append("!"); // 链式15sb.insert(0, "头");16sb.deleteCharAt(sb.length() - 1);17sb.reverse(); // 反转| 类 | 可变 | 线程安全 | 场景 |
|---|---|---|---|
| String | ✗ | ✓（不可变天然安全） | 绝大多数场景 |
| StringBuilder | ✓ | ✗ | 单线程拼接（默认） |
| StringBuffer | ✓ | ✓（synchronized） | 多线程（如今少见） |
1int → Integer double → Double char → Character2long → Long boolean → Boolean ...（其余同名首字母大写）3
4// 自动装箱/拆箱（编译器语法糖）5Integer boxed = 42; // 装箱：Integer.valueOf(42)6int raw = boxed; // 拆箱：boxed.intValue()7
8// 手动转换9Integer m = Integer.valueOf(42);10int n = m.intValue();11
12// 字符串互转（高频！）13int age = Integer.parseInt("18"); // String → int14double d = Double.parseDouble("3.14");15String s = String.valueOf(42); // 数 → String16String t = Integer.toString(42);1Integer a = 127, b = 127;2System.out.println(a == b); // true（-128~127 有缓存，同一对象）3
4Integer c = 128, d = 128;5System.out.println(c == d); // false！超出缓存范围，各自 new6System.out.println(c.equals(d)); // true7
8// 铁律：包装类比较一律 equals拆箱空指针：
1Integer score = null;2int s = score; // ❌ NullPointerException（null 拆箱炸）数据库字段/外部输入可能为 null 时，用 Integer 并先判空。
1import java.math.BigDecimal;2import java.math.RoundingMode;3
4// ⚠ 别用 new BigDecimal(0.1)——浮点误差原样带入！5BigDecimal a = new BigDecimal("0.1"); // ✓ 用字符串构造6BigDecimal b = BigDecimal.valueOf(0.1); // ✓ 或 valueOf7
8System.out.println(a.add(b)); // 0.2（精确！）9System.out.println(new BigDecimal("10").divide(10 new BigDecimal("3"), 2, RoundingMode.HALF_UP)); // 3.3311
12// 比较用 compareTo（equals 会连精度一起比：1.0 != 1.00）13new BigDecimal("1.0").compareTo(new BigDecimal("1.00")); // 0（相等）14new BigDecimal("1.0").equals(new BigDecimal("1.00")); // false！15
16// 金额展示17BigDecimal price = new BigDecimal("99.999");18System.out.println(price.setScale(2, RoundingMode.HALF_UP)); // 100.00老的
Date/SimpleDateFormat有线程安全与设计问题，新项目一律用 java.time。
1import java.time.*;2import java.time.format.DateTimeFormatter;3
4// —— 三大核心类型 ——5LocalDate date = LocalDate.now(); // 2026-10-29（仅日期）6LocalTime time = LocalTime.now(); // 12:30:45.123（仅时间）7LocalDateTime dt = LocalDateTime.now(); // 日期+时间8
9LocalDate birthday = LocalDate.of(2006, 6, 1);10LocalDateTime specific = LocalDateTime.of(2026, 10, 29, 14, 30);11
12// —— 格式化与解析 ——13DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");14System.out.println(dt.format(fmt)); // 2026年10月29日 12:30:4515LocalDateTime parsed = LocalDateTime.parse("2026-10-29 14:30:00",16 DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));17
18// —— 计算 ——19LocalDate tomorrow = date.plusDays(1);20LocalDate lastMonth = date.minusMonths(1);21LocalDate nextYearSameDay = date.plusYears(1);22
23Period age = Period.between(birthday, date);24System.out.printf("%d 岁 %d 个月%n", age.getYears(), age.getMonths());25
26long days = java.time.temporal.ChronoUnit.DAYS.between(birthday, date);27System.out.println("活了 " + days + " 天");28
29// 判断30System.out.println(date.isBefore(tomorrow)); // true31System.out.println(date.isLeapYear()); // 闰年判断32System.out.println(date.getDayOfWeek()); // THURSDAY33
34// —— 时间戳互转 ——35Instant now = Instant.now(); // UTC 时间戳36long epochMilli = now.toEpochMilli(); // 毫秒时间戳1import java.util.Objects;2
3Objects.equals(a, b); // null 安全的判等4Objects.isNull(x); // x == null5Objects.requireNonNull(param, "参数不能为空"); // 快速判空抛 NPE6Objects.hashCode(x);1int[] arr = {3, 1, 4};2int[] copy = Arrays.copyOf(arr, arr.length);3List<Integer> list = Arrays.asList(1, 2, 3); // 固定长度视图4List<Integer> mutable = new ArrayList<>(List.of(1, 2, 3));1import java.math.BigDecimal;2import java.math.RoundingMode;3import java.time.LocalDateTime;4import java.time.format.DateTimeFormatter;5import java.util.StringJoiner;6
7public class Bill {8 public static void main(String[] args) {9 String name = "小明";10 BigDecimal vipRate = new BigDecimal("0.88");11
12 String[][] items = { // [名称, 单价, 数量]13 {"机械键盘", "399", "1"},14 {"鼠标垫", "49.9", "2"},15 {"显示器支架", "159", "1"},16 };17
18 BigDecimal total = BigDecimal.ZERO;19 StringJoiner lines = new StringJoiner("\n"); // 拼接利器20 for (String[] it : items) {21 BigDecimal line = new BigDecimal(it[1])22 .multiply(new BigDecimal(it[2]));23 total = total.add(line);24 lines.add(String.format("%s × %s = ¥%s", it[0], it[2],25 line.setScale(2, RoundingMode.HALF_UP)));26 }27
28 BigDecimal pay = total.multiply(vipRate)29 .setScale(2, RoundingMode.HALF_UP);30
31 String time = LocalDateTime.now()32 .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));33
34 System.out.println("====== 消费账单 ======");35 System.out.println(lines);36 System.out.println("----------------------");37 System.out.printf("合计: ¥%s%n", total);38 System.out.printf("VIP 88折: ¥%s%n", pay);39 System.out.println("时间: " + time);40 }41}下一篇：集合框架——ArrayList/HashMap 全家桶，Java 数据处理的发动机。
本系列为 Cyber先锋社原创教程。String 的 == 陷阱与 Integer 缓存是笔试最爱，亲手跑一遍记住结论。
数组定长，集合（Collection）动态——Java 集合框架是日常开发的绝对主力（前几篇已偷偷用过 ArrayList）。本篇系统讲透 List/Set/Map 三大体系与排序方案。
1Collection（接口）2├── List 有序可重复3│ ├── ArrayList 动态数组（默认选择）4│ └── LinkedList 双向链表5├── Set 不可重复6│ ├── HashSet 哈希（最快，无序）7│ ├── LinkedHashSet 哈希 + 保插入序8│ └── TreeSet 红黑树（自动排序）9└── Queue 队列（了解）10
11Map（接口，独立于 Collection）12├── HashMap 哈希键值对（默认选择）13├── LinkedHashMap 保插入序14└── TreeMap 按键排序泛型 <T>：集合声明元素类型，编译期防类型错误——List<String> 只能装 String。
1import java.util.ArrayList;2import java.util.List;3
4List<String> langs = new ArrayList<>();5
6// —— 增 ——7langs.add("Java"); // 尾部追加8langs.add(0, "C++"); // 指定位置（O(n)）9langs.addAll(List.of("Python", "Go")); // 批量10
11// —— 删 ——12langs.remove("Go"); // 按对象删第一个13langs.remove(0); // 按下标删（返回被删元素）14langs.removeIf(s -> s.startsWith("P")); // 条件删除（Java 8+）15
16// —— 改查 ——17langs.set(0, "Java17");18String first = langs.get(0); // O(1) 随机访问19System.out.println(langs.contains("C++"));20System.out.println(langs.indexOf("Java"));21System.out.println(langs.size());22System.out.println(langs.isEmpty());23
24// —— 遍历 ——25for (String lang : langs) { } // 增强 for26for (int i = 0; i < langs.size(); i++) { } // 下标27langs.forEach(s -> System.out.println(s)); // 函数式28
29// —— 不可变集合（Java 9+）——30List<String> frozen = List.of("a", "b"); // 不可增删改！| ArrayList | LinkedList | |
|---|---|---|
| 随机访问 | O(1) | O(n) |
| 尾部增删 | 均摊 O(1) | O(1) |
| 中间增删 | O(n) | 定位 O(n) + 修改 O(1) |
| 实践建议 | 99% 场景 | 极少胜出 |
1List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4));2
3// ❌ 遍历中直接 remove → ConcurrentModificationException（fail-fast）4// for (Integer n : nums) { if (n % 2 == 0) nums.remove(n); }5
6// ✅ 三种正确姿势7nums.removeIf(n -> n % 2 == 0); // ① 条件删除（最简）8for (Iterator<Integer> it = nums.iterator(); it.hasNext(); ) { // ② 迭代器9 if (it.next() % 2 == 0) it.remove();10}11// ③ 倒序下标循环（正序会跳元素）1import java.util.*;2
3// HashSet：去重最快（依赖 hashCode/equals）4Set<String> tags = new HashSet<>();5tags.add("java");6tags.add("python");7tags.add("java"); // 重复添加被忽略8System.out.println(tags.size()); // 29System.out.println(tags.contains("java")); // true10
11// 列表去重一行流12List<Integer> dup = new ArrayList<>(List.of(3, 1, 3, 2, 1));13Set<Integer> uniq = new LinkedHashSet<>(dup); // 保序去重14System.out.println(uniq); // [3, 1, 2]15
16// TreeSet：自动排序17Set<Integer> sorted = new TreeSet<>(List.of(5, 1, 4));18System.out.println(sorted); // [1, 4, 5]19// 首尾与范围20TreeSet<Integer> ts = new TreeSet<>(List.of(1, 3, 5, 7, 9));21System.out.println(ts.first() + " " + ts.last()); // 1 922System.out.println(ts.headSet(5)); // [1, 3]（小于5）23System.out.println(ts.tailSet(5)); // [5, 7, 9]24System.out.println(ts.floor(6)); // 5（≤6 的最大）自定义对象入 HashSet/HashMap 的前提：正确重写 hashCode + equals（第六篇）——忘了重写，“相等”的两个对象会被当成两个存两份。
1import java.util.HashMap;2import java.util.Map;3
4Map<String, Integer> ages = new HashMap<>();5
6// —— 增改 ——7ages.put("小明", 18); // 不存在则增，存在则改（返回旧值！）8ages.putIfAbsent("小红", 17); // 不存在才放9ages.put("小明", 19); // 覆盖为 1910
11// —— 查 ——12int age = ages.get("小明"); // 1913Integer none = ages.get("不存在"); // null14int def = ages.getOrDefault("不存在", 0); // 0（推荐！防 null）15
16System.out.println(ages.containsKey("小明"));17System.out.println(ages.containsValue(19));18
19// —— 删 ——20ages.remove("小红");21ages.remove("小明", 19); // 键值都对上才删22
23// —— 遍历三式 ——24for (String key : ages.keySet()) { } // 遍历键25for (Integer val : ages.values()) { } // 遍历值26for (Map.Entry<String, Integer> e : ages.entrySet()) // 键值对（最常用）27 System.out.println(e.getKey() + " = " + e.getValue());28
29// Java 8+ 函数式遍历30ages.forEach((k, v) -> System.out.println(k + ":" + v));31
32// —— 统计利器 ——33ages.merge("小明", 1, Integer::sum); // 计数器模式：旧值+134System.out.println(ages); // {小明=20}35ages.computeIfAbsent("列表", k -> new java.util.ArrayList<String>())36 .add("元素"); // 多值 Map 的构建块1String[] words = "the quick the lazy the dog".split(" ");2Map<String, Integer> freq = new HashMap<>();3for (String w : words) {4 freq.merge(w, 1, Integer::sum); // 没有则放1，有则 +15}6System.out.println(freq); // {the=3, quick=1, lazy=1, dog=1}| HashMap | LinkedHashMap | TreeMap | |
|---|---|---|---|
| 查找 | O(1) | O(1) | O(log n) |
| 顺序 | 无 | 插入序 | 键排序 |
| 场景 | 默认 | 需保序（LRU） | 范围查询/排序遍历 |
1class Student implements Comparable<Student> {2 String name;3 int score;4
5 Student(String name, int score) { this.name = name; this.score = score; }6
7 @Override8 public int compareTo(Student o) {9 return Integer.compare(this.score, o.score); // 升序（反过来即降序）10 }11
12 @Override13 public String toString() { return name + ":" + score; }14}1import java.util.*;2
3List<Student> st = new ArrayList<>(List.of(4 new Student("小明", 90), new Student("小红", 92),5 new Student("小刚", 85)));6
7// 策略1：按分数降序（匿名内部类老写法 → lambda 新写法）8st.sort((a, b) -> b.score - a.score);9st.sort(Comparator.comparingInt((Student s) -> s.score).reversed());10
11// 策略2：按姓名排序12st.sort(Comparator.comparing(s -> s.name));13
14// 策略3：多级排序（分数降序，同分按姓名升序）15st.sort(Comparator.comparingInt((Student s) -> s.score).reversed()16 .thenComparing(s -> s.name));17
18System.out.println(st); // [小红:92, 小明:90, 小刚:85]选择：类的”天生顺序”用 Comparable；临时/多种排序策略用 Comparator（组合万岁）。
1Collections.sort(list); // = list.sort(null)2Collections.reverse(list);3Collections.shuffle(list); // 随机打乱4Collections.max(list);5Collections.frequency(list, "a"); // 出现次数6Collections.swap(list, 0, 1);7Collections.unmodifiableList(list); // 不可变视图1import java.util.*;2import java.util.stream.Collectors;3
4public class ScoreSystem {5 record Student(String name, String clazz, int score) {} // Java 16+ 数据类6
7 public static void main(String[] args) {8 List<Student> all = List.of(9 new Student("小明", "一班", 90),10 new Student("小红", "二班", 85),11 new Student("小刚", "一班", 92),12 new Student("小美", "二班", 78),13 new Student("小强", "一班", 66)14 );15
16 // 1. 排行榜（多级排序）17 List<Student> rank = new ArrayList<>(all);18 rank.sort(Comparator.comparingInt(Student::score).reversed());19 rank.forEach(s -> System.out.printf(" %s %s %d%n",20 s.name(), s.clazz(), s.score()));21
22 // 2. 按班级分组23 Map<String, List<Student>> byClass = new LinkedHashMap<>();24 for (Student s : all)25 byClass.computeIfAbsent(s.clazz(), k -> new ArrayList<>()).add(s);26
27 byClass.forEach((cls, list) -> {28 double avg = list.stream().mapToInt(Student::score)29 .average().orElse(0);30 System.out.printf("%s: %d人 平均%.1f%n", cls, list.size(), avg);31 });32
33 // 3. 词频式统计分数段34 Map<String, Integer> dist = new TreeMap<>();35 for (Student s : all) {36 String band = s.score() >= 90 ? "90+" : s.score() >= 80 ? "80+" :37 s.score() >= 60 ? "60+" : "挂科";38 dist.merge(band, 1, Integer::sum);39 }40 System.out.println("分数段: " + dist);41
42 // 4. 挂科名单（stream 预告第十二篇）43 List<String> failed = all.stream()44 .filter(s -> s.score() < 60)45 .map(Student::name)46 .collect(Collectors.toList());47 System.out.println("挂科: " + (failed.isEmpty() ? "无" : failed));48 }49}| 需求 | 选择 |
|---|---|
| 动态列表（默认） | ArrayList |
| 自动去重 | HashSet / 保序用 LinkedHashSet |
| 有序集合/排名 | TreeSet |
| 键值查找（默认） | HashMap |
| 键值保插入序 | LinkedHashMap |
| 键有序遍历/范围查 | TreeMap |
| 一键多值 | Map<K, List<V>> + computeIfAbsent |
| 只读常量集合 | List.of / Set.of / Map.of |
Map<String, List<String>> 实现”分组通讯录”：录入若干 (姓名, 分组)，按组输出Collections.shuffle 后取前 5 名（TreeSet 记录已中签防重复）merge(int[] a, int[] b) 改用 List<Integer> 实现，对比两种容器的代码差异下一篇：异常体系——try/catch 全解与自定义异常。
本系列为 Cyber先锋社原创教程。merge 计数器 + computeIfAbsent 分组 = 集合实战双绝，务必掌握。
Java 的异常体系是所有语言里最”操心”的——编译器强制你处理部分异常。本篇讲透分类、语法、资源管理与设计原则。
1Throwable2├── Error ← 严重错误，程序管不了（OutOfMemoryError、StackOverflowError）3└── Exception4 ├── RuntimeException ← 非受检异常（unchecked）：编译器不强制处理5 │ ├── NullPointerException 空指针6 │ ├── ArrayIndexOutOfBoundsException7 │ ├── ArithmeticException 除零（整数）8 │ ├── ClassCastException 强转失败9 │ ├── NumberFormatException parseInt("abc")10 │ └── IllegalArgumentException 参数非法11 └── 其他 Exception ← 受检异常（checked）：编译器强制 try 或 throws12 ├── IOException13 ├── SQLException14 └── FileNotFoundException受检 vs 非受检：
1// 受检异常：不处理 → 编译不过2public void readFile() {3 FileReader f = new FileReader("a.txt"); // ❌ 编译错误：未处理的 FileNotFoundException4}5
6// 非受检异常：处理与否自愿（通常是程序 bug 的信号）7public int div(int a, int b) {8 return a / b; // 可能 ArithmeticException，但不强制处理9}1public class ExceptDemo {2 static int parse(String s) {3 return Integer.parseInt(s); // 可能 NumberFormatException4 }5
6 public static void main(String[] args) {7 try {8 System.out.println(parse("42"));9 System.out.println(parse("abc")); // 这里抛出10 System.out.println("到不了这里");11 } catch (NumberFormatException e) {12 System.out.println("格式错误: " + e.getMessage());13 } catch (Exception e) { // 兜底（子类在前父类在后！）14 System.out.println("其他: " + e);15 } finally {16 System.out.println("finally 总会执行");17 }18 }19}执行规则：
catch (Exception) 放第一会”吃掉”一切并导致后面不可达的编译错误）1static int mystery() {2 try {3 return 1;4 } finally {5 System.out.println("finally 还是执行了！"); // 先打印，再 return 16 }7}1try {2 // ...3} catch (IOException | SQLException e) { // 竖线合并4 log(e);5}1catch (Exception e) {2 e.getMessage(); // 简短描述3 e.toString(); // 类名 + 描述4 e.printStackTrace(); // 完整堆栈（调试用，别用于生产日志）5}1// throws：声明"本方法可能抛出这些异常，调用者负责"2public static void setAge(int age) throws IllegalArgumentException {3 if (age < 0 || age > 150) {4 // throw：真正抛出异常对象5 throw new IllegalArgumentException("年龄非法: " + age);6 }7}8
9// 自定义受检异常：继承 Exception10class InsufficientFundsException extends Exception {11 private final double shortfall;12
13 public InsufficientFundsException(double shortfall) {14 super(String.format("余额不足，还差 %.2f 元", shortfall));15 this.shortfall = shortfall;16 }17 public double getShortfall() { return shortfall; }18}19
20public class Account {21 private double balance;22
23 // 受检异常：调用方必须 try-catch 或继续 throws（编译器盯着）24 public void withdraw(double amount) throws InsufficientFundsException {25 if (amount > balance)26 throw new InsufficientFundsException(amount - balance);27 balance -= amount;28 }29}30
31// 调用方32public static void main(String[] args) {33 Account acc = new Account();34 try {35 acc.withdraw(100);36 } catch (InsufficientFundsException e) {37 System.out.println(e.getMessage()); // 余额不足，还差 100.00 元38 System.out.println(e.getShortfall()); // 100.039 }40}受检/非受检的选型：调用方有能力恢复的（文件不存在→提示重选）→ 受检；程序 bug（空指针、参数错误）→ 非受检 RuntimeException，让它炸出来好修。
1// 老写法：嵌套深、易漏2FileReader fr = null;3try {4 fr = new FileReader("a.txt");5 int c = fr.read();6} catch (IOException e) {7 e.printStackTrace();8} finally {9 if (fr != null) {10 try { fr.close(); } catch (IOException e) { e.printStackTrace(); }11 }12}1// 实现了 AutoCloseable 的资源放 try(...) 里，自动 close（哪怕抛异常）2try (FileReader fr = new FileReader("a.txt");3 BufferedReader br = new BufferedReader(fr)) { // 多资源分号隔开4 System.out.println(br.readLine());5} catch (IOException e) {6 System.out.println("读取失败: " + e.getMessage());7}8// 离开 try 自动关，且后声明的先关（与声明顺序相反）军规：文件、数据库连接、网络流——一律 try-with-resources，告别手写 close。
1// 异常链：底层异常包装成业务异常，保留根因2public Config loadConfig(String path) {3 try {4 return parse(new String(java.nio.file.Files.readAllBytes(5 java.nio.file.Path.of(path))));6 } catch (IOException e) {7 throw new ConfigException("配置加载失败: " + path, e); // 传入原因8 }9}10
11class ConfigException extends RuntimeException {12 ConfigException(String msg, Throwable cause) {13 super(msg, cause); // cause 保留在堆栈里14 }15}16
17// 打印时看到 Caused by: ... 链条，定位根因1// 1. 精确捕获，最小范围2try {3 int n = Integer.parseInt(input);4} catch (NumberFormatException e) { /* 只包可能出错的行 */ }5
6// 2. 捕获后要么处理、要么转换后抛出，别吞7try { ... }8catch (IOException e) {9 log.error("导入失败", e);10 throw new ImportException("数据导入失败", e); // 转成语义化异常上抛11}12
13// 3. finally 里别写 return（会覆盖 try 的返回值，极度迷惑）1// 1. 空 catch 吞异常（出 bug 无迹可寻）2try { dangerous(); } catch (Exception e) { } // 🔥 火灾隐患3
4// 2. 捕获 Error / 用异常控制正常流程5for (int i = 0; ; i++) {6 try { list.get(i); } catch (IndexOutOfBoundsException e) { break; } // ❌ 用循环条件7}8
9// 3. e.printStackTrace() 当日志（生产用日志框架 SLF4J）10
11// 4. catch (Exception e) 一把梭（除非最外层兜底）1// 参数校验尽早抛（fail fast）——Spring 的 Assert / Objects.requireNonNull2public void transfer(Account to, double amount) {3 Objects.requireNonNull(to, "目标账户不能为空");4 if (amount <= 0) throw new IllegalArgumentException("金额必须为正");5 // ... 业务在可靠的输入上运行6}1import java.io.IOException;2import java.io.InputStream;3import java.util.Properties;4
5public class AppConfig {6 private final Properties props = new Properties();7
8 public static class ConfigException extends RuntimeException {9 ConfigException(String msg, Throwable cause) { super(msg, cause); }10 }11
12 public static AppConfig load(String filename) {13 // try-with-resources + 异常链 + 语义化包装14 try (InputStream in = AppConfig.class15 .getClassLoader().getResourceAsStream(filename)) {16 if (in == null)17 throw new ConfigException("找不到配置文件: " + filename, null);18 AppConfig cfg = new AppConfig();19 cfg.props.load(in);20 return cfg;21 } catch (IOException e) {22 throw new ConfigException("读取 " + filename + " 失败", e);23 }24 }25
26 public String get(String key, String def) { // 安全读取27 return props.getProperty(key, def);28 }29
30 public int getInt(String key, int def) { // 类型安全读取31 String v = props.getProperty(key);32 try {33 return v == null ? def : Integer.parseInt(v.trim());34 } catch (NumberFormatException e) {35 System.err.printf("配置 %s=%s 不是数字，用默认 %d%n", key, v, def);36 return def;37 }38 }39
40 public static void main(String[] args) {41 AppConfig cfg = load("application.properties");42 System.out.println("name = " + cfg.get("app.name", "未配置"));43 System.out.println("port = " + cfg.getInt("app.port", 8080));44 }45}这段代码展示了生产级套路：资源自动关、根因保留、语义化异常、带默认值的安全读取。
divide(int a, int b)：b 为 0 时抛自定义 MathException，main 里捕获处理safeParse(String[] args, int index)：下标越界与格式错误都返回默认值 0 并打印警告main → service → dao，dao 抛 IOException，service 包装成 ServiceException（带 cause），main 捕获打印完整链（观察 Caused by）下一篇：文件 IO 与序列化——让数据落盘。
本系列为 Cyber先锋社原创教程。“健壮配置读取器”是框架源码里的标准套路，读懂它。
让数据活过进程的生命周期——读写文件。Java IO 类库庞大（几十个类），但日常 90% 的需求靠 Files 工具类 + 缓冲流就能解决。本篇按”现代优先”的路线讲。
1import java.io.File;2import java.nio.file.*; // NIO（New IO，Java 7+，推荐）3
4// 老牌 File5File f = new File("data/demo.txt");6f.exists();7f.isFile(); f.isDirectory();8f.length(); // 字节数9f.delete();10
11// 现代 Path（推荐）12Path p = Path.of("data", "demo.txt"); // 自动拼路径（跨平台分隔符）13System.out.println(p.getFileName()); // demo.txt14System.out.println(p.toAbsolutePath()); // /Users/xxx/项目/data/demo.txt15
16Files.exists(p);17Files.size(p);18Files.createDirectories(Path.of("a/b/c")); // 递归建目录19Files.delete(p); // 删除（不存在抛异常）20Files.copy(Path.of("src"), Path.of("dst"), StandardCopyOption.REPLACE_EXISTING);21Files.move(src, dst);1import java.nio.file.Files;2import java.nio.file.Path;3import java.util.List;4import java.io.IOException;5
6Path file = Path.of("notes.txt");7
8// —— 文本全家桶 ——9Files.writeString(file, "第一行\n", StandardOpenOption.CREATE); // 覆盖写10Files.writeString(file, "追加的一行\n",11 StandardOpenOption.CREATE, StandardOpenOption.APPEND); // 追加写12Files.writeString(file, "第三行\n", StandardOpenOption.APPEND);13
14String all = Files.readString(file); // 一口气读完15System.out.println(all);16
17List<String> lines = Files.readAllLines(file); // 按行读进 List18for (String line : lines)19 System.out.println("> " + line);20
21// 流式逐行（大文件省内存）22try (var stream = Files.lines(file)) {23 stream.filter(l -> l.contains("一"))24 .forEach(System.out::println);25}26
27// —— 字节读（图片等二进制）——28byte[] bytes = Files.readAllBytes(Path.of("icon.png"));29Files.write(Path.of("copy.png"), bytes);30
31// —— 遍历目录树 ——32try (var walk = Files.walk(Path.of("."))) { // 递归所有子目录33 walk.filter(f -> f.toString().endsWith(".java"))34 .limit(5)35 .forEach(System.out::println);36}小文件（配置、日志、CSV）直接 Files 一行流；大文件用流式 Files.lines；两者都自动配 try-with-resources 最稳。
1字节流（byte） 字符流（char，文本专用）2InputStream Reader3├── FileInputStream ├── FileReader4└── BufferedInputStream ←── └── BufferedReader（缓冲，性能关键）5OutputStream Writer6├── FileOutputStream ├── FileWriter7└── BufferedOutputStream └── BufferedWriter / PrintWriter选择口诀：文本用字符流、二进制用字节流、永远套缓冲。
1import java.io.*;2import java.util.Scanner;3
4public class IoDemo {5 public static void main(String[] args) {6 // —— 写：PrintWriter（有 println/print/printf，最顺手）——7 try (PrintWriter out = new PrintWriter(8 new BufferedWriter(new FileWriter("diary.txt", true)))) { // true=追加9 out.println("2026-10-29 学完 Java IO");10 out.printf("用时 %d 分钟%n", 45);11 } catch (IOException e) {12 System.err.println("写失败: " + e.getMessage());13 }14
15 // —— 读 1：BufferedReader 逐行 ——16 try (BufferedReader br = new BufferedReader(new FileReader("diary.txt"))) {17 String line;18 while ((line = br.readLine()) != null) // readLine 自动去换行符19 System.out.println("| " + line);20 } catch (IOException e) {21 e.printStackTrace();22 }23
24 // —— 读 2：Scanner 读文件（nextInt 等 token 化）——25 try (Scanner sc = new Scanner(new File("data.txt"))) {26 while (sc.hasNextInt())27 System.out.println(sc.nextInt());28 } catch (FileNotFoundException e) {29 System.out.println("文件不存在");30 }31 }32}1// FileWriter 用系统默认编码（Windows 是 GBK！）——跨平台乱码之源2// ✅ 显式指定 UTF-8：3try (PrintWriter out = new PrintWriter(new BufferedWriter(4 new OutputStreamWriter(5 new FileOutputStream("data.txt"), java.nio.charset.StandardCharsets.UTF_8)))) {6 out.println("中文内容");7}8
9// Files 系列默认就是 UTF-8（又一个用它的理由）10Files.readString(file, java.nio.charset.StandardCharsets.UTF_8);对象 ↔ 字节的相互转换，用于暂存或网络传输：
1import java.io.*;2
3class User implements Serializable { // ① 实现标记接口4 private static final long serialVersionUID = 1L; // ② 版本号（改类不炸旧数据）5 String name;6 transient String password; // transient：敏感字段不序列化7
8 User(String n, String p) { name = n; password = p; }9}10
11public class SerDemo {12 public static void main(String[] args) throws Exception {13 User u = new User("小明", "123456");14
15 // 序列化16 try (ObjectOutputStream oos = new ObjectOutputStream(17 new FileOutputStream("user.dat"))) {18 oos.writeObject(u);19 }20
21 // 反序列化22 try (ObjectInputStream ois = new ObjectInputStream(23 new FileInputStream("user.dat"))) {24 User back = (User) ois.readObject();25 System.out.println(back.name + " / " + back.password); // 小明 / null26 }27 }28}现代项目更多用 JSON（Jackson/Gson）替代原生序列化——可读、跨语言。原生序列化主要用于面试与理解机制。
1import java.io.IOException;2import java.nio.charset.StandardCharsets;3import java.nio.file.Files;4import java.nio.file.Path;5import java.nio.file.StandardOpenOption;6import java.util.ArrayList;7import java.util.List;8import java.util.StringJoiner;9
10public class ContactBook {11 record Contact(String name, String phone, String group) {12 String toCsv() { return String.join(",", name, phone, group); } // 简单场景（值无逗号）13 static Contact fromCsv(String line) {14 String[] p = line.split(",", -1); // -1 保留空字段15 return p.length == 3 ? new Contact(p[0], p[1], p[2]) : null;16 }17 }18
19 private final Path file = Path.of("contacts.csv");20 private final List<Contact> data = new ArrayList<>();21
22 public ContactBook() { load(); }23
24 public void add(String name, String phone, String group) {25 data.add(new Contact(name, phone, group));26 save();27 }28
29 public boolean delete(String name) {30 boolean removed = data.removeIf(c -> c.name().equals(name));31 if (removed) save();32 return removed;33 }34
35 public List<Contact> search(String kw) {36 return data.stream()37 .filter(c -> c.name().contains(kw) || c.phone().contains(kw))38 .toList();39 }40
41 public void listAll() {42 StringJoiner sj = new StringJoiner("\n");43 data.forEach(c -> sj.add(String.format("%-8s %-12s [%s]",44 c.name(), c.phone(), c.group())));45 System.out.println(sj);46 }47
48 private void load() { // 启动时读49 if (!Files.exists(file)) return;50 try {51 for (String line : Files.readAllLines(file, StandardCharsets.UTF_8)) {52 Contact c = Contact.fromCsv(line);53 if (c != null) data.add(c);54 }55 } catch (IOException e) {56 System.err.println("读取失败: " + e.getMessage());57 }58 }59
60 private void save() { // 每次变更整写（小数据够用）61 try {62 Files.write(file,63 data.stream().map(Contact::toCsv).toList(),64 StandardCharsets.UTF_8,65 StandardOpenOption.CREATE,66 StandardOpenOption.TRUNCATE_EXISTING);67 } catch (IOException e) {68 System.err.println("保存失败: " + e.getMessage());69 }70 }71
72 public static void main(String[] args) {73 ContactBook book = new ContactBook(); // 重启自动加载旧数据！74
75 book.add("小明", "138xxxx", "同学");76 book.add("小红", "139xxxx", "家人");77 book.listAll();78
79 System.out.println("搜索'小': " + book.search("小").size() + " 条");80 System.out.println("删除小红: " + book.delete("小红"));81 book.listAll();82 }83}技术点清单：record 数据类、Files 读写（UTF-8 显式）、stream 过滤、启动加载 + 变更即存——把它扩展成命令行交互就是毕业设计级作品。
| 场景 | 方案 |
|---|---|
| 小文本读写 | Files.readString / writeString |
| 逐行处理大文本 | Files.lines（流式） |
| 按行写/格式化输出 | PrintWriter + 缓冲 |
| 读数字等 token | Scanner |
| 二进制（图片） | Files.readAllBytes / 字节流 |
| 遍历目录树 | Files.walk |
| 对象持久化 | JSON 库（实战）/ Serializable（了解） |
update 命令与”导出为可读文本报表”功能write 内容 追加带时间戳的一行，list 显示全部，grep 关键词 过滤下一篇：多线程与 Lambda——并发的世界与函数式语法糖。
本系列为 Cyber先锋社原创教程。CSV 通讯录几乎串联了全系列知识，建议默写一遍。
两个主题一次讲完：多线程（让程序同时干多件事）与 Lambda（函数式语法）。它们是 Java 8 的双主角，也是后端面试的必考区。目标：会建线程、懂同步、用线程池、熟练写 Lambda。
单线程：下载文件时界面卡死（一件事阻塞一切）。多线程：下载归下载、界面归界面——并发提升响应与吞吐。
1// 法1：继承 Thread2class Downloader extends Thread {3 private final String file;4 Downloader(String file) { this.file = file; }5
6 @Override7 public void run() { // 线程要做的事8 System.out.println("下载 " + file + " 开始");9 try { Thread.sleep(1000); } // 模拟耗时10 catch (InterruptedException e) { return; }11 System.out.println("下载 " + file + " 完成");12 }13}14
15// 法2：实现 Runnable（推荐——不占用继承名额）16class Task implements Runnable {17 @Override18 public void run() {19 System.out.println("任务运行在: " + Thread.currentThread().getName());20 }21}22
23public class ThreadDemo {24 public static void main(String[] args) throws InterruptedException {25 Thread t1 = new Downloader("a.zip");26 Thread t2 = new Thread(new Task(), "工作线程-2"); // 第二参命名27 Thread t3 = new Thread(() -> System.out.println("Lambda 更简洁"),28 "工作线程-3");29
30 t1.start(); // ⚠ 调 start() 不是 run()！run() 只是普通方法调用31 t2.start();32 t3.start();33
34 t1.join(); // main 线程等 t1 干完再往下走35 System.out.println("main 继续");36 }37}start() 启动新线程执行 run；直接调 run() 是在当前线程执行——没有新线程，这是新手第一大坑。
1Thread t = Thread.currentThread(); // 当前线程2t.getName();3Thread.sleep(500); // 当前线程睡 500ms（静态方法）4t.join(); // 等 t 结束5Thread.yield(); // 建议让出 CPU（了解）6t.setDaemon(true); // 守护线程（主程序结束它陪葬）7t.setPriority(Thread.MAX_PRIORITY); // 优先级（仅建议性）1class Counter {2 private int count = 0;3 public void increment() { count++; } // count++ 不是原子操作！4 public int get() { return count; }5}6
7// 1000 个线程各加 1000 次 → 理论 100 万，实际常小于（丢失更新）count++ 实际是”读→改→写”三步，两线程交错执行就丢更新。
1class SafeCounter {2 private int count = 0;3
4 public synchronized void increment() { // 同一时刻只有一个线程能进入5 count++;6 }7 public synchronized int get() { return count; }8}9
10// 同步块版（锁更小范围）11class Pair {12 private int a = 0;13 public void add() {14 synchronized (this) { // 锁住当前实例15 a++;16 }17 }18}1import java.util.concurrent.atomic.AtomicInteger;2
3class AtomicCounter {4 private final AtomicInteger count = new AtomicInteger();5 public void increment() { count.incrementAndGet(); } // CAS 实现，无锁高效6 public int get() { return count.get(); }7}1import java.util.concurrent.*;2
3public class ProducerConsumer {4 public static void main(String[] args) throws Exception {5 BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(5); // 容量56
7 // 生产者：往队列放（满了自动阻塞等待）8 Thread producer = new Thread(() -> {9 try {10 for (int i = 1; i <= 10; i++) {11 queue.put(i);12 System.out.println("生产 " + i);13 }14 queue.put(-1); // 结束信号15 } catch (InterruptedException ignored) {}16 });17
18 // 消费者：从队列取（空了自动阻塞等待）19 Thread consumer = new Thread(() -> {20 try {21 int v;22 while ((v = queue.take()) != -1)23 System.out.println(" 消费 " + v);24 } catch (InterruptedException ignored) {}25 });26
27 producer.start();28 consumer.start();29 producer.join();30 consumer.join();31 }32}手动 new Thread 有创建销毁开销、无法控数量。线程池 = 线程复用 + 队列排队 + 限流：
1import java.util.concurrent.*;2
3public class PoolDemo {4 public static void main(String[] args) throws Exception {5 // 固定 4 个工作线程的池6 ExecutorService pool = Executors.newFixedThreadPool(4);7
8 // 提交 10 个任务（自动排队分发）9 for (int i = 1; i <= 10; i++) {10 final int taskId = i;11 pool.submit(() -> { // submit 接收 Runnable/Callable12 System.out.printf("任务%d 由 %s 处理%n",13 taskId, Thread.currentThread().getName());14 try { Thread.sleep(300); }15 catch (InterruptedException e) { Thread.currentThread().interrupt(); }16 return taskId * taskId; // Callable 可返回结果17 });18 }19
20 // Callable + Future：拿异步结果21 Future<Integer> future = pool.submit(() -> {22 Thread.sleep(500);23 return 42;24 });25 System.out.println("等结果...");26 System.out.println("结果 = " + future.get()); // 阻塞直到完成27
28 pool.shutdown(); // 温和关闭（等任务做完）29 // pool.awaitTermination(5, TimeUnit.SECONDS);30 }31}池的选型：
| 工厂方法 | 适用 |
|---|---|
newFixedThreadPool(n) | 负载稳定（默认首选） |
newCachedThreadPool() | 短时大量小任务 |
newSingleThreadExecutor() | 任务需严格串行 |
生产环境推荐 new ThreadPoolExecutor(...) 手动配七个参数（核心数/最大数/队列/拒绝策略），框架（Spring/Tomcat）内部全是定制池——入门先会 Executors，进阶再读源码。
1// 需求：按长度排序2List<String> list = new ArrayList<>(List.of("banana", "apple", "fig"));3
4// 远古写法5list.sort(new Comparator<String>() {6 @Override7 public int compare(String a, String b) { return a.length() - b.length(); }8});9
10// Lambda 写法11list.sort((a, b) -> a.length() - b.length());12
13// 方法引用：更极致的简洁14list.sort(Comparator.comparingInt(String::length));1// (参数) -> 表达式 或 { 语句块 }2Runnable r1 = () -> System.out.println("无参");3Runnable r2 = () -> {4 System.out.println("多行");5 System.out.println("要花括号");6};7
8// 单参可省括号（类型自动推断）9java.util.function.Function<String, Integer> len = s -> s.length();10java.util.function.Function<String, Integer> len2 = String::length; // 方法引用11
12// 有返回值的13java.util.function.BinaryOperator<Integer> add = (a, b) -> a + b;1// Function<T,R>：T → R（转换）2Function<String, Integer> parse = Integer::parseInt;3System.out.println(parse.apply("42"));4
5// Predicate<T>：T → boolean（判断）6Predicate<String> isEmpty = String::isEmpty;7System.out.println(isEmpty.test("")); // true8
9// Consumer<T>：T → void（消费）10Consumer<String> printer = s -> System.out.println("⚡ " + s);11printer.accept("hello");12
13// Supplier<T>：() → T（生产/惰性）14Supplier<Double> random = Math::random;15System.out.println(random.get());Lambda 能出现在任何”函数式接口”（只有一个抽象方法的接口）的位置——Runnable、Comparator、以及上面四大金刚。
1String::length // 对象方法：x -> x.length()2System.out::println // 特定对象方法：x -> System.out.println(x)3Integer::parseInt // 静态方法：s -> Integer.parseInt(s)4ArrayList::new // 构造器：() -> new ArrayList<>()1import java.util.Optional;2
3// 包装可能为 null 的返回值4Optional<String> findUser(int id) {5 return id == 1 ? Optional.of("小明") : Optional.empty();6}7
8// 使用方（再也不写 if (x != null)）9findUser(1).ifPresent(name -> System.out.println("找到 " + name));10
11String name = findUser(2).orElse("游客"); // 默认值12String n2 = findUser(2).orElseGet(() -> "懒加载默认"); // 惰性默认13String n3 = findUser(1).orElseThrow(14 () -> new RuntimeException("用户不存在")); // 强制要求1import java.util.concurrent.*;2import java.util.concurrent.atomic.AtomicLong;3
4public class DownloadSimulator {5 public static void main(String[] args) throws Exception {6 String[] files = {"a.zip", "b.zip", "c.zip", "d.zip", "e.zip"};7 AtomicLong totalBytes = new AtomicLong(); // 原子累计8 ExecutorService pool = Executors.newFixedThreadPool(3);9
10 var futures = new java.util.ArrayList<Future<Long>>();11 long start = System.currentTimeMillis();12
13 for (String f : files) {14 futures.add(pool.submit(() -> { // Callable 返回本文件字节数15 Thread.sleep(500); // 模拟下载16 long size = (long) (Math.random() * 1_000_000);17 totalBytes.addAndGet(size);18 System.out.printf(" [%s] %s 完成: %,d B%n",19 Thread.currentThread().getName(), f, size);20 return size;21 }));22 }23
24 long sum = 0;25 for (Future<Long> fu : futures) sum += fu.get(); // 收齐结果26
27 pool.shutdown();28 System.out.printf("全部完成：%d 文件，共 %,d 字节，并发耗时 %d ms%n",29 files.length, sum,30 System.currentTimeMillis() - start); // 约 1 秒（串行要 2.5 秒）31 }32}join 让它们严格顺序执行Future 收集结果求和Function 链式组合：andThen 实现”字符串 → 长度 → 平方”下一篇：Stream API 与综合实战——系列的收官之战。
本系列为 Cyber先锋社原创教程。“并发耗时 vs 串行耗时”的对比实验请亲手跑，体感最深刻。
双主题收官：Stream API（Java 8 最优雅的数据处理武器）+ 综合实战（用全系列知识写一个学生管理系统）。
Stream 是数据流水线：数据源 → 中间操作（惰性）→ 终端操作（触发）。它不存数据、不改源，只声明”怎么处理”：
1import java.util.List;2import java.util.stream.Collectors;3
4List<String> names = List.of("小明", "小红", "小刚", "小美", "小强");5
6List<String> result = names.stream() // ① 建流7 .filter(n -> n.startsWith("小")) // ② 中间操作：过滤（还没执行！）8 .map(String::length) // ③ 中间操作：变换9 .collect(Collectors.toList()); // ④ 终端操作：触发整条流水线1// 集合 → stream()2List<Integer> list = List.of(1, 2, 3);3list.stream();4
5// 数组 → Arrays.stream6int[] arr = {1, 2, 3};7Arrays.stream(arr).sum();8
9// 静态工厂 → Stream.of / generate / iterate10Stream<Integer> s1 = Stream.of(1, 2, 3);11Stream<Integer> s2 = Stream.iterate(1, n -> n * 2).limit(10); // 1,2,4,8...10241List<Integer> nums = List.of(5, 3, 8, 1, 3, 9, 2);2
3// filter：过滤4nums.stream().filter(n -> n > 3).forEach(System.out::println); // 5 8 95
6// map：一对一变换7nums.stream().map(n -> n * n).forEach(System.out::println); // 25 9 64 ...8
9// distinct / sorted / limit / skip10nums.stream().distinct().sorted().limit(3).toList(); // [1, 2, 3]11nums.stream().sorted(Comparator.reverseOrder()).skip(1).toList(); // [8,5,3,3,2]12
13// flatMap：一对多展开（流中流拍扁）14List<List<Integer>> nested = List.of(List.of(1, 2), List.of(3, 4));15nested.stream().flatMap(List::stream).toList(); // [1,2,3,4]16
17// peek：偷看（调试利器）18nums.stream().peek(n -> System.out.println("处理中: " + n))19 .map(n -> n + 1).toList();1List<Integer> nums = List.of(5, 3, 8, 1, 9);2
3// —— 归约计算 ——4nums.stream().count(); // 55nums.stream().mapToInt(Integer::intValue).sum();// 26（先转 IntStream 性能更好）6nums.stream().max(Integer::compareTo); // Optional[9]7nums.stream().min(Integer::compareTo); // Optional[1]8nums.stream().filter(n -> n > 3).findFirst(); // Optional[5]9nums.stream().filter(n -> n > 3).findAny();10
11// —— 匹配判断 ——12nums.stream().allMatch(n -> n > 0); // true（全部满足）13nums.stream().anyMatch(n -> n > 8); // true（任一满足）14nums.stream().noneMatch(n -> n < 0); // true（都不满足）15
16// —— 遍历 ——17nums.stream().forEach(System.out::println);1List<Student> st = List.of(2 new Student("小明", "一班", 90),3 new Student("小红", "二班", 85),4 new Student("小刚", "一班", 92),5 new Student("小美", "二班", 78));6
7// toList / toSet8List<String> names = st.stream().map(s -> s.name).toList(); // Java 16+ 直接 toList9
10// joining：字符串拼接11String all = st.stream().map(s -> s.name)12 .collect(Collectors.joining(", ", "[", "]")); // [小明, 小红, 小刚, 小美]13
14// groupingBy：分组（Map<String, List<Student>>）15Map<String, List<Student>> byClass = st.stream()16 .collect(Collectors.groupingBy(s -> s.clazz));17
18// 分组 + 下游统计19Map<String, Long> countByClass = st.stream()20 .collect(Collectors.groupingBy(s -> s.clazz, Collectors.counting()));21// {一班=2, 二班=2}22
23Map<String, Double> avgByClass = st.stream()24 .collect(Collectors.groupingBy(s -> s.clazz,25 Collectors.averagingDouble(s -> s.score)));26// {一班=91.0, 二班=81.5}27
28Map<String, Optional<Student>> topByClass = st.stream()29 .collect(Collectors.groupingBy(s -> s.clazz,30 Collectors.maxBy(Comparator.comparing(s -> s.score))));31
32// partitioningBy：按布尔分两组33Map<Boolean, List<Student>> passFail = st.stream()34 .collect(Collectors.partitioningBy(s -> s.score >= 60));35
36// toMap：收集成 Map37Map<String, Integer> scoreMap = st.stream()38 .collect(Collectors.toMap(s -> s.name, s -> s.score,39 (a, b) -> b)); // 第3参处理键冲突1long sum = java.util.stream.IntStream.rangeClosed(1, 100_000_000)2 .parallel() // 一行变多核并行3 .sum();4// 适合：数据量大 + 元素计算重；小数据反而更慢（线程切换开销）全系列知识总集成：OOP + 集合 + 异常 + IO + 多线程。
1// ===== StudentSystem.java 完整可编译 =====2import java.io.IOException;3import java.nio.charset.StandardCharsets;4import java.nio.file.Files;5import java.nio.file.Path;6import java.nio.file.StandardOpenOption;7import java.util.*;8import java.util.stream.Collectors;9
10public class StudentSystem {11
12 // —— 数据模型（record + 封装）——13 record Student(String id, String name, String className, double score) {14 String toCsv() { return String.join(",", id, name, className, String.valueOf(score)); }15 static Student fromCsv(String line) {16 String[] p = line.split(",", -1);17 if (p.length != 4) return null;18 try { return new Student(p[0], p[1], p[2], Double.parseDouble(p[3])); }19 catch (NumberFormatException e) { return null; }20 }21 }22
23 // —— 业务异常（第九篇）——24 static class SysException extends RuntimeException {25 SysException(String msg) { super(msg); }26 }27
28 // —— 服务层：集合 + Stream（第八篇 + 本篇）——29 static class Service {30 private final Map<String, Student> data = new LinkedHashMap<>();31 private final Path file = Path.of("students.csv");32
33 Service() { load(); }34
35 Student add(String name, String className, double score) {36 if (score < 0 || score > 100)37 throw new SysException("成绩必须在 0~100: " + score);38 String id = "S" + (data.size() + 1001);39 Student s = new Student(id, name, className, score);40 data.put(id, s);41 save();42 return s;43 }44
45 void remove(String id) {46 if (data.remove(id) == null)47 throw new SysException("学号不存在: " + id);48 save();49 }50
51 List<Student> ranking() {52 return data.values().stream()53 .sorted(Comparator.comparingDouble(Student::score).reversed())54 .collect(Collectors.toList());55 }56
57 Map<String, Double> classAverages() {58 return data.values().stream()59 .collect(Collectors.groupingBy(Student::className,60 Collectors.averagingDouble(Student::score)));61 }62
63 List<Student> search(String kw) {64 return data.values().stream()65 .filter(s -> s.name().contains(kw) || s.id().contains(kw))66 .collect(Collectors.toList());67 }68
69 // —— 持久化（第十篇）——70 private void save() {71 try {72 Files.write(file,73 data.values().stream().map(Student::toCsv).toList(),74 StandardCharsets.UTF_8,75 StandardOpenOption.CREATE,76 StandardOpenOption.TRUNCATE_EXISTING);77 } catch (IOException e) {78 throw new SysException("保存失败: " + e.getMessage());79 }80 }81
82 private void load() {83 if (!Files.exists(file)) return;84 try {85 Files.readAllLines(file, StandardCharsets.UTF_8).stream()86 .map(Student::fromCsv)87 .filter(Objects::nonNull)88 .forEach(s -> data.put(s.id(), s));89 } catch (IOException e) {90 System.err.println("加载失败: " + e.getMessage());91 }92 }93 }94
95 // —— 控制台交互（流程控制 + 异常处理）——96 public static void main(String[] args) {97 Service svc = new Service();98 Scanner sc = new Scanner(System.in);99
100 System.out.println("=== 学生管理系统 ===");101 System.out.println("add 姓名 班级 成绩 | del 学号 | rank | stat | search 关键词 | list | quit");102
103 while (true) {104 System.out.print("\n> ");105 String line = sc.nextLine().trim();106 if (line.isEmpty()) continue;107 String[] p = line.split("\\s+");108 String cmd = p[0];109
110 try {111 switch (cmd) {112 case "quit" -> { System.out.println("再见！"); return; }113 case "add" -> {114 if (p.length < 4) throw new SysException("用法: add 姓名 班级 成绩");115 Student s = svc.add(p[1], p[2], Double.parseDouble(p[3]));116 System.out.println("✅ 已添加 " + s.id() + " " + s.name());117 }118 case "del" -> {119 svc.remove(p[1]);120 System.out.println("🗑 已删除");121 }122 case "rank" -> svc.ranking().forEach(s ->123 System.out.printf(" %-6s %-6s %-4s %.1f%n",124 s.id(), s.name(), s.className(), s.score()));125 case "stat" -> {126 svc.classAverages().forEach((cls, avg) ->127 System.out.printf(" %s: 平均 %.1f%n", cls, avg));128 System.out.println(" 全员均分: " +129 svc.ranking().stream()130 .mapToDouble(Student::score).average().orElse(0));131 }132 case "search" -> svc.search(p[1]).forEach(s ->133 System.out.println(" " + s));134 case "list" -> svc.ranking().forEach(s ->135 System.out.println(" " + s));136 default -> System.out.println("未知命令");137 }138 } catch (SysException e) {139 System.out.println("❌ " + e.getMessage());140 } catch (Exception e) {141 System.out.println("输入格式错误: " + e.getMessage());142 }143 }144 }145}运行演示：
1> add 小明 一班 902✅ 已添加 S1001 小明3> add 小红 二班 854✅ 已添加 S1002 小红5> rank6 S1001 小明 一班 90.07 S1002 小红 二班 85.08> stat9 一班: 平均 90.010 二班: 平均 85.011> del S100212🗑 已删除13> quit涉及知识清单：record（现代数据类）、LinkedHashMap、Stream 排序/分组/统计、Collectors 全家桶、自定义异常、Files 持久化、switch 表达式、Scanner 交互。这就是”全系列合体”。
| 篇 | 主题 | 关键收获 |
|---|---|---|
| 1 | 环境与第一个程序 | JDK/JVM、IDEA、main 结构 |
| 2 | 语法与运算符 | 八大类型、转换陷阱、printf |
| 3 | 流程控制 | switch 表达式、标签跳转 |
| 4 | 方法与数组 | 重载、值传递本质、Arrays 工具 |
| 5 | 面向对象（上） | 封装、JavaBean、static、包与权限 |
| 6 | 面向对象（下） | 继承、多态、接口、equals/hashCode |
| 7 | 核心类库 | String 不可变、包装类、BigDecimal、日期 |
| 8 | 集合框架 | List/Set/Map、merge 计数、Comparator |
| 9 | 异常处理 | 受检/非受检、try-with-resources |
| 10 | 文件 IO | Files 一行流、编码、CSV 持久化 |
| 11 | 多线程与 Lambda | 线程池、synchronized、函数式接口 |
| 12 | Stream 与实战（本篇） | 流水线、Collectors、综合项目 |
下一步方向：Spring Boot 后端开发、Android 应用、大数据生态（Hadoop/Spark 均是 Java 系）、或深入 JVM 原理。做出项目欢迎投稿本站！
本系列为 Cyber先锋社原创教程，共 12 篇完结。至此本站 Python（11篇）/ C++（12篇）/ Java（12篇）三大入门系列全部完结，欢迎在留言板晒毕业设计！
在所有编程语言中，Python 几乎是公认最适合入门的语言：语法接近自然英语、不用操心内存和类型声明的细节、装好就能跑，而且它在数据分析、人工智能、自动化脚本、Web 开发领域都是主流工具。学会 Python，等于拿到了信息技术世界的一把万能钥匙。
cmd），验证：1python --version看到 Python 3.x.x 即安装成功。
系统自带 Python，但版本可能较旧，推荐用 Homebrew 安装最新版：
1brew install python2python3 --version1sudo apt update && sudo apt install python3 python3-pip2python3 --versionWindows 上命令是 python，macOS/Linux 上通常是 python3，本文后续统一写 python，请按自己的系统对应。
打开命令行，输入 python 进入交互式环境（出现 >>> 提示符），然后输入：
1>>> print("Hello, Cyber先锋社!")2Hello, Cyber先锋社!回车即出结果——这就是交互式环境的好处：即写即测，非常适合学习阶段做小实验。输入 exit() 可退出。
也可以把代码存成文件。新建 hello.py：
1print("Hello, Cyber先锋社!")2print("我的第一个 Python 程序")在命令行运行：
1python hello.py.py 是 Python 源文件的扩展名。用 VS Code、PyCharm 等编辑器打开编写体验更好。
变量就是一个”名字标签”，指向内存里的某个数据。Python 里不需要声明类型，直接赋值即可：
1name = "小明" # 字符串 str2age = 18 # 整数 int3height = 1.75 # 浮点数 float4is_student = True # 布尔值 bool用 type() 函数可以查看任何数据的类型：
1>>> type(age)2<class 'int'>| 类型 | 名称 | 示例 | 用途 |
|---|---|---|---|
int | 整数 | 42, -7 | 计数、索引 |
float | 浮点数 | 3.14 | 小数运算 |
str | 字符串 | "hello" | 文本处理 |
bool | 布尔值 | True, False | 逻辑判断 |
1a = 102b = 33
4print(a + b) # 13 加5print(a - b) # 7 减6print(a * b) # 30 乘7print(a / b) # 3.3333... 除（结果一定是 float）8print(a // b) # 3 整除（舍去小数）9print(a % b) # 1 取余数10print(a ** b) # 1000 幂运算1s = "Cyber Pioneer"2
3print(len(s)) # 13，字符串长度4print(s.upper()) # CYBER PIONEER5print(s.lower()) # cyber pioneer6print(s + " Club") # 拼接：Cyber Pioneer Club7print(f"{s} 欢迎你") # f-string 格式化（推荐）f-string 是 Python 3.6+ 的格式化语法，在字符串前加 f，用 {} 嵌入变量，是现代 Python 的标准写法。
程序要与人交互，就需要输入输出：
1name = input("你叫什么名字？")2age = int(input("你多大了？")) # input 返回的是字符串，转成整数3
4print(f"{name}，你好！明年你就 {age + 1} 岁了")input() 的返回值永远是字符串。要做数学运算必须先转换：int() 转整数、float() 转浮点数。忘记转换是新手第二大翻车点。
123 ÷ 7 的商（整除）和余数int / float / str / boolinput() 返回字符串，运算前记得转换类型下一篇：条件判断与循环——让程序学会”思考”和”重复劳动”。
本系列为 Cyber先锋社原创教程，参考业界通用知识体系编写。有问题欢迎在留言板讨论！
上一篇我们让程序”跑了起来”，本篇把两块地基打牢：运算符（程序怎么算）和字符串（文本怎么处理）。这两块内容贯穿所有后续教程，务必动手把每个示例跑一遍。
Python 有七类运算符，逐一来看。
1a, b = 10, 32
3print(a + b) # 13 加4print(a - b) # 7 减5print(a * b) # 30 乘6print(a / b) # 3.3333333333333335 除，结果一定是 float7print(a // b) # 3 整除（向下取整）8print(a % b) # 1 取模（余数）9print(a ** b) # 1000 幂三个易错点：
/ 永远返回 float，哪怕能整除：10 / 2 得 5.0// 是向下取整，负数时要小心：1print(-10 // 3) # -4 （不是 -3！向负无穷方向取）2print(-10 % 3) # 2 （余数符号跟除数一致）1print(0.1 + 0.2) # 0.300000000000000042print(0.1 + 0.2 == 0.3) # False！需要精确计算（如金额）时用 decimal 模块：
1from decimal import Decimal2print(Decimal("0.1") + Decimal("0.2") == Decimal("0.3")) # True1print(3 > 2) # True2print(3 < 2) # False3print(3 >= 3) # True4print(3 == 3) # True 相等是两个等号！5print(3 != 3) # False 不等号新手第一大坑：= 是赋值，== 才是比较。写 if x = 3: 会直接报语法错误——这是 Python 刻意设计的保护。
Python 支持链式比较，很优雅：
1age = 202print(18 <= age < 60) # True，等价于 18 <= age and age < 601x = 102x += 5 # x = x + 5 → 153x -= 3 # 124x *= 2 # 245x //= 5 # 46x **= 2 # 16多重赋值与解包：
1a, b = 1, 2 # 同时赋值2a, b = b, a # 经典：一行交换两个变量（无需临时变量）3x = y = 0 # 链式赋值，x 和 y 都是 04
5first, *rest = [1, 2, 3, 4] # 星号解包：first=1, rest=[2,3,4]6print(first, rest) # 1 [2, 3, 4]Python 用英文单词而非符号：
1age = 202has_card = True3
4print(age >= 18 and has_card) # True 且5print(age < 18 or has_card) # True 或6print(not has_card) # False 非短路求值：and 左边为假时右边不再计算，or 左边为真时同理。常用于安全访问：
1# 列表非空才取第一个元素（若右边执行而列表为空会报错）2nums = []3if nums and nums[0] > 0:4 print("正数")真值表速记（哪些值被视为 False）：
| 假值 | 说明 |
|---|---|
False、None | |
0、0.0 | 数字零 |
""、[]、{}、()、set() | 空容器 |
其余一切值都为真，包括 "False" 这个非空字符串。
1print("py" in "python") # True2print(3 in [1, 2, 3]) # True3print("x" not in ["a", "b"]) # True4print("name" in {"name": "Tom"}) # True（查的是键）is 比较两个变量是否指向同一个对象，== 只比较值：
1a = [1, 2, 3]2b = [1, 2, 3]3print(a == b) # True 值相等4print(a is b) # False 不是同一个对象5
6c = a7print(c is a) # True c 和 a 指向同一列表判断 None 必须用 is None 而不是 == None，这是 PEP 8 规范。
直接对整数的二进制位操作，底层开发、算法优化才会常用：
1print(5 & 3) # 1 按位与：0b101 & 0b011 = 0b0012print(5 | 3) # 7 按位或3print(5 ^ 3) # 6 按位异或4print(5 << 1) # 10 左移一位相当于 ×25print(5 >> 1) # 2 右移一位相当于 //2经典应用：x << 1 比 x * 2 快；判断奇偶 x & 1（结果 1 为奇数）。
从高到低：** → 一元负号 → * / // % → + - → 比较运算 → not → and → or。记不住就加括号，括号永远最清晰。
字符串是字符组成的序列，可以按位置访问；但它是不可变的——任何”修改”都是创建新字符串：
1s = "CyberPioneer"2s[0] = "c" # ❌ TypeError！字符串不可修改3s = "c" + s[1:] # ✅ 拼出新字符串4print(s) # cyperPioneer1s = "CyberPioneer"2
3# 索引：从 0 开始，负数从末尾开始4print(s[0]) # C5print(s[-1]) # r6print(len(s)) # 127
8# 切片语法 s[起:止:步长]，含头不含尾9print(s[0:5]) # Cyber10print(s[5:]) # Pioneer（省略止 = 到结尾）11print(s[:5]) # Cyber（省略起 = 从开头）12print(s[::2]) # CyePoer（隔一个取一个）13print(s[::-1]) # renoiPreyC（经典倒序！）切片口诀：含头不含尾，省头从头起，省尾到尾止，负步长倒着走。
切片越界不会报错（索引越界才会）：
1print(s[0:100]) # 整个字符串，不报错2print(s[100]) # ❌ IndexError1s = " hello Cyber Pioneer "2
3# —— 大小写类 ——4print(s.strip()) # 去两端空白："hello Cyber Pioneer"5print(s.upper()) # 全大写6print(s.lower()) # 全小写7print(s.title()) # 每个单词首字母大写8print("abc".capitalize()) # Abc 首字母大写9
10# —— 查找类 ——11t = "hello"12print(t.find("l")) # 2 首次出现的索引，找不到返回 -113print(t.count("l")) # 2 出现次数14print(t.startswith("he")) # True15print(t.endswith("lo")) # True16
17# —— 分割与连接 ——18csv = "python,cpp,java"19langs = csv.split(",") # ['python', 'cpp', 'java']20print("-".join(langs)) # python-cpp-java21print("a b c".split()) # ['a', 'b', 'c']（无参分割自动处理多空格）22
23# —— 替换与判断 ——24print("1+1".replace("+", "-")) # 1-125print("abc123".isdigit()) # False（含字母）26print("12345".isdigit()) # True27print("abc".isalpha()) # True28print("Python".isupper()) # False注意：这些方法都不修改原字符串，而是返回新值：
1t = "hello"2t.upper() # 只是返回了新字符串，没有保存！3print(t) # hello（原样）4t = t.upper() # ✅ 要用变量接住5print(t) # HELLO1name, score = "小明", 95.52
3# 1. f-string（Python 3.6+，现代标准，推荐）4print(f"{name} 的成绩是 {score}")5print(f"及格了吗：{score >= 60}")6print(f"保留一位小数：{score:.1f}") # 95.57print(f"补零对齐：{7:03d}") # 0078print(f"百分比：{0.856:.1%}") # 85.6%9print(f"{name=} ") # name='小明' 调试神器10
11# 2. format 方法（老代码常见）12print("{} 的成绩是 {}".format(name, score))13print("{1} 比 {0} 高".format("小明", "小红")) # 位置参数14
15# 3. % 占位符（最古老，C 语言风格）16print("%s 的成绩是 %.1f" % (name, score))f-string 常用格式速查：
| 写法 | 作用 | 示例结果 |
|---|---|---|
{x:.2f} | 两位小数 | 3.14 |
{x:>10} | 右对齐宽 10 | hello |
{x:<10} | 左对齐宽 10 | hello |
{x:^10} | 居中宽 10 | hello |
{x:,} | 千分位 | 1,234,567 |
{x:08.2f} | 补零宽 8 两位小数 | 0003.14 |
1print("第一行\n第二行") # \n 换行2print("姓名\t年龄") # \t 制表符3print("他说：\"你好\"") # \" 输出双引号4print(r"C:\new\table") # 原始字符串：\n 不转义，正则/路径必备5print("""多行6字符串7写这里""") # 三引号保留换行1text = "the quick brown fox jumps over the lazy dog the end"2
3words = text.split() # ['the','quick',...]4print(f"总词数: {len(words)}") # 105
6the_count = text.count("the")7print(f"the 出现: {the_count} 次") # 38
9# 每个单词倒序输出10for w in words:11 print(w[::-1], end=" ")12# eht kciuq nworb xof spmuj revo eht yzal god eht dnelen()，用循环统计字符串长度（提示：计数器 + for 遍历，下篇揭晓）"上海自来水来自海上" 正读反读一致（提示：切片倒序比较）"hello world python" 每个单词首字母大写后用 - 连接is 验证小整数缓存的存在（提示：a=1; b=1; a is b 结果与 a=257; b=257; a is b 对比）/ 永远得 float，// 向下取整== 比较值，is 比较身份；判 None 用 is[::-1] 倒序split/join 是文本处理双璧；字符串方法返回新值需接住下一篇：条件判断与循环——让程序学会思考和重复。
本系列为 Cyber先锋社原创教程。动手跑一遍所有示例，比读十遍更有用。
前两篇的程序都是”从头跑到尾”，本篇让程序拥有判断（走哪条路）和重复（反复做事）的能力。这两者是所有程序逻辑的基石，学完本篇你就能写出真正”有逻辑”的程序了。
Python 不用 {} 園代码块，而用缩进（官方推荐 4 个空格）：
1if score >= 60:2 print("及格") # 缩进的行属于 if3 print("继续努力") # 同级缩进 = 同一块代码4print("无论如何都执行") # 不缩进 = 在 if 外面1score = 752
3if score >= 60:4 print("及格")5else:6 print("不及格")1score = 852
3if score >= 90:4 grade = "优秀"5elif score >= 80:6 grade = "良好"7elif score >= 70:8 grade = "中等"9elif score >= 60:10 grade = "及格"11else:12 grade = "不及格"13
14print(f"等级：{grade}") # 良好执行逻辑：从上往下逐个判断，命中即止——所以条件要从严格到宽松排列。如果把 score >= 60 放第一个，90 分也会被判”及格”。
1age = 202has_id = True3
4if age >= 18:5 if has_id:6 print("允许进入")7 else:8 print("请出示证件")9else:10 print("未成年禁止入内")嵌套超过两层就该考虑合并条件：if age >= 18 and has_id:。
一行搞定简单二选一：
1age = 202status = "成年" if age >= 18 else "未成年"3print(status) # 成年1def handle(command):2 match command.split():3 case ["go", direction]:4 return f"向 {direction} 移动"5 case ["look"]:6 return "环顾四周"7 case ["pick", item, "up"]:8 return f"捡起 {item}"9 case _:10 return "未知指令"11
12print(handle("go north")) # 向 north 移动13print(handle("pick key up")) # 捡起 key适合替代长串 elif，case _ 是兜底分支。
1count = 12while count <= 5:3 print(f"第 {count} 圈")4 count += 1 # 千万别忘了改变条件，否则死循环！三要素：初始化（count=1）、条件（<=5）、更新（count+=1）。漏掉第三步就是死循环。
1import random2
3answer = random.randint(1, 100) # 1~100 随机整数4tries = 05
6while True:7 guess = int(input("猜一个 1-100 的数："))8 tries += 19
10 if guess < answer:11 print("小了")12 elif guess > answer:13 print("大了")14 else:15 print(f"猜对了！用了 {tries} 次")16 break # 跳出循环while True + break 是”先执行、后判断退出”的标准写法。
for 用来逐个取出序列（字符串/列表/字典…）里的元素：
1# 遍历字符串2for ch in "abc":3 print(ch) # a b c 各一行4
5# 遍历列表6for lang in ["Python", "C++", "Java"]:7 print(lang)8
9# 遍历字典：items() 同时拿键和值10scores = {"小明": 90, "小红": 85}11for name, score in scores.items():12 print(f"{name}: {score}分")1range(5) # 0 1 2 3 4 （含头不含尾）2range(1, 6) # 1 2 3 4 53range(0, 10, 2) # 0 2 4 6 8 （步长 2）4range(10, 0, -1) # 10 9 8 ... 1 （倒序）5
6for i in range(1, 4):7 print(f"{i} 的平方是 {i**2}")1langs = ["Python", "C++", "Java"]2
3# 笨办法4for i in range(len(langs)):5 print(i, langs[i])6
7# 优雅办法8for i, lang in enumerate(langs):9 print(f"第{i}名：{lang}")10# 第0名：Python ...1names = ["小明", "小红", "小刚"]2scores = [90, 85, 78]3
4for name, score in zip(names, scores):5 print(f"{name}: {score}分")1# break：立即终止整个循环2for n in [3, 7, 12, 5, 8]:3 if n > 10:4 print(f"找到大于10的数：{n}")5 break6
7# continue：跳过本次，进入下一次8for n in range(10):9 if n % 2 == 0:10 continue # 偶数跳过11 print(n, end=" ") # 1 3 5 7 9循环的 else 子句（Python 特色，别处没有）：循环没被 break 打断而正常结束才执行：
1# 找质数的标准姿势2n = 133for i in range(2, n):4 if n % i == 0:5 print(f"{n} 不是质数，能被 {i} 整除")6 break7else:8 print(f"{n} 是质数") # 循环正常跑完没 break → 是质数1# 九九乘法表2for i in range(1, 10):3 for j in range(1, i + 1):4 print(f"{j}×{i}={i*j}", end="\t")5 print() # 每行结束换行输出（三角形排布）：
11×1=121×2=2 2×2=431×3=3 2×3=6 3×3=94...（共 9 行）嵌套循环次数是相乘的：外 3 次内 4 次共 12 次，层数越多越要小心性能。
用一行表达”遍历 + 处理 + 收集”：
1# 列表推导式：[表达式 for 变量 in 序列 if 条件]2squares = [i**2 for i in range(1, 6)]3print(squares) # [1, 4, 9, 16, 25]4
5evens = [i for i in range(20) if i % 2 == 0]6print(evens) # [0, 2, 4, 6, 8, ...]7
8# 带条件表达式9labels = ["偶" if i % 2 == 0 else "奇" for i in range(5)]10print(labels) # ['偶', '奇', '偶', '奇', '偶']11
12# 字典推导式13word = "hello"14freq = {ch: word.count(ch) for ch in set(word)}15print(freq) # {'h': 1, 'e': 1, 'l': 2, 'o': 1}可读性原则：逻辑超过一层嵌套就老实写 for 循环，别炫技。
1total = 02for i in range(1, 101):3 total += i4print(total) # 50505# 数学解法彩蛋：print(100*101//2)1a, b = 0, 12for _ in range(20):3 print(a, end=" ")4 a, b = b, a + b5# 0 1 1 2 3 5 8 13 21 ...1n = int(input("输入一个数："))2
3if n < 2:4 print("不是质数")5else:6 for i in range(2, int(n**0.5) + 1): # 只需检查到平方根7 if n % i == 0:8 print(f"不是质数，{n} = {i} × {n//i}")9 break10 else:11 print("是质数")优化点：判断到 n**0.5 即可——若 n 有大于平方根的因子，必然对应一个小于平方根的因子。
1for n in range(100, 1000):2 digits = str(n)3 if int(digits[0])**3 + int(digits[1])**3 + int(digits[2])**3 == n:4 print(n) # 153 370 371 407"3" not in str(n)）下一篇：列表与元组——Python 最常用的数据容器。
本系列为 Cyber先锋社原创教程。练习务必亲手做，答案写进你自己的代码笔记本。
单个变量存单个值，但现实数据往往是”一堆”：一门课的所有成绩、购物车里的商品、通讯录联系人。列表和元组就是 Python 存放”一堆数据”的基础容器，也是使用频率最高的数据结构。
1# 直接创建2scores = [90, 85, 78, 92, 66]3empty = [] # 空列表4mixed = [1, "hello", 3.14, True] # 可以混装类型（但不建议）5nested = [1, [2, 3], [4, [5]]] # 列表可以嵌套6
7# list() 从其他序列转换8print(list("abc")) # ['a', 'b', 'c']9print(list(range(5))) # [0, 1, 2, 3, 4]索引与切片规则与字符串完全一致（含头不含尾、负数索引）：
1scores = [90, 85, 78, 92, 66]2
3print(scores[0]) # 904print(scores[-1]) # 665print(scores[1:4]) # [85, 78, 92]6print(scores[::-1]) # 倒序列表7print(len(scores)) # 51langs = ["Python"]2
3langs.append("Java") # 尾部追加单个 → ['Python', 'Java']4langs.insert(1, "C++") # 指定位置插入 → ['Python', 'C++', 'Java']5langs.extend(["Go", "Rust"]) # 合并另一个序列 → [..., 'Go', 'Rust']6langs += ["C#"] # += 等价于 extendappend 与 extend 的经典坑：
1a = [1, 2]2a.append([3, 4]) # [1, 2, [3, 4]] 整个列表作为一个元素！3b = [1, 2]4b.extend([3, 4]) # [1, 2, 3, 4] 逐个合并 ✓1nums = [10, 20, 30, 20, 40]2
3nums.remove(20) # 按值删：只删第一个匹配项 → [10, 30, 20, 40]4last = nums.pop() # 按索引删并返回该值：40，nums → [10, 30, 20]5first = nums.pop(0) # 弹出索引0：106del nums[0] # del 语句删除：30 被删7# nums 现在是 [20]8
9# 值不存在时 remove 会报 ValueError，安全写法：10if 999 in nums:11 nums.remove(999)1scores = [90, 85, 78]2scores[0] = 95 # 单个改3scores[1:3] = [80, 88] # 切片批量改1langs = ["Python", "C++", "Java"]2
3print("Go" in langs) # False4print(langs.index("Java")) # 2（不存在会报 ValueError）5print([1, 2, 2, 3].count(2)) # 21nums = [3, 1, 4, 1, 5, 9, 2, 6]2
3# sorted()：返回新列表，原列表不动4new = sorted(nums)5print(new) # [1, 1, 2, 3, 4, 5, 6, 9]6print(nums) # [3, 1, 4, 1, 5, 9, 2, 6] 原样7
8# .sort()：原地排序，返回 None9nums.sort()10print(nums) # [1, 1, 2, 3, 4, 5, 6, 9]11
12# 降序13nums.sort(reverse=True)14print(sorted(nums, reverse=True))nums = nums.sort() 是经典错误——sort 返回 None，这句执行后 nums 变成 None。
1words = ["banana", "apple", "cherry", "fig"]2
3words.sort() # 字典序4words.sort(key=len) # 按长度：['fig', 'apple', ...]5words.sort(key=len, reverse=True) # 按长度降序6
7# 排序复杂数据：按成绩降序8students = [("小明", 90), ("小红", 85), ("小刚", 92)]9students.sort(key=lambda s: s[1], reverse=True)10print(students) # [('小刚', 92), ('小明', 90), ('小红', 85)]lambda s: s[1] 是匿名函数（第六篇详讲），意思是”取每个元素的第 1 位作为排序依据”。
1scores = [90, 85, 78, 92, 66]2
3print(max(scores), min(scores), sum(scores))4# 92 66 4115print(f"平均分 {sum(scores)/len(scores):.1f}") # 82.21a = [1, 2, 3]2b = a # 不是复制！b 和 a 指向同一个列表3b.append(4)4print(a) # [1, 2, 3, 4] —— a 也"变"了5print(a is b) # True1a = [1, 2, 3]2b = a.copy() # 写法13c = a[:] # 写法2 切片4d = list(a) # 写法3 构造5
6b.append(4)7print(a) # [1, 2, 3] ✓ a 不受影响8print(a is b) # False1a = [1, [2, 3]]2b = a.copy() # 浅拷贝：只复制第一层3b[1].append(4)4print(a) # [1, [2, 3, 4]] —— 内层列表是共享的！5
6# 深拷贝：彻底独立7import copy8c = copy.deepcopy(a)9c[1].append(99)10print(a) # [1, [2, 3, 4]] 不受影响 ✓记忆法：= 是”贴标签”，.copy() 是”复印一层”，deepcopy 是”整棵复印”。
1scores = [90, 85, 78, 92, 66, 88, 73]2
3print(f"人数: {len(scores)}")4print(f"最高: {max(scores)} 最低: {min(scores)}")5print(f"平均: {sum(scores)/len(scores):.1f}")6
7# 统计各分数段8a = [s for s in scores if s >= 90]9b = [s for s in scores if 80 <= s < 90]10c = [s for s in scores if s < 60]11print(f"90+ 有 {len(a)} 人，挂科 {len(c)} 人")12
13# 排名（保留原下标）14ranking = sorted(enumerate(scores), key=lambda x: x[1], reverse=True)15for rank, (idx, s) in enumerate(ranking, 1):16 print(f"第{rank}名：{s}分（第{idx+1}位同学）")1cart = [] # [(商品名, 单价, 数量), ...]2
3def add_item(name, price, qty=1):4 for i, (n, p, q) in enumerate(cart):5 if n == name: # 已存在则加数量6 cart[i] = (n, p, q + qty)7 return8 cart.append((name, price, qty))9
10def checkout():11 total = sum(p * q for _, p, q in cart)12 print("---- 账单 ----")13 for name, price, qty in cart:14 print(f"{name} × {qty} = ¥{price*qty:.2f}")15 print(f"合计：¥{total:.2f}")16
17add_item("键盘", 199, 1)18add_item("鼠标", 89, 2)19add_item("键盘", 199, 1) # 再买一把 → 数量变 220checkout()1point = (3, 5)2single = (42,) # ⚠️ 单元素必须带逗号！3also_tuple = 1, 2, 3 # 括号可省，逗号才是本质4x, y = point # 解包：x=3, y=55print(also_tuple)元组支持索引、切片、len、in、遍历——一切”读”操作都与列表相同；但不能增删改：
1point = (3, 5)2print(point[0], len(point), 3 in point) # ✓ 都可以3point[0] = 10 # ❌ TypeError4point.append(6) # ❌ 没有这个方法locations = {(39.9, 116.4): "北京"}return x, y 本质就是返回元组1t = (1, 2, 3)2lst = list(t) # (1,2,3) → [1,2,3]3back = tuple(lst) # [1,2,3] → (1,2,3)| 场景 | 选择 |
|---|---|
| 会增删改的数据（待办、消息队列） | 列表 |
| 固定不变的数据（坐标、常量组） | 元组 |
| 需要做字典的键 | 元组 |
| 函数返回多个值 | 元组（自动） |
[1,3,5] 与 [2,3,6] → [1,2,3,5,6]（提示：set 或 手写）[[1,2,3],[4,5,6]] → [[1,4],[2,5],[3,6]]（提示：嵌套推导式）a = (1, [2, 3]) 元组中内层列表的第 0 个元素为 99——会报错吗？（动手验证：元组不可变，但内层列表可以）= 是引用，.copy() 浅拷贝只复制一层，嵌套结构用 deepcopy下一篇：字典与集合——用键查值的”通讯录”与自动去重的”收纳盒”。
本系列为 Cyber先锋社原创教程。深浅拷贝的例子请务必亲手跑一遍，坑过一次就记住了。
列表用”位置”找数据（nums[0]），但很多时候我们需要用”名字”找数据——学号查成绩、用户名查密码、单词查释义。字典就是干这个的；集合则是自动去重的数学容器。学完本篇，Python 四大容器（列表/元组/字典/集合）就集齐了。
1# 键值对：{键: 值, ...}2student = {3 "name": "小明",4 "age": 18,5 "major": "计算机科学",6 "scores": {"python": 90, "cpp": 85}, # 字典可以嵌套7}8
9print(student["name"]) # 小明10print(student["scores"]["python"]) # 90（链式访问嵌套）11
12# 空字典13empty = {}14also_empty = dict()15
16# dict() 构造17ages = dict(小明=18, 小红=17) # {'小明': 18, '小红': 17}18pairs = dict([("a", 1), ("b", 2)]) # {'a': 1, 'b': 2}键的要求：必须不可变（字符串/数字/元组可以，列表不行），且唯一（重复定义后者覆盖前者）。
1user = {"name": "小明"}2
3user["age"] = 18 # 键不存在 → 新增4user["age"] = 19 # 键已存在 → 修改5user.update({"city": "北京", "age": 20}) # 批量增改6print(user) # {'name': '小明', 'age': 20, 'city': '北京'}1user = {"name": "小明", "age": 18}2
3# 1. [] 直接访问：键不存在直接报错4print(user["name"]) # 小明5# print(user["email"]) # ❌ KeyError!6
7# 2. .get()：不存在返回 None（或默认值），推荐8print(user.get("email")) # None9print(user.get("email", "未填写")) # 未填写10
11# 3. in：先判断再访问12if "age" in user:13 print("年龄:", user["age"])日常写法用 .get()；确定键必存在（如自己刚放进去的）才用 []。
1stats = {}2# 统计字符出现次数的优雅写法3for ch in "hello":4 stats.setdefault(ch, 0) # 没有该键就先设为 05 stats[ch] += 16print(stats) # {'h': 1, 'e': 1, 'l': 2, 'o': 1}1user = {"name": "小明", "age": 18, "city": "北京"}2
3age = user.pop("age") # 删除并返回值：184del user["city"] # del 语句删除5user.pop("email", None) # 键不存在不报错（给了默认值）6
7last = user.popitem() # 删除并返回最后一个键值对8print(user) # {}1scores = {"小明": 90, "小红": 85, "小刚": 92}2
3# 遍历键（默认就是遍历键）4for name in scores:5 print(name)6
7# 遍历值8for score in scores.values():9 print(score)10
11# 同时遍历键和值（最常用）12for name, score in scores.items():13 print(f"{name}: {score} 分")1scores = {"小明": 90, "小红": 85}2
3print(len(scores)) # 24print(max(scores, key=scores.get)) # 小刚→最高分的人名（key=按值比较）5print(list(scores.keys())) # ['小明', '小红']6print(list(scores.values())) # [90, 85]7
8# 合并（Python 3.5+）9extra = {"小刚": 92}10all_scores = {**scores, **extra}11# Python 3.9+ 更简洁：12all_scores = scores | extra1text = """python is simple and python is powerful2learn python and code python"""3
4# 方法：setdefault 计数5freq = {}6for word in text.split():7 freq.setdefault(word, 0)8 freq[word] += 19
10# 按次数降序输出 Top 311for word, count in sorted(freq.items(), key=lambda x: x[1], reverse=True)[:3]:12 print(f"{word}: {count} 次")13# python: 4 次14# and: 2 次15# is: 2 次1contacts = {2 "小明": {"phone": "138xxxx", "city": "北京", "tags": ["同学", "编程组"]},3 "小红": {"phone": "139xxxx", "city": "上海", "tags": ["同学"]},4}5
6def show(name):7 info = contacts.get(name)8 if info is None:9 print(f"没有 {name} 的联系方式")10 return11 tags = "/".join(info["tags"])12 print(f"{name}｜{info['phone']}｜{info['city']}｜标签: {tags}")13
14def search_by_city(city):15 found = [n for n, i in contacts.items() if i["city"] == city]16 print(f"{city} 的联系人: {found}")17
18show("小明") # 小明｜138xxxx｜北京｜标签: 同学/编程组19search_by_city("上海") # 上海 的联系人: ['小红']1# 花括号内是元素（不是键值对）就是集合2fruits = {"apple", "banana", "apple", "cherry"}3print(fruits) # {'apple', 'banana', 'cherry'} 自动去重！4print(len(fruits)) # 35
6# ⚠️ 空花括号是字典不是集合！7empty_dict = {}8empty_set = set() # 空集合必须用 set()9
10# 从列表去重（最常用场景）11nums = [1, 3, 2, 3, 1, 5]12unique = list(set(nums))13print(unique) # [1, 2, 3, 5]（顺序不保证！）14
15# 去重且保序的写法16unique_ordered = list(dict.fromkeys(nums))17print(unique_ordered) # [1, 3, 2, 5] ✓ 保持原序1s = {1, 2, 3}2
3s.add(4) # 添加单个4s.update([5, 6]) # 添加多个5s.remove(9) # ❌ 不存在会 KeyError6s.discard(9) # ✓ 不存在也不报错（推荐）7s.pop() # 随机弹出一个元素8print(s)两个班的选课情况对比：
1class_a = {"python", "cpp", "java", "go"}2class_b = {"python", "java", "rust", "js"}3
4# 交集：都选了的课5print(class_a & class_b) # {'python', 'java'}6print(class_a.intersection(class_b)) # 同上7
8# 并集：所有人选过的课9print(class_a | class_b) # {'python','cpp','java','go','rust','js'}10
11# 差集：A 选了 B 没选的12print(class_a - class_b) # {'cpp', 'go'}13
14# 对称差：只有一方选了的（并集 - 交集）15print(class_a ^ class_b) # {'cpp', 'go', 'rust', 'js'}16
17# 子集与超集18print({"python"} <= class_a) # True 子集判断19print(class_a.issubset(class_a | class_b)) # True助记：& 交（都有的）、| 并（合起来）、- 差（我有你没有）、^ 异（不共有的）。
1squares = {i**2 for i in range(1, 6)}2print(squares) # {1, 4, 9, 16, 25}3
4# frozenset：不可变集合，可作为字典键5fs = frozenset([1, 2, 3])6# fs.add(4) # ❌ 不可变7cache = {fs: "结果"} # ✓ 合法in 集合是 O(1)，in 列表是 O(n)——数据量大时差距巨大：
1import time2
3big_list = list(range(1_000_000))4big_set = set(big_list)5
6t1 = time.time()7for _ in range(100):8 999_999 in big_list9t2 = time.time()10for _ in range(100):11 999_999 in big_set12t3 = time.time()13
14print(f"列表查找: {(t2-t1)*1000:.1f}ms")15print(f"集合查找: {(t3-t2)*1000:.1f}ms") # 快百倍以上实践建议：频繁判断”某元素是否在一堆数据里”时，把那堆数据转成集合。
| 特性 | 列表 list | 元组 tuple | 字典 dict | 集合 set |
|---|---|---|---|---|
| 符号 | [1,2] | (1,2) | {"k":v} | {1,2} |
| 有序 | ✓ | ✓ | ✓（3.7+保序） | ✗ |
| 可变 | ✓ | ✗ | ✓ | ✓ |
| 允许重复 | ✓ | ✓ | 键不行 | ✗ |
| 典型用途 | 序列数据 | 固定数据 | 映射查找 | 去重/集合运算 |
| 查找效率 | O(n) | O(n) | O(1) 按键 | O(1) |
选型口诀：排队用列表、锁死用元组、查名用字典、去重用集合。
["a","b","c","d"]、B 班 ["c","d","e","f"]，输出所有人都名单与”只在一个班”的人.get()；计数用 setdefaultkeys() / values() / items(){**a, **b} 或 3.9+ 的 a | b& | - ^ 四大运算；discard 比 remove 安全set()；频繁成员测试选集合不选列表下一篇：函数——把代码封装成可复用的积木。
本系列为 Cyber先锋社原创教程。词频统计是面试与实战双高频题，务必独立写一遍。
前面所有代码都是”线性剧本”——从上往下一次演完。函数让你把一段逻辑打包成”招式”，随叫随到、反复使用。函数是代码复用的最小单元，也是从”写脚本”迈向”写工程”的第一步。
1def greet(name):2 """向指定的人问好""" # docstring 文档字符串3 print(f"你好，{name}！")4
5greet("小明") # 调用：你好，小明！6greet("小红") # 同一段代码，复用无需复制粘贴语法要点：
def 函数名(参数): 定义；函数名(实参) 调用help(greet) 可查看calc_average），动词开头更佳1def introduce(name, age, major):2 print(f"我是{name}，{age}岁，专业{major}")3
4introduce("小明", 18, "计算机") # 顺序必须一致1introduce(major="计算机", name="小明", age=18) # 顺序随意2introduce("小明", major="软件工程", age=19) # 位置在前，关键字在后 ✓1def greet(name, greeting="你好"):2 print(f"{greeting}，{name}！")3
4greet("小明") # 你好，小明！5greet("Tom", "Hello") # Hello, Tom!默认参数的头号大坑——用可变对象做默认值：
1def add_item(item, items=[]): # ❌ 危险！2 items.append(item)3 return items4
5print(add_item(1)) # [1]6print(add_item(2)) # [1, 2]！！默认列表被"记住"了7
8# ✅ 正确姿势9def add_item(item, items=None):10 if items is None:11 items = []12 items.append(item)13 return items原因：默认值在函数定义时只创建一次。面试高频题。
1def total(*nums):2 print(type(nums)) # <class 'tuple'> 收进元组3 return sum(nums)4
5print(total(1, 2)) # 36print(total(1, 2, 3, 4, 5)) # 151def show_info(name, **extra):2 print(f"姓名：{name}")3 for k, v in extra.items():4 print(f" {k}: {v}")5
6show_info("小明", age=18, city="北京", major="计算机")7# 姓名：小明8# age: 189# city: 北京10# major: 计算机1def func(位置参数, 默认参数=x, *args, **kwargs): ...即：**普通 → 带默认 → *args → kwargs。
1def area(a, b, c):2 # 海伦公式算三角形面积3 s = (a + b + c) / 24 return (s*(s-a)*(s-b)*(s-c)) ** 0.55
6sides = [3, 4, 5]7print(area(*sides)) # * 把列表拆成三个参数8
9info = {"name": "小明", "age": 18}10greet_info = lambda **kw: kw11print(greet_info(**info)) # ** 把字典拆成关键字参数1def is_even(n):2 if n % 2 == 0:3 return True4 return False # 函数遇 return 立即结束5
6# 无 return 或只写 return → 返回 None7def say_hi():8 print("hi")9
10result = say_hi()11print(result) # None1def min_max(nums):2 return min(nums), max(nums) # 打包成元组3
4low, high = min_max([3, 1, 4, 1, 5]) # 解包接收5print(low, high) # 1 51def divide(a, b):2 if b == 0:3 return None, "除数不能为 0" # 失败返回错误信息4 return a / b, None5
6result, error = divide(10, 2)7if error:8 print("出错:", error)9else:10 print(f"结果: {result}")Python 查找变量的顺序：Local（函数内）→ Enclosing（外层函数）→ Global（模块级）→ Built-in（内置）。
1x = 10 # 全局变量2
3def outer():4 y = 20 # outer 的局部变量5 def inner():6 z = 30 # inner 的局部变量7 print(x, y, z) # 10 20 30：都能看到（LEGB 逐层向外找）8 inner()9
10outer()1count = 02
3def click():4 global count # 声明我要改全局变量5 count += 16
7click(); click()8print(count) # 2需要 global 通常说明设计有问题——更好的做法是通过参数传入、返回值传出。多线程环境 global 是重灾区。
1def make_counter():2 n = 03 def counter():4 nonlocal n # 声明改的是外层函数的变量（不是全局）5 n += 16 return n7 return counter # 返回函数本身（不带括号！）8
9c = make_counter()10print(c(), c(), c()) # 1 2 3：n 被 counter 记住了nonlocal 用于修改外层函数的变量（global 是改模块级，别混淆）。
1# lambda 参数: 表达式2square = lambda x: x ** 23print(square(5)) # 254
5# 等价的 def 写法6def square(x):7 return x ** 2lambda 的定位：临时、简单、用完即弃，尤其作为参数传递时：
1students = [("小明", 90), ("小红", 85), ("小刚", 92)]2students.sort(key=lambda s: s[1]) # 按成绩排序3best = max(students, key=lambda s: s[1]) # 成绩最高的复杂逻辑禁止写 lambda——写不下也读不懂，老实用 def。
函数当参数传的函数叫高阶函数：
1nums = [1, 2, 3, 4, 5, 6]2
3# map：逐个变换4squares = list(map(lambda x: x**2, nums))5print(squares) # [1, 4, 9, 16, 25, 36]6
7# filter：按条件筛选8evens = list(filter(lambda x: x % 2 == 0, nums))9print(evens) # [2, 4, 6]10
11# sorted（前面讲过）：带 key 排序实际上推导式通常更清晰，map/filter 了解即可：
1squares = [x**2 for x in nums] # 与 map 等价，更 Pythonic2evens = [x for x in nums if x % 2 == 0] # 与 filter 等价1def factorial(n):2 """阶乘：n! = n × (n-1)!"""3 if n <= 1: # 基线条件（出口）——必须有！4 return 15 return n * factorial(n - 1) # 递归调用6
7print(factorial(5)) # 120 = 5×4×3×2×1递归两要素：基线条件（何时停）+ 递推关系（如何缩小学）。缺出口就是无限递归，触发 RecursionError（默认上限约 1000 层）。
经典：斐波那契的递归写法与低效问题——
1def fib(n):2 if n < 2:3 return n4 return fib(n-1) + fib(n-2)5
6print(fib(10)) # 55（fib(35) 就已经很慢——重复计算爆炸）装饰器是”给函数套一层壳”的语法，Python 工程必用。看懂下面这个计时器，你就理解了它的工作原理：
1import time2from functools import wraps3
4def timer(func):5 @wraps(func)6 def wrapper(*args, **kwargs):7 start = time.time()8 result = func(*args, **kwargs) # 调用原函数9 cost = (time.time() - start) * 100010 print(f"[{func.__name__}] 耗时 {cost:.2f}ms")11 return result12 return wrapper13
14@timer # 等价于 slow_sum = timer(slow_sum)15def slow_sum(n):16 return sum(range(n))17
18slow_sum(10_000_000) # [slow_sum] 耗时 187.35ms@timer 只是个语法糖。装饰器链、带参数的装饰器等进阶内容，等做项目时再深入。
重构前（线性脚本，无法复用）：
1scores = [90, 85, 78, 92, 66]2total = sum(scores)3avg = total / len(scores)4print(f"平均 {avg:.1f}")5above = [s for s in scores if s >= avg]6print(f"高于平均: {above}")重构后（函数化，可测试可复用）：
1def analyze(scores, precision=1):2 """分析成绩：返回统计摘要字典"""3 if not scores:4 return None5 avg = sum(scores) / len(scores)6 return {7 "count": len(scores),8 "avg": round(avg, precision),9 "max": max(scores),10 "min": min(scores),11 "above_avg": [s for s in scores if s >= avg],12 }13
14def report(data):15 """打印摘要"""16 if data is None:17 print("无数据")18 return19 print(f"人数 {data['count']}，平均 {data['avg']}，"20 f"最高 {data['max']}，高于平均 {len(data['above_avg'])} 人")21
22report(analyze([90, 85, 78, 92, 66]))23report(analyze([])) # 无数据函数化三原则：一个函数做一件事、参数进结果出（少用 global）、起个说清楚的名字。
is_prime(n) 判断质数，再用它输出 100 内所有质数（重构第三篇的循环版）apply_twice(func, x)：把 func 应用两次，如 apply_twice(lambda x: x*2, 5) → 20average(*nums)，不传参数时返回 0try_login() 计数 +1，超过 3 次返回”已锁定”play() 函数，支持参数”最大范围”与”最多机会”*args → **kwargs；默认参数别用可变对象* 拆序列、** 拆字典；return 多值是元组下一篇：迭代器与生成器——省内存的懒加载艺术。
本系列为 Cyber先锋社原创教程。默认参数的坑和闭包计数器请亲手复现一遍。
你每天都在用 for x in ...，但有没有想过 for 到底是怎么”一个个取出”元素的？这背后是 Python 的迭代协议。理解它，你就能用生成器写出处理百万行数据也不爆内存的代码——这是 Python 进阶的第一道分水岭。
1nums = [1, 2, 3]2
3for n in nums:4 print(n)这段代码的幕后流程：
nums 调用 iter() 拿到一个迭代器next() 取元素StopIteration 异常时结束循环手动模拟一遍：
1nums = [1, 2, 3]2it = iter(nums) # 列表 → 迭代器3
4print(next(it)) # 15print(next(it)) # 26print(next(it)) # 37# print(next(it)) # ❌ StopIteration！取完了两个概念：
| 概念 | 说明 | 例子 |
|---|---|---|
| 可迭代对象 Iterable | 实现了 __iter__，能被 for 遍历 | 列表、字符串、字典、文件 |
| 迭代器 Iterator | 实现了 __iter__ 和 __next__，能被 next() | iter(列表) 的返回值 |
关系：迭代器一定可迭代；可迭代对象要通过 iter() 变成迭代器才能 next()。
1from collections.abc import Iterable, Iterator2
3nums = [1, 2, 3]4print(isinstance(nums, Iterable)) # True5print(isinstance(nums, Iterator)) # False！列表本身不是迭代器6print(isinstance(iter(nums), Iterator)) # True1it = iter([1, 2, 3])2for x in it:3 print(x, end=" ") # 1 2 34for x in it:5 print(x, end=" ") # （空！已耗尽）而列表可以反复 for——因为每次 for 都会重新 iter() 出新迭代器。
函数体里出现 yield，它就不再是普通函数，而是生成器函数——调用它不执行代码，而是返回一个生成器（一种迭代器）：
1def count_down(n):2 print("开始倒数")3 while n > 0:4 yield n # 产出 n，在此暂停！5 n -= 16
7gen = count_down(3)8print(gen) # <generator object ...> 还没执行！9
10print(next(gen)) # 打印"开始倒数"，返回 311print(next(gen)) # 2（从暂停处继续）12print(next(gen)) # 113# next(gen) # ❌ StopIterationyield 与 return 的本质区别：
return：交值、函数终结yield：交值、函数暂停，下次 next 从暂停行继续，局部变量全部保留1def count_down(n):2 while n > 0:3 yield n4 n -= 15
6for x in count_down(5):7 print(x, end=" ") # 5 4 3 2 1生成 1000 万个平方数：
1import sys2
3# 列表：一次性全造好放内存4big_list = [x**2 for x in range(10_000_000)]5print(f"列表占用: {sys.getsizeof(big_list)/1024/1024:.0f} MB") # 约 80+ MB6
7# 生成器：用时才算，只存"当前位置"8big_gen = (x**2 for x in range(10_000_000))9print(f"生成器占用: {sys.getsizeof(big_gen)} 字节") # 约 200 字节！生成器表达式：把列表推导式的 [] 换成 () 即可。数据流”边生成边消费”，内存占用恒定——处理大文件、大数据集的标准姿势。
1# 一亿个数求和：列表版可能内存吃紧2total = sum(x for x in range(100_000_000)) # 生成器：平稳跑完3print(total)生成器不预生成全部，所以能表达”无限”：
1def fibonacci():2 """无限斐波那契数列"""3 a, b = 0, 14 while True: # 死循环？配合 yield 就是无限流5 yield a6 a, b = b, a + b7
8# 取前 10 个：islice 从无限流切片9from itertools import islice10print(list(islice(fibonacci(), 10)))11# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]12
13# 找到第一个大于 1000 的斐波那契数14for f in fibonacci():15 if f > 1000:16 print(f) # 159717 break1def read_large_file(path):2 """逐行读取大文件，绝不整体载入"""3 with open(path, encoding="utf-8") as f:4 for line in f: # 文件对象本身可迭代（懒加载）5 yield line.strip()6
7# 统计一个 10GB 日志也只用几 MB 内存8error_count = 09for line in read_large_file("app.log"):10 if "ERROR" in line:11 error_count += 112print(f"错误行数: {error_count}")多个生成器串成流水线，数据像水流过每一站：
1def lines(path):2 with open(path, encoding="utf-8") as f:3 yield from f # yield from：把子生成器的值逐个转发4
5def only_errors(lines_iter):6 for line in lines_iter:7 if "ERROR" in line:8 yield line9
10def with_lineno(lines_iter):11 for i, line in enumerate(lines_iter, 1):12 yield f"行{i}: {line.rstrip()}"13
14# 组装流水线：此刻什么都没发生（全懒）15pipeline = with_lineno(only_errors(lines("app.log")))16
17# 消费时数据才逐条流过三层18for item in pipeline:19 print(item)yield from iterable 等价于 for x in iterable: yield x 的简写。
1def window(seq, size):2 """滑动窗口：[1,2,3,4] size=2 → (1,2) (2,3) (3,4)"""3 for i in range(len(seq) - size + 1):4 yield tuple(seq[i:i+size])5
6print(list(window([1, 2, 3, 4, 5], 3)))7# [(1, 2, 3), (2, 3, 4), (3, 4, 5)]1from itertools import chain, product, combinations, islice, count2
3# chain：拼接多个可迭代对象4print(list(chain([1, 2], "ab", (3,)))) # [1, 2, 'a', 'b', 3]5
6# product：笛卡尔积（嵌套循环的扁平写法）7print(list(product("AB", "12")))8# [('A','1'), ('A','2'), ('B','1'), ('B','2')]9
10# combinations：组合（不重复）11print(list(combinations([1, 2, 3], 2))) # [(1,2), (1,3), (2,3)]12
13# count：无限计数器14for i in count(10, 5): # 从10开始步进5：10,15,20...15 if i > 25: break16 print(i, end=" ") # 10 15 20 2517
18# islice：给无限流"切片"19print(list(islice(count(1, 2), 5))) # [1, 3, 5, 7, 9]给类实现 __iter__ 和 __next__，就能被 for 遍历：
1class Countdown:2 def __init__(self, start):3 self.n = start4
5 def __iter__(self):6 return self # 自己就是迭代器7
8 def __next__(self):9 if self.n <= 0:10 raise StopIteration11 self.n -= 112 return self.n + 113
14for x in Countdown(3):15 print(x, end=" ") # 3 2 1类的语法下一篇详讲，此处先混个脸熟。
| 场景 | 选择 |
|---|---|
| 数据大（文件/百万行） | 生成器 |
| 只遍历一次 | 生成器 |
| 需反复遍历 / 下标访问 / len() | 列表 |
| 需要切片、排序完整结果 | 列表 |
| 无限/未知长度的流 | 只能生成器 |
性能口诀：一次消费用生成，多次使用存列表。
running_average(nums)：每接收一个数 yield 当前的平均值cycle(seq)：cycle("AB") 产出 A B A B…（不许看 itertools 源码）sum([i**2 for i in range(10**7)]) 与 sum(i**2 for i in range(10**7)) 的内存占用差异（用 sys.getsizeof 或内存监视器）iter() 拿迭代器 → 反复 next() → StopIteration 结束yield 让函数暂停/恢复；生成器函数调用返回生成器(x for x in ...) 惰性求值，内存恒定下一篇：模块与标准库——站在 Python 自带的”百宝箱”上开发。
本系列为 Cyber先锋社原创教程。把”管道处理日志”例子跑通，你会对数据流有全新体感。
Python 能长期霸榜，一半功劳属于它的生态：标准库自带”充电电池”（batteries included），第三方库超过 50 万个。本篇解决三个问题：怎么组织自己的代码（模块与包）、怎么用别人的代码（导入与 pip）、哪些标准库必须先掌握。
假设有一个 my_utils.py：
1PI = 3.141592
3def circle_area(r):4 return PI * r * r5
6def _secret():7 """下划线开头：约定为内部函数，不对外提供"""8 return "internal"在其他文件中使用：
1# 方式1：导入整个模块（推荐，命名空间清晰）2import my_utils3print(my_utils.circle_area(2))4
5# 方式2：导入模块并起别名6import my_utils as mu7print(mu.circle_area(2))8
9# 方式3：导入特定名称（少打字，但可能命名冲突）10from my_utils import circle_area, PI11print(circle_area(2))12
13# 方式4：导入全部（不推荐！污染命名空间）14from my_utils import *from x import * 会引入看不见的名字，还可能覆盖你的变量（如覆盖内置函数）。规范工程禁用。
if __name__ == "__main__"：模块的身份检查#每个模块都有魔法属性 __name__：
__name__ 等于 "__main__"__name__ 等于模块名（如 "my_utils"）1def circle_area(r):2 return PI * r * r3
4if __name__ == "__main__":5 # 这段代码只在直接运行时执行，被导入时不执行6 print("自测:", circle_area(1))这是 Python 项目的标准结构：功能放函数里，测试/演示代码放 main 保护下——既能当库被导入，又能当脚本运行。
__all__ 控制 import * 的范围#1__all__ = ["circle_area", "PI"] # 只导出这两个包 = 含 __init__.py 的目录（Python 3.3+ 该文件可省，但保留是好习惯）：
1project/2├── main.py3└── club/ # 顶层包4 ├── __init__.py # 让 club 成为包5 ├── utils.py # club.utils6 └── tools/ # 子包7 ├── __init__.py8 └── net.py # club.tools.net1import club.utils # 完整路径2club.utils.circle_area(2)3
4from club.tools import net # 从子包导入5from club.tools.net import ping # 导入具体函数6
7import club.tools.net as net # 别名包内部模块互相引用时：
1from club.utils import helper # 绝对导入（推荐：清晰）2
3from ..utils import helper # 相对导入：.. 上一层包4from . import local_module # . 当前包相对导入只能用在包内，脚本顶层文件不可用。
1pip install requests # 安装2pip install requests==2.31.0 # 指定版本3pip install "requests>=2.28" # 版本范围4pip install -r requirements.txt # 按清单批量安装5pip uninstall requests # 卸载6pip list # 已装列表7pip show requests # 包详情8pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名 # 国内镜像加速requirements.txt：项目依赖清单，交接与部署必备：
1pip freeze > requirements.txt # 导出当前环境全部依赖2pip install -r requirements.txt # 他人一键还原不同项目依赖不同版本的库会互相打架，虚拟环境给每个项目独立空间：
1# 创建（venv 是标准库自带）2python -m venv venv # 在项目目录生成 venv/ 目录3
4# 激活5source venv/bin/activate # macOS / Linux6venv\Scripts\activate # Windows7
8# 激活后命令行前缀出现 (venv)，此后 pip 装的包只进这个环境9(venv) pip install requests10
11# 退出12deactivate铁律：每个项目一个虚拟环境，venv/ 目录加入 .gitignore 不进版本库。
现代替代品 uv（pip + venv 的极速合一）、poetry 也值得了解，但 venv + pip 是基本功，先掌握它。
1import os2
3# 路径操作（最常用）4os.path.join("club", "docs", "a.md") # club/docs/a.md（跨平台拼接）5os.path.exists("/etc/hosts") # True 是否存在6os.path.isfile("a.py") # 是否文件7os.path.isdir("club") # 是否目录8os.path.basename("/a/b/c.txt") # c.txt9os.path.dirname("/a/b/c.txt") # /a/b10os.path.splitext("photo.jpg") # ('photo', '.jpg')11os.path.getsize("a.py") # 字节大小12
13# 目录操作14os.getcwd() # 当前工作目录15os.listdir(".") # 列出目录内容16os.makedirs("a/b/c", exist_ok=True) # 递归建目录（存在不报错）17os.remove("temp.txt") # 删文件跨平台路径推荐用 pathlib（面向对象风格）：
1from pathlib import Path2
3p = Path("club") / "docs" / "a.md" # 用 / 拼路径，优雅4print(p.exists(), p.suffix) # True .md5for md in Path(".").glob("**/*.md"): # 递归找所有 md6 print(md)1import sys2
3print(sys.version) # Python 版本串4print(sys.platform) # darwin / win32 / linux5print(sys.argv) # 命令行参数列表！6sys.exit(1) # 退出程序（非0=异常退出）7sys.path.append("/my/libs") # 追加模块搜索路径命令行参数实战：
1import sys2
3if __name__ == "__main__":4 # python args_demo.py hello 425 print(sys.argv) # ['args_demo.py', 'hello', '42']6 name = sys.argv[1] if len(sys.argv) > 1 else "陌生人"7 print(f"你好, {name}")1import math2
3print(math.sqrt(16)) # 4.0 平方根4print(math.ceil(3.2)) # 4 向上取整5print(math.floor(3.8)) # 3 向下取整6print(math.pi, math.e) # 3.141592653589793 2.7182818284590457print(math.gcd(12, 18)) # 6 最大公约数8print(math.log(math.e)) # 1.0 自然对数9print(math.radians(180)) # 3.1415... 角度转弧度1import random2
3random.seed(42) # 固定种子：结果可复现4print(random.random()) # 0.639 [0,1) 浮点5print(random.randint(1, 6)) # 1~6 整数（含两端）——掷骰子6print(random.uniform(1.5, 3.5)) # 区间浮点7
8fruits = ["苹果", "香蕉", "橘子"]9print(random.choice(fruits)) # 随机选一个10print(random.sample(fruits, 2)) # 随机选2个（不重复）11
12nums = [1, 2, 3, 4, 5]13random.shuffle(nums) # 原地打乱14print(nums) # 例如 [3, 1, 5, 2, 4]1import json2
3student = {"name": "小明", "age": 18, "scores": [90, 85], "vip": True}4
5# 序列化：Python → JSON 字符串6text = json.dumps(student, ensure_ascii=False, indent=2)7print(text)8# {9# "name": "小明",10# "age": 18, ...11# }12
13# 反序列化：JSON 字符串 → Python14data = json.loads(text)15print(data["scores"][0]) # 9016
17# 读写 JSON 文件18with open("data.json", "w", encoding="utf-8") as f:19 json.dump(student, f, ensure_ascii=False, indent=2)20
21with open("data.json", encoding="utf-8") as f:22 loaded = json.load(f)类型对应表：
| Python | JSON |
|---|---|
| dict | object |
| list / tuple | array |
| str | string |
| int / float | number |
| True / False | true / false |
| None | null |
ensure_ascii=False 让中文正常显示，indent=2 美化缩进——两个参数是日常标配。
1from datetime import datetime, date, timedelta2
3now = datetime.now()4print(now) # 2026-10-29 12:00:00.1234565print(now.year, now.month, now.day, now.hour)6print(now.weekday()) # 0=周一 ... 6=周日7
8# 格式化输出 ↔ 解析9print(now.strftime("%Y-%m-%d %H:%M:%S")) # 2026-10-29 12:00:0010print(now.strftime("%Y年%m月%d日 %A")) # 2026年10月29日 Thursday11
12t = datetime.strptime("2026-10-01 09:00", "%Y-%m-%d %H:%M")13print(t.year) # 202614
15# 时间差 timedelta16birthday = datetime(2026, 12, 25)17delta = birthday - now18print(f"还剩 {delta.days} 天")19
20three_days_later = now + timedelta(days=3)21last_hour = now - timedelta(hours=1)22
23# 常用格式码：%Y年 %m月 %d日 %H时 %M分 %S秒 %A星期 %B月名1from collections import Counter, defaultdict, deque2
3# Counter：计数器（词频统计一步到位）4words = "the quick the lazy the dog".split()5c = Counter(words)6print(c) # Counter({'the': 3, 'quick': 1, ...})7print(c.most_common(2)) # [('the', 3), ('quick', 1)]8
9# defaultdict：带默认值的字典（告别 KeyError）10groups = defaultdict(list)11for name, cls in [("小明","A"), ("小红","B"), ("小刚","A")]:12 groups[cls].append(name) # 键不存在自动建空列表13print(dict(groups)) # {'A': ['小明', '小刚'], 'B': ['小红']}14
15# deque：双端队列（头尾操作都是 O(1)，列表头部操作是 O(n)）16dq = deque([1, 2, 3])17dq.appendleft(0) # deque([0, 1, 2, 3])18dq.append(4) # deque([0, 1, 2, 3, 4])19dq.popleft() # 0（当队列用：append 入队，popleft 出队）1my_project/2├── main.py # 入口：只做调度3├── config.py # 配置集中管理4├── requirements.txt # 依赖清单5├── utils/ # 工具包6│ ├── __init__.py7│ ├── files.py # 文件相关函数8│ └── net.py # 网络相关函数9└── tests/ # 测试10 └── test_utils.py三条军规：入口薄、功能分文件、依赖写清单。
math_extra.py：提供 is_prime、fib_list(n)，带 __main__ 自测块；在另一文件导入验证pathlib 递归统计某目录下所有 .py 文件的总行数json 把一个”通讯录字典”保存到文件，重启程序后能加载回来Counter 统计一段英文中出现频率最高的 5 个单词（去掉 the/a/is 等停用词）datetime 实现import x / import x as y；禁用 import *if __name__ == "__main__" 让模块既能导入又能运行__init__.py；一项目一虚拟环境，依赖写 requirements.txt下一篇：文件操作与异常处理——让程序可靠地读写与容错。
本系列为 Cyber先锋社原创教程。json 与 datetime 在 Web/爬虫/数据处理的出镜率接近 100%。
程序的价值在于持久化（数据存下来）和健壮性（出错不崩）。本篇把文件操作与异常处理一次讲透——这两个主题天然是一对：凡是碰文件、网络、用户输入的代码，都必须考虑”出错怎么办”。
1f = open("demo.txt", "r", encoding="utf-8")常用模式：
| 模式 | 含义 | 文件不存在 | 文件存在 |
|---|---|---|---|
"r" | 只读（默认） | ❌ 报错 | 从头读 |
"w" | 只写 | ✅ 创建 | 清空重写！ |
"a" | 追加 | ✅ 创建 | 末尾追加 |
"x" | 独占创建 | ❌ 报错 | ❌ 报错（防覆盖） |
"r+" | 读+写 | ❌ 报错 | 读写均可 |
"b" | 二进制（rb/wb/ab） | 组合使用 | 处理图片/音频等 |
编码：永远显式写 encoding="utf-8"。不写的话 Windows 默认 GBK，同一份代码换个系统就读炸——中文乱码/UnicodeDecodeError 十有八九源自这里。
1# ❌ 手动式：忘了 close，或中途异常导致文件句柄泄漏2f = open("demo.txt", encoding="utf-8")3content = f.read()4f.close()5
6# ✅ with 式：代码块结束自动关闭，异常也会关闭7with open("demo.txt", encoding="utf-8") as f:8 content = f.read()9print(content)1# 1. read()：一次读完整个文件（小文件适用）2with open("demo.txt", encoding="utf-8") as f:3 text = f.read()4
5# 2. read(n)：读 n 个字符6with open("demo.txt", encoding="utf-8") as f:7 head = f.read(10) # 前 10 个字符8
9# 3. readline()：每次读一行10with open("demo.txt", encoding="utf-8") as f:11 first = f.readline() # 第一行（含 \n）12
13# 4. readlines()：读出所有行组成列表14with open("demo.txt", encoding="utf-8") as f:15 lines = f.readlines() # ['第一行\n', '第二行\n', ...]16
17# ⭐ 最佳实践：直接迭代文件对象（逐行懒加载，大文件友好）18with open("demo.txt", encoding="utf-8") as f:19 for line in f:20 process(line.strip()) # strip 去掉行尾换行符1# w 模式：覆盖写2with open("out.txt", "w", encoding="utf-8") as f:3 f.write("第一行\n")4 f.write("第二行\n")5 f.writelines(["三\n", "四\n"]) # 写入字符串列表（不自动加换行！）6
7# a 模式：追加写（记日志、断点续写）8with open("log.txt", "a", encoding="utf-8") as f:9 f.write(f"新的一条记录\n")write 不自动换行，要自己加 \n；"w" 模式打开的一瞬间文件就被清空——哪怕你一行都没写。
1with open("demo.txt", encoding="utf-8") as f:2 print(f.read()) # 读完，指针在末尾3 print(f.read()) # ''（空！指针已在末尾）4 f.seek(0) # 指针拨回开头5 print(f.read()) # 又能读了6 print(f.tell()) # 当前指针位置1import csv2from pathlib import Path3
4def save_students(students, path="students.csv"):5 """保存：[(姓名, 成绩), ...]"""6 with open(path, "w", newline="", encoding="utf-8") as f:7 writer = csv.writer(f)8 writer.writerow(["姓名", "成绩"]) # 表头9 writer.writerows(students)10
11def load_students(path="students.csv"):12 """读取，返回列表"""13 if not Path(path).exists():14 return []15 with open(path, encoding="utf-8") as f:16 reader = csv.reader(f)17 next(reader, None) # 跳过表头18 return [(row[0], int(row[1])) for row in reader if row]19
20save_students([("小明", 90), ("小红", 85)])21print(load_students())22# [('小明', 90), ('小红', 85)]csv 模块自动处理逗号转义与引号，比手动 split 可靠得多；newline="" 是 csv 写入的标准搭配。
1nums = [1, 2, 3]2print(nums[10]) # IndexError，程序当场去世3print("这行永远执行不到")1try:2 risky_code()3except SomeError:4 handle_it()1try:2 n = int(input("输入一个数：")) # 输入 "abc" 会抛 ValueError3 print(100 / n) # n=0 会抛 ZeroDivisionError4except ValueError:5 print("这不是有效的数字")6except ZeroDivisionError:7 print("除数不能为 0")1try:2 n = int("abc")3except ValueError as e:4 print(f"错误详情：{e}") # invalid literal for int() with base 10: 'abc'1try:2 data = load_config()3except (FileNotFoundError, PermissionError):4 print("配置文件读不了，用默认配置")5 data = {"debug": False}6except Exception as e: # 兜底：捕获所有常规异常7 print(f"未知错误: {e}")8 raise # 打印后继续抛出（记日志场景常用）工程军规：
except: 会连 Ctrl+C 的 KeyboardInterrupt 都吞掉，绝对禁止except Exception 只在最外层兜底用1def read_score(path):2 try:3 f = open(path, encoding="utf-8")4 except FileNotFoundError:5 print("文件不存在")6 return None7 else:8 # try 没出错才执行（把"成功逻辑"和"危险代码"分离）9 score = int(f.read())10 f.close()11 return score12 finally:13 print("无论如何都执行（常用于清理资源）")else：try 块没有发生异常时执行finally：无论如何都执行（成功/失败/return/break），释放资源的最后一道防线1def set_age(age):2 if not isinstance(age, int):3 raise TypeError("age 必须是整数")4 if not 0 <= age <= 150:5 raise ValueError(f"age 越界: {age}") # 参数校验的标准做法6 return age7
8set_age("十八") # TypeError: age 必须是整数1# 自定义异常：继承 Exception（命名以 Error 结尾）2class ConfigError(Exception):3 """配置相关错误"""4 def __init__(self, key, msg=""):5 super().__init__(f"配置项 [{key}] 出错: {msg}")6
7def load_config(key):8 data = {"host": "localhost"}9 if key not in data:10 raise ConfigError(key, "缺少必填配置") # 抛出自定义异常11
12try:13 load_config("port")14except ConfigError as e:15 print(e) # 配置项 [port] 出错: 缺少必填配置自定义异常的价值：调用方可以精确 catch 你的业务错误，而不是笼统的 Exception。
| 异常 | 触发场景 |
|---|---|
ValueError | 值不合法：int("abc") |
TypeError | 类型错误："a" + 1 |
IndexError | 下标越界：[1,2][5] |
KeyError | 字典键不存在：d["x"] |
FileNotFoundError | 打开不存在的文件 |
ZeroDivisionError | 除以零 |
AttributeError | 属性/方法不存在："a".push() |
NameError | 变量未定义 |
ImportError | 导入失败（库没装） |
RecursionError | 递归过深 |
综合本篇知识点（with + 精确捕获 + 自定义异常 + logging）：
1import logging2
3logging.basicConfig(4 filename="app.log", level=logging.INFO,5 format="%(asctime)s [%(levelname)s] %(message)s",6)7
8class DataFormatError(Exception):9 pass10
11def load_numbers(path):12 """读取每行一个数字的文件，返回 int 列表；格式问题跳行并记日志"""13 numbers = []14 with open(path, encoding="utf-8") as f:15 for lineno, line in enumerate(f, 1):16 line = line.strip()17 if not line:18 continue19 try:20 numbers.append(int(line))21 except ValueError as e:22 logging.warning("第%d行格式错误，已跳过: %r (%s)",23 lineno, line, e)24 return numbers25
26# 运行：合法行全收录，坏行进日志，程序不崩27print(load_numbers("numbers.txt"))这就是生产代码的样子：预期内的错降级处理，预期外的错明确抛出，全程留痕。
Python 社区推崇 EAFP（Easier to Ask Forgiveness than Permission，先斩后奏）：
1# LBYL：先问许可（先检查再操作——有竞态风险，且啰嗦）2if "port" in config:3 port = config["port"]4else:5 port = 80806
7# EAFP：直接干，出错再说（Pythonic）8try:9 port = config["port"]10except KeyError:11 port = 808012
13# 当然这个场景还有最简写法（第五篇）：14port = config.get("port", 8080)safe_divide(a, b)：除零时返回 None 并打印友好提示save(contacts, path) 存 json、load(path) 读 json；文件不存在返回空字典；json 损坏时给出明确错误并返回空字典try/except 改写第三篇猜数字游戏：输入非数字不崩溃，提示重输.log 文件总大小，单文件读取失败时记 warning 继续（OSError）load_numbers 加功能：支持”数字,标签”格式（如 90,数学），标签非法时跳行encoding="utf-8"for line in f，不 read() 全量下一篇：面向对象编程——用类搭建大型程序的组织形态。
本系列为 Cyber先锋社原创教程。把”带日志读取器”读懂改会，你的代码就从”能跑”升级到”可靠”。
函数把”动作”打包，类把”数据 + 动作”一起打包。面向对象编程（OOP）是组织大型程序的主流范式——游戏里的每个角色、Web 框架里的每个请求对象、AI 库里的每个模型，都是”类的实例”。本篇从零讲透 Python OOP。
1class Student:2 """学生类——图纸"""3 school = "Cyber先锋社" # 类属性：所有实例共享4
5 def __init__(self, name, age): # 构造方法：创建实例时自动调用6 self.name = name # 实例属性：每个实例独有7 self.age = age8
9 def introduce(self): # 实例方法10 return f"我是{name}..."核心概念对照：
| 概念 | 类比 | 归属 |
|---|---|---|
| 类 class | 图纸 | 一份 |
| 实例 instance | 按图纸造的产品 | 可以很多个 |
| 类属性 | 产品系列共同配置 | 所有实例共享 |
| 实例属性 | 单个产品的编号 | 各自独立 |
1class Student:2 school = "Cyber先锋社"3
4 def __init__(self, name, age):5 self.name = name6 self.age = age7
8 def introduce(self):9 return f"我是{self.name}，{self.age}岁，来自{self.school}"10
11ming = Student("小明", 18) # 自动调用 __init__12hong = Student("小红", 17)13
14print(ming.introduce()) # 我是小明，18岁，来自Cyber先锋社15print(hong.introduce()) # 我是小红，17岁，来自Cyber先锋社16print(ming.name) # 直接访问属性17print(Student.school) # 类属性通过类访问self 就是实例自己。ming.introduce() 实际是 Student.introduce(ming) 的语法糖——Python 把实例自动传给第一个参数：
1print(Student.introduce(ming)) # 与 ming.introduce() 完全等价三条铁律：实例方法第一个参数必须是 self（名字可换但别换）；调用时不传 self；self.xxx = 值 创建实例属性。
1class Student:2 school = "先锋社"3
4s1 = Student()5s2 = Student()6
7s1.school = "吉他社" # 给 s1 创建了同名实例属性（遮蔽类属性）8print(s1.school) # 吉他社（实例属性优先）9print(s2.school) # 先锋社（s2 没有实例属性，找到类属性）10
11Student.school = "篮球社" # 改类属性本身12print(s2.school) # 篮球社查找顺序：实例属性 → 类属性 → 父类属性。
1from datetime import date2
3class Student:4 school = "先锋社"5
6 def __init__(self, name, birth_year):7 self.name = name8 self.birth_year = birth_year9
10 def grade(self): # 实例方法：访问实例数据11 return date.today().year - self.birth_year12
13 @classmethod14 def from_birth_year(cls, name, age): # 类方法：备选构造器（常用！）15 return cls(name, date.today().year - age)16
17 @staticmethod18 def is_valid_age(age): # 静态方法：与实例无关的工具函数19 return 6 <= age <= 10020
21ming = Student.from_birth_year("小明", 18) # 类方法创建实例22print(Student.is_valid_age(ming.grade())) # Trueself@classmethod：第一个参数 cls，常用于备选构造方式@staticmethod：不带自动参数，就是放在类里的普通函数1class Account:2 def __init__(self, owner, balance=0):3 self.owner = owner # 公开：随意访问4 self._bank_no = "6222..." # 单下划线：约定为"内部"，外部别碰（语言不禁止）5 self.__password = "123456" # 双下划线：名称改写，外部无法直接访问6
7 def verify(self, pwd):8 return self.__check(pwd) # 内部方法公开调用9
10 def __check(self, pwd): # 私有方法11 return pwd == self.__password12
13acc = Account("小明")14# print(acc.__password) # ❌ AttributeError15# print(acc.__check("123")) # ❌ 同理16print(acc.verify("123456")) # True：通过公开接口使用内部实现Python 的私有是”君子协定”：__name 被改写为 _Account__name（用 acc._Account__password 其实能访问到，但永远别这么干）。
1class Circle:2 def __init__(self, radius):3 self._radius = radius4
5 @property6 def radius(self): # getter：c.radius 触发7 return self._radius8
9 @radius.setter10 def radius(self, value): # setter：c.radius = x 触发（带校验）11 if value <= 0:12 raise ValueError("半径必须为正数")13 self._radius = value14
15 @property16 def area(self): # 只读属性：只提供 getter17 return 3.14159 * self._radius ** 218
19c = Circle(5)20print(c.area) # 78.53975 —— 像属性，实际在计算21c.radius = 10 # 走 setter 校验22print(c.area) # 314.15923# c.area = 100 # ❌ AttributeError 只读使用时机：属性需要计算（面积）或赋值需要校验（半径）时，对外仍保持 obj.attr 的简洁语法。
1class Animal:2 def __init__(self, name):3 self.name = name4
5 def speak(self):6 return f"{self.name}在发出声音"7
8 def info(self):9 return f"[{type(self).__name__}] {self.name}"10
11class Dog(Animal): # Dog 继承 Animal12 def fetch(self): # 子类新增方法13 return f"{self.name}去捡球！"14
15class Cat(Animal):16 def speak(self): # 方法重写（override）17 return f"{self.name}：喵～"18
19dog = Dog("旺财")20cat = Cat("咪咪")21
22print(dog.info()) # [Dog] 旺财（继承来的方法）23print(dog.fetch()) # 旺财去捡球！（自己的新方法）24print(dog.speak()) # 旺财在发出声音（没重写，用父类版）25print(cat.speak()) # 咪咪：喵～（重写了自己的版本）1class Animal:2 def __init__(self, name, age):3 self.name = name4 self.age = age5
6class Dog(Animal):7 def __init__(self, name, age, breed):8 super().__init__(name, age) # 先让父类完成初始化9 self.breed = breed # 再补充子类特有的10
11d = Dog("旺财", 3, "柴犬")12print(d.name, d.age, d.breed)1def let_it_speak(animal):2 """不关心具体类型，只管调用 speak——多态的威力"""3 print(animal.speak())4
5animals = [Dog("旺财"), Cat("咪咪"), Animal("神秘生物")]6for a in animals:7 let_it_speak(a)8# 旺财在发出声音9# 咪咪：喵～10# 神秘生物在发出声音let_it_speak 对”任何有 speak 方法的对象”都有效——这叫鸭子类型（走起来像鸭子叫起来像鸭子，那就是鸭子）。Python 不检查继承关系，只看”有没有这个方法”：
1class Robot: # 没继承 Animal！2 def speak(self):3 return "嘀嘀——"4
5let_it_speak(Robot()) # ✓ 照样工作1print(isinstance(dog, Dog)) # True2print(isinstance(dog, Animal)) # True（Dog 是 Animal 的子类）3print(issubclass(Dog, Animal)) # True4print(issubclass(Cat, Dog)) # False双下划线包裹的方法在特定场景被 Python 自动调用：
1class Book:2 def __init__(self, title, price):3 self.title = title4 self.price = price5
6 def __str__(self): # print / str() 时调用7 return f"《{self.title}》¥{self.price}"8
9 def __repr__(self): # 调试/容器内显示时调用10 return f"Book({self.title!r}, {self.price})"11
12 def __eq__(self, other): # == 比较13 return isinstance(other, Book) and self.title == other.title14
15 def __lt__(self, other): # < 比较（配合 sort）16 return self.price < other.price17
18 def __len__(self): # len() 行为19 return len(self.title)20
21 def __add__(self, other): # + 行为22 return self.price + other.price23
24b1 = Book("Python入门", 59)25b2 = Book("Python入门", 79)26
27print(b1) # 《Python入门》¥5928print(b1 == b2) # True（同名即相等）29books = [Book("A书", 49), Book("B书", 29)]30books.sort() # 按 __lt__ 排序31print(len(b1)) # 9（标题字符数）32print(b1 + b2) # 138（价格相加）常用魔法方法速查：
| 方法 | 触发时机 |
|---|---|
__init__ | 创建实例 |
__str__ / __repr__ | print / 调试显示 |
__eq__ / __lt__ | == / <（排序） |
__len__ | len(obj) |
__add__ | obj + x |
__iter__ / __next__ | for 遍历（第七篇） |
__enter__ / __exit__ | with 语句 |
__getitem__ | obj[key] |
纯存数据的类（学生、订单、配置）可用 @dataclass 自动生成 __init__、__repr__、__eq__：
1from dataclasses import dataclass, field2
3@dataclass4class Student:5 name: str6 age: int7 scores: list = field(default_factory=list) # 可变默认值的安全写法8
9 def average(self):10 return sum(self.scores) / len(self.scores) if self.scores else 011
12s = Student("小明", 18, [90, 85])13print(s) # Student(name='小明', age=18, scores=[90, 85])14print(s.average()) # 87.5相比手写，省掉 80% 样板代码，现代 Python 写数据类的首选。
把本篇全部知识串起来：
1from dataclasses import dataclass, field2from datetime import date, timedelta3
4class LibraryError(Exception):5 """图书馆业务异常"""6 pass7
8@dataclass9class Book:10 isbn: str11 title: str12 copies: int = 113 borrowers: list = field(default_factory=list)14
15 @property16 def available(self) -> int:17 return self.copies - len(self.borrowers)18
19class Member:20 def __init__(self, mid: int, name: str):21 self.mid = mid22 self.name = name23 self.borrowed: dict[str, date] = {} # isbn -> 应还日期24
25 def __str__(self):26 return f"会员{self.mid}-{self.name}（在借{len(self.borrowed)}本）"27
28class Library:29 LOAN_DAYS = 3030 MAX_BOOKS = 331
32 def __init__(self):33 self._books: dict[str, Book] = {}34 self._members: dict[int, Member] = {}35
36 def add_book(self, isbn, title, copies=1):37 if isbn in self._books:38 self._books[isbn].copies += copies39 else:40 self._books[isbn] = Book(isbn, title, copies)41
42 def register(self, name) -> Member:43 mid = max(self._members, default=0) + 144 m = Member(mid, name)45 self._members[mid] = m46 return m47
48 def borrow(self, member: Member, isbn: str):49 """借书：封装所有业务规则校验"""50 book = self._books.get(isbn)51 if book is None:52 raise LibraryError(f"无此书: {isbn}")53 if book.available <= 0:54 raise LibraryError(f"《{book.title}》已全部借出")55 if len(member.borrowed) >= self.MAX_BOOKS:56 raise LibraryError(f"{member.name} 已达借阅上限{self.MAX_BOOKS}本")57
58 book.borrowers.append(member.name)59 member.borrowed[isbn] = date.today() + timedelta(days=self.LOAN_DAYS)60
61 def return_book(self, member: Member, isbn: str):62 if isbn not in member.borrowed:63 raise LibraryError(f"{member.name} 没借这本书")64 self._books[isbn].borrowers.remove(member.name)65 del member.borrowed[isbn]66
67 def __len__(self): # len(图书馆) = 藏书种数68 return len(self._books)69
70 def __contains__(self, isbn): # isbn in 图书馆71 return isbn in self._books72
73# —— 使用 ——74lib = Library()75lib.add_book("978-7-111-40701-0", "Python编程：从入门到实践", copies=2)76lib.add_book("978-7-115-53608-2", "算法（第4版）")77
78ming = lib.register("小明")79lib.borrow(ming, "978-7-111-40701-0")80print(ming) # 会员1-小明（在借1本）81print(f"馆藏 {len(lib)} 种；'978-7-115-53608-2' 在馆: {'978-7-115-53608-2' in lib}")82
83lib.return_book(ming, "978-7-111-40701-0")84print(ming) # 会员1-小明（在借0本）这个案例用到的知识点：dataclass、property、封装（_books 内部字典）、自定义异常、魔法方法 __len__/__contains__、类型注解。建议自己敲一遍再扩展（比如加逾期罚款计算）。
| 场景 | 建议 |
|---|---|
| 一次脚本、简单流程 | 函数式足够，别硬上类 |
| 多个实体有各自状态（游戏角色、订单） | 类 |
| 框架开发 / 库开发 | 类（用户需要可组合的抽象） |
| 数据 + 行为强绑定 | 类 |
| 纯数据传递 | dataclass |
Python 支持多范式：工具函数直接写函数，业务实体才建类，不要为了 OOP 而 OOP。
Rectangle 类：宽高属性、area/perimeter 方法、__eq__（面积相等即相等）BankAccount：__init__(owner, balance)、deposit、withdraw（余额不足抛自定义 InsufficientFundsError）、__str__Shape 基类 + Circle/Square 子类，各实现 area()，写函数打印一组图形的面积与总和（多态）Book 加 __iter__，使其能 for chapter in book 遍历章节名列表__init__ 构造、self 是实例自己_ 约定；property 让方法像属性（可校验可只读）super().__init__ 先父后子；重写实现多态；鸭子类型只看方法不看血统@dataclass下一篇：综合项目实战——从需求到成品的完整开发流程。
本系列为 Cyber先锋社原创教程。图书馆案例值得反复把玩——把它扩展成你的期末作品也毫不逊色。
十篇知识点集于一身：做一个完整可用的命令行待办事项管理器（Todo CLI）。你会经历真实项目的全流程——需求分析 → 架构设计 → 分模块实现 → 测试 → 打磨。做完这个项目，你就不是”学过 Python”，而是”用 Python 做过东西”。
先明确产品要做什么（真实项目第一步）：
1功能需求：21. 添加任务：标题 + 可选优先级（高/中/低）+ 可选截止日期32. 查看任务：全部 / 未完成 / 已完成 / 按优先级筛选43. 完成任务：按编号标记完成54. 删除任务65. 数据持久化：退出后数据还在（JSON 文件）76. 统计：总数、完成率、逾期数8
9非功能需求：10- 输入容错：非法输入不崩溃，给出友好提示11- 单文件可运行，也方便扩展成多模块数据结构先行——一个任务长什么样：
1{2 "id": 1, # 自增编号3 "title": "写Python作业", # 标题4 "priority": "high", # high / mid / low5 "due": "2026-11-05", # 截止日期（可空）6 "done": False, # 是否完成7 "created": "2026-10-29 12:00" # 创建时间8}模块划分：
1todo.py2├── 数据层：load / save（JSON 读写，第九篇）3├── 业务层：add / done / delete / list / stats（函数，第六篇）4├── 展示层：渲染表格、彩色输出5└── 交互层：main 循环解析命令（第八篇 sys.argv 思想 → 交互式菜单）分层原则：业务函数不 print 结果而是返回数据，展示层负责打印——这样以后加 Web 界面能直接复用业务层。
逐段实现（可直接拼成完整文件）：
1import json2import os3from datetime import datetime4
5DATA_FILE = "todos.json"6
7def load_todos():8 """读取数据文件；不存在或损坏时返回空列表（健壮性）"""9 if not os.path.exists(DATA_FILE):10 return []11 try:12 with open(DATA_FILE, encoding="utf-8") as f:13 return json.load(f)14 except (json.JSONDecodeError, OSError):15 print("⚠ 数据文件损坏，已重置")16 return []17
18def save_todos(todos):19 with open(DATA_FILE, "w", encoding="utf-8") as f:20 json.dump(todos, f, ensure_ascii=False, indent=2)1VALID_PRIORITIES = {"high": "🔴高", "mid": "🟡中", "low": "🟢低"}2
3def next_id(todos):4 return max((t["id"] for t in todos), default=0) + 15
6def add_todo(todos, title, priority="mid", due=None):7 """新增任务，返回新任务"""8 if priority not in VALID_PRIORITIES:9 raise ValueError(f"优先级必须是 {list(VALID_PRIORITIES)}")10 if due:11 try:12 datetime.strptime(due, "%Y-%m-%d") # 校验日期格式13 except ValueError:14 raise ValueError("日期格式应为 YYYY-MM-DD")15 todo = {16 "id": next_id(todos),17 "title": title.strip(),18 "priority": priority,19 "due": due,20 "done": False,21 "created": datetime.now().strftime("%Y-%m-%d %H:%M"),22 }23 todos.append(todo)24 save_todos(todos)25 return todo26
27def finish_todo(todos, todo_id):28 """标记完成，返回该任务；不存在抛 KeyError"""29 for t in todos:30 if t["id"] == todo_id:31 t["done"] = True32 save_todos(todos)33 return t34 raise KeyError(f"找不到编号 {todo_id} 的任务")35
36def delete_todo(todos, todo_id):37 for i, t in enumerate(todos):38 if t["id"] == todo_id:39 removed = todos.pop(i)40 save_todos(todos)41 return removed42 raise KeyError(f"找不到编号 {todo_id} 的任务")43
44def query(todos, status="all", priority=None):45 """筛选：status = all/todo/done；priority = high/mid/low"""46 result = todos47 if status == "todo":48 result = [t for t in result if not t["done"]]49 elif status == "done":50 result = [t for t in result if t["done"]]51 if priority:52 result = [t for t in result if t["priority"] == priority]53 return result54
55def is_overdue(todo):56 """已过期：未完成且截止日早于今天"""57 if todo["done"] or not todo["due"]:58 return False59 return todo["due"] < datetime.now().strftime("%Y-%m-%d")1def print_todos(todos, title="任务列表"):2 if not todos:3 print("（空空如也）")4 return5 print(f"\n== {title} ==")6 print(f"{'ID':<5}{'状态':<6}{'优先级':<8}{'截止':<12}标题")7 print("-" * 50)8 for t in todos:9 status = "✅" if t["done"] else ("⏳" if not is_overdue(t) else "❗逾期")10 due = t["due"] or "-"11 print(f"{t['id']:<5}{status:<6}{VALID_PRIORITIES[t['priority']]:<6}"12 f"{due:<12}{t['title']}")13
14def print_stats(todos):15 total = len(todos)16 done = sum(1 for t in todos if t["done"])17 overdue = sum(1 for t in todos if is_overdue(t))18 rate = done / total * 100 if total else 019 print(f"\n📊 统计：共 {total} 项｜完成 {done} 项"20 f"（{rate:.0f}%）｜逾期 {overdue} 项")1def main():2 todos = load_todos()3 print("=== 待办事项管理器 ===")4 print("命令：add 标题 [优先级] [日期] / list [all|todo|done] / "5 "done 编号 / del 编号 / stats / quit")6
7 while True:8 try:9 raw = input("\n> ").strip()10 if not raw:11 continue12 parts = raw.split(maxsplit=3) # 最多拆 4 段，标题保留空格13 cmd, args = parts[0].lower(), parts[1:]14
15 if cmd == "quit":16 print("再见！")17 break18
19 elif cmd == "add":20 title = args[0] if args else ""21 if not title:22 print("用法：add 标题 [high|mid|low] [YYYY-MM-DD]")23 continue24 priority = args[1] if len(args) > 1 and args[1] in VALID_PRIORITIES else "mid"25 due = args[2] if len(args) > 2 else None26 t = add_todo(todos, title, priority, due)27 print(f"✅ 已添加 #{t['id']} {t['title']}")28
29 elif cmd == "list":30 status = args[0] if args and args[0] in ("all", "todo", "done") else "todo"31 print_todos(query(todos, status=status), f"筛选:{status}")32
33 elif cmd == "done":34 finish_todo(todos, int(args[0]))35 print("🎉 已完成！")36
37 elif cmd == "del":38 delete_todo(todos, int(args[0]))39 print("🗑 已删除")40
41 elif cmd == "stats":42 print_stats(todos)43
44 else:45 print("未知命令，输入 quit 退出")46
47 except KeyError as e:48 print(f"操作失败：{e}")49 except ValueError as e:50 print(f"参数错误：{e}")51 except IndexError:52 print("缺少参数，请检查命令格式")53 except KeyboardInterrupt:54 print("\n再见！")55 break56
57if __name__ == "__main__": # 第八篇：可直接运行，也可被导入复用58 main()1=== 待办事项管理器 ===2> add 复习Python教程 high 2026-10-303✅ 已添加 #1 复习Python教程4> add 给社团投稿5✅ 已添加 #2 给社团投稿6> add 买咖啡 low7✅ 已添加 #3 买咖啡8
9> list all10== 筛选:all ==11ID 状态 优先级 截止 标题12--------------------------------------------------131 ⏳ 🔴高 2026-10-30 复习Python教程142 ⏳ 🟡中 - 给社团投稿153 ⏳ 🟢低 - 买咖啡16
17> done 318🎉 已完成！19> stats20📊 统计：共 3 项｜完成 1 项（33%）｜逾期 0 项21> quit重启程序，数据完好——todos.json 在工作目录里。
真实项目的验收环节，逐项跑一遍：
add 不带任何参数 → 提示用法，不崩溃add 测试 xyz（非法优先级）→ 自动降级为 mid，不崩溃add 测试 mid 2026-13-99 → 提示日期格式错误done 999 → 提示找不到，不崩溃全部通过，才算”完成”。这就是教程规则里”代码必须可运行”的含义。
这个骨架能长成什么：
storage.py / core.py / ui.py（第八篇的包结构）argparse 改造为 python todo.py add "标题" -p highdatetime 循环检测逾期任务并弹通知11 篇走过的路：
| 篇 | 主题 | 核心收获 |
|---|---|---|
| 1 | 环境与变量 | 安装、交互环境、四大类型 |
| 2 | 运算符与字符串 | 七类运算、切片、f-string |
| 3 | 条件与循环 | if/while/for、break/continue、推导式 |
| 4 | 列表与元组 | 增删改查、排序、深浅拷贝 |
| 5 | 字典与集合 | 键值映射、去重、集合运算 |
| 6 | 函数 | 参数全家族、作用域、lambda、闭包 |
| 7 | 迭代器与生成器 | 迭代协议、yield、省内存 |
| 8 | 模块与标准库 | 导入、虚拟环境、六大库 |
| 9 | 文件与异常 | with、精确捕获、自定义异常 |
| 10 | 面向对象 | 类、封装、继承多态、魔法方法 |
| 11 | 综合实战（本篇） | 分层架构、完整项目流程 |
下一步建议：C++ / Java 系列横向对照着学一遍（体会静态类型与编译）；或者直接挑一个小工具（自己用的）从零做出来——做东西是唯一的学习闭环。做出作品欢迎投稿到本站，或到留言板晒成果。
add 标题 #标签，list #作业 按标签筛argparse 命令行支持本系列为 Cyber先锋社原创教程，共 11 篇。完成毕业设计的同学，欢迎在留言板认领晒图名额！
CTF（Capture The Flag，夺旗赛） 是网络安全领域最流行的技术竞赛形式。参赛选手需要通过分析题目环境，找到隐藏在其中的特定格式的字符串（即 “Flag”），例如：
1flag{w3lc0me_t0_cyber_p10neer}CTF 不仅是一场比赛，更是检验和提升安全技能的最佳实践场。社团后续的训练营也将围绕 CTF 展开。
| 方向 | 主要内容 | 需要的基础 |
|---|---|---|
| Web | SQL 注入、XSS、SSRF、文件上传漏洞等 | HTTP 协议、Python、前后端基础 |
| Pwn | 栈溢出、堆漏洞、格式化字符串等二进制利用 | C 语言、汇编、Linux 系统 |
| Reverse | 逆向分析程序逻辑、破解算法 | C/C++、汇编、耐心 |
| Crypto | 古典密码、RSA、AES 等密码学攻击 | 数论、Python |
| Misc | 流量分析、隐写、取证等杂项 | 广泛的知识面 |
新手建议从 Web 或 Misc 入手，门槛相对友好；有 C 语言基础的同学可以直接挑战 Pwn 和 Reverse。
一台 Linux 虚拟机（推荐 Ubuntu 或 Kali）几乎是标配：
1# Ubuntu 下安装常用工具2sudo apt update3sudo apt install python3 python3-pip git curl burpsuite wireshark推荐从国内的新手友好平台开始：
每做完一道题，建议写一篇简短的 writeup，记录：
坚持复盘是快速成长的关键，优秀的 writeup 也可以投稿到本站，与大家分享。
社团 CTF 训练营每两周一次线下活动，形式包括：
具体时间安排请关注站内公告与社团群通知。
有问题随时在社团群里提问，期待在赛场上看到你的身影！
社团官网的核心需求很简单：展示文章、稳定、省资源、好维护。对比了几个方案：
| 方案 | 优点 | 缺点 |
|---|---|---|
| WordPress | 生态大、后台完善 | PHP + MySQL，资源占用高，需要持续打补丁 |
| Halo | 国产、界面现代 | 需要 Java 运行时，内存占用高 |
| Astro 静态站 | 零数据库、纯静态文件、速度快 | 更新内容需要重新构建 |
我们的服务器配置不高，静态方案几乎不占运行时资源，nginx 托管静态文件的内存开销可以忽略，安全性也远好于动态 CMS——最终选择 Astro + Firefly 主题。
1博客框架 Astro v7（静态站点生成）2主题 Firefly（基于 Fuwari 二次开发）3包管理器 pnpm4源码托管 GitHub - 1376524890/cyberpioneer_blog5Web 服务 nginx（托管静态文件）6部署方式 源码推 GitHub → 服务器拉取构建 → 同步上线1# 安装依赖（需要 Node.js >= 22.23）2corepack enable3pnpm install4
5# 本地预览 http://localhost:43216pnpm dev7
8# 构建静态站点到 dist/9pnpm build文章以 Markdown 格式存放在 src/content/posts/ 目录，只需复制一份模板修改 frontmatter：
1---2title: 文章标题3published: 2026-10-284description: 一句话摘要，会显示在列表页5tags: [标签1, 标签2]6category: 分类名7slug: url-friendly-slug8---9
10正文支持 Markdown……保存后推送到 GitHub，服务器端拉取重新构建即可上线。
静态博客的部署非常简单：任意一台 Linux 服务器 + nginx 托管 dist/ 目录即可。下面是一份通用的 nginx 站点配置示例（端口与路径按自己环境调整）：
1server {2 listen 80 default_server;3 listen [::]:80 default_server;4 server_name _;5
6 root /var/www/blog; # 指向构建产物目录7 index index.html;8
9 # Astro 默认带尾斜杠10 location / {11 try_files $uri $uri/ $uri/index.html =404;12 }13
14 # 静态资源长缓存15 location /_astro/ {16 expires 30d;17 add_header Cache-Control "public, immutable";18 }19
20 gzip on;21 gzip_types text/css application/javascript image/svg+xml application/json;22}我们的更新流程：源码推送到 GitHub 后，在服务器上拉取、构建，再把 dist/ 同步到站点目录，一条脚本搞定。出于安全考虑，服务器的具体信息不在此公开。
如果你也想给社团或自己搭一个博客，欢迎在群里交流，我们可以出一份保姆级教程。
假设一个校园活动报名系统，用下面这段 PHP 代码验证用户登录：
1<?php2// ⚠️ 危险代码，仅作教学演示3$username = $_POST['username'];4$password = $_POST['password'];5
6$sql = "SELECT * FROM users7 WHERE username='$username'8 AND password='$password'";9
10$result = $db->query($sql);11if ($result->num_rows > 0) {12 echo "登录成功";13}这段代码在功能上完全正常——正常用户输入正确的账号密码，就能登录成功。
但问题出在：用户输入被直接拼接进了 SQL 语句。
如果攻击者在密码框输入：
1' OR '1'='1那么最终执行的 SQL 变成了：
1SELECT * FROM users2WHERE username='admin'3AND password='' OR '1'='1'由于 '1'='1' 恒为真，这个查询条件永远成立，攻击者在不知道密码的情况下以 admin 身份登录——这就是一次最经典的 SQL 注入攻击。
本文所有内容仅用于教学演示。对未授权系统进行测试是违法行为，请在合法靶场环境中练习。
1admin' ORDER BY 3-- -逐步增大数字，根据页面报错判断查询结果的列数。
1' UNION SELECT username, password FROM users-- -通过 UNION 把数据库中的敏感数据直接拼进页面返回。
不同数据库的函数和报错信息各有特征：
| 数据库 | 探测语句 |
|---|---|
| MySQL | SELECT version() |
| PostgreSQL | SELECT version() |
| SQLite | SELECT sqlite_version() |
预编译让用户输入永远只作为”数据”而不是”代码”被处理：
1<?php2// ✅ 正确做法：参数化查询3$stmt = $db->prepare(4 "SELECT * FROM users WHERE username=? AND password=?"5);6$stmt->bind_param("ss", $username, $password);7$stmt->execute();Python (SQLAlchemy) 示例：
1from sqlalchemy import text2
3# ✅ 绑定参数，输入不会被当作 SQL 执行4db.execute(5 text("SELECT * FROM users WHERE username=:u AND password=:p"),6 {"u": username, "p": password},7)应用连接数据库的账号只授予必要权限，即使被注入也难以 DROP TABLE。
对输入做白名单校验、部署 WAF 可以增加攻击难度，但都不能替代参数化查询。
想亲手试试？推荐这些合法靶场：
社团活动室常年开放靶机环境，具体开放时间见群公告。
下一篇文章我们聊聊 XSS：当攻击者的脚本在你的浏览器里运行时会发生什么。