Cyber先锋社

Cyber先锋社官方博客正式上线！

Wed, 28 Oct 2026 00:00:00 GMT

🎉 博客上线了#

经过一段时间的筹备，Cyber先锋社（Cyber Pioneer Club） 的官方博客今天正式创建并与大家见面！

Cyber先锋社是一支专注于网络安全与信息技术的学生技术社团。此前我们的动态散落在群通知和公众号里，从今天起，这个博客将成为社团的官方阵地——社团动态、活动通知、技术文章都会第一时间在这里发布，欢迎收藏我们的地址。

🛡️ 在这里你能看到什么#

结合社团一直以来的活动方向，博客初期将围绕以下栏目更新：

社团动态：活动预告、赛事战报、纳新通知
技术分享：CTF 训练营复盘、Web/逆向/密码学方向的入门与进阶文章
活动记录：每周分享会与靶场演练的总结存档
开源项目：社团共创工具的开发日志

📣 想加入社团？#

如果你对网络安全、黑客技术充满好奇，想找到一群志同道合的技术伙伴——欢迎加入 Cyber先锋社！零基础也没关系，热情和坚持最重要。可以通过关于页面上的联系方式找到我们。

🚀 关于本站#

本站基于 Astro + Firefly 主题构建，源码托管在 GitHub，欢迎 Star 与共建。

这是本站的第一篇文章。博客刚起步，内容会逐步丰富，未来无限可能。

C++ 入门教程（一）：开发环境与第一个程序

Thu, 29 Oct 2026 00:00:00 GMT

为什么值得学 C++#

C++ 是一门”越学越值钱”的语言：操作系统、游戏引擎、数据库、高性能计算、嵌入式设备的底层几乎都由 C++ 驱动。它直接操作内存、贴近硬件，运行效率极高；同时现代 C++（11/17/20 标准）也提供了大量便利特性。

学 C++ 的过程能让你真正理解计算机是怎么工作的——这也是为什么很多高校把 C++ 作为第一门语言。相比 Python，它更严格，但也更锻炼基本功。

编译型语言 vs 解释型语言#

开始前先建立一个关键概念：

	Python	C++
执行方式	解释器逐行执行	先编译成机器码，再运行
源文件	`.py`	`.cpp` / `.cc`
类型检查	运行时	编译时（更严格）
运行速度	较慢	极快

写好的 C++ 代码不能直接运行，要经过 预处理 → 编译 → 汇编 → 链接 四步生成可执行文件。入门阶段不需要深究细节，只需知道：编辑器写代码，编译器造程序。

搭建开发环境#

Windows：安装 MinGW-w64（VS Code + g++）#

下载 MSYS2 并安装
在 MSYS2 终端执行：

Terminal window

1
pacman -S mingw-w64-ucrt-x86_64-gcc

把 C:\msys64\ucrt64\bin 加入系统 PATH
验证：

Terminal window

1
g++ --version

推荐搭配 VS Code + C/C++ 扩展使用。也可以直接安装 Visual Studio Community（一体化但体积大）。

macOS#

Terminal window

1
xcode-select --install   # 安装命令行工具（含 clang++）
2
clang++ --version

Linux（Ubuntu/Debian）#

Terminal window

1
sudo apt update && sudo apt install build-essential
2
g++ --version

第一个程序#

新建 hello.cpp：

1
#include <iostream>   // 引入输入输出库
2

3
int main() {          // main 函数：程序的入口
4
    std::cout << "Hello, Cyber先锋社!" << std::endl;
5
    return 0;         // 返回 0 表示程序正常结束
6
}

编译并运行：

Terminal window

1
g++ hello.cpp -o hello   # 编译，-o 指定输出文件名
2
./hello                   # 运行
3
Hello, Cyber先锋社!

逐行解读：

#include <iostream>：预处理指令，引入标准输入输出流库
int main()：每个 C++ 程序都从 main 函数开始执行，int 表示它返回一个整数
std::cout：标准输出流对象，<< 把内容”流向”屏幕
std::endl：换行符（并刷新缓冲区）
return 0：向操作系统报告程序成功执行

变量与数据类型#

C++ 是静态类型语言，变量必须先声明类型：

1
#include <iostream>
2
#include <string>
3

4
int 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`	动态	任意长度文本

Tip

用 sizeof(类型) 可以查看字节数，如 std::cout << sizeof(int)。理解内存大小是 C++ 的基本功。

输入与输出#

1
#include <iostream>
2
#include <string>
3

4
int 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 方向相反：>> 把输入”流入”变量。

用 using 简化书写#

每次写 std:: 很啰嗦，可以在文件开头声明：

1
#include <iostream>
2
using namespace std;    // 之后直接写 cout / cin / endl
3

4
int main() {
5
    cout << "简洁多了!" << endl;
6
    return 0;
7
}

Note

using namespace std 在大型工程中可能引发命名冲突，教学代码中用没问题，工程实践中建议保留 std:: 前缀或局部使用。

小练习#

编写程序输出你选的课表（每行一门课），体会 endl 与 \n 的用法
定义变量保存圆的半径，计算并输出周长与面积（3.14159 * r * r）
用 cin 读入两个整数，输出它们的和、差、积

本篇小结#

C++ 是编译型语言：g++ 源文件 -o 可执行文件 → ./可执行文件
程序入口是 main 函数，return 0 表示正常结束
变量必须声明类型，int / double / char / bool / std::string 是五大基础类型
std::cout << 输出、std::cin >> 输入，using namespace std 可简化书写

下一篇：分支与循环 + vector 容器入门——写出真正有逻辑的程序。

本系列为 Cyber先锋社原创教程，参考业界通用知识体系编写。

C++ 入门教程（二）：语法基础与运算符详解

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

上一篇搭好了环境、跑通了第一个程序。本篇把 C++ 的语法地基打牢：注释、变量细节、全部运算符与类型转换。C++ 是强类型语言，这些规则比 Python 严格得多，理解它们能少走很多弯路。

一、注释与代码风格#

1
// 单行注释：解释"为什么"而不是"是什么"
2

3
/*
4
   多行注释
5
   常用于文件头说明、暂时禁用大段代码
6
*/
7

8
/**
9
 * 文档注释（Doxygen 风格）
10
 * @brief 计算两数之和
11
 * @param a 加数
12
 * @param b 被加数
13
 * @return 和
14
 */
15
int add(int a, int b) {
16
    return a + b;
17
}

展开收起

二、变量进阶#

初始化的三种写法#

1
int a = 10;       // 传统 C 风格（拷贝初始化）
2
int b(20);        // 直接初始化
3
int c{30};        // 列表初始化（C++11，现代推荐）
4

5
// 列表初始化的杀手锏：禁止窄化转换（丢失精度直接报错）
6
int x{3.14};      // ❌ 编译错误！double → int 会丢失
7
int y = 3.14;     // ⚠ 编译器仅警告，y = 3（静默截断）

未初始化变量的危险#

1
int n;            // ⚠ 值是随机的（栈上残留数据）！
2
std::cout << n;   // 可能输出任何数
3

4
int m{};          // ✅ 值初始化为 0

军规：定义变量时永远给初值，尤其是之后要累加的计数器。

常量#

1
const double PI = 3.14159;        // 运行时常量：定义后不可修改
2
PI = 3.14;                        // ❌ 编译错误
3

4
// 编译期常量（C++11）：值必须在编译期可计算，性能更好
5
constexpr int MAX_SIZE = 100;
6
constexpr double AREA = PI * 2;   // ✓ 由编译期常量组合而来
7

8
int arr[MAX_SIZE];                // 数组大小需要编译期常量 ✓

类型别名#

1
typedef unsigned long ulong_t;        // 传统写法
2
using score_t = double;               // C++11 别名声明（推荐，更清晰）
3

4
score_t math = 95.5;
5
ulong_t big = 100000UL;

auto 类型推断（C++11）#

1
auto i = 42;              // int
2
auto d = 3.14;            // double
3
auto s = std::string("hi");   // std::string
4
auto v = std::vector<int>{1, 2, 3};   // 配合 STL 极大减少书写
5

6
// auto 用于复杂类型（迭代器）是真香现场：
7
std::vector<int> nums{1, 2, 3};
8
std::vector<int>::iterator it1 = nums.begin();   // 啰嗦
9
auto it2 = nums.begin();                          // 优雅

Note

auto 是”让编译器推断类型”，不是”动态类型”——推断完成后类型就固定了，且 auto 变量必须有初始化。

三、运算符全解#

1. 算术运算符#

1
#include <iostream>
2
int main() {
3
    int a = 10, b = 3;
4

5
    std::cout << a + b << "\n";    // 13
6
    std::cout << a - b << "\n";    // 7
7
    std::cout << a * b << "\n";    // 30
8
    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";        // 3
14
    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
}

展开收起

整数溢出（了解但重要）：

1
int big = 2147483647;    // int 最大值
2
big = big + 1;           // 溢出！值回绕成 -2147483648（未定义行为的常见形式）
3
// 大数运算用 long long，检测用 <limits>
4
#include <limits>
5
std::cout << std::numeric_limits<int>::max() << "\n";

2. 关系与逻辑运算符#

1
int a = 5, b = 10;
2

3
std::cout << (a > b) << "\n";       // 0    ⚠ 布尔值输出是 1/0
4
std::cout << (a == b) << "\n";      // 0
5
std::cout << std::boolalpha;        // 切换为 true/false 输出
6
std::cout << (a < b) << "\n";       // true
7

8
// 逻辑：&& 且  || 或  ! 非
9
int age = 20;
10
bool has_id = true;
11
std::cout << (age >= 18 && has_id) << "\n";    // true
12
std::cout << !has_id << "\n";                  // false

Warning

C++ 的布尔本质是 int（0 为假，非 0 为真）。经典错误：if (x = 5) 把比较写成赋值——条件永远为真，部分编译器加 -Wall 才会警告。

短路求值与 Python 一致：&& 左假右不算，|| 左真右不算。

3. 位运算符#

1
unsigned a = 0b1010;    // 10（C++14 二进制字面量）
2

3
std::cout << (a & 0b0110) << "\n";   // 2   按位与
4
std::cout << (a | 0b0101) << "\n";   // 15  按位或
5
std::cout << (a ^ 0b1111) << "\n";   // 5   异或
6
std::cout << (~a) << "\n";           // 按位取反（含符号位）
7
std::cout << (a << 2) << "\n";       // 40  左移 = ×4
8
std::cout << (a >> 1) << "\n";       // 5   右移 = ÷2
9

10
// 实用技：
11
bool is_odd = a & 1;             // 判奇偶
12
int half = a >> 1;               // 快速除2（现代编译器会自动优化，写 / 2 更清晰）

4. 赋值与逗号#

1
int x = 10;
2
x += 5;      // 15
3
x -= 3;      // 12
4
x *= 2;      // 24
5
x /= 5;      // 4
6
x %= 3;      // 1
7
x <<= 2;     // 4（位运算也有复合赋值）
8

9
int a, b, c;
10
a = (b = 1, c = 2, b + c);   // 逗号表达式：依次求值取最后结果，a = 3（少用，可读性差）

5. 三元与 sizeof#

1
int age = 20;
2
std::string s = (age >= 18) ? "成年" : "未成年";
3

4
std::cout << sizeof(int) << "\n";            // 4 字节
5
std::cout << sizeof(double) << "\n";         // 8
6
std::cout << sizeof("hello") << "\n";        // 6（含 '\0'）
7
int arr[]{1, 2, 3};
8
std::cout << sizeof(arr) / sizeof(arr[0]);   // 3 —— C 风格数组求长度

四、类型转换#

隐式转换（自动发生，注意方向）#

1
int i = 42;
2
double d = i;          // ✓ int → double（安全提升）
3
int j = 3.99;          // ⚠ double → int（窄化，j = 3）
4

5
char c = 'A';
6
std::cout << c + 1 << "\n";    // 66（char 提升为 int 参与运算）
7
std::cout << char(c + 1);      // 'B'

显式转换四种cast（重点）#

1
double pi = 3.14;
2

3
// C 风格（能用但不推荐——一刀切，语义不明）
4
int a = (int)pi;
5
int b = int(pi);
6

7
// C++ 四种具名 cast：
8
int c1 = static_cast<int>(pi);            // ① static_cast：常规数值转换（90%场景用它）
9
// ② dynamic_cast：继承体系安全向下转型（第十篇）
10
// ③ const_cast：去除 const（几乎不用）
11
// ④ reinterpret_cast：位模式重解释（底层操作，慎用）

现代 C++ 建议：数值转换统一 static_cast<T>(x)，一眼看懂意图、便于搜索。

字符串与数值互转（C++11）#

1
#include <string>
2

3
int n = std::stoi("42");            // string → int
4
double d = std::stod("3.14");       // string → double
5
long l = std::stol("100000");
6

7
std::string s1 = std::to_string(42);        // int → string
8
std::string s2 = std::to_string(3.14);      // "3.140000"

五、cin 的状态与错误输入#

1
#include <iostream>
2
#include <limits>
3

4
int 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++ 命令行程序的标准配件，值得整段背下来。

小练习#

计算 BMI：输入身高(m)体重(kg)，输出 体重/身高²，保留 1 位小数（std::fixed + std::setprecision(1)，需 <iomanip>）
用位运算实现：交换两个 int 变量（不用第三个变量；提示 ^）
7/2*2 等于几？7.0/2*2 呢？先笔算再上机验证
输入秒数，换算为”X小时Y分Z秒”输出（用到 / 和 %）

本篇小结#

三种初始化，{} 值初始化最安全（禁窄化）；变量定义必给初值
const 运行期常量、constexpr 编译期常量；using 别名优于 typedef
auto 让编译器推断类型，配 STL 神器
整数除法截断、i++ vs ++i、= 与 == 是三大新手坑
显式转换用 static_cast；字符串数值互转用 stoi/to_string
cin 错误状态要 clear + ignore 才能恢复

下一篇：流程控制——分支、循环与 C++ 特有的范围 for。

本系列为 Cyber先锋社原创教程。整数除法与类型转换请亲手验证每个示例。

C++ 入门教程（三）：流程控制

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

程序的三种结构：顺序、分支、循环。本篇讲全 C++ 的流程控制语法，与 Python 对比着学效率最高——逻辑相同，只是换了”语法外壳”。

一、分支结构#

if / else if / else#

1
#include <iostream>
2
int 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：多值分发#

当条件是”一个变量等于哪些值”时，switch 比 if 链清晰：

1
#include <iostream>
2
int 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，除非刻意利用贯穿。

Warning

忘 break 是 switch 第一大坑：

1
int x = 1;
2
switch (x) {
3
    case 1: std::cout << "一";    // 输出"一二"——贯穿了！
4
    case 2: std::cout << "二"; break;
5
}

三元运算符#

1
int a = 10, b = 20;
2
int max_val = (a > b) ? a : b;

二、循环结构#

while：条件前置#

1
#include <iostream>
2
int 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
}

do-while：先斩后奏（C++ 特有常见）#

1
int choice;
2
do {
3
    std::cout << "1.开始 2.设置 0.退出\n请选择: ";
4
    std::cin >> choice;
5
    // 处理 choice...
6
} while (choice != 0);      // 注意末尾分号
7

8
// 至少执行一次——天然适合"菜单系统"

for：计数循环#

1
// 打印 1~10 的平方
2
for (int i = 1; i <= 10; ++i) {
3
    std::cout << i << "²= " << i * i << "\n";
4
}
5

6
// 死循环的两种写法
7
for (;;) { /* ... */ }
8
while (true) { /* ... */ }
9

10
// for 的三个部分都可空：分号不能省
11
int i = 0;
12
for (; i < 5;) {
13
    std::cout << i << " ";
14
    ++i;
15
}

展开收起

范围 for + auto（C++11，遍历首选）#

1
#include <iostream>
2
#include <vector>
3
#include <string>
4

5
int main() {
6
    int arr[]{10, 20, 30, 40};
7
    for (int x : arr)                    // 遍历数组
8
        std::cout << x << " ";           // 10 20 30 40
9
    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)`	只读引用，零拷贝	大对象只读（默认选它）

三、break / continue#

1
// break：终止所在层循环
2
for (int i = 1; i <= 100; ++i) {
3
    if (i * i > 500) {
4
        std::cout << "第一个平方超500的是 " << i << "\n";
5
        break;
6
    }
7
}
8

9
// continue：跳过本次
10
for (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”，等价逻辑用一个标志变量实现。

四、嵌套循环与经典练习#

1. 九九乘法表#

1
for (int i = 1; i <= 9; ++i) {
2
    for (int j = 1; j <= i; ++j) {
3
        printf("%d×%d=%-4d", j, i, i * j);   // %-4d 左对齐宽4
4
    }
5
    std::cout << "\n";
6
}

2. 判断质数（带输入校验）#

1
#include <iostream>
2
#include <cmath>
3

4
bool 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

12
int main() {
13
    int n;
14
    std::cin >> n;
15
    std::cout << n << (is_prime(n) ? " 是" : " 不是") << "质数\n";
16
}

展开收起

3. 打印图形（嵌套循环的空间感）#

1
// 金字塔（5行）
2
int rows = 5;
3
for (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
// *********

4. 猜数字（do-while 的主场）#

1
#include <iostream>
2
#include <cstdlib>      // rand/srand
3
#include <ctime>
4

5
int main() {
6
    std::srand(std::time(nullptr));        // 播种子
7
    int answer = std::rand() % 100 + 1;    // 1~100
8
    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
}

展开收起

5. FizzBuzz（面试名题）#

1
for (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
}

五、goto：知道但别用#

1
    // C++ 保留了 goto，但现代编码规范一律禁用——破坏结构化、难以追踪
2
    goto end;
3
    std::cout << "这行被跳过";
4
end:
5
    return 0;

唯一”合理”场景是多层嵌套循环的一次性跳出，但那也该用函数 + return 重构。

小练习#

输入一个整数，逆序输出各位数字（1234 → 4321；while + % /）
求两个数的最大公约数（辗转相除：while ((b %= a %= b) …) 或标准三行版）
打印 100~999 的所有水仙花数（各位立方和等于自身）
用范围 for 统计 std::vector<int>{3,7,1,9,4} 的最大值、最小值与平均值
双重循环找”百钱买百鸡”：公鸡5元/只、母鸡3元/只、小鸡1元3只，100元买100只，输出所有方案

本篇小结#

if 条件必带括号；switch 只认整型/枚举、必带 break 与 default
while 先判后做、do-while 先做后判（菜单场景）、for 三段式
范围 for + const auto& 是遍历容器的默认姿势
break 跳出本层、continue 跳过本次；没有循环 else
goto 是历史遗迹，现代 C++ 禁用

下一篇：函数——定义、声明、重载与默认参数，C++ 的函数比 Python 讲究得多。

本系列为 Cyber先锋社原创教程。五个经典练习建议全部独立敲一遍，比看十遍教程有效。

C++ 入门教程（四）：函数详解

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

C++ 的函数体系比 Python 严格也强大：函数必须先声明后使用、参数传递方式直接决定性能与语义、还有重载与默认参数两大利器。本篇一次讲透，这是 C++ 分水岭之一。

一、定义、声明与头文件#

为什么需要”先声明”#

编译器从上往下读文件，调用函数前必须”见过”它。大项目里函数分散在多文件，靠**声明（原型）**解决：

1
// 函数声明（原型）：告诉编译器"有这个函数，长这样"
2
double calc_bmi(double weight, double height);
3

4
int main() {
5
    std::cout << calc_bmi(70, 1.75);    // ✓ 编译器已认识它
6
    return 0;
7
}
8

9
// 函数定义：真正实现
10
double calc_bmi(double weight, double height) {
11
    return weight / (height * height);
12
}

声明与定义的区别：声明是”预告”（无函数体），定义是”实现”。声明可多次，定义只能一次。

多文件组织（.h / .cpp）#

1
// ===== math_utils.h（头文件：放声明）=====
2
#ifndef MATH_UTILS_H          // 包含保护：防止重复包含
3
#define MATH_UTILS_H
4

5
double calc_bmi(double weight, double height);
6
bool   is_prime(int n);
7

8
#endif

1
// ===== math_utils.cpp（源文件：放定义）=====
2
#include "math_utils.h"       // 自己的头文件用 ""
3

4
double calc_bmi(double weight, double height) {
5
    return weight / (height * height);
6
}
7

8
bool 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

5
int main() {
6
    std::cout << calc_bmi(70, 1.75) << "\n";
7
}

编译：g++ main.cpp math_utils.cpp -o app（所有 cpp 都要参与编译）。

二、参数传递：C++ 的灵魂#

1. 值传递（默认）：拷贝一份#

1
void try_change(int x) {      // x 是实参的副本
2
    x = 100;
3
}
4

5
int main() {
6
    int n = 5;
7
    try_change(n);
8
    std::cout << n;           // 5 —— 原值不变
9
}

2. 引用传递（&）：起别名，可修改原值#

1
void actually_change(int& x) {    // x 是 n 的别名
2
    x = 100;
3
}
4

5
int main() {
6
    int n = 5;
7
    actually_change(n);
8
    std::cout << n;           // 100 ✓ 改的是原值
9
}

引用的经典用途 1：多返回值（出参）

1
// 同时返回商和余数
2
void divmod(int a, int b, int& quotient, int& remainder) {
3
    quotient = a / b;
4
    remainder = a % b;
5
}
6

7
int main() {
8
    int q, r;
9
    divmod(17, 5, q, r);
10
    std::cout << q << " 余 " << r;    // 3 余 2
11
}

3. const 引用传递：大对象只读零拷贝#

1
#include <string>
2

3
// 值传递会拷贝整个字符串（浪费）；const& 既不拷贝又不可改
4
void 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 风格接口

默认参数#

1
double power(double base, int exp = 2);     // 声明处给默认值
2

3
int main() {
4
    std::cout << power(3) << "\n";          // 9（用默认 exp=2）
5
    std::cout << power(3, 3) << "\n";       // 27
6
}
7

8
double 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) ❌。声明与定义分离时，默认值只能写在声明里。

三、函数重载（Overload）#

同名函数、参数不同（个数或类型），编译器按实参自动匹配：

1
#include <iostream>
2
#include <string>
3

4
int    max_of(int a, int b)             { return a > b ? a : b; }
5
double max_of(double a, double b)       { return a > b ? a : b; }
6
int    max_of(int a, int b, int c)      { return max_of(max_of(a, b), c); }
7
std::string max_of(const std::string& a, const std::string& b) { return a > b ? a : b; }
8

9
int main() {
10
    std::cout << max_of(3, 7) << "\n";            // int 版 → 7
11
    std::cout << max_of(3.14, 2.71) << "\n";      // double 版 → 3.14
12
    std::cout << max_of(1, 9, 4) << "\n";         // 三参版 → 9
13
    std::cout << max_of("apple", "banana") << "\n"; // string 版 → banana
14
}

Warning

重载只看参数，不看返回值——int f() 与 double f() 不构成重载，直接编译错误。 Python 没有重载（用默认参数模拟），这是 C++ 的”编译期多态”。

四、递归#

1
#include <iostream>
2

3
unsigned long long factorial(int n) {
4
    if (n <= 1) return 1;                       // 基线
5
    return n * factorial(n - 1);                // 递推
6
}
7

8
// 输出斐波那契第 n 项（递归版——直观但慢）
9
long long fib(int n) {
10
    if (n < 2) return n;
11
    return fib(n - 1) + fib(n - 2);
12
}
13

14
int 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

3
int g = 100;                    // 全局变量（尽量少用）
4

5
void demo() {
6
    int local = 1;              // 局部：函数结束销毁
7
    static int count = 0;       // 静态局部：只初始化一次，函数间保留
8
    ++count;
9
    std::cout << "local=" << local++ << " count=" << count << "\n";
10
}
11

12
int main() {
13
    demo();    // local=1 count=1
14
    demo();    // local=1 count=2（local 每次重建，count 保留！）
15
    {
16
        int block_var = 42;     // 块作用域
17
    }
18
    // std::cout << block_var;  // ❌ 出块即亡
19
}

展开收起

static 局部变量 = “只属于这个函数的全局变量”，常用于调用计数、缓存。

六、内联函数与 constexpr 函数#

1
// inline：建议编译器把函数体直接展开到调用处（省调用开销）
2
// 现代编译器很聪明，inline 更多语义是"允许多文件安全定义"
3
inline int square(int x) { return x * x; }
4

5
// constexpr 函数（C++11/14）：可在编译期求值
6
constexpr int cube(int x) { return x * x * x; }
7

8
int arr[cube(3)];          // ✓ 27 作为编译期数组大小
9
constexpr int c = cube(4); // 编译期计算出 64

七、实战：个税与工资计算器#

综合本篇知识（声明分离、引用出参、重载、默认参数）：

1
#include <iostream>
2
#include <iomanip>
3

4
// ===== salary.h 的声明部分（这里合并演示）=====
5
double calc_tax(double taxable);                       // 按超额累进
6
void   split_salary(double gross, double& net, double& tax);   // 出参
7

8
// ===== 实现 =====
9
double 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

17
void split_salary(double gross, double& net, double& tax) {
18
    tax = calc_tax(gross - 5000.0);      // 免征额 5000
19
    net = gross - tax;
20
}
21

22
int 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税额: " << tax
33
                  << "\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 1
把本篇工资计算器拆成 salary.h / salary.cpp / main.cpp 三文件编译通过

本篇小结#

声明与定义分离；头文件放声明（含包含保护），源文件放实现
值传递拷贝、T& 可修改实参、const T& 大对象只读零拷贝
默认参数靠右、写在声明处；重载按参数区分、与返回值无关
static 局部变量跨调用保留；递归必须有基线
inline/constexpr 提示编译期优化

下一篇：数组与 std::string/vector 三剑客——C++ 数据容器的正确打开方式。

本系列为 Cyber先锋社原创教程。“声明放头文件”是多文件编程的第一课，练习 5 必做。

C++ 入门教程（五）：数组与字符串

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

存”一堆数据”的三个层次：C 数组（原始、固定大小）、std::vector（动态数组，现代首选）、std::string（字符串专用容器）。重点放在后两者——现代 C++ 的原则是”能用 vector 不用数组，能用 string 不用 char*”。

一、C 风格数组#

一维数组#

1
#include <iostream>
2

3
int main() {
4
    int scores[5] = {90, 85, 78, 92, 66};   // 定义即初始化
5
    int zeros[10] = {};                      // 全部初始化为 0
6
    int partial[5] = {1, 2};                 // {1,2,0,0,0} 其余补 0
7

8
    // 访问与修改（下标从 0 开始）
9
    scores[0] = 95;
10
    std::cout << scores[4] << "\n";          // 66
11

12
    // 数组大小（仅对"本作用域数组"有效）
13
    int n = sizeof(scores) / sizeof(scores[0]);   // 5
14

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++（部分编译器扩展支持）
不记录长度：传给函数后退化成”裸指针”，sizeof 失效

1
void print_arr(int arr[], int size) {        // 数组参数必须附带长度
2
    // sizeof(arr) 在这里是指针大小（8），不是数组大小！
3
    for (int i = 0; i < size; ++i)
4
        std::cout << arr[i] << " ";
5
}

Warning

数组不检查越界：scores[100] 编译运行都不报错，直接读写非法内存——未定义行为，可能是乱码、崩溃或安全漏洞。这是 C/C++ 缓冲区溢出漏洞的根源。

二维数组#

1
int matrix[3][4] = {
2
    {1,  2,  3,  4},
3
    {5,  6,  7,  8},
4
    {9, 10, 11, 12},
5
};
6

7
int rows = 3, cols = 4;
8
for (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
// 打擂台找最大值及其位置
15
int max_v = matrix[0][0], mi = 0, mj = 0;
16
for (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
        }
21
std::cout << "最大 " << max_v << " 在 (" << mi << "," << mj << ")\n";

展开收起

二、std::vector：动态数组（现代首选）#

构造与基本操作#

1
#include <vector>
2
#include <iostream>
3

4
int 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 4
17
    return 0;
18
}

展开收起

增删#

1
std::vector<int> v = {2, 3};
2

3
v.push_back(4);               // 尾部追加：{2,3,4}   —— 最高频操作
4
v.insert(v.begin(), 1);       // 头部插入：{1,2,3,4}
5
v.insert(v.begin() + 2, 99);  // 指定位置：{1,2,99,3,4}
6

7
v.pop_back();                 // 删除尾部：{1,2,99,3}
8
v.erase(v.begin() + 2);       // 删除指定位置：{1,2,3}
9
v.erase(v.begin(), v.begin() + 2);   // 删除区间：{3}
10

11
v.clear();                    // 清空：{}

性能提示：push_back 尾部均摊 O(1)；insert/erase 中间是 O(n)——频繁中间插删的场景后续用 list（进阶）。

遍历与修改#

1
std::vector<int> v = {5, 3, 8, 1, 9};
2

3
// ① 下标循环（需要下标时）
4
for (std::size_t i = 0; i < v.size(); ++i)   // size() 返回无符号 size_t
5
    std::cout << v[i] << " ";
6

7
// ② 范围 for 只读
8
for (const auto& x : v) std::cout << x << " ";
9

10
// ③ 范围 for 修改
11
for (auto& x : v) x *= 2;             // 全部翻倍
12

13
// 已知量小或有符号运算时，int i 配 static_cast：
14
for (int i = 0; i < static_cast<int>(v.size()); ++i) { /* ... */ }

动态增长的实力#

1
std::vector<int> v;
2
for (int i = 1; i <= 100; ++i)
3
    v.push_back(i * i);        // 数组做不到的"边跑边长"
4
std::cout << v.size();         // 100

排序与查找#

1
#include <algorithm>
2

3
std::vector<int> v = {5, 3, 8, 1, 9};
4

5
std::sort(v.begin(), v.end());              // 升序 {1,3,5,8,9}
6
std::sort(v.begin(), v.end(), std::greater<int>());   // 降序
7

8
auto it = std::find(v.begin(), v.end(), 8); // 查找，返回迭代器
9
if (it != v.end())
10
    std::cout << "找到，下标 " << (it - v.begin()) << "\n";
11

12
// 排序复杂数据（lambda 第四篇提过，第十篇详讲）
13
std::vector<std::pair<std::string, int>> st{{"小明",90},{"小红",92}};
14
std::sort(st.begin(), st.end(),
15
          [](const auto& a, const auto& b) { return a.second > b.second; });

展开收起

三、std::string 详解#

构造与拼接#

1
#include <string>
2

3
std::string s1 = "hello";
4
std::string s2("world");
5
std::string s3(5, 'a');            // "aaaaa" 重复字符
6
std::string s4 = s1 + " " + s2;    // "hello world"（+ 随便拼）
7
s4 += "!";                          // 追加
8

9
// 数值拼接需先转换（第二篇）：
10
int age = 18;
11
std::string info = "年龄: " + std::to_string(age);

索引与常用方法#

1
std::string s = "CyberPioneer";
2

3
std::cout << s.size() << "\n";         // 12（size 与 length 等价）
4
std::cout << s[0] << s.back() << "\n"; // Cr
5
s[0] = 'c';                            // ✓ 可修改（不同于 Python！）
6

7
// 子串：substr(起点, 长度)
8
std::cout << s.substr(0, 5) << "\n";   // cyber
9
std::cout << s.substr(5) << "\n";      // Pioneer（到结尾）
10

11
// 查找：find 找不到返回 string::npos
12
if (s.find("Pioneer") != std::string::npos)
13
    std::cout << "包含 Pioneer，位置 " << s.find("Pioneer") << "\n";
14

15
// 修改
16
std::string t = "  hi  ";
17
std::cout << "|" << t.substr(1, 2) << "|\n";   // 手动去空格（无现成 strip）
18

19
std::string u = "a,b,c";
20
// 按","分割（STL 惯用法，sstream 第十一篇还会见）
21
#include <sstream>
22
std::vector<std::string> parts;
23
std::stringstream ss(u);
24
std::string item;
25
while (std::getline(ss, item, ','))
26
    parts.push_back(item);          // {"a","b","c"}

展开收起

比较#

1
std::string a = "apple", b = "banana";
2
if (a == b) std::cout << "相等";
3
if (a < b)  std::cout << "a 在前";   // 字典序，直接用比较运算符
4
int r = a.compare(b);                 // <0 / 0 / >0，与 strcmp 类似

C 字符串互转#

1
std::string cpp_s = "hello";
2
const char* c_s = cpp_s.c_str();     // string → C 串（用于旧接口/printf）
3

4
std::string back = c_s;              // C 串 → string 直接构造

四、数组 vs vector 选型#

维度	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

7
int 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].first
37
                  << " " << students[i].second << "\n";
38
}

展开收起

小练习#

不用 sort：手写选择排序把 {5,2,8,1} 升序（双重循环打擂台）
vector 去重：先排序，再 std::unique + erase 三连（查文档实现）
统计一句话中每个单词长度："the quick brown fox" → 3 5 5 3（stringstream 分割）
判断回文字符串（string 下标首尾双指针）
二维 vector 乘法表：std::vector<std::vector<int>>(9, std::vector<int>(9)) 填充并打印

本篇小结#

数组大小固定、不查越界、传参退化——现代 C++ 默认 vector
vector：push_back 尾增 O(1)、at() 安全访问、insert/erase 中间 O(n)
排序查找认准 <algorithm> 的 sort/find
string 可下标修改、substr 切子串、find 配 string::npos 判断
分割字符串用 stringstream + getline；C 互转靠 c_str()

下一篇：指针与引用——C++ 的深水区，也是它强大的根源。

本系列为 Cyber先锋社原创教程。vector 的每个方法都敲一遍，后面 STL 篇会轻松很多。

C++ 入门教程（六）：指针与引用

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

指针是 C++ 的分水岭：理解了它，才算真正理解”程序如何在内存中运行”。本篇从内存模型讲起，覆盖裸指针、动态内存、引用对比与智能指针入门。请逐个示例亲手运行——这一篇没有捷径。

一、内存模型：变量住在哪里#

1
int age = 18;

这行代码发生的事：程序在栈内存里划出 4 字节，存入 18，并把这块空间标记为 age。

每块内存都有编号——地址（一串十六进制数）。& 取地址运算符可以拿到它：

1
#include <iostream>
2
int main() {
3
    int age = 18;
4
    std::cout << &age << "\n";      // 0x7ffee4c0a8bc（每次运行可能不同）
5
    std::cout << sizeof(age);       // 4 字节
6
}

类比：内存是一整条街的房间，变量是房间里的住户，地址是门牌号。

二、指针：存地址的变量#

定义与解引用#

1
int age = 18;
2
int* p = &age;          // p 是指针，存的是 age 的地址
3

4
std::cout << p << "\n";     // 地址：0x7ffee4c0a8bc
5
std::cout << *p << "\n";    // 18：* 解引用——顺着地址找到值
6
std::cout << &p << "\n";    // p 自己的地址（指针也是变量）
7

8
*p = 20;                    // 通过地址改写 age！
9
std::cout << age << "\n";   // 20

两个符号记牢：

&x：取 x 的地址
*p：顺 p 存的地址取值（或写入）

1
int* p1, p2;        // ⚠ 坑：p1 是指针，p2 是 int！
2
int *p3, *p4;       // 两个都是指针

空指针与安全#

1
int* p = nullptr;       // C++11 空指针（替代 NULL 与 0）
2

3
if (p != nullptr) {
4
    std::cout << *p;    // 用前判空
5
}
6
// *p;                  // ❌ 解引用空指针 = 段错误（Segfault），程序崩溃

Warning

永远不要解引用空指针或未初始化的指针（野指针）。现代写法：定义指针就初始化（给值或给 nullptr）。

指针作为函数参数#

C 风格的”修改实参”方式（C++ 更推荐引用，但必须会读）：

1
void swap(int* a, int* b) {      // 接收地址
2
    int t = *a;                  // 通过地址取值
3
    *a = *b;                     // 通过地址写值
4
    *b = t;
5
}
6

7
int main() {
8
    int x = 1, y = 2;
9
    swap(&x, &y);                // 传地址
10
    std::cout << x << "," << y;  // 2,1
11
}

指针与数组#

数组名本质是”首元素地址”：

1
int arr[] = {10, 20, 30, 40};
2
int* p = arr;                    // 等价于 &arr[0]
3

4
std::cout << *p << "\n";         // 10
5
std::cout << *(p + 1) << "\n";   // 20：指针算术，+1 移动一个 int
6
std::cout << p[2] << "\n";       // 30：指针也能用下标（等价 *(p+2)）
7

8
// 遍历
9
for (int* q = arr; q != arr + 4; ++q)
10
    std::cout << *q << " ";

指针算术：p + 1 移动的字节数 = 指向类型的大小（int* 移 4 字节，double* 移 8 字节）。

三、动态内存：new / delete#

栈上的变量函数结束自动销毁；堆内存由你手动管理——能跨函数存活、大小运行期决定。

1
// 单个变量
2
int* p = new int(42);            // 堆上开 4 字节，初始化 42
3
std::cout << *p << "\n";
4
delete p;                        // 手动释放！
5
p = nullptr;                     // 置空好习惯
6

7
// 动态数组（大小可以是变量！）
8
int n;
9
std::cin >> n;
10
int* arr = new int[n]{};         // n 个 int 全 0
11
for (int i = 0; i < n; ++i) arr[i] = i * i;
12
delete[] arr;                    // 数组用 delete[]

两条铁律：

每个 new 必须对应一个 delete（数组 delete[]）
delete 后指针置 nullptr，防止”悬空指针”再次使用

内存泄漏：忘记 delete#

1
void leak() {
2
    int* p = new int(100);
3
    // 函数结束，p 这个"门牌号"没了，但堆上 4 字节还占着——永远无法释放
4
}   // 💥 内存泄漏
5

6
void worse() {
7
    int* p = new int(1);
8
    p = new int(2);              // 第一个内存块地址丢失，泄漏！
9
    delete p;
10
}

长期运行的服务（服务器程序）泄漏累积会耗尽内存——这是裸 new/delete 逐渐被弃用的原因。

四、引用 vs 指针#

维度	引用 `int& r = x`	指针 `int* p = &x`
本质	变量的别名	存地址的变量
初始化	必须初始化，不可换绑	可空、可改指向
空值	不存在	nullptr
用法	直接当原变量用	需 `*` 解引用
安全性	高	低（野指针/泄漏）

1
int x = 10;
2

3
int& r = x;          // r 就是 x 的第二个名字
4
r = 99;              // x 变 99
5
// int& bad;         // ❌ 引用必须初始化
6

7
int* p = &x;         // p 指向 x
8
p = nullptr;         // ✓ 指针可以为空
9
int y = 5;
10
p = &y;              // ✓ 指针可换指向

选择：能用引用就用引用（安全简洁）；需要”可能为空”或”改指向”才用指针。

五、智能指针（现代 C++ 的答案）#

C++11 用智能指针把 new/delete 交给对象自动管理——RAII：资源获取即初始化，析构自动释放。

unique_ptr：独占所有权#

1
#include <memory>
2
#include <iostream>
3

4
int 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，无需也无法手动 delete
10

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 析构 → 自动释放内存

展开收起

shared_ptr：共享所有权（计数引用）#

1
#include <memory>
2

3
auto a = std::make_shared<int>(100);   // 引用计数 = 1
4
{
5
    auto b = a;                        // 计数 = 2，可以拷贝
6
    std::cout << *b << "\n";
7
}                                      // b 销毁，计数 = 1
8
std::cout << a.use_count() << "\n";    // 1
9
// a 销毁时计数归零 → 内存自动释放

选型：默认 unique_ptr；确实多方持有才 shared_ptr。

六、实战：链表节点（指针的第一次真实应用）#

1
#include <iostream>
2

3
struct Node {              // 结构体第八篇详讲，先看用法
4
    int data;
5
    Node* next;            // 指向下一个节点——链表的骨架
6
};
7

8
int 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) 返回最大元素的地址（不是值）
用 new 申请一个 double 数组存 10 个成绩，输出平均分后正确 delete
验证”值传递不改原值、指针与引用传递改原值”：同一功能写三个版本对比
用 unique_ptr 管理一个动态 int 数组（std::unique_ptr<int[]> arr{new int[5]{}}），体会自动释放
（概念题）int* p = new int(5); delete p; std::cout << *p; 会发生什么？（悬空指针，未定义行为——说说为什么不能这么写）

本篇小结#

& 取地址、*p 解引用；指针存地址，是”携带门牌号的变量”
数组名≈首元素地址，指针算术按类型大小移动
new/delete 手动管理堆：一一配对、delete 后置空、防泄漏
引用是必须初始化的别名，优先用引用；可为空/换指向才用指针
现代 C++ 用 unique_ptr/shared_ptr 自动管理内存（RAII）
-> 是”指针访问成员”的语法糖

下一篇：结构体与枚举——把相关数据打包成自定义类型。

本系列为 Cyber先锋社原创教程。指针是 C++ 的门槛也是魅力：内存模型想通了，后面豁然开朗。

C++ 入门教程（七）：结构体与枚举

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

int/double/string 只能描述”单点信息”，现实实体往往是”一组信息”：学生有姓名+年龄+成绩，坐标有 x+y。结构体（struct） 让你自定义”打包类型”；枚举（enum） 让你定义”取值受限”的类型。它们是迈向面向对象（第九篇）前的最后一级台阶。

一、结构体基础#

定义与使用#

1
#include <iostream>
2
#include <string>
3

4
// 定义新类型（习惯放 main 前或头文件）
5
struct Student {
6
    std::string name;     // 成员变量
7
    int age;
8
    double score;
9
};                        // ⚠ 别忘了分号！
10

11
int 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
}

展开收起

指针访问成员：->#

1
Student s = {"小明", 18, 90.5};
2
Student* p = &s;
3

4
std::cout << (*p).name << "\n";    // 括号版（* 优先级低于 .）
5
std::cout << p->name << "\n";      // 箭头版（完全等价，推荐）
6
p->score = 95;                     // 通过指针修改成员

规则：对象/引用用 .，指针用 ->。

结构体嵌套#

1
struct Date {
2
    int year, month, day;
3
};
4

5
struct Event {
6
    std::string title;
7
    Date date;              // 结构体作成员
8
    struct Place {          // 内嵌定义
9
        std::string building;
10
        int room;
11
    } place;
12
};
13

14
Event e;
15
e.title = "C++ 分享会";
16
e.date = {2026, 10, 29};
17
e.place.building = "信息楼";
18
e.place.room = 301;
19

20
std::cout << e.title << " @ " << e.place.building
21
          << e.place.room << "室\n";

展开收起

二、结构体与容器/函数#

结构体数组与 vector#

1
#include <vector>
2
#include <algorithm>
3

4
std::vector<Student> students = {
5
    {"小明", 18, 90}, {"小红", 17, 85}, {"小刚", 19, 92},
6
};
7

8
// 遍历
9
for (const auto& s : students)
10
    std::cout << s.name << " " << s.score << "\n";
11

12
// 按分数降序（结构化绑定 + lambda）
13
std::sort(students.begin(), students.end(),
14
          [](const Student& a, const Student& b) { return a.score > b.score; });
15

16
// 找最高分
17
auto best = *std::max_element(students.begin(), students.end(),
18
          [](const Student& a, const Student& b) { return a.score < b.score; });
19
std::cout << "第一名: " << best.name << "\n";

展开收起

作函数参数：const 引用优先#

1
// 大结构体只读：const& 零拷贝
2
void print_student(const Student& s) {
3
    std::cout << s.name << "," << s.age << "岁," << s.score << "分\n";
4
}
5

6
// 要修改：引用
7
void birthday(Student& s) {
8
    ++s.age;
9
}
10

11
// 值传递会整体拷贝（string/vector 都复制一遍）——大结构体别这么传

运算符重载初见（让结构体支持比较/输出）#

1
struct Point {
2
    double x, y;
3

4
    // 成员函数（第九篇正式讲）
5
    double dist() const { return std::sqrt(x*x + y*y); }
6
};

完整的运算符重载（operator<、operator==）在第十篇面向对象展开。

三、枚举#

传统 enum（无作用域，有坑）#

1
enum Color { RED, GREEN, BLUE };        // 默认值 0,1,2
2

3
Color c = GREEN;
4
std::cout << c << "\n";                 // 1（本质是 int）
5

6
if (c == GREEN) std::cout << "绿色\n";
7

8
enum Level { LOW, MID = 5, HIGH };      // 可指定值：0,5,6

坑：枚举名裸露在全局，两个 enum 有同名成员就冲突：

1
enum TrafficLight { RED, YELLOW, GREEN };   // ❌ RED/GREEN 与 Color 重复定义！

enum class（C++11，强类型枚举——现代首选）#

1
enum class Status { Idle, Running, Error };
2
enum class Color2 { Red, Green };          // 同名不冲突：有作用域
3

4
Status s = Status::Running;                 // 必须带作用域 Status::
5

6
if (s == Status::Running)
7
    std::cout << "运行中\n";
8

9
// int n = s;               // ❌ 不隐式转 int（类型安全）
10
int n = static_cast<int>(s); // 显式转换 ✓
11

12
// 指定底层类型
13
enum class Priority : char { Low = 'L', Mid = 'M', High = 'H' };

enum class 三大优点：作用域隔离（不污染全局）、不隐式转 int（防误比较）、可指定底层类型。新代码一律 enum class。

枚举 + switch：状态机标配#

1
enum class OrderState { Created, Paid, Shipped, Done, Cancelled };
2

3
void 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：所有成员共享同一块内存（省空间，底层开发用）
2
union Packet {
3
    uint32_t raw;                 // 4 字节
4
    struct { uint8_t b0,b1,b2,b3; } bytes;   // 也是 4 字节，与 raw 重叠
5
};
6

7
Packet p;
8
p.raw = 0x11223344;
9
std::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

7
enum class BookState { Available, Borrowed, Lost };
8

9
struct 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

24
struct 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.isbn
48
                      << std::setw(16) << b.title
49
                      << b.state_str() << "\n";
50
    }
51
};
52

53
int 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>}，写函数计算每人平均分并输出最高的姓名
用 enum class 表示”星期”写函数：输入 1-7 返回中文星期名（switch）
结构体数组按多级排序：先按年龄升序，同龄按分数降序（lambda 组合比较）
定义 Vec2{x,y} 并写 add/sub/dot 三个函数（const 引用传参），实现向量加减与点积

本篇小结#

struct 把相关数据打包成自定义类型；定义后别忘分号
对象用 .、指针用 -> 访问成员；结构体可嵌套
结构体传参：只读 const&、要改 &；配 vector/sort 食用最佳
枚举新代码用 enum class：作用域安全、不隐式转 int
union 了解即可；struct 是 class 的”公开版”，面向对象见第九篇

下一篇：面向对象（上）——类、构造析构、封装。

本系列为 Cyber先锋社原创教程。图书管理案例先自己扩展”还书”功能，第十篇再见证它的进化。

C++ 入门教程（八）：面向对象（上）——类与封装

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

C++ 是”多范式语言”，但面向对象（OOP） 是它组织大型工程的主力方式。本篇讲 OOP 三大特性中的封装：把数据与操作绑定、对外隐藏细节。构造/析构/拷贝这”三巨头”是 C++ 面试与实战的高频考点。

一、从 struct 到 class#

1
class BankAccount {
2
private:                 // 私有：只有类自己的成员函数能访问
3
    std::string owner;
4
    double balance;
5

6
public:                  // 公开：外部的接口
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

27
int main() {
28
    BankAccount acc("小明", 100);
29
    acc.deposit(50);
30
    acc.withdraw(30);
31
    std::cout << acc.get_balance() << "\n";    // 120
32

33
    // acc.balance = -999;      // ❌ private，外部禁止直接改——封装的意义！
34
}

展开收起

class 与 struct 的唯一区别：默认访问权限——class 默认 private，struct 默认 public。习惯：纯数据用 struct，带行为用 class。

封装的价值：balance 不能被外部直接改成负数——所有修改必须经过 deposit/withdraw 的校验，不变量（余额非负）由类自己守护。

二、访问控制三档#

关键字	谁能访问
`private`	本类的成员函数（默认）
`protected`	本类 + 子类（第九篇）
`public`	任何人

三、构造函数详解#

重载与默认构造#

1
class Date {
2
    int y, m, d;
3
public:
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

11
Date a;              // 默认构造（注意：不带括号！）
12
Date b{2026, 10, 29};
13
Date c = Date(2026, 10, 29);
14
// Date d();         // ⚠ 经典陷阱：这是函数声明，不是构造对象！

explicit：防止单参构造的隐式转换#

1
void print(const Date& d);
2

3
// 若 Date(int) 不加 explicit：
4
// print(12345);    // 会被悄悄转换成 Date——意外行为！
5
// 加了 explicit 后必须显式：print(Date(12345));

军规：单参构造一律加 explicit。

委托构造与 default（C++11）#

1
class Widget {
2
public:
3
    Widget() : Widget(0, 0) {}          // 委托给另一个构造
4
    Widget(int x, int y) : x_(x), y_(y) {}
5
    Widget(const Widget&) = default;    // 让编译器生成默认版本
6
private:
7
    int x_, y_;
8
};

四、析构函数#

对象销毁时自动调用，名字是 ~类名，负责清理资源：

1
#include <iostream>
2

3
class FileLogger {
4
    FILE* fp;
5
public:
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

21
void demo() {
22
    FileLogger logger("app.log");       // 栈对象：demo 结束自动析构
23
    logger.log("hello");
24
}                                       // 打印 [关闭日志]——这就是 RAII！
25

26
int main() { demo(); std::cout << "demo 之后\n"; }
27
// 输出顺序：[打开日志] [关闭日志] demo 之后

展开收起

RAII（资源获取即初始化）：资源在构造函数获取、析构函数释放——智能指针、锁、文件句柄都靠它。C++ 程序员最重要的习惯：把资源包进对象，交给析构函数管理。

五、拷贝：三巨头之二#

拷贝构造与拷贝赋值#

1
class Buffer {
2
    int* data;
3
    size_t size;
4
public:
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 = a
17
            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=c
23
    }
24

25
    ~Buffer() { delete[] data; }       // 三巨头之三
26
};
27

28
Buffer a(10);
29
Buffer b = a;        // 拷贝构造（定义时初始化）
30
Buffer c(5);
31
c = a;               // 拷贝赋值（已存在对象赋值）

展开收起

浅拷贝的灾难（编译器默认拷贝的坑）#

若不写拷贝构造，编译器生成逐成员浅拷贝——指针成员只拷贝地址：

1
// 假设 Buffer 没写拷贝构造：
2
Buffer b = a;        // b.data 与 a.data 指向同一块内存！
3
// 析构时：a、b 各 delete 同一块内存 → 💥 双重释放，程序崩溃

规则：类持有裸资源（指针/文件句柄）就必须遵循三法则：自定义析构、拷贝构造、拷贝赋值（或全部 = delete 禁止拷贝）。

移动语义预告（C++11）#

深拷贝大 Buffer 很浪费，C++11 引入移动：Buffer d = std::move(a); 直接”偷”走 a 的资源不复制。进阶内容，此处知道有这回事即可。

六、static 成员与 this#

static：属于类而非对象#

1
class Counter {
2
public:
3
    Counter() { ++count_; }
4
    static int get_count() { return count_; }    // 静态成员函数：无 this
5
private:
6
    static int count_;           // 静态成员变量：所有对象共享一份
7
};
8
int Counter::count_ = 0;         // ⚠ 类外定义（C++17 可 inline static int count_ = 0;）
9

10
Counter a, b, c;
11
std::cout << Counter::get_count();   // 3（用类名调用，不需要对象）

this 指针#

每个成员函数都隐含 this（指向当前对象的指针）：

1
class Chain {
2
    int value;
3
public:
4
    Chain& add(int x) {       // 返回 *this 实现链式调用
5
        value += x;
6
        return *this;
7
    }
8
};
9

10
Chain c;
11
c.add(1).add(2).add(3);       // 链式：value = 6

七、常量成员与 mutable#

1
class Temp {
2
    mutable int access_count = 0;    // mutable：const 函数里也可改
3
    double celsius_ = 25.0;
4
public:
5
    double fahrenheit() const {      // const 成员函数：保证不改成员
6
        ++access_count;              // ✓ mutable 例外
7
        return celsius_ * 9 / 5 + 32;
8
    }
9
};
10

11
const Temp t;        // const 对象只能调用 const 成员函数
12
t.fahrenheit();      // ✓

规则：不修改成员的函数一律标 const——否则 const 对象/引用调不了它，STL 里会到处报错。

八、实战：矩阵类#

1
#include <vector>
2
#include <stdexcept>
3
#include <iomanip>
4
#include <iostream>
5

6
class Matrix {
7
public:
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

42
private:
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

51
int main() {
52
    Matrix a(2, 3, 1.0);
53
    Matrix b(3, 2, 2.0);
54
    Matrix c = a * b;        // 6 = 全1×全2
55
    c.print();
56
}

展开收起

用到的本篇知识：构造初始化列表、private 封装、const 成员函数重载、运算符重载、异常（第十一篇详讲）。

小练习#

实现 Fraction（分数类）：私有分子分母、reduce() 约分、operator+、print()，保证分母永不为 0
给第三篇的猜数字加 GameStats 类：static 成员统计总局数与总尝试次数
写 Timer 类：构造记录时间、析构时打印存活时长（RAII 计时器，函数性能粗测神器）
实现 Stack 类（基于 vector）：push/pop/top/empty/size，pop 空栈时抛异常
（概念）说出三法则是什么、为什么持有 int* 的类必须遵守

本篇小结#

class 默认 private；封装 = 数据私有 + 接口公开
构造函数可重载；初始化列表先于构造体执行；单参构造加 explicit
析构 ~T() 自动释放资源——RAII 是 C++ 的核心习惯
浅拷贝会双重释放；持有资源遵循三法则（析构+拷贝构造+拷贝赋值）
static 成员类共享；this 支持链式；只读函数标 const

下一篇：面向对象（下）——继承、多态与虚函数，OOP 的另一半拼图。

本系列为 Cyber先锋社原创教程。三法则与 RAII 是 C++ 区别于其他语言的核心概念，值得反复咀嚼。

C++ 入门教程（九）：面向对象（下）——继承与多态

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

OOP 三大特性的另外两个：继承（代码复用的层级体系）与多态（同一接口、不同行为）。虚函数是 C++ 多态的核心机制，也是面试必考。本篇讲透它的语法与原理。

一、继承基础#

基本语法#

1
#include <iostream>
2
#include <string>
3

4
// 基类（父类）
5
class Animal {
6
public:
7
    Animal(const std::string& name) : name_(name) {}
8
    void eat() const { std::cout << name_ << "在吃东西\n"; }
9
protected:                      // 子类可访问，外部不行
10
    std::string name_;
11
};
12

13
// 派生类（子类）：public 继承表示"是一个"关系
14
class Dog : public Animal {
15
public:
16
    Dog(const std::string& name, const std::string& breed)
17
        : Animal(name), breed_(breed) {}       // ⚠ 先调基类构造
18
    void fetch() const { std::cout << name_ << "去捡球\n"; }   // 直接用 protected 成员
19
private:
20
    std::string breed_;
21
};
22

23
class Cat : public Animal {
24
public:
25
    Cat(const std::string& name) : Animal(name) {}
26
    void scratch() const { std::cout << name_ << "在磨爪\n"; }
27
};
28

29
int 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
// 析构：派生类先析构，再基类（完全相反，像穿脱衣服）
3
class Base {
4
public:
5
    Base()  { std::cout << "Base构造\n"; }
6
    ~Base() { std::cout << "Base析构\n"; }
7
};
8
class Derived : public Base {
9
public:
10
    Derived()  { std::cout << "Derived构造\n"; }
11
    ~Derived() { std::cout << "Derived析构\n"; }
12
};
13
// Derived d; 输出：
14
// Base构造 → Derived构造 → Derived析构 → Base析构

二、虚函数与多态（本篇核心）#

问题引入#

1
Animal* a = new Dog("旺财");   // 基类指针指向子类对象（合法）

现在想让每个动物”叫出自己的声音”：

1
class Animal {
2
public:
3
    void speak() const {                 // ❌ 普通成员函数
4
        std::cout << name_ << "在发声\n";
5
    }
6
};
7
class Dog : public Animal {
8
public:
9
    void speak() const {                 // 隐藏（不是重写！）
10
        std::cout << name_ << "汪汪！\n";
11
    }
12
};
13

14
Animal* a = new Dog("旺财");
15
a->speak();      // 输出"旺财在发声"——调的是基类版本！

展开收起

普通函数调用在编译期按指针类型绑定（静态绑定），所以永远调 Animal 的版本。

virtual：运行期绑定#

1
class Animal {
2
public:
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
    }
9
protected:
10
    std::string name_;
11
};
12

13
class Dog : public Animal {
14
public:
15
    Dog(const std::string& n) : Animal(n) {}
16
    void speak() const override {        // override 显式标记重写（C++11）
17
        std::cout << name_ << "汪汪！\n";
18
    }
19
};
20

21
class Cat : public Animal {
22
public:
23
    Cat(const std::string& n) : Animal(n) {}
24
    void speak() const override {
25
        std::cout << name_ << "喵～\n";
26
    }
27
};
28

29
int 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 重写、通过基类指针或引用调用。

Tip

override 关键字让编译器帮你检查签名是否真的重写成功（拼错函数名会直接报错）——重写必写 override。

虚函数原理（面试高频，简版）#

每个含虚函数的类都有一张虚函数表（vtable），对象头部存指向 vtable 的指针（vptr）：

1
Animal* a → [vptr] → Animal::vtable  [ &Animal::speak ]
2
Dog 对象  → [vptr] → Dog::vtable     [ &Dog::speak    ]   ← Dog 覆盖了槽位
3

4
调用 a->speak() 编译为：a->vptr->speak槽位()   ← 运行期查表

代价：每对象多 8 字节指针 + 一次间接跳转。所以”不需要多态就别加 virtual”。

三、纯虚函数与抽象类#

1
class Shape {                        // 抽象类：含纯虚函数，不能实例化
2
public:
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

12
class Circle : public Shape {
13
    double r;
14
public:
15
    explicit Circle(double r) : r(r) {}
16
    double area() const override { return 3.14159 * r * r; }
17
};
18

19
class Rect : public Shape {
20
    double w, h;
21
public:
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

29
int 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 必须会算面积”，实现交给子类。纯虚析构除外，接口类通常只含纯虚函数。

四、虚析构函数（必考）#

1
class BadBase {
2
public:
3
    ~BadBase() { std::cout << "~BadBase\n"; }    // ❌ 非虚析构
4
};
5
class BadDerived : public BadBase {
6
    int* big_;
7
public:
8
    BadDerived() : big_(new int[1000]) {}
9
    ~BadDerived() { delete[] big_; std::cout << "~BadDerived\n"; }
10
};
11

12
int main() {
13
    BadBase* p = new BadDerived();
14
    delete p;      // ⚠ 只输出 ~BadBase！子类析构没执行 → big_ 泄漏 4000 字节
15
}

展开收起

修正：基类析构函数声明为 virtual ~Base() = default;。军规：只要类会被继承且通过基类指针删除，析构必须是 virtual。

五、final 与类型识别#

1
class Locked : public Base {
2
public:
3
    void speak() const final;      // final：禁止后代再重写
4
};
5
// class Sub : public Locked {};  // 也可 final 整个类：禁止再继承
6

7
// 运行期类型识别 dynamic_cast（向下转型，需多态类型）
8
Animal* a = new Dog("旺财");
9
if (Dog* d = dynamic_cast<Dog*>(a)) {   // 成功返回指针，失败返回 nullptr
10
    d->fetch();
11
}
12

13
// typeid 拿到真实类型名
14
#include <typeinfo>
15
std::cout << typeid(*a).name();         // 3Dog（名字修饰因编译器而异）

展开收起

六、综合实战：RPG 战斗模拟器#

综合继承+多态+虚析构+抽象类：

1
#include <iostream>
2
#include <memory>
3
#include <vector>
4
#include <string>
5
#include <random>
6

7
class Character {                          // 抽象基类
8
public:
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_ << " 受到 " << dmg
17
                  << " 伤害（剩 " << (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

24
protected:
25
    std::string name_;
26
    int hp_, atk_;
27
};
28

29
class Warrior : public Character {         // 战士：稳定输出
30
public:
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

38
class Mage : public Character {            // 法师：30% 概率暴击
39
public:
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

50
int 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）——灵活
3
class Engine { public: void start() {} };
4
class Car {
5
    Engine engine_;                  // 组合
6
public:
7
    void start() { engine_.start(); }   // 委托
8
};

经验法则：能用组合就用组合，“is-a”关系明确才用继承。

小练习#

Shape 体系加 Triangle（三边长，海伦公式）与 Square
写 Employee 抽象类 + Manager/Sales：月薪计算方式不同（虚函数 salary()），打印全员工资
给 Character 加 heal(Character&) 接口与 Priest 职业实现治疗
验证虚析构：把 BadBase 析构改成 virtual，观察输出变化
（概念）多态三条件是什么？override 和 final 分别解决什么问题？

本篇小结#

public 继承表达 is-a；构造先基后派、析构反序
virtual 开启动态绑定：基类指针/引用按真实类型调函数；重写必标 override
= 0 定义纯虚 → 抽象类不可实例化，作接口契约
基类析构必 virtual（通过基类指针删除时防泄漏）
dynamic_cast 安全向下转型；组合优先于继承
新增子类不改老代码——开闭原则的 C++ 实现

下一篇：运算符重载与友元——让自定义类型像内置类型一样自然运算。

本系列为 Cyber先锋社原创教程。RPG 案例的扩展性实验（加职业不动主逻辑）是多态最好的注脚。

C++ 入门教程（十）：运算符重载与友元

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

a + b、cout << obj、obj[i]——内置类型天然支持这些运算，自定义类型也可以。运算符重载让 Money + Money、Vector * Matrix 写起来像数学公式。这是 C++ 区别于多数语言的特性，用好了代码优雅，用滥了灾难现场。

一、基本概念与规则#

什么能重载、什么不能#

1
✅ 可重载：+ - * / % == != < > += -= << >> && || ! [] () -> new...
2
❌ 不可重载：:: . .* sizeof typeid ?:（三目） .*

两条硬规则：

至少一个操作数是自定义类型（不能重载 int + int）
不能发明新运算符、不能改变优先级与结合性

心法：重载后的行为要符合直觉——+ 就该是加法语义。把 + 重载成减法，同事会杀人。

成员 vs 非成员#

1
class Money {
2
    long cents_;                        // 用"分"存，避免浮点误差
3
public:
4
    // 成员函数版：左操作数必须是本类
5
    Money operator+(const Money& rhs) const {
6
        return Money(cents_ + rhs.cents_);
7
    }
8
};
9

10
// 非成员版（常配友元）：左操作数可以是其他类型
11
Money operator-(const Money& a, const Money& b);
12
std::ostream& operator<<(std::ostream&, const Money&);   // 流运算符必须非成员

选择：会修改左操作数（+=、=、[]）用成员；对称双目（+、==）与流运算符用非成员。

二、算术与比较运算符#

完整的 Fraction（分数）实现#

1
#include <iostream>
2
#include <numeric>      // std::gcd
3

4
class 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

13
public:
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
// 非成员：流输出
53
std::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

58
int main() {
59
    Fraction a(1, 2), b(3, 4);
60

61
    std::cout << a << " + " << b << " = " << a + b << "\n";   // 5/4
62
    std::cout << a << " * " << b << " = " << a * b << "\n";   // 3/8
63
    std::cout << a << " - " << b << " = " << a - b << "\n";   // -1/4
64
    std::cout << (a < b ? "a<b" : "a>=b") << "\n";
65

66
    Fraction c(2, 4);        // 自动约分成 1/2
67
    std::cout << c << "\n";  // 1/2
68
}

展开收起

省力技巧（C++20 <=>）：三路比较一行顶六行：

1
// C++20：自动生成 == != < <= > >=
2
auto operator<=>(const Fraction&) const = default;   // 需成员逐一可比较

三、流运算符 << 与 >>#

1
// << 必须是非成员（左操作数是 ostream，不是我们的类）
2
std::ostream& operator<<(std::ostream& os, const Fraction& f) {
3
    return os << f.num() << "/" << f.den();   // 返回 os 引用 → 支持链式
4
}
5

6
// >> 输入版
7
std::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
    else
13
        is.setstate(std::ios::failbit);       // 标记失败
14
    return is;
15
}
16
// 用法：std::cout << a << " " << b << "\n";  链式全靠返回 os

展开收起

四、下标、调用与类型转换运算符#

operator[]：让对象像数组#

1
class IntArray {
2
    std::vector<int> data_;
3
public:
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

12
IntArray arr(5);
13
arr[0] = 42;                  // 调可写版
14
std::cout << arr[0];          // 调只读版（const 场景）

operator()：仿函数（函数对象）#

1
class Multiplier {                    // "行为像函数的对象"
2
    int factor_;
3
public:
4
    explicit Multiplier(int f) : factor_(f) {}
5
    int operator()(int x) const {     // 重载调用运算符
6
        return x * factor_;
7
    }
8
};
9

10
Multiplier triple(3);
11
std::cout << triple(10);              // 30——像调用函数一样使用对象
12

13
// STL 中 lambda 本质就是编译器生成的仿函数类！
14
auto quadruple = [](int x) { return x * 4; };

类型转换运算符#

1
class Fraction {
2
    // ...
3
public:
4
    explicit operator double() const {      // 显式转 double
5
        return double(num_) / den_;
6
    }
7
};
8

9
Fraction f(1, 2);
10
double d = static_cast<double>(f);   // ✓ 显式转换
11
// double e = f;                    // ❌ explicit 禁止隐式转换（防意外）

五、友元（friend）#

问题：非成员函数想访问私有成员#

1
class BankAccount {
2
    friend std::ostream& operator<<(std::ostream&, const BankAccount&);
3
    // ↑ 声明这个函数是"朋友"：允许它访问我的 private
4

5
private:
6
    std::string owner_;
7
    double balance_;
8

9
public:
10
    BankAccount(std::string o, double b) : owner_(std::move(o)), balance_(b) {}
11
};
12

13
// 友元函数不是成员函数，但能访问私有成员
14
std::ostream& operator<<(std::ostream& os, const BankAccount& acc) {
15
    return os << acc.owner_ << ": ¥" << acc.balance_;   // ✓ 访问 private
16
}
17

18
int main() {
19
    BankAccount a("小明", 100.5);
20
    std::cout << a << "\n";    // 小明: ¥100.5
21
}

展开收起

友元类与要点#

1
class Matrix;
2
class MatrixIterator {
3
    friend class Matrix;      // Matrix 的所有成员函数都可访问我的私有
4
    // ...
5
};

友元三原则：friend 是”授予”而非”索取”（类自己声明谁是我朋友）；友元破坏封装，能不用就不用；合法场景：运算符重载、紧密协作的类对（Container 与它的 Iterator）。

友元不被继承、不是双向的、不传递。

六、何时不该重载#

场景	建议
数学类型（向量/分数/矩阵/复数）	✅ 重载 + - * /，天然合适
逻辑比较（排序、去重需要）	✅ `<` `==`（配 STL 容器）
输出调试	✅ `<<`
`&&` `
逗号 `，`、取地址 `&`	❌ 语义迷惑，别碰
为了少打字把 `+` 当”追加”用于文件/网络	⚠ 语义存疑，用命名方法 `append` 更清晰

七、实战：二维向量 Vector2D 完整版#

1
#include <iostream>
2
#include <cmath>
3

4
class Vec2 {
5
    double x_, y_;
6
public:
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)); }             // 复用 dot
18

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

26
Vec2 operator*(double k, const Vec2& v) { return v * k; }   // 3*v 也成立
27

28
int 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";    // 11
34
    std::cout << "|b|=" << b.length() << "\n";  // 5
35
    std::cout << "3a=" << 3 * a << "\n";        // (3, 6)
36

37
    Vec2 c = a + b * 2;                          // 数学式表达式
38
    std::cout << c[0] << "," << c[1] << "\n";   // 7,10
39
}

展开收起

小练习#

给 Fraction 补全 >= <= > !=（用 < 和 == 组合实现）
实现 Temperature 类：内部存摄氏，operator+、转华氏方法、<< 输出两种温标
实现 Str 简易字符串类：operator+ 拼接、operator[] 访问、operator== 比较
写 Accumulator 仿函数：每次 () 调用累加并返回累计值（对比第六篇闭包计数器）
（思考）为什么 operator<< 不能是成员函数？为什么 operator+= 通常是成员而 operator+ 常是非成员？

本篇小结#

可重载绝大多数运算符，但语义必须符合直觉；&&/|| 别重载（失短路）
修改自身用成员（+= = [] ()），对称与流用非成员（+ == << >>）
算术返回新值 const，复合赋值返回 *this&
<< 返回 ostream 引用支撑链式；C++20 <=> 一行生成全套比较
friend 授予外部访问私有的权限，仅用于运算符/姊妹类
仿函数 operator() 是 lambda 的本质

下一篇：STL 标准模板库总览——容器、迭代器与算法的完整武器库。

本系列为 Cyber先锋社原创教程。Fraction 与 Vec2 是面试白板题常客，建议默写一遍。

C++ 入门教程（十一）：STL 标准模板库

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

STL（Standard Template Library） 是 C++ 自带的”兵器库”：6+ 种容器、几十个算法、通用迭代器粘合两者。学完本篇，你写 C++ 的效率会翻倍——不再手写链表、排序、查找，组合现成部件即可。

一、STL 全景图#

1
STL 三大件：
2
├── 容器（Containers）：存数据    vector / list / map / set ...
3
├── 迭代器（Iterators）：胶水     统一遍历所有容器的方式
4
└── 算法（Algorithms）：处理数据  sort / find / count / accumulate ...
5
+ 仿函数 & lambda：算法的"策略参数"

头文件速记：容器各有头（<vector> <map>…），算法统一 <algorithm>，数值算法 <numeric>。

二、顺序容器#

vector（复习+补强）#

1
#include <vector>
2

3
std::vector<int> v{3, 1, 4};
4
v.push_back(5);
5
v.reserve(100);            // 预留容量，避免反复扩容拷贝
6
std::cout << v.capacity() << " " << v.size();   // 100 4

deque：双端队列#

1
#include <deque>
2

3
std::deque<int> dq{2, 3};
4
dq.push_front(1);      // 头部 O(1)！
5
dq.push_back(4);       // {1,2,3,4}
6
dq.pop_front();        // {2,3,4}

vs vector：头插头删 O(1)，但内存不连续（缓存稍差）。需要双端操作选它。

list：双向链表#

1
#include <list>
2

3
std::list<int> lst{1, 2, 4};
4
auto it = std::next(lst.begin());      // 指向 2
5
lst.insert(it, 3);                     // {1,2→3,4} 任意位置 O(1)
6
lst.remove(2);                         // 按值删
7
lst.sort();                            // list 自带 sort（std::sort 不支持它）
8
lst.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)（有迭代器）
内存	连续	分块	节点散布
默认选择	⭐	双端需求	特殊链表需求

三、关联容器#

map：有序键值对（红黑树）#

1
#include <map>
2
#include <string>
3

4
std::map<std::string, int> ages;
5

6
// 插入三种方式
7
ages["小明"] = 18;                          // 不存在则插入，存在则覆盖
8
ages.insert({"小红", 17});
9
ages.emplace("小刚", 19);                    // 原地构造（推荐）
10

11
// 安全访问：at 越界抛异常，[] 越界会"悄悄创建"！
12
try { ages.at("不存在"); } catch (const std::out_of_range&) { }
13
int cnt = ages.count("小明");                // 0 或 1
14
// ages["不存在的键"];                       // ⚠ 危险：会插入默认值！
15

16
// 遍历（按键自动排序）
17
for (const auto& [name, age] : ages)        // 结构化绑定
18
    std::cout << name << " " << age << "\n";
19

20
// 查找
21
if (auto it = ages.find("小明"); it != ages.end())
22
    std::cout << it->second << "\n";

展开收起

Warning

map::operator[] 对不存在的键会插入默认值——只读查询场景永远用 find 或 count，这是 map 的第一大坑。

set：有序去重集合#

1
#include <set>
2

3
std::set<int> s{3, 1, 4, 1, 5};         // {1,3,4,5} 自动去重排序
4
s.insert(2);
5
s.erase(1);
6

7
if (s.count(3)) std::cout << "3 在集合\n";
8
std::cout << s.size();                   // 4

unordered_map / unordered_set（哈希表）#

1
#include <unordered_map>
2

3
std::unordered_map<std::string, int> fast;
4
fast["apple"] = 5;
5
// 接口与 map 完全一致！区别在实现：
6
// map         红黑树   查找 O(log n)   键有序遍历
7
// unordered   哈希表   查找 O(1) 均摊  遍历无序

选型：需要有序遍历/范围查询用 map/set；纯查找用 unordered（更快，日常默认）。

multimap / multiset#

允许重复键：std::multimap<std::string, int> 一个键多个值（如一个学生多门课成绩）。

四、迭代器#

统一的遍历语法#

1
std::vector<int> v{1,2,3};
2
std::map<std::string,int> m{{"a",1}};
3

4
for (auto it = v.begin(); it != v.end(); ++it)
5
    std::cout << *it;
6

7
for (const auto& [k, val] : m)      // 范围 for 底层就是迭代器
8
    std::cout << k << val;

常用操作#

1
std::vector<int> v{10, 20, 30, 40, 50};
2

3
auto it = v.begin();
4
std::advance(it, 2);                    // 前进 2 → 指向 30
5
int d = std::distance(v.begin(), it);   // 2
6
auto it2 = std::next(v.begin());        // 第二个（原迭代器不动）
7
auto 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 的返回值
14
for (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

4
std::vector<int> v{3, 1, 4, 1, 5, 9, 2, 6};
5

6
std::find(v.begin(), v.end(), 5);            // 找值，end()=没找到
7
std::count(v.begin(), v.end(), 1);           // 2
8
std::accumulate(v.begin(), v.end(), 0);      // 31 求和（<numeric>）
9
std::max_element(v.begin(), v.end());        // 指向 9 的迭代器
10
std::minmax_element(v.begin(), v.end());     // pair<min_it, max_it>
11

12
// 条件版
13
auto cnt_even = std::count_if(v.begin(), v.end(),
14
                              [](int x){ return x % 2 == 0; });
15
auto it_big = std::find_if(v.begin(), v.end(),
16
                           [](int x){ return x > 5; });

展开收起

排序与变换#

1
std::sort(v.begin(), v.end());                          // 升序
2
std::sort(v.begin(), v.end(), std::greater<int>());     // 降序
3
std::stable_sort(...);                                  // 稳定（相等保持原序）
4
std::partial_sort(v.begin(), v.begin()+3, v.end());     // 只排前 3
5

6
std::reverse(v.begin(), v.end());
7
std::transform(v.begin(), v.end(), v.begin(),           // 原地变换
8
               [](int x){ return x * x; });
9

10
std::vector<int> dst(v.size());
11
std::copy(v.begin(), v.end(), dst.begin());

经典三连：remove + erase 真删除#

1
// remove 只把"要删的"挪到末尾，返回新逻辑末尾——容器 size 不变！
2
auto new_end = std::remove_if(v.begin(), v.end(),
3
                              [](int x){ return x < 3; });
4
v.erase(new_end, v.end());      // 真正删除（erase-remove 惯用法）

二分查找（需先有序）#

1
std::sort(v.begin(), v.end());
2
bool found = std::binary_search(v.begin(), v.end(), 5);   // 是否存在
3
auto lb = std::lower_bound(v.begin(), v.end(), 5);        // 第一个 >= 5
4
auto ub = std::upper_bound(v.begin(), v.end(), 5);        // 第一个 > 5
5
std::cout << ub - lb << "\n";                             // 值 5 的个数

六、综合案例#

1. 词频统计（map 的主场）#

1
#include <map>
2
#include <sstream>
3
#include <iostream>
4
#include <vector>
5
#include <algorithm>
6

7
int 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
}

展开收起

2. 学生成绩系统（多容器协作）#

1
struct Record { std::string name; int score; };
2

3
int 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 + erase
用 erase-remove 惯用法删除 vector 中所有负数
用 accumulate 计算字符串向量所有元素的总长度
模拟”商品库存”：unordered_map<string,int>，支持进货、售出（减到 0 提示缺货）、按名称排序输出全部

本篇小结#

顺序容器默认 vector；关联容器默认 unordered 系列；有序需求才 map/set
map[] 会插入默认值，只读用 find/count
迭代器是容器与算法的胶水；erase 返回值防迭代器失效
算法库三板斧：sort/count_if/accumulate + find_if/max_element
真删除用 erase-remove 惯用法；二分先排序
组合容器+算法，绝大多数需求无需手写数据结构

下一篇：异常处理与文件 IO——系列的收官与综合实战。

本系列为 Cyber先锋社原创教程。STL 的熟练度 = C++ 的日常生产力，练习 5 的库存系统务必完整实现。

C++ 入门教程（十二）：异常处理、文件 IO 与综合实战

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

最后两块拼图：异常处理（出错不崩）与文件 IO（数据持久化），随后用一个综合项目收官全系列——做一个支持增删改查、文件持久化的通讯录管理系统。

一、C++ 异常处理#

基本语法#

1
#include <iostream>
2
#include <stdexcept>
3

4
double safe_divide(double a, double b) {
5
    if (b == 0)
6
        throw std::invalid_argument("除数不能为零");   // 抛出异常对象
7
    return a / b;
8
}
9

10
int main() {
11
    try {
12
        std::cout << safe_divide(10, 2) << "\n";     // 5
13
        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 顺序敏感（子类必须放基类前面）。

标准异常层级（）#

1
std::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

4
class InsufficientFundsError : public std::runtime_error {
5
    double shortfall_;
6
public:
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

14
void withdraw(double balance, double amount) {
15
    if (amount > balance)
16
        throw InsufficientFundsError(amount - balance);
17
    // ...
18
}
19

20
int 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
}

展开收起

noexcept 与栈展开#

1
// noexcept 承诺"此函数不抛异常"——编译器可优化，违诺直接 std::terminate
2
void pure_compute(int x) noexcept { /* 不抛任何东西 */ }
3

4
// 异常抛出时的"栈展开"：沿途所有局部对象析构函数被依次调用
5
// → RAII 对象在异常路径同样安全释放（这就是 RAII 伟大的原因）
6
void demo() {
7
    FileLogger log("app.log");     // 第八篇的 RAII 类
8
    throw std::runtime_error("boom");
9
}   // log 的析构依然执行，文件被正确关闭！

异常安全军规：资源交给 RAII 对象管理，异常来了自动清理；不要在析构函数里抛异常。

二、文件 IO#

文本文件：ifstream / ofstream#

1
#include <fstream>
2
#include <iostream>
3
#include <string>
4

5
int 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`	二进制模式

1
std::ifstream f("data.txt");
2
if (!f.is_open()) { /* 打不开 */ }
3
if (f.eof())  { /* 读到文件尾 */ }
4
f.clear();                                 // 清除错误状态（重读前）

stringstream：内存中的流（第五篇分割的完整版）#

1
#include <sstream>
2

3
// 字符串 → 数值：split 一行 CSV
4
std::string line = "小明,18,90.5";
5
std::stringstream ss(line);
6
std::string name; int age; double score;
7
std::getline(ss, name, ',');
8
ss >> age; ss.ignore(1, ',');     // 跳过逗号
9
ss >> score;
10

11
// 数值 → 字符串（to_string 之外的格式化方式）
12
std::ostringstream os;
13
os << "成绩: " << std::fixed << std::setprecision(1) << score;
14
std::string result = os.str();

三、综合实战：通讯录管理系统#

全系列知识集大成：struct + vector + STL 算法 + 异常 + 文件持久化 + 菜单循环。

1
// ===== contacts.cpp 完整可编译运行 =====
2
// g++ contacts.cpp -o contacts -std=c++17
3
#include <iostream>
4
#include <fstream>
5
#include <sstream>
6
#include <vector>
7
#include <string>
8
#include <algorithm>
9
#include <iomanip>
10

11
struct Contact {
12
    std::string name;
13
    std::string phone;
14
    std::string group;      // 分组：朋友/家人/同学...
15
};
16

17
class ContactBook {
18
    std::vector<Contact> data_;
19
    const std::string path_ = "contacts.txt";
20

21
public:
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.phone
67
                          << " [" << c.group << "]\n";
68
    }
69

70
    size_t size() const { return data_.size(); }
71

72
private:
73
    void load() {                                // 每行: name,phone,group
74
        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

93
int 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->phone
121
                                 << " [" << 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";      // 析构也会 save
133
}

展开收起

用到的知识点清单：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
> list
8
【同学】
9
  小明 (138xxxx)
10
【家人】
11
  小红 (139xxxx)
12
> quit
13
数据已保存，再见！

四、系列总结#

篇	主题	关键收获
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 服务器、贪吃蛇）。做出作品欢迎投稿本站！

小练习（毕业设计）#

通讯录加”修改”命令（update 名字新电话）与”导入导出 CSV”
把通讯录数据改成 JSON 风格存储（自己设计转义规则）
用 class 重写第三篇猜数字为 GuessGame 类，含 play() 与统计功能

本系列为 Cyber先锋社原创教程，共 12 篇完结。欢迎在留言板晒出你的毕业设计！

Java 入门教程（一）：JDK、IDEA 与第一个程序

Thu, 29 Oct 2026 00:00:00 GMT

Java 的定位#

“一次编写，到处运行”（Write Once, Run Anywhere）是 Java 的招牌。它能做到这一点，靠的是 JVM（Java 虚拟机）：Java 源代码先编译成”字节码”（.class 文件），再由各平台的 JVM 执行——同一个字节码能在 Windows、macOS、Linux 上运行。

Java 是企业级开发的主力语言：银行系统、安卓 App、大型电商后端、大数据生态（Hadoop/Spark 均为 Java 系）都有它的身影。岗位多、生态成熟，是就业市场的常青树。

JDK / JRE / JVM 的关系#

初学必懂的三层概念：

1
JDK（开发工具包）
2
 ├── JRE（运行环境）
3
 │    ├── JVM（虚拟机：真正执行字节码）
4
 │    └── 核心类库
5
 ├── javac（编译器）
6
 └── 其他开发工具

只想运行 Java 程序 → 装 JRE 就够
想开发 Java 程序 → 装 JDK（包含 JRE）

安装 JDK 与开发环境#

安装 JDK（推荐 LTS 版本 17 或 21）#

Windows/macOS：从 Adoptium（Eclipse Temurin 发行版）下载安装包，一路下一步。

Linux（Ubuntu/Debian）：

Terminal window

1
sudo apt update && sudo apt install openjdk-21-jdk

验证安装#

Terminal window

1
java -version     # 运行环境版本
2
javac -version    # 编译器版本

两个命令都有输出即安装成功。

安装 IDEA#

Java 开发的事实标准 IDE 是 IntelliJ IDEA（JetBrains 出品）：

到 jetbrains.com/idea 下载
学生可申请免费的教育许可（Community 社区版本身也免费且够用）
首次使用学生邮箱激活 Ultimate 教育版更香

Tip

新手完全可以用 Community 社区版起步，功能足够写完整个入门系列。

第一个程序#

新建 Hello.java（文件名必须与类名一致，这是 Java 的硬规矩）：

1
public class Hello {
2
    public static void main(String[] args) {
3
        System.out.println("Hello, Cyber先锋社!");
4
    }
5
}

编译运行：

Terminal window

1
javac Hello.java    # 生成 Hello.class 字节码
2
java Hello          # JVM 执行（注意不带 .class 后缀）
3
Hello, Cyber先锋社!

在 IDEA 里只需右键 → Run，IDE 会自动完成编译执行。

解剖这个程序：

部分	含义
`public class Hello`	定义一个公开类，类名与文件名一致
`public static void main(String[] args)`	主方法：程序入口，格式固定照抄
`System.out.println(...)`	向控制台输出一行内容
`;`	每条语句以分号结尾

Warning

Java 对大小写极其敏感：System 写成 system 直接报错。main 方法的签名必须一字不差。

变量与数据类型#

Java 同样是静态类型语言，且区分基本类型与引用类型：

1
public 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

类型转换#

1
int a = 10;
2
double b = a;          // 自动转换（小 → 大，安全）
3

4
double pi = 3.99;
5
int c = (int) pi;      // 强制转换（大 → 小，截断小数），c = 3

输入：Scanner#

Java 读键盘输入用 Scanner 类：

1
import java.util.Scanner;   // 导包
2

3
public 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 读入长和宽，输出矩形面积与周长
已知某商品原价与折扣（如 88 折），计算折后价并保留两位小数（printf 的 %.2f）

本篇小结#

JDK = 开发工具集；JVM 负责执行字节码，实现跨平台
javac 编译 → java 运行；IDEA 可以一键搞定
文件名必须与 public 类名一致；main 方法是固定入口
8 种基本类型 + String 引用类型；var 可自动推断
Scanner 处理键盘输入，用完记得 close()

下一篇：流程控制与方法——把逻辑组织成可复用的积木。

本系列为 Cyber先锋社原创教程，参考业界通用知识体系编写。

Java 入门教程（二）：语法基础与运算符

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

上一篇跑通了第一个程序，本篇夯实 Java 语法地基：类型系统、运算符、输入输出。Java 是强类型语言的典范——类型规则比 Python 严、比 C++ 更”啰嗦”但更统一。

一、注释与命名规范#

1
// 单行注释
2

3
/* 多行注释 */
4

5
/**
6
 * 文档注释（javadoc）：IDE 悬停提示、官方文档都靠它
7
 * @param a 加数
8
 * @return 两数之和
9
 */
10
public static int add(int a, int b) { return a + b; }

Java 命名惯例（社区铁律）：

元素	规范	示例
类名	大驼峰	`StudentManager`
方法/变量	小驼峰	`calcAverage`、`maxScore`
常量	全大写下划线	`MAX_SIZE`
包名	全小写	`com.club.utils`

二、变量与基本类型#

八大基本类型#

1
public class Types {
2
    public static void main(String[] args) {
3
        // 整数家族
4
        byte b = 127;                  // 1字节 ±128
5
        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 = '先';           // ✓ 中文也是 char
16
        boolean ok = true;             // true/false（不是 1/0！）
17

18
        // 类型大小永不变（跨平台一致，这是 Java 的卖点）
19
        System.out.println(Integer.SIZE / 8);    // 4 字节
20
    }
21
}

展开收起

Warning

与 C++ 不同：Java 的 boolean 不是整数，if (1) 直接编译错误；char 是 16 位 Unicode。

var 局部变量推断（Java 10+）#

1
var name = "小明";            // String
2
var age = 18;                  // int
3
var scores = new int[]{90, 85};   // int[]
4
// var x;                      // ❌ 必须初始化
5
// var 只能用于局部变量，不能用于字段和参数

常量#

1
public class Config {
2
    public static final double TAX_RATE = 0.13;    // 类级常量：final + static
3
    public static final int MAX_RETRY = 3;
4
}
5

6
final int LOCAL_MAX = 100;     // 局部常量：赋值后不可改
7
// LOCAL_MAX = 200;            // ❌ 编译错误

默认值（成员变量才有！）#

1
public class Demo {
2
    static int a;           // 0
3
    static double d;        // 0.0
4
    static boolean flag;    // false
5
    static String s;        // null（引用类型默认 null）
6
    // ⚠ 局部变量没有默认值，未初始化直接用 → 编译错误
7
}

三、类型转换#

自动转换（小 → 大，安全）#

1
int i = 100;
2
long l = i;         // ✓ int → long
3
double d = l;       // ✓ long → double
4
double d2 = 10;     // ✓ int 字面量直接给 double
5

6
char c = 'A';
7
int code = c;       // ✓ 65

强制转换（大 → 小，可能丢失）#

1
double pi = 3.99;
2
int truncated = (int) pi;       // 3（直接截断，不是四舍五入！）
3

4
long big = 10000000000L;
5
int overflow = (int) big;       // 1410065408（高位截断，结果诡异）
6

7
// 经典陷阱：两个 int 相除
8
System.out.println(7 / 2);          // 3（int 除法！）
9
System.out.println(7 / 2.0);        // 3.5（一侧 double 则 double）
10
System.out.println((double) 7 / 2); // 3.5（先转再除）

数值溢出行为#

1
int max = Integer.MAX_VALUE;
2
System.out.println(max + 1);    // -2147483648（静默回绕！C++ 是未定义，Java 规定为回绕）
3

4
long safe = (long) max + 1;     // ✓ 先升格再运算
5
// 大数运算用 long，再大用 java.math.BigInteger

四、运算符全解#

算术#

1
int a = 10, b = 3;
2

3
System.out.println(a + b);      // 13
4
System.out.println(a - b);      // 7
5
System.out.println(a * b);      // 30
6
System.out.println(a / b);      // 3   整除截断
7
System.out.println(a % b);      // 1   取模（Java 的 % 可用于负数与浮点）
8
System.out.println(-7 % 3);     // -1（余数符号跟被除数）
9
System.out.println(7.5 % 2);    // 1.5（浮点取模合法！C++ 不行）
10

11
// ++ 与 --
12
int i = 5;
13
System.out.println(i++);        // 5 先用后加
14
System.out.println(++i);        // 7 先加后用

关系与逻辑#

1
int a = 5, b = 10;
2

3
System.out.println(a > b);      // false
4

5
// 逻辑运算符：& && | || !
6
boolean r1 = (a > 0) && (b > 0);    // 短路与（推荐日常用）
7
boolean r2 = (a > 0) &  (b > 0);    // 非短路与（两边都算，位运算语义）
8
boolean r3 = (a > 0) || (b < 0);    // 短路或
9

10
// ⚠ 经典面试点：短路与否影响副作用
11
int x = 0;
12
boolean r = (x != 0) && (++x > 0);  // 左边 false，右边不执行
13
System.out.println(x);              // 0
14

15
// Java 特有：异或 ^
16
System.out.println(true ^ false);   // true

展开收起

位运算（与 C++ 一致）#

1
int a = 0b1010;
2

3
System.out.println(a & 0b0110);    // 2
4
System.out.println(a | 0b0101);    // 15
5
System.out.println(a ^ 0b1111);    // 5
6
System.out.println(~a);            // -11
7
System.out.println(a << 2);        // 40
8
System.out.println(a >> 1);        // 5  算术右移（补符号位）
9
System.out.println(-8 >>> 1);      // 2147483644 逻辑右移（Java 特有 >>>，补 0）

三元与 instanceof#

1
int age = 20;
2
String status = age >= 18 ? "成年" : "未成年";
3

4
// instanceof：判断引用类型（面向对象篇重用）
5
Object obj = "hello";
6
if (obj instanceof String) {
7
    System.out.println("长度: " + ((String) obj).length());
8
}
9

10
// Java 16+ 模式匹配版（免强转）
11
if (obj instanceof String s) {
12
    System.out.println("长度: " + s.length());
13
}

运算符优先级记忆#

! > 算术 > 比较 > & > ^ > | > && > || > 三元 > 赋值。拿不准就加括号。

五、输入与格式化输出#

Scanner 进阶#

1
import java.util.Scanner;
2

3
public 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() 冲掉。

printf 格式化#

1
double price = 9.87654;
2
int n = 42;
3

4
System.out.printf("两位小数: %.2f%n", price);     // 9.88
5
System.out.printf("宽度10右对齐: [%10.2f]%n", price);
6
System.out.printf("宽度10左对齐: [%-10.2f]%n", price);
7
System.out.printf("补零: %08d%n", n);             // 00000042
8
System.out.printf("千分位: %,d%n", 1234567890);   // 1,234,567,890
9
System.out.printf("百分比: %.1f%%%n", 0.856);     // 85.6%
10
System.out.printf("类型: %s / %d / %b / %c%n", "文本", 1, true, 'A');
11

12
// %n 是跨平台换行符；String.format 同款语法返回字符串
13
String s = String.format("排名 No.%03d", 7);

Math 工具类#

1
System.out.println(Math.abs(-5));       // 5
2
System.out.println(Math.max(3, 7));     // 7
3
System.out.println(Math.min(3, 7));     // 3
4
System.out.println(Math.sqrt(16));      // 4.0
5
System.out.println(Math.pow(2, 10));    // 1024.0
6
System.out.println(Math.round(3.5));    // 4（四舍五入，区别于强转截断）
7
System.out.println(Math.ceil(3.1));     // 4.0 向上
8
System.out.println(Math.floor(3.9));    // 3.0 向下
9
System.out.println(Math.random());      // [0,1) 随机

六、典型陷阱速查#

1
// 1. 整数除法
2
System.out.println((1 + 2) / 2);        // 1 不是 1.5
3

4
// 2. char 参与算术
5
char c = 'A';
6
System.out.println(c + 1);              // 66（int）
7
System.out.println((char)(c + 1));      // B
8

9
// 3. = 与 ==（编译器会拦大部分，但 boolean 变量场景要小心）
10
boolean done = false;
11
if (done = true) { }                    // ⚠ 合法但几乎必是 bug
12

13
// 4. 负数取模
14
System.out.println(-10 % 3);            // -1（跟被除数）
15

16
// 5. float 精度（金额别用 float/double！）
17
System.out.println(0.1 + 0.2 == 0.3);   // false
18
// 金额用 long 存"分"，或 java.math.BigDecimal

展开收起

小练习#

输入三角形三边，用海伦公式输出面积（保留 2 位小数，注意整数转 double）
输入秒数，格式化输出 X天X小时X分X秒
验证 (char)('a' + 3) 输出什么？写循环打印 a-z（char 与 int 的关系）
用位运算判断整数奇偶、交换两个 int（不用第三变量）
int 逆序输出各位数字（12345 → 5 4 3 2 1；循环 + % /）

本篇小结#

八大基本类型大小跨平台固定；整数字面量默认 int、小数默认 double
long 加 L、float 加 f；boolean 不是整数
自动转换小→大；强转大→小会截断；两个 int 相除必得 int
&&/|| 短路；>>> 是 Java 特有逻辑右移
Scanner 的 next/nextLine 混用要清残留；printf 与 String.format 同语法
金额远离浮点——用 long 分或 BigDecimal

下一篇：流程控制——分支、循环与 Java 的 switch 表达式。

本系列为 Cyber先锋社原创教程。类型转换的每个例子请上机验证，坑见一次胜过听十次。

Java 入门教程（三）：流程控制

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

Java 的流程控制与 C/C++ 同源，但更安全（编译器更严格），且 Java 14+ 引入了现代的 switch 表达式。本篇全覆盖，含经典练习。

一、分支#

if / else if / else#

1
import java.util.Scanner;
2

3
public 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++ 安全）。

传统 switch 语句#

1
public 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。

switch 表达式（Java 14+，现代首选）#

箭头语法：不贯穿、不用 break、可直接返回值：

1
public 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
}

展开收起

新语法三大优点：不贯穿、强制穷尽（编译器查漏）、能当表达式赋值。新代码一律用它。

三元运算符#

1
int a = 10, b = 20;
2
int max = a > b ? a : b;

二、循环#

while 与 do-while#

1
// 1~100 求和
2
int sum = 0, i = 1;
3
while (i <= 100) {
4
    sum += i;
5
    i++;
6
}
7
System.out.println(sum);      // 5050
8

9
// do-while：至少执行一次（菜单场景）
10
int choice;
11
do {
12
    System.out.println("1.开始 0.退出");
13
    // choice = 读入...
14
    choice = 0;               // 演示用
15
} while (choice != 0);

展开收起

for 经典三段式#

1
for (int i = 1; i <= 9; i++) {
2
    System.out.printf("%d ", i * i);
3
}
4

5
// 多变量版本
6
for (int i = 0, j = 10; i < j; i++, j--) {
7
    System.out.println(i + " " + j);
8
}
9

10
// 死循环
11
for (;;) { }
12
while (true) { }

增强 for（for-each）：遍历数组/集合#

1
int[] nums = {10, 20, 30};
2
for (int n : nums) {
3
    System.out.println(n);
4
}
5

6
String[] langs = {"Java", "Python", "C++"};
7
for (String lang : langs) {
8
    System.out.println(lang);
9
}

限制：拿不到下标、遍历中不能修改数组元素（只读便利）。

三、break / continue 与标签#

1
// 常规：作用于本层
2
for (int i = 0; i < 10; i++) {
3
    if (i == 5) break;            // 0~4
4
    if (i % 2 == 0) continue;     // 跳过偶数
5
    System.out.println(i);
6
}
7

8
// Java 特色：标签跳转（直接跳出多层循环，goto 的安全版）
9
outer:
10
for (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）。

四、经典练习#

1. 九九乘法表#

1
for (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
}

2. 质数判断与 100 内质数表#

1
static 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

9
public 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
}

展开收起

3. 水仙花数#

1
for (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 407
5
}

4. 菱形图案（嵌套循环的空间训练）#

1
int n = 5;    // 菱形半径
2
for (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
}

5. 猜数字（输入校验 + 循环）#

1
import java.util.Random;
2
import java.util.Scanner;
3

4
public class Guess {
5
    public static void main(String[] args) {
6
        Random rand = new Random();
7
        int answer = rand.nextInt(100) + 1;     // 1~100
8
        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 类（推荐）
2
import java.util.Random;
3
Random rand = new Random();
4
int n = rand.nextInt(100) + 1;       // 1~100
5
double d = rand.nextDouble();         // [0,1)
6
boolean b = rand.nextBoolean();
7

8
// 方式2：Math.random()
9
int m = (int)(Math.random() * 100) + 1;
10

11
// 固定种子 → 可复现（测试用）
12
Random seeded = new Random(42);

小练习#

输入一个整数，判断是否为回文数（12321 ✓；循环反转数字后比较）
求 1000 内所有”完数”（因子和等于自身，如 6=1+2+3）
用 switch 表达式输出某年某月的天数（注意闰年二月：(y%4==0&&y%100!=0)||y%400==0）
打印斐波那契数列前 20 项（for + 两个变量滚动）
二重循环求”3 个数字组合能组成多少个互不相同的三位数”（1、2、3、4）

本篇小结#

条件必须 boolean（if 笔误编译期拦截）；switch 支持 String 与枚举
switch 表达式（Java 14+）：箭头不贯穿、强制穷尽、可赋值——新代码首选
增强 for 遍历数组简洁但无下标
标签 break/continue 可直接跳出多层循环
hasNextInt 先验后读防输入崩溃

下一篇：方法与数组——Java 版的函数与第一批容器。

本系列为 Cyber先锋社原创教程。五个经典练习独立完成后再看参考，效果翻倍。

Java 入门教程（四）：方法与数组

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

Java 的函数叫方法（method），必须定义在类里；数组是 Java 最原始的容器。本篇讲透两者的规则与工具，为面向对象做准备。

一、方法#

基本结构#

1
public class MathUtils {
2

3
    // 修饰符 返回类型 方法名(参数列表)
4
    public static int add(int a, int b) {
5
        return a + b;
6
    }
7

8
    // 无返回值用 void
9
    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 只有值传递——传基本类型是拷贝值，传引用类型是拷贝”地址值”：

1
static void tryChange(int x) { x = 100; }              // 改副本，无效
2

3
static void changeElement(int[] arr) { arr[0] = 100; } // 通过地址改内容，有效！
4

5
static void changeRef(int[] arr) { arr = new int[]{9}; } // 改的是地址副本，无效
6

7
public static void main(String[] args) {
8
    int n = 5;
9
    tryChange(n);
10
    System.out.println(n);        // 5
11

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
}

展开收起

类比：引用类型传的是”门牌号复印件”——拿着复印件能进屋搬东西（改内容），但把复印件改成新地址不影响你手里的原件（改指向）。

重载（Overload）#

1
public static int    max(int a, int b)          { return a > b ? a : b; }
2
public static double max(double a, double b)    { return a > b ? a : b; }
3
public static int    max(int a, int b, int c)   { return max(max(a, b), c); }
4

5
max(3, 7);          // int 版
6
max(3.5, 2.5);      // double 版
7
max(1, 9, 4);       // 三参版

重载规则：参数个数/类型/顺序不同即可；仅返回值不同不行。JDK 的 System.out.println 有 10 个重载——这就是重载的日常。

可变参数（varargs）#

1
// 类型... 名字 = 语法糖，本质是数组
2
public static int sum(int... nums) {
3
    int total = 0;
4
    for (int n : nums) total += n;
5
    return total;
6
}
7

8
sum();              // 0
9
sum(1, 2);          // 3
10
sum(new int[]{1,2,3});  // 6（直接传数组也行）
11

12
// ⚠ 可变参数必须是最后一个参数
13
public static void log(String level, Object... args) { }

方法递归#

1
public static long factorial(int n) {
2
    if (n <= 1) return 1;
3
    return n * factorial(n - 1);
4
}
5
// factorial(20) 已接近 long 上限（选对类型！）

二、数组#

声明与初始化#

1
// 静态初始化（定长不可变！）
2
int[] scores = {90, 85, 78, 92, 66};
3
int[] primes = new int[]{2, 3, 5, 7};
4

5
// 动态初始化（定容，默认值填充）
6
int[] nums = new int[5];          // {0,0,0,0,0}
7
String[] names = new String[3];   // {null, null, null}
8

9
// 长度是属性（不是方法！）
10
System.out.println(scores.length);    // 5
11

12
// C 风格声明 int scores[] 也合法，但不推荐

Warning

Java 数组长度固定、越界访问抛 ArrayIndexOutOfBoundsException（运行期异常，比 C++ 裸数组安全）。要动态长度用 ArrayList（第六篇集合）。

遍历三式#

1
int[] v = {3, 1, 4, 1, 5};
2

3
// ① 经典下标
4
for (int i = 0; i < v.length; i++)
5
    System.out.println(i + ": " + v[i]);
6

7
// ② 增强 for
8
for (int n : v)
9
    System.out.println(n);
10

11
// ③ 带索引的函数式（Java 8+，尝鲜）
12
java.util.Arrays.stream(v)
13
    .forEach(n -> System.out.println(n));
14

15
// 求 max/min/sum
16
int max = v[0];
17
for (int n : v) if (n > max) max = n;
18

19
int sum = 0;
20
for (int n : v) sum += n;
21
System.out.printf("max=%d avg=%.1f%n", max, sum / (double) v.length);

展开收起

数组工具类 java.util.Arrays（必备！）#

1
import java.util.Arrays;
2

3
int[] v = {5, 3, 8, 1, 9};
4

5
// 打印（toString 解决"打印数组显示乱码地址"问题）
6
System.out.println(Arrays.toString(v));   // [5, 3, 8, 1, 9]
7

8
// 排序（原地）
9
Arrays.sort(v);                            // [1, 3, 5, 8, 9]
10

11
// 查找（必须先有序！返回下标，-1 = 没找到）
12
int idx = Arrays.binarySearch(v, 8);       // 3
13

14
// 填充
15
int[] filled = new int[5];
16
Arrays.fill(filled, 7);                    // [7,7,7,7,7]
17

18
// 拷贝（真正的复制，不是引用）
19
int[] copy = Arrays.copyOf(v, v.length);
20
int[] part = Arrays.copyOfRange(v, 1, 4);  // 下标 [1,4) 的子数组
21

22
// 比较（内容比较，== 比较的是地址！）
23
int[] a = {1, 2};
24
int[] b = {1, 2};
25
System.out.println(a == b);                    // false（两个对象）
26
System.out.println(Arrays.equals(a, b));       // true（内容相等）

展开收起

二维数组#

1
int[][] matrix = {
2
    {1, 2, 3},
3
    {4, 5, 6},
4
    {7, 8, 9},
5
};
6

7
System.out.println(matrix.length);       // 3（行数）
8
System.out.println(matrix[0].length);    // 3（列数）
9

10
// 遍历求和
11
int total = 0;
12
for (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 数组本质是"数组的数组"）
17
int[][] ragged = new int[3][];
18
ragged[0] = new int[1];
19
ragged[1] = new int[2];
20
ragged[2] = new int[3];
21

22
// 打印二维：deepToString
23
System.out.println(Arrays.deepToString(matrix));

展开收起

main 的 String[] args#

1
public class ArgsDemo {
2
    public static void main(String[] args) {
3
        // java ArgsDemo hello 42
4
        for (String arg : args)
5
            System.out.println(arg);       // hello \n 42
6
        // args 是命令行参数数组（不含类名）
7
    }
8
}

三、综合实战#

1. 数组统计分析器#

1
import java.util.Arrays;
2

3
public 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 == 1
28
                    ? 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
}

展开收起

2. 矩阵转置#

1
public 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)：合并两个有序数组为有序数组（归并思想）
模拟”双色球抽奖”：从 1~33 随机取 6 个不重复红球 + 1 个蓝球，Arrays.sort 后输出

本篇小结#

方法必须住类里；签名 = 名字 + 参数；仅返回值不同不构成重载
Java 只有值传递：传引用改内容有效、改指向无效
可变参数 int... 本质数组，必须放最后
数组定长、length 是属性、越界抛异常
Arrays 工具类五件套：toString / sort / binarySearch / copyOf / equals
二维数组是”数组的数组”，可不规则

下一篇：面向对象（上）——类、对象、构造方法与封装。

本系列为 Cyber先锋社原创教程。“值传递本质”的三个实验请务必亲手跑一遍。

Java 入门教程（五）：面向对象（上）——类与封装

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

Java 是纯面向对象语言——一切代码都在类里。本篇讲 OOP 第一支柱封装：类的设计规范、构造方法、this、static 与包管理。Java 的 OOP 比 C++ 更”强制”也更统一。

一、类与对象#

第一个正式的类#

1
public 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
}

展开收起

1
public 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 存的是它的引用（地址）；多个变量可引用同一对象。

1
Student a = new Student("小明", 18, 90);
2
Student b = a;               // b 和 a 指向同一个对象！
3
b.setAge(20);
4
System.out.println(a.getAge());   // 20
5
System.out.println(a == b);       // true（同一地址）

JavaBean 规范#

字段私有 + 公有 getter/setter + 无参构造——行业通用的数据类写法，IDE 与框架都认这个约定（IDEA 里 Alt+Insert 一键生成）。

二、this 关键字#

1
public 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

20
new Account("小明", 100).deposit(50).deposit(30);

展开收起

三、封装三私有一公开#

1
// 反例：字段公开
2
public class Bad {
3
    public double balance;          // 任何代码都能写 account.balance = -999
4
}
5

6
// 正例：私有字段 + 校验入口
7
public 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，外界只通过方法访问——所有修改必须经过你的检查，不变量（余额非负）由类自己守护。

四、static：属于类的成员#

1
public 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++;                        // 每创建一个 +1
14
    }
15

16
    // 静态方法：属于类，没有 this（不能访问实例成员！）
17
    public static int getCreatedCount() {
18
        // System.out.println(this.name);     // ❌ 编译错误，静态无 this
19
        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 只能用类名调起入口。

五、包与访问权限#

包（package）：类的目录组织#

1
// 文件 src/com/club/utils/MathUtils.java
2
package com.club.utils;                    // 第一行声明包（对应目录结构）
3

4
public class MathUtils {
5
    public static boolean isPrime(int n) { /* ... */ return true; }
6
}
7

8
// 使用方
9
import com.club.utils.MathUtils;           // 导入
10

11
public 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。

六、综合案例：图书借阅系统（封装版）#

1
import java.util.ArrayList;
2
import java.util.List;
3

4
public 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）
给 Student 加 compareTo 风格方法 betterThan(Student other) 按成绩比较，main 里造 3 个对象找学霸

本篇小结#

字段私有 + getter/setter + 无参构造 = JavaBean 规范
this 三用：区名字 / this(…) 链构造 / 返回自身链式调用
引用变量存地址；== 比地址、内容比较用 equals（第七篇详讲）
static 属于类；静态方法无 this 不能摸实例成员
四档权限：private → 默认 → protected → public
封装的本质：状态私有，修改必经校验

下一篇：面向对象（下）——继承、多态、接口与抽象类，Java OOP 的完全体。

本系列为 Cyber先锋社原创教程。IDEA 的 Alt+Insert（生成 getter/setter/构造）先练熟，生产力 ×10。

Java 入门教程（六）：面向对象（下）——继承、多态与接口

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

OOP 剩余两大支柱继承与多态，以及 Java 的招牌——接口。Spring 等主流框架的根基全在本篇。学完后你能读懂 JDK 源码结构和绝大多数 Java 项目的类设计。

一、继承#

extends 与 super#

1
// 父类
2
class 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 一个父类）
15
class 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

28
Dog d = new Dog("旺财", "柴犬");
29
d.eat();        // 继承的
30
d.fetch();      // 自己的

展开收起

构造顺序：父类构造先执行（super）→ 子类构造。不写 super(…) 时编译器默认补 super()（父类必须有无参构造，否则报错）。

方法重写（Override）#

1
class Cat extends Animal {
2
    public Cat(String name) { super(name); }
3

4
    @Override                          // 注解：让编译器检查重写合法性
5
    public void eat() {                // 方法签名与父类完全一致
6
        System.out.println(name + "：吃小鱼干");
7
    }
8
}

重写规则（两同两小一大）：

方法名、参数列表相同
返回值小于等于父类（相同或是子类型）
异常小于等于父类抛的
访问权限大于等于父类（父 public 子不能 protected）

@Override 必写——拼写错误、签名不匹配时编译器立刻报错。

二、多态#

向上转型与动态绑定#

1
Animal a1 = new Dog("旺财", "柴犬");    // 向上转型：子对象当父类型用
2
Animal a2 = new Cat("咪咪");
3

4
a1.eat();      // ？——调用谁的 eat？
5
a2.eat();
6
// 输出：旺财 在吃东西 / 咪咪：吃小鱼干
7
// dog 覆写了 eat → 运行期按真实对象类型绑定！
8
// a1.fetch();  ❌ 编译错误：Animal 类型看不见 Dog 特有方法

多态三条件：继承体系 + 方法重写 + 父类引用指向子类对象。

编译看左、运行看右：能调什么方法由引用类型（左边）决定，实际执行哪个版本由对象类型（右边）决定。

多态的威力：统一处理#

1
public 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 一行不改——开闭原则。

向下转型与 instanceof#

1
Animal a = new Dog("旺财", "柴犬");
2

3
if (a instanceof Dog) {              // 先判断再转（否则 ClassCastException）
4
    Dog d = (Dog) a;                 // 向下转型：恢复子类能力
5
    d.fetch();
6
}
7

8
// Java 16+ 模式匹配（一步到位）
9
if (a instanceof Dog d) {
10
    d.fetch();                       // d 已就绪
11
}

三、抽象类#

1
abstract class Shape {                      // abstract 类不能 new
2
    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

13
class Circle extends Shape {
14
    private final double r;
15
    public Circle(double r) { super("圆"); this.r = r; }
16

17
    @Override
18
    public double area() { return Math.PI * r * r; }
19
}
20

21
class 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
    @Override
26
    public double area() { return w * h; }
27
}
28

29
// Shape s = new Shape("x");   ❌ 抽象类不能实例化
30
Shape s = new Circle(2);
31
s.describe();

展开收起

抽象类定位：模板/半成品——提取公共部分（字段、实现），强制子类完成”填空”（抽象方法）。

四、接口（Java 的招牌）#

定义与实现#

1
// 接口：纯契约（方法默认 public abstract）
2
interface Comparable2<T> {
3
    int compareTo(T other);                 // 抽象方法
4
}
5

6
interface 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

20
interface Walker {
21
    void walk();
22
}
23

24
// 类可实现多个接口（多继承能力的替代品！）
25
class Duck implements Swimmer, Walker {
26
    @Override
27
    public void swim() { System.out.println("鸭子划水"); }
28
    @Override
29
    public void walk() { System.out.println("鸭子摇摆走"); }
30
}
31

32
Duck d = new Duck();
33
d.swim(); d.walk(); d.swimFast();          // 默认方法直接用
34
Swimmer.info();                             // 静态方法接口名调

展开收起

接口 vs 抽象类#

维度	抽象类	接口
关键词	`extends` 单继承	`implements` 多实现
字段	任意	只能 `public static final` 常量
构造方法	有	无
方法	抽象+具体	抽象+default+static
语义	“是什么”（is-a，模板）	“能做什么”（can-do，能力）

经验：定义”身份与模板”用抽象类（Animal）；定义”能力”用接口（Comparable、Runnable、Swimmer）——类可以同时是动物并能游泳能跑。

面向接口编程（框架思维）#

1
interface Storage {
2
    void save(String key, String value);
3
    String load(String key);
4
}
5

6
class 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

12
class FileStorage implements Storage {          // 换个实现...
13
    public void save(String k, String v) { /* 写文件 */ }
14
    public String load(String k) { return null; }
15
}
16

17
// 使用方只依赖接口——实现随换随用（这就是"解耦"）
18
public 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 三巨头#

所有类隐式继承 Object，三个方法必须会改写：

1
class Money {
2
    private final long cents;
3

4
    Money(long cents) { this.cents = cents; }
5

6
    // 1. equals：内容比较（== 才是引用比较）
7
    @Override
8
    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
    @Override
16
    public int hashCode() { return Long.hashCode(cents); }
17

18
    // 3. toString：打印友好
19
    @Override
20
    public String toString() { return "¥" + cents / 100.0; }
21
}
22

23
Money a = new Money(1050), b = new Money(1050);
24
System.out.println(a.equals(b));    // true
25
System.out.println(a);              // ¥10.5
26
// IDEA：Alt+Insert 一键生成三者，日常用工具生成

展开收起

Warning

只重写 equals 不重写 hashCode 是大坑——HashMap/HashSet 会”找不到”相等的对象。永远两个一起改。

六、final 与继承的边界#

1
final class Sealed { }              // final 类：禁止继承（如 String）
2
// class Sub extends Sealed {}      ❌
3

4
class Tool {
5
    public final void spec() { }    // final 方法：禁止重写
6
    public static void main(String[] args) {
7
        final int X = 10;           // final 变量：常量
8
    }
9
}

七、综合实战：图形面积系统（接口版）#

1
import java.util.List;
2

3
interface Area {
4
    double area();
5
    // 接口 default 提供组合逻辑
6
    default double areaDifference(Area other) {
7
        return this.area() - other.area();
8
    }
9
}
10

11
class 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

18
class 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

25
public 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> 实现”按成绩降序”比较器（第六篇预告集合排序）
（概念）重载与重写的区别？接口与抽象类的区别？编译看左运行看右什么意思？

本篇小结#

单继承 extends；super 必须第一行；构造先父后子
重写遵循”两同两小一大”；@Override 必写
多态 = 继承 + 重写 + 向上转型；编译看左、运行看右
抽象类是模板，接口是能力（可多实现）；面向接口编程 = 解耦
equals/hashCode/toString 三件套成对改写
final 可锁类/方法/变量

下一篇：常用类库——String 深入、包装类、日期时间与数学工具。

本系列为 Cyber先锋社原创教程。接口优先的思维方式是读懂 Spring 全家源码的钥匙。

Java 入门教程（七）：核心类库——String、包装类与常用工具

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

日常 Java 开发 80% 的时间在和字符串、包装类、日期打交道。本篇把 JDK 自带的核心类库讲透——特别是那些”面试必考、实战必踩”的坑。

一、String 深入#

不可变性（核心！）#

1
String s = "hello";
2
s.toUpperCase();          // 产生新对象 "HELLO"
3
System.out.println(s);    // hello——原串纹丝不动！
4

5
s = s.toUpperCase();      // ✓ 必须接住返回值

String 内部的字符数组是 final 的——任何”修改”操作都返回新对象。好处：线程安全、可作 HashMap 的键、字符串常量池可复用。

常量池与 == 的坑（面试 TOP3）#

1
// 字面量赋值：进常量池，同字面量共享一个对象
2
String a = "hello";
3
String b = "hello";
4
System.out.println(a == b);         // true（常量池同一对象）
5

6
// new 出来的：堆里新对象
7
String c = new String("hello");
8
System.out.println(a == c);         // false（地址不同！）
9
System.out.println(a.equals(c));    // true（内容相同）
10

11
// 拼接陷阱：编译期能确定的进池，运行期拼接产生新对象
12
String d = "hel" + "lo";            // 编译期合并
13
System.out.println(a == d);         // true
14

15
String part = "lo";
16
String e = "hel" + part;            // 运行期拼接
17
System.out.println(a == e);         // false！
18
System.out.println(a == e.intern());// true（intern 取常量池版本）

展开收起

铁律：字符串内容比较永远用 equals，== 只用来判断”是不是同一个对象”。

常用方法全家桶#

1
String s = "  Hello, Java World  ";
2

3
System.out.println(s.length());              // 20
4
System.out.println(s.trim());                // 去两端空白 "Hello, Java World"
5
System.out.println(s.strip());               // Java 11+（还能处理全角空格）
6

7
System.out.println(s.charAt(1));             // 'H'
8
System.out.println(s.indexOf("Java"));       // 8
9
System.out.println(s.contains("Java"));      // true
10
System.out.println(s.startsWith("  He"));    // true
11
System.out.println(s.endsWith("  "));        // true
12

13
System.out.println(s.substring(8, 12));      // "Java"（含头不含尾）
14
System.out.println(s.replace("Java", "Python"));
15
System.out.println("a,b,c".split(",").length);       // 3
16
System.out.println("ab".repeat(3));          // ababab（Java 11+）
17

18
System.out.println("abc".toUpperCase());
19
System.out.println("ABC".toLowerCase());
20
System.out.println("".isEmpty());            // true
21
System.out.println("  ".isBlank());          // true（Java 11+ 纯空白）
22
System.out.println(String.join("-", "2026", "10", "29"));  // 2026-10-29
23

24
// 文本块（Java 15+）：多行字符串
25
String json = """
26
        {
27
          "name": "小明",
28
          "age": 18
29
        }""";

展开收起

判等空串与 null 的正确姿势#

1
String input = /* 可能为 null */ null;
2

3
// ❌ if (input.equals("")) → NPE 空指针
4
// ✅ 常量放前面 / 先判 null
5
if (input == null || input.isEmpty()) { }
6
if (input != null && "yes".equals(input)) { }    // 常量在前防 NPE

StringBuilder：循环拼接必用#

1
// ❌ 循环里 + 拼接：每次循环产生新 String 对象，O(n²)
2
String result = "";
3
for (int i = 0; i < 10000; i++) {
4
    result += i;
5
}
6

7
// ✅ StringBuilder：内部可变字符数组，O(n)
8
StringBuilder sb = new StringBuilder();
9
for (int i = 0; i < 10000; i++) {
10
    sb.append(i);
11
}
12
String fast = sb.toString();
13

14
sb.append("-").append(42).append("!");    // 链式
15
sb.insert(0, "头");
16
sb.deleteCharAt(sb.length() - 1);
17
sb.reverse();                             // 反转

展开收起

类	可变	线程安全	场景
String	✗	✓（不可变天然安全）	绝大多数场景
StringBuilder	✓	✗	单线程拼接（默认）
StringBuffer	✓	✓（synchronized）	多线程（如今少见）

二、包装类#

基本类型 ↔ 包装类#

1
int → Integer     double → Double     char → Character
2
long → Long       boolean → Boolean  ...（其余同名首字母大写）
3

4
// 自动装箱/拆箱（编译器语法糖）
5
Integer boxed = 42;            // 装箱：Integer.valueOf(42)
6
int raw = boxed;               // 拆箱：boxed.intValue()
7

8
// 手动转换
9
Integer m = Integer.valueOf(42);
10
int n = m.intValue();
11

12
// 字符串互转（高频！）
13
int age = Integer.parseInt("18");          // String → int
14
double d = Double.parseDouble("3.14");
15
String s = String.valueOf(42);             // 数 → String
16
String t = Integer.toString(42);

展开收起

Integer 缓存陷阱（面试 TOP1）#

1
Integer a = 127, b = 127;
2
System.out.println(a == b);        // true（-128~127 有缓存，同一对象）
3

4
Integer c = 128, d = 128;
5
System.out.println(c == d);        // false！超出缓存范围，各自 new
6
System.out.println(c.equals(d));   // true
7

8
// 铁律：包装类比较一律 equals

Warning

拆箱空指针：

1
Integer score = null;
2
int s = score;        // ❌ NullPointerException（null 拆箱炸）

数据库字段/外部输入可能为 null 时，用 Integer 并先判空。

三、BigDecimal：金额计算唯一正解#

1
import java.math.BigDecimal;
2
import java.math.RoundingMode;
3

4
// ⚠ 别用 new BigDecimal(0.1)——浮点误差原样带入！
5
BigDecimal a = new BigDecimal("0.1");           // ✓ 用字符串构造
6
BigDecimal b = BigDecimal.valueOf(0.1);         // ✓ 或 valueOf
7

8
System.out.println(a.add(b));                    // 0.2（精确！）
9
System.out.println(new BigDecimal("10").divide(
10
        new BigDecimal("3"), 2, RoundingMode.HALF_UP));   // 3.33
11

12
// 比较用 compareTo（equals 会连精度一起比：1.0 != 1.00）
13
new BigDecimal("1.0").compareTo(new BigDecimal("1.00"));  // 0（相等）
14
new BigDecimal("1.0").equals(new BigDecimal("1.00"));     // false！
15

16
// 金额展示
17
BigDecimal price = new BigDecimal("99.999");
18
System.out.println(price.setScale(2, RoundingMode.HALF_UP));   // 100.00

展开收起

四、日期时间（java.time，Java 8+）#

老的 Date/SimpleDateFormat 有线程安全与设计问题，新项目一律用 java.time。

1
import java.time.*;
2
import java.time.format.DateTimeFormatter;
3

4
// —— 三大核心类型 ——
5
LocalDate date = LocalDate.now();               // 2026-10-29（仅日期）
6
LocalTime time = LocalTime.now();               // 12:30:45.123（仅时间）
7
LocalDateTime dt = LocalDateTime.now();         // 日期+时间
8

9
LocalDate birthday = LocalDate.of(2006, 6, 1);
10
LocalDateTime specific = LocalDateTime.of(2026, 10, 29, 14, 30);
11

12
// —— 格式化与解析 ——
13
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
14
System.out.println(dt.format(fmt));              // 2026年10月29日 12:30:45
15
LocalDateTime parsed = LocalDateTime.parse("2026-10-29 14:30:00",
16
        DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
17

18
// —— 计算 ——
19
LocalDate tomorrow = date.plusDays(1);
20
LocalDate lastMonth = date.minusMonths(1);
21
LocalDate nextYearSameDay = date.plusYears(1);
22

23
Period age = Period.between(birthday, date);
24
System.out.printf("%d 岁 %d 个月%n", age.getYears(), age.getMonths());
25

26
long days = java.time.temporal.ChronoUnit.DAYS.between(birthday, date);
27
System.out.println("活了 " + days + " 天");
28

29
// 判断
30
System.out.println(date.isBefore(tomorrow));     // true
31
System.out.println(date.isLeapYear());           // 闰年判断
32
System.out.println(date.getDayOfWeek());         // THURSDAY
33

34
// —— 时间戳互转 ——
35
Instant now = Instant.now();                     // UTC 时间戳
36
long epochMilli = now.toEpochMilli();            // 毫秒时间戳

展开收起

五、其他高频工具#

Objects 工具类#

1
import java.util.Objects;
2

3
Objects.equals(a, b);            // null 安全的判等
4
Objects.isNull(x);               // x == null
5
Objects.requireNonNull(param, "参数不能为空");   // 快速判空抛 NPE
6
Objects.hashCode(x);

数组与集合桥梁（预热下一篇）#

1
int[] arr = {3, 1, 4};
2
int[] copy = Arrays.copyOf(arr, arr.length);
3
List<Integer> list = Arrays.asList(1, 2, 3);       // 固定长度视图
4
List<Integer> mutable = new ArrayList<>(List.of(1, 2, 3));

六、综合案例：会员账单生成器#

1
import java.math.BigDecimal;
2
import java.math.RoundingMode;
3
import java.time.LocalDateTime;
4
import java.time.format.DateTimeFormatter;
5
import java.util.StringJoiner;
6

7
public 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
}

展开收起

小练习#

统计字符串中每个字符出现次数，按次数降序输出（Map + 排序预热）
反转字符串中的单词顺序（“hello java world” → “world java hello”；split + StringBuilder）
验证 Integer 缓存：循环比较 -200~200 的装箱 == 结果，统计 true 的范围
用 BigDecimal 计算”等额本息月供”：本金 100 万、年利率 3.6%、30 年（公式查资料，重点练 API）
写”倒计时日历”：输入目标日期字符串，输出距今多少天（LocalDate + ChronoUnit）

本篇小结#

String 不可变；内容比较永远 equals；常量池与 == 的关系要懂
循环拼接用 StringBuilder；StringJoiner 处理分隔符
包装类比较一律 equals（Integer 缓存 -128~127）；拆箱 null 会 NPE
金额计算只信 BigDecimal（字符串构造 + compareTo 比较）
日期新 API：LocalDateTime + DateTimeFormatter + Period/ChronoUnit

下一篇：集合框架——ArrayList/HashMap 全家桶，Java 数据处理的发动机。

本系列为 Cyber先锋社原创教程。String 的 == 陷阱与 Integer 缓存是笔试最爱，亲手跑一遍记住结论。

Java 入门教程（八）：集合框架

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

数组定长，集合（Collection）动态——Java 集合框架是日常开发的绝对主力（前几篇已偷偷用过 ArrayList）。本篇系统讲透 List/Set/Map 三大体系与排序方案。

一、集合体系全景#

1
Collection（接口）
2
├── List   有序可重复
3
│   ├── ArrayList      动态数组（默认选择）
4
│   └── LinkedList     双向链表
5
├── Set    不可重复
6
│   ├── HashSet        哈希（最快，无序）
7
│   ├── LinkedHashSet  哈希 + 保插入序
8
│   └── TreeSet        红黑树（自动排序）
9
└── Queue  队列（了解）
10

11
Map（接口，独立于 Collection）
12
├── HashMap           哈希键值对（默认选择）
13
├── LinkedHashMap     保插入序
14
└── TreeMap           按键排序

泛型 <T>：集合声明元素类型，编译期防类型错误——List<String> 只能装 String。

二、List#

ArrayList（默认选择）#

1
import java.util.ArrayList;
2
import java.util.List;
3

4
List<String> langs = new ArrayList<>();
5

6
// —— 增 ——
7
langs.add("Java");                       // 尾部追加
8
langs.add(0, "C++");                     // 指定位置（O(n)）
9
langs.addAll(List.of("Python", "Go"));   // 批量
10

11
// —— 删 ——
12
langs.remove("Go");                      // 按对象删第一个
13
langs.remove(0);                         // 按下标删（返回被删元素）
14
langs.removeIf(s -> s.startsWith("P"));  // 条件删除（Java 8+）
15

16
// —— 改查 ——
17
langs.set(0, "Java17");
18
String first = langs.get(0);             // O(1) 随机访问
19
System.out.println(langs.contains("C++"));
20
System.out.println(langs.indexOf("Java"));
21
System.out.println(langs.size());
22
System.out.println(langs.isEmpty());
23

24
// —— 遍历 ——
25
for (String lang : langs) { }                    // 增强 for
26
for (int i = 0; i < langs.size(); i++) { }       // 下标
27
langs.forEach(s -> System.out.println(s));       // 函数式
28

29
// —— 不可变集合（Java 9+）——
30
List<String> frozen = List.of("a", "b");         // 不可增删改！

展开收起

ArrayList vs LinkedList#

	ArrayList	LinkedList
随机访问	O(1)	O(n)
尾部增删	均摊 O(1)	O(1)
中间增删	O(n)	定位 O(n) + 修改 O(1)
实践建议	99% 场景	极少胜出

安全删除：ConcurrentModificationException#

1
List<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
// ✅ 三种正确姿势
7
nums.removeIf(n -> n % 2 == 0);                       // ① 条件删除（最简）
8
for (Iterator<Integer> it = nums.iterator(); it.hasNext(); ) {   // ② 迭代器
9
    if (it.next() % 2 == 0) it.remove();
10
}
11
// ③ 倒序下标循环（正序会跳元素）

三、Set#

1
import java.util.*;
2

3
// HashSet：去重最快（依赖 hashCode/equals）
4
Set<String> tags = new HashSet<>();
5
tags.add("java");
6
tags.add("python");
7
tags.add("java");                         // 重复添加被忽略
8
System.out.println(tags.size());          // 2
9
System.out.println(tags.contains("java")); // true
10

11
// 列表去重一行流
12
List<Integer> dup = new ArrayList<>(List.of(3, 1, 3, 2, 1));
13
Set<Integer> uniq = new LinkedHashSet<>(dup);    // 保序去重
14
System.out.println(uniq);                 // [3, 1, 2]
15

16
// TreeSet：自动排序
17
Set<Integer> sorted = new TreeSet<>(List.of(5, 1, 4));
18
System.out.println(sorted);               // [1, 4, 5]
19
// 首尾与范围
20
TreeSet<Integer> ts = new TreeSet<>(List.of(1, 3, 5, 7, 9));
21
System.out.println(ts.first() + " " + ts.last());   // 1 9
22
System.out.println(ts.headSet(5));       // [1, 3]（小于5）
23
System.out.println(ts.tailSet(5));       // [5, 7, 9]
24
System.out.println(ts.floor(6));         // 5（≤6 的最大）

展开收起

自定义对象入 HashSet/HashMap 的前提：正确重写 hashCode + equals（第六篇）——忘了重写，“相等”的两个对象会被当成两个存两份。

四、Map#

HashMap（默认选择）#

1
import java.util.HashMap;
2
import java.util.Map;
3

4
Map<String, Integer> ages = new HashMap<>();
5

6
// —— 增改 ——
7
ages.put("小明", 18);                     // 不存在则增，存在则改（返回旧值！）
8
ages.putIfAbsent("小红", 17);             // 不存在才放
9
ages.put("小明", 19);                     // 覆盖为 19
10

11
// —— 查 ——
12
int age = ages.get("小明");               // 19
13
Integer none = ages.get("不存在");        // null
14
int def = ages.getOrDefault("不存在", 0); // 0（推荐！防 null）
15

16
System.out.println(ages.containsKey("小明"));
17
System.out.println(ages.containsValue(19));
18

19
// —— 删 ——
20
ages.remove("小红");
21
ages.remove("小明", 19);                  // 键值都对上才删
22

23
// —— 遍历三式 ——
24
for (String key : ages.keySet()) { }                  // 遍历键
25
for (Integer val : ages.values()) { }                 // 遍历值
26
for (Map.Entry<String, Integer> e : ages.entrySet()) // 键值对（最常用）
27
    System.out.println(e.getKey() + " = " + e.getValue());
28

29
// Java 8+ 函数式遍历
30
ages.forEach((k, v) -> System.out.println(k + ":" + v));
31

32
// —— 统计利器 ——
33
ages.merge("小明", 1, Integer::sum);      // 计数器模式：旧值+1
34
System.out.println(ages);                 // {小明=20}
35
ages.computeIfAbsent("列表", k -> new java.util.ArrayList<String>())
36
     .add("元素");                        // 多值 Map 的构建块

展开收起

merge 计数器（词频统计一行核心）#

1
String[] words = "the quick the lazy the dog".split(" ");
2
Map<String, Integer> freq = new HashMap<>();
3
for (String w : words) {
4
    freq.merge(w, 1, Integer::sum);       // 没有则放1，有则 +1
5
}
6
System.out.println(freq);                 // {the=3, quick=1, lazy=1, dog=1}

HashMap vs TreeMap vs LinkedHashMap#

	HashMap	LinkedHashMap	TreeMap
查找	O(1)	O(1)	O(log n)
顺序	无	插入序	键排序
场景	默认	需保序（LRU）	范围查询/排序遍历

五、排序：Comparable 与 Comparator#

Comparable：自然顺序（类自己定义）#

1
class 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
    @Override
8
    public int compareTo(Student o) {
9
        return Integer.compare(this.score, o.score);   // 升序（反过来即降序）
10
    }
11

12
    @Override
13
    public String toString() { return name + ":" + score; }
14
}

Comparator：外部策略（灵活多变）#

1
import java.util.*;
2

3
List<Student> st = new ArrayList<>(List.of(
4
        new Student("小明", 90), new Student("小红", 92),
5
        new Student("小刚", 85)));
6

7
// 策略1：按分数降序（匿名内部类老写法 → lambda 新写法）
8
st.sort((a, b) -> b.score - a.score);
9
st.sort(Comparator.comparingInt((Student s) -> s.score).reversed());
10

11
// 策略2：按姓名排序
12
st.sort(Comparator.comparing(s -> s.name));
13

14
// 策略3：多级排序（分数降序，同分按姓名升序）
15
st.sort(Comparator.comparingInt((Student s) -> s.score).reversed()
16
                  .thenComparing(s -> s.name));
17

18
System.out.println(st);   // [小红:92, 小明:90, 小刚:85]

展开收起

选择：类的”天生顺序”用 Comparable；临时/多种排序策略用 Comparator（组合万岁）。

Collections 工具类#

1
Collections.sort(list);                 // = list.sort(null)
2
Collections.reverse(list);
3
Collections.shuffle(list);              // 随机打乱
4
Collections.max(list);
5
Collections.frequency(list, "a");       // 出现次数
6
Collections.swap(list, 0, 1);
7
Collections.unmodifiableList(list);     // 不可变视图

六、综合案例：学生成绩管理系统#

1
import java.util.*;
2
import java.util.stream.Collectors;
3

4
public 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`

小练习#

词频统计 Top3：按次数降序、同次数按字典序（entrySet 搬进 List 多级排序）
两个班级名单求：并集（去重）、交集、只在一班的人
用 Map<String, List<String>> 实现”分组通讯录”：录入若干 (姓名, 分组)，按组输出
模拟抽签：ArrayList 装 30 人，Collections.shuffle 后取前 5 名（TreeSet 记录已中签防重复）
给第四篇的 merge(int[] a, int[] b) 改用 List<Integer> 实现，对比两种容器的代码差异

本篇小结#

List 有序可重复（ArrayList 默认）；Set 去重；Map 键值对
遍历中删除用 removeIf / 迭代器，防 fail-fast
自定义对象进 HashSet/HashMap：hashCode + equals 成对重写
merge/computeIfAbsent 是计数与分组的黄金搭档
Comparable 定天生序，Comparator 定策略序（comparing/reversed/thenComparing）
List.of 系列做不可变集合

下一篇：异常体系——try/catch 全解与自定义异常。

本系列为 Cyber先锋社原创教程。merge 计数器 + computeIfAbsent 分组 = 集合实战双绝，务必掌握。

Java 入门教程（九）：异常处理

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

Java 的异常体系是所有语言里最”操心”的——编译器强制你处理部分异常。本篇讲透分类、语法、资源管理与设计原则。

一、异常体系#

1
Throwable
2
├── Error                  ← 严重错误，程序管不了（OutOfMemoryError、StackOverflowError）
3
└── Exception
4
    ├── RuntimeException   ← 非受检异常（unchecked）：编译器不强制处理
5
    │   ├── NullPointerException        空指针
6
    │   ├── ArrayIndexOutOfBoundsException
7
    │   ├── ArithmeticException        除零（整数）
8
    │   ├── ClassCastException         强转失败
9
    │   ├── NumberFormatException     parseInt("abc")
10
    │   └── IllegalArgumentException   参数非法
11
    └── 其他 Exception    ← 受检异常（checked）：编译器强制 try 或 throws
12
        ├── IOException
13
        ├── SQLException
14
        └── FileNotFoundException

受检 vs 非受检：

1
// 受检异常：不处理 → 编译不过
2
public void readFile() {
3
    FileReader f = new FileReader("a.txt");   // ❌ 编译错误：未处理的 FileNotFoundException
4
}
5

6
// 非受检异常：处理与否自愿（通常是程序 bug 的信号）
7
public int div(int a, int b) {
8
    return a / b;      // 可能 ArithmeticException，但不强制处理
9
}

二、try / catch / finally#

基本结构#

1
public class ExceptDemo {
2
    static int parse(String s) {
3
        return Integer.parseInt(s);       // 可能 NumberFormatException
4
    }
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
}

展开收起

执行规则：

try 中抛出位置之后的代码不执行，直接跳到匹配的 catch
catch 按顺序匹配，父类必须放后面（catch (Exception) 放第一会”吃掉”一切并导致后面不可达的编译错误）
finally 无论如何都执行：正常结束、异常、甚至 try 里有 return

1
static int mystery() {
2
    try {
3
        return 1;
4
    } finally {
5
        System.out.println("finally 还是执行了！");   // 先打印，再 return 1
6
    }
7
}

多异常合并捕获（Java 7+）#

1
try {
2
    // ...
3
} catch (IOException | SQLException e) {      // 竖线合并
4
    log(e);
5
}

获取异常信息#

1
catch (Exception e) {
2
    e.getMessage();           // 简短描述
3
    e.toString();             // 类名 + 描述
4
    e.printStackTrace();      // 完整堆栈（调试用，别用于生产日志）
5
}

三、throw 与 throws#

1
// throws：声明"本方法可能抛出这些异常，调用者负责"
2
public static void setAge(int age) throws IllegalArgumentException {
3
    if (age < 0 || age > 150) {
4
        // throw：真正抛出异常对象
5
        throw new IllegalArgumentException("年龄非法: " + age);
6
    }
7
}
8

9
// 自定义受检异常：继承 Exception
10
class 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

20
public 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
// 调用方
32
public 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.0
39
    }
40
}

展开收起

受检/非受检的选型：调用方有能力恢复的（文件不存在→提示重选）→ 受检；程序 bug（空指针、参数错误）→ 非受检 RuntimeException，让它炸出来好修。

四、try-with-resources：资源管理正解#

传统 finally 关资源的啰嗦#

1
// 老写法：嵌套深、易漏
2
FileReader fr = null;
3
try {
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
}

try-with-resources（Java 7+，必用）#

1
// 实现了 AutoCloseable 的资源放 try(...) 里，自动 close（哪怕抛异常）
2
try (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
// 异常链：底层异常包装成业务异常，保留根因
2
public 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

11
class ConfigException extends RuntimeException {
12
    ConfigException(String msg, Throwable cause) {
13
        super(msg, cause);           // cause 保留在堆栈里
14
    }
15
}
16

17
// 打印时看到 Caused by: ... 链条，定位根因

展开收起

六、最佳实践与常见误区#

✅ 该做的#

1
// 1. 精确捕获，最小范围
2
try {
3
    int n = Integer.parseInt(input);
4
} catch (NumberFormatException e) { /* 只包可能出错的行 */ }
5

6
// 2. 捕获后要么处理、要么转换后抛出，别吞
7
try { ... }
8
catch (IOException e) {
9
    log.error("导入失败", e);
10
    throw new ImportException("数据导入失败", e);   // 转成语义化异常上抛
11
}
12

13
// 3. finally 里别写 return（会覆盖 try 的返回值，极度迷惑）

❌ 别做的#

1
// 1. 空 catch 吞异常（出 bug 无迹可寻）
2
try { dangerous(); } catch (Exception e) { }        // 🔥 火灾隐患
3

4
// 2. 捕获 Error / 用异常控制正常流程
5
for (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.requireNonNull
2
public void transfer(Account to, double amount) {
3
    Objects.requireNonNull(to, "目标账户不能为空");
4
    if (amount <= 0) throw new IllegalArgumentException("金额必须为正");
5
    // ... 业务在可靠的输入上运行
6
}

七、实战：健壮的配置读取器#

1
import java.io.IOException;
2
import java.io.InputStream;
3
import java.util.Properties;
4

5
public 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.class
15
                .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 里捕获处理
用 try-with-resources 读文本文件：文件不存在时给出友好提示（FileNotFoundException 分支）
实现 safeParse(String[] args, int index)：下标越界与格式错误都返回默认值 0 并打印警告
写三层调用 main → service → dao，dao 抛 IOException，service 包装成 ServiceException（带 cause），main 捕获打印完整链（观察 Caused by）
（概念）受检与非受检异常的区别？finally 一定会执行吗（System.exit 呢）？

本篇小结#

Error 不救、受检异常必须处理、非受检是 bug 信号
catch 子类在前父类在后；finally 无条件执行
throw 抛对象、throws 声明甩锅；自定义异常继承 Exception（受检）或 RuntimeException（非受检）
资源管理一律 try-with-resources
异常链保留 Caused by；空 catch 与 printStackTrace 是大忌
早抛晚捕、精确捕获、fail fast

下一篇：文件 IO 与序列化——让数据落盘。

本系列为 Cyber先锋社原创教程。“健壮配置读取器”是框架源码里的标准套路，读懂它。

Java 入门教程（十）：文件 IO 与 NIO

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

让数据活过进程的生命周期——读写文件。Java IO 类库庞大（几十个类），但日常 90% 的需求靠 Files 工具类 + 缓冲流就能解决。本篇按”现代优先”的路线讲。

一、File 与 Path#

1
import java.io.File;
2
import java.nio.file.*;       // NIO（New IO，Java 7+，推荐）
3

4
// 老牌 File
5
File f = new File("data/demo.txt");
6
f.exists();
7
f.isFile(); f.isDirectory();
8
f.length();                  // 字节数
9
f.delete();
10

11
// 现代 Path（推荐）
12
Path p = Path.of("data", "demo.txt");        // 自动拼路径（跨平台分隔符）
13
System.out.println(p.getFileName());          // demo.txt
14
System.out.println(p.toAbsolutePath());       // /Users/xxx/项目/data/demo.txt
15

16
Files.exists(p);
17
Files.size(p);
18
Files.createDirectories(Path.of("a/b/c"));    // 递归建目录
19
Files.delete(p);                              // 删除（不存在抛异常）
20
Files.copy(Path.of("src"), Path.of("dst"), StandardCopyOption.REPLACE_EXISTING);
21
Files.move(src, dst);

展开收起

二、Files 工具类：一行流（日常首选）#

1
import java.nio.file.Files;
2
import java.nio.file.Path;
3
import java.util.List;
4
import java.io.IOException;
5

6
Path file = Path.of("notes.txt");
7

8
// —— 文本全家桶 ——
9
Files.writeString(file, "第一行\n", StandardOpenOption.CREATE);   // 覆盖写
10
Files.writeString(file, "追加的一行\n",
11
        StandardOpenOption.CREATE, StandardOpenOption.APPEND);     // 追加写
12
Files.writeString(file, "第三行\n", StandardOpenOption.APPEND);
13

14
String all = Files.readString(file);                  // 一口气读完
15
System.out.println(all);
16

17
List<String> lines = Files.readAllLines(file);        // 按行读进 List
18
for (String line : lines)
19
    System.out.println("> " + line);
20

21
// 流式逐行（大文件省内存）
22
try (var stream = Files.lines(file)) {
23
    stream.filter(l -> l.contains("一"))
24
          .forEach(System.out::println);
25
}
26

27
// —— 字节读（图片等二进制）——
28
byte[] bytes = Files.readAllBytes(Path.of("icon.png"));
29
Files.write(Path.of("copy.png"), bytes);
30

31
// —— 遍历目录树 ——
32
try (var walk = Files.walk(Path.of("."))) {           // 递归所有子目录
33
    walk.filter(f -> f.toString().endsWith(".java"))
34
        .limit(5)
35
        .forEach(System.out::println);
36
}

展开收起

Tip

小文件（配置、日志、CSV）直接 Files 一行流；大文件用流式 Files.lines；两者都自动配 try-with-resources 最稳。

三、经典 IO 流体系（读得懂老代码）#

体系图#

1
字节流（byte）              字符流（char，文本专用）
2
InputStream                 Reader
3
├── FileInputStream         ├── FileReader
4
└── BufferedInputStream ←── └── BufferedReader（缓冲，性能关键）
5
OutputStream                Writer
6
├── FileOutputStream        ├── FileWriter
7
└── BufferedOutputStream    └── BufferedWriter / PrintWriter

选择口诀：文本用字符流、二进制用字节流、永远套缓冲。

字符读写模板#

1
import java.io.*;
2
import java.util.Scanner;
3

4
public 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：
3
try (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（又一个用它的理由）
10
Files.readString(file, java.nio.charset.StandardCharsets.UTF_8);

四、对象序列化（了解）#

对象 ↔ 字节的相互转换，用于暂存或网络传输：

1
import java.io.*;
2

3
class 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

11
public 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);   // 小明 / null
26
        }
27
    }
28
}

展开收起

现代项目更多用 JSON（Jackson/Gson）替代原生序列化——可读、跨语言。原生序列化主要用于面试与理解机制。

五、综合实战：CSV 通讯录（文件持久化）#

1
import java.io.IOException;
2
import java.nio.charset.StandardCharsets;
3
import java.nio.file.Files;
4
import java.nio.file.Path;
5
import java.nio.file.StandardOpenOption;
6
import java.util.ArrayList;
7
import java.util.List;
8
import java.util.StringJoiner;
9

10
public 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 过滤、启动加载 + 变更即存——把它扩展成命令行交互就是毕业设计级作品。

六、IO 选型决策#

场景	方案
小文本读写	`Files.readString` / `writeString`
逐行处理大文本	`Files.lines`（流式）
按行写/格式化输出	`PrintWriter` + 缓冲
读数字等 token	`Scanner`
二进制（图片）	`Files.readAllBytes` / 字节流
遍历目录树	`Files.walk`
对象持久化	JSON 库（实战）/ Serializable（了解）

小练习#

统计文本文件：行数、字符数、最长的一行
合并多个日志文件为一个大文件（Files.readAllLines + write 追加）
找出某目录下所有大于 1MB 的文件并按大小排序输出（Files.walk + Files.size）
给通讯录加 update 命令与”导出为可读文本报表”功能
简易”日记本”：write 内容 追加带时间戳的一行，list 显示全部，grep 关键词 过滤

本篇小结#

Path + Files 是现代首选：readString/writeString/readAllLines/lines/walk
流体系：文本字符流、二进制字节流、必套缓冲
编码显式 UTF-8，告别乱码；try-with-resources 管所有流
transient 排除敏感字段；实战持久化用 JSON 更香
启动加载 + 变更即存 = 最简持久化模型

下一篇：多线程与 Lambda——并发的世界与函数式语法糖。

本系列为 Cyber先锋社原创教程。CSV 通讯录几乎串联了全系列知识，建议默写一遍。

Java 入门教程（十一）：多线程与 Lambda

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

两个主题一次讲完：多线程（让程序同时干多件事）与 Lambda（函数式语法）。它们是 Java 8 的双主角，也是后端面试的必考区。目标：会建线程、懂同步、用线程池、熟练写 Lambda。

一、线程基础#

为什么需要多线程#

单线程：下载文件时界面卡死（一件事阻塞一切）。多线程：下载归下载、界面归界面——并发提升响应与吞吐。

创建线程两法#

1
// 法1：继承 Thread
2
class Downloader extends Thread {
3
    private final String file;
4
    Downloader(String file) { this.file = file; }
5

6
    @Override
7
    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（推荐——不占用继承名额）
16
class Task implements Runnable {
17
    @Override
18
    public void run() {
19
        System.out.println("任务运行在: " + Thread.currentThread().getName());
20
    }
21
}
22

23
public 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
}

展开收起

Warning

start() 启动新线程执行 run；直接调 run() 是在当前线程执行——没有新线程，这是新手第一大坑。

常用方法#

1
Thread t = Thread.currentThread();     // 当前线程
2
t.getName();
3
Thread.sleep(500);                     // 当前线程睡 500ms（静态方法）
4
t.join();                              // 等 t 结束
5
Thread.yield();                        // 建议让出 CPU（了解）
6
t.setDaemon(true);                     // 守护线程（主程序结束它陪葬）
7
t.setPriority(Thread.MAX_PRIORITY);    // 优先级（仅建议性）

二、线程安全与 synchronized#

竞态条件：多线程第一坑#

1
class 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++ 实际是”读→改→写”三步，两线程交错执行就丢更新。

synchronized：互斥锁#

1
class 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
// 同步块版（锁更小范围）
11
class Pair {
12
    private int a = 0;
13
    public void add() {
14
        synchronized (this) {                // 锁住当前实例
15
            a++;
16
        }
17
    }
18
}

展开收起

原子类：无锁方案（简单计数首选）#

1
import java.util.concurrent.atomic.AtomicInteger;
2

3
class AtomicCounter {
4
    private final AtomicInteger count = new AtomicInteger();
5
    public void increment() { count.incrementAndGet(); }    // CAS 实现，无锁高效
6
    public int get() { return count.get(); }
7
}

生产者-消费者（BlockingQueue，工程正解）#

1
import java.util.concurrent.*;
2

3
public class ProducerConsumer {
4
    public static void main(String[] args) throws Exception {
5
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(5);  // 容量5
6

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 有创建销毁开销、无法控数量。线程池 = 线程复用 + 队列排队 + 限流：

1
import java.util.concurrent.*;
2

3
public 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/Callable
12
                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()`	任务需严格串行

Tip

生产环境推荐 new ThreadPoolExecutor(...) 手动配七个参数（核心数/最大数/队列/拒绝策略），框架（Spring/Tomcat）内部全是定制池——入门先会 Executors，进阶再读源码。

四、Lambda 与函数式接口#

从匿名内部类到 Lambda#

1
// 需求：按长度排序
2
List<String> list = new ArrayList<>(List.of("banana", "apple", "fig"));
3

4
// 远古写法
5
list.sort(new Comparator<String>() {
6
    @Override
7
    public int compare(String a, String b) { return a.length() - b.length(); }
8
});
9

10
// Lambda 写法
11
list.sort((a, b) -> a.length() - b.length());
12

13
// 方法引用：更极致的简洁
14
list.sort(Comparator.comparingInt(String::length));

Lambda 语法全解#

1
// (参数) -> 表达式 或 { 语句块 }
2
Runnable r1 = () -> System.out.println("无参");
3
Runnable r2 = () -> {
4
    System.out.println("多行");
5
    System.out.println("要花括号");
6
};
7

8
// 单参可省括号（类型自动推断）
9
java.util.function.Function<String, Integer> len = s -> s.length();
10
java.util.function.Function<String, Integer> len2 = String::length;   // 方法引用
11

12
// 有返回值的
13
java.util.function.BinaryOperator<Integer> add = (a, b) -> a + b;

四大函数式接口（java.util.function）#

1
// Function<T,R>：T → R（转换）
2
Function<String, Integer> parse = Integer::parseInt;
3
System.out.println(parse.apply("42"));
4

5
// Predicate<T>：T → boolean（判断）
6
Predicate<String> isEmpty = String::isEmpty;
7
System.out.println(isEmpty.test(""));        // true
8

9
// Consumer<T>：T → void（消费）
10
Consumer<String> printer = s -> System.out.println("⚡ " + s);
11
printer.accept("hello");
12

13
// Supplier<T>：() → T（生产/惰性）
14
Supplier<Double> random = Math::random;
15
System.out.println(random.get());

展开收起

Lambda 能出现在任何”函数式接口”（只有一个抽象方法的接口）的位置——Runnable、Comparator、以及上面四大金刚。

方法引用四式#

1
String::length            // 对象方法：x -> x.length()
2
System.out::println       // 特定对象方法：x -> System.out.println(x)
3
Integer::parseInt         // 静态方法：s -> Integer.parseInt(s)
4
ArrayList::new            // 构造器：() -> new ArrayList<>()

五、Optional：告别 NPE#

1
import java.util.Optional;
2

3
// 包装可能为 null 的返回值
4
Optional<String> findUser(int id) {
5
    return id == 1 ? Optional.of("小明") : Optional.empty();
6
}
7

8
// 使用方（再也不写 if (x != null)）
9
findUser(1).ifPresent(name -> System.out.println("找到 " + name));
10

11
String name = findUser(2).orElse("游客");                 // 默认值
12
String n2 = findUser(2).orElseGet(() -> "懒加载默认");     // 惰性默认
13
String n3 = findUser(1).orElseThrow(
14
        () -> new RuntimeException("用户不存在"));          // 强制要求

六、实战：并发下载统计#

1
import java.util.concurrent.*;
2
import java.util.concurrent.atomic.AtomicLong;
3

4
public 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
}

展开收起

小练习#

创建 3 个线程分别打印 1~20，观察输出交错；用 join 让它们严格顺序执行
用 AtomicInteger 写”10 线程各加 10 万次”验证总数正确；改成普通 int 对比丢失
线程池提交 20 个计算任务（平方），用 Future 收集结果求和
用 Function 链式组合：andThen 实现”字符串 → 长度 → 平方”
用 Optional 重写”根据 id 查学生成绩”：找不到返回默认 0 并打印提示

本篇小结#

Thread 两种创建法；start() 启动、join() 等待；sleep 静态方法
count++ 非原子；synchronized 互斥、AtomicInteger 无锁计数
BlockingQueue 天然解决生产者消费者
线程池三工厂 + submit/Future 收结果；生产用 ThreadPoolExecutor 定制
Lambda 只认函数式接口；四大金刚 Function/Predicate/Consumer/Supplier
方法引用四式；Optional 优雅防空

下一篇：Stream API 与综合实战——系列的收官之战。

本系列为 Cyber先锋社原创教程。“并发耗时 vs 串行耗时”的对比实验请亲手跑，体感最深刻。

Java 入门教程（十二）：Stream API 与综合实战

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

双主题收官：Stream API（Java 8 最优雅的数据处理武器）+ 综合实战（用全系列知识写一个学生管理系统）。

一、Stream API#

是什么#

Stream 是数据流水线：数据源 → 中间操作（惰性）→ 终端操作（触发）。它不存数据、不改源，只声明”怎么处理”：

1
import java.util.List;
2
import java.util.stream.Collectors;
3

4
List<String> names = List.of("小明", "小红", "小刚", "小美", "小强");
5

6
List<String> result = names.stream()            // ① 建流
7
        .filter(n -> n.startsWith("小"))          // ② 中间操作：过滤（还没执行！）
8
        .map(String::length)                      // ③ 中间操作：变换
9
        .collect(Collectors.toList());            // ④ 终端操作：触发整条流水线

创建流的三种方式#

1
// 集合 → stream()
2
List<Integer> list = List.of(1, 2, 3);
3
list.stream();
4

5
// 数组 → Arrays.stream
6
int[] arr = {1, 2, 3};
7
Arrays.stream(arr).sum();
8

9
// 静态工厂 → Stream.of / generate / iterate
10
Stream<Integer> s1 = Stream.of(1, 2, 3);
11
Stream<Integer> s2 = Stream.iterate(1, n -> n * 2).limit(10);    // 1,2,4,8...1024

中间操作全家桶#

1
List<Integer> nums = List.of(5, 3, 8, 1, 3, 9, 2);
2

3
// filter：过滤
4
nums.stream().filter(n -> n > 3).forEach(System.out::println);   // 5 8 9
5

6
// map：一对一变换
7
nums.stream().map(n -> n * n).forEach(System.out::println);      // 25 9 64 ...
8

9
// distinct / sorted / limit / skip
10
nums.stream().distinct().sorted().limit(3).toList();             // [1, 2, 3]
11
nums.stream().sorted(Comparator.reverseOrder()).skip(1).toList(); // [8,5,3,3,2]
12

13
// flatMap：一对多展开（流中流拍扁）
14
List<List<Integer>> nested = List.of(List.of(1, 2), List.of(3, 4));
15
nested.stream().flatMap(List::stream).toList();                   // [1,2,3,4]
16

17
// peek：偷看（调试利器）
18
nums.stream().peek(n -> System.out.println("处理中: " + n))
19
     .map(n -> n + 1).toList();

展开收起

终端操作全家桶#

1
List<Integer> nums = List.of(5, 3, 8, 1, 9);
2

3
// —— 归约计算 ——
4
nums.stream().count();                          // 5
5
nums.stream().mapToInt(Integer::intValue).sum();// 26（先转 IntStream 性能更好）
6
nums.stream().max(Integer::compareTo);          // Optional[9]
7
nums.stream().min(Integer::compareTo);          // Optional[1]
8
nums.stream().filter(n -> n > 3).findFirst();   // Optional[5]
9
nums.stream().filter(n -> n > 3).findAny();
10

11
// —— 匹配判断 ——
12
nums.stream().allMatch(n -> n > 0);             // true（全部满足）
13
nums.stream().anyMatch(n -> n > 8);             // true（任一满足）
14
nums.stream().noneMatch(n -> n < 0);            // true（都不满足）
15

16
// —— 遍历 ——
17
nums.stream().forEach(System.out::println);

展开收起

Collectors：收集器（最强大）#

1
List<Student> st = List.of(
2
    new Student("小明", "一班", 90),
3
    new Student("小红", "二班", 85),
4
    new Student("小刚", "一班", 92),
5
    new Student("小美", "二班", 78));
6

7
// toList / toSet
8
List<String> names = st.stream().map(s -> s.name).toList();   // Java 16+ 直接 toList
9

10
// joining：字符串拼接
11
String all = st.stream().map(s -> s.name)
12
        .collect(Collectors.joining(", ", "[", "]"));         // [小明, 小红, 小刚, 小美]
13

14
// groupingBy：分组（Map<String, List<Student>>）
15
Map<String, List<Student>> byClass = st.stream()
16
        .collect(Collectors.groupingBy(s -> s.clazz));
17

18
// 分组 + 下游统计
19
Map<String, Long> countByClass = st.stream()
20
        .collect(Collectors.groupingBy(s -> s.clazz, Collectors.counting()));
21
// {一班=2, 二班=2}
22

23
Map<String, Double> avgByClass = st.stream()
24
        .collect(Collectors.groupingBy(s -> s.clazz,
25
                 Collectors.averagingDouble(s -> s.score)));
26
// {一班=91.0, 二班=81.5}
27

28
Map<String, Optional<Student>> topByClass = st.stream()
29
        .collect(Collectors.groupingBy(s -> s.clazz,
30
                 Collectors.maxBy(Comparator.comparing(s -> s.score))));
31

32
// partitioningBy：按布尔分两组
33
Map<Boolean, List<Student>> passFail = st.stream()
34
        .collect(Collectors.partitioningBy(s -> s.score >= 60));
35

36
// toMap：收集成 Map
37
Map<String, Integer> scoreMap = st.stream()
38
        .collect(Collectors.toMap(s -> s.name, s -> s.score,
39
                (a, b) -> b));                 // 第3参处理键冲突

展开收起

并行流一行提速#

1
long sum = java.util.stream.IntStream.rangeClosed(1, 100_000_000)
2
        .parallel()                             // 一行变多核并行
3
        .sum();
4
// 适合：数据量大 + 元素计算重；小数据反而更慢（线程切换开销）

二、综合实战：学生管理系统#

全系列知识总集成：OOP + 集合 + 异常 + IO + 多线程。

1
// ===== StudentSystem.java 完整可编译 =====
2
import java.io.IOException;
3
import java.nio.charset.StandardCharsets;
4
import java.nio.file.Files;
5
import java.nio.file.Path;
6
import java.nio.file.StandardOpenOption;
7
import java.util.*;
8
import java.util.stream.Collectors;
9

10
public 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 小明 一班 90
2
✅ 已添加 S1001 小明
3
> add 小红 二班 85
4
✅ 已添加 S1002 小红
5
> rank
6
  S1001  小明   一班  90.0
7
  S1002  小红   二班  85.0
8
> stat
9
  一班: 平均 90.0
10
  二班: 平均 85.0
11
> del S1002
12
🗑 已删除
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 原理。做出项目欢迎投稿本站！

小练习（毕业设计）#

学生系统加”修改成绩”与”按班级删除”命令
把存储从 CSV 升级为 JSON（手写简易序列化或引入 Gson）
加”异步导出报表”功能：线程池执行导出，导出完成后提示（多线程 + Future）
用 Stream 一行实现：求数组中”偶数的平方的平均值”
（三系列横向）用 Python 与 C++ 各重写一个命令行 Todo，对比三种语言的代码量与思路差异

本系列为 Cyber先锋社原创教程，共 12 篇完结。至此本站 Python（11篇）/ C++（12篇）/ Java（12篇）三大入门系列全部完结，欢迎在留言板晒毕业设计！

Python 入门教程（一）：从安装到第一个程序

Thu, 29 Oct 2026 00:00:00 GMT

为什么从 Python 开始#

在所有编程语言中，Python 几乎是公认最适合入门的语言：语法接近自然英语、不用操心内存和类型声明的细节、装好就能跑，而且它在数据分析、人工智能、自动化脚本、Web 开发领域都是主流工具。学会 Python，等于拿到了信息技术世界的一把万能钥匙。

安装 Python#

Windows#

访问 python.org/downloads 下载最新版安装包（3.x 系列）
运行安装程序，务必勾选 “Add Python to PATH”，这是新手最常见的翻车点
安装完成后打开命令提示符（Win+R 输入 cmd），验证：

Terminal window

1
python --version

看到 Python 3.x.x 即安装成功。

macOS#

系统自带 Python，但版本可能较旧，推荐用 Homebrew 安装最新版：

Terminal window

1
brew install python
2
python3 --version

Linux（Ubuntu/Debian）#

Terminal window

1
sudo apt update && sudo apt install python3 python3-pip
2
python3 --version

Tip

Windows 上命令是 python，macOS/Linux 上通常是 python3，本文后续统一写 python，请按自己的系统对应。

第一个程序：Hello World#

打开命令行，输入 python 进入交互式环境（出现 >>> 提示符），然后输入：

1
>>> print("Hello, Cyber先锋社!")
2
Hello, Cyber先锋社!

回车即出结果——这就是交互式环境的好处：即写即测，非常适合学习阶段做小实验。输入 exit() 可退出。

也可以把代码存成文件。新建 hello.py：

1
print("Hello, Cyber先锋社!")
2
print("我的第一个 Python 程序")

在命令行运行：

Terminal window

1
python hello.py

Note

.py 是 Python 源文件的扩展名。用 VS Code、PyCharm 等编辑器打开编写体验更好。

变量与数据类型#

变量：给数据贴标签#

变量就是一个”名字标签”，指向内存里的某个数据。Python 里不需要声明类型，直接赋值即可：

1
name = "小明"        # 字符串 str
2
age = 18             # 整数 int
3
height = 1.75        # 浮点数 float
4
is_student = True    # 布尔值 bool

用 type() 函数可以查看任何数据的类型：

1
>>> type(age)
2
<class 'int'>

常用数据类型速览#

类型	名称	示例	用途
`int`	整数	`42`, `-7`	计数、索引
`float`	浮点数	`3.14`	小数运算
`str`	字符串	`"hello"`	文本处理
`bool`	布尔值	`True`, `False`	逻辑判断

基本运算#

1
a = 10
2
b = 3
3

4
print(a + b)    # 13  加
5
print(a - b)    # 7   减
6
print(a * b)    # 30  乘
7
print(a / b)    # 3.3333... 除（结果一定是 float）
8
print(a // b)   # 3   整除（舍去小数）
9
print(a % b)    # 1   取余数
10
print(a ** b)   # 1000 幂运算

字符串操作#

1
s = "Cyber Pioneer"
2

3
print(len(s))           # 13，字符串长度
4
print(s.upper())        # CYBER PIONEER
5
print(s.lower())        # cyber pioneer
6
print(s + " Club")      # 拼接：Cyber Pioneer Club
7
print(f"{s} 欢迎你")    # f-string 格式化（推荐）

f-string 是 Python 3.6+ 的格式化语法，在字符串前加 f，用 {} 嵌入变量，是现代 Python 的标准写法。

输入与输出#

程序要与人交互，就需要输入输出：

1
name = input("你叫什么名字？")
2
age = int(input("你多大了？"))   # input 返回的是字符串，转成整数
3

4
print(f"{name}，你好！明年你就 {age + 1} 岁了")

Warning

input() 的返回值永远是字符串。要做数学运算必须先转换：int() 转整数、float() 转浮点数。忘记转换是新手第二大翻车点。

小练习#

定义变量保存你的姓名、年龄、专业，用 f-string 输出一段自我介绍
计算并输出 123 ÷ 7 的商（整除）和余数
让用户输入两个数，输出它们的和、差、积、商

本篇小结#

Python 通过解释器直接运行，交互式环境适合边学边试
变量无需声明类型，赋值即创建
四大数据类型：int / float / str / bool
input() 返回字符串，运算前记得转换类型

下一篇：条件判断与循环——让程序学会”思考”和”重复劳动”。

本系列为 Cyber先锋社原创教程，参考业界通用知识体系编写。有问题欢迎在留言板讨论！

Python 入门教程（二）：运算符与字符串详解

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

上一篇我们让程序”跑了起来”，本篇把两块地基打牢：运算符（程序怎么算）和字符串（文本怎么处理）。这两块内容贯穿所有后续教程，务必动手把每个示例跑一遍。

一、运算符全解#

Python 有七类运算符，逐一来看。

1. 算术运算符#

1
a, b = 10, 3
2

3
print(a + b)    # 13    加
4
print(a - b)    # 7     减
5
print(a * b)    # 30    乘
6
print(a / b)    # 3.3333333333333335  除，结果一定是 float
7
print(a // b)   # 3     整除（向下取整）
8
print(a % b)    # 1     取模（余数）
9
print(a ** b)   # 1000  幂

三个易错点：

/ 永远返回 float，哪怕能整除：10 / 2 得 5.0
// 是向下取整，负数时要小心：

1
print(-10 // 3)   # -4  （不是 -3！向负无穷方向取）
2
print(-10 % 3)    # 2   （余数符号跟除数一致）

浮点数有精度问题，这是所有语言的通病：

1
print(0.1 + 0.2)            # 0.30000000000000004
2
print(0.1 + 0.2 == 0.3)     # False！

需要精确计算（如金额）时用 decimal 模块：

1
from decimal import Decimal
2
print(Decimal("0.1") + Decimal("0.2") == Decimal("0.3"))   # True

2. 比较运算符#

1
print(3 > 2)      # True
2
print(3 < 2)      # False
3
print(3 >= 3)     # True
4
print(3 == 3)     # True   相等是两个等号！
5
print(3 != 3)     # False  不等号

Warning

新手第一大坑：= 是赋值，== 才是比较。写 if x = 3: 会直接报语法错误——这是 Python 刻意设计的保护。

Python 支持链式比较，很优雅：

1
age = 20
2
print(18 <= age < 60)   # True，等价于 18 <= age and age < 60

3. 赋值运算符#

1
x = 10
2
x += 5    # x = x + 5 → 15
3
x -= 3    # 12
4
x *= 2    # 24
5
x //= 5   # 4
6
x **= 2   # 16

多重赋值与解包：

1
a, b = 1, 2          # 同时赋值
2
a, b = b, a          # 经典：一行交换两个变量（无需临时变量）
3
x = y = 0            # 链式赋值，x 和 y 都是 0
4

5
first, *rest = [1, 2, 3, 4]   # 星号解包：first=1, rest=[2,3,4]
6
print(first, rest)   # 1 [2, 3, 4]

4. 逻辑运算符#

Python 用英文单词而非符号：

1
age = 20
2
has_card = True
3

4
print(age >= 18 and has_card)    # True  且
5
print(age < 18 or has_card)      # True  或
6
print(not has_card)              # False 非

短路求值：and 左边为假时右边不再计算，or 左边为真时同理。常用于安全访问：

1
# 列表非空才取第一个元素（若右边执行而列表为空会报错）
2
nums = []
3
if nums and nums[0] > 0:
4
    print("正数")

真值表速记（哪些值被视为 False）：

假值	说明
`False`、`None`
`0`、`0.0`	数字零
`""`、`[]`、`{}`、`()`、`set()`	空容器

其余一切值都为真，包括 "False" 这个非空字符串。

5. 成员运算符#

1
print("py" in "python")        # True
2
print(3 in [1, 2, 3])          # True
3
print("x" not in ["a", "b"])   # True
4
print("name" in {"name": "Tom"})   # True（查的是键）

6. 身份运算符#

is 比较两个变量是否指向同一个对象，== 只比较值：

1
a = [1, 2, 3]
2
b = [1, 2, 3]
3
print(a == b)    # True  值相等
4
print(a is b)    # False 不是同一个对象
5

6
c = a
7
print(c is a)    # True  c 和 a 指向同一列表

Tip

判断 None 必须用 is None 而不是 == None，这是 PEP 8 规范。

7. 位运算符（了解即可）#

直接对整数的二进制位操作，底层开发、算法优化才会常用：

1
print(5 & 3)    # 1   按位与：0b101 & 0b011 = 0b001
2
print(5 | 3)    # 7   按位或
3
print(5 ^ 3)    # 6   按位异或
4
print(5 << 1)   # 10  左移一位相当于 ×2
5
print(5 >> 1)   # 2   右移一位相当于 //2

经典应用：x << 1 比 x * 2 快；判断奇偶 x & 1（结果 1 为奇数）。

运算符优先级（简表）#

从高到低：** → 一元负号 → * / // % → + - → 比较运算 → not → and → or。记不住就加括号，括号永远最清晰。

二、字符串详解#

字符串的本质：不可变序列#

字符串是字符组成的序列，可以按位置访问；但它是不可变的——任何”修改”都是创建新字符串：

1
s = "CyberPioneer"
2
s[0] = "c"     # ❌ TypeError！字符串不可修改
3
s = "c" + s[1:]   # ✅ 拼出新字符串
4
print(s)       # cyperPioneer

索引与切片（重中之重）#

1
s = "CyberPioneer"
2

3
# 索引：从 0 开始，负数从末尾开始
4
print(s[0])     # C
5
print(s[-1])    # r
6
print(len(s))   # 12
7

8
# 切片语法 s[起:止:步长]，含头不含尾
9
print(s[0:5])    # Cyber
10
print(s[5:])     # Pioneer（省略止 = 到结尾）
11
print(s[:5])     # Cyber（省略起 = 从开头）
12
print(s[::2])    # CyePoer（隔一个取一个）
13
print(s[::-1])   # renoiPreyC（经典倒序！）

切片口诀：含头不含尾，省头从头起，省尾到尾止，负步长倒着走。

切片越界不会报错（索引越界才会）：

1
print(s[0:100])   # 整个字符串，不报错
2
print(s[100])     # ❌ IndexError

常用内置方法#

1
s = " hello Cyber Pioneer "
2

3
# —— 大小写类 ——
4
print(s.strip())            # 去两端空白："hello Cyber Pioneer"
5
print(s.upper())            # 全大写
6
print(s.lower())            # 全小写
7
print(s.title())            # 每个单词首字母大写
8
print("abc".capitalize())   # Abc 首字母大写
9

10
# —— 查找类 ——
11
t = "hello"
12
print(t.find("l"))       # 2  首次出现的索引，找不到返回 -1
13
print(t.count("l"))      # 2  出现次数
14
print(t.startswith("he"))   # True
15
print(t.endswith("lo"))     # True
16

17
# —— 分割与连接 ——
18
csv = "python,cpp,java"
19
langs = csv.split(",")       # ['python', 'cpp', 'java']
20
print("-".join(langs))       # python-cpp-java
21
print("a b  c".split())      # ['a', 'b', 'c']（无参分割自动处理多空格）
22

23
# —— 替换与判断 ——
24
print("1+1".replace("+", "-"))    # 1-1
25
print("abc123".isdigit())         # False（含字母）
26
print("12345".isdigit())          # True
27
print("abc".isalpha())            # True
28
print("Python".isupper())         # False

展开收起

注意：这些方法都不修改原字符串，而是返回新值：

1
t = "hello"
2
t.upper()          # 只是返回了新字符串，没有保存！
3
print(t)           # hello（原样）
4
t = t.upper()      # ✅ 要用变量接住
5
print(t)           # HELLO

三种格式化方式#

1
name, score = "小明", 95.5
2

3
# 1. f-string（Python 3.6+，现代标准，推荐）
4
print(f"{name} 的成绩是 {score}")
5
print(f"及格了吗：{score >= 60}")
6
print(f"保留一位小数：{score:.1f}")        # 95.5
7
print(f"补零对齐：{7:03d}")               # 007
8
print(f"百分比：{0.856:.1%}")             # 85.6%
9
print(f"{name=} ")                        # name='小明' 调试神器
10

11
# 2. format 方法（老代码常见）
12
print("{} 的成绩是 {}".format(name, score))
13
print("{1} 比 {0} 高".format("小明", "小红"))   # 位置参数
14

15
# 3. % 占位符（最古老，C 语言风格）
16
print("%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

转义字符与原始字符串#

1
print("第一行\n第二行")      # \n 换行
2
print("姓名\t年龄")          # \t 制表符
3
print("他说：\"你好\"")       # \" 输出双引号
4
print(r"C:\new\table")       # 原始字符串：\n 不转义，正则/路径必备
5
print("""多行
6
字符串
7
写这里""")                    # 三引号保留换行

练手小案例：统计单词#

1
text = "the quick brown fox jumps over the lazy dog the end"
2

3
words = text.split()                    # ['the','quick',...]
4
print(f"总词数: {len(words)}")          # 10
5

6
the_count = text.count("the")
7
print(f"the 出现: {the_count} 次")       # 3
8

9
# 每个单词倒序输出
10
for w in words:
11
    print(w[::-1], end=" ")
12
# eht kciuq nworb xof spmuj revo eht yzal god eht dne

小练习#

不用 len()，用循环统计字符串长度（提示：计数器 + 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 是文本处理双璧；字符串方法返回新值需接住
格式化首选 f-string

下一篇：条件判断与循环——让程序学会思考和重复。

本系列为 Cyber先锋社原创教程。动手跑一遍所有示例，比读十遍更有用。

Python 入门教程（三）：条件判断与循环控制

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

前两篇的程序都是”从头跑到尾”，本篇让程序拥有判断（走哪条路）和重复（反复做事）的能力。这两者是所有程序逻辑的基石，学完本篇你就能写出真正”有逻辑”的程序了。

一、代码块与缩进：Python 的命门#

Python 不用 {} 園代码块，而用缩进（官方推荐 4 个空格）：

1
if score >= 60:
2
    print("及格")          # 缩进的行属于 if
3
    print("继续努力")      # 同级缩进 = 同一块代码
4
print("无论如何都执行")     # 不缩进 = 在 if 外面

Warning

缩进错误（IndentationError）是新手最高频报错。规则：同级代码缩进必须完全一致，禁止 tab 和空格混用。把编辑器的 Tab 键设置为”插入 4 空格”一劳永逸。

二、条件判断#

基础 if / else#

1
score = 75
2

3
if score >= 60:
4
    print("及格")
5
else:
6
    print("不及格")

多分支 elif#

1
score = 85
2

3
if score >= 90:
4
    grade = "优秀"
5
elif score >= 80:
6
    grade = "良好"
7
elif score >= 70:
8
    grade = "中等"
9
elif score >= 60:
10
    grade = "及格"
11
else:
12
    grade = "不及格"
13

14
print(f"等级：{grade}")    # 良好

执行逻辑：从上往下逐个判断，命中即止——所以条件要从严格到宽松排列。如果把 score >= 60 放第一个，90 分也会被判”及格”。

嵌套判断#

1
age = 20
2
has_id = True
3

4
if age >= 18:
5
    if has_id:
6
        print("允许进入")
7
    else:
8
        print("请出示证件")
9
else:
10
    print("未成年禁止入内")

嵌套超过两层就该考虑合并条件：if age >= 18 and has_id:。

条件表达式（三元运算符）#

一行搞定简单二选一：

1
age = 20
2
status = "成年" if age >= 18 else "未成年"
3
print(status)     # 成年

match-case（Python 3.10+ 结构化匹配）#

1
def 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

12
print(handle("go north"))     # 向 north 移动
13
print(handle("pick key up"))  # 捡起 key

适合替代长串 elif，case _ 是兜底分支。

三、while 循环：条件驱动#

1
count = 1
2
while count <= 5:
3
    print(f"第 {count} 圈")
4
    count += 1        # 千万别忘了改变条件，否则死循环！

三要素：初始化（count=1）、条件（<=5）、更新（count+=1）。漏掉第三步就是死循环。

经典应用：猜数字游戏#

1
import random
2

3
answer = random.randint(1, 100)   # 1~100 随机整数
4
tries = 0
5

6
while True:
7
    guess = int(input("猜一个 1-100 的数："))
8
    tries += 1
9

10
    if guess < answer:
11
        print("小了")
12
    elif guess > answer:
13
        print("大了")
14
    else:
15
        print(f"猜对了！用了 {tries} 次")
16
        break       # 跳出循环

展开收起

while True + break 是”先执行、后判断退出”的标准写法。

四、for 循环：遍历序列#

for 用来逐个取出序列（字符串/列表/字典…）里的元素：

1
# 遍历字符串
2
for ch in "abc":
3
    print(ch)          # a b c 各一行
4

5
# 遍历列表
6
for lang in ["Python", "C++", "Java"]:
7
    print(lang)
8

9
# 遍历字典：items() 同时拿键和值
10
scores = {"小明": 90, "小红": 85}
11
for name, score in scores.items():
12
    print(f"{name}: {score}分")

range()：生成数字序列#

1
range(5)         # 0 1 2 3 4        （含头不含尾）
2
range(1, 6)      # 1 2 3 4 5
3
range(0, 10, 2)  # 0 2 4 6 8        （步长 2）
4
range(10, 0, -1) # 10 9 8 ... 1     （倒序）
5

6
for i in range(1, 4):
7
    print(f"{i} 的平方是 {i**2}")

enumerate()：同时拿下标和元素#

1
langs = ["Python", "C++", "Java"]
2

3
# 笨办法
4
for i in range(len(langs)):
5
    print(i, langs[i])
6

7
# 优雅办法
8
for i, lang in enumerate(langs):
9
    print(f"第{i}名：{lang}")
10
# 第0名：Python ...

zip()：并行遍历多个序列#

1
names = ["小明", "小红", "小刚"]
2
scores = [90, 85, 78]
3

4
for name, score in zip(names, scores):
5
    print(f"{name}: {score}分")

五、break、continue 与循环 else#

1
# break：立即终止整个循环
2
for n in [3, 7, 12, 5, 8]:
3
    if n > 10:
4
        print(f"找到大于10的数：{n}")
5
        break
6

7
# continue：跳过本次，进入下一次
8
for n in range(10):
9
    if n % 2 == 0:
10
        continue       # 偶数跳过
11
    print(n, end=" ")  # 1 3 5 7 9

循环的 else 子句（Python 特色，别处没有）：循环没被 break 打断而正常结束才执行：

1
# 找质数的标准姿势
2
n = 13
3
for i in range(2, n):
4
    if n % i == 0:
5
        print(f"{n} 不是质数，能被 {i} 整除")
6
        break
7
else:
8
    print(f"{n} 是质数")     # 循环正常跑完没 break → 是质数

六、循环嵌套：二维世界#

1
# 九九乘法表
2
for i in range(1, 10):
3
    for j in range(1, i + 1):
4
        print(f"{j}×{i}={i*j}", end="\t")
5
    print()    # 每行结束换行

输出（三角形排布）：

1
1×1=1
2
1×2=2  2×2=4
3
1×3=3  2×3=6  3×3=9
4
...（共 9 行）

嵌套循环次数是相乘的：外 3 次内 4 次共 12 次，层数越多越要小心性能。

七、推导式：循环的语法糖（进阶必备）#

用一行表达”遍历 + 处理 + 收集”：

1
# 列表推导式：[表达式 for 变量 in 序列 if 条件]
2
squares = [i**2 for i in range(1, 6)]
3
print(squares)          # [1, 4, 9, 16, 25]
4

5
evens = [i for i in range(20) if i % 2 == 0]
6
print(evens)            # [0, 2, 4, 6, 8, ...]
7

8
# 带条件表达式
9
labels = ["偶" if i % 2 == 0 else "奇" for i in range(5)]
10
print(labels)           # ['偶', '奇', '偶', '奇', '偶']
11

12
# 字典推导式
13
word = "hello"
14
freq = {ch: word.count(ch) for ch in set(word)}
15
print(freq)             # {'h': 1, 'e': 1, 'l': 2, 'o': 1}

展开收起

可读性原则：逻辑超过一层嵌套就老实写 for 循环，别炫技。

八、经典练习（附思路）#

1. 计算 1~100 的和#

1
total = 0
2
for i in range(1, 101):
3
    total += i
4
print(total)    # 5050
5
# 数学解法彩蛋：print(100*101//2)

2. 打印斐波那契数列前 20 项#

1
a, b = 0, 1
2
for _ in range(20):
3
    print(a, end=" ")
4
    a, b = b, a + b
5
# 0 1 1 2 3 5 8 13 21 ...

3. 判断质数（函数版在第六篇会重写）#

1
n = int(input("输入一个数："))
2

3
if n < 2:
4
    print("不是质数")
5
else:
6
    for i in range(2, int(n**0.5) + 1):    # 只需检查到平方根
7
        if n % i == 0:
8
            print(f"不是质数，{n} = {i} × {n//i}")
9
            break
10
    else:
11
        print("是质数")

优化点：判断到 n**0.5 即可——若 n 有大于平方根的因子，必然对应一个小于平方根的因子。

4. 水仙花数（三位数 = 各位数字立方和）#

1
for 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

小练习#

输入一个整数，倒序逐位输出（如 1234 → 4 3 2 1），分别用 while 和字符串切片两种方法实现
打印 100 内所有能被 3 整除但不含数字 3 的数（提示："3" not in str(n)）
用嵌套循环打印直角三角形星号图案（5 行）
用列表推导式生成 1~50 中所有奇数的平方列表

本篇小结#

缩进即语法：同级一致，4 空格，禁混 tab
if/elif 从严到宽；三元表达式一行二选一；3.10+ 可用 match-case
while 三要素；for 遍历序列；range 生成数字；enumerate 带下标；zip 并行
break 终止 / continue 跳过 / 循环 else 表示”没被 break”
推导式是”遍历+收集”的语法糖，一层以内使用

下一篇：列表与元组——Python 最常用的数据容器。

本系列为 Cyber先锋社原创教程。练习务必亲手做，答案写进你自己的代码笔记本。

Python 入门教程（四）：列表与元组

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

单个变量存单个值，但现实数据往往是”一堆”：一门课的所有成绩、购物车里的商品、通讯录联系人。列表和元组就是 Python 存放”一堆数据”的基础容器，也是使用频率最高的数据结构。

一、列表：可变的有序容器#

创建与访问#

1
# 直接创建
2
scores = [90, 85, 78, 92, 66]
3
empty = []                     # 空列表
4
mixed = [1, "hello", 3.14, True]   # 可以混装类型（但不建议）
5
nested = [1, [2, 3], [4, [5]]]     # 列表可以嵌套
6

7
# list() 从其他序列转换
8
print(list("abc"))             # ['a', 'b', 'c']
9
print(list(range(5)))          # [0, 1, 2, 3, 4]

索引与切片规则与字符串完全一致（含头不含尾、负数索引）：

1
scores = [90, 85, 78, 92, 66]
2

3
print(scores[0])      # 90
4
print(scores[-1])     # 66
5
print(scores[1:4])    # [85, 78, 92]
6
print(scores[::-1])   # 倒序列表
7
print(len(scores))    # 5

增：四种方式#

1
langs = ["Python"]
2

3
langs.append("Java")           # 尾部追加单个 → ['Python', 'Java']
4
langs.insert(1, "C++")         # 指定位置插入 → ['Python', 'C++', 'Java']
5
langs.extend(["Go", "Rust"])   # 合并另一个序列 → [..., 'Go', 'Rust']
6
langs += ["C#"]                # += 等价于 extend

Warning

append 与 extend 的经典坑：

1
a = [1, 2]
2
a.append([3, 4])    # [1, 2, [3, 4]]   整个列表作为一个元素！
3
b = [1, 2]
4
b.extend([3, 4])    # [1, 2, 3, 4]     逐个合并 ✓

删：三种方式#

1
nums = [10, 20, 30, 20, 40]
2

3
nums.remove(20)        # 按值删：只删第一个匹配项 → [10, 30, 20, 40]
4
last = nums.pop()      # 按索引删并返回该值：40，nums → [10, 30, 20]
5
first = nums.pop(0)    # 弹出索引0：10
6
del nums[0]            # del 语句删除：30 被删
7
# nums 现在是 [20]
8

9
# 值不存在时 remove 会报 ValueError，安全写法：
10
if 999 in nums:
11
    nums.remove(999)

改：直接赋值#

1
scores = [90, 85, 78]
2
scores[0] = 95             # 单个改
3
scores[1:3] = [80, 88]     # 切片批量改

查：in / index / count#

1
langs = ["Python", "C++", "Java"]
2

3
print("Go" in langs)          # False
4
print(langs.index("Java"))    # 2（不存在会报 ValueError）
5
print([1, 2, 2, 3].count(2))  # 2

二、列表排序#

sort 与 sorted 的区别（必考题）#

1
nums = [3, 1, 4, 1, 5, 9, 2, 6]
2

3
# sorted()：返回新列表，原列表不动
4
new = sorted(nums)
5
print(new)               # [1, 1, 2, 3, 4, 5, 6, 9]
6
print(nums)              # [3, 1, 4, 1, 5, 9, 2, 6] 原样
7

8
# .sort()：原地排序，返回 None
9
nums.sort()
10
print(nums)              # [1, 1, 2, 3, 4, 5, 6, 9]
11

12
# 降序
13
nums.sort(reverse=True)
14
print(sorted(nums, reverse=True))

Warning

nums = nums.sort() 是经典错误——sort 返回 None，这句执行后 nums 变成 None。

按自定义规则排序：key 参数#

1
words = ["banana", "apple", "cherry", "fig"]
2

3
words.sort()                        # 字典序
4
words.sort(key=len)                 # 按长度：['fig', 'apple', ...]
5
words.sort(key=len, reverse=True)   # 按长度降序
6

7
# 排序复杂数据：按成绩降序
8
students = [("小明", 90), ("小红", 85), ("小刚", 92)]
9
students.sort(key=lambda s: s[1], reverse=True)
10
print(students)     # [('小刚', 92), ('小明', 90), ('小红', 85)]

lambda s: s[1] 是匿名函数（第六篇详讲），意思是”取每个元素的第 1 位作为排序依据”。

max / min / sum#

1
scores = [90, 85, 78, 92, 66]
2

3
print(max(scores), min(scores), sum(scores))
4
# 92 66 411
5
print(f"平均分 {sum(scores)/len(scores):.1f}")   # 82.2

三、遍历与复制：深浅拷贝的坑#

直接赋值 ≠ 复制#

1
a = [1, 2, 3]
2
b = a              # 不是复制！b 和 a 指向同一个列表
3
b.append(4)
4
print(a)           # [1, 2, 3, 4] —— a 也"变"了
5
print(a is b)      # True

浅拷贝的三种写法#

1
a = [1, 2, 3]
2
b = a.copy()       # 写法1
3
c = a[:]           # 写法2 切片
4
d = list(a)        # 写法3 构造
5

6
b.append(4)
7
print(a)           # [1, 2, 3] ✓ a 不受影响
8
print(a is b)      # False

浅拷贝依然有坑：嵌套结构#

1
a = [1, [2, 3]]
2
b = a.copy()       # 浅拷贝：只复制第一层
3
b[1].append(4)
4
print(a)           # [1, [2, 3, 4]] —— 内层列表是共享的！
5

6
# 深拷贝：彻底独立
7
import copy
8
c = copy.deepcopy(a)
9
c[1].append(99)
10
print(a)           # [1, [2, 3, 4]] 不受影响 ✓

记忆法：= 是”贴标签”，.copy() 是”复印一层”，deepcopy 是”整棵复印”。

四、案例：成绩统计与购物车#

成绩统计#

1
scores = [90, 85, 78, 92, 66, 88, 73]
2

3
print(f"人数: {len(scores)}")
4
print(f"最高: {max(scores)}  最低: {min(scores)}")
5
print(f"平均: {sum(scores)/len(scores):.1f}")
6

7
# 统计各分数段
8
a = [s for s in scores if s >= 90]
9
b = [s for s in scores if 80 <= s < 90]
10
c = [s for s in scores if s < 60]
11
print(f"90+ 有 {len(a)} 人，挂科 {len(c)} 人")
12

13
# 排名（保留原下标）
14
ranking = sorted(enumerate(scores), key=lambda x: x[1], reverse=True)
15
for rank, (idx, s) in enumerate(ranking, 1):
16
    print(f"第{rank}名：{s}分（第{idx+1}位同学）")

展开收起

购物车#

1
cart = []            # [(商品名, 单价, 数量), ...]
2

3
def 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
            return
8
    cart.append((name, price, qty))
9

10
def 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

17
add_item("键盘", 199, 1)
18
add_item("鼠标", 89, 2)
19
add_item("键盘", 199, 1)    # 再买一把 → 数量变 2
20
checkout()

展开收起

五、元组：不可变的列表#

创建与使用#

1
point = (3, 5)
2
single = (42,)          # ⚠️ 单元素必须带逗号！
3
also_tuple = 1, 2, 3    # 括号可省，逗号才是本质
4
x, y = point            # 解包：x=3, y=5
5
print(also_tuple)

元组支持索引、切片、len、in、遍历——一切”读”操作都与列表相同；但不能增删改：

1
point = (3, 5)
2
print(point[0], len(point), 3 in point)   # ✓ 都可以
3
point[0] = 10     # ❌ TypeError
4
point.append(6)   # ❌ 没有这个方法

为什么需要元组#

安全：不希望被修改的数据（坐标、配置、日期）用元组，防止误改
字典键：列表不可哈希不能做键，元组可以：locations = {(39.9, 116.4): "北京"}
函数多返回值：return x, y 本质就是返回元组
性能：比列表省内存、创建更快

元组与列表互转#

1
t = (1, 2, 3)
2
lst = list(t)          # (1,2,3) → [1,2,3]
3
back = tuple(lst)      # [1,2,3] → (1,2,3)

六、列表 vs 元组选择指南#

场景	选择
会增删改的数据（待办、消息队列）	列表
固定不变的数据（坐标、常量组）	元组
需要做字典的键	元组
函数返回多个值	元组（自动）

小练习#

合并两个列表并去重排序：[1,3,5] 与 [2,3,6] → [1,2,3,5,6]（提示：set 或手写）
统计列表中出现次数最多的元素（不用库，提示：count + max）
矩阵转置：[[1,2,3],[4,5,6]] → [[1,4],[2,5],[3,6]]（提示：嵌套推导式）
交换 a = (1, [2, 3]) 元组中内层列表的第 0 个元素为 99——会报错吗？（动手验证：元组不可变，但内层列表可以）

本篇小结#

列表增删改查：append/extend、insert、remove/pop/del、index/count
sorted 返回新列表，.sort() 原地排序；key 参数自定义规则
= 是引用，.copy() 浅拷贝只复制一层，嵌套结构用 deepcopy
元组不可变但可读；单元素要带逗号；适合做字典键与返回值
容器选型：要改用列表，固定用元组

下一篇：字典与集合——用键查值的”通讯录”与自动去重的”收纳盒”。

本系列为 Cyber先锋社原创教程。深浅拷贝的例子请务必亲手跑一遍，坑过一次就记住了。

Python 入门教程（五）：字典与集合

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

列表用”位置”找数据（nums[0]），但很多时候我们需要用”名字”找数据——学号查成绩、用户名查密码、单词查释义。字典就是干这个的；集合则是自动去重的数学容器。学完本篇，Python 四大容器（列表/元组/字典/集合）就集齐了。

一、字典：键值对映射#

创建与基本访问#

1
# 键值对：{键: 值, ...}
2
student = {
3
    "name": "小明",
4
    "age": 18,
5
    "major": "计算机科学",
6
    "scores": {"python": 90, "cpp": 85},   # 字典可以嵌套
7
}
8

9
print(student["name"])            # 小明
10
print(student["scores"]["python"])   # 90（链式访问嵌套）
11

12
# 空字典
13
empty = {}
14
also_empty = dict()
15

16
# dict() 构造
17
ages = dict(小明=18, 小红=17)      # {'小明': 18, '小红': 17}
18
pairs = dict([("a", 1), ("b", 2)]) # {'a': 1, 'b': 2}

展开收起

键的要求：必须不可变（字符串/数字/元组可以，列表不行），且唯一（重复定义后者覆盖前者）。

增与改#

1
user = {"name": "小明"}
2

3
user["age"] = 18          # 键不存在 → 新增
4
user["age"] = 19          # 键已存在 → 修改
5
user.update({"city": "北京", "age": 20})   # 批量增改
6
print(user)               # {'name': '小明', 'age': 20, 'city': '北京'}

查：安全访问三件套#

1
user = {"name": "小明", "age": 18}
2

3
# 1. [] 直接访问：键不存在直接报错
4
print(user["name"])          # 小明
5
# print(user["email"])       # ❌ KeyError!
6

7
# 2. .get()：不存在返回 None（或默认值），推荐
8
print(user.get("email"))             # None
9
print(user.get("email", "未填写"))    # 未填写
10

11
# 3. in：先判断再访问
12
if "age" in user:
13
    print("年龄:", user["age"])

Tip

日常写法用 .get()；确定键必存在（如自己刚放进去的）才用 []。

setdefault：不存在才设置#

1
stats = {}
2
# 统计字符出现次数的优雅写法
3
for ch in "hello":
4
    stats.setdefault(ch, 0)   # 没有该键就先设为 0
5
    stats[ch] += 1
6
print(stats)     # {'h': 1, 'e': 1, 'l': 2, 'o': 1}

删#

1
user = {"name": "小明", "age": 18, "city": "北京"}
2

3
age = user.pop("age")      # 删除并返回值：18
4
del user["city"]           # del 语句删除
5
user.pop("email", None)    # 键不存在不报错（给了默认值）
6

7
last = user.popitem()      # 删除并返回最后一个键值对
8
print(user)                # {}

遍历三件套#

1
scores = {"小明": 90, "小红": 85, "小刚": 92}
2

3
# 遍历键（默认就是遍历键）
4
for name in scores:
5
    print(name)
6

7
# 遍历值
8
for score in scores.values():
9
    print(score)
10

11
# 同时遍历键和值（最常用）
12
for name, score in scores.items():
13
    print(f"{name}: {score} 分")

其他常用操作#

1
scores = {"小明": 90, "小红": 85}
2

3
print(len(scores))            # 2
4
print(max(scores, key=scores.get))   # 小刚→最高分的人名（key=按值比较）
5
print(list(scores.keys()))    # ['小明', '小红']
6
print(list(scores.values()))  # [90, 85]
7

8
# 合并（Python 3.5+）
9
extra = {"小刚": 92}
10
all_scores = {**scores, **extra}
11
# Python 3.9+ 更简洁：
12
all_scores = scores | extra

案例：词频统计（字典最经典应用）#

1
text = """python is simple and python is powerful
2
learn python and code python"""
3

4
# 方法：setdefault 计数
5
freq = {}
6
for word in text.split():
7
    freq.setdefault(word, 0)
8
    freq[word] += 1
9

10
# 按次数降序输出 Top 3
11
for 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 次

展开收起

案例：通讯录（嵌套字典）#

1
contacts = {
2
    "小明": {"phone": "138xxxx", "city": "北京", "tags": ["同学", "编程组"]},
3
    "小红": {"phone": "139xxxx", "city": "上海", "tags": ["同学"]},
4
}
5

6
def show(name):
7
    info = contacts.get(name)
8
    if info is None:
9
        print(f"没有 {name} 的联系方式")
10
        return
11
    tags = "/".join(info["tags"])
12
    print(f"{name}｜{info['phone']}｜{info['city']}｜标签: {tags}")
13

14
def search_by_city(city):
15
    found = [n for n, i in contacts.items() if i["city"] == city]
16
    print(f"{city} 的联系人: {found}")
17

18
show("小明")           # 小明｜138xxxx｜北京｜标签: 同学/编程组
19
search_by_city("上海")  # 上海 的联系人: ['小红']

展开收起

二、集合：去重与集合运算#

创建与去重#

1
# 花括号内是元素（不是键值对）就是集合
2
fruits = {"apple", "banana", "apple", "cherry"}
3
print(fruits)          # {'apple', 'banana', 'cherry'} 自动去重！
4
print(len(fruits))     # 3
5

6
# ⚠️ 空花括号是字典不是集合！
7
empty_dict = {}
8
empty_set = set()      # 空集合必须用 set()
9

10
# 从列表去重（最常用场景）
11
nums = [1, 3, 2, 3, 1, 5]
12
unique = list(set(nums))
13
print(unique)          # [1, 2, 3, 5]（顺序不保证！）
14

15
# 去重且保序的写法
16
unique_ordered = list(dict.fromkeys(nums))
17
print(unique_ordered)  # [1, 3, 2, 5] ✓ 保持原序

展开收起

增删#

1
s = {1, 2, 3}
2

3
s.add(4)          # 添加单个
4
s.update([5, 6])  # 添加多个
5
s.remove(9)       # ❌ 不存在会 KeyError
6
s.discard(9)      # ✓ 不存在也不报错（推荐）
7
s.pop()           # 随机弹出一个元素
8
print(s)

集合运算：交并差#

两个班的选课情况对比：

1
class_a = {"python", "cpp", "java", "go"}
2
class_b = {"python", "java", "rust", "js"}
3

4
# 交集：都选了的课
5
print(class_a & class_b)          # {'python', 'java'}
6
print(class_a.intersection(class_b))   # 同上
7

8
# 并集：所有人选过的课
9
print(class_a | class_b)          # {'python','cpp','java','go','rust','js'}
10

11
# 差集：A 选了 B 没选的
12
print(class_a - class_b)          # {'cpp', 'go'}
13

14
# 对称差：只有一方选了的（并集 - 交集）
15
print(class_a ^ class_b)          # {'cpp', 'go', 'rust', 'js'}
16

17
# 子集与超集
18
print({"python"} <= class_a)      # True 子集判断
19
print(class_a.issubset(class_a | class_b))   # True

展开收起

助记：& 交（都有的）、| 并（合起来）、- 差（我有你没有）、^ 异（不共有的）。

集合推导式与 frozenset#

1
squares = {i**2 for i in range(1, 6)}
2
print(squares)      # {1, 4, 9, 16, 25}
3

4
# frozenset：不可变集合，可作为字典键
5
fs = frozenset([1, 2, 3])
6
# fs.add(4)         # ❌ 不可变
7
cache = {fs: "结果"}   # ✓ 合法

成员测试的性能优势#

in 集合是 O(1)，in 列表是 O(n)——数据量大时差距巨大：

1
import time
2

3
big_list = list(range(1_000_000))
4
big_set = set(big_list)
5

6
t1 = time.time()
7
for _ in range(100):
8
    999_999 in big_list
9
t2 = time.time()
10
for _ in range(100):
11
    999_999 in big_set
12
t3 = time.time()
13

14
print(f"列表查找: {(t2-t1)*1000:.1f}ms")
15
print(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 班 ["a","b","c","d"]、B 班 ["c","d","e","f"]，输出所有人都名单与”只在一个班”的人
实现简单的英汉字典：支持查词（不存在提示”未收录”）、添加新词、遍历输出所有词条
用集合推导式生成 1~100 中能被 3 或 5 整除的数的平方集合

本篇小结#

字典按键存取 O(1)；安全访问用 .get()；计数用 setdefault
遍历三件套：keys() / values() / items()
合并字典：{**a, **b} 或 3.9+ 的 a | b
集合自动去重；& | - ^ 四大运算；discard 比 remove 安全
空集合用 set()；频繁成员测试选集合不选列表
四大容器选型口诀：排队列表、锁死元组、查名字典、去重集合

下一篇：函数——把代码封装成可复用的积木。

本系列为 Cyber先锋社原创教程。词频统计是面试与实战双高频题，务必独立写一遍。

Python 入门教程（六）：函数详解

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

前面所有代码都是”线性剧本”——从上往下一次演完。函数让你把一段逻辑打包成”招式”，随叫随到、反复使用。函数是代码复用的最小单元，也是从”写脚本”迈向”写工程”的第一步。

一、定义与调用#

1
def greet(name):
2
    """向指定的人问好"""          # docstring 文档字符串
3
    print(f"你好，{name}！")
4

5
greet("小明")        # 调用：你好，小明！
6
greet("小红")        # 同一段代码，复用无需复制粘贴

语法要点：

def 函数名(参数): 定义；函数名(实参) 调用
定义不执行、调用才执行——函数可以定义在调用之前（Python 从上往下读）
三引号 docstring 描述函数用途，help(greet) 可查看
函数名规则：小写+下划线（calc_average），动词开头更佳

二、参数全家族#

1. 位置参数：按顺序对号入座#

1
def introduce(name, age, major):
2
    print(f"我是{name}，{age}岁，专业{major}")
3

4
introduce("小明", 18, "计算机")    # 顺序必须一致

2. 关键字参数：指名道姓#

1
introduce(major="计算机", name="小明", age=18)   # 顺序随意
2
introduce("小明", major="软件工程", age=19)        # 位置在前，关键字在后 ✓

3. 默认参数：不传就用默认值#

1
def greet(name, greeting="你好"):
2
    print(f"{greeting}，{name}！")
3

4
greet("小明")                # 你好，小明！
5
greet("Tom", "Hello")        # Hello, Tom!

Warning

默认参数的头号大坑——用可变对象做默认值：

1
def add_item(item, items=[]):      # ❌ 危险！
2
    items.append(item)
3
    return items
4

5
print(add_item(1))    # [1]
6
print(add_item(2))    # [1, 2]！！默认列表被"记住"了
7

8
# ✅ 正确姿势
9
def add_item(item, items=None):
10
    if items is None:
11
        items = []
12
    items.append(item)
13
    return items

原因：默认值在函数定义时只创建一次。面试高频题。

4. 可变参数 *args：接收任意个数#

1
def total(*nums):
2
    print(type(nums))         # <class 'tuple'> 收进元组
3
    return sum(nums)
4

5
print(total(1, 2))            # 3
6
print(total(1, 2, 3, 4, 5))   # 15

5. 关键字可变参数 **kwargs：接收任意关键字参数#

1
def show_info(name, **extra):
2
    print(f"姓名：{name}")
3
    for k, v in extra.items():
4
        print(f"  {k}: {v}")
5

6
show_info("小明", age=18, city="北京", major="计算机")
7
# 姓名：小明
8
#   age: 18
9
#   city: 北京
10
#   major: 计算机

参数顺序铁律#

1
def func(位置参数, 默认参数=x, *args, **kwargs): ...

即：**普通 → 带默认 → *args → kwargs。

* 与 ** 的解包妙用#

1
def area(a, b, c):
2
    # 海伦公式算三角形面积
3
    s = (a + b + c) / 2
4
    return (s*(s-a)*(s-b)*(s-c)) ** 0.5
5

6
sides = [3, 4, 5]
7
print(area(*sides))            # * 把列表拆成三个参数
8

9
info = {"name": "小明", "age": 18}
10
greet_info = lambda **kw: kw
11
print(greet_info(**info))      # ** 把字典拆成关键字参数

三、返回值#

return 的规则#

1
def is_even(n):
2
    if n % 2 == 0:
3
        return True
4
    return False               # 函数遇 return 立即结束
5

6
# 无 return 或只写 return → 返回 None
7
def say_hi():
8
    print("hi")
9

10
result = say_hi()
11
print(result)                  # None

返回多个值（本质是元组）#

1
def min_max(nums):
2
    return min(nums), max(nums)    # 打包成元组
3

4
low, high = min_max([3, 1, 4, 1, 5])   # 解包接收
5
print(low, high)                        # 1 5

函数与解包配合#

1
def divide(a, b):
2
    if b == 0:
3
        return None, "除数不能为 0"      # 失败返回错误信息
4
    return a / b, None
5

6
result, error = divide(10, 2)
7
if error:
8
    print("出错:", error)
9
else:
10
    print(f"结果: {result}")

四、作用域：变量看得见谁#

LEGB 规则#

Python 查找变量的顺序：Local（函数内）→ Enclosing（外层函数）→ Global（模块级）→ Built-in（内置）。

1
x = 10                  # 全局变量
2

3
def outer():
4
    y = 20              # outer 的局部变量
5
    def inner():
6
        z = 30          # inner 的局部变量
7
        print(x, y, z)  # 10 20 30：都能看到（LEGB 逐层向外找）
8
    inner()
9

10
outer()

局部改全局：global（慎用）#

1
count = 0
2

3
def click():
4
    global count        # 声明我要改全局变量
5
    count += 1
6

7
click(); click()
8
print(count)            # 2

Tip

需要 global 通常说明设计有问题——更好的做法是通过参数传入、返回值传出。多线程环境 global 是重灾区。

闭包：外层函数的变量被”记住”#

1
def make_counter():
2
    n = 0
3
    def counter():
4
        nonlocal n      # 声明改的是外层函数的变量（不是全局）
5
        n += 1
6
        return n
7
    return counter      # 返回函数本身（不带括号！）
8

9
c = make_counter()
10
print(c(), c(), c())    # 1 2 3：n 被 counter 记住了

nonlocal 用于修改外层函数的变量（global 是改模块级，别混淆）。

五、lambda 与高阶函数#

lambda：一行的小函数#

1
# lambda 参数: 表达式
2
square = lambda x: x ** 2
3
print(square(5))         # 25
4

5
# 等价的 def 写法
6
def square(x):
7
    return x ** 2

lambda 的定位：临时、简单、用完即弃，尤其作为参数传递时：

1
students = [("小明", 90), ("小红", 85), ("小刚", 92)]
2
students.sort(key=lambda s: s[1])            # 按成绩排序
3
best = max(students, key=lambda s: s[1])     # 成绩最高的

复杂逻辑禁止写 lambda——写不下也读不懂，老实用 def。

三大高阶函数#

函数当参数传的函数叫高阶函数：

1
nums = [1, 2, 3, 4, 5, 6]
2

3
# map：逐个变换
4
squares = list(map(lambda x: x**2, nums))
5
print(squares)          # [1, 4, 9, 16, 25, 36]
6

7
# filter：按条件筛选
8
evens = list(filter(lambda x: x % 2 == 0, nums))
9
print(evens)            # [2, 4, 6]
10

11
# sorted（前面讲过）：带 key 排序

实际上推导式通常更清晰，map/filter 了解即可：

1
squares = [x**2 for x in nums]          # 与 map 等价，更 Pythonic
2
evens = [x for x in nums if x % 2 == 0] # 与 filter 等价

六、递归：函数调用自己#

1
def factorial(n):
2
    """阶乘：n! = n × (n-1)!"""
3
    if n <= 1:               # 基线条件（出口）——必须有！
4
        return 1
5
    return n * factorial(n - 1)   # 递归调用
6

7
print(factorial(5))    # 120 = 5×4×3×2×1

递归两要素：基线条件（何时停）+ 递推关系（如何缩小学）。缺出口就是无限递归，触发 RecursionError（默认上限约 1000 层）。

经典：斐波那契的递归写法与低效问题——

1
def fib(n):
2
    if n < 2:
3
        return n
4
    return fib(n-1) + fib(n-2)
5

6
print(fib(10))    # 55（fib(35) 就已经很慢——重复计算爆炸）

七、装饰器入门（进阶预告）#

装饰器是”给函数套一层壳”的语法，Python 工程必用。看懂下面这个计时器，你就理解了它的工作原理：

1
import time
2
from functools import wraps
3

4
def timer(func):
5
    @wraps(func)
6
    def wrapper(*args, **kwargs):
7
        start = time.time()
8
        result = func(*args, **kwargs)      # 调用原函数
9
        cost = (time.time() - start) * 1000
10
        print(f"[{func.__name__}] 耗时 {cost:.2f}ms")
11
        return result
12
    return wrapper
13

14
@timer                        # 等价于 slow_sum = timer(slow_sum)
15
def slow_sum(n):
16
    return sum(range(n))
17

18
slow_sum(10_000_000)          # [slow_sum] 耗时 187.35ms

展开收起

@timer 只是个语法糖。装饰器链、带参数的装饰器等进阶内容，等做项目时再深入。

八、实战重构：把脚本函数化#

重构前（线性脚本，无法复用）：

1
scores = [90, 85, 78, 92, 66]
2
total = sum(scores)
3
avg = total / len(scores)
4
print(f"平均 {avg:.1f}")
5
above = [s for s in scores if s >= avg]
6
print(f"高于平均: {above}")

重构后（函数化，可测试可复用）：

1
def analyze(scores, precision=1):
2
    """分析成绩：返回统计摘要字典"""
3
    if not scores:
4
        return None
5
    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

14
def report(data):
15
    """打印摘要"""
16
    if data is None:
17
        print("无数据")
18
        return
19
    print(f"人数 {data['count']}，平均 {data['avg']}，"
20
          f"最高 {data['max']}，高于平均 {len(data['above_avg'])} 人")
21

22
report(analyze([90, 85, 78, 92, 66]))
23
report(analyze([]))            # 无数据

展开收起

函数化三原则：一个函数做一件事、参数进结果出（少用 global）、起个说清楚的名字。

小练习#

写 is_prime(n) 判断质数，再用它输出 100 内所有质数（重构第三篇的循环版）
写 apply_twice(func, x)：把 func 应用两次，如 apply_twice(lambda x: x*2, 5) → 20
写可变参数函数 average(*nums)，不传参数时返回 0
用闭包写一个”密码尝试计数器”：每调用一次 try_login() 计数 +1，超过 3 次返回”已锁定”
（选做）给第三篇的猜数字游戏包一个 play() 函数，支持参数”最大范围”与”最多机会”

本篇小结#

参数顺序：普通 → 默认 → *args → **kwargs；默认参数别用可变对象
* 拆序列、** 拆字典；return 多值是元组
LEGB 作用域；改全局用 global、改外层用 nonlocal，但都应少用
lambda 用于临时的 key/短逻辑；map/filter 会被推导式替代
递归 = 基线条件 + 递推；装饰器 = 函数的”包装壳”
工程习惯：单一职责、参数进结果出、好名字

下一篇：迭代器与生成器——省内存的懒加载艺术。

本系列为 Cyber先锋社原创教程。默认参数的坑和闭包计数器请亲手复现一遍。

Python 入门教程（七）：迭代器与生成器

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

你每天都在用 for x in ...，但有没有想过 for 到底是怎么”一个个取出”元素的？这背后是 Python 的迭代协议。理解它，你就能用生成器写出处理百万行数据也不爆内存的代码——这是 Python 进阶的第一道分水岭。

一、for 循环的真相：迭代协议#

可迭代对象与迭代器#

1
nums = [1, 2, 3]
2

3
for n in nums:
4
    print(n)

这段代码的幕后流程：

Python 对 nums 调用 iter() 拿到一个迭代器
反复对迭代器调用 next() 取元素
抛出 StopIteration 异常时结束循环

手动模拟一遍：

1
nums = [1, 2, 3]
2
it = iter(nums)          # 列表 → 迭代器
3

4
print(next(it))          # 1
5
print(next(it))          # 2
6
print(next(it))          # 3
7
# print(next(it))        # ❌ StopIteration！取完了

两个概念：

概念	说明	例子
可迭代对象 Iterable	实现了 `__iter__`，能被 for 遍历	列表、字符串、字典、文件
迭代器 Iterator	实现了 `__iter__` 和 `__next__`，能被 next()	`iter(列表)` 的返回值

关系：迭代器一定可迭代；可迭代对象要通过 iter() 变成迭代器才能 next()。

1
from collections.abc import Iterable, Iterator
2

3
nums = [1, 2, 3]
4
print(isinstance(nums, Iterable))     # True
5
print(isinstance(nums, Iterator))     # False！列表本身不是迭代器
6
print(isinstance(iter(nums), Iterator))   # True

迭代器是一次性的#

1
it = iter([1, 2, 3])
2
for x in it:
3
    print(x, end=" ")     # 1 2 3
4
for x in it:
5
    print(x, end=" ")     # （空！已耗尽）

而列表可以反复 for——因为每次 for 都会重新 iter() 出新迭代器。

二、生成器函数：yield 的魔法#

从写一个开始#

函数体里出现 yield，它就不再是普通函数，而是生成器函数——调用它不执行代码，而是返回一个生成器（一种迭代器）：

1
def count_down(n):
2
    print("开始倒数")
3
    while n > 0:
4
        yield n          # 产出 n，在此暂停！
5
        n -= 1
6

7
gen = count_down(3)
8
print(gen)               # <generator object ...> 还没执行！
9

10
print(next(gen))         # 打印"开始倒数"，返回 3
11
print(next(gen))         # 2（从暂停处继续）
12
print(next(gen))         # 1
13
# next(gen)              # ❌ StopIteration

yield 与 return 的本质区别：

return：交值、函数终结
yield：交值、函数暂停，下次 next 从暂停行继续，局部变量全部保留

生成器 + for：正常使用姿势#

1
def count_down(n):
2
    while n > 0:
3
        yield n
4
        n -= 1
5

6
for x in count_down(5):
7
    print(x, end=" ")     # 5 4 3 2 1

三、为什么用生成器：省内存#

对比实验#

生成 1000 万个平方数：

1
import sys
2

3
# 列表：一次性全造好放内存
4
big_list = [x**2 for x in range(10_000_000)]
5
print(f"列表占用: {sys.getsizeof(big_list)/1024/1024:.0f} MB")   # 约 80+ MB
6

7
# 生成器：用时才算，只存"当前位置"
8
big_gen  = (x**2 for x in range(10_000_000))
9
print(f"生成器占用: {sys.getsizeof(big_gen)} 字节")              # 约 200 字节！

生成器表达式：把列表推导式的 [] 换成 () 即可。数据流”边生成边消费”，内存占用恒定——处理大文件、大数据集的标准姿势。

求和场景实测#

1
# 一亿个数求和：列表版可能内存吃紧
2
total = sum(x for x in range(100_000_000))    # 生成器：平稳跑完
3
print(total)

四、生成器实战模式#

1. 无限序列#

生成器不预生成全部，所以能表达”无限”：

1
def fibonacci():
2
    """无限斐波那契数列"""
3
    a, b = 0, 1
4
    while True:            # 死循环？配合 yield 就是无限流
5
        yield a
6
        a, b = b, a + b
7

8
# 取前 10 个：islice 从无限流切片
9
from itertools import islice
10
print(list(islice(fibonacci(), 10)))
11
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
12

13
# 找到第一个大于 1000 的斐波那契数
14
for f in fibonacci():
15
    if f > 1000:
16
        print(f)          # 1597
17
        break

展开收起

2. 读大文件（最经典场景）#

1
def 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 内存
8
error_count = 0
9
for line in read_large_file("app.log"):
10
    if "ERROR" in line:
11
        error_count += 1
12
print(f"错误行数: {error_count}")

3. 管道式处理（生成器链）#

多个生成器串成流水线，数据像水流过每一站：

1
def lines(path):
2
    with open(path, encoding="utf-8") as f:
3
        yield from f            # yield from：把子生成器的值逐个转发
4

5
def only_errors(lines_iter):
6
    for line in lines_iter:
7
        if "ERROR" in line:
8
            yield line
9

10
def with_lineno(lines_iter):
11
    for i, line in enumerate(lines_iter, 1):
12
        yield f"行{i}: {line.rstrip()}"
13

14
# 组装流水线：此刻什么都没发生（全懒）
15
pipeline = with_lineno(only_errors(lines("app.log")))
16

17
# 消费时数据才逐条流过三层
18
for item in pipeline:
19
    print(item)

展开收起

yield from iterable 等价于 for x in iterable: yield x 的简写。

4. 生成器实现滑窗#

1
def 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

6
print(list(window([1, 2, 3, 4, 5], 3)))
7
# [(1, 2, 3), (2, 3, 4), (3, 4, 5)]

五、itertools：迭代器工具箱（标准库）#

1
from itertools import chain, product, combinations, islice, count
2

3
# chain：拼接多个可迭代对象
4
print(list(chain([1, 2], "ab", (3,))))      # [1, 2, 'a', 'b', 3]
5

6
# product：笛卡尔积（嵌套循环的扁平写法）
7
print(list(product("AB", "12")))
8
# [('A','1'), ('A','2'), ('B','1'), ('B','2')]
9

10
# combinations：组合（不重复）
11
print(list(combinations([1, 2, 3], 2)))     # [(1,2), (1,3), (2,3)]
12

13
# count：无限计数器
14
for i in count(10, 5):      # 从10开始步进5：10,15,20...
15
    if i > 25: break
16
    print(i, end=" ")       # 10 15 20 25
17

18
# islice：给无限流"切片"
19
print(list(islice(count(1, 2), 5)))         # [1, 3, 5, 7, 9]

展开收起

六、自定义迭代器类（预习面向对象）#

给类实现 __iter__ 和 __next__，就能被 for 遍历：

1
class Countdown:
2
    def __init__(self, start):
3
        self.n = start
4

5
    def __iter__(self):
6
        return self          # 自己就是迭代器
7

8
    def __next__(self):
9
        if self.n <= 0:
10
            raise StopIteration
11
        self.n -= 1
12
        return self.n + 1
13

14
for x in Countdown(3):
15
    print(x, end=" ")        # 3 2 1

展开收起

类的语法下一篇详讲，此处先混个脸熟。

七、何时用生成器 vs 列表#

场景	选择
数据大（文件/百万行）	生成器
只遍历一次	生成器
需反复遍历 / 下标访问 / len()	列表
需要切片、排序完整结果	列表
无限/未知长度的流	只能生成器

性能口诀：一次消费用生成，多次使用存列表。

小练习#

写生成器 running_average(nums)：每接收一个数 yield 当前的平均值
用生成器表达式求 1~1000 中所有素数的平方和（提示：配合第五篇的 is_prime 思路）
写无限生成器 cycle(seq)：cycle("AB") 产出 A B A B…（不许看 itertools 源码）
用管道模式实现：读入一组英文句子 → 只保留含 “python” 的行 → 全部转小写 → 前 5 条（三层生成器链）
（选做）对比 sum([i**2 for i in range(10**7)]) 与 sum(i**2 for i in range(10**7)) 的内存占用差异（用 sys.getsizeof 或内存监视器）

本篇小结#

for 的本质：iter() 拿迭代器 → 反复 next() → StopIteration 结束
可迭代 ≠ 迭代器；迭代器是一次性的
yield 让函数暂停/恢复；生成器函数调用返回生成器
生成器表达式 (x for x in ...) 惰性求值，内存恒定
四大实战模式：无限序列、大文件、管道链、滑窗
itertools 提供现成工具：chain/product/combinations/islice/count

下一篇：模块与标准库——站在 Python 自带的”百宝箱”上开发。

本系列为 Cyber先锋社原创教程。把”管道处理日志”例子跑通，你会对数据流有全新体感。

Python 入门教程（八）：模块、包与常用标准库

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

Python 能长期霸榜，一半功劳属于它的生态：标准库自带”充电电池”（batteries included），第三方库超过 50 万个。本篇解决三个问题：怎么组织自己的代码（模块与包）、怎么用别人的代码（导入与 pip）、哪些标准库必须先掌握。

一、模块：一个 .py 就是一个模块#

四种导入方式#

假设有一个 my_utils.py：

my_utils.py

1
PI = 3.14159
2

3
def circle_area(r):
4
    return PI * r * r
5

6
def _secret():
7
    """下划线开头：约定为内部函数，不对外提供"""
8
    return "internal"

在其他文件中使用：

1
# 方式1：导入整个模块（推荐，命名空间清晰）
2
import my_utils
3
print(my_utils.circle_area(2))
4

5
# 方式2：导入模块并起别名
6
import my_utils as mu
7
print(mu.circle_area(2))
8

9
# 方式3：导入特定名称（少打字，但可能命名冲突）
10
from my_utils import circle_area, PI
11
print(circle_area(2))
12

13
# 方式4：导入全部（不推荐！污染命名空间）
14
from my_utils import *

Warning

from x import * 会引入看不见的名字，还可能覆盖你的变量（如覆盖内置函数）。规范工程禁用。

`if name == "main"`：模块的身份检查#

每个模块都有魔法属性 __name__：

直接运行该文件时，__name__ 等于 "__main__"
被导入时，__name__ 等于模块名（如 "my_utils"）

my_utils.py

1
def circle_area(r):
2
    return PI * r * r
3

4
if __name__ == "__main__":
5
    # 这段代码只在直接运行时执行，被导入时不执行
6
    print("自测:", circle_area(1))

这是 Python 项目的标准结构：功能放函数里，测试/演示代码放 main 保护下——既能当库被导入，又能当脚本运行。

`all` 控制 `import *` 的范围#

my_utils.py

1
__all__ = ["circle_area", "PI"]    # 只导出这两个

二、包：目录形式的模块集合#

结构#

包 = 含 __init__.py 的目录（Python 3.3+ 该文件可省，但保留是好习惯）：

1
project/
2
├── main.py
3
└── club/                     # 顶层包
4
    ├── __init__.py           # 让 club 成为包
5
    ├── utils.py              # club.utils
6
    └── tools/                # 子包
7
        ├── __init__.py
8
        └── net.py            # club.tools.net

导入包内模块#

1
import club.utils                      # 完整路径
2
club.utils.circle_area(2)
3

4
from club.tools import net             # 从子包导入
5
from club.tools.net import ping        # 导入具体函数
6

7
import club.tools.net as net           # 别名

绝对导入与相对导入#

包内部模块互相引用时：

club/tools/net.py

1
from club.utils import helper      # 绝对导入（推荐：清晰）
2

3
from ..utils import helper         # 相对导入：.. 上一层包
4
from . import local_module         # . 当前包

相对导入只能用在包内，脚本顶层文件不可用。

三、pip 与虚拟环境#

pip：第三方包管理器#

Terminal window

1
pip install requests               # 安装
2
pip install requests==2.31.0       # 指定版本
3
pip install "requests>=2.28"       # 版本范围
4
pip install -r requirements.txt    # 按清单批量安装
5
pip uninstall requests             # 卸载
6
pip list                           # 已装列表
7
pip show requests                  # 包详情
8
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名   # 国内镜像加速

requirements.txt：项目依赖清单，交接与部署必备：

Terminal window

1
pip freeze > requirements.txt      # 导出当前环境全部依赖
2
pip install -r requirements.txt    # 他人一键还原

虚拟环境：项目隔离的结界#

不同项目依赖不同版本的库会互相打架，虚拟环境给每个项目独立空间：

Terminal window

1
# 创建（venv 是标准库自带）
2
python -m venv venv                 # 在项目目录生成 venv/ 目录
3

4
# 激活
5
source venv/bin/activate            # macOS / Linux
6
venv\Scripts\activate               # Windows
7

8
# 激活后命令行前缀出现 (venv)，此后 pip 装的包只进这个环境
9
(venv) pip install requests
10

11
# 退出
12
deactivate

铁律：每个项目一个虚拟环境，venv/ 目录加入 .gitignore 不进版本库。

Tip

现代替代品 uv（pip + venv 的极速合一）、poetry 也值得了解，但 venv + pip 是基本功，先掌握它。

四、六大高频标准库详解#

1. os：操作系统交互#

1
import os
2

3
# 路径操作（最常用）
4
os.path.join("club", "docs", "a.md")    # club/docs/a.md（跨平台拼接）
5
os.path.exists("/etc/hosts")            # True 是否存在
6
os.path.isfile("a.py")                  # 是否文件
7
os.path.isdir("club")                   # 是否目录
8
os.path.basename("/a/b/c.txt")          # c.txt
9
os.path.dirname("/a/b/c.txt")           # /a/b
10
os.path.splitext("photo.jpg")           # ('photo', '.jpg')
11
os.path.getsize("a.py")                 # 字节大小
12

13
# 目录操作
14
os.getcwd()                             # 当前工作目录
15
os.listdir(".")                         # 列出目录内容
16
os.makedirs("a/b/c", exist_ok=True)     # 递归建目录（存在不报错）
17
os.remove("temp.txt")                   # 删文件

展开收起

跨平台路径推荐用 pathlib（面向对象风格）：

1
from pathlib import Path
2

3
p = Path("club") / "docs" / "a.md"      # 用 / 拼路径，优雅
4
print(p.exists(), p.suffix)             # True .md
5
for md in Path(".").glob("**/*.md"):    # 递归找所有 md
6
    print(md)

2. sys：解释器信息#

1
import sys
2

3
print(sys.version)              # Python 版本串
4
print(sys.platform)             # darwin / win32 / linux
5
print(sys.argv)                 # 命令行参数列表！
6
sys.exit(1)                     # 退出程序（非0=异常退出）
7
sys.path.append("/my/libs")     # 追加模块搜索路径

命令行参数实战：

args_demo.py

1
import sys
2

3
if __name__ == "__main__":
4
    # python args_demo.py hello 42
5
    print(sys.argv)             # ['args_demo.py', 'hello', '42']
6
    name = sys.argv[1] if len(sys.argv) > 1 else "陌生人"
7
    print(f"你好, {name}")

3. math 与 random#

1
import math
2

3
print(math.sqrt(16))        # 4.0 平方根
4
print(math.ceil(3.2))       # 4   向上取整
5
print(math.floor(3.8))      # 3   向下取整
6
print(math.pi, math.e)      # 3.141592653589793 2.718281828459045
7
print(math.gcd(12, 18))     # 6   最大公约数
8
print(math.log(math.e))     # 1.0 自然对数
9
print(math.radians(180))    # 3.1415... 角度转弧度

1
import random
2

3
random.seed(42)                     # 固定种子：结果可复现
4
print(random.random())              # 0.639  [0,1) 浮点
5
print(random.randint(1, 6))         # 1~6 整数（含两端）——掷骰子
6
print(random.uniform(1.5, 3.5))     # 区间浮点
7

8
fruits = ["苹果", "香蕉", "橘子"]
9
print(random.choice(fruits))        # 随机选一个
10
print(random.sample(fruits, 2))     # 随机选2个（不重复）
11

12
nums = [1, 2, 3, 4, 5]
13
random.shuffle(nums)                # 原地打乱
14
print(nums)                         # 例如 [3, 1, 5, 2, 4]

4. json：数据交换格式（前后端/存储必备）#

1
import json
2

3
student = {"name": "小明", "age": 18, "scores": [90, 85], "vip": True}
4

5
# 序列化：Python → JSON 字符串
6
text = json.dumps(student, ensure_ascii=False, indent=2)
7
print(text)
8
# {
9
#   "name": "小明",
10
#   "age": 18, ...
11
# }
12

13
# 反序列化：JSON 字符串 → Python
14
data = json.loads(text)
15
print(data["scores"][0])          # 90
16

17
# 读写 JSON 文件
18
with open("data.json", "w", encoding="utf-8") as f:
19
    json.dump(student, f, ensure_ascii=False, indent=2)
20

21
with 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 美化缩进——两个参数是日常标配。

5. datetime：日期时间#

1
from datetime import datetime, date, timedelta
2

3
now = datetime.now()
4
print(now)                    # 2026-10-29 12:00:00.123456
5
print(now.year, now.month, now.day, now.hour)
6
print(now.weekday())          # 0=周一 ... 6=周日
7

8
# 格式化输出 ↔ 解析
9
print(now.strftime("%Y-%m-%d %H:%M:%S"))    # 2026-10-29 12:00:00
10
print(now.strftime("%Y年%m月%d日 %A"))       # 2026年10月29日 Thursday
11

12
t = datetime.strptime("2026-10-01 09:00", "%Y-%m-%d %H:%M")
13
print(t.year)                 # 2026
14

15
# 时间差 timedelta
16
birthday = datetime(2026, 12, 25)
17
delta = birthday - now
18
print(f"还剩 {delta.days} 天")
19

20
three_days_later = now + timedelta(days=3)
21
last_hour = now - timedelta(hours=1)
22

23
# 常用格式码：%Y年 %m月 %d日 %H时 %M分 %S秒 %A星期 %B月名

展开收起

6. collections：加强版容器#

1
from collections import Counter, defaultdict, deque
2

3
# Counter：计数器（词频统计一步到位）
4
words = "the quick the lazy the dog".split()
5
c = Counter(words)
6
print(c)                    # Counter({'the': 3, 'quick': 1, ...})
7
print(c.most_common(2))     # [('the', 3), ('quick', 1)]
8

9
# defaultdict：带默认值的字典（告别 KeyError）
10
groups = defaultdict(list)
11
for name, cls in [("小明","A"), ("小红","B"), ("小刚","A")]:
12
    groups[cls].append(name)          # 键不存在自动建空列表
13
print(dict(groups))        # {'A': ['小明', '小刚'], 'B': ['小红']}
14

15
# deque：双端队列（头尾操作都是 O(1)，列表头部操作是 O(n)）
16
dq = deque([1, 2, 3])
17
dq.appendleft(0)           # deque([0, 1, 2, 3])
18
dq.append(4)               # deque([0, 1, 2, 3, 4])
19
dq.popleft()               # 0（当队列用：append 入队，popleft 出队）

展开收起

五、组织你自己项目的建议#

1
my_project/
2
├── main.py              # 入口：只做调度
3
├── config.py            # 配置集中管理
4
├── requirements.txt     # 依赖清单
5
├── utils/               # 工具包
6
│   ├── __init__.py
7
│   ├── 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
六大标准库：os(path)/sys(argv)/math/random/json/datetime/collections
路径处理认准 pathlib，词频统计认准 Counter，默认值字典认准 defaultdict

下一篇：文件操作与异常处理——让程序可靠地读写与容错。

本系列为 Cyber先锋社原创教程。json 与 datetime 在 Web/爬虫/数据处理的出镜率接近 100%。

Python 入门教程（九）：文件操作与异常处理

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

程序的价值在于持久化（数据存下来）和健壮性（出错不崩）。本篇把文件操作与异常处理一次讲透——这两个主题天然是一对：凡是碰文件、网络、用户输入的代码，都必须考虑”出错怎么办”。

一、文件操作#

打开模式与编码#

1
f = open("demo.txt", "r", encoding="utf-8")

常用模式：

模式	含义	文件不存在	文件存在
`"r"`	只读（默认）	❌ 报错	从头读
`"w"`	只写	✅ 创建	清空重写！
`"a"`	追加	✅ 创建	末尾追加
`"x"`	独占创建	❌ 报错	❌ 报错（防覆盖）
`"r+"`	读+写	❌ 报错	读写均可
`"b"`	二进制（rb/wb/ab）	组合使用	处理图片/音频等

编码：永远显式写 encoding="utf-8"。不写的话 Windows 默认 GBK，同一份代码换个系统就读炸——中文乱码/UnicodeDecodeError 十有八九源自这里。

with 语句：自动关闭（标准姿势）#

1
# ❌ 手动式：忘了 close，或中途异常导致文件句柄泄漏
2
f = open("demo.txt", encoding="utf-8")
3
content = f.read()
4
f.close()
5

6
# ✅ with 式：代码块结束自动关闭，异常也会关闭
7
with open("demo.txt", encoding="utf-8") as f:
8
    content = f.read()
9
print(content)

读的四种方式#

1
# 1. read()：一次读完整个文件（小文件适用）
2
with open("demo.txt", encoding="utf-8") as f:
3
    text = f.read()
4

5
# 2. read(n)：读 n 个字符
6
with open("demo.txt", encoding="utf-8") as f:
7
    head = f.read(10)          # 前 10 个字符
8

9
# 3. readline()：每次读一行
10
with open("demo.txt", encoding="utf-8") as f:
11
    first = f.readline()       # 第一行（含 \n）
12

13
# 4. readlines()：读出所有行组成列表
14
with open("demo.txt", encoding="utf-8") as f:
15
    lines = f.readlines()      # ['第一行\n', '第二行\n', ...]
16

17
# ⭐ 最佳实践：直接迭代文件对象（逐行懒加载，大文件友好）
18
with open("demo.txt", encoding="utf-8") as f:
19
    for line in f:
20
        process(line.strip())   # strip 去掉行尾换行符

展开收起

写文件#

1
# w 模式：覆盖写
2
with 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 模式：追加写（记日志、断点续写）
8
with open("log.txt", "a", encoding="utf-8") as f:
9
    f.write(f"新的一条记录\n")

Warning

write 不自动换行，要自己加 \n；"w" 模式打开的一瞬间文件就被清空——哪怕你一行都没写。

文件指针#

1
with 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())        # 当前指针位置

案例：班级成绩管理（CSV 风格）#

1
import csv
2
from pathlib import Path
3

4
def 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

11
def 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

20
save_students([("小明", 90), ("小红", 85)])
21
print(load_students())
22
# [('小明', 90), ('小红', 85)]

展开收起

csv 模块自动处理逗号转义与引号，比手动 split 可靠得多；newline="" 是 csv 写入的标准搭配。

二、异常处理#

没有异常处理的 world#

1
nums = [1, 2, 3]
2
print(nums[10])          # IndexError，程序当场去世
3
print("这行永远执行不到")

try / except 基本结构#

1
try:
2
    risky_code()
3
except SomeError:
4
    handle_it()

1
try:
2
    n = int(input("输入一个数："))     # 输入 "abc" 会抛 ValueError
3
    print(100 / n)                     # n=0 会抛 ZeroDivisionError
4
except ValueError:
5
    print("这不是有效的数字")
6
except ZeroDivisionError:
7
    print("除数不能为 0")

捕获异常信息#

1
try:
2
    n = int("abc")
3
except ValueError as e:
4
    print(f"错误详情：{e}")       # invalid literal for int() with base 10: 'abc'

多异常与兜底#

1
try:
2
    data = load_config()
3
except (FileNotFoundError, PermissionError):
4
    print("配置文件读不了，用默认配置")
5
    data = {"debug": False}
6
except Exception as e:            # 兜底：捕获所有常规异常
7
    print(f"未知错误: {e}")
8
    raise                         # 打印后继续抛出（记日志场景常用）

工程军规：

精确捕获优先——裸 except: 会连 Ctrl+C 的 KeyboardInterrupt 都吞掉，绝对禁止
except Exception 只在最外层兜底用
捕获了就要处理（降级/默认值/日志），静默 pass 是埋雷

else 与 finally#

1
def read_score(path):
2
    try:
3
        f = open(path, encoding="utf-8")
4
    except FileNotFoundError:
5
        print("文件不存在")
6
        return None
7
    else:
8
        # try 没出错才执行（把"成功逻辑"和"危险代码"分离）
9
        score = int(f.read())
10
        f.close()
11
        return score
12
    finally:
13
        print("无论如何都执行（常用于清理资源）")

else：try 块没有发生异常时执行
finally：无论如何都执行（成功/失败/return/break），释放资源的最后一道防线

raise：主动抛出#

1
def 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 age
7

8
set_age("十八")     # TypeError: age 必须是整数

异常链与自定义异常#

1
# 自定义异常：继承 Exception（命名以 Error 结尾）
2
class ConfigError(Exception):
3
    """配置相关错误"""
4
    def __init__(self, key, msg=""):
5
        super().__init__(f"配置项 [{key}] 出错: {msg}")
6

7
def load_config(key):
8
    data = {"host": "localhost"}
9
    if key not in data:
10
        raise ConfigError(key, "缺少必填配置")   # 抛出自定义异常
11

12
try:
13
    load_config("port")
14
except 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）：

1
import logging
2

3
logging.basicConfig(
4
    filename="app.log", level=logging.INFO,
5
    format="%(asctime)s [%(levelname)s] %(message)s",
6
)
7

8
class DataFormatError(Exception):
9
    pass
10

11
def 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
                continue
19
            try:
20
                numbers.append(int(line))
21
            except ValueError as e:
22
                logging.warning("第%d行格式错误，已跳过: %r (%s)",
23
                                lineno, line, e)
24
    return numbers
25

26
# 运行：合法行全收录，坏行进日志，程序不崩
27
print(load_numbers("numbers.txt"))

展开收起

这就是生产代码的样子：预期内的错降级处理，预期外的错明确抛出，全程留痕。

四、EAFP：Python 的容错哲学#

Python 社区推崇 EAFP（Easier to Ask Forgiveness than Permission，先斩后奏）：

1
# LBYL：先问许可（先检查再操作——有竞态风险，且啰嗦）
2
if "port" in config:
3
    port = config["port"]
4
else:
5
    port = 8080
6

7
# EAFP：直接干，出错再说（Pythonic）
8
try:
9
    port = config["port"]
10
except KeyError:
11
    port = 8080
12

13
# 当然这个场景还有最简写法（第五篇）：
14
port = 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,数学），标签非法时跳行

本篇小结#

with 自动关文件；读写前想清楚 r/w/a 模式；永远显式 encoding="utf-8"
大文件逐行迭代 for line in f，不 read() 全量
try/except 精确捕获；else 无错执行；finally 必执行；raise 主动抛
禁裸 except；吞异常必须处理；业务错误用自定义异常类
EAFP：先干再说，是 Python 的方式

下一篇：面向对象编程——用类搭建大型程序的组织形态。

本系列为 Cyber先锋社原创教程。把”带日志读取器”读懂改会，你的代码就从”能跑”升级到”可靠”。

Python 入门教程（十）：面向对象编程

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

函数把”动作”打包，类把”数据 + 动作”一起打包。面向对象编程（OOP）是组织大型程序的主流范式——游戏里的每个角色、Web 框架里的每个请求对象、AI 库里的每个模型，都是”类的实例”。本篇从零讲透 Python OOP。

一、类与实例：图纸与产品#

最小类#

1
class Student:
2
    """学生类——图纸"""
3
    school = "Cyber先锋社"        # 类属性：所有实例共享
4

5
    def __init__(self, name, age):    # 构造方法：创建实例时自动调用
6
        self.name = name              # 实例属性：每个实例独有
7
        self.age = age
8

9
    def introduce(self):              # 实例方法
10
        return f"我是{name}..."

核心概念对照：

概念	类比	归属
类 class	图纸	一份
实例 instance	按图纸造的产品	可以很多个
类属性	产品系列共同配置	所有实例共享
实例属性	单个产品的编号	各自独立

创建与使用#

1
class Student:
2
    school = "Cyber先锋社"
3

4
    def __init__(self, name, age):
5
        self.name = name
6
        self.age = age
7

8
    def introduce(self):
9
        return f"我是{self.name}，{self.age}岁，来自{self.school}"
10

11
ming = Student("小明", 18)          # 自动调用 __init__
12
hong = Student("小红", 17)
13

14
print(ming.introduce())     # 我是小明，18岁，来自Cyber先锋社
15
print(hong.introduce())     # 我是小红，17岁，来自Cyber先锋社
16
print(ming.name)            # 直接访问属性
17
print(Student.school)       # 类属性通过类访问

展开收起

self 到底是什么#

self 就是实例自己。ming.introduce() 实际是 Student.introduce(ming) 的语法糖——Python 把实例自动传给第一个参数：

1
print(Student.introduce(ming))    # 与 ming.introduce() 完全等价

三条铁律：实例方法第一个参数必须是 self（名字可换但别换）；调用时不传 self；self.xxx = 值 创建实例属性。

类属性 vs 实例属性的坑#

1
class Student:
2
    school = "先锋社"
3

4
s1 = Student()
5
s2 = Student()
6

7
s1.school = "吉他社"        # 给 s1 创建了同名实例属性（遮蔽类属性）
8
print(s1.school)            # 吉他社（实例属性优先）
9
print(s2.school)            # 先锋社（s2 没有实例属性，找到类属性）
10

11
Student.school = "篮球社"   # 改类属性本身
12
print(s2.school)            # 篮球社

查找顺序：实例属性 → 类属性 → 父类属性。

实例方法 / 类方法 / 静态方法#

1
from datetime import date
2

3
class Student:
4
    school = "先锋社"
5

6
    def __init__(self, name, birth_year):
7
        self.name = name
8
        self.birth_year = birth_year
9

10
    def grade(self):                        # 实例方法：访问实例数据
11
        return date.today().year - self.birth_year
12

13
    @classmethod
14
    def from_birth_year(cls, name, age):    # 类方法：备选构造器（常用！）
15
        return cls(name, date.today().year - age)
16

17
    @staticmethod
18
    def is_valid_age(age):                  # 静态方法：与实例无关的工具函数
19
        return 6 <= age <= 100
20

21
ming = Student.from_birth_year("小明", 18)   # 类方法创建实例
22
print(Student.is_valid_age(ming.grade()))   # True

展开收起

实例方法：第一个参数 self
类方法 @classmethod：第一个参数 cls，常用于备选构造方式
静态方法 @staticmethod：不带自动参数，就是放在类里的普通函数

二、封装：藏好内部实现#

下划线约定#

1
class 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.__password
12

13
acc = Account("小明")
14
# print(acc.__password)    # ❌ AttributeError
15
# print(acc.__check("123"))  # ❌ 同理
16
print(acc.verify("123456"))    # True：通过公开接口使用内部实现

展开收起

Python 的私有是”君子协定”：__name 被改写为 _Account__name（用 acc._Account__password 其实能访问到，但永远别这么干）。

property：像属性一样调用的方法#

1
class Circle:
2
    def __init__(self, radius):
3
        self._radius = radius
4

5
    @property
6
    def radius(self):              # getter：c.radius 触发
7
        return self._radius
8

9
    @radius.setter
10
    def radius(self, value):       # setter：c.radius = x 触发（带校验）
11
        if value <= 0:
12
            raise ValueError("半径必须为正数")
13
        self._radius = value
14

15
    @property
16
    def area(self):                # 只读属性：只提供 getter
17
        return 3.14159 * self._radius ** 2
18

19
c = Circle(5)
20
print(c.area)          # 78.53975 —— 像属性，实际在计算
21
c.radius = 10          # 走 setter 校验
22
print(c.area)          # 314.159
23
# c.area = 100         # ❌ AttributeError 只读

展开收起

使用时机：属性需要计算（面积）或赋值需要校验（半径）时，对外仍保持 obj.attr 的简洁语法。

三、继承与多态#

继承：代码复用#

1
class Animal:
2
    def __init__(self, name):
3
        self.name = name
4

5
    def speak(self):
6
        return f"{self.name}在发出声音"
7

8
    def info(self):
9
        return f"[{type(self).__name__}] {self.name}"
10

11
class Dog(Animal):                     # Dog 继承 Animal
12
    def fetch(self):                   # 子类新增方法
13
        return f"{self.name}去捡球！"
14

15
class Cat(Animal):
16
    def speak(self):                   # 方法重写（override）
17
        return f"{self.name}：喵～"
18

19
dog = Dog("旺财")
20
cat = Cat("咪咪")
21

22
print(dog.info())        # [Dog] 旺财（继承来的方法）
23
print(dog.fetch())       # 旺财去捡球！（自己的新方法）
24
print(dog.speak())       # 旺财在发出声音（没重写，用父类版）
25
print(cat.speak())       # 咪咪：喵～（重写了自己的版本）

展开收起

super()：调用父类#

1
class Animal:
2
    def __init__(self, name, age):
3
        self.name = name
4
        self.age = age
5

6
class Dog(Animal):
7
    def __init__(self, name, age, breed):
8
        super().__init__(name, age)    # 先让父类完成初始化
9
        self.breed = breed             # 再补充子类特有的
10

11
d = Dog("旺财", 3, "柴犬")
12
print(d.name, d.age, d.breed)

多态：同一接口，不同行为#

1
def let_it_speak(animal):
2
    """不关心具体类型，只管调用 speak——多态的威力"""
3
    print(animal.speak())
4

5
animals = [Dog("旺财"), Cat("咪咪"), Animal("神秘生物")]
6
for a in animals:
7
    let_it_speak(a)
8
# 旺财在发出声音
9
# 咪咪：喵～
10
# 神秘生物在发出声音

let_it_speak 对”任何有 speak 方法的对象”都有效——这叫鸭子类型（走起来像鸭子叫起来像鸭子，那就是鸭子）。Python 不检查继承关系，只看”有没有这个方法”：

1
class Robot:                # 没继承 Animal！
2
    def speak(self):
3
        return "嘀嘀——"
4

5
let_it_speak(Robot())       # ✓ 照样工作

继承层次检查#

1
print(isinstance(dog, Dog))       # True
2
print(isinstance(dog, Animal))    # True（Dog 是 Animal 的子类）
3
print(issubclass(Dog, Animal))    # True
4
print(issubclass(Cat, Dog))       # False

四、魔法方法：给类装上”系统接口”#

双下划线包裹的方法在特定场景被 Python 自动调用：

1
class Book:
2
    def __init__(self, title, price):
3
        self.title = title
4
        self.price = price
5

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.title
14

15
    def __lt__(self, other):              # < 比较（配合 sort）
16
        return self.price < other.price
17

18
    def __len__(self):                    # len() 行为
19
        return len(self.title)
20

21
    def __add__(self, other):             # + 行为
22
        return self.price + other.price
23

24
b1 = Book("Python入门", 59)
25
b2 = Book("Python入门", 79)
26

27
print(b1)                    # 《Python入门》¥59
28
print(b1 == b2)              # True（同名即相等）
29
books = [Book("A书", 49), Book("B书", 29)]
30
books.sort()                 # 按 __lt__ 排序
31
print(len(b1))               # 9（标题字符数）
32
print(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：数据类的省事写法（3.7+）#

纯存数据的类（学生、订单、配置）可用 @dataclass 自动生成 __init__、__repr__、__eq__：

1
from dataclasses import dataclass, field
2

3
@dataclass
4
class Student:
5
    name: str
6
    age: int
7
    scores: list = field(default_factory=list)   # 可变默认值的安全写法
8

9
    def average(self):
10
        return sum(self.scores) / len(self.scores) if self.scores else 0
11

12
s = Student("小明", 18, [90, 85])
13
print(s)                 # Student(name='小明', age=18, scores=[90, 85])
14
print(s.average())       # 87.5

相比手写，省掉 80% 样板代码，现代 Python 写数据类的首选。

六、综合实战：图书馆管理系统#

把本篇全部知识串起来：

1
from dataclasses import dataclass, field
2
from datetime import date, timedelta
3

4
class LibraryError(Exception):
5
    """图书馆业务异常"""
6
    pass
7

8
@dataclass
9
class Book:
10
    isbn: str
11
    title: str
12
    copies: int = 1
13
    borrowers: list = field(default_factory=list)
14

15
    @property
16
    def available(self) -> int:
17
        return self.copies - len(self.borrowers)
18

19
class Member:
20
    def __init__(self, mid: int, name: str):
21
        self.mid = mid
22
        self.name = name
23
        self.borrowed: dict[str, date] = {}     # isbn -> 应还日期
24

25
    def __str__(self):
26
        return f"会员{self.mid}-{self.name}（在借{len(self.borrowed)}本）"
27

28
class Library:
29
    LOAN_DAYS = 30
30
    MAX_BOOKS = 3
31

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 += copies
39
        else:
40
            self._books[isbn] = Book(isbn, title, copies)
41

42
    def register(self, name) -> Member:
43
        mid = max(self._members, default=0) + 1
44
        m = Member(mid, name)
45
        self._members[mid] = m
46
        return m
47

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._books
72

73
# —— 使用 ——
74
lib = Library()
75
lib.add_book("978-7-111-40701-0", "Python编程：从入门到实践", copies=2)
76
lib.add_book("978-7-115-53608-2", "算法（第4版）")
77

78
ming = lib.register("小明")
79
lib.borrow(ming, "978-7-111-40701-0")
80
print(ming)                                   # 会员1-小明（在借1本）
81
print(f"馆藏 {len(lib)} 种；'978-7-115-53608-2' 在馆: {'978-7-115-53608-2' in lib}")
82

83
lib.return_book(ming, "978-7-111-40701-0")
84
print(ming)                                   # 会员1-小明（在借0本）

展开收起

这个案例用到的知识点：dataclass、property、封装（_books 内部字典）、自定义异常、魔法方法 __len__/__contains__、类型注解。建议自己敲一遍再扩展（比如加逾期罚款计算）。

七、什么时候用 OOP#

场景	建议
一次脚本、简单流程	函数式足够，别硬上类
多个实体有各自状态（游戏角色、订单）	类
框架开发 / 库开发	类（用户需要可组合的抽象）
数据 + 行为强绑定	类
纯数据传递	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 遍历章节名列表
（综合）扩展图书馆：会员分级（学生可借 3 本 30 天 / 教师可借 10 本 60 天），用继承实现

本篇小结#

类是图纸、实例是产品；__init__ 构造、self 是实例自己
类属性共享、实例属性独立；查找顺序实例 → 类 → 父类
封装靠 _ 约定；property 让方法像属性（可校验可只读）
继承复用、super().__init__ 先父后子；重写实现多态；鸭子类型只看方法不看血统
魔法方法接入 Python 语法（print/==/len/+）；数据类用 @dataclass
OOP 时机：多实体 + 各自状态；脚本工具用函数就好

下一篇：综合项目实战——从需求到成品的完整开发流程。

本系列为 Cyber先锋社原创教程。图书馆案例值得反复把玩——把它扩展成你的期末作品也毫不逊色。

Python 入门教程（十一）：综合实战——命令行待办事项管理器

Thu, 29 Oct 2026 00:00:00 GMT

本篇目标#

十篇知识点集于一身：做一个完整可用的命令行待办事项管理器（Todo CLI）。你会经历真实项目的全流程——需求分析 → 架构设计 → 分模块实现 → 测试 → 打磨。做完这个项目，你就不是”学过 Python”，而是”用 Python 做过东西”。

一、需求分析#

先明确产品要做什么（真实项目第一步）：

1
功能需求：
2
1. 添加任务：标题 + 可选优先级（高/中/低）+ 可选截止日期
3
2. 查看任务：全部 / 未完成 / 已完成 / 按优先级筛选
4
3. 完成任务：按编号标记完成
5
4. 删除任务
6
5. 数据持久化：退出后数据还在（JSON 文件）
7
6. 统计：总数、完成率、逾期数
8

9
非功能需求：
10
- 输入容错：非法输入不崩溃，给出友好提示
11
- 单文件可运行，也方便扩展成多模块

二、架构设计#

数据结构先行——一个任务长什么样：

1
{
2
    "id": 1,                       # 自增编号
3
    "title": "写Python作业",        # 标题
4
    "priority": "high",            # high / mid / low
5
    "due": "2026-11-05",           # 截止日期（可空）
6
    "done": False,                 # 是否完成
7
    "created": "2026-10-29 12:00"  # 创建时间
8
}

模块划分：

1
todo.py
2
├── 数据层：load / save（JSON 读写，第九篇）
3
├── 业务层：add / done / delete / list / stats（函数，第六篇）
4
├── 展示层：渲染表格、彩色输出
5
└── 交互层：main 循环解析命令（第八篇 sys.argv 思想 → 交互式菜单）

分层原则：业务函数不 print 结果而是返回数据，展示层负责打印——这样以后加 Web 界面能直接复用业务层。

三、完整实现#

逐段实现（可直接拼成完整文件）：

1. 数据层#

1
import json
2
import os
3
from datetime import datetime
4

5
DATA_FILE = "todos.json"
6

7
def 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

18
def save_todos(todos):
19
    with open(DATA_FILE, "w", encoding="utf-8") as f:
20
        json.dump(todos, f, ensure_ascii=False, indent=2)

展开收起

2. 业务层#

1
VALID_PRIORITIES = {"high": "🔴高", "mid": "🟡中", "low": "🟢低"}
2

3
def next_id(todos):
4
    return max((t["id"] for t in todos), default=0) + 1
5

6
def 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 todo
26

27
def finish_todo(todos, todo_id):
28
    """标记完成，返回该任务；不存在抛 KeyError"""
29
    for t in todos:
30
        if t["id"] == todo_id:
31
            t["done"] = True
32
            save_todos(todos)
33
            return t
34
    raise KeyError(f"找不到编号 {todo_id} 的任务")
35

36
def 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 removed
42
    raise KeyError(f"找不到编号 {todo_id} 的任务")
43

44
def query(todos, status="all", priority=None):
45
    """筛选：status = all/todo/done；priority = high/mid/low"""
46
    result = todos
47
    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 result
54

55
def is_overdue(todo):
56
    """已过期：未完成且截止日早于今天"""
57
    if todo["done"] or not todo["due"]:
58
        return False
59
    return todo["due"] < datetime.now().strftime("%Y-%m-%d")

展开收起

3. 展示层#

1
def print_todos(todos, title="任务列表"):
2
    if not todos:
3
        print("（空空如也）")
4
        return
5
    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

14
def 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 0
19
    print(f"\n📊 统计：共 {total} 项｜完成 {done} 项"
20
          f"（{rate:.0f}%）｜逾期 {overdue} 项")

展开收起

4. 交互层#

1
def 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
                continue
12
            parts = raw.split(maxsplit=3)      # 最多拆 4 段，标题保留空格
13
            cmd, args = parts[0].lower(), parts[1:]
14

15
            if cmd == "quit":
16
                print("再见！")
17
                break
18

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
                    continue
24
                priority = args[1] if len(args) > 1 and args[1] in VALID_PRIORITIES else "mid"
25
                due = args[2] if len(args) > 2 else None
26
                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
            break
56

57
if __name__ == "__main__":      # 第八篇：可直接运行，也可被导入复用
58
    main()

展开收起

四、运行演示#

1
=== 待办事项管理器 ===
2
> add 复习Python教程 high 2026-10-30
3
✅ 已添加 #1 复习Python教程
4
> add 给社团投稿
5
✅ 已添加 #2 给社团投稿
6
> add 买咖啡 low
7
✅ 已添加 #3 买咖啡
8

9
> list all
10
== 筛选:all ==
11
ID   状态    优先级  截止        标题
12
--------------------------------------------------
13
1    ⏳    🔴高   2026-10-30 复习Python教程
14
2    ⏳    🟡中   -          给社团投稿
15
3    ⏳    🟢低   -          买咖啡
16

17
> done 3
18
🎉 已完成！
19
> stats
20
📊 统计：共 3 项｜完成 1 项（33%）｜逾期 0 项
21
> quit

展开收起

重启程序，数据完好——todos.json 在工作目录里。

五、自测清单（交付前必做）#

真实项目的验收环节，逐项跑一遍：

add 不带任何参数 → 提示用法，不崩溃
add 测试 xyz（非法优先级）→ 自动降级为 mid，不崩溃
add 测试 mid 2026-13-99 → 提示日期格式错误
done 999 → 提示找不到，不崩溃
数据文件手动改成乱码 → 启动提示损坏并重置
完成/删除后重启 → 状态保持
造一条昨天截止的任务 → list 显示”❗逾期”

全部通过，才算”完成”。这就是教程规则里”代码必须可运行”的含义。

六、进阶改造方向#

这个骨架能长成什么：

多模块拆分：按架构图拆成 storage.py / core.py / ui.py（第八篇的包结构）
命令行参数版：用标准库 argparse 改造为 python todo.py add "标题" -p high
Web 化：加 Flask/FastAPI 路由包装业务层——因为业务与展示分离，几乎不用改核心
数据升级：JSON → SQLite（标准库 sqlite3），支持按标题搜索
定时提醒：结合 datetime 循环检测逾期任务并弹通知

七、系列总结#

11 篇走过的路：

篇	主题	核心收获
1	环境与变量	安装、交互环境、四大类型
2	运算符与字符串	七类运算、切片、f-string
3	条件与循环	if/while/for、break/continue、推导式
4	列表与元组	增删改查、排序、深浅拷贝
5	字典与集合	键值映射、去重、集合运算
6	函数	参数全家族、作用域、lambda、闭包
7	迭代器与生成器	迭代协议、yield、省内存
8	模块与标准库	导入、虚拟环境、六大库
9	文件与异常	with、精确捕获、自定义异常
10	面向对象	类、封装、继承多态、魔法方法
11	综合实战（本篇）	分层架构、完整项目流程

下一步建议：C++ / Java 系列横向对照着学一遍（体会静态类型与编译）；或者直接挑一个小工具（自己用的）从零做出来——做东西是唯一的学习闭环。做出作品欢迎投稿到本站，或到留言板晒成果。

小练习（毕业设计，三选一）#

给 Todo 加”标签”功能：add 标题 #标签，list #作业 按标签筛
做”单词打卡器”：每日录入生词与释义，随机抽测，答对率统计（random + json + datetime）
把 Todo 拆成三模块的包并加 argparse 命令行支持

本系列为 Cyber先锋社原创教程，共 11 篇。完成毕业设计的同学，欢迎在留言板认领晒图名额！

CTF 入门指南：什么是 CTF，如何开始你的第一道题？

Wed, 28 Oct 2026 00:00:00 GMT

什么是 CTF？#

CTF（Capture The Flag，夺旗赛） 是网络安全领域最流行的技术竞赛形式。参赛选手需要通过分析题目环境，找到隐藏在其中的特定格式的字符串（即 “Flag”），例如：

1
flag{w3lc0me_t0_cyber_p10neer}

CTF 不仅是一场比赛，更是检验和提升安全技能的最佳实践场。社团后续的训练营也将围绕 CTF 展开。

五大主流方向#

方向	主要内容	需要的基础
Web	SQL 注入、XSS、SSRF、文件上传漏洞等	HTTP 协议、Python、前后端基础
Pwn	栈溢出、堆漏洞、格式化字符串等二进制利用	C 语言、汇编、Linux 系统
Reverse	逆向分析程序逻辑、破解算法	C/C++、汇编、耐心
Crypto	古典密码、RSA、AES 等密码学攻击	数论、Python
Misc	流量分析、隐写、取证等杂项	广泛的知识面

Tip

新手建议从 Web 或 Misc 入手，门槛相对友好；有 C 语言基础的同学可以直接挑战 Pwn 和 Reverse。

入门学习路径#

第一步：搭建环境#

一台 Linux 虚拟机（推荐 Ubuntu 或 Kali）几乎是标配：

Terminal window

1
# Ubuntu 下安装常用工具
2
sudo apt update
3
sudo apt install python3 python3-pip git curl burpsuite wireshark

第二步：刷题入门#

推荐从国内的新手友好平台开始：

BUUCTF（buuoj.cn）：题目收录全面，writeup 丰富
攻防世界（adworld.xctf.org.cn）：分类清晰，适合按方向刷题
PicoCTF：纯英文，但题目设计非常适合零基础

第三步：学会复盘#

每做完一道题，建议写一篇简短的 writeup，记录：

题目考察的知识点
自己卡壳的地方
别人的更优解法

坚持复盘是快速成长的关键，优秀的 writeup 也可以投稿到本站，与大家分享。

社团训练计划#

社团 CTF 训练营每两周一次线下活动，形式包括：

入门专题讲座：由高年级社员或校外讲师主讲
组队模拟赛：还原真实比赛节奏，赛后集体复盘
年度重点赛事：组队参加 XCTF、强网杯、网鼎杯等赛事

具体时间安排请关注站内公告与社团群通知。

有问题随时在社团群里提问，期待在赛场上看到你的身影！

本博客的诞生记录：Astro + Firefly 建站全流程

Wed, 28 Oct 2026 00:00:00 GMT

为什么选择静态博客#

社团官网的核心需求很简单：展示文章、稳定、省资源、好维护。对比了几个方案：

方案	优点	缺点
WordPress	生态大、后台完善	PHP + MySQL，资源占用高，需要持续打补丁
Halo	国产、界面现代	需要 Java 运行时，内存占用高
Astro 静态站	零数据库、纯静态文件、速度快	更新内容需要重新构建

我们的服务器配置不高，静态方案几乎不占运行时资源，nginx 托管静态文件的内存开销可以忽略，安全性也远好于动态 CMS——最终选择 Astro + Firefly 主题。

技术栈一览#

1
博客框架     Astro v7（静态站点生成）
2
主题         Firefly（基于 Fuwari 二次开发）
3
包管理器     pnpm
4
源码托管     GitHub - 1376524890/cyberpioneer_blog
5
Web 服务     nginx（托管静态文件）
6
部署方式     源码推 GitHub → 服务器拉取构建 → 同步上线

本地开发流程#

Terminal window

1
# 安装依赖（需要 Node.js >= 22.23）
2
corepack enable
3
pnpm install
4

5
# 本地预览 http://localhost:4321
6
pnpm dev
7

8
# 构建静态站点到 dist/
9
pnpm build

写一篇新文章#

文章以 Markdown 格式存放在 src/content/posts/ 目录，只需复制一份模板修改 frontmatter：

1
---
2
title: 文章标题
3
published: 2026-10-28
4
description: 一句话摘要，会显示在列表页
5
tags: [标签1, 标签2]
6
category: 分类名
7
slug: url-friendly-slug
8
---
9

10
正文支持 Markdown……

保存后推送到 GitHub，服务器端拉取重新构建即可上线。

部署要点#

静态博客的部署非常简单：任意一台 Linux 服务器 + nginx 托管 dist/ 目录即可。下面是一份通用的 nginx 站点配置示例（端口与路径按自己环境调整）：

1
server {
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/ 同步到站点目录，一条脚本搞定。出于安全考虑，服务器的具体信息不在此公开。

一点心得#

静态博客把安全面缩到最小：没有数据库、没有后台登录、没有插件供应链
GitHub 管源码，服务器只管渲染结果，职责清晰
小内存机器跑 nginx + 静态文件毫无压力，轻松扛住校园级流量

如果你也想给社团或自己搭一个博客，欢迎在群里交流，我们可以出一份保姆级教程。

Web 安全入门：从一个 SQL 注入的诞生说起

Wed, 28 Oct 2026 00:00:00 GMT

从一段有问题的代码说起#

假设一个校园活动报名系统，用下面这段 PHP 代码验证用户登录：

1
<?php
2
// ⚠️ 危险代码，仅作教学演示
3
$username = $_POST['username'];
4
$password = $_POST['password'];
5

6
$sql = "SELECT * FROM users
7
        WHERE username='$username'
8
        AND password='$password'";
9

10
$result = $db->query($sql);
11
if ($result->num_rows > 0) {
12
    echo "登录成功";
13
}

这段代码在功能上完全正常——正常用户输入正确的账号密码，就能登录成功。

但问题出在：用户输入被直接拼接进了 SQL 语句。

注入是如何发生的#

如果攻击者在密码框输入：

1
' OR '1'='1

那么最终执行的 SQL 变成了：

1
SELECT * FROM users
2
WHERE username='admin'
3
AND password='' OR '1'='1'

由于 '1'='1' 恒为真，这个查询条件永远成立，攻击者在不知道密码的情况下以 admin 身份登录——这就是一次最经典的 SQL 注入攻击。

Warning

本文所有内容仅用于教学演示。对未授权系统进行测试是违法行为，请在合法靶场环境中练习。

更进一步：万能密码与信息刺探#

探测列数#

1
admin' ORDER BY 3-- -

逐步增大数字，根据页面报错判断查询结果的列数。

联合查询读取数据#

1
' UNION SELECT username, password FROM users-- -

通过 UNION 把数据库中的敏感数据直接拼进页面返回。

数据库指纹#

不同数据库的函数和报错信息各有特征：

数据库	探测语句
MySQL	`SELECT version()`
PostgreSQL	`SELECT version()`
SQLite	`SELECT sqlite_version()`

正确的防御姿势#

1. 参数化查询（最有效）#

预编译让用户输入永远只作为”数据”而不是”代码”被处理：

1
<?php
2
// ✅ 正确做法：参数化查询
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) 示例：

1
from sqlalchemy import text
2

3
# ✅ 绑定参数，输入不会被当作 SQL 执行
4
db.execute(
5
    text("SELECT * FROM users WHERE username=:u AND password=:p"),
6
    {"u": username, "p": password},
7
)

2. 最小权限原则#

应用连接数据库的账号只授予必要权限，即使被注入也难以 DROP TABLE。

3. 输入校验与 WAF#

对输入做白名单校验、部署 WAF 可以增加攻击难度，但都不能替代参数化查询。

动手练习#

想亲手试试？推荐这些合法靶场：

sqli-labs：经典的 SQL 注入练习靶场
DVWA：综合型 Web 漏洞演练平台
Pikachu：中文界面的入门友好靶场

社团活动室常年开放靶机环境，具体开放时间见群公告。

下一篇文章我们聊聊 XSS：当攻击者的脚本在你的浏览器里运行时会发生什么。