仙鹤的学习小窝

数据结构（综述）

Tue, 08 Sep 2026 00:00:00 GMT

数据结构

依据王道考研《数据结构》课程整理（本文件为全部章节的总笔记，随阅读逐章追加）。

第一章绪论

1.0 开篇——数据结构在学什么？

数据结构在学什么？

如何用程序代码把现实世界的问题信息化；
如何用计算机高效地处理这些信息从而创造价值。

人类文明三次浪潮（阿尔文·托夫勒《第三次浪潮》）：

浪潮	阶段	说明
第一次	农业（约 1 万年前）	学会农耕，从"动物"到"人类"
第二次	工业（17 世纪末）	出现枪炮与机械，导致古文明灭亡
第三次	信息化（正在到来）	高度信息化的世界，导致 ? ? ?

托夫勒："唯一可以确定的是，明天会使我们所有人大吃一惊。"

"信息化"：把现实事物用计算机表示。

现实事物	信息化后的表示
财富（存钱罐）	电子零钱（浮点型变量 `float`）
排队（海底捞取号）	号单/用户号（数组？还是…）
友谊（朋友圈/粉丝）	社交网络（粉丝列表、二维码）

学完 C 语言后，如何用计算机表示这些信息、并高效处理 → 这就是数据结构要解决的问题。

计算机系统分层（信息化世界）：一台计算机/手机 = 计组（硬件） → 操作系统 → C、数据结构（软件）；多台计算机之间通过计算机网络互联，构成"信息化世界"。

1.1 数据结构的基本概念

学习建议：概念多但较基础，抓大放小、形成框架。讨论一种数据结构时，关注"三要素"。

知识总览：

graph LR
    V[数据结构] --> A[基本概念]
    V --> B[三要素]
    A --> A1[数据]
    A --> A2[数据元素、数据项]
    A --> A3[数据对象、数据结构]
    A --> A4[数据类型、抽象数据类型 ADT]
    B --> B1[逻辑结构]
    B --> B2[物理结构（存储结构）]
    B --> B3[数据的运算]

1. 什么是数据

数据：信息的载体，是描述客观事物属性的数、字符及所有能输入到计算机中并被计算机程序识别和处理的符号的集合。数据是计算机程序加工的原料。（计算机内以二进制 0/1 表示。）

2. 数据元素、数据项

数据元素：数据的基本单位，通常作为一个整体来考虑和处理。
数据项：构成数据元素的不可分割的最小单位。
一个数据元素可由若干数据项组成；根据实际业务需求确定"什么是数据元素、什么是数据项"。例：海底捞取号记录 = {号数、取号时间、就餐人数}；微博账号 = {昵称、性别、生日（年/月/日可为"组合项"）}。

3. 数据结构、数据对象

结构：各个元素之间的关系（如汉字"沙 / 粥 / 曼"的不同结构）。
数据结构：相互之间存在一种或多种特定关系的数据元素的集合。
数据对象：具有相同性质的数据元素的集合，是数据的一个子集。例：数据结构 = 某个特定门店的排队顾客信息及其关系；数据对象 = 全国所有门店的排队顾客信息。

4. 数据结构的三要素

讨论一种数据结构要关注：逻辑结构、物理结构（存储结构）、数据的运算。

① 逻辑结构（数据元素之间的逻辑关系是什么？）：

graph LR
    L[逻辑结构] --> A[集合]
    L --> B[线性结构]
    L --> C[树形结构]
    L --> D[图状结构]

逻辑结构	关系	例子
集合	各元素同属一个集合，别无其他关系	火锅配料
线性结构	一对一；除第一个外均有唯一前驱，除最后一个外均有唯一后继	排队取号、烤串
树形结构	一对多	文件系统目录
图状结构（网状）	多对多	微信好友

线性结构 = 一对一；集合、树形、图状结构 = 非线性结构。

② 物理结构（存储结构）（如何用计算机表示数据元素的逻辑关系？）：

存储结构	含义
顺序存储	逻辑上相邻的元素在物理位置上也相邻，关系由存储单元的邻接关系体现
链式存储	逻辑上相邻的元素物理位置可不相邻，借助指针表示逻辑关系
索引存储	存储元素信息的同时建立附加的索引表，索引项形如（关键字，地址）
散列存储	根据元素关键字直接算出存储地址（又称 Hash 存储）

链式、索引、散列属于非顺序存储。 绪论只需理解两点：①顺序存储元素物理上必须连续，非顺序存储可以离散；②存储结构会影响存储空间分配的方便程度（如"有人插队"）；③存储结构会影响对数据运算的速度（如"找第三个人"）。

③ 数据的运算：运算的定义针对逻辑结构（指出功能），运算的实现针对存储结构（指出操作步骤）。例：队列逻辑结构（海底捞排队）定义运算：①队头元素出队；②新元素入队；③输出队列长度。

5. 数据类型、抽象数据类型（ADT）

数据类型：一个值的集合和定义在此集合上的一组操作的总称。

原子类型：其值不可再分的数据类型（如 bool、int）。
结构类型：其值可再分解为若干成分（分量）的数据类型（如 struct Customer{ int num; int people; }）。

类型	值的范围	可进行的操作
bool	true / false	与、或、非
int	-2147483648 ~ 2147483647	加、减、乘、除、模…
struct Customer	num∈1~9999，people∈1~12	如"拼桌"运算

抽象数据类型（ADT, Abstract Data Type）：抽象数据组织及与之相关的操作。用数学化的语言定义数据的逻辑结构、定义运算，与具体的实现无关。

重要结论：

定义了一个 ADT，就是定义了数据的逻辑结构、数据的运算，即定义了一个数据结构。

确定一种存储结构，就表示出了逻辑结构；存储结构不同，运算的具体实现也不同；确定了存储结构才能实现数据结构。

数据结构这门课看重的是数据元素之间的关系和对这些数据元素的操作，而不关心具体的数据项内容。

1.2.1 算法的基本概念

什么是算法？

程序 = 数据结构 + 算法（数据结构是要处理的信息；算法是处理信息的步骤）。
算法（Algorithm）：对特定问题求解步骤的一种描述，是指令的有限序列，其中的每条指令表示一个或多个操作。
例：做番茄炒蛋（食材+步骤）；对线性表按年龄递增排序（选择排序 Step1~Step4）。

程序设计 = 设计一个好的数据结构 + 设计一个好的算法。

算法的五个特性：

特性	含义
有穷性	算法总在执行有穷步后结束，且每一步都能在有穷时间内完成
确定性	每条指令必须有确切的含义，相同输入只能得出相同的输出
可行性	描述的每一步都能通过已实现的基本运算执行有限次来实现
输入	有零个或多个输入，取自某个特定对象的集合
输出	有一个或多个输出，是与输入有某种特定关系的量

注：算法必须是有穷的，而程序可以是无穷的（如微信是程序，不是算法）。

"好"算法的特质（设计时要尽量追求的目标）：

正确性：能正确地解决求解问题。
可读性：描述要让别人看得懂（可由代码/伪代码/文字描述，重要的是无歧义）。
健壮性：输入非法数据时能恰当地反应或处理，不产生莫名其妙的输出。
高效率与低存储量需求：省时、省内存，即时间复杂度低、空间复杂度低。

1.2.2 算法的时间复杂度

如何评估算法时间开销？

让算法先运行、事后统计运行时间？存在问题：和机器性能、编程语言、编译程序指令质量有关；有些算法不能事后统计（如导弹控制算法）。
应事前预估：算法时间复杂度 = 事前预估算法时间开销 $T(n)$ 与问题规模 $n$ 的关系（T 表示 time）。

大 O 表示法：$T(n) = O(f(n))$，表示二者同阶/同等数量级（当 $n \to \infty$ 时二者之比为常数）。只考虑阶数高的部分，系数和低次幂可忽略。

计算规则：

加法规则：$T(n) = O(f(n)) + O(g(n)) = O(\max(f(n), g(n)))$ —— 多项相加，只保留最高阶项，系数变为 1。
乘法规则：$T(n) = O(f(n)) \times O(g(n)) = O(f(n)\times g(n))$ —— 多项相乘，都保留。

常用技巧：顺序执行的代码只影响常数项（忽略）；只需挑循环中的一个基本操作、分析其执行次数与 n 的关系；多层嵌套循环只需关注最深层循环循环了几次。

三种时间复杂度：

类型	含义
最坏时间复杂度	考虑输入数据"最坏"的情况
平均时间复杂度	所有输入示例等概率出现时算法的期望运行时间
最好时间复杂度	考虑输入数据"最好"的情况

很多算法执行时间与输入数据有关（如顺序查找）；算法性能问题在 n 很大时才会暴露。

如何计算：①找一个基本操作（最深层循环）→ ②分析其执行次数 $x$ 与问题规模 $n$ 的关系 $x=f(n)$ → ③取 $O(x)$ 即 $T(n)$。

例题：

逐步递增：int i=1; while(i<=n){ i++; printf(...); } → $T(n)=3n+3=O(n)$。
指数递增：i=i*2 每次翻倍 → 最深层循环语句频度 $x$，结束时 $2^x>n$，$x=\log_2 n+1$ → $T(n)=O(\log_2 n)$。
顺序查找（数组中找元素 n）：最好 $O(1)$、最坏 $O(n)$、平均 $\frac{1+2+\dots+n}{n}=\frac{1+n}{2}$ → $O(n)$。

常见复杂度排序（口诀"常对幂指阶"）：

$$O(1) < O(\log_2 n) < O(n) < O(n\log_2 n) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)$$

1.2.3 算法的空间复杂度

空间复杂度：空间开销（内存开销）与问题规模 $n$ 的关系，记作 $S(n) = O(f(n))$（S 表示 Space）。

程序运行时的内存需求：

程序代码：大小固定，与问题规模无关；
数据：局部变量、参数等，其中与 $n$ 相关的变量才影响空间复杂度。

原地工作：算法所需内存空间为常量，即 $S(n) = O(1)$。（如算法1 逐步递增型爱你，无论 $n$ 怎么变，内存都是固定常量。）

例题：

程序	所需空间	$S(n)$
`int flag[n]; int i;`	$\approx 4n+8$	$O(n)$
`int flag[n][n];`	$n\times n$	$O(n^2)$
`flag[n][n] + other[n] + i`	$O(n^2)+O(n)+O(1)$	$O(n^2)$（加法规则）
递归 `loveYou(n)`（各层存参数 n）	递归深度 $n$	$O(n)$
递归 `loveYou(n)`（各层存 `flag[n]` 数组）	$1+2+\dots+n=\frac{n(n+1)}{2}$	$O(n^2)$

递归的空间复杂度 = 递归调用的深度（若各层所需存储空间不同，分析方法略有区别）。

如何计算空间复杂度：

普通程序：①找到所占空间大小与问题规模相关的变量 → ②分析其所占空间 $x$ 与 $n$ 的关系 $x=f(n)$ → ③取 $O(x)$ 即 $S(n)$；
递归程序：找到递归调用的深度 $x$ 与 $n$ 的关系，取 $O(x)$ 即 $S(n)$。

常用技巧：同时间复杂度，加法/乘法规则、"常对幂指阶"（$O(1)<O(\log_2 n)<O(n)<O(n\log_2 n)<O(n^2)<O(n^3)<O(2^n)<O(n!)$）。

小结

基本概念：数据、数据元素/数据项、数据对象/数据结构、数据类型/抽象数据类型 ADT。
数据结构的三要素：逻辑结构（集合/线性/树形/图状，即线性与非线性）、物理结构/存储结构（顺序/链式/索引/散列，后三者非顺序）、数据的运算（定义针对逻辑结构、实现针对存储结构）。
算法：程序 = 数据结构 + 算法；算法的五个特性（有穷性、确定性、可行性、输入、输出），"好"算法特质（正确、可读、健壮、高效低存储）。
时间复杂度：$T(n)=O(f(n))$；加法/乘法规则；"常对幂指阶"；最好/最坏/平均。
空间复杂度：$S(n)=O(f(n))$；原地工作 $O(1)$；递归空间 = 递归深度。
主考点：定义了一个 ADT 就是定义了一个数据结构；存储结构影响运算实现；复杂度用大 O 只留最高阶。

第二章线性表

2.1 线性表的定义和基本操作

线性表（Linear List）定义：是具有相同数据类型的 $n$（$n\ge0$）个数据元素的有限序列。$n$ 为表长，$n=0$ 时是空表。用 $L$ 命名线性表，一般表示为：

$$L = (a_1,\ a_2,\ \dots,\ a_i,\ a_{i+1},\ \dots,\ a_n)$$

特性：①元素个数有限；②元素类型相同（每个元素所占空间一样大）；③元素有次序。

重要术语：

$a_i$ 是线性表中的"第 $i$ 个"元素——线性表中的位序（从 1 开始，注意数组下标从 0 开始，用数组实现线性表时要审题）。
$a_1$ 是表头元素，$a_n$ 是表尾元素。
除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继。

Eg：所有整数按递增次序排列，是线性表吗？——否（无限序列，不是线性表）。

graph LR
    A1[a1] --> A2[a2] --> A3[a3] --> A4[a4] --> A5[a5]

基本操作（记忆思路：创销、增删改查）：

操作	功能	说明
InitList(&L)	初始化表	构造空表，分配内存空间（从无到有）
DestroyList(&L)	销毁表	释放线性表占用的内存空间（从有到无）
ListInsert(&L,i,e)	插入	在表 L 第 i 个位置插入元素 e（增）
ListDelete(&L,i,&e)	删除	删除表 L 第 i 个位置的元素，用 e 返回其值（删）
LocateElem(L,e)	按值查找	在表 L 中查找具有给定关键字值的元素
GetElem(L,i)	按位查找	获取表 L 第 i 个位置的元素的值
Length(L)	求表长	返回 L 中数据元素的个数
PrintList(L)	输出	按前后顺序输出 L 的所有元素
Empty(L)	判空	若 L 为空表返回 true，否则 false

为什么要实现基本操作：①团队合作编程，定义的 ADT 要让人方便使用（封装）；②将常用操作封装成函数，避免重复工作、降低出错风险。 改、查（本质是"定位"）：改之前也要先"查"（LocateElem / GetElem）。

什么时候要传入参数的引用 &：对参数的修改结果需要"带回来"时。如 InitList(&L)、DestroyList(&L)、ListInsert(&L,i,e)、ListDelete(&L,i,&e)；而 LocateElem(L,e)、GetElem(L,i) 只读，不加 &。

void test(int &x){ x = 1024; ... }   // 引用传递，x 的修改"带回来了"
int x = 1;  test(x);                 // 调用后 x=1024

Tips：比起学会"How"，更重要的是想明白"Why"；函数命名要有可读性。

2.2.1 顺序表的定义

顺序表：用顺序存储的方式实现线性表。顺序存储把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。（即用"数组"存放数据元素。）

元素地址：设线性表第一个元素存放位置为 LOC(L)（location 的缩写），则第 $i$ 个元素地址 = LOC(L) + $(i-1)\times$ sizeof(ElemType)。用 C 语言 sizeof(ElemType) 得到元素大小（如 sizeof(int)=4B，sizeof(Customer)=8B）。

顺序表的实现——静态分配：

#define MaxSize 10                 // 定义最大长度
typedef struct {
    ElemType data[MaxSize];        // 用静态的"数组"存放数据元素
    int length;                    // 顺序表的当前长度
} SqList;                          // 顺序表类型定义（静态分配）

Sq = sequence（顺序、序列）。给数据元素分配连续存储空间，大小为 MaxSize × sizeof(ElemType)。

表长一开始就确定、无法更改（静态）。存满就"放弃治疗"；若一开始就声明很大的空间，又会浪费。

顺序表的实现——动态分配（静态数组存满无法扩容，用动态数组）：

#define InitSize 10
typedef struct {
    ElemType *data;    // 指示动态分配数组的指针
    int MaxSize;       // 顺序表的最大容量
    int length;        // 顺序表的当前长度
} SeqList;             // 动态分配方式

L.data = (ElemType *) malloc(sizeof(ElemType) * InitSize);   // 申请一片连续空间

C 用 malloc / free（头文件 <stdlib.h>），C++ 用 new / delete。
动态扩容（IncreaseSize(&L, len)）：int *p = L.data; L.data = (int *) malloc((L.MaxSize + len) * sizeof(int)); for(...) L.data[i]=p[i]; L.MaxSize += len; free(p);
注：可用 realloc 实现，但建议初学者用 malloc / free 以理解过程；扩容要把旧数据复制到新区域，时间开销大（O(n)）。

顺序表的特点：

特点	说明
随机访问	能在 $O(1)$ 时间内找到第 $i$ 个元素（`data[i-1]`，位序从 1、下标从 0）
存储密度高	每个节点只存储数据元素，无指针
拓展容量不方便	静态分配无法改变；动态分配扩容也要搬移数据（$O(n)$）
插入、删除不方便	需要移动大量元素

2.2.2_1 顺序表的插入和删除

插入：ListInsert(&L, i, e) —— 在表 L 的第 i 个位置插入元素 e。

bool ListInsert(SqList &L, int i, int e){
    if(i < 1 || i > L.length + 1) return false;   // 判断 i 的范围是否有效
    if(L.length >= MaxSize) return false;          // 当前存储空间已满，不能插入
    for(int j = L.length; j >= i; j--)             // 将第 i 个元素及之后的元素后移
        L.data[j] = L.data[j-1];
    L.data[i-1] = e;                               // 在位置 i 处放入 e
    L.length++;                                     // 长度 +1
    return true;
}

注意位序 i 与数组下标关系：元素后移时从表尾元素开始往前移动。
健壮性：if 判断 i 是否合法、空间是否已满，返回 bool 给使用者反馈。

插入时间复杂度（问题规模 n = L.length）：

情况	说明	复杂度
最好	插到表尾（i=n+1），0 次移动	$O(1)$
最坏	插到表头（i=1），n 次移动	$O(n)$
平均	各位置概率 $\frac{1}{n+1}$，平均移动 $\frac{n}{2}$	$O(n)$

删除：ListDelete(&L, i, &e) —— 删除表 L 第 i 个位置的元素，并用 e 返回其值。

bool ListDelete(SqList &L, int i, int &e){
    if(i < 1 || i > L.length) return false;   // 判断 i 的范围是否有效
    e = L.data[i-1];                           // 将被删除的元素赋值给 e
    for(int j = i; j < L.length; j++)          // 将第 i 个位置后的元素前移
        L.data[j-1] = L.data[j];
    L.length--;                                 // 长度 -1
    return true;
}

元素前移时从靠前的元素开始（与插入的后移相反，注意别弄反）。
e 加了 &，因为要把删除的值"带回来"；不加 & 传的是复制品，改不回去。

删除时间复杂度（问题规模 n = L.length）：

情况	说明	复杂度
最好	删除表尾（i=n），0 次移动	$O(1)$
最坏	删除表头（i=1），n-1 次移动	$O(n)$
平均	各位置概率 $\frac{1}{n}$，平均移动 $\frac{n-1}{2}$	$O(n)$

2.2.2_2 顺序表的查找

按位查找：GetElem(L, i) —— 获取表 L 第 i 个位置的元素的值。

ElemType GetElem(SeqList L, int i){
    return L.data[i-1];      // 位序 i 对应数组下标 i-1
}

时间复杂度 $O(1)$：顺序表数据元素在内存中连续存放，根据起始地址 + 元素大小可立即定位第 i 个元素（随机存取特性）。
指针类型决定"步长"：data[i] = 起始地址 + i×sizeof(ElemType)；malloc 返回 void*，需强制转换成 ElemType*。

按值查找：LocateElem(L, e) —— 在表 L 中查找第一个元素值等于 e 的元素，返回其位序（找不到返回 0）。

int LocateElem(SeqList L, ElemType e){
    for(int i = 0; i < L.length; i++)
        if(L.data[i] == e)  return i + 1;   // 数组下标 i 对应位序 i+1
    return 0;                               // 退出循环，查找失败
}

基本数据类型（int、char、double、float…）可直接用 == 比较；
结构类型不能直接用 ==（C 语言会报错），需逐分量比较，或封装成 isCustomerEqual(a, b) 函数；考研初试手写代码可直接用 ==（主要考算法思想）。

按值查找时间复杂度（问题规模 n = L.length）：

情况	说明	复杂度
最好	目标元素在表头，循环 1 次	$O(1)$
最坏	目标元素在表尾，循环 n 次	$O(n)$
平均	各位置概率 $\frac{1}{n}$，平均 $\frac{n+1}{2}$ 次	$O(n)$

2.3.1 单链表的定义

单链表：用链式存储（存储结构）实现了线性结构（逻辑结构）。每个结点存储一个数据元素，各结点间的先后关系用一个指针表示。

	顺序表（顺序存储）	单链表（链式存储）
优点	可随机存取，存储密度高	不要求大片连续空间，改变容量方便
缺点	要求大片连续空间，改变容量不方便	不可随机存取，要耗费空间存放指针

graph LR
    H[头指针 L] --> N1[a1] --> N2[a2] --> N3[a3] --> N4[a4] --> N5[NULL]

用代码定义一个单链表：

typedef struct LNode{      // 定义单链表结点类型
    ElemType data;         // 数据域，存放一个数据元素
    struct LNode *next;    // 指针域，指向下一个结点
}LNode, *LinkList;

typedef <数据类型> <别名>：给类型重命名。LNode 是结点类型，LinkList 等价于 LNode *。前者强调"是一个结点"，后者强调"这是一个单链表"，合适的地方用合适的名字可读性更高。
新建结点：LNode * p = (LNode *) malloc(sizeof(LNode));（malloc 返回 void*，需强制转换）。

两种实现方式：带头结点 / 不带头结点（头结点不存放数据，只是为了操作方便）：

	不带头结点	带头结点
初始化	`InitList(&L){ L = NULL; }`	`InitList(&L){ L = (LNode*)malloc(sizeof(LNode)); L->next = NULL; }`
空表判断	`L == NULL`	`L->next == NULL`
写代码	麻烦（首个/后续结点、空表/非空表逻辑不同）	更方便（统一处理）

头指针 L 就代表整个单链表；因为要修改头指针，InitList 的参数要加 & 引用。

2.3.2_1 单链表的插入和删除

插入：

① 按位序插入 ListInsert(&L, i, e)：在第 i 个位置插入元素 e，核心是找到第 i-1 个结点，把新结点插到它后面。

bool ListInsert(LinkList &L, int i, ElemType e){
    if(i < 1) return false;
    LNode *p; int j = 0;
    p = L;                                // 头结点看作第 0 个结点
    while(p != NULL && j < i-1){ p = p->next; j++; }   // 找到第 i-1 个结点
    if(p == NULL) return false;
    LNode *s = (LNode *) malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;                    // 先连（顺序不能颠倒）
    p->next = s;                          // 再断
    return true;
}

时间复杂度：最好 $O(1)$（插表头 i=1），最坏 $O(n)$（插表尾），平均 $O(n)$。
不带头结点：不存在"第 0 个"结点，i=1 需特殊处理（改头指针 L）。

② 指定结点的后插 InsertNextNode(p, e)：s->next = p->next; p->next = s; —— $O(1)$。

③ 指定结点的前插 InsertPriorNode(p, e)：偷天换日——把新结点 s 插到 p 后面，再交换数据，$O(1)$：

s->next = p->next; p->next = s;
s->data = p->data;      // 把 p 中元素复制到 s
p->data = e;            // p 覆盖为 e

删除：

① 按位序删除 ListDelete(&L, i, &e)：找到第 i-1 个结点，令其指向第 i+1 个结点，释放第 i 个结点。

bool ListDelete(LinkList &L, int i, ElemType &e){
    if(i < 1) return false;
    LNode *p; int j = 0; p = L;
    while(p != NULL && j < i-1){ p = p->next; j++; }
    if(p == NULL) return false;
    if(p->next == NULL) return false;      // 第 i-1 个结点之后已无其余结点
    LNode *q = p->next;
    e = q->data;
    p->next = q->next;                     // 将 *q 从链中"断开"
    free(q);
    return true;
}

时间复杂度：最好 $O(1)$（删表头），最坏/平均 $O(n)$。

② 指定结点的删除 DeleteNode(p)：

方法 1：传入头指针，循环找到 p 的前驱，改前驱的 next。
方法 2：偷天换日——把 p->next 的数据复制到 p，再删除 p->next，$O(1)$。

有坑：p 是最后一个结点时（p->next == NULL），方法 2 要特殊处理。

Tips：这些代码都要会写；注意审题（带头否？）；体会"封装"的好处。

2.3.2_2 单链表的查找

按位查找 GetElem(L, i)：返回第 i 个结点（头结点看作第 0 个结点）。

LNode * GetElem(LinkList L, int i){
    if(i < 0) return NULL;
    LNode *p; int j = 0;
    p = L;                                       // 头结点为第 0 个结点
    while(p != NULL && j < i){ p = p->next; j++; }
    return p;                                     // i 超过表长时返回 NULL
}

时间复杂度 $O(n)$：[单链表不具备"随机访问"特性，只能依次扫描]（对比顺序表是 $O(1)$）。
王道书版本用 j=1; p=L->next；if(i==0) return L; if(i<1) return NULL;。

按值查找 LocateElem(L, e)：返回第一个数据域等于 e 的结点指针，找不到返回 NULL。

LNode * LocateElem(LinkList L, ElemType e){
    LNode *p = L->next;                          // 从第 1 个结点开始查找
    while(p != NULL && p->data != e) p = p->next;
    return p;
}

平均时间复杂度 $O(n)$。（ElemType 是复杂结构类型时需逐分量比较，同顺序表。）

求单链表长度 Length(L)：

int Length(LinkList L){
    int len = 0; LNode *p = L;
    while(p->next != NULL){ p = p->next; len++; }
    return len;
}

时间复杂度 $O(n)$。

对比：顺序表可"随机存取"（$O(1)$ 按位访问）；单链表只能依次扫描，三种基本操作（按位插入/删除/查找）平均都是 $O(n)$。写循环扫描时要注意边界条件。

Java 核心与 AI 开发进阶

Sun, 06 Sep 2026 00:00:00 GMT

Java核心与AI开发进阶

第十二章：集合高级

集合是长度可变的容器。Java 集合按"单列/双列"分为两大体系：单列（一次添加一个元素，对应 Collection 接口）和双列（一次添加两个元素即键值对，对应 Map 接口）。本篇覆盖 Collection、List、常用数据结构、ArrayList / LinkedList 以及泛型基础。

一、集合体系结构

整体划分：

分类	顶层接口	子接口 / 实现类	一次添加	特点
<span style="color:blue">单列集合</span>	`Collection`	`List`：ArrayList、LinkedList	1 个元素	有序
单列集合	`Collection`	`Set`：TreeSet、HashSet、LinkedHashSet	1 个元素	无序
<span style="color:green">双列集合</span>	`Map`	TreeMap、HashMap、LinkedHashMap	2 个元素（键值对）	键不可重复

List 与 Set 的核心区别：

接口	存取	索引	重复元素
<span style="color:blue">List 接口</span>	存取有序	有	<span style="color:orange">可以</span>存储重复
<span style="color:green">Set 接口</span>	存取无序	<span style="color:red">没有</span>	<span style="color:red">不可以</span>存储重复

注意：单列集合调用 add(元素)，双列集合调用 put(键, 值)。

二、Collection 接口的使用

Collection 是所有单列集合的父接口，其内部方法（add / remove / contains / …）所有单列集合都可以使用。

方法	说明
`public boolean add(E e)`	把给定的对象添加到当前集合中
`public void clear()`	清空集合中所有的元素
`public boolean remove(E e)`	把给定的对象在当前集合中删除
`public boolean contains(Object obj)`	判断当前集合中是否包含给定的对象
`public boolean isEmpty()`	判断当前集合是否为空
`public int size()`	返回集合中元素的个数（集合的长度）

⚠ 关键点：remove() 与 contains() 方法底层依赖对象的 equals 方法判断是否相等。若集合中存的是自定义对象（如 Student），未重写 equals 时会调用 Object.equals（比地址），需重写才能按内容比较。

三、集合的通用遍历方式

通用遍历方式有三种，Set 没有索引不能用普通 for 循环，所以后两种才真正"通用"。

方式	适用场景	备注
<span style="color:blue">普通 for 循环</span>	仅 `List`（需索引）	写法 `list.get(i)`，Set 不可用
<span style="color:green">迭代器</span> Iterator	所有 Collection	`hasNext()` 判断 + `next()` 取值并后移
<span style="color:orange">增强 for 循环</span>	所有 Collection 与数组	JDK5 引入，内部原理就是 Iterator

普通 for（仅 List）：

ArrayList<String> list = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
    String s = list.get(i);
}

迭代器：

Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String s = it.next();
    System.out.println(s);
}

注意：next() 方法会取出当前元素并将指针向后移动一位。调用次数不能超过 hasNext() 的次数，否则抛 NoSuchElementException。

增强 for（语法糖）：

for (String s : list) {          // 内部就是 Iterator
    System.out.println(s);
}

四、List 接口

List 因为支持索引，所以在 Collection 基础上多了一组"索引操作"的独特 API。

方法	说明
`void add(int index, E element)`	在集合中的指定位置插入指定元素
`E remove(int index)`	删除指定索引处的元素，返回被删除的元素
`E set(int index, E element)`	修改指定索引处的元素，返回被修改的元素
`E get(int index)`	返回指定索引处的元素

List 接口的 5 种遍历方式：迭代器 Iterator、增强 for、foreach 方法、普通 for 循环、列表迭代器 ListIterator。

4.1 并发修改异常

使用迭代器遍历集合的过程中，调用了集合对象的 add / remove 方法，就会出现 ConcurrentModificationException（并发修改异常）。

想要的操作	正确做法
迭代过程中做<span style="color:red">删除</span>	使用 `Iterator` 自带的 `remove` 方法
迭代过程中做<span style="color:green">添加</span>	使用 `ListIterator` 自带的 `add` 方法

// 错误写法：会抛 ConcurrentModificationException
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String s = it.next();
    if ("xxx".equals(s)) {
        list.remove(s);          // ❌
    }
}

// 正确写法：用迭代器自己的 remove()
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String s = it.next();
    if ("xxx".equals(s)) {
        it.remove();             // ✅
    }
}

五、数据结构

集合的"底层"就是数据结构：ArrayList 用数组，LinkedList 用链表，Stack / Queue 用栈 / 队列。理解数据结构才能选对集合。

5.1 栈（Stack）

栈是一种 先进后出（后进先出） 的线性表，像弹匣——只有一端开口（栈顶），另一端封闭（栈底）。

操作	别名	方向
入栈	压栈 / push	从栈顶进入
出栈	弹栈 / pop	从栈顶出去

flowchart TB
  A["数据A"] -->|压栈| B["数据A 数据B"]
  B -->|压栈| C["数据A 数据B 数据C"]
  C -->|弹栈| B
  B -->|弹栈| A

5.2 队列（Queue）

队列是 先进先出 的线性表，像排队——两端都开口。

位置	操作	方向
后端（rear）	入队 / offer	元素从后端进入
前端（front）	出队 / poll	元素从前端出去

5.3 数组（Array）

数组在内存中连续存储，每个元素有固定下标（索引）。

优点	缺点
<span style="color:green">查询速度快</span>：通过地址值 + 索引定位，查询任意数据耗时相同	<span style="color:red">增删效率低</span>：新增 / 删除数据时，可能大批量移动数组中其他元素

5.4 链表（Linked List）

链表中的结点是独立的内存块，结点之间通过"下一个结点地址"串联，内存不连续。

优点	缺点
<span style="color:green">增删相对快</span>：只需要改变相邻结点的地址指向	<span style="color:red">查询慢</span>：无论查哪个数据都要从头开始找

单向链表 vs 双向链表：

类型	存储内容	遍历方向
<span style="color:blue">单向链表</span>	数据 + 下一个结点地址	只能从头到尾
<span style="color:green">双向链表</span>	前一个结点地址 + 数据 + 下一个结点地址	可前后双向，查找第 N 个元素更灵活

链表的插入过程（在数据 A、C 之间插入 B）：

数据 B 对应的下一个数据地址指向数据 C
数据 A 对应的下一个数据地址指向数据 B

六、ArrayList 类

ArrayList 底层是数组实现的，因此根据索引查询元素快，增删相对慢。

6.1 长度可变原理

flowchart LR
  S1["1. 底层创建 长度 10 的空数组"] --> S2["2. 存满后扩容 原数组 × 1.5"]
  S2 --> S3["3. 拷贝原数据 到新数组"]
  S3 --> S4["4. 添加新元素 到新数组"]

四步概括：① 初始长度 10 的空数组 → ② 存满后扩容 1.5 倍 → ③ 旧数据拷贝到新数组 → ④ 新元素添加到新数组。

6.2 源码解析

步骤	行为
①	使用空参构造器创建的集合，底层会创建一个默认长度为 0 的数组
②	添加第一个元素时，底层会创建一个新的长度为 10 的数组
③	数组存满时，会扩容 1.5 倍

6.3 LinkedList 类

LinkedList 底层基于双链表实现：查询元素慢，增删首尾元素非常快。

特有方法	说明
`public void addFirst(E e)`	在该列表开头插入指定的元素
`public void addLast(E e)`	将指定的元素追加到此列表的末尾
`public E getFirst()`	返回此列表中的第一个元素
`public E getLast()`	返回此列表中的最后一个元素
`public E removeFirst()`	从此列表中删除并返回第一个元素
`public E removeLast()`	从此列表中删除并返回最后一个元素

思考：LinkedList 也有 get(int index) 方法，表面看起来是根据索引获取元素，实际上要从头 / 尾开始逐个查找，所以查询性能差；如果大量查询请用 ArrayList，大量首尾增删请用 LinkedList。

七、泛型（Generics）

JDK5 引入的特性，可以在编译阶段约束操作的数据类型，并进行检查。

7.1 泛型的好处

统一数据类型
将运行期的错误提升到编译期（编译时就能发现类型不匹配）

⚠ 注意事项：泛型中只能编写引用数据类型，不能写基本类型（要用包装类：int → Integer、double → Double）。

// ❌ 错误
ArrayList<int> list = new ArrayList<>();

// ✅ 正确
ArrayList<Integer> list = new ArrayList<>();

7.2 泛型类

在类名后用 <E> 声明类型占位符，类中即可用 E 表示"某种类型"。

public class ArrayList<E> {
    public boolean add(E e) { ... }
}

7.3 泛型方法

场景	泛型声明方式
<span style="color:blue">非静态方法</span>	泛型根据类的泛型去匹配
<span style="color:green">静态方法</span>	需要自己声明独立的泛型（静态先于对象存在，无法用类的泛型）

// 非静态：使用类上声明的 E
public class ArrayList<E> {
    public boolean add(E e) { ... }
}

// 静态：必须自己声明 <T>
public static <T> void printArray(T[] array) { ... }

7.4 泛型接口

类实现带泛型的接口时，有两种操作方式：

实现接口时直接确定类型：public class ArrayList<E> implements List<E>
保持接口的泛型，等创建对象时再确定：public class ArrayList<E> implements List<E>

7.5 泛型通配符 `?`

用于方法形参接收"任意类型"的集合，常配合上下限 ? extends T / ? super T 使用（进阶内容，留到后续章节）。

集合高级（2）

本篇聚焦 Set 家族（TreeSet / HashSet / LinkedHashSet）和 Map 家族（HashMap / LinkedHashMap / TreeMap）的实现原理、API 与遍历方式，以及 Collections 工具类的常用方法（含可变参数）。

一、Set 集合介绍

Set 接口是 Collection 的子接口。Set 实现类有 3 个：TreeSet / HashSet / LinkedHashSet，整体特点是：存取顺序不一致，没有跟索引有关的方法，不能存储重复元素。

实现类	特点	底层
<span style="color:blue">TreeSet</span>	<span style="color:green">元素排序</span>	红黑树
<span style="color:green">HashSet</span>	<span style="color:orange">元素唯一</span>（不保证顺序）	哈希表
<span style="color:blue">LinkedHashSet</span>	元素唯一，<span style="color:green">保证存取顺序</span>	哈希表 + 双向链表

注意：Set 没有索引，三种通用遍历方式（迭代器 / 增强 for / foreach）都可用，普通 for 循环不可用。

二、TreeSet 集合

TreeSet 特点是元素按规则排序（默认自然排序 / 自定义比较器），本质底层是红黑树（一种自平衡的二叉查找树）。

2.1 底层数据结构演进

数据结构	规则	缺点
普通的二叉树	父结点只跟子结点相连	退化成链表时查询效率 O(n)
<span style="color:green">二叉查找树</span>（二叉排序树）	小的存左边，大的存右边，一样的不存	数据倾斜时仍可能退化成链表
<span style="color:blue">平衡二叉树</span>	在满足查找二叉树规则下，让树尽可能矮小，提高查询性能	频繁旋转开销大
<span style="color:green">红黑树</span>（TreeSet 实际用）	近似平衡的二叉查找树，规则更灵活，旋转更少	—

2.2 两种排序方式

TreeSet 支持两种排序方式：自然排序（元素自身实现 Comparable）和比较器排序（构造时传入 Comparator）。

自然排序三步骤：

类实现 Comparable 接口
重写 compareTo 方法
根据 compareTo 返回值组织排序规则：负数：左边走、正数：右边走、0：不存

public class Student implements Comparable<Student> {
    @Override
    public int compareTo(Student o) {
        return this.age - o.age;   // 按年龄升序
    }
}

注意：TreeSet 取出的顺序是左中右（中序遍历），张三, 23 李四, 24 王五, 25 赵六, 26。

比较器排序：当同具备自然排序和比较器排序时，会优先按照比较器进行排序操作。当 String / Integer / Double 等内置自然排序规则不符合需求时（如 String 是字典序，需要按长度排），使用比较器排序。

三、HashSet 集合

HashSet 特点：元素唯一、不保证顺序。底层是哈希表，因此存取速度快。

3.1 `hashCode` 与 `equals` 配合流程

哈希值是一个 int 类型的随机值，Java 中每个对象都有一个哈希值（由 Object.hashCode() 底层 C++ 计算）。自定义对象必须按"内容"实现 hashCode + equals，否则重复元素识别不出来。

hashCode 的作用：定位元素应存入哪个桶（数组下标）；equals 的作用：同一桶内的元素去重判断。

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Student student = (Student) o;
    return age == student.age && Objects.equals(name, student.name);
}

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

⚠ 关键点：根据对象内容生成 hash 值，不同的对象 hash 值也可能相等（如 "重地" 和 "通话"），这种现象叫 哈希碰撞。

3.2 HashSet 底层原理

HashSet 底层就是 HashMap，存储流程基于哈希表（JDK 8 前后结构不同）。

版本	底层结构
JDK 8 之前	<span style="color:blue">数组 + 链表</span>
JDK 8 之后	<span style="color:green">数组 + 链表 + 红黑树</span>

哈希表存储数据的详细流程：

flowchart TD
  S1["① 创建默认长度16的数组（加载因子 0.75）"] --> S2["② 用元素的哈希值跟数组长度 计算应存入的位置"]
  S2 --> S3{"③ 该位置是否为 null?"}
  S3 -->|是 null| S4["直接存入"]
  S3 -->|不为 null| S5["④ 调用 equals 比较"]
  S5 -->|相等| S6["不存"]
  S5 -->|不相等| S7["存入（挂到链表中）"]
  S4 --> S8["⑤ 存满到 16×0.75=12 时 自动扩容为原长度的 2 倍"]

关键参数	默认值
初始数组长度	16
加载因子	0.75
扩容触发点	元素数 = 16 × 0.75 = 12
扩容规则	每次扩为原来的 2 倍

注意：JDK 8 之前是新元素占老元素位置、老元素挂下面；JDK 8 之后是新元素直接挂在老元素下面。当链表长度超过 8 且数组长度 ≥ 64时，链表自动转成红黑树提升查询性能。

四、LinkedHashSet 集合

LinkedHashSet 依然是基于哈希表（数组 + 链表 + 红黑树）实现的，但每个元素额外多了一个双向链表机制记录前后元素位置——所以保证存取顺序。

元素唯一 ✔（继承自 HashSet）
保证存取顺序 ✔（多了一条双向链表）
效率低于HashSet（多维护一条链表）

五、Collections 工具类

java.util.Collections 是集合工具类，提供操作集合的静态方法。

5.1 可变参数（Varargs）

可变参数用在形参中可以接收多个数据，本质在方法内部就是一个数组。

格式	说明
`数据类型...参数名称`	只能写在形参列表中

调用方式灵活：可以不传参数、传 1 个或多个、传一个数组。

⚠ 注意事项：

一个形参列表中可变参数只能有一个

可变参数必须放在形参列表的最后面

public static int sum(int... nums) {     // 本质 int[] nums
    int total = 0;
    for (int n : nums) total += n;
    return total;
}

sum();              // 0
sum(1, 2, 3);       // 6
sum(new int[]{1,2});// 3

六、Map 集合介绍

Map 是键值对集合，一次添加两个元素。需要存储一对应的数据时，优先考虑 Map。

实现类	键的特点
<span style="color:blue">HashMap</span>	按键<span style="color:blue">无序</span>，不重复，无索引
<span style="color:green">LinkedHashMap</span>	按键<span style="color:green">有序</span>，不重复，无索引
<span style="color:orange">TreeMap</span>	按键<span style="color:orange">排序</span>，不重复，无索引

三个实现类的值都不做要求（可重复、可为 null）。

6.1 常见 API

Map 是双列集合的顶层接口，它的功能是全部双列集合都可以使用的。

方法	说明
`V put(K key, V value)`	添加元素
`V remove(Object key)`	根据键删除键值对元素
`void clear()`	移除所有的键值对元素
`boolean containsKey(Object key)`	判断集合是否包含指定的键
`boolean containsValue(Object value)`	判断集合是否包含指定的值
`boolean isEmpty()`	判断集合是否为空
`int size()`	集合的长度（键值对的个数）

6.2 三种遍历方式

方式	核心方法	适用场景
<span style="color:blue">通过键找值</span>	`keySet()` + `get(key)`	只想用键的遍历
<span style="color:green">通过键值对对象</span>	`entrySet()` + `Map.Entry`	同时拿键和值（推荐）
<span style="color:orange">通过 `forEach`</span>	`forEach(BiConsumer)`	Lambda 风格

方式 1：通过键找值（分 3 步）

Set<String> keys = map.keySet();          // ① 获取所有键
for (String key : keys) {                 // ② 遍历 Set 集合
    String value = map.get(key);          // ③ 根据键找值
    System.out.println(key + "=" + value);
}

方式 2：通过键值对对象（核心是 Map.Entry）

// Map.Entry 内部接口的方法
K getKey();      // 获取键
V getValue();    // 获取值

Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
    System.out.println(entry.getKey() + "=" + entry.getValue());
}

方式 3：通过 forEach（Lambda）

map.forEach((key, value) -> System.out.println(key + "=" + value));

七、Map 集合的实现类

实现类	键的底层
<span style="color:blue">TreeMap</span>	红黑树
<span style="color:green">HashMap</span>	哈希表
<span style="color:orange">LinkedHashMap</span>	哈希表 + 双向链表

7.1 HashMap 底层原理

HashMap 与 HashSet 底层结构完全相同：哈希表。

版本	结构	重要升级
JDK 8 之前	数组 + 链表	—
<span style="color:green">JDK 8 开始</span>	数组 + 链表 + <span style="color:green">红黑树</span>	链表长度 > 8 且数组长度 ≥ 64 时自动转红黑树

map.put("键", "值") 的存储过程：

flowchart LR
  A["利用键计算哈希值 跟值无关"] --> B["根据哈希值与数组长度 计算应存入位置"]
  B --> C{"该位置是否 为 null?"}
  C -->|是| D["Entry 对象直接存入"]
  C -->|否| E["调用 equals 比较"]
  E -->|相等| F["值覆盖"]
  E -->|不相等| G["挂到链表中"]

7.2 LinkedHashMap

底层是哈希表 + 双向链表，与 LinkedHashSet 同理——哈希表保证键唯一，双向链表保证存取顺序。

7.3 TreeMap

底层是红黑树，键按排序组织。Comparable / Comparator 两种排序方式与 TreeSet 一致。

八、Set / List / Map 选择速查

需求	推荐集合	底层
元素可重复	<span style="color:green">ArrayList</span>（用的最多）	数组
元素可重复，<span style="color:red">增删明显多于查询</span>	LinkedList	链表
元素去重	<span style="color:green">HashSet</span>（用的最多）	哈希表
元素去重，且<span style="color:green">保证存取顺序</span>	LinkedHashSet	哈希表 + 双向链表
元素<span style="color:orange">排序</span>	TreeSet	红黑树

九、练习：统计字符出现次数

需求：字符串 aababcabcdabcde，统计每个字符出现次数，按 a(5)b(4)c(3)d(2)e(1) 格式输出。

public class CharCount {
    public static void main(String[] args) {
        String s = "aababcabcdabcde";
        Map<Character, Integer> map = new LinkedHashMap<>(); // 保证输出顺序
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            map.merge(c, 1, Integer::sum);     // 简化 put 逻辑
        }

        StringBuilder sb = new StringBuilder();
        map.forEach((k, v) -> sb.append(k).append('(').append(v).append(')'));
        System.out.println(sb);                 // a(5)b(4)c(3)d(2)e(1)
    }
}

注意：用 LinkedHashMap 而不是 HashMap，是为了保证输出顺序与首次出现顺序一致。

第十三章：Stream 流

Stream 流 配合 Lambda 表达式使用，可以简化集合和数组操作。其思想类似"工厂流水线"：原料（数据）→ 加工（中间方法）→ 出厂（终结方法），每一步都可以灵活组合，写出链式编程风格的代码。

一、Stream 流思想三步骤

flowchart LR
  A["① 将数据到流中 （获取流对象）"] --> B["② 中间方法 过滤/转换/去重..."]
  B --> C["③ 终结方法 遍历/统计/收集"]

步骤	关键点
① 获取流对象	把集合/数组/零散数据"上"到流水线
② 中间方法	调用后返回新的 Stream，可继续链式调用
③ 终结方法	调用后<span style="color:red">流被消费</span>，链式调用结束

二、获取 Stream 流对象

共有 3 种获取方式，根据数据来源选择。

数据来源	调用方式	方法签名
<span style="color:blue">集合</span>	`Collection` 接口中的默认方法	`default Stream<E> stream()`
<span style="color:green">数组</span>	`Arrays` 工具类的静态方法	`static <T> Stream<T> stream(T[] array)`
<span style="color:orange">零散数据</span>	`Stream` 接口中的静态方法	`static <T> Stream<T> of(T... values)`

// ① 集合
List<String> list = ...;
Stream<String> s1 = list.stream();

// ② 数组
Integer[] arr = {1, 2, 3};
Stream<Integer> s2 = Arrays.stream(arr);

// ③ 零散数据
Stream<String> s3 = Stream.of("a", "b", "c");

三、Stream 中间操作方法

中间方法调用后返回新的 Stream，支持链式编程。

方法签名	说明
`Stream<T> filter(Predicate<? super T> predicate)`	用于对流中的数据进行<span style="color:green">过滤</span>
`Stream<T> limit(long maxSize)`	获取前几个元素
`Stream<T> skip(long n)`	跳过前几个元素
`Stream<T> distinct()`	去除流中重复的元素（依赖 `hashCode` 和 `equals`）
`static <T> Stream<T> concat(Stream a, Stream b)`	<span style="color:orange">合并</span> a 和 b 两个流为一个流
`Stream<R> map(Function<? super T, ? extends R> mapper)`	对流中的每一个元素进行转换

⚠ 注意事项：如果流对象已经被消费过，就不允许再次使用。每个流对象只能终结一次，多次调用终结方法会抛 IllegalStateException。

// 链式编程：用 limit + concat + distinct 一气呵成
Stream<String> s1 = list.stream().limit(4);
Stream<String> s2 = list.stream().skip(2);
Stream<String> s3 = Stream.concat(s1, s2);
s3.distinct().forEach(System.out::println);   // 消费 s3 后流就关闭

四、Stream 终结操作方法

终结方法调用后流被关闭，链式结束。

方法签名	说明
`void forEach(Consumer action)`	对此流的每个元素执行遍历操作
`long count()`	返回此流中的元素数

五、Stream 收集操作

Stream 流操作不会修改数据源，操作完成后若需要重新得到集合/数组，需要用 collect 方法。

// 把流中的数据转回集合
R collect(Collector collector);

Collectors 工具类提供 3 种常用收集方式：

静态方法	作用
`public static <T> Collector toList()`	把元素收集到 <span style="color:blue">List</span> 集合中
`public static <T> Collector toSet()`	把元素收集到 <span style="color:green">Set</span> 集合中
`public static Collector toMap(Function keyMapper, Function valueMapper)`	把元素收集到 <span style="color:orange">Map</span> 集合中

5.1 收集到 Map 示例

需求：将 ArrayList 中的 "zhangsan,23" / "lisi,24" / "wangwu,25" 收集到 Map<姓名, 年龄>。

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "zhangsan,23", "lisi,24", "wangwu,25");

Map<String, Integer> map = list.stream()
        .collect(Collectors.toMap(
                s -> s.split(",")[0],   // 键：姓名
                s -> Integer.parseInt(s.split(",")[1])  // 值：年龄
        ));
// {zhangsan=23, lisi=24, wangwu=25}

5.2 综合练习：演员信息处理

需求：两个 ArrayList 集合分别存储 6 名男演员和 6 名女演员。

男演员只要名字为 3 个字的前两人

女演员只要姓林的，并且不要第一个

把过滤后的男演员姓名和女演员姓名合并到一起

把合并后的元素作为构造方法的参数创建 Actor 对象，遍历数据

演员类 Actor 含一个成员变量、一个带参构造方法、对应 get / set 方法

// 演员类
public class Actor {
    private String name;
    public Actor(String name) { this.name = name; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}

// 处理
ArrayList<String> males = new ArrayList<>(Arrays.asList(
        "蔡徐坤", "李易峰", "王俊凯", "易烊千玺", "陈伟霆", "邓伦"));
ArrayList<String> females = new ArrayList<>(Arrays.asList(
        "林允儿", "林志玲", "杨幂", "赵丽颖", "刘亦菲", "林心如"));

Stream<String> m = males.stream().filter(s -> s.length() == 3).limit(2);
Stream<String> f = females.stream().filter(s -> s.startsWith("林")).skip(1);
Stream.concat(m, f).map(Actor::new).forEach(a -> System.out.println(a.getName()));

第十四章：异常

异常 指的是程序在编译或执行过程中，出现的非正常的情况（错误）。常见如 ArrayIndexOutOfBoundsException / ClassCastException / NullPointerException。语法错误不是异常。

一、异常体系

flowchart TD
  T["Throwable"] --> E["Error"]
  T --> X["Exception"]
  X --> R["RuntimeException 及其子类"]
  X --> C["除 RuntimeException 之外 所有的异常"]

父类	子类	性质	举例
<span style="color:red">Error</span>	严重级别问题	<span style="color:red">无法处理</span>	`StackOverflowError`（栈内存溢出）、`OutOfMemoryError`（堆内存溢出）
<span style="color:blue">Exception</span>	异常类，程序常见错误	可处理	见下分类

1.1 Exception 两大类

分类	触发时机	常见异常	原因
<span style="color:blue">运行时异常</span>（`RuntimeException` 及其子类）	编译不报错，<span style="color:orange">运行时可能</span>出错	数组索引越界 `ArrayIndexOutOfBoundsException`、空指针 `NullPointerException`、类型转换 `ClassCastException`	程序员代码<span style="color:red">不严谨</span>
<span style="color:green">编译时异常</span>（除 `RuntimeException` 外）	<span style="color:red">编译阶段就报错</span>	`new FileReader("D:\\A.txt")`	起到提醒作用，需提前处理

注意：编译时异常不报错，运行时可能报错；编译时异常没继承 RuntimeException，编译阶段就会出错。

二、异常的默认处理流程

不做任何处理时，JVM 的默认行为：

flowchart TD
  A["① 虚拟机在出现异常的代码处 自动创建异常对象"] --> B["② 异常从方法出现的点抛出给调用者 调用者最终抛出给 JVM"]
  B --> C["③ JVM 收到异常后 在控制台输出异常信息"]
  C --> D["④ 终止 Java 程序运行"]

三、异常处理方式

Java 提供 2 种 主动处理方式：捕获（try...catch）和抛出（throws / throw）。

3.1 `try...catch`：捕获异常

优点：程序可以继续往下执行。

try {
    // 可能会出现异常的代码
} catch (异常类型1 变量) {
    // 处理异常的方案
} catch (异常类型2 变量) {
    // 处理异常的方案
}

⚠ 关键点：如果使用多个 catch，最大的异常需要放在最后（父类在后）。

Throwable 常见方法：

方法	说明
`public String getMessage()`	获取异常的错误原因（简短）
`public void printStackTrace()`	展示完整的异常错误信息（最常用）

3.2 `throws`：抛出异常

用在方法名后面，声明"这个方法存在异常，但不做处理，交给调用方处理"。

public void method() throws 异常1, 异常2, 异常3... { }

⚠ 关键点：子类重写父类方法时，不能抛出父类没有的异常，或者比父类更大的异常。

3.3 两种方式怎么选

方式	出现问题时	选择依据
<span style="color:blue">try...catch</span>	程序可以继续执行	问题不需要暴露给调用者
<span style="color:orange">throws 抛出</span>	程序在错误点停止	问题需要暴露出去

思路：看这个问题是否需要暴露出来 → 需要：抛出，不需要：try...catch。

3.4 `throw` vs `throws`

关键字	位置	后面跟	作用
<span style="color:blue">`throw`</span>	方法体中	异常对象	抛出异常对象
<span style="color:green">`throws`</span>	方法名后面	异常类型	声明方法存在异常

细节：抛出的异常对象如果是编译时异常，必须使用 throws 声明；如果是运行时异常，则不需要写 throws。

四、自定义异常

Java 无法为这个世界上全部的问题提供异常类。当企业想用异常管理某个业务问题时，需要自定义异常类。

4.1 两类自定义异常

类型	父类	步骤
<span style="color:blue">自定义编译时异常</span>	继承 `Exception`	① 定义类 ② 重写构造器
<span style="color:green">自定义运行时异常</span>	继承 `RuntimeException`	① 定义类 ② 重写构造器

4.2 示例：自定义业务异常

// 1. 自定义运行时异常
public class AgeOutOfRangeException extends RuntimeException {
    public AgeOutOfRangeException() { super(); }
    public AgeOutOfRangeException(String message) { super(message); }
}

// 2. 业务方法中抛出
public void setAge(int age) {
    if (age < 0 || age > 150) {
        throw new AgeOutOfRangeException("年龄超出范围: " + age);
    }
    this.age = age;
}

// 3. 调用方捕获
try {
    setAge(200);
} catch (AgeOutOfRangeException e) {
    System.out.println(e.getMessage());   // 年龄超出范围: 200
}

好处：通过自定义异常可以精准表达特定错误（比通用 Exception 更有语义）。

第十五章：File 类、递归

File 类是操作系统文件对象（文件、文件夹）的 Java 封装，本章先掌握 File 的 API，再学习递归——用 File 遍历多层目录的关键。

一、File 类创建对象

File 封装的对象仅仅是一个路径名，这个路径可以存在，也可以不存在。

构造方法	说明
`public File(String pathname)`	根据文件路径创建文件对象
`public File(String parent, String child)`	根据父路径 + 子路径字符串创建文件对象
`public File(File parent, String child)`	根据父路径 File 对象 + 子路径字符串创建文件对象

1.1 绝对路径 vs 相对路径

路径类型	含义	示例
<span style="color:blue">绝对路径</span>	从<span style="color:green">盘符根目录</span>开始，到具体的文件或文件夹	`new File("D:\\A.txt")`
<span style="color:orange">相对路径</span>	相对于<span style="color:orange">当前项目</span>的所在目录	`new File("A.txt")`（实际路径是"项目根\A.txt"）

二、File 类常用 API

2.1 判断方法

方法	说明
`public boolean isDirectory()`	判断是否为<span style="color:blue">文件夹</span>
`public boolean isFile()`	判断是否为<span style="color:green">文件</span>
`public boolean exists()`	判断路径是否<span style="color:orange">存在</span>

2.2 获取信息方法

方法	说明
`public long length()`	返回文件的大小（字节数）
`public String getAbsolutePath()`	返回文件的<span style="color:blue">绝对路径</span>
`public String getPath()`	返回定义文件时使用的路径
`public String getName()`	返回文件的名称，带后缀
`public long lastModified()`	返回文件的最后修改时间（时间毫秒值）

2.3 创建和删除方法

方法	说明
`public boolean createNewFile()`	创建一个新的空文件
`public boolean mkdir()`	只能创建<span style="color:orange">一级文件夹</span>
`public boolean mkdirs()`	可以创建多级文件夹（推荐）
`public boolean delete()`	删除文件或<span style="color:red">空文件夹</span>

⚠ 关键点：delete() 方法只能删除空文件夹，且不走回收站（不可恢复）。

2.4 遍历方法

方法	说明
`public File[] listFiles()`	获取当前目录下所有的一级文件对象（不包含子目录内容）

注意：listFiles() 返回值的 4 种情况：

路径不存在 → 返回 null

路径是文件 → 返回 null

路径是空文件夹 → 返回长度为 0 的数组

路径是需权限才能访问的文件夹 → 返回 null

三、递归

递归 是指方法直接或者间接调用本身。它的核心思路是：将大问题层层转化为与原问题相似、规模更小的问题来解决。

⚠ 关键点：递归如果没有控制好终止，会出现递归死循环，导致栈内存溢出（StackOverflowError）。

3.1 案例：求 5 的阶乘

推导：5! = 5 × 4!、4! = 4 × 3!、…、1! = 1。

public class RecursionDemo1 {
    public static void main(String[] args) {
        int result = jc(5);
        System.out.println(result);   // 120
    }

    public static int jc(int num) {
        if (num == 1) {
            return 1;                    // 终止条件
        }
        return num * jc(num - 1);        // 自己调自己，参数规模更小
    }
}

递归栈帧：

flowchart LR
  A["jc(5) return 5*24"] --> B["jc(4) return 4*6"]
  B --> C["jc(3) return 3*2"]
  C --> D["jc(2) return 2*1"]
  D --> E["jc(1) return 1"]

3.2 案例：不死神兔（斐波那契数列）

题目：一对兔子，从出生后第 3 个月起每个月都生一对兔子，小兔子长到第 3 个月后又生一对。假设兔子都不死，问第 20 个月的兔子对数为多少？

规律：从第 3 个月开始，兔子对数 = 前两个月之和。

月	1	2	3	4	5	6	7	8	...
对数	1	1	2	3	5	8	13	21	...

public static int rabbit(int month) {
    if (month == 1 || month == 2) return 1;
    return rabbit(month - 1) + rabbit(month - 2);
}

3.3 递归使用场景

常用于逻辑类似的业务：文件遍历、目录树、阶乘、斐波那契等。

四、递归案例实战

4.1 找出所有 `.java` 文件（含子目录）

需求：键盘录入一个文件夹路径，找出这个文件夹下所有的 .java 文件（包括子文件夹）。思路：单层用 listFiles() 即可，子文件夹需要递归进入查找。

public static void findJava(File dir, ArrayList<String> list) {
    File[] files = dir.listFiles();
    if (files == null) return;

    for (File f : files) {
        if (f.isFile() && f.getName().endsWith(".java")) {
            list.add(f.getAbsolutePath());
        } else if (f.isDirectory()) {
            findJava(f, list);                 // 递归
        }
    }
}

4.2 递归删除文件夹

注意：delete() 只能删除空文件夹，所以要先删子再删自己（后序遍历）。

public static void deleteDir(File dir) {
    File[] files = dir.listFiles();
    if (files == null) return;

    for (File f : files) {
        if (f.isFile()) {
            f.delete();                       // 文件直接删
        } else if (f.isDirectory()) {
            deleteDir(f);                     // 递归
        }
    }
    dir.delete();                             // 最后删自己
}

4.3 递归统计文件夹大小

思路：文件夹 = 所有文件大小之和；遇到子文件夹继续递归。

public static long sizeOf(File dir) {
    long total = 0;
    File[] files = dir.listFiles();
    if (files == null) return 0;

    for (File f : files) {
        if (f.isFile()) {
            total += f.length();
        } else if (f.isDirectory()) {
            total += sizeOf(f);
        }
    }
    return total;
}

五、键盘录入路径案例

需求：键盘录入一个文件夹路径，如果输入错误就给出提示，并继续录入，直到正确为止。

分析：输入的路径可能不存在或是文件路径，所以需用 exists() + isDirectory() 双重判断。

Scanner sc = new Scanner(System.in);
File dir;
while (true) {
    System.out.print("请输入文件夹路径: ");
    String path = sc.nextLine();
    dir = new File(path);
    if (!dir.exists()) {
        System.out.println("路径不存在，请重新输入");
    } else if (!dir.isDirectory()) {
        System.out.println("不是文件夹，请重新输入");
    } else {
        break;
    }
}
System.out.println("已找到文件夹: " + dir.getAbsolutePath());

第十六章：常用 API

Java 提供了一系列"工具类"来完成数学计算、系统操作、日期处理等通用任务。本章覆盖 Math、System、包装类、BigDecimal、Arrays、Date、SimpleDateFormat、LocalDateTime / LocalDate / LocalTime、DateTimeFormatter 以及时间间隔工具 ChronoUnit / Duration / Period。

一、Math 类

Math 类是用于执行基本数字运算的工具类，所有方法都是 static 修饰，可直接通过类名调用。

方法名	说明
`public static int abs(int a)`	获取参数绝对值
`public static double ceil(double a)`	向上取整
`public static double floor(double a)`	向下取整
`public static int round(float a)`	四舍五入
`public static int max(int a, int b)`	获取两个 int 值中的较大值
`public static double pow(double a, double b)`	返回 a 的 b 次幂的值
`public static double random()`	返回值为 double 的随机值，范围 `[0.0, 1.0)`

二、System 类

System 的功能是静态的，都是直接用类名调用即可。

方法名	说明
`public static void exit(int status)`	终止当前运行的 Java 虚拟机，非零表示异常终止
`public static long currentTimeMillis()`	返回当前系统的时间毫秒值形式
`public static void arraycopy(数据源数组, 起始索引, 目的地数组, 起始索引, 拷贝个数)`	数组拷贝

时间原点小知识：计算机中的时间原点是 1970 年 1 月 1 日 08:00:00。1969 年 8 月贝尔实验室的肯·汤普逊利用妻子离开一个月的机会开发了 Unix，使用 B 编译语言在 PDP-7 上开发，随后丹尼斯·里奇改进了 B 语言，开发出 C 语言重写了 Unix，因此 1970 年 1 月 1 日也算 C 语言的生日。

三、包装类

Java 是面向对象的语言，但基本类型（如 int、double）不是对象，无法调用方法或参与泛型。包装类的作用就是将基本数据类型包装成类（变成引用数据类型），从而可以创建对象、调用方法解决问题。

基本数据类型	引用数据类型	基本数据类型	引用数据类型
<span style="color:green">byte</span>	<span style="color:green">Byte</span>	<span style="color:green">float</span>	<span style="color:green">Float</span>
<span style="color:green">short</span>	<span style="color:green">Short</span>	<span style="color:green">double</span>	<span style="color:green">Double</span>
<span style="color:green">int</span>	<span style="color:green">Integer</span>	<span style="color:green">boolean</span>	<span style="color:green">Boolean</span>
<span style="color:green">long</span>	<span style="color:green">Long</span>	<span style="color:red">char</span>	<span style="color:red">Character</span>

⚠ 注意事项：除了 int → Integer 和 char → Character 是"特殊拼写"外，其他都是基本类型首字母大写。

3.1 Integer 类

用于将基本数据类型手动包装为类。

构造 / 方法	说明
<span style="color:red">`public Integer(int value)`</span>	~~已过时，不推荐使用~~
<span style="color:green">`public static Integer valueOf(int i)`</span>	推荐通过静态方法装箱

说明：从 JDK9 开始 new Integer(int) 构造方法已被标记为过时，建议使用 valueOf 或自动装箱。

3.2 自动装箱与自动拆箱

名称	解释
<span style="color:blue">自动装箱</span>	基本类型的数据和变量可以直接赋值给包装类型的变量
<span style="color:green">自动拆箱</span>	包装类型的变量可以直接赋值给基本数据类型的变量

Integer i = 10;        // 自动装箱
int n = i;             // 自动拆箱
int result = i + 100;  // 拆箱后参与运算

简单记：有了自动拆装箱，基本数据类型和对应的包装类，可以直接运算，操作起来非常便捷。

3.3 包装类练习

需求：已知字符串 String s = "10,50,30,20,40"，请将该字符串转换为整数并存入数组，随后求出最大值打印在控制台。

String s = "10,50,30,20,40";
String[] arr = s.split(",");
int[] nums = new int[arr.length];
int max = nums[0];
for (int i = 0; i < arr.length; i++) {
    nums[i] = Integer.parseInt(arr[i]);   // 字符串 → int
    if (nums[i] > max) {
        max = nums[i];
    }
}
System.out.println("最大值: " + max);

四、BigDecimal 类

用于解决小数运算中出现的不精确问题。例如：

double num1 = 0.1;
double num2 = 0.2;
System.out.println(num1 + num2);   // 0.30000000000000004

4.1 创建对象

构造 / 方法	说明
`public BigDecimal(double val)`	通过 double 创建（不推荐，仍有精度问题）
<span style="color:green">`public BigDecimal(String val)`</span>	通过字符串创建，<span style="color:green">推荐</span>
<span style="color:green">`public static BigDecimal valueOf(double val)`</span>	静态方法，<span style="color:green">推荐</span>

4.2 常用方法

方法名	说明
`public BigDecimal add(BigDecimal b)`	加法
`public BigDecimal subtract(BigDecimal b)`	减法
`public BigDecimal multiply(BigDecimal b)`	乘法
`public BigDecimal divide(BigDecimal b)`	除法
`public BigDecimal divide(另一个 BigDecimal 对象, 精确几位, 舍入模式)`	除法（精确控制）

4.3 divide 除法细节

除法运算需要注意除不尽的情况，必须指定保留位数与舍入模式。

BigDecimal divide = bd1.divide(参与运算的对象, 小数点后精确到多少位, 舍入模式);

舍入模式	含义
`RoundingMode.UP`	<span style="color:orange">进一法</span>
`RoundingMode.DOWN`	<span style="color:orange">去尾法</span>
`RoundingMode.HALF_UP`	<span style="color:orange">四舍五入</span>

BigDecimal a = new BigDecimal("10");
BigDecimal b = new BigDecimal("3");
BigDecimal r = a.divide(b, 2, RoundingMode.HALF_UP);  // 3.33

小结：BigDecimal 用于解决小数运算的精度损失问题；创建对象推荐 BigDecimal(String) 或 static valueOf(double)；除法运算要注意除不尽的情况。

五、Arrays 类

数组操作工具类，专门用于操作数组元素。

方法名	说明
`public static String toString(类型[] a)`	将数组元素拼接为带格式的字符串
`public static boolean equals(类型[] a, 类型[] b)`	比较两个数组内容是否相同
`public static int binarySearch(int[] a, int key)`	查找元素在数组中的索引（<span style="color:red">二分查找法</span>）
`public static void sort(类型[] a)`	对数组进行默认升序排序

5.1 二分查找原理

二分查找的前提：必须是排好序的数据。每次取中间位置元素与目标值比较：

中间元素 < 目标值 → 往右半区查找

中间元素 > 目标值 → 往左半区查找

中间元素 = 目标值 → 找到

flowchart LR
  A["原始数组 11 22 33 44 55 66 77 88 99 100"] -->|"查找 88 中间=55 比 55 大，往右"| B["右半区 66 77 88 99 100"]
  B -->|"中间=88 正好相等"| C["找到索引 7"]

⚠ 注意：如果查找的元素不在数组中，binarySearch 会返回负数（即 - (插入点 + 1)）。

int[] arr = {11, 22, 33, 44, 55, 66, 77, 88, 99, 100};
int idx = Arrays.binarySearch(arr, 88);   // 7

六、Date 类

Date 代表日期和时间，位于 java.util 包下。

构造器	说明
`public Date()`	创建一个 `Date` 对象，代表系统当前此刻的日期时间
`public Date(long time)`	把时间毫秒值转换成 `Date` 日期对象

常见方法	说明
`public long getTime()`	返回从 1970 年 1 月 1 日 00:00:00 走到此列的总毫秒数
`public void setTime(long time)`	设置日期对象的时间为当前时间毫秒值对应的时间

Date d1 = new Date();
System.out.println(d1);                    // 当前时间
System.out.println(d1.getTime());          // 当前时间毫秒值
Date d2 = new Date(0L);                    // 时间原点
System.out.println(d2);                    // Thu Jan 01 08:00:00 CST 1970

小结：① Date 对象创建 → new Date()；② 获取时间毫秒值 → getTime()；③ 时间毫秒值转 Date 对象 → new Date(long time) 或 setTime(long time)。

七、SimpleDateFormat 类

用于日期格式化（Date → 字符串）和解析（字符串 → Date）。

7.1 构造器与格式化方法

分类	方法名	说明
<span style="color:blue">构造器</span>	`public SimpleDateFormat()`	构造一个 SimpleDateFormat，使用默认格式
<span style="color:blue">构造器</span>	`public SimpleDateFormat(String pattern)`	构造一个 SimpleDateFormat，使用指定的格式
<span style="color:green">格式化方法</span>	`public final String format(Date date)`	将日期格式化成日期/时间字符串
<span style="color:green">格式化方法</span>	`public final Date parse(String source)`	将字符串解析为日期类型

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = new Date();
String s = sdf.format(d);                  // Date → 字符串
Date d2 = sdf.parse("2025-01-20 15:30:00"); // 字符串 → Date

常用格式符号：yyyy（年）MM（月）dd（日）HH（时）mm（分）ss（秒）。

八、JDK8 新增的时间 API

JDK8 之后新增的时间 API 设计更合理、功能丰富、使用方便，主要特点：

都是不可变对象，修改后会返回新的时间对象，不会丢失最开始的时间

线程安全

能精确到毫秒、纳秒

8.1 LocalDateTime / LocalDate / LocalTime

类	含义
<span style="color:blue">LocalDate</span>	代表本地日期（年、月、日、星期）
<span style="color:blue">LocalTime</span>	代表本地时间（时、分、秒、纳秒）
<span style="color:red">LocalDateTime</span>	代表本地日期 + 时间（年、月、日、星期、时、分、秒、纳秒）

获取对象：

方法	示例
`public static Xxxx now()`：获取系统当前时间对应的该对象	`LocalDate ld = LocalDate.now();`<br>`LocalTime lt = LocalTime.now();`<br>`LocalDateTime ldt = LocalDateTime.now();`
`public static Xxxx of(...)`：获取指定时间的对象	`LocalDate.of(2099, 11, 11)`<br>`LocalTime.of(9, 8, 59)`<br>`LocalDateTime.of(2025, 11, 16, 14, 30, 1)`

获取年月日时分秒相关的方法：

方法名	功能
`int getYear()`	获取年份字段
`Month getMonth()`	使用 Month 枚举获取年份字段
`int getMonthValue()`	获取 1 到 12 之间的月份字段
`int getDayOfMonth()`	获取日期字段
`DayOfWeek getDayOfWeek()`	获取星期几字段，即枚举 DayOfWeek
`int getHour()`	获取当日时间字段
`int getMinute()`	获取分钟字段
`int getSecond()`	获取秒字段

修改年月日时分秒相关的方法：

LocalDateTime / LocalDate / LocalTime 都是不可变的，下列方法返回的是一个新的对象。

方法名	说明
`withHour`、`withMinute`、`withSecond`、`withNano`	<span style="color:blue">修改时间，返回新时间对象</span>
`plusHours`、`plusMinutes`、`plusSeconds`、`plusNanos`	把某个信息<span style="color:green">加</span>多少，返回新时间对象
`minusHours`、`minusMinutes`、`minusSeconds`、`minusNanos`	把某个信息<span style="color:red">减</span>多少，返回新时间对象
`equals` / `isBefore` / `isAfter`	判断 2 个时间对象是否相等，在前还是在后

LocalDateTime ldt = LocalDateTime.now();
LocalDateTime newLdt = ldt
        .withHour(10)               // 修改小时
        .plusDays(7)                // 加 7 天
        .minusHours(2);             // 减 2 小时

8.2 DateTimeFormatter

用于时间的格式化和解析，是 JDK8 新增时间 API 的"格式器"。

方法名	说明
`static DateTimeFormatter ofPattern(格式)`	<span style="color:green">获取格式对象</span>
`String format(时间对象)`	按照指定方式格式化

DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime ldt = LocalDateTime.now();
String s = dtf.format(ldt);                     // 格式化
LocalDateTime ldt2 = LocalDateTime.parse(s, dtf); // 解析

九、时间间隔工具类

用于计算时间间隔，JDK8 提供了三个工具：

类	用途
<span style="color:blue">Duration</span>	用于计算两个"时间"间隔（秒、纳秒）
<span style="color:green">Period</span>	用于计算两个"日期"间隔（年、月、日）
<span style="color:orange">ChronoUnit</span>	用于计算两个"日期"间隔

// 计算两个 LocalDateTime 之间相差的天、时、分
LocalDateTime start = LocalDateTime.of(2025, 1, 1, 0, 0, 0);
LocalDateTime end   = LocalDateTime.now();

long days  = ChronoUnit.DAYS.between(start, end);
long hours = ChronoUnit.HOURS.between(start, end);
long mins  = ChronoUnit.MINUTES.between(start, end);

案例：根据用户填写的生日计算年龄——使用 Period.between(birth, today) 取得"年、月、日"三段间隔，进而精确计算周岁。

LocalDate birth = LocalDate.of(1990, 12, 1);
LocalDate today = LocalDate.now();
Period p = Period.between(birth, today);
System.out.println("年龄：" + p.getYears() + " 岁 "
        + p.getMonths() + " 月 " + p.getDays() + " 天");

第十七章：IO 流

IO 是 "Input / Output" 的缩写，意为输入 / 输出，本质是数据传输。常见场景：读写配置文件 / 日志文件、客户端与服务端通讯、文件上传下载等。

一、IO 介绍和分类

1.1 IO 流向

把外存中的数据读取到内存中称为"输入"（读），把内存中的数据写出到外存中称为"输出"（写）。

flowchart LR
  subgraph 输入流管道
    direction LR
    FILE["D:\user.txt"] -->|"读取数据"| JVM["Java 程序"]
  end
  subgraph 输出流管道
    direction RL
    FILE2["D:\user.txt"] <==|"写出数据"| JVM2["Java 程序"]
  end

1.2 IO 流体系结构

IO 流按"数据单位"分为两大体系：字节流（万能流，所有文件都能操作）和字符流（纯文本文件专用，能解决中文乱码）。

分类	抽象类	说明	抽象类的子类
<span style="color:orange">字节流</span>（万能流）	`InputStream`	字节输入流	`FileInputStream`
字节流	`OutputStream`	字节输出流	`FileOutputStream`
<span style="color:blue">字符流</span>（纯文本）	`Reader`	字符输入流	`FileReader`
字符流	`Writer`	字符输出流	`FileWriter`

小结：字符流使用场景：读写纯文本文件；字节流使用场景：不是纯文本文件都用字节流。

二、FileOutputStream 字节输出流

FileOutputStream 是字节输出流的子类，用于把 Java 程序的数据写出到文件（如 D:\A.txt）。

2.1 构造方法

构造方法	说明
`FileOutputStream(String name)`	输出流关联文件，文件路径以字符串形式给出
`FileOutputStream(String name, boolean append)`	第二个参数是<span style="color:green">追加写入</span>的开关
`FileOutputStream(File file)`	输出流关联文件，文件路径以 `File` 对象形式给出
`FileOutputStream(File file, boolean append)`	第二个参数是追加写入的开关

⚠ 注意事项：① 关联的文件如果不存在会自动创建；② 如果文件已存在，默认会清空原有的内容再重新写入（除非开启追加模式）。

2.2 成员方法

方法	说明
`void write(int b)`	写出<span style="color:orange">单个字节</span>
`void write(byte[] b)`	写出一个<span style="color:orange">字节数组</span>
`void write(byte[] b, int off, int len)`	写出字节数组的<span style="color:orange">一部分</span>

// 示例：写出数据
FileOutputStream fos = new FileOutputStream("D:\\A.txt", true);  // 追加写入
fos.write(97);                      // 写出单个字节 'a'
fos.write("Hello".getBytes());      // 写出整个字符串
fos.close();                        // 关闭流，释放资源

三、关流与异常处理

流对象使用完毕后，记得调用 close 方法关闭，不然会占用资源。

3.1 JDK7 之后的 try-with-resources 写法

try 后面的小括号里可以直接写需要关闭的对象，前提是该对象实现了 AutoCloseable 接口。

try (FileOutputStream fos = new FileOutputStream("D:\\A.txt")) {
    fos.write("Hello".getBytes());
} catch (IOException e) {
    e.printStackTrace();
}

优势：① 自动调用 close() 释放资源；② 代码更简洁，避免忘记关流。

四、FileInputStream 字节输入流

FileInputStream 是字节输入流，用于读取文件中的数据到 Java 程序（如把 D:\A.txt 的内容读进来）。

4.1 构造方法

构造方法	说明
`FileInputStream(String name)`	输入流关联文件，文件路径以字符串形式给出
`FileInputStream(File file)`	输入流关联文件，文件路径以 `File` 对象形式给出

⚠ 注意事项：① 关联的文件不存在会抛出 FileNotFoundException 异常；② 文件夹的话会拒绝访问。

4.2 成员方法

方法	说明
`int read()`	读取一个字节并返回，如果到达文件结尾则返回 -1
`int read(byte[] b)`	将读取到字节放到传入的数组，<span style="color:green">返回读取到的有效字节个数</span>，到达文件结尾则返回 -1

// 方式一：单字节读取（效率低）
try (FileInputStream fis = new FileInputStream("D:\\A.txt")) {
    int b;
    while ((b = fis.read()) != -1) {
        System.out.print((char) b);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 方式二：字节数组读取（推荐，效率高）
try (FileInputStream fis = new FileInputStream("D:\\A.txt")) {
    byte[] bys = new byte[2];
    int len;
    while ((len = fis.read(bys)) != -1) {
        System.out.print(new String(bys, 0, len));
    }
} catch (IOException e) {
    e.printStackTrace();
}

4.3 String 构造方法（配合使用）

构造方法	说明
`public String(byte[] bytes, int offset, int length)`	将字节数组转换为字符串，参数 1：字节数组；参数 2：起始索引；参数 3：转换的个数

五、文件拷贝案例

需求：将 D:\嘿嘿.jpg 拷贝到 E:\ 根目录下。

flowchart LR
  A["1. 创建输入流对象 读取文件"] --> B["2. 创建输出流对象 关联数据目的"]
  B --> C["3. 读写操作"]
  C --> D["4. 关流释放资源"]

try (
    FileInputStream fis = new FileInputStream("D:\\嘿嘿.jpg");
    FileOutputStream fos = new FileOutputStream("E:\\嘿嘿.jpg")
) {
    byte[] bys = new byte[1024];
    int len;
    while ((len = fis.read(bys)) != -1) {
        fos.write(bys, 0, len);
    }
} catch (IOException e) {
    e.printStackTrace();
}

六、FileReader 字符输入流

用于读取纯文本文件，能解决中文乱码问题。

分类	方法	说明
<span style="color:blue">构造</span>	`FileReader(String fileName)`	字符输入流关联文件，路径以字符串形式给出
构造	`FileReader(File file)`	字符输入流关联文件，路径以 `File` 对象形式给出
<span style="color:green">成员方法</span>	`public int read()`	读取<span style="color:green">单个字符</span>
成员方法	`public int read(char[] cbuf)`	读取一个字符数组，<span style="color:green">返回读取到的有效字符个数</span>

七、FileWriter 字符输出流

7.1 构造方法

构造方法	说明
`FileWriter(String fileName)`	字符输出流关联文件，路径以字符串形式给出
`FileWriter(String fileName, boolean append)`	参数 2：<span style="color:green">追加写入</span>的开关
`FileWriter(File file)`	字符输出流关联文件，路径以 `File` 对象形式给出
`FileWriter(File file, boolean append)`	参数 2：追加写入的开关

7.2 成员方法

方法	说明
`public void write(int c)`	写出<span style="color:blue">单个字符</span>
`public void write(char[] cbuf)`	写出一个<span style="color:blue">字符数组</span>
`public void write(char[] cbuf, int off, int len)`	写出字符数组的<span style="color:blue">一部分</span>
`public void write(String str)`	写出<span style="color:blue">字符串</span>
`public void write(String str, int off, int len)`	写出字符串的<span style="color:blue">一部分</span>

⚠ 注意事项：字符输出流写出数据，需要调用 flush 或 close 方法，数据才会写出。

flush() 后可以继续写出

close() 后不能继续写出（流已关闭）

八、Properties 集合

Properties 是 java.util 包下的类，继承自 Hashtable<Object, Object>，本质是一个 Map 集合，但键和值都必须是 String。

8.1 作为集合使用

分类	方法	说明
<span style="color:blue">构造</span>	`Properties()`	创建一个没有默认值的空属性列表
<span style="color:green">成员方法</span>	`Object setProperty(String key, String value)`	添加 / 修改一个键值对
成员方法	`String getProperty(String key)`	根据键获取值
成员方法	`Set<String> stringPropertyNames()`	获取集合中所有的键

Properties prop = new Properties();
prop.setProperty("username", "admin");
prop.setProperty("password", "123456");
System.out.println(prop.getProperty("username"));  // admin

8.2 和 IO 有关的方法

方法	说明
`void load(InputStream inStream)`	从输入字节流读取属性列表（键和元素对）
`void load(Reader reader)`	从输入字符流读取属性列表（键和元素对）
`void store(OutputStream out, String comments)`	将此属性列表写入输出字节流，以适合 `load(InputStream)` 方法的格式
`void store(Writer writer, String comments)`	将此属性列表写入输出字符流，以适合 `load(Reader)` 方法的格式

// 把集合中的键值对写到配置文件
Properties prop = new Properties();
prop.setProperty("username", "admin");
prop.setProperty("password", "123456");
try (FileWriter fw = new FileWriter("config.properties")) {
    prop.store(fw, "user config");
}

// 从配置文件中读取键值对到集合
Properties prop2 = new Properties();
try (FileReader fr = new FileReader("config.properties")) {
    prop2.load(fr);
    System.out.println(prop2.getProperty("username"));
}

小结：① Properties 本质就是 Map 集合，键值都是 String；② setProperty(键,值) 添加、getProperty(键) 取值；③ load 从流加载、store 写入流——将来加载配置文件时很方便。

九、HuTool 工具

9.1 Hutool 介绍

Hutool 是一个小而全的 Java 工具类库，通过静态方法封装，降低相关 API 的学习成本，提高工作效率。

名称由来：Hutool = Hu + tool，是原公司项目底层代码剥离后的开源库，"Hu" 是公司名称的表示，tool 表示工具

谐音"糊涂"，一方面简洁易用，一方面寓意"难得糊涂"

9.2 Hutool 常用 API

Hutool 不是 JDK 自带的，使用时需要导入 jar 包（后续学习 Maven 可简化此操作）。

IoUtil 类提供的部分方法：

方法	说明
`copy(InputStream in, OutputStream out, int bufferSize)`	字节流拷贝
`copy(Reader reader, Writer writer)`	字符流拷贝
`readLines(Reader reader, Collection<String> collection)`	按行读取内容到集合
`close(Closeable closeables)`	<span style="color:green">安全关闭流</span>

FileUtil 类提供的部分方法：

方法	说明
`touch(filePath)`	<span style="color:green">创建文件</span>（自动创建父目录）
`mkdir(dirPath)`	<span style="color:green">创建目录</span>（支持多级目录）
`copy(srcPath, destPath, isOverride)`	复制文件或目录（可选覆盖）
`move(srcFile, destDir, isOverride)`	<span style="color:green">移动</span>文件或目录

Tips：Hutool 导入 jar 包的方式较为繁琐，后面学到 Maven 的时候可以简化。

第十八章：多线程

多线程是 Java 编程中非常重要的特性，用于提高程序执行效率和同时处理多个任务。本章从进程和线程的概念讲起，逐步深入到 Java 线程的创建、线程安全、线程同步以及线程池的使用。

一、进程和线程

1.1 进程介绍

进程（Process） 是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配的基本单位。简单理解为程序的执行过程。

进程的特点：

特点	说明
<span style="color:green">独立性</span>	每一个进程都有自己的空间，在没有经过进程本身允许的情况下，一个进程不可以直接访问其它的进程空间
<span style="color:orange">动态性</span>	进程是动态产生、动态消亡的
<span style="color:blue">并发性</span>	任何进程都可以同其它进程一起并发执行

小结：进程是程序的执行过程，具有独立性、动态性、并发性。对于一个 CPU 而言，它是在多个进程间轮换执行的。

1.2 并行和并发

并行：在同一时刻，有多个指令在多个 CPU 上同时执行。并发：在同一时刻，有多个指令在单个 CPU 上交替执行。

flowchart LR
  subgraph 并行
    direction LR
    A["CPU 1"] --> A1["任务 1"]
    B["CPU 2"] --> B1["任务 2"]
  end
  subgraph 并发
    direction LR
    C["单个 CPU"] --> C1["任务 1"]
    C1 -.-> C2["任务 2"]
    C2 -.-> C1
  end

1.3 线程介绍

线程（Thread）：进程可以同时执行多个任务，每个任务就是一个线程。例如：360 安全卫士中的"电脑清理"和"电脑杀毒"是同一个进程中的不同线程。

flowchart TB
  P["进程"] --> T1["子任务 1（单线程）"]
  P --> T2["子任务 2（多线程）"]
  T1 --> S1["子任务 1"]
  S1 --> S2["子任务 2"]
  T2 --> S3["子任务 1"]
  T2 --> S4["子任务 2"]

1.4 多线程的意义

随着处理器上的核心数量越来越多，现在大多数计算机都比以往更加擅长并行计算。一个线程，在一个时刻，只能运行在一个处理器核心上。

多线程的两个核心作用：

作用	说明
<span style="color:green">提高执行效率</span>	多个任务并行执行，节省时间
<span style="color:blue">同时处理多个任务</span>	一个应用可以同时处理多种业务（如下载 + 上传）

小结：线程是进程中的任务，多线程就是多个任务。多线程的意义在于提高效率、可以同时处理多个任务。

二、Java 开启线程的方式

Java 中有三种方式可以开启线程：继承 Thread 类、实现 Runnable 接口、实现 Callable 接口。推荐后两种方式，因为它们扩展性更好（避免了单继承的局限性）。

方式	是否需要返回值	说明
<span style="color:blue">继承 Thread 类</span>	无返回值	重写 `run()` 方法，调用 `start()` 启动线程
<span style="color:green">实现 Runnable 接口</span>	<span style="color:green">线程任务无返回值</span>	实现 `run()` 方法，传入 `Thread` 构造器启动
<span style="color:orange">实现 Callable 接口</span>	<span style="color:orange">线程任务有返回值</span>	实现 `call()` 方法，借助 `FutureTask` 启动

三、线程相关方法

3.1 常用方法

Thread 类提供了丰富的线程控制方法，红色标记的是静态方法。

方法名称	说明
`String getName()`	返回此线程的名称
`void setName(String name)`	设置线程的名字（构造方法也可以设置名字）
<span style="color:red">`static`</span> `Thread currentThread()`	获取当前线程的对象
<span style="color:red">`static`</span> `void sleep(long time)`	让线程休眠指定的时间，单位为毫秒
`setPriority(int newPriority)`	设置线程的优先级
`final int getPriority()`	获取线程的优先级
`final void setDaemon(boolean on)`	设置为<span style="color:orange">守护线程</span>

// 示例：获取并设置线程名
MyThread t1 = new MyThread("线程A");
MyThread t2 = new MyThread("线程B");

t1.setName("高铁");
t2.setName("飞机");

System.out.println(t1.getName());  // 高铁
System.out.println(t2.getName());  // 飞机

// Thread.currentThread()：获取当前线程对象
System.out.println(Thread.currentThread().getName());  // main

3.2 线程调度方式

Java 线程调度采用抢占式调度（线程优先级高的先获取 CPU 资源），但结果随机（因为多线程有随机性）。

调度方式	说明
<span style="color:green">抢占式调度</span>	优先级高的线程先抢占 CPU，<span style="color:green">Java 采用此方式</span>
非抢占式调度	按顺序执行，公平但效率低

优先级范围：1 ~ 10，默认值为 5。优先级高只是获取 CPU 资源的概率高，不是绝对先执行。

MyThread t1 = new MyThread("高铁");
MyThread t2 = new MyThread("飞机");

t1.setPriority(Thread.MIN_PRIORITY);  // 1
t2.setPriority(Thread.MAX_PRIORITY);  // 10

System.out.println(t1.getPriority());  // 1
System.out.println(t2.getPriority());  // 10

四、线程安全和同步

4.1 线程安全的问题

需求：某电影院目前正在上映国产大片，共有 100 张票，而它有 3 个窗口卖票。请设计一个程序模拟该电影院卖票。

class Tickets implements Runnable {
    int tickets = 1;

    @Override
    public void run() {
        while (true) {
            if (tickets <= 0) {
                break;
            }
            System.out.println(Thread.currentThread().getName() + "卖出了第" + tickets + "号票");
            tickets--;
        }
    }
}

上面的代码存在线程安全问题：多个线程同时操作共享数据 tickets，可能导致卖出同一张票甚至卖出 0 号、-1 号票。

4.2 线程安全问题分析

三个线程同时进入 while 循环，都读取到 tickets = 1，于是都"卖出了第 1 号票"，然后 tickets-- 多次，结果出现重复卖票或卖出非法票号。

安全问题出现的条件：

条件	说明
<span style="color:red">是多线程环境</span>	必须有多个线程并发执行
<span style="color:red">有共享数据</span>	多个线程操作同一个数据
<span style="color:red">有多条语句操作共享数据</span>	多个操作共享数据的代码

4.3 线程同步

同步技术：将多条语句操作共享数据的代码锁起来，让任意时刻只能有一个线程可以执行。

flowchart TB
  subgraph 同步前
    direction TB
    T1["线程 1"] -->|"进入"| Code["多条语句操作共享数据"]
    T2["线程 2"] -->|"进入"| Code
    T3["线程 3"] -->|"进入"| Code
  end
  subgraph 同步后
    direction TB
    T1A["线程 1"] -->|"加锁"| LockA["🔒 锁"]
    LockA -->|"执行"| CodeA["多条语句操作共享数据"]
    T2A["线程 2"] -.等待.-> LockA
    T3A["线程 3"] -.等待.-> LockA
  end

Java 提供三种同步方式：

方式	说明
<span style="color:blue">同步代码块</span>	`synchronized(锁对象) { ... }`
<span style="color:green">同步方法</span>	在方法返回值前加 `synchronized` 关键字
<span style="color:orange">Lock 锁</span>	`java.util.concurrent.locks.Lock` 接口，更灵活

4.3.1 同步代码块

synchronized(锁对象) {
    多条语句操作共享数据的代码
}

⚠ 注意事项：

锁对象可以是任意对象，但是需要保证多条线程的锁对象，是同一把锁

同步可以解决多线程的数据安全问题，但是也会降低程序的运行效率

class Tickets implements Runnable {
    int tickets = 100;
    Object lock = new Object();  // 锁对象

    @Override
    public void run() {
        while (true) {
            synchronized (lock) {
                if (tickets <= 0) {
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "卖出了第" + tickets + "号票");
                tickets--;
            }
        }
    }
}

4.3.2 同步方法

在方法的返回值类型前面加入 synchronized 关键字。

public synchronized void method() {
    // 多条语句操作共享数据的代码
}

小细节：

方法分为静态和非静态

静态方法的锁对象是字节码对象（类名.class）

非静态方法的锁对象是 this

4.3.3 Lock 锁

使用 Lock 锁，我们可以更清晰地看到哪里加了锁，哪里释放了锁。相比 synchronized，Lock 锁更灵活、性能更好。

对比：

// 方式一：同步代码块
synchronized(锁对象) {
    多条语句操作共享数据的代码
}

// 方式二：同步方法
public synchronized void method() { }

// 方式三：Lock 锁
lock.lock();
...
lock.unlock();

Lock 是接口，无法直接创建对象。

构造方法	说明
`public ReentrantLock()`	创建一个 `ReentrantLock` 的实例

成员方法	说明
`void lock()`	<span style="color:green">加锁</span>
`void unlock();`	<span style="color:orange">释放锁</span>

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Lock;

class Tickets implements Runnable {
    int tickets = 100;
    Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            lock.lock();
            try {
                if (tickets <= 0) {
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "卖出了第" + tickets + "号票");
                tickets--;
            } finally {
                lock.unlock();  // 无论是否异常，都需要释放锁
            }
        }
    }
}

五、线程池介绍

5.1 线程池的好处

池：提前创建好的一组资源（如数据库连接池、常量池）。将线程对象交给线程池维护，可以降低系统成本，从而提升程序的性能。

为什么需要线程池：

问题	说明
创建成本高	系统创建一个线程的成本是比较高的，因为它涉及到与操作系统交互
资源浪费	当程序中需要创建大量生存期很短暂的线程时，频繁的创建和销毁线程，就会严重浪费系统资源

5.2 线程池学习路径

学习线程池分三步：理解线程池的好处 → 使用 JDK 提供的线程池 → 自定义线程池。

flowchart LR
  A["理解线程池的好处"] --> B["使用 JDK 提供的线程池"]
  B --> C["自定义线程池"]

⚠【强制】线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

说明：Executors 返回的线程池对象的弊端如下：

FixedThreadPool 和 SingleThreadPool：允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。

CachedThreadPool：允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。

5.3 使用 JDK 提供的线程池

Executors 中提供静态方法来创建线程池（了解即可，实际开发推荐使用 ThreadPoolExecutor）。

方法	介绍
`static ExecutorService newCachedThreadPool()`	创建一个默认的线程池
`static newFixedThreadPool(int nThreads)`	创建一个指定最多线程数量的线程池

六、自定义线程池

6.1 ThreadPoolExecutor 类

ThreadPoolExecutor 是线程池的核心实现类，其构造方法有 7 个参数。

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
                   BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)

6.2 参数详解

参数	含义	约束
参数 1	<span style="color:blue">核心线程数量</span>（<span style="color:orange">正式员工</span>）	不能小于 0
参数 2	<span style="color:green">最大线程数量</span>（<span style="color:orange">正式员工 + 临时工</span>）	不能小于等于 0，<span style="color:red">最大数量 >= 核心线程数量</span>
参数 3	<span style="color:orange">空闲时间</span>	不能小于 0
参数 4	<span style="color:purple">时间单位</span>	时间单位
参数 5	<span style="color:green">任务队列</span>（<span style="color:orange">指定排队人数</span>）	不能为 null
参数 6	<span style="color:red">线程对象工厂</span>	不能为 null
参数 7	<span style="color:blue">拒绝策略</span>	不能为 null

flowchart TB
  Customers["顾客队列"] -->|"新任务"| Core["核心线程（正式员工） 数 = corePoolSize"]
  Core -->|"核心线程满"| Queue["任务队列 BlockingQueue"]
  Queue -->|"队列满"| Temp["临时线程 (maximumPoolSize - corePoolSize)"]
  Temp -->|"全部忙 + 队列满"| Reject["拒绝策略 RejectedExecutionHandler"]
  Temp -->|"空闲 keepAliveTime"| Temp
  Core -->|"空闲 keepAliveTime"| Core

6.3 线程池拒绝策略

策略选项	说明
<span style="color:blue">`ThreadPoolExecutor.AbortPolicy`</span>	丢弃任务并抛出 `RejectedExecutionException` 异常（<span style="color:red">默认</span>）
<span style="color:green">`ThreadPoolExecutor.DiscardPolicy`</span>	丢弃任务，但是不抛出异常，<span style="color:red">这是不推荐的做法</span>
<span style="color:orange">`ThreadPoolExecutor.DiscardOldestPolicy`</span>	抛弃队列中等待最久的任务，然后把当前任务加入队列中
<span style="color:purple">`ThreadPoolExecutor.CallerRunsPolicy`</span>	调用任务的 `run()` 方法，绕过线程池直接执行

6.4 自定义线程池小结

思考：临时线程什么时候创建？什么时候会开启拒绝策略？

问题	触发条件
<span style="color:green">临时线程什么时候创建？</span>	线程任务数 <span style="color:red">></span> <span style="color:blue">核心线程数</span> + 任务队列的数量
<span style="color:orange">什么时候会开启拒绝策略？</span>	线程任务数 <span style="color:red">></span> <span style="color:green">最大线程数</span> + 任务队列的数量

flowchart TB
  T["提交新任务"] --> Q1{"核心线程 是否已满？"}
  Q1 -->|"否"| C1["创建核心线程执行"]
  Q1 -->|"是"| Q2{"任务队列 是否已满？"}
  Q2 -->|"否"| Q3["任务进入队列等待"]
  Q2 -->|"是"| Q4{"当前线程数 是否达到最大？"}
  Q4 -->|"否"| C2["创建临时线程执行"]
  Q4 -->|"是"| Q5["执行拒绝策略"]

小结：自定义线程池通过 ThreadPoolExecutor 的 7 个参数灵活控制线程池的行为。核心线程处理正常业务，任务队列起到缓冲作用，临时线程应对突发流量，拒绝策略保证系统在极端情况下不会崩溃。

第十九章：网络编程

网络编程是实现设备间数据通信的核心技术，本章从通信架构、网络三要素讲起，重点掌握 UDP 和 TCP 两种协议的数据收发方式。

一、网络编程基本概念

1.1 网络编程

网络编程是让设备中的程序与网络上其他设备中的程序进行数据交互的技术（实现网络通信）。典型场景：手机与手机聊天、网页访问服务器。

1.2 基本的通信架构

基本的通信架构有 2 种形式：CS 架构、BS 架构。

架构	全称	典型应用	特点
<span style="color:green">CS 架构</span>	Client 客户端 / Server 服务端	微信、IntelliJ IDEA、网易云音乐	需要程序员开发客户端软件；需要用户下载安装客户端软件
<span style="color:green">BS 架构</span>	Browser 浏览器 / Server 服务端	Chrome、Edge、火狐浏览器访问网页	不需要程序员开发客户端；需要用户下载安装浏览器

⚠ 无论是 CS 架构，还是 BS 架构的软件都必须依赖网络编程！Java 提供了哪些网络编程解决方案？java.net.* 包下提供了网络编程的解决方案！

flowchart LR
  subgraph CS架构
    direction LR
    A1["Client 客户端"] -->|"请求"| B1["Server 服务端"]
    B1 -->|"响应"| A1
  end
  subgraph BS架构
    direction LR
    A2["Browser 浏览器"] -->|"HTTP请求"| B2["Server 服务端"]
    B2 -->|"HTTP响应"| A2
  end

二、网络编程三要素

网络通信三要素：IP 地址、端口、协议。

要素	含义
<span style="color:red">01 IP 地址</span>	设备在网络中的地址，<span style="color:red">是设备在网络中的唯一标识</span>
<span style="color:orange">02 端口</span>	应用程序在设备中的<span style="color:red">唯一标识</span>
<span style="color:green">03 协议</span>	连接和数据在网络中传输的<span style="color:red">规则</span>

2.1 IP 地址

IP（Internet Protocol）：全称"互联网协议地址"，是分配给上网设备的唯一标识。目前，被广泛采用的 IP 地址形式有两种：IPv4、IPv6。

类别	位数	字节数	表示法	数量
<span style="color:green">IPv4</span>	32 位	4 个字节	<span style="color:red">点分十进制</span>（如 `192.168.1.66`）	最多 `2^32` 个，<span style="color:red">目前已用完</span>
<span style="color:green">IPv6</span>	128 位	16 个字节	<span style="color:red">冒分十六进制</span>（如 `2001:0db8:0000:0023:0008:0800:200c:417a`）	最多 `2^128` 个，<span style="color:green">可为地球上每一粒沙子编号</span>

小细节：IPv4 地址一般写成 11000000.10101000.00000001.01000010，转成十进制就是 192.168.1.66。

2.1.1 IPv4 地址的分类形式

分类	说明	范围
<span style="color:green">公网地址</span>	万维网使用	—
<span style="color:orange">私有地址</span>	局域网使用，专门为组织机构内部使用，以此节省 IP	`192.168.0.0 ~ 192.168.255.255`

小结：常见场景为网吧、公寓、商场、办公楼等小型组织内部使用 192.168.xxx.xxx 的私有地址。

2.1.2 特殊 IP 地址

127.0.0.1（也可以是 localhost）：是回送地址也称本地回环地址，也称本机 IP，永远只会寻找当前所在本机。 建议：自己练习就写 127.0.0.1。

flowchart LR
  A["你的电脑"] -->|"访问其他电脑"| B["192.168.1.10"]
  A -->|"访问自己"| C["127.0.0.1"]

2.1.3 IP 和域名

平时上网没有用过 IP，都是用网址的。浏览器访问服务器时，先通过 DNS 服务器把网址（域名）解析成 IP 地址，再去访问对应的服务器。

flowchart LR
  Browser["浏览器"] -->|"网址/域名"| DNS["DNS 服务器"]
  DNS -->|"IP 地址"| Browser
  Browser -->|"访问黑马程序员服务器"| Server["黑马程序员服务器"]
  Server -->|"返回数据"| Browser

2.1.4 常用的 CMD 命令

命令	说明
`ipconfig`	查看本机 IP 地址
`ping`	检查网络是否连通

小结：

现在如何解决 IPv4 不够的问题？ 利用局域网 IP 解决 IP 不够的问题

特殊的 IP 是什么？ 127.0.0.1（永远表示本机）

常见的两个 CMD 命令？ ipconfig、ping

2.1.5 InetAddress 类

为了方便对 IP 地址的获取和操作，Java 提供了 InetAddress 类。 InetAddress：此类表示 Internet 协议（IP）地址。

方法名	说明
<span style="color:red">`static`</span> `InetAddress getByName(String host)`	确定主机名称的 IP 地址。主机名称可以是机器名称，也可以是 IP 地址
`String getHostName()`	获取此 IP 地址的主机名
`String getHostAddress()`	返回文本显示中的 IP 地址字符串

import java.net.InetAddress;

public class InetAddressDemo {
    public static void main(String[] args) throws Exception {
        InetAddress address = InetAddress.getByName("DESKTOP-ABC123");
        // InetAddress address = InetAddress.getByName("192.168.1.100");

        System.out.println(address.getHostName());   // 主机名
        System.out.println(address.getHostAddress()); // IP 地址字符串
    }
}

2.2 端口号

端口号是应用程序在设备中唯一的标识。

项目	说明
范围	<span style="color:red">0 ~ 65535</span>（由两个字节表示的整数）
知名端口	<span style="color:orange">0 ~ 1023</span> 用于一些知名的网络服务或者应用
自定义端口	<span style="color:green">1024 以上</span> 端口号自己使用

⚠ 注意：一个端口号只能被一个应用程序使用。

flowchart LR
  subgraph 电脑A
    APP1["WeChat 6666"] --> P65533["65533 消息"]
    APP2["QQ 7777"] --> P65533
    APP3["Game 8888"] --> P65533
  end
  P65533 -->|"端口号"| 电脑B

2.3 协议

计算机网络中，连接和通信的规则被称为网络通信协议。常见的协议有 UDP 协议 和 TCP 协议。

2.3.1 UDP 协议

用户数据报协议（User Datagram Protocol）。

面向无连接的通信协议

速度快，有大小限制（一次最多发送 64K）

数据不安全，易丢失数据

不管是否已经连接成功，都会发送

典型应用：在线视频

2.3.2 TCP 协议

传输控制协议 TCP（Transmission Control Protocol）。

面向连接的通信协议

速度慢，没有大小限制，数据安全

通过三次握手建立连接

通过四次挥手断开连接

典型应用：下载软件

flowchart LR
  subgraph 三次握手
    direction TB
    A1["客户端"] -->|"① 连接请求"| B1["服务器"]
    B1 -->|"② 响应"| A1
    A1 -->|"③ 确认"| B1
  end
  subgraph 四次挥手
    direction TB
    A2["客户端"] -->|"① 取消请求"| B2["服务器"]
    B2 -->|"② 响应"| A2
    B2 -->|"③ 处理数据后确认"| A2
    A2 -->|"④ 确认"| B2
  end

小结：网络通信三要素是 IP 地址、端口、协议，三者缺一不可。

三、UDP 协议收发数据

3.1 UDP 协议发送数据

类比快递流程：① 找快递公司 → ② 打包礼物 → ③ 快递公司发送包裹 → ④ 付钱走人。

步骤	类比	代码对应
① 找快递公司	找快递公司	<span style="color:green">创建发送端的 `DatagramSocket` 对象</span>
② 打包礼物	打包礼物	<span style="color:green">数据打包（`DatagramPacket`）</span>
③ 快递公司发送包裹	快递公司发送包裹	<span style="color:green">发送数据</span>
④ 付钱走人	付钱走人	<span style="color:green">释放资源</span>

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UDPSend {
    public static void main(String[] args) throws Exception {
        // ① 创建发送端的 DatagramSocket 对象
        DatagramSocket ds = new DatagramSocket();

        // ② 打包礼物（数据）
        String msg = "你好 UDP";
        byte[] bytes = msg.getBytes();
        InetAddress address = InetAddress.getByName("127.0.0.1");
        int port = 10086;

        DatagramPacket dp = new DatagramPacket(bytes, bytes.length, address, port);

        // ③ 发送数据
        ds.send(dp);

        // ④ 释放资源
        ds.close();
    }
}

3.2 UDP 协议接收数据

类比快递流程：① 找快递公司 → ② 接收箱子 → ③ 从箱子里面获取礼物 → ④ 签收走人。

步骤	类比	代码对应
① 找快递公司	找快递公司	<span style="color:green">创建接收端的 `DatagramSocket` 对象</span>
② 接收箱子	接收箱子	<span style="color:green">接收打包好的数据</span>
③ 从箱子里面获取礼物	从箱子里面获取礼物	<span style="color:green">解析数据包</span>
④ 签收走人	签收走人	<span style="color:green">释放资源</span>

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UDPReceive {
    public static void main(String[] args) throws Exception {
        // ① 创建接收端的 DatagramSocket 对象
        // 必须指定端口号，跟发送端一致
        DatagramSocket ds = new DatagramSocket(10086);

        // ② 接收打包好的数据
        byte[] bytes = new byte[1024];
        DatagramPacket dp = new DatagramPacket(bytes, bytes.length);

        // 该方法是阻塞的，会一直等发送端发送数据
        ds.receive(dp);

        // ③ 解析数据包
        byte[] data = dp.getData();
        int len = dp.getLength();
        String msg = new String(data, 0, len);
        System.out.println("数据是：" + msg);

        // ④ 释放资源
        ds.close();
    }
}

小结：UDP 协议收发数据

使用 DatagramSocket 搭建站点

使用 DatagramPacket 打包数据

send 方法用于发送

receive 方法用于接收

四、TCP 协议收发数据

4.1 TCP 通信程序

TCP 通信严格区分客户端和服务端。

4.1.1 客户端

步骤	说明	API
1	创建 `Socket` 对象指定 IP 和端口	`Socket(String host, int port)`
2	通过 socket 对象获取传输数据的流对象	`OutputStream getOutputStream()`、`InputStream getInputStream()`
3	通过流对象收发数据	—
4	释放资源	—

提示：这里的流对象不是读写文件中的数据

输出流：写出数据到服务端

输入流：读取服务端发送过来的数据

4.1.2 服务端

步骤	说明	API
1	创建 `ServerSocket` 对象指定端口	`ServerSocket(int port)`
2	响应客户端发送的请求	`Socket accept()`
3	通过 socket 对象获取传输数据的流对象	`OutputStream getOutputStream()`、`InputStream getInputStream()`
4	通过流对象收发数据	—
5	释放资源	—

// ================ 客户端 ================
import java.io.OutputStream;
import java.net.Socket;

public class TCPClient {
    public static void main(String[] args) throws Exception {
        // 1. 创建 Socket 对象指定 IP 和端口
        Socket socket = new Socket("127.0.0.1", 10086);

        // 2. 通过 socket 对象获取输出流
        OutputStream os = socket.getOutputStream();

        // 3. 写出数据
        os.write("你好 TCP".getBytes());

        // 4. 释放资源
        os.close();
        socket.close();
    }
}

// ================ 服务端 ================
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPServer {
    public static void main(String[] args) throws Exception {
        // 1. 创建 ServerSocket 对象指定端口
        ServerSocket ss = new ServerSocket(10086);

        // 2. 响应客户端发送的请求，得到 Socket 对象
        Socket socket = ss.accept();

        // 3. 通过 socket 对象获取输入流
        InputStream is = socket.getInputStream();

        // 4. 读取数据
        byte[] bytes = new byte[1024];
        int len = is.read(bytes);
        String msg = new String(bytes, 0, len);
        System.out.println("客户端发来：" + msg);

        // 5. 释放资源
        is.close();
        socket.close();
        ss.close();
    }
}

小结：TCP 协议区分客户端和服务端

客户端创建 Socket 对象，指定 IP 和端口号

服务端创建 ServerSocket 对象，指定端口号

调用 accept() 响应请求，得到 Socket 对象

两端通过 Socket 对象获取输入输出流，收发数据

第二十章：Java 高级技术

本章是 Java 高级特性的综合章节，涵盖枚举、类加载器、反射、注解、动态代理等核心技术。这些技术是框架的基石，掌握它们可以更深入地理解框架的运行原理。

一、枚举

1.1 枚举介绍

枚举是 Java 中的一种特殊类型，一般用来做信息的标记和分类。例如用标记来区分春、夏、秋、冬四个季节。

传统方式 vs 枚举方式：

// 传统方式：使用 public static final 常量
class Season {
    public static final int SPRING = 1;
    public static final int SUMMER = 2;
    public static final int AUTUMN = 3;
    public static final int WINTER = 4;
}

// 枚举方式：使用 enum 关键字
enum Season {
    SPRING, SUMMER, AUTUMN, WINTER;
}

1.2 枚举定义格式

枚举本质上是一个类，但比类多了几个特殊限制。

修饰符 enum 枚举类名 {
    枚举项1, 枚举项2, 枚举项3...;
}

public enum Season {
    SPRING, SUMMER, AUTUMN, WINTER;
}

1.3 枚举的特点

特点	说明
每一个枚举项其实就是该枚举的<span style="color:green">一个对象</span>	默认 public static final 修饰
通过<span style="color:green">枚举类名</span>去访问指定的枚举项	`Season.SPRING`
所有枚举类都是 `Enum` 的子类	继承自 `java.lang.Enum`
枚举也是类，可以定义成员变量	—
枚举类第一行必须是枚举项	最后一个枚举项后的分号可以省略，但有其他内容时不能省略
枚举类可以有构造器，但必须是 `private` 的	<span style="color:red">默认也是 private</span>
枚举类可以有抽象方法	但<span style="color:red">枚举项必须重写</span>该方法

1.4 枚举的使用场景

枚举最适合用于做信息的标记和分类。

场景：商品状态有 在售/预售/售罄 三种情况。

// 传统方式：定义多个常量
public static final int PRE_SALE = 1;  // 预售
public static final int SALE = 2;      // 在售
public static final int SELLOUT = 3;   // 售罄

// 枚举方式：一目了然
enum GoodState {
    PRE_SALE,   // 预售
    SALE,       // 在售
    SELLOUT     // 售罄
}

小结：使用枚举做信息的标记和分类，代码可读性更高，入参约束严谨，代码优雅。

二、类加载器

2.1 类加载器介绍

类加载器负责将类的字节码载入方法区中。加载时机为：用到就加载。

flowchart LR
  A[Java 源文件] -->|javac 编译| B[class 字节码文件]
  B -->|类加载器载入| C[方法区]

加载时机（满足以下任一条件即可）：

条件	示例
<span style="color:green">创建对象</span>	`Student stu = new Student();`
<span style="color:green">调用类的静态成员</span>	`System.out.println(A.num);`
<span style="color:green">初始化继承体系</span>	`Zi z = new Zi();`（`Zi extends Fu`）
<span style="color:green">使用反射加载类的字节码</span>	`Class.forName("com.xxx");`

2.2 类加载器的加载过程

类的加载过程分三步：加载 → 链接（验证、准备、解析） → 初始化。

flowchart LR
  A[加载] -->|找到 class| B[链接]
  B --> C[验证]
  C --> D[准备]
  D --> E[解析]
  E --> F[初始化]

阶段	功能
<span style="color:purple">加载</span>	通过包名 + 类名获取这个类，准备用流进行传输；将类加载到内存中；加载完毕创建一个 `Class` 对象
<span style="color:red">链接 - 验证</span>	验证类是否符合 JVM 规范，<span style="color:green">安全性检查</span>
<span style="color:red">链接 - 准备</span>	为 `static` 变量分配空间，<span style="color:green">设置默认值</span>（如 `String school = null`）
<span style="color:red">链接 - 解析</span>	将常量池中的<span style="color:green">符号引用</span>解析为<span style="color:green">直接引用</span>
<span style="color:blue">初始化</span>	根据程序员程序编码制定的主观计划去初始化类变量和其他资源（如 `String school = "传智大学"`）

小工具：jps 是 JDK 提供的一个查看当前 Java 进程的小工具。HSDB（Hotspot Debugger）是一款内置于 SA 中的 GUI 调试工具，可用于调试 JVM 运行时数据。启动命令：
java -cp ./lib/sa-jdi.jar sun.jvm.hotspot.HSDB

2.3 类加载器的分类

类加载器	说明	负责范围
<span style="color:red">Bootstrap class loader</span>	<span style="color:green">启动类加载器</span>，虚拟机的内置类加载器，<span style="color:red">通常表示为 null</span>	C++ 实现，获取到的只能是 null
<span style="color:orange">Platform class loader</span>	<span style="color:green">平台类加载器</span>，负责加载 JDK 中一些特殊的模块（JDK9 之前是 Extension Class Loader）	负责加载 `lib\modules` 内部的类（JDK9 之前是 `jre\lib\ext` 目录下的类）
<span style="color:blue">Application class loader</span>	<span style="color:green">应用程序类加载器</span>	负责加载自己写的类
自定义类加载器	上级为 Application	目前不做讲解

获取类加载器：

方法	功能
`public ClassLoader getClassLoader()`	获取该类的类加载器对象

2.4 双亲委派模式

双亲委派模式是 Java 类加载器的核心机制。

flowchart TB
  Start["开始 AppClassLoader"] --> A1{"是否加载过?"}
  A1 -->|是| Loaded["已经加载过 不再加载"]
  A1 -->|否| A2{"是否可以加载?"}
  A2 -->|否| P1["向上委托 PlatformClassLoader"]
  A2 -->|是| Done["自己加载此类"]
  P1 --> P2{"是否加载过?"}
  P2 -->|是| Loaded
  P2 -->|否| P3{"是否可以加载?"}
  P3 -->|否| B1["向上委托 BootStrapClassLoader"]
  P3 -->|是| Done
  B1 --> B2{"是否加载过?"}
  B2 -->|是| Loaded
  B2 -->|否| B3{"是否可以加载?"}
  B3 -->|否| CNF["ClassNotFoundException"]
  B3 -->|是| Done

双亲委派模式的原则：

如果一个类加载器收到了类加载请求，它并不会自己先去加载
而是把这个请求委托给父类的加载器去执行
如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归
请求最终将到达顶层的启动类加载器
如果父类加载器可以完成类加载任务，就成功返回
倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式
避免类的重复加载

小结：

类加载器负责将类的字节码载入到方法区中

加载时机：用到就加载

加载过程：加载 → 链接（验证、准备、解析） → 初始化

三、反射

3.1 反射介绍

反射是框架技术的灵魂。反射是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意属性和方法。这种动态获取信息以及动态调用对象方法的功能称为 Java 语言的反射机制。

理解：注释是给人看的，注解是给虚拟机看的。反射操作的是字节码对象。

flowchart LR
  Byte["字节码对象"] -->|"解剖"| A1["构造方法对象"]
  Byte --> A2["成员变量对象"]
  Byte --> A3["成员方法对象"]
  A1 -->|"创建"| A1a["创建对象"]
  A2 -->|"赋值、获取"| A2a["赋值 获取"]
  A3 -->|"调用"| A3a["调用"]

3.2 反射技术的学习路径

获取类的字节码对象
反射类中的构造方法，随后创建对象
反射类中的成员变量，完成赋值和获取
反射类中的成员方法，调用成员方法

3.3 获取类的字节码对象

获取 Class 对象有三种方式。

方式	说明	适用场景
<span style="color:green">`Class.forName("全类名")`</span>	<span style="color:green">全类名（包名+类名）</span>	编译时还不知道类名（<span style="color:red">最常用</span>）
<span style="color:green">`类名.class`</span>	通过类名直接获取	编译时已确定类名
<span style="color:green">`对象.getClass()`</span>	通过对象获取	已有对象时使用

// 1. Class.forName（最常用）
Class<?> clazz1 = Class.forName("com.itheima.Student");

// 2. 类名.class
Class<?> clazz2 = Student.class;

// 3. 对象.getClass()
Student stu = new Student();
Class<?> clazz3 = stu.getClass();

小结：反射是框架技术的灵魂，在运行状态中可以操作任意类中的任意属性任意方法；反射操作的是字节码对象；获取字节码对象的三种方式见上表。

3.4 反射类中的构造方法

方法	功能
<span style="color:green">`Constructor<?>[] getConstructors()`</span>	返回所有<span style="color:green">公共构造方法</span>对象的数组
<span style="color:green">`Constructor<?>[] getDeclaredConstructors()`</span>	返回所有构造方法对象的数组
<span style="color:green">`Constructor<T> getConstructor(Class<?>... parameterTypes)`</span>	返回单个<span style="color:green">公共构造方法</span>对象
<span style="color:green">`Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)`</span>	返回单个构造方法对象

Constructor 类用于创建对象的方法：

方法	功能
<span style="color:green">`T newInstance(Object... initargs)`</span>	根据指定的构造方法创建对象
<span style="color:green">`setAccessible(boolean flag)`</span>	设置为 true，<span style="color:green">表示取消访问检查</span>（暴力反射）

// 通过反射获取无参构造方法并创建对象
Class<?> clazz = Class.forName("com.itheima.Student");
Constructor<?> con = clazz.getDeclaredConstructor();
con.setAccessible(true);  // 取消访问检查
Object obj = con.newInstance();

⚠ 反射建议：禁止暴力反射操作（生产环境慎用 setAccessible(true)）。

3.5 反射类中的成员变量

方法	功能
<span style="color:green">`Field[] getFields()`</span>	返回所有<span style="color:green">公共成员变量</span>对象的数组
<span style="color:green">`Field[] getDeclaredFields()`</span>	返回所有成员变量对象的数组
<span style="color:green">`Field getField(String name)`</span>	返回单个<span style="color:green">公共成员变量</span>对象
<span style="color:green">`Field getDeclaredField(String name)`</span>	返回单个成员变量对象

Field 类的设置和获取方法：

方法	功能
<span style="color:green">`void set(Object obj, Object value)`</span>	<span style="color:green">赋值</span>
<span style="color:green">`Object get(Object obj)`</span>	<span style="color:green">获取值</span>

Class<?> clazz = Class.forName("com.itheima.Student");
Object obj = clazz.getDeclaredConstructor().newInstance();

// 反射获取 name 成员变量并赋值
Field nameField = clazz.getDeclaredField("name");
nameField.setAccessible(true);
nameField.set(obj, "张三");
String name = (String) nameField.get(obj);
System.out.println(name);  // 张三

3.6 反射类中的成员方法

方法	功能
<span style="color:green">`Method[] getMethods()`</span>	返回所有公共成员方法对象的数组，<span style="color:green">包括继承的</span>
<span style="color:green">`Method[] getDeclaredMethods()`</span>	返回所有成员方法对象的数组，<span style="color:red">不包括继承的</span>
<span style="color:green">`Method getMethod(String name, Class<?>... parameterTypes)`</span>	返回单个公共成员方法对象
<span style="color:green">`Method getDeclaredMethod(String name, Class<?>... parameterTypes)`</span>	返回单个成员方法对象

Method 类用于执行方法的方法：

方法	功能
<span style="color:green">`Object invoke(Object obj, Object... args)`</span>	<span style="color:green">运行方法</span>

Class<?> clazz = Class.forName("com.itheima.Student");
Object obj = clazz.getDeclaredConstructor().newInstance();

// 反射调用 study 方法
Method method = clazz.getDeclaredMethod("study");
method.setAccessible(true);
method.invoke(obj);  // 调用 study()

3.7 反射练习

练习 1（伪泛型）：请向一个泛型为 Integer 的集合，添加一个 String 字符串。 思路：Java 中的泛型是假的，只在编译的时候有效。

ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);

// 通过反射绕过泛型检查
Class<?> clazz = list.getClass();
Method add = clazz.getMethod("add", Object.class);
add.invoke(list, "hello");

System.out.println(list);  // [1, 2, hello]

练习 2（配置文件 + 反射）：编写 Student/Teacher/Worker 三个 JavaBean（属性均为 name、age），通过修改配置文件实现不修改代码切换调用不同类的不同方法。

# config.properties
className=com.itheima.Student
methodName=study

public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        // 1. 读取配置文件
        Properties prop = new Properties();
        prop.load(new FileInputStream("config.properties"));
        String className = prop.getProperty("className");
        String methodName = prop.getProperty("methodName");

        // 2. 通过反射创建对象
        Class<?> clazz = Class.forName(className);
        Constructor<?> con = clazz.getDeclaredConstructor();
        Object obj = con.newInstance();

        // 3. 通过反射调用方法
        Method method = clazz.getDeclaredMethod(methodName);
        method.invoke(obj);
    }
}

四、注解

4.1 注解介绍

Annotation 表示注解，是 JDK 1.5 的新特性。注解的主要作用是对程序进行标注。

理解：

注释是给人看的，注解是给虚拟机看的

通过注解可以给类增加额外的信息

编译器或 JVM 可以根据注解来完成对应的功能

JDK 中常见注解：

注解	说明
<span style="color:green">`@Override`</span>	表示方法的重写（<span style="color:red">编译时检查</span>）
<span style="color:green">`@Deprecated`</span>	表示修饰的方法已过时
<span style="color:green">`@SuppressWarnings("all")`</span>	<span style="color:green">压制警告</span>

4.2 自定义注解

重要：自定义注解单独存在意义不大，一般会跟反射结合起来使用。

4.2.1 自定义注解格式

public @interface 注解名称 {
    public 属性类型 属性名() default 默认值;
}

public @interface Anno {
    String show() default "show...";
}

属性类型：

类型	说明
<span style="color:green">基本数据类型</span>	`int`、`boolean` 等
<span style="color:green">String</span>	字符串
<span style="color:green">Class</span>	类对象
<span style="color:green">注解</span>	嵌套注解
<span style="color:green">枚举</span>	`enum` 类型
<span style="color:green">以上类型的一维数组</span>	如 `int[]`、`String[]`

完整示例：

public @interface MyAnno {
    public static final int num1 = 100;
    public static final String num2 = "abc";
    public static final MyAnno num3 = null;
    public static final Class num4 = String.class;
    public static final int[] num5 = {};

    public abstract String show1() default "show1";
    public abstract int show2() default 132;
    public abstract MyAnno2 show3() default @MyAnno2;
    public abstract Class show4() default String.class;
    public abstract int[] show5() default {1, 2, 3};
}

4.2.2 自定义注解使用

常用位置：

类
方法

⚠ 注意：

在使用注解时，如果注解的属性没有给出默认值，需要手动给出

@Anno(name="张三")

如果数组中只有一个属性值，在使用时 {} 是可以省略的

4.2.3 特殊的属性 value

如果只有一个属性名字为 value 没有赋值，使用时直接给出值，不需要写属性名。

public @interface SuppressWarnings {
    String[] value();
}

// 简化写法
@SuppressWarnings("all")
public class MyClass { }

4.3 元注解

元注解就是用在注解上的注解。

元注解名	说明
<span style="color:green">`@Target`</span>	指定了注解能哪里使用
<span style="color:green">`@Retention`</span>	可以理解为<span style="color:green">保留时间（生命周期）</span>

4.3.1 @Target

@Target：用来标识注解使用的位置，如果没有使用该注解标识，则自定义的注解可以使用在任意位置。

@Target 可使用的值定义在 ElementType 枚举类中：

值	说明
<span style="color:green">`TYPE`</span>	<span style="color:green">类，接口</span>
<span style="color:green">`FIELD`</span>	<span style="color:green">成员变量</span>
<span style="color:green">`METHOD`</span>	<span style="color:green">成员方法</span>
<span style="color:green">`PARAMETER`</span>	方法参数
`CONSTRUCTOR`	构造方法
`LOCAL_VARIABLE`	局部变量

4.3.2 @Retention

@Retention：用来标识注解的生命周期（有效范围）。

@Retention 可使用的值定义在 RetentionPolicy 枚举类中：

值	说明
`SOURCE`	注解只作用在源码阶段，<span style="color:red">生成的字节码文件中不存在</span>
<span style="color:green">`CLASS`</span>	注解作用在源码阶段，字节码文件阶段，<span style="color:red">运行阶段不存在</span>，<span style="color:red">默认值</span>
<span style="color:green">`RUNTIME`</span>	注解作用在源码阶段，<span style="color:red">字节码文件阶段，运行阶段</span>（<span style="color:green">反射需要使用</span>）

自定义测试注解案例：

需求：自定义一个注解 @Test，用于指定类的方法上，如果类中的某个方法上使用了该注解，就执行该方法。

// 1. 自定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {
}

// 2. 使用注解
public class UserTest {
    @Test
    public void test1() { System.out.println("test1 执行了"); }

    public void test2() { System.out.println("test2 没执行"); }
}

// 3. 通过反射执行
public static void main(String[] args) throws Exception {
    Class<?> clazz = UserTest.class;
    Object obj = clazz.getDeclaredConstructor().newInstance();
    for (Method method : clazz.getDeclaredMethods()) {
        if (method.isAnnotationPresent(Test.class)) {
            method.invoke(obj);
        }
    }
}

五、动态代理

5.1 动态代理

动态代理是对象的另外一种创建方式，这种方式可以在不修改源码的情况下，增强方法。

创建对象的方式：

Dog d = new Dog();                    // 1. new
Animal a = new Dog();                 // 2. 多态
Dog.class.getConstructor().newInstance();  // 3. 反射

5.2 代理

代理：在原有功能基础上进行增强。例如：房产中介可以在房东原有售卖房产、房屋出租的功能基础上，额外提供代驾、喂养宠物等服务。

// 1. 共同的接口
public interface Sale {
    void sale(double money);
    void hire(double money);
}

// 2. 被代理对象（房东）
public class Owner implements Sale {
    @Override
    public void sale(double money) {
        System.out.println("售卖房产" + money + "元");
    }

    @Override
    public void hire(double money) {
        System.out.println("出租房产" + money + "元");
    }
}

// 3. 代理对象（中介）
public class SaleImpl implements Sale {
    private Owner owner;

    public SaleImpl(Owner owner) {
        this.owner = owner;
    }

    @Override
    public void sale(double money) {
        money += 20000;       // 代理对象对功能增强（中介费）
        owner.sale(money);    // 被代理对象处理执行原有功能
    }

    @Override
    public void hire(double money) {
        money += 1000;        // 代理对象对功能增强
        owner.hire(money);    // 被代理对象处理执行原有功能
    }
}

5.3 JDK 动态代理

动态代理在运行时动态生成代理类，无需手动为每个目标类编写代理类。

Java 提供了 java.lang.reflect.Proxy 类，提供了使用动态代理方式创建对象的 API。

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

参数介绍：

参数	作用
参数一	用于指定用哪个<span style="color:green">类加载器</span>，去加载生成的实现类
参数二	指定<span style="color:green">接口</span>，这些接口用于指定生成的实现类中有什么，也就是有哪些方法
参数三	用来指定生成的实现类中<span style="color:green">不同方法的实现方案</span>

完整示例：

public class ProxyUtil {
    public static <T> T createProxy(T obj) {
        // 获取被代理对象的 ClassLoader
        ClassLoader loader = obj.getClass().getClassLoader();
        // 获取被代理对象实现的所有接口
        Class<?>[] interfaces = obj.getClass().getInterfaces();
        // 创建 InvocationHandler
        InvocationHandler h = (proxy, method, args) -> {
            // 增强逻辑
            if (method.getName().equals("sale")) {
                System.out.println("收取中介费 20000 元");
            }
            // 调用被代理对象的原方法
            return method.invoke(obj, args);
        };
        // 返回代理对象
        return (T) Proxy.newProxyInstance(loader, interfaces, h);
    }
}

public static void main(String[] args) {
    Owner owner = new Owner();
    Sale sale = ProxyUtil.createProxy(owner);
    sale.sale(1000000);   // 输出：收取中介费 20000 元 / 售卖房产1020000.0元
    sale.hire(3000);      // 输出：出租房产3000.0元
}

小结：

动态代理是对象的另外一种创建方式，这种方式可以在不修改源码的情况下，增强方法

代理对象可以在原有功能的基础上进行增强

动态代理在运行时动态生成代理类，无需手动为每个目标类编写代理类

使用 Proxy 中的 newProxyInstance() 方法创建代理对象

大二上物理

Sun, 06 Sep 2026 00:00:00 GMT

大二上物理

课时一振动学方程

考点	重要程度	占分	常见题型
1. 认识简谐运动	★★★★	3~5	选择 / 填空
2. 振动学方程	必考	5~10	大题

1. 认识简谐运动

弹簧振子在水平方向上做往复运动，速度在两端最大位移处为零（$v=0$），在平衡位置处最大。可用旋转矢量法直观表示。

简谐运动的基本公式：

物理量	表达式	说明
运动方程	$x = A\cos(\omega t + \varphi_0)$
振幅	$A = \sqrt{x_0^2 + \dfrac{v_0^2}{\omega^2}}$	由初始条件决定
角频率	$\omega = \sqrt{\dfrac{k}{m}} = \dfrac{2\pi}{T}$	弹簧振子
初相	$\varphi_0$	由初始条件决定
相位	$\omega t + \varphi_0$
周期	$T = \dfrac{2\pi}{\omega}$
频率	$\nu = \dfrac{1}{T} = \dfrac{\omega}{2\pi}$
速度	$v = \dfrac{dx}{dt} = -A\omega\sin(\omega t + \varphi_0)$，$v_{\max} = A\omega$
加速度	$a = \dfrac{dv}{dt} = -A\omega^2\cos(\omega t + \varphi_0)$，$a_{\max} = A\omega^2$

[!tip] 旋转矢量法用一个长度为 $A$ 的旋转矢量以角速度 $\omega$ 逆时针旋转，矢量在 $x$ 轴上的投影即对应位移 $x$。矢量与 $x$ 轴的夹角即为相位 $\omega t + \varphi_0$，$t=0$ 时的夹角为初相 $\varphi_0$。

<img src="/images/posts/physics-oscillation/assets/1-1-旋转矢量法.svg" alt="旋转矢量法示意" style="width:30vw;"/>

[!tip] 弹簧串并联弹簧串联：$\dfrac{1}{k} = \dfrac{1}{k_1} + \dfrac{1}{k_2}$ 弹簧并联：$k = k_1 + k_2$

<img src="/images/posts/physics-oscillation/assets/1-3-弹簧串并联.svg" alt="弹簧串并联模型" style="width:30vw;"/>

题1. 一质点按如下规律沿 $x$ 轴作简谐运动：$x = 0.1\cos\left(8\pi t + \dfrac{2\pi}{3}\right)$ (SI)，求此振动的周期、振幅、初相、速度最大值和加速度最大值。

解：

振幅 $A = 0.1,\text{m}$
角频率 $\omega = 8\pi$，$T = \dfrac{2\pi}{\omega} = \dfrac{2\pi}{8\pi} = 0.25,\text{s}$
初相 $\varphi_0 = \dfrac{2\pi}{3}$
速度最大值 $v_{\max} = A\omega = 0.1 \times 8\pi = 2.5,\text{m/s}$
加速度最大值 $a_{\max} = A\omega^2 = 0.1 \times (8\pi)^2 = 63.1,\text{m/s}^2$

题2. 质点做简谐运动，振动方程 $x = A\cos(\omega t + \varphi)$，当 $t = T/2$（$T$ 为周期）时，质点的速度为（）

$A.\ -A\omega\sin\varphi \quad B.\ A\omega\sin\varphi \quad C.\ -A\omega\cos\varphi \quad D.\ A\omega\cos\varphi \quad E.\ 0$

答：B

解：

$$v = \frac{dx}{dt} = -A\omega\sin(\omega t + \varphi)\Big|_{t=T/2}$$

$$= -A\omega\sin\left(\omega\cdot\frac{T}{2} + \varphi\right) = -A\omega\sin\left(\omega\cdot\frac{2\pi/\omega}{2} + \varphi\right)$$

$$= -A\omega\sin(\pi + \varphi) = A\omega\sin\varphi$$

题3. 将倔强系数为 $k$ 的轻质弹簧截去一半，然后一端固定，另一端下挂质量为 $m$ 的小球，组成振动系统。那么该系统的频率是（）

$A.\ \dfrac{1}{4\pi}\sqrt{\dfrac{k}{m}} \quad B.\ \dfrac{1}{2\pi}\sqrt{\dfrac{k}{m}} \quad C.\ \dfrac{1}{2\sqrt{2}\pi}\sqrt{\dfrac{k}{m}} \quad D.\ \dfrac{\sqrt{2}}{2\pi}\sqrt{\dfrac{k}{m}}$

答：D

解：两段半弹簧并联：$\dfrac{1}{k'} + \dfrac{1}{k'} = \dfrac{1}{k} \Rightarrow k' = 2k$

$$\omega = \sqrt{\frac{k'}{m}} = \sqrt{\frac{2k}{m}}, \quad \nu = \frac{\omega}{2\pi} = \frac{\sqrt{2}}{2\pi}\sqrt{\frac{k}{m}}$$

2. 振动学方程 $x = A\cos(\omega t + \varphi_0)$

题1. 已知一物体作简谐运动，周期为 $1,\text{s}$，振动曲线如图所示，求简谐运动的余弦表达式。

解：

振幅 $A = 0.04,\text{m}$
周期 $T = 1,\text{s}$，$\omega = \dfrac{2\pi}{T} = 2\pi,\text{rad/s}$
由旋转矢量法得 $\varphi_0 = -\dfrac{\pi}{3}$

$$x = 0.04\cos\left(2\pi t - \frac{\pi}{3}\right)$$

题2. 一质点作简谐运动，振幅为 $A$，在起始位置时刻质点的位移为 $\dfrac{A}{2}$，且向 $x$ 轴的正方向运动，代表此简谐运动的旋转矢量图为：

答：B（位移 $x = \dfrac{A}{2}$，且向 $+x$ 方向运动 ⟹ 矢量在第一象限，逆时针旋转）

题3. 质点沿 $x$ 轴作简谐运动，用余弦函数表示，振幅为 $A$，当 $t=0$ 时，质点处于 $x_0 = -\dfrac{A}{2}$ 处且向 $x$ 轴负方向运动，则其初相为：

$A.\ \dfrac{\pi}{6} \quad B.\ \dfrac{2\pi}{3} \quad C.\ \dfrac{4\pi}{3} \quad D.\ \dfrac{\pi}{3}$

答：B

解：由旋转矢量法，$\varphi_0 = \dfrac{2\pi}{3}$（位于第二象限，对应 $x = -\dfrac{A}{2}$ 且向 $-x$ 方向旋转分量最大处）。

题4. 质点振动的 $x-t$ 曲线如图所示，求：

（1）质点的振动方程；

（2）质点从 $t=0$ 的位置到达 $P$ 点相应位置所需的最短时间。

解：

（1）$A = 0.1$

由旋转矢量法知 $\varphi_0 = -\dfrac{\pi}{3}$，$x = 0.1\cos\left(\omega t - \dfrac{\pi}{3}\right)$

$0 = 0.1\cos\left(\omega t - \dfrac{\pi}{3}\right)$ 时 $\omega t - \dfrac{\pi}{3} = \dfrac{\pi}{2} \Rightarrow \omega = \dfrac{5\pi}{6}$

$$x = 0.1\cos\left(\frac{5\pi}{6}t - \frac{\pi}{3}\right)$$

（2）$t = 0$ 时 $\varphi_0 = -\dfrac{\pi}{3}$；$t = t_P$ 时 $\varphi_P = 0$

$$\Delta t = \frac{\Delta\varphi}{\omega} = \frac{\pi/3}{5\pi/6} = 0.4,\text{s}$$

题5. 如图所示，质量为 $1.0\times10^{-2},\text{kg}$ 的子弹，以 $500,\text{m/s}$ 的速度射入并嵌在木块中，同时使弹簧压缩而作简谐运动。设木块质量为 $4.99,\text{kg}$，弹簧的劲度系数为 $k = 8.00\times10^3,\text{N/m}$。若以弹簧原长时木块所在处为坐标原点，向右为轴正方向，求简谐运动方程。

解：由动量守恒

$$mv = (M + m)v_0 \Rightarrow v_0 = \frac{m}{M + m}v = \frac{0.01}{0.01 + 4.99}\times 500 = 1,\text{m/s}$$

$$\omega = \sqrt{\frac{k}{M + m}} = \sqrt{\frac{8\times10^3}{0.01 + 4.99}} = 40,\text{rad/s}$$

$$A = \sqrt{x_0^2 + \frac{v_0^2}{\omega^2}} = \sqrt{0^2 + \frac{1^2}{40^2}} = 2.5\times10^{-2},\text{m}$$

由旋转矢量法知 $\varphi_0 = \dfrac{\pi}{2}$

$$x = 2.5\times10^{-2}\cos\left(40t + \frac{\pi}{2}\right)$$

课时二振动的能量及合成

考点	重要程度	占分	常见题型
1. 振动的能量	★★★	0~2	选择 / 填空
2. 振动的合成	★★★	0~2	选择 / 填空

1. 振动的能量

简谐运动的机械能守恒：

机械能 = 动能 + 势能
$E = \dfrac{1}{2}mv^2 + \dfrac{1}{2}kx^2$
在最大位移处（$x=\pm A$，$v=0$）：动能 $E_k = 0$，势能 $E_p = \dfrac{1}{2}kA^2$
总机械能：$E = \dfrac{1}{2}kA^2$（不变）

题1. 质点做简谐运动，从平衡位置运动到最大位移处时，质点的动能 ______，势能 ______，总的机械能 ______。（填增大、减小或不变）

答：减小，增大，不变

解：从平衡位置（$x=0$，$v$ 最大）到最大位移处（$x=\pm A$，$v=0$），动能 $E_k = \frac{1}{2}mv^2$ 减小，势能 $E_p = \frac{1}{2}kx^2$ 增大；总机械能 $E = \frac{1}{2}kA^2$ 守恒不变。

题2. 一弹簧振子作简谐运动，当其偏离平衡位置的位移的大小为振幅的 $\dfrac{1}{4}$ 时，其动能为振动总能量的（　）。

$A.\ \dfrac{9}{16}\quad B.\ \dfrac{11}{16}\quad C.\ \dfrac{13}{16}\quad D.\ \dfrac{15}{16}$

答：D

解：

势能 $E_p = \dfrac{1}{2}k\left(\dfrac{A}{4}\right)^2 = \dfrac{1}{32}kA^2$
总机械能 $E = \dfrac{1}{2}kA^2$
动能 $E_k = E - E_p = \dfrac{1}{2}kA^2 - \dfrac{1}{32}kA^2 = \dfrac{15}{32}kA^2$
$\dfrac{E_k}{E} = \dfrac{\dfrac{15}{32}kA^2}{\dfrac{1}{2}kA^2} = \dfrac{15}{16}$

题3. 有一水平的弹簧振子，弹簧的劲度系数 $k = 25,\text{N/m}$，物体质量 $m = 1.0,\text{kg}$，物体静止在平衡位置。设以水平向左的恒力 $F = 10,\text{N}$ 作用在物体上（不计一切摩擦），使其由平衡位置向左运动了 $0.05,\text{m}$，此时撤除力 $F$，当物体运动到最左边时开始计时，求物体的运动方程。

解：

由机械能守恒 $F\cdot x = \dfrac{1}{2}kA^2$，即 $10\times0.05 = \dfrac{1}{2}\times25\times A^2 \Rightarrow A = 0.2,\text{m}$
角频率 $\omega = \sqrt{\dfrac{k}{m}} = \sqrt{\dfrac{25}{1}} = 5,\text{rad/s}$
由旋转矢量法知 $\varphi_0 = \pi$（物体从最左边 $x=-A$ 处开始计时）
运动方程：$x = 0.2\cos(5t + \pi)$

2. 振动的合成

同方向同频率的两个简谐运动 $x_1 = A_1\cos(\omega t + \varphi_1)$、$x_2 = A_2\cos(\omega t + \varphi_2)$ 合成：

$$A = \sqrt{A_1^2 + A_2^2 + 2A_1A_2\cos(\varphi_2 - \varphi_1)}$$

$$\tan\varphi = \frac{A_1\sin\varphi_1 + A_2\sin\varphi_2}{A_1\cos\varphi_1 + A_2\cos\varphi_2}$$

题1. 某质点同时参与轴上的两个简谐运动：$x_1 = 0.03\cos\left(2\pi t + \dfrac{\pi}{3}\right)$，$x_2 = 0.05\cos\left(2\pi t - \dfrac{2\pi}{3}\right)$（SI），合成振动的振动方程为 ______。

解：

解法一（旋转矢量法）： 相位差 $\varphi_2 - \varphi_1 = -\dfrac{2\pi}{3} - \dfrac{\pi}{3} = -\pi$，两振动方向相反，故

$$A = 0.05 - 0.03 = 0.02,\text{m},\qquad \varphi_0 = -\frac{2\pi}{3}$$

$$\Rightarrow x = 0.02\cos\left(2\pi t - \frac{2\pi}{3}\right)$$

解法二（公式法）：

$$A = \sqrt{A_1^2 + A_2^2 + 2A_1A_2\cos(\varphi_2-\varphi_1)} = \sqrt{0.03^2 + 0.05^2 + 2\times0.03\times0.05\cos(-\pi)} = 0.02$$

$$\tan\varphi = \frac{0.03\sin\frac{\pi}{3} + 0.05\sin\left(-\frac{2\pi}{3}\right)}{0.03\cos\frac{\pi}{3} + 0.05\cos\left(-\frac{2\pi}{3}\right)} = \sqrt{3}$$

由旋转矢量法可知 $\varphi = -\dfrac{2\pi}{3}$，故 $x = 0.02\cos\left(2\pi t - \dfrac{2\pi}{3}\right)$。

课时三机械波

考点	重要程度	占分	常见题型
1. 认识机械波	★★★	0~3	选择、填空
2. 波动方程	必考	5~10	大题

1. 认识机械波

机械波的形成： 波源振动带动相邻质点依次振动，振动形式在介质中由近及远传播。介质中各质点只在自己的平衡位置附近振动，不随波迁移，传播的是振动形式和能量。

波速、波长、周期的关系：

$$u = \frac{\lambda}{T} = \lambda \nu$$

波速 $u$：波形传播的速度，由介质决定
波长 $\lambda$：一个完整波形沿传播方向占据的长度，等于波线上相位差为 $2\pi$ 的两点间距离
周期 $T$：波传播一个波长所需的时间，等于波源的振动周期（由波源决定）

两点间相位差：

$$\Delta\varphi = \frac{2\pi}{\lambda},\Delta x \quad\Longleftrightarrow\quad \frac{\lambda}{\Delta x} = \frac{2\pi}{\Delta\varphi}$$

[!tip] 记忆口诀 "见者有份"：波长对应 $2\pi$ 相位，两点距离 $\Delta x$ 占波长多少份，相位差就占 $2\pi$ 多少份。

波动方程（沿 +x 方向传播）

原点 $O$ 的振动方程：$y = A\cos(\omega t + \varphi_0)$

若波沿 $+x$ 方向传播，$x$ 处质点的振动比 $O$ 点落后 $\Delta t = \dfrac{x}{u}$，故

$$y = A\cos\left[\omega\left(t - \frac{x}{u}\right) + \varphi_0\right] = A\cos\left[2\pi\left(\nu t - \frac{x}{\lambda}\right) + \varphi_0\right] = A\cos\left[\omega t + \varphi_0 - \frac{2\pi}{\lambda}x\right]$$

若波沿 $-x$ 方向传播，$x$ 处质点的振动比 $O$ 点超前，则

$$y = A\cos\left[\omega\left(t + \frac{x}{u}\right) + \varphi_0\right] = A\cos\left[2\pi\left(\nu t + \frac{x}{\lambda}\right) + \varphi_0\right] = A\cos\left[\omega t + \varphi_0 + \frac{2\pi}{\lambda}x\right]$$

[!warning] 易错点判断传播方向时，"上坡下、下坡上"：在波形图上升段（沿波传播方向）质点向下振动，下降段质点向上振动。

例题

题1. 已知一平面简谐波的波动方程为：$y = 2.0\cos\left2\pi\left(t - \dfrac{x}{8}\right) + \dfrac{\pi}{3}\right$，则此波沿 $x$ 轴 ______ 方向传播，波速为 ______，波长为 ______，原点处初相为 ______。

答：正；$8,\text{m/s}$；$8,\text{m}$；$\dfrac{\pi}{3}$

解：波动方程与标准式 $y = A\cos\left[2\pi\left(\nu t - \dfrac{x}{\lambda}\right) + \varphi_0\right]$ 对照：

括号内为 $\left(t - \dfrac{x}{8}\right)$，$x$ 前为负号 ⟹ 沿 $+x$（正）方向传播
波长 $\lambda = 8,\text{m}$，频率 $\nu = 1,\text{Hz}$
波速 $u = \lambda\nu = 8\times1 = 8,\text{m/s}$
初相 $\varphi_0 = \dfrac{\pi}{3}$

<hr>

题2. 一横波沿绳子传播时，波的表达式为 $y = 0.05\cos(10\pi t - 4\pi x)$（SI），则（　）。

$A.\ 波长为\ 0.5,\text{m} \quad B.\ 波速为\ 5,\text{m/s} \quad C.\ 波速为\ 25,\text{m/s} \quad D.\ 频率为\ 2,\text{Hz}$

答：A

解：对照标准式 $y = A\cos\left[\omega t + \varphi_0 - \dfrac{2\pi}{\lambda}x\right]$：

由 $-4\pi x = -\dfrac{2\pi}{\lambda}x \Rightarrow \lambda = 0.5,\text{m}$ ✓
$\omega = 10\pi \Rightarrow T = \dfrac{2\pi}{\omega} = 0.2,\text{s}$
$u = \dfrac{\lambda}{T} = \dfrac{0.5}{0.2} = 2.5,\text{m/s}$（B、C 均错）
$\nu = \dfrac{1}{T} = \dfrac{1}{0.2} = 5,\text{Hz}$（D 错）

<hr>

题3. 频率为 $100,\text{Hz}$，传播速度为 $300,\text{m/s}$ 的平面简谐波，波线上距离小于波长的两点振动的相位差为 $\dfrac{\pi}{3}$，则两点相距（　）。

$A.\ 2.86,\text{m} \quad B.\ 2.19,\text{m} \quad C.\ 0.5,\text{m} \quad D.\ 0.25,\text{m}$

答：C

解：

$$\lambda = uT = u\cdot\frac{1}{\nu} = 300 \times \frac{1}{100} = 3,\text{m}$$

$$\Delta\varphi = \frac{2\pi}{\lambda}\Delta x \Rightarrow \frac{\pi}{3} = \frac{2\pi}{3}\Delta x \Rightarrow \Delta x = 0.5,\text{m}$$

2. 波动方程

[!note] 解题三步法 ① 求原点振动方程 $y = A\cos(\omega t + \varphi_0)$（旋转矢量法定 $\varphi_0$） ② 求波速 $u = \dfrac{\lambda}{T} = \lambda\nu$ ③ 代入波动方程 $y = A\cos\left[\omega\left(t \mp \dfrac{x}{u}\right) + \varphi_0\right]$

例题

题1. 已知一沿 $x$ 轴正向传播的平面简谐波，时间 $t = 0$ 时的波形如图所示，且 $T = 2,\text{s}$，求：

（1）$O$ 点的振动方程；

（2）该波的波动方程；

（3）$x = 60,\text{m}$ 处质点的振动方程和速度表达式。

解：

（1）振幅 $A = 0.1,\text{m}$，$\omega = \dfrac{2\pi}{T} = \dfrac{2\pi}{2} = \pi\ \text{rad/s}$

由旋转矢量法得 $\varphi_0 = -\dfrac{2\pi}{3}$（$t=0$ 时原点位移为负、且向 $-y$ 方向运动），故

$$y = 0.1\cos\left(\pi t - \frac{2\pi}{3}\right)$$

（2）$\lambda = 40,\text{m}$，$u = \dfrac{\lambda}{T} = \dfrac{40}{2} = 20,\text{m/s}$，波沿 $+x$ 传播：

$$y = 0.1\cos\left[\pi\left(t - \frac{x}{20}\right) - \frac{2\pi}{3}\right]$$

（3）将 $x = 60,\text{m}$ 代入：

$$y = 0.1\cos\left[\pi\left(t - \frac{60}{20}\right) - \frac{2\pi}{3}\right] = 0.1\cos\left(\pi t - \frac{11\pi}{3}\right)$$

速度表达式：

$$v = \frac{dy}{dt} = -0.1\pi\sin\left(\pi t - \frac{11\pi}{3}\right)$$

<hr>

题2. 一平面简谐波在介质中以波速 $u = 2,\text{m/s}$ 沿 $x$ 轴负方向传播，原点 $O$ 处质点的振动曲线如图所示，求：

（1）原点 $O$ 的质点的振动方程；

（2）该波的波动方程；

（3）$x = 20,\text{m}$ 处质点的振动方程。

解：

（1）振幅 $A = 4\times10^{-2},\text{m}$，周期 $T = 8,\text{s}$，$\omega = \dfrac{2\pi}{T} = \dfrac{2\pi}{8} = \dfrac{\pi}{4}\ \text{rad/s}$

由旋转矢量法得 $\varphi_0 = -\dfrac{\pi}{2}$，故

$$y = 4\times10^{-2}\cos\left(\frac{\pi}{4}t - \frac{\pi}{2}\right)$$

（2）波沿 $-x$ 方向传播，$u = 2,\text{m/s}$：

$$y = 4\times10^{-2}\cos\left[\frac{\pi}{4}\left(t + \frac{x}{2}\right) - \frac{\pi}{2}\right]$$

（3）$x = 20,\text{m}$ 处：

$$y = 4\times10^{-2}\cos\left[\frac{\pi}{4}\left(t + \frac{20}{2}\right) - \frac{\pi}{2}\right] = 4\times10^{-2}\cos\left(\frac{\pi}{4}t + 2\pi\right) = 4\times10^{-2}\cos\left(\frac{\pi}{4}t\right)$$

<hr>

题3. 一平面简谐波沿 $Ox$ 轴的负方向传播，波长为 $\lambda$，$P$ 处质点的振动规律如图所示，已知 $P$ 点与 $O$ 点的距离为 $d$。

（1）求 $P$ 处质点的振动方程；

（2）求此波的波动表达式。

解：

（1）由振动图：振幅 $A$，$\varphi_0 = \pi$，$t = 1,\text{s}$ 时 $y = 0$，即

$$0 = A\cos(\omega + \pi) \Rightarrow \omega + \pi = \frac{3\pi}{2} \Rightarrow \omega = \frac{\pi}{2}$$

$$y_P = A\cos\left(\frac{\pi}{2}t + \pi\right)$$

（2）$T = \dfrac{2\pi}{\omega} = \dfrac{2\pi}{\pi/2} = 4,\text{s}$，$u = \dfrac{\lambda}{T} = \dfrac{\lambda}{4}$

以 $P$ 为原点（波沿 $-x$ 传播，$O$ 在 $P$ 的左侧 $d$ 处）：

$$y = A\cos\left[\frac{\pi}{2}\left(t + \frac{x}{\lambda/4}\right) + \pi\right] = A\cos\left[\frac{\pi}{2}\left(t + \frac{4x}{\lambda}\right) + \pi\right]$$

以 $O$ 为原点（$O$ 点比 $P$ 点振动超前 $\dfrac{d}{u}$）：

$$y = A\cos\left[\frac{\pi}{2}\left(t + \frac{4(x-d)}{\lambda}\right) + \pi\right]$$

[!tip] 波沿 $-x$ 传播的波动方程以振动规律已知的点 $P$ 为原点，$x$ 取正方向为 $-x$ 方向；以 $O$ 为原点时，$O$ 点比 $P$ 点超前 $d/u$，故相位项为 $+\dfrac{2\pi d}{\lambda}$（对应 $t + \dfrac{x+d'}{u}$ 形式）。

Java 核心与 AI 开发基础

Fri, 04 Sep 2026 00:00:00 GMT

Java核心与AI开发基础

第零章导学部分

AI 智能应用开发（Java）导学视频 —— 融合 Java 核心技术与 AI 创新能力多一句没有，少一句不行。用更短的时间，教会更实用的技术

课程介绍

课程定位与能力要求

就业方向	岗位技术力	专业技能 & 项目经验	课程阶段
Java+AI 初级工程师（1~2 年经验）<br>参与软件需求分析、负责代码模块功能实现、抽象系统能力、参加设计文档及系统能力，重大项目主导设计能力	6 门技术 + 整体项目经验 + 第三方方案	掌握 Java 核心语法、集合、多线程、IO/NIO、掌握 JVM 内存模型与 GC 机制、熟练使用 Spring Boot + MyBatis 开发 Web 应用、掌握分布式技术架构设计、熟悉 Kafka/MQ/Redis 中间件、掌握 MySQL/MongoDB 分布式存储与读写分离、掌握 Java 集合综合使用……	第一阶段：Java 核心与 AI 开发基础<br>第二阶段：Java 核心与 AI 开发进阶
Java+AI 中级工程师（3~5 年经验）<br>参与技术方案选型与设计、解决疑难问题、调优与扩展能力、参与重大项目主导设计能力	第三方技术 + 分布式项目经验 + AI 智能体应用开发	掌握微服务架构、Spring Cloud（Nacos/Sentinel/Seata）、微服务分布式事务、RabbitMQ 消息中间件、Redisson 分布式锁；熟练使用 Java 集合高级 API、Stream API、NIO、Netty；掌握 JVM 调优、SQL 调优；Redis 高级优化等技术；微服务高可用技术；分布式系统架构设计；微服务架构设计	第三阶段：AI 智能 Web 开发<br>第四阶段：企业级智能体项目（神州养车）<br>第五阶段：微服务 SCA<br>第六阶段：互联网分布式微服务项目（云岚到家）<br>第八阶段：沉浸式项目实战（神州养车）<br>第九阶段：Java AI 智能体应用开发<br>第十阶段：BAT 大厂 360° 测试开发 / 就业指导
能够清晰地表达自己的技术能力和项目经验	—	—	—
构建「Java 核心 + AI 创新」复合竞争力	—	掌握核心概念和技术，深入理解大模型智能体技术概念，包括提示词数据微调（Prompt Tuning）和特征改进微调（PET/Tuna）开源模型应用技术	雷达拓展课：分布式项目集<br>雷达拓展课：AI 大模型开发实战

课程总目标与时长

总目标	学习时长	课程阶段	任务包	学习周期
通过系统学习和实战项目，达到企业招聘需求，实现高薪就业	每周 ≥ 24 小时<br>（视频时长 12 小时，练习时长 12 小时）	第一阶段：Java 核心与 AI 开发基础	19	3 周（约 72 小时）
		第二阶段：Java 核心与 AI 开发进阶	12	2 周+（约 56 小时）
		第三阶段：AI 智能 Web 开发	18	7 周（约 168 小时）
		第四阶段：企业级智能体项目（神州养车）	15	4 周（约 96 小时）
		第五阶段：微服务 SCA	15	3 周（约 72 小时）
		第六阶段：互联网分布式微服务项目（云岚到家）	14	4 周（约 96 小时）

学习计划

什么是任务包？

任务包是老师为了帮助我们学好 Java 开发技能，将各阶段内容带分出的具体学习单元。每个任务包围绕学习目标展开，包含一系列具体的学习材料（视频、练习题等）以及预估学习时长，助力我们逐步达成学习目标，扎实吸收知识，实现高效学习。

任务包组成

维度	组成	详细说明
学习目标（技能点）	学习目标	每个任务包都有明确的学习目标，结合具体技能点。告诉你学完后要达到什么水平。例如：「Java 开发环境搭建」任务包中有三个技能点。
	技能点掌握要求	技能点 1：JDK 的下载和安装<br>技能点 2：配置环境变量、path 环境变量配置<br>技能点 3：使用 IDE 编写并运行 Java 代码<br>要求：不仅要看得懂，还要弄清楚运行环境中的概念，能够跟别人讲解自己写下来<br>举例 2：使用 IDEA 编写并运行 Java 代码<br>备注：通过实际操作，比如编写和运行简单的 Java 程序，确保能灵活运用这些知识解决实际问题。
学习材料	视频教程	详细讲解每个技能点，帮助你理解和掌握知识。
	知识总结	通过思维导图，快速复习所学技能点。
	练习题	通过实际操作巩固知识，提升应用能力。
质量验收	练习题	每个任务包都有练习题，帮助我们巩固所学知识。
	章节测评	每个关键章节结束后，有测评来检查学习进度。
	阶段考试	每个阶段结束后，老师会和我们对一对面试，检查编写能力；沟通表达能力。确保真正掌握了知识。
时间规划	任务包总时长	明确视频学习、练习和测评的预估时长，帮助我们合理安排时间。
	周计划	根据每周可投入的学习时间，合理分配任务包数量，确保学习进度和质量。

任务包能带来什么好处？

维度	好处
明确学习目标	每个任务包都有清晰的目标，结合具体的技能点和掌握要求，让我们清楚地知道要达成什么。集中精力在关键知识点上，提高学习效率。
系统化学习路径	通过分步骤的任务包，循序渐进地完成完整的学习体系，帮助我们更好地理解和掌握复杂内容。
高效时间管理	提供预估的学习时长和周计划，帮助我们合理安排时间，平衡学习与生活。
提升学习动力	每完成一个任务包，我们都能获得成就感，激发和保持热情，让我们设定确保每个阶段都有反馈和奖励。
易于跟踪进度	通过练习题、章节测评和阶段测试，清晰跟踪学习进度，及时调整学习计划，确保始终在正确的轨道上前进。

学习平台：博学谷

线上学习灵活，每日任务量可动态调整，但要确保周计划整体完成。平台提供日历视图，每日展示具体任务（前端学科就业班、Java 后端开发、20 天下载安装、学习阶段汇总、开发 Java 程序等），支持打卡、查看学习路线。

学习方法

flowchart LR
    S1["01 STEP 多动手实操"] --> S2["02 STEP 保持连贯性"] --> S3["03 STEP 学会总结"]

学习 Java 的三大步骤：多动手实操 → 保持连贯性 → 学会总结

学后测评

测评类型	用途
任务包练习	巩固任务包所学知识；编程题无需上传代码，提交后即可查看参考答案
章节测评	关键章节结束后的阶段检查
阶段考试	阶段性的综合考试，含面试问答

任务包练习示例（Java 核心与 AI 开发基础-任务包一[开发环境搭建]）：在 IntelliJ IDEA 中完成以下操作，创建一个 Java 工程并实现一个简单的打印功能。

①创建工程：打开 IntelliJ IDEA，创建一个名为 JavaSePractices 的空工程。 ②创建模块、包、类：在 JavaSePractices 工程中，创建一个名为 chapter01 的模块。在 chapter01 模块下，创建一个名为 com.buxuegu.demo01 的包。在 com.buxuegu.demo01 包中，创建一个名为 Test01 的类。 ③编写代码：在 Test01 类中，使用 main 方法打印 hello world 的控制台。 ④运行程序：运行 Test01 类，确保控制台输出以下内容：hello world

Java 的应用领域

Java 语言拥有 27 年发展历史，长盛不衰，是大型软件的服务端开发首选语言。

类别	典型应用
互联网应用	抖音、京东、快手、QQ、淘宝、美团、微信、今日头条、钉钉
资讯社区	知乎、豆瓣、CSDN、猫眼、中国知网
游戏 / 工具	任天堂

Java+AI 工程师的核心能力

Java 核心功夫是王道 —— 不管有没有 AI，写好 Java 代码都是根本！就像学武功，马步得扎稳。你写的 Java 代码就是指挥棒！代码写得好，逻辑清晰，AI 助手才能更好地执行任务，整个系统才稳定可靠。

地基四要素

flowchart LR
    Base[("地基 Java 核心功夫")]
    Data["数据感"]
    Learn["学习力"]
    Connect["对接 AI"]
    Business["业务眼"]
    Base --- Data
    Base --- Learn
    Base --- Connect
    Base --- Business

要素	含义	Java 中的体现
数据感	当好 AI 的原料整理师，把「乱糟糟」变成「整齐齐」	Java 程序收集用户对商品的评价文字
学习力	拥抱变化的心态	持续学习新框架、新工具
对接 AI	学会调用 AI「外挂」	在 Java 程序里方便地「调用」现成的 AI 功能
业务眼	知道用 AI 解决什么问题	区分哪些业务用传统代码、哪些用 AI 服务

对接 AI 案例

场景	Java 代码负责	AI 服务负责
评论情感分析	把一段用户评论发给 AI 服务	告诉评论的情感是正面还是负面的
图像识别	把一张图片传给 AI 服务	识别图片里有什么物体

业务眼 — AI 落地的典型场景

业务领域	描述
客服系统	自动回复、智能问答
图像与视频分析	内容理解、目标检测
金融交易	风控、量化决策
保险理赔	智能核损、定损

4 步能力成长路径

flowchart LR
    Step1["01 扎扎实实学好 Java 编程基础 入门期间，代码需要自己动手编写 不能依赖 AI 工具"] --> Step2["02 数据意识 收集数据，整理数据，传递数据"]
    Step2 --> Step3["03 对接 AI 开发期间，可以调用现成的、强大的 AI 功能 让程序更智能"]
    Step3 --> Step4["04 业务观察力、持续学习力 分辨出哪些业务需要传统代码实现 哪些业务可以调用 AI 服务"]

课程总览（第一、第二阶段）

阶段	章节	章节名
第一阶段	第一章	Java 开发环境搭建
	第二章	基础语法
	第三章	流程控制语句
	第四章	数组
	第五章	面向对象基础
	第六章	面向对象高级
	第七章	常用 API
	第八章	综合案例
第二阶段	第一章	集合高级
	第二章	异常
	第三章	File 类
	第四章	常用 API IO 流
	第五章	多线程
	第六章	网络编程
	第七章	Java 高级技术

第一章开发环境搭建

培养 AI 新时代 Java 工程师

Java 背景介绍

Java 语言的历史

Java 是由 James Gosling（詹姆斯·高斯林）于 1995 年在 Sun 公司开发的计算机高级编程语言，在 2009 年被 Oracle 公司收购。

James Gosling —— Java 之父

项目	内容
出生	1955 年出生于加拿大
学士	1977 年获得卡尔加里大学计算机学士学位
博士	1983 年获得卡内基梅隆大学计算机博士学位
称号	Java 之父

Java 的应用领域

方向	典型应用	说明
桌面应用开发	IDEA、Eclipse	集成开发工具
企业级应用开发	微服务、大型互联网应用	Java 的主战场
移动应用开发	Android	Android 原生应用
服务器系统	应用的后台	服务端开发
大数据开发	hadoop	大数据生态
游戏开发	我的世界 MineCraft	游戏服务端

Java 的三大技术平台

平台	全称	中文	定位
JavaSE	Java Standard Edition	标准版	Java 技术的核心和基础
JavaEE	Java Enterprise Edition	企业版	企业级应用开发的一套解决方案
JavaME	Java Micro Edition	小型版	针对移动设备应用的解决方案

本节复习

问题	答案
Java 是什么？	一门高级编程语言
Java 是哪家公司的？现在属于哪家公司？	Sun 公司、Oracle 公司
Java 之父是谁？	詹姆斯·高斯林
Java 能做什么？	基本上什么都可以干，主要做企业服务端开发
Java 有哪三大使用平台？	JavaSE（标准版）、JavaEE（企业版）、JavaME（小型版）

JDK 工具的下载和安装

JDK 简介

开发 Java 程序必须先安装好 JDK（Java Development Kit），也就是 Java 开发工具包。

LTS 版本（Long-Term Support）：JDK 8、JDK 11、JDK 17、JDK 21。很多企业还在使用 JDK 8 / JDK 11。

下载步骤

在 Oracle 的官网可以找到 JDK 的下载链接：Java Downloads | Oracle 中国

步骤	操作
①	选择 JDK 版本（推荐 JDK 17）
②	选择操作系统版本（如 Windows）
③	选择安装包类型（如 x64 Installer）

安装验证

安装完成后，通过 CMD 命令行测试是否安装成功：

步骤	操作
①	按下键盘上的 Win + R 键，会打开一个运行窗口
②	在窗口中输入 `cmd`，然后按下 Enter 键，弹出 DOS 窗口
③	在 DOS 窗口输入命令，测试 Java 工具及其版本是否正确

java -version
javac -version

JDK bin 目录核心工具

工具	类型	作用
`java.exe`	执行工具	启动 JVM 运行 class 文件
`javac.exe`	编译工具	将 `.java` 源文件翻译成 `.class` 字节码
`javadoc.exe`	文档工具	生成 API 文档

我们写好的 Java 程序都是高级语言，计算机底层是硬件，不能识别这些语言，必须先通过 javac 编译工具进行翻译，然后再通过 java 执行工具执行才可以驱动机器干活。

JDK 的组成

flowchart TB
    subgraph JDK["JDK（Java Development Kit） Java 开发工具包"]
        direction TB
        subgraph JRE["JRE（Java Runtime Environment） Java 运行环境"]
            direction TB
            JVM["JVM（Java Virtual Machine） Java 虚拟机 真正运行 Java 程序的地方"]
            CoreLib["核心类库 Java 自己写好的程序 给程序员自己的程序调用"]
            JVM --- CoreLib
        end
        DevTools["开发工具 java、javac..."]
    end

组件	含义	角色
JVM	Java Virtual Machine，Java 虚拟机	真正运行 Java 程序的地方
核心类库	Java 自己写好的程序	给程序员自己的程序调用
JRE	Java Runtime Environment，Java 运行环境	JVM + 核心类库
JDK	Java Development Kit，Java 开发工具包	JRE + 开发工具（含 java、javac 等）

DOS 常用命令

常用命令	作用
`盘符:`	切换盘符：`D:`、`E:`
`dir`	查看当前路径下的文件信息
`cd`	进入单级目录：`cd itheima` / 回退到上一级目录：`cd ..` / 回退到盘符根目录：`cd /`
`cls`	清屏
`tab`	自动补全指定字符开头的单词
`↑` 键	查看历史命令
`↓` 键	查看历史命令
`exit`	退出

本节复习

问题	答案
要使用 Java，必须先安装什么？去哪里下载？	JDK（Java Development Kit）开发者工具包；Oracle 官网
LTS 版本有哪些？很多企业还在使用哪个 JDK 版本？	JDK 8、11、17、21；很多企业还在使用 JDK 8 / JDK 11
如何验证 JDK 是否安装成功了？	打开命令行窗口，输入 `java -version`、`javac -version` 看版本号
JDK 中最重要的 2 个命令行程序是什么？各自的作用是？	`javac`、`java`；编译工具、执行工具

第一个 Java 程序 Hello World

Java 程序的开发步骤

flowchart LR
    A["① 编写代码 HelloWorld.java 源代码文件"] --> B["② 编译代码 javac HelloWorld.java → 生成 HelloWorld.class"]
    B --> C["③ 运行代码 java HelloWorld → 输出 Hello World"]

步骤	命令	说明
① 编写代码	—	用记事本等编辑器写 `HelloWorld.java`
② 编译代码	`javac HelloWorld.java`	生成 `HelloWorld.class` 字节码文件
③ 运行代码	`java HelloWorld`	JVM 执行 class，输出 `Hello World`

D:\code>javac HelloWorld.java
D:\code>java HelloWorld
Hello World

HelloWorld 代码解析

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World !");
    }
}

元素	含义
`public class HelloWorld`	`class` 定义一个类，后面跟上的是类名称；`public` 是权限修饰符（暂时理解：限制类名称和文件名称需要保持一致）
`public static void main(String[] args)`	程序执行时的入口点，`main` 方法也称之为主方法
`System.out.println("Hello World !")`	打印语句，使程序在控制台打印双引号所包裹的内容

Java 程序执行原理

机器语言与硬件

计算机底层都是硬件电路，可以通过不通电和通电，表示 0、1。 机器语言：由 0、1 组成，如 00011100 00110101。

编程语言发展历程

阶段	特点
机器语言	由 0/1 组成，计算机直接识别，难读难写
汇编语言	用助记符代替 0/1，仍是低级语言
高级语言	接近人类语言，需翻译成机器语言才能执行

高级语言更简单，使用接近人类自己的语言书写代码，再将其翻译成计算机能理解的机器指令。

Java 的跨平台原理

flowchart LR
    Java["Java 源代码"] --> Class[".class 字节码"]
    Class --> Win["Windows JVM 虚拟机"]
    Class --> Linux["Linux JVM 虚拟机"]
    Class --> Mac["MacOS JVM 虚拟机"]

总结：在需要运行 Java 应用程序的操作系统上，安装一个与操作系统对应的 Java 虚拟机（JVM，Java Virtual Machine） 即可。

本节复习

问题	答案
Java 程序的执行原理是什么样的？	不管是什么样高级编程语言，最终要翻译成计算机底层可以识别的机器语言
机器语言是由什么组成的？	0 和 1
Java 跨平台指的是什么？原理又是什么？	Java 程序可以在任意操作系统中运行；在不同的操作系统中，安装与之对应版本的 JVM 虚拟机

Java 环境配置

Path 环境变量

Path 环境变量用于记住程序路径，方便在命令行窗口的任意目录启动程序。

示例：QQ.exe 在 D:\App\QQ 目录下，从 D: 盘 >QQ、C: 盘 >qq、E: 盘 >qq 都能启动。

Path 环境变量位置：此电脑 → 属性 → 高级系统设置 → 高级 → 环境变量

Path 环境变量的原理：当我们在 Path 中配置某个程序路径后，启动命令行窗口启动程序时，系统会按 Path 中配置的目录顺序查找该程序。

JDK 的环境变量配置

较新版本的 JDK 安装时会自动配置 javac、java 程序的路径到 Path 环境变量中去，因此，javac、java 可以直接使用。

注意：以前的老版本的 JDK 在安装时是没有自动配置 Path 环境变量的，此时需要自己配置 Path 环境变量。

Path 值示例：E:\develop\Java\jdk21\bin（本机路径，不要抄，去复制）

重新配置了环境变量后，必须检测是否配置成功：打开命令行窗口，输入 java -version 分别看版本提示。

JAVA_HOME：告诉操作系统 JDK 安装在了哪个位置（将来其他技术要通过这个环境变量找 JDK）。

本节复习

问题	答案
什么是 Path 环境变量？	用于配置程序的路径，方便我们在命令行窗口的任意目录下启动该程序
JDK 安装时，关于环境变量的配置，需要注意什么？	较新版本的 JDK 会自动配置 PATH 环境变量，较老的 JDK 版本则不会
建议如何处理？	建议还是自己配置一下「PATH」、「JAVA_HOME」

第二章 IDEA 开发工具

工欲善其事必先利其器

IDEA 介绍和安装

IDE 集成环境

IDE 集成环境：把代码编写，编译，执行，调试等多种功能综合到一起的开发工具。

主流 Java 开发工具

工具	厂商	特点
IntelliJ IDEA	JetBrains	目前使用最多的 Java 开发集成环境
NetBeans	Oracle	开源
Eclipse	IBM 开源社区	老牌 IDE

官方网站：IntelliJ IDEA – the Leading Java and Kotlin IDE (jetbrains.com)

本节小结

关键点	内容
IDEA 全称	<span style="color:blue">IntelliJ IDEA</span>，是目前使用最多的 Java 开发集成环境
IDE 集成环境	把代码的编写、编译、运行、调试等多种功能综合到一起的开发工具

IDEA 中的第一个代码

IDEA 创建 Java 项目的代码结构

flowchart LR
    P["Project 工程"] --> M["Module 模块"]
    M --> Pa["Package 包"]
    Pa --> C["Class 类"]

层级	含义	作用
Project	工程	一个项目下可以管理多个模块
Module	模块	独立的业务单元（如商品模块、订单模块）
Package	包	组织类，避免类名冲突
Class	类	实际编写代码的地方

模块化项目示例

flowchart TB
    subgraph Project["Project 项目"]
        M1["商品模块"]
        M2["搜索模块"]
        M3["订单模块"]
        M4["购物车模块"]
    end

模块内部代码结构

每个模块（Module）内部通常按职责划分为：

代码类别	作用
前端交互代码	接收用户请求、返回响应数据
业务代码	处理业务逻辑（如商品查询、下单）
数据访问代码	与数据库交互（增删改查）

学习中的目录结构

整个基础篇创建一个 Project，今后每一天都创建一个新的 Module

BasicCodes/                      ← Project
├── .idea/
├── day01/                       ← Module（第 1 天）
├── day02/                       ← Module（第 2 天）
├── day03/                       ← Module（第 3 天）
├── BasicCodes.iml
├── External Libraries
└── Scratches and Consoles

IDEA 的使用操作

常用操作

操作类别	操作项
类文件	新建类文件、删除类文件、修改类文件
模块	新建模块、删除模块、修改模块、导入模块
项目	关闭项目、打开项目、修改项目、新建项目

常用快捷键

快捷键	功能
`psvm` + 回车	快速生成 main 方法
`sout` + 回车	快速生成输出语句
`Ctrl + Alt + L`	格式化代码
`Alt + Shift + ↑`	上移当前行
`Alt + Shift + ↓`	下移当前行
`Alt + 回车`	导入包，自动修正
`Ctrl + N`	查找类
`Ctrl + R`	替换文本
`Ctrl + F`	查找文本
`Shift + F6`	重构-重命名
`Ctrl + X`	剪切当前行
`Ctrl + D`	复制行
`Ctrl + /`	批量加入单行注释，再按一次就是取消
`Ctrl + Shift + /`	批量加入多行注释，再按一次就是取消
`Alt + 1`	快速打开或隐藏工程面板

第三章 Java 基础语法

根基稳，万事可成

注释

什么是注释

注释是写在程序中对代码进行解释说明的文字，方便自己和其他人查看，以便理解程序的。

Java 注释的三种写法

注释类型	写法格式	特点
单行注释	`// 注释内容`	只能写一行
多行注释	`/* 注释内容1<br>注释内容2 */`	可以写多行
文档注释	`/** 注释内容<br>注释内容 */`	可以生成 API 文档

/**
 * 通过class关键字定义了一个类，类名叫做 HelloWorld
 * public 起到限制作用，限制文件名和类名保持一致
 */
public class HelloWorld {
    public static void main(String[] args) {
        // 这是一个单行注释，有效范围是从 // 开始到当前行结尾
        System.out.println("HelloWorld");

        /*
            这是一个
            多行注释
         */
        System.out.println("HelloWorld");
    }
}

注意事项：注释内容不会参与编译和运行

本节小结

问题	答案
注释是什么？	写在程序中对程序进行解释说明的文字
Java 程序中书写注释的方式有几种，各自有什么不同？	单行注释：`//`<br>多行注释：`/* /`<br>文档注释：`/* */`
注释有什么特点？为什么？	不影响程序的执行，编译后的 class 文件中已经没有注释了

关键字

关键字介绍

关键字：被 Java 赋予了特定涵义的英文单词。

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("HelloWorld");
    }
}

例如：class 表示"创建类"。

注意事项：Java 中的关键字，已经被赋予了特殊的涵义，这些单词不允许使用。

Java 关键字大全

分类	关键字
访问控制	`private` `protected` `public`
类/方法/变量修饰符	`abstract` `class` `extends` `final` `implements` `interface` `native` `new` `static` `strictfp` `synchronized` `transient` `volatile`
程序控制	`break` `case` `continue` `default` `do` `else` `for` `if` `instanceof` `return` `switch` `while`
包相关	`import` `package`
数据类型	`boolean` `byte` `char` `double` `float` `int` `long` `short` `void`
错误处理	`assert` `catch` `finally` `throw` `throws` `try`
其他	`const` `enum` `goto` `super` `this`

字面量

字面量介绍

字面量：就是程序中能直接书写的数据，学这个知识的重点是：搞清楚 Java 程序中数据的书写格式。

常用数据	生活中的写法	程序中的写法	说明
整数	666、-88	666、-88	写法一致
小数	13.14、-5.21	13.14、-5.21	写法一致
字符串	黑马程序员	`"HelloWorld"`、`"黑马程序员"`	<span style="color:red">程序中必须使用双引号</span>
字符	A、0、我	`'A'`、`'0'`、`'我'`	<span style="color:red">程序中必须使用单引号，有且仅能一个字符</span>
布尔值	真、假	`true`、`false`	只有两个值：`true` 代表真，`false` 代表假
空值	—	值是：`null`	一个特殊的值，空值（后面会讲解作用，暂时不管）

字面量练习

需求：请将自己的个人信息打印在控制台（姓名，年龄，性别，身高，婚姻状况）

public class Main {
    public static void main(String[] args) {
        System.out.println("张三");
        System.out.println(23);
        System.out.println('男');
        System.out.println(180.1);
        System.out.println(false);
    }
}

张三
23
男
180.1
false

Process finished with exit code 0

本节小结

问题	答案
关键字指的是什么？	被 Java 赋予了特定含义的英文单词
关键字我们能使用吗？	不允许使用
字面量这个知识是要求同学们学会什么？	数据在程序中的书写格式
字符、字符串在程序中的书写格式有什么要求？	字符必须单引号围起来，有且仅能一个字符<br>字符串必须用双引号围起来
几个常见的特殊值的书写格式是？	`true`、`false`、`null`

变量

变量的介绍和定义格式

变量就是内存中的一块区域，可以理解成一个盒子，用来装程序要处理的数据的。

flowchart LR
    A["数据类型 变量名称 = 变量值;"] --> B["自己起的名字"]
    A --> C["赋值"]
    A --> D["限制盒子中只能存储某种数据形式 例如：int（整数类型）、double（小数类型）"]

部分	含义
数据类型	限制盒子中只能存储某种数据形式
变量名称	自己起的名字
=	赋值（将右边的值赋给左边的变量）
变量值	实际存储的数据

示例：int age = 18;

认识变量

变量有啥特点？变量里装的数据是可以被替换的。

int age = 18;
age = 19;             // 把 18 替换成 19

System.out.println(age);   // 输出 19
age = age + 1;             // 在 19 的基础上 + 1，变成 20

System.out.println(age);   // 输出 20

变量有啥应用场景呢？写程序对数据进行处理就很方便了。

本节小结

问题	答案
变量是什么，变量的完整定义格式是什么样的？	变量是内存中的一块区域，可以理解成盒子，用来记住成程序要处理的数据的。<br>数据类型变量名称 = 数据;
为啥要用变量，变量有啥好处？	使用变量记要处理的数据，编写的代码更灵活，管理代码更方便
变量有什么特点？基于这个特点，变量有啥应用场景？	变量里装的数据可以被替换

变量的注意事项

序号	注意事项
1	变量要先声明才能使用
2	变量是什么类型，就必须装什么类型的数据
3	变量只在自己所归属的 `{}` 范围内有效
4	同一个范围内，变量的名称不能一样
5	变量定义的时候可以不赋初始值，但在使用时，变量里必须有值
6	一条语句可以定义多个变量，中间使用逗号分隔

标识符

标识符概述

标识符：就是给类，方法，变量等起名字的符号。

public class Demo {

    public static void main(String[] args) {

        int salary = 12000;
        System.out.println(salary);

        salary = 15000;
        System.out.println(salary);

        int age = 18;
        System.out.println(age);
    }
}

标识符命名规则

硬性要求（不满足则编译报错）

规则	说明
组成字符	由<span style="color:blue">数字、字母、下划线（_）和美元符（$）</span>组成
开头	<span style="color:red">不能以数字开头</span>
关键字	<span style="color:red">不能是关键字</span>
大小写	区分大小写

判断下列变量名哪些不符合规则（红色 = 不符合）：

变量名	是否符合	原因
`bj`	✅	符合
`b2`	✅	符合
`2b`	❌	数字开头
`class`	❌	是关键字
`_2b`	✅	符合
`#itheima`	❌	包含非法字符 `#`
`ak47`	✅	符合
`Class`	✅	符合（首字母大写但不是关键字）
`helloworld`	✅	符合

标识符命名规范

软性建议（不满足不报错，但建议遵守）

命名法	适用场景	单单词	多单词
小驼峰命名法	变量、方法	所有字母小写：`name`	从第二个单词开始，首字母大写：`firstName`
大驼峰命名法	类	首字母大写：`Student`	每个单词的首字母大写：`GoodStudent`

本节小结

问题	答案
什么是标识符？	标识符就是名字
标识符的规则？	由数字、字母、下划线、美元符等组成；<span style="color:red">且不能数字开头，不能用关键字，不能用特殊符号（&、%）</span>
命名建议？	见名知义，驼峰命名

数据类型

数据类型分类

flowchart LR
    A["数据类型"] --> B["基本数据类型"]
    A --> C["引用数据类型"]

八种基本数据类型

数据类型	关键字	取值范围	内存占用
整数	`byte`	-128 ~ 127	1
整数	`short`	-32768 ~ 32767	2
整数	`int`（默认）	-2147483648 ~ 2147483647（10 位数）	4
整数	`long`	-9223372036854775808 ~ 9223372036854775807（19 位数）	8
浮点数	`float`	1.401298e-45 到 3.402823e+38	4
浮点数	`double`（默认）	4.9000000e-324 到 1.797693e+308	8
字符	`char`	0 ~ 65535	2
布尔	`boolean`	`true`、`false`	1

说明：e+38 表示是乘以 10 的 38 次方；同样，e-45 表示乘以 10 的负 45 次方。

public class Test {
    public static void main(String[] args) {
        System.out.println(10);     // 整数默认 int 类型
        System.out.println(12.3);   // 小数默认 double 类型
    }
}

编码表与 ASCII 码表

编码表：是计算机中字节到字符的一套对应关系。

ASCII 码表：American Standard Code for Information Interchange，美国信息交换标准代码。

项目	内容
数字 `0`	对应 ASCII 码 `48`
大写字母 `A`	对应 ASCII 码 `65`
小写字母 `a`	对应 ASCII 码 `97`

注：表中的 ASCII 字符可以用 ALT + 小键盘上的数字键 输入。

数据类型案例

需求：请将自己的个人信息，使用变量保存，并展示在控制台。

字段	示例值	数据类型
姓名	黑马谢广坤	`String`
年龄	18	`int`
性别	男	`char`
身高	180.1	`double`
是否单身	是	`boolean`

本节小结

问题	答案
Java 中的数据类型大体分为两类，分别是？	基本数据类型、引用数据类型
整数类型首选？小数类型首选？	`int`、`double`
定义字符串类型的变量，类型选的是？	`String`
所有整数默认是？小数默认是？	整数默认 `int`；小数默认 `double`
`char` 类型的变量，可以接收整数类型的数据吗？	可以（`char` 取值范围 0 ~ 65535，对应 ASCII 码）

第四章运算符

对变量和字面量操作的符号

算术运算符

运算符分类

符号	作用	说明
`+`	加	参看小学一年级
`-`	减	参看小学一年级
`*`	乘	参看小学二年级，与 "×" 相同
`/`	除	参看小学二年级，与 "÷" 相同
`%`	取余	获取的是两个数据做除法的<span style="color:red">余数</span>

/ 和 % 的区别：两个数据做除法，/ 取结果的商，% 取结果的余数。

整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。

案例：数值拆分

需求：将数字 123 拆分出个位、十位、百位后，打印在控制台

整数123的个位为:3
整数123的十位为:2
整数123的百位为:1

拆分位	公式	计算过程
个位	`数值 % 10`	123 除以 10（商 12，余数为 3）
十位	`数值 / 10 % 10`	123 除以 10（商 12），12 除以 10（商 1，余数为 2）
百位	`数值 / 10 / 10 % 10`	123 / 10 得到 12，12 / 10 得到 1，1 % 10 得到 1

公式总结：

个位：数值 % 10

十位：数值 / 10 % 10

百位：数值 / 10 / 10 % 10

千位：数值 / 10 / 10 / 10 % 10

……

本节小结

问题	答案
整数相除可以直接得到小数结果吗？如果不可以该怎么解决？	不可以，需要加入小数运算
假设给定一个五位数 65536，获取千位的计算公式是？	`数值 / 10 / 10 / 10 % 10`

字符串拼接

当 + 操作中，遇到了字符串，这时 + 就是字符串连接符，而不是算术运算。

public class Test {
    public static void main(String[] args) {
        System.out.println(1 + 23);                  // 24
        System.out.println("年龄为:" + 23);           // 年龄为:23
        System.out.println(1 + 99 + "年黑马");        // 100年黑马
    }
}

说明：从左到右依次运算，遇到字符串后，所有后续 + 都变为字符串拼接。

public class Test {
    public static void main(String[] args) {
        System.out.println("年龄为:" + 23 + 1);        // 年龄为:231
    }
}

计算过程：

"年龄为:" + 23 → "年龄为:23"

"年龄为:23" + 1 → "年龄为:231"

解决方案：使用小括号改变运算优先级。

public class Test {
    public static void main(String[] args) {
        System.out.println("年龄为:" + (23 + 1));      // 年龄为:24
    }
}

当 + 号操作中遇到了字符串，就会变成字符串拼接。

自增自减运算符

符号	作用	说明
`++`	自增	变量自身的值加 1
`--`	自减	变量自身的值减 1

++ 和 -- 既可以放在变量的后边，也可以放在变量的前边（参考购物车 + / - 按钮）。

本节小结

场景	规则
单独使用	`++`、`--` 单独使用在变量前后无区别
参与运算	`++` 在前，<span style="color:red">先自增再操作</span>；`++` 在后，<span style="color:orange">先操作再自增</span>
操作数限制	`++`、`--` 只能操作变量，不能操作字面量

类型转换

flowchart LR
    A["类型转换"] --> B["隐式转换"]
    A --> C["强制转换"]

隐式转换介绍

把一个取值范围小的数值或者变量，赋值给另一个取值范围大的变量

public class Test {
    public static void main(String[] args) {
        int a = 10;
        double b = a;          // 隐式转换：int → double
        System.out.println(b); // 10.0
    }
}

flowchart LR
    byte --> short --> int --> long --> float --> double
    char --> int

运算过程中的隐式转换

取值范围小的数据，和取值范围大的数据进行运算，小的会先提升为大的之后，再进行运算

public class Test {
    public static void main(String[] args) {
        int a = 10;
        double b = 12.3;
        double c = a + b;      // 22.3，a 临时提升为 double
    }
}

特殊规则：byte short char 三种数据在运算的时候，都会先提升为 int，然后再进行运算。

public class Test {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        byte c = a + b;        // 编译报错：a + b 提升为 int，需要强转
    }
}

public class Test {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        int c = a + b;         // 正确：int 接收
    }
}

char 与 int 相加时，char 会提升为 int（按 ASCII 码取值）。

public class Test {
    public static void main(String[] args) {
        int a = 1;
        char b = 'a';
        int c = a + b;         // 98（'a' 对应 ASCII 码 97）
        System.out.println(c);
    }
}

强制类型转换

把一个取值范围大的数值或者变量，赋值给另一个取值范围小的变量

不允许直接赋值，需要加入强制转换

格式：目标数据类型变量名 = (目标数据类型) 被强转的数据;

public class Test {
    public static void main(String[] args) {
        double a = 12.3;
        int b = (int) a;       // 12（精度损失，小数部分丢失）
        System.out.println(b);
    }
}

本节小结

类别	规则
基本的隐式转换	把一个取值范围小的数值或者变量，赋值给另一个取值范围大的变量
运算中的隐式转换	取值范围小的数据，和取值范围大的数据进行运算，小的会先提升为大的之后，再进行运算；`byte`、`short`、`char` 三种数据运算时会先提升为 `int`
强制类型转换	取值范围大的数据，给取值范围小的变量赋值，需要强制类型转换；<span style="color:red">强转有可能造成精度损失</span>

赋值运算符

基本赋值运算符

符号	作用	说明
`=`	赋值	`a = 10`，将 10 赋值给变量 a

扩展赋值运算符

符号	作用	说明
`+=`	加后赋值	`a += b`，将 a + b 的值给 a
`-=`	减后赋值	`a -= b`，将 a - b 的值给 a
`*=`	乘后赋值	`a *= b`，将 a × b 的值给 a
`/=`	除后赋值	`a /= b`，将 a ÷ b 的商给 a
`%=`	取余后赋值	`a %= b`，将 a ÷ b 的余数给 a

注意：扩展赋值运算符隐含了强转效果。

本节小结

类别	符号
基本赋值运算符	`=`
扩展赋值运算符	`+=` `-=` `*=` `/=` `%=`（隐含了强转效果）
关系运算符	`>` `>=` `<` `<=` `==` `!=`（最终返回 `boolean` 类型结果）

警告：== 是关系运算符，= 是赋值运算符，不要混淆！

关系运算符

符号	说明
`==`	`a==b`，判断 a 和 b 的值是否相等，成立为 `true`，不成立为 `false`
`!=`	`a!=b`，判断 a 和 b 的值是否不相等，成立为 `true`，不成立为 `false`
`>`	`a>b`，判断 a 是否大于 b，成立为 `true`，不成立为 `false`
`>=`	`a>=b`，判断 a 是否大于等于 b，成立为 `true`，不成立为 `false`
`<`	`a<b`，判断 a 是否小于 b，成立为 `true`，不成立为 `false`
`<=`	`a<=b`，判断 a 是否小于等于 b，成立为 `true`，不成立为 `false`

关系运算符最终返回的都是 boolean 类型的结果。

逻辑运算符

把多个条件放在一起运算，最终返回布尔类型的值：true、false

连接布尔类型的表达式，或者是值。

案例：判断成绩是否优秀

需求：在程序中，判断一个学生成绩是否在 90~100 之间，是的话程序输出优秀。

public class Test {
    public static void main(String[] args) {
        int score = 95;
        System.out.println(score >= 90 & score <= 100);  // true
    }
}

逻辑运算符分类

符号	介绍	说明
`&`	逻辑与	并且，遇 `false` 则 `false`
`\|`	逻辑或	或者，遇 `true` 则 `true`
`!`	逻辑非	取反
`^`	逻辑异或	相同为 `false`，不同为 `true`

短路逻辑运算符

符号	介绍	说明
`&&`	短路与	作用和 `&` 相同，但是有<span style="color:red">短路效果</span>
`\|\|`	短路或	作用和 `\|` 相同，但是有<span style="color:red">短路效果</span>

运算符	左操作数	右操作数
`&`（逻辑与）	无论 `true` 还是 `false`	右边都要执行
`&&`（短路与）	左为 `true`	右边执行
`&&`（短路与）	左为 `false`	<span style="color:red">右边不执行</span>
`\|`（逻辑或）	无论 `true` 还是 `false`	右边都要执行
`\|\|`（短路或）	左为 `false`	右边执行
`\|\|`（短路或）	左为 `true`	<span style="color:red">右边不执行</span>

flowchart LR
    A["& 逻辑与"] --> A1["遇 false 则 false"]
    B["&& 短路与"] --> B1["左边为 false 右边不执行"]
    C["| 逻辑或"] --> C1["遇 true 则 true"]
    D["|| 短路或"] --> D1["左边为 true 右边不执行"]
    E["! 逻辑非"] --> E1["取反"]
    F["^ 逻辑异或"] --> F1["相同是 false 不同是 true"]

注意：实际开发中，常用的逻辑运算符是：&&、||、!

三元运算符

格式：判断条件 ? 值1 : 值2;

执行流程：

首先计算判断条件的值
如果值为 true，值 1 就是运算结果
如果值为 false，值 2 就是运算结果

flowchart LR
    A["判断条件 ?"] --> B{"判断条件的值"}
    B -- true --> C["值 1 （运算结果）"]
    B -- false --> D["值 2 （运算结果）"]

总结：根据判断条件，从两份数据中二者选其一。

运算符优先级

优先级	运算符
1	`.` `()`
2	`!`、`~`、`++`、`--`
3	`*`、`/`、`%`
4	`+`、`-`
5	`<<`、`>>`、`>>>`
6	`<`、`<=`、`>`、`>=`、`instanceof`
7	`==`、`!=`
8	`&`
9	`^`
10	`\|`
11	`&&`
12	`\|\|`
13	`?:`
14	`=`、`+=`、`-=`、`*=`、`/=`、`%=`、`&=`

规律：&& 优先级高于 ||，赋值运算符优先级最低。

优先级案例解析

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a > b || a < b && a > b);
        // 解析：&& 优先级高于 ||，先算 a < b && a > b（false），再算 a > b || false（false || false = false）
    }
}

小技巧：不确定优先级时，用 () 改变优先级，可读性更强。

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println((a > b || a < b) && a > b);
        // 显式加括号：先算 a > b || a < b（true），再算 true && a > b（true && false = false）
    }
}

Scanner 键盘录入

需求

请在程序中，提示用户通过键盘输入自己的姓名、年龄，并能在程序中收到这些数据。

Java 已经写好了实现程序，我们调用即可。

三个步骤

import java.util.Scanner;       // ① 导包：告诉程序去 JDK 的哪个包中找扫描器技术

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);  // ② 创建对象：代表得到键盘扫描器对象

        System.out.println("请输入您的年龄：");
        int age = sc.nextInt();              // ③ 调用方法：等待接收用户输入数据
        System.out.println("年龄是：" + age);

        System.out.println("请输入您的名称：");
        String name = sc.next();
        System.out.println("欢迎：" + name);
    }
}

本节小结

Java 程序中如何实现接收用户键盘输入的数据？

使用 Java 提供的类 Scanner 来完成，步骤如下：

步骤	代码	说明
1	`import java.util.Scanner;`	<span style="color:blue">导包</span>
2	`Scanner sc = new Scanner(System.in);`	<span style="color:blue">创建对象</span>
3	`sc.nextInt()` / `sc.next()` / `sc.nextDouble()`	<span style="color:blue">调用方法接收数据</span>

方法	作用
`sc.nextInt()`	接收整数
`sc.next()`	接字符串
`sc.nextDouble()`	接收浮点数

第五章方法

函数，实现特定功能的操作步骤集合

方法的介绍

为什么要使用方法

如果将所有功能都写在 main 方法中，代码会臃肿（"臃肿"），不便于维护。

public class Test {
    public static void main(String[] args) {
        // ...50 行代码
    }
}

解决方法：将每个功能单独封装到一个方法中，main 中只负责调用。

public class Test {
    public static void main(String[] args) {

    }

    /** 查看全部商品 */
    public static void showGoodsInfo() { ... }

    /** 上架商品 */
    public static void addGoods() { ... }

    /** 下架商品 */
    public static void deleteGoods() { ... }

    /** 修改商品 */
    public static void updateGoods() { ... }
}

方法的概念

维度	内容
别名	方法（method）、函数（function）
定义	一段具有独立功能的代码块
特点	<span style="color:red">不调用就不执行</span>

小结

方法（函数）就是将具有独立功能的代码封装起来，组成一个独立的小工具，方便重复使用，提升维护性。

维度	好处
代码管理	可以将挤在一起的臃肿代码按照功能进行分类管理，<span style="color:green">提高维护性</span>
代码复用	<span style="color:green">提高代码的复用性</span>

方法的基本定义和调用

定义和调用格式

维度	格式
定义格式	`public static void 方法名() { // 方法体 }`
调用格式	`方法名();`

public class Test {
    public static void show() {
        // 方法体
    }

    public static void main(String[] args) {
        show();   // 调用
    }
}

案例：方法计算两个整数最大值

需求：定义一个方法，方法中定义两个整数变量，求出最大值并打印在控制台

步骤	内容
1	根据格式编写方法，方法名自己给出（见名知意小驼峰命名法）
2	方法内部定义出两个 `int` 类型变量
3	使用三元运算符求出最大值
4	调用该方法，让内部的逻辑执行起来

方法的执行流程

方法的调用流程

阶段	行为
方法未被调用时	字节码文件存放在 <span style="color:red">方法区</span>
方法被调用时	需要进入到 <span style="color:red">栈内存</span> 中运行

flowchart LR
    A["方法区 字节码文件 例如 main"] -->|被调用| B["栈内存 方法运行时进入的内存"]

入栈与出栈

行为	描述
入栈	方法被调用时，进入栈内存
出栈	方法执行完毕后，弹出栈内存

public class MethodDemo1 {
    public static void main(String[] args) {
        System.out.println("开始");
        getMax();
        System.out.println("结束");
    }

    public static void getMax() {
        int num1 = 10;
        int num2 = 20;
        int max = num1 > num2 ? num1 : num2;
        System.out.println(max);
    }
}

执行流程：

flowchart TD
    M["main 压栈 执行 println 开始"] --> G["getMax 压栈 求 max = 20"]
    G --> G1["println 打印 20"]
    G1 --> G2["getMax 执行完毕 出栈"]
    G2 --> M1["main 继续执行 println 结束"]
    M1 --> M2["main 执行完毕 出栈"]

多个方法嵌套调用

public class MethodDemo2 {
    public static void main(String[] args) {
        study();
    }

    public static void sleep() {
        System.out.println("睡觉");
    }

    public static void eat() {
        System.out.println("吃饭");
    }

    public static void study() {
        eat();
        System.out.println("学习");
        sleep();
    }
}

小结

内存区域	说明
方法区	<span style="color:red">字节码文件加载时进入的内存</span>
栈内存	<span style="color:red">方法运行时入栈，方法运行结束出栈</span>

带参数的方法

为什么要带参数

方法中写死的数据不灵活，每次只能处理固定的内容。

public class MethodDemo1 {
    public static void main(String[] args) {
        getMax();
    }

    public static void getMax() {
        int num1 = 10;
        int num2 = 20;
        int max = num1 > num2 ? num1 : num2;
        System.out.println(max);
    }
}

上面的 getMax() 只能计算 10 和 20 的最大值。 解决办法：让方法可以接收调用方传入的数据 → 形参 + 实参

定义格式

参数数量	格式
单个参数	`public static void 方法名 (数据类型变量名) { // 方法体 }`
多个参数	`public static void 方法名 (数据类型变量名1, 数据类型变量名2...) { // 方法体 }`

public static void call(String name) {
    // ...
}

public static void add(int a, int b) {
    // ...
}

调用格式

参数数量	格式
单个参数	`方法名(参数);`
多个参数	`方法名(参数1, 参数2);`

call("钢门吹雪");
add(10, 20);

形参和实参

名称	全称	出现时机	说明
<span style="color:red">形参</span>	形式参数	<span style="color:red">定义</span>方法时	方法声明的参数，相当于局部变量的声明
<span style="color:red">实参</span>	实际参数	<span style="color:red">调用</span>方法时	传入的具体数据

public class MethodDemo2 {
    public static void main(String[] args) {
        getMax(10, 20);   // 10、20 是实参
    }

    public static void getMax(int num1, int num2) {  // num1、num2 是形参
        int max = num1 > num2 ? num1 : num2;
        System.out.println(max);
    }
}

小结

知识点	说明
参数作用	<span style="color:green">带参数的方法可以提高方法的灵活性</span>
形参	方法定义时声明的参数
实参	方法调用时传入的参数

带返回值的方法

为什么需要返回值

A 方法产生的数据，B 方法想要使用的话，就需要定义带返回值的方法

// 之前：A 方法中计算 sum，B 方法想用 sum 是用不了的
public static void methodA(int a, int b) {
    int sum = a + b;
    // ...
}

public static void methodB() {
    System.out.println(sum % 2 == 0);   // 报错，拿不到 sum
}

// 现在：A 方法通过 return 把数据交给 B 方法
public static int methodA(int a, int b) {
    int sum = a + b;
    return sum;
}

public static void methodB() {
    int result = methodA(10, 20);
    System.out.println(result % 2 == 0);
}

定义格式

public static 数据类型 方法名 (数据类型 变量名1, 数据类型 变量名2...) {
    return 数据值;
}

public static int add(int a, int b) {
    int c = a + b;
    return c;
}

public static double getNum() {
    return 12.3;
}

调用格式

场景	格式
单纯调用	`方法名(参数...);`
接收返回值	`数据类型变量名 = 方法名(参数...);`

add(10, 20);                    // 单纯调用，返回值被丢弃
int result = add(10, 20);       // 用变量接收

小结

知识点	说明
使用场景	A 方法中的数据，如果 B 方法想要使用的话，就需要设计返回值
关键字	通过 <span style="color:red">`return`</span> 关键字，将结果数据返回
返回位置	返回到方法的调用处

方法通用定义格式

完整格式

public static 返回值类型 方法名(参数) {
    方法体;
    return 数据;
}

组成	含义	类比
参数	制作材料	面粉、酵母、糖…
方法体	使用材料干活	搅拌、烘烤…
返回值	成品	面包

定义方法的两个明确

明确项	说明
<span style="color:red">明确参数</span>	主要是明确参数的类型和数量
<span style="color:red">明确返回值类型</span>	方法操作完毕后是否有结果数据，如果有写对应的数据类型，没有写 `void`

调用方法的两种方式

方法类型	调用方式
`void` 类型的方法	直接调用即可：`方法名(参数);`
非 `void` 类型的方法	推荐用变量接收调用：`数据类型变量名 = 方法名(参数);`

案例

需求编号	需求
需求 1	设计一个方法，能够计算出 2 个小数的和
需求 2	设计一个方法，能够计算出 3 个整数的最小值
需求 3	设计一个方法，能够打印出用户的个人信息（姓名，年龄，身高，性别）

方法注意事项

序号	注意事项
1	<span style="color:red">方法不调用就不执行</span>
2	方法与方法之间是<span style="color:red">平级关系，不能嵌套定义</span>
3	方法的编写顺序和执行顺序<span style="color:red">无关</span>
4	方法的返回值类型为 `void` 时，表示该方法没有返回值，没有返回值的方法可以省略 `return` 语句不写
5	如果要编写 `return`，后面不能跟具体的数据（`void` 方法中）
6	`return` 语句下面，不能编写代码，因为永远执行不到，属于无效的代码

// 错误示例：return 之后还有代码
public class MethodDemo {
    public static void method() {
        // 代码片段
        return;
        System.out.println("卑微代码");   // ❌ 报错
    }
}

方法重载

引入

需求：提供 4 个计算方法，功能如下

2 个 int 相加

2 个 double 相加

3 个 int 相加

3 个 double 相加

public class Test {
    public static int add1(int a, int b) {
        return a + b;
    }

    public static double add2(double a, double b) {
        return a + b;
    }

    public static int add3(int a, int b, int c) {
        return a + b + c;
    }

    public static double add4(double a, double b, double c) {
        return a + b + c;
    }
}

但是 4 个 add1/add2/add3/add4 名字太繁琐了， 能否全部用 add 同一个名字？→ 方法重载

public class Test {
    public static int    add(int a, int b)              { return a + b; }
    public static double add(double a, double b)        { return a + b; }
    public static int    add(int a, int b, int c)       { return a + b + c; }
    public static double add(double a, double b, double c) { return a + b + c; }
}

flowchart LR
    C1["add(10, 20)"] --> M1["add(int, int)"]
    C2["add(10, 20, 30)"] --> M2["add(int, int, int)"]
    C3["add(12.3, 12.3)"] --> M3["add(double, double)"]
    C4["add(12.3, 12.3, 12.3)"] --> M4["add(double, double, double)"]

调用方法的时候，Java 虚拟机会通过参数的不同来区分同名的方法

方法重载的定义

维度	说明
位置	在<span style="color:red">同一个类</span>中
方法名	多个方法的<span style="color:red">方法名相同</span>
参数	每个方法具有<span style="color:red">不同的参数类型或参数个数</span>
结果	这些同名的方法，就构成了重载关系（Overload）

简单记：同一个类中，方法名相同，参数不同的方法 参数不同：个数不同、类型不同、顺序不同

注意：识别方法之间是否是重载关系，只看方法名和参数，跟返回值无关。

重载判断正误

示例	是否构成重载	原因
`void fn(int a)` / `int fn(int a)`	❌	参数相同，仅返回值不同
`void fn(int a)` / `int fn(int a, int b)`	✅	参数个数不同
`void fn(int a)` / `int fn(double a)`	✅	参数类型不同
两个类中的 `fn(int a)` / `fn(double a)`	❌	不在同一个类中
`void fn(int a, double b)` / `void fn(double a, int b)`	✅	参数顺序不同
`void fn(int a, double b)` / `void fn(int c, double d)`	❌	仅形参名不同

方法重载的好处

不用记忆过多繁琐的方法名字

public class MethodDemo {
    public static void main(String[] args) {
        // 输出调用
        System.out.println(10);       // 同一个 println，传入 int
        System.out.println(10.1);     // 同一个 println，传入 double
        System.out.println(true);     // 同一个 println，传入 boolean
    }
}

小结

知识点	说明
方法重载 Overload	<span style="color:red">同一个类中，方法名相同，参数不同的方法</span>
重载看返回值吗？	<span style="color:green">不看，只看参数类型、参数个数、参数顺序</span>
重载有啥好处？	<span style="color:green">不需要记忆太多方法名字</span>

IDEA 安装 AI 插件

IDEA 集成通义灵码

阶段	说明
IDEA 之前的编程方式	程序的编码工作，还是需要程序员思考，并逐行编写
AI 出现后	IDEA 可以集成很多辅助编程的 AI 编程插件
推荐插件	阿里巴巴通义灵码

官网：https://lingma.aliyun.com/lingma/download

第六章流程控制语句

控制程序代码执行顺序 多一句没有，少一句不行。用更短的时间，教会更实用的技术

1. 流程控制语句分类

分类	说明	关键字
<span style="color:red">顺序结构</span>	Java 程序默认的执行流程，没有特定的语法结构，按照代码的先后顺序，依次执行	程序默认
<span style="color:red">分支结构</span>	根据条件选择性地执行某段代码	`if`、`switch`
<span style="color:red">循环结构</span>	让一段代码重复执行很多次	`for`、`while`、`do...while`

flowchart LR
    S[开始] --> A[语句A] --> B[语句B] --> C[语句C] --> E[结束]

public class Test {
    public static void main(String[] args) {
        System.out.println("A");
        System.out.println("B");
        System.out.println("C");
    }
}

2. 分支结构 if

if 的三种格式

格式	语法	适用场景
<span style="color:red">格式 1</span>	`if (判断条件) { 语句体; }`	单条件判断
<span style="color:red">格式 2</span>	`if (判断条件) { 语句体1; } else { 语句体2; }`	二选一
<span style="color:red">格式 3</span>	`if (判断条件1) { 语句体1; } else if (判断条件2) { 语句体2; } ... else { 语句体n+1; }`	多条件区间判断

执行流程：

flowchart LR
    S[开始] --> C1{判断条件}
    C1 -- true --> B1[执行语句体]
    C1 -- false --> E[结束]
    B1 --> E

flowchart LR
    S[开始] --> C1{判断条件}
    C1 -- true --> B1[执行语句体1]
    C1 -- false --> B2[执行语句体2]
    B1 --> E[结束]
    B2 --> E

flowchart LR
    S[开始] --> C1{判断条件1}
    C1 -- true --> B1[执行语句体1]
    C1 -- false --> C2{判断条件2}
    C2 -- true --> B2[执行语句体2]
    C2 -- false --> C3{...}
    C3 -- true --> Bn[执行相应语句体]
    C3 -- false --> Bx[执行语句体n+1]
    B1 --> E[结束]
    B2 --> E
    Bn --> E
    Bx --> E

if 分支是什么？可以根据条件，选择执行某段程序

if 分支的写法有几种？三种（见上表）

案例：考试奖励

需求：键盘录入考试成绩，根据成绩所在的区间，程序打印出不同的奖励

成绩区间	奖励
95 ~ 100	自行车一辆
90 ~ 94	游乐场玩一次
80 ~ 89	变形金刚一个
80 分以下	胖揍一顿

Scanner sc = new Scanner(System.in);
System.out.print("请输入考试成绩：");
int score = sc.nextInt();

if (score >= 95 && score <= 100) {
    System.out.println("自行车一辆");
} else if (score >= 90 && score <= 94) {
    System.out.println("游乐场玩一次");
} else if (score >= 80 && score <= 89) {
    System.out.println("变形金刚一个");
} else {
    System.out.println("胖揍一顿");
}

if 语句注意事项

if 语句中，如果大括号控制的是一条语句，大括号可以省略不写
if 语句的 () 和 {} 之间不要写分号
if 语句的 () 中需要产生 boolean 类型的结果，根据结果决定程序的走向

3. 分支结构 switch

通过比较值来决定执行哪条分支

switch 分支的执行流程

先计算表达式的值，再拿着这个值去与 case 后的值进行匹配
与哪个 case 后的值匹配为 true 就执行哪个 case 块的代码，遇到 break 就跳出 switch 分支
如果全部 case 后的值与之匹配都是 false，则执行 default 块的代码

switch (表达式) {
    case 值1:
        语句体1;
        break;
    case 值2:
        语句体2;
        break;
    ...
    default:
        语句体n+1;
        break;
}

if 适合做条件是区间判断的情况

switch 适合做：条件是比较值的情况、代码优雅、性能较好

switch 语句注意事项

表达式类型只能是 byte、short、int、char，不支持 double、float、long
- JDK5 开始支持枚举
- JDK7 开始支持 String
case 给出的值不允许重复，且只能是字面量，不能是变量
正常使用 switch 的时候，不要忘记写 break，否则会出现穿透现象

4. Debug 工具

Debug：是供程序员使用的程序调试工具

它可以用于查看程序的执行流程

也可以用于追踪程序执行过程来调试程序

Debug 调试，又被称为断点调试，断点其实是一个标记，告诉 Debug 从标记的地方开始查看

Debug 工具栏

操作	说明
<span style="color:red">程序向下执行一步</span>	单步执行（F8）
<span style="color:red">跳出当前方法</span>	从方法中返回到调用处
<span style="color:red">进入方法查看详情</span>	进入方法体逐行执行（F7）
<span style="color:red">结束 DeBug 模式</span>	终止本次调试
<span style="color:red">再点一次取消断点</span>	移除该行断点

Debug 视图

Frames：显示正在执行的方法（main6, Main、getMax:12, Main）
Variables：显示变量的变化过程（a = 10、b = 20）
Console：控制台输出

Breakpoints 视图

统一管理所有断点（Java Line Breakpoints、Java Exception Breakpoints 等），可设置 Suspend: All / Thread、Condition、Log message、Remove once hit 等高级属性

5. 循环结构 for

循环语句的作用：可以将一段代码重复的执行很多次

for (初始化语句; 条件判断语句; 条件控制语句) {
    循环体语句;
}

跑圈示例

循环任务：跑圈控制循环：根据心中 1 2 3 4 数字的变化进行控制循环条件：心中的数小于 4，就开始循环任务

flowchart LR
    S[开始] --> I[初始化语句 int i = 1] --> C{i < 4}
    C -- true --> B[循环体语句 sout 跑圈] --> U[条件控制语句 i++]
    U --> C
    C -- false --> E[结束]

for 循环小结

循环语句的作用：可以将一段代码重复的执行很多次 for 循环语句格式：

for (初始化语句; 条件判断语句; 条件控制语句) {
    循环体语句;
}

执行流程：

初始化语句
执行条件判断语句，看结果是 true，还是 false；false 结束，true 继续
执行循环体语句
执行条件控制语句
回到 2 继续

案例：循环打印 10 次「黑马程序员」

需求：请使用循环，在控制台打印出 10 次「黑马程序员」

for (int i = 1; i <= 10; i++) {
    System.out.println("黑马程序员");
}

案例：模拟计时器

需求：请使用循环在控制台打印数字 1~3 和 3~1 的数据

思路积累	说明
<span style="color:green">循环中，用于控制循环的变量还可以放在循环体中，继续进行使用</span>	—
<span style="color:green">条件控制语句，不一定是 `++`</span>	例如 `i--`

// 打印 1 ~ 3
for (int i = 1; i <= 3; i++) {
    System.out.println(i);
}
System.out.println("------------");

// 打印 3 ~ 1
for (int i = 3; i >= 1; i--) {
    System.out.println(i);
}

案例：求和

需求：求 1-100 之间的偶数和，并把求和结果在控制台输出

分析：

定义求和变量 sum，准备记录累加的结果
使用 for 循环，分别获取数据 1 ~ 100
循环使用 if 语句，筛选出偶数数据
将每一个偶数数据，和 sum 变量进行累加
循环结束后，打印求和后的结果

思路积累：今后若遇到的需求是，求 xxx 的和，就要联想到求和变量 sum

int sum = 0;
for (int i = 1; i <= 100; i++) {
    if (i % 2 == 0) {
        sum += i;
    }
}
System.out.println("1-100之间的偶数和是：" + sum);

案例：水仙花数

需求：在控制台输出所有的「水仙花数」

定义	解释
<span style="color:red">水仙花数是一个三位数</span>	例：111、222、333、370、371、520、999
<span style="color:red">个位、十位、百位的数字立方和等于原数</span>	例：123 → 1³+2³+3³ = 1+8+27 = 36 ≠ 123（不是水仙花数）<br/>例：371 → 3³+7³+1³ = 27+343+1 = 371 = 371（是水仙花数）

分析：

通过 for 循环，获取到所有的三位数 100 ~ 999
在循环内部，将每一个三位数拆分为（个位，十位，百位）
加入 if 筛选条件：if (ge*ge*ge + shi*shi*shi + bai*bai*bai == 原数)
满足条件则输出水仙花数

for (int i = 100; i <= 999; i++) {
    int ge = i % 10;
    int shi = i / 10 % 10;
    int bai = i / 100 % 10;
    if (ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
        System.out.println(i);
    }
}

案例：统计水仙花数

需求：在控制台输出所有的「水仙花数」，并统计出水仙花数的个数

分析：

定义计数器变量 count，准备统计水仙花数的个数
通过 for 循环，获取到所有的三位数 100 ~ 999
在循环内部，将每一个三位数拆分为（个位，十位，百位）
加入 if 筛选条件：if (ge*ge*ge + shi*shi*shi + bai*bai*bai == 原数)
满足条件则输出水仙花数，count 变量 ++
打印 count 所记录的值

思路积累：今后若遇到的需求是，统计 xxx，就要联想到计数器变量 count

int count = 0;
for (int i = 100; i <= 999; i++) {
    int ge = i % 10;
    int shi = i / 10 % 10;
    int bai = i / 100 % 10;
    if (ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
        System.out.println(i);
        count++;
    }
}
System.out.println("水仙花数共有：" + count + " 个");

for 循环语句注意事项

循环 {} 中定义的变量，在每一轮循环结束后，都会从内存中释放
循环 () 中定义的变量，在整个循环结束后，都会从内存中释放
循环语句 () 和 {} 之间不要写分号

循环 () 中定义的变量，在循环结束后还可以继续使用吗？

循环 {} 中定义的变量，什么时候从内存中消失？

循环 () 和 {} 之间写分号，还可以控制循环体吗？

循环嵌套

循环嵌套：在循环语句中，继续出现循环语句。 外循环执行一次，内循环执行一圈

for (int i = 1; i <= 5; i++) {
    for (int j = 1; j <= 5; j++) {
        System.out.println("HelloWorld");
    }
}

案例：循环嵌套

使用 * 在控制台打印出 4 行 5 列的矩形

* * * * *
* * * * *
* * * * *
* * * * *

使用 * 在控制台打印出 5 行的直角三角形

*
* *
* * *
* * * *
* * * * *

// 4 行 5 列矩形
for (int i = 1; i <= 4; i++) {
    for (int j = 1; j <= 5; j++) {
        System.out.print("* ");
    }
    System.out.println();
}

// 5 行直角三角形
for (int i = 1; i <= 5; i++) {
    for (int j = 1; j <= i; j++) {
        System.out.print("* ");
    }
    System.out.println();
}

循环嵌套：在循环中继续编写循环语句

执行流程：外循环执行一次，内循环执行一圈

思路：如果一个循环任务还要继续执行多次，使用外循环包裹

6. 循环结构 while

初始化语句;
while (判断语句) {
    循环体语句;
    控制语句;
}

案例：珠穆朗玛峰

需求：世界最高峰珠穆朗玛峰高度是 8848.86 米 = 8848860 毫米，假如我有一张足够大的纸，它的厚度是 0.1 毫米。请问：该纸张折叠多少次，可以折成珠穆朗玛峰的高度？

分析：

定义变量存储珠穆朗玛峰的高度、纸张的高度

double peakHeight = 8848860;   // 山峰高度
double paperThickness = 0.1;   // 纸张厚度

使用 while 循环来控制纸张折叠，循环条件是（纸张厚度 < 山峰高度），循环每执行一次，就表示纸张折叠一次，并把纸张厚度变为原来两倍
循环外定义计数变量 count，循环每折叠一次纸张，让 count 变量 +1

double peakHeight = 8848860;
double paperThickness = 0.1;
int count = 0;
while (paperThickness < peakHeight) {
    paperThickness *= 2;
    count++;
}
System.out.println("需要折叠 " + count + " 次");

while 与 for 的区别

while 循环的格式，执行流程是怎么样的？

初始化语句;
while (循环条件) {
    循环体语句;
    迭代语句;
}

int i = 1;
while (i <= 3) {
    System.out.println("HelloWorld");
    i++;
}

while 和 for 有什么区别？什么时候用 for，什么时候用 while？

功能上是完全一样的，for 能解决的 while 也能解决，反之亦然

使用规范：知道循环次数，使用 for；不知道循环次数建议使用 while

7. 循环结构 do...while

初始化语句;
do {
    循环体语句;
    条件控制语句;
} while (循环条件);

int i = 0;
do {
    System.out.println("Hello World!");
    i++;
} while (i < 3);

do-while 循环的特点：先执行后判断

三种循环的区别

循环	判断时机	适用场景
<span style="color:red">for 循环</span>	先判断后执行	已知循环次数
<span style="color:red">while 循环</span>	先判断后执行	不明确循环次数
<span style="color:red">do...while 循环</span>	先执行后判断	循环体至少执行一次

for 循环和 while 循环的执行流程是一模一样的，功能上无区别，for 能做的 while 也能做，反之亦然

使用规范：如果已知循环次数建议使用 for 循环，如果不清楚要循环多少次建议使用 while 循环

其他区别：for 循环中，控制循环的变量只在循环中使用；while 循环中，控制循环的变量在循环后还可以继续使用

// for 循环：循环结束后控制变量不可用
for (int i = 0; i < 3; i++) {
    System.out.println("Hello World");
}
System.out.println(i);  // 报错：i 已不可用

// while 循环：循环结束后控制变量仍可用
int i = 0;
while (i < 3) {
    System.out.println("Hello World");
    i++;
}
System.out.println(i);  // 输出 3

8. break、continue

跳转控制语句

关键字	作用
<span style="color:red">break</span>	<span style="color:red">终止</span> 循环体内容的执行，也就是说结束当前的整个循环
<span style="color:red">continue</span>	<span style="color:red">跳过</span> 某次循环体内容的执行，继续下一次的执行

注意事项：

break：只能在循环，和 switch 当中进行使用

continue：只能在循环中进行使用

带标号的 break（跳出指定循环）

如果出现循环嵌套，默认操作内层循环，如需改动，可以使用标号控制

lo:
for (int i = 1; i <= 5; i++) {
    for (int j = 1; j <= 5; j++) {
        if (j == 2) {
            break lo;
        }
    }
}

9. Random 生成随机数

import java.util.Random;

public class Test {
    public static void main(String[] args) {
        Random r = new Random();
        int num1 = r.nextInt(10);
    }
}

步骤	说明
① 导包	告诉程序去 JDK 的哪个包中找随机数生成器（`import java.util.Random;`）
② 抄代码	代表得到随机数生成器对象（东西）（`Random r = new Random();`）
③ 抄代码	生成一个随机数，指定随机范围（`int num1 = r.nextInt(10);`）

注意：r.nextInt(n); 的范围是 0 ~ n-1，不包含 n

思考：产生一个 1~100 的随机数

r.nextInt(?) 传入什么参数？ int num = r.nextInt(100) + 1;（nextInt(100) 得到 0~99，加 1 得到 1~100）

案例：猜数字小游戏

产生一个 1~100 之间的随机数作为中奖数字

随后键盘录入用户猜的数字进行比对

没有猜中的话给出提示，直到用户猜对为止，程序结束

import java.util.Random;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Random r = new Random();
        int lucky = r.nextInt(100) + 1;

        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.print("请输入：");
            int guess = sc.nextInt();
            if (guess > lucky) {
                System.out.println("猜大了");
            } else if (guess < lucky) {
                System.out.println("猜小了");
            } else {
                System.out.println("恭喜，猜中了！");
                break;
            }
        }
    }
}

运行示例：

请输入：50
猜大了
请输入：25
猜小了
请输入：15
猜小了
请输入：10
猜小了
请输入：12
恭喜，猜中了！

第七章数组

数组指一种容器，可以存储同种类型的多个值

1. 数组介绍

为什么使用数组

销售部门共有 10 个员工，需要录入 10 个人的销售业绩，然后找出最大值、找出最小值、计算销售总额。如果使用普通变量，需要定义 10 个 int 变量存储，繁琐且不利于批量操作。

什么是数组

数组是一种容器，可以用来存储同种数据类型的多个值

例如：int a = 10; int b = 20; int c = 30; 三个变量分别存储 → int[] arr = {10, 20, 30, ..., 90}; 一个数组存储

数组是什么？能干什么？ 答：一种容器，可以存储同种数据类型的多个值

什么时候使用数组？ 答：如果要操作的数据有多个，并且还属于一个整体

2. 数组定义和静态初始化

数组定义

格式	语法	范例
<span style="color:red">格式一</span>	`数据类型[] 数组名;`	`int[] array1;`
<span style="color:red">格式二</span>	`数据类型数组名[];`	`int array2[];`

数组的定义格式为？ 数据类型[] 数组名;

数组的静态初始化格式为？

完整：数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3...};

简化：数据类型[] 数组名 = {元素1, 元素2, 元素3...};

打印数组名会看到什么？ 十六进制内存地址

数组静态初始化

初始化：就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程

// 完整格式
数据类型[] 数组名 = new 数据类型[]{ 元素1, 元素2, 元素3... };
int[] array = new int[]{ 11, 22, 33 };
double[] array2 = new double[]{ 11.1, 22.2, 33.3 };

// 简化格式（开发中推荐使用）
数据类型[] 数组名 = { 元素1, 元素2, 元素3... };
int[] array = { 11, 22, 33 };
double[] array2 = { 11.1, 22.2, 33.3 };

注意事项：打印数组名，会看到数组在内存中的十六进制地址值 例如：[I@10f87f48、[D@b4c966a

flowchart LR
    subgraph M[内存]
        direction TB
        V1[11]
        V2[22]
        V3[33]
    end
    Arr[数组名] --> M

3. 数组元素访问

格式：数组名[索引];

索引：就是数组容器中空间的编号，编号从 0 开始，逐个 +1 增长

flowchart LR
    subgraph array[array 数组]
        direction TB
        E0[索引 0] --> E1[索引 1] --> E2[索引 2] --> E3[索引 3]
    end
    Caller[array 小组，2 号滚出列] --> E2

数组元素访问格式为？ 数组名[索引];

索引（角标、下标）：指数组中每一个元素的编号，编号从 0 开始，逐个 +1 增长

数组名.length：动态获取数组的长度（元素的个数）

4. 数组遍历操作

数组遍历：依次访问数组中的每一个元素

数组遍历 - 求偶数和

需求：已知数组元素为 {11, 22, 33, 44, 55}，请将数组中偶数元素取出并求和，最后打印求和结果

分析：

静态初始化数组
定义求和变量
遍历数组取出每一个元素
判断当前元素是否是偶数，是的话跟求和变量做累加操作
打印求和变量

int[] arr = {11, 22, 33, 44, 55};
int sum = 0;
for (int i = 0; i < arr.length; i++) {
    if (arr[i] % 2 == 0) {
        sum += arr[i];
    }
}
System.out.println("数组中所有偶数的和为：" + sum);  // 66

数组遍历 - 求最大值

需求：已知数组元素为 {5, 44, 33, 55, 22}，请找出数组中最大值并打印在控制台

选手	战力	索引
选手 0	5	0
选手 1	44	1
选手 2	33	2
选手 3	55	3
选手 4	22	4

分析：

定义 max 变量来记录擂台上不断变化的数据
数组中 0 号选手先上台，因此 int max = arr[0];
遍历数组取出每一个元素，索引从 1 开始
逐个进行比较，找到更大的，max 变量记录更大的数据
遍历后打印 max 变量所记录的值

int[] arr = {5, 44, 33, 55, 22};
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
    if (arr[i] > max) {
        max = arr[i];
    }
}
System.out.println("数组最大值为：" + max);  // 55

数组元素反转

需求：已知一个数组 arr = {11, 22, 33, 44, 55};，用程序实现把数组中的元素值交换，交换后的数组 arr = {55, 44, 33, 22, 11};，并在控制台输出交换后的数组元素。

两变量交换（借助第三变量）

需求：实现两个变量的数据交换

int a = 10;
int b = 20;

// 定义第三个变量，完成交换
int c = a;
a = b;
b = c;

思路：使用一个空杯（第三个变量）作为中转，先把 a 倒到 c，再把 b 倒到 a，最后把 c 倒到 b，完成交换

反转过程

步骤	操作	数组状态	指针位置
初始	`int start = 0, end = arr.length - 1;`	`11 22 33 44 55 66`	start=0, end=5
第一次	交换 `arr[0]` 和 `arr[5]`	`66 22 33 44 55 11`	start=1, end=4
第二次	交换 `arr[1]` 和 `arr[4]`	`66 55 33 44 22 11`	start=2, end=3
第三次	交换 `arr[2]` 和 `arr[3]`	`66 55 44 33 22 11`	start=3, end=2（停止）

flowchart LR
    subgraph 0[交换前]
        A0[11] --> A1[22] --> A2[33] --> A3[44] --> A4[55] --> A5[66]
    end
    subgraph 1[第三次后]
        B0[66] --> B1[55] --> B2[44] --> B3[33] --> B4[22] --> B5[11]
    end
    0 --> 1

// 交换条件：start < end
// 交换：arr[start] 和 arr[end]
// 交换后：start++, end--

int[] arr = {11, 22, 33, 44, 55, 66};

for (int start = 0, end = arr.length - 1; start < end; start++, end--) {
    int temp = arr[start];
    arr[start] = arr[end];
    arr[end] = temp;
}

for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i] + " ");
}
// 66 55 44 33 22 11

5. 数组动态初始化

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值

格式：数据类型[] 数组名 = new 数据类型[数组长度];
范例：int[] arr = new int[3];

数据类型	明细	默认值
<span style="color:red">基本数据类型</span>	整数	`0`
	小数	`0.0`
	字符	`'\u0000'`（常见体现为空白字符）
	布尔	`false`
<span style="color:red">引用数据类型</span>	类、接口、数组	`null`

动态初始化 vs 静态初始化

维度	动态初始化	静态初始化
<span style="color:red">格式</span>	`数据类型[] 数组名 = new 数据类型[长度];`	`数据类型[] 数组名 = {元素1, 元素2, 元素3...};`
<span style="color:red">特点</span>	手动指定长度，系统自动分配默认初始化值	手动指定元素，系统计算出数组长度
<span style="color:red">场景</span>	不明确要操作元素的时候	明确具体要操作的元素

案例：评委打分

需求：在编程竞赛中，有 6 个评委为参赛的选手打分，分数为 0-100 的整数分。选手的最后得分为：去掉一个最高分和一个最低分后的 4 个评委平均值

6. 数组内存图

Java 内存分配介绍

区域	作用
<span style="color:red">栈</span>	方法运行时所进入的内存（局部变量）
<span style="color:red">堆</span>	`new` 出来的东西会在这块内存中开辟空间，并产生地址
<span style="color:red">方法区</span>	字节码文件加载时进入的内存（包含本地方法栈、寄存器）

一个数组内存图

简化格式只是简化了代码书写，真正运行期间还是按照完整格式运行的：int[] arr = new int[]{11,22,33};

flowchart LR
    A["Test.class main"]
    B["main int[] arr → 10f87f48"]
    C["10f87f48 int[] length=3 0:44 1:55 2:66"]
    A --> B --> C

输出结果：44 55 66

两个数组指向相同内存图

重要：两个数组名指向同一个数组时，操作的是同一块内存空间

int[] array1 = {11, 22, 33};
int[] array2 = array1;     // array2 指向 array1 的地址
array2[0] = 100;            // 通过 array2 修改元素
// array1[0] 也是 100

方法参数传递内存图

数据类型	是否改变原值	原因
<span style="color:red">基本数据类型</span>	不改变	传递的是数据值，修改形参不影响实参（除非用 `return` 把结果返回）
<span style="color:red">引用数据类型</span>	改变	传递的是地址值，方法内通过地址操作堆内存数据

// 基本数据类型 - 形参改变不影响实参
public static void change(int number) {
    number = 200;
}
// 调用前：100，调用后：100

// 基本数据类型 - 用 return 返回
public static int change(int number) {
    number = 200;
    return number;
}
// 调用前：100，调用后：200

// 引用数据类型 - 通过形参影响实参
public static void change(int[] arr) {
    arr[0] = 66;
}
// 调用前：11，调用后：66

7. 数组常见问题

索引越界异常

ArrayIndexOutOfBoundsException：当访问了数组中不存在的索引，就会引发索引越界异常

空指针异常

当引用数据类型变量被赋值为 null 之后，地址的指向被切断，还继续访问堆内存数据，就会引发空指针异常

public static void main(String[] args) {
    int[] arr = new int[2];
    // 把 null 赋值给数组
    arr = null;
    // 输出元素
    System.out.println(arr[0]);   // NullPointerException
}

flowchart LR
    M1["方法: main int[] arr = null"]
    H1["10f87f48 int[] length=2 0:0 1:0"]
    M1 -. × .- H1

8. 二维数组

二维数组是一种容器，该容器用于存储一维数组

使用场景

要操作的一维数组有多个，并且属于同一个整体，可以考虑使用二维数组

// 销售部门四个季度的销售业绩
int[] arr = { {22, 66, 44}, {77, 33, 88}, {25, 45, 65}, {11, 66, 99} };

二维数组静态初始化

格式	语法	范例
<span style="color:red">完整</span>	`数据类型[][] 数组名 = new 数据类型[][]{...};`	`int[][] arr = new int[][]{{11,22},{33,44}};`
<span style="color:red">简化</span>	`数据类型[][] 数组名 = {{...},{...}};`	`int[][] arr = {{11,22},{33,44}};`

二维数组元素访问

格式：数组名[索引][索引];
范例：arr[1][0];

案例：二维数组遍历

需求：已知一个二维数组 arr = {{11, 22, 33}, {33, 44, 55}};，遍历该数组，取出所有元素并打印

分析：

遍历二维数组，取出里面每一个一维数组
在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素

int[][] arr = {{11, 22, 33}, {33, 44, 55}};

for (int i = 0; i < arr.length; i++) {
    // arr[i] 就是每一个一维数组
    for (int j = 0; j < arr[i].length; j++) {
        System.out.print(arr[i][j] + " ");
    }
    System.out.println();
}
// 11 22 33
// 33 44 55

第八章面向对象基础

万物皆对象 面向对象是一种编程的指导思想以什么形式组织代码 / 以什么思路解决问题

1. 面向对象介绍

面向对象：并不是一个技术，而是一种编程的指导思想 以什么形式组织代码 / 以什么思路解决问题因为生活中，我们解决问题时，就是采用这种指导思想去解决的所以，我们写程序去解决问题时，如果也能采用这种指导思想，就会使编程变得非常简单，程序也便于人理解

flowchart LR
    A[面向对象] --> B[一种编程的指导思想]
    A --> C[以什么形式 组织代码]
    A --> D[以什么思路 解决问题]

万物皆对象 试卷、钱、手机、人、试柜 → 都是对象老师、学生 → 也是对象老师 t = new 老师(); 试卷 s = t.出题(); 学生 stu = new 学生(); stu.考试(s); t.批卷(s);

public class Test {
    public static void main(String[] args) {
        老师 t = new 老师();
        试卷 s = t.出题();
        学生 stu = new 学生();
        stu.考试(s);
        t.批卷(s);
    }
}

面向对象，重点学什么？

学习自己如何设计对象

学习已有的对象如何使用

学习目标：

自己设计对象使用

掌握已有对象的使用

2. 类和对象

Java 中想要创建对象，必须先要有类的存在

类指的是一组相关属性和行为的集合，我们将其理解为是一张对象的设计图

类和对象的关系：

Java 中需要根据类，创建对象

一个类，可以创建出多个对象

类的组成

类由两部分组成：属性 + 行为

组成	语法要点	范例
<span style="color:red">属性</span>（成员变量）	跟之前定义变量的格式一样，<span style="color:red">只不过位置需要放在方法的外面</span>	`String name = "张三";`<br>`int age = 23;`
<span style="color:red">行为</span>（成员方法）	跟之前定义方法的格式一样，<span style="color:red">只不过需要去掉 static 关键字</span>	`public void study() { System.out.println("学习Java"); }`<br>`public void eat() { System.out.println("吃饭"); }`

创建对象、使用对象

步骤	语法	范例
<span style="color:red">创建对象</span>	`类名对象名 = new 类名();`	`Student stu = new Student();`
<span style="color:red">使用成员变量</span>	`对象名.变量名;`	`stu.name`<br>`stu.age = 24;`
<span style="color:red">使用成员方法</span>	`对象名.方法名(实际参数);`	`stu.study();`<br>`stu.eat();`

小结：

类的组成：属性、行为

属性：成员变量，描述事物的名词

行为：成员方法，描述事物的动词

创建对象格式：类名对象名 = new 类名();

使用对象格式：对象名.变量名; 对象名.方法名();

练习：类的定义与对象的创建和使用

需求：定义一个手机类 Phone，包含属性（品牌 brand、颜色 color、价格 price）和行为（打电话 call、发短信 sendMessage），并编写一个手机测试类 PhoneTest 创建两个手机对象，赋值后打印并调用成员方法。

public class Phone {
    String brand;
    String color;
    int price;

    public void call(String name) {
        System.out.println("给 " + name + " 打电话");
    }

    public void sendMessage() {
        System.out.println("群发短信");
    }
}

public class PhoneTest {
    public static void main(String[] args) {
        Phone p1 = new Phone();
        p1.brand = "小米";
        p1.color = "白色";
        p1.price = 4999;
        System.out.println(p1.brand + " " + p1.color + " " + p1.price);

        Phone p2 = new Phone();
        p2.brand = "华为";
        p2.color = "黑色";
        p2.price = 6999;
        System.out.println(p2.brand + " " + p2.color + " " + p2.price);

        p1.call("张总");
        p2.sendMessage();
    }
}

3. 类和对象内存图

一个对象的内存图 → 栈内存（局部变量 + 引用）→ 堆内存（new 出来的对象，成员变量 + 成员方法引用）→ 方法区（字节码）

flowchart LR
    subgraph 方法区
        M[TestStudent.class main]
    end
    subgraph 栈内存
        S1[main Student stu = 7ef20235]
    end
    subgraph 堆内存
        H1[7ef20235 String name: 张三 int age: 23 成员方法引用地址]
    end
    方法区 --> 栈内存 --> 堆内存

flowchart LR
    subgraph 方法区
        M[Test.class main]
    end
    subgraph 栈内存
        S1[main Student stu1 = 7ef20235]
        S2[Student stu2 = 27d6c5e0]
    end
    subgraph 堆内存
        H1[7ef20235 name: 张三 age: 23]
        H2[27d6c5e0 name: 李四 age: 24]
    end
    M --> S1 --> H1
    S1 --> H2

flowchart LR
    subgraph 方法区
        M[Test.class main]
    end
    subgraph 栈内存
        S1[main Student stu1 = 7ef20235 Student stu2 = 7ef20235]
    end
    subgraph 堆内存
        H1[7ef20235 name: 钢门吹雪]
    end
    M --> S1 --> H1

4. 成员变量和局部变量区别

区别	<span style="color:red">成员变量</span>	<span style="color:red">局部变量</span>
<span style="color:red">类中位置</span>	方法外	方法中
<span style="color:red">初始化值</span>	有默认初始化值	没有，使用前需要完成赋值
<span style="color:red">内存位置</span>	堆内存	栈内存
<span style="color:red">生命周期</span>	随着对象的创建而存在，随着对象的消失而消失	随着方法的调用而存在，随着方法的运行结束而消失
<span style="color:red">作用域</span>	在自己所属类的大括号中	在自己所归属的大括号中

5. this 关键字

this 可以解决的问题

当局部变量和成员变量出现了重名的情况，Java 使用的是就近原则 但是我就非要用成员变量 → 用 this.成员变量

public class Student {
    String name;
    int age;

    public void sayHello(String name) {
        System.out.println(this.name);   // 我就非要用成员变量
    }
}

this 介绍

this 代表当前类对象的引用（地址）

flowchart LR
    subgraph 栈内存
        S[main Student stu = 0011]
    end
    subgraph 堆内存
        H[0011 this → 0011 name: 钢门吹雪 age: 23]
    end
    S --> H

this 小结

当局部变量和成员变量重名的时候，Java 使用的是就近原则

this 关键字的作用是：调用本类成员

this.本类成员变量; —— 如果不涉及变量重复，this. 可以省略

this.本类成员方法(); —— 没有前提条件，this. 可以直接省略

this 代表什么呢？代表当前类对象的引用（地址）

6. 构造方法

构造器：初始化一个新构建的对象，构建、创建对象的时候，所调用的方法

格式：

方法名与类名相同，大小写也要一致

没有返回值类型，连 void 都没有

没有具体的返回值（不能由 return 带回结果数据）

执行时机：

创建对象的时候调用，每创建一次对象，就会执行一次构造方法

不能手动调用构造方法

public class Test {
    public static void main(String[] args) {
        Student stu = new Student();
    }
}

构造方法作用

本质作用：创建对象

结合构造方法执行时机：给对象中的属性（成员变量）进行初始化

构造方法注意事项

构造方法的创建：

如果没有定义构造方法，系统将给出一个默认的无参数构造方法

如果定义了构造方法，系统将不再提供默认的构造方法

构造方法的重载：构造方法也是方法，允许重载关系出现

推荐的使用方式：无参数构造方法，和带参数构造方法，都自己手动给出

class Student {
    int age;
    public Student() {}
    public Student(int age) {
        this.age = 18;
    }
}

构造方法执行流程

flowchart LR
    subgraph 栈内存
        M[main Student stu = 0011 构造方法 Student 调用者 this→0011 String name = 钢门吹雪 int age = 23]
    end
    subgraph 堆内存
        H[0011 this → 0011 name: 钢门吹雪 age: 23]
    end
    M --> H

public class Student {
    String name;
    int age;
    public Student() {}
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void show() {
        System.out.println(name + "---" + age);
    }
}

构造方法小结

构造方法的作用：1. 创建对象 2. 给成员变量初始化

构造方法的格式：1. 方法名与类名相同，大小写也要一致 2. 没有返回值类型，连 void 都没有 3. 没有具体的返回值

构造方法的注意事项：1. 如果一个类中没有写构造方法，系统会提供一个默认的无参数构造方法 2. 如果手动编写了构造方法，系统将不会提供默认的那个无参构造方法，建议无参构造、带参构造全部手动给出

7. 封装

面向对象三大特征：封装 / 继承 / 多态

封装思想

封装就是将数据（属性）和操作数据的方法捆绑在一起

组成一个整体，也就是类

同时，通过访问修饰符来控制对类中属性和方法的访问权限，从而实现信息隐藏

更好的维护数据

使用者无需关心内部实现，只要知道如何使用即可

核心：合理隐藏，合理暴露

案例：学生成绩

需求：计算每一名学生的总成绩，展示学生的所有信息

id	姓名	年龄	数学成绩	语文成绩
1	张三	23	90	87
2	李四	24	69	91

public class Student {
    int id;
    String name;
    int age;
    double mathScore;
    double chineseScore;

    public Student(int id, String name, int age, double mathScore, double chineseScore) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.mathScore = mathScore;
        this.chineseScore = chineseScore;
    }

    // 省略构造方法
    public double getTotalScore() {
        return mathScore + chineseScore;
    }

    public void showStudentInfos() {
        System.out.println("学号：" + id);
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
        System.out.println("数学成绩：" + mathScore);
        System.out.println("语文成绩：" + chineseScore);
    }
}

public class Test {
    public static void main(String[] args) {
        Student stu1 = new Student(1, "张三", 23, 90, 87);
        stu1.showStudentInfos();

        Student stu2 = new Student(2, "李四", 24, 69, 91);
        stu2.showStudentInfos();
    }
}

案例：电话簿

合理隐藏：saveLog() 方法设为 private；合理暴露：call() 方法设为 public

public class Phone {
    public void call(String name) {
        System.out.println("给 " + name + " 打电话");
        saveLog();
    }

    private void saveLog() {
        System.out.println("通话记录");
        System.out.println("将联系人 - 时间 - 通话时长保存到本地");
    }
}

权限修饰符

修饰符	可修饰
<span style="color:red">private</span>	成员变量、成员方法、构造方法
<span style="color:red">(default)</span>	成员变量、成员方法、构造方法
<span style="color:red">protected</span>	成员变量、成员方法、构造方法
<span style="color:red">public</span>	成员变量、成员方法、构造方法

8. JavaBean

标准 JavaBean：

这个类中的成员变量都要私有，并且要对外提供相应的 getXxx、setXxx 方法

类中提供无参，带参构造方法

实体类的应用场景：实体类只负责数据存取，而对数据的处理交给其他类来完成，以实现数据和数据业务处理相分离

public class Student {
    private String name;
    private double score;

    // getter setter 方法
    // 计算学生总成绩
    // 展示学生所有信息
    // ...
}

public class StudentOperator {
    private Student s;
    public StudentOperator(Student s) {
        this.s = s;
    }
}

9. static 关键字

static 是静态的意思，可以修饰成员变量，也可以修饰成员方法

static 修饰成员的特点

被其修饰的成员，被该类的所有对象所共享

多了一种调用方式，可以通过类名调用

随着类的加载而加载，优先于对象存在

类型	用途
<span style="color:red">static 成员变量</span>	共享数据
<span style="color:red">static 成员方法</span>	常用于工具类

static 内存图

flowchart LR
    subgraph 栈内存
        M[main User u1, u2]
    end
    subgraph 堆内存
        H1[u1: name=张三 age=23]
        H2[u2: name=李四 age=24]
        SH[User 静态成员变量区 int onLineNumber = 2]
    end
    subgraph 方法区
        Z[StaticTest1.class main]
    end
    M --> H1
    M --> H2
    H1 --> SH
    H2 --> SH
    Z --> M

注意事项

static 方法中，只能访问静态成员（直接访问）

static 中不允许使用 this 关键字

案例：数组工具类

需求：编写一个类 ArrayTools，内部编写三个方法：

从数组中找最大值

从数组中找最小值

打印出数组中所有的元素

public class ArrayTools {
    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) max = arr[i];
        }
        return max;
    }

    public static int getMin(int[] arr) {
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) min = arr[i];
        }
        return min;
    }

    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

重新认识 main 方法

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("HelloWorld");
    }
}

关键字	含义
<span style="color:red">public</span>	被 JVM 调用，访问权限足够大
<span style="color:red">static</span>	被 JVM 调用，不用创建对象<br>因为 main 方法是静态的，所以测试类中其他方法也需要是静态的
<span style="color:red">void</span>	被 JVM 调用，不需要给 JVM 返回值
<span style="color:red">main</span>	一个通用的名称，虽然不是关键字，但是被 JVM 识别
<span style="color:red">String[] args</span>	以前用于接收键盘录入数据的，现在没用

第九章面向对象高级

1. 继承

继承介绍

继承是面向对象三大特征之一，可以让类跟类之间产生父子关系 子类可以直接使用父类中非私有的成员

继承的好处与弊端

继承的好处：

提高代码的复用性

提高了代码的维护性

让类与类之间产生了关系，是多态的前提

继承的弊端：

继承让类与类之间产生了关系，耦合性增强

开发原则：高内聚，低耦合

继承的语法格式

继承用关键字 extends

public class 子类 extends 父类 { }

继承后成员访问特点

成员	访问特点
成员变量	<span style="color:orange">就近原则：先在子类局部范围找，再到子类成员范围找，最后到父类成员范围找</span>
成员方法	<span style="color:orange">就近原则</span>
构造方法	<span style="color:orange">子类的所有构造方法默认都会访问父类的<strong>无参构造方法</strong></span>

继承中变量访问

子类局部范围有就使用子类的

子类成员范围有就使用子类的

父类成员范围有就使用父类的

如果都没有就报错（不用考虑父类的父类）

class Fu {
    String name = "Fu";
}

class Zi extends Fu {
    String name = "Zi";
    
    public void show() {
        String name = "局部";
        System.out.println(name);       // 局部
        System.out.println(this.name);  // Zi
        System.out.println(super.name); // Fu
    }
}

super 关键字

super 代表的是父类对象的引用 this 代表的是当前对象的引用

关键字	访问成员变量	访问成员方法	访问构造方法
`this.`	本类的成员变量	本类的成员方法	`this(...)` 访问本类构造
`super.`	父类的成员变量	父类的成员方法	`super(...)` 访问父类构造

继承中构造方法访问

子类所有构造方法的第一行，默认都有一个 super() 调用父类无参构造

如果父类没有无参构造，子类构造方法中必须显式调用父类的有参构造 super(参数)

子类构造方法中，this() 和 super() 不能同时存在，因为它们都必须放在第一行

子类构造方法中，默认调用父类无参构造是 Java 帮我们加上的

flowchart TB
    A[创建子类对象] --> B[先执行父类构造]
    B --> C[再执行子类构造]

继承的特点

Java 只支持单继承，不支持多继承（一个子类只能有一个父类）

Java 支持多层继承（父类可以有父类）

一个父类可以有多个子类

顶层父类是 Object，所有类都直接或间接继承 Object

classDiagram
    A <|-- B
    B <|-- C
    A : Object
    B : 父类
    C : 子类

方法重写

方法重写：在子类中，出现和父类一模一样的方法声明（方法名、参数列表、返回值类型都相同） 方法重写的意义：子类可以覆盖父类的实现，提供自己的逻辑

方法重写的注意事项：

私有方法不能被重写（父类私有成员子类不能继承）

子类重写父类方法时，访问权限不能更低（public > 默认 > private）

子类重写父类方法时，建议加上 @Override 注解来校验

class Fu {
    public void show() {
        System.out.println("Fu show");
    }
}

class Zi extends Fu {
    @Override
    public void show() {
        System.out.println("Zi show");
    }
}

继承的练习

需求：定义老师类和学生类，找出他们的共同特征，抽到父类中共同特征：姓名、年龄、吃饭特有功能：老师 - 讲课；学生 - 学习

classDiagram
    class Person {
        +String name
        +int age
        +eat()
    }
    class Teacher {
        +teach()
    }
    class Student {
        +study()
    }
    Person <|-- Teacher
    Person <|-- Student

2. Object 类

Object 类介绍

Object 是所有类的顶层父类，所有类都直接或间接继承 Object 一个类如果没有显式继承其他类，默认继承 Object

常用方法

方法	说明
`public String toString()`	返回对象的字符串表示，默认打印的是<strong>地址值</strong>
`public boolean equals(Object obj)`	比较两个对象是否相等，默认比较的是<strong>地址值</strong>
`public Class<?> getClass()`	返回对象的字节码文件对象
`protected Object clone()`	克隆对象

toString 方法的重写

打印对象时，会自动调用 toString() 方法默认 toString() 返回的是：类名@十六进制地址值，没有意义所以需要重写 toString()，返回对象的属性值

@Override
public String toString() {
    return "Student{name=" + name + ", age=" + age + "}";
}

equals 方法的重写

默认 equals() 比较的是对象的地址值 业务中通常需要比较对象的内容是否相同，需要重写 equals()

@Override
public boolean equals(Object o) {
    // 如果两个对象的地址相同，代表是同一块内存控件，里面的内容肯定相同
    if (this == o) return true;
    
    // 代码如果可以执行到这里，说明stu1肯定不是null
    // stu1不是null，stu2为null，直接返回fallse
    // 比较零个对象的字节码，如果字节码不相同，代表类型不一致
    if (o == null || getClass() != o.getClass()) return false;
    
    // 向下转型，调用子类特有的属性
    Student student = (Student) o;
    
    // 比较两个对象的属性值
    return age == student.age && Objects.equals(name, student.name);
}

快捷键：Alt + Insert → toString() / equals() 可自动生成

Objects 类

Objects 类与 Object 仍然是继承关系，Objects 类是从 JDK 1.7 开始之后才有的工具类 位于 java.util.Objects，是一个工具类，提供一些静态方法来操作对象

Objects 常见方法

方法名	说明
<span style="color:red">`public static boolean equals(Object a, Object b)`</span>	<span style="color:orange">比较两个对象，底层会先进行<strong>非空判断</strong>，从而可以<strong>避免空指针异常</strong>，再进行 equals 比较
<span style="color:red">`public static boolean isNull(Object obj)`</span>	<span style="color:orange">判断变量是否为 `null`

Objects.equals 源码分析

public static boolean equals(Object a, Object b) {
    return (a == b) || (a != null && a.equals(b));
}

关键点：先比较 a == b（地址），如果为 true 直接返回；否则判断 a != null 后再调用 a.equals(b)，避免空指针异常

Objects 小结

Objects 中的 equals 方法仅仅是个工具类中的方法，底层依赖于我们自己编写的 equals 方法 优势：加入了健壮性判断（提前做非空判断，避免空指针异常）

3. final 关键字

final 介绍

final 是最终的意思，可以修饰类、方法、变量

final 修饰的特点

修饰对象	效果
修饰类	<span style="color:red">该类<strong>不能被继承</strong>（太监类）</span>
修饰方法	<span style="color:red">该方法<strong>不能被重写</strong></span>
修饰变量	<span style="color:red">该变量<strong>不能被重新赋值</strong>，<strong>只能赋值一次</strong></span>

final class Fu { }              // 该类不能被继承
class Zi {
    public final void show() { } // 该方法不能被重写
}

final 修饰变量的细节

修饰基本数据类型：变量存储的数据值不能发生改变

修饰引用数据类型：变量存储的地址值不能发生改变，对象的内容可以改变

变量是成员变量时，由于有默认值，用 final 修饰后必须手动赋值（构造方法或直接赋值）

final 修饰的变量一般叫常量，命名规范：所有字母都大写，多个单词用下划线分隔

final int AGE = 18;        // AGE 是常量
final int[] ARR = {1, 2, 3};
// ARR = new int[5];      // 错误，地址值不能改
ARR[0] = 100;              // 正确，内容可以改

4. 抽象类

抽象类介绍

抽象类是一种特殊的父类，里面可以定义没有方法体的抽象方法

抽象方法

抽象方法：将共性的行为（方法）抽取到父类之后，发现每个子类的执行逻辑不一样，此时在父类中不能给出具体的方法体，这种方法就是抽象方法

public abstract 返回值类型 方法名(参数列表);   // 抽象方法，没有方法体

抽象类定义格式

public abstract class 类名 {                  // 抽象类
    public abstract 返回值类型 方法名(参数列表); // 抽象方法
}

抽象类特点

抽象类不能实例化（不能创建对象）

抽象类中可以有构造方法，供子类访问父类数据初始化

抽象类中可以有非抽象方法，提高代码复用性

抽象类的子类必须重写所有抽象方法，否则子类也必须是抽象类

classDiagram
    class Animal {
        <<abstract>>
        +name: String
        +eat()*
        +drink() 抽象方法
    }
    class Dog {
        +eat()
        +drink()
    }
    Animal <|-- Dog

抽象类的意义

强制子类必须按照父类的格式定义方法 抽象类存在的意义是为了被子类继承，否则抽象类将毫无意义

public abstract class Animal {
    private String name;
    
    public Animal() { }
    public Animal(String name) { this.name = name; }
    
    public abstract void eat();  // 抽象方法
    
    public void sleep() {        // 普通方法
        System.out.println("睡觉");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

抽象类练习

需求：定义一个抽象类 Shape，包含抽象方法 getArea() 和 getPerimeter()，让 Circle 和 Rectangle 继承

classDiagram
    class Shape {
        <<abstract>>
        +getArea()*
        +getPerimeter()*
    }
    class Circle {
        -radius: double
        +getArea()
        +getPerimeter()
    }
    class Rectangle {
        -length: double
        -width: double
        +getArea()
        +getPerimeter()
    }
    Shape <|-- Circle
    Shape <|-- Rectangle

5. 接口

接口介绍

接口是一种规则，是对行为的抽象 Java 中的接口更多体现的是一种规范（约定），是一种引用数据类型

接口的定义格式

public interface 接口名 { 
    // 成员变量：只能是常量，默认修饰 public static final
    // 成员方法：只能是抽象方法，默认修饰 public abstract
    // JDK8：可以定义默认方法、静态方法
    // JDK9：可以定义私有方法
}

接口的实现

public class 类名 implements 接口名 { 
    // 重写接口中所有抽象方法
}

接口的成员特点

成员	特点
成员变量	<span style="color:red">只能是<strong>常量</strong>，默认修饰符 `public static final`</span>
成员方法	<span style="color:red">只能是<strong>抽象方法</strong>，默认修饰符 `public abstract`</span>（JDK8 前）
构造方法	<span style="color:red"><strong>没有</strong>构造方法</span>

public interface Animal {
    public static final int AGE = 10;   // 常量
    public abstract void eat();          // 抽象方法
}

接口的关系

关系	写法
类与类	<span style="color:orange">继承关系（`extends`），单继承或多层继承</span>
类与接口	<span style="color:orange">实现关系（`implements`），可以单实现，也可以<strong>多实现</strong></span>
接口与接口	<span style="color:orange">继承关系（`extends`），可以单继承，也可以<strong>多继承</strong></span>

// 类多实现接口
class A implements B, C { }

// 接口多继承接口
interface D extends B, C { }

JDK8 接口新特性

JDK8 之后，接口中可以定义默认方法和静态方法，用来解决接口升级的问题

方法类型	格式	特点
<span style="color:red">默认方法</span>	`public default 返回值类型方法名(参数) { }`	<span style="color:orange">有方法体；实现类可以<strong>继承</strong>，也可以<strong>重写</strong></span>
<span style="color:red">静态方法</span>	`public static 返回值类型方法名(参数) { }`	<span style="color:orange">有方法体；只能通过<strong>接口名调用</strong>，不能通过实现类调用</span>

public interface MyInterface {
    default void show() {               // 默认方法
        System.out.println("默认方法");
    }
    
    static void staticMethod() {        // 静态方法
        System.out.println("静态方法");
    }
}

// 调用
MyInterface.staticMethod();

JDK9 接口新特性

JDK9 之后，接口中可以定义私有方法，用来抽取默认方法或静态方法中重复的代码

public interface MyInterface {
    default void show1() {
        methodCommon();
        System.out.println("show1");
    }
    
    default void show2() {
        methodCommon();
        System.out.println("show2");
    }
    
    private void methodCommon() {       // 私有方法，供默认方法使用
        System.out.println("公共代码");
    }
}

6. 抽象类和接口的区别

成员	抽象类	接口
<span style="color:red">成员变量</span>	可以是变量，也可以是常量	<span style="color:orange">只能是 `public static final` 常量</span>
<span style="color:red">成员方法</span>	可以是抽象方法，也可以是非抽象方法	<span style="color:orange">JDK8 前：只能是 `public abstract` 抽象方法<br>JDK8 后：可以加 default / static<br>JDK9 后：可以加 private</span>
<span style="color:red">构造方法</span>	<span style="color:orange">有</span>	<span style="color:orange">无</span>
<span style="color:red">使用场景</span>	抽取共性代码（is a）	定义规则（like a）

classDiagram
    class 抽象类 {
        +构造方法
        +普通方法
        +抽象方法
        +普通变量
        +常量
    }
    class 接口 {
        +常量
        +抽象方法
        +默认方法(JDK8)
        +静态方法(JDK8)
        +私有方法(JDK9)
    }

设计原则：接口优先于抽象类。当两者都能满足需求时，优先使用接口

7. 多态

多态介绍

多态是面向对象三大特征之一，是指同一行为，通过不同的事物，可以体现出不同的形态 多态是方法的多态，跟属性无关

多态的前提

要有继承或实现关系

要有方法重写

要父类引用指向子类对象：Fu f = new Zi();

Animal a = new Dog();   // 父类引用指向子类对象（向上转型）
a.eat();                // 调用的是 Dog 重写后的方法

多态中成员访问特点

成员	访问特点
成员变量	<span style="color:red"><strong>编译看左边，运行也看左边</strong>（访问的是父类的成员变量）</span>
成员方法	<span style="color:red"><strong>编译看左边，运行看右边</strong>（访问的是子类重写后的方法）</span>

记忆口诀：成员方法看右边（运行），其他成员看左边（编译）

多态的好处和弊端

好处：

提高了程序的扩展性（定义方法时，使用父类作为参数，使用时传入子类对象）

弊端：

多态情况下，不能访问子类特有的成员

多态中的转型

向上转型：从子到父（自动转换），父类引用指向子类对象 向下转型：从父到子（强制转换），子类引用指向父类对象（实际还是子类）

Animal a = new Dog();           // 向上转型（自动）
Dog d = (Dog) a;                // 向下转型（强制）
d.watchHouse();                 // 调用 Dog 特有方法

instanceof 关键字

用于判断某个对象是否属于某个类型，避免类型转换异常 ClassCastException

if (a instanceof Dog) {
    Dog d = (Dog) a;
    d.watchHouse();
} else if (a instanceof Cat) {
    Cat c = (Cat) a;
    c.catchMouse();
}

多态内存图

flowchart LR
    subgraph stack[栈]
        F[Fu 类型引用 a]
    end
    subgraph heap[堆]
        Z[Zi 类对象]
    end
    F --> Z
    Z -.继承自 Fu.-> FU[父类成员]
    Z -.重写.-> FM[方法区]

多态练习

需求：定义动物类，猫和狗继承动物类，都有 eat 方法；定义测试类，传入任意动物对象调用 eat 方法

classDiagram
    class Animal {
        <<abstract>>
        +eat()*
    }
    class Cat {
        +eat()
    }
    class Dog {
        +eat()
    }
    Animal <|-- Cat
    Animal <|-- Dog

8. 代码块

代码块介绍

在 Java 中，使用 {} 括起来的代码被称为代码块

代码块的分类

类型	位置	特点
<span style="color:red">局部代码块</span>	<span style="color:orange">方法内部</span>	<span style="color:orange">限定变量的<strong>生命周期</strong>，及早释放内存</span>
<span style="color:red">构造代码块</span>	<span style="color:orange">类中方法外</span>	<span style="color:orange">每次创建对象都会执行，优先于构造方法执行</span>
<span style="color:red">静态代码块</span>	<span style="color:orange">类中方法外，加 `static`</span>	<span style="color:orange">随着类加载而执行，<strong>只执行一次</strong>，优先于构造代码块执行</span>

public class Student {
    static {
        System.out.println("静态代码块");     // 加载类时执行
    }
    
    {
        System.out.println("构造代码块");     // 每次 new 都执行
    }
    
    public Student() {
        System.out.println("构造方法");
    }
}

静态代码块的应用

用于类的初始化，加载驱动、加载配置文件等

public class JDBCUtils {
    static {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

9. 包

什么是包

包（package）本质就是文件夹，用来管理类文件的 通过包，可以将不同功能的类进行分类管理，避免类重名的问题

包的定义格式

package 公司域名倒写.技术名称.包名;
// 范例
package com.itheima.pojo;

public class Student { }

规范：包名建议全部英文小写，且具备意义，一般使用公司域名倒写 + 项目名 + 功能名 注意：package 语句必须是程序的第一行可执行代码

导包

相同包下的类可以直接访问，不同包下的类必须导包，才可以使用！

import 包名.类名;     // 导包格式
import com.itheima.pojo.Student;  // 范例

如果导入的类在 java.lang 包下（核心包），就不需要编写 import 导包代码

假如一个类中需要用到不同类，而这两个类的名称是一样的，那么默认只能导入一个类，另一个类要带包名访问

导包练习

// 1. 手动导包
import java.util.Scanner;

// 2. 通配符 * 导入整个包的所有类（不建议）
import java.util.*;

10. 内部类

内部类介绍

内部类就是在一个类的内部又定义了另一个类 例如：在一个类 A 的内部定义一个类 B，B 就被称为内部类，A 称为外部类

内部类的分类

类型	位置	说明
<span style="color:red">成员内部类</span>	<span style="color:orange">类中方法外</span>	<span style="color:orange">与成员变量、成员方法同级</span>
<span style="color:red">静态内部类</span>	<span style="color:orange">类中方法外，加 `static`</span>	<span style="color:orange">静态的成员内部类</span>
<span style="color:red">局部内部类</span>	<span style="color:orange">方法内</span>	<span style="color:orange">定义在方法中的类</span>
<span style="color:red">匿名内部类</span>	<span style="color:orange">方法内</span>	<span style="color:orange">没有名字的内部类，<strong>本质是一个对象</strong></span>

成员内部类

public class Outer {
    private int num = 10;
    
    public class Inner {
        public void show() {
            System.out.println(num);   // 内部类可以直接访问外部类成员
        }
    }
}

// 创建对象
Outer.Inner oi = new Outer().new Inner();
oi.show();

成员内部类访问特点

内部类可以直接访问外部类的所有成员（包括私有）

外部类要访问内部类的成员，必须创建对象

内部类中如果定义了和外部类同名的成员变量，默认访问内部类的

访问外部类同名成员：外部类名.this.成员变量

静态内部类

静态内部类只能访问外部类的静态成员

public class Outer {
    static class Inner {
        public void show() {
            System.out.println("静态内部类");
        }
    }
}

// 创建对象
Outer.Inner oi = new Outer.Inner();
oi.show();

局部内部类

定义在方法中的类，外界无法直接使用，需要在方法内部创建对象使用 可以直接访问外部类的成员，也可以访问方法内的局部变量（final 修饰的常量，JDK8 后 final 可省略）

public class Outer {
    public void method() {
        int num = 10;
        class Inner {
            public void show() {
                System.out.println(num);   // 访问方法中的局部变量
            }
        }
        new Inner().show();
    }
}

匿名内部类

匿名内部类是局部内部类的一种特殊写法，本质是一个对象

new 接口名/类名() {
    // 重写方法
}.方法名();

// 案例
new Inter() {
    @Override
    public void show() {
        System.out.println("匿名内部类");
    }
}.show();

匿名内部类的应用场景

当方法的参数是接口或抽象类时，可以直接传递匿名内部类作为实参

public static void main(String[] args) {
    useInter(new Inter() {
        @Override
        public void show() {
            System.out.println("show");
        }
    });
}

public static void useInter(Inter i) {
    i.show();
}

11. Lambda 表达式

Lambda 表达式介绍

Lambda 表达式是 JDK8 之后的新特性，可以用来简化匿名内部类的书写 只能简化函数式接口的匿名内部类

函数式接口：有且仅有一个抽象方法的接口（可以有其他非抽象方法），可以加 @FunctionalInterface 注解

Lambda 表达式的标准格式

() -> { }

部分	说明
`()`	形参列表，接口中抽象方法的形参列表
`->`	固定写法，代表指向动作
`{}`	方法体，接口中抽象方法的方法体

Lambda 表达式练习

抽象方法无参无返回值

抽象方法有参无返回值

抽象方法有参有返回值

// 案例 1：无参无返回值
useInter(() -> System.out.println("Lambda"));

// 案例 2：有参无返回值
useInter((int num) -> System.out.println(num));

// 案例 3：有参有返回值
useInter((int a, int b) -> a + b);

Lambda 表达式的省略规则

参数类型可以省略，但多个参数不能只省略一个

如果参数只有一个，小括号可以省略

如果方法体只有一句话，大括号可以省略，且如果有 return 也要省略

// 完整写法
(int a, int b) -> { return a + b; }

// 省略参数类型
(a, b) -> { return a + b; }

// 省略大括号和 return
(a, b) -> a + b;

Lambda 表达式与匿名内部类的区别

对比项	匿名内部类	Lambda 表达式
<span style="color:red">类型</span>	编译后产生<strong>单独的字节码文件</strong>（`Outer$1.class`）	<span style="color:orange">编译后<strong>不产生单独的字节码文件</strong>，对应的字节码会在运行时动态生成</span>
<span style="color:red">使用范围</span>	<span style="color:orange">所有接口和抽象类都可以使用</span>	<span style="color:orange">只能简化<strong>函数式接口</strong>的匿名内部类</span>

第十章常用 API

1. 常用 API 概述

什么是 API

API（Application Programming Interface）—— 应用程序编程接口 就是别人写好的一些类，给咱们程序员直接拿去调用即可解决问题的

已经学习过的 API

API	作用
<span style="color:red">Scanner</span>	<span style="color:orange">键盘录入</span>
<span style="color:red">Random</span>	<span style="color:orange">随机数</span>

JDK-API 帮助文档：JDK 提供的类的使用说明书，所有 API 都可以在这里查到

2. String 类

String 类的特点

Java 程序中所有双引号字符串，都是 String 类的对象

字符串在创建之后，其内容不可更改

字符串虽然不可改变，但是可以被共享

String s = "abc";   // 字符串"abc"是 String 类的对象，s 指向它
s = "def";          // 不是修改内容，而是把 s 的指向改为新的"def"

String 类的常见构造方法

构造方法	说明
<span style="color:red">`public String()`</span>	创建空白字符串，不含任何内容
<span style="color:red">`public String(String original)`</span>	根据传入的字符串，创建字符串对象
<span style="color:red">`public String(char[] chs)`</span>	根据字符数组，创建字符串对象

// 两种最常用的方式
String s1 = new String("abc");   // 通过构造方法
String s2 = "abc";                // 直接赋值（推荐）

String 类的常见面试题（== 比较）

字符串字面量赋值，先在字符串常量池中查找； 如果存在，则直接共享，不创建新对象；不存在则创建新对象并存入池中

String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2);   // true（共享常量池中同一个对象）

通过 new 关键字创建的字符串对象，每次都会在堆内存中开辟新空间

String s1 = "abc";
String s2 = new String("abc");
System.out.println(s1 == s2);   // false（地址不同）

字符串拼接 + 的底层会创建 StringBuilder 对象，拼接后再 toString()； 结果是新对象，所以和常量池中的不相等

String s1 = "abc";
String s2 = "ab" + "c";           // 常量拼接，编译期优化 → true
String s3 = s2 + "c";             // 变量拼接 → new StringBuilder().toString() → false
System.out.println(s1 == s3);     // false

flowchart LR
    subgraph heap[堆内存]
        ST[StringTable 字符串常量池]
        H[new String 对象]
    end
    subgraph stack[栈内存]
        A[s1]
        B[s2]
    end
    A --> ST
    B --> H
    H -.不共享.-> ST

结论：比较字符串内容是否相同，请使用 equals() 方法，而不是 ==

String 用于比较的方法

方法	说明
<span style="color:red">`public boolean equals(要比较的字符串)`</span>	<span style="color:orange">完全一样结果才是 `true`，否则为 `false`</span>
<span style="color:red">`public boolean equalsIgnoreCase(要比较的字符串)`</span>	<span style="color:orange">忽略大小写的比较</span>

String s1 = "abc";
String s2 = "ABC";
System.out.println(s1.equals(s2));           // false
System.out.println(s1.equalsIgnoreCase(s2)); // true

案例：模拟用户登录

需求：已知正确的用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示

import java.util.Scanner;

public class Login {
    public static void main(String[] args) {
        String rightUsername = "itheima";
        String rightPassword = "123456";
        Scanner sc = new Scanner(System.in);
        
        for (int i = 0; i < 3; i++) {
            System.out.print("请输入用户名：");
            String username = sc.next();
            System.out.print("请输入密码：");
            String password = sc.next();
            
            if (rightUsername.equals(username) && rightPassword.equals(password)) {
                System.out.println("登录成功！");
                break;
            } else {
                System.out.println("登录失败，还有 " + (2 - i) + " 次机会");
            }
        }
    }
}

String 字符串的遍历

方法	说明
<span style="color:red">`public char[] toCharArray()`</span>	<span style="color:orange">将字符串转换为字符数组</span>
<span style="color:red">`public char charAt(int index)`</span>	<span style="color:orange">根据索引找字符</span>
<span style="color:red">`public int length()`</span>	<span style="color:orange">返回字符串的长度</span>

// 方式一：charAt + length
String s = "abcde";
for (int i = 0; i < s.length(); i++) {
    System.out.println(s.charAt(i));
}

// 方式二：toCharArray
for (char c : s.toCharArray()) {
    System.out.println(c);
}

案例：统计字符次数

需求：键盘录入一个字符串，统计该字符串中大写字母字符、小写字母字符、数字字符出现的次数（不考虑其他字符）例如：aAb3&c2B*4CD1 → 小写：3 个；大写：4 个；数字：4 个

String s = new Scanner(System.in).next();
int upper = 0, lower = 0, digit = 0;
for (int i = 0; i < s.length(); i++) {
    char c = s.charAt(i);
    if (c >= 'A' && c <= 'Z') upper++;
    else if (c >= 'a' && c <= 'z') lower++;
    else if (c >= '0' && c <= '9') digit++;
}
System.out.println("大写：" + upper + "，小写：" + lower + "，数字：" + digit);

String 字符串的截取方法

方法	说明
<span style="color:red">`public String substring(int beginIndex, int endIndex)`</span>	<span style="color:orange">截取；<strong>包头不包尾</strong>，只有返回值才是截取的小串</span>
<span style="color:red">`public String substring(int beginIndex)`</span>	<span style="color:orange">从 beginIndex 截取到末尾</span>

String s = "abcdef";
System.out.println(s.substring(1, 3));   // bc（包左不包右）
System.out.println(s.substring(2));      // cdef

案例：手机号屏蔽

需求：以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽最终效果为：156****1234

String phone = "15612341234";
String result = phone.substring(0, 3) + "****" + phone.substring(7);
System.out.println(result);   // 156****1234

String 字符串的替换方法

方法	说明
<span style="color:red">`public String replace(旧值, 新值)`</span>	<span style="color:orange">返回值才是<strong>替换之后</strong>的结果，原串不变</span>

String s = "abcabc";
String r = s.replace("a", "x");
System.out.println(r);   // xbcxbc
System.out.println(s);   // abcabc（不变）

案例：敏感词替换

需求：键盘录入一个字符串，如果字符串中包含 (TMD)，则使用 *** 替换

String s = new Scanner(System.in).next();
String r = s.replace("TMD", "***");
System.out.println(r);

String 字符串的切割方法

方法	说明
<span style="color:red">`public String[] split(String regex)`</span>	<span style="color:orange">根据传入的字符串作为规则进行切割；<br>将切割后的内容存入字符串数组中，并将字符串数组返回</span>

String s = "a,b,c,d";
String[] arr = s.split(",");
for (String x : arr) {
    System.out.println(x);
}

注意：切割时如果中间存在空格，需要用 , + 或 "," 处理； 切割规则如果是特殊字符（如 .、|），需要转义（加 \\）

String 方法小结

方法	说明
<span style="color:red">`equals(要比较的字符串)`</span>	<span style="color:orange">比较内容</span>
<span style="color:red">`equalsIgnoreCase(要比较的字符串)`</span>	<span style="color:orange">比较内容，忽略大小写</span>
<span style="color:red">`toCharArray()`</span>	<span style="color:orange">将字符串转换为字符数组</span>
<span style="color:red">`charAt(int index)`</span>	<span style="color:orange">根据索引找字符</span>
<span style="color:red">`length()`</span>	<span style="color:orange">返回字符串的长度</span>
<span style="color:red">`substring(int beginIndex)`</span>	<span style="color:orange">截取到末尾</span>
<span style="color:red">`substring(int beginIndex, int endIndex)`</span>	<span style="color:orange">根据开始和结束索引做截取，<strong>包含头不包含尾</strong></span>
<span style="color:red">`replace(旧值, 新值)`</span>	<span style="color:orange">替换</span>
<span style="color:red">`split(String regex)`</span>	<span style="color:orange">切割</span>

3. StringBuilder 类

StringBuilder 引入

StringBuilder 可以大幅度提高字符串操作效率 如果在大量拼接字符串的场景下，使用 String 的 + 会反复创建对象，效率低，推荐用 StringBuilder

StringBuilder 介绍

StringBuilder 是字符串的缓冲区，我们可以将其理解为是一种容器

StringBuilder 是一种可变的字符序列

StringBuilder 构造方法

构造方法	说明
<span style="color:red">`public StringBuilder()`</span>	<span style="color:orange">创建一个空的字符串缓冲区（容器）</span>
<span style="color:red">`public StringBuilder(String str)`</span>	<span style="color:orange">创建一个字符串缓冲区，并初始化好指定的参数内容</span>

StringBuilder sb1 = new StringBuilder();
StringBuilder sb2 = new StringBuilder("abc");

StringBuilder 常用方法

方法名	说明
<span style="color:red">`public StringBuilder append(任意类型)`</span>	<span style="color:orange">添加数据，并<strong>返回对象本身</strong>（支持链式编程）</span>
<span style="color:red">`public StringBuilder reverse()`</span>	<span style="color:orange">反转容器中的内容</span>
<span style="color:red">`public int length()`</span>	<span style="color:orange">返回长度（字符出现的个数）</span>
<span style="color:red">`public String toString()`</span>	<span style="color:orange">通过 toString() 就可以实现把 StringBuilder 转换为 String</span>

StringBuilder sb = new StringBuilder();
sb.append("a").append("b").append("c");   // 链式编程
System.out.println(sb);          // abc
System.out.println(sb.length()); // 3

String s = sb.toString();        // 转成 String

案例：回文字符串

需求：键盘接受一个字符串，程序判断出该字符串是否是对称字符串，并在控制台打印是或不是对称字符串：123321、111 非对称字符串：123123

String s = new Scanner(System.in).next();
StringBuilder sb = new StringBuilder(s);
String reverse = sb.reverse().toString();

if (s.equals(reverse)) {
    System.out.println("是对称字符串");
} else {
    System.out.println("不是对称字符串");
}

案例：按照指定的格式拼接字符串

需求：定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回。调用该方法，并在控制台输出结果例如：数组为 int[] arr = {1,2,3}; → 输出 [1, 2, 3]

public static String arrayToString(int[] arr) {
    StringBuilder sb = new StringBuilder("[");
    for (int i = 0; i < arr.length; i++) {
        if (i == arr.length - 1) {
            sb.append(arr[i]).append("]");
        } else {
            sb.append(arr[i]).append(", ");
        }
    }
    return sb.toString();
}

StringBuilder 原理（一个加号，堆内存中俩对象）

当执行 String s = s1 + s2; 时，底层会做：

创建一个 StringBuilder 对象

调用 append() 把 s1、s2 加入

调用 toString() 创建新的 String 对象返回

flowchart LR
    subgraph stack[栈内存]
        s1[s1 = 'a']
        s2[s2 = s1 + 'b']
        s3[s3 = s2 + 'c']
    end
    subgraph heap[堆内存]
        SB1[StringBuilder 'ab']
        ST1[String 'ab']
        SB2[StringBuilder 'abc']
        ST2[String 'abc']
    end
    s1 --> H1[StringTable 'a']
    s2 --> SB1
    SB1 -.toString.-> ST1
    s2 --> SB2
    SB2 -.toString.-> ST2
    s3 --> ST2

结论：每次 + 都会产生一个 StringBuilder + 一个新 String 对象，频繁拼接效率低

StringBuilder 拼接原理（append 复用自身）

直接使用 StringBuilder 的 append()，方法返回自身对象，始终在同一个缓冲区中操作

flowchart LR
    subgraph stack[栈内存]
        sb[Reference sb]
    end
    subgraph heap[堆内存]
        BUF[StringBuilder 同一个对象]
    end
    sb --> BUF
    BUF --> A1[append a]
    BUF --> A2[append b]
    BUF --> A3[append c]

优势：不会产生中间 String 对象，效率远高于 + 拼接

StringBuilder 小结

StringBuilder 可以大幅度提升字符串操作效率 今后若频繁进行字符串拼接操作，建议使用 StringBuilder

StringBuilder 与 String 互转

// StringBuilder → String：通过 toString()
String s = sb.toString();

// String → StringBuilder：通过构造方法
StringBuilder sb2 = new StringBuilder("hello");

链式编程

StringBuilder 的 append() 方法返回的是对象本身，因此可以连续调用

StringBuilder sb = new StringBuilder();
sb.append("a").append("b").append("c").reverse().append("d");
System.out.println(sb);   // dcba

第十一章集合基础

1. 集合概述

什么是集合

集合是一种容器，用来装数据的，类似于数组

数组 vs 集合

对比项	数组	集合
<span style="color:red">长度</span>	<span style="color:orange"><strong>固定不变</strong></span>	<span style="color:orange"><strong>可变</strong></span>
<span style="color:red">类型</span>	<span style="color:orange">基本数据类型 / 引用数据类型</span>	<span style="color:orange">只能存放<strong>引用数据类型</strong>（基本类型用包装类）</span>
<span style="color:red">使用场景</span>	<span style="color:orange">元素个数固定不变</span>	<span style="color:orange">元素个数经常发生改变</span>

结论：开发中集合用的更多，因为业务中数据量往往是动态的

集合的体系结构

classDiagram
    class Collection
    class Map
    Collection <|-- List
    Collection <|-- Set
    List <|-- ArrayList
    List <|-- LinkedList
    List <|-- Vector
    Set <|-- HashSet
    Set <|-- TreeSet
    Set <|-- LinkedHashSet
    Map <|-- HashMap
    Map <|-- LinkedHashMap
    Map <|-- TreeMap

Collection 接口：单列集合，每次操作存储一个元素 Map 接口：双列集合，每次操作存储一对键值对（key-value）

2. ArrayList

ArrayList 长度可变原理

当创建 ArrayList 集合容器的时候，底层会存在一个长度为 10 的空数组

当数组存满后，再次添加新元素时，ArrayList 会扩容原数组 1.5 倍 大小的新数组

将原数组数据拷贝到新数组中

将新元素添加到新数组中

flowchart TB
    A[创建 ArrayList 底层数组长度 10] --> B{数组是否存满?}
    B -- 否 --> C[直接添加]
    B -- 是 --> D[扩容原数组 1.5 倍新数组]
    D --> E[拷贝原数据到新数组]
    E --> F[添加新元素]
    F --> B

集合和数组的使用选择小结

数组：存储的元素个数固定不变

集合：存储的元素个数经常发生改变

3. 创建集合

创建集合的两种方式

方案 1（不推荐）：不写泛型，添加数据时可以是任意类型，但取数据时容易出问题

ArrayList list = new ArrayList();
list.add(1);
list.add(12.3);
list.add('a');
list.add("abc");
list.add(false);

方案 2（推荐）：写泛型，限制集合中只能存储指定类型的元素

ArrayList<String> list = new ArrayList<>();
list.add(1);       // ❌ 编译报错，类型不匹配
list.add(12.3);    // ❌
list.add("abc");   // ✅

建议使用方案 2，创建集合的时候加入泛型可以使数据严谨和规范

创建集合小结

集合在创建的时候如果不加泛型，添加数据的时候可以是任意类型

建议创建的时候加入泛型，保证数据的严谨和规范

JDK7 版本开始，右侧 <> 中可以省略类型

// JDK7 前：右侧需要写泛型
ArrayList<String> list = new ArrayList<String>();

// JDK7+：右侧 <> 可省略（菱形语法）
ArrayList<String> list = new ArrayList<>();

4. ArrayList 常用成员方法

增删改查方法

方法名	说明
<span style="color:red">`public boolean add(E e)`</span>	<span style="color:orange">将指定的元素添加到此集合的<strong>末尾</strong></span>
<span style="color:red">`public void add(int index, E element)`</span>	<span style="color:orange">在此集合中的<strong>指定位置</strong>插入指定的元素</span>
<span style="color:red">`public E get(int index)`</span>	<span style="color:orange">返回指定索引处的元素</span>
<span style="color:red">`public int size()`</span>	<span style="color:orange">返回集合中的元素的个数</span>
<span style="color:red">`public E remove(int index)`</span>	<span style="color:orange">删除指定索引处的元素，<strong>返回被删除的元素</strong></span>
<span style="color:red">`public boolean remove(Object o)`</span>	<span style="color:orange">删除指定的元素，<strong>返回删除是否成功</strong></span>
<span style="color:red">`public E set(int index, E element)`</span>	<span style="color:orange">修改指定索引处的元素，<strong>返回被修改的元素</strong></span>

集合的遍历

ArrayList<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");

// 方式 1：普通 for
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

// 方式 2：增强 for（推荐）
for (String s : list) {
    System.out.println(s);
}

5. 集合练习

练习 1：集合存储字符串并遍历

需求：创建一个存储字符串的集合，内部存储 3 个字符串元素，使用程序实现在控制台遍历该集合

ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");

for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

练习 2：集合存储学生对象并遍历

需求：创建一个存储学生对象的集合，存储 3 个学生对象，使用程序实现在控制台遍历该集合学生的姓名和年龄来自于键盘录入

public class Student {
    private String name;
    private int age;
    
    public Student() { }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 省略 getter / setter
}

ArrayList<Student> list = new ArrayList<>();
Scanner sc = new Scanner(System.in);

for (int i = 0; i < 3; i++) {
    System.out.print("请输入姓名：");
    String name = sc.next();
    System.out.print("请输入年龄：");
    int age = sc.nextInt();
    
    Student stu = new Student(name, age);
    list.add(stu);
}

for (Student stu : list) {
    System.out.println(stu.getName() + "，" + stu.getAge());
}

集合存储对象内存图

以 addStudent(list) 三个学生对象为例，逐步展示栈内存和堆内存的变化

flowchart LR
    subgraph stack[栈内存]
        M[方法 main ArrayList list 001]
        A1[方法 addStudent name 张三 age 23 stu 00A]
        A2[方法 addStudent name 李四 age 24 stu 00B]
        A3[方法 addStudent name 王五 age 25 stu 00C]
    end
    subgraph heap[堆内存]
        L[new ArrayList 001 内部存 00A 00B 00C]
        O1[new Student 00A 张三 23]
        O2[new Student 00B 李四 24]
        O3[new Student 00C 王五 25]
    end
    M --> L
    A1 -.add 后.-> L
    A2 -.add 后.-> L
    A3 -.add 后.-> L
    L --> O1
    L --> O2
    L --> O3

关键结论：集合中存储的是对象的地址值，而非对象本身 由于 ArrayList 底层是数组，所以数组中存的是对象的地址引用

练习 3：集合删除元素

需求：创建一个存储 String 的集合，内部存储 (test, 张三, 李四, test, test) 字符串删除所有的 test 字符串，删除后，将集合剩余元素打印在控制台

ArrayList<String> list = new ArrayList<>();
list.add("test");
list.add("张三");
list.add("李四");
list.add("test");
list.add("test");

// 注意：不能一边遍历一边删除，会导致索引错乱
// 方案 1：倒着遍历
for (int i = list.size() - 1; i >= 0; i--) {
    if ("test".equals(list.get(i))) {
        list.remove(i);
    }
}

// 方案 2：使用迭代器（推荐）
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if ("test".equals(it.next())) {
        it.remove();   // 使用迭代器自己的 remove
    }
}

练习 4：集合元素筛选

需求：定义一个方法，方法接收一个集合对象（泛型为 Student），方法内部将年龄低于 18 的学生对象找出，并存入新集合对象，方法返回新集合

public static ArrayList<Student> filterStudents(ArrayList<Student> list) {
    ArrayList<Student> result = new ArrayList<>();
    for (Student s : list) {
        if (s.getAge() < 18) {
            result.add(s);
        }
    }
    return result;
}

注意：返回值必须是一个新的集合，不能修改原集合

集合小结

集合是一种长度可变的容器

开发中推荐使用方案 2（加泛型）创建集合，保证数据严谨

集合中存储的是对象的地址，不是对象本身

遍历集合常用普通 for（带索引）和增强 for

删除元素不能一边遍历一边删除，要倒着删或用迭代器

C 语言过渡 C++

Thu, 03 Sep 2026 00:00:00 GMT

C 语言过渡 C++

本笔记按"基础篇 → STL 篇 → 进阶篇 → C++11 篇"四部分整理，弥补 C 与 C++ 在语法、标准库、常用特性上的差异，作为刷题与竞赛入门的过渡资料。

一、基础篇

本节聚焦 C++ 相对 C 的核心语法变化：命名空间、IO 流、头文件、变量声明、bool、const、string、结构体、引用。

C++ 与 C 的核心差异速览

维度	C 语言	C++
输入输出	`scanf` / `printf`	`cin` / `cout`（流式）
头文件	`<stdio.h>`	`<iostream>`（去 `.h`、加 `c` 前缀）
变量声明	必须出现在语句块开头	任意位置（C++17 起更宽松）
布尔类型	用 `0/1` 模拟	原生 `bool`，值为 `true` / `false`
常量	`#define` / `enum`	`const` / `constexpr`
字符串	`char[]` + 字符串函数	原生 `string` 类
结构体	必须写 `struct stu a;`	可省略 `struct`，直接 `stu a;`
引用	无（只能传指针）	引用 `&`（语法糖，本质是指针）
函数默认值	无	支持参数默认值
函数重载	不支持	支持

命名空间 `using namespace std`

std 是 C++ 标准库的命名空间，cin / cout / string 等都在 std 里。

两种写法：

using namespace std; —— 一次性把 std 全部展开（偷懒，小项目/刷题常用）
std::cin / std::cout —— 每次显式指定（正式项目推荐，避免命名冲突）

#include <iostream>

using namespace std;

int main() {
    int n;
    cin >> n;
    cout << "wohaoshuai" << n << endl;

    return 0;
}

#include <iostream>

int main() {
    int n;
    std::cin >> n;
    std::cout << "wohaoshuai" << n << std::endl;

    return 0;
}

注意：endl 等价于 '\n' + flush()，频繁使用会降低 IO 性能。刷题数据量大时，可改为 '\n'。

cin 和 cout

运行速度

注意：cin / cout 默认会与 C 标准库 scanf / printf 同步，且绑定到 cin.tie(nullptr)，因此比 scanf / printf 慢。数据量大时建议关闭同步。

关闭同步提速（刷题常用）：

ios::sync_with_stdio(false);
cin.tie(nullptr);

使用方式：>> 读入、<< 输出、配合 endl 或 '\n' 换行。

头文件

C++ 标准库头文件去掉 .h，C 语言风格头文件加 c 前缀（stdio.h → cstdio），这样所有符号都在 std 命名空间里。

C 风格	C++ 风格
`<stdio.h>`	`<cstdio>`
`<string.h>`	`<cstring>`
`<math.h>`	`<cmath>`
`<stdlib.h>`	`<cstdlib>`
`<ctype.h>`	`<cctype>`

#include <cstring>
#include <cmath>

变量声明

C99 之后 C 语言也允许在 for 循环里定义循环变量，但 C++ 从一开始就支持——这在 C89 时代的 C 里是违法的。

#include <iostream>

int main() {
    for (int i = 0; i < 10; i++) {
        // 循环体，i 作用域仅限 for 块内
    }
    // 这里使用 i 会编译报错
    return 0;
}

bool 变量

bool 是 C++ 原生类型，只有两个值：true / false。任何非 0 值 隐式转换为 true，0 转换为 false。

#include <iostream>

using namespace std;

int main() {
    bool flag = true;
    bool flag2 = -1;
    bool flag3 = 0;

    cout << flag << " " << flag2 << " " << flag3 << " " << endl; // 1 1 0

    return 0;
}

注意：cout 输出 bool 会显示 0/1，想看 true/false 需 cout << boolalpha << flag;。

const 定义常量

const 比 #define 更安全（有类型、参与编译检查），比 enum 更通用（任何类型都可）。

#include <iostream>

using namespace std;

int main() {
    const int MAX = 100;

    cout << MAX << endl;

    return 0;
}

string 类

C++ 的 string 是对 char[] 的封装，自动管理内存，提供拼接、查找、截取等操作，比 C 的字符串函数安全得多。

#include <iostream>

using namespace std;

int main() {
    // 定义
    string s = "hello";
    string s2 = " world";

    // 拼接
    string s3 = s + s2;
    cout << s3 << endl; // hello world

    // 输入输出
    cin >> s;
    cout << s << endl;

    // getline, 让带有空格的输入能被读取
    getline(cin, s);


    // 处理
    // s.length() 获取字符串长度
    cout << s.length << endl;

    // s.substr(n, m) 从下标 n 开始，取 m 长度的字串
    cout << s3.substr(0, 2) << endl; // he

    return 0;
}

常用方法速览：

方法	功能
`s.length()` / `s.size()`	获取长度
`s1 + s2`	拼接
`s1 == s2`	比较
`s.substr(pos, len)`	截取子串
`s.find(str)`	查找子串位置，未找到返回 `string::npos`
`s.replace(pos, len, str)`	替换
`s.insert(pos, str)`	插入
`s.erase(pos, len)`	删除

注意：刷题时输入含空格的整行用 getline(cin, s)；cin >> s 遇到空格就停。

结构体

C++ 中可省略 struct 关键字直接使用类型名，结构体里也能写函数（与类几乎等价，区别在默认访问权限）。

#include <iostream>
using namespace std;

struct stu {
    string name;
    int age;
};

int main() {
    stu a[10]; // 省略 struct

    return 0;
}

引用 `&` 和取地址 `&`

C++ 的 & 和 C 语言的 & 是两个完全不同的符号：C++ 中 & 在类型后是引用声明（语法糖），在变量前是取地址。

用法	含义	示例
`int& r = a;`	声明引用（`r` 是 `a` 的别名）	函数参数传递、避免拷贝
`&a`	取变量 `a` 的地址	`int* p = &a;`
`a && b`	逻辑与（与 C 相同）	`if (a && b) {...}`

引用的本质：编译器内部实现为常量指针（int* const p = &a;），引用必须在声明时初始化、不能重新指向其他变量。

#include <iostream>
using namespace std;

// 形参为引用 → 函数内修改会反映到调用方
void c(int& a) {
    a++;
}

int main() {
    int a = 4;

    c(a);

    cout << a << endl; // 5

    return 0;
}

引用 vs 指针：引用更安全（无空引用、不可重绑），语法更简洁；指针更灵活（可空、可改、可算术）。优先用引用。

二、STL 篇

STL（Standard Template Library）是 C++ 的标准模板库，核心是容器 + 迭代器 + 算法。刷题 90% 的场景都依赖它。

容器分类总览

graph LR
  STL[STL 容器] --> SEQ[顺序容器]
  STL --> ASSOC[关联容器]
  STL --> UNORD[无序容器]

  SEQ --> V[vector]
  SEQ --> DEQ[deque]
  SEQ --> L[list]

  ASSOC --> S[set]
  ASSOC --> M[map]
  ASSOC --> MS[multiset]
  ASSOC --> MM[multimap]

  UNORD --> US[unordered_set]
  UNORD --> UM[unordered_map]

容器	底层	特点	时间复杂度
`vector`	动态数组	随机访问 O(1)，尾部插入 O(1)	随机访问最优
`deque`	分段数组	头尾插入 O(1)	双端队列
`list`	双向链表	任意位置插入 O(1)，无随机访问	频繁插入
`set` / `map`	红黑树	自动排序，查找 O(log n)	有序场景
`unordered_set` / `unordered_map`	哈希表	查找 O(1) 平均	不需排序的最快查找

vector

动态数组，默认容器，刷题首选。size() 动态变化，超出容量时自动 2 倍扩容。

#include <iostream>
#include <vector> // 头文件
using namespace std;

int main() {
    // 创建数组
    vector<int> a;            // 不分配空间
    vector<int> b(10);        // 分配 10 个空间，元素值默认为 0
    vector<int> c(10, 2);     // 分配 10 个空间，每个初始化为 2

    // 分配数组大小
    a.resize(10);

    // .size() 获取长度
    cout << a.size() << endl; // 10

    // 赋值
    for (int i = 0; i < a.size(); i++) {
        a[i] = i;
        cout << a[i] << " ";
    } // 0 1 2 3 4 5 6 7 8 9

    // 末尾添加新数据
    a.push_back(11);
    for (int i = 0; i < a.size(); i++) {
        cout << a[i] << " ";
    } // 0 1 2 3 4 5 6 7 8 9 11

    // 迭代器
    for (auto p = a.begin(); p != a.end(); p++) {
        cout << *p << " ";
    } // 0 1 2 3 4 5 6 7 8 9 11

    return 0;
}

常用方法：

方法	功能
`v.push_back(x)`	尾部插入
`v.pop_back()`	尾部删除
`v.size()` / `v.empty()`	长度 / 是否为空
`v.resize(n)`	调整大小
`v.clear()`	清空
`v.front()` / `v.back()`	访问首尾元素
`v.begin()` / `v.end()`	迭代器

set

set 是集合，元素互异且自动从小到大排序。底层是红黑树，插入/查找/删除都是 O(log n)。

#include <iostream>
#include <set> // 头文件
using namespace std;

int main() {
    // 创建集合
    set<int> s; // 和 vector 类似，因为集合元素互异，所以不能通过参数初始化

    // 插入
    s.insert(1);
    s.insert(2);
    s.insert(3);

    // 遍历——迭代器
    for (auto p = s.begin(); p != s.end(); p++) {
        cout << *p << " ";
    } // 1 2 3

    // 查找 s.find(data)，寻找 data 的地址，返回值是一个指针
    cout << (s.find(2) != s.end()) << endl; // 1 表示地址不同，已经找到
    cout << (s.find(4) != s.end()) << endl; // 0 地址指向数组后一位空间，没找到

    // 删除
    s.erase(1); // 删除元素 1
    cout << (s.find(1) != s.end()) << endl; // 0 未找到，1 已删除

    // 获取长度
    cout << s.size() << endl;
    return 0;
}

注意：s.erase(1) 中的 1 是值（会先查找再删除）；如果传迭代器 it，则删除该位置元素。

map（键值对）

map 是键值对集合，按键自动从小到大排序（multimap 允许键重复）。

#include <iostream>
#include <map> // 头文件
using namespace std;

int main() {
    // 创建键值对
    map<string, int> m;

    // 添加
    m["hello"] = 2;
    m["world"] = 3;

    cout << "hello : " << m["hello"] << endl; // hello : 2

    // 迭代器
    for (auto p = m.begin(); p != m.end(); p++) {
        cout << p->first << ":" << p->second << " ";
    }
    /*
        hello:2 world:3
    */

    // 获取长度
    cout << m.size() << endl;

    return 0;
}

注意：m["key"] 即使 key 不存在也会插入默认值，可能掩盖逻辑错误。判断存在性用 m.find(key) != m.end() 或 m.count(key) > 0。

pair（键值对简述）

pair<T1, T2> 把两个值绑在一起，常用于 map 的迭代器（p->first 是键，p->second 是值）。

pair<string, int> p = {"age", 18};
cout << p.first << "=" << p.second; // age=18

stack（栈）

stack 是后进先出（LIFO）的容器适配器，底层默认用 deque 实现。只允许访问栈顶。

#include <iostream>
#include <stack>
using namespace std;

int main() {
    stack<int> s;

    // 压栈
    s.push(1);
    s.push(2);
    s.push(3);

    // 访问栈顶
    cout << s.top() << endl; // 3

    // 出栈
    s.pop();
    cout << s.top() << endl; // 2

    // 获取长度
    cout << s.size() << endl; // 2

    // 是否为空
    cout << s.empty() << endl; // 0 (false)

    return 0;
}

常用方法：push（压栈）→ top（访问栈顶）→ pop（出栈）→ size / empty。

注意：pop 只删元素不返回值，必须先用 top() 拿到值再 pop()。

queue（队列）

queue 是先进先出（FIFO）的容器适配器。BFS、层次遍历、滑动窗口常用。

#include <iostream>
#include <queue>
using namespace std;

int main() {
    queue<int> q;

    // 入队
    q.push(1);
    q.push(2);
    q.push(3);

    // 访问队首
    cout << q.front() << endl; // 1

    // 访问队尾
    cout << q.back() << endl; // 3

    // 出队
    q.pop();
    cout << q.front() << endl; // 2

    // 获取长度
    cout << q.size() << endl; // 2

    return 0;
}

常用方法：push（入队）→ front（队首） / back（队尾）→ pop（出队）→ size / empty。

deque（双端队列）

头尾都能 O(1) 插入/删除，支持随机访问（dq[i]）。queue 和 stack 的功能它都覆盖，但常数略大。

#include <iostream>
#include <deque>
using namespace std;

int main() {
    deque<int> dq = {1, 2, 3};
    dq.push_front(0); // 头部插入
    dq.push_back(4);  // 尾部插入
    cout << dq[1];    // 1（随机访问）
    return 0;
}

unordered_map 和 unordered_set

这两个就是不会排序的 map（键值对）和 set（集合），底层是哈希表。如果刷题时 map / set 超时，换成它们通常能快一档。

#include <iostream>
#include <unordered_map>
using namespace std;

int main() {
    unordered_map<string, int> um;
    um["a"] = 1;
    um["b"] = 2;
    cout << um["a"]; // 1
    return 0;
}

注意：哈希表最坏复杂度 O(n)，且无序；如需有序遍历、有序集合，请用 map / set。

迭代器分类

类别	支持的操作	典型容器
输入迭代器	只读、`++`	`istream_iterator`
前向迭代器	读写、`++`	`forward_list`
双向迭代器	读写、`++` / `--`	`list` / `set` / `map`
随机访问迭代器	读写、`++` / `--` / `+n` / `-n` / `[]`	`vector` / `deque`

注意：STL 算法（sort、binary_search 等）依赖迭代器类别，sort 不能用于 list / set，这些容器自带排序或 list::sort()。

三、进阶篇

本节收录 bitset、sort、二分查找、字符处理等刷题常用工具。

位运算 bitset

bitset 类似一个固定长度的二进制位数组。位数在编译期必须确定（下标 b[0] 是低位，b[size-1] 是高位），所以直接输出整个 bitset 的方向与 b[i] 单个访问方向相反。

#include <iostream>
#include <bitset>
using namespace std;

int main() {
    // 初始化
    bitset<5> b;             // 5 表示 5 个二进制位，初始化为 0，00000
    bitset<5> c(3);          // 十进制转二进制，输出 c 的结果为 00011
    bitset<5> d("101");      // 填入字符串，长度不够高位补 0，输出 d 的结果为 00101
    string s = "01010011";
    bitset<5> e(s, 1, 5);    // 从字符串的索引 1 开始取 5 个字符 10100，输出 e 的结果为 10100
    bitset<6> f("10011", 1); // 从字符串的索引 0 开始取 1 个字符高位补零，输出 f 的结果为 000001

    cout << b << endl; // 00000
    cout << c << endl; // 00011
    cout << d << endl; // 00101
    cout << e << endl; // 10100
    cout << f << endl; // 00011

    // 遍历
    for (int i = 0; i < d.size(); i++) {
        cout << d[i] << " ";
    }

    // 处理
    cout << "是否有 1：" << d.any() << endl;
    cout << "是否不存在 1：" << d.none() << endl;
    cout << "1 的个数：" << d.count() << endl;
    cout << "d 中元素个数：" << d.size() << endl;
    cout << "下标为 i 的元素是不是 1：" << d.test(1) << endl;

    d.set(3); // 把下标为 i 处设置为 1

    // 归零
    b.reset();   // 所有位归零
    d.reset(2);  // 第 i 位归零

    // 取反
    d.flip();   // 所有位取反
    d.flip(2);  // 第 i 位取反

    // 转换类型
    cout << "转换为 unsigned long 类型：" << d.to_ulong() << endl;
    cout << "转换为 string 类型：" << d.to_string() << endl;

    return 0;
}

常用方法：

方法	功能
`b.any()` / `b.none()`	是否存在 / 不存在 1
`b.count()`	1 的个数
`b.set(i)` / `b.reset(i)`	置 1 / 置 0
`b.flip()`	按位取反
`b.test(i)`	第 i 位是否为 1
`b.to_ulong()` / `b.to_string()`	转 `unsigned long` / `string`

sort 函数

sort 对区间 [first, last) 进行排序，默认升序。vector 容器用 v.begin() 表示头、v.end() 表示尾；原生数组 int arr[] 用 arr 表示首地址、arr + n 表示尾。

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
    vector<int> m(10);
    for (int i = 0; i < m.size(); i++) {
        m[i] = i;
    }

    m.push_back(-1);
    // 排序
    sort(m.begin(), m.end());

    for (int i = 0; i < m.size(); i++)
        cout << m[i] << " "; // -1 0 1 2 3 4 5 6 7 8 9
    return 0;
}

使用 sort 自定义 cmp 函数

cmp(x, y) 返回 true 表示 x 排在 y 前面。返回值必须用严格 > 或 <，不能用 >= 或 <=（否则相等情况会导致排序不稳定 / 未定义行为）。

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

bool cmp(int x, int y) {
    return x > y; // 降序
}
int main() {
    vector<int> v;
    for (int i = 1; i <= 10; i++) {
        v.push_back(11 - i); // 10, 9, 8, ..., 1
    }

    for (auto p = v.begin(); p != v.end(); p++)
        cout << *p << " ";

    cout << endl;

    // 排序
    sort(v.begin(), v.end(), cmp); // 原理：返回值为真，x 放 y 前面；为假，x 放 y 后面

    for (auto p = v.begin(); p != v.end(); p++)
        cout << *p << " "; // 10 9 8 7 6 5 4 3 2 1
    return 0;
}

结构体多关键字排序：

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

struct stu {
    string name;
    int age;
};

bool cmp(stu a, stu b) {
    if (a.age != b.age) {
        return a.age < b.age; // 年龄小的在前
    } else {
        return a.name < b.name; // 同龄按名字字典序
    }
}

int main() {
    stu s[3];
    for (int i = 0; i < 3; i++) {
        cin >> s[i].name >> s[i].age;
    }
    sort(s, s + 3, cmp);
    for (int i = 0; i < 3; i++) {
        cout << s[i].name << " " << s[i].age << endl;
    }
    return 0;
}

stable_sort / partial_sort

函数	特点
`sort`	不保证相等元素原顺序（不稳定）
`stable_sort`	稳定排序（相等元素保持原顺序），略慢
`partial_sort(beg, mid, end)`	只排序到 `mid` 位置（取前 k 小），O(n log k)

二分查找 lower_bound / upper_bound

前提：区间已排序。返回值是迭代器（或指针），不是下标。

函数	含义
`lower_bound(beg, end, val)`	第一个 `>= val` 的位置
`upper_bound(beg, end, val)`	第一个 `> val` 的位置
`binary_search(beg, end, val)`	是否存在 `val`（返回 `bool`）

#include <algorithm>
vector<int> v = {1, 2, 2, 3, 4};
auto it = lower_bound(v.begin(), v.end(), 2); // 指向第一个 2
auto it2 = upper_bound(v.begin(), v.end(), 2); // 指向 3

cctype 头文件的函数

用于单个字符的判断与转换，常配合 string 遍历使用。

函数	功能
`isalpha(c)`	是否字母
`islower(c)` / `isupper(c)`	是否小写 / 大写字母
`isalnum(c)`	是否字母或数字
`isspace(c)`	是否空白（ / `\t` / `\r` / `\n`）
`isdigit(c)`	是否数字
`tolower(c)`	转换为小写字母
`toupper(c)`	转换为大写字母

四、C++11 篇

本节收录 C++11 起加入的现代语法：auto、范围 for、to_string、stoi / stod、lambda、智能指针、nullptr。auto、to_string、stoi、stof、unordered_map、unordered_set 都是 C++11 的标志性特性。

auto 声明

auto 让编译器根据初始值推断变量类型，代码更简洁，尤其配合长类型名（如迭代器）。

基础用法：

auto x = 100;     // int
auto y = 1.5;     // double
auto s = "hello"; // const char*

迭代器场景（C++11 之前要写很长）：

vector<int> v = {1, 2, 3};
// 之前：for (vector<int>::iterator it = v.begin(); it != v.end(); ++it)
for (auto it = v.begin(); it != v.end(); ++it) cout << *it;

注意：auto 会丢掉顶层 const 和引用。如果想保留，用 const auto&（遍历时避免拷贝）。

基于范围的 for 循环

直接遍历容器或数组的每个元素，不需要下标。

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    vector<int> v = {1, 2, 3, 4, 5};

    // 输出数组中的每一个元素的值（不能改变元素的数值）
    for (int i : a) cout << i << " ";

    cout << endl;

    // 将数组中每一个元素都乘以 2，只有在引用的时候才能改变元素的值
    for (int& i : a)
        i *= 2;

    // 所有的容器，配合 auto，都可以使用这种方式来循环
    for (auto i : v) cout << i << " ";

    return 0;
}

注意：默认是拷贝遍历，原容器不变；要修改元素必须用 auto& / int& 引用。

to_string

将数字转换为字符串，常用于拼接输出。

头文件：#include <string>

#include <iostream>
#include <string>
using namespace std;

int main() {
    string s = to_string(123);
    string s2 = to_string(3.14);

    cout << s << endl;  // 123
    cout << s2 << endl; // 3.140000
    return 0;
}

stoi 和 stod

函数	功能
`stoi(s)`	字符串 → `int`
`stol(s)` / `stoll(s)`	字符串 → `long` / `long long`
`stoul(s)` / `stoull(s)`	字符串 → `unsigned long` / `unsigned long long`
`stof(s)`	字符串 → `float`
`stod(s)`	字符串 → `double`
`stold(s)`	字符串 → `long double`

#include <iostream>
#include <string>
using namespace std;

int main() {
    int a = stoi("123");
    double b = stod("123.34");

    cout << a - 1 << endl;  // 122
    cout << b - 1 << endl;  // 122.34
    return 0;
}

注意：字符串非数字前缀会抛 std::invalid_argument 异常；数字越界抛 std::out_of_range。

lambda 表达式

lambda 是匿名函数，可内联写在调用处，常用于 sort / for_each 等需要传函数对象的场景。

语法：[捕获列表](参数) -> 返回值 { 函数体 }

#include <algorithm>
#include <vector>
using namespace std;

int main() {
    vector<int> v = {3, 1, 4, 1, 5, 9, 2, 6};
    // 降序排序：lambda 替代独立 cmp 函数
    sort(v.begin(), v.end(), [](int a, int b) { return a > b; });
    return 0;
}

常用捕获：

写法	含义
`[]`	不捕获任何变量
`[=]`	按值捕获所有外部变量
`[&]`	按引用捕获所有外部变量
`[x, &y]`	`x` 按值、`y` 按引用

智能指针（简述）

补充知识：C++11 起标准库提供自动管理堆内存的智能指针，避免 new / delete 配对失误导致内存泄漏。

智能指针	特点
`unique_ptr<T>`	独占所有权，不可复制，只能 `move`
`shared_ptr<T>`	共享所有权，引用计数，最后一个销毁时释放
`weak_ptr<T>`	不增加引用计数，配合 `shared_ptr` 解决循环引用

#include <memory>
unique_ptr<int> p = make_unique<int>(10);
shared_ptr<int> sp = make_shared<int>(20);

nullptr

nullptr 是 C++11 引入的空指针常量，类型严格为 std::nullptr_t，替代 C 风格的 NULL（NULL 实际是 0，会和整数重载冲突）。

int* p = nullptr;  // 推荐
int* q = NULL;     // 不推荐，NULL == 0

知识小结

要点	说明	重要度
<span style="color:blue">命名空间</span>	`using namespace std;` 仅刷题用，项目慎用	★★★
<span style="color:blue">cin/cout 提速</span>	`ios::sync_with_stdio(false); cin.tie(nullptr);`	★★★★
头文件	C 风格去 `.h` 加 `c` 前缀	★★★
<span style="color:blue">bool</span>	原生类型，非 0 即 `true`	★★
<span style="color:blue">string</span>	自动管理内存，含 `substr` / `find` / `length`	★★★★
结构体	C++ 可省略 `struct` 关键字	★★
<span style="color:red">引用 `&` vs 取地址 `&`</span>	类型后是引用，变量前是取地址	★★★★★
<span style="color:blue">vector</span>	顺序容器首选，随机访问 O(1)	★★★★★
<span style="color:blue">set / map</span>	有序容器，红黑树，O(log n)	★★★★★
<span style="color:blue">stack / queue</span>	容器适配器，仅暴露受限接口	★★★★
<span style="color:blue">unordered_map / set</span>	哈希表，平均 O(1)，最坏 O(n)	★★★★
迭代器	`begin()` / `end()` 是半开区间 `[begin, end)`	★★★★
<span style="color:blue">bitset</span>	编译期定长位数组，索引 0 是低位	★★★
<span style="color:red">sort 的 cmp</span>	必须用严格 `>` / `<`，不能用 `>=` / `<=`	★★★★★
<span style="color:blue">auto</span>	推断类型，丢掉 `const` / 引用	★★★★
范围 for	`for (auto& x : v)` 修改、`auto x` 拷贝	★★★★
<span style="color:blue">stoi / stod</span>	字符串转数字，越界抛异常	★★★
lambda	`[捕获](参数){...}`，常作 `sort` 第三参数	★★★
<span style="color:green">nullptr</span>	替代 `NULL`，类型安全	★★★

补充整型的选择

🧮 C++ 整型速查表（刷题专用）

类型	字节	二进制范围	十进制约等于	适用情况
`int`	4	$-2^{31}$ ~ $2^{31}-1$	≈ ±2.147×10⁹	单值 ≤ 2×10⁹
`unsigned int`	4	$0$ ~ $2^{32}-1$	≈ 0 ~ 4.29×10⁹	只用正数且 ≤ 4e9
`long long`	8	$-2^{63}$ ~ $2^{63}-1$	≈ ±9.22×10¹⁸	单值 ≤ 9×10¹⁸
`unsigned long long`	8	$0$ ~ $2^{64}-1$	≈ 1.84×10¹⁹	超大正数（极少用）

🔑 常见次方对照

幂次	十进制近似	对应类型上限
$10^9$	1,000,000,000	< int max
$10^{18}$	1,000,000,000,000,000,000	< long long max
$2^{31}$	2,147,483,648	比 int max 大 1 → 用 long long
$2^{31}-1$	2,147,483,647	int 最大值
$2^{63}$	9,223,372,036,854,775,808	比 long long max 大 1 → 用 unsigned long long
$2^{63}-1$	9,223,372,036,854,775,807	long long 最大值

⚠️ 避坑规则（必看）

单值：看到 $10^9$ → int；看到 $10^{18}$ → long long。
求和：若数组长度 × 单值上限 > 当前类型范围，总和变量要升一级。
乘法中间值：int a=1e6, b=1e6; long long c = 1LL * a * b; —— 乘 1LL 强制提升。
不确定时：一律用 long long（除非二维数组过大，内存不够才精细算）。
不要用 long：不同平台长度不一（Windows 4 字节，Linux 8 字节），刷题统一用 int 和 long long。

C++ 常用头文件

Thu, 03 Sep 2026 00:00:00 GMT

C++常用头文件

本节按头文件分组整理算法竞赛常用 API：cmath 负责数学函数，algorithm 负责通用算法（排序、查找、堆），numeric 负责数值算法（累加、GCD、扫描）。三者搭配 STL 容器，覆盖刷题 90% 的场景。

cmath

<cmath> 是 C 标准数学库的 C++ 包装，所有函数都在 std 命名空间下，参数和返回值多为 double。刷题时最常用的是取整、幂运算、浮点处理三类。

常用函数速览

函数	功能	备注
`abs(x)`	整数绝对值	实际定义在 `<cstdlib>`，C++11 起 `<cmath>` 也支持
`fabs(x)`	浮点绝对值	等价于 `abs(double)`
`sqrt(x)`	平方根	比 `pow(x, 0.5)` 更快、更准
`cbrt(x)`	立方根	C++11 起
`pow(x, y)`	`x^y`	整数次方不要用它，会引入浮点误差
`exp(x)`	`e^x`
`log(x)`	自然对数	底为 `e`
`log10(x)`	常用对数	底为 10
`log2(x)`	底为 2 的对数	C++11 起
`hypot(x, y)`	`sqrt(x² + y²)`	防数值溢出专用，见下
`max(a, b)` / `min(a, b)`	两值最大/最小	也可处理 `initializer_list`（C++11）
`fmax(a, b)` / `fmin(a, b)`	浮点版 max/min	处理 NaN 行为不同

三角函数

函数	功能
`sin` / `cos` / `tan`	正弦 / 余弦 / 正切（弧度）
`asin` / `acos` / `atan`	反正弦 / 反余弦 / 反正切
`sinh` / `cosh` / `tanh`	双曲正弦 / 余弦 / 正切
`atan2(y, x)`	二参数反正切，能区分象限（比 `atan(y/x)` 安全）

常用常量：

常量	值
`M_PI`	圆周率 π
`M_E`	自然常数 e
`M_SQRT2`	√2

注意：M_PI 不是 C++ 标准的一部分，GCC/Clang 默认开启，MSVC 需定义 _USE_MATH_DEFINES 后 include <cmath>。严谨做法是自己定义：const double PI = acos(-1.0);

取整函数

函数	功能	示例（`x = 2.7`）	示例（`x = -2.7`）
`ceil(x)`	向上取整	`3`	`-2`
`floor(x)`	向下取整	`2`	`-3`
`round(x)`	四舍五入（远离 0）	`3`	`-3`
`trunc(x)`	截断小数部分	`2`	`-2`
`fmod(x, y)`	浮点取模（结果符号同 `x`）	—	—

#include <cmath>
#include <iostream>
using namespace std;

int main() {
    cout << ceil(2.7) << " " << floor(2.7) << " " << round(2.7) << endl;       // 3 2 3
    cout << ceil(-2.7) << " " << floor(-2.7) << " " << round(-2.7) << endl;     // -2 -3 -3
    return 0;
}

⚠ 警告：负数取整的方向常与直觉相反，floor(-2.7) = -3（向更小的整数），刷题务必测试。

幂运算与整数次方

⚠ 警告：pow(2, 10) 看似能算 2^10，但内部用浮点实现，结果可能因精度损失而不准（如 pow(10, 2) = 99.9999...）。整数次方用快速幂（手写）或 1LL << n（仅限 2 的幂）。

// 整数快速幂：a^n mod mod（比赛最常用）
long long qpow(long long a, long long n, long long mod) {
    long long res = 1;
    a %= mod;
    while (n > 0) {
        if (n & 1) res = res * a % mod;
        a = a * a % mod;
        n >>= 1;
    }
    return res;
}

浮点处理技巧

1. 浮点比较：== 比较浮点几乎一定出错，必须用容差：

#include <cmath>
const double EPS = 1e-9;
bool eq(double a, double b) { return fabs(a - b) < EPS; }
bool lt(double a, double b) { return a < b - EPS; }
bool le(double a, double b) { return a < b + EPS; }

2. 防止 sqrt(x² + y²) 溢出：

// 错误：x、y 很大时 x*x 先溢出
double len = sqrt(x * x + y * y);

// 正确：hypot 内部做缩放
double len = hypot(x, y);

3. INF / NaN：

double inf = numeric_limits<double>::infinity();
double nan = numeric_limits<double>::quiet_NaN();

关键注意点

易错点	说明
<span style="color:red">整数次方用 `pow`</span>	浮点精度坑，改用快速幂
三角函数单位是弧度	转角度：`rad * PI / 180`
负数 `floor` / `ceil`	方向与直觉相反
`M_PI`	非标准常量，MSVC 需宏定义
浮点 `==`	必带 EPS 容差
`sqrt(xx + yy)`	大数时改用 `hypot(x, y)`

algorithm

<algorithm> 是 STL 算法层的核心头文件，提供排序、查找、变换、堆等通用算法。所有算法通过迭代器操作容器，与具体容器解耦。

取最值

函数	范围	返回值
`min(a, b)` / `max(a, b)`	两个值	较小/较大的值
`min({a, b, c})` / `max({...})`	多个值（C++11 initializer_list）	同上
`min_element(begin, end)`	区间	迭代器，需 `*` 解引用
`max_element(begin, end)`	区间	迭代器，需 `*` 解引用
`minmax(a, b)`	两个值	`pair<较小值, 较大值>`
`minmax_element(begin, end)`	区间	`pair<最小迭代器, 最大迭代器>`
`clamp(v, lo, hi)`	单值（C++17）	钳制到 `[lo, hi]`

#include <algorithm>
using namespace std;

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

// 容器里的最大值（迭代器要 * 解引用）
auto it = max_element(v.begin(), v.end());
cout << *it;            // 9
cout << it - v.begin(); // 4（下标）

// 三个数
cout << max({1, 5, 3}); // 5

// 钳制
cout << clamp(15, 0, 10); // 10

排序

函数	特点
`sort(begin, end)`	快速排序（实际 introsort），O(n log n)，不稳定
`stable_sort(begin, end)`	稳定排序，相等元素保持原顺序
`partial_sort(begin, mid, end)`	排序到 `mid`，取前 k 小 O(n log k)
`nth_element(begin, nth, end)`	第 `nth` 位置就位（前 k 小，不保证其余顺序）
`is_sorted(begin, end)`	是否已排序（O(n)）

vector<int> v = {3, 1, 4, 1, 5};
sort(v.begin(), v.end());                      // 1 1 3 4 5
partial_sort(v.begin(), v.begin() + 2, v.end());// 前 2 小排到头部

注意：sort 的 cmp(x, y) 返回 true 表示 x 排前；必须用严格 > / <，不能 >= / <=。

查找

函数	前提	返回值
`find(begin, end, val)`	无	第一个等于 `val` 的迭代器
`find_if(begin, end, pred)`	无	第一个满足 `pred` 的迭代器
`count(begin, end, val)`	无	等于 `val` 的元素个数
`count_if(begin, end, pred)`	无	满足 `pred` 的元素个数
`binary_search(begin, end, val)`	已排序	`bool`：是否存在
`lower_bound(begin, end, val)`	已排序	第一个 `>= val` 的迭代器
`upper_bound(begin, end, val)`	已排序	第一个 `> val` 的迭代器
`equal_range(begin, end, val)`	已排序	`[lower, upper)` 的 `pair`

vector<int> v = {1, 2, 2, 3, 4};
auto lo = lower_bound(v.begin(), v.end(), 2); // 指向第一个 2
auto hi = upper_bound(v.begin(), v.end(), 2); // 指向 3
cout << hi - lo; // 2（2 出现了 2 次）

修改 / 变换

函数	功能
`reverse(begin, end)`	翻转
`rotate(begin, mid, end)`	旋转（`mid` 移到开头）
`shuffle(begin, end, rng)`	随机打乱（C++11，需 `<random>` 引擎）
`next_permutation(begin, end)`	下一个排列，到末尾返回 `false`
`prev_permutation(begin, end)`	上一个排列
`fill(begin, end, val)`	填充
`replace(begin, end, old, new)`	替换
`unique(begin, end)`	相邻去重（需先 `sort`）
`swap(a, b)` / `iter_swap(it1, it2)`	交换

注意：unique 只删相邻重复，所以通常先 sort 再 unique。返回值是新结尾迭代器：v.erase(it, v.end())。

vector<int> v = {1, 2, 2, 3, 2, 4};
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end()); // 1 2 3 4

集合算法（已排序区间）

输入区间必须有序，结果区间可与输入重叠。

函数	含义
`merge(a, b, out)`	归并两个有序区间到 `out`
`set_union(a, b, out)`	并集
`set_intersection(a, b, out)`	交集
`set_difference(a, b, out)`	差集（在 a 不在 b）
`set_symmetric_difference(a, b, out)`	对称差
`includes(a, b)`	b 是否是 a 的子集

堆（priority_queue 替代品）

priority_queue 内部用堆，但只暴露受限接口。如需在任意位置操作堆，用 algorithm 提供的 4 个函数。

函数	功能
`make_heap(begin, end)`	把区间建成大根堆（默认 `less`，最大元素在 `begin`）
`push_heap(begin, end)`	假设 `end-1` 是新元素，上浮调整
`pop_heap(begin, end)`	把堆顶移到 `end-1`，下沉调整
`sort_heap(begin, end)`	堆排序（区间先 make_heap）
`is_heap(begin, end)`	是否是堆

vector<int> v = {3, 1, 4, 1, 5, 9, 2, 6};
make_heap(v.begin(), v.end()); // 大根堆：9 在 v[0]
pop_heap(v.begin(), v.end()); // 9 移到末尾
cout << v.back();              // 9
v.pop_back();                  // 真正删除

注意：默认是大根堆（less），想要小根堆传 greater<int>{}：make_heap(v.begin(), v.end(), greater<int>());

其他常用

函数	功能
`for_each(begin, end, f)`	对每个元素执行 `f`（C++17 起可返回）
`transform(a, b, out, f)`	把 `f` 应用到元素，写到 `out`
`any_of` / `all_of` / `none_of`	谓词判断（任一/全部/无）
`equal(a, b)` / `equal(a, b, pred)`	两区间是否相等
`lexicographical_compare`	字典序比较
`partition` / `stable_partition`	按谓词分两段

numeric

<numeric> 提供针对数值的算法：累加、内积、扫描、序列生成、最大公约数等。accumulate 是刷题出现频率最高的之一。

累加 / 归约

函数	功能
`accumulate(begin, end, init)`	累加 + 初始值（可自定义二元运算）
`accumulate(begin, end, init, op)`	自定义运算（如 `multiplies` 求积）
`reduce(begin, end, init)`	类似但无序（C++17，并行友好）
`inner_product(a, b, init)`	两区间内积 + 初始值
`transform_reduce`	`transform` + `reduce` 组合（C++17）

#include <numeric>
vector<int> v = {1, 2, 3, 4, 5};

int sum = accumulate(v.begin(), v.end(), 0);          // 15
int prod = accumulate(v.begin(), v.end(), 1, multiplies<int>()); // 120
// 字符串拼接（init 给空串）
string s = accumulate(v.begin(), v.end(), string(""),
                      [](string a, int x) { return a + to_string(x); });
// "12345"

注意：accumulate 的初始值是累加的起点（不是数组里的元素），整数累加请写 0LL 避免溢出。

扫描（部分和 / 相邻差）

函数	功能
`partial_sum(begin, end, out)`	前缀和（含当前项）
`inclusive_scan`	C++17，等价 `partial_sum`
`exclusive_scan(begin, end, out, init)`	前缀和（不含当前项，从 `init` 开始）
`adjacent_difference(begin, end, out)`	相邻元素差（首元素不变）

vector<int> v = {1, 2, 3, 4, 5};
vector<int> pre(5), diff(5);
partial_sum(v.begin(), v.end(), pre.begin());        // 1 3 6 10 15
adjacent_difference(v.begin(), v.end(), diff.begin());// 1 1 1 1 1

序列生成

函数	功能
`iota(begin, end, val)`	从 `val` 开始递增填充：`v[i] = val + i`

vector<int> v(5);
iota(v.begin(), v.end(), 10); // 10 11 12 13 14

GCD / LCM（C++17）

函数	功能
`gcd(a, b)`	最大公约数（C++17）
`lcm(a, b)`	最小公倍数（C++17）
`midpoint(a, b)`	两数中点（避免 `(a+b)/2` 溢出，C++20）

cout << gcd(12, 18); // 6
cout << lcm(4, 6);   // 12

// 安全的 a+b/2
long long mid = midpoint(1LL, 1e18);

注意：C++17 之前的 __gcd 是 GCC 扩展；严谨代码自己写欧几里得：
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }

随机数（`<random>` 配合使用）

<random> 虽不在 <numeric> 里，但常一起用。告别 rand()——rand() 范围小、质量差、且依赖实现。

#include <random>
#include <ctime>
mt19937 rng(time(nullptr));                        // 32 位引擎
mt19937_64 rng64(chrono::steady_clock::now().time_since_epoch().count()); // 64 位

// 范围 [lo, hi] 均匀整数
uniform_int_distribution<int> dist(1, 100);
int x = dist(rng);

// 范围 [0, 1) 均匀浮点
uniform_real_distribution<double> fdist(0.0, 1.0);
double y = fdist(rng);

// 容器洗牌
shuffle(v.begin(), v.end(), rng);

引擎	位数	用途
`mt19937`	32	通用、够用
`mt19937_64`	64	大范围 ID、需要 64 位
`default_random_engine`	视实现	不推荐（质量参差）

关键注意点

易错点	说明
<span style="color:red">`accumulate` 初始值用 `0`</span>	大数累加用 `0LL` 防溢出
`partial_sum` 含当前项	想要"前 i-1 项和"用 `exclusive_scan`
`iota` 不检查越界	区间要先 `resize`
`gcd` / `lcm`	C++17 起，旧编译器用 `__gcd` 或手写
`rand()`	范围小、质量差，统一换 `mt19937`
`shuffle` 需要引擎	传 `mt19937`，不能传 `time(nullptr)`

iomanip

<iomanip> 提供格式化输出的"操控器"（manipulator），用来控制 cout 的宽度、精度、对齐、进制等。默认状态不会持久化——除了 fixed / scientific / boolalpha 等"标志型"，像 setw 这种只对下一次输出生效。

精度与浮点格式

操控器	作用	备注
`setprecision(n)`	设置精度（有效数字位数）	默认模式
`setprecision(n)` + `fixed`	设置小数位数	刷题最常考
`setprecision(n)` + `scientific`	设置科学计数法的小数位数
`defaultfloat`	还原默认（C++11）	退出 `fixed` 模式
`showpoint` / `noshowpoint`	强制 / 不强制显示小数点

#include <iostream>
#include <iomanip>
using namespace std;

int main() {
    double pi = 3.14159265358979;

    cout << setprecision(4) << pi << endl;         // 3.142（4 位有效数字）
    cout << fixed << setprecision(2) << pi << endl; // 3.14（保留 2 位小数）
    cout << defaultfloat << setprecision(6) << pi; // 3.14159

    // 默认 cout 输出 1.0 会显示 1，showpoint 强制显示 1.00000
    cout << fixed << setprecision(2);
    cout << 1.0 << endl; // 1.00
    return 0;
}

注意：fixed / scientific 是持久的，影响后续所有浮点输出；用完想还原要 cout << defaultfloat;（C++11）。

宽度与填充

操控器	作用	备注
`setw(n)`	设置下一次输出的最小宽度	只生效一次
`setfill(c)`	设置填充字符（默认空格）	持久
`left` / `right`	左对齐 / 右对齐（默认 right）	持久
`internal`	符号左对齐、数值右对齐（如 `- 123`）	持久

#include <iostream>
#include <iomanip>
using namespace std;

int main() {
    // 题目要求：输出 4 位整数，不足补 0（如 1 → 0001）
    cout << setfill('0');
    for (int i = 1; i <= 5; i++) {
        cout << setw(4) << i << endl;
    }
    // 0001
    // 0002
    // 0003
    // 0004
    // 0005

    // 对齐：左对齐 + 宽度 10，填充 *
    cout << setfill('*') << left << setw(10) << "hi" << "end" << endl;
    // hi********end
    return 0;
}

⚠ 警告：setw 只对下一次输出生效！多个字段都要设宽度时，必须每次都写 setw。

进制与布尔

操控器	作用
`hex` / `dec` / `oct`	十六进制 / 十进制 / 八进制（持久）
`setbase(n)`	进制（只接受 8/10/16，其余按 10 处理）
`showbase` / `noshowbase`	显示 / 不显示进制前缀（`0x` / `0`）
`uppercase` / `nouppercase`	十六进制字母大写 / 小写
`boolalpha` / `noboolalpha`	bool 输出 `true` / `false` 还是 `1` / `0`

cout << hex << 255;              // ff
cout << showbase << hex << 255;  // 0xff
cout << uppercase << hex << 255; // 0XFF

bool flag = true;
cout << flag;                    // 1
cout << boolalpha << flag;       // true

输入侧操控器

操控器	作用
`ws`	跳过前导空白字符（常用于 `getline` 前清空残留换行）
`get_money(m)` / `put_money(m)`	货币格式（C++11，少用）
`get_time(t, fmt)` / `put_time(t, fmt)`	时间格式（C++11，少用）

int n;
string s;
cin >> n;
// >> 之后缓冲区留有 '\n'，getline 会读空串
cin.ignore(numeric_limits<streamsize>::max(), '\n');
getline(cin, s);

注意：刷题最常见的坑是 cin >> n 后接 getline(cin, s) 读到空串，必须 cin.ignore 清除残留换行。

关键注意点

易错点	说明
<span style="color:red">`setw` 只生效一次</span>	多个字段必须每次都写
`setprecision` 默认是有效数字	想保留 n 位小数要加 `fixed`
`fixed` 持久生效	用完记得 `defaultfloat` 还原
`cout << bool` 输出 `0/1`	想看 `true/false` 需 `boolalpha`
`hex` 也持久	想回十进制要 `dec`
`cin >> n` + `getline`	记得 `cin.ignore()` 清残留换行

<climits>

极限宏

宏名称	对应类型	值（十进制）	用途
`INT_MAX`	`int`	2,147,483,647	int 最大值
`INT_MIN`	`int`	-2,147,483,648	int 最小值
`LLONG_MAX`	`long long`	9,223,372,036,854,775,807	long long 最大值
`LLONG_MIN`	`long long`	-9,223,372,036,854,775,808	long long 最小值
`ULLONG_MAX`	`unsigned long long`	18,446,744,073,709,551,615	unsigned long long 最大值
`LONG_MAX`	`long`	Windows: 2,147,483,647<br>Linux: 9,223,372,036,854,775,807	长度随平台，刷题不推荐
`LONG_MIN`	`long`	Windows: -2,147,483,648<br>Linux: -9,223,372,036,854,775,808	同上

整型字面量后缀（无需头文件）

后缀	类型	示例	用途
无后缀	`int`	`123`	默认整型
`L`	`long`	`123L`	不推荐（平台相关）
`LL`	`long long`	`123LL`	明确 64 位有符号
`ULL`	`unsigned long long`	`123ULL`	明确 64 位无符号
`u`	`unsigned int`	`123u`	无符号 int
`f`	`float`	`3.14f`	单精度浮点

⚠️ 刷题最常用：1LL * a * b 防止乘法溢出。

Git 与 GitHub

Fri, 28 Aug 2026 00:00:00 GMT

Git 与 GitHub

本笔记涵盖 Git 版本控制与 GitHub 协作平台的核心概念、常用命令、多人协作流程及高级特性。 参考链接
【Git+Github核心概念大串讲，从零到一全攻略，详细实战教程】 https://www.bilibili.com/video/BV1ySLc6QEcB/?share_source=copy_web&vd_source=9d34ca7f21db859ee3f136b49b89515d

一、Git 与 GitHub 概述

本节介绍版本控制、Git 与 GitHub 的基本概念和分区模型。

Git 分区概念

Git 的数据流转分为四个核心区域：

flowchart LR
  A[<b>工作区</b> Working Directory] -->|git add| B[<b>暂存区</b> Staging Area]
  B -->|git commit| C[<b>本地仓库</b> Local Repository]
  C -->|git push| D[<b>远程仓库</b> Remote Repository]
  D -->|git pull| A

分区	说明
<span style="color:blue">工作区</span> (Working Directory)	本地可见的普通文件目录，用户直接编辑修改文件的地方
<span style="color:blue">暂存区</span> (Staging / Index)	通过 `git add` 命令将工作区变更暂存的中转区域
<span style="color:blue">本地仓库</span> (Local Repository)	通过 `git commit` 将暂存区内容永久存储的版本库
<span style="color:blue">远程仓库</span> (Remote Repository)	通过 `git push` 同步到服务器的共享版本库

核心命令

git clone   <url>      # 克隆远程仓库到本地
git add     <file>     # 将工作区变更添加到暂存区
git commit  -m "msg"  # 将暂存区变更提交到本地仓库
git push               # 将本地仓库变更推送到远程仓库
git pull               # 拉取远程仓库最新变更
git merge   <branch>   # 合并分支变更
git fetch              # 获取远程仓库最新信息

Git 是什么

Git 是开源免费的 分布式版本控制系统，用 commit 记录每次完整快照。

典型应用场景：管理论⽂修改版本（第⼀版、第⼆版、定稿版等）、协同开发⼤型项⽬（处理成千上万⽂件）。

核⼼优势：解决纯⼈⼯版本控制的复杂性，⽀持多⼈协同开发。

仓库管理：被 Git 管理的⽂件夹会⽣成 .git ⼦⽂件夹，使⽤ commit 作为版本控制基本单元，每次 commit 保存仓库完整快照，形成可回溯的 commit 历史链路。

仓库类型：本地仓库运⾏在开发者个⼈电脑上，远程仓库是服务器上的备份仓库⽤于代码分享，可⾃⾏搭建或使⽤ GitHub 等托管服务。

GitHub 是什么

GitHub = Git + Hub，是全球最⼤的 代码托管与协作平台。

名称解析：Git 指版本控制系统，Hub 意为中⼼ / 集合。

核⼼功能：存储和分享 Git 仓库，⽀持多⼈协作开发。

仓库类型：公开仓库可被搜索、浏览和学习（示例：Linux 内核、CPython 解释器、Nginx），私有仓库仅限指定⼈员访问。同类服务还包括 GitLab、BitBucket 等，开源是计算机科学的基⽯与瑰宝。

二、环境准备与配置

本节介绍 Git、VS Code、GitHub 账号的安装与 AI Agent 的接入方法。

Git 安装

Windows 安装

# 推荐使用 winget 安装
winget install --id Git.Git -e --source winget
# 或访问 https://git-scm.com 下载安装包

访问 Git 官⽹下载 Windows 安装包，选择对应 CPU 架构（通常为 x86），运⾏安装程序并默认设置完成安装。

Mac 安装

xcode-select --install   # 同意安装命令⾏⼯具包（包含 Git）
git --version            # 验证安装

VS Code 安装

访问 VS Code 官⽹下载对应操作系统版本：Windows 系统直接运⾏安装程序，Mac 系统拖拽到 Applications ⽂件夹。验证命令 code --version。

GitHub 账号注册

注册流程：访问 GitHub 官⽹点击 Sign up → 填写⽤户名、邮箱和密码 → 验证邮箱收取验证码。

注意：国内⽤户可能需要特殊⽹络设置；建议使⽤常⽤邮箱注册；记住账号密码⽤于后续 Git 操作。

配置 AI Agent

配置步骤：在 GitHub 创建新仓库 → 复制仓库地址备⽤ → 使⽤ Codex 初始化本地项⽬ → 将本地项⽬与远程仓库关联。关键操作：通过 AI 辅助完成 Git 配置，需要授权 GitHub 账户访问，确保⽹络连接稳定。

环境验证

git --version    # Git 版本
code --version   # VS Code 运⾏状态
# GitHub 账号登录状态、 AI Agent 连接情况

常见问题：⽹络连接问题、权限配置错误、环境变量未设置。

三、Git 本地基础操作

本节介绍仓库初始化、.gitignore 配置、提交、后悔药和分支等本地操作。

初始化仓库

git init 命令将⼀个普通⽂件夹转变为 Git 管理的仓库。

cd my-project
git init
# 此时会⽣成隐藏的 .git ⼦⽂件夹

操作步骤：在 VS Code 中选择 Open Folder 打开任意⽂件夹（空或⾮空）→ 找到左侧 Source Control ⾯板 → 点击 Initialize Repository 按钮完成初始化。初始化成功后，⽂件夹内会⽣成隐藏的 .git ⼦⽂件夹，存储所有 Git 相关数据。

删除 此⽂件夹将取消 Git 管理。

`.gitignore` 配置

.gitignore ⽂件⽤于声明仓库中 不应被 Git 管理 的⽂件/⽬录。

典型应⽤场景：存储密钥的 .env ⽂件（安全考虑）、Node.js 项⽬的 node_modules/ ⽬录（可通过 npm install 重新⽣成）。

配置⽅法：在仓库根⽬录创建 .gitignore ⽂件，每⾏写⼊⼀个略规则（⽬录需加斜杠，如 node_modules/）。

最佳实践：项⽬初始化时就应创建 .gitignore，避免误提交敏感或不必要⽂件。

提交 (commit)

commit 意为提交，每次提交保存仓库状态的完整快照，形成可回溯的历史链路。操作流程：创建/修改⽂件（如 fruits.txt）→ 在 Source Control ⾯板查看待提交⽂件→ 填写有意义的 commit message（说明本次修改内容）→ 点击 commit 按钮完成提交。

AI 协作技巧：让 AI 完成⼩功能点后⽴即提交，便于版本控制。

Git 后悔药

后悔药三件套：discard（未提交）→ reset（已提交未推送）→ revert（已推送）

flowchart TD
  A{需要回退?} -->|未提交| B["discard 丢弃工作区改动"]
  A -->|已提交| C{推送到远端?}
  C -->|未推送| D["reset 强制回退历史"]
  C -->|已推送| E["revert 生成反向提交"]

操作	适用场景	操作方法	风险
`discard`	未提交的更改	VS Code 点击 `Discard Changes` 按钮	<span style="color:green">低</span>：仅影响工作区
`reset`	已提交未推送	命令行 `git reset <commit>`	<span style="color:red">高</span>：重写历史
`revert`	已推送	命令行 `git revert <commit>`	<span style="color:green">低</span>：不重写历史

⚠ 警告：多⼈协作分⽀禁⽤ reset，重写历史会导致他⼈分⽀断裂；优先使⽤ revert。

分支

分⽀本质：指向某次 commit 的可移动指针，HEAD 指向当前分⽀。分离头指针状态（HEAD 直接指向某次历史提交）易丢失代码，应避免修改。

flowchart LR
  M[main] -->|git checkout -b| F[feature]
  F -->|开发 + commit| F
  F -->|git merge| M

分⽀四操作：创建（基于任意提交创建新分⽀，实质是指针操作）、切换（在 VS Code 左下⻆选择⽬标分⽀）、合并（使⽤ git merge 将特性分⽀合并回主⼲）、删除（切换⾄其他分⽀后删除⽬标分⽀）。⼯作模式：每个开发者/Agent 在独⽴分⽀开发，完成后合并。

四、Git 高级特性

本节介绍工作树、合并冲突等高级功能。

工作树 (Worktree)

flowchart LR
  Main["主仓库 (主工作区)"] -->|git worktree| WT1["worktree 1 (并行副本)"]
  Main --> WT2["worktree 2 (并行副本)"]
  WT1 -.->|完成后 merge| Main
  WT2 -.->|完成后 merge| Main

本质：创建新分⽀并将代码完整复制到新⽂件夹，主⽂件夹与⼯作树⽂件夹并⾏⼯作互不⼲扰，底层通过 Git 关联，改动可轻松合并回主⼲。适⽤场景：需要并⾏开发测试时使⽤。创建⽅法：命令⾏ claude --worktree <分⽀名>，或图形界⾯右键项⽬选择 "创建永久⼯作树"。

合并冲突

冲突：两个分⽀修改同⼀⽂件的同⼀⾏代码时，Git ⽆法⾃动合并，需要⼈⼯/AI 选择保留⽅案。

解决⽅法：让 AI 合并时遇到冲突暂停 → ⼈⼯选择保留⽅案：保留某⼀⽅改动，或合并双⽅改动（可指定顺序）。AI 通过⾃然语⾔交互简化了传统 git 冲突解决流程。

五、远程仓库实战

本节介绍远程仓库的创建、克隆、推送与同步等操作。

数据流转总览

flowchart LR
  L["本地工作区"] -->|git add| S[暂存区]
  S -->|git commit| R["本地仓库"]
  R -->|git push| REM["远程仓库"]
  REM -->|git pull| L

暂存区的作用

暂存区作为 commit 前的准备区域，允许选择性提交部分⽂件改动。现代 Git ⼯具（如 VS Code）常将 git add 和 git commit 合并简化操作。

创建远端仓库

创建步骤：点击 GitHub 的 New 按钮 → 设置仓库名称（英⽂）→ 选择公开 (Public) 或私有 (Private) 属性 → 可选添加 README、.gitignore 和许可证⽂件。

仓库属性区别：公开仓库代码对所有⼈可⻅，私有仓库仅⾃⼰可⻅。

克隆远端仓库到本地

克隆流程：复制 GitHub 仓库地址 → 在 VS Code 中选择 Clone Repository → 粘贴仓库地址 → 选择本地存储路径。克隆效果：⾃动创建本地仓库，⽣成⼯作⽬录，建⽴与远端仓库的关联。

本地提交到远端仓库

提交流程：在本地⼯作区修改/新增⽂件 → 执⾏ git commit 提交到本地仓库 → 点击 Publish 按钮推送到远端。

权限限制：只有仓库管理员或被授权⽤户才能 push 成功，不能直接 push 到他⼈仓库。

本地仓库绑定远端仓库（第二种方法）

# 1. 初始化本地仓库
git init
# 2. 进⾏⾸次 commit
git add .
git commit -m "init"
# 3. 在 VS Code 点击 Publish 按钮
# 4. 设置远端仓库名称和属性(公开/私有)

特点：适⽤于已有本地项⽬的情况，推送后⾃动创建对应的远端仓库。

远端仓库改动同步到本地

git pull   # 相当于 git fetch + git merge
# 或在 VS Code 中点击 Sync Changes 按钮

常⻅场景：远端仓库直接修改（如 GitHub ⽹⻚端编辑）、协作者推送了新提交。分⽀显示：origin/main 表示远端分⽀，main 表示本地分⽀，箭头图标显示同步状态。

六、GitHub 网页入门

本节介绍 GitHub 网页界面、仓库管理、搜索、Issues、快捷键与在线开发环境。

仓库网址的构成

基本结构 github.com/作者名/仓库名，其中 github.com 是平台主域名，中间是开发者⽤户名，最后是仓库英⽂名称。

仓库界面与代码库

界⾯中央显示项⽬源代码。代码获取⽅式：直接浏览、点击 Code 按钮下载压缩包、执⾏ git clone <仓库地址>。Commit message 记录修改内容，最后更新⽇期反映项⽬活跃度，⻓期未更新可能表示项⽬停⽌维护。

README 与 Releases

README ⾃动展示在仓库⻚⻚，包含项⽬简介、功能说明和使⽤⽅法。Releases 提供打包好的软件下载，包含版本号和更新内容，可选择历史版本下载。

About、Star、Fork

About 模块显示项⽬简介、标签和开源协议。Star 类似点赞收藏，数量反映项⽬热度。Fork 将仓库复制到⾃⼰的账户，可⽤于学习源码或⼆次开发，也可通过 Pull Request 贡献代码。

搜索功能

局部搜索在当前仓库内查找内容，全局搜索可搜索整个 GitHub 平台，⽀持⽂件名、代码内容搜索及⾼级搜索语法。

Issues 功能

Issues 是与项⽬作者讨论的平台，可报告 bug 或提出新功能建议。状态分 Open（未解决）和 Closed（已解决）。

GitHub 快捷键

快捷键	功能
<span style="color:blue">/</span>	快速打开 GitHub 的全局搜索功能栏
<span style="color:blue">t</span>	在仓库⻚⾯快速定位到⽂件搜索栏，⽀持按⽂件名搜索
<span style="color:blue">l</span>	快速跳转到指定⾏号（如输⼊ 33 跳转到 33 ⾏）
<span style="color:blue">?</span>	打开快捷键速查表
<span style="color:blue">gi</span>	快速进⼊ issues ⻚⾯（先按 g 再按 i）
<span style="color:blue">gc</span>	快速查看代码（go to code）

⾏操作功能：Copy line 复制当前⾏、Copy perm link 复制永久链接、git blame 查看提交历史和贡献者。

在线开发环境

按 . (句号键) 可在⽹⻚版 VS Code 中打开当前仓库，即 Codespaces：云端开发环境（⽀持双核 8GB 内存配置），可在浏览器中调试代码，通过右上⻆ Run 按钮执⾏代码（如 Python 脚本）。调试时优先使⽤ Codespaces ⽽⾮本地环境。

注意事项

始终可通过 ? 键调出速查表；调试时优先使⽤ Codespaces ⽽⾮本地环境；在 issues ⻚⾯可使⽤ is:issue is:open 等过滤器搜索。

七、GitHub 多人协作

本节介绍 Fork、PR、Code Review、Cherry Pick、Rebase 等多人协作流程。

协作流程总览

flowchart LR
  A[Fork 复刻] --> B[Clone 到本地]
  B --> C[新建分支]
  C --> D[修改 + commit]
  D --> E[git push]
  E --> F[创建 PR]
  F --> G[Code Review]
  G --> H[Merge 合并]

贡献代码前的准备：复刻项目

贡献者点击 Fork 按钮将项⽬复制到⾃⼰的账户下，这是贡献代码的第⼀步。复刻后项⽬会出现在贡献者⾃⼰的 GitHub 账户下。点击 Create fork 即可完成复刻。

权限说明：贡献者没有直接修改原项⽬的权限，必须通过复刻创建个⼈副本后才能进⾏修改。

本地修改：克隆与分支创建

在复刻后的项⽬中点击 Code 获取项⽬地址，使⽤ VS Code 的克隆功能将项⽬下载到本地。修改代码前必须先创建新分⽀，避免直接在 main 分⽀上修改，这样可以防⽌后续同步代码时产⽣冲突。修改流程：通过 VS Code 左下⻆菜单创建分⽀ → 进⾏代码修改 → 提交 commit → 点击 Publish 推送⾄ GitHub。

例题 1：提交改动与创建合并请求

修改完成后将分⽀推送到 GitHub，可以在对应分⽀看到提交记录。通过 Compare & pull request 按钮创建合并请求 (PR)，将⾃⼰的修改合并回原项⽬。PR 会清晰展示两个分⽀间的代码差异，便于管理员审核。

合并请求的审核与合并

Pull Request (PR) 是合并请求的提案，贡献者提议将⾃⼰的分⽀合并到主⼲分⽀。项⽬管理员会进⾏ code review（代码审核），可能提出修改意⻅，确认⽆误后才会同意合并。协作流程：复刻项⽬ → 创建分⽀ → 修改代码 → 提交 PR → 等待审核 → 合并完成。

例题 2：同步母项目代码与解决冲突

同步必要性：在创建 PR 前必须先将⺟项⽬的最新代码同步到⾃⼰的分⽀，确保没有冲突。

冲突预防：当主⼲和特性分⽀同时修改相同⽂件时会产⽣冲突，应先在本地解决冲突再提交 PR。

最佳实践：始终保持特性分⽀与主⼲同步，可以⼤⼤减少合并时的冲突可能性。

Codex 操作演示

操作前需先将分⽀切换为 feature 分⽀。当合并⺟项⽬遇到冲突时，Codex 会提示⽤户选择处理⽅式（如选择 "两个都保留"）。最终采⽤樱桃合并⽅式同步⼦项⽬与⺟项⽬的最新改动。

推送本地改动并创建 PR

git push                  # 推送 feature 分⽀
git push -f               # 必要时强制推送

明确合并⽅向：⼦项⽬ feature 分⽀ → ⺟项⽬ main 分⽀。填写清晰 PR 标题（如 "⽔果清单，增加更多⽔果"）。

管理员处理合并请求

审核流程：管理员通过 File changes 查看提交代码，可提出修改建议或直接批准。合并操作：点击 Merge 按钮确认合并，系统⾃动更新贡献者列表。

协作者设置与直接推送代码

协作者添加：路径 Settings → Collaborators → Add people，需被添加者在 GitHub 收件箱确认邀请。权限优势：免去 fork 步骤，可直接创建分⽀并 push 到远端仓库，提交 PR 前需先合并主⼲最新改动。

Cherry Pick（拣选提交）

flowchart LR
  subgraph feature 分支
    direction LR
    A1[A 蔬菜] --> A2[B 肉类] --> A3[C 主食]
  end
  M[main] -->|cherry-pick A1| M1[main']
  M1 -->|cherry-pick A3| M2[main'']

应⽤场景：当需要将特定分⽀的某些提交（⽽⾮全部）合并到当前分⽀时使⽤。例如 feature 分⽀有 3 次提交（蔬菜清单、⾁类清单、主⻝清单），但只需要合并其中两次。

# 1. 复制⽬标提交的 ID
# 2. 在⽬标分⽀执⾏ cherry-pick
git checkout main
git cherry-pick <commit-id-1>
git cherry-pick <commit-id-3>

效果验证：通过查看分⽀历史记录，确认只有选择的特定提交被合并（如蔬菜和主⻝提交），未选择的提交（如⾁类）则不会包含，且不会产⽣额外的 merge commit 记录。

Rebase 变基

flowchart LR
  subgraph merge [git merge]
    direction TB
    M1[main] --- A1[A]
    M1 --- B1[B]
    A1 --> X["merge commit 保留分叉"]
    B1 --> X
  end
  subgraph rebase [git rebase]
    direction TB
    M2[main] --> C1["B' (重放)"]
    C1 --> D1["A' (重放)"]
  end

定义：变基操作属于 Git ⾼级操作，通过改变提交的基准点来整理提交历史。与 merge 相比，rebase 不会⽣成 "Merge branch..." 这类合并提交记录，而是将当前分⽀的提交 "嫁接" 到⽬标分⽀的最新提交之后。适⽤场景：适合个⼈开发分⽀整理历史，不适合多⼈协作分⽀。

# 命令格式：git rebase <⽬标分⽀>
git checkout feature
git rebase main
# 完成后必须强制推送
git push -f

执⾏步骤：确保当前位于需要变基的分⽀（如 feature 分⽀）→ 执⾏ rebase 命令指向⽬标分⽀（如 main 分⽀）→ 处理可能的冲突（如有）→ 完成变基后必须使⽤强制推送 git push -f。注意事项：变基后原提交会⽣成新的提交 ID（如 C2 变为 C2'），原分⽀的根基提交会变更到⽬标分⽀的最新提交。

⚠ 警告：强制推送覆盖远端历史，多⼈协作分⽀绝不可⽤ git push -f。

操作结果验证：

历史记录特征：提交历史变为线性结构（如 main 的 C3→C4→C5→feature 的 C2'），原合并分⽀的提交会按时间顺序重新排列，不会出现合并冲突产⽣的特殊提交记录。强制推送必要性：因为分⽀根基已改变，普通推送会被拒绝，强制推送前需确保没有其他协作者基于旧历史进⾏开发。

知识小结

要点	说明	注意事项	重要度
<span style="color:blue">HEAD</span> 指针	指向当前所处的 commit 位置；分离头指针（detached <span style="color:blue">HEAD</span>）状态易<span style="color:red">丢失</span>代码	避免在分离头指针状态修改代码	<span style="color:red">★★★</span>☆☆
后悔药操作	discard 放弃未提交更改；reset 强制回退历史版本；revert 生成反向提交	多人协作分支<span style="color:red">禁用</span> reset，优先用 revert	<span style="color:red">★★★★</span>☆
Work Tree	创建分支的物理副本文件夹，与主仓库并行开发	需通过 `merge` 将改动合并回主干	<span style="color:red">★★★</span>☆☆
合并<span style="color:red">冲突</span>	多个分支修改同一文件同一行时需人工/AI 解决<span style="color:red">冲突</span>	AI 可辅助选择保留内容（如西瓜+草莓）	<span style="color:red">★★★★</span>☆
<span style="color:blue">Git</span> 分区	工作区 → 暂存区 → 本地仓库 → 远端仓库	VS Code 默认合并 add 和 commit 操作	<span style="color:red">★★★</span>☆☆
远端协作	clone 下载仓库；push 上传代码；pull 同步远端改动（含 fetch+`merge`）	无权限无法直接 push 他人仓库	<span style="color:red">★★★</span>☆☆
<span style="color:blue">Git</span>Hub 功能	Fork 复制项目；`Pull Request` 合并请求；`Issues` 问题讨论；<span style="color:blue">Releases</span> 版本发布	公开仓库代码可被所有人查看	<span style="color:red">★★</span>☆☆☆
Cherry Pick	选择性合并特定提交（如仅合并蔬菜+主食提交）	需手动指定 commit ID	<span style="color:red">★★★★</span>☆
Stash	临时存储未完成代码（如紧急切换分支时）	区别于暂存区（<span style="color:blue">Staging Area</span>）	<span style="color:red">★★★</span>☆☆
Rebase 变基	更改分支根基，保持提交历史线性整洁	必须<span style="color:red">强制推送</span>（`git push -f`），多人分支<span style="color:red">禁用</span>	<span style="color:red">★★★★★</span>

C 语言

Sun, 23 Aug 2026 00:00:00 GMT

C 语言

第一章 C 语言入门

计算机系统组成

计算机系统由 硬件系统 和 软件系统 组成，硬件是物理载体，软件是运行其上的指令集合。

flowchart LR
    A["输入设备 （如鼠标、键盘）"] -->|数据流| B["内存储器"]
    C["中央处理器 (CPU)"] -->|数据流| B
    B -->|数据流| D["输出设备 （如声卡、显卡）"]
    C -.->|地址| B
    C -.->|控制流| A
    C -.->|控制流| D
    B <--> E["外存储器"]

组成部分	说明
输入设备	鼠标、键盘、麦克风、扫描仪
输出设备	显示屏、扬声器、打印机
中央处理器 (CPU)	运算速度非常快，ns 级别
运算器	算逻单元，负责数据运算
控制器	帮助 CPU 获取指令交给运算器
寄存器	存储 CPU 用来运算的数据
预取器	从内存中获取程序中的指令
MMU	虚拟内存映射
内存储器（内存）	断电后数据丢失，读写速度快
ROM	read only memory
RAM	random access memory
外存储器（硬盘）	断电后数据依然存在，读写速度慢

内存靠「电信号」来存储数据。 断电没！数据存储不能持久化。优点：数据读写速度快。

硬盘采用「磁信号」来存储数据。 断电依然在。数据能持久化存储。缺点：数据读写速度慢。

硬件系统

mindmap
  root((计算机系统 的组成))
    硬件系统
      主机
        中央处理器
          运算器
          控制器
        内存储器
          只读存储器
          随机存储器
      外部设备
        输入设备
        输出设备
        外存储器
    软件系统
      系统软件
        操作系统
        语言处理系统
        系统服务程序
        数据库管理系统
      应用软件
        文字处理软件
        表格处理软件
        辅助设计软件
        实时控制软件

主机部分	说明
CPU	中央处理器
内存储器	内存条

外设部分	说明
输入设备	读入
输出设备	写出
外存储器	持久化存储

CPU 内部结构

flowchart LR
    subgraph CPU
        YS["运算器"]
        KZ["控制器"]
        YQ["寄存器"]
        YXQ["预取器"]
    end
    YS --> YQ
    KZ --> YQ
    KZ --> YXQ
    YQ --> JC["Cache 缓存"]
    YXQ --> JC
    JC --> NC["内存"]
    NC --> YP["硬盘（磁盘）"]
    YP --> WL["网络"]
    JC -.->|读入| NC
    NC -.->|写出| YP

软件系统

系统软件

操作系统
- 优秀的商业公司、开源组织，站出来，编写一套针对硬件的底层程序。管理声卡、显卡、网卡、磁盘等这些硬件。
- 概念：操作系统就是管理计算机硬件与软件资源的一个计算机程序。本质：程序！！

flowchart TB
    A["播放 MP3"] -->|向下| OS["操作系统"]
    B["网络聊天"] -->|向下| OS
    C["查看"] -->|向下| OS
    OS -->|向下| SK["声卡"]
    OS -->|向下| XK["显卡"]
    OS -->|向下| WK["网卡"]
    OS -->|向下| CP["磁盘"]
    OS -.->|向上：图形界面| D["图形界面：普通用户，鼠标点点点"]
    OS -.->|向上：终端界面| E["终端界面：普通用户、开发人员都可以使用"]
    OS -.->|向上：系统调用| F["系统调用：操作系统提供给开发人员使用的函数"]

操作系统（OS）向下的作用：提供驱动程序，管理硬件
操作系统（OS）向上的作用：
- 图形界面：普通用户，鼠标点点点
- 终端界面：普通用户、开发人员都可以使用
- 系统调用：操作系统提供给开发人员使用的函数

常用操作系统	别名
Windows	微软
MacOS	苹果
Linux	开源
Unix	-

语言系统
- 计算机语言：C、C++、Java、Python、PHP …
- 机器语言：二进制（10101001）

应用软件

需要根据实际需求，来制定功能。

文件处理
图形处理
表格处理
实时控制

编译器和语言

概念	说明
编程语言	控制计算机硬件工作，由字母、特殊字符组成，每种编程语言有自己一套规则、语法
编译器	CPU 只认识 1010010 二进制码，abc、汉字看不懂；编译器将人类易读易写的语言转换成 CPU 能读懂的语言
跨编译器	语言不同、语法不同，因此使用的编译器不同；Java 使用 javac 编译器，不能拿它来编译 C 语言；C 语言使用 gcc 编译器，不能拿它来编译 Java 语言

C 语言简述

计算机语言发展史

机器语言：101100110
汇编语言：助记符：abc ← 10100101。问题：硬件不同，指令不同。不同架构（CPU）指令集不同。只能支持某一种特定的硬件，跨平台性差。衍生出 B 语言。
C 语言：借助编译器，就能将 C 代码，转换成各种平台使用的指令。跨平台。
C++、Java、Oc、Python：面向对象编程。程序扩展性好！
SQL 语句：人类易理解。

机器生汇编，汇编生 B，B 生 C，C 生万物！！！

C 语言标准

标准简史：

1972 年 C 语言在贝尔实验室诞生，丹尼斯·里奇参考 B 语言开发
1970-80 年代，C 语言被广泛应用，产生很多不同的 C 语言版本，程序可移植性比较差
1983 年，美国国家标准委员会（ANSI）成立了一个小组来制定 C 语言的标准：C 语言支持哪些语法、支持哪些功能等
1989 年，通过了 C 语言的第一个标准，C89 标准
1990 年，国际标准化组织（ISO）和国际电工委员会（IEC）将 C89 标准当做国际的 C 语言标准。C90 标准、C89 和 C90 指的是同一个标准
1994 年 ISO 和 IEC 对 C89 标准进行修订，C94 标准，由于并没有增加新的语法特性，还是叫做 C89 或者 C90
1995 年 ISO 和 IEC 再次做了修正，C95 标准
1999 年 ISO 和 IEC 发布了 C 语言新标准，C 语言第二个标准。在该标准中，新增许多实用的 C 语言语法特性，增加新的关键字、可变长数组等等。C99 标准
2007 年，重新修订了 C 语言
2011 年，发布新的版本。新增了一些语法，泛型、国际化支持。目前为止最新版本是 C11

标准的影响：

可将 C 语言的标准理解为 C 语言说明书。但，其并没有强制性约束力。

如：微软拿到标准，认为有些标准不合理，不支持。微软认为某些特性非常好，但标准中没有，微软自己新增语法。
如果编译器不支持标准，我们即使使用标准中的语法仍然会报错。
编译器版本也会影响程序。因此，编写程序之前要确定编译器版本。

常见的 C/C++ 编译器：

序号	编译器	说明
1	Borland C++	宝蓝公司
2	Intel C++	英特尔编译器
3	VC++	微软公司
4	<span style="color:red">g++ 编译器</span>	gcc 是编译套件，Linux 默认使用的编译器，对标准支持最好

C 语言的优缺点

优点：

学习成本低
运行速度快
功能强大

缺点：

代码实现周期长
可移植性差
对经验要求高
对平台库依赖多

C 语言的应用领域

服务器
操作系统
上层应用。MFC、QT
嵌入式
人工智能、硬件驱动
中间件
网络攻防、数据安全
大学必修课
名企、外企

C 语言 32 个关键字

32 个关键字：（由系统定义，不能重作其它定义）

-	-	-	-	-
auto	break	case	char	const
continue	default	do	double	else
enum	extern	float	for	goto
if	int	long	register	return
short	signed	sizeof	static	struct
switch	typedef	unsigned	union	void
volatile	while

9 种控制语句

序号	语句
1	if () ~ else ~
2	for () ~
3	while () ~
4	do ~ while ()
5	continue
6	break
7	switch
8	goto
9	return

34 种运算符

类别	运算符
算术运算符	+、-、*、/、%、++、--
关系运算符	<、<=、==、>、>=、!=
逻辑运算符	!、&&、\|\|
位运算符	<<、>>、~、\|、^、&
赋值运算符	= 及其扩展
条件运算符	?:
逗号运算符	,
指针运算符	*、&
求字节数	sizeof
强制类型转换	(类型)
分量运算符	.、->
下标运算符	[]
其它	()

文本编辑 HelloWorld

修改计算机显示扩展名

打开任意一个目录 → 查看 → 文件扩展名（勾选）

编写第一个 hello world 程序

#include <stdio.h>

int main(void)
{
    printf("hello world\n");
    return 0;
}

编译 hello world 程序 —— 得到机器能识别的二进制码

# 编译 C 程序，得到二进制码
gcc HelloWorld.c -o HelloWorld.exe

# 运行二进制程序
HelloWorld.exe

快捷打开 HelloWorld.c 文件所在目录

进入 HelloWorld.c 文件所在目录
直接在「地址栏」中键入 cmd，不需要 cd 目录。切换。

常见 IDE

IDE：集编辑器、编译器、调试器于一身的集合工具。

平台	IDE
Windows	vs2013、vs2015、vs2017、<span style="color:red">vs2019</span>、Clion、Qt Creator、Eclipse
MacOS	Xcode、Clion、Qt Creator、Eclipse
Linux	vi/vim、Clion、Qt Creator、Eclipse

VS2019 基本使用

打开 VS2019，新建项目 → 选择 C++ → Windows → 控制台
创建项目，指定项目目录
确保保留「解决方案资源管理器」
创建 helloworld.c 文件：右键源文件 → 添加 → 新建项 → 选择 C++ 文件 (.cpp) → 修改扩展名为 .c → 命名 helloworld.c
编写 helloworld.c 程序
修改字体：
- 工具 → 选项 → 环境 → 字体和颜色 → 选择字体
- Ctrl + 鼠标滚轮放大、缩小字号
编写完成。点击 本地 Windows 调试器 图标运行

解决窗口一闪而过问题

使用函数解决。在 return 0; 代码前添加一行代码：
```
system("pause");
```
修改 VS2019 工具配置属性解决
- 项目名上，右键 → 属性 → 配置属性 → 链接器 → 系统 → 子系统 → 下拉框中选择「控制台 (/SUBSYSTEM:CONSOLE)」→ 点击「应用」→ 点击确定。

HelloWorld 释义

#include <stdio.h>

int main(void)
{
    printf("hello world!\n");
    return 0;
}

代码释义

序号	代码	释义
1	`#`	代表引入头文件专用特殊字符
2	include	引入头文件专用关键字
3	`<>`	用来包裹库头文件名
4	stdio.h	使用的头文件。因为程序中使用了 `printf()` 函数，就必须使用该头文件。std = standard，i = input 输入，o = output 输出
5	int	main 函数返回值为整型，int
6	main	整个程序的入口函数。任何 .c 程序，有且只有一个 main 函数
7	(void)	当前 main 函数没有参数
8	`{}`	内部放函数体
9	printf("helloworld\n")	见下方
10	return 0;	见下方

printf 详解：

printf()：C 语言向屏幕输出字符使用的函数
"helloworld"：待写出的字符串内容
\n：回车换行

return 详解：

return：返回。C 程序要求，main 函数要有返回值。借助 return 实现返回
0：成功！因为 int，返回整数

注意事项

程序中使用的所有的字符，全部是「英文半角」字符。
程序中，严格区分大小写。
; 代表一行结束。不能使用中文「；」，必须是英文。

代码运行 4 种模式

序号	模式	说明
1	Debug x86	以调试模式，运行 32 位程序
2	Debug x64	以调试模式，运行 64 位程序
3	Release x86	以发布模式，运行 32 位程序
4	Release x64	以发布模式，运行 64 位程序

Debug：调试模式。生成的 .exe 文件比 Release 模式生成文件大。带有调试信息。学习中，只使用该模式。

Release：发布模式。生成的 .exe 文件没有调试信息。文件较小。

热键：运行编写的程序。Ctrl + F5

注释

单行注释：// 待注释的内容
多行注释：/* 待注释的内容 */
- 多行注释内，可以嵌套单行注释。多行注释之间不能嵌套。

System 函数

作用：执行 windows 系统中的指定的命令
命令：
- pause：暂停
- cmd：启动新的终端
- calc：唤起 windows 下的计算器
- notepad：唤起 windows 下的记事本
- mspaint：唤起 windows 下的画图工具
- cls：清空当前 windows 终端中的内容

#include <stdio.h>     // 引入头文件 stdio.h ，因为下面使用了 printf() 必须添加此头文件。
#include <Windows.h>   // 引入头文件 Windows.h，因为下面使用 Sleep() 函数。

int main(void)         // main 是程序的入口函数。void 表示没有参数。int 表示返回整数。
{
    printf("hello world1\n");   // 打印 helloworld 字符串，到屏幕。 \n 换行之
    printf("hello world2!\n");
    printf("hello world3!\n");
    printf("hello world4!\n");
    printf("hello world5!\n");
    printf("hello world6!\n");
    printf("hello world7!\n");

    Sleep(3000);          // 使当前程序，打印完 helloworld 后，睡眠 3s 钟

    // system("cmd");     // 3s 后，再有机会执行。启动一个新终端。
    // system("calc");    // 3s 后，启动计算器
    // system("notepad"); // 3s 后，启动记事本
    // system("mspaint"); // 3s 后，启动画图工具
    system("cls");        // 3s 后，将当前 终端 清空。

    return 0;             // 因为 main 返回 int 。所以这里有 return 0;
}

Sleep() 函数，指定程序睡眠。默认单位：毫秒。需要使用头文件：#include <Windows.h>

第二章核心语法（运行过程、常量、变量、标识符）

main 函数种类

main 函数标准类型

无参：
```
int main(void) { return 0; }
```

有参：

int main(int argc, char *argv[]) { return 0; }

main 函数其他类型

都能正常运行，但不是 main 的标准语法格式。

// 都能正常运行，但不是 main 的标准语法格式。
void main(int argc, char *argv[]);
void main(void);
int main();
int main(void);
main();
main(int argc, char *argv[]);

gcc 编译 4 步骤

整体过程

flowchart LR
    SRC["源文件 hello.c"] -.->|gcc hello.c -o hello.exe| EXE["可执行文件 hello.exe"]
    SRC -.->|-E| PRE["预处理"]
    PRE -->|hello.i 预处理文件| COM["编译"]
    COM -->|hello.s 汇编文件| ASM["汇编"]
    ASM -->|hello.o 目标文件 （本质：二进制）| LINK["链接"]
    LINK --> EXE

预处理

参数：-E
生成的文件：xxx.i 预处理文件
使用命令：gcc -E xxx.c -o xxx.i
工具：预处理器（包含在 gcc 编译集合工具中）

完成的工作：

头文件展开
- 展开 stdio.h 文件内容，和源码一起，放到 xxx.i 文件中
- 不检查语法错误！可以在此阶段提升任意文件
- 测试命令：gcc -E hello.c -o hello.i -I（大）.（当前目录）

宏定义替换

将宏名，替换成宏值
#define PI 3.14【解释】：define：创建宏。PI：宏名 3.14：宏值

// 测试案例。使用命令： gcc -E hello.c -o hello.i
#include <stdio.h>

// 定义宏
#define PI 3.14

int main(void)
{
    printf("hello world\n");

    // 使用宏
    printf("PI = %f\n", PI);

    return 0;
}

替换注释
- 把单行、多行注释替换成空行

展开条件编译

根据条件来展开代码

// 测试案例
#include <stdio.h>

// 定义宏
// #define PI 3.14   // PI 定义与否，直接决定下面的 -----666 是否打印。

int main(void)
{
    printf("hello world\n");

    // 使用宏
    //printf("PI = %f\n", PI);

    // 使用条件编译，含义是：如果定义了 PI ，那么就打印 -----666，否则不打印。
    #ifdef PI
        printf("-----------------6666\n");
    #endif
        return 0;
}

编译

参数：-S
生成的文件：xxx.s 汇编文件
使用命令：gcc -S xxx.i -o xxx.s
工具：编译器（包含在 gcc 编译集合工具中）

完成的工作：

逐行检查语法错误！【重点】 —— 编译过程整个 gcc 编译 4 步骤中，最耗时
将 C 程序翻译成汇编指令。得到 .s 汇编文件

.file    "hello.c"
.text
.def    ___main; .scl    2; .type    32; .endef
.section .rdata,"dr"
.LC0:
    .ascii "hello world\0"
.LC2:
    .ascii "PI = %f\12\0"
.LC3:
    .ascii "-----------------6666\0"
    .text
    .globl  main
    .def    main; .scl    2; .type    32; .endef
    .seh_proc   main
main:
    pushq   %rbp
    .seh_pushreg    %rbp
    movq    %rsp, %rbp
    .seh_setframe   %rbp, 0
    subq    $32, %rsp
    .seh_stackalloc 32
    .seh_endprologue
    call    ___main
    leaq    .LC0(%rip), %rcx
    call    puts
    movq    %rcx, %rax
    movq    %rdx, %xmm1
    movq    %rax, %rdx
    leaq    .LC2(%rip), %rcx
    call    printf
    leaq    .LC3(%rip), %rcx
    call    puts
    movl    $0, %eax
    addq    $32, %rsp
    popq    %rbp
    ret
    .seh_endproc
    .section .rdata,"dr"
    .align 8
.LC1:
    .long   1374389535
    .long   1074339512
    .ident  "GCC: (x86_64-posix-sjlj-rev0, Built by MinGW-W64 project) 8.1.0"
    .def    puts; .scl    2; .type    32; .endef
    .def    printf; .scl    2; .type    32; .endef

汇编

参数：-c
生成的文件：xxx.o 目标文件（二进制，人类看不懂）
使用命令：gcc -c xxx.s -o xxx.o
工具：汇编器（包含在 gcc 编译集合工具中）
完成的工作：
- 翻译：将汇编指令翻译成对应的二进制指令

连接

参数：无（-o 不是链接阶段参数，是用来指定文件名）
生成的文件：xxx.exe 可执行文件（二进制，人类看不懂）
使用命令：gcc xxx.o -o xxx.exe
工具：链接器（包含在 gcc 编译集合工具中）
完成的工作：
- 库引入
- 合并并目标文件
- 合并并启动例程

# 完整 4 步骤编译流程
gcc -E hello.c -o hello.i
gcc -S hello.i -o hello.s
gcc -c hello.s -o hello.o
gcc hello.o -o hello.exe

# 一句话完成
gcc hello.c -o hello.exe

小结

gcc 编译的 4 个步骤中，每个步骤直接都可相互转换。

flowchart LR
    SRC["源文件 hello.c"] -.->|gcc hello.c -o hello.exe| EXE["可执行文件 hello.exe"]
    SRC -.->|-E| PRE["预处理"]
    PRE -->|-S| COM["编译"]
    COM -->|-c| ASM["汇编"]
    ASM -->|无参| LINK["链接"]
    LINK --> EXE
    SRC -.->|-S| COM
    SRC -.->|-c| ASM
    SRC -.->|无参| LINK

printf 格式化输出 int

#include <stdio.h>

#define PI 3.14

int main(void)
{
    int a = 10;

    printf("%d\n", a);       // %d：格式匹配符，匹配整数。
    printf("a = %d\n", a);   // a = 在 "" 中，代表普通字符串，原样输出。
    printf("%d\n", 100);

    printf("%f\n", PI);      // %f：格式匹配符，匹配小数。
    printf("PI = %f\n", PI); // PI = 在 "" 中，代表普通字符串，原样输出。

    printf("%f\n", 3.45678); // %f：格式匹配符，匹配小数。

    int b = 20;

    printf("%d + %d = %d\n", a, b, a+b);   // +、= 在 "" 中，代表普通字符串，原样输出。
    printf("%d + %d = %d\n", 3, 7, 3+7);
    return 0;
}

程序调试

前提：程序，没有语法错误。—— 语法错误 VS 帮我检查。
- 检查程序中出现的逻辑错误！
核心思想：
- 让程序一行的执行
添加行号：
- 工具 → 选项 → 文本编辑器 → c/c++ → 行号（勾选）

程序调试流程

添加断点。——可以添加多个
1. 鼠标点击待添加断点行，左侧行号前灰色区域。再次点击取消
2. 光标停止在待添加断点行的任意位置，按 F9 添加断点。再次按 F9 取消断点
测试，必须在 Debug 模式下进程。Release 模式无效
F5 启动调试
断点停止的位置，是尚未执行的指令
开始调试：
1. 逐语句执行。逐语句执行下一行（F11）：遇见函数，进入自定义函数内部，逐条跟踪执行
2. 逐过程执行。逐过程执行下一行（F10）：遇见函数，不进入函数内部，逐条跟踪执行
3. 逐断点执行。代码中有多个断点，直接跳转至下一个断点。—— 点击"继续"，无快捷键
4. 跳出函数。跳出当前断点所在的函数。shift + F10

变量

变量 3 要素

变量名：用来在程序中使用
变量类型：开辟内存空间大小
变量值：存储的实际数据

flowchart LR
    MEM["内存"]
    MEM --> A["a 空间大小：4字节 变量类型：int 变量值：10 10"]
    MEM --> B["b 空间大小：4字节 变量类型：int 变量值：20 20"]

变量定义

定义语法：类型名变量名 = 变量值（一般定义方法），int m = 57;
会开辟内存空间给变量。变量声明不会开辟内存空间。

变量声明

语法：
- int a; 没有变量值的变量定义，叫做声明
- extern int a; 添加 extern 关键字
特性：
- 变量要想使用，必须有定义
- 编译器，在使用变量之前，必须能看到变量定义。如果没有看到，编译器会自动寻找一个变量声明。提升成定义
- 如果变量声明前，添加了 extern 关键字，无法提升！

常量

不会变化、不能被修改的数据。

"hello"、'A'、57、-10、3.1415926（浮点常量）
#define PI 3.14 —— 【宏定义】语法：#define 宏名宏值
- 强调：没有 ; 结束标记
- 强调：没有 =
const int a = 10; 定义语法：const 类型名变量名 = 变量值
- const 关键字：被该关键字修饰的变量，表示为只读变量

练习：

#define PI 3.1415926      // 定义常量

int main(void)
{
    // 圆的面积：S = PI * r * r
    // 圆的周长：L = 2 * PI * r
    int r = 3;             // 变量的定义

    float S = PI * r * r;  // 表达式。作为变量值。
    float L = 2 * PI * r;

    //printf("圆的面积：%f\n", s);// 28.274334  默认显示 6 位小数。
    //printf("圆的周长：%f\n", l);// 18.849556

    //printf("圆的面积：%.2f\n", s);// 28.27
    //printf("圆的周长：%.2f\n", l);// 18.85指定保留小数点后两位，对第 3 位四舍五入

    float m = 3.4567891;

    printf("m=%6.2f\n", m);
    //共显示6位数，包含小数点，保留小数点后两位，对第3位四舍五入，不是6位用空格补齐。

    printf("m=%06.2f\n", m);
    //共显示6位数，包含小数点，保留小数点后两位，对第3位四舍五入，不是6位用0补齐。

    return 0;
}

标识符

变量和常量总称

硬性要求

标识符不能是关键字、函数名。 system、printf、int、main、return、..
只能有字母、数字、下划线组成。 a-z/A-Z/0-9_
- abc_1/abc_2/_abc_1/a_b_c_d
不能以数字开头。
- int a5ir = 10; ok
- int _34F = 6; ok
- float 98i_54 = 5.4; error
大小写严格区分。
- 通常使用大写来定义常量。#define MAX 100
- 通常使用小写来定义变量

命名规范

大驼峰法：int HelloWorldHahaHohoHehe = 10;
- 多个单词组成变量名，每个单词首字母大写
小驼峰法：int helloWorldHahaHohoHehe = 10;
- 多个单词组成变量名，首个单词的首字母小写，其余每个单词首字母大写
小写 + 下划线：int hello_world_haha_hoho_hehe = 10;
- C 语言专用！

sizeof 关键字

sizeof 不是函数
求变量、数据类型，占用的内存空间大小
使用方法：
1. sizeof(变量名) —— 返回变量大小，单位整数字节
2. sizeof(类型名) —— 返回数据类型大小，单位整数字节
3. sizeof 变量名 —— 语法 C 语言支持该写法，不推荐使用

整型

有符号整型

获取数据类型的最小值、最大值，可以使用 #include <limits.h>

整型名	名称	格式匹配符	占用的大小	最小值	最大值
int	整型	%d	4 字节	-2147483648	2147483647
short	短整型	%hd	2 字节	-32768	32767
long	长整型	%ld	windows：32/64位：4 字节 Linux 下：32位：4 字节、64位：8 字节	-2147483648	2147483647
long long	长长整型	%lld	8 字节	-9223372036854775808	9223372036854775807

#include <stdio.h>
#include <limits.h>

int main(void)
{
    printf("int大小 = %u\n", sizeof(int));
    printf("int最小值: %d, 最大值: %d\n", INT_MIN, INT_MAX);

    printf("short大小 = %u\n", sizeof(short));
    printf("short最小值: %hd, 最大值: %hd\n", SHRT_MIN, SHRT_MAX);

    printf("long大小 = %u\n", sizeof(long));
    printf("long最小值: %ld, 最大值: %ld\n", LONG_MIN, LONG_MAX);

    printf("long long大小 = %u\n", sizeof(long long));
    printf("long long最小值: %lld, 最大值: %lld\n", LLONG_MIN, LLONG_MAX);

    return 0;
}

无符号整型

整型名	名称	格式匹配符	占用的大小	最大值
unsigned int	无符号整型	%u	4 字节	-
unsigned short	无符号短整型	%hu	2 字节	-
unsigned long	无符号长整型	%lu	windows：32/64位：4 字节 Linux 下：32位：4 字节、64位：8 字节	-
unsigned long long	无符号长长整型	%llu	8 字节	-

第三章核心语法（数据类型和进制转换）

char 类型

基础信息

字符型
单位：一个字节（8 bit 位）
格式匹配符：
- 数值型：
  - 有符号：%hhd —— char 显示数值专用格式匹配符
  - 无符号：%hhu —— unsigned char 显示数值专用格式匹配符
- 字符型：%c
取值范围：
- 有符号：-128 ~ 127
- 无符号：0 ~ 255
程序获取：

#include <stdio.h>
#include <limits.h>

int main(void)
{
    // 获取无符号数值范围
    printf("char 无符号 min = 0, max = %hhu\n", UCHAR_MAX);
    // 获取有符号数值范围
    printf("char 有符号 min = %hhd, max = %hhd\n", CHAR_MIN, CHAR_MAX);
    // 获取 char 占用的字节数
    printf("char 大小 = %u\n", sizeof(char));
    // 获取 unsigned char 占用的字节数
    printf("unsigned char 大小 = %u\n", sizeof(unsigned char));

    return 0;
}

ASCII 码

char 类型数据，数值对应一个 ASCII 码
ASCII 表（American Standard Code for Information Interchange 美国标准信息交换代码）

字符	ASCII 码	字符	ASCII 码
0	48	A	65
1	49	a	97
9	57	Z	90
'A'	65	'a'	97
'0'	48	'\n'	10
'\t'	9	'\0'	0

#include <stdio.h>

int main(void)
{
    char ch = 'A';   // 定义变量 ch, 指定初值为 'A';

    printf("ch = %c\n", ch);   // c: character. %c 用来显示字符的 格式匹配符。

    ch = 'm';     // 给变量 ch 赋值成 'm', 覆盖 原来的 'A';

    printf("ch = %c\n", ch);

    ch = 97;     // 使用 范围内的数值 97, 给 ch 赋值.

    printf("ch = %c\n", ch);   // 将数值97, 按照字符格式打印输出。

    ch = 98;     // 使用 范围内的数值 98, 给 ch 赋值.

    printf("ch = %c\n", ch);   // 将数值98, 按照字符格式打印输出。

    return 0;
}

练习

将大写字母，转换成小写字母：

#include <stdio.h>

int main(void)
{
    char ch = 'R';   // char 变量定义

    printf("R 转换的小写为: %c\n", ch+32);   // ch+32 表达式，对应格式匹配符 %c

    char ch2 = 'h'; // char 变量定义

    printf("h 转换的大写为: %c\n", ch2-32); // ch2-32 表达式，对应格式匹配符 %c

    char ch3 = '5';
    // 借助字符 5, 利用 ASCII特性, 打印出 字符9
    printf("打印字符9 = %c\n", ch3+4);

    return 0;
}

ASCII 表说明

0 ~ 32 ASCII 码对应的字符都不可见
常用的 ASCII 码：
- 'a'：ASCII 码值 97
- 'A'：ASCII 码值 65
- '0'：ASCII 码值 48
- '\n'：ASCII 码值 10
- '\t'：制表符。tab 键对应的字符。（ASCII 码值 9）
- '\0'：ASCII 码值 0

char 与 printf 对应关系

flowchart LR
    A["char ch = 'A';"] --> CH["'A'"]
    CH -->|"%hhd / %d / %hd"| V["65 打印 ch 对应的值"]
    CH -->|"%c"| C["A 打印 ch 对应的字符"]

练习：在一个 printf 函数中，打印输出 hello 换行 world 换行

// 方法 1
int main(void)
{
    printf("hello\nworld\n");
    return 0;
}

// 方法 2
int main(void)
{
    char ch = '\n'; // 定义 ch 变量，初值为 '\n'

    printf("hello%cworld%c", ch, ch); // 等价于 printf("hello\nworld\n");

    return 0;
}

一个 printf 中打印 hello（一个 tab 缩进）world 换行：

int main(void)
{
    char ch1 = '\t';   // 实现 一个 tab 缩进
    char ch2 = '\n';   // 实现 一个换行

    printf("hello%cworld%c", ch1, ch2);

    return 0;
}

转义字符

'/'：自右向左划，叫做「斜杠」
'\'：自左向右划，叫做「反斜杠」。—— 是转义字符
转义字符的作用：
1. 将普通字符，转换为特殊意
  - 如：'\n'：这是一个字符，代表换行
  - 如：'\t'：这是一个字符，代表一个制表符
2. 将特殊字符，还原成本身意
  - 如：'\\n'：这样就将一个字符 \n，还原成两个字符：'\' 和 'n'

练习：将特殊字符转换成本身意。

题目：屏幕上严格输出如下内容：【"\n"的值是 10】要求显示时要有 "

int main(void)
{
    printf("\"\\n\"的值是 %hhd", '\n');
    return 0;
}

实型（浮点型）【了解】

显示小数

基础信息

float：单精度浮点型。%f 大小：4 字节。（可以使用 sizeof() 求取）
- 4.35 默认会被编译器理解为 double 类型
- float v = 4.567f;：编译器理解 float
- %f 格式匹配符，默认保留 6 位小数
double：双精度浮点型。%lf 大小：8 字节。
- double d = 5.68;

取值范围

使用头文件 #include <float.h> 获取浮点型取值范围：

int main(void)
{
    printf("float 范围: %f ~ %f\n", FLT_MIN, FLT_MAX);
    printf("double 范围: %lf ~ %lf\n", DBL_MIN, DBL_MAX);

    return 0;
}

精度问题

float 类型：
- 精度 6~7 位
 - 整数部分 + 小数部分 <= 6 位，准确
 - 整数部分 + 小数部分 == 7 位，可能准确，也可能不准确
 - 整数部分 + 小数部分 > 7 位，不准确
double 类型：
- 精度 15~16 位
 - 整数部分 + 小数部分 <= 15 位，准确
 - 整数部分 + 小数部分 == 16 位，可能准确，也可能不准确
 - 整数部分 + 小数部分 > 16 位，不准确

int main(void)
{
    float f = 439243243.9f;

    printf("f = %f\n", f);

    return 0;
}

不同平台（操作系统），对应 float、double 类型实现的精度有可能不同。以上是 Windows 下特性。

float 和 double 不存在"无符号"类型。

bool 类型

C 语言原来没有 bool 类型。C99 标准中，新增了 bool 类型。C++ 自带 bool 类型。

用处：
- 表示：
  - 好、坏
  - 真、假
  - 对、错
  - 是、否
- 取值：
  - true —— 真 —— 1
  - false —— 假 —— 0
C 语言使用 bool 的条件：
- 编译器要支持 C99 标准
- 导入 #include <stdbool.h>
bool 类型的大小：
- 1 字节。（sizeof() 求取）
bool 没有专用的格式匹配符。打印时，使用 %d 来打印
- true —— 真 —— 1
- false —— 假 —— 0

int main(void)
{
    bool aa = true;   // 定义 bool 类型变量 aa, 初值为 true == 1

    printf("aa = %d\n", aa);

    aa = false;   // 给 bool 类型变量 aa 赋值为 false == 0

    printf("aa = %d\n", aa);

    return 0;
}

进制和转换

计算机只使用 2 进制
8 进制、10 进制、16 进制，统统都是给人类用的！！！

存储知识

1 bit 位就是一个二进制位，存 0 或 1
一个字节（Byte） 1B = 8 bit 位
"内存单元" 是计算机内存存储的最小单位，一个内存单元 == 1 字节
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB

2 进制

取值 1 或 0，逢 2 进 1，借 1 当 2
没有格式匹配符

10 转 2：

除 2 反向取余法

示例：56 → 111000；173 → 1010 1101

2 转 10：

掌握 2⁰ ~ 2¹⁰ 各自的取值：

指数	值	指数	值	指数	值
2⁰	1	2⁴	16	2⁸	256
2¹	2	2⁵	32	2⁹	512
2²	4	2⁶	64	2¹⁰	1024
2³	8	2⁷	128	-	-

计算方法，对应二进制位，有 1 累加 2 的指数次幂值，有 0 略过

11101 —— 29

10110 —— 2+4+16 = 22

8 进制

逢 8 进 1，借 1 当 8
取值：0/1/2/3/4/5/6/7 最大值 7
格式匹配符：%o 和 %#o
表示语法：0 开头
8 进制 ——> 10 进制：
- 056 == 8⁰ * 6 + 8¹ * 5 = 6 + 40 = 46
- 0123 = 8⁰ * 3 + 8¹ * 2 + 8² * 1 = 3 + 16 + 64 = 83
10 进制 ——> 8 进制：
- 除 8 反向取余法
- 135 —— 0207

8 转 2：

转换算法：将 8 进制数，自左向右，每一位，用 421 码展开
练习：
- 056 —— 101110
- 04735 —— 1001 1101 1101
- 053261 —— 101 0110 1011 0001

2 转 8：

转换方法：自右向左，每 3 个二级制位一组，不足 3 位补 0
- 1101010101111010
  - 分组：1 101 010 101 111 010
  - 补齐：001 101 010 101 111 010
  - 八进制数为：0152572
- 101101111011
  - 分组：10 110 111 011
  - 补齐：010 110 111 011
  - 八进制数为：02673

16 进制

逢 16 进 1，借 1 当 16
取值：0~9 10-A/a 11-B/b 12-C/c 13-D/d 14-E/e 15-F/f 最大值：F/f
格式匹配符：%x 或 %#x
表示语法：0x 开头
16 进制 ——> 10 进制：
- 将每一个 16 进制位，展开相加得 10 进制
10 进制 ——> 16 进制：
- 除 16 反向取余法
- 37：0x25
- 43：0x2B

16 转 2：

转换算法：将 16 进制数，自左向右，每一位，用 8421 码展开
- 0xFAC12：1111 1010 1100 0001 0010

2 转 16：

转换方法：自右向左，每 4 个二级制位一组，不足 4 位补 0
- 101001011101011001
  - 分组：10 1001 0111 0101 1001
  - 补齐：0010 1001 0111 0101 1001
  - 16 进制数为：0x29759
- 1110110100111101
  - 分组：1110 1101 0011 1101
  - 补齐：1110 1101 0011 1101
  - 16 进制数为：0xED3D

小结

使用频率最高的是 10 进制。其次是：16 进制
- int m = 0x15f4;
- int n = 0345;
- int k = 01011101;
  - 不能直接将变量值赋值为 2 进制
  - 上述的赋值，会被编译器理解为 8 进制数

#include <stdio.h>

int main(void)
{
    int a = 56;   // 10 进制数作 a 变量初始化。 -- 定义。

    printf("10进制: a = %d\n", a);
    printf("8进制: a = %o\n", a);
    printf("8进制: a = %#o\n", a);  // 在 % 和 #o 中间添加#，可以在输出时，显示 8 进制前缀。
    printf("16进制: a = %x\n", a);
    printf("16进制: a = %#x\n", a); // 在 % 和 #x 中间添加#，可以在输出时，显示 16 进制前缀。

    return 0;
}

常用的格式匹配符

格式符	用途
%d	整型
%c	字符
%x	16 进制
%u	无符号
%s	字符串
%o	8 进制
%#o	带前缀 8 进制
%#x	带前缀 16 进制
%hhd	char 有符号
%hd	short 有符号
%ld	long
%lld	long long
%hhu	char / unsigned char 无符号
%hu	unsigned short
%lu	unsigned long
%llu	unsigned long long
%f	float
%lf	double

编码和存储

无符号存储

unsigned int a = 12;   // 占用 4 字节 32 个 bit 位存储。
空间: 00000000 00000000 00000000 00000000   ----  4 字节。
存储: 00000000 00000000 00000000 00001100

unsigned short b = 15;   // 占用 2 字节 16 个 bit 位存储。
空间: 00000000 00000000                ----  2 字节。
存储: 00000000 00001111

有符号存储

需要拿出一个二进制位，专门存储符号。标识正、负
- 选用最高位为符号位
- 正：0
- 负：1

有符号正数：

// 采用 "源码" 存储
int a = 5;
空间: 0 0000000 00000000 00000000 00000000
存储: 0 0000000 00000000 00000000 00000101   --- 表示存储正数 5 。

有符号负数：

有符号的负数，采用「补码」存储
- 源码：数值的二进制制直接存储
- 反码：符号位不变，将其余数值位取反
- 补码：反码 + 1

int b = -33;
空间: 0 0000000 00000000 00000000 00000000
源码: 1 0000000 00000000 00000000 00100001
反码: 1 1111111 11111111 11111111 11011110
补码: 1 1111111 11111111 11111111 11011111   --- 负 33 在计算机中实际的存储形式。

小结：
- int —— 4 字节 —— 32 bit 位
  - 有符号：31 个数值位，取值范围 -2³¹ ~ 2³¹ - 1 ——> -2147483648 ~ +2147483647
  - 无符号：32 个数值位，取值范围 0 ~ 2³² - 1 ——> 0 ~ 4294967295
- short —— 2 字节 —— 16 bit 位
  - 有符号：15 个数值位，取值范围 -2¹⁵ ~ 2¹⁵ - 1 ——> -32768 ~ 32767
  - 无符号：16 个数值位，取值范围 0 ~ 2¹⁶ - 1 ——> 0 ~ 65535
因此，知道数据类型占用内存的大小，就能算出该类型无符号数、有符号数对应的取值范围。

数据溢出

详见练习章节

数值溢出

如果 int 类型变量，已经取最大值（2147483647），再给这个变量 +1，就发了溢出
- 上溢出：最大值 + 1
- 下溢出：最小值 - 1

flowchart LR
    A["int unsigned int 0"] -->|→| B["..."]
    B -->|→| C["2³² - 1"]
    C -->|+1| A
    C -->|-1| B

无符号数

取值范围 0 ~ 2³² - 1
最大值 + 1 ——> 0
0 - 1 ——> 最大值

// 上溢出
int main(void)
{
    unsigned int a = UINT_MAX;   // 取出无符号最大值

    printf("最大值+1 = %d\n", a + 1);  // 0
    printf("最大值+2 = %d\n", a + 2);  // 1

    return 0;
}

// 下溢出
int main(void)
{
    unsigned int a = 0; // 取出无符号最小值

    printf("最小值-1 = %u, 最大值 = %u\n", a - 1, UINT_MAX);

    return 0;
}

有符号数

上溢出：

最大值 + 1，下溢出 == 最小值

// unsigned 上溢出。
int main(void)
{
    int a = INT_MAX;   // 取出无符号最小值

    printf("最大值+1 = %d, 最小值 = %d\n", a+1, INT_MIN);

    return 0;
}

// signed 上溢出。
int main(void)
{
    int a = INT_MAX;   // 取出有符号最小值

    printf("最大值+1 = %d, 最小值 = %d\n", a+1, INT_MIN);

    return 0;
}

下溢出：

最小值 - 1，下溢出 == 最大值

// signed 下溢出。
int main(void)
{
    int a = INT_MIN;   // 取出有符号最小值

    printf("最小值-1 = %d, 最大值 = %d\n", a - 1, INT_MAX);

    return 0;
}

小结

大部分编译器，对于数值溢出，采用上述处理方式。但，个别编译器有可能不能
受数值溢出影响，进行数据存储时，要选择恰当的数据类型。389482390483209 —— int

不常用关键字（了解）

第四章核心语法（运算符、if、switch、while）

extern：表示声明。声明没有内存空间，不能提升为定义
const：限制一个变量为只读。—— 常量
Volatile：防止编译优化
register：定义一个寄存器变量。没有内存地址

输入输出函数

输出函数

printf()：%d, %c, %x, %u, %s ...
putchar() 函数：
- 输出一个字符到屏幕
- 'abcZ' 是错误的定义，既不是 char 也不是字符串

putchar(97);     // 97 == 'a'

putchar('\n');   // 输出换行符。

putchar('b');

putchar('\n');   // 使用率较高。  printf("\n");

putchar('abcZ'); // 'abcZ' 是错误的定义，既不是 char 也不是字符串。

输入函数

scanf 函数

使用：

安装指定个格式匹配符，获取指定类型数据
获取整数：

int a;   // 可以定义 a 变量（有内存空间），也可以声明（自动提升成定义，有内存空间）
scanf("%d", &a);     // &: 取变量 a 的地址 ---> 拿到 a 的内存空间。

示例：

// scanf 输入
int main(void)
{
    //int a = 10;
    int a;   // 在 scanf 执行时，会提升为定义。

    int ret = scanf("%d", &a);  // scanf 可以从键盘获取用户输入，用户根据 %d 输入整数。

    printf("获取的a为: %d\n", a);

    return EXIT_SUCCESS;
}

一次性获取多个整数：
常见的错误书写方法：

int a, b, c;   // 一次性创建多个 int 类型变量。

// scanf 可以从键盘获取用户输入，用户根据 多个%d 输入整数。
int ret = scanf("%d%d%d", &a, &b, &c);

// 上述写法编译器无法识别。输入的 123 应该怎样分配给 3 个 %d

正确的书写方式：（推荐）

int main(void)
{
    int a, b, c;   // 一次性创建多个 int 类型变量。

    // scanf 可以从键盘获取用户输入，用户根据 多个%d 输入整数。
    int ret = scanf("%d %d %d", &a, &b, &c);

    printf("获取的a为: %d\n", a);
    printf("获取的b为: %d\n", b);
    printf("获取的c为: %d\n", c);

    return EXIT_SUCCESS;
}

获取字符：

// scanf 输入，获取字符。
int main(void)
{
    char ch1, ch2, ch3;   // 一次性创建多个 char 变量

    printf("请输入3个字符，用空格隔分: ");

    scanf("%c %c %c", &ch1, &ch2, &ch3);

    printf("ch1 = %c\n", ch1);
    printf("ch2 = %c\n", ch2);
    printf("ch3 = %c\n", ch3);

    return EXIT_SUCCESS;
}

注意事项：

不要随意 在 scanf() 函数中，添加 \n。如果添加了，换行符，会被 scanf 当成格式来约束用户输入
1. printf() 中的 \n 用来屏幕输出换行
2. scanf() 函数中的 \n，不能用来输出，因为这是一个输入函数
解决 VS 中使用 scanf 函数报错 C4996 错误：

以下是错误描述

C4996 'scanf': This function or variable may be unsafe. Consider using scanf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
解决方法：在 .c 文件的第一行添加 #define _CRT_SECURE_NO_WARNINGS

getchar 函数

直接从键盘接收一个字符，并将得到的字符对应的 ASCII 返回

int main(void)
{
    char ch = getchar();  // 定义 char 变量 ch, 接收 getchar() 函数返回值做为初值。

    printf("ch的数值: %d\n", ch);   // %hhd %hd
    printf("ch的字符: %c\n", ch);

    return EXIT_SUCCESS;
}

运算符

算数运算符

+ - * /：先乘除取余，后加减
除法运算后，得到的结果赋值给整型变量，取整数部分。int c = 10/20; ——> 0
除 0：错误操作，不允许。printf("%d\n", 10/0);
对 0 取余：错误操作，不允许。printf("%d\n", 123 % 0);
不允许对小数取模。35 % 3.4;
对负数取余，结果为余数的绝对值。printf("%d\n", 10 % -3); ——> 1

自增自减运算符

前缀自增 (++)，自减 (--)
- 先自增、自减，再取值
```
int a = 10;
++a; // 等价于 a = a+1;
```
后缀自增 (++)，自减 (--)
- 先取值，再自增、自减

// ++ / -- 运算符
int main(void)
{
    // 前缀
    int a = 10;
    printf("%d\n", ++a);  // ++a 等价于 a = a+1;

    // 后缀
    int b = 10;
    printf("%d\n", b++);  // b++ 等价于 b = b+1;

    // 不管前缀、后缀、含有变量 ++/-- 表达式执行完后，变量均发生了自增、自减。
    printf("b = %d\n", b);

    return EXIT_SUCCESS;
}

赋值运算符

=，在计算机中，只能完成"赋值"操作，一定是右边赋值给左边，也叫单向赋值
a += 10 // 等价于 a = a+10;
a -= 30 // 等价于 a = a-30;
a %= 5; // 等价于 a = a%5;

比较运算符

真：1（非 0），假：0
== 判等符（= 不是用来判等）
!= 不等
< 小于
<= 小于等于
> 大于
>= 大于等于
【强调】：数学运算中 13 < var < 16 判断，在计算机中，要写成：var > 13 && var < 16;

逻辑运算符

0 为假，非 0 为真。（非 0：1、27、-9）

逻辑非（!）

非真为假，非假为真

// 逻辑运算符
int main(void)
{
    // 逻辑非
    int a = 34;  // 34 是非0， 默认 a 为真。
    int b = 0;

    printf("!a = %d\n", !a);  // a 为真，非a 为假！ ---> 0
    printf("b = %d\n", !b);   // b=0，b 为假，非b，为真。 ---> 1

    return EXIT_SUCCESS;
}

逻辑与（&&）

同真为真，其余为假

printf("=====&&%d\n", a && !b);  // a为真，!b为真，真&&真 -- 真。 ----> 1

逻辑或（||）

有真为真，同假为假

printf("-----||%d\n", a || b);   // a 为真，!b 为真，真||真 -- 真。 ---> 1
printf("------%d\n", !a || b);   // !a 为假，b 为假，假||假 -- 假。 ---> 0
printf("-----||%d\n", !a || !b); // !a 为假，b 为假，假||假 -- 假。 ---> 0

运算符优先级

() > ++/--（后缀高于前缀）(强转) ! (逻辑非) sizeof > 算数运算符(先乘除取余，后加减) > 比较运算符 > 逻辑运算符 > 三目运算（条件运算）> 赋值运算符 > 逗号运算符

一周左右的时间，记忆运算符优先级

逗号运算符

int x, y, z;
int a = (x=1, y=2, z=3);  // x=1, y=2, z=3 是一个逗号运算符表达式。运算结果为 a = 3;

int a = (x=1, z=3, y=2?);  // 运算结果为 a = 2?;

含有"," 运算符表达式运算结果，是最后一个子表达式的结果

三目运算符

语法：表达式1 ? 表达式2 : 表达式3
- 表达式 1 必须是一个判断表达式
- 结果为真：整个三目运算，返回表达式 2
- 结果为假：整个三目运算，返回表达式 3

// 三目运算
int main(void)
{
    int a = 40;
    int b = 4;

    //int m = a > b ? 69 : 10;
    //printf("m = %d\n", m);  // m = 69;

    //int m = a < b ? 69 : 10;
    //printf("m = %d\n", m);   // m = 10;

    // 三目运算支持嵌套
    int m = a < b ? 69 : (a<b?3+5); // 先算表达式3，加5，整个三目运算，取表达式3-->5
    printf("m = %d\n", m);   // m = 5;

    int m = a < b ? 69 : a < b ? 3 : 5;
    printf("m = %d\n", m);   // m = 5;

    return EXIT_SUCCESS;
}

如果不使用 ()，三目运算默认的结合性，自右向左

类型转换

隐式类型转换

编译器自动完成。（小类型转大类型，同类型大小）

flowchart TB
    D["高 double"] --> L["long"]
    L --> UI["unsigned int"]
    UI --> SI["低 signed int"]
    CH["char, short"] --> SI
    F["float"] --> D

由赋值产生：

int r = 3;
float s = 3.14 * r * r;
// 3.14 默认类型是 double, r 是 int 类型。运算过程中，转换为 double 类型运算。
// 运算结束，赋值给 s 时，转换为 float。

小类型 ——> 大类型。没问题
大类型 ——> 小类型。可能丢失数据
- VS 中 Ctrl + F7 只编译，检查语法错误，不运行

int main(void)
{
    int a = 321;
    char ch = a;   // 用值为 321 的a变量，给 char 类型赋值。

    printf("ch = %d\n", ch);   // 运行输出 65;

    return EXIT_SUCCESS;
}

321：2⁸=256 有，128 没有，64 有，32/16/8/4/2 没有，有 1

0000 0000 0000 0000 0000 0001 0100 0001 —— 321 二进制表现形式

0000 0000 —— char 只有一个字节。

赋值后，char 值为：0100 0001 --- 1 + 64 = 65

强制类型转换

语法：
1. 强制变量：(目标类型) 变量
2. 强制表达式：(目标类型) 表达式

int main(void)
{
    float price = 3.6;   // 单价
    int weight = 4; // 斤数

    //int sum = weight * (int)price;   // 强制变量。
    //printf("sum = %d\n", sum);  // --- 12

    int sum = (int)(weight * price);   // 强制表达式。
    printf("sum = %d\n", sum);  // --- 14

    return EXIT_SUCCESS;
}

if 分支语句

if...else 分支语句，实现一种模糊匹配。匹配一个范围
if...else 分支

if (判断表达式) {
    判断表达式为真，执行的代码。
}
else
{
    判断表达式为假，执行的代码。
}

示例：

int a;

printf("请输入一个数: ");

int ret = scanf("%d", &a);

if (a > 0) {
    printf("a > 0\n");
}
else
{
    printf("a <= 0\n");
}

多个分支逻辑：

if (判断表达式1) {
    判断表达式1为真，执行的代码。
}
else if (判断表达式2)
{
    判断表达式1为假，判断表达式2为真，执行的代码。
}
else if (判断表达式3)
{
    判断表达式1为假，判断表达式2为假，判断表达式3为真，执行的代码。
}
...
else
{
    以上所有判断表达式都为假，执行的代码。
}

示例：

int score;

printf("请输入学生成绩: ");

scanf("%d", &score);

if (score >= 90)    // 优秀
{
    printf("优秀\n");
}
else if (score >=70 && score < 90)         // 70 < score < 90 错误写法。
{
    printf("良好\n");
}
else if (score >= 60 && score < 70)
{
    printf("及格\n");
}
else
{
    printf("差劲\n");
}

练习：

编写程序，实现 3 只小猪评体重。屏幕输入 3 个小猪的重量，借助 if 分支，找出最重的那只小猪

int main(void)
{
    int pig1, pig2, pig3;

    printf("请输入3只小猪的重量: ");

    scanf("%d %d %d", &pig1, &pig2, &pig3);

    if (pig1 > pig2)  // pig1 重
    {
        if (pig1 > pig3)  // 1、这行不能写分号。  2、缩进使用 tab 实现。
        {
            printf("第一只小猪最重，体重为: %d\n", pig1);
        }
        else
        {
            printf("第3只小猪最重，体重为: %d\n", pig3);
        }
    }
    else     // pig2 重
    {
        if (pig2 > pig3)
        {
            printf("第2只小猪最重，体重为: %d\n", pig2);
        }
        else
        {
            printf("第3只小猪最重，体重为: %d\n", pig3);
        }
    }
    return EXIT_SUCCESS;

    // 其他实现方法：
    // 使用逻辑运算  if (pig1 > pig2 && pig1 > pig3) ---> pig1。
    // 使用三目运算  pig1 > pig2 ? pig1 : pig2;
}

分支语句中，可以嵌套其他分支语句
else 总是找它前面最近的未配对的 if 组合使用

switch 分支语句

精确匹配。结构较清晰。较 if 语句执行效率略高
缺点：不能直接判断区间，需要借助表达式运算

switch (表达式)
{
    case 1:
        执行语句;
        break;   // 表示一个分支执行结束，跳出 switch.
    case 2:
        执行语句;
        break;   // 表示一个分支执行结束，跳出 switch.
    case N:
        执行语句;
        break;   // 表示一个分支执行结束，跳出 switch.
    default:
        其他情况，执行语句;（上述所有的 case 都不满足）
        break;
}

练习：获取学生成绩，给出优良可差

int main(void)
{
    int score;

    printf("请输入学生成绩: ");
    scanf("%d", &score);

    // 将 学生成绩，通过运算，得出可以放入 switch case 分支 的 表达式。
    switch (score/10)
    {
        case 10:
            printf("优秀\n");
            break;   // 表示当前分支结束。
        case 9:
            printf("优秀\n");
            break;
        case 8:
            printf("良好\n");
            break;
        case 7:
            printf("良好\n");
            break;
        case 6:
            printf("及格\n");
            break;
        default:         // 所有 case 都不满足的其他情况。
            printf("不及格\n");
            break;
    }
    return EXIT_SUCCESS;
}

case 穿透

一个 case 分支，如果没有 break；它执行完本 case 的代码后，会继续向下，执行下一个 case 分支的代码。这称之为 case 穿透
大多数情况下，一个 case 分支，应该对应一个 break
利用 case 穿透

switch (score/10)
{
    case 10:        // 故意让 switch 发生 case 穿透
    case 9:
        printf("优秀\n");
        break;
    case 8:         // 故意让 switch 发生 case 穿透
    case 7:
        printf("良好\n");
        break;
    case 6:
        printf("及格\n");
        break;
    default:         // 所有 case 都不满足的其他情况。
        printf("不及格\n");
        break;
}

while 循环语句

语法：

while (判别表达式)   // 如果为真，执行循环体，如果为假，跳出循环。
{
    循环体
}

练习：

敲 7：从 1~100 数数，逢 7 和 7 的倍数，敲桌子
分析：
- 7 的倍数：num % 7 == 0
- 个位含 7：num % 10 == 7
- 十位含 7：num / 10 == 7

int main(void)
{
    //7的倍数： num % 7 == 0
    //个位含7： num % 10 == 7
    //十位含7： num / 10 == 7

    int num = 1;

    while (num <= 100)
    {
        // 判断敲桌子的时机
        // if ((num % 7 == 0) || (num % 10 == 7) || (num / 10 == 7))
        if (num % 7 == 0 || num % 10 == 7 || num / 10 == 7)
        {
            printf("敲桌子!\n");
        }
        else
        {
            printf("%d\n", num);
        }
        num++;
    }
    return EXIT_SUCCESS;
}

do while 循环语句

无论如何先执行一次循环体，然后再判断循环是否应该继续
语法：

do {
    循环体
} while (判断表达式);

练习：

求水仙花数。一个三位数（100~999），各个位上数字的立方和等于本数字
分析：
- 3 位数：100~999 —— 如：234、861
- 个位数：int a = num % 10;
- 十位数：int b = num / 10 % 10;
- 百位数：int c = num / 100;

int main(void)
{
    //个位数: int a = num % 10;
    //十位数: int b = num / 10 % 10;
    //百位数: int c = num / 100;

    int num = 100;   // 数数从 100 开始。
    int a, b, c;     // 定义存储个位、十位、百位 的变量。

    do {
        a = num % 10;        // 求个位数。
        b = num / 10 % 10;
        c = num / 100;

        // 判断 这个数字是否是"水仙花数".
        if (a * a * a + b * b * b + c * c * c == num)
        {
            printf("水仙花数: %d\n", num);
        }
        num++;   // 不断向后数数。

    } while (num <= 999);

    return EXIT_SUCCESS;
}

第五章核心语法（for、数组）

配置 VS2019 快捷导入代码

准备快捷导入代码的脚本文件，保存至系统目录中（位置自定义）：C:\Software\fastCode（如 #1.snippet、#2.snippet、#3.snippet）
在 VS2019 中配置，使用上述目录中的脚本文件
- 工具 —— 代码片段管理器 —— 修改 Basic 为 Visual C++ —— 选择上述自定义的目录位置
在程序中使用快捷导入代码
- #1 ---- tab 键

for 循环

语法

for (表达式1; 表达式2; 表达式3)
{
    循环体;
}

循环从 表达式1 开始 ——> 表达式2（判别表达式）——> 真 ——> 执行循环体 ——> 表达式 3 ——> 判断表达式 2
- 真：继续循环体 ——> 表达式 3 ——> 表达式 2 ...
- 假：跳出循环。（正常情况下，for 循环的出口是表达式 2）

练习

使用 for 循环求 1~100 的和：

// 1~100 求和       1+2+3+4+5+...+100
int main(void)
{
    // 定义循环因子。
    int i = 0;        // 定义 i, 给初值。

    // 定义变量 记录累加值
    int sum = 0;      // 初值为 0
    for (i = 1; i <= 100; i++)
    {
        sum = sum + i;
    }

    // 循环结束，打印 累加结果
    printf("sum = %d\n", sum);

    return EXIT_SUCCESS;
}

for 循环的变换形式

循环因子 i：

在 for 循环之前定义。在 for 循环，结束后依然能使用

定义在 for 循环之内。for 循环结束后，不能使用

for (int i = 1; i <= 100; i++)    // 将 i 的定义放到 for 内 表达式1 上。
{
    sum = sum + i;
}

// 循环结束，打印 累加结果
printf("sum = %d. i = %d\n", sum, i);  // 编译器保存，"未定义标识符"

for 循环 3 个表达式，在使用时，均可省略。但，2 个 ; 不允许省略

省略表达式 1：

int i = 1;  // 定义 循环因子
int sum = 0;

for (; i <= 100; i++)   // 不写表达式1
{
    sum = sum + i;
}

省略表达式 3：

int i = 1;  // 定义 循环因子
int sum = 0;

for ( ; i <= 100; )    // 不写表达式1，不写表达式3
{
    sum = sum + i;
    i++;         // 将原来的表达式3 写到循环体中。
}

省略表达式 2：

int i = 1;  // 定义 循环因子

for ( ; ; ) // 不写表达式2，相当于 for ( ; 1; ) 表达式2为 真(1)。这是一个死循环。
{
    printf("i = %d\n", i);
    i++;
}
// for ( ; ; ) 死循环 相当于  while(1) {};

for 每个表达式中，可以含有多个算式：

int i = 0;   // 定义 循环因子
int a = 0;

for (i=1, a=3; a<20, i<10; i++, a+=3)  // i<10, a <20 也可以写成  i<10 && a<20
{
    printf("i = %d\n", i);
    printf("a = %d\n", a);
}

死循环：

// 方法1:
for(;;)
{
}

// 方法2:
while(1)
{
}

练习

猜数字游戏：
- 产生一个随机数，用户键盘输入一个数据，程序提示用户，输入的数据 > <= 随机数。用户根据提示不断变换输入，最终猜中！

生成随机数：

添加一个随机数种子。作用：保证随机是真正的随机

srand(time(NULL));  // 固定写法。

// time(NULL) 获取系统当前时间。unsigned long long 类型。
// srand() 函数来生成随机数，使用 系统时间为 算法的 系数。

添加头文件

// srand() --- <stdlib.h>
// time() --- <time.h>

生成随机数：

int n = rand() % 100;          // 随机数范围: 0 ~ 99
int n = rand() % 100 + 13;     // 随机数范围: 13 ~ 112
int n = rand() % 63 + 17;      // 随机数范围: 0~17 ~ 62+17

思路分析：

// 伪代码
int main(void)
{
    1. 生成随机数。(3步骤)
    2. 创建死循环，用户猜测    while(1)
        int num ;
    while (1)
    {
        接收用户输入: scanf("%d", &num);
        if 判断用户输入的数据，与实际随机 大小。
            num > 随机数
            提示用户。继续循环。
        num < 随机数
            提示用户。继续循环。
        num == 随机数
            提示用户 猜中！结束循环。
            break;  跳出循环。
    }
    return 0;
}

编码实现：

int main(void)
{
    // 播种随机数种子
    srand(time(NULL));

    // 生成随机数 n
    int n = rand() % 100;   // 范围 0~99

    // 定义 num 变量，存储用户输入的数据。
    int num;

    // 创建 死循环，给用户猜数字。
    for (;;)    // while(1) 等价
    {
        printf("请输入猜测的数字: ");
        // 获取用户输入数据
        scanf("%d", &num);

        // 提示用户，测试方向
        if (num > n)
        {
            printf("猜大了!\n");
        }
        // 如果 if分支、for、while 满足后，执行语句只有一条时，{} 可以省略。
        else if (num < n)
        {
            printf("猜小了!\n");  // 语法允许，不写 {}
        }
        else
        {
            printf("猜中了！！！\n");
            break;  // 不必再循环。
        }
    }
    printf("本尊数: %d\n", n);

    return EXIT_SUCCESS;
}

嵌套 for 循环

int i = 0;  // 外层循环的循环因子
int j = 0;  // 内层循环的循环因子

for (i = 0; i < 10; i++)
{
    for (j = 2; j < 10; j++)
    {
        // 循环体
    }
}

结论：外层循环执行一次，内层循环执行一周

练习

模拟电子表打印
分析：

// 最外层
for (i = 0; i < 24; i++)
{
    for (j = 0; j < 60; j++)
    {
        for (k = 0; k < 60; k++)
        {
            打印时间。
        }
    }
}

11:30:54
11:30:56
...
11:31:00
...
12:00:00
12:00:01

实现：

int main(void)
{
    int i, j, k;

    for (i = 0; i < 24; i++)  // 小时
    {
        for (j = 0; j < 60; j++)  // 分钟
        {
            for (k = 0; k < 60; k++)  // 秒
            {
                printf("%02d:%02d:%02d\n", i, j, k);
                Sleep(980);
                system("cls");  // 清屏
            }
        }
    }

    return EXIT_SUCCESS;
}

练习

打印正序 9x9 乘法表

1x1= 1           // 第1行，打印1列
1x2= 2 2x2= 4     // 第2行，打印2列
1x3= 3 2x3= 6 3x3= 9     // 第3行，打印3列
1x4= 4 2x4= 8 3x4=12 4x4=16    // 第4行，打印4列
...
1x9= 9 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81    // 第9行，9列

jxi =
第 i 行，打印 i 列。

分析 + 实现：

for (i = 1; i <= 9; i++)  // 外层，描述行。
{
    for (j = 1; j <= i; j++)  // 内层，描述每一列。
    {
        printf("%dx%d=%d\t", j, i, i*j);
    }
    printf("\n");
}

打印倒序 9x9 乘法表：

1x9= 9 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81    // 第1行
1x8= 8 2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64
1x7= 7 2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49
1x6= 6 2x6=12 3x6=18 4x6=24 5x6=30 6x6=36
1x5= 5 2x5=10 3x5=15 4x5=20 5x5=25
1x4= 4 2x4= 8 3x4=12 4x4=16
1x3= 3 2x3= 6 3x3= 9
1x2= 2 2x2= 4
1x1= 1

jxi = 值

for (i = 9; i >= 1; i--)   // i 控制 行
{
    for (j = 1; j <= i; j++)
    {
        printf("%dx%d=%d\t", j, i, i*j);
    }
    putchar('\n');
}

// 上述省略{}写法无误，不推荐。 --- 推荐下面的写法。
int main(void)
{
    int i, j;
    for (i = 9; i >= 1; i--)
    {
        for (j = 1; j <= i; j++)
        {
            printf("%dx%d=%d\t", j, i, j * i);
        }
        putchar('\n');   // printf("\n");
    }
    return EXIT_SUCCESS;
}

跳转语句

break

作用 1：
- 一次 break，可以跳出一重循环。（for、while、do while）
作用 2：
- 防止 case 穿透。结束 switch()。

continue

作用：结束本次循环，continue 关键字之后的代码，在这次循环中，不执行
示例 1：

for (int i = 0; i < 5; i++)
{
    printf("==========1=========\n");
    printf("==========2=========\n");
    if (i == 2) {
        continue;
    }
    printf("==========3=========\n");
    printf("==========4=========\n");
    printf("==========5=========\n");
    printf("\n");
}

示例 2：

int main(void)
{
    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            if (j == 2)
            {
                continue;  // 只跳出（后续代码不执行）本次 j == 3 时的循环。
            }
            printf("i = %d, j= %d\n", i, j);
        }
        printf("\n");
    }
    return EXIT_SUCCESS;
}

goto

语法：
1. 设定一个标签。标签名自定义，一般大写。如：ABC、LABLE、AAA
2. 使用 "goto 标签名" 跳转到标签的位置。（只函数内生效）
示例：

int main(void)
{
    printf("==========1=========\n");
    printf("==========2=========\n");
    printf("==========3=========\n");

    goto LABLE;
    printf("==========4=========\n");
    printf("==========5=========\n");
    printf("==========6=========\n");
    printf("==========7=========\n");

LABLE:
    printf("==========8=========\n");
    printf("==========9=========\n");

    return EXIT_SUCCESS;
}

示例：

int main(void)
{
    int i = 0, j = 0;

    for (i = 0; i < 5; i++)
    {
        if (i == 2)
        {
            goto ABC234;
        }
        printf("i = %d\n", i);
    }

    for (j = 0; j < 5; j++)
    {
ABC234:
        printf("j = %d\n", j);
    }

    return EXIT_SUCCESS;
}

j = 0 的表达式，没有执行。

goto 语法过于灵活，会打乱程序的执行逻辑，降低代码的可读性。后续编程中，尽量少用
- C 程序中，简单的逻辑，依然可以使用 goto。

数组

什么是数组：
- 数组是，相同数据类型有序的、连续的存储集合

// 定义数组，定义10个类型相同、连续、有序存储 的 数据。
int arr[10] = {19, 2, 23, 4, 5, 6, 10, 7, 8, 9};

//printf("arr[0] = %d\n", arr[0]);   // 取数组的第一个元素。
printf("&arr[0] = %p\n", &arr[0]);   // 取数组的第一个元素的 内存地址。
//printf("&arr[0] = %x\n", &arr[0]);   // 内存地址使用 16 机制数表示。
//printf("&arr[0] = %#x\n", &arr[0]);
printf("&arr[1] = %p\n", &arr[1]);
printf("&arr[2] = %p\n", &arr[2]);
printf("&arr[3] = %p\n", &arr[3]);

%p：
- 用来打印变量内存地址的专用格式匹配符（占位符）

基本特性

各个元素，连续存储
数组名为地址，是数组首个元素的地址。arr == &arr[0]

求数组的总大小：

printf("数组的大小: %u\n", sizeof(arr));

求数组每一个元素的大小：

printf("数组元素的大小: %u\n", sizeof(arr[0]));

求数组元素的个数：

printf("数组元素的个数: %d\n", sizeof(arr)/sizeof(arr[0]));

数组第一个元素的下标：0
数组最后一个元素的下标：
```
sizeof(arr)/sizeof(arr[0]) - 1
```

数组初始化

// 初始化方法1
int arr[5] = {3, 7, 2, 1, 9};

// 初始化方法2 [多用]
int arr[5] = {3, 7};        // 剩余未初始化的元素，默认值 0

// 初始化方法3 [多用]
int arr[5] = {0};   // 初始化一个 全部元素为 0 的数组。 ---闭0  常用。

// 初始化方法4 [多用]
int arr[] = {3, 7, 2, 1, 6, 9, 13};   // 编译器会自动求取数组元素个数。

// 初始化方法5
int arr[] = {0};   // 定义了只有一个元素的数组，值为 0

// 初始化方法6 [多用]
int arr[10];   // 声明了一个有10个元素数组。
arr[0] = 5;
arr[1] = 6;
arr[2] = 7;  // 剩余未初始化的元素，默认值 --- 随机数。

练习

数组元素逆序

// 数组元素逆序
int main(void)
{
    int arr[] = {1, 6, 8, 0, 4, 3, 9, 2};  // 变为：{2, 9, 3, 4, 0, 8, 6, 1}

    // 获取数组的元素个数
    int n = sizeof(arr) / sizeof(arr[0]);

    int i = 0;     // 从前向后
    int j = n-1;   // 从后向前
    int tmp = 0;   // 定义临时变量。

    // 交换数组元素之前，打印数组的所有元素。
    for (int i = 0; i < n; i++)
    {
        printf("%d ", arr[i]);
    }
    putchar('\n');

    // 循环交换数组元素。
    while (i < j)
    {
        tmp = arr[i];     // 三杯水变量交换法
        arr[i] = arr[j];
        arr[j] = tmp;
        i++;   // 不断后移
        j--;   // 不断前移
    }

    // 交换数组元素之后，打印数组的所有元素。
    for (int i = 0; i < n; i++)
    {
        printf("%d ", arr[i]);
    }
    putchar('\n');

    return 0;
}

冒泡排序

flowchart TB
    A0["2 4 0 5 7 8 1 3 9"] --> A1["2 0 4 5 7 1 3 8"]
    A1 --> A2["2 0 4 5 3 1 7 8"]
    A2 --> A3["2 0 4 5 3 1 7 8"]
    A3 --> A4["2 0 4 5 3 1 7 8"]
    A4 --> A5["2 0 4 5 3 1 7"]
    A5 --> A6["2 0 4 5 3 1"]
    A6 --> A7["2 0 4 5 3"]
    A7 --> A8["2 0 4 5"]
    A8 --> A9["2 0 4"]
    A9 --> A10["2 0"]

N 个数，证 N-1 阶

int main(void)
{
    int i, j, tmp;

    int xjp[] = {12, 2, 32, 14, 62, 54, 27, 89, 9, 10, 3};

    // 求取数组元素个数。
    int n = sizeof(xjp) / sizeof(xjp[0]);

    // 开始排序。
    for (i = 0; i < n - 1; i++)   // 外层控制行
    {
        for (j = 0; j < n - 1 - i; j++)  // 内层控制列。

            // 相邻两两比较，三杯水交换
            if (xjp[j] > xjp[j + 1])
            {
                tmp = xjp[j];
                xjp[j] = xjp[j + 1];
                xjp[j + 1] = tmp;
            }
    }
    // 打印排序结果。
    for (i = 0; i < n; i++)
    {
        printf("%d ", xjp[i]);
    }
    printf("\n");

    return EXIT_SUCCESS;
}

第六章核心语法（二维数组、字符串、函数）

二维数组

基本使用

int arr[10] = {1,2,3,4,5,6,7}; // 一维数组

{1,2,3,4,5,6,7}
{1,2,3,4,5,6,7}
{1,2,3,4,5,6,7} // 多个一维数组，组成二维数组。

定义语法

int arr[r][c] = {数组元素}
int arr[2][3] =
{
    {2, 5, 8},            // 第0行
    {7, 9, 10}            // 第1行
};
// 常规写法：
int arr[3][5] = {{2, 3, 54, 56, 7}, {2, 67, 4, 35, 9}, {1, 4, 9, 3, 78}};

打印

// 自动补齐的 for 自带的 size_t 来源：
// 查看：方法1：右键 -- 转到定义
//      方法2：F12
typedef unsigned int size_t;   // 给 unsigned int 起别名，叫 size_t

// 以下是打印 2 维数组的方法：
int arr[3][5] = { {2, 3, 54, 56, 7}, {2, 67, 4, 35, 9}, {1, 4, 9, 3, 78} };

for (size_t i = 0; i < 3; i++)   // 行
{
    for (size_t j = 0; j < 5; j++) // 列
    {
        printf("%d ", arr[i][j]);
    }
    printf("\n");
}

特性

数组大小

printf("数组大小：%u\n", sizeof(arr));

一行大小

printf("数组一行大小：%u\n", sizeof(arr[0]));

一个元素大小

printf("数组一个元素大小：%u\n", sizeof(arr[0][0]));

行数

int row = sizeof(arr) / sizeof(arr[0]);   // 数组总大小 / 每行大小

列数

int col = sizeof(arr[0]) / sizeof(arr[0][0]);   // 一行大小 / 每个元素大小

地址合一

数组的地址 == 数组的首元素地址 == 数组的首行地址
printf("%p\n", arr);   // 数组的首地址
printf("%p\n", arr[0]);   // 数组首行地址
printf("%p\n", &arr[0][0]);   // 数组首元素的地址

初始化

常规初始化

int arr[3][5] = { {2, 3, 54, 56, 7}, {2, 67, 4, 35, 9}, {1, 4, 9, 3, 78} };

不完全初始化

int arr[3][5] = {{2,3},, {2, 67, 4}, {1, 4, 16, 78}};   // 未被初始化的数值，为0
int arr[3][5] = {0};   // 初值全部为0的二维数组
int arr[3][5] = { 2, 3, 4, 5, 6, 7, 8, 9, 99, 2, 16, 78}; //【少见】系统自动分配行列

不完全指定行列初始化

int arr[][] = {1, 23, 4, 56, 7, 8};  【错误】 // 二维数组定义，至少需要指定 列值。
int arr[][2] = { 1, 23, 4, 56, 7, 8, 10};   // 可以不指定行值。

int row = sizeof(arr) / sizeof(arr[0]);
int col = sizeof(arr[0]) / sizeof(arr[0][0]);

for (size_t i = 0; i < row; i++)   // 行
{
    for (size_t j = 0; j < col; j++)   // 列
    {
        printf("%d ", arr[i][j]);
    }
    printf("\n");
}

练习

求出 5 名学生 3 门功课的总成绩。（总成绩：一个学生的总成绩。一门功课的总成绩）

int main(void)
{
    int scores[5][3];   // 5个学生，3门功课

    int row = sizeof(scores) / sizeof(scores[0]);
    int col = sizeof(scores[0]) / sizeof(scores[0][0]);

    // 获取 5 个学生 3门功课成绩
    for (size_t i = 0; i < row; i++)
    {
        for (size_t j = 0; j < col; j++)
        {
            scanf("%d", &scores[i][j]);
        }
    }
    // 一门功课的总成绩
    for (size_t i = 0; i < col; i++)   // 一次取出，每个学生的一门功课
    {
        int sum = 0;   // 累加每门功课的分数。
        for (size_t j = 0; j < row; j++)   // 每门功课第几个学生
        {
            sum += scores[j][i];
        }
        printf("第%d门功课总成绩：%d\n", i + 1, sum);
    }

    // 求每个学生的总成绩
    for (size_t i = 0; i < row; i++)   // 每个学生
    {
        int sum = 0;   // 累加每个学生的成绩。

        for (size_t j = 0; j < col; j++)   // 每个学生的成绩
        {
            sum += scores[i][j];  // sum = sum + scores[i][j];
        }
        printf("第%d个学生的总成绩为：%d\n", i+1, sum);
    }
    //printf("-----------------------------------\n");

    ///// 打印 5 个学生 3门功课成绩
    //for (size_t i = 0; i < row; i++)
    //{
    //  for (size_t j = 0; j < col; j++)
    //  {
    //      printf("%d ", scores[i][j]);
    //  }
    //  printf("\n");
    //}
    //system("pause");
    return EXIT_SUCCESS;
}

多维数组（了解）

三维数组：[层][行][列]
语法：类型名数组名[层][行][列]

int arr[3][3][4] =
{
    {
        {{12, 3, 4, 5}},    // 第0行
        {{12, 3, 4, 5}},    // 第1行
        {{12, 3, 4, 5}}     // 第2行
    }, // 第0层
    {
        {}, // 第0行
        {}, // 第1行
        {}  // 第2行
    }    // 第1层
};

打印：

int main(void)
{
    int arr[3][4][2] =
    {
        {
            {1, 2},
            {3, 4},
            {5, 6},
            {7, 8}
        },
        {
            {12, 24},
            {31, 49},
            {5, 46},
            {17, 88}
        },
        {
            {122, 24},
            {311, 419},
            {15, 46},
            {17, 188}
        }
    };

    for (size_t i = 0; i < 3; i++) // 层
    {
        for (size_t j = 0; j < 4; j++) // 行
        {
            for (size_t k = 0; k < 2; k++) // 列
            {
                printf("%d ", arr[i][j][k]);
            }
            printf("\n");
        }
        printf("\n\n");
    }

    system("pause");
    return EXIT_SUCCESS;
}

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

int arr[][3][4] = {1,2,3,4,5,6,7,8,9}; // 层数，可以省略。

数组的首地址 == 首层地址 == 首层首行地址 == 首元素地址。

4维、5维、6维。。。。。N维

int arr[2][3]
short arr[2][3]
float arr[2]
long long arr[2][3][5]

字符串

一串字符。C 语言中，一定使用 '\0' 结束。

字符数组和字符串的区别

字符数组

char str1[5] = {'h','e','l','l','o'};   // 不是字符串，没有 \0

字符串

char str2[6] = {'h','e','l','l','o','\0'};  【麻烦】
char str3[6] = "hello";  // 自动带有 \0 结束标志.

字符串输出

printf("%s")
- 打印字符串。挨着从字符串的第一个字符顺序向后打印，打印到 '\0' 结束，没碰到 '\0' 不结束。
- 'a' != "a"('a','\0')
- 'abc' 是一个错误定义！既不是字符串，也不是有效字符。

其他格式匹配符

%Ns：
- 显示 N 个字符的字符串，不足 N 用空格向右填充。
```
printf("%9s\n", str);
```
%0Ns：
- 显示 N 个字符的字符串，不足 N 用 0 向左填充。
```
printf("%09s\n", str);
```
%-Ns：
- 显示 N 个字符的字符串，不足 N 用空格向左填充。
```
printf("%-9s\n", str);
```
%%：与字符串无直接关系。
- 显示一个 %。转义字符 %，% 无效。转义 %，使用 %% 本身。
- 输出 [10 % 3 = 1]：printf("10 %% 3 = 1\n");

练习

键盘输入字符串，存至 str 中，统计每个字母出现的次数。
分析

flowchart LR
    H["h"] --> IDX0["索引 0"]
    E["e"] --> IDX1["索引 1"]
    L1["l"] --> IDX2["索引 2"]
    L2["l"] --> IDX3["索引 3"]
    O["o"] --> IDX4["索引 4"]
    W["w"] --> IDX5["索引 5"]
    O2["o"] --> IDX6["索引 6"]
    R["r"] --> IDX7["索引 7"]
    L3["l"] --> IDX8["索引 8"]
    D["d"] --> IDX9["索引 9"]
    IDX0 --> A["a=97 d=100 l(小写) = 'L' - 'a' 的下标 L(大写) = 'l' - 'A' 的下标 获取d的下标 = 'd' - 'a' = 3"]

int main(void)
{
    char str[1024] = { 0 };   // 定义有10个元素的字符数组，初值均为0

    for (size_t i = 0; i < 11; i++)
    {
        scanf("%c", &str[i]);  // helloworld
    }
    // 定义一个有26个元素的数组，初始化成 0
    char count[26] = { 0 };   // 代码26个英文字符出现的次数。

    for (size_t i = 0; i < 11; i++)
    {
        int index = str[i] - 'a';    // 提取每个字符，在 count 表中对应的下标。
        count[index]++;    // 向对应字符，位置++，代表该字符出现了一次。
    }

    // 循环遍历 count 数组，打印每个字符，出现的次数。
    for (size_t i = 0; i < 26; i++)
    {
        if (count[i] != 0)   // 0 == \0
        {
            printf("%c字符，在字符串%s中，出现了%d次\n", i+'a', str, count[i]);
        }
    }

    system("pause");
    return EXIT_SUCCESS;
}

scanf 获取字符串

char str[1024] = {0};   // 定义字符串存储的空间，保证足够大。
scanf("%s", str);

注意事项：
- 用于存储字符串的空间，必须足够大！防止溢出。
- %s 遇到空格和 \n 终止。
```
char str[1024] = {0};
scanf("%s", str);  --- 获取 "hello world haha xixi" 字符串
printf("%s", str);  --- 输出 hello
```
- 借助「正则表达式」，可以获取带有空格的字符串。scanf("%[^\n]", str);

字符串操作函数

gets

从（键盘）标准输入 stdin 获取字符串。返回字符串首地址，可以获取带有空格的字符串，不保存 \n，将其替换为 0

#include <stdio.h>

char *gets(char *s);   // char * 等价于 char []
    参数：用来存储字符串的空间地址。
    返回值：返回实际获取到的字符串的首地址。
// 示例
char str[1024] = {0};
printf("获取的字符串为：%s\n", gets(str));

fgets

从（键盘）标准输入 stdin 获取字符串。一定会给字符串预留 0 空间。可以获取带有空格的字符串。如果空间足够，保留 \n，如果空间不足，不保留 \n。

#include <stdio.h>
char *fgets(char *s, int size, FILE *stream);   // char * 等价于 char []
    参数1：用来存储字符串的空间地址。
    参数2：空间的大小。（严格对应实际空间的大小）
    参数3：读取字符串的位置。 -- stdin（键盘）

    返回值：返回实际获取到的字符串的首地址。

// 示例：
char str[15];
int len = sizeof(str);
printf("获取到的字符串为：%s\n", fgets(str, len, stdin));

puts

将字符串输出到屏幕标准输出 stdout，输出后会自动向屏幕输出 \n

// printf("%s\n", "hello")

#include <stdio.h>

int puts(const char *s);   // char * 等价于 char []
    参数：待 写入到屏幕的字符串。
    返回值：
        成功：0，失败：-1
// 示例：
char str[] = "hello world";
int ret = puts(str);
printf("ret = %d\n", ret);

fputs

将字符串输出到屏幕标准输出 stdout，不自动添加 \n 字符。

#include <stdio.h>

int fputs(const char * str, FILE * stream);   // char * 等价于 char []
    参数1：待输出到屏幕的字符串。
    参数2：写入的位置。 -- stdout 标准输出，屏幕。
    返回值：
        成功：0，失败：-1
// 示例：
char str[] = "hello world\n";

int ret = fputs(str, stdout);

printf("ret = %d\n", ret);

strlen

作用：获取一个字符串有效字符个数（字符串的长度）。不含 \0（碰到 \0 结束）

#include <string.h>

size_t strlen(const char *s);
    参数：待 求长度的字符串
    返回：有效字符个数
// 示例：
char str[] = "hello world\n";
printf("有效长度=%u\n", strlen(str));   // 不含有 \0 长度
printf("sizeof=%u\n", sizeof(str));     // 含有 \0 长度

实现 strlen 函数

int main(void)
{
    char str[] = "hello world";

    int i = 0;
    while (str[i] != '\0')
    {
        i++;
    }
    printf("不含\0的字符串长度为：%d\n", i);

    printf("strlen = %d\n", strlen(str)) ;

    system("pause");
    return EXIT_SUCCESS;
}

字符串追加

flowchart LR
    subgraph str1
        S1_0["h"]
        S1_1["e"]
        S1_2["l"]
        S1_3["l"]
        S1_4["o"]
        S1_5["\0"]
    end
    str1 -->|i == 5| str3_0["h"]:::target
    subgraph str2
        S2_0["w"]
        S2_1["o"]
        S2_2["r"]
        S2_3["l"]
        S2_4["d"]
        S2_5["\0"]
    end
    str2 -->|j = 0 ++| str3
    subgraph str3
        S3_0["h"]
        S3_1["e"]
        S3_2["l"]
        S3_3["l"]
        S3_4["o"]
        S3_5["w"]
        S3_6["o"]
        S3_7["r"]
        S3_8["l"]
        S3_9["d"]
        S3_10["\0"]
    end
    classDef target fill:#f96

int main(void)
{
    char str1[] = "hello";
    char str2[] = "world";
    char str3[100];

    // 循环将 str1 中的字符，依次写入到 str3 中
    int i = 0;
    while (str1[i] != '\0')
    {
        str3[i] = str1[i];
        i++;
    }
    // 循环结束，str3 = [hello] 无 \0
    // printf("i = %d\n", i);  --- 循环结束为 5。

    int j = 0;  // 循环 str2

    // 循环将 str2 中的字符，接着str1的内容顺序写入到 str3 中
    while (str2[j])  // while(str2[i] != 0) == while (str2[i] != '\0')
    {
        str3[i+j] = str2[j];
        j++;
    }
    // 循环结束，str3 = [helloworld] 无 \0

    // 手动添加 \0 结束标记
    str3[i + j] = '\0';

    printf("str3 = %s\n", str3);

    system("pause");
    return EXIT_SUCCESS;
}

函数

函数的作用

提高代码复用率。
提高程序模块化组织性。

函数分类

系统库函数：标准库。libc
1. 必须引入头文件 #include <xxx.h> ---- 函数声明。
2. 根据函数库函数原型，调用函数。
用户自定义函数：
- bubble_sort()、myPrint()
- 除了需要提供函数原型之外，还需要提供函数实现。

使用函数

函数定义、函数声明、函数调用

函数定义

函数定义必须包含"函数原型" 和 "函数体"
- 函数原型：返回值类型 + 函数名 + 形参列表。
  - 形参列表：形参参数列表。一定包含：类型名、形参名
```
// 加法函数
int add(int a, int b)
```
- 函数体：一对 {} 包裹函数实现。
```
// 例子：
int add(int a, int b)
{
    int ret = a + b;
    return ret;
}
// int test(char ch, short b, int arr[], int m)
```

函数调用

包含：函数名(实参列表)：
- 实参（实际参数）：在调用时，传参必须严格按照形参填充。（参数个数、类型、顺序）
- 实参在调用时，没有类型描述符。
```
// 例子
int m = 10;
int n = 20;
int ret = add(m, n);
```

函数声明

包含：函数原型(返回值类型 + 函数名 + 形参列表) + ";"
要求，在函数调用之前，编译器，必须见过函数定义。否则需要函数声明。
如果，没有函数声明，编译器默认做"隐式声明"。
- 隐式声明：【不要依赖】
  - 编译器认为所有的函数，返回值都是 int。
  - 可以根据函数调用，推测函数原型。
#include <xxx.h> 内部，包含函数声明。

exit 函数

return 关键字：
- 返回当前函数调用。将返回值返回调用者。（在底层，会调用 _exit() 函数。）
exit() 函数：
- 退出当前程序

// 函数声明
// int test(int a, char ch);
int test(int, char); // 函数声明de 简化写法。声明时，形参名 可以省略。

int main(void)
{
    // 函数调用
    int ret = test(10, 'a');  // test函数，调用结束，return 给 main

    printf("test函数返回: ret = %d\n", ret);

    // return 0;   // 返回给调用者（自动例程）-- 作用：结束程序。
    exit(0);   // 结束程序。
}

// 函数定义
int test(int a, char ch)
{
    printf("a = %d\n", a);
    printf("ch = %c\n", ch);

    // return 97;   // 返回给调用者。程序不结束。
    // 结束程序
    exit(97);   // 使用 #include <stdlib.h>
}

多文件编程

头文件守卫：为了防止头文件被重复包含。 --- head.h

#pragma once 是 VS 自动生成的。只应用于 windows 系统。

#ifndef _HEAD_H_    // 习惯写成这样。
#define _HEAD_H_
//... 头文件内容：#include <xx.h>/宏定义 #define PI 3.14/函数声明/类型定义
#endif

// 示例：
#ifndef _HEAD_H_    // 标准引入"头文件守卫"
#define _HEAD_H_

// include 头文件
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

// 函数声明
int add(int a, int b);
int sub(int a, int b);
// 宏定义
#define PI 3.14

// 类型定义


#endif

<> 包含的是，系统库头文件。
"" 包裹的是，用户自定义头文件。

// main函数所在的 .c 文件中：
#include "head.h"

第七章高级语法（指针）

指针

指针和内存单元

指针：地址！
指针变量：用存储地址的变量！
内存单元：是计算机中内存最小的存储单位。内存单元大小 —— 1字节(8bit位)。
- 每个内存单元，都有一个唯一的编号。
- 这个内存单元的编号，称之为"地址"

flowchart TB
    subgraph 内存
        M3["0000 0000"] --- M2["0000 0000"] --- M1["0000 0000"] --- M0["0000 1010"]
    end
    M3 --- A3["0xff03"]
    M2 --- A2["0xff02"]
    M1 --- A1["0xff01"]
    M0 --- A0["0xff00"]
    A0 -.-> M0
    M3 --- HIGH["高"]
    A0 --- LOW["低"]

int a = 10; 占用 4 字节（由 int 决定）

指针的定义和使用

int a = 10;
int *p = &a;

// printf("%p = %d\n", *p);  // 间接引用 -- 右值。
// 解引用、间接引用。
*p = 250;   // 间接引用 -- 左值。
printf("a = %d\n", a);

*p 作用：
- 将 p 变量的内容，取出，当成地址看待。找到该地址对应的内存空间。
  - 如果做左值，存储数据到空间中。
  - 如果做右值，取出空间中的内容。

指针类型大小

指针，算一种自定义数据类型。int *
指针的大小，与类型无关！只与当前使用的平台架构有关（32位：4字节、64位：8字节）。

int main(void)
{
    printf("int * 的大小：%u\n", sizeof(int*));
    printf("short * 的大小：%u\n", sizeof(short*));
    printf("char * 的大小：%u\n", sizeof(char*));
    printf("long * 的大小：%u\n", sizeof(long*));
    printf("long long * 的大小：%u\n", sizeof(long long *));
}

可以在一条语句中，同时定义多个指针变量、普通变量。

int a, b, c;   // 多个普通变量

int *p1, *p2, *p3;   // 多个指针变量。 每个变量都有一个自己的 *

int a, *b, *c, d;   // 定义整型变量a、d，同时定义指针变量 b、c

空指针和野指针

野指针

没有使用"有效"的地址，给指针初始化。

int* p;   // 没有给 p 指定一个有效地址。
*p = 1000;

p 指针变量有值，但是，该值不是一个有效的地址。

int* p = 10;   // 没有给 p 指定一个有效地址。
*p = 1000;

【结论】：编程时，杜绝野指针。

空指针

NULL == 0 == '\0'

int* p = NULL;   // #define NULL ((void *)0)   // 定义一个空指针。
*p = 1000;       // *p 所指向的内存空间，是一个"无效访问区域"。

泛型指针（万能指针 void *）

可以接受任意一种变量的地址，但是，在使用时【必须】借助"强制类型转换"具体化数据类型。
void * 类型的大小。32位：4字节。64位：8字节。

int main(void)
{
    printf("void * 的大小：%u\n", sizeof(void *));

    char ch = 'R';
    void* p;       // 泛型指针（万能指针）

    p = &ch;

    printf("*p = %c", *((char *)p));   // 将p变量类型，(i)void* 强制成 char *

    return EXIT_SUCCESS;
}

const 关键字

修饰变量

const int a = 20;   // a 为只读变量，不能修改。
//*a = 200;   // 不可以修改
int* p = &a;
*p = 677;
printf("a = %d\n", a);   // 借助指针可以修改 const 普通变量的值。

修饰指针

// 方式1
const int *p;   // 向后（右）作用

// 示例：
int a = 10;
int b = 20;
const int *p = &a;
*p = 500;   //【失败】：将 a 的值，改为 500。不能改！
p = &b;   //【成功】：可以修改 p 变量的内容（地址）。

// 方式2
int const *p;   // 向后（右）作用
// 作用方式同上！

常用：在函数内，限制指针所指向的内存空间，为只读（不允许修改）

指针和数组

数组名

数组名，是地址常量。 —— 不可以被修改。赋值（=、+=、-=、*=、/=、%= 带有副作用的运算符）

int a[3] = { 1,2,3 };   // a 就是数组地址。
int b[3];     // b 是常量
b = a;   // 不允许！！因为 b 是地址常量。

指针，是变量。可以使用数组名，给指针赋值。

int *p = a;   // a 就是数组地址。允许！！

取数组元素

int arr[] = {1, 3, 5, 7, 9};
int *p = arr;   // 使用数组地址，给p指针变量初始化

// 结论：
arr[0] == *(arr+0) == p[0] == *(p+0)
arr[1] == *(arr+1) == p[1] == *(p+1)
arr[2] == *(arr+2) == p[2] == *(p+2)
...
arr[N] == *(arr+N) == p[N] == *(p+N)

指针和数组名区别

指针是变量，数组名是常量。
sizeof（指针） ——> 4字节、8字节。
sizeof（数组名） ——> 数组实际的字节数。

指针的算术运算

数据类型对指针的作用

间接引用（解引用）：
- 指针的数据类型，确定了从指针存储的地址开始，向后读取的字节数。（与指针本身存储空间无关）
```
int a = 0x12345678;

//int* p = &a;
//int* p;   --- 0x12345678;
//short* p;   --- 0x5678;
char* p;   //  --- 0x78;
p = &a;

printf("%#x\n", *p);
```

加减运算。

指针的数据类型，决定了指针进行 +/- 操作时，向后/前跳过的字节数。

int *    +1   实际加过 4 字节。
short *  +1   实际加过 2 字节。
char *   +1   实际加过 1 字节。
long long *  +1   实际加过 8 字节。

指针++操作数组

int main(void)
{
    int arr[] = {1,2,3,4,5,6,7,8,9,0};
    int* p = arr;

    int n = sizeof(arr) / sizeof(arr[0]);

    //for (size_t i = 0; i < n; i++)
    //{
    //  printf("%d ", arr[i]);
    //}

    for (size_t i = 0; i < n; i++)
    {
        printf("%d ", *p);
        p++;    // p = p+1, 一次加过 一个 int 大小（一个数组元素）。
    }
    // p值随着循环，不断变化。 打印结束后，p指向一块无效的内存空间（野指针）
    printf("\n");

    return 0;
}

练习

练习：使用指针给空数组连续赋值。再使用"指针挪移"方法打印这个数组。

int main(void)
{
    int arr[10];
    int n = sizeof(arr) / sizeof(arr[0]);
    int* p = arr;   // p 指向 arr[0]
    printf("*p = %p\n", p);

    // 使用 指针，给空数组连续赋值。
    for (size_t i = 0; i < n; i++)
    {
        //arr[i] = i + 10;
        *(p + i) = 10 + i;    // *(p + i) == arr[i];
    }
    // 循环结束时，p指向谁？？ 依然指向 arr[0];
    printf("循环结束后：p = %p\n", p);

    // 使用"指针挪移"方法打印这个数组。
    for (size_t i = 0; i < n; i++)
    {
        printf("%d ", *p);
        p++;     // p = p+1, 一次加过 一个 int 大小（一个数组元素）。
    }
    printf("\n");
    // 循环结束时，p指向谁？？ 指向数组尾元素的下一个内存（野指针）。
    printf("2 for 循环结束后：p = %p\n", p);

    return 0;
}

指针 +- 整数

普通指针变量 + 整数

char *p;   p+1    偏过1个字节。
short *p;  p+1    偏过2个字节。
int *p;    p+1    偏过4个字节。

在数组中，+ 整数

short arr[] = {1, 3, 5, 8, 12, 17, 19};
short *p = arr+3;

p + 3;   向后（右）偏过 3 个元素。 6 个字节。
p - 2;   向前（左）偏过 2 个元素。 4 个字节。

&数组名 + 1

&数组名 + 1，加过的是一个数组的总大小。

int main(void)
{
    short arr[] = {1,2,3,4,5,6,7,8,9,0};
    printf("arr = %p\n", arr);
    printf("&arr[0] = %p\n", &arr[0]);
    printf("arr+1 = %p\n", arr+1);

    printf("&arr = %p\n", &arr);   // 取"整个数组"的地址。
    printf("&arr+1 = %p\n", &arr + 1);   // +1，跳过一个数组 short [10]
    return 0;
}

指针其他运算

指针 * / %
- 不允许！！！

指针+ - 指针

指针+ - 指针
- 不允许 error!

指针-指针：

普通变量来说，语法允许，但，无实际意义。
对于数组来说，得到偏移过的元素个数。

int main(void)
{
    int a[] = {1,2,3,4,5,6,7,8,9,0};
    int* p = a;   // 保存数组首地址。

    p = &a[3];   // 修改p保存的地址
    printf("p-a = %d\n", p - a);   // ---- 3

    int* q = &a[8];
    printf("q-p = %d\n", q - p);   // ---- 5

    return 0;
}

指针实现 strlen()

借助数组实现

// 数组实现
int myStrlen1(char str[])
{
    int i = 0;
    while (str[i] != '\0')
    {
        i++;
    }
    return i;
}

借助指针实现

// 指针实现
int myStrlen2(char str[])
{
    char* p = str;
    while (*p != '\0')
    {
        p++;
    }
    return p-str;   // 返回元素个数。
}

指针比较运算

普通变量。
- 语法允许，但无实际意义。

数组。

对于数组来说，地址之间可以比大小。得到元素存储的先后顺序。

int arr[] = {1,2,3,5,6,7,8};
int* p = &arr[2];

if (p > arr) {
    printf("成立\n");
}
else if (p < arr) {
    printf("不成立");
}
else {
    printf("==\n");
}

判断 NULL

int* p;
int a = 10;
// p = NULL  // 初始化空指针。
p = &a;

if (p != NULL)
{
    printf("p is not NULL\n");
}
else
{
    printf("p is NULL\n");
}

指针数组

指针数组的本质，是一个二级指针。

int a = 10;
int b = 20;
int c = 30;

int *arr[] = {&a, &b, &c};   // int型指针数组，保存地址的数组。

printf("*arr[0] = %d\n", *arr[0]);   // arr[0] == *(arr+0)
printf("*arr[0] = %d\n", *(arr + 0));
printf("**arr = %d\n", **arr);      // * 结合性，自右向左。

二维数组，是指针数组，是二级指针。

int a[] = { 10 };
int b[] = { 20 };
int c[] = { 30 };

int* arr[] = {a, b, c};   // 存地址。

printf("arr[0][0] = %d\n", arr[0][0]);
printf("(*(arr+0)) = %d\n", *(*(arr+0)));
printf("**arr = %d\n", **arr);   // 二级指针的简介应用。


## 第八章 高级语法（多级指针、指针和字符串）

### 多级指针

- 多级指针不能跳跃定义。有一级，才能定义二级；有二级才能定义三级；有三级，才能定义4级、。。。

```c
int a = 10;   // 普通变量
int *p = &a;       // 一级指针，是变量的地址。
int **pp = &p;     // 二级指针，是一级指针的地址。【重点】
int ***ppp = &pp;  // 三级指针，是二级指针的地址。
int ****pppp = &ppp;// 四级指针，是三级指针的地址。
......
*pp == pp == &p
**ppp == *pp == p == &a;
***pppp == **ppp == *p == a;

flowchart LR
    A["a 0xaa00"] --> P["p 0xaa00"]
    P --> PP["pp 0xbb00"]
    PP --> PPP["ppp 0xcc00"]

int a = 10;
*ppp == pp == &p
**ppp == *pp == p == &a
***ppp == **pp == *p == a

指针和函数

栈帧

当函数被调用时，系统会在 stack 空间上申请一块内存，用来给函数调用提供空间。存储形参和局部变量。（定义在函数内部的变量）。
函数调用结束时，这块内存空间，会被自动释放（消失）。

flowchart TB
    subgraph 程序运行空间
        subgraph 栈空间
            subgraph main栈帧
                A1["m"]:::active
            end
            subgraph test栈帧
                A2["a"]:::active
            end
        end
    end

传值和传址

传值（值传递）

函数调用期间，实参将自己的数据值，拷贝一份给形参。

// 定义函数，交换两个数。 -- 3杯水法
int swap1(int a, int b)   // a、b 形参
{
    int tmp = 0;   // 局部变量
    tmp = a;
    a = b;
    b = tmp;
}

int main(void)
{
    int m = 10;
    int n = 55;

    // 调用 函数 swap1，交换两个数。
    swap1(m, n);   // m、n 实参。

    system("pause");
    return EXIT_SUCCESS;
}

传址（传引用）

函数调用期间，实参将自己的"地址值"，拷贝一份赋值给形参。
- 可以在 A 栈帧中，借助地址，修改B栈帧上的变量数据。

// 定义函数，交换两个数。 -- 传引用（传址）
int swap2(int *a, int *b)   // a、b 形参。
{
    int tmp = 0;

    tmp = *a;
    *a = *b;
    *b = tmp;
}

int main(void)
{
    int m = 10;
    int n = 55;

    swap2(&m, &n);

    system("pause");
    return EXIT_SUCCESS;
}

数组做函数参数

数组做函数参数时，传递的不再是整个数组，而是数组的首地址（指针）。

int main(void)
{
    int arr[] = {1, 4, 6, 7, 9, 0};

    printf("main : sizeof(arr) = %u\n", sizeof(arr));   // 整个数组的大小。

    // 调用 test 函数，传参 数组。
    test(arr);   // 实参！

    system("pause");
    return EXIT_SUCCESS;
}

// 定义函数，用数组做参数
void test(int arr[])   // 形参
{
    printf("test : sizeof(arr) = %u\n", sizeof(arr));   // 指针的大小。

    printf("arr[0] = %d\n", arr[0]);
}

当整型数组做函数参数时，通常在函数定义中，封装2个参数，一个表数组首地址，另一个表元素个数。

// 冒泡排序
//void BubbleSort(int arr[])  这种传参，无法在函数内，求元素个数。
void BubbleSort(int arr[], int n)
{
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j < n - 1 - i; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main(void)
{
    int arr[] = {1, 4, 8, 12, 19, 43, 2, 7, 15};

    // 获取元素个数
    int n = sizeof(arr) / sizeof(arr[0]);

    // 排序
    BubbleSort(arr, n);

    // 打印排序后结果
    for (size_t i = 0; i < n; i++)
    {
        printf("%d ", arr[i]);
    }
    putchar('\n');

    return 0;
}

数组做函数参数，也可以写成指针的形式。（本质一样）

void Bubblesort(int arr[], int n) == void Bubblesort(int *arr, int n)

指针做函数返回值

指针做函数返回值，不能返回【局部变量的地址】。
- 当函数调用结束，栈帧空间释放，局部变量的地址，无效。
数组做函数返回值，不允许！（C语言中，只能写成指针形式）

指针和字符串

基本知识

char str1[] = {'h','i','\0'};  【麻烦】   变量，可读可写。
char str2[] = "hi";                 变量，可读可写。
char *str3 = "hi";                  常量，只读。
char *str4 = {'h','i','\0'};   //  错误！

演示 demo1：

char *str2 = "hello" 是一个常量。不允许修改。

int main0401(void)
{
    char str1[] = "hello";   // 相当于 {'h','e','l','l','o','\0'}
    char* str2 = "";

    str1[0] = 'R';   // 相当于 {'h','e','l','l','o','\0'}是变量，可以随意修改。
    printf("%s\n", str1);

    str2[0] = 'R';   // "hello" 是字符串常量。 不能修改！
    printf("%s\n", str2);

    system("pause");
    return EXIT_SUCCESS;
}

演示 demo2：

同一个字符串常量，可以给多个不同的指针赋值。
char* str2 = "hello" 和 char* n = "hello"，地址值都相同。都是字符串"hello"的地址。

int main(void)
{
    char str1[] = "hello";   // 相当于 {'h','e','l','l','o','\0'}
    char m[] = "hello";

    char* str2 = "hello";
    char* n = "hello";

    printf("str1 = %p\n", str1);
    printf("m    = %p\n", m);   // 数组定义的 hello 地址不同。

    printf("str2 = %p\n", str2);
    printf("n    = %p\n", n);   // 指针定义的 hello 是字符串常量。是同一个地址。

    system("pause");
    return EXIT_SUCCESS;
}

【结论】：当字符串（含有 \0 字符数组），做函数参数时，不需要提供 2 个参数。因为每个字符串都有 \0。

练习

字符串比较（strcmp() 函数）

比较 str1 和 str2，如果相同返回 0，不同则依次比较ASCII码，str1 > str2 返回 1，否则返回 -1
- 按对应的位置，比较字符的大小。不比较ASCII 码和。
分析：
- 循环，依次比较两个字符串中对应位字符。\0 结束。都相同 ---> 0
- 对应位不同，比较字符的 ASCII 码。 str1 > str2 ---> 1；str1 < str2 ---> -1

// 数组的实现方式
int myStrcmp(char *str1, char *str2)
{
    int i = 0;
    while (str1[i] == str2[i])   // *(str1+i) == *(str2+i)
    {
        if (str1[i] == '\0')
        {
            return 0;    // 2个字符串，一样!
        }
        i++;
    }
    // str1 和 str2 有字符不同。
    return str1[i] > str2[i] ? 1 : -1;
}

// 指针的实现方式
int myStrcmp2(char* str1, char* str2)
{
    while (*str1 == *str2)   // *(str1+i) == *(str2+i)
    {
        if (*str1 == '\0')
        {
            return 0;    // 2个字符串，一样!
        }
        str1++;
        str2++;
    }
    // str1 和 str2 有字符不同。
    return *str1 > *str2 ? 1 : -1;
}

字符串拷贝（strcpy 函数）

将一个字符串中的所有字符，依次拷贝存放到另一空字符数组中。

// 数组版：
void myStrcpy(char* src, char* dst)
{
    int i = 0;
    while (src[i] != '\0')   // while(src[i] != 0)   while(strc[i])
    {
        dst[i] = src[i];
        i++;
    }
    dst[i] = '\0';   //main中的 dst 初始化为0。此步可以省略。
}

// 指针版
void myStrcpy2(char* src, char* dst)
{
    while (*src != '\0')   // while(src[i] != 0)   while(strc[i])
    {
        *dst = *src;
        src++;
        dst++;
    }
    *dst = '\0';   //main中的 dst 初始化为0。此步可以省略。
}

在字符串中查找字符出现的位置（strchr 函数）

"helloworld" 'e' ---> "elloworld"
'l' ---> "lloworld"
'r' ---> "rld"

// 指针版
char* myStrchr(char* str, char ch)
{
    while (*str)   //while (*str != '\0')  ==while (*str != 0)
    {
        if (*str == ch)
        {
            return str;
        }
        str++;
    }
    return NULL;   // 在 str 中，没有找到 ch
}

// 数组版
char* myStrchr2(char* str, char ch)
{
    int i = 0;
    while (str[i])   //while (str[i] != '\0') == while (str[i] != 0)
    {
        if (str[i] == ch)    // str[i] == *(str+i)
        {
            return &str[i];
        }
        i++;
    }
    return NULL;   // 在 str 中，没有找到 ch
}

字符串去空格

"ni chou sha ? chou ni za di ! " ---> "nichousha?chounizadi!"

// 封装函数，去除字符串中空格  --- 数组版
void str_no_space(char* src, char* dst)
{
    int i = 0;     // 遍历 src 字符串
    int j = 0;     // 记录 dst存储位置。
    while (src[i])
    {
        if (src[i] != ' ')    // 只有不为空格，才存到 dst中。
        {
            dst[j] = src[i];
            j++;        // 不为空格，后移。为空格，j不动。
        }
        i++;
    }
    dst[j] = '\0';
}

// 封装函数，去除字符串中空格  --- 指针版
void str_no_space2(char* src, char* dst)
{
    while (*src)
    {
        if (*src != ' ')    // 只有不为空格，才存储到 dst中。
        {
            *dst = *src;
            dst++;     // 不为空格，指针后移。为空格，指针不动
        }
        src++;
    }
    *dst = '\0';
}

int main(void)
{
    char str[] = "ni chou sha ? chou ni za di ! zai chou yi ge shi shi";
    char dst[1024] = {0};

    // 调用函数，去除 str中的空格，保存到 dst 中
    // str_no_space(str, dst);
    str_no_space2(str, dst);

    printf("dst = %s\n", dst);

    system("pause");
    return EXIT_SUCCESS;
}

带参数的 main 函数

无参版：
```
int main(void) { return 0; }
```

有参版：

int main(int argc, char *argv[]) { return 0; }
    参数1：表示给 main 函数传递的参数的 总个数。
    参数2：是一个数组，数组的每一个元素都是 字符串 （char *）

测试代码：

int main(int argc, char *argv[])
{
    int i = 0;

    for (i = 0; i < argc; i++)
    {
        printf("argv[%d] = %s\n", i, argv[i]);
    }

    system("pause");
    return EXIT_SUCCESS;
}

测试方法

在终端中，使用 gcc 编译得到可执行文件，如 test.exe
不能获取带有空格的字符串！！！空格是分隔符。

gcc 09-带参数的main.c -o test.exe

test.exe aa bb cc dd ee
test.exe hello world haha xixi hoho heihei .....
argc: --- 6
argv[0] = test.exe
argv[1] = aa
argv[2] = bb
argv[3] = cc
argv[4] = dd
argv[5] = ee

在 VS 中，项目名称上右键 —— 属性 —— 配置属性 —— 调试 —— 命令行参数 —— 写入待测试的命令行参数。

字符串练习

str 中 substr 出现的次数

str : "hellolllolllolllo "
substr: "llo"

写函数测试，llo 在 "hellolllolllolllo" 出现了多少次。

学习、使用 strstr() 函数。再实现上述的题目。

求字符串非空格元素个数

"ni chou sha ? chou ni za di ! zai chou yi ge shi shi" 统计这里，除空格外 字符 的个数。

字符串逆置

"hello" ---> "olleh"
"word" ---> "drow"

判断字符串是回文

abcba --- 是回文
amkilolikma --- 是回文。
abccba --- 是回文。
abcdba --- 不是回文。

第九章高级语法（字符串和内存管理）

字符串练习

str 中 substr 出现的次数

str = "hellollloabclllollo "
substr: "llo" strlen("llo")

写函数测试，llo 在 "hellolllolllolllo" 出现了多少次。

strstr() 函数

#include <string.h>
char *strstr(const char *haystack, const char *needle);
char *strstr(const char *str, const char *substr);
    参数1：原串
    参数2：子串
    返回值：
        成功：返回子串在原串中的位置（地址值）
        失败：NULL

测试 strstr()

// 测试 strstr
int main(void)
{
    char* ret = strstr("hellollloabclllollo", "llo");
    printf("str = %s\n", ret);

    system("pause");
    return EXIT_SUCCESS;
}

count = 0;
strstr("hellolllollo", "llo")  ---> "llolllollo"   --->count++
"llolllollo" += strlen("llo");  ---> "llollo"
strstr("llollo", "llo")  ---> "llollo"   ---> count++
"llollo" += strlen("llo");  ---> "llo"
strstr("llo", "llo")  ---> "llo"   --->count++
"llo" += strlen("llo");  ---> ""
strstr("", "llo")  ---> NULL

// 封装函数，统计 str字符串中，substr出现的次数
int substr_times(char* str, char* substr)
{
    int count = 0;  // 定义变量统计substr出现的次数。
    char *p = strstr(str, substr);   // ---> "llollloabclloxyzllollo";

    // 循环的截取 str 串，判断剩余 str串中是否包含 substr
    while (p != NULL)     // while (p)
    {
        count++;
        p += strlen(substr);     // "llollloabclloxyzllollo";

        p = strstr(p, substr);
    }
    return count;
}

// 在 str字符串中，找子串 substr出现的次数
int main(void)
{
    char str[] = "hell9qaqllloabclloxyzlmllollo";
    char substr[] = "llo";

    int ret = substr_times(str, substr);
    printf("%s 串中，%s 子串 出现 %d 次\n", str, substr, ret);

    system("pause");
    return EXIT_SUCCESS;
}

求字符串非空格元素个数

"ni chou sha ? chou ni za di ! zai chou yi ge shi shi" 统计这里，除空格外 字符 的个数。

// 统计非空格数
int no_space_num(char* str)
{
    int count = 0;
    // 指针方式实现。
    char* p = str;
    while (*p)
    {
        if (*p != ' ')
        {
            count++;
        }
        p++;
    }
    return count;
}

int main(void)
{
    char str[] = "hello ni hao ma world?";

    int ret = no_space_num(str);

    printf("ret = %d\n", ret);

    system("pause");
    return EXIT_SUCCESS;
}

字符串逆置

"hello" ---> "olleh"
"word" ---> "drow"

参考"数组逆置"实现，day05

// h e l l o
// 字符串的逆序
void str_inverse(char* str)
{
    char* start = str;       // 记录首个元素的地址
    char* end = str + strlen(str)-1;    // 记录最后一个元素的地址

    // 循环交换字符串首尾元素
    while (start < end)
    {
        char tmp = *start;      // 三杯水交换字符元素。
        *start = *end;
        *end = tmp;

        start++;   // 首元素指针后移
        end--;     // 尾元素指针前移
    }
}

int main(void)
{
    char str[] = "this is a test";

    str_inverse(str);

    printf("%s\n", str);

    system("pause");
    return EXIT_SUCCESS;
}

判断字符串是回文

// 判断字符串是否是回文
int str_is_abcba(char* str)
{
    char* start = str;
    char* end = str + strlen(str) - 1;

    while (start < end)
    {
        if (*start != *end)
        {
            return 0;     // 不是回文
        }
        start++;
        end--;
    }
    return 1;
}

int main(void)
{
    char str[] = "abcmmcba";

    int ret = str_is_abcba(str);
    if (ret == 1)     // 是回文
    {
        printf("%s 是回文！\n", str);
    }
    else if (ret == 0)
    {
        printf("%s 不是回文！\n", str);
    }

    system("pause");
    return EXIT_SUCCESS;
}

字符串处理函数

全部都是标准C库函数。使用头文件 #include <string.h>

字符串拷贝

strcpy

char *strcpy(char *dest, const char *src);    // src:source  dest:dst

将 src 的内容，拷贝给 dest。返回 dest，dest空间要足够大。
- strcpy 函数，不去检查 dest 是否足够大。 ——【不安全函数】
函数调用结束，返回值和 dest 结果一致。

// 字符串拷贝
int main(void)
{
    char str[] = "you will be die if you copy me!";

    char dst[100] = { 0 };

    char *p = strcpy(dst, str);

    printf("dest = %s\n", dst);
    printf("*p = %s\n", p);

    system("pause");
    return EXIT_SUCCESS;
}

strncpy

char *strncpy(char *dest, const char *src, size_t n);    // 安全

将 src 的内容，拷贝给 dest。只拷贝 n 个字节。dest空间要足够大。通常 n 与 dest 的空间大小一致。

特性：

n > src：只拷贝 src 大小。
n < src：只拷贝 n 个字节。不会自动添加 \0

// 测试
int main(void)
{
    char str[] = "hello world";

    char dst[100] = { 0 };

    char* p = strncpy(dst, str, sizeof(dst));

    //for (size_t i = 0; i < 10; i++)
    //{
    //  printf("%c\n", p[i]);
    //}

    printf("%s\n", p);

    system("pause");
    return EXIT_SUCCESS;
}

字符串拼接

strcat

char *strcat(char *dest, const char *src);

将 src 中内容，拼接到 dest 后。返回拼接成功的字符串。——需要保证 dest 空间足够大。
函数调用结束后，dest 和返回值结果相同。

int main(void)
{
    char str[] = "hello world";

    char dst[100] = "haha hoho xixi";

    char *p = strcat(dst, str);

    printf("p = %s\n", p);
    printf("dst = %s\n", dst);

    system("pause");
    return EXIT_SUCCESS;
}

strncat

char *strncat(char *dest, const char *src, size_t n);

将 src 中前 n 个字符，拼接到 dest 后。返回拼接成功的字符串。——需要保证 dest 空间足够大。
函数调用结束后，dest 和返回值结果相同。

// 字符串拼接 strncat
int main(void)
{
    char str[] = "hello world";

    char dst[100] = "haha hoho xixi";

    char* p = strncat(dst, str, 7);

    printf("p = %s\n", p);
    printf("dst = %s\n", dst);

    system("pause");
    return EXIT_SUCCESS;
}

字符串比较

字符串比较可以使用 > < >= <= == !=，字符串不允许使用。

strcmp

int strcmp(const char *s1, const char *s2);

比较 s1 和 s2 两个字符串，如果相等返回 0；
如果不相等，进一步比 s1 和 s2 对应位上的 ASCII 码值。
- s1 > s2 返回 1
- s1 < s2 返回 -1

int main(void)
{
    char s1[] = "helloz";

    char s2[] = "helloworld";

    printf("ret = %d\n", strcmp(s1, s2));    // 不比较 ASCII 的 和

    system("pause");
    return EXIT_SUCCESS;
}

strncmp

int strncmp(const char *s1, const char *s2, size_t n);

比较 s1 和 s2 两个字符串的前 n 个字符，如果相等返回 0；
如果不相等，进一步比 s1 和 s2 对应位上的 ASCII 码值。（不比较 ASCII 的和）

char s1[] = "helloz";
char s2[] = "helloworld";
printf("ret = %d\n", strncmp(s1, s2, 5));   --- 0

字符串格式化输入、输出

s —— string.

sprintf

int sprintf(char *str, const char *format, ...);
// ... 代表 这是一个参数可变的函数。

对应 printf 记忆。作用将原来输出到屏幕的"格式化字符串"，写到参数1的 str 中。

// printf("%d + %d = %d\n", 10, 24, 10+24);

char str[1024] = {0};     // 保证空间足够大
sprintf(str, "%d + %d = %d\n", 10, 24, 10 + 24);    // 写到 str 中。不打印屏幕

puts(str);
printf("---%s", str);

sscanf

int sscanf(const char *str, const char *format, ...);

对应 scanf 记忆。作用将原来从键盘获取到的"格式化字符串"，从参数1的 str 中获取。

int a, b, c;

// scanf("%d+%d=%d", &a, &b, &c);    // 从键盘 stdin 读取。

char str[] = "10+20=30";       // 提供给 sscanf 参数1 使用。

int ret = sscanf(str, "%d+%d=%d", &a, &b, &c);

printf("a = %d\n", a);
printf("b = %d\n", b);
printf("c = %d\n", c);

字符串查找字符、子串

strchr

char *strchr(const char *s, int c);

在字符串 s 中，找字符 c 出现的位置。返回字符在字符串中的地址。

// 字符串中找字符出现位置 strchr
int main(void)
{
    printf("%s\n", strchr("hellohehexixihoho", 'i'));

    system("pause");
    return EXIT_SUCCESS;
}

strrchr

r: right

char *strrchr(const char *s, int c);

自右向左，在字符串 s 中，找字符 c 出现的位置。返回字符在字符串中的地址。

int main(void)
{
    //printf("%s\n", strchr("hellohehexixihoho", 'i'));
    printf("%s\n", strrchr("hellohehexixihoho", 'x'));

    system("pause");
    return EXIT_SUCCESS;
}

strstr

char *strstr(const char *str, const char *substr);

在字符串 str 中，找寻子串 substr 第一次出现的位置。返回地址。

字符串分割

strtok

char *strtok(char *str, const char *delim);
    参数1：待拆分字符串
    参数2：分割符组成的字符串。 strtok("www.baidu.com", ".");  // 写成 '.' 错误！

按照（参2）既定的分割符，来拆分字符串。www.baidu.com 按 "." 拆分。

// 测试1：
int main(void)
{
    char str[] = "www.itcast.cn";   // ---> "www\0itcast.cn";
    char *p = strtok(str, ".");     // strtok调用完成，会将 分割符用 \0 替换。

    printf("p = %s\n", p);

    // 调用一次 strtok 分割之后，再去打印原串 str
    for (size_t i = 0; i < 13; i++)
    {
        //printf("%c\n", str[i]);
        printf("%d\n", str[i]);   // 打印每个字符的 ASCII码
    }

    system("pause");
    return EXIT_SUCCESS;
}

结论：
- strtok() 函数，直接在原串上对字符串分割。不能分割字符串常量。char *str = "hello";
- strtok() 函数调用结束，会将分割符，替换成 \0
- 第一次用 strtok 拆分，参数1 传待拆分的原串中。第1+次拆分，参数1 传 NULL。

// 字符串分割 strtok
int main(void)
{
    char str[] = "www.itcast.cn.net.com";   // ---> "www\0itcast.cn";
    //char *str = "www.itcast.cn.net";    // 字符串常量。

    char *p = strtok(str, ".");     // strtok调用完成，会将 分割符用 \0 替换。

    printf("p = %s\n", p);

    // 循环按 "." 拆分 剩余 字符串。
    while (1)
    {
        p = strtok(NULL, ".");
        if (p == NULL)
        {
            break;
        }
        printf("p = %s\n", p);
    }
}

练习：
- 拆分字符串 "www.itcast.cn$This is a test$for strtok"，按分割符 "$".

//拆分 字符串 "www.itcast.cn$This is a test$for strtok"，按 分割符 "$" ...
int main(void)
{
    char str[] = "www.itcast.cn$This is a test$for strtok";

    // 调用第一次
    char* p = strtok(str, ".$");   // 分割符有3个：'.' / '$' / ' ' 空格
    printf("p = %s\n", p);

    // 后续 N+1次调用。while循环，参数NULL
    while (1)
    {
        p = strtok(NULL, ".$");
        if (p == NULL)
        {
            break;
        }
        printf("循环中 p = %s\n", p);
    }

    system("pause");
    return EXIT_SUCCESS;
}

字符串转换

a: 代表字符串 string.
将字符串转换成数、小数、长整数、长长整型。
使用这类函数进行转换时，要求原串必须是可转换的字符串。
- 错误使用："abc123"、"yxac123"、"1245dke89" 不能正确转换。

atoi

#include <stdlib.h>
int atoi(const char *nptr);

double atof(const char *nptr);
long atol(const char *nptr);
long long atoll(const char *nptr);

示例：

char str1[] = "12abc3456";
int num = atoi(str1);
printf("num = %d\n", num);

char str2[] = "3.14";
double num2 = atof(str2);
printf("num2 = %lf\n", num2);

char str3[] = "34568490354";
long long num3 = atoll(str3);
printf("num3 = %lld\n", num3);

内存管理

局部变量

概念：
- 定义在函数内部的变量。
作用域：
- 从定义位置开始，到包裹该变量的第一个右大括号结束。（函数作用域、块作用域。）

void test(void)
{
    {
        int m = 10;   // 局部变量。 -- 块作用域。出了 } 不能使用。
    }
    printf("---m = %d\n", m);

    //int i = 0;
    for (size_t i = 0; i < 10; i++)
    {
        printf("m = %d\n", m);
    }
    //printf("i = %d\n", i);
}

全局变量

概念：
- 定义在函数外部的变量。
作用域：
- 从定义位置开始，默认到本文件内部。其他文件如果想使用，可以通过"声明"的方式，将作用域导出。

static 变量

static 全局变量

定义语法：
- 在全局变量定义之前，添加 static 关键字。如：static int a = 10;
作用域：
- 被限制在本文件内部，不允许通过"声明"方式导出作用域。（java不同）

static 局部变量

定义语法：
- 在局部变量定义之前，添加 static 关键字。
作用域：
- 从定义位置开始，到包裹该变量的第一个右大括号结束。
特性：
- 静态局部变量，只定义一次。相当于，在全局位置定义。通常用来做计数器。

void test08(void)
{
    static int b = 10;   // 静态局部变量
    printf("%d\n", b++);
}

int main(void)
{
    for (size_t i = 0; i < 10; i++)
    {
        test08();   // 调用 test08 10 次。
    }

    system("pause");
    return EXIT_SUCCESS;
}

static 函数

全局函数：
- 就是"函数"。
- 定义语法：函数原型 + 函数体。
static 函数：
- 定义语法：static 函数原型 + 函数体。
- 特性：
  - static 函数，只能在本文件内使用。其他文件即使声明也无法使用。

// A.c 文件中有如下代码
// static 关键字修饰 test09 函数限制在本文件内。 外部文件，不能访问
static void test09(void)
{
    for (size_t i = 0; i < 5; i++)
    {
        printf("i = %d\n", i);
    }
}

//-------------------

//B.C 文件中调用上述函数。由于 static， B.C 不能使用 test09函数，会报错！
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

// void test09(void);   // 声明函数
extern void test09(void);   // 声明函数

int main(void)
{
    test09();

    system("pause");
    return EXIT_SUCCESS;
}

生命周期

助记：
- 生命周期：出生 --- 死亡 80岁。生命周期：80年。
- 作用域：班花：全班。村长：全村。县长：全县。

局部变量：定义位置开始，函数调用结束（存储在栈stack上）。 —— 函数被调用期间。
全局变量：从程序启动开始（早于 main() 函数），程序终止结束。 —— 程序执行期间。
static 局部变量：从程序启动开始，程序终止结束（定义在全局位置）。 —— 程序执行期间。
static 全局变量：从程序启动开始，程序终止结束。 —— 程序执行期间。
全局函数：从程序启动开始，程序终止结束。 —— 程序执行期间。
static 函数：从程序启动开始，程序终止结束。 —— 程序执行期间。

命名冲突

如果全局变量和局部变量命名冲突。采用就近原则。
强烈不推荐！

内存4区模型

代码段：.text 段。存储程序源码（二进制形式）
数据段：只读数据段 .rodata、初始化数据段 .data、未初始化数据段 .bss。
stack：栈。在其之上开辟帧栈。（较小：windows：1M~10M，Linux：8M~16M）
- 存储特性：后进先出 FILO (LIFO)
heap：堆。给用户自定义提供空间。（较大：约1.3G+）

Heap 堆空间

开劈/释放 heap 空间

在 heap 上开劈空间

#include <stdlib.h>

void *malloc(size_t size);    // 向 系统申请内存空间，在 heap 上。单位：字节。
    参数：申请空间的大小。
    返回值：
        成功：heap 内存空间的首地址。
        失败：NULL
// 申请成功的内存，通常拿来当成"数组" 使用

释放 heap 申请的空间

void free(void *ptr);
    参：就是 malloc 函数的返回值。

示例：

int main(void)
{
    // int arr[10];
    // 申请能存储 10 个 int 数的空间。 40字节。
    int *p = (int *)malloc(sizeof(int)*10);    // 强转的目的，方便阅读代码。
    if (p == NULL)
    {
        printf("malloc error\n");
        return -1;   // 退出程序。 -1, 非正常结束。
    }

    // 写 - 数据到 malloc 申请的空间
    for (size_t i = 0; i < 10; i++)
    {
        p[i] = i + 10;   // 存 数据到 malloc 申请的空间中。
    }

    // 从malloc申请的空间中，读数据。
    for (size_t i = 0; i < 10; i++)
    {
        printf("%d ", *(p+i));
    }
    printf("\n");

    // 释放malloc申请的空间。
    free(p);

    system("pause");
    return EXIT_SUCCESS;
}

使用 heap 空间注意事项

申请的 heap 堆内存空间连续，当成"数组"使用。
free 后的空间，不会立即失效。通常将 free后的地址，置为 NULL。
free 地址必须是 malloc 函数返回的地址。否则，报错！
如果 malloc 后的地址一定会变化，通常使用临时变量 tmp 保存。

二级指针对应的 heap 空间

内存操作函数

memset

#include <string.h>
void *memset(void *s, int c, size_t n);

memcpy

void *memcpy(void *dest, const void *src, size_t n);

memmove

void *memmove(void *dest, const void *src, size_t n);

memcmp

int memcmp(const void *s1, const void *s2, size_t n);

内存常见问题

申请 0 字节空间
- C 语言中，允许申请 0 字节的内存空间。
- 0 字节的空间，不能拿来使用。
free 空指针
- 空 NULL 指针，反复 free，不会报错。
- 非空的指针，反复 free，会报错！！！ —— 推荐 free 后的指针，一定置 NULL。
越界访问
- 不允许！！！导致程序崩溃。
free ++ 后的地址
- 不能正常释放。
- 如果程序中，必须要将 p++，定义临时变量，保存 p 值。以便 free 释放。

第十章高级语法（内存管理、结构体、联合体）

heap 空间操作

二级指针对应的 heap 空间

int **p = int *p[3] ==> (int *, int *, int *) ==> [(1, 2, 3, 54, 5), int *, int *]

flowchart LR
    A["malloc(12) int* int* int*"] --> B["10 / 29 / 34 / ..."]
    A --> C["10 / 29 / 34 / ..."]
    A --> D["10 / 29 / 34 / ..."]

int main(void)
{
    // 给外层空间malloc申请内存
    int** p = malloc(sizeof(int *) * 3);
    if (p == NULL)
    {
        printf("malloc error!\n");
        return -1;
    }
    // 给 内层指针 申请 malloc 空间
    for (size_t i = 0; i < 3; i++)
    {
        p[i] = malloc(sizeof(int) * 5);
        if (p[i] == NULL)
        {
            printf("malloc p[i] error!\n");
            return -1;
        }
    }
    // 使用空间 -- 写
    for (size_t i = 0; i < 3; i++)
    {
        for (size_t j = 0; j < 5; j++)
        {
            p[i][j] = i + j;    // 随意初始化值。
        }
    }
    // 使用空间 -- 读
    for (size_t i = 0; i < 3; i++)
    {
        for (size_t j = 0; j < 5; j++)
        {
            printf("%d ", *(*(p + i) + j));    // p[i][j] == *(p+i)[j] == *(*(p+i)+j)
        }
        printf("\n");
    }

    // free空间时，应该先释放 内层空间，再释放外层
    for (size_t i = 0; i < 3; i++)
    {
        free(p[i]);
        p[i] = NULL;
    }

    // 释放外层空间
    free(p);
    p = NULL;

    system("pause");
    return EXIT_SUCCESS;
}

以 char **p 为例

// 先申请外层指针。
char **p = malloc(sizeof(char *) * 5);
// 申请内层指针
for (int i = 0; i<5; i++)
{
    p[i] = malloc(sizeof(char) * 10);    // 字符串长度 <= 10个字符。
}
// 写
for (int i = 0; i<5; i++)
{
    // p[i] = "hello";  错误!
    strcpy(p[i],"hello");
}
// 释放外层
for (int i = 0; i<5; i++)
{
    free(p[i]);
    p[i] = NULL;
}
// 释放外层
free(p);
p = NULL;

内存操作函数

以 4 个函数，专门用来操作 heap 内层。stack 由系统自动申请，自动释放。

memset

#include <string.h>
void *memset(void *s, int c, size_t n);
    参1：内存首地址。
    参2：置成什么。一般传 0
    参3：内存大小。单位：字节。
    返回值：
        成功：设置后的地址。
        失败：NULL

memset(首地址, 0, 空间大小);

绝大多数，memset 用来将申请好的 heap 内存，置 0。 —— 单位：字节。

int* p = (int *)malloc(sizeof(int) * 10);
if (p == NULL)
{
    printf("malloc error");
    return -1;
}
// 将申请好的内存，全部置 0
memset(p, 0, sizeof(int) * 10);

// 直接打印申请好的空间内容。
for (size_t i = 0; i < 10; i++)
{
    printf("%d ", p[i]);
}

free(p);
p = NULL;

memset 函数按"字节"设置。
- 置 0 ——> 每一个字节都为 0。
- 置 1 ——> 每一个字节都为 1。 —— 4字节 == 0x01010101 == 16843009

memcpy

以字节为单元，内存拷贝。strcpy ——> 只能拷贝字符串。

void *memcpy(void *dest, const void *src, size_t n);

// 拷贝内存中的整型数据
int arr[10] = { 1, 2, 3, 4, 5 };
int arr2[10];

memcpy(arr2, arr, sizeof(int)*10);

for (size_t i = 0; i < 10; i++)
{
    printf("%d ", arr2[i]);
}
printf("\n");

// 拷贝内存中的字符串
char str[] = "hello world";
char p[100];
//memcpy(p, str, strlen(str)+1);   // 按内存拷贝
strcpy(p, str);    // 字符串拷贝
strncpy(p, str, strlen(str) + 1);

printf("p = %s\n", p);

memmove

作用完全等同于 memcpy，以字节为单元，内存拷贝。---- 安全的！
拷贝的 src 和 dest 之间如果有重叠，memcpy由于底层实现原因，有可能出错。推荐使用 memmove。

void *memmove(void *dest, const void *src, size_t n);

memcmp

以字节为单位，比较内存！
作用可以完全参照，strncmp。
规则：s1 == s2 --> 0, s1 > s2 --> 1, s2 < s2 --> -1

int memcmp(const void *s1, const void *s2, size_t n);

int arr1[] = { 14, 56, 22, 59, 21, 49, 25, 86, 89, 66, 71, 31, 98 };
int arr2[] = { 14, 56, 29, 59, 21};

int ret = memcmp(arr1, arr2, 5 * sizeof(int));

printf("ret = %d\n", ret);

函数内申请空间使用

A 函数内申请空间，A 函数使用

注意上述 4 点。

int *p = malloc(10);
free(p); p = NULL;

A 函数内申请空间，B 函数使用

例1

// A函数中申请空间，B函数使用。
int* func1(void)
{
    int* p = malloc(4);
    *p = 456;
    return p;    // 返回的 heap 堆空间的地址值，函数调用结束，地址 有效。
    //return &p;    // 返回的 stack 栈空间的地址值，函数调用结束，地址 无效。
}

int main(void)
{
    int* ret = NULL;
    ret = func1();

    printf("%d\n", *ret);
    free(ret);
    ret = NULL;

    system("pause");
    return EXIT_SUCCESS;
}

例2

// A函数中申请空间，B函数使用。
int* func2(int *p)
{
    p = malloc(4);
    return p;
}

int main(void)
{
    int* ret = NULL;
    ret = func2(ret);

    *ret = 345;    // 写
    printf("%d\n", *ret);    // 读

    free(ret);
    ret = NULL;

    system("pause");
    return EXIT_SUCCESS;
}

例3

void func3(int** p)    // int** 是一级指针的地址。
{
    *p = malloc(4);
}

int main(void)
{
    int* ret = NULL;

    func3(&ret);    // 传 一级指针的地址。
    // func3 函数，调用完成，ret指针，不在为 NULL，而是指向一块有效的 heap 空间地址。
    *ret = 789;
    printf("%d\n", *ret);

    free(ret);
    ret = NULL;

    system("pause");
    return EXIT_SUCCESS;
}

结构体

结构体定义语法

复合类型：用户自定义类型：int []、int *、char **、struct student

// 定义结构体类型
struct student {
    int age;       // 成员变量 -- 属性。不能被赋初值。
    int num;
    char name[10];
};
// 用结构体类型，定义变量。
struct student a;    // 定义了一个结构体类型的变量 a。

以上定义了一个结构体类型。名字叫 struct student。
- struct student 的地位，等同于 int、char、short、char *、int[]、long long
通常结构体类型定义在全局位置。或者，放到 xxx.h 头文件。
头文件：

// 头文件守卫
#ifndef _XXX_H_
#define _XXX_H_
/* #include、宏定义、函数声明、类型定义（结构体类型）。
#endif

普通结构体变量

定义语法

struct student stu1, stu2, stu3;    // 一次定义3个变量。没赋初值。
struct student stu = {18, 1, "Andy"};

访问成员方法

使用 . 访问成员。

// 定义一个结构体变量，赋初值。
struct student stu = {18, 1, "Andy"};

printf("first: age = %d, name = %s, num = %d\n",
    stu.age, stu.name, stu.num);

stu.age = 118;
stu.num = 119;
//stu.name = "cuihua";    // name为地址常量，不能被赋值。
strcpy(stu.name, "cuihua");

printf("last: age = %d, name = %s, num = %d\n",
    stu.age, stu.name, stu.num);

普通变量使用 "->" 访问成员 ---- 不常用！

(&stu)->age = 118;
(&stu)->num = 119;

结构体指针变量

定义语法

struct student *p1, *p2, *p3;    // 一次定义3个指针变量。野指针！！！

访问成员方法

使用 "->" 访问成员。
避免野指针、空指针：

// 1. struct student stu, *p1; //一次定义两个结构体变量，一个普通变量stu。另一指针变量p1
p1 = &stu;    // 给指针初始化。

// 2. struct student *p1;
p1 = (struct student *)malloc(sizeof(struct student));

指针使用 "." 访问成员。 ---- 不常用！

(*p1).age = 18;
strcpy((*p1).name, "cuihua");
(*p1).num = 119;

非常规定义语法（了解）

struct student {
    int age;
    int num;
    char name[10];
} s1, *s2;    // 定义结构体类型的同时，定义1个结构体变量 s1, 一个指针变量s2

struct {    // 匿名结构体
    int age;
    int num;
    char name[10];
} s3, *s4;    // 定义匿名结构体类型的同时，定义1个结构体变量 s3, 一个指针变量s4。

// 无法再定义其他变量。

结构体数组

struct student {
    int age;
    int num;
    char name[10];
};
struct student stu[5] = {{18, 1, "Andy"}, {19, 2, "Lucy"}, {118, 3, "李四"}};
int n = sizeof(stu) / sizeof(stu[0]);
for (int i = 0; i<n; i++)
{
    printf("age=%d,num=%d,name=%s\n", stu[i].age, stu[i].num, stu[i].name);
}

struct student *stu; // 要求指针指向能存储3个student 元素的空间，并给3个元素赋初值。访问。

struct student *stu;    // 野指针.

// 得到到heap堆空间，当成数组使用。
stu = malloc(sizeof(struct student)*3);    // 等价于 struct student stu[3];

// 给数组的第1个元素赋值。
stu[0].age = 11;
stu[0].num = 111;
strcpy(stu[0].name, "aaa");

// 给数组的第2个元素赋值。
stu[1].age = 22;
stu[1].num = 222;
strcpy(stu[1].name, "bbb");

// 给数组的第3个元素赋值。
stu[2].age = 33;
stu[2].num = 333;
strcpy(stu[2].name, "ccc");

//int n = sizeof(stu) / sizeof(stu[0]);    // 不能求元素个数。

for (int i = 0; i < 3; i++)
{
    printf("age=%d,num=%d,name=%s\n", stu[i].age, stu[i].num, stu[i].name);
}

free(stu);
stu = NULL;

结构体嵌套

struct person {
    int age;
    char name[10]);
    // 类型
};
struct student {
    struct person man;    // person 类型的变量，作为 student 类型成员。
    int id;
    char addr[100];
};

int main(void)
{
    struct student stu = {{18, "zhaolu"}, 1, "北京朝阳区"};

    printf("age = %d\n", stu.man.age);
    printf("name = %s\n", stu.man.name);
    printf("addr = %s\n", stu.addr);

    // 修改
    stu.man.age = 119;
    strcpy(stu.man.name, "张三丰");
    strcpy(stu.addr, "武当山");

    printf("\nage = %d\n", stu.man.age);
    printf("name = %s\n", stu.man.name);
    printf("addr = %s\n", stu.addr);

    system("pause");
    return EXIT_SUCCESS;
}

做函数参数、返回值

结构体变量赋值

主要应用于，函数调用期间，实参给形参赋值。
要求：
- 结构体变量赋值时，必须类型相同、成员个数一致、顺序一致。

做参数、返回值

传值：
- 结构体变量做函数参数，将结构体变量的值(实参)，拷贝一份给形参。
- 形参、实参共 2 份结构体。
传址：
- 结构体指针变量做函数参数，将结构体的地址值做实参，拷贝一份给形参。
- 形参、实参共 1 份结构体。
结论：
- 结构体做函数参数、返回值时，通常采用 "传址" 方式，节省空间。

void func08(struct student **m)
{
    *m = malloc(sizeof(struct student));
    if (NULL == *m)
    {
        printf("malloc error\n");
        return -1;
    }
    //p->age = 100;
    //p->num = 1;
    //strcpy(p->name, "zyx");
    (*m)->age = 100;
    (*m)->num = 1;
    strcpy((*m)->name, "zyx");
}

int main(void)
{
    struct student* p = NULL;    // 空指针

    func08(&p);

    //p->age = 100;
    //p->num = 1;
    //strcpy(p->name, "zyx");

    printf("age=%d, name=%s, num=%d\n", p->age, p->name, p->num);

    free(p);
    p = NULL;

    system("pause");
    return EXIT_SUCCESS;
}

含有指针成员的结构体

申请内存：先申请外层空间，再申请内层空间。
释放内存：先释放内层空间，再释放外层空间。

struct student {
    int age;
    int num;
    char *name;    // 野指针.
};

int main(void)
{
    struct student* p;    //野指针.

    // 给 p 初始化堆空间
    p = malloc(sizeof(struct student));
    if (NULL == p)
    {
        printf("malloc p error\n");
        return -1;
    }
    // 给成员变量 name 开辟堆空间
    p->name = malloc(sizeof(char) * 100);
    if (NULL == p->name)
    {
        printf("malloc p->name error\n");
        return -1;
    }
    // 写数据到结构体中
    p->age = 100;
    p->num = 10;
    strcpy(p->name, "张三丰");

    printf("age=%d, name=%s, num=%d\n", p->age, p->name, p->num);

    // 先释放内层空间
    free(p->name);
    p->name = NULL;

    free(p);
    p = NULL;

    return 0;
}

typedef 关键字

给现有的数据类型起别名。【注意】：不能定义新的数据类型。

typedef unsigned int  size_t;    // 给 unsigned int 起别名叫 size_t

int a;    a 是变量。
typedef int a;    a 变成了 类型名。 a b;    定义一个整型变量 b. (可读性差)

通常使用 typedef 定义过的类型，添加一个 "_t" 结尾。
定义语法：
- typedef 旧类型名新类型名_t;

typedef struct student {
    int age;
    int num;
    char *name;    // 野指针.
} stu_t;    // 新类型名：stu_t;
// 定义变量
struct student stu1;    // 依然可以正常使用
stu_t stu2;    // 定义一个 struct student 类型的变量。

使用 typedef 的好处：
1. 简化类型名。
2. 便于代码的修改和维护。

typedef long long int32_t;    // int ----> long long

struct student {
    int age;
    int32_t num;
    char *name;    // 野指针.
    int32_t num1;
    int32_t num2;
    int32_t num3;
    int32_t num4;
} stu_t;

共用体（联合体）

union test {
    char ch;
    short sh;
    int var;
};    // 创建一个联合体类型。

特性：
- 内部所有成员变量的地址一致。等同于整个联合体的地址。
- 联合体的大小，是内部成员变量中，最大的那个成员的大小。（对齐）
- 修改其中一个成员的值，其他成员的值也跟着变化。

flowchart LR
    subgraph struct [struct test]
        direction TB
        s1["var 4字节"]
        s2["sh 2字节"]
        s3["ch 1字节"]
    end
    subgraph union [union test]
        direction TB
        u1["4字节"]
        u2["共享区域"]
    end

typedef union test {
    char ch;
    short sh;
    int var;
} test_t;

int main(void)
{
    test_t obj;

    obj.var = 0x87654321;

    printf("&obj       = %p\n", &obj);
    printf("&obj.ch = %p\n", &obj.ch);
    printf("&obj.sh = %p\n", &obj.sh);
    printf("&obj.var= %p\n", &obj.var);

    printf("sizeof(test_t) = %u\n", sizeof(test_t));

    printf("var = %#x\n", obj.var);
    printf("sh  = %#x\n", obj.sh);
    printf("ch  = %#x\n", obj.ch);

    obj.ch = 0xAA;

    printf("var = %#x\n", obj.var);
    printf("sh  = %#x\n", obj.sh);
    printf("ch  = %#x\n", obj.ch);

    system("pause");
    return EXIT_SUCCESS;
}

第十一章高级语法（文件基础）

枚举

语法：enum 枚举名 { 枚举常量 };

enum color {red, green, blue, black, pink, yellow};

枚举常量：
- 必须是整型常量，不允许是浮点数。可以是负值。默认值从 0 开始，后续常量较前一个 +1
- 可以给任意一个常量赋初值，后续常量较前一个 +1。

enum color {red, green=-5, blue, black, pink=-18, yellow};

示例：

//enum color { red, green = -5, blue, black, pink = 18, yellow };
enum { red, green = -5, blue, black, pink = 18, yellow };

int main(void)
{
    int flg = 2;
    if (flg == blue)
    {
        printf("blue is -4\n");
    }
    else
    {
        printf("bule is not %d, blue=%d\n", flg, blue);
    }

    printf("red = %d, yellow = %d\n", red, yellow);

    system("pause");
    return EXIT_SUCCESS;
}

文件

系统文件

scanf -- 键盘 -- 标准输入 -- stdin -- 0
printf -- 屏幕 -- 标准输出 -- stdout -- 1
perror -- 屏幕 -- 标准错误 -- stderr -- 2

以上 3 个文件，为系统文件。应用程序启动时，这3个文件被系统自动打开，程序执行结束，由系统自动关闭（隐式回收）。

fclose(stdout);    // 关闭文件。
printf("hello world\n");    // 报错！！！

文件分类

设备文件：（与硬件有直接关系）
- 屏幕、键盘、网卡、声卡、显卡、扬声器 …
磁盘文件：
- 文本文件：文件内容为 ASCII 码
- 二进制文件：文件内容为二进制编码数据。

文件指针

普通指针

int *p;    // 野指针.
p = &a;    // 初始化方法1
p = malloc()    // 初始化方法2

文件指针

FILE *fp;    // 野指针.

文件指针，借助"文件操作函数"来改变 fp 为空、为野的情况！
- 举例：fopen()---> 将 fp 变为非野。

flowchart LR
    A["FILE *fp 野指针"] -->|"fopen()"| B["打开的文件描述信息"]
    B <--> C["内存"]
    C <--> D["磁盘"]

操作文件，可以使用的函数：fputc、fgetc、fputs、fgets、fread、fwrite ...

文件操作一般步骤

打开文件：fopen() ------> FILE *fp;
读写文件：fputc、fgetc、fputs、fgets、fread、fwrite...
关闭文件：fclose()

文件操作

打开、关闭文件

打开文件

#include <stdio.h>
FILE *fp;    // 野指针
FILE * fopen(const char * filename, const char * mode);
    参1：待打开的文件名（访问路径）
    参2：文件打开权限。（如字，值多前3个）
        r：只读方式打开文件，文件如果不存在，报错！存在，以只读方式打开。
        w：只写方式打开文件，文件如果不存在，创建一个空文件。文件已经存在，清空并打开。
        w+：读、写方式打开文件，文件如果不存在，创建一个空文件。文件已经存在，清空并打开。
        r+：读、写方式打开文件，文件如果不存在，报错！存在，以读、写方式打开。
        a：以追加方式打开文件。
        b：操作二进制文件使用的。(windows)
    返回值：
        成功：返回打开文件的文件指针(fp) 【强调】：这个fp指针，不使用"解引用"操作数据。
        失败：NULL

关闭文件

#include <stdio.h>
int fclose(FILE * stream);
    参：打开的文件fp（fopen()返回值）
    返回值：
        成功：0
        失败：-1

示例：

int main(void)
{
    FILE* fp;

    // 打开文件
    //fp = fopen("C:\\itcast\\test.txt", "r");    // 错误传参
    //fp = fopen("C:\\itcast\\test.txt", "r");    // 正确传参
    //fp = fopen("C:/itcast/test.txt", "r");    // 正确传参
    //fp = fopen("C:/itcast/test2.txt", "r");    // 指定r打开，文件不存在，报错
    fp = fopen("C:/itcast/test2.txt", "w");    // 指定w打开，文件不存在创建，存在，清空
    if (fp == NULL)
    {
        perror("fopen error");    // printf("fopen error\n");
        return -1;
    }

    // 读写文件...

    // 关闭
    int ret = fclose(fp);
    printf("ret = %d, ----------finish\n", ret);

    system("pause");
    return EXIT_SUCCESS;
}

绝对、相对路径

绝对路径：
- 从系统磁盘的盘符开始，找到待访问的文件的路径。
- windows 下的书写方法：
  1. C:\\users\\afei\\Desktop\\TTTTTT\\01-复习.avi
  2. C:/users/afei/Desktop/TTTTTT/01-复习.avi -- 也是 Linux 系统。
相对路径：
1. 如果在 VS 环境下，使用 Ctrl+F5 编译执行，文件的相对路径是相对于 day11.vcxproj 所在目录位置。不是相对于 .c 文件。
2. 如果双击 .c 文件同级目录下的 Debug 目录下的 xxx.exe 文件，文件的相对路径是相对于 xxx.exe 所在的目录位置。
3. 如果 gcc 生成的 xxx.exe 文件，运行。文件的相对路径是相对于 xxx.exe 所在的目录位置。

按字符写文件 fputc

int fputc(int ch, FILE * stream);    // 将指定一个字符，写入指定文件
    参1：待写入的 字符
    参2：打开的文件 fp （fopen的返回值）
    返回值：
        成功：写入到文件中的那个字符的 ASCII
        失败：-1

练习：创建一个新文件，向该文件中写入 26 个大写英文字母。

int main(void)
{
    char* filename = "03test.txt";    // 相对路径
    int ret = 0;
    char ch = 'A';

    FILE* fp = fopen(filename, "w");    // 文件存在，会清空
    if (NULL == fp)
    {
        perror("fopen error");
        return -1;
    }
    // 循环写26个大写字母 到 文件中。
    while (ch <= 'Z')
    {
        ret = fputc(ch, fp);
        ch++;
    }

    ret = fclose(fp);
    printf("ret = %d, ----------finish\n", ret);

    system("pause");
    return EXIT_SUCCESS;
}

fputc 向文件中写字符时，文件读写指针（参照光标理解），会自动后移。

按字符读文件 fgetc

int fgetc(FILE * stream);    // 从指定文件中，读取一个字符。
    参：待读取的文件fp(fopen()的返回值)
    返回值：
        成功：实际读到的字符的ASCII
        失败：-1

void read_file(void)
{
    char* filename = "03test.txt";
    int ret = 0;
    char ch = 0;    // 存储读到的字符

    FILE* fp = fopen(filename, "r");    // r方式打开有文件。
    if (NULL == fp)
    {
        perror("fopen error");
        return -1;
    }
    // 从文件中读 字符
    while (1)
    {
        ch = fgetc(fp);
        //printf("ch = %c\n", ch);
        if (ch == EOF)    // 已经读到文件末尾.
        {
            break;
        }
        printf("ch = %c\n", ch);    // 写到这里，不读 EOF 结束标记。
    }

    ret = fclose(fp);
    printf("ret = %d, ----------finish\n", ret);
}

int main(void)
{
    //write_file();
    read_file();    // 读一个已经存有数据的文件
    system("pause");
    return EXIT_SUCCESS;
}

fgetc 在读取文件时，文件读写指针（参照光标理解），会自动后移。
文本文件，结束处，系统会自动添加一个结束标记 EOF --> -1 (#define EOF -1)
- 文件关闭时，系统自动添加。

feof 函数

int feof(FILE * stream);    // 判断是否到达文件结尾。
    参：fopen()返回值
    返回值：
        到达文件结尾 ---> 非0【真】
        没到达文件结尾 ---> 0【假】

作用：
- 用来判断文件是否到达结尾。既能判断文本文件，也能判断二进制文件。
特性：
- 要想使用 feof() 判断到达文件结尾，在 feof() 调用之前，必须要有读文件的函数调用。

FILE* fp = fopen("04test.txt", "r");
if (NULL == fp)
{
    perror("fopen error");
    return -1;
}

while (1)
{
    printf("没有到达文件结尾\n");
    // 没有这个fgetc函数读文件，feof函数，无法正常判断到达文件结尾。
    fgetc(fp);    // 一次读一个字符，读到的字符直接丢弃！
    if (feof(fp))
    {
        break;
    }
}

fclose(fp);

按行读文件 fgets

获取一个字符串，以 \n 作为结束标记。自动添加 \0。空间足够大，读 \n。空间不足，舍弃 \n。一定会预留空间存 \0

char * fgets(char *str, int size, FILE * stream);
    参1：用来存储字符串的空间首地址
    参2：空间大小
    参3：数据来源的文件fp。
    返回值：
        成功：返回实际读到的字符串。
        失败：NULL

// 示例：
char buf[10];
printf("%s", fgets(buf, 10, stdin));    "hello" ---> hello\n\0
printf("%s", fgets(buf, 10, stdin));    "helloworld" ---> helloworl\0

按行写文件 fputs

写出一个字符串，到文件中。如果字符串中没有 \n，不会写 \n

int fputs(const char * str, FILE * stream);
    参1：将写出的字符串首地址。
    参2：写出源的文件fp。
    返回值：
        成功：0
        失败：-1

// 示例：
char *str = "hello";
fputs(str, stdout);    ----> 不添加 \n

练习：接收用户键盘输入，写入文件

获取用户键盘输入，将所有内容，写入文件。规定：如果用户输入了 ":wq"，终止接收用户输入，将之前读到的数据，保存成一个文件。
提示：
- 从 stdin 中读入到程序中。写出到文件 fp。
- feof() 在本题中用不上，用 strcmp 判断读到的句子，是不是 ":wq\n"。

// 练习：接收用户键盘输入，写入文件。遇见 :wq 停止接收，保存成文件
int main(void)
{
    // 创建文件，具备写权限
    FILE* fp = fopen("05test.txt", "w");
    if (NULL == fp)
    {
        perror("fopen error");
        return -1;
    }

    // 创建一个空间，保存读到的数据内容
    char buf[MAX] = { 0 };

    // 从键盘读
    while (1)
    {
        fgets(buf, MAX, stdin);
        // 每读的一行数据，都判断是否是 ":wq\n"
        if (strcmp(buf, ":wq\n") == 0)
        {
            break;    // 用户输入了结束标志，终止读入，保存文件。
        }
        // 写入fp 文件中
        fputs(buf, fp);
    }

    // 关闭文件。
    fclose(fp);

    system("pause");
    return EXIT_SUCCESS;
}

练习：文件版四则运算

说明：
文件中有表达式：

//四则运算.txt
10/2=
10*3=
4+3=
8-6=

读出表达式，运算，将结果写回文件。

//四则运算.txt
10/2=5
10*3=30
4+3=7
8-6=2

分析：
- 10/2= ---> fgets(buf, 4096, 四则运算.txt 对应的 fp) ---> "10/2=\n" ---> 10 / 2 =
- strtok()、sscanf()-->选sscanf()实现 ---> sscanf(buf, "%d%c%d=\n", &a, &ch, &b) -->
- a = 10, b = 2, ch ='/'

switch (ch) {
case '/':
    ret = a / b;
    break;
case '*':
    ret = a * b;
    break;
...
}

fopen("", "w") 清空原来只有表达式没有结果的文件，将带有结果的表达式直接覆盖。
拼接上述字符串，使用 sprintf() / strcat() --> "10/2=5\n10*3=30\n4+3=7\n8-6=2\n"
最终写出：char result[] "10/2=5\n10*3=30\n4+3=7\n8-6=2\n" ---fputs(result, fp)
实现

#define BUF_MAX 4096

// 写算式到文件中
void write_file06(void)
{
    FILE* fp = fopen("C:/itcast/四则运算.txt", "w");
    if (NULL == fp)
    {
        perror("fopen error");
        return;    // 退出函数调用。
    }

    fputs("10/2=\n", fp);
    fputs("10*3=\n", fp);
    fputs("4+3=\n", fp);
    fputs("10-2=\n", fp);

    fclose(fp);
}

// 从文件中读算式、提取、拆分、计算、写回
void read_file06(void)
{
    // 创建存储算式的 空间
    char buf[BUF_MAX] = { 0 };
    // 创建空间，保存算式及运算结果
    char str[BUF_MAX] = { 0 };
    // 创建空间，保存 4 个带有结果的算式
    char result[BUF_MAX] = { 0 };

    // 定义变量，保存运算数和运算符，结果
    int a, b, ret;
    char ch;

    FILE* fp = fopen("C:/itcast/四则运算.txt", "r");
    if (NULL == fp)
    {
        perror("fopen error");
        return;    // 退出函数调用。
    }
    // 循环读取文件中的算式
    while (1)
    {
        fgets(buf, BUF_MAX, fp);    // buf = "10/2=\n\0"

        // 判断是否到达文件结尾。
        if (feof(fp))
        {
            break;
        }

        // 将 sscanf 的返回值强转为 void
        (void)sscanf(buf, "%d%c%d=\n", &a, &ch, &b);    // a:10  b:2  ch:'/'
        // 根据不同的运算符，做不同运算
        switch (ch) {
        case '/':
            ret = a / b;
            break;
        case '*':
            ret = a * b;
            break;
        case '+':
            ret = a + b;
            break;
        case '-':
            ret = a - b;
            break;
        default:
            printf("运算符错误\n");
            break;
        }
        // 拼接 ret 到 算式上。
        sprintf(str, "%d%c%d=%d\n", a, ch, b, ret);    // 10/2=5

        // 测试、是否能正常获取数据，拼接成带结果的表达式。
        //printf("%s", str);

        // 拼接 4 个子算式，到 一个 大空间中
        strcat(result, str);
    }

    // 测试、拼接 4 个子算式、到 一个 大空间中、打印输出。
    printf("%s", result);

    fclose(fp);

    // 清空原来没有结果的算式所在的文件。
    fp = fopen("C:/itcast/四则运算.txt", "w");
    if (NULL == fp)
    {
        perror("fopen error");
        return;    // 退出函数调用。
    }
    // 将既有算式，又有结果的字符串，写入到同一个文件中。
    fputs(result, fp);

    fclose(fp);
}

int main(void)
{
    // 测试写出算式到文件。
    write_file06();

    getchar();    // 从键盘读一个字符，如果用户不输入，程序不继续，阻塞等。

    // 测试读取算式
    read_file06();

    system("pause");
    return EXIT_SUCCESS;
}

getchar() 函数
- 从键盘获取一个字符。返回 ASCII。如果用户不输入，程序都向后执行。
putchar() 函数
- 向屏幕输出一个字符。
- putchar('m');

第十二章高级语法（文件进阶）

格式化读写文件

fprintf() 函数

printf ---- sprintf ---- fprintf
- 变参函数，参数列表中，有 "..."。最后一个固定参数通常是一个模式描述串(包含格式匹配符)，函数实际调用时传递的参数的个数、类型、顺序，由这个固定参数决定。

printf("hello");
printf("%s", "hello");
printf("%d = %d%c%d\n", 10+5, 10, '+', 5);    ----> 屏幕

char buf[1024];    // 内存空间 --- 缓冲区
sprintf(buf, "%d = %d%c%d\n", 10+5, 10, '+', 5)    ----> buf 中

函数原型

#include <stdio.h>
int fprintf(FILE * stream, const char * format, ...);    ----> 文件fp 中

测试

FILE* fp = fopen("abc", "w");    // 相对路径法
if (!fp)    // NULL == fp
{
    perror("fopen error");
    return -1;
}

fprintf(fp, "%d%c%d=%d\n", 10, '+', 7, 10+7);

fclose(fp);

fscanf() 函数

scanf ---- sscanf ---- fscanf

int m;
scanf("%d", &m);                键盘 ---> m

char str[] = "98";
sscanf(str, "%d", &m);          str ---> m

FILE *fp = fopen("r");
fscanf(fp, "%d", &m);           fp指向的文件中 ---> m

函数原型

int fscanf(FILE * stream, const char *format, ...);

测试：

int a, b, c;
char ch;

FILE* fp = fopen("abc", "r");    // 相对路径法
if (!fp)    // NULL == fp
{
    perror("fopen error");
    return -1;
}

(void)fscanf(fp, "%d%c%d=%d\n", &a, &ch, &b, &c);

printf("a = %d\n", a);
printf("b = %d\n", b);
printf("c = %d\n", c);
printf("ch = %c\n", ch);

printf("%d%c%d=%d", a, ch, b, c);

fclose(fp);

格式化读写特性（扩展知识）

返回值

int fprintf(FILE * stream, const char * format, ...);

fprintf() 函数的返回值：
- 成功：实际写入文件的字符个数。
- 失败：-1

int fscanf(FILE * stream, const char * format, ...);

fscanf() 函数的返回值：
- 成功：正确匹配的个数。
- 失败：-1

fscanf 读取特性

边界溢出问题。存储读取数据的空间，在使用之前，应该进行清空。否则会出现边界溢出异常。
- 清空：memset(buf, 0, sizeof(buf));
fscanf 函数，每次在调用的同时，都会判断，下一次调用是否能成功匹配参2，如果不匹配提前结束读取文件（feof(fp) 为真）

练习：文件版排序

生成随机数，写入文件。将文件内乱序随机数读出，排好序再写回文件。

// 生成随机数，写入文件
void write_rand(void)
{
    FILE* fp = fopen("test03.txt", "w");    // 相对路径法
    if (!fp)    // NULL == fp
    {
        perror("fopen error");
        return -1;
    }

    // 播种种机种子
    srand(time(NULL));
    for (size_t i = 0; i < 10; i++)
    {
        //int num = rand() % 100;    // 0 -- 99
        fprintf(fp, "%d\n", rand() % 100);    // 将生成的随机数写入到文件。
    }

    fclose(fp);
}

void BubbleSort(int* src, int len)
{
    for (int i = 0; i < len - 1; i++)
    {
        for (int j = 0; j < len - 1 - i; j++)
        {
            if (src[j] > src[j + 1])
            {
                int temp = src[j];
                src[j] = src[j + 1];
                src[j + 1] = temp;
            }
        }
    }
}

// 从文件中，读取随机数
void read_rand(void)
{
    // 定义数组，存储 10 个随机数
    int arr[10] = { 0 }, i = 0;

    FILE* fp = fopen("test03.txt", "r");    // 相对路径法
    if (!fp)    // NULL == fp
    {
        perror("fopen error");
        return -1;
    }
    // 循环读取文件内的随机数
    while (1)
    {
        (void)fscanf(fp, "%d\n", &arr[i]);
        i++;
        if (feof(fp))    // 先存储，后判断，防止最后一个元素丢失。
        {
            break;
        }
    }
    // 使用冒泡排序
    BubbleSort(arr, sizeof(arr)/sizeof(arr[0]));

    fclose(fp);    //关闭随机数据的文件

    // 清空 随机数据的文件
    fp = fopen("test03.txt", "w");
    if (!fp)    // NULL == fp
    {
        perror("fopen error");
        return -1;
    }

    for (size_t i = 0; i < 10; i++)
    {
        fprintf(fp, "%d\n", arr[i]);    // 将排好序的数组写入到文件。
    }

    fclose(fp);
}

int main(void)
{
    write_rand();

    getchar();    // 从键盘获取一个字符，如果用户不输入，就阻塞程序，不向下执行。

    read_rand();

    printf("--------------finish\n");

    system("pause");
    return EXIT_SUCCESS;
}

按块读写文件

读写函数	对应关系
fgetc	fputc
fgets	fputs
fprintf	fscanf

以上 3 组函数，默认用来处理文本文件。

fwrite - fread 既可以处理文本文件，也可以处理二进制文件。

fwrite() 函数

写出数据到文件中。

#include <stdio.h>
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
    参1：待写出的数据的首地址。
    参2：待写出数据的大小（一次写多大）
    参3：写出的个数（写多少次）    写出数据的总大小 = 参2 x 参3
    参4：文件fp
    返回值：
        成功：永远返回参3。通常调用函数时，将 参2传1，参3代表实际写出的字节数。
        失败：0
// fwrite 函数，写入数据到文件中时，是按 二进制 写入。

测试

typedef struct student {
    int age;
    char name[10];
    int num;
} stu_t;

// 按块写文件、fwrite
void write_struct(void)
{
    // 定义结构体数组
    stu_t stu[4] = {
        18, "afei", 10,
        20, "andy", 20,
        30, "lily", 30,
        16, "james", 40
    };

    FILE* fp = fopen("test04.txt", "w");    // 相对路径法
    if (!fp)    // NULL == fp
    {
        perror("fopen error");
        return ;
    }

    int ret = fwrite(&stu[0], 1, sizeof(stu_t) * 4, fp);
    if (ret == 0)
    {
        perror("fwrite error");
        return ;
    }
    printf("ret = %d\n", ret);

    fclose(fp);
}

fread() 函数

从文件fp中读取数据。

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
    参1：读取到的数据存放的地址。
    参2：一次读取数据的字节数（一次读多大）
    参3：读多少次    读出数据的总大小 = 参2 x 参3
    参4：文件fp
    返回值：
        成功：永远返回参3。 通常调用函数时，将 参2传1，参3代表实际读出的字节数。
        0 : 1) 读失败
            2) 到达文件结尾 == feof(fp)为真

测试

typedef struct student {
    int age;
    char name[10];
    int num;
    char addr[100];
} stu_t;

// 按块读文件、fread，一次读一个 stu_t 元素
void read_struct(void)
{
    FILE* fp = fopen("test04.txt", "r");    // 相对路径法
    if (!fp)    // NULL == fp
    {
        perror("fopen error");
        return;
    }

    stu_t s1;

    // 从文件中，按块读取。
    int ret = fread(&s1, 1, sizeof(stu_t), fp);
    printf("ret = %d\n", ret);

    printf("age=%d, name=%s, num=%d\n", s1.age, s1.name, s1.num);

    fclose(fp);
}

// 按块读文件、fread，一次读所有 stu_t 元素
void read_struct2(void)
{
    FILE* fp = fopen("test04.txt", "r");    // 相对路径法
    if (!fp)    // NULL == fp
    {
        perror("fopen error");
        return;
    }

    stu_t s1[10];    // stu_t *s1 = malloc(sizeof(stu_t) * 1024);
    int i = 0;

    // 从文件中，循环按块读取。
    while (1)
    {
        int ret = fread(&s1[i], 1, sizeof(stu_t), fp);
        //if (ret == 0)    // 效果一样。
        if (feof(fp))    // 效果一样。
        {
            printf("读取到文件结尾\n");
            break;
        }
        printf("age=%d, name=%s, num=%d\n", s1[i].age, s1[i].name, s1[i].num);
        i++;
    }
    fclose(fp);
}

练习：大文件拷贝

已知一个任意类型的文件，对该文件复制，产生一个相同的新文件。
实现思路：
1. 打开两个文件。一个 "r"，另一个 "w"
2. 从 r 中 fread，fwrite 写到 w 文件中
3. 循环读，判断到达文件结尾，跳出循环。
4. 关闭2个文件。
注意: 在windows下，打开二进制文件（mp4, MP3, avi, jpg）读写，需要 "b"。如："rb"、"wb"

int main(void)
{
    // 创建一个缓存区（内存空间），用来存储读到的数据。
    char buf[4096] = { 0 };
    int ret = 0;

    FILE* rfp = fopen("C:\\users\\afei\\Desktop\\TTTTTT\\11-午后回顾.avi", "rb");
    if (!rfp)
    {
        perror("fopen error");
        return -1;
    }
    FILE* wfp = fopen("mycopy.avi", "wb");
    if (!rfp)
    {
        perror("fopen error");
        return -1;
    }

    // 循环从文件中读，写到另一个文件中。
    while (1)
    {
        ret = fread(buf, 1, sizeof(buf), rfp);
        if (ret == 0)
        {
            break;    // 读到文件末尾。
        }
        printf("ret = %d\n", ret);
        // 没有读到文件末尾，将实际读到的数据，"原封不动"的写入 wfp 中。
        fwrite(buf, 1, ret, wfp);
    }

    fclose(rfp);
    fclose(wfp);

    system("pause");
    return EXIT_SUCCESS;
}

随机位置读写文件

强调：文件读写指针，在一个文件内，只有一个。读、写都使用这一个。

fseek

#include <stdio.h>
int fseek(FILE *stream, long offset, int whence);    // 修改文件偏移量(文件读写指针)
    参1：文件fp
    参2：偏移量（矢量：正数向后，负数向前）
    参3：偏移的起始位置
        SEEK_SET：文件开头位置
        SEEK_CUR：当前位置
        SEEK_END：文件结尾位置
    返回值：成功：0    失败：-1

ftell

long ftell(FILE *stream);    // 获取文件偏移量（文件读写指针位置）
    返回值：从当前读写位置，到文件起始位置的偏移量。

// 借助 ftell(fp) + fseek(fp, -50, SEEK_END) 来求取文件大小。

rewind

void rewind(FILE *stream);    // 回卷文件读写指针，将文件读写指针移动到起始位置。
// 相当于：fseek(fp, 0, SEEK_SET);

其他文件相关操作

Linux 和 Windows 文件区别

对于二进制文件操作，Windows 下必须要使用 "b"。Linux下二进制文件和文本文件操作没区别。
windows下的回车换行 \r\n，回车 \r，换行 \n。Linux 下回车换行 \n。
对文件指针：
- 先写后读可以直接操作。windows 和 Linux 一致。
- 先读后写。Linux无序修改。Windows下需要在写操作之前，添加 fseek(fp, 0, SEEK_CUR) 函数调用，获取文件读写指针，再来写。才能生效。

int main(int argc, char* argv[])
{
    FILE* fp = fopen("test1.txt", "r+");

    char buf[6] = { 0 };
    char* ptr = fgets(buf, 6, fp);

    printf("buf=%s, ptr=%s\n", ptr, buf);

    fseek(fp, 0, SEEK_CUR);    //获取文件读写指针。如果没有这句，win下程序会崩溃。

    int ret = fputs("AAAA", fp);
    printf("ret = %d\n", ret);

    fclose(fp);

    return 0;
}

获取文件状态

ftell(fp) + fseek(fp, 0, SEEK_END) 可以获取文件大小。此种方法获取文件大小，必须要打开文件，文件打开、关闭操作，对于系统而言，系统资源消耗较大。

#include <sys/types.h>
#include <sys/stat.h>
int stat(const char *path, struct stat *buf);    // status
    参1：文件访问路径
    参2：文件属性结构体指针（传出参数：函数调用结束时，充当函数返回值）
    返回值：成功：0    失败：-1
// 示例：
struct stat buf;
stat("待打开文件", &buf);
buf.st_size    获取文件的实际大小。

获取文件大小

struct stat buf;

int ret = stat("test06.txt", &buf);    // buf传出参数
printf("ret = %d\n", ret);

printf("获取文件的大小为：%d\n", buf.st_size);

删除、重命名文件

int remove(const char *pathname);    // 删除

int rename(const char *oldpath, const char *newpath);    // 重命名


// 重命名：
//int ret = rename("test06.txt", "呜呜哈嘿.txt");
//printf("ret = %d\n", ret);

// 删除文件
int ret = remove("呜呜哈嘿.txt");
printf("ret = %d\n", ret);

缓冲区刷新

flowchart LR
    A[程序] -->|"写入数据"| B["缓冲区 (512B)"]
    B -->|"刷新到"| C["磁盘 磁道 扇区"]
    C -->|"读入"| B
    B -->|"读取数据"| A

磁盘：物理操作，速度慢。 内存：电子操作，速度快。 缓冲区：存在的意义，一次性物理访问磁盘盘过程时，尽可能多的读数据，保存在内存中。 预读入、缓输出。

标准输出 -- stdout -- 标准输出缓冲区。
- 写给屏幕的数据，都是先存入缓冲区中，由缓冲区一次性刷新到物理设备（屏幕）
标准输入 -- stdin -- 标准输入缓冲区。
- 从键盘读取的数据，直接读到缓冲区，由缓冲区给程序提供数据。
缓冲机制：
1. 行缓冲：遇到 \n 刷新缓冲区的数据到物理设备上。printf();
2. 全缓冲：缓冲区存满，数据才刷新到物理设备上、文件。
3. 无缓冲：缓冲区中只要有数据，立即刷新到物理设备。perror
手动刷新缓冲区的方法：

#include <stdio.h>
int fflush(FILE *stream);
    参：文件fp
    返回值：成功：0    失败：-1

当文件关闭时，会强制刷新缓冲区，写入磁盘。 —— 隐式回收
隐式回收：关闭文件，刷新缓冲区，释放malloc申请的内存。

int main(void)
{
    FILE* fp = fopen("test10.txt", "w-");
    if (!fp)
    {
        perror("fopen error");
        return -1;
    }
    char ch = 0;

    while (1)
    {
        (void)scanf("%c", &ch);
        if (ch == ':')
        {
            break;
        }
        fputc(ch, fp);

        // 手动刷新缓冲区，写入物理磁盘。
        fflush(fp);
    }
    fclose(fp);    // 当文件关闭时，会强制刷新缓冲区，写入磁盘。

    system("pause");
    return EXIT_SUCCESS;
}

第十三章练习（电话簿管理系统）

实现流程

定义联系人的数据结构（结构体）
创建存储联系人数据的 static 全局数组和记录联系人实际数量的 static 全局变量。
搭建电话簿的主业务逻辑框架（工作流程）
定义并实现相应的功能函数
1. 添加联系人
2. 删除联系人
3. 查找联系人
4. 显示联系人
组织上述功能函数的调用逻辑。
整体测试、微调。

框架搭建1

main.c

// 管理程序运行的主业务逻辑
#define _CRT_SECURE_NO_WARNINGS
#include "telephoneBook.h"

// 定义枚举，使用枚举常量描述事件
enum {ADD=1, DEL, SREACH, SHOW, EXIT};

// 显示菜单
void show_menu(void)
{
    printf("---------显示菜单-----------\n");
}

// 电话簿启动、工作
void startworking(void)
{
    // 电话簿具体工作内容
    while (1)
    {
        // 显示菜单
        show_menu();

        // 接收用户输入(1.添加，2.删除，3.查找，4.显示，5.退出)
        int number = 0;
        printf("请在菜单中选择您的需求：");
        (void)scanf("%d", &number);

        // 根据用户输入，作用相应操作
        switch (number)
        {
        case ADD:
            printf("1. 添加联系人\n");
            break;
        case DEL:
            printf("2. 删除联系人\n");
            break;
        case SREACH:
            printf("3. 查找联系人\n");
            break;
        case SHOW:
            printf("4. 显示联系人\n");
            break;
        case EXIT:
            printf("5. 退出系统\n");
            return;    // 结束整个电话簿系统
        default:
            break;
        }
    }
}

int main(void)
{
    startworking();

    system("pause");
    return EXIT_SUCCESS;
}

telephoneBook.c

// 管理电话簿 相关信息
#include "telephoneBook.h"

// 定义 结构体数组 存储联系人
static person_t numbers[MAX_PERSON_NUM];

// 描述数组中，实际存储联系人个数
static int size = 0;

// 具体添加联系人
// 具体删除联系人
// 具体查找联系人
// 显示所有联系人

telephoneBook.h

// #pragma once    // windows 系统自带防止头文件重复包含。

#ifndef _TELEPHONE_BOOK_H_
#define _TELEPHONE_BOOK_H_

// 系统库头文件引入
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

// 函数声明
void show_menu(void);

// 宏定义，常量描述数组容量
#define MAX_PERSON_NUM 2048

// 定义联系人结构体
typedef struct person {
    char name[32];    // 联系人姓名
    char phone[16];   // 联系人电话
} person_t;

#endif

框架搭建2

main.c

// 管理程序运行的主业务逻辑
#define _CRT_SECURE_NO_WARNINGS

#include "telephoneBook.h"

// 定义枚举，使用枚举常量描述事件
enum {ADD=1, DEL, SREACH, SHOW, EXIT};

// 显示菜单
void show_menu(void)
{
    printf("\n欢迎使用简易电话簿系统\n\n");
    printf("\t1. 添加联系人\n\n");
    printf("\t2. 删除联系人\n\n");
    printf("\t3. 查找联系人\n\n");
    printf("\t4. 显示联系人\n\n");
    printf("\t5. 退出系统\n\n");
}

// ADD分支
void add(void)
{
    printf("\n\t【姓名】为：");
    char name[32] = { 0 };        // 临时获取用户输入、存储联系人姓名
    (void)scanf("%s", name);

    printf("\n\t【电话】为：");
    char phone[16] = { 0 };        // 临时获取用户输入、存储联系人姓名
    (void)scanf("%s", phone);

    // 相联系人数组中，添加一个新联系人
    add_person(name, phone);

    printf("\n联系人【%s】添加成功！\n", name);
}

// DEL分支
void del(void)
{
    printf("\n\t将【删除】的联系人姓名为：");
    char name[32] = { 0 };        // 临时获取用户输入、存储联系人姓名
    (void)scanf("%s", name);

    // 从联系人数组中，删除联系人
    del_person(name);

    printf("\n联系人【%s】已成功删除！\n", name);
}

// SREACH分支
void search(void)
{
    printf("\n\t将【查找】的联系人姓名为：");
    char name[32] = { 0 };        // 临时获取用户输入、存储联系人姓名
    (void)scanf("%s", name);

    // 从联系人数组中，查找联系人的电话
    char *phone = search_person(name);
    if (NULL == phone)
    {
        printf("\n抱歉！电话簿中【%s】查无此人！\n", name);
    }
    else
    {
        printf("n联系人【%s】的电话为：%s\n", name, phone);
    }
}

// SHOW分支  --- 可以不封装该函数，直接调用 telephoneBook.c 中的 show_person()
//void show(void)
//{
//    printf("4. 显示联系人\n");
//}

// 电话簿启动、工作
void startworking(void)
{
    // 电话簿具体工作内容
    while (1)
    {
        // 显示菜单
        show_menu();

        // 接收用户输入(1.添加，2.删除，3.查找，4.显示，5.退出)
        int number = 0;
        printf("请在菜单中选择您的需求：");
        (void)scanf("%d", &number);

        // 根据用户输入，作用相应操作
        switch (number)
        {
        case ADD:
            add();
            break;
        case DEL:
            del();
            break;
        case SREACH:
            search();
            break;
        case SHOW:
            show_person();
            break;
        case EXIT:
            printf("\n欢迎下次再使用电话簿系统，再见~~\n");
            return;        // 结束整个电话簿系统
        default:
            break;
        }
    }
}

int main(void)
{
    startworking();

    system("pause");
    return EXIT_SUCCESS;
}

telephoneBook.c

// 管理电话簿 相关信息
#include "telephoneBook.h"

// 定义 结构体数组 存储联系人
static person_t numbers[MAX_PERSON_NUM];

// 描述数组中，实际存储联系人个数
static int size = 0;

// 具体添加联系人
void add_person(const char* name, const char* phone)
{

}

// 具体删除联系人
void del_person(const char* name)
{

}

// 具体查找联系人 ---- 返回联系人的电话
char *search_person(const char* name)
{
    return NULL;
}

// 显示所有联系人
void show_person(void)
{

}

telephoneBook.h

// #pragma once    // windows 系统自带防止头文件重复包含。

#ifndef _TELEPHONE_BOOK_H_
#define _TELEPHONE_BOOK_H_

// 系统库头文件引入
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

// 函数声明
void add_person(const char* name, const char* phone);
void del_person(const char* name);
char* search_person(const char* name);
void show_person(void);

void show_menu(void);
void add(void);
void del(void);
void search(void);

// 宏定义，常量描述数组容量
#define MAX_PERSON_NUM 2048

// 定义联系人结构体
typedef struct person {
    char name[32];    // 联系人姓名
    char phone[16];   // 联系人电话
} person_t;

#endif

具体功能函数实现

添加联系人

// 具体添加联系人
void add_person(const char* name, const char* phone)
{
    // 校验参数
    if (NULL == name || NULL == phone)
    {
        printf("add_person 添加联系人失败！参数错误！\n");
        return;
    }

    strcpy(numbers[size].name, name);    // 存姓名到数组
    strcpy(numbers[size].phone, phone);  // 存电话到数组

    ++size;    // 更新size
}

线性代数笔记

Sat, 22 Aug 2026 00:00:00 GMT

线性代数笔记

第一部分：行列式

1.1 行列式的性质

按行/列展开不变性：n阶矩阵 $A$ 的行列式按任意一行（列）展开，其值相等。

两行（列）全相同则行列式为0：若n阶行列式有两行（列）对应元素全相等，则行列式值为0。

行（列）的可拆分性：某一行（列）的元素为两数之和时，行列式可拆分为两个行列式之和：

$$ \begin{vmatrix} a_{11} & a_{12} & \dots & a_{1n} \ b_i + c_i & b_{i2} + c_{i2} & \dots & b_{in} + c_{in} \ \vdots & \vdots & & \vdots \ a_{n1} & a_{n2} & \dots & a_{nn} \end{vmatrix}

\begin{vmatrix} a_{11} & a_{12} & \dots & a_{1n} \ b_i & b_{i2} & \dots & b_{in} \ \vdots & \vdots & & \vdots \ a_{n1} & a_{n2} & \dots & a_{nn} \end{vmatrix} + \begin{vmatrix} a_{11} & a_{12} & \dots & a_{1n} \ c_i & c_{i2} & \dots & c_{in} \ \vdots & \vdots & & \vdots \ a_{n1} & a_{n2} & \dots & a_{nn} \end{vmatrix} $$

初等变换对行列式的影响：
- 某一行（列）乘以数 $k$，行列式值变为原来的 $k$ 倍：$\det A_1 = k\det A$（$A_1$ 为 $A$ 的某行乘 $k$ 得到的矩阵）
- 某一行（列）的 $k$ 倍加到另一行（列），行列式值不变：$\det A_2 = \det A$（$A_2$ 为 $A$ 经过该变换后的矩阵）
- 交换两行（列），行列式值变号：$\det A_3 = -\det A$（$A_3$ 为 $A$ 交换两行后的矩阵）

转置不变性：行列式与其转置行列式值相等，即 $\det A^T = \det A$。

行列式的推论

若行列式的某一行（列）元素全为0，则行列式值为0。
若行列式的某两行（列）对应元素成比例，则行列式值为0。

1.2 行列式的计算

范德蒙德行列式： $$ V_n = \begin{vmatrix} 1 & 1 & \dots & 1 \ x_1 & x_2 & \dots & x_n \ x_1^2 & x_2^2 & \dots & x_n^2 \ \vdots & \vdots & & \vdots \ x_1^{n-1} & x_2^{n-1} & \dots & x_n^{n-1} \end{vmatrix} = \prod_{1 \le i < j \le n} (x_j - x_i) = (x_2-x_1)(x_3-x_1)\dots(x_n-x_1)(x_3-x_2)\dots(x_n-x_2)\dots(x_n-x_{n-1}) $$

拉普拉斯定理推论（分块行列式）： $$ \begin{vmatrix} A & O \ C & B \end{vmatrix} = |A||B|, \quad \begin{vmatrix} A & O \ O & B \end{vmatrix} = |A||B|, \quad \begin{vmatrix} A & C \ O & B \end{vmatrix} = |A||B| $$ $$ \begin{vmatrix} O & A \ B & O \end{vmatrix} = (-1)^{mn}|A||B| \quad (m,n为A,B的阶数) $$ （其中 $A,B$ 为方阵，$O$ 为零矩阵，$C$ 为任意矩阵）

1.3 克莱姆法则

引理：行列式的任一行元素乘另一行对应元素的代数余子式之和为 0。

克拉默法则：设 $n$ 阶矩阵 $A$ 可逆，则线性方程组 $Ax = b$ 有唯一解 $x=(x_1,x_2,\dots,x_n)^T$，其中 $$ x_j = \frac{\det A_j}{\det A} \quad (j=1,2,\dots,n) $$ （$\det A_j$ 是用 $b$ 替换 $\det A$ 的第 $j$ 列得到的行列式）

齐次线性方程组判定：对于 $Ax=0$：
- 若 $\det A \neq 0$，方程组只有零解；
- 若 $\det A = 0$，方程组有非零解。

第二部分：矩阵

2.1 矩阵的概念

矩阵与行列式对比

	行列式	矩阵
本质	数	数表
形状	必须是方的（行数=列数）	行数和列数不一定相等

矩阵的定义

矩阵：$m \times n$ 的数表
同型矩阵：矩阵 $A$、$B$ 的行数和列数都相等
矩阵相等：$A=B \iff$ 是同型矩阵，且对应位置元素相等

几类特殊矩阵

方阵：行数=列数的矩阵
行矩阵：只有一行的矩阵，如 $A = \begin{pmatrix} 1 & 2 & 3 \end{pmatrix}$
列矩阵：只有一列的矩阵，如 $B = \begin{pmatrix} 1 \ 2 \ 3 \end{pmatrix}$
零矩阵：元素全为 0 的矩阵，如 $\begin{pmatrix} 0 & 0 \ 0 & 0 \end{pmatrix}$、$\begin{pmatrix} 0 & 0 & 0 \end{pmatrix}$
负矩阵：如 $A = \begin{pmatrix} 1 & 3 & 0 \ 2 & -4 & 5 \end{pmatrix}$，其负矩阵 $-A = \begin{pmatrix} -1 & -3 & 0 \ -2 & 4 & -5 \end{pmatrix}$
上三角形矩阵：主对角线下方的元素全为 0 的矩阵，如 $\begin{pmatrix} 1 & 2 & 3 \ 0 & -1 & 4 \ 0 & 0 & 5 \end{pmatrix}$、$\begin{pmatrix} 0 & 1 \ 0 & 4 \end{pmatrix}$
下三角形矩阵：主对角线上方的元素全为 0 的矩阵，如 $\begin{pmatrix} 1 & 0 \ 3 & 2 \end{pmatrix}$、$\begin{pmatrix} 0 & 0 & 0 \ -2 & 5 & 0 \ 0 & 1 & 4 \end{pmatrix}$
对角形矩阵：非主对角线元素全为 0 的矩阵，如 $\begin{pmatrix} 1 & 0 & 0 \ 0 & 2 & 0 \ 0 & 0 & 3 \end{pmatrix}$、$\begin{pmatrix} 1 & 0 \ 0 & 3 \end{pmatrix}$，也可记为 $\text{diag}(1,2,3)$
数量矩阵：主对角线上元素相同的对角矩阵，如 $\begin{pmatrix} a & 0 & 0 \ 0 & a & 0 \ 0 & 0 & a \end{pmatrix}$
单位矩阵：主对角线上元素全为 1 的对角矩阵记作 $I$ 或 $E$： $$ I = E = \begin{pmatrix} 1 & & & \ & 1 & & \ & & \ddots & \ & & & 1 \end{pmatrix} $$

2.2 矩阵的加法、减法与数乘

矩阵的加、减运算

定义：同型矩阵对应位置元素相加/相减。
运算规律：
1. $A+B = B+A$（交换律）
2. $(A+B)+C = A+(B+C)$（结合律）
3. $A+O = A$（$O$ 为零矩阵）
4. $A+(-A) = O$
5. $A-B = A+(-B)$
6. $A+B = C \iff A = C-B$

矩阵的数乘运算

定义：用数 $k$ 乘以矩阵 $A$ 的每一个元素，例： $$ A = \begin{pmatrix} a & b \ c & d \end{pmatrix}, \quad kA = \begin{pmatrix} ka & kb \ kc & kd \end{pmatrix} $$

公因子提取对比

矩阵：所有元素均有公因子 $k$，$k$ 向外提一次。
行列式：某一行（列）有公因子 $k$，$k$ 向外提一次。
行列式：所有元素均有公因子 $k$，$k$ 向外提 $n$ 次（$n$ 为阶数）。

数乘的运算规律

$k(A+B) = kA + kB$
$(k+l)A = kA + lA$
$k(lA) = (kl)A = l(kA)$
$1A = A$
$(-1)A = -A$

2.3 矩阵的乘法

定义

可乘条件：$A_{m \times n}$ 与 $B_{p \times q}$ 相乘，需要 $n = p$
结果形状：$AB$ 是 $m \times q$ 矩阵。

矩阵乘法不满足的规律

不满足交换律：
- AB，BA都有意义，二者不一定相等
- AB有意义，BA不一定有意义
不满足消去律：
- 若AB=AC，且A≠O，推不出B=C
- 若BA=CA，且A≠O，推不出B=C
两个非零矩阵的成绩可能是零矩阵
- 若AB=O，推不出A=O，B=O

矩阵乘法满足的运算规律

结合律：$(AB)C = A(BC)$
分配律：
- 左分配律：$(A+B)C = AC + BC$
- 右分配律：$C(A+B) = CA + CB$
数乘结合律：$k(AB) = (kA)B = A(kB)$
单位矩阵性质：$AE = EA = A$
数量矩阵性质：若 $A = aE$（数量矩阵），则 $AB = aB$

矩阵的可交换性

若 $AB = BA$，则称 $A$ 与 $B$ 可交换。常见可交换情况：

可交换的矩阵一定是同阶方阵
不同阶矩阵一定不可交换
AB≠BA，一定不可交换
单位矩阵E和任一同阶方阵可交换
两个同阶对角矩阵可交换

2.4 方阵的幂

定义：设 $A$ 为方阵，定义 $A^k = \underbrace{A \cdot A \cdot \dots \cdot A}_{k\text{个}}$，规定 $A^0 = E$。
性质（$A$ 为方阵，$k,k_1,k_2$ 为非负整数，$k,l$ 为常数）：
1. $A^{k_1}A^{k_2} = A^{k_1+k_2}$
2. $(A^{k_1})^{k_2} = A^{k_1k_2}$
3. $(lA)^k = l^kA^k$

注：由于矩阵乘法不满足交换律，一般情况下，$(AB)^k \neq A^kB^k$（$A,B$为同阶方阵）

若矩阵$A,B$可交换，则有： $A^2 - B^2 = (A+B)(A-B) = (A-B)(A+B)$ $(A+B)^2 = A^2 + 2AB + B^2$ $(A-B)^2 = A^2 - 2AB + B^2$ $A^3 - B^3 = (A-B)(A^2 + AB + B^2)$ $A^3 + B^3 = (A+B)(A^2 - AB + B^2)$ $(AB)^k = A^kB^k$

恒成立公式

$A^2 - E = (A+E)(A-E)$ $(A+E)^2 = A^2 + 2A + E$ $(A-E)^2 = A^2 - 2A + E$ $A^3 - E = (A-E)(A^2 + A + E)$ $A^3 + E = (A+E)(A^2 - A + E)$

方阵多项式

设$f(x) = a_mx^m + a_{m-1}x^{m-1} + \dots + a_1x + a_0$，则 $f(A) = a_mA^m + a_{m-1}A^{m-1} + \dots + a_1A + a_0E$

2.5 矩阵的转置

定义

将矩阵的行依次变为列，列依次变为行，得到的新矩阵称为原矩阵的转置矩阵，记作 $A^T$。例：若 $A = \begin{pmatrix} 1 & 2 & 3 \ 0 & -1 & 4 \end{pmatrix}$，则 $$ A^T = \begin{pmatrix} 1 & 0 \ 2 & -1 \ 3 & 4 \end{pmatrix} $$

转置矩阵的性质

$(A^T)^T = A$
$(A+B)^T = A^T + B^T$
$(kA)^T = kA^T$（$k$ 为常数）
$(AB)^T = B^T A^T$（反序法则）
$(A^k)^T = (A^T)^k$（$k$ 为正整数）

对称矩阵与反对称矩阵

对称矩阵

若 $n$ 阶矩阵 $A$ 满足 $A^T = A$，则称 $A$ 为对称矩阵。等价条件：$A = (a_{ij}){n×n}$ 为对称矩阵 $\iff a{ij} = a_{ji}$（$i,j=1,2,\dots,n$）。例：$A = \begin{pmatrix} 1 & 2 & 0 \ 2 & 3 & -1 \ 0 & -1 & 4 \end{pmatrix}$

对称矩阵的结论：

若 $A,B$ 为同阶对称矩阵，则 $A+B$、$A-B$ 仍为对称矩阵
- $(A+B)^T=A^T+B^T=A+B$
- $(A-B)^T=A^T-B^T=A-B$

若 $A$ 为对称矩阵，则 $kA$、$A^m$ 仍为对称矩阵（$k$ 为常数，$m$ 为正整数）

若 $A,B$ 为同阶对称矩阵，则 $AB$ 为对称矩阵的充要条件是 $AB=BA$
- 证：$(AB)^T=B^TA^T=BA=AB$

对任意 $m×n$ 矩阵 $A$，则 $A^TA$、$AA^T$ 均为对称矩阵

反对称矩阵

设 $A=(a_{ij}){n×n}$，$A$ 为反对称矩阵 $\Leftrightarrow A^T=-A \Leftrightarrow a{ij}=-a_{ji}$（$i,j=1,2,3\cdots n$）注：$A$ 为反对称矩阵，主对角线元素全为0；关于主对角线对称位置的元素互为相反数

反对称矩阵的结论：

若 $A,B$ 为同阶反对称矩阵，则 $A+B$、$A-B$ 仍为反对称矩阵
若 $A$ 为反对称矩阵，则 $kA$ 仍为反对称矩阵
若 $A$ 为反对称矩阵，$k$ 为正整数，则 $A^k$ 为对称矩阵（$k$ 为偶数）、反对称矩阵（$k$ 为奇数）；$(A^k)^T=(A^T)^k=(-A)^k=(-1)^kA^k$

2.6 方阵的行列式

设 $n$ 阶方阵 $A$，则 $A$ 的行列式为 $|A|$ 注：1. $A$ 的行列式 $|A|$ 是一个数；2. 只有方阵才有行列式

方阵行列式的性质：

设 $A,B$ 为 $n$ 阶方阵，$k$ 为常数，$m$ 为正整数：

$|A^T|=|A|$
$|kA|=k^n|A|$
$|AB|=|A|\cdot|B|$
$|A^m|=|A|^m$，如 $|A^3|=|AAA|=|A||A||A|=|A|^3$
$|E|=1$（$E$ 为单位矩阵）

2.7 方阵的伴随矩阵

伴随矩阵的定义

设 $ A=(a_{ij}){n×n} $，$ |A| $ 中元素 $ a{ij} $ 的代数余子式为 $ A_{ij} $（$ i,j=1,2,\dots,n $），$ A $ 的伴随矩阵 $ A^* $ 定义为： $$ A^* = \begin{pmatrix} A_{11} & A_{21} & \dots & A_{n1} \ A_{12} & A_{22} & \dots & A_{n2} \ \vdots & \vdots & & \vdots \ A_{1n} & A_{2n} & \dots & A_{nn} \end{pmatrix} $$

注意：

$ A^* $ 的元素是 $ a_{ij} $ 的代数余子式，是把行的代数余子式放到列上；
任一方阵都有伴随矩阵；
只有方阵才有伴随矩阵。

伴随矩阵的性质

对任意方阵 $ A $，有 $ AA^* = A^A = |A|E $（不管 $ A $ 可逆与否，均成立）例： $$ A = \begin{pmatrix} a_{11} & a_{12} & a_{13} \ a_{21} & a_{22} & a_{23} \ a_{31} & a_{32} & a_{33} \end{pmatrix}, \quad A^ = \begin{pmatrix} A_{11} & A_{21} & A_{31} \ A_{12} & A_{22} & A_{32} \ A_{13} & A_{23} & A_{33} \end{pmatrix} $$ $$ AA^* = \begin{pmatrix} |A| & 0 & 0 \ 0 & |A| & 0 \ 0 & 0 & |A| \end{pmatrix} = |A| \begin{pmatrix} 1 & & \ & 1 & \ & & 1 \end{pmatrix} = |A|E $$

若 $ A $ 为 $ n $ 阶方阵，则 $ |A^| = |A|^{n-1} $ 证：由 $ AA^ = |A|E $，两边取行列式得： $$ |A||A^| = | |A|E | = |A|^n |E| = |A|^n $$ 两边除以 $ |A| $（$ |A|≠0 $ 时），得 $ |A^| = |A|^{n-1} $。

若 $ A $ 为方阵，则 $ (A^T)^* = (A^*)^T $

若 $ A $ 为 $ n $ 阶方阵，$ k $ 为常数，则 $ (kA)^* = k^{n-1}A^* $ 证：以3阶矩阵为例： $$ kA = \begin{pmatrix} ka & kb & kc \ kd & ke & kf \ kh & ki & kg \end{pmatrix}, \quad (kA){ij} = (-1)^{i+j} \begin{vmatrix} ke & kf \ ki & kg \end{vmatrix} = k^2 A{ij} $$ 推广得 $ (kA)^* = k^{n-1}A^* $。

若 $ A=\begin{pmatrix}a&b\c&d\end{pmatrix} $，则 $ A^*=\begin{pmatrix}d&-b\-c&a\end{pmatrix} $，主对换，负号易号。

2.8 逆矩阵

逆矩阵的定义

设 $ A $ 为 $ n $ 阶方阵，若存在 $ n $ 阶方阵 $ B $，使 $ AB=BA=E $，则称 $ A $ 是可逆矩阵，$ B $ 为 $ A $ 的逆矩阵，记作 $ A^{-1} $。注：任何方阵未必都有逆矩阵；若方阵 $ A $ 可逆，则 $ A^{-1} $ 是唯一的（证明：若 $ B_1,B_2 $ 满足 $ B_1A=E,AB_2=E $，则 $ B_1=B_1E=B_1(AB_2)=(B_1A)B_2=EB_2=B_2 $）。
设 $ A $ 为 $ n $ 阶方阵，若 $ |A|≠0 $，称 $ A $ 是非奇异矩阵，可逆；若 $ |A|=0 $，称 $ A $ 是奇异矩阵，不可逆。

矩阵可逆的判定及逆矩阵的求法

定理1：方阵 $ A $ 可逆的充要条件是 $ A $ 为非奇异矩阵，即 $ |A|≠0 $，并且当 $ A $ 可逆时，$ A^{-1}=\frac{1}{|A|}A^* $。

定理2（对角形矩阵）：$ \text{diag}A=\text{diag}(a_1,a_2,\dots,a_n) $ 可逆的充要条件是 $ a_1,a_2,\dots,a_n $ 都不等于0，且 $ A^{-1}=\text{diag}(\frac{1}{a_1},\frac{1}{a_2},\dots,\frac{1}{a_n}) $。

定理3：设 $ A $ 是 $ n $ 阶方阵，若存在 $ n $ 阶方阵 $ B $，使 $ AB=E $ 或 $ BA=E $，则 $ A $ 可逆，且 $ A^{-1}=B $。

可逆矩阵的性质

若 $ A $ 可逆，则 $ A^{-1} $ 也可逆，且 $ (A^{-1})^{-1}=A $。

若 $ A $ 可逆，则 $ A^T $ 也可逆，且 $ (A^T)^{-1}=(A^{-1})^T $（证明：$ A^T(A^{-1})^T=(A^{-1}A)^T=E^T=E $）。

若 $ A $ 可逆，$ k $ 为非零常数，则 $ kA $ 也可逆，且 $ (kA)^{-1}=\frac{1}{k}A^{-1} $。

若 $ A $ 可逆，则 $ A^* $ 也可逆，且 $ (A^)^{-1}=(A^{-1})^=\frac{1}{|A|}A $。证：$ AA^=A^A=|A|E $，则 $ (\frac{1}{|A|}A)A^=A^(\frac{1}{|A|}A)=E $，故 $ A^* $ 可逆。附：$ |kA|=k^n|A| $，$ (kA)^=k^{n-1}A^ $，$ (kA)^{-1}=\frac{1}{k}A^{-1} $。运算顺序可交换：$ (A^T)^{-1}=(A^{-1})^T $，$ (A^)^T=(A^T)^ $，$ (A^)^{-1}=(A^{-1})^ $。

若 $ A,B $ 同阶可逆，则 $ AB $ 也可逆，$ (AB)^{-1}=B^{-1}A^{-1} $。证：$ |A|≠0,|B|≠0 $，则 $ |AB|=|A||B|≠0 $，$ AB $ 可逆；$ ABB^{-1}A^{-1}=AEA^{-1}=AA^{-1}=E $。

若 $ A $ 可逆，$ m $ 为正整数，则 $ A^m $ 也可逆，且 $ (A^m)^{-1} = (A^{-1})^m $。 $ |A| \neq 0 $，$ |A^m| = |A|^m \neq 0 $， $ A^m(A^{-1})^m = (A^{-1}A)^m = E^m = E $。

若 $ A $ 可逆，则 $ |A^{-1}| = \frac{1}{|A|} $。

若 $ A $ 可逆，则 $ A^{-1} = \frac{1}{|A|}A^* $。

矩阵方程

若 $ A,B $ 均为可逆矩阵，则矩阵方程：

$ AX = C $，其解为 $ X = A^{-1}C $。证：$ A^{-1}AX = A^{-1}C \Rightarrow X = A^{-1}C $

$ XA = C $，其解为 $ X = CA^{-1} $。证：$ XAA^{-1} = CA^{-1} \Rightarrow X = CA^{-1} $

$ AXB = C $，其解为 $ X = A^{-1}CB^{-1} $。证：$ A^{-1}AXB B^{-1} = A^{-1}CB^{-1} \Rightarrow X = A^{-1}CB^{-1} $

2.9 矩阵的初等变换

定义

矩阵初等变换分为：行变换和列变换。

初等行变换：

交换矩阵的两行；
用数 $ k \neq 0 $ 乘矩阵某一行的所有元素；
把矩阵某一行所有元素的 $ l $ 倍加到另一行对应的元素上去。

标准形矩阵：元素只有 $ 1 $ 和 $ 0 $ 组成，且矩阵左上角是单位矩阵，其余元素全为 $ 0 $。例： $$ \begin{pmatrix}1&0&0&0\0&1&0&0\0&0&0&0\end{pmatrix}, \quad \begin{pmatrix}1&0&0\0&1&0\0&0&0\end{pmatrix}, \quad \begin{pmatrix}1&0\0&1\end{pmatrix} $$

定理：任何矩阵都能通过初等变换化为标准型矩阵，此矩阵称为矩阵的标准形。

行阶梯形矩阵

定义：若矩阵满足以下条件，则称为行阶梯形矩阵：
- 若矩阵存在零行，则零行都在非零行的下方；
- 任一非零行从左到右第一个非零元素（非零首元）所在的列中，该元素左下方的元素全为零。

行简化阶梯形矩阵：行阶梯形矩阵的非零首元均为 $1$，且非零首元所在列的其他元素全为零。

例子： $$ \begin{pmatrix} -1 & 0 & 3 \ 0 & 2 & 0 \ 0 & 0 & 5 \end{pmatrix}, \quad \begin{pmatrix} 1 & 2 & 0 & 0 \ 0 & 0 & 1 & 0 \ 0 & 0 & 0 & 1 \end{pmatrix} $$

定理：任何矩阵都可通过初等行变换化为唯一的行阶梯形矩阵；再通过初等行变换化为唯一的行简化阶梯形矩阵；最终可通过初等列变换化为唯一的标准形矩阵，其中“$1$”的个数等于矩阵的秩 $r(A)$。

2.10 初等矩阵

定义

由单位矩阵 $E$ 经过一次初等行（列）变换得到的矩阵，称为初等矩阵，分为三类：

交换 $E$ 的第 $i,j$ 两行（列），得到 $E(i,j)$；
用非零数 $k$ 乘 $E$ 的第 $i$ 行（列），得到 $E(i(k))$；
把 $E$ 的第 $j$ 行的 $l$ 倍加到第 $i$ 行，得到 $E(i,j(l))$。

性质

行列式非零：$|E(i,j)| = -1$，$|E(i(k))| = k$，$|E(i,j(l))| = 1$
转置仍为同类型初等矩阵：$E(i,j)^T = E(i,j)$，$E(i(k))^T = E(i(k))$，$E(i,j(l))^T = E(j,i(l))$
可逆，且逆矩阵仍为同类型初等矩阵：$E(i,j)^{-1} = E(i,j)$，$E(i(k))^{-1} = E(i(1/k))$，$E(i,j(l))^{-1} = E(i,j(-l))$

初等矩阵与矩阵初等变换的关系

设 $ A $ 为 $ m×n $ 矩阵，则：

对 $ A $ 进行一次初等行变换得到的矩阵，等于用同类型的 $ m $ 阶初等矩阵左乘 $ A $；
对 $ A $ 进行一次初等列变换得到的矩阵，等于用同类型的 $ n $ 阶初等矩阵右乘 $ A $。（左乘对应行变换，右乘对应列变换）

2.11 矩阵的等价

定义

若矩阵 $A$ 可经过有限次初等变换化为矩阵 $B$，则称 $A$ 与 $B$ 等价，记作 $A \cong B$。 $A \cong B \iff A \to B$。

矩阵等价的性质

矩阵的等价具有下列性质：

反身性：对任何矩阵 $A$，都有 $A \cong A$；
对等称性：若矩阵 $A \cong B$，则 $B \cong A$；
传递性：若矩阵 $A \cong B$，$B \cong C$，则 $A \cong C$。

矩阵等价的有关结论

任意一个矩阵 $A_{m×n}$ 都和其标准形矩阵 $$ D=\begin{pmatrix} 1 & & & & \ & \ddots & & & \ & & 1 & & \ & & & 0 & \ & & & & \ddots \ & & & & & 0 \end{pmatrix}_{m×n} $$ 等价。

矩阵 $A \cong B$ 的充要条件是存在一系列初等矩阵 $P_1, P_2, \dots, P_s, Q_1, Q_2, \dots, Q_t$，使 $$ P_s \cdots P_2 P_1 A Q_1 Q_2 \cdots Q_t = B $$

矩阵 $A \cong B$ 的充要条件是存在可逆矩阵 $P,Q$，使 $PAQ=B$。

若矩阵 $A \cong B$，则 $A$ 与 $B$ 的标准形相同。

若矩阵 $A \cong B$，则 $A$ 与 $B$ 的秩相等，即 $r(A)=r(B)$。

若 $A,B$ 为同型矩阵，则 $A \cong B$ 的充要条件是 $r(A)=r(B)$。

若 $A, B$ 为同阶方阵，且 $A \cong B$，则 $|A| = k|B|$（$k \neq 0$。

若 $A, B$ 为同阶方阵，且 $A \cong B$，则 $A, B$ 同时可逆，或同时不可逆。

设 $A$ 为 $n$ 阶方阵，则 $A$ 可逆的充要条件为 $A \cong E$。

设 $A$ 为方阵，则 $A$ 可逆的充要条件是 $A$ 可以表示为有限个初等矩阵的乘积。

2.12 初等变换法求逆矩阵

具体步骤

第一步：利用矩阵 $A$ 和同阶单位矩阵 $E$，作 $n \times 2n$ 的矩阵 $(A \vdots E)$；

第二步：对 $(A \vdots E)$ 进行初等行变换，将其化为行简化阶梯形矩阵： $$ (A \vdots E) \xrightarrow{\text{行}} (B \vdots D) $$ （注：只能进行行变换）其中，$(B \vdots D)$ 为行简化阶梯形矩阵，此时相应的有 $A \xrightarrow{\text{行}} B$，$E \xrightarrow{\text{行}} D$；

第三步：判定得结论： $$ \begin{cases} \text{若 } B=E, \text{ 则 } A \text{ 可逆，且 } A^{-1}=D; \ \text{若 } B \neq E, \text{ 则 } A \text{ 不可逆.} \end{cases} $$

示例

求矩阵 $ A = \begin{pmatrix} 1 & 2 & 3 \ 2 & 2 & 1 \ 3 & 4 & 3 \end{pmatrix} $ 的逆矩阵。

构造增广矩阵： $$ (A \mid E) = \begin{pmatrix} 1 & 2 & 3 & 1 & 0 & 0 \ 2 & 2 & 1 & 0 & 1 & 0 \ 3 & 4 & 3 & 0 & 0 & 1 \end{pmatrix} $$

进行初等行变换：

$ r_2 - 2r_1 $，$ r_3 - 3r_1 $： $$ \begin{pmatrix} 1 & 2 & 3 & 1 & 0 & 0 \ 0 & -2 & -5 & -2 & 1 & 0 \ 0 & -2 & -6 & -3 & 0 & 1 \end{pmatrix} $$
$ r_3 - r_2 $： $$ \begin{pmatrix} 1 & 2 & 3 & 1 & 0 & 0 \ 0 & -2 & -5 & -2 & 1 & 0 \ 0 & 0 & -1 & -1 & -1 & 1 \end{pmatrix} $$
$ r_3 \times (-1) $： $$ \begin{pmatrix} 1 & 2 & 3 & 1 & 0 & 0 \ 0 & -2 & -5 & -2 & 1 & 0 \ 0 & 0 & 1 & 1 & 1 & -1 \end{pmatrix} $$
$ r_2 + 5r_3 $，$ r_1 - 3r_3 $： $$ \begin{pmatrix} 1 & 2 & 0 & -2 & -3 & 3 \ 0 & -2 & 0 & 3 & 6 & -5 \ 0 & 0 & 1 & 1 & 1 & -1 \end{pmatrix} $$
$ r_2 \times (-\frac{1}{2}) $： $$ \begin{pmatrix} 1 & 2 & 0 & -2 & -3 & 3 \ 0 & 1 & 0 & -\frac{3}{2} & -3 & \frac{5}{2} \ 0 & 0 & 1 & 1 & 1 & -1 \end{pmatrix} $$
$ r_1 - 2r_2 $： $$ \begin{pmatrix} 1 & 0 & 0 & 1 & 3 & -2 \ 0 & 1 & 0 & -\frac{3}{2} & -3 & \frac{5}{2} \ 0 & 0 & 1 & 1 & 1 & -1 \end{pmatrix} $$

因此，$ A^{-1} = \begin{pmatrix} 1 & 3 & -2 \ -\frac{3}{2} & -3 & \frac{5}{2} \ 1 & 1 & -1 \end{pmatrix} $。

初等变换法解矩阵方程

设 $A$ 为 $n$ 阶可逆矩阵，求解矩阵方程 $AX=B$，有下列两种方法：

方法一：先求出 $A^{-1}$，然后求 $X=A^{-1}B$ 即可。

方法二（初等变换法）：只适用于方程 $AX=B$。对矩阵 $(A \vdots B)$ 进行初等行变换，将其化为如下形式： $$ (A \vdots B) \xrightarrow{\text{行}} (E \vdots C) $$ （注：只能进行行变换）则 $X=C$。即将 $A$ 对应的左边子块化为单位矩阵 $E$ 时，$B$ 对应的右边子块化出的矩阵 $C$ 即为所求的矩阵 $X$。

对于 $AX=B$，需要构建2n * n的矩阵,把 $A$ 和 $B$ 放在矩阵的上边和下边,然后对矩阵进行初等列变换,直到 $A$ 变化为单位矩阵 $E$。

2.13 分块矩阵

将 $A$ 进行如下分块： $$ A= \begin{pmatrix} 1 & 2 & 0 & \bigm| & -1 & 3 \ 0 & -1 & 1 & \bigm| & 2 & 1 \ 0 & 1 & 5 & \bigm| & -2 & 2 \ \hline 1 & 3 & 4 & \bigm| & 0 & 6 \end{pmatrix} $$

于是 $A$ 成为分块矩阵： $$ A= \begin{pmatrix} A_{11} & A_{12} \ A_{21} & A_{22} \ A_{31} & A_{32} \end{pmatrix} $$

将 $A$ 按行分块，可得 $$ A= \begin{pmatrix} 1 & 2 & 0 & -1 & 3 \ 0 & -1 & 1 & 2 & 1 \ 0 & 1 & 5 & -2 & 2 \ 1 & 3 & 4 & 0 & 6 \end{pmatrix} = \begin{pmatrix} \alpha_1 \ \alpha_2 \ \alpha_3 \ \alpha_4 \end{pmatrix} $$ 其中 $$ \alpha_1=(1\ 2\ 0\ -1\ 3),\quad \alpha_2=(0\ -1\ 1\ 2\ 1), $$ $$ \alpha_3=(0\ 1\ 5\ -2\ 2),\quad \alpha_4=(1\ 3\ 4\ 0\ 6). $$ $\alpha_1,\alpha_2,\alpha_3,\alpha_4$ 也叫 $A$ 的行向量组。

将 $A$ 按列分块，可得： $$ A= \begin{pmatrix} 1 & 2 & 0 & -1 & 3 \ 0 & -1 & 1 & 2 & 1 \ 0 & 1 & 5 & -2 & 2 \ 1 & 3 & 4 & 0 & 6 \end{pmatrix} = (\beta_1\ \beta_2\ \beta_3\ \beta_4\ \beta_5) $$ 其中 $$ \beta_1= \begin{pmatrix} 1 \ 0 \ 0 \ 1 \end{pmatrix},\ \beta_2= \begin{pmatrix} 2 \ -1 \ 1 \ 3 \end{pmatrix},\ \beta_3= \begin{pmatrix} 0 \ 1 \ 5 \ 4 \end{pmatrix},\ \beta_4= \begin{pmatrix} -1 \ 2 \ -2 \ 0 \end{pmatrix},\ \beta_5= \begin{pmatrix} 3 \ 1 \ 2 \ 6 \end{pmatrix} $$ $\beta_1,\beta_2,\beta_3,\beta_4,\beta_5$ 也叫 $A$ 的列向量组。

将矩阵分块是为了简化计算，具体如何分块，要根据具体情况而定。

1.特殊的分块矩阵

上三角形分块矩阵：形如 $$ \begin{pmatrix} A_1 & * & \dots & * \ & A_2 & \dots & * \ & & \ddots & \vdots \ & & & A_k \end{pmatrix} $$ 的分块方阵，其中 $A_1, A_2, \dots, A_k$ 为方阵。

下三角形分块矩阵：形如

$$ \begin{pmatrix} A_1 & & & \
- & A_2 & & \ \vdots & \vdots & \ddots & \
- & * & \dots & A_k \end{pmatrix} $$ 的分块方阵，其中 $A_1, A_2, \dots, A_k$ 均为方阵。

对角形分块矩阵：形如 $$ \begin{pmatrix} A_1 & & & \ & A_2 & & \ & & \ddots & \ & & & A_k \end{pmatrix} $$ 的分块方阵，其中 $A_1, A_2, \dots, A_k$ 均为方阵。

2.分块矩阵的运算

分块矩阵的加法与数乘设矩阵 $A_{m\times n}$、$B_{m\times n}$ 按同一方式分块： $$ A = \begin{pmatrix} A_{11} & A_{12} & \dots & A_{1t} \ A_{21} & A_{22} & \dots & A_{2t} \ \vdots & \vdots & & \vdots \ A_{s1} & A_{s2} & \dots & A_{st} \end{pmatrix},\quad B = \begin{pmatrix} B_{11} & B_{12} & \dots & B_{1t} \ B_{21} & B_{22} & \dots & B_{2t} \ \vdots & \vdots & & \vdots \ B_{s1} & B_{s2} & \dots & B_{st} \end{pmatrix} $$ 则 $$ A+B= \begin{pmatrix} A_{11}+B_{11} & A_{12}+B_{12} & \dots & A_{1t}+B_{1t} \ A_{21}+B_{21} & A_{22}+B_{22} & \dots & A_{2t}+B_{2t} \ \cdots & \cdots & \cdots & \cdots \ A_{s1}+B_{s1} & A_{s2}+B_{s2} & \dots & A_{st}+B_{st} \end{pmatrix} $$

设矩阵 $A$ 按分块形式表示为 $$ A= \begin{pmatrix} A_{11} & A_{12} & \dots & A_{1t} \ A_{21} & A_{22} & \dots & A_{2t} \ \vdots & \vdots & & \vdots \ A_{s1} & A_{s2} & \dots & A_{st} \end{pmatrix} $$ 则 $kA$ 的分块形式为 $$ kA= \begin{pmatrix} kA_{11} & kA_{12} & \dots & kA_{1t} \ kA_{21} & kA_{22} & \dots & kA_{2t} \ \vdots & \vdots & & \vdots \ kA_{s1} & kA_{s2} & \dots & kA_{st} \end{pmatrix} $$

分块矩阵的乘法设矩阵 $A_{m\times l}$、$B_{l\times n}$，把 $A$、$B$ 分块，使 $A$ 的列分块和 $B$ 的行分块相同： $$ A = \begin{pmatrix} A_{11} & A_{12} & \dots & A_{1t} \ A_{21} & A_{22} & \dots & A_{2t} \ \vdots & \vdots & & \vdots \ A_{s1} & A_{s2} & \dots & A_{st} \end{pmatrix}, \quad B = \begin{pmatrix} B_{11} & B_{12} & \dots & B_{1r} \ B_{21} & B_{22} & \dots & B_{2r} \ \vdots & \vdots & & \vdots \ B_{t1} & B_{t2} & \dots & B_{tr} \end{pmatrix} $$

设分块矩阵： $$ A= \begin{pmatrix} A_1 & A_2 & A_3 \ A_4 & A_5 & A_6 \end{pmatrix},\quad B= \begin{pmatrix} B_1 & B_2 \ B_3 & B_4 \ B_5 & B_6 \end{pmatrix} $$ 则分块乘法结果为： $$ AB= \begin{pmatrix} A_1B_1+A_2B_3+A_3B_5 & A_1B_2+A_2B_4+A_3B_6 \ A_4B_1+A_5B_3+A_6B_5 & A_4B_2+A_5B_4+A_6B_6 \end{pmatrix} $$

分块矩阵乘法的前提条件： 矩阵 $A$ 的列分法与矩阵 $B$ 的行分法必须完全相同，即 $A$ 的列数与 $B$ 的行数相同，且分块的方式一致，以保证子块之间可以进行矩阵乘法运算。

特别地，若 $A,B$ 是同阶对角形分块矩阵，且分块方式相同： $$ A = \begin{pmatrix} A_1 & & & \ & A_2 & & \ & & \ddots & \ & & & A_k \end{pmatrix},\quad B = \begin{pmatrix} B_1 & & & \ & B_2 & & \ & & \ddots & \ & & & B_k \end{pmatrix} $$ 则 $$ AB = \begin{pmatrix} A_1B_1 & & & \ & A_2B_2 & & \ & & \ddots & \ & & & A_kB_k \end{pmatrix},\quad A^m = \begin{pmatrix} A_1^m & & & \ & A_2^m & & \ & & \ddots & \ & & & A_k^m \end{pmatrix} $$

3.分块矩阵的转置

设分块矩阵 $$ A= \begin{pmatrix} A_1 & A_2 \ A_3 & A_4 \end{pmatrix} $$ 则其转置为 $$ A^T= \begin{pmatrix} A_1^T & A_3^T \ A_2^T & A_4^T \end{pmatrix} $$

分块矩阵转置的两步法：

整体转置：将子块视为普通元素，对分块矩阵整体进行转置（交换行和列）。
子块转置：对每个子块分别求其转置。

4.分块矩阵的逆矩阵

设 $A, B$ 为方阵，则上三角分块矩阵 $ \begin{pmatrix} A & C \ O & B \end{pmatrix} $ 可逆的充要条件是 $A, B$ 都可逆，且其逆矩阵为： $$ \begin{pmatrix} A & C \ O & B \end{pmatrix}^{-1} = \begin{pmatrix} A^{-1} & -A^{-1}CB^{-1} \ O & B^{-1} \end{pmatrix} $$

设 $A, B$ 为方阵，则下三角分块矩阵 $ \begin{pmatrix} A & O \ C & B \end{pmatrix} $ 可逆的充要条件是 $A, B$ 都可逆，且其逆矩阵为： $$ \begin{pmatrix} A & O \ C & B \end{pmatrix}^{-1} = \begin{pmatrix} A^{-1} & O \ -B^{-1}CA^{-1} & B^{-1} \end{pmatrix} $$

设 $A_1, A_2, \dots, A_k$ 为方阵，则对角分块矩阵 $$ \begin{pmatrix} A_1 & & & \ & A_2 & & \ & & \ddots & \ & & & A_k \end{pmatrix} $$ 可逆的充要条件是 $A_1, A_2, \dots, A_k$ 都可逆，且其逆矩阵为：

$$ \begin{pmatrix} A_1 & & & \ & A_2 & & \ & & \ddots & \ & & & A_k \end{pmatrix}^{-1}

\begin{pmatrix} A_1^{-1} & & & \ & A_2^{-1} & & \ & & \ddots & \ & & & A_k^{-1} \end{pmatrix} $$

设 $A = \begin{pmatrix} & B \ C & \end{pmatrix}$，其中 $B, C$ 为方阵且均可逆，则其逆矩阵为： $$ A^{-1} = \begin{pmatrix} & C^{-1} \ B^{-1} & \end{pmatrix} $$

设 $A,B,C$ 均为可逆方阵，则分块对角矩阵的逆矩阵满足：

$$ \begin{pmatrix} A & & \ & B & \ & & C \end{pmatrix}^{-1}

\begin{pmatrix} A^{-1} & & \ & B^{-1} & \ & & C^{-1} \end{pmatrix} $$

设 $A,B,C$ 均为可逆方阵，则反对角分块矩阵的逆矩阵为：

$$ \begin{pmatrix} & & A \ & B & \ C & & \end{pmatrix}^{-1}

\begin{pmatrix} & & C^{-1} \ & B^{-1} & \ A^{-1} & & \end{pmatrix} $$ 该结论是反对角分块矩阵求逆的通用形式，核心规律是：

每个子块取自身的逆；
逆矩阵中的子块位置与原矩阵呈中心对称。

5.分块矩阵的行列式

分块三角矩阵的行列式性质

一.若 $A_1, A_2, \dots, A_k$ 均为方阵，则：

上三角分块矩阵：

$$ \begin{vmatrix} A_1 & * & \dots & * \ & A_2 & \dots & * \ & & \ddots & \vdots \ & & & A_k \end{vmatrix} = |A_1| \cdot |A_2| \cdot \dots \cdot |A_k| $$
下三角分块矩阵：

$$ \begin{vmatrix} A_1 & & & \
- & A_2 & & \ \vdots & \vdots & \ddots & \
- & * & \dots & A_k \end{vmatrix} = |A_1| \cdot |A_2| \cdot \dots \cdot |A_k| $$
对角分块矩阵的行列式性质：

若 $A_1, A_2, \dots, A_k$ 均为方阵，则： $$ \begin{vmatrix} A_1 & & & \ & A_2 & & \ & & \ddots & \ & & & A_k \end{vmatrix} = |A_1| \cdot |A_2| \cdot \dots \cdot |A_k| $$

二.若 $A$ 为 $m$ 阶方阵，$B$ 为 $n$ 阶方阵，则：

$$ \left|\begin{pmatrix} O & A \ B & C \end{pmatrix}\right| = (-1)^{mn} |A| \cdot |B| $$ $$ \left|\begin{pmatrix} C & A \ B & O \end{pmatrix}\right| = (-1)^{mn} |A| \cdot |B| $$ $$ \left|\begin{pmatrix} O & A \ B & O \end{pmatrix}\right| = (-1)^{mn} |A| \cdot |B| $$

2.14 矩阵的秩

矩阵的子式：设矩阵 $A=(a_{ij})_{m\times n}$，在 $A$ 中任取 $k$ 行 $k$ 列（$k\le\min(m,n)$），位于这些行列交叉点处的 $k^2$ 个元素，按原位置不变得到的 $k$ 阶行列式，称为矩阵 $A$ 的一个 $k$ 阶子式。
矩阵的秩：矩阵 $A$ 中非零子式的最高阶数，称为矩阵 $A$ 的秩，记作 $r(A)$。

例如： $$ A = \begin{pmatrix} 0 & 1 & 2 & 0 \ 0 & 0 & 0 & 0 \ 1 & 0 & 5 & -3 \end{pmatrix} $$

子式分析

1阶子式：存在非零值，如 $|1|=1$、$|2|$、$|0|$ 等，说明矩阵至少存在1阶非零子式。
2阶子式：存在非零值，如 $\begin{vmatrix} 0 & 1 \ 1 & 0 \end{vmatrix}=-1$，说明矩阵至少存在2阶非零子式。
3阶子式：所有3阶子式的值均为0，如 $\begin{vmatrix} 0 & 1 & 2 \ 0 & 0 & 0 \ 1 & 0 & 5 \end{vmatrix}=0$，说明矩阵不存在3阶非零子式。

根据矩阵秩的定义，该矩阵的秩为2。

注:

零矩阵没有非零子式，规定零矩阵的秩为零。
若 $A \neq O$，则 $r(A) \ge 1$。
对任意矩阵 $A_{m \times n}$，有 $0 \le r(A) \le \min(m,n)$。

满秩矩阵与降秩矩阵

定义 2.15：设 $A$ 为 $m \times n$ 矩阵，若 $r(A) = \min(m,n)$，称 $A$ 为满秩矩阵。

若 $r(A) = m$，称 $A$ 为行满秩矩阵；
若 $r(A) = n$，称 $A$ 为列满秩矩阵。

若 $r(A) < \min(m,n)$，称 $A$ 为降秩矩阵。

特别地，若 $A$ 为 $n$ 阶方阵：

若 $r(A) = n$，称 $A$ 为满秩矩阵；
若 $r(A) < n$，称 $A$ 为降秩矩阵。

由定义可知：若 $A$ 为 $n$ 阶方阵，则

$A$ 满秩 $\iff r(A)=n \iff |A| \neq 0 \iff A$ 可逆 $\iff A$ 非奇异；
$A$ 降秩 $\iff r(A)<n \iff |A| = 0 \iff A$ 不可逆 $\iff A$ 奇异。

矩阵秩的性质

$r(A)=r(r>0) \iff$ 矩阵 $A$ 中至少有一个 $r$ 阶子式不等于零，而所有的 $r+1$ 阶子式全等于零（或根本没有 $r+1$ 阶子式）。

$r(A) \ge r \iff$ 矩阵 $A$ 中至少有一个 $r$ 阶子式不等于零。

$r(A) < r \iff$ 矩阵 $A$ 中所有 $r$ 阶子式全等于零。

$r(A)=r(A^T)$，$r(A)=r(-A)$，$r(kA)=r(A)\ (k\neq 0)$。

$r(A)=0\iff A=O$，$r(A)\ge 1\iff A\neq O$。

若 $A \neq O$，则 $A$ 的任意两行（列）元素对应成比例 $\iff r(A)=1$。

若 $A$ 为行阶梯形矩阵，则 $r(A)$ 等于 $A$ 中非零行的行数。

初等变换不改变矩阵的秩。即若 $A \cong B$，则 $r(A)=r(B)$。

若 $A, B$ 为同型矩阵，则 $A \cong B \iff r(A)=r(B)$。

若 $A$ 的标准形为 $D=\begin{pmatrix}1&&&&\&\ddots&&&\&&1&&\&&&0&\&&&&\ddots\&&&&&0\end{pmatrix}$，则 $r(A)$ 等于 $D$ 中1的个数。

若 $A,B$ 同为 $m \times n$ 矩阵，则 $r(A \pm B) \le r(A) + r(B)$。

若 $A$ 为 $m\times n$ 矩阵，$B$ 为 $n\times s$ 矩阵，则 $$ r(A)+r(B)-n\le r(AB)\le \min(r(A), r(B)). $$

若 $A$ 为 $m\times n$ 矩阵，$B$ 为 $n\times s$ 矩阵，且 $AB=O$，则 $$ r(A)+r(B)\le n. $$

$$ r(A^T A)=r(AA^T)=r(A)=r(A^T). $$

若 $A$ 为可逆方阵，则 $$ r(AB)=r(B),\quad r(CA)=r(C). $$

（16）若 $A$ 为 $n$ 阶方阵（$n\ge2$），$A^$ 为 $A$ 的伴随矩阵，则： $$ r(A^)= \begin{cases} n, & r(A)=n; \ 1, & r(A)=n-1; \ 0, & r(A)<n-1. \end{cases} $$

矩阵秩的求法

定义法若矩阵 $A$ 中有不等于零的 $r$ 阶子式，而所有的 $r+1$ 阶子式全都等于零（或根本没有 $r+1$ 阶子式），则 $r(A)=r$。

初等变换法利用矩阵的初等行变换，将矩阵化为行阶梯形矩阵，行阶梯形矩阵的非零行的行数即为矩阵的秩。

行列式法若 $A$ 为 $n$ 阶方阵，通过计算行列式 $|A|$ 来判断秩：

若 $|A| \neq 0$，则 $r(A)=n$（矩阵满秩）；
若 $|A| = 0$，则 $r(A)<n$（矩阵降秩）。

第三部分：向量

3.1 向量的概念与线性运算

向量的概念

零向量：所有分量全为零的向量，记为 $\boldsymbol{0}$。

如： $$\boldsymbol{0} = (0, 0, \dots, 0) \quad \text{或} \quad \boldsymbol{0} = \begin{pmatrix} 0 \ 0 \ \vdots \ 0 \end{pmatrix}$$

负向量：将每个分量都取相反数得到的向量。

向量 $\boldsymbol{\alpha}=(a_1, a_2, \dots, a_n)$ 的负向量为 $-\boldsymbol{\alpha}=(-a_1, -a_2, \dots, -a_n)$。

向量 $\boldsymbol{\beta} = \begin{pmatrix} b_1 \ b_2 \ \vdots \ b_m \end{pmatrix}$ 的负向量为 $-\boldsymbol{\beta} = \begin{pmatrix} -b_1 \ -b_2 \ \vdots \ -b_m \end{pmatrix}$。

向量的转置：按矩阵的转置来求。

向量的相等：两个同种类型的向量相等 $\Leftrightarrow$ 相同位置的分量对应相等。

如：设向量 $\boldsymbol{\alpha}=(a_1, a_2, \dots, a_n)$，$\boldsymbol{\beta}=(b_1, b_2, \dots, b_n)$，则 $$\boldsymbol{\alpha}=\boldsymbol{\beta} \Leftrightarrow a_1=b_1,\ a_2=b_2,\ \dots,\ a_n=b_n$$

向量的线性运算

1. 向量的加法与减法

定义 3.2：设两个 $n$ 维向量 $\boldsymbol{\alpha}=(a_1, a_2, \dots, a_n)$，$\boldsymbol{\beta}=(b_1, b_2, \dots, b_n)$，

向量加法定义为： $$\boldsymbol{\alpha} + \boldsymbol{\beta} = (a_1+b_1,\ a_2+b_2,\ \dots,\ a_n+b_n)$$ （对应分量相加）
借助负向量和加法，定义向量的减法： $$\boldsymbol{\alpha} - \boldsymbol{\beta} = \boldsymbol{\alpha} + (-\boldsymbol{\beta}) = (a_1-b_1,\ a_2-b_2,\ \dots,\ a_n-b_n)$$

2. 向量的数乘（定义3.3）

设向量 $\boldsymbol{\alpha}=(a_1, a_2, \dots, a_n)$，$k$ 是一个常数。数 $k$ 与向量 $\boldsymbol{\alpha}$ 的乘法（简称数乘）定义为： $$k\boldsymbol{\alpha}=(ka_1,\ ka_2,\ \dots,\ ka_n)$$ （每个分量都乘 $k$）

示例： $$5\begin{pmatrix} 1 \ 2 \ 3 \end{pmatrix} = \begin{pmatrix} 5 \ 10 \ 15 \end{pmatrix}$$ （该运算可用于提公因子）

3. 向量的运算律

交换律：$\boldsymbol{\alpha} + \boldsymbol{\beta} = \boldsymbol{\beta} + \boldsymbol{\alpha}$

结合律：$(\boldsymbol{\alpha} + \boldsymbol{\beta}) + \boldsymbol{\gamma} = \boldsymbol{\alpha} + (\boldsymbol{\beta} + \boldsymbol{\gamma})$

零向量性质：$\boldsymbol{\alpha} + \boldsymbol{0} = \boldsymbol{0} + \boldsymbol{\alpha} = \boldsymbol{\alpha}$（其中 $\boldsymbol{0}$ 为同型的 $n$ 维零向量）

负向量性质：$\boldsymbol{\alpha} + (-\boldsymbol{\alpha}) = (-\boldsymbol{\alpha}) + \boldsymbol{\alpha} = \boldsymbol{0}$（其中 $\boldsymbol{0}$ 为同型的 $n$ 维零向量）

$1 \cdot \boldsymbol{\alpha} = \boldsymbol{\alpha}$

$(kl)\boldsymbol{\alpha} = k(l\boldsymbol{\alpha}) = l(k\boldsymbol{\alpha})$

$k(\boldsymbol{\alpha} + \boldsymbol{\beta}) = k\boldsymbol{\alpha} + k\boldsymbol{\beta}$

$(k+l)\boldsymbol{\alpha} = k\boldsymbol{\alpha} + l\boldsymbol{\alpha}$

并且还可以推出：

(i) $\boldsymbol{\alpha} + \boldsymbol{\beta} = \boldsymbol{\gamma} \iff \boldsymbol{\alpha} = \boldsymbol{\gamma} - \boldsymbol{\beta} \iff \boldsymbol{\beta} = \boldsymbol{\gamma} - \boldsymbol{\alpha}$

(ii) $k\boldsymbol{\alpha} = \boldsymbol{0} \iff k=0$ 或 $\boldsymbol{\alpha} = \boldsymbol{0}$（$k$ 为实数，$\boldsymbol{\alpha}$ 为向量）。

3.2 向量的线性组合与线性表示

定义 3.4

设 $\boldsymbol{\alpha}_1, \boldsymbol{\alpha}_2, \dots, \boldsymbol{\alpha}_m$ 是一组 $n$ 维向量，$k_1, k_2, \dots, k_m$ 是一组常数，则称 $$k_1\boldsymbol{\alpha}_1 + k_2\boldsymbol{\alpha}_2 + \dots + k_m\boldsymbol{\alpha}_m$$ 为向量组 $\boldsymbol{\alpha}_1, \boldsymbol{\alpha}_2, \dots, \boldsymbol{\alpha}_m$ 的一个线性组合，其中 $k_1, k_2, \dots, k_m$ 称为组合系数。

定义 3.5

设 $\boldsymbol{\beta}, \boldsymbol{\alpha}_1, \boldsymbol{\alpha}_2, \dots, \boldsymbol{\alpha}_m$ 是 $n$ 维向量，若存在常数 $k_1, k_2, \dots, k_m$，使关系式 $$\boldsymbol{\beta} = k_1\boldsymbol{\alpha}_1 + k_2\boldsymbol{\alpha}_2 + \dots + k_m\boldsymbol{\alpha}_m$$ 成立，则称 $\boldsymbol{\beta}$ 是向量组 $\boldsymbol{\alpha}_1, \boldsymbol{\alpha}_2, \dots, \boldsymbol{\alpha}_m$ 的线性组合，也称 $\boldsymbol{\beta}$ 可由向量组 $\boldsymbol{\alpha}_1, \boldsymbol{\alpha}_2, \dots, \boldsymbol{\alpha}_m$ 线性表示。称 $k_1, k_2, \dots, k_m$ 为组合系数。

β 可由 α₁, …, αₛ 表示	Ax=β 方程组
可以表示	有解
不可以表示	无解
可以唯一地表示	唯一解
可以表示，不唯一	无穷多解

有关向量的线性组合与线性表示的结论：

零向量是任意向量组的线性组合。
向量组 $\alpha_1, \alpha_2, \dots, \alpha_n$ 中任一向量 $\alpha_i$（$1 \le i \le n$）均可由本向量组线性表示。
任一$n$维向量$\alpha=(a_1,a_2,\dots,a_n)$都可由$n$维基本单位向量组$\varepsilon_1=(1,0,0,\dots,0)$，$\varepsilon_2=(0,1,0,\dots,0)$，…，$\varepsilon_n=(0,0,0,\dots,1)$线性表示，且表示法唯一。

即有 $$\alpha = a_1\varepsilon_1 + a_2\varepsilon_2 + \dots + a_n\varepsilon_n$$

组合系数即为$\alpha$的分量。

3.3 向量组的线性相关性

定义 3.7

给定向量组 $\alpha_1,\alpha_2,\dots,\alpha_n$，如果存在不全为零的数 $k_1,k_2,\dots,k_n$，使 $$k_1\alpha_1 + k_2\alpha_2 + \dots + k_n\alpha_n = 0 \tag{*}$$ 则称向量组 $\alpha_1,\alpha_2,\dots,\alpha_n$ 线性相关，而称 $k_1,k_2,\dots,k_n$ 为一组相关系数。否则，称向量组 $\alpha_1,\alpha_2,\dots,\alpha_n$ 线性无关。

线性无关的等价表述：

不存在不全为零的 $k_1,\dots,k_n$，使 (*) 式成立；
若 (*) 式成立，则 $k_1,\dots,k_n$ 必全取 $0$；
对任意不全为 $0$ 的 $k_1,\dots,k_n$，都有 $k_1\alpha_1 + \dots + k_n\alpha_n \neq 0$。

补充：$0\alpha_1 + 0\alpha_2 + \dots + 0\alpha_m = 0$

线性相关性性质的结论

（1）：一个向量$\alpha$ 线性相关 $\iff \alpha = 0$；
一个向量$\alpha$ 线性无关 $\iff \alpha \neq 0$。 （2）：两个非零向量$\alpha$与$\beta$线性相关$\iff \alpha$与$\beta$的分量对应成比例。 （3）：如果向量组中有一部分向量（称为部分组）线性相关，则该向量组线性相关。 （4）：若向量组线性无关，则其任一部分组也线性无关。 （5）：含有零向量的向量组必线性相关。 （6）：$n$维单位坐标向量组必线性无关。 （7）：设$r$维向量$\alpha_1,\alpha_2,\dots,\alpha_m$线性无关，$\beta_1,\beta_2,\dots,\beta_m$为$\alpha_1,\alpha_2,\dots,\alpha_m$的$r+l$维接长向量，则$\beta_1,\beta_2,\dots,\beta_m$线性无关。 （8）：设$\alpha_1,\alpha_2,\dots,\alpha_m$是$r$维向量，$\beta_1,\beta_2,\dots,\beta_m$是其$r+l$维接长向量，若$\beta_1,\beta_2,\dots,\beta_m$线性相关，则$\alpha_1,\alpha_2,\dots,\alpha_m$也线性相关。 （9）：若向量组中有两个向量成比例，则向量组必线性相关。

3.4 极大线性无关组

定义

设向量组 $ T $ 的一个部分组 $ \alpha_{i_1}, \alpha_{i_2}, \dots, \alpha_{i_r} $ 满足：

线性无关：$ \alpha_{i_1}, \alpha_{i_2}, \dots, \alpha_{i_r} $ 线性无关；
极大性：向量组 $ T $ 中任意一个向量都可由 $ \alpha_{i_1}, \alpha_{i_2}, \dots, \alpha_{i_r} $ 线性表示。

则称 $ \alpha_{i_1}, \alpha_{i_2}, \dots, \alpha_{i_r} $ 是向量组 $ T $ 的一个极大线性无关组。

性质

（1）：向量组与其极大线性无关组等价。
（2）：线性无关的向量组，其极大线性无关组为向量组本身。
（3）：向量组的极大线性无关组可能不唯一。
（4）：向量组和它的任一极大线性无关组等价。
（5）：同一向量组的两个极大线性无关组等价，所含向量个数相等。
（6）：若向量组（Ⅰ）可由向量组（Ⅱ）线性表示，则向量组（Ⅰ）的极大线性无关组可由向量组（Ⅱ）的极大线性无关组线性表示。
（7）：等价的向量组，其极大线性无关组也等价。

极大线性无关组的求法-初等矩阵变换法

方法原理

将向量组中的向量作为列向量构成矩阵 $ A $，对 $ A $ 进行初等行变换化为行阶梯形矩阵。行阶梯形矩阵中非零行的首元（主元）所在的列，对应的原矩阵中的列向量即为向量组的一个极大线性无关组。

核心依据：初等行变换不改变矩阵列向量之间的线性相关性。

具体步骤

构造矩阵：设向量组为 $ \alpha_1, \alpha_2, \dots, \alpha_s $，构造矩阵 $ A = (\alpha_1, \alpha_2, \dots, \alpha_s) $；
初等行变换：对 $ A $ 进行初等行变换，化为行阶梯形矩阵 $ B $；
确定主元列：在 $ B $ 中找出非零行首元所在的列（主元列）；
对应原向量：原矩阵 $ A $ 中与 $ B $ 主元列对应的列向量，构成极大线性无关组。

示例

求向量组 $ \alpha_1 = (1, 2, 3)^T $，$ \alpha_2 = (2, 4, 6)^T $，$ \alpha_3 = (1, 0, 1)^T $，$ \alpha_4 = (3, 2, 5)^T $ 的极大线性无关组。

构造矩阵： $$ A = (\alpha_1, \alpha_2, \alpha_3, \alpha_4) = \begin{pmatrix} 1 & 2 & 1 & 3 \ 2 & 4 & 0 & 2 \ 3 & 6 & 1 & 5 \end{pmatrix} $$
初等行变换： $$ A \xrightarrow{r_2-2r_1, r_3-3r_1} \begin{pmatrix} 1 & 2 & 1 & 3 \ 0 & 0 & -2 & -4 \ 0 & 0 & -2 & -4 \end{pmatrix} \xrightarrow{r_3-r_2} \begin{pmatrix} 1 & 2 & 1 & 3 \ 0 & 0 & -2 & -4 \ 0 & 0 & 0 & 0 \end{pmatrix} $$
确定主元列：行阶梯形矩阵中，第1列和第3列为主元列（非零行首元所在列）。
对应原向量：原矩阵中第1列和第3列对应的向量 $ \alpha_1, \alpha_3 $ 是一个极大线性无关组。

向量的线性表示

若需将其他向量用极大线性无关组表示，可继续将行阶梯形矩阵化为行简化阶梯形矩阵： $$ \begin{pmatrix} 1 & 2 & 1 & 3 \ 0 & 0 & -2 & -4 \ 0 & 0 & 0 & 0 \end{pmatrix} \xrightarrow{r_2 \times (-\frac{1}{2})} \begin{pmatrix} 1 & 2 & 1 & 3 \ 0 & 0 & 1 & 2 \ 0 & 0 & 0 & 0 \end{pmatrix} \xrightarrow{r_1-r_3} \begin{pmatrix} 1 & 2 & 0 & 1 \ 0 & 0 & 1 & 2 \ 0 & 0 & 0 & 0 \end{pmatrix} $$

由此可得：

$ \alpha_2 = 2\alpha_1 $（第2列：$ (2, 0, 0)^T = 2(1, 0, 0)^T $）
$ \alpha_4 = \alpha_1 + 2\alpha_3 $（第4列：$ (1, 2, 0)^T = 1(1, 0, 0)^T + 2(0, 1, 0)^T $）

注意事项

行变换而非列变换：必须使用初等行变换，不能使用初等列变换；
主元列的选择：不同的初等行变换可能得到不同的主元列位置，但极大线性无关组所含向量个数相同；
结果验证：可通过验证所选向量组线性无关，且其他向量可由其线性表示来确认正确性；
行简化阶梯形：化为行简化阶梯形矩阵可直接得到线性表示系数。

定义 3.9 向量组 $\alpha_1,\alpha_2,\dots,\alpha_s$ 的任一极大线性无关组所含向量的个数，称为该向量组的秩，记作 $r(\alpha_1,\alpha_2,\dots,\alpha_s)$。

规定：零向量组的秩为 $0$，$0 \le r(\alpha_1,\alpha_2,\dots,\alpha_s) \le s$。

矩阵的行秩与列秩

矩阵行向量组的秩称为行秩，列向量组的秩称为列秩。行秩 $=$ 列秩 $= r(A)$

第四部分：线性方程组

4.1 线性方程组的表示法

一般形式

$$ \begin{cases} a_{11}x_1 + a_{12}x_2 + \dots + a_{1n}x_n = b_1 \ a_{21}x_1 + a_{22}x_2 + \dots + a_{2n}x_n = b_2 \ \quad\quad\quad\quad\quad\quad\quad\quad\vdots \ a_{m1}x_1 + a_{m2}x_2 + \dots + a_{mn}x_n = b_m \end{cases} $$

$m$：方程的个数
$n$：未知量的个数

矩阵形式

系数矩阵： $$ A = \begin{pmatrix} a_{11} & a_{12} & \dots & a_{1n} \ a_{21} & a_{22} & \dots & a_{2n} \ \vdots & \vdots & & \vdots \ a_{m1} & a_{m2} & \dots & a_{mn} \end{pmatrix} $$
增广矩阵： $$ \overline{A} = (A,b) = \begin{pmatrix} a_{11} & a_{12} & \dots & a_{1n} & b_1 \ a_{21} & a_{22} & \dots & a_{2n} & b_2 \ \vdots & \vdots & & \vdots & \vdots \ a_{m1} & a_{m2} & \dots & a_{mn} & b_m \end{pmatrix} $$
未知数列向量： $$ x = \begin{pmatrix} x_1 \ x_2 \ \vdots \ x_n \end{pmatrix} $$
常数列向量： $$ b = \begin{pmatrix} b_1 \ b_2 \ \vdots \ b_m \end{pmatrix} $$

向量形式

将系数矩阵 $ A $ 按列分块，即 $ A = (\alpha_1, \alpha_2, \dots, \alpha_n) $，根据向量的线性运算，则非齐次线性方程组（4.1）可以表示为向量形式： $$ x_1\alpha_1 + x_2\alpha_2 + \dots + x_n\alpha_n = b $$

齐次线性方程组（4.2）的向量形式为： $$ x_1\alpha_1 + x_2\alpha_2 + \dots + x_n\alpha_n = 0 $$

其中，$ \alpha_1, \alpha_2, \dots, \alpha_n $ 为系数矩阵 $ A $ 的列向量组。

4.2 线性方程组解的判定

定义 4.1.1 线性方程组的下列三种变换，称为线性方程组的初等变换：

交换两个方程的位置；
在方程两端乘以数 $ k \neq 0 $；
某方程两端 $ l $ 倍后加到另一个方程上。

n 元非齐次线性方程组 $Ax = b$ 解的判定

解的情况	充要条件
有解	$ r(A) = r(\overline{A}) $
有唯一解	$ r(A) = r(\overline{A}) = n $
有无穷多解	$ r(A) = r(\overline{A}) < n $
无解	$ r(A) \neq r(\overline{A}) $

逻辑关系

$ r(A) \neq r(\overline{A}) \implies $ 无解
$ r(A) = r(\overline{A}) \implies $ 有解
- $ r(A) = r(\overline{A}) = n \implies $ 唯一解
- $ r(A) = r(\overline{A}) < n \implies $ 无穷多解

齐次线性方程组解的判定

核心结论

$Ax=0$ 有非零解 $\iff$ 向量组 $\alpha_1, \alpha_2, \dots, \alpha_n$ 线性相关 $\iff r(\alpha_1, \alpha_2, \dots, \alpha_n) < n$ $\iff r(A) < n$
$Ax=0$ 只有零解 $\iff$ 向量组 $\alpha_1, \alpha_2, \dots, \alpha_n$ 线性无关 $\iff r(\alpha_1, \alpha_2, \dots, \alpha_n) = n$ $\iff r(A) = n$

定理 4.2

$n$ 元齐次线性方程组 $Ax=0$ 有非零解的充要条件是其系数矩阵 $A$ 的秩小于未知量的个数，即 $r(A) < n$。
$Ax=0$ 只有零解的充要条件是其系数矩阵 $A$ 的秩等于未知量的个数，即 $r(A) = n$。

解的情况	充要条件
有非零解	$r(A) < n$
只有零解	$r(A) = n$

推论 4.1

对于齐次线性方程组 $Ax=0$，若方程个数 $m$ 小于未知数个数 $n$，则 $Ax=0$ 必有非零解。
（理由：$r(A) \le \min{m, n} = m < n$）

推论 4.2

对于齐次线性方程组 $Ax=0$，若方程个数等于未知数个数（即 $A$ 为方阵）：

$Ax=0$ 有非零解 $\iff |A| = 0$
$Ax=0$ 只有零解 $\iff |A| \neq 0$

4.3 线性方程组的解的性质

齐次线性方程组解的性质

性质1：若 $\xi_1, \xi_2$ 是 $Ax=0$ 的解，则 $\xi_1+\xi_2$ 也是 $Ax=0$ 的解。证明：$A(\xi_1+\xi_2)=A\xi_1+A\xi_2=0+0=0$。
性质2：若 $\xi$ 是 $Ax=0$ 的解，则对任意常数 $k$，$k\xi$ 也是 $Ax=0$ 的解。证明：$A(k\xi)=kA\xi=k\cdot0=0$。
性质3：若 $\xi_1, \xi_2, \dots, \xi_s$ 是 $Ax=0$ 的解，则它们的线性组合 $c_1\xi_1+c_2\xi_2+\dots+c_s\xi_s$（$c_1,c_2,\dots,c_s$ 为任意常数）也是 $Ax=0$ 的解。证明：$A(c_1\xi_1+\dots+c_s\xi_s)=c_1A\xi_1+\dots+c_sA\xi_s=0$。

非齐次线性方程组解的性质

（$Ax=b$ 与其导出组 $Ax=0$ 的解的关系）

性质4：设 $\eta_1, \eta_2$ 是 $Ax=b$ 的任意两个解，则 $\eta_1-\eta_2$ 是导出组 $Ax=0$ 的解。证明：$A(\eta_1-\eta_2)=A\eta_1-A\eta_2=b-b=0$。
性质5：设 $\eta$ 是 $Ax=b$ 的解，$\xi$ 是导出组 $Ax=0$ 的解，则 $\xi+\eta$ 是 $Ax=b$ 的解。证明：$A(\eta+\xi)=A\eta+A\xi=b+0=b$。
性质6：若 $\eta^$ 是 $Ax=b$ 的一个特解，则 $Ax=b$ 的任一解都可表示为 $\xi+\eta^$，其中 $\xi$ 是导出组 $Ax=0$ 的解。

4.4 齐次线性方程组的基础解系

定义 4.1 基础解系

设 $\xi_1, \xi_2, \dots, \xi_s$ 是齐次线性方程组 $Ax=0$ 的解向量，若满足：

$\xi_1, \xi_2, \dots, \xi_s$ 线性无关；
方程组 $Ax=0$ 的任一解向量都可以由 $\xi_1, \xi_2, \dots, \xi_s$ 线性表示。则称 $\xi_1, \xi_2, \dots, \xi_s$ 是 $Ax=0$ 的一个基础解系。

定理 4.3

对于 $n$ 元齐次线性方程组 $Ax=0$，若系数矩阵的秩 $r(A)=r < n$，则：

$Ax=0$ 一定存在基础解系；
基础解系中含有 $n-r$ 个线性无关的解向量。

示例：求基础解系

写出齐次方程组： $$ \begin{cases} x_1 + x_2 + x_3 + 4x_4 - 3x_5 = 0 \ x_1 - x_2 + 3x_3 - 2x_4 - x_5 = 0 \ 2x_1 + x_2 + 3x_3 + 5x_4 - 5x_5 = 0 \ 3x_1 + x_2 + 5x_3 + 6x_4 - 7x_5 = 0 \end{cases} $$
对系数矩阵做初等行变换，化为阶梯形： $$ A = \begin{pmatrix} 1 & 1 & 1 & 4 & -3 \ 1 & -1 & 3 & -2 & -1 \ 2 & 1 & 3 & 5 & -5 \ 3 & 1 & 5 & 6 & -7 \end{pmatrix} \rightarrow \begin{pmatrix} 1 & 0 & 2 & 1 & -2 \ 0 & 1 & -1 & 3 & -1 \ 0 & 0 & 0 & 0 & 0 \ 0 & 0 & 0 & 0 & 0 \end{pmatrix} $$
写出同解方程组： $$ \begin{cases} x_1 = -2x_3 - x_4 + 2x_5 \ x_2 = x_3 - 3x_4 + x_5 \end{cases} $$
令自由变量 $(x_3, x_4, x_5)$ 分别取 $(1,0,0), (0,1,0), (0,0,1)$，得： $$ \xi_1 = \begin{pmatrix} -2 \ 1 \ 1 \ 0 \ 0 \end{pmatrix}, \quad \xi_2 = \begin{pmatrix} -1 \ -3 \ 0 \ 1 \ 0 \end{pmatrix}, \quad \xi_3 = \begin{pmatrix} 2 \ 1 \ 0 \ 0 \ 1 \end{pmatrix} $$ $\xi_1, \xi_2, \xi_3$ 即为该方程组的一个基础解系。

基础解系的判定

根据基础解系的定义及存在条件，可知：

向量组 $\xi_1, \xi_2, \dots, \xi_s$ 是 $n$ 元齐次线性方程组 $Ax=0$ 的基础解系，当且仅当：

（Ⅰ）$\xi_1, \xi_2, \dots, \xi_s$ 是 $Ax=0$ 的解向量；
（Ⅱ）$\xi_1, \xi_2, \dots, \xi_s$ 线性无关；
（Ⅲ）方程组 $Ax=0$ 的任一解向量都可以由 $\xi_1, \xi_2, \dots, \xi_s$ 线性表示。

向量组 $\xi_1,\xi_2,\dots,\xi_s$ 是 $n$ 元齐次线性方程组 $Ax=0$ 的基础解系，当且仅当：

（Ⅰ）$\xi_1,\xi_2,\dots,\xi_s$ 是 $Ax=0$ 的解向量；
（Ⅱ）$\xi_1,\xi_2,\dots,\xi_s$ 线性无关；
（Ⅲ）向量组 $\xi_1,\xi_2,\dots,\xi_s$ 中向量的个数等于 $n-r(A)$（即能表示方程组的所有解）。

基础解系的性质（具备极大线性无关组的性质）

当 $Ax=0$ 有非零解时，基础解系存在；
若 $Ax=0$ 的基础解系存在，则基础解系不唯一；
$Ax=0$ 的不同基础解系之间可以互相线性表示；
$Ax=0$ 的不同基础解系中所含向量的个数相等，均为 $n - r(A)$（其中 $n$ 为未知数的个数，$r(A)$ 为系数矩阵的秩）。
$Ax=0$ 的任意 $n-r(A)$ 个线性无关的解向量都是它的基础解系（其中 $n$ 为未知数的个数）。
若 $\xi_1,\xi_2,\dots,\xi_s$ 是 $Ax=0$ 的一个基础解系，则 $Ax=0$ 的任一解都可用 $\xi_1,\xi_2,\dots,\xi_s$ 线性表示。

4.5 线性方程组解的结构

齐次线性方程组解的结构（定理4.4）

当齐次线性方程组 $Ax=0$ 只有零解时，问题自然解决；当有非零解时，有如下结论：

对于 $n$ 元齐次线性方程组 $Ax=0$，若系数矩阵 $A$ 的秩 $r(A)=r<n$，且 $\xi_1,\xi_2,\dots,\xi_{n-r}$ 为其一个基础解系，则方程组的通解可表示为： $$ x = c_1\xi_1 + c_2\xi_2 + \dots + c_{n-r}\xi_{n-r} $$ 其中 $c_1,c_2,\dots,c_{n-r}$ 为任意常数。

由于基础解系不唯一，齐次线性方程组的通解形式也不唯一，但都可以表示方程组的所有解。

非齐次线性方程组解的结构（定理4.5）

对于 $n$ 元非齐次线性方程组 $Ax=b$，若 $r(A)=r(\overline{A})=r<n$，且：

$\alpha_0$ 是 $Ax=b$ 的一个特解，
$\xi_1,\xi_2,\dots,\xi_{n-r}$ 为其导出组 $Ax=0$ 的一个基础解系，

则方程组的通解可表示为： $$ x = \alpha_0 + c_1\xi_1 + c_2\xi_2 + \dots + c_{n-r}\xi_{n-r} $$ 其中 $c_1,c_2,\dots,c_{n-r}$ 为任意常数。

4.6 线性方程组的求解

一、齐次线性方程组 $ A\mathbf{x} = \mathbf{0} $

求解步骤

写出系数矩阵 $ A $；
初等行变换：将 $ A $ 化为行简化阶梯形矩阵；
确定秩：设 $ r(A) = r $，未知数个数 $ n $；
判断解的情况：
- 若 $ r = n $，方程组只有零解；
- 若 $ r < n $，方程组有非零解（无穷多解）；
写出基础解系：
- 确定自由未知量（非主元列对应的未知数）；
- 令自由未知量分别取 $ (1,0,\dots,0), (0,1,\dots,0), \dots, (0,0,\dots,1) $；
- 求出对应的解向量，即为基础解系 $ \xi_1, \xi_2, \dots, \xi_{n-r} $；
写出通解： $$ \mathbf{x} = c_1\xi_1 + c_2\xi_2 + \dots + c_{n-r}\xi_{n-r} $$ 其中 $ c_1, c_2, \dots, c_{n-r} $ 为任意常数。

示例

求解齐次线性方程组： $$ \begin{cases} x_1 + x_2 + x_3 + x_4 = 0 \ 2x_1 + 3x_2 + 4x_3 + 5x_4 = 0 \ 3x_1 + 4x_2 + 5x_3 + 6x_4 = 0 \end{cases} $$

解：

系数矩阵： $$ A = \begin{pmatrix} 1 & 1 & 1 & 1 \ 2 & 3 & 4 & 5 \ 3 & 4 & 5 & 6 \end{pmatrix} $$
初等行变换： $$ A \xrightarrow{r_2-2r_1, r_3-3r_1} \begin{pmatrix} 1 & 1 & 1 & 1 \ 0 & 1 & 2 & 3 \ 0 & 1 & 2 & 3 \end{pmatrix} \xrightarrow{r_3-r_2} \begin{pmatrix} 1 & 1 & 1 & 1 \ 0 & 1 & 2 & 3 \ 0 & 0 & 0 & 0 \end{pmatrix} $$ $$ \xrightarrow{r_1-r_2} \begin{pmatrix} 1 & 0 & -1 & -2 \ 0 & 1 & 2 & 3 \ 0 & 0 & 0 & 0 \end{pmatrix} $$
确定秩：$ r(A) = 2 $，$ n = 4 $，$ n-r = 2 $，有无穷多解。
确定自由未知量：$ x_3, x_4 $ 为自由未知量。
求基础解系：
- 令 $ x_3 = 1, x_4 = 0 $，得 $ x_1 = 1, x_2 = -2 $，$ \xi_1 = (1, -2, 1, 0)^T $；
- 令 $ x_3 = 0, x_4 = 1 $，得 $ x_1 = 2, x_2 = -3 $，$ \xi_2 = (2, -3, 0, 1)^T $。
通解： $$ \mathbf{x} = c_1\begin{pmatrix} 1 \ -2 \ 1 \ 0 \end{pmatrix} + c_2\begin{pmatrix} 2 \ -3 \ 0 \ 1 \end{pmatrix} $$ （$ c_1, c_2 $ 为任意常数）

二、非齐次线性方程组 $ A\mathbf{x} = \mathbf{b} $

求解步骤

写出增广矩阵 $ \bar{A} = (A \mid \mathbf{b}) $；
初等行变换：将 $ \bar{A} $ 化为行简化阶梯形矩阵；
判断解的情况：
- 若 $ r(A) \neq r(\bar{A}) $，方程组无解；
- 若 $ r(A) = r(\bar{A}) = n $，方程组有唯一解；
- 若 $ r(A) = r(\bar{A}) = r < n $，方程组有无穷多解；
求解：
- 唯一解：直接读出解；
- 无穷多解：先求特解 $ \alpha_0 $，再求导出组 $ A\mathbf{x} = \mathbf{0} $ 的基础解系 $ \xi_1, \xi_2, \dots, \xi_{n-r} $；
写出通解： $$ \mathbf{x} = \alpha_0 + c_1\xi_1 + c_2\xi_2 + \dots + c_{n-r}\xi_{n-r} $$ 其中 $ c_1, c_2, \dots, c_{n-r} $ 为任意常数。

示例

求解非齐次线性方程组： $$ \begin{cases} x_1 + x_2 + x_3 = 2 \ 2x_1 + 3x_2 + 4x_3 = 7 \ 3x_1 + 4x_2 + 5x_3 = 9 \end{cases} $$

解：

增广矩阵： $$ \bar{A} = \begin{pmatrix} 1 & 1 & 1 & 2 \ 2 & 3 & 4 & 7 \ 3 & 4 & 5 & 9 \end{pmatrix} $$
初等行变换： $$ \bar{A} \xrightarrow{r_2-2r_1, r_3-3r_1} \begin{pmatrix} 1 & 1 & 1 & 2 \ 0 & 1 & 2 & 3 \ 0 & 1 & 2 & 3 \end{pmatrix} \xrightarrow{r_3-r_2} \begin{pmatrix} 1 & 1 & 1 & 2 \ 0 & 1 & 2 & 3 \ 0 & 0 & 0 & 0 \end{pmatrix} $$ $$ \xrightarrow{r_1-r_2} \begin{pmatrix} 1 & 0 & -1 & -1 \ 0 & 1 & 2 & 3 \ 0 & 0 & 0 & 0 \end{pmatrix} $$
判断：$ r(A) = r(\bar{A}) = 2 < 3 $，有无穷多解。
求特解：令自由未知量 $ x_3 = 0 $，得 $ x_1 = -1, x_2 = 3 $，特解 $ \alpha_0 = (-1, 3, 0)^T $。
求导出组的基础解系：
- 令 $ x_3 = 1 $，得 $ x_1 = 1, x_2 = -2 $，$ \xi_1 = (1, -2, 1)^T $。
通解： $$ \mathbf{x} = \begin{pmatrix} -1 \ 3 \ 0 \end{pmatrix} + c_1\begin{pmatrix} 1 \ -2 \ 1 \end{pmatrix} $$ （$ c_1 $ 为任意常数）

三、含参数的线性方程组

讨论步骤

对增广矩阵 $ \bar{A} $ 进行初等行变换，化为行阶梯形矩阵；
根据参数的取值，讨论 $ r(A) $ 与 $ r(\bar{A}) $ 的关系；
确定方程组有解、无解、唯一解、无穷多解的条件；
在有解的情况下求解。

示例

讨论方程组解的情况： $$ \begin{cases} x_1 + x_2 + x_3 = 1 \ x_1 + 2x_2 + ax_3 = 2 \ x_1 + 4x_2 + a^2x_3 = a \end{cases} $$

解：

增广矩阵： $$ \bar{A} = \begin{pmatrix} 1 & 1 & 1 & 1 \ 1 & 2 & a & 2 \ 1 & 4 & a^2 & a \end{pmatrix} \xrightarrow{r_2-r_1, r_3-r_1} \begin{pmatrix} 1 & 1 & 1 & 1 \ 0 & 1 & a-1 & 1 \ 0 & 3 & a^2-1 & a-1 \end{pmatrix} $$ $$ \xrightarrow{r_3-3r_2} \begin{pmatrix} 1 & 1 & 1 & 1 \ 0 & 1 & a-1 & 1 \ 0 & 0 & a^2-3a+2 & a-4 \end{pmatrix} $$
讨论：
- $ a^2-3a+2 = (a-1)(a-2) $
- 当 $ a \neq 1 $ 且 $ a \neq 2 $ 时，$ r(A) = r(\bar{A}) = 3 = n $，有唯一解；
- 当 $ a = 1 $ 时，$ \bar{A} \to \begin{pmatrix} 1 & 1 & 1 & 1 \ 0 & 1 & 0 & 1 \ 0 & 0 & 0 & -3 \end{pmatrix} $，$ r(A) = 2 \neq r(\bar{A}) = 3 $，无解；
- 当 $ a = 2 $ 时，$ \bar{A} \to \begin{pmatrix} 1 & 1 & 1 & 1 \ 0 & 1 & 1 & 1 \ 0 & 0 & 0 & -2 \end{pmatrix} $，$ r(A) = 2 \neq r(\bar{A}) = 3 $，无解。

四、线性方程组解的结构定理

定理：设 $ n $ 元线性方程组 $ A\mathbf{x} = \mathbf{b} $ 的系数矩阵 $ A $ 的秩 $ r(A) = r $，则：

若 $ r(A) \neq r(\bar{A}) $，方程组无解；
若 $ r(A) = r(\bar{A}) = n $，方程组有唯一解；
若 $ r(A) = r(\bar{A}) = r < n $，方程组有无穷多解，通解为： $$ \mathbf{x} = \alpha_0 + c_1\xi_1 + c_2\xi_2 + \dots + c_{n-r}\xi_{n-r} $$ 其中：
- $ \alpha_0 $ 是 $ A\mathbf{x} = \mathbf{b} $ 的一个特解；
- $ \xi_1, \xi_2, \dots, \xi_{n-r} $ 是导出组 $ A\mathbf{x} = \mathbf{0} $ 的基础解系；
- $ c_1, c_2, \dots, c_{n-r} $ 为任意常数。

五、解题技巧总结

行简化阶梯形：尽量化为行简化阶梯形，可直接读出解；
自由未知量选择：通常选非主元列对应的未知量为自由未知量；
特解求法：令所有自由未知量为 0，可直接得到一个特解；
基础解系求法：对每个自由未知量轮流取 1，其余取 0；
参数讨论：注意使分母为 0 或使某行全为 0 的参数值；
验证：可将求得的解代入原方程组验证正确性。

第五部分：特征值与特征向量

5.1 特征值与特征向量的定义与关系

特征值与特征向量定义

设 $A$ 为 $n$ 阶方阵，$\alpha$ 为 $n$ 维非零列向量，$\lambda$ 为数。若满足： $$A\alpha = \lambda\alpha$$ 则称 $\lambda$ 为方阵 $A$ 的特征值，$\alpha$ 为 $A$ 对应于特征值 $\lambda$ 的特征向量。

关键说明

矩阵 $A$ 必须是方阵 若 $A$ 不是方阵，则 $A\alpha$ 与 $\lambda\alpha$ 的维度无法匹配，因此特征值/特征向量仅对方阵定义。
特征值 $\lambda$ 是一个数，可取 0 $$ \begin{pmatrix} 1 & -1 \ 1 & -1 \end{pmatrix} \begin{pmatrix} 1 \ 1 \end{pmatrix} = 0 \times \begin{pmatrix} 1 \ 1 \end{pmatrix} $$ 此处 $\lambda=0$ 为该矩阵的一个特征值。
特征向量 $\alpha$ 是非零列向量

列向量：满足矩阵乘法维度要求；
非零向量：$\alpha=0$ 时等式恒成立，无法体现矩阵特性，故特征向量规定为非零。

特征值与特征向量的关系

性质1 若$\alpha$是矩阵$A$对应于特征值$\lambda$的特征向量，则$k\alpha(k\neq0)$也是矩阵$A$对应于特征值$\lambda$的特征向量。

性质2 给定方阵$A$，特征向量$\alpha$只能属于一个特征值。

性质3 给定方阵$A$，若$\alpha_1,\alpha_2$都是对应于特征值$\lambda$的特征向量，当线性组合$k_1\alpha_1+k_2\alpha_2\neq0$时，该组合也是对应于特征值$\lambda$的特征向量。

5.2 特征值与特征向量的求法

特征值的求法（公式：$|\lambda E - A| = 0$）

步骤1：写出 $\lambda E - A$

构造方法：
1. $\lambda$ 仅出现在主对角线上；
2. 其余元素为矩阵 $A$ 对应元素的相反数。
示例：若 $A=\begin{pmatrix}1&1&1\2&2&2\3&3&3\end{pmatrix}$，则 $$ \lambda E - A = \begin{pmatrix} \lambda-1 & -1 & -1 \ -2 & \lambda-2 & -2 \ -3 & -3 & \lambda-3 \end{pmatrix} $$

步骤2：写出 $|\lambda E - A|$

将矩阵 $\lambda E - A$ 改写为行列式形式（熟练后可省略步骤1）： $$ |\lambda E - A| = \begin{vmatrix} \lambda-1 & -1 & -1 \ -2 & \lambda-2 & -2 \ -3 & -3 & \lambda-3 \end{vmatrix} $$

步骤3：解特征方程 $|\lambda E - A| = 0$

根据矩阵类型，有以下常见情况：

情况1：2阶矩阵

直接展开行列式计算。

例：$A=\begin{pmatrix}1&1\4&1\end{pmatrix}$ $$ |\lambda E - A| = \begin{vmatrix}\lambda-1 & -1 \ -4 & \lambda-1\end{vmatrix} = (\lambda-1)^2 - 4 = (\lambda+1)(\lambda-3)=0 $$ 解得：$\lambda_1=-1,\ \lambda_2=3$。

情况2：对角、上三角、下三角矩阵

特征值等于主对角线元素，直接写出结果。

例：上三角矩阵 $A=\begin{pmatrix}-3&6&9\0&4&-11\0&0&7\end{pmatrix}$，特征值为 $\lambda_1=-3,\ \lambda_2=4,\ \lambda_3=7$。

情况3：特征行列式零元素较多

按某一行（列）展开，优先选择只有一个非零元素的行/列；若零元素不足，可先用行列式性质消零再展开。

情况4：行和（列和）相等的矩阵

先将所有列加到第1列，提取公因子，再化为上三角行列式。

例：$A=\begin{pmatrix}1&1&1\1&1&1\1&1&1\end{pmatrix}$ $$ |\lambda E - A| = \begin{vmatrix}\lambda-1 & -1 & -1 \ -1 & \lambda-1 & -1 \ -1 & -1 & \lambda-1\end{vmatrix} = (\lambda-3)\lambda^2 = 0 $$ 解得：$\lambda_1=\lambda_2=0,\ \lambda_3=3$。

情况5：行列式中有对应相等/相反数元素

利用行列式性质消元，构造零元素，再展开求解。

例：$A=\begin{pmatrix}-1&1&2\-2&2&2\-2&1&3\end{pmatrix}$，通过行变换消元后可得 $|\lambda E - A|=(\lambda-1)^2(\lambda-2)=0$，解得 $\lambda_1=\lambda_2=1,\ \lambda_3=2$。

特征向量的求法

求出特征值后，特征向量的求解就是求齐次线性方程组的非零解。

推导过程： $$ A\alpha = \lambda\alpha $$ $$ \lambda\alpha - A\alpha = 0 $$ $$ (\lambda E - A)\alpha = 0,\ \alpha \text{ 为非零向量} $$ 即：求齐次线性方程组 $(\lambda E - A)x = 0$ 的非零解。

【例10】矩阵特征值与特征向量求解

求矩阵 $$ A=\begin{pmatrix} -1 & 1 & 0 \ -4 & 3 & 0 \ 1 & 0 & 2 \end{pmatrix} $$ 的特征值与特征向量。

求特征值 计算特征行列式： $$ |\lambda E - A| = \begin{vmatrix} \lambda+1 & -1 & 0 \ 4 & \lambda-3 & 0 \ -1 & 0 & \lambda-2 \end{vmatrix} = (\lambda-2)(-1)^{3+3} \begin{vmatrix} \lambda+1 & -1 \ 4 & \lambda-3 \end{vmatrix} = (\lambda-2)(\lambda-1)^2 $$ 令 $|\lambda E - A|=0$，解得特征值： $$ \lambda_1=2,\quad \lambda_2=\lambda_3=1 $$
对特征值 $\lambda_1=2$ 求特征向量 构造并化简矩阵 $2E-A$： $$ 2E-A = \begin{pmatrix} 3 & -1 & 0 \ 4 & -1 & 0 \ -1 & 0 & 0 \end{pmatrix} \rightarrow \begin{pmatrix} 0 & -1 & 0 \ 0 & 0 & 0 \ 1 & 0 & 0 \end{pmatrix} \rightarrow \begin{pmatrix} 1 & 0 & 0 \ 0 & 1 & 0 \ 0 & 0 & 0 \end{pmatrix} $$ 得同解方程组： $$ \begin{cases} x_1 = 0 \ x_2 = 0 \end{cases} $$ 取 $x_3=1$，得基础解系： $$ c_1\begin{pmatrix} 0 \ 0 \ 1 \end{pmatrix},\ c_1\neq 0 $$
对特征值 $\lambda_2=\lambda_3=1$ 求特征向量 构造并化简矩阵 $E-A$： $$ E-A = \begin{pmatrix} 2 & -1 & 0 \ 4 & -2 & 0 \ -1 & 0 & -1 \end{pmatrix} \rightarrow \begin{pmatrix} 2 & -1 & 0 \ 0 & 0 & 0 \ -1 & 0 & -1 \end{pmatrix} \rightarrow \begin{pmatrix} 1 & 0 & 1 \ 0 & 1 & 2 \ 0 & 0 & 0 \end{pmatrix} $$ 得同解方程组： $$ \begin{cases} x_1 = -x_3 \ x_2 = -2x_3 \end{cases} $$ 取 $x_3=1$，得基础解系： $$ c_2\begin{pmatrix} -1 \ -2 \ 1 \end{pmatrix},\ c_2\neq 0 $$

5.3 特征值与特征向量的性质

特征值与特征向量全套性质整理

性质1

$n$阶矩阵$A$在复数域内必有$n$个特征值（重根按重数计算）。

备注：该知识点一般仅作了解，通常不考核。

性质2

$n$阶方阵$A$与其转置矩阵$A^\mathrm{T}$有相同的特征多项式，因此二者特征值完全相同； ⚠️ 注意：$A$和$A^\mathrm{T}$特征向量一般不相等。

性质3（迹与行列式公式，高频考点）

设$n$阶方阵$A$全部特征值为$\lambda_1,\lambda_2,\dots,\lambda_n$：

特征值之和 = 矩阵主对角线元素之和（矩阵的迹） $$\lambda_1+\lambda_2+\dots+\lambda_n = a_{11}+a_{22}+\dots+a_{nn}$$
特征值之积 = 方阵行列式 $$\lambda_1\lambda_2\cdots\lambda_n = |A|$$

性质4（可逆性等价判定）

$n$阶方阵$A$可逆 $\iff$ $A$所有特征值都不为$0$；
$n$阶方阵$A$不可逆 $\iff$ $A$至少有一个特征值为$0$。

性质5

方阵$A$对应互不相同特征值的特征向量线性无关。

性质6

取自不同特征值、各自内部线性无关的特征向量，合并之后整体仍线性无关。

性质7（重特征向量个数约束）

若$\lambda$是$A$的$k$重特征值，则对应于$\lambda$的线性无关特征向量数量$\le k$；
单特征值（一重特征值）有且仅有1个线性无关的特征向量。

性质8（矩阵变换后特征值对照表，必考）

设$\lambda$是$A$的特征值，$\boldsymbol{\alpha}$是对应特征向量：

矩阵	$A$	$A^m$	$kA$	$A+E$	$f(A)$多项式矩阵	$A^2+2A+3E$	$A^{-1}$	$A^*$伴随矩阵
对应特征值	$\lambda$	$\lambda^m$	$k\lambda$	$\lambda+1$	$f(\lambda)$	$\lambda^2+2\lambda+3$	$\dfrac{1}{\lambda}$	$\dfrac{
特征向量	$\boldsymbol{\alpha}$	$\boldsymbol{\alpha}$	$\boldsymbol{\alpha}$	$\boldsymbol{\alpha}$	$\boldsymbol{\alpha}$	$\boldsymbol{\alpha}$	$\boldsymbol{\alpha}$	$\boldsymbol{\alpha}$

配套例题

已知$8$是$A$的特征值，$|A|=15$：

$2A$特征值：$2\times8$
$-14A$特征值：$-14\times8$
$A^3$特征值：$8^3$
$3A^2$特征值：$3\times8^2$
$A+E$特征值：$8+1$
$2A^2+A+3E$特征值：$2\times8^2+8+3$
$A^4+A^3+2A^2+5A-6E$特征值：$8^4+8^3+2\times8^2+5\times8-6$
$A^{-1}$特征值：$\dfrac{1}{8}$
$A^*$特征值：$\dfrac{15}{8}$

推论

若$\lambda$是方阵$A$的特征值，$f(x)$为多项式，且$f(A)=\boldsymbol{O}$（零矩阵），则必有$f(\lambda)=0$。

性质9（秩1矩阵专用结论）

$n$阶方阵$A=(a_{ij})$，若$r(A)=1$：

一个特征值：$\lambda_1=\displaystyle\sum_{i=1}^n a_{ii}$（矩阵的迹）
剩余$n-1$个特征值：$\lambda_2=\lambda_3=\dots=\lambda_n=0$

5.4 相似矩阵的概念与性质

一、相似矩阵定义（定义5.2）

设 $A,B$ 均为 $n$ 阶方阵，若存在可逆矩阵 $P$，满足 $$P^{-1}AP=B$$ 则称矩阵 $A$ 与 $B$ 相似，记作 $A\sim B$，$B$ 是 $A$ 的相似矩阵。

特殊定义：若方阵 $A$ 能和对角矩阵相似，则称 $A$ 可对角化。

二、相似矩阵整体性质

性质1：相似是等价关系 等价关系满足三条公理：

反身性：$A\sim A$
对称性：若 $A\sim B$，则 $B\sim A$
传递性：若 $A\sim B,\ B\sim C$，则 $A\sim C$

推论：$A\sim B \implies A$ 与 $B$ 等价（$A\cong B$）。

性质2：秩相等 若 $A\sim B$，则 $r(A)=r(B)$。依据：相似矩阵必等价，等价矩阵秩相同。

性质3：特征多项式、特征值完全相同 若 $A\sim B$，则 $|\lambda E-A|=|\lambda E-B|$，二者特征值一致。

推论

若 $A$ 相似于对角矩阵，则 $A$ 的全部特征值就是该对角矩阵主对角线元素。

性质4：行列式、迹相等 若 $A\sim B$，则： $$|A|=|B|,\quad \mathrm{tr}(A)=\mathrm{tr}(B)$$

性质5：可逆性同步

$|A|,|B|$ 同时为0，或同时非0；
$A$ 可逆 $\iff B$ 可逆；
$A$ 不可逆 $\iff B$ 不可逆。简言之：相似矩阵要么同时可逆，要么同时不可逆。

性质6：逆矩阵、伴随矩阵也相似（$A,B$ 均可逆时）

$A^{-1}\sim B^{-1}$
$A^{}\sim B^{}$

性质7：幂矩阵相似 若 $A\sim B$，$m$ 为正整数，则 $A^m\sim B^m$。

性质8：转置矩阵相似 若 $A\sim B$，则 $A^\mathrm{T}\sim B^\mathrm{T}$。

性质9：相似矩阵的性质 若 $A\sim B$，$k$ 为常数，$f(x)$ 为一元多项式，则： $$kA\sim kB,\quad A+kE\sim B+kE,\quad f(A)\sim f(B)$$

$A\sim B$ 完整推论导图

$$ A\sim B\Rightarrow \begin{cases} A\cong B\Rightarrow r(A)=r(B)\ A、B\text{ 特征值相同} \begin{cases} |A|=|B|\ \mathrm{tr}(A)=\mathrm{tr}(B) \end{cases}\ A、B\text{ 可逆性完全一致}\ A^{-1}\sim B^{-1},\ A^\sim B^\ A^\mathrm{T}\sim B^\mathrm{T}\ kA\sim kB\ f(A)\sim f(B)\ A^m\sim B^m\ (m\text{ 正整数}) \end{cases} $$

5.5 矩阵的对角化

一、可对角化三大核心问题

如何判断方阵 $A$ 是否能相似对角化？
若可对角化，可逆变换矩阵 $P$ 如何求解？
对角矩阵 $\Lambda$ 如何求解？

二、可对角化判定定理

定理5.1（充要核心定理） $n$ 阶方阵 $A$ 可对角化 $\iff A$ 拥有 $n$ 个线性无关的特征向量。

定理5.2（充分条件，常用快速判定） 若 $n$ 阶方阵 $A$ 有 $n$ 个互不相同的特征值，则 $A$ 一定可对角化。

注意：该条件只是充分非必要，有重特征值也有可能可对角化。

定理5.3（重特征值判定充要条件） $n$ 阶方阵 $A$ 可对角化 $\iff$ 每一个 $s$ 重特征值 $\lambda$，对应的线性无关特征向量个数恰好等于重数 $s$，等价表述：

齐次方程组 $(\lambda E-A)\boldsymbol{x}=\boldsymbol 0$ 的基础解系含 $s$ 个向量；
$n-r(\lambda E-A)=s$；
$r(\lambda E-A)=n-s$。

三、$P$ 与对角矩阵 $\Lambda$ 求解公式

设 $A\boldsymbol\alpha_i=\lambda_i\boldsymbol\alpha_i\quad(i=1,2,\dots,n)$，$\boldsymbol\alpha_1,\boldsymbol\alpha_2,\dots,\boldsymbol\alpha_n$ 线性无关： $$ A(\boldsymbol\alpha_1,\boldsymbol\alpha_2,\dots,\boldsymbol\alpha_n) =(\boldsymbol\alpha_1,\boldsymbol\alpha_2,\dots,\boldsymbol\alpha_n) \begin{pmatrix} \lambda_1 & & \ & \lambda_2 & \ & & \ddots & \ & & & \lambda_n \end{pmatrix} $$ 记： $$ P=(\boldsymbol\alpha_1,\boldsymbol\alpha_2,\dots,\boldsymbol\alpha_n),\quad \Lambda=\mathrm{diag}(\lambda_1,\lambda_2,\dots,\lambda_n) $$ 则有 $P^{-1}AP=\Lambda$。

关键配对规则

$P$ 的第 $i$ 列 = 特征值 $\lambda_i$ 对应的特征向量 $\boldsymbol\alpha_i$；

$P$ 列向量顺序、$\Lambda$ 对角线特征值顺序必须一一对应，顺序可同步调换。

四、完整例题演示

题目 $$ A=\begin{pmatrix} 1 & -2 & 2 \ -2 & -2 & 4 \ 2 & 4 & -2 \end{pmatrix} $$ 判断能否对角化；若可以，求 $P,\Lambda$ 满足 $P^{-1}AP=\Lambda$。

步骤1：求特征值 $$ |\lambda E-A|=(\lambda-2)^2(\lambda+7)=0 $$ 特征值：$\lambda_1=\lambda_2=2$（二重），$\lambda_3=-7$（一重）。

步骤2：判定可对角化 二重特征值 $\lambda=2$ 解方程组 $(2E-A)\boldsymbol x=\boldsymbol0$，得到2个线性无关特征向量；一重特征值天然对应1个线性无关特征向量，总计3个线性无关特征向量，$A$ 可对角化。

步骤3：求特征向量

$\lambda_1=\lambda_2=2$：$\boldsymbol\alpha_1=\begin{pmatrix}-2\1\0\end{pmatrix},\boldsymbol\alpha_2=\begin{pmatrix}2\0\1\end{pmatrix}$
$\lambda_3=-7$：$\boldsymbol\alpha_3=\begin{pmatrix}1\2\-2\end{pmatrix}$

步骤4：构造 $P,\Lambda$ $$ P=(\boldsymbol\alpha_1,\boldsymbol\alpha_2,\boldsymbol\alpha_3)= \begin{pmatrix} -2 & 2 & 1 \ 1 & 0 & 2 \ 0 & 1 & -2 \end{pmatrix},\quad \Lambda= \begin{pmatrix} 2 & & \ & 2 & \ & & -7 \end{pmatrix} $$ 满足 $P^{-1}AP=\Lambda$。

5.6 内积与正交

一、向量内积（数量积）四条基本性质

设 $\boldsymbol \alpha,\boldsymbol \beta,\boldsymbol \alpha_1,\boldsymbol \alpha_2$ 为 $n$ 维向量，$k$ 为实数：

非负性：$(\boldsymbol\alpha,\boldsymbol\alpha)\ge 0$，且 $(\boldsymbol\alpha,\boldsymbol\alpha)=0 \iff \boldsymbol\alpha=\boldsymbol 0$ 若 $\boldsymbol\alpha=(x_1,x_2,\dots,x_n)$，则 $(\boldsymbol\alpha,\boldsymbol\alpha)=x_1^2+x_2^2+\dots+x_n^2$。
对称性：$(\boldsymbol\alpha,\boldsymbol\beta)=(\boldsymbol\beta,\boldsymbol\alpha)$
齐次性：$(k\boldsymbol\alpha,\boldsymbol\beta)=k(\boldsymbol\alpha,\boldsymbol\beta)$
线性可加性 $$ \begin{align*} (\boldsymbol\alpha_1+\boldsymbol\alpha_2,\boldsymbol\beta)&=(\boldsymbol\alpha_1,\boldsymbol\beta)+(\boldsymbol\alpha_2,\boldsymbol\beta)\ (\boldsymbol\alpha,\boldsymbol\beta_1+\boldsymbol\beta_2)&=(\boldsymbol\alpha,\boldsymbol\beta_1)+(\boldsymbol\alpha,\boldsymbol\beta_2) \end{align*} $$

二、向量长度（范数/模）

1. 定义

$$ |\boldsymbol\alpha|=\sqrt{(\boldsymbol\alpha,\boldsymbol\alpha)}=\sqrt{x_1^2+x_2^2+\dots+x_n^2} $$ 满足 $(\boldsymbol\alpha,\boldsymbol\alpha)=|\boldsymbol\alpha|^2$。

2. 单位向量与单位化

单位向量：长度 $|\boldsymbol\alpha|=1$ 的向量；
单位化公式：非零向量 $\boldsymbol\alpha$，令 $$ \boldsymbol\beta=\frac{1}{|\boldsymbol\alpha|}\boldsymbol\alpha $$ $\boldsymbol\beta$ 即为单位向量，该变换过程称为单位化。

三、正交相关定义

定义5.6 向量正交 若 $(\boldsymbol\alpha,\boldsymbol\beta)=0$，称 $\boldsymbol\alpha$ 与 $\boldsymbol\beta$ 正交，记作 $\boldsymbol\alpha\perp\boldsymbol\beta$。备注：

零向量和任意向量都正交；
只有零向量和自身正交。

定义5.7 正交向量组 两两正交的非零向量构成的向量组；单个非零向量也属于正交向量组。

定义5.8 标准正交（单位正交）向量组 每个向量都是单位向量的正交向量组，满足： $$ (\boldsymbol\alpha_i,\boldsymbol\alpha_j)= \begin{cases} 1,&i=j\ 0,&i\ne j \end{cases} $$

定理5.4 正交向量组一定线性无关；线性无关向量组不一定正交。

四、施密特正交化（线性无关组 → 等价正交组）

1. 正交化公式

已知线性无关向量组 $\boldsymbol\alpha_1,\boldsymbol\alpha_2,\dots,\boldsymbol\alpha_s$： $$ \begin{align*} \boldsymbol\beta_1&=\boldsymbol\alpha_1\ \boldsymbol\beta_2&=\boldsymbol\alpha_2-\frac{(\boldsymbol\alpha_2,\boldsymbol\beta_1)}{(\boldsymbol\beta_1,\boldsymbol\beta_1)}\boldsymbol\beta_1\ \boldsymbol\beta_3&=\boldsymbol\alpha_3-\frac{(\boldsymbol\alpha_3,\boldsymbol\beta_1)}{(\boldsymbol\beta_1,\boldsymbol\beta_1)}\boldsymbol\beta_1-\frac{(\boldsymbol\alpha_3,\boldsymbol\beta_2)}{(\boldsymbol\beta_2,\boldsymbol\beta_2)}\boldsymbol\beta_2 \end{align*} $$ 得到的 $\boldsymbol\beta_1,\boldsymbol\beta_2,\boldsymbol\beta_3$ 两两正交，且与原向量组等价。

2. 再单位化得到标准正交组

$$ \boldsymbol\gamma_1=\frac{\boldsymbol\beta_1}{|\boldsymbol\beta_1|},\quad \boldsymbol\gamma_2=\frac{\boldsymbol\beta_2}{|\boldsymbol\beta_2|},\quad \boldsymbol\gamma_3=\frac{\boldsymbol\beta_3}{|\boldsymbol\beta_3|} $$ $\boldsymbol\gamma_1,\boldsymbol\gamma_2,\boldsymbol\gamma_3$ 就是和原向量组等价的标准正交向量组。

5.7 实对称矩阵的相似对角化

一、正交相似定义（定义5.10）

设 $A,B$ 为 $n$ 阶方阵，若存在正交矩阵 $Q$，满足： $$Q^{-1}AQ=B$$ 则称 $A$ 与 $B$ 正交相似。补充：正交矩阵满足 $Q^{-1}=Q^\mathrm{T}$，因此上式等价于 $Q^\mathrm{T}AQ=B$。

二、实对称矩阵核心7条性质

实对称矩阵满足 $\boldsymbol A^\mathrm{T}=A$，全部性质罗列如下： 性质1 实对称矩阵所有特征值都是实数，对应的特征向量全为实向量。

性质2 属于不同特征值的特征向量互相正交。

一般方阵仅能保证线性无关，实对称矩阵可加强为正交。

性质3 对 $s$ 重特征值 $\lambda$，恒有 $r(\lambda E-A)=n-s$。

性质4 $s$ 重特征值恰好对应**$s$ 个线性无关**的特征向量。

性质5 $n$ 阶实对称矩阵一定拥有 $n$ 个线性无关的特征向量。

性质6 实对称矩阵必定可以相似对角化（无条件可对角化）。

性质7 实对称矩阵一定能和对角矩阵正交相似；即存在正交矩阵 $Q$，使得 $$Q^{-1}AQ=Q^\mathrm{T}AQ=\Lambda=\mathrm{diag}(\lambda_1,\lambda_2,\dots,\lambda_n)$$ $\lambda_1,\lambda_2,\dots,\lambda_n$ 是 $A$ 的全部特征值。

三、实对称矩阵两种对角化完整步骤

前置通用两步（两种方式共用）

求特征值：解特征方程 $|\lambda E-A|=0$，得到全部特征值 $\lambda_1,\lambda_2,\dots,\lambda_n$；
求特征向量：对每个特征值 $\lambda_i$，解 $(\lambda_i E-A)\boldsymbol x=\boldsymbol 0$，得到 $n$ 个线性无关特征向量 $\boldsymbol\alpha_1,\boldsymbol\alpha_2,\dots,\boldsymbol\alpha_n$。

方式1：普通相似对角化（构造可逆矩阵 $P$）

直接拼接特征向量构成可逆矩阵：$P=(\boldsymbol\alpha_1,\boldsymbol\alpha_2,\dots,\boldsymbol\alpha_n)$
结果：$P^{-1}AP=\Lambda$，$A\sim\Lambda$

适用：题目只要求相似对角化，不要求正交矩阵。

方式2：正交相似对角化（构造正交矩阵 $Q$，必考）

正交化处理
- 不同特征值对应的特征向量天然正交，无需处理；
- 同一重特征值内部多个线性无关特征向量，用施密特正交化得到正交向量组 $\boldsymbol\beta_1,\boldsymbol\beta_2,\dots,\boldsymbol\beta_n$。
单位化 $$\boldsymbol\gamma_i=\frac{1}{|\boldsymbol\beta_i|}\boldsymbol\beta_i,\quad i=1,2,\dots,n$$
拼接正交矩阵：$Q=(\boldsymbol\gamma_1,\boldsymbol\gamma_2,\dots,\boldsymbol\gamma_n)$
结果： $$Q^{-1}AQ=Q^\mathrm{T}AQ=\Lambda$$ $A$ 与对角阵正交相似。

适用：题目明确要求正交矩阵、二次型标准化。

四、实对称矩阵正交相似对角化分三类情形完整操作

实对称矩阵正交相似对角化分三类情形完整操作

设三阶实对称矩阵 $\boldsymbol A$，要构造正交矩阵 $\boldsymbol Q$ 使得 $\boldsymbol Q^\mathrm{T}\boldsymbol A\boldsymbol Q=\boldsymbol \Lambda$，按特征值重数分3种情况处理：

情形一：$\lambda_1,\lambda_2,\lambda_3$ 三个互不相同单特征值

实对称矩阵不同特征值对应的特征向量天然正交，无需施密特正交化，只做单位化：

对每个特征值求出特征向量 $\boldsymbol\alpha_1,\boldsymbol\alpha_2,\boldsymbol\alpha_3$；
分别单位化： $$\boldsymbol\gamma_1=\frac{\boldsymbol\alpha_1}{|\boldsymbol\alpha_1|},\quad \boldsymbol\gamma_2=\frac{\boldsymbol\alpha_2}{|\boldsymbol\alpha_2|},\quad \boldsymbol\gamma_3=\frac{\boldsymbol\alpha_3}{|\boldsymbol\alpha_3|}$$
正交矩阵 $\boldsymbol Q=(\boldsymbol\gamma_1,\boldsymbol\gamma_2,\boldsymbol\gamma_3)$。

情形二：$\lambda_1$ 单根，$\lambda_2=\lambda_3$ 二重特征值

单特征值 $\lambda_1$：特征向量 $\boldsymbol\alpha_1$ 直接单位化得到 $\boldsymbol\gamma_1$；
二重特征值 $\lambda_2=\lambda_3$：解方程组得到2个线性无关特征向量 $\boldsymbol\alpha_2,\boldsymbol\alpha_3$
- 这两个同特征值的向量不一定正交，必须先做施密特正交化得到正交向量 $\boldsymbol\beta_2,\boldsymbol\beta_3$；
- 再分别单位化得到 $\boldsymbol\gamma_2,\boldsymbol\gamma_3$；
拼接正交矩阵 $\boldsymbol Q=(\boldsymbol\gamma_1,\boldsymbol\gamma_2,\boldsymbol\gamma_3)$。

情形三：$\lambda_1=\lambda_2=\lambda_3$ 三重特征值

3个线性无关特征向量 $\boldsymbol\alpha_1,\boldsymbol\alpha_2,\boldsymbol\alpha_3$ 全部属于同一个重特征值，互相不一定正交：

先对 $\boldsymbol\alpha_1,\boldsymbol\alpha_2,\boldsymbol\alpha_3$ 整体做施密特正交化，得到两两正交的 $\boldsymbol\beta_1,\boldsymbol\beta_2,\boldsymbol\beta_3$；
再逐个单位化得到 $\boldsymbol\gamma_1,\boldsymbol\gamma_2,\boldsymbol\gamma_3$；
拼接得到正交矩阵 $\boldsymbol Q=(\boldsymbol\gamma_1,\boldsymbol\gamma_2,\boldsymbol\gamma_3)$。

核心规则总结

跨不同特征值：特征向量自动正交，跳过正交化，仅单位化；
同一多重特征值内部：线性无关特征向量不一定正交，必须施密特正交化 + 单位化两步；
最终全部单位化后的列向量拼成矩阵，一定是正交矩阵，满足 $\boldsymbol Q^{-1}=\boldsymbol Q^\mathrm{T}$。

补充关键对比

矩阵类型	能否对角化	不同特征值特征向量关系	能否正交相似对角化
普通 $n$ 阶方阵	不一定，要看无关特征向量个数	仅线性无关	不一定
实对称矩阵	一定可以	互相正交	一定可以

第六部分：二次型

6.1 二次型及矩阵表示

一、二次型定义（定义6.1）

1. 文字定义

$n$ 个变量 $x_1,x_2,\dots,x_n$ 的二次齐次多项式称为 $n$ 元二次型，简称二次型；系数全为实数时，称作实二次型，本课程只讨论实二次型。展开形式： $$ \begin{align*} f(x_1,x_2,\dots,x_n) =&a_{11}x_1^2+2a_{12}x_1x_2+2a_{13}x_1x_3+\dots+2a_{1n}x_1x_n\ &+a_{22}x_2^2+2a_{23}x_2x_3+\dots+2a_{2n}x_2x_n\ &+\dots+a_{nn}x_n^2 \end{align*} $$

2. 判断规则

只允许二次项（平方项 $x_i^2$、交叉项 $x_ix_j,i\ne j$）；
不能出现一次项、常数项、三次及更高次项。

例题判断结果：

$f=2x_1^2-x_2^2+4x_3^2+5x_1x_2-x_1x_3+3x_2x_3$：✅ 是二次型
$f=x_1x_2-x_1x_3+3x_2x_3$：✅ 是二次型（无平方项仅有交叉项也成立）
$f=x_1^2-2x_2^2+4x_3^2$：✅ 是二次型（纯平方项，标准型）
$f=-x_1^2+x_2^2+x_1x_2-x_1x_3+\boldsymbol3$：❌ 含常数项，不是
$f=x^2-xy+\boldsymbol y$：❌ 含一次项，不是

二、二次型矩阵表达式（核心）

1. 矩阵标准写法

记 $$ \boldsymbol x=\begin{pmatrix}x_1\x_2\\vdots\x_n\end{pmatrix},\quad A=(a_{ij}),\ A^\mathrm{T}=A $$ 二次型唯一对称矩阵形式： $$ f(x_1,x_2,\dots,x_n)=\boldsymbol x^\mathrm{T}A\boldsymbol x $$ 规定：二次型的矩阵 $A$ 必须是实对称矩阵。

三、二次型标准形（定义6.3）

1. 定义

二次型只含平方项、不含任何交叉项 $x_ix_j(i\ne j)$： $$ f=d_1x_1^2+d_2x_2^2+\dots+d_nx_n^2 $$ 称作二次型的一个标准形；$d_i$ 可为任意实数（包含0）。

2. 由二次型写出对称矩阵 $A$ 口诀

平方项 $x_i^2$ 系数直接放到主对角线 $a_{ii}$；
交叉项 $2a,x_ix_j$，系数除以 $2$，分别填入 $a_{ij}$、$a_{ji}$，保证对称。

示例： $$ f(x_1,x_2,x_3)=x_1^2+2x_1x_2+3x_2^2-8x_2x_3+x_3^2 $$ $$ A=\begin{pmatrix} 1 & 1 & 0\ 1 & 3 & -4\ 0 & -4 & 1 \end{pmatrix} $$

3. 由对称矩阵还原二次型口诀

主对角线元素 $a_{ii}$ 为 $x_i^2$ 系数；
上三角元素 $a_{ij}$ 乘以 $2$，作为 $x_ix_j$ 交叉项系数。

示例： $$ A=\begin{pmatrix}3&1&0\1&-1&-2\0&-2&5\end{pmatrix} $$ $$ f=3x_1^2-x_2^2+5x_3^2+2x_1x_2-4x_2x_3 $$

4. 二次型的秩

二次型的秩 = 它的对称矩阵 $A$ 的秩： $$ r(f)=r(A) $$

非对称矩阵形式必须先对称化，再求秩。

四、二次型规范形（定义6.4）

1. 定义

标准形的平方项系数只能取 $\boldsymbol 1,-1,0$ 时，称为二次型的规范形，标准排布形式： $$ f=z_1^2+\dots+z_p^2-z_{p+1}^2-\dots-z_r^2 $$ 其中 $r=r(A)$ 是二次型的秩，$p\le r\le n$。

2. 对应矩阵结构

规范形的矩阵是对角阵，对角元依次为 $p$ 个$1$、$(r-p)$个$-1$、$(n-r)$个$0$，分块写法： $$ \Lambda=\begin{pmatrix} E_p & & \ & -E_{r-p} & \ & & O_{n-r} \end{pmatrix} $$

3. 关键结论

惯性定理：任意实二次型的规范形唯一，与可逆线性变换的选取无关。

惯性指数与符号差（定义6.5）

设二次型秩为 $r$

正惯性指数 $p$：标准形/规范形里，系数为正数的平方项个数；
负惯性指数 $q$：标准形/规范形里，系数为负数的平方项个数；
符号差：$p-q$；
核心等式：$\boldsymbol r=p+q$。

线性变换（定义6.6）

1. 矩阵表达

两组变量 $\boldsymbol x=(x_1,\dots,x_n)^\mathrm T,\boldsymbol y=(y_1,\dots,y_n)^\mathrm T$，变换记作： $$ \boldsymbol x=C\boldsymbol y $$ $C=(c_{ij})$ 是 $n$ 阶变换矩阵。

2. 两类重要线性变换

可逆线性变换 $|C|\ne 0$（$C$ 满秩、非退化、非奇异），逆变换：$\boldsymbol y=C^{-1}\boldsymbol x$。
正交变换 若 $C$ 是正交矩阵（$C^{-1}=C^\mathrm T$），则 $\boldsymbol x=C\boldsymbol y$ 为正交线性变换。

3. 变换复合定理（定理6.1）

多个线性变换连续复合后的总矩阵 = 各变换矩阵依次相乘；多个可逆线性变换复合后，仍然是可逆线性变换。

可逆线性变换作用于二次型（定理6.2）

二次型 $\boldsymbol x^\mathrm T A\boldsymbol x$ 做可逆变换 $\boldsymbol x=C\boldsymbol y$： $$ \boldsymbol x^\mathrm T A\boldsymbol x =(C\boldsymbol y)^\mathrm T A(C\boldsymbol y) =\boldsymbol y^\mathrm T (C^\mathrm T A C)\boldsymbol y =\boldsymbol y^\mathrm T B\boldsymbol y $$ 其中 $B=C^\mathrm T A C$。
结论：
- 变换后依旧是二次型；
- 新矩阵 $B$ 与原矩阵 $A$ 合同；
- 秩不变：$r(B)=r(A)$，即二次型秩在可逆变换下恒定。

标准形、规范形、惯性指数关系梳理

形式	系数取值	是否唯一	核心标识量
标准形	任意实数	不唯一	正、负惯性指数唯一不变
规范形	仅 $1,-1,0$	唯一	$p,q,r$ 全部固定不变

合同矩阵定义（定义6.8）

设 $A,B$ 为 $n$ 阶方阵，若存在可逆矩阵 $C$，满足： $$C^\mathrm{T}AC=B$$ 则称矩阵 $A$ 与 $B$ 合同，记作 $A\simeq B$；该变换称作合同变换，$C$ 是合同变换矩阵。

相似、正交相似、合同公式对比

关系	核心等式	变换矩阵要求
相似	$P^{-1}AP=B$	$P$ 可逆
正交相似	$P^{-1}AP=P^\mathrm{T}AP=B$	$P$ 正交矩阵
合同	$P^\mathrm{T}AP=B$	$P$ 可逆

合同关系三大等价性质（等价关系）

反身性：任意方阵 $A$，$A\simeq A$；
对称性：若 $A\simeq B$，则 $B\simeq A$；
传递性：若 $A\simeq B,\ B\simeq C$，则 $A\simeq C$。

合同矩阵重要推论

秩相等：$A\simeq B \implies r(A)=r(B)$，同时 $A,B$ 等价；
对称性同步：$A$ 是对称矩阵 $\iff B$ 是对称矩阵；
可逆性一致：$A,B$ 同时可逆或同时不可逆；若均可逆，则 $A^{-1}\simeq B^{-1}$；
转置也合同：$A\simeq B \implies A^\mathrm{T}\simeq B^\mathrm{T}$。

二次型视角下的合同结论

结论1（普通可逆线性变换）

二次型 $f=\boldsymbol x^\mathrm{T}A\boldsymbol x$，做可逆变换 $\boldsymbol x=C\boldsymbol y$，得到 $f=\boldsymbol y^\mathrm{T}(C^\mathrm{T}AC)\boldsymbol y=\boldsymbol y^\mathrm{T}B\boldsymbol y$，则 $A\simeq B$。

结论2（正交变换特殊情况）

正交变换 $\boldsymbol x=Q\boldsymbol y$（$Q$ 正交矩阵，$Q^\mathrm{T}=Q^{-1}$），此时 $$B=Q^\mathrm{T}AQ=Q^{-1}AQ$$ $A$ 与 $B$ 既相似，又合同。

6.2 化二次型为标准形

方法1：配方法（可逆线性变换，标准形不唯一）

分类操作步骤

含平方项（第一题例题） 优先对出现平方项的变量配方，逐步消去交叉项： $$f(x_1,x_2,x_3)=x_1^2-3x_2^2+4x_3^2-2x_1x_2+2x_1x_3-6x_2x_3$$ 先把含 $x_1$ 的项全部收拢配方，再依次对 $x_2$ 配方，最终化成纯平方项： $$f=y_1^2-y_2^2+4y_3^2$$ 同时写出可逆线性变换 $\boldsymbol x=C\boldsymbol y$，$C$ 为可逆变换矩阵。
无平方项（只有交叉项，第二题例题） 先做可逆变换构造出平方项： $$\begin{cases}x_1=y_1+y_2\x_2=y_1-y_2\x_3=y_3\end{cases}$$ 代入后产生 $y_1^2,y_2^2$，再继续常规配方，最终得到标准形。

配套定理6.3

任意 $n$ 元二次型，都能通过可逆线性变换化为标准形： $$f=d_1y_1^2+d_2y_2^2+\dots+d_ny_n^2$$ ⚠️ 配方法得到的标准形系数 $d_i$ 不唯一，但正、负惯性指数固定不变。

方法2：正交变换法（正交相似，标准形唯一）

核心原理

正交变换化二次型 = 实对称矩阵正交相似对角化。正交矩阵 $Q$ 满足 $Q^\mathrm T=Q^{-1}$，因此 $Q^\mathrm TAQ=Q^{-1}AQ=\Lambda$，$A$ 和对角阵既相似又合同。

定理6.5

实二次型 $f=\boldsymbol x^\mathrm TA\boldsymbol x$（$A^\mathrm T=A$），正交变换 $\boldsymbol x=Q\boldsymbol y$ 可化为： $$f=\lambda_1y_1^2+\lambda_2y_2^2+\dots+\lambda_ny_n^2$$ $\lambda_1,\lambda_2,\dots,\lambda_n$ 恰好是矩阵 $A$ 的全部特征值。

完整解题步骤（例题演示）

$$f=2x_1^2+x_2^2-4x_1x_2-4x_2x_3$$

写出对称矩阵 $$A=\begin{pmatrix}2&-2&0\-2&1&-2\0&-2&0\end{pmatrix}$$
解特征方程 $|\lambda E-A|=0$，求出特征值 $\lambda_1=1,\lambda_2=4,\lambda_3=-2$；
逐个求特征向量，不同特征值向量天然正交；
全部特征向量单位化，拼成正交矩阵 $Q$；
正交变换 $\boldsymbol x=Q\boldsymbol y$，直接写出标准形： $$f=y_1^2+4y_2^2-2y_3^2$$

二、实对称矩阵合同判定核心结论

定理6.4

任意 $n$ 阶实对称矩阵 $A$，一定合同于对角矩阵。

定理6.8（合同充要条件）

实对称矩阵 $A\simeq B$ 的等价判定（全部互为充要）：

秩相等 + 正惯性指数相等；
秩相等 + 负惯性指数相等；
正、负惯性指数全部相同；
规范形完全一致；
正特征值个数、负特征值个数分别对应相等。

重要推论

若两个实对称矩阵相似，则二者一定合同。

解释：相似特征值完全相同，正负特征值数量一致，惯性指数相等，必然合同；反之合同不一定相似。

三、两种化标准形方法对比表

对比维度	配方法（可逆线性变换）	正交变换法
变换矩阵性质	$C$ 可逆，无正交要求	$Q$ 正交矩阵，$Q^\mathrm T=Q^{-1}$
$A$ 与对角阵关系	仅合同，不相似	既合同，又相似
标准形系数	任意实数，不唯一	只能是 $A$ 的特征值，唯一
惯性指数	唯一不变	唯一不变
适用场景	只求标准形、规范形、惯性指数	题目明确要求正交变换、二次曲面几何变换

四、做题易错提醒 💡

配方法得到的变换矩阵 $C$ 必须验算行列式 $|C|\ne0$，保证变换可逆；
正交变换标准形系数固定为特征值，不需要额外配方，直接写结果；
只有实对称矩阵能用「惯性指数相等」判定合同，普通方阵不适用该结论；
相似 $\implies$ 合同（实对称），合同 $\nRightarrow$ 相似。

6.3 二次型与对称矩阵的有定性

一、二次型定性五大分类（定义6.9）

设实二次型 $f(\boldsymbol x)=\boldsymbol x^\mathrm T A \boldsymbol x,\ A^\mathrm T=A$，对任意非零实向量 $\boldsymbol x\ne\boldsymbol 0$：

正定：恒有 $f(\boldsymbol x)>0$
负定：恒有 $f(\boldsymbol x)<0$
半正定：恒有 $f(\boldsymbol x)\ge0$，存在非零向量使 $f=0$
半负定：恒有 $f(\boldsymbol x)\le0$，存在非零向量使 $f=0$
不定：既有 $\boldsymbol x_1$ 使 $f>0$，又有 $\boldsymbol x_2$ 使 $f<0$

例题定性判断

$f=2x_1^2+x_2^2+5x_3^2$：正定
$f=-x_1^2-3x_2^2-4x_3^2$：负定
$f=x_1^2+3x_2^2+0x_3^2$：半正定（取 $\boldsymbol x=(0,0,1)^\mathrm T,f=0$）

二、正定二次型核心性质（定理6.9）

正定二次型经过任意可逆线性变换，仍然是正定二次型。

本质：可逆变换不改变正惯性指数，正定要求正惯性指数 $p=n$，因此不变。

三、正定矩阵（实对称）充要判定方法（全套考研结论）

设 $A$ 为 $n$ 阶实对称矩阵，下述条件全部等价：

方法1：惯性指数判定

正惯性指数 $p=n$；规范形为 $y_1^2+y_2^2+\dots+y_n^2$。

方法2：合同判定

$A$ 合同于单位矩阵 $E$，$\exists$ 可逆阵 $C$，$C^\mathrm T A C=E$。

方法3：矩阵分解判定

存在可逆矩阵 $C$，使得 $\boldsymbol A=C^\mathrm T C$。

方法4：特征值判定

$A$ 的所有特征值 $\lambda_i>0$。

方法5：顺序主子式判定（霍尔维茨定理，最常用）

$A$ 的各阶顺序主子式全部大于0： $$ D_k=\begin{vmatrix} a_{11} & \dots & a_{1k}\ \vdots & & \vdots\ a_{k1} & \dots & a_{kk} \end{vmatrix}>0,\quad k=1,2,\dots,n $$ $k$ 阶顺序主子式：取矩阵前 $k$ 行、前 $k$ 列构成子方阵的行列式。

四、正定矩阵必要条件（只能排除，不能判定正定）

$A$ 一定是对称矩阵（正定前提）；
主对角线元素全部 $a_{ii}>0$；
行列式 $|A|>0$；
$A$ 可逆。

五、正定矩阵常用运算性质

$A^\mathrm T,A^{-1},A^*$ 均正定；
$kA\ (k>0)$、$A^m$（$m$ 正整数）正定；
$A,B$ 同阶正定/半正定 $\implies A+B$ 正定。

六、做题思路速查表

已知条件	首选判定方法
已化标准形/规范形	数正惯性指数是否等于阶数 $n$
给出全部特征值	逐个检查是否全大于0
低阶方阵、无特征值	逐阶计算顺序主子式，全部>0即正定
矩阵表达式变形证明题	证 $A=C^\mathrm T C$ 或 $A\simeq E$

例7 证明：$A,B$ 均 $n$ 阶正定矩阵 $\implies A+B$ 正定

验证对称性 正定矩阵必对称：$A^\mathrm T=A,\ B^\mathrm T=B$ $$(A+B)^\mathrm T=A^\mathrm T+B^\mathrm T=A+B$$ 故 $A+B$ 是实对称矩阵，满足二次型矩阵前提。
正定定义验证 任取非零列向量 $\boldsymbol x\ne\boldsymbol 0$： $$\boldsymbol x^\mathrm T(A+B)\boldsymbol x=\boldsymbol x^\mathrm T A\boldsymbol x+\boldsymbol x^\mathrm T B\boldsymbol x$$ $A,B$ 正定，因此 $\boldsymbol x^\mathrm T A\boldsymbol x>0,\ \boldsymbol x^\mathrm T B\boldsymbol x>0$，相加得： $$\boldsymbol x^\mathrm T(A+B)\boldsymbol x>0$$ 由正定定义，$A+B$ 正定。

例8 已知实对称矩阵 $A^2-3A+2E=O$，证 $A+E$ 正定

特征值满足矩阵多项式方程：若 $\lambda$ 是 $A$ 的特征值，则 $$\lambda^2-3\lambda+2=0 \implies (\lambda-1)(\lambda-2)=0$$ 解得 $A$ 的特征值只能是 $\lambda_1=1,\ \lambda_2=2$。
设 $A$ 特征值为 $\lambda$，则 $A+E$ 的特征值为 $\lambda+1$：

$\lambda=1$ 时，$\lambda+1=2>0$
$\lambda=2$ 时，$\lambda+1=3>0$

$A$ 实对称 $\implies A+E$ 实对称；全部特征值大于0，故 $A+E$ 正定。

例9 求 $t$ 的取值，使二次型正定

$$f(x_1,x_2,x_3)=2x_1^2+x_2^2+x_3^2+2x_1x_2+tx_2x_3$$ 步骤1：写出实对称矩阵

$$A=\begin{pmatrix} 2 & 1 & 0\ 1 & 1 & \dfrac t2\ 0 & \dfrac t2 & 1 \end{pmatrix}$$

步骤2：顺序主子式全大于0（霍尔维茨定理） 1阶顺序主子式：$D_1=2>0$，恒成立； 2阶顺序主子式：

$$D_2=\begin{vmatrix}2&1\1&1\end{vmatrix}=2-1=1>0$$ 3阶顺序主子式：

$$ D_3= \begin{vmatrix} 2 & 1 & 0\ 1 & 1 & \frac t2\ 0 & \frac t2 & 1 \end{vmatrix} =2\left(1-\frac{t^2}{4}\right)-1\cdot\left(1-0\right) =1-\frac{t^2}{2}>0 $$

步骤3：解不等式 $$ 1-\frac{t^2}{2}>0 \implies t^2<2 $$ 最终取值范围： $$\boldsymbol{-\sqrt{2}<t<\sqrt{2}}$$

三类正定证明题型方法总结

题型特征	首选方法
矩阵相加、线性组合证明正定	原始定义 $\boldsymbol x^\mathrm T A\boldsymbol x>0$
给出矩阵多项式方程（$f(A)=O$）	求特征值，验证所有特征值$>0$
含参数二次型求参数范围	顺序主子式逐阶大于0，解不等式

概率论与数理统计

Tue, 30 Jun 2026 00:00:00 GMT

概率论与数理统计-速成课笔记

第一章

第一讲随机事件及其概率（一）

本讲包含 2 种题型。

一、利用"四大公式"求事件概率

"四大公式"：加法公式、减法公式、乘法公式、条件概率公式。

例1

（1） 设 $P(A)=0.5$，$P(A\cup B)=0.8$，且 $A,B$ 互不相容，求 $P(B)$。

（2） 设 $P(A)=P(B)=P(C)=\dfrac{1}{4}$，$P(AC)=\dfrac{1}{8}$，$P(AB)=P(BC)=0$，求 "$A,B,C$ 至少发生一个" 的概率。

【分析】

① "四大公式"

加法公式
1. $P(A\cup B)$ 的含义："$A,B$ 至少发生一个"。（问：$A\cup B\cup C$ 呢？）
2. $P(A\cup B)=P(A)+P(B)-P(AB)$
3. $P(A\cup B\cup C)=P(A)+P(B)+P(C)-P(AB)-P(AC)-P(BC)+P(ABC)$
口诀："加奇减偶"。

【解】

（1） 由 $A,B$ 互不相容，则 $AB=\varnothing$，又 $P(A\cup B)=0.8$

$$\Rightarrow P(A)+P(B)-P(AB)=0.8$$

$$\therefore P(B)=0.8-P(A)=0.8-0.5=0.3$$

补充：$ABC \subseteq AB$，$P(ABC) \leq P(AB) = 0$（互不相容），所以 $P(ABC)=0$。

（2） "$A,B,C$ 至少发生一个" $= P(A\cup B\cup C)$

$$= P(A)+P(B)+P(C)-P(AB)-P(AC)-P(BC)+P(ABC)$$

$$= \dfrac{1}{4}+\dfrac{1}{4}+\dfrac{1}{4}-0-\dfrac{1}{8}-0+0 = \dfrac{5}{8}$$

例2

设 $P(A)=0.7$，$P(A-B)=0.3$，求 $P(\overline{AB})$。

【分析】

① 减法公式：$P(A-B)=P(A)-P(AB)$

② 对立事件：$P(\overline{A})=1-P(A)$

【解】

① 由 $P(A-B)=0.3 \Rightarrow P(A)-P(AB)=0.3$

$$\Rightarrow P(AB)=P(A)-0.3=0.7-0.3=0.4$$

② $P(\overline{AB})=1-P(AB)=1-0.4=0.6$

例3

设 $P(B)=0.4$，$P(A\cup B)=0.5$，求 $P(A|\overline{B})$。

【分析】

① 条件概率公式：$P(A|B)=\dfrac{P(AB)}{P(B)}$

② $P(A-B)=P(A)-P(AB)$

【解】

由 $P(B)=0.4$，$P(A\cup B)=0.5$，则：

$$P(A)+P(B)-P(AB)=0.5$$

$$\Rightarrow P(A)-P(AB)=0.5-P(B)=0.5-0.4=0.1$$

$$P(A|\overline{B}) = \dfrac{P(A\overline{B})}{P(\overline{B})} = \dfrac{P(A)-P(AB)}{1-P(B)} = \dfrac{0.1}{1-0.4} = \dfrac{1}{6}$$

例4

设 $A,B$ 相互独立，$P(B)=0.4$，$P(A\cup B)=0.5$，求 $P(\overline{B}|A)$。

【分析】

① $A$ 与 $B$ 独立 $\Longleftrightarrow$ $A$ 与 $B$ 互不影响 $\Longleftrightarrow$ $P(B|A)=P(B)$

$$\Longleftrightarrow P(AB)=P(A)P(B)$$

② $A$ 与 $B$ 独立 $\Longleftrightarrow$ $B$ 是否发生不受 $A$ 的影响 $\Longleftrightarrow$ $\overline{B}$ 与 $A$，$\overline{B}$ 与 $\overline{A}$，$B$ 与 $\overline{A}$ 独立

$$\Longleftrightarrow P(\overline{B}|A)=P(\overline{B})$$

口诀："有爸无爸，对妈独立无影响"。

【解】

法一：由 $A,B$ 独立 $\Rightarrow P(AB)=P(A)P(B)=0.4P(A)$

而 $P(A\cup B)=0.5 \Rightarrow P(A)+P(B)-P(AB)=0.5$

$$\Rightarrow P(A)+0.4-0.4P(A)=0.5 \Rightarrow P(A)=\dfrac{1}{4}$$

$$P(\overline{B}|A)=\dfrac{P(A\overline{B})}{P(A)}=\dfrac{P(A)-P(AB)}{P(A)}=\dfrac{P(A)-0.4P(A)}{P(A)}=0.6$$

法二：由 $A,B$ 独立 $\Rightarrow$ $\overline{B}$ 与 $A$ 独立

$$\Rightarrow P(\overline{B}|A)=P(\overline{B})=1-P(B)=1-0.4=0.6$$

二、古典型求概率

例1

袋中有 5 只白球，6 只黑球，从中任取 2 球，求：

取到 1 白 1 黑的概率；
至少取到 1 只黑球的概率。

【分析】

① 古典型概率：事件 $A$ 发生的概率公式：

$$P(A)=\dfrac{A\text{ 中可能的点数}}{\Omega\text{ 中可能的点数}}$$

② 排列：$A_{11}^{2}$ 表示从 11 个不同元素中任取 2 个排成一列的排法：$A_{11}^{2}=11\times 10$

组合：$C_{11}^{2}$ 表示从 11 个不同元素中任取 2 个（不计顺序）的取法：$C_{11}^{2}=\dfrac{11\times 10}{2!}$

【解】

（1）法一 设 $A$ = "取到 1 黑 1 白球"，$\Omega$ = "从 11 球中任取 2 球"（不计顺序，一次取 2 球）

$$P(A)=\dfrac{C_{5}^{1}\cdot C_{6}^{1}}{C_{11}^{2}}=\dfrac{5\times 6}{\dfrac{11\times 10}{2!}}=\dfrac{6}{11}$$

（分步相乘，分类相加）

法二设 $A$ = "取到 1 黑 1 白球"，$\Omega$ = "从 11 球中任取 2 球"（共取 2 次，一次取 1 球，分类："先白后黑" + "先黑后白"）

$$P(A)=\dfrac{A_{5}^{1}\cdot A_{6}^{1}+A_{6}^{1}\cdot A_{5}^{1}}{A_{11}^{2}}=\dfrac{5\times 6+6\times 5}{11\times 10}=\dfrac{6}{11}$$

答案是一样的。

（2） 设 $B$ = "至少取到 1 只黑球"，$\overline{B}$ = "2 只球均为白球"（不计顺序）

$$P(B)=1-P(\overline{B})=1-\dfrac{C_{5}^{2}}{C_{11}^{2}}=1-\dfrac{\dfrac{5\times 4}{2!}}{\dfrac{11\times 10}{2!}}=1-\dfrac{2}{11}=\dfrac{9}{11}$$

第二讲随机事件及其概率（二）

本讲包含 2 种题型。

三、全概率公式与贝叶斯公式

【分析】 ① 在用题中，若适合分两个阶段完成，则用全概率公式或贝叶斯公式。

① 全概率公式：

$$P(A)=P(AB_{1}\cup AB_{2}\cup AB_{3})=P(B_{1})P(A|B_{1})+P(B_{2})P(A|B_{2})+P(B_{3})P(A|B_{3})$$

② 贝叶斯公式：

$$P(B_{i}|A)=\dfrac{P(AB_{i})}{P(A)}=\dfrac{P(B_{i})P(A|B_{i})}{\text{全概率公式}}$$

步骤：

第1步：把第一阶段所有可能结果看成完备组 $B_{1},B_{2},B_{3}$；

第2步：把第二阶段的某个可能结果看成 $A$；

第3步：用全概率或贝叶斯公式。

例1

甲袋中有 5 只红球、4 只白球；乙袋中有 4 只红球、5 只白球。先从甲中任取 1 只球放入乙中，再从乙中取 1 只球，求：

从乙中取到的球是白球的概率；
若已知从乙中取到 1 白球，问从甲中取到的球是白球的概率。

【解】

（1） 第 1 阶段：甲→乙

$B_{1}=$ 从甲中取到红球，$P(B_{1})=\dfrac{5}{9}$
$B_{2}=$ 从甲中取到白球，$P(B_{2})=\dfrac{4}{9}$

第 2 阶段：从乙中取 1 球，$A=$ "从乙中取到白球"

由全概率公式：

$$P(A)=P(B_{1})P(A|B_{1})+P(B_{2})P(A|B_{2})=\dfrac{5}{9}\times\dfrac{5}{10}+\dfrac{4}{9}\times\dfrac{6}{10}=\dfrac{49}{90}$$

（2） 由题意（贝叶斯公式）：

$$P(B_{2}|A)=\dfrac{P(B_{2}A)}{P(A)}=\dfrac{P(B_{2})P(A|B_{2})}{49/90}=\dfrac{\dfrac{4}{9}\times\dfrac{6}{10}}{49/90}=\dfrac{24}{49}$$

例2

已知男性中有 $5%$ 是色盲，女性中有 $0.25%$ 是色盲，今从男女人数相等的人群中随机挑选一人，恰好是色盲，问此人是男性的概率。

【解】

第一阶段：从人群中选人

$B_{1}=$ "选到男性"
$B_{2}=$ "选到女性"

第二阶段：判断此人是否色盲，$A=$ "发现此人是色盲"

① 全概率公式：

$$P(A)=P(B_{1})P(A|B_{1})+P(B_{2})P(A|B_{2})=\dfrac{1}{2}\times 5%+\dfrac{1}{2}\times 0.25%=\dfrac{21}{800}$$

② 贝叶斯公式：

$$P(B_{1}|A)=\dfrac{P(B_{1})P(A|B_{1})}{P(A)}=\dfrac{\dfrac{1}{2}\times 5%}{21/800}=\dfrac{20}{21}$$

四、伯努利概型求概率

【分析】 当出现"独立"、"$n$ 重试验"、"每次试验只有 $A$ 与 $\overline{A}$ 两种结果"，则用伯努利概型：

$$P_{n}(k)=C_{n}^{k},p^{k}(1-p)^{n-k}, \quad \text{其中 } p=P(A),\ 1-p=P(\overline{A})$$

例

某人打靶的命中率为 $0.8$，现独立射击 5 次，问 5 次中命中 2 次的概率。

【解】 5 次独立重复射击，$p=0.8$，则：

$$P{\text{5 次试验中命中 2 次}}=P_{5}(2)=C_{5}^{2}\cdot p^{2}\cdot(1-p)^{3}=C_{5}^{2}\cdot 0.8^{2}\cdot 0.2^{3}$$

线性代数公式要点

Tue, 23 Jun 2026 00:00:00 GMT

线性代数公式要点

第一部分：行列式

概念性质

按行/列展开不变性：n阶矩阵 $A$ 的行列式按任意一行（列）展开，其值相等。

两行（列）全相同则行列式为0：若n阶行列式有两行（列）对应元素全相等，则行列式值为0。

行（列）的可拆分性：某一行（列）的元素为两数之和时，行列式可拆分为两个行列式之和。

初等变换对行列式的影响：
- 某一行（列）乘以数 $k$，行列式值变为原来的 $k$ 倍；
- 某一行（列）的 $k$ 倍加到另一行（列），行列式值不变；
- 交换两行（列），行列式值变号。

转置不变性：行列式与其转置行列式值相等，即 $\det A^T = \det A$。

行列式的推论：若行列式的某一行（列）元素全为0，则行列式值为0；若行列式的某两行（列）对应元素成比例，则行列式值为0。

范德蒙德行列式：特殊行列式，结果为所有下标较大的元素减去下标较小的元素的乘积。

拉普拉斯定理推论（分块行列式）：上三角分块、对角分块行列式等于对角线上各子块行列式的乘积；反对角分块行列式等于 $(-1)^{mn}|A||B|$。

克拉默法则：设 $n$ 阶矩阵 $A$ 可逆，则线性方程组 $Ax = b$ 有唯一解 $x_j = \frac{\det A_j}{\det A}$。

齐次线性方程组判定：对于 $Ax=0$，若 $\det A \neq 0$，方程组只有零解；若 $\det A = 0$，方程组有非零解。

公式

$n$阶行列式定义：$D = \sum(-1)^t a_{1p_1}a_{2p_2}\dots a_{np_n}$

转置行列式：$\det A^T = \det A$

行乘常数 $k$：$\det A_1 = k\det A$

交换两行：$\det A_3 = -\det A$

范德蒙德行列式：$V_n = \prod_{1 \le i < j \le n} (x_j - x_i)$

上三角分块行列式：$\begin{vmatrix} A & C \ O & B \end{vmatrix} = |A||B|$

对角分块行列式：$\begin{vmatrix} A & O \ O & B \end{vmatrix} = |A||B|$

反对角分块行列式：$\begin{vmatrix} O & A \ B & O \end{vmatrix} = (-1)^{mn}|A||B|$

克拉默法则：$x_j = \frac{\det A_j}{\det A}$（$j=1,2,\dots,n$）

第二部分：矩阵

概念性质

矩阵定义：$m \times n$ 的数表。

同型矩阵：矩阵 $A$、$B$ 的行数和列数都相等。

矩阵相等：$A=B \iff$ 是同型矩阵，且对应位置元素相等。

特殊矩阵：方阵、行矩阵、列矩阵、零矩阵、负矩阵、上/下三角矩阵、对角矩阵、数量矩阵、单位矩阵。

矩阵加法运算规律：交换律 $A+B = B+A$，结合律 $(A+B)+C = A+(B+C)$，$A+O = A$，$A+(-A) = O$。

矩阵数乘运算规律：$k(A+B) = kA + kB$，$(k+l)A = kA + lA$，$k(lA) = (kl)A$，$1A = A$，$(-1)A = -A$。

矩阵乘法条件：$A_{m \times n}$ 与 $B_{p \times q}$ 相乘，需要 $n = p$，结果是 $m \times q$ 矩阵。

矩阵乘法不满足交换律和消去律：$AB \neq BA$，$AB=AC$ 推不出 $B=C$，两个非零矩阵的乘积可能是零矩阵。

矩阵乘法满足的运算规律：结合律 $(AB)C = A(BC)$，分配律 $(A+B)C = AC + BC$ 和 $C(A+B) = CA + CB$，数乘结合律 $k(AB) = (kA)B = A(kB)$，单位矩阵性质 $AE = EA = A$。

方阵的幂：$A^k = \underbrace{A \cdot A \cdot \dots \cdot A}_{k\text{个}}$，$A^0 = E$，$A^{k_1}A^{k_2} = A^{k_1+k_2}$，$(A^{k_1})^{k_2} = A^{k_1k_2}$。

矩阵的转置：$(A^T)^T = A$，$(A+B)^T = A^T + B^T$，$(kA)^T = kA^T$，$(AB)^T = B^T A^T$。

对称矩阵：$A^T = A$，即 $a_{ij} = a_{ji}$；同阶对称矩阵之和、差仍对称；$kA$、$A^m$ 仍对称；$AB$ 对称的充要条件是 $AB=BA$。

反对称矩阵：$A^T = -A$，即 $a_{ij} = -a_{ji}$，主对角线元素全为0；同阶反对称矩阵之和、差仍反对称；$kA$ 仍反对称。

方阵行列式性质：$|A^T|=|A|$，$|kA|=k^n|A|$，$|AB|=|A|\cdot|B|$，$|A^m|=|A|^m$。

伴随矩阵：$AA^* = A^A = |A|E$，$|A^| = |A|^{n-1}$，$(A^T)^* = (A^)^T$，$(kA)^ = k^{n-1}A^*$。

逆矩阵：$A$ 可逆 $\iff |A| \neq 0$，$A^{-1} = \frac{1}{|A|}A^*$；$(A^{-1})^{-1}=A$，$(A^T)^{-1}=(A^{-1})^T$，$(kA)^{-1}=\frac{1}{k}A^{-1}$，$(AB)^{-1}=B^{-1}A^{-1}$。

矩阵方程解：$AX=C \Rightarrow X=A^{-1}C$，$XA=C \Rightarrow X=CA^{-1}$，$AXB=C \Rightarrow X=A^{-1}CB^{-1}$。

初等矩阵：可逆，逆矩阵仍为同类型初等矩阵；$E(i,j)^{-1}=E(i,j)$，$E(i(k))^{-1}=E(i(1/k))$，$E(i,j(l))^{-1}=E(i,j(-l))$。

矩阵等价：$A \cong B \iff$ 存在可逆矩阵 $P,Q$ 使 $PAQ=B \iff r(A)=r(B)$。

矩阵的秩：非零子式的最高阶数，$0 \le r(A) \le \min(m,n)$；$r(A)=r(A^T)$，$r(kA)=r(A)\ (k \neq 0)$。

矩阵秩的不等式：$r(A+B) \le r(A)+r(B)$，$r(AB) \le \min(r(A),r(B))$，$r(A)+r(B)-n \le r(AB)$。

伴随矩阵的秩：当 $r(A)=n$ 时，$r(A^)=n$；当 $r(A)=n-1$ 时，$r(A^)=1$；当 $r(A)<n-1$ 时，$r(A^*)=0$。

公式

矩阵加法：$A+B = (a_{ij}+b_{ij})$

矩阵数乘：$kA = (ka_{ij})$

矩阵乘法：$AB = (\sum_{k=1}^n a_{ik}b_{kj})$

转置性质：$(AB)^T = B^TA^T$

方阵行列式：$|kA| = k^n|A|$，$|AB| = |A||B|$

伴随矩阵性质：$AA^* = A^A = |A|E$，$|A^| = |A|^{n-1}$

逆矩阵公式：$A^{-1} = \frac{1}{|A|}A^*$

逆矩阵性质：$(AB)^{-1} = B^{-1}A^{-1}$，$|A^{-1}| = \frac{1}{|A|}$

矩阵方程解：$AX=C \Rightarrow X=A^{-1}C$，$AXB=C \Rightarrow X=A^{-1}CB^{-1}$

初等变换法求逆：$(A \mid E) \xrightarrow{\text{行}} (E \mid A^{-1})$

分块三角行列式：$\begin{vmatrix} A & C \ O & B \end{vmatrix} = |A||B|$

分块对角逆矩阵：$\mathrm{diag}(A,B,C)^{-1} = \mathrm{diag}(A^{-1},B^{-1},C^{-1})$

秩的不等式：$r(A)+r(B)-n \le r(AB) \le \min(r(A),r(B))$

矩阵乘积为零：$AB=O \Rightarrow r(A)+r(B) \le n$

秩与转置：$r(A^T A)=r(AA^T)=r(A)$

可逆矩阵不改变秩：若 $A$ 可逆，则 $r(AB)=r(B)$，$r(CA)=r(C)$

第三部分：向量

概念性质

向量的线性运算：加法 $\boldsymbol{\alpha} + \boldsymbol{\beta} = (a_1+b_1, \dots, a_n+b_n)$，数乘 $k\boldsymbol{\alpha} = (ka_1, \dots, ka_n)$。

向量运算律：交换律、结合律、零向量性质、负向量性质、数乘结合律、分配律。

线性组合：$k_1\boldsymbol{\alpha}_1 + k_2\boldsymbol{\alpha}_2 + \dots + k_m\boldsymbol{\alpha}_m$。

线性表示：若存在常数 $k_1,\dots,k_m$ 使 $\boldsymbol{\beta} = k_1\boldsymbol{\alpha}_1 + \dots + k_m\boldsymbol{\alpha}_m$，则 $\boldsymbol{\beta}$ 可由向量组线性表示。

线性表示与方程组的关系：$\boldsymbol{\beta}$ 可由向量组表示 $\iff$ 方程组 $Ax=\boldsymbol{\beta}$ 有解。

线性相关：存在不全为零的数 $k_1,\dots,k_n$ 使 $k_1\boldsymbol{\alpha}_1 + \dots + k_n\boldsymbol{\alpha}_n = \boldsymbol{0}$。

线性无关：若 $k_1\boldsymbol{\alpha}_1 + \dots + k_n\boldsymbol{\alpha}_n = \boldsymbol{0}$，则 $k_1=\dots=k_n=0$。

线性相关性性质：一个向量线性相关 $\iff \boldsymbol{\alpha} = \boldsymbol{0}$；两个向量线性相关 $\iff$ 对应分量成比例；部分组线性相关则整体线性相关；整体线性无关则部分组线性无关；含零向量的向量组必线性相关。

极大线性无关组：满足线性无关且能表示向量组中任一向量的部分组。

向量组的秩：极大线性无关组所含向量的个数。

等价向量组：能互相线性表示的向量组，秩相等。

矩阵的行秩与列秩：行秩 = 列秩 = $r(A)$。

公式

向量加法：$\boldsymbol{\alpha} + \boldsymbol{\beta} = (a_1+b_1, \dots, a_n+b_n)$

向量数乘：$k\boldsymbol{\alpha} = (ka_1, ka_2, \dots, ka_n)$

线性组合：$k_1\boldsymbol{\alpha}_1 + k_2\boldsymbol{\alpha}_2 + \dots + k_m\boldsymbol{\alpha}_m$

线性表示：$\boldsymbol{\beta} = k_1\boldsymbol{\alpha}_1 + k_2\boldsymbol{\alpha}_2 + \dots + k_m\boldsymbol{\alpha}_m$

线性相关判定：$k_1\boldsymbol{\alpha}_1 + k_2\boldsymbol{\alpha}_2 + \dots + k_n\boldsymbol{\alpha}_n = \boldsymbol{0}$（$k_i$ 不全为0）

向量组的秩：$r(\boldsymbol{\alpha}_1,\dots,\boldsymbol{\alpha}_s)$ = 极大线性无关组向量个数

矩阵秩与向量组秩：$r(A)$ = 矩阵列向量组的秩 = 矩阵行向量组的秩

等价向量组秩关系：等价向量组的秩相等

第四部分：线性方程组

概念性质

线性方程组的三种形式：一般形式、矩阵形式 $Ax=b$、向量形式 $x_1\boldsymbol{\alpha}_1 + \dots + x_n\boldsymbol{\alpha}_n = b$。

非齐次线性方程组解的判定：
- 有解 $\iff r(A) = r(\overline{A})$；
- 有唯一解 $\iff r(A) = r(\overline{A}) = n$；
- 有无穷多解 $\iff r(A) = r(\overline{A}) < n$；
- 无解 $\iff r(A) \neq r(\overline{A})$。

齐次线性方程组解的判定：
- 有非零解 $\iff r(A) < n$；
- 只有零解 $\iff r(A) = n$。

齐次方程组解的性质：解的线性组合仍是解。

非齐次方程组解的性质：两个解之差是导出组的解；解与导出组解之和仍是解。

基础解系：线性无关且能表示所有解的解向量组，含 $n-r(A)$ 个向量。

齐次方程组通解：$\boldsymbol{x} = c_1\boldsymbol{\xi}1 + c_2\boldsymbol{\xi}2 + \dots + c{n-r}\boldsymbol{\xi}{n-r}$。

非齐次方程组通解：$\boldsymbol{x} = \boldsymbol{\alpha}_0 + c_1\boldsymbol{\xi}1 + c_2\boldsymbol{\xi}2 + \dots + c{n-r}\boldsymbol{\xi}{n-r}$（$\boldsymbol{\alpha}_0$ 为特解）。

公式

矩阵形式：$Ax = b$（非齐次），$Ax = \boldsymbol{0}$（齐次）

向量形式：$x_1\boldsymbol{\alpha}_1 + x_2\boldsymbol{\alpha}_2 + \dots + x_n\boldsymbol{\alpha}_n = b$

增广矩阵：$\overline{A} = (A \mid b)$

非齐次解判定：$r(A) = r(\overline{A})$ 有解；$r(A) \neq r(\overline{A})$ 无解

齐次解判定：$r(A) < n$ 有非零解；$r(A) = n$ 只有零解

齐次通解：$\boldsymbol{x} = c_1\boldsymbol{\xi}1 + c_2\boldsymbol{\xi}2 + \dots + c{n-r}\boldsymbol{\xi}{n-r}$

非齐次通解：$\boldsymbol{x} = \boldsymbol{\alpha}_0 + c_1\boldsymbol{\xi}1 + c_2\boldsymbol{\xi}2 + \dots + c{n-r}\boldsymbol{\xi}{n-r}$

基础解系向量数：$n - r(A)$

第五部分：特征值与特征向量

概念性质

特征值与特征向量定义：若 $A\boldsymbol{\alpha} = \lambda\boldsymbol{\alpha}$（$\boldsymbol{\alpha} \neq \boldsymbol{0}$），则 $\lambda$ 为特征值，$\boldsymbol{\alpha}$ 为特征向量。

特征方程：$|\lambda E - A| = 0$。

特征向量求法：解齐次方程组 $(\lambda E - A)\boldsymbol{x} = \boldsymbol{0}$ 的非零解。

特征值性质：
- 特征值之和 = 矩阵迹：$\lambda_1+\dots+\lambda_n = a_{11}+\dots+a_{nn}$；
- 特征值之积 = 行列式：$\lambda_1\lambda_2\cdots\lambda_n = |A|$；
- $A$ 可逆 $\iff$ 所有特征值不为0。

矩阵变换后特征值：若 $\lambda$ 是 $A$ 的特征值，则 $k\lambda$ 是 $kA$ 的特征值，$\lambda^m$ 是 $A^m$ 的特征值，$\frac{1}{\lambda}$ 是 $A^{-1}$ 的特征值，$\frac{|A|}{\lambda}$ 是 $A^*$ 的特征值。

相似矩阵定义：若存在可逆矩阵 $P$ 使 $P^{-1}AP = B$，则 $A \sim B$。

相似矩阵性质：特征值相同，秩相等，行列式相等，迹相等；$A^{-1}\sim B^{-1}$，$A^\sim B^$，$A^m\sim B^m$。

矩阵可对角化判定：$A$ 有 $n$ 个线性无关特征向量；或 $n$ 个互不相同特征值；或每个 $k$ 重特征值对应 $k$ 个线性无关特征向量。

内积性质：非负性、对称性、齐次性、线性可加性。

10. 向量长度：$\|\boldsymbol{\alpha}\| = \sqrt{(\boldsymbol{\alpha},\boldsymbol{\alpha})}$。

正交向量组：两两正交的非零向量组，一定线性无关。

施密特正交化：将线性无关向量组化为正交向量组。

实对称矩阵性质：特征值都是实数，不同特征值的特征向量正交，必可对角化，可正交相似对角化。

公式

特征值定义：$A\boldsymbol{\alpha} = \lambda\boldsymbol{\alpha}$（$\boldsymbol{\alpha} \neq \boldsymbol{0}$）

特征方程：$|\lambda E - A| = 0$

特征向量方程：$(\lambda E - A)\boldsymbol{x} = \boldsymbol{0}$

特征值之和：$\lambda_1 + \lambda_2 + \dots + \lambda_n = \mathrm{tr}(A)$

特征值之积：$\lambda_1\lambda_2\cdots\lambda_n = |A|$

相似矩阵定义：$P^{-1}AP = B$

对角化公式：$P^{-1}AP = \Lambda = \mathrm{diag}(\lambda_1,\dots,\lambda_n)$

向量内积：$(\boldsymbol{\alpha},\boldsymbol{\beta}) = a_1b_1 + a_2b_2 + \dots + a_nb_n$

9. 向量长度：$\|\boldsymbol{\alpha}\| = \sqrt{x_1^2 + x_2^2 + \dots + x_n^2}$

10. 单位化公式：$\boldsymbol{\beta} = \frac{1}{\|\boldsymbol{\alpha}\|}\boldsymbol{\alpha}$

施密特正交化：$\boldsymbol{\beta}_1 = \boldsymbol{\alpha}_1$，$\boldsymbol{\beta}_2 = \boldsymbol{\alpha}_2 - \frac{(\boldsymbol{\alpha}_2,\boldsymbol{\beta}_1)}{(\boldsymbol{\beta}_1,\boldsymbol{\beta}_1)}\boldsymbol{\beta}_1$，$\boldsymbol{\beta}_3 = \boldsymbol{\alpha}_3 - \frac{(\boldsymbol{\alpha}_3,\boldsymbol{\beta}_1)}{(\boldsymbol{\beta}_1,\boldsymbol{\beta}_1)}\boldsymbol{\beta}_1 - \frac{(\boldsymbol{\alpha}_3,\boldsymbol{\beta}_2)}{(\boldsymbol{\beta}_2,\boldsymbol{\beta}_2)}\boldsymbol{\beta}_2$

正交相似对角化：$Q^TAQ = Q^{-1}AQ = \Lambda$（$Q$ 正交矩阵）

第六部分：二次型

概念性质

二次型定义：$n$ 个变量的二次齐次多项式，$f(x_1,\dots,x_n) = \boldsymbol{x}^TA\boldsymbol{x}$（$A^T = A$）。

标准形：只含平方项的二次型，$f = d_1y_1^2 + d_2y_2^2 + \dots + d_ny_n^2$。

规范形：平方项系数仅为 $1,-1,0$ 的标准形，唯一。

惯性定理：实二次型的规范形唯一，正惯性指数 $p$ 和负惯性指数 $q$ 固定不变。

合同矩阵定义：若存在可逆矩阵 $C$ 使 $C^TAC = B$，则 $A \simeq B$。

合同性质：秩相等，对称性同步，可逆性一致。

化二次型为标准形方法：配方法（可逆变换）、正交变换法（标准形系数为特征值）。

二次型定性分类：正定（$f > 0$）、负定（$f < 0$）、半正定（$f \ge 0$）、半负定（$f \le 0$）、不定。

正定矩阵判定：正惯性指数 $p = n$；合同于 $E$；特征值全大于0；各阶顺序主子式全大于0（霍尔维茨定理）。

正定矩阵性质：$A^T, A^{-1}, A^*$ 均正定；$kA(k>0)$、$A^m$ 正定；正定矩阵之和正定。

公式

二次型矩阵形式：$f = \boldsymbol{x}^TA\boldsymbol{x}$（$A^T = A$）

二次型展开形式：$f = \sum_{i=1}^n a_{ii}x_i^2 + 2\sum_{1 \le i < j \le n} a_{ij}x_ix_j$

标准形：$f = d_1y_1^2 + d_2y_2^2 + \dots + d_ny_n^2$

规范形：$f = z_1^2 + \dots + z_p^2 - z_{p+1}^2 - \dots - z_r^2$

二次型的秩：$r(f) = r(A)$

合同矩阵定义：$C^TAC = B$

惯性指数关系：$r = p + q$，符号差 = $p - q$

正交变换化标准形：$f = \lambda_1y_1^2 + \lambda_2y_2^2 + \dots + \lambda_ny_n^2$（$\lambda_i$ 为特征值）

顺序主子式：$D_k = \begin{vmatrix} a_{11} & \dots & a_{1k} \ \vdots & & \vdots \ a_{k1} & \dots & a_{kk} \end{vmatrix}$

正定矩阵判定：$D_k > 0$（$k=1,2,\dots,n$）

大学物理B1

Mon, 22 Jun 2026 00:00:00 GMT

大学物理B1

01质点运动学（一）
02质点运动学（二）
03常见力和牛顿三定律
04动量,冲量,动量守恒
05质点运动的功和能
01电场强度
02电通量,高斯定理
03电势,电势能
04导体
05电容器
06电介质,电场能
07磁感应强度
08磁通量,高斯定理
09安培力,磁力矩,洛伦兹力
10磁介质,磁场能
11电磁感应
12自感和互感（选学）

01质点运动学（一）

考点概览

考点	重要程度	占分	常见题型
1. 位移/速度/加速度	基础知识	0~3	选择
2. $\vec{r} \to \vec{v} \to \vec{a}$ 型	必考	5~10	大题
3. $\vec{a} \to \vec{v} \to \vec{r}$ 型	必考	5~10	大题
4. 相对运动	★★	0~3	填空

1. 位移/速度/加速度

基本概念和公式

① 位矢（位置矢量）： $$\vec{r} = x\vec{i} + y\vec{j}$$

② 位移： $$\Delta\vec{r} = \vec{r}_B - \vec{r}_A$$

③ 路程：$\overset{\frown}{AB}$（弧长）

④ 速度：

平均速度：$\vec{\bar{v}} = \frac{\Delta\vec{r}}{\Delta t} = \frac{\vec{r}_B - \vec{r}_A}{t_2 - t_1}$
瞬时速度：$\vec{v} = \frac{d\vec{r}}{dt} = \frac{dx}{dt}\vec{i} + \frac{dy}{dt}\vec{j}$
大小：$|\vec{v}| = \left|\frac{d\vec{r}}{dt}\right| = \sqrt{\left(\frac{dx}{dt}\right)^2 + \left(\frac{dy}{dt}\right)^2} = \frac{ds}{dt}$

⑤ 加速度： $$\vec{a} = \frac{d\vec{v}}{dt} = \frac{dv_x}{dt}\vec{i} + \frac{dv_y}{dt}\vec{j} = \frac{dv}{dt}\vec{\tau} + \frac{v^2}{R}\vec{n}$$

切向加速度：$a_t = \frac{dv}{dt}$
法向加速度：$a_n = \frac{v^2}{R}$
大小：$|\vec{a}| = \sqrt{\left(\frac{dv_x}{dt}\right)^2 + \left(\frac{dv_y}{dt}\right)^2} = \sqrt{\left(\frac{dv}{dt}\right)^2 + \left(\frac{v^2}{R}\right)^2}$

/2.png)

例题

题1：一质点在xoy平面内运动，其运动学方程为$x = 3\cos4t$，$y = 3\sin4t$，则$t$时刻质点的位矢$\vec{r}(t) =$ ______

解：$\vec{r} = x\vec{i} + y\vec{j} = 3\cos4t\ \vec{i} + 3\sin4t\ \vec{j}$

题2：已知平面内运动方程为$x = at^2$，$y = bt^2$（其中$a, b$为常量），则该质点运动轨迹为（）

A. 双曲线 B. 抛物线 C. 圆周 D. 直线

解： $$\begin{cases} x = at^2 \ y = bt^2 \end{cases} \Rightarrow \frac{x}{y} = \frac{a}{b} \Rightarrow y = \frac{b}{a}x$$ 轨迹为直线，选D

题3：一运动质点在某瞬间矢径$\vec{r}(x, y)$的端点处，其速度大小为（）

A. $\frac{dr}{dt}$ B. $\frac{d\vec{r}}{dt}$ C. $\frac{d|\vec{r}|}{dt}$ D. $\sqrt{\left(\frac{dx}{dt}\right)^2 + \left(\frac{dy}{dt}\right)^2}$

解：速度大小为$|\vec{v}| = \sqrt{\left(\frac{dx}{dt}\right)^2 + \left(\frac{dy}{dt}\right)^2}$，选D

/4.png)

题4：质点作半径为$R$的变速圆周运动时的加速度大小为（）（$v$表示任一时刻质点的速率）

A. $\frac{dv}{dt}$ B. $\frac{v^2}{R}$ C. $\frac{dv}{dt} + \frac{v^2}{R}$ D. $\sqrt{\left(\frac{dv}{dt}\right)^2 + \left(\frac{v^2}{R}\right)^2}$

解：加速度大小为$|\vec{a}| = \sqrt{\left(\frac{dv}{dt}\right)^2 + \left(\frac{v^2}{R}\right)^2}$，选D

/5.png)

2. $\vec{r} \to \vec{v} \to \vec{a}$ 型

已知位矢求速度和加速度，解题方法：求导

例题

题1：质点的运动方程为$\vec{r} = (2 + 2t^2)\vec{i} + \left(\frac{1}{3}t^3 + 2t\right)\vec{j}$，求$t = 2$时的速度和加速度。

解： $$\vec{v} = \frac{d\vec{r}}{dt} = 4t\vec{i} + (t^2 + 2)\vec{j}$$ $$\vec{v}\big|_{t=2} = 8\vec{i} + 6\vec{j}$$

$$\vec{a} = \frac{d\vec{v}}{dt} = 4\vec{i} + 2t\vec{j}$$ $$\vec{a}\big|_{t=2} = 4\vec{i} + 4\vec{j}$$

题2：已知某质点的运动方程为$x = 2t$，$y = 2 - t^2$，式中$x$以$m$计，$t$以$s$计，求：

位置矢量表达式，速度和加速度表达式；
前2s内质点的平均速度和平均加速度；
第2s内质点的平均速度；
计算1s末和2s末质点的加速度。

解：

(1) $$\vec{r} = 2t\vec{i} + (2 - t^2)\vec{j}$$ $$\vec{v} = \frac{d\vec{r}}{dt} = 2\vec{i} - 2t\vec{j}$$ $$\vec{a} = \frac{d\vec{v}}{dt} = -2\vec{j}$$

(2) 前2s内（$t=0$到$t=2$）： $$\vec{r}_0 = 2\vec{j}, \quad \vec{v}_0 = 2\vec{i}$$ $$\vec{r}_2 = 4\vec{i} - 2\vec{j}, \quad \vec{v}_2 = 2\vec{i} - 4\vec{j}$$ $$\Delta\vec{r} = \vec{r}_2 - \vec{r}_0 = 4\vec{i} - 4\vec{j}$$ $$\vec{\bar{v}} = \frac{\Delta\vec{r}}{\Delta t} = \frac{4\vec{i} - 4\vec{j}}{2 - 0} = 2\vec{i} - 2\vec{j}$$ $$\Delta\vec{v} = \vec{v}_2 - \vec{v}_0 = -4\vec{j}$$ $$\vec{\bar{a}} = \frac{\Delta\vec{v}}{\Delta t} = \frac{-4\vec{j}}{2 - 0} = -2\vec{j}$$

(3) 第2s内（$t=1$到$t=2$）： $$\vec{r}_1 = 2\vec{i} + \vec{j}, \quad \vec{r}_2 = 4\vec{i} - 2\vec{j}$$ $$\Delta\vec{r} = \vec{r}_2 - \vec{r}_1 = 2\vec{i} - 3\vec{j}$$ $$\vec{\bar{v}} = \frac{\Delta\vec{r}}{\Delta t} = 2\vec{i} - 3\vec{j}$$

(4) 1s末和2s末质点的加速度： $$\vec{a} = -2\vec{j}$$

3. $\vec{a} \to \vec{v} \to \vec{r}$ 型

已知加速度求速度和位矢，解题方法：积分

解题方法

$$a = \frac{dv}{dt} \Rightarrow dv = adt \Rightarrow \int_{v_0}^{v} dv = \int_{0}^{t} adt$$

$$v = \frac{dx}{dt} \Rightarrow dx = vdt \Rightarrow \int_{x_0}^{x} dx = \int_{0}^{t} vdt$$

匀变速直线运动公式

$$v = v_0 + at$$ $$x = x_0 + v_0t + \frac{1}{2}at^2$$ $$v_2^2 - v_1^2 = 2a(x_2 - x_1)$$

例题

题1：设质点沿$x$轴作匀变速直线运动，加速度为$a$不随时间变化，初速度为$v_0$，初位置为$x_0$，试根据速度、加速度的定义求出该质点的速度公式和运动学方程。

解： $$a = \frac{dv}{dt} \Rightarrow dv = adt \Rightarrow \int_{v_0}^{v} dv = \int_{0}^{t} adt$$ $$v - v_0 = at \Rightarrow v = v_0 + at$$

$$v = \frac{dx}{dt} \Rightarrow dx = vdt = (v_0 + at)dt \Rightarrow \int_{x_0}^{x} dx = \int_{0}^{t} (v_0 + at)dt$$ $$x - x_0 = v_0t + \frac{1}{2}at^2 \Rightarrow x = x_0 + v_0t + \frac{1}{2}at^2$$

题2：一质点做直线运动，加速度$a = 2m/s^2$，开始时$v_1 = 2m/s$，一段时间后$v_2 = 6m/s$，问质点在这段时间内的位移大小。

解：由$v_2^2 - v_1^2 = 2a(x_2 - x_1)$ $$6^2 - 2^2 = 2 \times 2 \times (x_2 - x_1)$$ $$36 - 4 = 4(x_2 - x_1)$$ $$x_2 - x_1 = 8\ m$$

题3：质点沿直线运动，加速度$a = 4 - t^2$，式中$a$的单位为$m/s^2$，$t$的单位为$s$，如果当$t = 3s$时，$x = 9m$，$v = 2m/s$，求质点的运动方程。

解： $$a = 4 - t^2 = \frac{dv}{dt} \Rightarrow dv = (4 - t^2)dt \Rightarrow \int_{v_0}^{v} dv = \int_{0}^{t} (4 - t^2)dt$$ $$v = v_0 + 4t - \frac{1}{3}t^3 \quad \text{①}$$

$$v = \frac{dx}{dt} \Rightarrow dx = vdt = \left(v_0 + 4t - \frac{1}{3}t^3\right)dt \Rightarrow \int_{x_0}^{x} dx = \int_{0}^{t} \left(v_0 + 4t - \frac{1}{3}t^3\right)dt$$ $$x = x_0 + v_0t + 2t^2 - \frac{1}{12}t^4 \quad \text{②}$$

将$t = 3s$，$x = 9m$，$v = 2m/s$代入①②得： $$v_0 = -1m/s, \quad x_0 = 0.75m$$

所以质点的运动方程为： $$x = 0.75 - t + 2t^2 - \frac{1}{12}t^4 \quad (m)$$

题4：一质点沿一直线运动，其加速度为$a = -2x$，式中$x$的单位为$m$，$a$的单位为$m/s^2$。试求该质点的速度$v$与位置坐标$x$之间的关系。设当$x_0 = 1$时，$v_0 = 4m/s$。

解： $$a = -2x = \frac{dv}{dt} = \frac{dv}{dx} \cdot \frac{dx}{dt} = \frac{dv}{dx} \cdot v$$ $$\frac{dv}{dx} \cdot v = -2x$$

分离变量得： $$vdv = -2xdx \Rightarrow \int_{v_0}^{v} vdv = \int_{x_0}^{x} -2xdx$$

$$\frac{1}{2}v^2 - \frac{1}{2}v_0^2 = -x^2 + x_0^2$$

代入$x_0 = 1$，$v_0 = 4$： $$\frac{1}{2}v^2 - 8 = -x^2 + 1$$ $$v^2 = -2x^2 + 18$$

4. 相对运动

相对关系

$$\vec{v}{绝对} = \vec{v}{牵连} + \vec{v}{相对}$$ $$\vec{a}{绝对} = \vec{a}{牵连} + \vec{a}{相对}$$

例题

题1：甲船以$v_1 = 10m/s$的速度向南航行，乙船以$v_2 = 10m/s$的速度向东航行，则甲船上的人观察乙船的速度大小为 ______

解：

$v_1$：牵连速度（甲船相对于地面）
$v_2$：绝对速度（乙船相对于地面）

$$\vec{v}2 = \vec{v}1 + \vec{v}{相对}$$ $$\vec{v}{相对} = \vec{v}_2 - \vec{v}_1$$

由勾股定理： $$v_{相对} = \sqrt{v_1^2 + v_2^2} = \sqrt{10^2 + 10^2} = 10\sqrt{2}\ m/s$$

/12.png)

02质点运动学（二）

考点概览

考点	重要程度	占分	题型
1. 角位移/角速度/角加速度	基础知识	不单独出题	无
2. $\theta \to \omega \to \beta$ 型	★★	3~10	选填为主，偶尔大题
3. $\beta \to \omega \to \theta$ 型	★★★	3~10	选填为主，偶尔大题
4. 角量与线量关系	必考	3~10	选填为主，偶尔大题

1. 角位移/角速度/角加速度

基本概念和公式

角位移：$\theta$，单位：$\text{rad}$（弧度）
角速度：$\omega = \frac{d\theta}{dt}$，单位：$\text{rad/s}$
角加速度：$\beta = \frac{d\omega}{dt} = \frac{d^2\theta}{dt^2}$，单位：$\text{rad/s}^2$
周期：$T = \frac{2\pi}{\omega}$，单位：$\text{s}$（秒）

/2.png)

2. $\theta \to \omega \to \beta$ 型

已知角位置求角速度和角加速度，解题方法：求导

例题

题1：某质点上的角位置和时间关系为$\theta = 4t - 3t^2 + t^3$（SI），则在2秒末的角速度大小$\omega =$ ______，角加速度大小$\beta =$ ______，在2秒末到4秒末这段时间内，平均角速度大小$\bar{\omega} =$ ______。

解： $$\omega = \frac{d\theta}{dt} = 4 - 6t + 3t^2$$ $$\omega\big|_{t=2} = 4 - 6 \times 2 + 3 \times 2^2 = 4\ \text{rad/s}$$

$$\beta = \frac{d\omega}{dt} = -6 + 6t$$ $$\beta\big|_{t=2} = -6 + 6 \times 2 = 6\ \text{rad/s}^2$$

$$t = 2\ \text{s}\ \text{时}\ \theta_2 = 4$$ $$t = 4\ \text{s}\ \text{时}\ \theta_4 = 32$$ $$\Delta\theta = 32 - 4 = 28$$

$$\bar{\omega} = \frac{\Delta\theta}{\Delta t} = \frac{28}{4 - 2} = 14\ \text{rad/s}$$

3. $\beta \to \omega \to \theta$ 型

已知角加速度求角速度和角位置，解题方法：积分

解题方法

$$\beta = \frac{d\omega}{dt} \Rightarrow d\omega = \beta dt \Rightarrow \int_{\omega_0}^{\omega} d\omega = \int_{0}^{t} \beta dt$$

$$\omega = \frac{d\theta}{dt} \Rightarrow d\theta = \omega dt \Rightarrow \int_{\theta_0}^{\theta} d\theta = \int_{0}^{t} \omega dt$$

匀变速圆周运动公式

$$\omega = \omega_0 + \beta t$$ $$\theta = \theta_0 + \omega_0t + \frac{1}{2}\beta t^2$$ $$\omega_2^2 - \omega_1^2 = 2\beta(\theta_2 - \theta_1)$$

例题

题1：已知匀变速圆周运动，角加速度为$\beta$，$t = 0$时，角速度为$\omega_0$，角位移为$\theta_0$，试用定义公式，求角速度和角位移表达式。

解： $$\beta = \frac{d\omega}{dt} \Rightarrow d\omega = \beta dt \Rightarrow \int_{\omega_0}^{\omega} d\omega = \int_{0}^{t} \beta dt$$ $$\omega - \omega_0 = \beta t \Rightarrow \omega = \omega_0 + \beta t$$

$$\omega = \frac{d\theta}{dt} \Rightarrow d\theta = \omega dt = (\omega_0 + \beta t)dt \Rightarrow \int_{\theta_0}^{\theta} d\theta = \int_{0}^{t} (\omega_0 + \beta t)dt$$ $$\theta - \theta_0 = \omega_0t + \frac{1}{2}\beta t^2 \Rightarrow \theta = \theta_0 + \omega_0t + \frac{1}{2}\beta t^2$$

题2：搅拌机叶片以恒定角加速度$1.50\ \text{rad/s}^2$转动，求： (1) 从静止启动后经过多少时间角速度将达到$36.0\ \text{rad/s}$？ (2) 在此时间内共转过多少转？

解： (1) 由$\omega = \omega_0 + \beta t$得： $$36 = 0 + 1.5t \Rightarrow t = 24\ \text{s}$$

(2) 由$\theta = \theta_0 + \omega_0t + \frac{1}{2}\beta t^2$： $$\theta = 0 + 0 + \frac{1}{2} \times 1.5 \times 24^2 = 432\ \text{rad}$$

$$n = \frac{\theta}{2\pi} = \frac{432}{2 \times 3.14} = 68.8\ \text{（转）}$$

题3：绕定轴转动的飞轮，均匀减速，$t = 0$时$\omega_0 = 5\ \text{rad/s}$，$t = 20$时$\omega = 0.8\omega_0$，则飞轮的角加速度$\beta =$ ______ $\text{rad/s}^2$，转过的角度$\theta =$ ______ $\text{rad}$。

解： $$t = 0\ \text{时}\ \omega_0 = 5,\quad t = 20\ \text{时}\ \omega = 0.8\omega_0 = 4$$

由$\omega = \omega_0 + \beta t$： $$4 = 5 + \beta \times 20 \Rightarrow \beta = -0.05\ \text{rad/s}^2$$

由$\omega^2 - \omega_0^2 = 2 \cdot \beta \cdot \Delta\theta$： $$\Delta\theta = \frac{\omega^2 - \omega_0^2}{2\beta} = \frac{4^2 - 5^2}{-2 \times 0.05} = 90\ \text{rad}$$

4. 角量与线量关系（必考）

基本关系

物理量	角量表达式	线量表达式	关系
速度	$\omega$	$v$	$v = \omega R$
切向加速度	$\beta$	$a_t$	$a_t = \beta R$
法向加速度	$\omega$	$a_n$	$a_n = \omega^2 R = \frac{v^2}{R}$

/7.png)

例题

题1：质点在作半径为$R$的圆周运动：

质点的线速度$v$与角速度$\omega$的关系为$v = \omega R$；
质点的切向加速度$a_t$与角加速度$\beta$的关系为$a_t = \beta R$；
质点的法向加速度$a_n$与角速度$\omega$的关系为$a_n = \omega^2 R$。

题2：质点沿半径为$R$的圆周运动，运动学方程为$\theta = 3 + 2t^2$（SI），则$t$时刻质点的法向加速度大小为$a_n =$ ______，切向加速度$a_t =$ ______。

解： $$\omega = \frac{d\theta}{dt} = 4t,\quad \beta = \frac{d\omega}{dt} = 4$$

$$a_n = \omega^2 R = (4t)^2 R = 16Rt^2$$

$$a_t = \beta R = 4R$$

题3：一质点在半径为$0.1\ \text{m}$的圆周上运动，其角位置变化关系为$\theta = 2 + 4t^3$（rad）。问： (1) 在$t = 2\ \text{s}$时，质点的法向加速度和切向加速度大小各为多少？ (2) 当切向加速度大小恰好等于总加速度大小的一半时，$\theta$值为多少？ (3) 在什么时刻，切向加速度和法向加速度恰好大小相等？

解： $$\omega = \frac{d\theta}{dt} = 12t^2,\quad \beta = \frac{d\omega}{dt} = 24t$$

(1) $$a_n = \omega^2 R = (12t^2)^2 \times 0.1 = 14.4t^4$$ $$a_n\big|_{t=2} = 14.4 \times 2^4 = 230.4\ \text{m/s}^2$$

$$a_t = \beta R = 24t \times 0.1 = 2.4t$$ $$a_t\big|_{t=2} = 2.4 \times 2 = 4.8\ \text{m/s}^2$$

(2) $$a = \sqrt{a_t^2 + a_n^2} = \sqrt{(2.4t)^2 + (14.4t^4)^2}$$

依题意$a_t = \frac{1}{2}a$： $$2.4t = \frac{1}{2}\sqrt{(2.4t)^2 + (14.4t^4)^2}$$ $$t^3 = \frac{\sqrt{3}}{6}$$ $$\theta = 2 + 4t^3 = 2 + 4 \times \frac{\sqrt{3}}{6} = 3.15\ \text{rad}$$

(3) 依题意$a_t = a_n$： $$2.4t = 14.4t^4$$ 解得：$t = 0.55\ \text{s}$

03常见力和牛顿三定律

考点概览

考点	重要程度	占分	常见题型
1. 常见力	基础知识	5~10	选择、填空、大题
2. 牛顿三定律	基础知识	5~10	选择、填空、大题

1. 常见力

基本概念和公式

重力：$G = mg$，$g = 9.8N/kg$
弹力：$F = kx$（$k$为弹性系数）
摩擦力：
- ①滑动摩擦：$f = \mu_k N$（$\mu_k$为滑动摩擦系数，$N$为支持力）
- ②静摩擦：$0 \leq f \leq \mu_s N$（$\mu_s$为最大静摩擦系数）
万有引力：$F = G\frac{Mm}{r^2}$，$G = 6.67 \times 10^{-11} N \cdot m^2/kg^2$

2. 牛顿三定律

牛顿三定律内容

牛顿第一定律：不受力或合外力为0，质点保持静止或匀速直线运动
牛顿第二定律：$F = ma$（力是物体产生加速度的原因）
牛顿第三定律：$F_{作用} = F_{反作用}$（作用力等于反作用力）

解题步骤

选物体
分析受力
列方程
求解

例题

题1：关于摩擦力的说法，下列哪一种说法正确（）

A. 摩擦力总是阻碍物体运动 B. 摩擦力的方向总是与物体运动方向相反 C. 摩擦力总是对物体做负功 D. 以上说法都不对

解：选D

题2：用水平力$F_N$把一个物体压着靠在粗糙的竖直墙面上保持静止，当$F_N$逐渐增大时，物体所受到的静摩擦力$F_f$的大小（）

A. 不为零，但保持不变 B. 随$F_N$成正比增大 C. 开始随$F_N$增大，达到某一最大值后就保持不变 D. 无法确定

解：$F_N = N$，$F_N$增大则$N$增大，但静摩擦力$F_f = mg$，与$F_N$无关，保持不变。选A

题3：两物体A和B，质量分别是$m_1$和$m_2$，互相接触放在光滑水平面上，对物体A施以水平推力$F$，则物体A对物体B的作用力等于______。

解： $$F = (m_1 + m_2)a \quad \text{①}$$ $$F - F_{AB} = m_1a \quad \text{②}$$

由①②得：$F_{AB} = \frac{m_2}{m_1 + m_2}F$

题4：设电梯中有一质量可以忽略的滑轮，在滑轮两侧用轻绳悬挂着质量分别为$m_1$和$m_2$的重物A和B，已知$m_1 > m_2$，当电梯匀速上升，求绳中的张力$T$和物体A相对于电梯的加速度$a$。

解：对A受力分析：$m_1g - T = m_1a$

对B受力分析：$T - m_2g = m_2a$

联立解得： $$T = \frac{2m_1m_2}{m_1 + m_2}g$$ $$a = \frac{m_1 - m_2}{m_1 + m_2}g$$

题5：一艘行驶的质量为$m$的快艇，在发动机关闭后，受到一阻力作用，且$f = -kv^2$，式中$k$为正常数，求快艇在关闭发动机后速度与行驶距离的关系。（已知发动机关闭时快艇速度为$v_0$）

解：根据牛顿第二定律： $$f = -kv^2 = ma = m\frac{dv}{dt} = m\frac{dv}{dx} \cdot \frac{dx}{dt} = mv\frac{dv}{dx}$$ $$-kv = m\frac{dv}{dx}$$

分离变量：$\frac{1}{v}dv = -\frac{k}{m}dx$

两边同时积分： $$\int_{v_0}^{v} \frac{1}{v}dv = \int_{0}^{x} -\frac{k}{m}dx$$ $$\ln v - \ln v_0 = -\frac{k}{m}x$$ $$\ln \frac{v}{v_0} = -\frac{k}{m}x$$ $$\frac{v}{v_0} = e^{-\frac{k}{m}x}$$ $$v = v_0 e^{-\frac{k}{m}x}$$

题6：简述牛顿定律的适用范围

(1) 只适用于低速运动的物体（与光速比速度较低）； (2) 只适用于宏观物体，不适用于微观原子； (3) 参照系应为惯性系。

04动量,冲量,动量守恒

考点概览

考点	重要程度	占分	常见题型
1. 动量定理	必考	5~10	选/填
2. 动量守恒	必考	5~10	大题

1. 动量定理

基本概念和公式

动量：$\vec{p} = m\vec{v}$，单位：$kg \cdot m/s$
动量定理：$\vec{I} = m\vec{v}_2 - m\vec{v}1 = \int{t_1}^{t_2} \vec{F}dt$，单位：$N \cdot s$

要点

①冲量为矢量，等于动量的矢量差，也等于冲力对时间的积分

②$\vec{F}$为冲力，为合外力

③$\vec{F}$若为常力，$\vec{I} = m\vec{v}_2 - m\vec{v}_1 = \vec{F} \cdot \Delta t$

例题

题1：一物体质量为$m$，$t_1$时刻速度大小为$v_0$，方向沿$x$负方向，$t_2$时刻速度大小仍为$v_0$，方向沿$y$轴正方向，$t_1$到$t_2$冲量大小为______

解： $$I = \sqrt{(mv_0)^2 + (mv_0)^2} = \sqrt{2}mv_0$$

题2：一垒球的质量$m = 0.20kg$，如果其投出时的速度为$30m/s$，被棒击回的速度为$50m/s$，方向相反，球的冲量大小为______；球与棒的接触时间为$\Delta t = 0.0020s$，则棒击打垒球的平均冲力$F =$ ______

解： $$I = mv_2 - mv_1 = 0.2 \times 50 - 0.2 \times (-30) = 16\ N \cdot s$$

$$I = F \cdot \Delta t$$ $$16 = F \times 0.002$$ $$F = 8000N$$

题3：质量为$3kg$的静止物体在水平力$F = 3t^2$（$N$）作用下，在光滑水平面上作直线运动，物体在$0 \sim 3$秒内获得的冲量______$N \cdot s$，第3秒末物体的速度值______$m/s$

解： $$I = \int_{t_1}^{t_2} Fdt = \int_{0}^{3} 3t^2 dt = 27\ N \cdot s$$

$$I = mv_2 - mv_1 = mv_2$$ $$27 = 3 \times v_2 \Rightarrow v_2 = 9\ m/s$$

题4：一静止的质点，在合力为$\vec{F} = 10t\vec{i} + 2(2-t)\vec{j}$作用下，在$2s$末的动量为______

解： $$F_x = 10t,\quad F_y = 2(2-t)$$

$$mv_{x_2} - 0 = \int_{0}^{2} F_x dt = \int_{0}^{2} 10t dt = 20$$

$$mv_{y_2} - 0 = \int_{0}^{2} F_y dt = \int_{0}^{2} 2(2-t) dt = 4$$

$$\vec{p}_2 = 20\vec{i} + 4\vec{j}$$

2. 动量守恒

动量守恒条件

$F_{合} = 0$：不受外力或所受合外力为零
内力不改变系统的总动量（例如：爆炸）
内力远大于外力时，也可认为$F_{合} = 0$

动量守恒定律

$$\sum m_i \vec{v}{i1} = \sum m_i \vec{v}{i2}$$

例题

题1：粒子B的质量是粒子A的质量的4倍，开始时粒子A的速度为$3\vec{i}$，粒子B的速度为$2\vec{i}$，由于两者的相互作用，粒子A的速度变为$7\vec{i}$，此时粒子B的速度为（）

A. $\vec{i}$ B. $2\vec{i}$ C. $0$ D. $5\vec{i}$

解：由动量守恒： $$m \cdot 3 + 4m \cdot 2 = m \cdot 7 + 4m \cdot v_B$$ $$3 + 8 = 7 + 4v_B$$ $$v_B = 1$$

选A

题2：一人站在长度为$4m$的船一端，船漂浮于静止水面上。船的质量为$600kg$，人的质量为$80kg$，若此人从船头走到船尾，则船相对于水面移动了多少米？（忽略水对船的阻力）

解：水平方向动量守恒： $$mv_{人} = Mv_{船} \Rightarrow m\frac{dx_1}{dt} = M\frac{dx_2}{dt}$$

整理得：$mdx_1 = Mdx_2$

两边同时积分： $$\int_{0}^{x_1} mdx_1 = \int_{0}^{x_2} Mdx_2 \Rightarrow mx_1 = Mx_2$$

即：$80x_1 = 600x_2$

又：$x_1 + x_2 = 4$

联立两式解得： $$\begin{cases} x_1 = 3.53m \ x_2 = 0.47m \end{cases}$$

故船移动了$0.47m$

题3：下列几种说法正确的是（）

(1) 作用力的冲量与反作用力的冲量总是等值相反的 (2) 系统的内力不能改变系统的总动量 (3) 冲量的方向与物体动量的方向相同 (4) 以恒力作用于物体，时间越长，物体的动量越大

A. 只有(1)是正确的 B. (1)(2)是正确的 C. (1)(3)是正确的 D. (2)(4)是正确的

解：选B

题4：判断下列运动是否动量守恒

运动类型	是否守恒	说明
匀速圆周运动	不守恒	动量方向不断改变
卫星绕地球	不守恒	受万有引力作用
弹性碰撞	守恒	系统动量守恒，机械能守恒
非弹性碰撞	守恒	系统动量守恒，机械能减小
完全非弹性碰撞	守恒	系统动量守恒，机械能损失最大
子弹打击木块（绳）	守恒	水平方向无外力
子弹打击木块（杆）	不守恒	杆受外力作用

05质点运动的功和能

考点概览

考点	重要程度	占分	常见题型
1. 做功	必考	5~10	填空、大题
2. 动能定理	必考	5~10	填空、大题
3. 保守力、势能	★★	5~10	填空、大题
4. 机械能守恒	必考	5~10	填空、大题

1. 做功

基本概念和公式

① 元功：$dA = \vec{F} \cdot d\vec{r}$

② 功： $$A = \int \vec{F} \cdot d\vec{r}$$

当 $F = f(x)$ 时： $$A = \int_{x_1}^{x_2} F dx$$

③ 恒力做功： $$A = \vec{F} \cdot \vec{r} = F_x x + F_y y + F_z z$$

例题

题1：某质点在力 $F = (4 + 5x)$ 的作用下沿 $x$ 轴做直线运动，在从 $x = 0$ 移动到 $x = 1$ 的过程中，力 $F$ 所做的功为______

解： $$A = \int_{0}^{1} F dx = \int_{0}^{1} (4 + 5x) dx = 4x + \frac{5}{2}x^2 \Big|_{0}^{1} = 4 + \frac{5}{2} = 6.5\ J$$

题2：一质点在恒力 $\vec{F} = 3\vec{i} - 5\vec{j} + 6\vec{k}$ 的作用下产生位移为 $\vec{r} = 2\vec{i} - 4\vec{j} - 3\vec{k}$，在该位移过程中所做的功为______

解： $$A = \vec{F} \cdot \vec{r} = 3 \times 2 + (-5) \times (-4) + 6 \times (-3) = 6 + 20 - 18 = 8\ J$$

题3：一人从 $10m$ 深的井中提水，起始桶中装有 $10kg$ 的水，由于水桶漏水，每升高 $1m$ 要漏去 $0.2kg$ 的水，水桶被匀速地从井中提到井口，求人所做的功。

解：

设水桶升高 $x$ 米时，水的质量为： $$m = 10 - 0.2x$$

人所施加的力为： $$F = mg = (10 - 0.2x)g$$

人所做的功为： $$A = \int_{0}^{10} F dx = \int_{0}^{10} (10 - 0.2x)g dx = g \left(10x - 0.1x^2\right) \Big|_{0}^{10} = g(100 - 10) = 90g = 882\ J$$

2. 动能定理

基本概念和公式

① 动能： $$E_k = \frac{1}{2}mv^2$$

② 动能定理： $$A = E_{k2} - E_{k1} = \frac{1}{2}mv_2^2 - \frac{1}{2}mv_1^2$$

合外力对物体所做的功等于物体动能的增量。

例题

题1：质量为 $1kg$ 的物体运动速率由 $2m/s$ 增加到 $4m/s$ 的过程中，合外力对它所做的功为______

解： $$A = \frac{1}{2}mv_2^2 - \frac{1}{2}mv_1^2 = \frac{1}{2} \times 1 \times 4^2 - \frac{1}{2} \times 1 \times 2^2 = 8 - 2 = 6\ J$$

题2：用铁锤把钉子敲入墙面木板，设木板对钉子的阻力与钉子进入木板的深度成正比，即 $F = kx$。若第一次打击时，能把钉子打入木板 $1cm$。第二次打击时，保持第一次打击的速度，第二次能把钉子打入的深度为______

解：

设第一次打击前钉子速度为 $v$，第一次打击后钉子深度为 $x_1 = 1cm$

第一次打击： $$\frac{1}{2}mv^2 = \int_{0}^{x_1} kx dx = \frac{1}{2}kx_1^2$$

第二次打击（钉子从深度 $x_1$ 打到深度 $x_2$）： $$\frac{1}{2}mv^2 = \int_{x_1}^{x_2} kx dx = \frac{1}{2}k(x_2^2 - x_1^2)$$

由两次打击动能相等： $$\frac{1}{2}kx_1^2 = \frac{1}{2}k(x_2^2 - x_1^2)$$ $$x_1^2 = x_2^2 - x_1^2$$ $$x_2^2 = 2x_1^2$$ $$x_2 = \sqrt{2}x_1 = \sqrt{2}cm$$

第二次打入深度： $$\Delta x = x_2 - x_1 = (\sqrt{2} - 1)cm$$

题3：质量均匀分布的钢性链条，总长为 $L$，伸出光滑桌面的长度为 $a$，若由静止释放。求：链条全部脱离光滑桌面时速率。

解：

设链条线密度为 $\lambda = \frac{m}{L}$

链条从伸出 $a$ 到全部脱离桌面，重心下降高度： $$h = \frac{L}{2} - \frac{a}{2} = \frac{L - a}{2}$$

链条重力做功： $$A = mg \cdot h = m \cdot g \cdot \frac{L - a}{2}$$

由动能定理： $$A = \frac{1}{2}mv^2 - 0$$ $$mg \cdot \frac{L - a}{2} = \frac{1}{2}mv^2$$ $$v = \sqrt{g(L - a)}$$

3. 保守力、势能

基本概念和公式

① 保守力：做功与路径无关，只与始末位置有关的力。

② 保守力的特点：

保守力做功与路径无关，只与始末位置有关
保守力沿一闭合路径运动一周，做功为零
势能的引入是以保守力做功为前提
不同的势能零点，对应的势能值不一样
势能大小 = 保守力把物体移至势能零点所做的功
保守力做正功，对应势能减小
功能计算时，功-能计算一个，就要忽略这个保守力

③ 常用保守力势能及零势能点：

保守力	势能表达式	常用零势能点
重力 $G = mg$	$E_p = mgh$	地面
弹力 $F = kx$	$E_p = \frac{1}{2}kx^2$	平衡位置
万有引力 $F = G\frac{Mm}{r^2}$	$E_p = -G\frac{Mm}{r}$	无穷远处
静电力 $F = \frac{1}{4\pi\varepsilon_0}\frac{q_1q_2}{r^2}$	$E_p = \frac{1}{4\pi\varepsilon_0}\frac{q_1q_2}{r}$	无穷远处

4. 机械能守恒

基本概念和公式

① 机械能： $$E = E_k + E_p = \frac{1}{2}mv^2 + E_p$$

② 机械能守恒定律： $$E_{k1} + E_{p1} = E_{k2} + E_{p2}$$

机械能只包含动能和势能
系统内只有保守力做功，其他内力和一切外力都不做功

例题

题1：如图所示，质量 $m = 2kg$ 的物体从静止开始，沿 $1/4$ 圆弧从 $A$ 滑到 $B$，在 $B$ 处的速度大小为 $v = 6m/s$，已知圆的半径 $R = 4m$，则物体从 $A$ 到 $B$ 的过程中摩擦力对它所做的功为______

解：

$A$ 点机械能： $$E_A = mgR$$

$B$ 点机械能： $$E_B = \frac{1}{2}mv^2$$

摩擦力做功等于机械能损失： $$A_f = E_B - E_A = \frac{1}{2}mv^2 - mgR = \frac{1}{2} \times 2 \times 6^2 - 2 \times 9.8 \times 4 = 36 - 78.4 = -42.4\ J$$

题2：质量为 $m$ 的子弹，穿过如图所示的摆锤后，速率由 $v$ 变为 $\frac{v}{2}$。已知摆锤的质量为 $M$，摆线的长度为 $L$，如果摆锤能在垂直平面内完成一个完全的圆周运动，子弹的速度最小值应为多大？

解：

子弹穿过摆锤瞬间，动量守恒： $$mv = m \cdot \frac{v}{2} + Mv'$$ $$v' = \frac{m}{M} \cdot \frac{v}{2}$$

摆锤可以完成圆周运动，则在最高点满足： $$Mg = M\frac{v_{最高}^2}{L}$$ $$v_{最高} = \sqrt{gL}$$

摆锤开始上扬，满足机械能守恒： $$\frac{1}{2}Mv'^2 = \frac{1}{2}Mv_{最高}^2 + Mg \cdot 2L$$ $$\frac{1}{2}M \cdot \left(\frac{m}{M} \cdot \frac{v}{2}\right)^2 = \frac{1}{2}M \cdot gL + 2MgL$$ $$\frac{m^2v^2}{4M^2} = 5gL$$ $$v = \frac{2M}{m}\sqrt{5gL}$$

题3：子弹水平地射入一端固定在弹簧上的木块内，由弹簧压缩的距离求出子弹的速度。已知子弹质量是 $0.02kg$，木块质量是 $8.98kg$，弹簧的劲度系数是 $100N/m$，子弹射入木块后，弹簧被压缩 $0.1m$。设木块与平面间的动摩擦因数为 $0.2$，求子弹的速度。

解：

子弹射入木块瞬间，动量守恒： $$mv = (m + M)v'$$ $$v' = \frac{m}{m + M}v = \frac{0.02}{0.02 + 8.98}v = \frac{0.02}{9}v$$

弹簧开始压缩，满足功能关系： $$\frac{1}{2}(m + M)v'^2 - \mu(m + M)g \cdot x = \frac{1}{2}kx^2$$ $$\frac{1}{2} \times 9 \times \left(\frac{0.02}{9}v\right)^2 - 0.2 \times 9 \times 9.8 \times 0.1 = \frac{1}{2} \times 100 \times 0.1^2$$ $$\frac{1}{2} \times 9 \times \frac{0.0004}{81}v^2 - 1.764 = 0.5$$ $$\frac{0.0004}{18}v^2 = 2.264$$ $$v^2 = \frac{2.264 \times 18}{0.0004} = 101880$$ $$v = 319.2\ m/s$$

题4：对于一个物体来说，在下列的哪种情况下系统的机械能守恒（）

A. 合外力为0
B. 合外力不做功
C. 外力和非保守力都不做功
D. 外力和保守内力都不做功

解：机械能守恒条件：系统内只有保守力做功，其他内力和一切外力都不做功。选C

题5：对功的概念有以下几种说法：

(1) 保守力作正功时，系统内相应的势能增加；
(2) 质点运动经一闭合路径，保守力对质点作的功为零；
(3) 作用力与反作用力大小相等，方向相反，所以两者所做功的代数和必为零。

以上说法正确的是（）

A. (1)(2)是正确的
B. (2)(3)是正确的
C. 只有(2)是正确的
D. 只有(3)是正确的

解：

(1) 错误：保守力做正功时，势能减小
(2) 正确：保守力沿闭合路径做功为零
(3) 错误：作用力与反作用力做功的代数和不一定为零

选C

01电场强度

考点概览

考点	重要程度	占分	常见题型
1. 离散型	★★	0~3	选择/填空
2. 连续型	★★★★★	5~10	选择/填空/大题
3. 结论型	★★★★★	5~10	选择/填空/大题

1. 求电场强度—离散型

基本概念和公式

库仑定律： $$F = \frac{1}{4\pi\varepsilon_0} \cdot \frac{q \cdot q_0}{r^2}$$ (1) 同性相斥，异性相吸 (2) 电场力跟$q, q_0$电量成正比，跟$r^2$成反比 (3) 真空介电常量：$\varepsilon_0 = 8.85 \times 10^{-12}\ C^2/(N \cdot m^2)$

电场强度： $$E = \frac{F}{q_0} = \frac{1}{4\pi\varepsilon_0} \cdot \frac{q}{r^2}$$ (矢量，有大小有方向)

(1) $\vec{E}$方向判定：将正电荷放入电场中，受力方向即$\vec{E}$的方向 (2) 电场强度跟场源电荷$q$和位置$r$有关，与试探电荷$q_0$无关

例题

题1：在点电荷$q_1$激发的电场中有一试探电荷$q_0$受力为$\vec{F}$，若将另一个点电荷$q_2$移入该区域后，$q_0$与$q_1$之间的作用力将（）

A. 不变 B. 变大 C. 变小 D. 无法确定

解：$q_0$与$q_1$之间的作用力只与它们之间的距离和电量有关，与$q_2$无关。选A

题2：如图所示，求在$P$点和$Q$点处的场强和方向？

解：

P点： $$E = E_1 - E_2 = \frac{1}{4\pi\varepsilon_0} \cdot \frac{q}{(2l)^2} - \frac{1}{4\pi\varepsilon_0} \cdot \frac{q}{(4l)^2} = \frac{3q}{64\pi\varepsilon_0 l^2}$$ 方向沿$x$轴正方向

Q点： $$E_1 = E_2 = \frac{1}{4\pi\varepsilon_0} \cdot \frac{q}{(2l)^2} = \frac{q}{16\pi\varepsilon_0 l^2}$$ $$E = E_y = \frac{q}{16\pi\varepsilon_0 l^2}$$ 方向沿$y$轴负方向

2. 求电场强度—连续型

解题方法

$$dE = \frac{1}{4\pi\varepsilon_0} \cdot \frac{dq}{r^2}$$ $$E = \int dE = \int \frac{1}{4\pi\varepsilon_0} \cdot \frac{dq}{r^2}$$

常用积分公式： $$\int xdx = \frac{1}{2}x^2 + C$$ $$\int dx = x + C$$

例题

题1：均匀带电细棒，棒长$L$，电荷线密度$\lambda$，求：棒的延长线上与棒的右端相距$d$处的场强。

解：在带电棒上取一线元$dx$，则$dx$所带的电荷量：$dq = \lambda \cdot dx$

在$P$处： $$dE = \frac{1}{4\pi\varepsilon_0} \cdot \frac{\lambda \cdot dx}{(L + d - x)^2}$$

$$E = \int dE = \int_{0}^{L} \frac{1}{4\pi\varepsilon_0} \cdot \frac{\lambda}{(L + d - x)^2} dx$$ $$= \frac{\lambda}{4\pi\varepsilon_0} \cdot \frac{1}{(L + d - x)} \bigg|_{0}^{L} = \frac{\lambda}{4\pi\varepsilon_0} \left( \frac{1}{d} - \frac{1}{L + d} \right)$$

另一种坐标设定（原点在棒右端）： $$dE = \frac{1}{4\pi\varepsilon_0} \cdot \frac{\lambda \cdot dx}{(x + d)^2}$$

$$E = \int_{0}^{L} \frac{1}{4\pi\varepsilon_0} \cdot \frac{\lambda}{(x + d)^2} dx$$ $$= \frac{\lambda}{4\pi\varepsilon_0} \cdot \frac{-1}{(x + d)} \bigg|_{0}^{L} = \frac{\lambda}{4\pi\varepsilon_0} \left( \frac{1}{d} - \frac{1}{L + d} \right)$$

题2：一个半径为$R$的均匀带正电半圆环，电荷线密度为$\lambda$，求环心处$O$点的场强和方向。

解：在半圆环上任取线元$dl$，$dl = Rd\theta$，所带电量：$dq = \lambda \cdot dl = \lambda \cdot Rd\theta$

在$O$点产生的场强： $$dE = \frac{1}{4\pi\varepsilon_0} \cdot \frac{\lambda \cdot dl}{R^2} = \frac{\lambda}{4\pi\varepsilon_0 R^2} dl$$

分量分解： $$dE_x = dE \cdot \sin\theta = \frac{\lambda}{4\pi\varepsilon_0 R^2} \sin\theta \cdot Rd\theta = \frac{\lambda}{4\pi\varepsilon_0 R} \sin\theta d\theta$$ $$dE_y = dE \cdot \cos\theta = \frac{\lambda}{4\pi\varepsilon_0 R} \cos\theta d\theta$$

积分： $$E_x = \int_{0}^{\pi} \frac{\lambda}{4\pi\varepsilon_0 R} \sin\theta d\theta = \frac{\lambda}{2\pi\varepsilon_0 R}$$ $$E_y = \int_{0}^{\pi} \frac{\lambda}{4\pi\varepsilon_0 R} \cos\theta d\theta = 0$$

$$E = E_x = \frac{\lambda}{2\pi\varepsilon_0 R}$$ 方向朝$x$正方向

3. 求电场强度—结论型

常用结论汇总

带电体	场强公式	备注
点电荷	$E = \frac{1}{4\pi\varepsilon_0} \cdot \frac{q}{r^2}$
无限长均匀带电直线	$E = \frac{\lambda}{2\pi\varepsilon_0 r}$	$r$为到直线距离
无限大均匀带电平面	$E = \frac{\sigma}{2\varepsilon_0}$	与距离无关
均匀带电圆柱面	$E = 0$（$r < R$）<br>$E = \frac{\lambda}{2\pi\varepsilon_0 r}$（$r > R$）	高斯推导
均匀带电球体	$E = \frac{qr}{4\pi\varepsilon_0 R^3}$（$r < R$）<br>$E = \frac{q}{4\pi\varepsilon_0 r^2}$（$r > R$）	高斯推导

例题

题1：均匀带电"无限大"平面上的面电荷密度为$\sigma_0$，其场强与场点到带电平板的距离无关，其场强大小为______

解：$E = \frac{\sigma_0}{2\varepsilon_0}$

题2：真空中两个平行的"无限大"均匀带电平面，电荷面密度为$+\sigma$和$-2\sigma$，则$A, B, C$三个区域的场强分别为：

解：

$A$区：$\vec{E}_A = \frac{\sigma}{2\varepsilon_0}\vec{i}$
$B$区：$\vec{E}_B = \frac{3\sigma}{2\varepsilon_0}\vec{i}$
$C$区：$\vec{E}_C = -\frac{\sigma}{2\varepsilon_0}\vec{i}$

题3：一宽为$b$的无限长均匀带电平面薄板，其电荷面密度为$\sigma$，试求平板所在平面内，距薄板边缘为$a$处的电场强度。

解：薄板内任取一窄条，宽为$dx$，窄条可视为无限长带电线，线密度：$\lambda = \sigma dx$

无限长带电线在$P$点的场强： $$dE = \frac{\sigma dx}{2\pi\varepsilon_0 \left(a + \frac{b}{2} - x\right)}$$

整个薄板在$P$点的场强： $$E = \int_{-\frac{b}{2}}^{\frac{b}{2}} \frac{\sigma dx}{2\pi\varepsilon_0 \left(a + \frac{b}{2} - x\right)} = \frac{\sigma}{2\pi\varepsilon_0} \ln\frac{a + b}{a}$$

02电通量,高斯定理

考点概览

考点	重要程度	占分	常见题型
1. 电通量	★★★★★	0~3	选择、填空
2. 高斯定理求场强	必考	5~10	大题

1. 电通量

电场线性质

(1) 电场线总是起自正电荷，终止于负电荷。

(2) 电场线不会自成闭合线，任意两条电场线也不会相交。

(3) 电场线密度大的地方，电场强度$E$越大。

电通量公式

(1) 电通量：$\Phi_e = E \cdot S$

(2) $E$和$S$必须是垂直关系

(3) 对于曲面，向外穿出为正，向内穿入为负

三种情况：

平面垂直电场：$\Phi_e = E \cdot S$
平面与电场成$\theta$角：$\Phi_e = E \cdot S \cdot \cos\theta$
曲面：$d\Phi_e = \vec{E} \cdot d\vec{S}$，$\Phi_e = \int d\Phi_e = \iint \vec{E} \cdot d\vec{S}$

例题

题1：一电场强度为$\vec{E}$的均匀电场，$\vec{E}$的方向沿$x$轴正向，则通过图中一半径为$R$的半球面的电场强度通量为（）

A. $\frac{\pi R^2 E}{2}$ B. $0$ C. $2\pi R^2 E$ D. $\pi R^2 E$

解：选B（电场线穿入和穿出相等，总通量为0）

题2：如图，在电场强度$E$的匀强电场中，有一半径为$R$的半球面，场强$E$的方向与半球面对称轴平行，穿过此半球面的电通量为（）

A. $2\pi R^2 E$ B. $\sqrt{2}\pi R^2 E$ C. $\pi R^2 E$ D. $\frac{\pi R^2 E}{2}$

解：$\Phi_e = E \cdot S = \pi \cdot R^2 E$，选C

题3：有一半径为$R$的半球面如图所示，放在均匀电场中，通过半球面的电通量（）

A. $2\pi R^2 E$ B. $-\pi R^2 E$ C. $2\pi R^2 \cos\theta$ D. $-\pi R^2 E \cos\theta$

解：$\Phi_e = -E \cdot S \cos\theta = -\pi \cdot R^2 E \cos\theta$，选D

2. 静电场中的高斯定理

高斯定理内容

闭合曲面的电通量等于包含电荷量除以$\varepsilon_0$：

$$\Phi_e = \oiint \vec{E} \cdot d\vec{S} = \frac{1}{\varepsilon_0} \sum q_{内}$$

例题

题1：求电荷量为$q$的均匀带电球壳内外场强分布。

解：由高斯定理： $$\oiint \vec{E} \cdot d\vec{S} = E \cdot \oiint dS = E \cdot 4\pi r^2 = \frac{1}{\varepsilon_0} \sum q_{内}$$

$$\Rightarrow E = \frac{\sum q_{内}}{4\pi \varepsilon_0 r^2}$$

$r < R$时：$\sum q_{内} = 0 \Rightarrow E = 0$
$r > R$时：$\sum q_{内} = q \Rightarrow E = \frac{q}{4\pi \varepsilon_0 r^2}$

题2：半径为$R$的球体，均匀带电$q$，试求场强分布。

解：由高斯定理： $$\oiint \vec{E} \cdot d\vec{S} = E \cdot 4\pi r^2 = \frac{1}{\varepsilon_0} \sum q_{内} \Rightarrow E = \frac{\sum q_{内}}{4\pi \varepsilon_0 r^2}$$

体密度：$\rho = \frac{q}{V} = \frac{q}{\frac{4}{3}\pi R^3} = \frac{3q}{4\pi R^3}$

$r < R$时：$\sum q_{内} = \rho \cdot V_r = \frac{3q}{4\pi R^3} \cdot \frac{4}{3}\pi r^3 = \frac{qr^3}{R^3}$

$$E = \frac{qr^3/R^3}{4\pi \varepsilon_0 r^2} = \frac{qr}{4\pi \varepsilon_0 R^3}$$

$r > R$时：$\sum q_{内} = q \Rightarrow E = \frac{q}{4\pi \varepsilon_0 r^2}$

题3：一半径为$R$的带电球体，其电荷密度$\rho = A \cdot r$（$A > 0$），试求球内外的场强分布。

解：由高斯定理： $$\oiint \vec{E} \cdot d\vec{S} = E \cdot 4\pi r^2 = \frac{1}{\varepsilon_0} \sum q_{内} \Rightarrow E = \frac{\sum q_{内}}{4\pi \varepsilon_0 r^2}$$

$dV = 4\pi r^2 \cdot dr$，$dq = \rho \cdot dV = Ar \cdot 4\pi r^2 dr$

$r < R$时：$\sum q_{内} = \int_0^r Ar \cdot 4\pi r^2 dr = \pi A r^4$

$$E = \frac{\pi A r^4}{4\pi \varepsilon_0 r^2} = \frac{A r^2}{4\varepsilon_0}$$

$r > R$时：$\sum q_{内} = \int_0^R Ar \cdot 4\pi r^2 dr = \pi A R^4$

$$E = \frac{\pi A R^4}{4\pi \varepsilon_0 r^2} = \frac{A R^4}{4\varepsilon_0 r^2}$$

题4：求半径为$R$，线密度为$\lambda$的无限长均匀带电圆柱体内外场强分布。

解：由高斯定理： $$\oiint \vec{E} \cdot d\vec{S} = E \cdot \oiint dS = E \cdot 2\pi r h = \frac{1}{\varepsilon_0} \sum q_{内}$$

$$\Rightarrow E = \frac{\sum q_{内}}{2\pi \varepsilon_0 r h}$$

$r < R$时：$\sum q_{内} = \frac{\lambda h}{\pi R^2 h} \cdot \pi r^2 h = \frac{r^2}{R^2} \lambda h$

$$E = \frac{\frac{r^2}{R^2} \lambda h}{2\pi \varepsilon_0 r h} = \frac{\lambda r}{2\pi \varepsilon_0 R^2}$$

$r > R$时：$\sum q_{内} = \lambda h$

$$E = \frac{\lambda h}{2\pi \varepsilon_0 r h} = \frac{\lambda}{2\pi \varepsilon_0 r}$$

题5：点电荷$q$位于一边长为$a$的立方体中心，试求： (1) 在该点电荷电场中穿过立方体的任一个面的电通量； (2) 若将该场源点电荷移动到立方体的一个顶点上，则穿过立方体各面的电通量。

解：

(1) $\Phi_e = \oiint_S \vec{E} \cdot d\vec{S} = \frac{q}{\varepsilon_0}$

$$\Rightarrow \Phi_e' = \frac{\Phi_e}{6} = \frac{q}{6\varepsilon_0}$$

(2) $\Phi_e = \oiint_S \vec{E} \cdot d\vec{S} = \frac{q}{\varepsilon_0}$

$$\Rightarrow \Phi_e' = \frac{\Phi_e}{24} = \frac{q}{24\varepsilon_0}$$

与电荷直接相连的三个面电通量为$0$
与电荷不相连的三个面电通量为$\frac{q}{24\varepsilon_0}$

题6：点电荷$q_1, q_2, q_3, q_4, q_5$在真空中的分布如图所示，图中为闭合曲面，则通过该闭合曲面的电场强度通量为（）

A. $\frac{q_1+q_2+q_3}{\varepsilon_0}$ B. $\frac{q_1+q_2+q_3+q_4+q_5}{\varepsilon_0}$ C. $\frac{q_2+q_3+q_5}{\varepsilon_0}$ D. $\frac{q_1+q_2+q_4}{\varepsilon_0}$

解：选D，电通量只与高斯面内电荷有关

题7：如图所示，闭合曲面$S$内有一点电荷$q$，$P$为$S$面上任一点，$S$面外有一点电荷$q'$，设通过$S$的电通量为$\Phi$，$P$点的场强为$\vec{E}_P$，当$q'$从$A$点移动到$B$点时（）

A. $\Phi$改变，$\vec{E}_P$不变 B. $\Phi, \vec{E}_P$都不变

C. $\Phi, \vec{E}_P$都改变 D. $\Phi$不变，$\vec{E}_P$改变

解：$\Phi$只与高斯面内电荷有关，$\vec{E}_P$由面内和面外电荷共同决定。选D

题8：在高斯定理中，$\oiint_S \vec{E} \cdot d\vec{S} = \frac{q}{\varepsilon_0}$，$S$和$q$的物理意义是（）

A. $S$为闭合面，$q$为$S$内的总电量

B. $S$为闭合面，$q$为空间总电量

C. $S$为任意曲面，$q$为$S$上分布的电量

D. $S$为任意曲面，$q$为空间总电量

解：选A

题9：对于高斯定理$\oiint_S \vec{E} \cdot d\vec{S} = \frac{q}{\varepsilon_0}$，以下说法正确的是（）

A. 高斯面上的场强仅由高斯面内的电荷所产生

B. 若$\oiint_S \vec{E} \cdot d\vec{S} = 0$则高斯面内必无任何电荷分布

C. 若高斯面上的场强处处为零，则高斯面内无净电荷

D. 高斯面内净电荷等于零，则高斯面上的场强也必等于零

解：选C

题10：关于高斯定理的理解有下面几种说法，其中正确的是（）

A. 如果高斯面内无电荷，则高斯面上$\vec{E}$处处为零

B. 如果高斯面上$\vec{E}$处处不为零，则该面内必有电荷

C. 如果高斯面上$\vec{E}$处处为零，则该面内必无电荷

D. 如果高斯面内净电荷不为零，则通过该面的电通量必不为零

解：选D

高斯定理要点总结

(1) 电通量与高斯面面内电荷有关，与电荷的位置以及高斯面面外电荷无关

(2) $\sum q_{内}$是指高斯面内的净电荷（所有正负电荷的代数和）

(3) 高斯面上的场强$E$，不仅由面内电荷影响，还由面外电荷影响

03电势,电势能

考点概览

考点	重要程度	占分	常见题型
1. 电势	必考	5~10	大题
2. 电势能	★★★	0~3	选择、填空
3. 电势与电场关系	★★★	3~5	选择、填空

1. 电势

基本概念和公式

做功与路径无关 → 电场力是保守力 → 电势能

电势能：$W_M = \int_{M}^{\infty} \vec{F} \cdot d\vec{l} = \int_{M}^{\infty} q_0 \vec{E} \cdot d\vec{l}$

电势零点：可以自定义，一般默认无穷远处

电势定义： $$V = \frac{W_M}{q_0} = \int_{r}^{\infty} \vec{E} \cdot d\vec{l} = \frac{q}{4\pi \varepsilon_0 r}$$

电势在数值上等于单位正电荷从该点沿任意路径到零势能点电场力做功。

求电势三种类型

① 离散型：$V = \frac{q}{4\pi \varepsilon_0 r}$

② 连续型：$dV = \frac{dq}{4\pi \varepsilon_0 r}$，$V = \int \frac{dq}{4\pi \varepsilon_0 r}$

③ 已知场强求电势：$V = \int_{起点}^{\infty} \vec{E} \cdot d\vec{l}$

例题：连续型

题1：一均匀带电半圆环，半径为$R$，电量为$+Q$，求环心处的电势。

解：带电圆环上取线元$dl$，则$dl$所带的电量：$dq = \frac{Q}{\pi R} \cdot dl$

在$O$点产生的电势： $$dV = \frac{dq}{4\pi \varepsilon_0 r} = \frac{Q dl}{4\pi^2 \varepsilon_0 R^2}$$

$$V = \int dV = \int_{0}^{\pi R} \frac{Q dl}{4\pi^2 \varepsilon_0 R^2} = \frac{Q}{4\pi \varepsilon_0 R}$$

结论：圆环/半圆环/部分圆环，总带电量为$Q$，在圆心处的电势：$V_O = \frac{Q}{4\pi \varepsilon_0 R}$

题2：一绝缘细棒弯成半径为$R$的1/4圆形环，使之均匀带正电，电荷线密度为$+\lambda$，设无穷远处为电势零点，则在1/4圆环圆心$O$处的电势为（）

A. $\frac{\lambda}{8\varepsilon_0}$ B. $\frac{\lambda}{\varepsilon_0}$ C. $\frac{\lambda}{2\varepsilon_0}$ D. $\frac{\lambda}{4\varepsilon_0}$

解：1/4圆形环带电量：$Q = \lambda \cdot \frac{1}{4} \cdot 2\pi R = \frac{1}{2}\pi R \lambda$

所以在$O$点的电势： $$V = \frac{Q}{4\pi \varepsilon_0 R} = \frac{\frac{1}{2}\pi R \lambda}{4\pi \varepsilon_0 R} = \frac{\lambda}{8\varepsilon_0}$$

选A

例题：已知场强求电势

题1：求电荷量为$q$的均匀带电球壳内外电势分布。

解：先由高斯定理求场强： $$\oiint \vec{E} \cdot d\vec{S} = E \cdot 4\pi r^2 = \frac{1}{\varepsilon_0} \sum q_{内} \Rightarrow E = \frac{\sum q_{内}}{4\pi \varepsilon_0 r^2}$$

$r < R$时：$\sum q_{内} = 0 \Rightarrow E_1 = 0$
$r > R$时：$\sum q_{内} = q \Rightarrow E_2 = \frac{q}{4\pi \varepsilon_0 r^2}$

再由场强求电势：

$r < R$时：$V = \int_{起点}^{\infty} \vec{E} \cdot d\vec{l} = \int_{r}^{R} E_1 dr + \int_{R}^{\infty} E_2 dr = \int_{r}^{R} 0 dr + \int_{R}^{\infty} \frac{q}{4\pi \varepsilon_0 r^2} dr = \frac{q}{4\pi \varepsilon_0 R}$
$r > R$时：$V = \int_{起点}^{\infty} \vec{E} \cdot d\vec{l} = \int_{r}^{\infty} E_2 dr = \int_{r}^{\infty} \frac{q}{4\pi \varepsilon_0 r^2} dr = \frac{q}{4\pi \varepsilon_0 r}$

题2：如图所示，在半径为$R_1$和$R_2$的两个同心球面上分别均匀带电$q_1$和$q_2$，求三个区域内的电势分布。

解：

(1) 先求场强分布： $$\oiint \vec{E} \cdot d\vec{S} = E \cdot 4\pi r^2 = \frac{1}{\varepsilon_0} \sum q_{内} \Rightarrow E = \frac{\sum q_{内}}{4\pi \varepsilon_0 r^2}$$

$r < R_1$时：$\sum q_{内} = 0 \Rightarrow E_1 = 0$
$R_1 < r < R_2$时：$\sum q_{内} = q_1 \Rightarrow E_2 = \frac{q_1}{4\pi \varepsilon_0 r^2}$
$r > R_2$时：$\sum q_{内} = q_1 + q_2 \Rightarrow E_3 = \frac{q_1 + q_2}{4\pi \varepsilon_0 r^2}$

(2) 电势分布：

$r < R_1$时： $$V_1 = \int_{r}^{R_1} 0 dr + \int_{R_1}^{R_2} \frac{q_1}{4\pi \varepsilon_0 r^2} dr + \int_{R_2}^{\infty} \frac{q_1 + q_2}{4\pi \varepsilon_0 r^2} dr = \frac{1}{4\pi \varepsilon_0} \left( \frac{q_2}{R_2} + \frac{q_1}{R_1} \right)$$
$R_1 < r < R_2$时： $$V_2 = \int_{r}^{R_2} \frac{q_1}{4\pi \varepsilon_0 r^2} dr + \int_{R_2}^{\infty} \frac{q_1 + q_2}{4\pi \varepsilon_0 r^2} dr = \frac{1}{4\pi \varepsilon_0} \left( \frac{q_1}{r} + \frac{q_2}{R_2} \right)$$
$r > R_2$时： $$V_3 = \int_{r}^{\infty} \frac{q_1 + q_2}{4\pi \varepsilon_0 r^2} dr = \frac{q_1 + q_2}{4\pi \varepsilon_0 r}$$

题3：半径为$R_1$和$R_2$的两个无限长同轴圆柱面，单位长度上分别带有电量$\lambda$和$-\lambda$，试求：(1) 空间场强分布；(2) 两圆柱面之间的电势差。

解：

(1) 由高斯定理： $$\oiint \vec{E} \cdot d\vec{S} = E \cdot 2\pi r h = \frac{1}{\varepsilon_0} \sum q_{内} \Rightarrow E = \frac{\sum q_{内}}{2\pi \varepsilon_0 r h}$$

$r < R_1$时：$\sum q_{内} = 0 \Rightarrow E_1 = 0$
$R_1 < r < R_2$时：$\sum q_{内} = \lambda h \Rightarrow E_2 = \frac{\lambda}{2\pi \varepsilon_0 r}$
$r > R_2$时：$\sum q_{内} = \lambda h - \lambda h = 0 \Rightarrow E_3 = 0$

(2) 两圆柱面之间的电势差： $$V_{AB} = \int_{R_1}^{R_2} \vec{E}2 \cdot d\vec{r} = \int{R_1}^{R_2} \frac{\lambda}{2\pi \varepsilon_0 r} dr = \frac{\lambda}{2\pi \varepsilon_0} \ln \frac{R_2}{R_1}$$

题4：一电荷$q = 10^{-9}C$，$A, B, C$三点分别距离该点电荷10cm, 20cm, 30cm。若选$B$点电势为零，则$A$点的电势为______，$C$点的电势为______。

解：

$$V_A = \int_{r_A}^{r_B} \vec{E} \cdot d\vec{l} = \int_{r_A}^{r_B} \frac{q}{4\pi \varepsilon_0 r^2} dr = \frac{q}{4\pi \varepsilon_0} \left( \frac{1}{r_A} - \frac{1}{r_B} \right)$$ $$= \frac{10^{-9}}{4\pi \times 8.85 \times 10^{-12}} \left( \frac{1}{0.1} - \frac{1}{0.2} \right) = 45\ V$$

$$V_C = \int_{r_C}^{r_B} \vec{E} \cdot d\vec{l} = \int_{r_C}^{r_B} \frac{q}{4\pi \varepsilon_0 r^2} dr = \frac{q}{4\pi \varepsilon_0} \left( \frac{1}{r_C} - \frac{1}{r_B} \right)$$ $$= \frac{10^{-9}}{4\pi \times 8.85 \times 10^{-12}} \left( \frac{1}{0.3} - \frac{1}{0.2} \right) = -15\ V$$

2. 电势能

基本概念和公式

电势能 = 电荷 × 电势 = 电场力做功

$$W_M = q_0 V = \int_{M}^{零势能点} \vec{F} \cdot d\vec{l}$$

电场力做正功 = 电势能减小

$$A = -(W_2 - W_1)$$

例题

题1：如图所示，在$A、B$两点处有电量分别为$+q、-q$的点电荷，$A、B$间的距离为$2R$，现将另一正试验点电荷$q_0$从$O$点经半圆弧移动到$C$点，电场力所做的功为______。

解：

$O$点电势：$V_O = \frac{q}{4\pi \varepsilon_0 R} + \frac{-q}{4\pi \varepsilon_0 R} = 0$

$C$点电势：$V_C = \frac{q}{4\pi \varepsilon_0 \cdot 3R} + \frac{-q}{4\pi \varepsilon_0 R} = -\frac{q}{6\pi \varepsilon_0 R}$

电势能变化：$W_2 - W_1 = q_0 V_C - q_0 V_O = -\frac{q q_0}{6\pi \varepsilon_0 R}$

故电场力做功：$A = -(W_2 - W_1) = \frac{q q_0}{6\pi \varepsilon_0 R}$

题2：一电量为$q$的点电荷位于圆心$O$处，$A, B, C, D$为同一圆周上的四点，现将一试验电荷从$A$点分别移动到$B, C, D$各点，则（）

A. 从$A$到$B$，电场力做功最大

B. 从$A$到各点，电场力做功相等

C. 从$A$到$D$，电场力做功最大

D. 从$A$到$C$，电场力做功最大

解：同一圆周上各点电势相等：$V_A = V_B = V_C = V_D$

电势能相等：$q_0 V_A = q_0 V_B = q_0 V_C = q_0 V_D$

所以从$A$到各点，电势能变化为0，电场力做功相等。选B

3. 电场和电势关系

基本关系

(1) $E = 0 \nRightarrow V = 0$，$E$大小 $\nRightarrow V$大小

(2) 电场线密的地方电场强度越大

(3) 电势沿电场线方向减小

(4) 某点电势随电势零点不同而不同

(5) $\vec{E} = -\left( \frac{\partial V}{\partial x}, \frac{\partial V}{\partial y}, \frac{\partial V}{\partial z} \right)$

例题

题1：描述静电场性质的两个基本物理量是______。

解：电场强度和电势

题2：在某电场区域内的电场线（实线）和等势面（虚线）如图所示，由图判断出正确结论为（）

A. $E_A > E_B > E_C$，$V_A > V_B > V_C$

B. $E_A > E_B > E_C$，$V_A < V_B < V_C$

C. $E_A < E_B < E_C$，$V_A > V_B > V_C$

D. $E_A < E_B < E_C$，$V_A < V_B < V_C$

解：电场线越密场强越大，故$E_A < E_B < E_C$；电势沿电场线方向减小，故$V_A > V_B > V_C$。选C

04导体

考点概览

考点	重要程度	占分	题型
1. 静电平衡	必考	3~6	选择/填空
2. 导体的场强和电势	★★★★★	5~10	大题

1. 静电平衡

静电平衡条件

(1) 电荷分布在外表面，内部场强处处为零（$E = 0$）

(2) 导体表面电场强度 $E = \frac{\sigma}{\varepsilon_0}$

(3) 导体是等势体，表面是等势面，但场强并非处处相等

(4) 导体表面曲率越大（尖锐），电荷密度越大

例题

题1：半径为$R$的金属球体是一个等势体，其电势$V = 100V$，则球心处的场强大小为______

解：$E = 0$（导体内部场强处处为零）

题2：均匀带电无限大平面附近的场强大小为______，均匀带电无限大平面导体附近的场强大小为______

解：$\frac{\sigma}{2\varepsilon_0}$；$\frac{\sigma}{\varepsilon_0}$

题3：如图所示，金属球$B$被一同心金属球壳$A$所包围，分别给$A,B$两导体以电量$+5C$和$+3C$，则$A$球壳的外表面带电量为（）

A. $0C$ B. $+5C$ C. $+8C$ D. $-3C$

解：$B$球带$+3C$，$A$球壳内表面感应$-3C$，$A$球壳外表面带电量为$5 + 3 = +8C$。选C

题4：一个带电导体达到静电平衡时（）

A. 表面上电荷密度较大处电势较高

B. 导体内任意两点的电势差等于零

C. 导体内部的电势比表面的电势高

D. 表面曲率较大处电势较高

解：导体是等势体，内部任意两点电势差为零。选B

题5：如图所示将一个电量为$q$的点电荷放在一个半径为$R$的不带电的导体球附近，点电荷距离导体球球心为$d$，设无穷远处为零势能点，则在导体球球心$O$点有（）

A. $E = 0$，$V = \frac{q}{4\pi \varepsilon_0 d}$

B. $E = \frac{q}{4\pi \varepsilon_0 d^2}$，$V = \frac{q}{4\pi \varepsilon_0 d}$

C. $E = 0$，$V = 0$

D. $E = \frac{q}{4\pi \varepsilon_0 d^2}$，$V = \frac{q}{4\pi \varepsilon_0 R}$

解：导体内部场强为零；电势由点电荷$q$和感应电荷共同产生，球心电势等于点电荷$q$在球心处产生的电势。选A

题6：一个带电的空腔导体球壳，内半径为$R$，在空腔内离球心的距离为$d$处（$d < R$），固定一点电荷$+q$，则在球心$O$处的电势为______；用导线把球壳接地后，再把地线撤销，选无穷远为电势零点，则球心$O$处的电势为______

解：

(1) 根据电势叠加： $$V_O = \frac{q}{4\pi \varepsilon_0 d} + \frac{-q}{4\pi \varepsilon_0 R} + \frac{q}{4\pi \varepsilon_0 R} = \frac{q}{4\pi \varepsilon_0 d}$$

(2) 接地后，球壳外表面电荷为零： $$V_O = \frac{q}{4\pi \varepsilon_0 d} + \frac{-q}{4\pi \varepsilon_0 R} = \frac{q}{4\pi \varepsilon_0} \left( \frac{1}{d} - \frac{1}{R} \right)$$

2. 导体中的电场和电势

例题

题1：有一外半径为$R_3$，内半径为$R_2$的金属球壳，在球壳内放一半径为$R_1$的同心金属球，若使金属球带有$q$的正电荷。求：(1) 电荷分布；(2) 电场分布；(3) 电势分布。

解：

(1) 电荷分布：

金属球表面：$+q$
球壳内表面：$-q$
球壳外表面：$+q$

(2) 电场分布（由高斯定理）： $$\oiint \vec{E} \cdot d\vec{S} = E \cdot 4\pi r^2 = \frac{1}{\varepsilon_0} \sum q_{内} \Rightarrow E = \frac{\sum q_{内}}{4\pi \varepsilon_0 r^2}$$

$r < R_1$时：$\sum q_{内} = 0 \Rightarrow E_1 = 0$
$R_1 < r < R_2$时：$\sum q_{内} = q \Rightarrow E_2 = \frac{q}{4\pi \varepsilon_0 r^2}$
$R_2 < r < R_3$时：$\sum q_{内} = q - q = 0 \Rightarrow E_3 = 0$
$r > R_3$时：$\sum q_{内} = q - q + q = q \Rightarrow E_4 = \frac{q}{4\pi \varepsilon_0 r^2}$

(3) 电势分布：

$r < R_1$时： $$V = \frac{q}{4\pi \varepsilon_0 R_1} - \frac{q}{4\pi \varepsilon_0 R_2} + \frac{q}{4\pi \varepsilon_0 R_3} = \frac{q}{4\pi \varepsilon_0} \left( \frac{1}{R_1} - \frac{1}{R_2} + \frac{1}{R_3} \right)$$
$R_1 < r < R_2$时： $$V = \frac{q}{4\pi \varepsilon_0 r} - \frac{q}{4\pi \varepsilon_0 R_2} + \frac{q}{4\pi \varepsilon_0 R_3} = \frac{q}{4\pi \varepsilon_0} \left( \frac{1}{r} - \frac{1}{R_2} + \frac{1}{R_3} \right)$$
$R_2 < r < R_3$时： $$V = \frac{q}{4\pi \varepsilon_0 r} - \frac{q}{4\pi \varepsilon_0 r} + \frac{q}{4\pi \varepsilon_0 R_3} = \frac{q}{4\pi \varepsilon_0 R_3}$$
$r > R_3$时： $$V = \frac{q}{4\pi \varepsilon_0 r} - \frac{q}{4\pi \varepsilon_0 r} + \frac{q}{4\pi \varepsilon_0 r} = \frac{q}{4\pi \varepsilon_0 r}$$

05电容器

考点概览

考点	重要程度	占分	常见题型
1. 电容器	★★★★★	3~5	选择、填空

1. 电容器

基本概念和公式

电容定义：$C = \frac{q}{U}$，单位：$F$（法拉），$1\mu F = 10^{-6}F$，$1pF = 10^{-12}F$

关键要点：

(1) 电容器是由导体构成，电荷量等值异号，分布在极板内侧

(2) $C = \frac{q}{U}$，$q$代表一侧的电荷量取正，$U$代表极板间电压

(3) 极板间电场强度：$E = \frac{\sigma}{\varepsilon_0} = \frac{U}{d}$，电势差：$U = \frac{q}{C} = E \cdot d$

(4) 极板间相互作用力：$F = \frac{1}{2} E \cdot q$

(5) 含介质：$C = \varepsilon_r C_0$，$E = \frac{E_0}{\varepsilon_r}$，$\varepsilon = \varepsilon_0 \cdot \varepsilon_r$

电介质参数：

$\varepsilon$：介电常量（电容率）
$\varepsilon_0$：真空中介电常量（真空中电容率）
$\varepsilon_r$：相对介电常量（相对电容率），$\varepsilon_r \geq 1$，真空中$\varepsilon_r = 1$

常见电容器电容公式

电容器类型	真空中电容	含介质$\varepsilon_r$电容
平行板电容器	$C = \frac{\varepsilon_0 S}{d}$	$C = \frac{\varepsilon_0 \varepsilon_r S}{d}$
圆柱形电容器	$C = \frac{2\pi \varepsilon_0 l}{\ln R_B / R_A}$	$C = \frac{2\pi \varepsilon_0 \varepsilon_r l}{\ln R_B / R_A}$
球形电容器	$C = 4\pi \varepsilon_0 \frac{R_A R_B}{R_B - R_A}$	$C = 4\pi \varepsilon_0 \varepsilon_r \frac{R_A R_B}{R_B - R_A}$
孤立导体电容器	$C = 4\pi \varepsilon_0 R_A$	$C = 4\pi \varepsilon_0 \varepsilon_r R_A$

电容器串并联

串联：$\frac{1}{C} = \frac{1}{C_1} + \frac{1}{C_2}$

并联：$C = C_1 + C_2$

例题

题1：求面积为$S$，两极板间距离为$d$的平行板电容器的电容。

解：电荷 $q = \sigma \cdot S$

电势差：$U = E \cdot d = \frac{\sigma}{\varepsilon_0} \cdot d$

电容：$C = \frac{q}{U} = \frac{\sigma S}{\frac{\sigma}{\varepsilon_0} \cdot d} = \frac{\varepsilon_0 S}{d}$

含介质时：$C = \frac{\varepsilon_0 \varepsilon_r S}{d}$

结论：电容大小只与极板大小、形状、相对位置以及电介质有关

题2：设两平行板电容器的电容为$C$，若将两极板的正对面积增大到原来的2倍，极板间距离增大到原来的3倍，则此电容器的电容变为______。

解：平行板电容器：$C = \frac{\varepsilon_0 S}{d}$

$S' \to 2S$，$d' \to 3d$

$$C' = \frac{\varepsilon_0 S'}{d'} = \frac{\varepsilon_0 \cdot 2S}{3d} = \frac{2}{3} \cdot \frac{\varepsilon_0 S}{d} = \frac{2}{3}C$$

题3：当平行板电容器板间为真空时，其电容为$C_0$，板间场强大小为$E_0$，当充满着相对介电常数为$\varepsilon_r$的电介质，则电容为______。

解：$C = \varepsilon_r C_0$

题4：真空中半径为$R$的金属球的电容为______，若放在无限大相对介电常量为$\varepsilon_r$的电介质中电容为______。

解：$C = 4\pi \varepsilon_0 R$；$C = 4\pi \varepsilon_0 \varepsilon_r R$

题5：四个电容器连接如图，则$a,b$两端的等效电容为______。

解： $$\frac{1}{C_1} = \frac{1}{12} + \frac{1}{4} = \frac{1}{3} \Rightarrow C_1 = 3\mu F$$

$$C_2 = C_1 + 2 = 3 + 2 = 5\mu F$$

$$\frac{1}{C_{ab}} = \frac{1}{C_2} + \frac{1}{20} = \frac{1}{5} + \frac{1}{20} = \frac{1}{4} \Rightarrow C_{ab} = 4\mu F$$

题6：平行板电容器两板间距离为$d$，极板面积为$S$，在真空时的电容、自由电荷面密度、电势差、电场强度的大小分别用$C_0, \sigma_0, U_0, E_0$表示。

(1) 如充电后与电源断开，将$\varepsilon_r$的均匀介质充满电容器，则：

$C =$，$\sigma =$，$U =$，$E =$

(2) 与电源保持联接，将$\varepsilon_r$的均匀介质充满电容器，则：

$C =$，$\sigma =$，$U =$，$E =$

解：

(1) 电荷量$Q$不变： $$C = \varepsilon_r C_0$$ $$\sigma = \frac{Q}{S} = \sigma_0$$ $$U = \frac{Q}{C} = \frac{Q}{\varepsilon_r C_0} = \frac{U_0}{\varepsilon_r}$$ $$E = \frac{U}{d} = \frac{U_0}{\varepsilon_r d} = \frac{E_0}{\varepsilon_r}$$

(2) 电压不变$U = U_0$： $$C = \varepsilon_r C_0$$ $$\sigma = \frac{Q}{S} = \frac{C \cdot U}{S} = \frac{\varepsilon_r C_0 \cdot U}{S} = \frac{\varepsilon_r Q_0}{S} = \varepsilon_r \sigma_0$$ $$U = U_0$$ $$E = \frac{U}{d} = \frac{U_0}{d} = E_0$$

题7：一平行板空气电容器的两极板相距$d$，$A$和$B$极板上面电荷密度分别为$+\sigma$和$-\sigma$，其间插入与极板大小相等，厚度为$d/2$的金属板后，金属板与极板间场强大小为______，金属板内的场强大小为______，两极板间的电势差为______。

解：插入金属板，极板电荷不变，$\sigma$不变

金属与极板间：$E = \frac{\sigma}{\varepsilon_0}$
金属板是导体，内部：$E = 0$
两极板间电势差：$U_{AB} = E d_1 + E d_2 = E(d_1 + d_2) = E \cdot \frac{d}{2} = \frac{d\sigma}{2\varepsilon_0}$

结论：电势差会减小，与金属板放置的位置无关

题8：一空气平行板电容器，电容为$C$，两极板间距离为$d$，充电后，两极板间的相互作用力为$F$，则两极板间的电势差为______，极板上的电荷为______。

解：$C = \frac{\varepsilon_0 S}{d}$，$F = \frac{1}{2} E q$，$E = \frac{2F}{q}$

$$U = \frac{q}{C} = E \cdot d = \frac{2F}{q} \cdot d$$

$$\Rightarrow q = \sqrt{2FCd}$$

$$U = \frac{q}{C} = \frac{\sqrt{2FCd}}{C} = \sqrt{2F d / C}$$

06电介质,电场能

考点概览

考点	重要程度	占分	常见题型
1. 电介质高斯定理	★★★★★★	5~10	大题
2. 电场能	★★★	3~5	选择、填空

1. 电介质高斯定理

基本概念和公式

电介质中的高斯定理：$\oiint \vec{D} \cdot d\vec{S} = \sum q_{内}$，适用：含介质和真空

电位移：$D = \varepsilon_0 \varepsilon_r E$，$\sum q_{内}$为自由电荷代数和

真空中：$\varepsilon_r = 1$，$D = \varepsilon_0 E$

电介质中的场强：$E = E_0 - E' = \frac{E_0}{\varepsilon_r}$

极化电荷面密度：$\sigma' = \left( 1 - \frac{1}{\varepsilon_r} \right) \sigma_0$

例题

题1：在半径为$R_1$的金属球之外包有一层外半径为$R_2$的均匀电介质球壳，介质的相对介电常数为$\varepsilon_r$，金属球带电$Q$，试求：(1) 电介质内外的场强；(2) 电介质内外的电势。

解：

(1) 由电介质高斯定理：$\oiint \vec{D} \cdot d\vec{S} = D \cdot 4\pi r^2 = \sum q_{内} \Rightarrow D = \frac{\sum q_{内}}{4\pi r^2} \Rightarrow E = \frac{D}{\varepsilon_0 \varepsilon_r}$

$r < R_1$时：$\sum q_{内} = 0 \Rightarrow D = 0 \Rightarrow E_1 = 0$
$R_1 < r < R_2$时：$\sum q_{内} = Q \Rightarrow D = \frac{Q}{4\pi r^2} \Rightarrow E_2 = \frac{Q}{4\pi \varepsilon_0 \varepsilon_r r^2}$
$r > R_2$时：$\sum q_{内} = Q \Rightarrow D = \frac{Q}{4\pi r^2} \Rightarrow E_3 = \frac{Q}{4\pi \varepsilon_0 r^2}$

(2) 电势分布：

$r < R_1$时： $$V = \int_{R_1}^{R_2} E_2 dr + \int_{R_2}^{\infty} E_3 dr = \int_{R_1}^{R_2} \frac{Q}{4\pi \varepsilon_0 \varepsilon_r r^2} dr + \int_{R_2}^{\infty} \frac{Q}{4\pi \varepsilon_0 r^2} dr = \frac{Q}{4\pi \varepsilon_0 \varepsilon_r} \left( \frac{1}{R_1} - \frac{1}{R_2} \right) + \frac{Q}{4\pi \varepsilon_0 R_2}$$
$R_1 < r < R_2$时： $$V = \int_{r}^{R_2} E_2 dr + \int_{R_2}^{\infty} E_3 dr = \int_{r}^{R_2} \frac{Q}{4\pi \varepsilon_0 \varepsilon_r r^2} dr + \int_{R_2}^{\infty} \frac{Q}{4\pi \varepsilon_0 r^2} dr = \frac{Q}{4\pi \varepsilon_0 \varepsilon_r} \left( \frac{1}{r} - \frac{1}{R_2} \right) + \frac{Q}{4\pi \varepsilon_0 R_2}$$
$r > R_2$时： $$V = \int_{r}^{\infty} E_3 dr = \int_{r}^{\infty} \frac{Q}{4\pi \varepsilon_0 r^2} dr = \frac{Q}{4\pi \varepsilon_0 r}$$

题2：一圆柱形电容器由半径为$R_1$的导线和与它同轴的导体圆筒构成，圆筒长为$l$，内半径为$R_2$，导线与圆筒间充满相对电容率$\varepsilon_r$的电介质，设沿轴线单位长度上导线的电量为$\lambda$，圆筒的电量为$-\lambda$，略去边缘效应，求：(1) 电介质中电位移$D$，场强$E$；(2) 两极板的电势差。

解：

(1) $\oiint \vec{D} \cdot d\vec{S} = D \cdot 2\pi r h = \sum q_{内} \Rightarrow D = \frac{\sum q_{内}}{2\pi r h} \Rightarrow E = \frac{D}{\varepsilon_0 \varepsilon_r}$

$R_1 < r < R_2$时：$\sum q_{内} = \lambda h$

$$\Rightarrow D = \frac{\lambda h}{2\pi r h} = \frac{\lambda}{2\pi r} \Rightarrow E = \frac{\lambda}{2\pi \varepsilon_0 \varepsilon_r r}$$

(2) 两极板间电势差： $$U_{AB} = \int_{R_1}^{R_2} \vec{E} \cdot d\vec{r} = \int_{R_1}^{R_2} \frac{\lambda}{2\pi \varepsilon_0 \varepsilon_r r} dr = \frac{\lambda}{2\pi \varepsilon_0 \varepsilon_r} \ln \frac{R_2}{R_1}$$

题3：静电场中，作闭合曲面$S$，若有$\oiint_S \vec{D} \cdot d\vec{S} = 0$（式中$\vec{D}$为电位移矢量），则$S$内面必定（）

A. 既无自由电荷，又无束缚电荷

B. 没有自由电荷

C. 自由电荷和束缚电荷的代数和为零

D. 自由电荷的代数和为零

解：由$\oiint \vec{D} \cdot d\vec{S} = \sum q_{内}$，$\sum q_{内} = 0$表示自由电荷代数和为零。选D

2. 电场能

基本概念和公式

电场能密度（单位：$J/m^3$）： $$w_e = \frac{1}{2} D E = \frac{1}{2} \varepsilon_0 \varepsilon_r E^2$$

电场能： $$W = \int_V w_e dV$$

电容器储存的电场能： $$W = \frac{Q^2}{2C} = \frac{1}{2} C (V_1 - V_2)^2 = \frac{1}{2} Q (V_1 - V_2)$$

例题

题1：在相对电容率$\varepsilon_r = 4$的各向同性均匀电介质中，与能量密度$w_e = 2 \times 10^6 J/m^3$相应的电场强度大小$E =$______$N/C$

解：由$w_e = \frac{1}{2} \varepsilon_0 \varepsilon_r E^2$： $$E = \sqrt{\frac{2w_e}{\varepsilon_0 \varepsilon_r}} = \sqrt{\frac{2 \times 2 \times 10^6}{8.85 \times 10^{-12} \times 4}} = 3.36 \times 10^8 N/C$$

题2：一个$3\mu F$的电容被接到$12V$的电源，则储存在电容器中的能量为______

解：$3\mu F = 3 \times 10^{-6}F$ $$W = \frac{1}{2} C (V_1 - V_2)^2 = \frac{1}{2} \times 3 \times 10^{-6} \times 12^2 = 2.16 \times 10^{-4} J$$

题3：有一半径为$R$的带电导体球，带电量为$q$，放在相对电容率为$\varepsilon_r$的无限大均匀介质中，则此系统的电场能量为（）

A. $\frac{q^2}{8\pi \varepsilon_0 \varepsilon_r R}$

B. $\frac{q}{4\pi \varepsilon_0 \varepsilon_r R^2}$

C. $\frac{q}{8\pi \varepsilon_0 \varepsilon_r R^2}$

D. $\frac{q^2}{4\pi \varepsilon_0 \varepsilon_r R^2}$

解：$C = 4\pi \varepsilon_0 \varepsilon_r R$ $$W = \frac{Q^2}{2C} = \frac{q^2}{2 \times 4\pi \varepsilon_0 \varepsilon_r R} = \frac{q^2}{8\pi \varepsilon_0 \varepsilon_r R}$$

选A

07磁感应强度

考点概览

考点	重要程度	占分	常见题型
1. 毕奥-萨伐尔定律	★★★★	3~5	选择、填空
2. 安培环路定理	必考	5~10	大题

1. 毕奥-萨伐尔定律

基本概念

毕奥-萨伐尔定律（毕萨定理）：描述电流元在空间产生的磁感应强度

$$dB = \frac{\mu_0}{4\pi} \cdot \frac{Idl \cdot \sin\theta}{r^2}$$

$$B = \int dB = \frac{\mu_0}{4\pi} \int \frac{Idl \sin\theta}{r^2}$$

单位：$T$（特斯拉）

真空中磁导率：$\mu_0 = 4\pi \times 10^{-7} T \cdot m/A$

磁场线图示

直线电流：同心圆磁场线
环形电流：类似条形磁铁的磁场线
螺线管：内部匀强磁场

符号约定：

$\otimes$：垂直纸面向内
$\odot$：垂直纸面向外

毕奥-萨伐尔定律基本公式

例题：载流直导线

题1：在长为$L$的一段载流直导线中，通有电流$I$，求距离导线为$a$处一点$P$的磁感应强度。

解：任取一电流元$Idl$

$$dB = \frac{\mu_0}{4\pi} \cdot \frac{Idl \sin\theta}{r^2}$$

$$B = \int dB = \frac{\mu_0}{4\pi} \int \frac{Idl \sin\theta}{r^2}$$

通过变量替换：$r = \frac{a}{\sin\theta}$，$dl = a \csc^2\theta d\theta$

$$B = \frac{\mu_0 I}{4\pi a} \int_{\theta_1}^{\theta_2} \sin\theta d\theta = \frac{\mu_0 I}{4\pi a} (\cos\theta_1 - \cos\theta_2)$$

方向垂直纸面向里

常见结论汇总

电流类型	磁感应强度公式
有限长直导线	$B = \frac{\mu_0 I}{4\pi a} (\cos\theta_1 - \cos\theta_2)$
无限长直导线	$B = \frac{\mu_0 I}{2\pi a}$
半无限长直导线	$B = \frac{\mu_0 I}{4\pi a}$
无限大电流平面	$B = \frac{1}{2} \mu_0 \alpha$
圆弧（圆心角$\varphi$）	$B = \frac{\mu_0 I}{4\pi R} \varphi$
圆电流（圆心处）	$B = \frac{\mu_0 I}{2R}$
螺绕环	$B = \mu_0 nI = \frac{\mu_0 NI}{2\pi R}$
长直螺线管	$B = \mu_0 nI = \frac{\mu_0 NI}{L}$

例题

题2：真空中，一根无限长的直导线，通过的电流强度为$I$，在距离导线$r$处的磁感应强度为（）

A. $\frac{\mu_0 I}{r}$ B. $\frac{\mu_0 I}{2r}$ C. $\frac{\mu_0 I}{2\pi r}$ D. $\frac{\mu_0 I}{4\pi r}$

解：选C，$B = \frac{\mu_0 I}{2\pi r}$

题3：真空中一根无限长导线弯成如图形状，设各线段都在同一平面内（纸面内），水平部分的延长线经过圆心$O$，竖直向下的导线垂直于水平方向。导线中通有电流$I$，求图中$O$处的磁感应强度的大小和方向。

解：

$AB$段和$CD$段过$O$点，在$O$点不产生磁场
$\overset{\frown}{BC}$段：$B_1 = \frac{\mu_0 I}{2R_1} \cdot \frac{1}{2} = \frac{\mu_0 I}{4R_1}$，朝内
$DE$段：$B_2 = \frac{\mu_0 I}{4\pi \cdot \sqrt{2}R_2/2} (\cos\frac{\pi}{4} - \cos\frac{3\pi}{4}) = \frac{\mu_0 I}{2\pi R_2}$，朝外
$\overset{\frown}{EF}$段：$B_3 = \frac{\mu_0 I}{2R_2} \cdot \frac{1}{4} = \frac{\mu_0 I}{8R_2}$，朝外
$FG$段：$B_4 = \frac{\mu_0 I}{2\pi R_2} \cdot \frac{1}{2} = \frac{\mu_0 I}{4\pi R_2}$，朝外

$$B = B_2 + B_3 + B_4 - B_1 = \frac{3\mu_0 I}{4\pi R_2} + \frac{\mu_0 I}{8R_2} - \frac{\mu_0 I}{4R_1}$$

方向朝外

题4：如图所示，一无限长薄电流板均匀通有电流$I$，电流板宽为$a$，求在电流板同一平面内距板边为$a$的$P$点处的磁感应强度。

解：电流板上取窄条$dx$

窄条的电流：$dI = \frac{I}{a} \cdot dx$

$dI$在$P$点处产生的磁感应强度： $$dB = \frac{\mu_0 dI}{2\pi (2a - x)} = \frac{\mu_0 I}{2\pi a (2a - x)} dx$$

$$B = \int dB = \int_0^a \frac{\mu_0 I}{2\pi a (2a - x)} dx = \frac{\mu_0 I}{2\pi a} \ln 2$$

方向垂直纸面向里

2. 安培环路定理

基本概念和公式

安培环路定理： $$\oint \vec{B} \cdot d\vec{l} = \mu_0 \sum I_{内}$$

关键要点：

(1) 安培环路定理只与环路内电流有关，与电流位置以及环路外电流无关

(2) $\sum I_{内}$是指环路内的净电流（所有电流的代数和）

(3) 环路上的磁感应强度$B$，不仅由环路内电流影响，还由环路外电流影响

例题

题1：已知半径为$R$的铜线，通过电流为$I$，电流在导线横截面上均匀分布，求导线内外磁感应强度的分布？

解：由$\oint \vec{B} \cdot d\vec{l} = B \cdot \oint dl = B \cdot 2\pi r = \mu_0 \sum I_{内} \Rightarrow B = \frac{\mu_0 \sum I_{内}}{2\pi r}$

$r < R$时：$\sum I_{内} = \frac{I}{\pi R^2} \cdot \pi r^2 = \frac{Ir^2}{R^2}$

$$B = \frac{\mu_0 Ir}{2\pi R^2}$$

$r > R$时：$\sum I_{内} = I$

$$B = \frac{\mu_0 I}{2\pi r}$$

方向沿逆时针方向

题2：如图所示的空心柱形导体半径分别为$R_1$和$R_2$，导体内载流有电流$I$，设电流$I$均匀分布在导线的横截面上，求导体内部各点（$R_1 < r < R_2$）的磁感应强度$B$。

解：由$\oint \vec{B} \cdot d\vec{l} = B \cdot 2\pi r = \mu_0 \sum I_{内} \Rightarrow B = \frac{\mu_0 \sum I_{内}}{2\pi r}$

$$\sum I_{内} = \frac{I}{\pi (R_2^2 - R_1^2)} \cdot \pi (r^2 - R_1^2) = \frac{I (r^2 - R_1^2)}{R_2^2 - R_1^2}$$

$$\Rightarrow B = \frac{\mu_0 I (r^2 - R_1^2)}{2\pi r (R_2^2 - R_1^2)}$$

方向逆时针

题3：如图所示，垂直流出纸面的电流为$2I$，垂直流进纸面的电流为$I$，两电流均为稳恒电流，则环路积分正确的是（）

A. $\oint_L \vec{B} \cdot d\vec{l} = 2\mu_0 I$ B. $\oint_L \vec{B} \cdot d\vec{l} = 3\mu_0 I$

C. $\oint_L \vec{B} \cdot d\vec{l} = \mu_0 I$ D. $\oint_L \vec{B} \cdot d\vec{l} = -\mu_0 I$

解：垂直纸面向里为正，$\sum I_{内} = I - 2I = -I$

$$\oint_L \vec{B} \cdot d\vec{l} = \mu_0 \sum I_{内} = -\mu_0 I$$

选D

题4：取一闭合积分回路$L$，使三根载流导线穿过它所围成的面，现改变三根导线之间的相互间隔，但不越出积分回路，则（）

A. 回路$L$内的$I$改变，$L$上各点的$\vec{B}$改变

B. 回路$L$内的$I$改变，$L$上各点的$\vec{B}$不变

C. 回路$L$内的$I$不变，$L$上各点的$\vec{B}$改变

D. 回路$L$内的$I$不变，$L$上各点的$\vec{B}$不变

解：回路$L$内的净电流$I$不变（三根导线都在回路内），但各电流位置变化会导致环路上各点的$\vec{B}$改变。选C

题5：下列说法中正确的是（）

A. 闭合回路上各点磁感应强度都为零时，回路内穿过电流的代数和必为零

B. 闭合回路上各点磁感应强度都为零时，回路内一定没有电流通过

C. 磁感应强度沿闭合回路积分不为零时，回路上任意一点的磁感应强度都不可能为零

D. 磁感应强度沿闭合回路积分为零时，回路上各点的磁感应强度必为零

解：由$\oint \vec{B} \cdot d\vec{l} = \mu_0 \sum I_{内} = 0 \Rightarrow \sum I_{内} = 0$，但回路外电流仍会产生磁场。选A

题6：如图，在一圆形电流$I$所在的平面内，选取一个同心圆形闭合回路$L$，则由安培环路定理可知（）

A. $\oint_L \vec{B} \cdot d\vec{l} = 0$，且环路上任意一点$B = 0$

B. $\oint_L \vec{B} \cdot d\vec{l} = 0$，且环路上任意一点$B \neq 0$

C. $\oint_L \vec{B} \cdot d\vec{l} \neq 0$，且环路上任意一点$B \neq 0$

D. $\oint_L \vec{B} \cdot d\vec{l} \neq 0$，且环路上任意一点$B =$常量

解：回路$L$内没有电流，$\sum I_{内} = 0$，所以$\oint_L \vec{B} \cdot d\vec{l} = 0$；但圆形电流在回路$L$上各点会产生磁场，$B \neq 0$。选B

08磁通量,高斯定理

考点概览

考点	重要程度	占分	常见题型
1. 磁通量、高斯定理	必考	5~10	大题

1. 磁通量、高斯定理

基本概念和公式

磁通量：$\Phi_m = B \cdot S$，单位：$Wb$（韦伯）

三种情况：

(1) 平面垂直磁场：$\Phi_m = B \cdot S$

(2) 平面与磁场成$\theta$角：$\Phi_m = B \cdot S \cdot \cos\theta$

(3) 曲面：$d\Phi_m = \vec{B} \cdot d\vec{S}$，$\Phi_m = \int d\Phi_m = \iint \vec{B} \cdot d\vec{S}$

关键要点：

(1) $B$和$S$必须是垂直关系

(2) 对于曲面，向外穿出为正，向内穿入为负

(3) 磁场中高斯定理：$\Phi_m = \oiint \vec{B} \cdot d\vec{S} = 0$，沿闭合曲面积分为零：穿进等于穿出

例题

题1：如图所示，在磁感应强度为$\vec{B}$的均匀磁场中作一半径为$r$的半球面$S$，则通过半球面$S$的磁通量为（）

A. $2\pi r^2 B$ B. $-\pi r^2 B$ C. $-2\pi r B$ D. $\pi r^2 B$

解：$\Phi_m = -B \cdot S = -B \cdot \pi r^2$，选B

题2：在稳恒磁场中，穿过任一闭合曲面的总磁通量必然为______

解：$0$（磁场高斯定理）

题3：一个密绕细长螺线管，每米长度上绕有1000匝细导线，螺线管的横截面积为$0.001m^2$。当在螺线管中通入10A的电流时，它的横截面上的磁通量为______$Wb$（$\mu_0 = 4\pi \times 10^{-7} T \cdot m/A$）

解： $$B = \mu_0 nI = 4\pi \times 10^{-7} \times 1000 \times 10 = 1.256 \times 10^{-2} T$$

$$\Phi_m = B \cdot S = 1.256 \times 10^{-2} \times 0.001 = 1.256 \times 10^{-5} Wb$$

题4：如图，一无限长直导线通以电流$I$，若有一矩形导体线框与直导线共面且距导线为$a$，试求通过矩形导体线框的磁通量。

解：矩形线框中取窄条宽为$dx$，$dS = l \cdot dx$

载流直导线在$x$处产生的磁感应强度：$B = \frac{\mu_0 I}{2\pi x}$

$$d\Phi_m = B \cdot dS = B \cdot l \cdot dx = \frac{\mu_0 I l}{2\pi x} dx$$

$$\Phi_m = \int d\Phi_m = \int_{a}^{a+b} \frac{\mu_0 I l}{2\pi x} dx = \frac{\mu_0 I l}{2\pi} \ln \frac{a+b}{a}$$

题5：磁场中的高斯定理为$\oiint \vec{B} \cdot d\vec{S} = 0$，它表明磁场是（）

A. 非保守力 B. 保守力 C. 无源场 D. 有源场

解：选C

电场与磁场的对比

定理	电场	磁场
高斯定理	$\Phi_e = \oiint \vec{E} \cdot d\vec{S} = \frac{1}{\varepsilon_0} \sum q_{内}$	$\Phi_m = \oiint \vec{B} \cdot d\vec{S} = 0$
性质	有源场	无源场
环路定理	$\oint \vec{E} \cdot d\vec{l} = 0$	$\oint \vec{B} \cdot d\vec{l} = \mu_0 \sum I_{内}$
性质	无旋场，保守场	有旋场

09安培力,磁力矩,洛伦兹力

考点概览

考点	重要程度	占分	常见题型
1. 安培力	★★★	0~5	选择、填空
2. 磁矩、磁力矩	★★★★★★	2~5	选择、填空、大题
3. 洛伦兹力	★★	0~3	选择、填空

1. 安培力

基本概念和公式

安培力：$F = B \cdot I \cdot L$，条件：$B \perp I \perp L$

一般情况：$F = B \cdot I \cdot L \cdot \sin\alpha$（$\alpha$为电流方向与磁场方向夹角）

电流元受力：$dF = BIdl$，$F = \int dF$

右手定则：掌心向里，四指指向电流方向，大拇指指向受力方向

例题

题1：如图所示，一根长直导线载有电流$I_1$，矩形回路载有电流$I_2$，两者共面，试计算：作用在回路各边上的安培力以及线圈所受合外力。

解：

$AB$段：$F_1 = B \cdot I \cdot L = \frac{\mu_0 I_1}{2\pi a} \cdot I_2 \cdot l = \frac{\mu_0 I_1 I_2 l}{2\pi a}$，朝左
$BC$段：$dF = B \cdot I \cdot dx = \frac{\mu_0 I_1}{2\pi x} I_2 dx$，$F_2 = \int dF = \frac{\mu_0 I_1 I_2}{2\pi} \ln \frac{a+b}{a}$，朝上
$CD$段：$F_3 = B \cdot I \cdot L = \frac{\mu_0 I_1}{2\pi (a+b)} \cdot I_2 \cdot l = \frac{\mu_0 I_1 I_2 l}{2\pi (a+b)}$，朝右
$DA$段：$F_4 = F_2 = \frac{\mu_0 I_1 I_2}{2\pi} \ln \frac{a+b}{a}$，朝下

合力：$F = F_1 - F_3 = \frac{\mu_0 I_1 I_2 l}{2\pi} \left( \frac{1}{a} - \frac{1}{a+b} \right)$

题2：图示表示一段半圆形导线，通有电流$I$，圆的半径为$R$，放在均匀磁场$B$中，磁场与导线平面垂直，求磁场作用在半圆形导线上的安培力$F =$______。

解：$F = B \cdot I \cdot L = B \cdot I \cdot 2R = 2BIR$

结论：任意形状的载流导线在均匀磁场中所受安培力等于连接导线两端的直导线所受的安培力

2. 磁矩、磁力矩

基本概念和公式

磁矩：$p_m = I \cdot S$，单位：$A \cdot m^2$

磁力矩：$M = B p_m \sin\theta$（$\theta$为$B$和$p_m$夹角）

特殊情况：

$\theta = \frac{\pi}{2}$时，磁力矩最大：$M_{max} = BIS$
$\theta = 0$时，磁力矩最小：$M_{min} = 0$

磁力矩做功：$A = I \Delta \Phi_m$

例题

题1：一半径为$R = 0.10m$的圆形闭合线圈，通有稳恒电流$I = 10A$，则此线圈磁矩$p_m$的大小是______

解：$p_m = I \cdot S = I \cdot \pi R^2 = 10 \times 3.14 \times 0.1^2 = 0.314 A \cdot m^2$

题2：一正方形线圈，由细导线做成，边长为$a$，共有$N$匝，可以绕通过其相对两边中点的一个竖直轴自由转动，现在线圈中通有电流$I$，并把线圈放在均匀的水平外磁场$\vec{B}$中，求线圈磁矩与磁场$\vec{B}$的夹角为$\theta$时，线圈受到的转动力矩为______

解：单匝磁矩：$p_m = I \cdot S = Ia^2$

单匝磁力矩：$M = B p_m \sin\theta = BIa^2 \sin\theta$

总磁力矩：$M_{总} = NM = NBIa^2 \sin\theta$

题3：如图所示，半径为$R$的半圆形载流线圈在均匀磁场$\vec{B}$中所受的磁力矩大小______

解：$\theta = \pi$，$M = B p_m \sin\pi = 0$

题4：一半圆形闭合线圈半径$R = 0.1m$，通过电流$I = 10A$，放在均匀磁场中，磁场方向与线圈平面平行，$B = 0.5T$

(1) 求线圈所受力矩的大小

(2) 若此线圈受力矩的作用转到线圈平面与磁场垂直的位置，则力矩做功多少？

解：

(1) 磁矩：$p_m = I \cdot S = I \cdot \frac{1}{2}\pi R^2 = 10 \times \frac{1}{2}\pi \times 0.1^2 = 0.157 A \cdot m^2$

磁力矩：$M = B p_m \sin\frac{\pi}{2} = 0.5 \times 0.157 \times 1 = 7.85 \times 10^{-2} N \cdot m$

(2) 磁通量该变量：$\Delta \Phi_m = BS - 0 = BS$

磁力矩做功：$A = I \Delta \Phi_m = IBS = 10 \times 0.5 \times \frac{1}{2}\pi \times 0.1^2 = 7.84 \times 10^{-2} J$

3. 洛伦兹力

基本概念和公式

洛伦兹力：$F = Bqv$（$v \perp B$）

圆周运动半径：$F = Bqv = m \frac{v^2}{R} \Rightarrow R = \frac{mv}{Bq}$

周期：$T = 2\pi \frac{m}{Bq}$

洛伦兹力不做功（力始终与速度垂直）

例题

题1：

一带电粒子平行磁感线射入匀强磁场，则它作匀速直线运动
一带电粒子垂直磁感线射入匀强磁场，则它作匀速圆周运动
一带电粒子与磁感线成任意角射入匀强磁场，则它作螺旋运动

题2：图为四个带电粒子在$O$点沿相同方向垂直于磁感线射入均匀磁场后的偏转轨迹的照片。磁场方向垂直纸面向外，轨迹所对应的四个粒子的质量相等，电荷大小也相等，则其中动能最大的带负电的粒子的轨迹是（）

A. $Oa$ B. $Ob$ C. $Oc$ D. $Od$

解：$E_k = \frac{1}{2}mv^2$，$R = \frac{mv}{Bq}$，$R$越大则$v$越大，$E_k$越大。负电荷受力方向与正电荷相反，选C

10磁介质,磁场能

考点概览

考点	重要程度	占分	常见题型
1. 磁介质中安培环路定理	★★★★★	5~10	大题
2. 磁场能量	★★	2~3	选择、填空

1. 磁介质中安培环路定理

基本概念和公式

磁介质中安培环路定理：$\oint \vec{H} \cdot d\vec{l} = \sum I_{内}$，适用介质和真空

真空中安培环路定理：$\oint \vec{B} \cdot d\vec{l} = \mu_0 \sum I_{内}$

磁场强度：$H = \frac{B}{\mu_0 \mu_r} = \frac{B}{\mu}$

磁感应强度与磁场强度关系：$B = \mu_0 \mu_r H = \mu H$

磁导率：

$\mu$：磁导率
$\mu_0$：真空中磁导率
$\mu_r$：相对磁导率，$\mu_r = \frac{B}{B_0}$

三种磁介质：

顺磁质：$\mu_r > 1$
抗磁质：$\mu_r < 1$
铁磁质：$\mu_r \gg 1$

真空中相对磁导率：$\mu_r = 1$，$H = \frac{B}{\mu_0}$

例题

题1：长直圆柱形铜导线，外面包一层相对磁导率为$\mu_r$的圆筒形磁介质。导线半径为$R_1$，磁介质的半径为$R_2$，导线内有均匀分布的电流$I$通过，铜的相对磁导率可取1，求导线和介质内外的磁场强度$H$和磁感应强度$B$的分布。

解：由$\oint \vec{H} \cdot d\vec{l} = H \cdot 2\pi r = \sum I_{内} \Rightarrow H = \frac{\sum I_{内}}{2\pi r}$，$B = \mu_0 \mu_r H$

$r < R_1$时（导线内部，$\mu_r = 1$）： $$\sum I_{内} = \frac{I}{\pi R_1^2} \cdot \pi r^2 = \frac{Ir^2}{R_1^2}$$ $$H = \frac{Ir}{2\pi R_1^2}$$ $$B = \frac{\mu_0 Ir}{2\pi R_1^2}$$
$R_1 < r < R_2$时（磁介质内部）： $$\sum I_{内} = I$$ $$H = \frac{I}{2\pi r}$$ $$B = \frac{\mu_0 \mu_r I}{2\pi r}$$
$r > R_2$时（介质外部，真空）： $$\sum I_{内} = I$$ $$H = \frac{I}{2\pi r}$$ $$B = \frac{\mu_0 I}{2\pi r}$$

题2：磁介质有三种，用相对磁导率$\mu_r$表征它们的各自特性是（）

A. 顺磁质$\mu_r > 0$，抗磁质$\mu_r < 0$，铁磁质$\mu_r \gg 1$

B. 顺磁质$\mu_r > 1$，抗磁质$\mu_r = 1$，铁磁质$\mu_r \gg 1$

C. 顺磁质$\mu_r > 1$，抗磁质$\mu_r < 1$，铁磁质$\mu_r \gg 1$

D. 顺磁质$\mu_r > 0$，抗磁质$\mu_r < 0$，铁磁质$\mu_r > 1$

解：选C

2. 磁场能量

基本概念和公式

磁能密度：$w_m = \frac{1}{2} \frac{B^2}{\mu_0}$

磁场能：$W_m = \int_V w_m dV$

例题

题1：真空中一长直密绕螺线管通以电流$I$，管上单位长度绕$n$匝导线，内部的磁能密度为$w_m =$______

解：$B = \mu_0 nI$ $$w_m = \frac{1}{2} \frac{B^2}{\mu_0} = \frac{\mu_0 n^2 I^2}{2}$$

题2：真空中一根无限长直细导线上通电流$I$，则距导线垂直距离为$a$的空间某点处的磁能密度为（）

A. $\frac{1}{2} \mu_0 \left( \frac{\mu_0 I}{2\pi a} \right)^2$

B. $\frac{1}{2\mu_0} \left( \frac{\mu_0 I}{2\pi a} \right)^2$

C. $\frac{1}{2} \left( \frac{2\pi a}{\mu_0 I} \right)^2$

D. $\frac{1}{2\mu_0} \left( \frac{\mu_0 I}{2a} \right)^2$

解：$B = \frac{\mu_0 I}{2\pi a}$ $$w_m = \frac{1}{2} \frac{B^2}{\mu_0} = \frac{1}{2\mu_0} \left( \frac{\mu_0 I}{2\pi a} \right)^2$$

选B

11电磁感应

（待整理：2.11电磁感应文件夹）

12自感和互感（选学）

考点概览

考点	重要程度	占分	常见题型
1. 自感和互感	★★	0~3	选择、填空
2. 麦克斯韦方程组	★★★★★★	2~5	选择、填空

提示：查看自己往年试卷，看下是否考察这部分内容

1. 自感与互感

基本概念和公式

自感：

自感系数：$L = \frac{\Phi}{I}$
自感电动势：$\varepsilon = L \frac{dI}{dt}$

互感：

互感系数：$M = \frac{\Phi_2}{I_1} = \frac{\Phi_1}{I_2}$

例题

题1：一无铁芯的长直螺线管，在保持其半径和总匝数不变的情况下，把螺线管拉长一些，则它的自感系数将（）

A. 增大 B. 减小 C. 不变 D. 不能确定

解：长直螺线管内的磁感应强度：$B = \mu_0 nI = \mu_0 \frac{N}{l} I$

磁通量：$\Phi = NBS = N \cdot \mu_0 \frac{N}{l} I \cdot \pi R^2 = \frac{\mu_0 N^2 I}{l} \pi R^2$

自感系数：$L = \frac{\Phi}{I} = \frac{\mu_0 N^2}{l} \pi R^2$

拉长后$l$增大，$L$减小。选B

题2：一自感线圈中，电流强度在0.002s内均匀地由10A增加到12A，此过程中线圈内自感电动势为400V，则线圈的自感系数为$L =$______$H$

解：由$\varepsilon = L \frac{dI}{dt}$： $$400 = L \cdot \frac{12 - 10}{0.002} \Rightarrow L = 0.4 H$$

题3：一边长为$a$的正方形线圈放在一根长直导线旁，线圈与直导线共面。其中线圈的中心距长直导线为$\frac{3a}{2}$，线圈的一组对边与直导线平行。此时，正方形线圈与直导线的互感系数为（）

A. $\frac{\mu_0 a}{\pi} \ln 2$ B. $\frac{\mu_0 a}{2\pi} \ln 2$ C. $\frac{\mu_0}{2\pi} \ln 2$ D. $\frac{\mu_0}{\pi} \ln 2$

解：在$x$处取窄条，宽为$dx$

$$d\Phi = B \cdot dS = \frac{\mu_0 I}{2\pi x} \cdot adx = \frac{\mu_0 I a}{2\pi x} dx$$

$$\Phi = \int d\Phi = \int_{a}^{2a} \frac{\mu_0 I a}{2\pi x} dx = \frac{\mu_0 I a}{2\pi} \ln 2$$

$$M = \frac{\Phi_2}{I_1} = \frac{\frac{\mu_0 I a}{2\pi} \ln 2}{I} = \frac{\mu_0 a}{2\pi} \ln 2$$

选B

2. 麦克斯韦方程组

基本概念和公式

1. 电场高斯定理 — 电场是有源场，电荷总伴随着电场 $$\oiint \vec{D} \cdot d\vec{S} = \sum q = \int_V \rho dV$$

2. 磁场高斯定理 — 磁场是无源场，磁力线闭合 $$\oiint \vec{B} \cdot d\vec{S} = 0$$

3. 变化的电场产生磁场（全电流安培环路定理） $$\oint \vec{H} \cdot d\vec{l} = I + I_d = \iint_S \vec{j} \cdot d\vec{S} + \iint_S \frac{\partial \vec{D}}{\partial t} \cdot d\vec{S}$$

4. 变化的磁场一定伴随着电场 $$\oint \vec{E} \cdot d\vec{l} = -\frac{d\Phi}{dt} = -\iint_S \frac{\partial \vec{B}}{\partial t} \cdot d\vec{S}$$

例题

题1：反应电磁场基本性质和规律的积分形式的麦克斯韦方程为：

A. $\oiint_S \vec{D} \cdot d\vec{S} = \int_V \rho dV$

B. $\oint_l \vec{E} \cdot d\vec{l} = -\iint_S \frac{\partial \vec{B}}{\partial t} \cdot d\vec{S}$

C. $\oiint_S \vec{B} \cdot d\vec{S} = 0$

D. $\oint_l \vec{H} \cdot d\vec{l} = \iint_S \left( \vec{j} + \frac{\partial \vec{D}}{\partial t} \right) d\vec{S}$

试判断下列结论是包含于或等效于哪一个麦克斯韦方程式：

(1) 变化的磁场一定伴随有电场：B

(2) 变化的电场产生磁场：D

(3) 磁场是无源场，磁力线闭合：C

(4) 电荷总伴随着电场：A

大物B1公式要点速览

Mon, 22 Jun 2026 00:00:00 GMT

大学物理B1公式要点速览

01质点运动学（一）

公式名称	公式	备注
位矢	$\vec{r} = x\vec{i} + y\vec{j}$	位置矢量
位移	$\Delta\vec{r} = \vec{r}_B - \vec{r}_A$	矢量差
平均速度	$\vec{\bar{v}} = \frac{\Delta\vec{r}}{\Delta t}$	位移与时间比值
瞬时速度	$\vec{v} = \frac{d\vec{r}}{dt} = \frac{dx}{dt}\vec{i} + \frac{dy}{dt}\vec{j}$	位矢对时间求导
速度大小	$\|\vec{v}\| = \frac{ds}{dt} = \sqrt{\left(\frac{dx}{dt}\right)^2 + \left(\frac{dy}{dt}\right)^2}$	速率
加速度	$\vec{a} = \frac{d\vec{v}}{dt} = \frac{dv}{dt}\vec{\tau} + \frac{v^2}{R}\vec{n}$	速度对时间求导
切向加速度	$a_t = \frac{dv}{dt}$	改变速度大小
法向加速度	$a_n = \frac{v^2}{R}$	改变速度方向
加速度大小	$\|\vec{a}\| = \sqrt{\left(\frac{dv}{dt}\right)^2 + \left(\frac{v^2}{R}\right)^2}$	总加速度大小
相对速度	$\vec{v}{绝对} = \vec{v}{牵连} + \vec{v}_{相对}$	相对运动关系
相对加速度	$\vec{a}{绝对} = \vec{a}{牵连} + \vec{a}_{相对}$	相对加速度关系
匀变速直线运动（速度）	$v = v_0 + at$	速度公式
匀变速直线运动（位移）	$x = x_0 + v_0t + \frac{1}{2}at^2$	位移公式
匀变速直线运动（速度位移）	$v_2^2 - v_1^2 = 2a(x_2 - x_1)$	速度位移关系

02质点运动学（二）

公式名称	公式	备注
角位移	$\theta$	单位：rad
角速度	$\omega = \frac{d\theta}{dt}$	角位置对时间求导
角加速度	$\beta = \frac{d\omega}{dt} = \frac{d^2\theta}{dt^2}$	角速度对时间求导
周期	$T = \frac{2\pi}{\omega}$	转动一周时间
线速度与角速度	$v = \omega R$	角量与线量关系
切向加速度与角加速度	$a_t = \beta R$	角量与线量关系
法向加速度与角速度	$a_n = \omega^2 R = \frac{v^2}{R}$	角量与线量关系
匀变速圆周运动（角速度）	$\omega = \omega_0 + \beta t$	角速度公式
匀变速圆周运动（角位移）	$\theta = \theta_0 + \omega_0t + \frac{1}{2}\beta t^2$	角位移公式
匀变速圆周运动（角速度角位移）	$\omega_2^2 - \omega_1^2 = 2\beta(\theta_2 - \theta_1)$	角速度角位移关系

03常见力和牛顿三定律

公式名称	公式	备注
重力	$G = mg$	$g = 9.8N/kg$
弹力（胡克定律）	$F = kx$	$k$为弹性系数
滑动摩擦力	$f = \mu_k N$	$\mu_k$为滑动摩擦系数
最大静摩擦力	$f_{max} = \mu_s N$	$\mu_s$为静摩擦系数
万有引力	$F = G\frac{Mm}{r^2}$	$G = 6.67 \times 10^{-11} N \cdot m^2/kg^2$
牛顿第二定律	$\vec{F} = m\vec{a}$	力是产生加速度的原因

04动量,冲量,动量守恒

公式名称	公式	备注
动量	$\vec{p} = m\vec{v}$	单位：$kg \cdot m/s$
动量定理	$\vec{I} = m\vec{v}_2 - m\vec{v}1 = \int{t_1}^{t_2} \vec{F}dt$	冲量等于动量变化
常力冲量	$\vec{I} = \vec{F} \cdot \Delta t$	力为常量时
动量守恒定律	$\sum m_i \vec{v}{i1} = \sum m_i \vec{v}{i2}$	条件：合外力为零

05质点运动的功和能

公式名称	公式	备注
元功	$dA = \vec{F} \cdot d\vec{r}$	力与位移点积
功	$A = \int \vec{F} \cdot d\vec{r}$	元功积分
一维变力做功	$A = \int_{x_1}^{x_2} F dx$	$F = f(x)$时
恒力做功	$A = \vec{F} \cdot \vec{r} = F_x x + F_y y + F_z z$	力为常量时
动能	$E_k = \frac{1}{2}mv^2$	动能定义
动能定理	$A = E_{k2} - E_{k1} = \frac{1}{2}mv_2^2 - \frac{1}{2}mv_1^2$	合外力做功等于动能增量
重力势能	$E_p = mgh$	零势能点：地面
弹性势能	$E_p = \frac{1}{2}kx^2$	零势能点：平衡位置
万有引力势能	$E_p = -G\frac{Mm}{r}$	零势能点：无穷远
静电力势能	$E_p = \frac{1}{4\pi\varepsilon_0}\frac{q_1q_2}{r}$	零势能点：无穷远
机械能	$E = E_k + E_p$	动能+势能
机械能守恒	$E_{k1} + E_{p1} = E_{k2} + E_{p2}$	条件：只有保守力做功

06电场强度

公式名称	公式	备注
库仑定律	$F = \frac{1}{4\pi\varepsilon_0} \cdot \frac{q \cdot q_0}{r^2}$	点电荷间作用力
真空介电常量	$\varepsilon_0 = 8.85 \times 10^{-12}\ C^2/(N \cdot m^2)$	常量
电场强度定义	$\vec{E} = \frac{\vec{F}}{q_0} = \frac{1}{4\pi\varepsilon_0} \cdot \frac{q}{r^2}$	单位正电荷受力
点电荷场强	$E = \frac{1}{4\pi\varepsilon_0} \cdot \frac{q}{r^2}$	球对称分布
无限长均匀带电直线场强	$E = \frac{\lambda}{2\pi\varepsilon_0 r}$	$\lambda$为线密度
无限大均匀带电平面场强	$E = \frac{\sigma}{2\varepsilon_0}$	$\sigma$为面密度，与距离无关
均匀带电圆柱面场强	$E = 0$（$r < R$）；$E = \frac{\lambda}{2\pi\varepsilon_0 r}$（$r > R$）	高斯定理推导
均匀带电球体场强	$E = \frac{qr}{4\pi\varepsilon_0 R^3}$（$r < R$）；$E = \frac{q}{4\pi\varepsilon_0 r^2}$（$r > R$）	高斯定理推导
连续带电体场强	$dE = \frac{1}{4\pi\varepsilon_0} \cdot \frac{dq}{r^2}$，$E = \int dE$	积分求解

07电通量,高斯定理

公式名称	公式	备注
电通量（平面垂直）	$\Phi_e = E \cdot S$	$E$与$S$垂直
电通量（平面倾斜）	$\Phi_e = E \cdot S \cdot \cos\theta$	$\theta$为$E$与$S$夹角
电通量（曲面）	$d\Phi_e = \vec{E} \cdot d\vec{S}$，$\Phi_e = \iint \vec{E} \cdot d\vec{S}$	积分求解
高斯定理	$\Phi_e = \oiint \vec{E} \cdot d\vec{S} = \frac{1}{\varepsilon_0} \sum q_{内}$	闭合曲面电通量

08电势,电势能

公式名称	公式	备注
电势定义	$V = \frac{W_M}{q_0} = \int_{r}^{\infty} \vec{E} \cdot d\vec{l}$	单位正电荷电势能
点电荷电势	$V = \frac{q}{4\pi \varepsilon_0 r}$	离散型
连续带电体电势	$dV = \frac{dq}{4\pi \varepsilon_0 r}$，$V = \int \frac{dq}{4\pi \varepsilon_0 r}$	连续型
已知场强求电势	$V = \int_{起点}^{\infty} \vec{E} \cdot d\vec{l}$	场强积分法
电势差	$U_{AB} = V_A - V_B = \int_{A}^{B} \vec{E} \cdot d\vec{l}$	两点电势差
电势能	$W_M = q_0 V$	电荷与电势乘积
电场力做功与电势能	$A = -(W_2 - W_1)$	电场力做正功，势能减小
场强与电势关系	$\vec{E} = -\left( \frac{\partial V}{\partial x}, \frac{\partial V}{\partial y}, \frac{\partial V}{\partial z} \right)$	电势梯度负值

09导体

公式名称	公式	备注
导体内部场强	$E = 0$	静电平衡条件
导体表面场强	$E = \frac{\sigma}{\varepsilon_0}$	$\sigma$为表面电荷密度
均匀带电无限大平面导体场强	$E = \frac{\sigma}{\varepsilon_0}$	导体表面
均匀带电无限大平面场强	$E = \frac{\sigma}{2\varepsilon_0}$	带电平面两侧

10电容器

公式名称	公式	备注
电容定义	$C = \frac{q}{U}$	单位：F（法拉）
平行板电容器（真空）	$C = \frac{\varepsilon_0 S}{d}$	$S$为极板面积，$d$为间距
平行板电容器（介质）	$C = \frac{\varepsilon_0 \varepsilon_r S}{d}$	$\varepsilon_r$为相对介电常数
圆柱形电容器（真空）	$C = \frac{2\pi \varepsilon_0 l}{\ln R_B / R_A}$	$l$为长度
圆柱形电容器（介质）	$C = \frac{2\pi \varepsilon_0 \varepsilon_r l}{\ln R_B / R_A}$	含介质
球形电容器（真空）	$C = 4\pi \varepsilon_0 \frac{R_A R_B}{R_B - R_A}$	同心球壳
球形电容器（介质）	$C = 4\pi \varepsilon_0 \varepsilon_r \frac{R_A R_B}{R_B - R_A}$	含介质
孤立导体球电容（真空）	$C = 4\pi \varepsilon_0 R$	单个导体球
孤立导体球电容（介质）	$C = 4\pi \varepsilon_0 \varepsilon_r R$	含介质
电容器串联	$\frac{1}{C} = \frac{1}{C_1} + \frac{1}{C_2}$	等效电容
电容器并联	$C = C_1 + C_2$	等效电容
极板间场强	$E = \frac{\sigma}{\varepsilon_0} = \frac{U}{d}$	电场与电压关系
极板间作用力	$F = \frac{1}{2} E \cdot q$	极板相互作用
含介质电容	$C = \varepsilon_r C_0$	电容增大$\varepsilon_r$倍
含介质场强	$E = \frac{E_0}{\varepsilon_r}$	场强减小$\varepsilon_r$倍
介电常量关系	$\varepsilon = \varepsilon_0 \cdot \varepsilon_r$	介电常量乘积

11电介质,电场能

公式名称	公式	备注
电介质高斯定理	$\oiint \vec{D} \cdot d\vec{S} = \sum q_{内}$	$D$为电位移矢量
电位移与场强关系	$D = \varepsilon_0 \varepsilon_r E$	$D$与$E$关系
电介质中总场强	$E = E_0 - E' = \frac{E_0}{\varepsilon_r}$	自由电荷+极化电荷场强
极化电荷面密度	$\sigma' = \left( 1 - \frac{1}{\varepsilon_r} \right) \sigma_0$	极化电荷与自由电荷关系
电场能密度	$w_e = \frac{1}{2} D E = \frac{1}{2} \varepsilon_0 \varepsilon_r E^2$	单位体积电场能
电场能	$W = \int_V w_e dV$	体积分
电容器储存能量	$W = \frac{Q^2}{2C} = \frac{1}{2} C U^2 = \frac{1}{2} Q U$	三种表达式

12磁感应强度

公式名称	公式	备注
毕奥-萨伐尔定律	$dB = \frac{\mu_0}{4\pi} \cdot \frac{Idl \cdot \sin\theta}{r^2}$	电流元产生磁场
真空中磁导率	$\mu_0 = 4\pi \times 10^{-7} T \cdot m/A$	常量
有限长直导线磁场	$B = \frac{\mu_0 I}{4\pi a} (\cos\theta_1 - \cos\theta_2)$	$\theta_1, \theta_2$为两端夹角
无限长直导线磁场	$B = \frac{\mu_0 I}{2\pi a}$	特殊情况
半无限长直导线磁场	$B = \frac{\mu_0 I}{4\pi a}$	一端在无穷远
无限大电流平面磁场	$B = \frac{1}{2} \mu_0 \alpha$	$\alpha$为面电流密度
圆弧电流磁场（圆心处）	$B = \frac{\mu_0 I}{4\pi R} \varphi$	$\varphi$为圆心角（弧度）
圆电流磁场（圆心处）	$B = \frac{\mu_0 I}{2R}$	$\varphi = 2\pi$
螺绕环磁场	$B = \mu_0 nI = \frac{\mu_0 NI}{2\pi R}$	$n$为单位长度匝数
长直螺线管磁场	$B = \mu_0 nI = \frac{\mu_0 NI}{L}$	内部匀强磁场
安培环路定理	$\oint \vec{B} \cdot d\vec{l} = \mu_0 \sum I_{内}$	环路积分等于$\mu_0$倍环路内电流

13磁通量,高斯定理

公式名称	公式	备注
磁通量（平面垂直）	$\Phi_m = B \cdot S$	$B$与$S$垂直
磁通量（平面倾斜）	$\Phi_m = B \cdot S \cdot \cos\theta$	$\theta$为$B$与$S$夹角
磁通量（曲面）	$d\Phi_m = \vec{B} \cdot d\vec{S}$，$\Phi_m = \iint \vec{B} \cdot d\vec{S}$	积分求解
磁场高斯定理	$\Phi_m = \oiint \vec{B} \cdot d\vec{S} = 0$	闭合曲面磁通量为零

14安培力,磁力矩,洛伦兹力

公式名称	公式	备注
安培力（垂直）	$F = B \cdot I \cdot L$	$B \perp I \perp L$
安培力（一般）	$F = B \cdot I \cdot L \cdot \sin\alpha$	$\alpha$为电流与磁场夹角
电流元受力	$dF = BIdl$，$F = \int dF$	积分求解
磁矩	$p_m = I \cdot S$	单位：$A \cdot m^2$
磁力矩	$M = B p_m \sin\theta$	$\theta$为$B$与$p_m$夹角
最大磁力矩	$M_{max} = BIS$	$\theta = \frac{\pi}{2}$
最小磁力矩	$M_{min} = 0$	$\theta = 0$
磁力矩做功	$A = I \Delta \Phi_m$	电流乘以磁通量变化
洛伦兹力	$F = Bqv$	$v \perp B$
圆周运动半径	$R = \frac{mv}{Bq}$	带电粒子在磁场中
周期	$T = 2\pi \frac{m}{Bq}$	圆周运动周期

15磁介质,磁场能

公式名称	公式	备注
磁介质安培环路定理	$\oint \vec{H} \cdot d\vec{l} = \sum I_{内}$	$H$为磁场强度
磁场强度	$H = \frac{B}{\mu_0 \mu_r} = \frac{B}{\mu}$	$H$与$B$关系
磁感应强度与磁场强度	$B = \mu_0 \mu_r H = \mu H$	含磁介质
相对磁导率	$\mu_r = \frac{B}{B_0}$	真空中$\mu_r = 1$
顺磁质	$\mu_r > 1$	磁介质类型
抗磁质	$\mu_r < 1$	磁介质类型
铁磁质	$\mu_r \gg 1$	磁介质类型
磁能密度	$w_m = \frac{1}{2} \frac{B^2}{\mu_0}$	单位体积磁场能
磁场能	$W_m = \int_V w_m dV$	体积分

16电磁感应（选学）

公式名称	公式	备注
法拉第电磁感应定律	$\varepsilon = -\frac{d\Phi}{dt}$	感应电动势
动生电动势	$\varepsilon = \int (\vec{v} \times \vec{B}) \cdot d\vec{l}$	导体运动产生
感生电动势	$\varepsilon = \oint \vec{E}_v \cdot d\vec{l} = -\frac{d\Phi}{dt}$	变化磁场产生
互感电动势	$\varepsilon_2 = -M \frac{dI_1}{dt}$	互感产生

17自感和互感（选学）

公式名称	公式	备注
自感系数	$L = \frac{\Phi}{I}$	自感定义
自感电动势	$\varepsilon = L \frac{dI}{dt}$	自感电动势
互感系数	$M = \frac{\Phi_2}{I_1} = \frac{\Phi_1}{I_2}$	互感定义

18麦克斯韦方程组（选学）

公式名称	公式	备注
电场高斯定理	$\oiint_S \vec{D} \cdot d\vec{S} = \int_V \rho dV$	电场有源
磁场高斯定理	$\oiint_S \vec{B} \cdot d\vec{S} = 0$	磁场无源
全电流安培环路定理	$\oint_l \vec{H} \cdot d\vec{l} = \iint_S \left( \vec{j} + \frac{\partial \vec{D}}{\partial t} \right) d\vec{S}$	变化电场产生磁场
法拉第电磁感应定律	$\oint_l \vec{E} \cdot d\vec{l} = -\iint_S \frac{\partial \vec{B}}{\partial t} \cdot d\vec{S}$	变化磁场产生电场

物理常量汇总

常量名称	符号	数值	单位
真空介电常量	$\varepsilon_0$	$8.85 \times 10^{-12}$	$C^2/(N \cdot m^2)$
真空中磁导率	$\mu_0$	$4\pi \times 10^{-7}$	$T \cdot m/A$
万有引力常量	$G$	$6.67 \times 10^{-11}$	$N \cdot m^2/kg^2$
重力加速度	$g$	$9.8$	$m/s^2$

响应式布局

Mon, 15 Jun 2026 00:00:00 GMT

响应式布局

媒体查询
BootStrap响应式

响应式布局是一种网页设计方法是，使网页能够根据用户设备的屏幕尺寸，分辨率，方向（横屏/书评）等特性自动调整布局和内容**，提供一致且优化的用户体验。其核心目标是“一次设计，多端适配”

优点	缺点
1. 一套代码适配多端设备	1. 复杂布局需较多调试
2. 节省开发和维护成本	2. 过度使用媒体查询可能影响性能
3. 用户体验一致性高	3. 需精准计算断点（什么屏幕下，怎么显示）

响应式布局核心技术
布局方式

弹性盒子（Flexbox）
网格布局（CSS Grid）
百分比布局（流式布局）
单位可借助 vw 实现

断点（Breakpoints）设置

根据常见设备宽度设置断点
- 手机：< 768px
- 平板：768px ~ 1024px
- PC：> 1024px
根据不同设备宽度显示不同布局样式

断点名称	最小宽度	CSS 媒体查询	适用场景
xs	<576px	`@media (min-width: 0)`	超小设备（手机竖屏）
sm	≥576px	`@media (min-width: 576px)`	平板竖屏/小屏手机横屏
md	≥768px	`@media (min-width: 768px)`	平板横屏/桌面小屏
lg	≥992px	`@media (min-width: 992px)`	桌面中屏
xl	≥1200px	`@media (min-width: 1200px)`	桌面大屏
xxl	≥1400px	`@media (min-width: 1400px)`	超宽屏（4K 显示器等）

响应式布局实现方案

媒体查询 媒体查询是 CSS3 的功能，允许根据设备的特性（如屏幕宽度、高度、分辨率、设备类型等）应用不同的样式规则。它是实现响应式设计的核心技术。
第三方框架 Bootstrap 预置样式和组件减少重复编码，缩短项目周期，适配 PC、移动端及主流浏览器。后续还可以学习其他不同的框架。

媒体查询

1. 基本语法

/* 方式一：@media规则 */
@media 媒体类型 and (媒体特性) {
    /* CSS样式 */
}

/* 方式二：在link标签中引入 */
<link media="媒体类型 and (媒体特性)" href="styles.css">

/* 方式三：在CSS中使用@import */
@import url("styles.css") 媒体类型 and (媒体特性);

2. 媒体类型

媒体类型	说明	常用场景
`screen`	屏幕设备	网页显示（最常用）
`print`	打印设备	打印机、打印预览
`all`	所有设备	默认值
`speech`	语音合成器	屏幕阅读器
`tv`	电视设备	智能电视

3. 媒体特性

媒体特性	说明	示例
`width`	视口宽度	`@media (width: 768px)`
`height`	视口高度	`@media (height: 1024px)`
`min-width`	最小宽度（及以上）	`@media (min-width: 768px)`
`max-width`	最大宽度（及以下）	`@media (max-width: 1200px)`
`min-height`	最小高度	`@media (min-height: 600px)`
`max-height`	最大高度	`@media (max-height: 800px)`
`orientation`	屏幕方向	`@media (orientation: landscape)`
`aspect-ratio`	宽高比	`@media (aspect-ratio: 16/9)`

4. 逻辑运算符

/* and：同时满足多个条件 */
@media screen and (min-width: 768px) and (max-width: 1024px) {
    /* 平板设备 */
}

/* not：对整个媒体查询取反 */
@media not screen {
    /* 非屏幕设备 */
}

/* only：仅在指定媒体类型生效 */
@media only screen {
    /* 仅屏幕设备 */
}

/* 逗号（或）：满足任一条件 */
@media (min-width: 768px), (orientation: landscape) {
    /* 宽度≥768px 或 横屏 */
}

5. 常见使用场景

场景一：根据屏幕宽度改变布局

/* 默认样式（移动端） */
.container {
    width: 100%;
    padding: 10px;
}

/* 平板及以上设备 */
@media (min-width: 768px) {
    .container {
        width: 750px;
        padding: 20px;
    }
}

/* 桌面及以上设备 */
@media (min-width: 992px) {
    .container {
        width: 970px;
        padding: 30px;
    }
}

/* 大屏幕设备 */
@media (min-width: 1200px) {
    .container {
        width: 1170px;
        padding: 40px;
    }
}

场景二：隐藏/显示元素

/* 默认显示 */
.sidebar {
    display: block;
}

/* 小屏幕隐藏侧边栏 */
@media (max-width: 768px) {
    .sidebar {
        display: none;
    }
}

场景三：横屏/竖屏适配

/* 横屏模式 */
@media (orientation: landscape) {
    .container {
        flex-direction: row;
    }
}

/* 竖屏模式 */
@media (orientation: portrait) {
    .container {
        flex-direction: column;
    }
}

场景四：Retina屏幕高清显示

/* 普通屏幕 */
.logo {
    background-image: url("logo.png");
}

/* Retina屏幕（2倍密度） */
@media (-webkit-min-device-pixel-ratio: 2), (min-resolution: 192dpi) {
    .logo {
        background-image: url("logo@2x.png");
    }
}

6. 移动优先 vs 桌面优先

移动优先（推荐）

/* 1. 先编写移动端基础样式 */
.box {
    width: 100%;
    font-size: 14px;
}

/* 2. 逐步添加更大屏幕的样式 */
@media (min-width: 768px) {
    .box {
        width: 50%;
        font-size: 16px;
    }
}

@media (min-width: 1200px) {
    .box {
        width: 33.33%;
        font-size: 18px;
    }
}

桌面优先

/* 1. 先编写桌面端样式 */
.box {
    width: 33.33%;
    font-size: 18px;
}

/* 2. 逐步添加小屏幕的样式 */
@media (max-width: 1199px) {
    .box {
        width: 50%;
        font-size: 16px;
    }
}

@media (max-width: 767px) {
    .box {
        width: 100%;
        font-size: 14px;
    }
}

7. 最佳实践

断点设置建议

/* 超小屏幕（手机竖屏）<576px */
/* 小屏幕（手机横屏/小平板）576px-767px */
/* 中等屏幕（平板）768px-991px */
/* 大屏幕（桌面）992px-1199px */
/* 超大屏幕（桌面大屏）≥1200px */

实用技巧

/* 1. 使用min-width而不是精确值 */
@media (min-width: 768px) { /* ✓ 好 */ }
@media (width: 768px) { /* ✗ 差：768px的设备很少 */ }

/* 2. 合理控制媒体查询数量 */
@media (min-width: 576px) { /* 小屏平板 */ }
@media (min-width: 768px) { /* 平板 */ }
@media (min-width: 992px) { /* 桌面 */ }
@media (min-width: 1200px) { /* 大屏桌面 */ }

/* 3. 使用CSS变量管理断点 */
:root {
    --breakpoint-sm: 576px;
    --breakpoint-md: 768px;
    --breakpoint-lg: 992px;
    --breakpoint-xl: 1200px;
}

/* 4. 配合flex和grid使用 */
.grid {
    display: grid;
    grid-template-columns: 1fr;
}

@media (min-width: 768px) {
    .grid {
        grid-template-columns: repeat(2, 1fr);
    }
}

@media (min-width: 1200px) {
    .grid {
        grid-template-columns: repeat(4, 1fr);
    }
}

8. 浏览器兼容性

功能	Chrome	Firefox	Safari	Edge	IE
基础媒体查询	1+	1+	1+	12+	9+
min/max前缀	1+	1+	1+	12+	9+
orientation	3+	6+	5+	12+	9+
aspect-ratio	3+	6+	5+	12+	✗

9. 常见错误避免

/* ✗ 错误1：媒体查询位置不当 */
/* 媒体查询应该放在样式规则之后 */
.box { color: red; }
@media (min-width: 768px) { .box { color: blue; } }

/* ✗ 错误2：断点重叠 */
@media (min-width: 768px) { .box { width: 750px; } }
@media (min-width: 750px) { .box { width: 970px; } } /* 750px处重叠 */

/* ✓ 正确：断点保持合理间距 */
@media (min-width: 768px) { .box { width: 750px; } }
@media (min-width: 992px) { .box { width: 970px; } }

/* ✗ 错误3：单位混淆 */
@media (min-width: 768) { /* ✗ 缺少单位 */ }
@media (min-width: 768px) { /* ✓ 正确 */ }

/* ✗ 错误4：媒体特性拼写错误 */
@media (min-width: 768px) and (max-with: 1200px) { /* ✗ max-with */ }
@media (min-width: 768px) and (max-width: 1200px) { /* ✓ max-width */ }

BootStrap响应式

BootStrap框架介绍和引用

什么是Bootstrap

Bootstrap 是由 Twitter 公司开发维护的一套前端UI框架，它提供了一套现成的CSS样式和组件，开发者可以直接引用这些类名，快速搭建响应式网页。

Bootstrap优势

优势	说明
响应式设计	一套代码适配手机、平板、PC等多端设备
标准化	提供统一的视觉风格和组件规范
开发效率高	大量预置样式和组件，无需从零写CSS
跨浏览器兼容	兼容主流浏览器，减少兼容性调试
可定制	支持按需定制，也可以覆盖默认样式

Bootstrap版本

版本	特点	适用场景
Bootstrap 3	经典稳定，支持IE8+，国内网课最常用	学习入门、传统项目
Bootstrap 4	引入Flexbox，移除IE支持，新增卡片等组件	现代项目
Bootstrap 5	移除jQuery依赖，新增RTL支持，纯CSS组件	新项目推荐

引入方式

方式一：CDN引入（推荐学习时使用）

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8">
    <!-- 必须配置viewport，否则响应式无效 -->
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Bootstrap示例</title>
    <!-- Bootstrap核心CSS -->
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@3.4.1/dist/css/bootstrap.min.css" rel="stylesheet">
    <!-- jQuery（Bootstrap3的JS依赖jQuery） -->
    <script src="https://cdn.jsdelivr.net/npm/jquery@1.12.4/dist/jquery.min.js"></script>
    <!-- Bootstrap核心JS -->
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@3.4.1/dist/js/bootstrap.min.js"></script>
</head>
<body>
    <!-- 页面内容 -->
</body>
</html>

方式二：本地引入

下载Bootstrap压缩包并解压
将css、js、fonts文件夹复制到项目中
在HTML中引入本地文件

<link rel="stylesheet" href="bootstrap/css/bootstrap.min.css">
<script src="bootstrap/js/jquery.min.js"></script>
<script src="bootstrap/js/bootstrap.min.js"></script>

注意事项：

viewport meta标签是响应式的必要条件，必须添加
Bootstrap 3的JS插件依赖jQuery，需要先引入jQuery
引入顺序：先CSS，再jQuery，最后Bootstrap JS

BootStrap框架基本使用

容器（Container）

Bootstrap需要一个容器来包裹页面内容，提供两种容器类：

容器类	特点	适用场景
`.container`	固定宽度，居中显示，两侧留白	PC端页面、常规布局
`.container-fluid`	100%宽度，充满视口	全屏布局、移动端

<!-- 固定宽度容器 -->
<div class="container">
  <h1>固定宽度容器</h1>
  <p>在不同屏幕尺寸下有不同的固定宽度，并居中显示</p>
</div>

<!-- 全屏宽度容器 -->
<div class="container-fluid">
  <h1>全屏宽度容器</h1>
  <p>始终占满整个屏幕宽度</p>
</div>

.container在不同断点下的宽度：

屏幕尺寸	断点宽度	container宽度
超小屏（手机）	<768px	100%
小屏（平板）	≥768px	750px
中屏（桌面）	≥992px	970px
大屏（大桌面）	≥1200px	1170px

按钮（Buttons）

Bootstrap提供了多种预定义按钮样式：

<!-- 基础按钮 -->
<button class="btn btn-default">默认按钮</button>

<!-- 按钮颜色样式 -->
<button class="btn btn-default">默认</button>
<button class="btn btn-primary">主要</button>
<button class="btn btn-success">成功</button>
<button class="btn btn-info">信息</button>
<button class="btn btn-warning">警告</button>
<button class="btn btn-danger">危险</button>
<button class="btn btn-link">链接</button>

<!-- 按钮尺寸 -->
<button class="btn btn-primary btn-lg">大按钮</button>
<button class="btn btn-primary">默认按钮</button>
<button class="btn btn-primary btn-sm">小按钮</button>
<button class="btn btn-primary btn-xs">超小按钮</button>

<!-- 块级按钮（占满整行） -->
<button class="btn btn-primary btn-block">块级按钮</button>

<!-- 按钮状态 -->
<button class="btn btn-primary active">激活状态</button>
<button class="btn btn-primary disabled">禁用状态</button>

也可以用在<a>标签上：

<a href="#" class="btn btn-primary">链接按钮</a>
<input type="button" class="btn btn-success" value="输入框按钮">

排版类

<!-- 标题 -->
<h1>h1. Bootstrap标题 <small>副标题</small></h1>
<h2>h2. Bootstrap标题</h2>
<h3>h3. Bootstrap标题</h3>

<!-- 页面主体（突出显示） -->
<p class="lead">这是一个突出显示的段落</p>

<!-- 文本对齐 -->
<p class="text-left">左对齐</p>
<p class="text-center">居中</p>
<p class="text-right">右对齐</p>

<!-- 文本颜色 -->
<p class="text-muted">柔和灰色</p>
<p class="text-primary">主要蓝色</p>
<p class="text-success">成功绿色</p>
<p class="text-info">信息蓝色</p>
<p class="text-warning">警告橙色</p>
<p class="text-danger">危险红色</p>

<!-- 文本大小写 -->
<p class="text-lowercase">LOWERCASE 转为小写</p>
<p class="text-uppercase">uppercase 转为大写</p>
<p class="text-capitalize">capitalized 首字母大写</p>

列表

<!-- 无序列表（去点） -->
<ul class="list-unstyled">
  <li>列表项1</li>
  <li>列表项2</li>
  <li>列表项3</li>
</ul>

<!-- 内联列表（横向排列） -->
<ul class="list-inline">
  <li>首页</li>
  <li>产品</li>
  <li>关于</li>
</ul>

表格

<table class="table table-striped table-bordered table-hover">
  <thead>
    <tr>
      <th>姓名</th>
      <th>年龄</th>
    </tr>
  </thead>
  <tbody>
    <tr class="success">
      <td>张三</td>
      <td>20</td>
    </tr>
    <tr>
      <td>李四</td>
      <td>22</td>
    </tr>
    <tr class="danger">
      <td>王五</td>
      <td>25</td>
    </tr>
  </tbody>
</table>

表格样式类：

.table - 基础表格样式（必加）
.table-striped - 斑马纹
.table-bordered - 带边框
.table-hover - 鼠标悬停高亮
.table-condensed - 紧凑表格

表单

<form>
  <div class="form-group">
    <label>用户名</label>
    <input type="text" class="form-control" placeholder="请输入用户名">
  </div>
  <div class="form-group">
    <label>密码</label>
    <input type="password" class="form-control" placeholder="请输入密码">
  </div>
  <button type="submit" class="btn btn-primary">提交</button>
</form>

BootStrap栅格布局

栅格系统简介

Bootstrap的栅格系统（Grid System）是一套响应式、移动设备优先的流式栅格布局系统。它将页面容器平均划分为12列，通过给列添加类名来控制元素在不同屏幕下的宽度。

栅格系统工作原理

┌──────────────────────────────────────────┐
│              container                   │
│  ┌───────────────────────────────────┐   │
│  │            row (12列)             │   │
│  ├─────┬─────┬─────┬─────┬─────┬─────┤   │
│  │col- │col- │col- │col- │col- │col- │   │
│  │ md-2│ md-2│ md-2│ md-2│ md-2│ md-2│   │
│  └─────┴─────┴─────┴─────┴─────┴─────┘   │
└──────────────────────────────────────────┘

核心要点：

行（row）必须放在container中
列（col）必须作为row的直接子元素
内容应该放在列（col）中
每行12列，列数之和超过12会自动换行

栅格参数（断点）

	超小屏 <br>手机 (<768px)	小屏 <br>平板 (≥768px)	中屏 <br>桌面 (≥992px)	大屏 <br>大桌面 (≥1200px)
类名前缀	`.col-xs-*`	`.col-sm-*`	`.col-md-*`	`.col-lg-*`
列数	12	12	12	12
最大列宽	自动	~62px	~81px	~97px
间距(gutter)	30px（左右各15px）	30px	30px	30px
是否浮动	是	是	是	是

基础用法

示例1：等宽列（三列布局）

<div class="container">
  <div class="row">
    <div class="col-md-4">第一列（占4列，4/12 = 1/3）</div>
    <div class="col-md-4">第二列（占4列）</div>
    <div class="col-md-4">第三列（占4列）</div>
  </div>
</div>

示例2：不等宽列（侧边栏+主内容）

<div class="container">
  <div class="row">
    <div class="col-md-3">侧边栏（占3列）</div>
    <div class="col-md-9">主内容区（占9列）</div>
  </div>
</div>

示例3：移动端和桌面端不同布局

<div class="container">
  <div class="row">
    <!-- 手机：12列（满宽），平板/桌面：6列（半宽） -->
    <div class="col-xs-12 col-md-6">左侧内容</div>
    <!-- 手机：12列（满宽），平板/桌面：6列（半宽） -->
    <div class="col-xs-12 col-md-6">右侧内容</div>
  </div>
</div>

列组合示例代码（带颜色区分）：

<style>
  .row > div {
    height: 50px;
    background-color: pink;
    border: 1px solid #fff;
  }
</style>

<div class="container">
  <!-- 12列：12个col-md-1 -->
  <div class="row">
    <div class="col-md-1">1</div>
    <div class="col-md-1">2</div>
    <div class="col-md-1">3</div>
    <div class="col-md-1">4</div>
    <div class="col-md-1">5</div>
    <div class="col-md-1">6</div>
    <div class="col-md-1">7</div>
    <div class="col-md-1">8</div>
    <div class="col-md-1">9</div>
    <div class="col-md-1">10</div>
    <div class="col-md-1">11</div>
    <div class="col-md-1">12</div>
  </div>
  <!-- 6列：6个col-md-2 -->
  <div class="row">
    <div class="col-md-2">2</div>
    <div class="col-md-2">2</div>
    <div class="col-md-2">2</div>
    <div class="col-md-2">2</div>
    <div class="col-md-2">2</div>
    <div class="col-md-2">2</div>
  </div>
  <!-- 4列：4个col-md-3 -->
  <div class="row">
    <div class="col-md-3">3</div>
    <div class="col-md-3">3</div>
    <div class="col-md-3">3</div>
    <div class="col-md-3">3</div>
  </div>
  <!-- 3列：3个col-md-4 -->
  <div class="row">
    <div class="col-md-4">4</div>
    <div class="col-md-4">4</div>
    <div class="col-md-4">4</div>
  </div>
  <!-- 2列：2个col-md-6 -->
  <div class="row">
    <div class="col-md-6">6</div>
    <div class="col-md-6">6</div>
  </div>
  <!-- 1列：1个col-md-12 -->
  <div class="row">
    <div class="col-md-12">12</div>
  </div>
</div>

列偏移（列与列之间的距离）

使用 .col-md-offset-* 类可以将列向右偏移*个列宽：

<div class="container">
  <div class="row">
    <!-- 向右偏移3列，实际位置在第4列开始 -->
    <div class="col-md-4 col-md-offset-3">
      占4列，向右偏移3列
    </div>
  </div>
  
  <!-- 两列居中分开 -->
  <div class="row">
    <div class="col-md-3">左侧</div>
    <div class="col-md-3 col-md-offset-6">右侧（偏移6列靠右）</div>
  </div>
  
  <!-- 居中显示 -->
  <div class="row">
    <!-- 占6列，偏移3列，实现居中（(12-6)/2=3） -->
    <div class="col-md-6 col-md-offset-3">
      这个div水平居中
    </div>
  </div>
</div>

常用的offset组合：

需求	类名
列居中（占6列）	`col-md-6 col-md-offset-3`
列居中（占4列）	`col-md-4 col-md-offset-4`
列居中（占8列）	`col-md-8 col-md-offset-2`
两列两端对齐	`col-md-3` + `col-md-3 col-md-offset-6`

BootStrap列布局和字体图标

列排序（push/pull）

使用 .col-md-push-* 向右推，.col-md-pull-* 向左拉，可以改变列的顺序：

<div class="row">
  <!-- 左列向右推6列（到右侧） -->
  <div class="col-md-6 col-md-push-6">
    原来在左边，现在在右边
  </div>
  <!-- 右列向左拉6列（到左侧） -->
  <div class="col-md-6 col-md-pull-6">
    原来在右边，现在在左边
  </div>
</div>

应用场景：移动端和PC端内容顺序互换

<div class="row">
  <!-- PC端：主内容在左(9列)，侧边栏在右(3列) -->
  <!-- 移动端：侧边栏显示在上方，主内容在下方 -->
  <div class="col-md-9 col-md-push-3">主内容区</div>
  <div class="col-md-3 col-md-pull-9">侧边栏</div>
</div>

列嵌套

栅格系统支持列嵌套，即在列中再使用row和col：

<div class="row">
  <div class="col-md-9">
    第一列占9列
    <!-- 在col-md-9中嵌套新的行（自动分成12列） -->
    <div class="row">
      <div class="col-md-6">嵌套第一列（占父级的一半）</div>
      <div class="col-md-6">嵌套第二列（占父级的一半）</div>
    </div>
  </div>
  <div class="col-md-3">
    第二列占3列
  </div>
</div>

注意：嵌套的row不需要container了，因为父级col已经有padding。

响应式工具（显示/隐藏）

通过类名控制元素在不同屏幕下的显示与隐藏：

类名	超小屏 <768px	小屏 ≥768px	中屏 ≥992px	大屏 ≥1200px
`.visible-xs-*`	可见	隐藏	隐藏	隐藏
`.visible-sm-*`	隐藏	可见	隐藏	隐藏
`.visible-md-*`	隐藏	隐藏	可见	隐藏
`.visible-lg-*`	隐藏	隐藏	隐藏	可见
`.hidden-xs`	隐藏	可见	可见	可见
`.hidden-sm`	可见	隐藏	可见	可见
`.hidden-md`	可见	可见	隐藏	可见
`.hidden-lg`	可见	可见	可见	隐藏

<!-- 只在手机上显示 -->
<div class="visible-xs-block">手机端菜单按钮</div>

<!-- 在手机上隐藏，其他尺寸显示 -->
<div class="hidden-xs">PC端侧边栏</div>

字体图标（Glyphicons）

Bootstrap 3 内置了 Glyphicons Halflings 字体图标，共包含200多个图标。

使用方法：

<!-- 基本用法 -->
<span class="glyphicon glyphicon-search"></span>

<!-- 图标配合文字 -->
<button class="btn btn-primary">
  <span class="glyphicon glyphicon-plus"></span> 新增
</button>

<button class="btn btn-danger">
  <span class="glyphicon glyphicon-trash"></span> 删除
</button>

<!-- 图标大小 -->
<span class="glyphicon glyphicon-star" style="font-size: 20px;"></span>
<span class="glyphicon glyphicon-star" style="font-size: 30px;"></span>

<!-- 图标颜色 -->
<span class="glyphicon glyphicon-heart" style="color: red;"></span>
<span class="glyphicon glyphicon-ok" style="color: green;"></span>

常用字体图标类名：

类名	图标含义
`glyphicon-search`	搜索（放大镜）
`glyphicon-user`	用户
`glyphicon-home`	首页（房子）
`glyphicon-heart`	心形/收藏
`glyphicon-star`	星星
`glyphicon-plus`	加号/新增
`glyphicon-minus`	减号
`glyphicon-trash`	删除/垃圾桶
`glyphicon-pencil`	编辑/铅笔
`glyphicon-cog` / `glyphicon-wrench`	设置/齿轮
`glyphicon-film`	视频/影片
`glyphicon-music`	音乐
`glyphicon-camera`	相机
`glyphicon-envelope`	信封/邮件
`glyphicon-shopping-cart`	购物车
`glyphicon-ok`	对勾/成功
`glyphicon-remove`	叉号/关闭
`glyphicon-chevron-left`	左箭头
`glyphicon-chevron-right`	右箭头
`glyphicon-arrow-up`	上箭头
`glyphicon-arrow-down`	下箭头

Bootstrap 5 图标（Bootstrap Icons）

Bootstrap 4/5 不再内置Glyphicons，推荐使用 Bootstrap Icons：

<!-- 引入Bootstrap Icons -->
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.10.0/font/bootstrap-icons.css">

<!-- 使用 -->
<i class="bi bi-search"></i>
<i class="bi bi-person"></i>
<i class="bi bi-heart"></i>

字体图标使用原理：

字体图标本质上是一种特殊字体，通过CSS的::before伪元素插入字符，每个类名对应一个图标的Unicode编码：

.glyphicon-search::before {
  content: "\e003";  /* Unicode编码，渲染为搜索图标 */
}

优点：

加载速度快（字体文件比图片小）
可任意缩放不失真
可用CSS修改颜色、大小、阴影等
支持CSS动画

其他技巧

svg裁剪背景

有时候，想要裁剪更复杂的形状，但是clip-path只能裁剪矩形。这时候，可以使用svg的clip-path属性来裁剪更复杂的形状。

示例

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>SVG裁剪背景示例</title>
    <style>
        /* 定义SVG裁剪路径 */
        .clip-svg {
            clip-path: url(#myClip);
        }

        /* 被裁剪的元素 */
        .clipped-element {
            width: 400px;
            height: 300px;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            clip-path: url(#myClip);
        }

        /* 对比：不裁剪的元素 */
        .normal-element {
            width: 400px;
            height: 300px;
            background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
            margin-top: 20px;
        }
    </style>
</head>
<body>
    <!-- 定义SVG裁剪路径 -->
    <svg width="0" height="0">
        <defs>
            <!-- 复杂形状裁剪路径：波浪形 -->
            <clipPath id="myClip">
                <path d="M0,50 Q100,0 200,50 T400,50 L400,300 L0,300 Z" />
            </clipPath>
            
            <!-- 其他裁剪路径示例 -->
            <!-- 圆形裁剪 -->
            <clipPath id="circleClip">
                <circle cx="200" cy="150" r="100" />
            </clipPath>
            
            <!-- 多边形裁剪（六边形） -->
            <clipPath id="hexagonClip">
                <polygon points="200,0 400,75 400,225 200,300 0,225 0,75" />
            </clipPath>
            
            <!-- 文字裁剪 -->
            <clipPath id="textClip">
                <text x="50" y="150" font-size="60" font-weight="bold">HELLO</text>
            </clipPath>
        </defs>
    </svg>

    <!-- 使用裁剪路径的元素 -->
    <h3>使用SVG裁剪路径的元素（波浪形状）：</h3>
    <div class="clipped-element"></div>

    <h3>对比：不裁剪的元素：</h3>
    <div class="normal-element"></div>

    <!-- 其他裁剪形状示例 -->
    <h3>圆形裁剪：</h3>
    <div style="width: 400px; height: 300px; background: linear-gradient(45deg, #FF6B6B, #4ECDC4); clip-path: url(#circleClip);"></div>

    <h3>六边形裁剪：</h3>
    <div style="width: 400px; height: 300px; background: linear-gradient(45deg, #45B7D1, #96CEB4); clip-path: url(#hexagonClip);"></div>

    <h3>文字裁剪：</h3>
    <div style="width: 400px; height: 300px; background: url('https://picsum.photos/400/300') center/cover; clip-path: url(#textClip);"></div>
</body>
</html>

关键要点：

SVG定义：在HTML中定义SVG的<defs>标签，包含各种<clipPath>元素
裁剪路径ID：每个<clipPath>需要一个唯一的ID，如id="myClip"
CSS引用：在CSS中使用clip-path: url(#myClip)引用SVG裁剪路径
复杂形状：SVG裁剪路径可以创建任意复杂的形状，如波浪、多边形、文字等

SVG裁剪路径类型对比：

裁剪类型	SVG元素	适用场景	复杂度
简单形状	`<circle>`、`<rect>`	圆形、矩形裁剪	低
多边形	`<polygon>`	星形、六边形等	中
自定义路径	`<path>`	波浪、复杂曲线	高
文字裁剪	`<text>`	文字形状背景	高

与CSS clip-path对比：

特性	CSS clip-path	SVG clip-path
基础形状	支持（circle、polygon等）	支持
复杂路径	不支持	✓ 支持
文字裁剪	不支持	✓ 支持
动画支持	✓ 支持	✓ 支持
浏览器兼容	较好	略差（IE不支持）

实用技巧：

/* 1. 响应式裁剪 */
.clipped-responsive {
    clip-path: url(#responsiveClip);
}

/* 2. 动画裁剪 */
.clipped-animated {
    clip-path: url(#animatedClip);
    animation: clip-animation 3s infinite;
}

@keyframes clip-animation {
    0% { clip-path: url(#clip1); }
    50% { clip-path: url(#clip2); }
    100% { clip-path: url(#clip1); }
}

/* 3. hover效果 */
.clipped-hover {
    clip-path: url(#normalClip);
    transition: clip-path 0.3s ease;
}

.clipped-hover:hover {
    clip-path: url(#hoverClip);
}

注意事项：

SVG裁剪路径需要在HTML中定义，不能在CSS中直接创建
裁剪路径的坐标系相对于被裁剪元素的左上角（0,0）
被裁剪的部分会完全隐藏，不显示任何内容
SVG裁剪路径支持动画和过渡效果
浏览器兼容性：IE不支持，Edge12+支持

TDK网站优化标签

TDK是 Title、Description 和 Keywords 三个元标签的缩写，它们是网站SEO优化的核心元素，直接影响搜索引擎对网页的理解和排名。

标签	作用
Title	决定搜索结果的标题显示，是搜索引擎判断页面主题的首要依据
Description	生成搜索结果的摘要描述，影响用户点击率（CTR）
Keywords	提供页面主题关键词（尽管现代搜索引擎已弱化其权重，仍部分参考）

三者共同构成网页的"第一印象"，优化不当可能导致排名下降或点击流失。

代码示例：

<title>vivo智能手机官方网站 - X200s 影像旗舰</title>

<meta name="keywords" content="vivo, vivo官网, vivo智能手机大全, vivo手机最新报价, vivo手机图片, X200系列, S20系列, X Fold3, vivo Pad5 Pro, vivo WATCH 5, iQOO 13">

<meta name="description" content="手机领域的国际化品牌，vivo官网提供手机资讯、售前咨询、在线购买、售后服务等功能；vivo当季明星...">

提示：国内几乎每个网站都会有这三大标签，是SEO优化的基础。

图片遮罩 mask-image

mask-image的核心作用是通过定义一张图片或一个渐变来充当遮罩，从而控制一个元素的可视区域。

语法：

.box {
mask-image: url('图片URL');
/* 或者 */
mask-image: linear-gradient(45deg, #FF6B6B, #4ECDC4);
}

自定义浏览器滚动条

浏览器滚动条包含两个部分，轨道和滑块。

/* 滚动条设置宽度和高度 */
::-webkit-scrollbar {
  width: 10px;
}
/* 设置轨道背景色，圆角等 */
::-webkit-scrollbar-track {
  background-color: var(--vivo-dark);
}
/* 设置滑块样式 */
::-webkit-scrollbar-thumb {
  background: linear-gradient(45deg, var(--vivo-blue), var(--vivo-cyan));
  border-radius: 10px;
}
/* 鼠标经过滑块 */
::-webkit-scrollbar-thumb:hover {
  background: linear-gradient(45deg, var(--vivo-cyan), var(--vivo-blue));
}

css移动网页开发

Wed, 10 Jun 2026 00:00:00 GMT

移动网页开发

移动端知识
vw/vmin适配方案
.rem适配方案

移动端知识

常见的移动端开发

原生APP开发：针对安卓，ios，鸿蒙移动操作系统开发的APP
小程序端：微信小程序，支付宝小程序，uniapp等
web端(H5)：H5,CSS3,JavaScript等技术

PC页面会设置版心，移动端如何设置呢？

移动端页面宽度根据设备宽度来确定

视口标签：

<meta name="viewport" content="width=device-width, initial-scale=1.0">

属性名	作用	取值	默认值	示例	注意事项
`width`	设置视口宽度	`device-width` 或具体数值（如 375）	980px（移动端默认）	`<meta name="viewport" content="width=device-width">`	移动端默认的980px称为布局视口，`device-width` 以匹配设备宽度称为理想视口
`initial-scale`	页面初始缩放比例	数值（如 1.0）	1.0	`<meta name="viewport" content="initial-scale=1.0">`	与 `width` 和 `device-width` 配合使用，避免缩放混乱
`minimum-scale`	允许用户缩放的最小比例	数值（如 0.5）	0.1	`<meta name="viewport" content="minimum-scale=0.5">`	若设为 1.0，则用户无法放大页面
`maximum-scale`	允许用户缩放的最大比例	数值（如 2.0）	10.0	`<meta name="viewport" content="maximum-scale=3.0">`	限制缩放范围，但可能影响无障碍访问
`user-scalable`	是否允许用户手动缩放	`yes` 或 `no`	`yes`	`<meta name="viewport" content="user-scalable=no">`	禁用缩放可提升体验，但需谨慎使用（无障碍场景需权衡）

物理像素和CSS像素

物理像素（也称设备像素）：是设备屏幕的实际物理像素数量，即硬件成眠的像素点中枢，出厂默认。
例如：一台设备的屏幕分辨率为2352*1170，表示横向有2352个物理像素，纵向有1170个物理像素。
硬件相关：由屏幕硬件决定，不同设备的物理分辨率可能不同。

将更多的物理像素点压缩至一块屏幕里，从而达到更多的分辨率，提高了屏幕显示的细腻程度

CSS像素（也称设备独立像素或者逻辑像素）：
是CSS中使用的虚拟像素单位，用于布局和样式计算
它是一个抽象概念，不直接对应无力像素，而是通过**设备像素比（Device Pixel Ratio, DPR）**与物理像素关联。
比如：PC端，一个CSS像素就是一个物理像素，但是手机端要看DPR

设计稿：
移动端设计稿通常以750作为标准宽度（尤其是微信小程序，H5页面等）

早期移动端设计以iPhone为基准，，750px称为行业默认规范
iPhone 6/7/8 的物理分辨率是750×1334px，设计稿按750px宽度制作时，能直接对应这些设备的1:1视觉还原，方便设计师精准把控细节（如字体大小，间距等）

设计稿按750px（2倍大小）制作后：

开发时直接缩放到50%（如CSS中写375px），即可适配逻辑分辨率。
图片和图标按`2倍尺寸输出，在高清屏上显示更清晰。（2倍图）

vw/vmin适配方案

实现移动端适配方案：

响应式：一套代码通过响应式方案完成pc，平板，手机端的适配（vivo官网，华为官网等）
单位适配：pc和平板通过响应式完成适配。单独制作手机端页面，通过rem，vw单位完成页面适配（淘宝手机端，B站手机端，京东手机端等）

不管哪种方案，页面布局还是使用grid，flex百分比等，元素大小需要进行适配

vw/vh单位适配：
vw是一种基于视口宽度的相对单位，非常适合用于移动端适配
vw单位定义：

1vw=视窗宽度的1%
如果视窗宽度是375px，则1vw=3.75px
同理100vw=等于视窗完整宽度
vh：视窗高度的1%
注意vw和%不一样，%相对于父容器

注意：

网页是主要对屏幕宽度适配，所以通常用vw即可，vh很少用到

设计稿转换公式：
vw值=（元素在设计稿中的px值 / 设计稿宽度）× 100vw
(106px/375px) * 100vw = 28.26vw

方式1：使用calc函数

.nav {
  width: calc(106 / 375 * 100vw);
  height: calc(106 / 375 * 100vw);
}

书写繁琐

方式2：使用CSS预处理器（推荐）

less或者sass实现，后续工程化讲

但是实际开发里面直接写px不需要计算

方式3：结合PostCSS插件（最佳实践）

less/sass代码直接写px
使用postcss-px-to-viewport插件，打包发布的时候会统一自动转换为VW
但是需要脚手架知识，后续vue阶段讲

方式4：使用trae插件转换（当前阶段）
px to rem & rpx & vw(cssrem)

独立圆角属性

css提供了四个独立的圆角属性，分别控制四个角：
border-top-left-radius左上角圆角
border-top-right-radius右上角圆角
border-bottom-left-radius左下角圆角
border-bottom-right-radius右下角圆角

如果后面跟两个值分别表示该角的水平半径和垂直半径

点击高亮

a {
  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
  /* 移除移动端点击高亮 */
}

移动端适配

vmin/vmax单位：
当设备旋转（如手机从竖屏转横屏时），视口的宽高会变化，但vmin始终取当前宽高的较小值，vmax取较大值

特性	vw (Viewport Width)	vmin (Viewport Minimum)
定义	视口宽度的 1%	视口较小尺寸（宽度或高度）的 1%
计算依据	仅基于视口宽度（width）	取视口宽度与高度的较小值
方向敏感性	始终基于宽度，无视口方向	根据视口方向动态调整（宽度或高度取较小值）
竖屏（如手机）	基于宽度（如 375px 宽度的 50vw = 187.5px）	基于高度（如 812px 高度的 50vmin = 406px）
代码示例	`width: 50vw;`（视口宽度的 50%）	`height: 50vmin;`（视口较小边的 50%）
优势	精准控制横向尺寸	自动适应不同方向，适合全屏或动态比例布局
劣势	无法响应视口高度变化	在宽屏设备上可能不如 vw 直观

如果需要照顾手机端横屏状态，可以使用 vmin，比如 B 站全站就采用 vmin 来适配横竖屏场景。

rem适配方案

rem单位适配：
通过动态修改根元素（html）的font-size属性，使得页面元素基于rem的布局能够自适应不同屏幕尺寸。
比如京东、淘宝、小米移动端使用rem适配

动态修改html文字大小（基准值）方案：

方式一：媒体查询方案(京东写法)

html {
  font-size: 20px;
  font-size: 5.33333vw;
}

@media screen and (max-width: 320px) {
  html {
    font-size: 17.0667px;
  }
}

@media screen and (min-width: 540px) {
  html {
    font-size: 28.8px;
  }
}

方式二：js方式引入（推荐）
阿里巴巴手淘团队开发的移动端适配方案Flexible.js通过动态调整根元素html的font-size属性，结合rem单位实现页面自适应（拼多多，淘宝写法）。

<script src="./js/flexible.js"></script>

//set 1rem = view width / 10
function setRemUnit() {
  var rem = docEl.clientWidth / 10
  docEl.style.fontSize = rem + 'px'
}

方式三：使用PostCSS插件（最佳实践）
设计稿转换公式：
rem值 = 设计稿元素尺寸 / html的font-size（基准值）
(106 / 37.5) = 2.826rem

less/sass代码直接写px
使用postcss-pxtorem插件，打包发布的时候会容易自动转换为rem
但是需要脚手架知识，后续Vue阶段讲

方式四：转换插件（目前阶段）

Flexible.js实现动态修改html根字号大小
利用插件实现px转换为rem单位

css前沿技术拓展

Sun, 07 Jun 2026 00:00:00 GMT

前言技术拓展

SVG图片

SVG(Scalable Vector Graphics)是一种基于XML的矢量图形标准，由W3C制定，支持无损缩放，交互性和动态效果。其核心点包括：

矢量特性：无论放大或做小均保持清晰，文件体积小，适合网络传输，尤其适用于高分辨率设备
可编辑性：直接通过文本编辑器修改SVG代码，支持颜色，形状，动画参数的实时调整
交互性：支持javascript和CSS控制，可实现点击，悬停等动态响应
兼容性：主流浏览器（Chrome,Firefox,Safari,Edge）均支持SVG格式，移动端适配性强

SVG图片下载

svg组成

svg根元素。svg图标必须包裹在<svg>标签内
<path>路径。通过d属性定义路径指令。M:移动画笔到坐标点，Z:闭合路径

svg图标常见css属性

svg是行内块元素，可以设置大小，移动位置，动画等。但是有自己特殊的样式属性

属性	描述	取值示例
`fill`	填充颜色（支持颜色值、渐变、图案），不需要时可改为 `none`	`fill: #f00;`
`stroke`	定义描边颜色（支持颜色值、渐变、图案）	`stroke: #f00;`
`stroke-width`	描边宽度（支持像素、百分比、px、em 等单位）	`stroke-width: 2px;`
`stroke-dasharray`	虚线模式（实线长度 + 间隔长度）	`stroke-dasharray: 10;`
`stroke-dashoffset`	调整虚线与间隔的起始位置（负值表示向左偏移）

获得svg图片描边的长度
给svg添加id属性，例如<svg id="svg-icon"></svg>，在浏览器console中使用javascript,svg-icon.getTotalLength()即可获得svg图片描边的长度 clip-path

clip-path属性用于定义元素的剪裁路径

clip-path

取值	描述	取值示例
`circle()`	圆形裁剪	`circle(50% at 50% 50%)`
`ellipse()`	椭圆裁剪	`ellipse(50% 30% at 50% 50%)`
`polygon()`	多边形裁剪	`polygon(50% 0%, 100% 100%, 0% 100%)`
`inset()`	矩形裁剪	`inset(10% 20% 30% 10%)`
`path()`	任意路径裁剪	`path('M0 0 L100 100 Z')`
`url()`	引用SVG clipPath元素	`url(#clipId)`

clip-path使用示例

/* 圆形裁剪 */
.element {
  clip-path: circle(50% at 50% 50%);
}

/* 多边形裁剪（三角形）*/
.element {
  clip-path: polygon(50% 0%, 0% 100%, 100% 100%);
}

/* 动画效果 */
.element {
  clip-path: circle(0% at 50% 50%);
  transition: clip-path 0.5s ease;
}
.element:hover {
  clip-path: circle(50% at 50% 50%);
}

scale()

scale()属性用于缩放元素的大小，默认缩放比例为1，即不缩放

rotate()

turn单位用于旋转元素，1turn等于360度

filter()

filter()属性用于对元素进行图像处理，如模糊，锐化，颜色转换等

滤镜函数	语法示例与说明
`blur()`	高斯模糊：`blur(5px)`
`brightness()`	调整元素亮度：`brightness(150%)`<br>- `100%`（或 `1`）为原始亮度<br>- `<100%`（或 `<1`）变暗<br>- `>100%`（或 `>1`）变亮
`contrast()`	调整元素对比度：`contrast(200%)`（取值规则同 `brightness()`）
`saturate()`	调整背景饱和度：取值 `0%`（无色彩）~`100%`（原饱和度）~`>100%`（更高饱和）
`grayscale()`	将元素转换为灰度图：`grayscale(100%)`<br>- `0%`（或 `0`）为原始色彩<br>- `100%`（或 `1`）为完全灰度
`hue-rotate()`	调整元素色相（改变颜色倾向）：`hue-rotate(90deg)`
`sepia()`	将元素转换为深褐色（复古效果）：`sepia(70%)`<br>- `0%`（或 `0`）为原始色彩<br>- `100%`（或 `1`）为完全深褐色
`drop-shadow()`	为元素添加投影（类似 `box-shadow`，但支持非矩形元素）：`drop-shadow(5px 5px 5px #669)`

backdrop-filter()

背景滤镜的使用和filter()属性类似，只是作用范围不同。backdrop-filter()属性用于对元素的背景进行滤镜处理，影响元素的透明度和颜色。

动画时间线

animation-timeline属性用于定义动画的时间线

animation-timeline取值

取值	描述	取值示例
`scroll()`	滚动时间线，绑定滚动条位置	`animation-timeline: scroll();`
`view()`	视图时间线，绑定元素在视口中的可见比例	`animation-timeline: view();`
`auto`	使用animation-name定义的动画	`animation-timeline: auto;`

scroll()滚动时间线

/* 默认绑定根元素滚动条 */
.scrollbar {
  animation-timeline: scroll();
}

/* 绑定最近的可滚动祖先容器 */
.element {
  animation-timeline: scroll(nearest);
}

/* 绑定根元素滚动条 */
.element {
  animation-timeline: scroll(root);
}

/* 绑定特定元素的滚动条 */
.container {
  overflow-y: auto;
  scrollbar-gutter: stable;
}
.progress {
  animation-timeline: scroll(self);
}

scroll()滚动时间线示例

<!DOCTYPE html>
<html>
<head>
  <style>
    * { margin: 0; padding: 0; }
    body { height: 3000px; }
    .navbar {
      position: fixed;
      top: 0;
      left: 0;
      width: 100%;
      height: 100px;
      background: #fff;
      box-shadow: 0 0 10px rgba(0, 0, 0, 0.5);
    }
    .scrollbar {
      width: 0%;
      height: 3px;
      background: linear-gradient(90deg, #96f, #bf70ff, #e67aff, #ff89dc, #ffa176, #ffb90f);
      animation: scrollbar linear forwards;
      animation-timeline: scroll();
    }
    @keyframes scrollbar {
      0% { width: 0%; }
      100% { width: 100%; }
    }
  </style>
</head>
<body>
  <div class="navbar">
    <div class="scrollbar"></div>
  </div>
  <div class="content">
    <p>里面有很多的文字</p>
    <!-- 更多内容产生滚动 -->
  </div>
</body>
</html>

view()视图时间线

/* 绑定元素在视口中的可见比例 */
.element {
  animation: fade-in linear;
  animation-timeline: view();
}

@keyframes fade-in {
  from { opacity: 0; }
  to { opacity: 1; }
}

/* 带有滚动轴的视图时间线 */
.element {
  animation: slide-in linear;
  animation-timeline: view(scroll());
}

@keyframes slide-in {
  from { transform: translateY(100%); }
  to { transform: translateY(0); }
}

/* 自定义视图时间线范围 */
.element {
  animation: scale linear;
  animation-timeline: view(inline);
  animation-range: entry 0% cover 50%;
}

view()视图时间线示例

<!DOCTYPE html>
<html>
<head>
  <style>
    .container {
      height: 200vh;
      padding: 50px;
    }
    .card {
      height: 300px;
      background: #f0f0f0;
      margin-bottom: 100px;
      animation: slide-in linear both;
      animation-timeline: view();
    }
    @keyframes slide-in {
      from {
        transform: translateY(100%);
        opacity: 0;
      }
      to {
        transform: translateY(0);
        opacity: 1;
      }
    }
  </style>
</head>
<body>
  <div class="container">
    <div class="card">卡片1</div>
    <div class="card">卡片2</div>
    <div class="card">卡片3</div>
  </div>
</body>
</html>

animation-range视图时间线范围

取值	描述
`cover 0%`	元素完全进入视口前
`cover 100%`	元素完全离开视口后
`entry 0%`	元素开始进入视口时
`entry 100%`	元素刚好完全进入视口时
`exit 0%`	元素开始离开视口时
`exit 100%`	元素刚好完全离开视口时

animation-range使用示例

.element {
  animation: scale linear both;
  animation-timeline: view();
  animation-range: entry 0% cover 40%;
}

@keyframes scale {
  from { transform: scale(0.5); }
  to { transform: scale(1); }
}

animation-duration和animation-timeline的关系

/* 当使用scroll()或view()时，animation-duration表示滚动距离对应的时间 */
.progress {
  animation-name: progress;
  animation-duration: 1s;
  animation-timeline: scroll();
  animation-fill-mode: both;
}

@keyframes progress {
  from { width: 0; }
  to { width: 100%; }
}

/* 如果想要动画速度与滚动同步，设置duration为1s即可 */

兼容性说明

动画时间线API是较新的CSS特性，目前主要在Chrome、Edge等Chromium内核浏览器中得到支持，Firefox和Safari支持有限。

变量和函数

CSS增强了逻辑性和动态计算能力，比如CSS变量和一些动态函数(calc(),clamp()等)

使用场景：

主体切换
响应式设计
交互动画等

变量

CSS变量（也可称为自定义属性）是一种动态存储和复用值的机制，它让样式管理更灵活，可维护。变量可以理解为一个容器，里面可以存放数据

定义变量：通过--变量名定义变量

  --color: #007bff;

使用变量：通过var(--变量名)使用变量

  color: var(--color);

作用域：变量的作用范围

:root { /* 全局变量 */
  --color: #007bff;
}
.box { /* 局部变量 */
  --color: #0056b3;
}

全局作用域：通过:root元素定义，作用于整个网页
局部作用域：在特定选择器中定义，仅影响该元素及其子元素的样式

CSS3计算能力

calc()函数可以执行数学运算（加减乘除），支持混合单位示例

  width: calc(80% - 10px); /* 父元素的宽度的80%减去10px */

加减乘除运算写法：+, -, *, /，注意符号左右两侧保留空格

vw/vh

vw和vh是CSS中的视口单位（viewport units），用于基于浏览器视口（viewport）的储存来定义元素的尺寸或位置

vw和vh始终基于浏览器可视区域的实施尺寸计算（不包含浏览器工具栏、地址栏、标签栏等界面元素），他们的值会自动更新。特别适合响应式设计,全屏布局，移动适配等场景。

vw（viewport width）：表示视口宽度的1%
vh（viewport height）：表示视口高度的1%

交互动效设计

Sat, 06 Jun 2026 00:00:00 GMT

交互动效设计

一.变换

csstransform是元素进行2D/3D变换的核心属性，支持平移、旋转、倾斜、缩放、倾斜等效果，且不破坏原有文档流布局

场景：应用非常广泛，通过简介的语法实现复杂的视觉动态效果

坐标系：
变换的时候很多情况需要按照坐标轴来变化，介绍2D坐标系和3D坐标系

2D坐标系

盒子往右是正值，往左是负值盒子往下是正值，往上是负值

3D坐标系

基础变换函数-2D

变换类型	函数语法	核心描述	应用场景
平移	`translate(x, y)`<br>`translateX(x)`<br>`translateY(y)`	沿 X/Y 轴移动元素，参数可为像素或百分比（百分比相对于元素自身尺寸）	微调元素位置、悬停偏移效果
旋转	`rotate(angle)`	以元素中心为基点顺时针旋转，需加单位 `deg`（负值为逆时针）	图标旋转、卡片翻转
缩放	`scale(sx, sy)`<br>`scaleX(sx)`<br>`scaleY(sy)`	X/Y 轴按比例缩放，单参数时等比例缩放（>1 放大，<1 缩小，支持百分比）	悬停放大、焦点突出
倾斜	`skew(x-angle, y-angle)`<br>`skewX(angle)`<br>`skewY(angle)`	沿 X/Y 轴扭曲元素形状，参数为倾斜角度（支持负值）	斜切导航栏、动态图表

1.变换函数-2D平移

平移（translate）沿X/Y轴移动元素位置，不改变元素的实际布局（原位置仍保留）

场景：

悬停元素微调。鼠标放入元素上下或者左右移动（添加过渡更优雅）
元素居中。元素实现水平垂直居中

平移不影响页面布局，仅是视觉上的移动
添加鼠标经过元素移动，优先transform而不是通过left，top等，性能更佳
如果单位是百分比，相对于元素自身尺寸，而非父容器

示例：

.box {
  transition: transform 0.3s;
}

.box:hover {
  transform: translate(10px, 10px);
}

2.变换函数-2D旋转

旋转（rotate）通过改变元素在平面或空间中的角度实现视觉效果

场景：

悬停动画（如按钮旋转）
加载动画（无线循环旋转）

语法：

.box {
  transform: rotate(360deg); /* 旋转 */
  transform-origin: center center; /* 旋转的基点，默认中心 */
}

参数单位：deg(度)，正值是顺时针，负值是逆时针
transform-origin设置旋转中心点
属性值支持left，top等，也可以支持数字比如像素和百分比等

注意：
 行内元素的布局特性（无法设置宽高，盒模型限制，transform基准异常）会破环旋转效果的稳定性，所以文字类要转换行内块或者块级元素，比如字体图标需要转换

3.变换函数-2D缩放

缩放（scale）用于调整元素尺寸，且不改变元素在文档流中的原始占位

场景：

悬停放大。鼠标悬停在元素上时，元素放大

语法： transform: scale(1.5); 整体放大1.5倍 transform: scale(1.5, 1); 水平方向放大，垂直方向不放大

单参数：同时作用于x轴和y轴，等比例缩放
双参数：分别作用于x轴和y轴，不同比例缩放

4.变换函数-2D倾斜

倾斜（skew）用于对元素进行二维*倾斜变换，通过沿x轴或y轴扭曲元素的几何形状

场景：

鼠标经过元素倾斜效果

语法： transform: skew(30deg, 30deg); 水平方向倾斜30度，垂直方向倾斜30度 transform: skewX(30deg); 水平方向倾斜30度，垂直方向不倾斜 transform: skewY(30deg); 垂直方向倾斜30度，水平方向不倾斜

单参数：y轴默认倾斜角度为0
双参数：分别作用于x轴和y轴，不同角度倾斜
transform-origin设置倾斜中心点，默认中心

5.过渡transition完整写法

transition完整写法： transition: 过渡属性持续时间速度曲线延迟时间;

过渡属性：过渡属性属性值变化时触发过渡效果
持续时间：属性值变化时的过渡时间，单位秒
速度曲线：属性值变化时的过渡曲线
延迟时间：属性值变化时的过渡时间延迟，单位秒

过渡属性：过渡属性的值可以是：

none：表示没有过渡效果
all：表示所有可过渡的属性都参与过渡（默认值）
具体属性名：如 transform、opacity、background-color、width、height、margin、padding、border、box-shadow 等常用CSS属性

注意：并非所有CSS属性都可以过渡，只有具有中间值的属性才能实现平滑过渡效果。颜色、尺寸、位置、透明度等连续性属性最适合过渡。

速度曲线：

速度曲线参数	效果描述	曲线可视化
ease	默认值，慢速开始 → 加速 → 慢速结束，适合大多数自然过渡（如按钮悬停）
linear	匀速运动，无加速/减速，适合机械感效果（如进度条）
ease-in	慢速开始 → 逐渐加速，适合元素从静止启动（如弹窗出现）
ease-out	快速开始 → 逐渐减速，适合元素退出（如关闭动画）
ease-in-out	慢速开始和结束，中间加速，适合对称性动画（如页面切换）
cubic-bezier(x1,y1,x2,y2)	贝塞尔曲线。通过四值（0-1范围内）自定义速度曲线，实现弹跳、骤停等创意效果（如按钮点击反馈）

工具：

6.变换函数-复合写法

在css中，transform属性的复合写法是将每个函数用空格隔开（多个变换函数组合使用）

语法； transform: A() B() C();

顺序：

核心规则：从右到左的执行顺序
实际的执行顺序是：先执行最右侧的C()，再执行B()，最后执行A()

示例：轮胎移动效果

.img {
  transition: transform 0.3s;
}

.box:hover img {
  transform: translate(10px, 10px) rotate(360deg);
}

注意： 如果translate和rotate写反了，会导致元素先移动再旋转，效果不符合预期

3D变换与透视

css3D效果通过将二维元素在三位空间中进行变换，为网页添加立体感和动态交互体验

场景：

卡片翻转效果
3D幻灯片/轮播图
数据可视化。立体图表（如3D柱状图等）

相比JavaScript或WebGL，css3D利用GPU加速，动画更流畅，性能更高效

3D坐标系：
网页中的三维坐标系：
坐标数值：

x轴代表左右方向。右边是正值，左边是负值
y轴代表上下方向。上边是正值，下边是负值
z轴代表前后方向。接近屏幕是正值，远离屏幕是负值。

默认情况下，元素在二维平面上呈现，Z轴值为0
当应用3D变换时，元素便可以在三维空间中自由变换

3D旋转

旋转（rotate）通过改变元素在3D空间中的角度实现视觉效果

语法： transform: rotateX(30deg); 围绕x轴旋转30度 transform: rotateY(30deg); 围绕y轴旋转30度 transform: rotateZ(30deg); 围绕z轴旋转30度

参数单位：deg（度），正值是顺时针旋转，负值是逆时针旋转
rotateZ和二维里面的rotate()一样的，只是在3D空间中旋转

透视（Perspective）

”透视“（Perspective）一词源于拉丁文”perspclre“（看透），指在平面上描绘物体的口康健关系的方法或技术。

在css中，透视效果（perspective）用于模拟人眼观察3D空间时的进大远小效果

语法：
perspective: 1000px; 透视距离为1000px

数值越小，透视效果越强
给父元素添加，里面所有子元素都会添加透视效果（常用）
给子元素添加，当前元素添加透视效果

同时使用多个属性： transform: perspective(1000px) rotateX(30deg);

注意：perspective()必须作为transform属性的第一个元素（否则无效）

3D旋转方向：左手大拇指指向坐标轴正方向，四指指向的方向就是正值方向

3D旋转-两面翻转的盒子示例

backface-visibility：当元素旋转时，是否显示背面面

visible：显示背面
hidden：隐藏背面

示例：创建一个正面粉色反面蓝色，悬停时可翻转的盒子

.box {
  position: relative;
  margin: 100px auto;
  width: 600px;
  height: 300px;
}

.box .front,
.box .back {
  position: absolute;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
  /* 元素翻转隐藏背面 */
  backface-visibility: hidden;
  transition: transform 0.6s;
}

.box .front {
  background-color: lightblue;
  transform: rotateY(0deg);
}

.box .back {
  background-color: pink;
  transform: rotateY(-180deg);
}

.box:hover .front {
  transform: rotateY(180deg);
}
.box:hover .back {
  transform: rotateY(0deg);
}

3D位移

CSS 3D函数translatrZ()与translateX3d()

语法：
transform: translateX3d(xpx, ypx, zpx); 沿着x轴移动xpx，y轴移动ypx，z轴移动zpx

在三维空间中同时沿x轴、y轴、z轴平移元素，支持更复杂的空间定位
位移建议通过3D变换强制启用GPU渲染，提升动画流畅度

语法：
transform: translateZ(zpx);

沿z轴平移元素，实现进大远小的立体效果
正值元素放大，负值元素缩小
需父容器设置透视距离（perspective），否则无视觉变化

开启3D空间：
在变换的时候（如卡片翻转）要使子元素保留3D位置，父元素需要设置transform-style: preserve-3d;

transform-style默认值为flat，即2D空间，不保留3D位置
开启3D空间后，子元素会保留3D位置，实现3D效果

二.动画

动画的基本使用

CSS3的animation是一种通过定义关键帧和动画属性来实现元素动态效果的技术

优势：

性能高效：通过浏览器原生支持，利用GPU加速渲染，避免频繁的javascript计算开销
代码简洁：解决了传统CSS过渡（transition）只能定义两帧状态的局限性，可以利用关键帧实现更复杂动画
交互增强：支持与用户操作（如悬停、点击）结合，提升网页的动态变现里和用户体验

关键帧

关键帧（keyframe）是动画和视频制作中用于定义动作或状态变化的核心节点，它决定了动画的其实，转折和结束状态，中间帧（插帧）通过算法自动生成，形成连贯的动画效果

动画的使用

动画的使用要先定义动画，再使用动画

1.定义动画：

@keyframes move {
  0% {
    transform: translateX(0);
  }
  50% {
    transform: translateX(50px);
  }
  100% {
    transform: translateX(100px);
  }
}

@keyframes：定义动画的关键帧
move：动画名称，自定义
0% 50% 100%：关键帧的时间点，0%表示动画开始，50%表示动画中间，100%表示动画结束
关键帧可以定义多个，每个关键帧可以设置不同的属性值

@keyframes move {
  from {
    transform: translateX(0);
  }
  to {
    transform: translateX(100px);
  }
}

from：动画开始时的状态，相当于0%
to：动画结束时的状态，相当于100%

2.使用动画：动画属性要写到目标元素里面

.box {
  animation: move 1s;
}

animation：应用动画
move：动画名称，与定义动画时的名称一致
1s：动画持续时间，单位为秒

animation属性完整写法

animation: 动画名称动画持续时间速度曲线延迟时间播放次数播放方向执行完毕状态;

动画名称和动画时长是必填项，其余可以省略，但是要保证书写顺序
动画属性要写到目标元素里面

step逐帧动画

速度曲线除了常见的linear、ease、cubic-bezier等，还包含steps()函数，steps()是CSS动画中用于控制动画分段执行的计时函数，它通过将动画分割为离散的步骤，实现类似传统帧动画（逐帧动画）的跳跃效果

语法：

animation: move 1s steps(8) infinite;

steps(步数)，步数为正整数
经常和背景图片（精灵图）来实现动画效果

逐帧动画原理：

移动图片。其实是通过变化背景位置，展示不同的图片帧，实现动画效果
图片有N个不同图形，steps()步数就写N

示例：

盒子大小：宽度548px，高度513px
背景图片大小：宽度13700px，高度513px
背景图片一共有25张小图片组成

@keyframes move {
  0% {
    background-position: 0 0;
  }
  100% {
    background-position: -13700px 0;
  }
}

.box {
  width: 548px;
  height: 513px;
  background: url(./images/box.png) no-repeat left/13700px 513px;
  /* 使用动画 */
  animation: move 1s steps(25) infinite;
}

动画单写属性

动画子属性	默认值	说明
`animation-timing-function`	`ease`	动画速度曲线，支持 `linear`、`cubic-bezier()` 等
`animation-delay`	`0s`	动画延迟时间，可设为负值（跳过部分动画）
`animation-iteration-count`	`1`	播放次数，若需无限循环需显式声明 `infinite`
`animation-direction`	`normal`	播放方向，可选 `reverse`（反向）、`alternate`（交替）
`animation-fill-mode`	`none`	执行完毕状态，动画结束后是否保留样式（如 `forwards` 保留最后一帧）
`animation-play-state`	`running`	暂停或者继续动画，需单独设置 `paused` 暂停动画

三.其他效果

box-reflect: 倒影效果

box-reflect是css中用于为元素创建倒影效果语法； box-reflect: 倒影方向倒影距离倒影图像

倒影方向（必写）：

above:倒影在元素上方
below:倒影在元素下方
left:倒影在元素左侧
right:倒影在元素右侧

倒影距离（必写）：

倒影距离，单位为像素

倒影图像（可选）：

倒影图像，可选值还有none（无倒影）
url(./images/reflect.png)：倒影图像，可选值还有linear-gradient()（线性渐变）、radial-gradient()（径向渐变）等

注意，因为兼容性问题，前面需要添加-webkit-前缀，例如-webkit-box-reflect: below 10px #f5f5f5;

:has() 父亲选择器

:has()选择器是css中用于选择包含指定子元素的元素语法； :has(子元素)

子元素（必写）：
- 子元素，可选值还有::first-child（第一个子元素）、::last-child（最后一个子元素）、::nth-child(第n个子元素)（第n个子元素）等
- 例如：:has(子元素)：选择包含子元素的元素
- 例如：:has(子元素):nth-child(2)：选择包含子元素的第2个子元素

:not() 反选器

:not()选择器是css中用于选择不包含指定子元素的元素语法； :not(子元素)

子元素（必写）：
- 子元素，可选值还有::first-child（第一个子元素）、::last-child（最后一个子元素）、::nth-child(第n个子元素)（第n个子元素）等
- 例如：:not(子元素)：选择不包含子元素的元素
- 例如：:not(子元素):nth-child(2)：选择不包含子元素的第2个子元素

opacity 透明度

opacity是css中用于设置元素透明度的属性语法； opacity: 透明度值

透明度值（必写）：
- 透明度值，取值范围为0到1之间
- 0：完全透明
- 1：完全不透明
- 0.5：半透明
- 例如：opacity: 0.5;：设置元素透明度为0.5

现代网页布局

Wed, 03 Jun 2026 00:00:00 GMT

现代网页布局

CSS 布局是网页设计的核心技术之一，用于控制元素在页面中的排列方式

常见布局技术

布局技术	英文名称	核心特点
正常布局	`normal`	遵循浏览器默认的文档流规则
模式转换布局	`display`	通过 `display` 属性改变元素显示模式
弹性布局	`flexbox`	一维布局，适合灵活排列子元素
定位布局	`position`	通过定位属性精确控制元素位置
网格布局	`grid`	二维布局，适合复杂的行列结构
多列布局	`column`	实现文本或元素的多列排版

每种技术都有它们的用途，各有优缺点，相互辅助

简单布局：优先使用 Flexbox（一维） 或 Grid（二维）。
复杂响应式布局：使用 Grid + 媒体查询。
文本内容分栏：使用多列布局（column-count）。
兼容旧浏览器：使用浮动布局或 Flexbox 的降级方案。
趋势：CSS Grid 逐渐成为主流，支持更复杂的布局场景。

一.CSS 正常布局流

正常布局流是指在不对页面进行任何布局控制时，浏览器默认的 HTML 布局方式，也称为标准流。它是 CSS 布局的基石，页面大的布局基本就是利用区块元素上下罗列而成。

区块元素（block）

独占一行，宽度默认撑满父容器。
垂直方向排列，可设置宽高。
示例：div、p、h1 等。

行内元素（inline）

水平方向依次排列，直到容器宽度不足则换行。
宽度和高度由内容决定，无法直接设置。
示例：span、img、strong 等。

文档流方向

默认从上到下、从左到右排列。

二.display转换

正常流中的所有内容都有一个display的属性，用作指定元素的显示模式。
但是开发的时候，我们需要一个块级盒子一行排列，或者行内元素需要设置大小，怎么办？
display属性允许我们更改元素默认的显示模式

display: block;：转换为区块元素，独占一行，可设置宽高，默认宽度撑满父容器
display: inline;：转换为行内元素，不独占一行，不可设置宽高，默认宽度由内容决定
display: inline-block;：转换为行内块元素，不独占一行，可设置宽高，默认宽度由内容决定

属性值	是否独占一行	能否设置宽高	默认宽度
`block`	是	能	撑满父容器
`inline`	否	不能	内容决定
`inline-block`	否	能	内容决定

表单元素默认inline-block,其他元素想要转换可以: display: inline-block;

使用场景

让块级盒子一行显示
让行内盒子具备宽度和高度

注意

行内块元素中间会有空白缝隙，给父元素字号改为0可以去掉
实际开发适合于对间距要求不高的情况下可以转换
如果真的想要精细布局，请用flex或者grid布局更合适

三.被放弃的浮动

浮动(float)最早是做“文字环绕”效果的

浮动(float)可以让元素脱离文档流，向左或向右浮动，知道碰到父容器边缘或其他浮动元素

属性值	说明
`float: left;`	向左浮动
`float: right;`	向右浮动

浮动带来的影响：

父盒子没有高度（很多情况下不能给父亲指定高度）
子元素浮动
影响其他盒子布局了

清除浮动

清楚浮动也可以理解为闭合浮动，简单来说，就是让浮动的元素尽量控制在父盒子内，不要影响其他盒子

清楚浮动主要有四种方式：

1.额外标签法：在浮动元素的最后面新增一个块级标签。添加属性clear: both;

2.单伪元素清除浮动：父元素添加伪元素

.clearfix::after{
  visibility: hidden;
  content: "";
  clear: both;
  display: block;
  height: 0;
}

3.双伪元素清除浮动：父元素添加双伪元素

.clearfix::after,
.clearfix::before{
  content: "";
  display: table;
} 
.clearfix::after{
  clear: both;
}

4.overflow属性清除浮动：父元素添加overflow属性

.clearfix{
  overflow: auto;
}

四.弹性盒子

Flexbox是CSS弹性盒子布局模块（Flexible Box Layout Module）的缩写，可以快速实现元素的对齐、分布和空间分配。

弹性盒布局-display:flex

弹性盒子核心：

父控子（亲父子）

父盒子控制子盒子如何排列布局
父盒子称为容器，子盒子称为项目

主轴和交叉轴（侧轴）

主轴（main axis）：默认水平方向，项目沿主轴排列
交叉轴（cross axis）：默认垂直方向，项目沿交叉轴排列

容器（父盒子）属性：

属性	作用	示例
display	定义元素为 Flex 容器	.container { display: flex; }
flex-direction	定义主轴方向（项目排列方向）	.container { flex-direction: row; }
flex-wrap	控制是否换行	.container { flex-wrap: wrap; }
justify-content	定义主轴上的对齐方式（整体分布）	.container { justify-content: center; }
align-items	定义交叉轴上的对齐方式（单行时整体对齐）	.container { align-items: center; }
align-content	定义多行时交叉轴上的对齐方式（仅当 flex-wrap: wrap 且内容换行时生效）	.container { align-content: space-between; }

项目（子盒子）属性：

属性	作用	示例
order	定义项目的排列顺序（默认 0，数值越小越靠前）	.item { order: -1; }
flex-grow	定义项目的放大比例（默认 0，即不放大）	.item { flex-grow: 1; }
flex-shrink	定义项目的缩小比例（默认 1，空间不足时等比缩小）	.item { flex-shrink: 0; }
flex-basis	定义项目在主轴方向上的初始大小（优先级高于 width/height）	.item { flex-basis: 200px; }
flex	flex-grow、flex-shrink、flex-basis 的简写	.item { flex: 1; }
align-self	覆盖容器的 align-items，单独定义某个项目的交叉轴对齐方式	.item { align-self: center; }

容器（父盒子）设置display: flex;可以让盒子按照主轴方式排列。

如果子元素有大小，则按照给定大小来显示
如果子元素没有大小，则拉伸从满父容器
若子元素总宽度超过容器宽度，默认会压缩子元素

开发中大部分情况下，父容器设置display: flex,子元素设定大小

弹性盒布局-主轴和交叉轴对齐

justify-content定义主轴上的对齐方式

属性值	效果	示例
flex-start	左对齐（默认）	子元素靠左排列
flex-end	右对齐	子元素靠右排列
center	居中对齐	子元素居中
space-between	两端对齐	首个子元素放置于起点，末尾元素放置于终点
space-around	项目两侧间隔相等	每个子元素周围分配相同的空间
space-evenly	项目间隔均匀分布	每个子元素之间的间隔相等

align-items定义交叉轴上的对齐方式（单行时整体对齐）

属性值	作用描述
flex-start	项目在交叉轴起点对齐（默认值）
flex-end	项目在交叉轴终点对齐
center	项目在交叉轴居中对齐
stretch	项目拉伸填充整个容器高度（需子项目无固定高度）

弹性盒布局-改变主轴方向flex-direction

flex-direction定义主轴方向（改变主轴方向）

属性值	描述	示例效果	代码示例
row	主轴为水平方向，项目从左至右排列（默认值）	A B C	.container { flex-direction: row; }
row-reverse	主轴为水平方向，项目从右至左排列	C B A	.container { flex-direction: row-reverse; }
column	主轴为垂直方向，项目从上至下排列	ABC	.container { flex-direction: column; }
column-reverse	主轴为垂直方向，项目从下至上排列	CBA	.container { flex-direction: column-reverse; }

弹性盒布局-换行wrap以及多行交叉轴对齐

flex-wrap控制是否换行

属性值	排列效果
nowrap	不换行，所有项目横向排列（可能会被压缩）
wrap	换行，第一行在上方，第二行在下方
wrap-reverse	换行，第一行在下方，第二行在上方（顺序翻转）

align-content定义多行时交叉轴上的对齐方式（仅当flex-wrap:wrap且内容换行时生效）

属性值	效果	说明
flex-start	上对齐	子元素在容器头部（顶部）对齐，默认排列方式
flex-end	下对齐	子元素在容器尾部（底部）对齐
center	居中对齐	子元素在容器垂直方向居中排列
space-between	两端对齐	子元素平均分布在容器内，首尾子元素分别贴紧容器两端（中间无空隙）
space-around	两侧间隔相等	每个子元素两侧的间距相等，整体间距均匀分布
space-evenly	间隔均匀分布	子元素及容器两端的间距完全一致，分布最均匀

开发中大部分情况下，该属性使用较少，大部分子元素顺序排列即可

弹性盒布局-子项目flex伸缩以及gap间隙

子项目flex伸缩

子元素的属性用于控制自身的尺寸、顺序或对齐方式。

语法： flex: 1;

表示该子元素占据1份剩余空间，并且可以伸缩盒子大小。
数字为正整数，代表子元素在剩余空间中所占的份数。

属性	作用	示例
flex-grow	定义子元素剩余空间分配放大比例（默认0，即不放大）	.item { flex-grow: 1; }
flex-shrink	定义子元素剩余空间分配缩小比例（默认1，空间不足时等比缩小，0为不缩小）	.item { flex-shrink: 0; }
flex-basis	定义项目在主轴方向上的初始大小（默认auto，优先级高于width/height）	.item { flex-basis: 200px; }
flex	flex-grow、flex-shrink、flex-basis的简写flex: 1 → 1 1 0%（等比放大/收缩，初始无基准尺寸）flex: 2 → 2 1 0%（等比放大/收缩，初始无基准尺寸）	.item { flex: 1; }
align-self	覆盖容器的align-items，单独定义某个项目的交叉轴对齐方式	.item { align-self: center; }
order	定义项目的排列顺序（默认0，数值越小越靠前）	.item { order: -1; }

gap间距

gap：简写属性，用于设置行与列之间的间隙（间距）
使用场景：让子元素之间保留间隙
语法：
- gap: 20px;：行和列之间保持20像素间隙
- gap: 20px 30px;：行间距20像素，列间距30像素
注意：gap 需写在父元素（容器）上

小总结

容器属性（作用于父元素）

属性	取值示例（含注释）	中文说明
display	flex —— 启用弹性盒布局	将元素设为 Flex 容器，子元素变为 Flex 项目
flex-direction	row —— 水平从左到右（默认）row-reverse —— 水平从右到左column —— 垂直从上到下column-reverse —— 垂直从下到上	定义主轴方向（即项目排列方向）
flex-wrap	nowrap —— 不换行（默认）wrap —— 换行，新行在下方wrap-reverse —— 换行，新行在上方	控制项目是否换行及堆叠方向
justify-content	flex-start —— 主轴起点对齐（默认）flex-end —— 主轴终点对齐center —— 主轴居中对齐space-between —— 两端对齐，中间等间距space-around —— 每个项目两侧等间距space-evenly —— 所有间距（包括边缘）完全相等	定义项目在主轴上的对齐与分布方式
align-items	stretch —— 拉伸填满交叉轴（默认，高度/宽度未设时生效）flex-start —— 交叉轴起点对齐flex-end —— 交叉轴终点对齐center —— 交叉轴居中对齐baseline —— 按文字基线对齐	定义单行项目在交叉轴上的对齐方式
align-content	stretch —— 行拉伸填满剩余空间（默认）flex-start —— 多行交叉轴起点对齐flex-end —— 多行交叉轴终点对齐center —— 多行居中对齐space-between —— 行两端对齐，中间空隙均等space-around —— 行之间均匀环绕	定义多行项目在交叉轴上的分布方式（仅当 flex-wrap: wrap 且有多行时生效）

项目属性（作用于子元素）

属性	取值示例（含注释）	中文说明
flex-grow	0 —— 不放大（默认）1、2 —— 按比例放大（如两个项目都为1，则平分剩余空间）	空间有剩余时，项目的放大比例
flex-shrink	1 —— 可缩小（默认）0 —— 禁止缩小2 —— 缩小比例更高	空间不足时，项目的缩小比例
flex-basis	auto —— 根据内容或 width/height 决定（默认）100px —— 初始主轴尺寸为100px20% —— 占主轴20%	分配多余空间前，项目在主轴上的基准尺寸
flex	0 1 auto —— 默认值（不放大、不缩小、基准为auto）1 —— 常用：等价于 1 1 0%（自动占满剩余空间，自适应大小）none —— 等价于 0 0 auto（固定大小，不伸缩）	flex-grow、flex-shrink、flex-basis 的简写形式
align-self	auto —— 继承容器的 align-items（默认）flex-start / center / stretch 等 —— 覆盖容器设置	单个项目在交叉轴上的对齐方式（可单独设置）
order	0 —— 默认顺序-1 —— 排在前面2 —— 排在后面	控制项目显示顺序（数值越小越靠前，可为负数）

弹性盒布局-淘宝京东多行伸缩布局

淘宝：

<html>
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>弹性盒布局-子项目flex伸缩以及gap间隙</title>
    <style>
      *{
        margin: 0;
        padding: 0;
        box-sizing: border-box;
      }
      .w {
        width: 80%;
        margin: 20px auto;

      }
      .box {
        display: flex;
        flex-wrap: wrap;

        margin-left: -8px;
        margin-right: -8px;
      }
      .box .item {
        flex: 0 0 16.666666%;
        height: 120px;
        margin-bottom: 16px;
        /* margin-right: 16px; */
        padding: 0 8px;
      }
      .item .content{
        width: 100%;
        height: 100%;
        background-color: lightblue;
      }
      .footer{
        width: 80%;
        height: 120px;
        background-color: black;
        margin: 0 auto;
      }
    </style>
  </head>
  <body>
    <div class="w">
      <div class="box">
      <div class="item">
        <div class="content"></div>
      </div>
      <div class="item">
        <div class="content"></div>
      </div>
      <div class="item">
        <div class="content"></div>
      </div>
      <div class="item">
        <div class="content"></div>
      </div>
      <div class="item">
        <div class="content"></div>
      </div>
      <div class="item">
        <div class="content"></div>
      </div>
      <div class="item">
        <div class="content"></div>
      </div>
      <div class="item">
        <div class="content"></div>
      </div>
      <div class="item">
        <div class="content"></div>
      </div>
      <div class="item">
        <div class="content"></div>
      </div>
      <div class="item">
        <div class="content"></div>
      </div>
      <div class="item">
        <div class="content"></div>
      </div>
      <div class="item">
        <div class="content"></div>
      </div>
      <div class="item">
        <div class="content"></div>
      </div>
      <div class="item">
        <div class="content"></div>
      </div>
      <div class="item">
        <div class="content"></div>
      </div>
      <div class="item">
        <div class="content"></div>
      </div>
      </div>
    </div>
    <div class="footer">
      <div class="content"></div>
    </div>
  </body>
</html>

京东：

<html>
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>弹性盒布局-子项目flex伸缩以及gap间隙</title>
    <style>
      *{
        margin: 0;
        padding: 0;
        box-sizing: border-box;
      }

      .box {
        display: flex;
        flex-wrap: wrap;
        width: 80%;
        margin: 0 auto;
        border: 1px solid red;
      }
      .box .item {
        flex: 1;
        width: 80px;
        height: 120px;
        background-color: pink;

        min-width: calc(16.666666666666664% - 16px);
        max-width: calc(16.666666666666664% - 16px);

        margin: 0 8px 16px;
      }
      .footer{
        width: 80%;
        height: 120px;
        background-color: black;
        margin: 0 auto;
      }
    </style>
  </head>
  <body>
    <div class="box">
      <div class="item">1</div>
      <div class="item">2</div>
      <div class="item">3</div>
      <div class="item">4</div>
      <div class="item">5</div>
      <div class="item">6</div>
      <div class="item">7</div>
      <div class="item">8</div>
      <div class="item">9</div>
      <div class="item">10</div>
      <div class="item">11</div>
      <div class="item">12</div>
      <div class="item">13</div>
      <div class="item">14</div>
      <div class="item">15</div>
      <div class="item">16</div>
    </div>

    <div class="footer">
    </div>
  </body>
</html>

这种多行多列这种布局，不是flex布局的强项，所以我们一般会使用grid布局来实现。

弹性盒布局-瀑布流百度图片综合案例

<html>
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>瀑布流</title>
    <link rel="stylesheet" href="./瀑布流.css">
  </head>
  <body>
    <div class="box">
      <div class="column">
        <div class="a">
          <img src="/images/posts/page_layouts/1.jpg" alt="">
        </div>
        <div class="a">
          <img src="./2.jpg" alt="">
        </div>
        <div class="a">
          <img src="./3.jpg" alt="">
        </div>
        <div class="a">
          <img src="./4.png" alt="">
        </div>
        <div class="a">
          <img src="./5.jpg" alt="">
        </div>
        <div class="a">
          <img src="./6.jpg" alt="">
        </div>
        <div class="a">
          <img src="./7.jpg" alt="">
        </div>
        <div class="a">
          <img src="./8.jpg" alt="">
        </div>
      </div>
      <div class="column">
        <div class="a">
          <img src="./9.jpg" alt="">
        </div>
        <div class="a">
          <img src="./10.jpg" alt="">
        </div>
        <div class="a">
          <img src="./11.jpg" alt="">
        </div>
        <div class="a">
          <img src="./12.jpg" alt="">
        </div>
        <div class="a">
          <img src="./13.jpg" alt="">
        </div>
        <div class="a">
          <img src="./14.webp" alt="">
        </div>
        <div class="a">
          <img src="./15.png" alt="">
        </div>
        <div class="a">
          <img src="./16.png" alt="">
        </div>
      </div>
      <div class="column">
        <div class="a">
          <img src="./17.png" alt="">
        </div>
        <div class="a">
          <img src="./18.webp" alt="">
        </div>
        <div class="a">
          <img src="./19.webp" alt="">
        </div>
        <div class="a">
          <img src="./20.jpg" alt="">
        </div>
        <div class="a">
          <img src="./21.webp" alt="">
        </div>
        <div class="a">
          <img src="./22.webp" alt="">
        </div>
        <div class="a">
          <img src="./23.webp" alt="">
        </div>
        <div class="a">
          <img src="./24.webp" alt="">
        </div>
      </div>
      <div class="column">
        <div class="a">
          <img src="./25.webp" alt="">
        </div>
        <div class="a">
          <img src="./26.webp" alt="">
        </div>
        <div class="a">
          <img src="./27.webp" alt="">
        </div>
        <div class="a">
          <img src="./28.webp" alt="">
        </div>
        <div class="a">
          <img src="./29.png" alt="">
        </div>
        <div class="a">
          <img src="./30.png" alt="">
        </div>
        <div class="a">
          <img src="./31.jpg" alt="">
        </div>
        <div class="a">
          <img src="./32.jpg" alt="">
        </div>
      </div>
      <div class="column">
        <div class="a">
          <img src="./33.webp" alt="">
        </div>
        <div class="a">
          <img src="./34.webp" alt="">
        </div>
        <div class="a">
          <img src="./35.jpg" alt="">
        </div>
        <div class="a">
          <img src="./36.jpg" alt="">
        </div>
        <div class="a">
          <img src="./37.jpg" alt="">
        </div>
        <div class="a">
          <img src="./38.jpg" alt="">
        </div>
        <div class="a">
          <img src="./39.jpg" alt="">
        </div>
        <div class="a">
          <img src="./40.jpg" alt="">
        </div>
      </div>
    </div>

  </body>
</html>

* {
  margin: 0;
  padding: 0;
  box-sizing: border-box;
}

.box {
  gap: 16px;
  display: flex;
  width: 80%;
  margin: 10px auto;
}

.box .column {
  flex: 1;
}

.box .column .a {
  overflow: hidden;
  display: block;
  border-radius: 20px;
  width: 100%;
  margin-bottom: 16px;
}

.box .column .a img {
  width: 100%;
}

垂直对齐-解决底部空白缝隙的问题

基线：浏览器**行内元素（行内块元素）**排版中存在用于对齐的基线（baseline）

![alt text](image-1.png null)

图片默认和文字基线对齐

解决方法

把图片转换为块级元素
设置图片对齐方式不是基线对齐即可

vertical-align属性值

值	描述
baseline	默认值。元素的基线对齐
top	把元素的垂直对齐位置设置为顶部
middle	把元素的垂直对齐位置设置为中间
bottom	把元素的垂直对齐位置设置为底部

img {
  <!-- 防止浏览器默认给图片添加边框 -->
  border: 0;
  <!-- 垂直居中对齐 -->
  vertical-align: middle;
}

五.定位布局

CSS定位布局（position）是控制元素在页面中位置的核心技术之一。通过定位，可以实现元素脱离文档流，层叠，固定在特定位置的布局效果（定位跟位置有关）

场景：

固定导航栏：页面滚动时导航栏始终固定在视口顶部
吸顶效果：元素在滚动到某个位置后固定
弹出菜单/下拉框：鼠标悬停是显示浮动菜单
悬浮效果：元素悬浮在其他元素上方 ...

定位分类：

相对定位
绝对定位
固定定位
粘性定位

相对定位

CSS相对定位（position: relative;）是布局中常用的定位方式，其核心在于元素相对于自身正常位置进行偏移

场景：

和绝对定位搭配使用，主要作用是给绝对定位当爹的

语法：

/* 设定元素为相对定位 */
.relative {
  position: relative;
}

相对于自身原来位置移动距离
不脱离正常流，元素原位置仍被保留，其他元素按布局排列
可以通过top、right、bottom、left属性进行偏移，也可以通过inset属性，同时设置四个方向的偏移距离
优先级：若同时设置top和bottom，仅生效top，同理left覆盖right

示例：

/* 相对定位 */
.relative {
  position: relative;
  /* 相对自身顶部向下移动10px */
  top: 10px;
  /* 相对自身左侧向右移动10px */
  left: 10px;
}

绝对定位

CSS绝对定位（position: absolute;）核心是脱离正常文档流并基于定位基准进行偏移

场景：

弹出菜单/下拉框：鼠标悬停是显示浮动菜单
悬浮效果：元素悬浮在其他元素上方

语法:

/* 设定元素为绝对定位 */
.absolute {
  position: absolute;
}

元素脱离正常流，不占据空间，其他元素按原布局排列
相对于最近的已定位祖先元素（position非static）移动位置，若都无定位，则相对于视口来定位
可以通过top、right、bottom、left属性进行偏移
优先级：若同时设置top和bottom，仅生效top，同理left覆盖right

示例：

/* 绝对定位 */
/* 父元素 */
.father {
  position: relative;
  width: 200px;
  height: 200px;
  background-color: pink;
}

/* 子元素 */
.son {
  position: absolute;
  width: 100px;
  height: 100px;
  background-color: red;
  /* 相对父元素顶部向下移动10px */
  top: 10px;
  /* 相对父元素左侧向右移动10px */
  left: 10px;
}

定位-子绝父相

为什么是子绝父相？

子元素可以悬浮其他元素上方，就不能占有位置，影响其他元素布局，所以绝对定位
但是子元素不能随便乱跑，要配合父元素移动位置，此时父元素需要加定位
父元素需要站原来的位置，不能影响其他元素布局，此时相对定位最合适

小技巧1-圆点变化

如果用边框，会比较麻烦：

边框要增大，需要修改盒子模型为box-sizing: content-box;
盒子变大，会影响后面小圆点的排列

如果用阴影更简单：阴影不占位置，所以不会增加盒子大小，从而不影响布局

/* 阴影 */
.shadow {
  box-shadow: 0 0 0 10px rgba(0, 0, 0, 0.5);
}

小技巧2-定位的盒子垂直居中

/* 定位的盒子垂直居中 */
.vertical-center {
  width: 100px;
  height: 100px;
  background-color: blue;
  position: absolute;
  /* 往下走父盒子自身高度的一半 */
  top: 50%;
  /* 往上走自身高度的一半 */
  margin-top: -50px;
}

固定定位

CSS固定定位（position: fixed;）是一种将元素脱离文档流并始终相对于浏览器窗口定位的布局技术

场景：

固定导航栏：页面滚动时导航栏始终固定在视口顶部
页面广告：广告覆盖整个页面

语法：

/* 设定元素为固定定位 */
.fixed {
  position: fixed;
}

元素脱离正常流，不占据空间，其他元素按原布局排列
相对于浏览器窗口定位位置，滚动页面时位置不变
可以通过top、right、bottom、left属性进行偏移
优先级：若同时设置top和bottom，仅生效top，同理left覆盖right

示例：

/* 固定定位 */
.fixed {
  /* 固定定位 */
  position: fixed;
  width: 600px;
  height: 120px;
  border-radius: 15px;
  /* 偏移调整 */
  left: 50%;
  margin-left: -300px;
  bottom: 20px;
  /* 背景颜色 */
  background-color: pink;
  /* 文字对齐 */
  text-align: center;
  line-height: 60px;
}

效果：

粘性定位

CSS粘性定位（position: sticky;）是一种混合定位模式，结合了相对定位（relative）和固定定位（fixed）的特性

场景：

吸顶效果：元素在滚动到某个位置后固定
变革表头固定：长表格滚动时表头始终可见

语法：

/* 设定元素为粘性定位 */
.sticky {
  position: sticky;
}

元素在滚动到指定位置（如top: 10px），相对于最近的已定位祖先元素前为相对定位，之后转为固定定位
父容器的overdlow需为visible,否则粘性定位无效
可以通过top、right、bottom、left属性进行偏移
需指定top,right,bottom,left中之一，才可使粘性定位生效

示例（滑动表格，表头固定）：

/* 粘性定位 */
.sticky {
  position: sticky;
  top: 0px;
}

定位布局-层叠顺序

z-index属性用于控制元素在三维空间中的层叠顺序（即z轴方向）。当多个元素在同一个平面（如同一行或列）重叠时，z-index决定哪个元素在最上层

场景：

提高层级悬浮效果（如导航栏）
实现图片层叠效果

语法：

/* 设定元素为层叠顺序 */
.z-index {
  z-index: 数值;
}

值类型：整数（整数，负数，零）或auto，数值越大，层级越高
默认值：auto（等同于未设置，后出现的元素覆盖前者）
生效条件：仅对定位元素（position值为relative、absolute、fixed、sticky）有效

定位总结

定位类型	脱离文档流	定位基准	层叠控制	典型场景
static	否	默认文档流	无	普通元素布局
relative	否	自身正常位置	支持	微调元素、子绝父相
absolute	是	最近定位祖先 / 视口	支持	弹窗、下拉菜单、悬浮元素
fixed	是	视口	支持	固定导航栏、返回顶部按钮
sticky	否	视口或滚动祖先	支持	吸顶导航栏、侧边栏固定

定位属性：

position: （static/relative/absolute/fixed/sticky）
偏移属性：（top、right、bottom、left）
z-index：（控制层叠顺序，数值越大层级越高）

常见组合：

固定导航栏：position: fixed; + z-index: 100;
弹窗：position: absolute; + 居中技巧 + z-index: 1000;
吸顶效果：position: sticky; + top: 0;

六.网格布局

1.基本概念

网格布局时一种二位布局模型，允许开发者通过定义行（rows）和列（columns）来精确控制网页元素的位置和尺寸，还可以实现响应式设计

网格布局的核心：创建好网格并放入各类元素
开发常见：单行布局用flex，多行或者响应式用grid

2.网格容器

容器（父盒子）设置display: grid;（块级）或者display: inline-grid;（行内）
与弹性盒子不同的是，在定义网格后，网页并不会马上发生变化，因为display: grid;的声明之创建了一个只有一列的网格容器

3.网格轨道

网格轨道（grid track）决定了网格容器的基础布局结构，为子元素提供放置的位置

绘制网格：（网格轨道） grid-template-columns定义网格中的列，每个值代表一列的宽度 grid-template-rows定义网格中的行，每个值代表一行的高度

grid-template: grid-template-columns / grid-template-rows; 同时定义列和行

属性值：

几个属性值代表创建几列/行
长度单位（px、fr等）

属性值	说明	示例	应用场景
固定长度	使用 px、em 等固定单位定义列宽	`grid-template-columns: 100px 200px;`	需要精确控制列宽的固定布局
百分比	按容器宽度百分比分配列宽	`grid-template-columns: 30% 70%;`	响应式布局中按比例划分列
fr 单位	分配轨道剩余空间的比例（1fr 表示一份，总和为容器剩余空间，fr 是 fraction 缩写，意为分数）	`grid-template-columns: 1fr 2fr;`	需要自适应比例分配的布局
auto	列宽由内容自动撑开	`grid-template-columns: auto 100px;`	内容宽度不确定时的灵活布局
repeat() 函数	简化重复的列定义	`grid-template-columns: repeat(3, 1fr);`（等效于 `1fr 1fr 1fr`）	多列等宽布局
minmax() 函数	定义列宽的最小值和最大值	`grid-template-columns: minmax(100px, 1fr);`	响应式布局中限制列宽范围

示例：

.grid {
  display: grid;
  /* 定义三列，每列宽度为200px */
  grid-template-columns: 200px 200px 200px;
  /* 定义三行，每行高度为200px */
  grid-template-rows: 200px 200px 200px;
}

技巧：如果想不限制行数，可以不设置grid-template-rows，给子盒子定义高度即可，父盒子会自动调整行数以适应子盒子的高度

repeat() 函数

语法： repeat(次数，轨道尺寸)或repeat(自动填充，轨道尺寸)

自动填充：适用于响应式布局中“列数随容器宽度变化”的场景 auto-fill：尽可能多地创建列 auto-fit：尽可能拉伸列填满容器（会合并空白，列宽不小于minmax的最小值）

区别：

auto-fill：会创建 as many columns as possible（尽可能多地创建列），直到容器宽度不足，留有空白空间

空白空间的地方也是被创建的列，只是没有内容，总共不止4列

auto-fit：会创建 as many columns as possible（尽可能多地伸展列），直到容器宽度不足，填满空白空间

空白的地方被拉伸填满，总共只有4列

minmax() 函数

语法： minmax(最小值，最大值)

最小值：定义轨道的最小尺寸 最大值：定义轨道的最大尺寸

响应式布局示例：

.grid {
  display: grid;
  /* 响应式布局，列数随容器宽度变化，列宽在100px到1fr之间 */
  grid-template-columns: minmax(auto-fill, minmax(100px, 1fr));
}

4.网格轨道-对齐方式

justify-content是控制列轨道（Columns Tracks）在容器内水平分布 align-content是控制行轨道（Rows Tracks）在容器内垂直分布

属性值	水平方向效果	垂直方向效果
start（默认值）	左对齐	顶部对齐
end	右对齐	底部对齐
center	水平居中对齐	垂直居中对齐
space-around	两侧留出相等的空白，项目周围空间均匀分布	上下留出相等的空白，项目周围空间均匀分布
space-between	首尾项目贴边	上下项目贴边
space-evenly	项目间、首尾与边界的空白相等	项目间、首尾与边界的空白相等

5.网格间距

gap简写属性用于设置行与列之间的间隙（网格间距）

语法： gap: 20px; 行和列之间的保持20像素间隙 gap: 20px 40px; 行之间的保持20像素间隙，列之间的保持40像素间隙

注意：gap是简写形式也可以分开写 column-gap: 20px; 行之间的保持20像素间隙 row-gap: 40px; 列之间的保持40像素间隙

6.网格线

网格线会在使用网格布局时被创建，线编号从1开始计算，3列就会有4根线

使用场景：

实现元素跨越多个网格单元

实现语法1：

跨列：grid-column: 开始线编号/结束线编号;
跨行：grid-row: 开始线编号/结束线编号;

注意：该属性要加到项目（子元素）上

示例：

.grid .item:first-child {
  /* ... */
  /* 跨列 */
  grid-column: 1 / 3;
  /* 跨行 */
  grid-row: 1 / 3;
}

效果：

实现语法2：

跨列：grid-column: 开始线编号/span 跨单元格数量;
跨行：grid-row: 开始线编号/span 跨单元格数量;

示例：

.grid .item:first-child {
  /* ... */
  /* 跨列 1到3列 */
  grid-column: 1 / span 2;
  /* 跨行 1到3行 */
  grid-row: 1 / span 2;
}

效果同上

7.网格填充方式

grid-auto-flow决定网格容器中子元素排列填充方式

语法：

grid-auto-flow: column; 子元素按先行后列顺序填充，优先填满一列后换列
grid-auto-flow: row; 子元素按先列后行顺序填充，优先填满一行后换行

场景： b站布局中有些子元素是按照列方式显示

object-fit

object-fit是css中用于控制替换元素（如<img>、<video>、<iframe>等加载外部资源的元素）内容如何适应其容器尺寸的属性

值	描述
fill	默认值。拉伸内容以完全填充容器，不保持宽高比，可能导致内容变形（最常用但需谨慎）
contain	保持内容固有宽高比，缩放至完全适应容器内部（内容全部可见），容器可能有空白（类似“适应”模式）
cover	保持内容固有宽高比，缩放至覆盖容器（内容可能部分被裁剪），容器无空白（类似“填充”模式）

配合object-position：

object-position 用于控制替换元素内容在容器内的对齐位置，配合 object-fit 使用可以精确控制内容的显示区域。

语法：

object-position: <x-position> <y-position>;

常用值：

值类型	示例	描述
关键字	`left` / `center` / `right` / `top` / `bottom`	基本方向对齐
百分比	`50% 50%`	水平和垂直位置百分比（默认值，居中）
长度值	`10px 20px`	具体像素或其他长度单位
混合值	`left 50%`	关键字与百分比/长度混合使用

使用示例：

/* 左对齐 */
img {
  object-fit: cover;
  object-position: left;
}

/* 左上角对齐 */
img {
  object-fit: cover;
  object-position: 0 0;
}

/* 向左移动10%，垂直居中 */
img {
  object-fit: cover;
  object-position: 10% center;
}

/* 向右移动20px，向下移动30px */
img {
  object-fit: cover;
  object-position: 20px 30px;
}

应用场景：

图片裁剪时需要显示特定区域（如人物照片只显示面部）
响应式布局中保持图片的重要内容可见
视频播放器中控制视频画面的显示位置

注意事项：

仅对替换元素有效（img、video、canvas等）
需要与 object-fit 配合使用才能发挥最大效果
百分比值的参考系是容器的尺寸，而非内容本身的尺寸

8.项目对齐方式

在css grid布局中，控制单元格里的子元素的对齐方式

场景：

元素在网格内对齐

语法：

justfy-items: 水平对齐方式; 水平方向（行轴）
align-items: 垂直对齐方式; 垂直方向（列轴）
place-items: 水平对齐方式垂直对齐方式; 同时设置水平和垂直对齐方式

为了提高可读性和兼容性，体长使用前面两种方式

注意：

该属性要加到网格容器上，而不是项目上
不要和align-content，justify-content混淆
点我跳转轨道对齐方式

属性值：

属性值	水平方向效果	垂直方向效果	代码示例
start	对齐单元格起始边缘（左对齐）	对齐单元格起始边缘（顶部对齐）	`.container { justify-items: start; }`
end	对齐单元格结束边缘（右对齐）	对齐单元格结束边缘（底部对齐）	`.container { justify-items: end; }`
center	水平居中对齐	垂直居中对齐	`.container { justify-items: center; }`
stretch	拉伸填满单元格宽度（默认值）	拉伸填满单元格高度（默认值）	`.container { justify-items: stretch; }`

七.多列布局

多列布局用于将元素的内容自动分割为指定数量的列

场景：

长文章分栏：文章自动分列，中间有间隙，也可以做响应式
图片瀑布流

优势：自动分列，无需额外准备列盒子

实现语法：

属性	作用	示例值
`column-count`	根据容器宽度和 `column-count` 值，自动分配列宽	`column-count: 3;` 分为 3 列
`column-gap`	列之间的间距	`20px`、`normal`（默认 1em）
`column-rule`	列间的分隔线样式（颜色、宽度、样式）	`column-rule: 1px solid #ccc;`

注意：

底部子元素被“切断”。
原因：column-count的本质是将内容按垂直方向自动分割到多列（类似报纸排版）
内容会优先填满一列后再流入下一列

解决方案： break-inside: avoid-column; 强制元素不跨列分割（默认auto，允许跨列）

该属性给子元素添加，而不是容器

八.鼠标样式

在css中，cursor属性用于控制鼠标指针在元素上的显示样式，通过改变光标形态可以向用户传递交互提示（如“可点击”、“不可选中”等），从而提升界面交互体验。

值	描述
default	默认箭头（通常是系统默认的箭头光标）
pointer	手型（指尖朝上的小手），常用于可点击元素（如链接 `<a>`、按钮 `<button>`）
text	I 型竖线（类似文本输入光标），用于可编辑文本区域（如 `<textarea>`、`contenteditable` 元素）
wait	等待（旋转圆圈或沙漏），表示操作进行中（如加载、提交时）
help	帮助（带问号的箭头），提示用户需要帮助（如提示信息区域）
not-allowed	禁止（圆圈带斜线），表示操作不可用（如禁用的按钮）
grab	抓取（手型带抓取动作），表示可拖动（如可拖拽的元素）
grabbing	抓取中（手型收紧），表示正在拖动（配合 `grab` 使用）
zoom-in	放大（+号），表示放大操作（如图片预览时）
zoom-out	缩小（-号），表示缩小操作（如图片预览时）

示例：

/* 鼠标悬停时显示手型 */
.item:hover {
  cursor: pointer;
}

九.CSS书写顺序

合理的属性顺序应遵循【布局→盒模型→视觉→交互→其他】的逻辑，核心目标是让代码更易读、更易维护。实际开发中可根据项目需求微调，但保持团队一致性是关键。

顺序	常见属性列表
布局相关	`display`（显示类型）、`visibility`（可见性）、`position`（定位方式）、`top/right/bottom/left`（定位偏移）、`float`（浮动）、`clear`（清除浮动）、`overflow`（溢出处理）、`z-index`（层叠顺序）、`clip`（裁剪）
盒模型	`box-sizing`（盒模型计算方式）、`width/min-width/max-width`（宽度）、`height/min-height/max-height`（高度）、`margin`（外边距）、`padding`（内边距）、`border`（边框）、`outline`（轮廓，可选）
视觉样式	`color`（文本颜色）、`background`（背景，含 `background-color/background-image` 等）、`font`（字体合写）、`font-size`（字号）、`font-family`（字体系列）、`line-height`（行高）、`text-align`（文本对齐）、`text-indent`（首行缩进）、`letter-spacing`（字间距）、`white-space`（空白处理）
交互与动画	`cursor`（鼠标指针）、`opacity`（透明度）、`transition`（过渡）、`animation`（动画）、`transform`（变换，如旋转、缩放）
其他（特殊/低频）	`filter`（滤镜）、`clip-path`（裁剪路径）、`backdrop-filter`（背景滤镜）、`will-change`（优化提示）、`touch-action`（触摸行为）、`scroll-behavior`（滚动行为）

CSS基础知识入门

Mon, 01 Jun 2026 00:00:00 GMT

CSS3核心技术

板块

CSS3基础知识
CSS3选择器
CSS3盒子模型
CSS3精灵图
CSS3字体图标

CSS简介

CSS(Cascading Style Sheets,层叠样式表)。是用来控制网页在浏览器中的显示外观的语言。
CSS3现在已被大部分现代浏览器支持，而下一版CSS4仍在开发中。

作用：
样式美化：文本样式，背景，边框等
布局与定位：元素排列，响应式设计
动画交互：伪类，过渡，动画

CSS的核心是<ins>控制视觉表现</ins>

html：html是结构，用于展示内容
css：css是样式，用于设置网页的样式及布局

简单示例：

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>document</title>
    <style>
      div {
        font-size: 20px;
        color: red;
      }
    </style>
  </head>
  <body>
    <div>文字内容</div>
  </body>
</html>

这样div元素的文字内容就会显示为20px的红色字体。

CSS分类（位置分类）

1.内联样式表（行内样式表）
样式写到标签内部，可以控制当前标签的样式，特殊情况使用。

<p style="color: red; font-size: 14px;">文字内容</p>

2.内部样式表
写到<head>标签中，脱离结构，可以控制当前页面的所有标签，较为常用。

<style>
  div {
    font-size: 20px;
    color: red;
  }
</style>

3.外部样式表
单独新建一个CSS文件，完全脱离结构，可以控制整个网站的所有标签，最常用。

<link rel="stylesheet" href="./css/index.css" />

初识CSS选择器

选择器是什么?
CSS选择器是CSS规则的一部分，它是选择 HTML 元素的方式。

CSS属性：采取键值对形式。属性名:属性值;

CSS选择器：选择标签
CSS属性：设置标签的样式

选择器分类

根据使用场景不同，选择器也分不同类型

基础选择器
关系选择器
分组选择器
伪类和伪元素
属性选择器 ...

CSS基础选择器

基础选择器指由单个选择器组成，常见的有：

类型选择器
```
p {
  color: gold;
}
```

类选择器
```
.box {
  color: gold;
}
```

id选择器
```
#box {
  color: gold;
}
```

通配符选择器
```
* {
  color: gold;
}
```

类型选择器

类型选择器选择某个类型的元素，也称为标签选择器。

/* 选择所有div标签修改样式 */
div {
  color: gold;
}

/* 选择所有span标签修改样式 */
span {
  color: green;
}

CSS层叠性：
CSS 规则可以同时作用于一个元素，浏览器通过特定规则决定最终生效的样式。层叠性解决了样式冲突问题。
原则：后定义的样式覆盖先前的样式（就近原则）。

CSS书写规范

良好的书写规范，让我们更专业。虽然代码自动格式化，但是我们还需要了解：

选择器和大括号中间保留1个空格距离。
属性名和属性值中间也要保留1个空格。
每个CSS属性单独占一行。后期会打包压缩，无需担心体积问题。

示例代码

p {
  color: gold;
  font-size: 20px;
}

CSS注释 + AI注释

CSS注释的快捷键是 ctrl + /，注意注释内容左右两侧保持一个空格距离是良好习惯。

示例代码

span {
  /* 这里添加注释 */
  color: green;
}

AI工具注释

单个属性注释可以在CSS属性后面打一个空格即可自动添加注释。
如果想要给多个属性添加注释，选中CSS添加到右侧对话区，输入提示词即可。

类选择器

类选择器选择某一个元素或者多个元素。
场景：

语法：
CSS:

<style>
  .pink {
    color: pink;
  }
</style>

.类名 { 样式声明; ... }

HTML:

<ul>
  <li>猪爸爸</li>
  <li>猪妈妈</li>
  <li>乔治</li>
  <li class="pink">佩奇</li>
</ul>

<标签 class="类名">

类选择器注意事项：

类名自定义，不能是中文、纯数字。
多个英文单词组成尽量使用 - 链接。
命名要有意义，尽量见名知义。
class 属性可以有多类名，中间用空格隔开。
类选择器的权重（优先级）高于类型选择器（标签选择器）。

id选择器

选择 HTML 中具有特定 id 属性的唯一元素

语法：

CSS:

#header {
  color: red;
}

#id名 { 样式声明; ... }

HTML:

<div id="header">修改样式</div>

<标签 id="id名">

id选择器和类选择器区别

类选择器

语法：以 . 开头，后跟类名（如 .nav）
作用：选择 class 属性的一个或多个元素
特点：可以使用多次
类似：身份证的名字，可以使用多次
场景：后期修改样式基本都是类选择器

id选择器

语法：以 # 开头，后跟 id 名（如 #header）
作用：选择特定 id 属性的唯一元素
特点：同一页面中，id 值必须唯一（不能重复）
类似：身份证的编号，唯一，只能用一次
场景：后期主要是配合 JavaScript 添加交互效果

通配符选择器

通配符可以选择 HTML 中所有的标签，进行样式修改。特殊情况下通过通配符清除所有元素的默认边距和填充，统一不同浏览器的默认样式。
语法：

* {
  margin: 0; /* 去除所有元素的外边距 */
  padding: 0; /* 去除所有元素的内边距 */
  box-sizing: border-box; /* 统一盒模型，包括内边距和边框 */
}

CSS基础选择器总结

选择器类型	语法示例	匹配范围	复用性	典型使用场景	注意事项
类型选择器	`div { ... }`	匹配所有指定HTML标签元素	某一类型标签	全局样式重置、基础标签样式（如body, p）	避免滥用，可能导致样式冲突
类选择器	`.nav { ... }`	匹配所有含指定class的元素	多次使用	多元素共享样式	优先使用，避免与ID选择器冲突
ID选择器	`#header { ... }`	匹配唯一含指定id的元素	唯一性	唯一元素标识	必须唯一，避免样式覆盖风险
通配符选择器	`* { ... }`	匹配所有元素	全局覆盖	全局样式重置	性能较差，慎用

大部分情况下，我们使用类选择器，是最重要的。

CSS关系选择器

关系选择器是通过位置关系来选择目标元素（标签），可以更精准选择某些元素。常见的有：

后代选择器
```
.box p {
  color: pink;
}
```
选择 .box 元素内部所有层级的 p 元素（包括子、孙等后代）。

子代选择器
```
.box > p {
  color: pink;
}
```
选择 .box 元素内部直接子层级的 p 元素（仅父子关系，不包含孙级及以下）。

邻接兄弟选择器
```
h2 + p {
  color: red;
}
```
选择 h2 元素紧挨着的下一个兄弟 p 元素（仅相邻的第一个兄弟）。

通用兄弟选择器
```
h2 ~ p {
  color: blue;
}
```
选择 h2 元素后面所有同级的 p 元素（不要求紧邻）。

后代选择器

选择某个元素的后代元素（不限层级，包括子元素，孙元素等）。
场景：

图中有的链接字大，有的字小，就是通过后代选择器来实现的。

语法：

父元素 后代元素 {
  样式声明;
  ...
}

示例：
CSS：

div p {
  color: pink;
}

HTML：

<div>
  <p>我是文字</p>
</div>
<p>我是文字</p>

注：后代选择器可以是任意层级，不仅仅是一层，还可以是多层。

ul li a {
  color: pink;
}

更好的写法，结合类选择器，使选择更精确

.nav li a {
  color: pink;
}

<ul class="nav">
  <li><a href="#">首页</a></li>
</ul>
<ul>
  <li><a href="#">关于我们</a></li>
  <li><a href="#">联系我们</a></li>
</ul>

这样，就可以只修改类为 .nav 的 ul 元素下的 a 元素的颜色，而不影响其他 ul 元素下的 a 元素。

说明：选择div标签里面的p元素，中间空格隔开。父级div作用是限定，子元素p修改样式。父级和子集都可以是任意选择器。

子代选择器

选择某个元素的直接子元素（仅限一层）。
语法：

父元素 > 子元素 {
  样式声明;
  ...
}

选择父元素里面的第一层子元素，中间用 > 隔开。

示例：

CSS：

div > span {
  color: pink;
}

HTML：

<div>
  <span>我是儿子</span>
  <p>
    <span>我是孙子</span>
  </p>
</div>

说明：
这样，就可以只修改 div 元素直接子元素 span”我是儿子“ 的颜色，而不影响 p 元素或 p 元素的子元素 span“我是孙子”的颜色。

补充：和后代选择器类似，可以使用多个选择器组合

兄弟选择器

兄弟选择器分为邻接兄弟选择器和通用兄弟选择器：

邻接兄弟选择器

选中紧跟在指定元素后面的第一个同级元素。
语法：

指定元素 + 同级元素 {
  样式声明;
  ...
}

通用兄弟选择器

选中指定元素后面所有同级元素（不要求紧邻）。
语法：

指定元素 ~ 同级元素 {
  样式声明;
  ...
}

我们用以下HTML结构来详细说明邻接兄弟选择器和通用兄弟选择器的区别。

<div class="box">
  <p>文字内容</p>
  <p>文字内容</p>
  <p>文字内容</p>
  <h2>标题</h2>
  <p>文字内容</p>
  <p>文字内容</p>
  <p>文字内容</p>
</div>

使用邻接兄弟选择器选中紧跟在h2后面的第一个p元素

h2 + p {
  color: pink;
}

效果：

使用通用兄弟选择器选中紧跟在h2后面的所有p元素

h2 ~ p {
  color: pink;
}

效果：

关系选择器总结

选择器	语法	选择范围	实例
后代选择器	`A B`	所有后代（跨层级）	`ul li {color: pink;}`
子代选择器	`A > B`	直接子元素（仅一层）	`div>span {color: pink;}`
邻接兄弟选择器	`A + B`	紧邻的下一个同级元素	`h2+p {}` 标题后的第一个p元素
通用兄弟选择器	`A ~ B`	A之后的所有同级元素	`h2~p {}` 标题后的所有p元素

后代选择器是我们最常用的。

CSS文本样式

CSS文本样式用于控制网页中文字的外观，包括字体、颜色、对齐、间距等，主要分为两大类：

字体样式
比如：使用哪种字体，字体大小，字体粗体、斜体，等等

文本布局
比如：文本对齐、行高、字间距、首行缩进等

注意：文字是无法直接通过CSS来更改样式的，必须要用适合的标签来包裹它们，本质是修改标签样式，里面文字跟随样式变化

字体样式

给文字设置颜色、大小、粗体、装饰等效果

字体样式	说明
`color`	设置字体颜色
`font-family`	字体族
`font-size`	字体大小
`font-style`	字体风格
`font-weight`	字体粗体
`text-decoration`	字体装饰

字体颜色color

最常见的颜色指定方式：使用关键字、十六进制值和 rgb() 值。
学习可以用关键字，开发用十六进制，特殊情况用rgb。

1. 关键字
这些颜色通常不会在生产环境的网站中使用，主要学习使用。
比如：red、green、blue、pink等。
示例代码：

p {
  color: pink;
}

2. 十六进制
这个是开发最常用的。实际开发中，我们从设计稿直接复制即可。
比如：红色 #FF0000 或者 #F00。
示例代码：

p {
  color: #f00;
}

3. rgb格式
rgb() 函数接受三个参数，分别表示颜色的红、绿和蓝。也是设计稿复制的。
比如：红色 rgb(255,0,0)。
示例代码：

p {
  color: rgb(255, 0, 0);
}

4. rgba格式
rgba() 函数与 rgb() 类似，但多了一个参数表示透明度。0是完全透明，1是不透明
比如：红色 rgba(255,0,0, 0.3) 表示红色透明度为 0.3。
示例代码：

p {
  color: rgba(255, 0, 0, 0.3);
}

字体族font-family

给定一个有先后顺序的，由字体名或者字体族名组成的列表来为选定的元素设置字体

body {
  fonot-familiy: Arial, Helvetica, sans-serif;
}

属性值用逗号隔开。浏览器会选择列表中第一个该计算机上有安装的单位

在实际开发中，都是规定好的可以直接复制即可，无需记忆

字体大小font-size

font-size可以设置字体大小

p {
  font-size: 18px;
}

像素px

CSS像素(CSS Pixel)是CSS中用于定义长度，尺寸的单位(简写为px)
绝对单位

不同浏览器默认字体大小不一样，谷歌默认16px，建议给body标签统一指定大小，做到浏览器统一

字体风格font-style

font-style用来打开和关闭文本italic(斜体)
属性值：

normal：将文本设置为普通字体(将存在的斜体关闭)
italic：如果当前字体的斜体版本可用，那么文本设置为斜体版本

p {
  font-style: italic; /* 设置斜体样式 */
}

最常见：让em或者i标签取消默认倾斜

em {
  font-style: normal;
}

i {
  font-style: normal;
}

字体粗体font-weight

font-weight设置文字的粗体大小

使用场景:

很多标题是不要加粗的，此时可以用CSS取消加粗

部分大批量文字可以利用CSS样式加粗

属性值：

normal：正常粗细
bold：加粗其他值受属性影响基本不用

数字属性值（常用）：

400：正常粗细
700：加粗取值范围100到900之间，常用就是400和700

示例：

p {
  font-weight: 700;
}

字体装饰text-decoration

设置/取消字体上的文本装饰

使用场景：

最常见设置链接下划线，比如取消下划线等

特殊情况添加删除线

属性值：

none:取消文本装饰
underline:下划线
overline:上划线
line-through:穿过文本的线

示例：

a {
  text-decoration: none;
}

字体样式总结

属性	描述	常见取值	示例
`color`	设置文本内容的颜色	颜色名称(red, blue)<br/>六进制(#F00000)<br/>RGB(rgb(255,0,0))<br/>RGBA(rgba(255,0,0,0.5))	`color: red;`<br>`color: #3366cc;`
`font-family`	设置文本的字体系列	无衬线字体	`font-family: "Microsoft YaHei", sans-serif;`
`font-size`	设置文本的大小	`px`	`font-size: 16px;`
`font-style`	设置文本的样式	`normal`(正常)、`italic`(斜体)	`font-style: normal;`
`font-weight`	设置文本的粗细	数值(100-900)<br/>关键字(`normal`, `bold`)	`font-weight: 400;`<br>`font-weight: 700;`
`text-decoration`	设置文本的装饰效果	`none`(无装饰)<br/>`underline`(下划线)<br/>`overline`(上划线)<br/>`line-through`(中划线)	`text-decoration: underline;`<br>`text-decoration: line-through;`

文本布局

作用域文本的对齐，缩进，间距等布局功能的属性

文本布局样式表

字体样式	说明
`text-align`	文本对齐
`text-indent`	首行缩进
`letter-spacing`	文本字符间距
`line-height`	行高

文本对齐text-align

控制文本在它所在的块级盒子内如何水平对齐

使用场景：

文本/图片在盒子水平对齐

文章文字两端对齐

属性值：

left:文本左对齐
right:文本右对齐
center:文本水平居中对齐
justify:自动改变字间距，两端对齐

示例：

p {
  text-align: center; /* 居中对齐 */
}

首行缩进text-indent

设置块级元素中文本行前面空格（缩进）的长度

使用场景：

段落首行缩进两个字的效果

logo隐藏文字效果(后续讲解)

属性值：数字
常见单位是em，相对单位，本元素的文字大小1em等于当前元素的字体大小，如果当前元素没有大小，则按照父元素文字大小

示例：

p {
  text-indent: 2em; /* 缩进2个文字大小 */
}

字间距letter-spacing

用于设置文本字符的间距

使用场景：

调整字与字间距，用户体验更好

属性值：数字 常见单位是px ，默认是0px

示例：

p {
  letter-spacing: 2px; /* 字间距2px */
}

行高line-height

设置文本每行的高

使用场景：

设置多行文本之间的上下间距。
让单行文本垂直居中。

常用属性值：

数字px
数字不带单位(当前字体大小的倍数)

示例：

p {
  line-height: 24px; /* 行高24px */
}

单行文本垂直居中原理：
行高组成：

上间距
字体大小
下间距

行高等于盒子高度，即可实现垂直居中

文本布局总结

属性名	作用	核心取值	注意事项	示例
`text-align`	设置文本的水平对齐方式	`left`、`right`、`center`、`justify`（两端对齐）	仅对块级元素生效	`p { text-align: center; }`
`text-indent`	设置首行文本的缩进量	长度值（如 20px、2em）	仅对块级元素生效	`p { text-indent: 2em; }`
`letter-spacing`	设置文本中字符之间的间距	数值	负值可使字符重叠（需谨慎使用）	`h1 { letter-spacing: 2px; }`
`line-height`	设置文本行与行之间的垂直间距	像素或者倍数	1.5 表示当前字体大小1.5倍；行高等于容器高时，单行文字垂直居中	`p { line-height: 1.6; }`

font简写

font简写属性在一个声明中设置多个字体属性

使用场景：

给整个页面设置相关字体样式

语法：

font: font-style font-weight font-size/line-height font-family;

其中font-size和font-family必须写
其他可以省略，默认显示
有严格的书写顺序

忘了属性请跳转到字体样式总结

示例：

p {
  font: italic bold 16px/24px "微软雅黑";
}

p {
  font: 18px/1.5 "宋体";
}

CSS继承性

子元素自动继承父元素某些CSS样式属性。

主要继承跟文字相关的样式属性，比如字体，颜色，文本对齐等
如果子元素定义自己样式，会优先自己样式，不会继承父元素样式

分组选择器

是将不同的选择器组合在一起，使用逗号分割
也称为并集选择器

使用场景：

给多个元素设置相同的样式

语法：

选择器1,
选择器2,
选择器3 {
  /* 样式声明 */
}

示例：

p,
h1,
h2 {
  color: red; /* 所有p、h1、h2元素文字颜色都是红色 */
}

伪类选择器

选择元素的特定状态或结构位置，符号是冒号:

对比：
类选择器：.类名
伪类选择器：:伪类名

分类：

状态伪类
- 根据用户交互或状态变化选择
- 比如：鼠标经过链接，表单获得焦点等
结构伪类
- 根据元素的位置选择
- 比如：选择第五个第十个元素，选择第三个元素等
表单伪类
- 针对表单元素的状态选择
- 比如：表单禁用，选中复选框等

状态伪类选择器

链接伪类

链接伪类用于根据链接的不同状态（如未访问，悬停，点击等）为其添加样式，从而提升用户体验和界面交互性。

使用场景：

设置链接不同状态的样式

链接伪类使用：

链接伪类	作用
`a:link`	未访问链接的默认样式
`a:visited`	已访问链接的样式
`a:hover`	鼠标悬浮在链接上时的反馈
`a:active`	链接被点击时的瞬时状态（按下到松开）

伪类顺序规则（LVHA 顺序） a:link -> a:visited -> a:hover -> a:active

注意事项：

链接伪类的顺序不能颠倒，否则会导致样式失效
链接伪类可以与其他选择器组合使用，比如：p a:hover表示段落中的悬停链接

示例：

a:link {
  color: blue; /* 未访问链接为蓝色 */
}

a:visited {
  color: purple; /* 已访问链接为紫色 */
}

a:hover {
  color: red; /* 鼠标悬停链接为红色 */
}

a:active {
  color: green; /* 链接被点击时为绿色 */
}

实际开发中，一般这样写：

淘宝

a {
  text-decoration: none;
}
a:hover {
  text-decoration: underline;
}

京东

a {
  color: #666;
  text-decoration: none;
}
a:hover {
  color: #ff0f23;
}

小米

a {
  color: #757575;
}
a,
a:hover {
  text-decoration: none;
}
a:hover {
  color: #ff6700;
}

用户行为伪类

用户以某种方式和文档交互的时候使用，这些用户行为伪类，有时叫做动态伪类。

使用场景：

鼠标经过元素的时候，修改样式
表单获得焦点的时候，修改样式

用户行为伪类使用：

用户行为伪类	作用
`:hover`	鼠标经过元素
`:focus`	获得焦点的元素（表单）

示例：

鼠标经过元素

div {
  background-color: pink;
}
div:hover {
  background-color: red;
  color: red;
  /* 鼠标经过元素，背景颜色和文字颜色都变成红色 */
}

获得焦点的元素（表单）

input {
  border: 1px solid #ccc;
}
input:focus {
  border: 2px solid red;
  width: 200px;
  /* 表单获得焦点时，边框变成红色,宽度变成200px */
}

结构伪类选择器

根据元素的位置选择目标元素。

使用场景：

选择第一个或者最后一个或者第n个元素

每个元素都有左竖线，但是第一个元素的被去掉了，这就是伪类选择器的作用。

结构伪类选择器使用：

结构伪类	作用
`:first-child`	一组兄弟元素中的第一个元素
`:last-child`	一组兄弟元素中的最后一个元素
`:nth-child(n)`	一组兄弟元素列表中第n个元素

对于nth-child(n)，n可以是：

数字
关键字：even（偶数），odd（奇数）
公式：
- 3n：3的倍数，表示第3个、第6个、第9个...等元素
- n+2：表示第二个及以后的元素
- -n+3：表示前三个元素
- 注意公式的n取值从0开始计算

示例：

ul li:first-child {
  color: pink;
  /* 第一个li元素的字体颜色为粉色 */
}

ul li:nth-child(5) {
  color: blue;
  /* 第五个li元素的字体颜色为蓝色 */
}

ul li:last-child {
  color: green;
  /* 最后一个li元素的字体颜色为绿色 */
}

表单伪类选择器

针对表单元素的状态

使用场景：

表单按钮禁用的时候，调整颜色
复选框选中的修改样式

表单伪类选择器使用：

表单伪类选择器	作用
`:disabled`	禁用的表单元素
`:checked`	选中的复选框或单选框

示例：

禁用的表单元素

button:disabled {
  background-color: #ccc;
  color: #666;
  cursor: not-allowed;
  /* 禁用的按钮背景颜色为灰色，文字颜色为深灰色，鼠标悬停时显示不能点击的图标 */
}

<button type="submit" disabled>提交</button> /*
提交按钮被禁用时，背景颜色为灰色，文字颜色为深灰色，鼠标悬停时显示不能点击的图标
*/

选中的复选框或单选框

input:checked + label {
  font-weight: bold;
  color: red;
  /* 复选框1被选中时，文字加粗，颜色为红色 */
}

<input type="checkbox" id="checkbox1" />
<label for="checkbox1">复选框1</label>
/* 复选框1被选中时，文字加粗，颜色为红色 */

伪元素选择器

选择元素特定的部分（使用双冒号::）

对比:

类选择器：选择元素的某个类名（.nav）
伪类选择器：选择元素的某个状态（:hover）
伪元素选择器：选择元素的某个部分（::before）

使用场景：

让表单里面的placeholder文字变颜色
做更多的修饰效果

伪元素选择器使用：

选择特定部分
插入内容

1.选择特定部分

伪元素选择器	作用
`::first-line`	选择首行
`::first-letter`	首字母
`::placeholder`	选择input或者textarea占位符（常用）

示例：

input::placeholder {
  color: #bbb;
  line-height: 30px;
  /* input或者textarea占位符文字颜色为灰色, 行高为30px */
}

2.插入内容

本质上插入的是盒子模型中的内容区域（content area）

伪元素选择器	作用
`::before`	元素内插入伪元素，作为第一个元素
`::after`	元素内插入伪元素，作为最后一个元素

示例：

div::before {
  content: "开始";
  color: red;
  background-color: #eee;
  padding: 5px;
  /* 元素内插入伪元素，作为第一个元素，内容为"开始"，颜色为红色，背景颜色为浅灰色，内边距为5px */
}

div::after {
  content: "结束";
  color: red;
  background-color: #eee;
  padding: 5px;
  /* 元素内插入伪元素，作为最后一个元素，内容为"结束"，颜色为红色，背景颜色为浅灰色，内边距为5px */
}

属性选择器

根据元素的属性特征来精准定位元素，从而实现更灵活的样式控制
使用场景：

表单样式控制
图标字体控制
国际化语言适配等等

属性选择器分类：

属性选择器	作用
`[属性]`	匹配包含指定属性的元素
`[属性=值]`	匹配属性值等于指定值的元素
`[属性^=值]`	匹配属性值以指定字符串开头的元素
`[属性$=值]`	匹配属性值以指定字符串结尾的元素
`[属性*=值]`	匹配属性值任意位置包含指定子串的元素

示例：

/* 属性选择器 */
/* 1. 选择包含属性（所有带class属性的a标签） */
a[class] {
  color: #333;
}

/* 2. 选择属性等于值 完全匹配（class="red"的a标签） */
a[class="red"] {
  color: red;
}

/* 3. 选择属性值以xx开头（class以"font"开头的a标签） */
a[class^="font"] {
  color: blue;
}

/* 4. 选择属性值以xx结尾（class以"16"结尾的a标签） */
a[class$="16"] {
  color: purple;
}

/* 5. 选择属性包含xx（class包含"on"的a标签，此处匹配"font"） */
a[class*="font"] {
  font-weight: bold;
}

HTML结构：

<a href="#">修改文字颜色</a> <br />
<!-- 注释：所有带class属性的a标签文字颜色为#333 -->
<a href="#" class="font">修改文字颜色</a> <br />
<!-- 注释：class="font"的a标签文字颜色为蓝色 -->
<a href="#" class="font14">修改文字颜色</a> <br />
<!-- 注释：class="font14"的a标签文字颜色为紫色 -->
<a href="#" class="font16">修改文字颜色</a> <br />
<!-- 注释：class="font16"的a标签文字颜色为紫色 -->
<a href="#" class="red">修改文字颜色</a> <br />
<!-- 注释：class="red"的a标签文字颜色为红色 -->

CSS三大特性

继承性

子元素继承父元素样式
主要是跟文字相关的样式继承
如果子元素设置了自己的样式，就会覆盖继承的样式（因为继承的权重是0,0,0,0，详情请看优先级）

层叠性

后面样式会覆盖前面样式
主要解决样式冲突问题
但是要看选择器权重来决定优先级

优先级

浏览器通过优先级来判断哪些属性值与一个元素值相关，优先级是基于不同种类选择器组成的匹配规则。
优先级由选择器的权重决定，权重高的规则覆盖权重低的规则

原则

优先级相等的时候，CSS中最后的那个声明的样式将会被应用到元素上。（层叠就近原则）
其余判断哪个选择器权重高，就优先执行那个样式
权重是4位一组，是分开的层级，不能进位。

选择器类型	示例	权重值	优先级说明
`!important`	`color: red !important;`	无限大	强制覆盖所有规则（慎用）
内联样式	`<div style="color: red">`	`(1, 0, 0, 0)`	行内样式权重最高 `(1,0,0,0)`
ID 选择器	`#myId`	`(0, 1, 0, 0)`	每个 ID 增加 `0,1,0,0`
类/属性/伪类	`.class, [type="text"]`	`(0, 0, 1, 0)`	每个类/属性/伪类增加 `0,0,1,0`
类型（标签）/伪元素	`div, ::after`	`(0, 0, 0, 1)`	每个标签/伪元素增加 `0,0,0,1`
通配符/继承	`*`, 继承的样式	`(0, 0, 0, 0)`	通配符和继承权重最低

权重累加

权重是累加的，每个选择器的层级权重相加，最终得到一个4位的权重值。

示例：#nav .item a 的权重为：
(0,1,0,0) + (0,0,1,0) + (0,0,0,1) = (0,1,1,1)

tip:查看权重可以使用trae鼠标悬停在选择器上查看，也可以通过浏览器的调试工具查看。

盒子模型

所有的元素都被一个个的“盒子”包围着，学会盒子模型是实现准确布局，处理元素排列的关键。

在CSS中，我们有几种类型的盒子，一般分为区块盒子（block boxes）和行内盒子（inline boxes）。

区块盒子：

盒子会产生换行
width和height属性可以发挥作用
不设置宽度则默认和是父元素空间的100%
内边距，外边距和边框会撑大元素
常见的比如：div，p，h，ul，table等

行内盒子：

盒子不会产生换行
width和height属性将不起作用
垂直方向的内边距，外边距不起效果
水平方向的内边距，外边距会有效果
常见的比如：span，em，a，strong等

盒子模型组成

CSS盒模型整体上适用于区块盒子，包含盒子内容，内边距，外边距，边框四部分。

盒子内容：显示内容的区域，由内容或者指定宽度高度来决定内容大小
内边距 padding：元素内容与边框之间的距离，由padding属性设置
外边距 margin：元素边框与其他元素之间的距离，由margin属性设置
边框 border：元素边框，由border属性设置

使用调试工具可以查看盒子模型的组成

盒子模型组成-边框

border属性用于设置盒子边框

使用场景一

设置盒子四条或者单独边框

属性值：
border: 边框粗细边框样式边框颜色

边框有三部分属性值组成，中间必须用空格隔开
三部分属性值没有先后顺序

边框样式表：

边框样式	描述	视觉效果
dotted	点状边框	圆点组成的虚线
dashed	虚线边框	短横线组成的虚线
solid	实线边框	连续的实线
double	双线边框	两条实线组成的边框
groove	凹槽边框	3D凹槽效果
ridge	垄状边框	3D垄状效果
inset	内凹边框	3D内凹效果
outset	外凹边框	3D外凹效果

示例：

div {
  border: 1px solid #f1f1f1;
}

使用场景二

四个边框不同
底部一条线做分割线

属性：
根据方位名词。top,bottom,left,right

border-top: 1px solid #f1f1f1;
border-bottom: 1px solid #f1f1f1;
border-left: 1px solid #f1f1f1;
border-right: 1px solid #f1f1f1;

示例：

div {
  border-top: 3px solid #ff9900;
  border-bottom: 1px solid pink;
  border-left: 1px solid pink;
  border-right: 1px solid pink;
}

盒子模型组成-圆角边框

border-radius属性用于设置盒子圆角边框

使用场景：

盒子设置圆角更好看
盒子或者图片设置为圆形

属性值：
border-radius: 圆角大小

示例：

div {
  border-radius: 10px;
}

特殊场景一：

胶囊圆角
盒子或者图片设置为圆形

实现：

胶囊圆角：长方形将圆角设置为盒子高度的一半
圆形：正方形将圆角设置为盒子宽度的一半或者50%

示例：

/* 胶囊 */
div {
  width: 200px;
  height: 100px;
  border-radius: 50px;
}

/* 圆形 */
div {
  width: 200px;
  height: 200px;
  border-radius: 50%;
}

特殊场景二：

分别设置不同角的圆角大小

圆角写法	描述
border-radius: 10px;	所有角都设置为10px
border-radius: 10px 20px;	左上，右下是10px，右上，左下是20px
border-radius: 10px 20px 30px;	左上是10px, 右上，左下是20px，右下是30px
border-radius: 10px 20px 30px 40px;	左上是10px, 右上是20px，右下是30px，左下是40px

圆角原理图示：

盒子模型组成-内边距

padding属性用于设置盒子内边距，内边距是内容与边框之间的距离。

使用场景：

让盒子内容和边框保留一定距离，更美观

内边距写法（多值规则：顺时针记忆）

内边距写法	作用
`padding: 10px;`	上下左右4个内边距均为10px
`padding: 10px 20px;`	上下内边距为10px，左右内边距为20px
`padding: 10px 20px 30px;`	上内边距10px，左右内边距20px，下内边距30px
`padding: 10px 20px 30px 40px;`	上10px → 右20px → 下30px → 左40px（顺时针顺序）

示例：

div {
  padding: 10px;
}

单边内边距设置

可通过方位名词单独设置某一侧的内边距：

padding-left: 10px; 设置左内边距
padding-right: 10px; 设置右内边距
padding-top: 10px; 设置上内边距
padding-bottom: 10px; 设置下内边距

示例：

div {
  padding-left: 10px;
}

盒子模型组成-外边距

外边距margin是盒子周围一圈看不到的空间，它会把其他元素退离盒子

使用场景：

让盒子与其他元素之间有一定距离，更美观

外边距写法	作用
`margin: 10px;`	上下左右4个外边距均为10px
`margin: 10px 20px;`	上下外边距为10px，左右外边距为20px
`margin: 10px 20px 30px;`	上外边距10px，左右外边距20px，下外边距30px
`margin: 10px 20px 30px 40px;`	上10px → 右20px → 下30px → 左40px（顺时针顺序）

示例：

div {
  margin: 10px;
}

单边外边距设置

可通过方位名词单独设置某一侧的外边距：

margin-left: 10px; 设置左外边距
margin-right: 10px; 设置右外边距
margin-top: 10px; 设置上外边距
margin-bottom: 10px; 设置下外边距

示例：

div {
  margin-left: 10px;
}

注意事项：

行内元素：左右外边距生效，上下外边距无效。
行内元素：设置宽度和高度也无效。

盒子模型-尺寸计算

在 CSS 盒子模型的默认定义（标准盒模型）中：

元素的 width/height 仅指内容区域的大小。
padding（内边距）和 border（边框）会额外增加盒子的总尺寸。

实际宽度计算示例

基础情况：
- 内容宽度：200px
- 无 padding、无 border
- 盒子实际宽度 = 200px
带 padding 和 border 的情况：
- 内容宽度：200px
- 边框：5px（左右各 5px）
- 内边距：10px（左右各 10px）
- 计算：200 + 5 + 5 + 10 + 10 = 230
- 盒子实际宽度 = 230px

结论：在默认盒模型下

总宽度 = width + 左右padding + 左右border
总高度 = height + 上下padding + 上下border
这会导致布局计算变得复杂，容易超出预期尺寸。

box-sizing 属性说明
box-sizing 用于定义元素的盒模型计算方式，控制 width 和 height 是否包含 padding 和 border。

语法

box-sizing: 属性值;

属性值说明：

属性值	描述
`content-box`	默认值。`width`/`height` 仅包含内容区域，不包含 `padding` 和 `border`。<br>理解：`width = 内容宽度`
`border-box`	`width`/`height` 包含内容、`padding` 和 `border`。<br>理解：`width = border + padding + 内容宽度`

当设置 box-sizing: border-box; 时：

元素总宽度固定为 200px
即使有 border: 5px 和 padding: 10px，内容区域会自动缩小，总宽度仍保持 200px

盒子背景（background）

background 用于设置元素背景相关属性，包括：

背景颜色
背景图片
背景位置
背景重复方式
背景渐变等

使用场景：

给盒子添加背景图片，让界面更精美
给列表添加统一小图标，实现装饰效果
给页面设置大尺寸背景图，增强视觉冲击力
纯 CSS 实现背景渐变效果，无需图片

background背景常见属性

| 属性 | 作用 | 常用值 | 示例代码 | | ----------------------- | -------------------- | ----------------------------------------------------------- | -----------------0--------------- | | background-color | 设置元素背景颜色 | 颜色名称、十六进制、RGB、透明度 | background-color: #f0f0f0; | | background-image | 设置背景图片 | url(image.jpg) | background-image: url(bg.png); | | background-repeat | 控制背景图片是否重复 | repeat（默认）、no-repeat、repeat-x、repeat-y | background-repeat: no-repeat; | | background-position | 定位背景图片位置 | x y（如 center top，或 px、% 单位） | background-position: center; | | background-size | 调整背景图片尺寸 | 默认 auto、cover（覆盖）、contain（包含）或 px、% | background-size: cover; | | background-attachment | 背景是否随页面滚动 | scroll（默认）、fixed | background-attachment: fixed; |

示例：

div {
  /* 背景颜色 */
  background-color: #f0f0f0;
  /* 背景图片 */
  background-image: url(bg.png);
  /* 背景图片不重复 */
  background-repeat: no-repeat;
  /* 背景图片居中 */
  background-position: center;
  /* 背景图片覆盖 */
  background-size: cover;
  /* 背景图片固定不动 */
  background-attachment: fixed;
}

背景复合写法

background 属性可以同时设置多个背景属性，包括背景颜色，背景图片，背景位置，背景重复方式，背景尺寸，背景固定不动等。

背景复合写法：

div {
  background: 颜色 图片 重复 固定 位置/尺寸; /* 顺序无关 */
}

示例：

div {
  div {
  background: #f0f0f0 url(bg.png) no-repeat fixed center / cover;
}
}

背景渐变

在CSS中，可使用linear-gradient(线性渐变)和radial-gradient(径向渐变)实现背景渐变效果。

场景:

文字底色渐变甚至动画，更吸引用户
盒子添加更加美观

属性/方法	描述	示例代码
`linear-gradient(方向, 颜色1 位置, 颜色2 位置...)`	线性渐变（方向可控）	`background: linear-gradient(to right, #ff6b6b, #4ecdc4)`<br>`background-image: linear-gradient(90deg, #ff6b6b 30%, #4ecdc4 70%)`
`radial-gradient(形状, 颜色1, 颜色2...)`	径向渐变（形状和位置可控）	`radial-gradient(circle, #ff9a9e, #fad0c4)`

线性渐变

方向：可以是方位名词（如 to right、to left、to top、to bottom）或角度(deg)（如 90deg、45deg 等）。
色标位置：可以指定颜色和其在渐变中的位置（如 #ff6b6b 30% 表示在 30% 位置使用 #ff6b6b 颜色）,不是必须写的。

示例：

div {
  /* 线性渐变：从左到右，从红色到蓝色 */
  background: linear-gradient(to right, #ff6b6b, #4ecdc4);
}

.gradient-box {
  /* 线性渐变：从左上角到右下角，从红色到蓝色 */
  width: 300px;
  height: 200px;
  background: linear-gradient(45deg, #ff6b6b, #4ecdc4);
}

文字背景线性渐变：

div {
  /* 设置背景渐变 */
  background: linear-gradient(to right, pink, red);

  /* 兼容性写法：谷歌老版本浏览器 */
  -webkit-background-clip: text;
  /* 文字范围裁剪背景 */
  background-clip: text;

  /* 文本填充颜色设置为透明，让背景渐变显示出来 */
  -webkit-text-fill-color: transparent;
}

径向渐变

形状：可以是 circle（圆形）或 ellipse（椭圆形）。
色标位置：与线性渐变相同。

示例：

div {
  /* 径向渐变：从中心向四周，从红色到蓝色 */
  background: radial-gradient(circle, #ff6b6b, #4ecdc4);
}

盒子阴影

CSS 中的 box-shadow 属性用于在元素的框架上添加阴影效果。

场景:

给盒子添加阴影，使页面看起来更加立体
鼠标经过元素显示阴影，更加突出元素

语法： box-shadow: x偏移量 y偏移量模糊半径扩展半径颜色 (内阴影);

多个属性用空格隔开
x轴偏移量和y轴偏移量必填，其他属性可省略采取默认值
默认是外阴影，若要内阴影，需添加 inset 关键字

示例：

div {
  box-shadow: 0 0 10px 5px rgba(0, 0, 0, 0.3);
}

div:hover {
  box-shadow: 0 0 10px 5px rgba(0, 0, 0, 0.5);
}

过渡

过渡效果（transition）用于在元素的属性值发生变化时，平滑地过渡（而不是瞬间切换）。

场景：

鼠标经过图片放大
表单获得焦点，输入框变宽

语法：
transition：过渡属性过渡时间过渡函数延迟时间；

属性值中间空格隔开
过渡属性如果都要变化可以写all
过渡时间单位是秒（s）或毫秒（ms）
过渡函数可选，默认是ease，常用值有linear（线性）、ease（默认，先慢后快）、ease-in（慢开始）、ease-out（慢结束）、ease-in-out（慢开始慢结束）
延迟时间可选，默认是0，单位是秒（s）或毫秒（ms）

示例：

/* 过渡写到盒子上，不是写在:hover上 */
.box {
  /* 宽度 */
  width: 100px;
  /* 高度 */
  height: 100px;
  /* 背景颜色 */
  background-color: #f0f0f0;
  /* 过渡属性：所有属性 */
  transition: all 0.3s ease-in-out;
}

.box :hover {
  /* 显示阴影 */
  box-shadow: 0 0 10px 5px rgba(0, 0, 0, 0.3);
}

样式初始化

浏览器对HTML元素有默认样式（如 margin、padding、font-size 等）。不同样式浏览器默认样式可能不一致，导致跨浏览器兼容问题，我们需要对这些默认样式进行初始化。

初始化的核心目的：

统一浏览器默认样式，消除差异
减少后续开发中的冗余代码
提高代码可维护性

最佳实践

小型项目

/* 全局重置 */
* {
  margin: 0; /* 清除所有元素的 margin */
  padding: 0; /* 清除所有元素的 padding */
  box-sizing: border-box; /* 推荐同时设置盒模型 */
}

/* 重置列表样式 */
ul,
ol {
  list-style: none; /* 去除列表样式 */
}

/* 重置链接样式 */
a {
  text-decoration: none; /* 去除下划线 */
}

中大型项目:推荐Normalize.css

推荐方案：中大型项目推荐使用 Normalize.css 进行样式重置，它能在保留有用浏览器默认样式的同时，统一不同浏览器的渲染表现。 引入方式：

<link rel="stylesheet" href="./css/Normalize.css" />

官网下载地址：https://necolas.github.io/normalize.css/ Vue 官网等项目就引入了该 CSS 文件。

字体图标

字体图标是一种将图标以字体形式嵌入网页的技术，允许开发者像使用文字一样通过 CSS 控制图标的样式（如颜色、大小、阴影等）。

使用场景

导航菜单图标
按钮操作图标
结合动画效果

优势

矢量缩放：无损放大缩小
样式灵活：通过 CSS 直接修改颜色、大小、阴影等属性
减少 HTTP 请求：一个字体文件可包含多个图标，比多张图片更高效
兼容性好：支持所有现代浏览器，甚至部分旧版浏览器

字体图标库

字体图标要么设计师提供，要么去字体库下载。

图标库名称	特点	官网链接
Font Awesome	图标最全，支持免费版和Pro付费版	fontawesome.com
Bootstrap Icons	Bootstrap生态内图标，简单易用	icons.getbootstrap.com
icomoon	最早推出了第一个自定义图标字体生成器	icomoon.io
iconfont	阿里字体库，包含淘宝图标库和阿里妈妈图标库（免费）	http://www.iconfont.cn/

使用字体图标

先以icon font图标库为例，其他图标库使用方法类似。

字体图标使用步骤

下载字体图标文件 去官网或者由设计师提供字体图标文件，将其保存到项目目录下。各个文件的作用：
- iconfont.css：包含字体图标类名的 CSS 样式表，用于定义图标对应的字体和 Unicode 编码。
- iconfont.ttf、iconfont.woff、iconfont.woff2：字体文件，包含实际的图标字形。浏览器会根据用户设备支持的字体格式加载对应的字体文件。
引入到HTML文件中 根据下载的压缩包，使用 <link> 标签引入对应的 CSS 文件。
```
<link rel="stylesheet" href="./fonts/iconfont.css" />
```
使用字体图标
- 一般通过标签调用类名来选择对应的字体图标。
- 可根据实际需求，通过 CSS 调整图标的样式，如颜色、大小、位置等。
```

```

CSS精灵图

CSS精灵图是将多个小图标或图像合并到一张大图中，通过调整 background-position 属性来显示特定部分的图像技术。

使用场景

导航菜单图标
按钮操作图标
复杂彩色小图标更适合精灵图

优势

减少HTTP请求：多个小图标合并为一张图片，只需一次请求
提升性能：减少网络开销，尤其适合移动端或低带宽场景
统一管理：方便维护图标集，避免文件分散

通过合理使用CSS精灵图，可以有效优化网页性能。对于复杂场景（如高清屏适配），建议结合SVG或字体图标使用。

CSS精灵图原理

给盒子添加背景图片：将合并后的精灵图作为元素的背景图片。
通过背景定位对齐：使用 background-position 属性调整背景图的位置，使目标图标区域与元素可视区域对齐。
注意网页坐标规则：网页背景定位的坐标原点在左上角，x轴向右、y轴向下，因此 background-position 的负值用于向左、向上移动背景图。

在线测量工具：https://www.tugaigai.com/online_ps/

示例

.icon-home {
  /* 背景图片 */
  background-image: url("./sprite.png");
  /* 背景定位 */
  background-position: -10px -10px;
  /* 图标大小 */
  width: 32px;
  height: 32px;
}

graph LR
    A["CSS3核心技术"] --> B["CSS简介 作用：样式美化/布局/动画"]
    A --> C["CSS分类 内联/内部/外部"]
    A --> D["CSS选择器"]
    A --> E["CSS文本样式"]
    A --> F["CSS三大特性 继承/层叠/优先级"]
    A --> G["盒子模型"]
    A --> H["字体图标 iconfont等"]
    A --> I["精灵图 背景定位"]

    D --> D1["基础选择器"]
    D1 --> D1a["类型选择器 div {}"]
    D1 --> D1b["类选择器 .class {} 可复用"]
    D1 --> D1c["ID选择器 #id {} 唯一"]
    D1 --> D1d["通配符 * {} 全局重置"]

    D --> D2["关系选择器"]
    D2 --> D2a["后代 A B"]
    D2 --> D2b["子代 A > B"]
    D2 --> D2c["邻接兄弟 A + B"]
    D2 --> D2d["通用兄弟 A ~ B"]

    D --> D3["分组选择器 A, B"]

    D --> D4["伪类选择器"]
    D4 --> D4a["状态伪类"]
    D4a --> D4a1["link/visited/hover/active （LVHA顺序）"]
    D4a --> D4a2["hover（任何元素）"]
    D4a --> D4a3["focus（表单焦点）"]
    D4 --> D4b["结构伪类"]
    D4b --> D4b1["first-child"]
    D4b --> D4b2["last-child"]
    D4b --> D4b3["nth-child(n)"]
    D4 --> D4c["表单伪类"]
    D4c --> D4c1["disabled"]
    D4c --> D4c2["checked"]

    D --> D5["伪元素选择器"]
    D5 --> D5a["first-line/first-letter"]
    D5 --> D5b["placeholder"]
    D5 --> D5c["before/after 需content"]

    D --> D6["属性选择器"]
    D6 --> D6a["[attr]"]
    D6 --> D6b["[attr=value]"]
    D6 --> D6c["[attr^=value] 开头"]
    D6 --> D6d["[attr$=value] 结尾"]
    D6 --> D6e["[attr*=value] 包含"]

    E --> E1["字体样式"]
    E1 --> E1a["color 颜色"]
    E1 --> E1b["font-family 字体族"]
    E1 --> E1c["font-size 大小"]
    E1 --> E1d["font-style 斜体"]
    E1 --> E1e["font-weight 粗细"]
    E1 --> E1f["text-decoration 装饰"]

    E --> E2["文本布局"]
    E2 --> E2a["text-align 水平对齐"]
    E2 --> E2b["text-indent 首行缩进"]
    E2 --> E2c["letter-spacing 字间距"]
    E2 --> E2d["line-height 行高 垂直居中"]

    E --> E3["font简写 顺序：style weight size/line-height family"]

    F --> F1["继承性 文字相关"]
    F --> F2["层叠性 后定义覆盖"]
    F --> F3["优先级 !important > 内联 > ID > 类 > 标签 > 通配符"]

    G --> G1["盒子类型 block/inline"]
    G --> G2["盒子组成"]
    G2 --> G2a["内容 content"]
    G2 --> G2b["边框 border 样式：solid/dashed/dotted等"]
    G2 --> G2c["圆角 border-radius px/% 胶囊=高一半"]
    G2 --> G2d["内边距 padding 上右下左"]
    G2 --> G2e["外边距 margin 行内上下无效"]
    G2 --> G2f["尺寸计算 box-sizing content-box / border-box"]

    G --> G3["背景 background"]
    G3 --> G3a["背景色 background-color"]
    G3 --> G3b["背景图 background-image"]
    G3 --> G3c["背景重复 background-repeat"]
    G3 --> G3d["背景位置 background-position"]
    G3 --> G3e["背景尺寸 background-size cover/contain"]
    G3 --> G3f["背景固定 background-attachment"]
    G3 --> G3g["复合写法 background"]
    G3 --> G3h["渐变 linear-gradient / radial-gradient"]

    G --> G4["盒子阴影 box-shadow x偏移 y偏移 模糊 扩展 颜色 inset"]
    G --> G5["过渡 transition 属性 时长 曲线 延迟"]
    G --> G6["样式初始化 *重置 / Normalize.css"]

    H --> H1["使用步骤 下载→引入→加类名"]
    I --> I1["原理：背景图+定位"]
    I --> I2["background-position负值"]

用C语言实现扫雷的扩散逻辑

Sun, 03 May 2026 00:00:00 GMT

用C语言实现扫雷的扩散逻辑

刚学习完C语言数组部分的内容，跟着b站老师用C语言写了个扫雷游戏，但是老师并没有教我们写扫雷扩散逻辑，所以我就自己设计了一个扫雷的扩散逻辑

什么是扫雷的扩散逻辑

如图所示，当我们翻开一个位置（图中红色圆圈），如果这个位置为空白区，意味着它的相邻区域（图中红框标记范围）是没有雷的，相邻区域大概可以分为两种情况，一种是数字，一种是空白区。如果是数字，则会直接显示出来；如果是空，除了会显示出来，还会继续检查周围区域，从而继续扩散，直到周围没有空区域为止

扩散函数的设计

因为之前有py的基础，看到这种问题第一反应就是用递归的思想去解决。递归调用的条件是周围存在空白区域，递归停止的条件则是周围不存在空白区域，一下是我自己设计的函数

//扩散逻辑
//char mine[][COLS] 存放雷的字符数组，1为雷，0为安全
//char show[][COLS] 存放游玩界面的字符数组，*表示未翻开，#表示雷，0表示四周八个方向没有雷，其他数字表示雷的个数
// int row col 扫雷区域的行数和列数
// int x y 玩家选择的坐标
// *p 存放int win的地址，当检查到一个区域不是雷，win++,win到达一定值判定游戏胜利
void AutoFind(char mine[][COLS], char show[][COLS], int row, int col, int x, int y, int* p){
    //周围区域相对坐标
	int dx[] = {-1,-1,1,1,-1,0,0,1};
	int dy[] = {-1,1,-1,1,0,-1,1,0};
    for(int k = 0; k < 8; k++){
        //搜寻具体坐标
		int i = x + dx[k];
		int j = y + dy[k];
		//确认检查的坐标在扫雷区域内部，并且这个位置不是雷，且未显示
		if(1 <= i && i <= row && 1 <= j && j <= col && mine[i][j] != '1' && show[i][j] == '*'){
			int jud = CotMine(mine, i, j);//计算雷的数量
			switch (jud) {
			case 0:
				show[i][j] = '0';//如果雷数量为0，则显示
				*p += 1;
				AutoFind(mine, show, row, col, i, j, p);//雷数量为0，进行递归扩散
				break;
			default:
				*p += 1;
				show[i][j] = '0' + jud;//如果数量不为零，则直接显示
				break;
			}
		}
	}
}

最后能实现的效果就是这样的（翻开前和翻开后）最后，我会把我扫雷的源代码分享给大家，供大家学习使用，第一次写这么多代码并没有很好的划分各种功能，导致标记功能的制作难以下手，还请谅解

python竞赛常用模块总结

Sat, 31 Jan 2026 12:00:00 GMT

python竞赛常用模块总结

一.快速读取输入

使用sys模块，读取效率较高，推荐使用。

简单快读模板

重新定义input函数，使读取效率加快。

import sys
input = lambda: sys.stdin.readline().strip()

快速读取一行`sys.stdin.readline()`

import sys

# 读取一行，包含末尾的\n
line = sys.stdin.readline()

# 去掉首尾换行符
line = sys.stdin.readline().strip()

# 读取整数
n = int(sys.stdin.readline())

# 读取多个整数
a, b = map(int, sys.stdin.readline().split())

快速读取所有输入`sys.stdin.read()`

import sys

# 读取所有输入，返回一个字符串
all_input = sys.stdin.read()

# 常用模式：按空白字符分割
data = sys.stdin.read().split()

# 转换为整数列表
numbers = list(map(int, sys.stdin.read().split()))

二.常用数学函数

内置数学函数

基本数学运算

函数	名称	说明	示例
`abs(x)`	绝对值函数	返回x的绝对值	`abs(-5) → 5`
`pow(x, y[, z])`	快速幂	`pow(x, y)`返回$x^y$<br/>`pow(x, y, z)`返回$x^y \bmod z$	`pow(2, 3) → 8`, `pow(2, 3, 5) → 3`
`round(x,n)`	四舍五入	`round(x)`保留整数<br/>`round(x, n)`保留`n`位小数	`round(3.14) → 3`<br/>`round(3.14159, 2) → 3.14`
`divmod(x, y)`	整除函数	返回`(x//y, x%y)`	`divmod(7, 2) → (3, 1)`

进制转换

函数	名称	说明	示例
`bin(x)`	二进制转换	返回整数x的二进制表示	`bin(10) → '0b1010'`
`oct(x)`	八进制转换	返回整数x的八进制表示	`oct(10) → '0o12'`
`hex(x)`	十六进制转换	返回整数x的十六进制表示	`hex(10) → '0xa'`

math模块

导入math模块

import math

基本数学运算

函数/常量	名称	说明	示例
`sqrt(x)`	平方根	返回x的平方根	`sqrt(4) → 2.0`
`ceil(x)`	向上取整	返回大于等于x的最小整数	`ceil(3.14) → 4`
`floor(x)`	向下取整	返回小于等于x的最大整数	`floor(3.99) → 3`

数论函数

函数	名称	说明	示例
`gcd(a, b)`	最大公约数	返回a和b的最大公约数	`gcd(12, 18) → 6`
`lcm(a, b)`	最小公倍数	返回a和b的最小公倍数	`lcm(4, 6) → 12`
`comb(n, k)`	组合数	返回$C_n^k$	`comb(5, 2) → 10`
`perm(n, k)`	排列数	返回$P_n^k$	`perm(5, 2) → 20`
`factorial(n)`	阶乘	返回$n!$	`factorial(5) → 120`

数学常量

常量	名称	说明	示例
`pi`	圆周率	数学常量π	`pi → 3.14159...`
`e`	自然对数底	数学常量e	`e → 2.71828...`
`inf`	无穷大	正无穷大	`inf → inf`
`nan`	非数字	非数字值	`nan → nan`

其他函数

函数	名称	说明	示例
`isqrt(x)`	整数平方根	返回x的整数平方根	`isqrt(16) → 4`
`dist(p, q)`	距离	返回两点之间的欧几里得距离	`dist((0,0), (3,4)) → 5.0`

三.is判断函数

判断字符串是否满足某种条件，返回True或False。

字符串判断方法（str对象方法）

字符类型判断

方法	名称	说明	示例
`isalnum()`	字母数字判断	字符串是否由字母和数字组成	`"abc123".isalnum() → True`
`isalpha()`	字母判断	字符串是否只由字母组成	`"abc".isalpha() → True`
`isdecimal()`	十进制数字	字符串是否只包含十进制数字	`"123".isdecimal() → True`
`isdigit()`	数字判断	字符串是否只包含数字	`"123".isdigit() → True`

格式与大小写判断

方法	名称	说明	示例
`islower()`	小写判断	字符串是否至少有一个字母且所有字母都是小写	`"abc".islower() → True`
`isupper()`	大写判断	字符串是否至少有一个字母且所有字母都是大写	`"ABC".isupper() → True`
`istitle()`	标题判断	字符串是否每个单词首字母大写	`"Hello World".istitle() → True`

常用数据结构模块

导入collections模块

from collections import deque, Counter

常用数据结构：

类/函数	名称	说明	示例
`deque`	双端队列	线程安全，快速从两端添加或删除元素	`deque([1,2,3])`
`Counter`	计数器	统计可哈希对象	`Counter('abcabc')`

deque 双端队列

方法	说明	示例
`deque()`	初始化	创建一个新的双端队列
`append(x)`	右端添加x	`d.append(4)`
`appendleft(x)`	左端添加x	`d.appendleft(0)`
`pop()`	右端弹出	`d.pop() → 4`
`popleft()`	左端弹出	`d.popleft() → 0`
`extend(iterable)`	右端扩展	`d.extend([5,6])`
`extendleft(iterable)`	左端扩展	`d.extendleft([-1,-2])`
`rotate(n)`	旋转n步	`d.rotate(1)`
`clear()`	清空队列	`d.clear()`

Counter 计数器

方法	说明	示例
`Counter()`	初始化	创建一个新的计数器，可以像字典一样使用
`most_common(n)`	前n个最常见元素	`Counter('abracadabra').most_common(3)` → `[('a', 5), ('b', 2), ('r', 2)]`
`total()`	计数总和	`Counter('abc').total() → 3`

堆操作

导入heapq模块

import heapq

堆默认为最小堆，即堆顶为最小元素。

函数	名称	说明	示例
`heapify(x)`	堆化	将列表x转换为堆	`heapify([3,1,2])` → 堆为[1,3,2]
`heappush(heap, item)`	入堆	将item加入堆	`heappush(heap, 4)`
`heappop(heap)`	出堆	弹出并返回堆顶元素	`heappop(heap)` → 1
`heappushpop(heap, item)`	先入后出	将item入堆然后弹出堆顶	`heappushpop(heap, 0)` → 0
`heapreplace(heap, item)`	先出后入	弹出堆顶然后将item入堆	`heapreplace(heap, 5)` → 1
`nlargest(n, iterable)`	前n个最大	返回iterable中前n个最大元素	`nlargest(3, [1,5,2,4,3])` → [5,4,3]
`nsmallest(n, iterable)`	前n个最小	返回iterable中前n个最小元素	`nsmallest(3, [1,5,2,4,3])` → [1,2,3]

二分查找

导入bisect模块

import bisect

这些函数用于在已排序的列表中进行二分查找。

函数	名称	说明	示例
`bisect_left(a, x)`	左插入点	返回第一个大于等于x的索引	`bisect_left([1,2,4], 2)` → 1
`bisect(a, x)`	右插入点	返回第一个大于x的索引	`bisect([1,2,4], 2)` → 2
`insort_left(a, x)`	左插入	找到第一个大于等于x的索引，将x插入该位置	`insort_left([1,2,4], 2)` → [1,2,2,4]
`insort(a, x)`	右插入	找到第一个大于x的索引，将x插入该位置	`insort([1,2,4], 2)` → [1,2,2,4]

迭代与序列

所有函数概览表

函数	名称	说明	时间复杂度	示例
`len()`	获取长度	返回对象长度（元素个数）	O(1)	`len([1,2,3]) → 3`
`reversed()`	反转序列	返回序列的反向迭代器	O(1)	`list(reversed([1,2,3])) → [3,2,1]`
`sorted()`	排序	返回排序后的新列表	O(n log n)	`sorted([3,1,2]) → [1,2,3]`
`enumerate()`	枚举	返回(索引, 元素)对的迭代器	O(1)	`list(enumerate(['a','b'])) → [(0,'a'),(1,'b')]`
`zip()`	组合	将多个可迭代对象组合成元组迭代器	O(1)	`list(zip([1,2],['a','b'])) → [(1,'a'),(2,'b')]`
`slice()`	创建切片对象	创建切片对象用于扩展切片	O(1)	`arr[slice(1,3)]`
`filter()`	过滤	过滤可迭代对象，保留满足条件的元素	O(n)	`list(filter(lambda x: x>0, [-1,0,1,2])) → [1,2]`
`map()`	映射	对可迭代对象的每个元素应用函数	O(n)	`list(map(str, [1,2,3])) → ['1','2','3']`
`all()`	所有为真	所有元素都为真时返回True	O(n)	`all([True, True]) → True`
`any()`	任一为真	任一元素为真时返回True	O(n)	`any([False, True]) → True`

reversed()-反转序列

# 反转列表（返回迭代器）
list(reversed([1, 2, 3])) # [3, 2, 1]

# 反转字符串
list(reversed("abc")) # ['c', 'b', 'a']

# 反转范围对象
list(reversed(range(5))) # [4, 3, 2, 1, 0]

# 与切片反转对比
arr = [1, 2, 3]
arr[::-1] # [3, 2, 1]（返回新列表）
reversed(arr) # <list_reverseiterator>（返回迭代器）

# 遍历反向迭代器
for item in reversed([1, 2, 3]):
    print(item)                     # 3, 2, 1

特点

返回迭代器，节省内存
原始序列不会被修改

enumerate()-枚举索引

# 基本用法
list(enumerate(['a', 'b', 'c']))  # [(0, 'a'), (1, 'b'), (2, 'c')]

# 指定起始索引
list(enumerate(['a', 'b', 'c'], start=1))  # [(1, 'a'), (2, 'b'), (3, 'c')]

zip()-组合多个可迭代对象

# 组合两个列表
list(zip([1, 2, 3], ['a', 'b', 'c']))  # [(1, 'a'), (2, 'b'), (3, 'c')]

# 长度不等时以最短的为准
list(zip([1, 2, 3], ['a', 'b']))       # [(1, 'a'), (2, 'b')]

# 组合三个列表
list(zip([1, 2], ['a', 'b'], ['x', 'y']))  # [(1, 'a', 'x'), (2, 'b', 'y')]

# 解压（使用*操作符）
pairs = [(1, 'a'), (2, 'b'), (3, 'c')]
nums, letters = zip(*pairs)            # nums=(1,2,3), letters=('a','b','c')

# 矩阵转置
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transposed = list(zip(*matrix))        # [(1,4,7), (2,5,8), (3,6,9)]

# 遍历组合
names = ['Alice', 'Bob', 'Charlie']
scores = [85, 92, 78]
for name, score in zip(names, scores):
    print(f"{name}: {score}")  # Alice: 85, Bob: 92, Charlie: 78

slice()-创建切片对象

# 创建切片对象
s = slice(1, 4) # 等价于 [1:4]
arr = [0, 1, 2, 3, 4, 5]
arr[s] # [1, 2, 3]

# 带步长的切片
s = slice(0, 5, 2) # 等价于 [0:5:2]
arr[s] # [0, 2, 4]

# 省略开始或结束
s = slice(None, 3) # [:3]
arr[s] # [0, 1, 2]

# 动态创建切片
def get_slice(arr, start=None, stop=None, step=None):
    s = slice(start, stop, step)
    return arr[s]

get_slice([0,1,2,3,4], 1, 4) # [1, 2, 3]

# 获取切片属性
s = slice(1, 5, 2)
s.start # 1
s.stop # 5
s.step # 2

filter()-过滤序列

# 过滤偶数
nums = [1, 2, 3, 4, 5, 6]
even = list(filter(lambda x: x % 2 == 0, nums))  # [2, 4, 6]

# 过滤非空字符串
words = ['hello', '', 'world', '', '!']
non_empty = list(filter(None, words))            # ['hello', 'world', '!']
# 注意：filter(None, iterable)会过滤掉bool值为False的元素

# 过滤正数
list(filter(lambda x: x > 0, [-2, -1, 0, 1, 2]))  # [1, 2]

# 使用函数作为过滤条件
def is_vowel(char):
    return char.lower() in 'aeiou'
list(filter(is_vowel, 'hello world')) # ['e', 'o', 'o']

# 惰性求值（返回迭代器）
filtered = filter(lambda x: x > 0, [-1, 0, 1, 2])
next(filtered) # 1

map()-映射函数

# 转换为字符串
list(map(str, [1, 2, 3]))                # ['1', '2', '3']

# 平方运算
list(map(lambda x: x**2, [1, 2, 3, 4]))  # [1, 4, 9, 16]

# 多个序列运算
list(map(lambda x, y: x + y, [1, 2, 3], [10, 20, 30]))  # [11, 22, 33]

# 内置函数作为映射函数
list(map(abs, [-1, 2, -3, 4]))           # [1, 2, 3, 4]

# 多参数函数
def add(a, b, c):
    return a + b + c

list(map(add, [1, 2, 3], [10, 20, 30], [100, 200, 300]))  # [111, 222, 333]

all()和any()-逻辑判断

# all(): 所有元素为True时返回True
all([True, True, True])           # True
all([True, False, True])          # False
all([])                           # True（空序列）

# any(): 任一元素为True时返回True
any([False, False, True])         # True
any([False, False, False])        # False
any([])                           # False（空序列）

# 实际应用
# 检查所有数字是否为正数
all(x > 0 for x in [1, 2, 3, 4])   # True
all(x > 0 for x in [1, 2, -3, 4])  # False

# 检查是否有正数
any(x > 0 for x in [-1, -2, 3])    # True

# 检查所有字符串是否非空
strings = ['hello', 'world', '']
all(strings) # False（空字符串为False）
any(strings) # True

# 结合map使用
all(map(str.isalpha, 'abc123')) # False（有数字）
all(map(str.isalpha, 'abc')) # True

大一上数学公式整理

Tue, 20 Jan 2026 00:00:00 GMT

高等数学上公式汇总

这学期的高等数学也是通关了，之前记了一些公式就拿出来分享一下吧，给需要补考的同学们提供一些便利

不定积分

常用不定积分公式

基本积分表

$\int k , dx = kx + C$
$\int x^\mu , dx = \frac{x^{\mu+1}}{\mu+1} + C$ ($\mu \neq -1$)
$\int \frac{1}{x} , dx = \ln|x| + C$
$\int a^x , dx = \frac{a^x}{\ln a} + C$
$\int e^x , dx = e^x + C$
$\int \sin x , dx = -\cos x + C$
$\int \cos x , dx = \sin x + C$
$\int \sec^2 x , dx = \tan x + C$
$\int \csc^2 x , dx = -\cot x + C$
$\int \sec x \tan x , dx = \sec x + C$
$\int \csc x \cot x , dx = -\csc x + C$
$\int \frac{1}{\sqrt{1-x^2}} , dx = \arcsin x + C$
$\int \frac{1}{1+x^2} , dx = \arctan x + C$
$\int \tan x , dx = -\ln|\cos x| + C$
$\int \cot x , dx = \ln|\sin x| + C$

重要补充公式

$\int \frac{1}{a^2+x^2} , dx = \frac{1}{a} \arctan \frac{x}{a} + C$
$\int \frac{1}{\sqrt{a^2-x^2}} , dx = \arcsin \frac{x}{a} + C$
$\int \frac{1}{x^2-a^2} , dx = \frac{1}{2a} \ln \left| \frac{x-a}{x+a} \right| + C$
$\int \frac{1}{\sqrt{x^2 \pm a^2}} , dx = \ln |x + \sqrt{x^2 \pm a^2}| + C$

等价无穷小

常用等价无穷小 (当 $x \to 0$ 时)

$\sin x \sim x$
$\tan x \sim x$
$\arcsin x \sim x$
$\arctan x \sim x$
$1 - \cos x \sim \frac{1}{2}x^2$
$e^x - 1 \sim x$
$\ln(1+x) \sim x$
$(1+x)^\alpha - 1 \sim \alpha x$
$a^x - 1 \sim x \ln a$
$\sqrt[n]{1+x} - 1 \sim \frac{x}{n}$
$x - \sin x \sim \frac{1}{6}x^3$
$\tan x - x \sim \frac{1}{3}x^3$
$x - \ln(1+x) \sim \frac{1}{2}x^2$

函数求导

常用函数求导公式

基本初等函数导数

$(C)' = 0$
$(x^\mu)' = \mu x^{\mu-1}$
$(a^x)' = a^x \ln a$
$(e^x)' = e^x$
$(\log_a x)' = \frac{1}{x \ln a}$
$(\ln x)' = \frac{1}{x}$
$(\sin x)' = \cos x$
$(\cos x)' = -\sin x$
$(\tan x)' = \sec^2 x$
$(\cot x)' = -\csc^2 x$
$(\sec x)' = \sec x \tan x$
$(\csc x)' = -\csc x \cot x$
$(\arcsin x)' = \frac{1}{\sqrt{1-x^2}}$
$(\arccos x)' = -\frac{1}{\sqrt{1-x^2}}$
$(\arctan x)' = \frac{1}{1+x^2}$
$(\text{arccot } x)' = -\frac{1}{1+x^2}$

求导法则

$(u \pm v)' = u' \pm v'$
$(uv)' = u'v + uv'$
$\left(\frac{u}{v}\right)' = \frac{u'v - uv'}{v^2}$
$[f(g(x))]' = f'(g(x)) \cdot g'(x)$

积分学

积分学重要补充公式

定积分基本公式与性质

$\int_a^b f(x) dx = F(b) - F(a)$
$\int_a^b [kf(x) \pm lg(x)] dx = k\int_a^b f(x) dx \pm l\int_a^b g(x) dx$
$\int_a^b f(x) dx = \int_a^c f(x) dx + \int_c^b f(x) dx$

定积分计算技巧

$\int_a^b f(x) dx = \int_\alpha^\beta f[\varphi(t)] \varphi'(t) dt$
$\int_a^b u dv = [uv]_a^b - \int_a^b v du$
若 $f(x)$ 偶函数，则 $\int_{-a}^a f(x) dx = 2\int_0^a f(x) dx$
若 $f(x)$ 奇函数，则 $\int_{-a}^a f(x) dx = 0$

常用定积分公式

$\int_0^{\pi/2} \sin^n x dx = \int_0^{\pi/2} \cos^n x dx = \begin{cases} \frac{(n-1)!!}{n!!} \cdot \frac{\pi}{2} & n\text{为偶数}\ \frac{(n-1)!!}{n!!} & n\text{为奇数} \end{cases}$
$\int_0^{+\infty} e^{-x^2} dx = \frac{\sqrt{\pi}}{2}$
$\int_0^\pi x f(\sin x) dx = \frac{\pi}{2} \int_0^\pi f(\sin x) dx$

反常积分

$\int_a^{+\infty} f(x) dx = \lim\limits_{t \to +\infty} \int_a^t f(x) dx$
$\int_{-\infty}^b f(x) dx = \lim\limits_{t \to -\infty} \int_t^b f(x) dx$
$\int_a^b f(x) dx = \lim\limits_{t \to a^+} \int_t^b f(x) dx$

积分应用公式

直角坐标面积：$S = \int_a^b |f(x) - g(x)| dx$
极坐标面积：$S = \frac{1}{2} \int_\alpha^\beta r^2(\theta) d\theta$
绕x轴旋转体体积：$V = \pi \int_a^b [f(x)]^2 dx$
绕y轴旋转体体积（柱壳法）：$V = 2\pi \int_a^b x |f(x)| dx$
直角坐标弧长：$L = \int_a^b \sqrt{1 + [f'(x)]^2} dx$
参数方程弧长：$L = \int_\alpha^\beta \sqrt{[x'(t)]^2 + [y'(t)]^2} dt$
极坐标弧长：$L = \int_\alpha^\beta \sqrt{r^2(\theta) + [r'(\theta)]^2} d\theta$

极限与连续

极限与连续的重要公式

两个重要极限

$\lim\limits_{x \to 0} \frac{\sin x}{x} = 1$
$\lim\limits_{x \to \infty} \left(1 + \frac{1}{x}\right)^x = e$

连续性相关

零点定理：若 $f(x)$ 在 $[a,b]$ 上连续，且 $f(a) \cdot f(b) < 0$，则存在 $\xi \in (a,b)$，使 $f(\xi) = 0$
介值定理：若 $f(x)$ 在 $[a,b]$ 上连续，则对于任意 $C \in [m, M]$，存在 $\xi \in [a,b]$，使 $f(\xi) = C$

解微分方程

微分方程的基本概念与一阶微分方程

一阶微分方程的基本类型

可分离变量方程：$\frac{dy}{dx} = f(x)g(y)$
齐次方程：$\frac{dy}{dx} = f\left(\frac{y}{x}\right)$
一阶线性微分方程：$\frac{dy}{dx} + P(x)y = Q(x)$ 通解公式：$y = e^{-\int P(x)dx} \left[ \int Q(x)e^{\int P(x)dx}dx + C \right]$
伯努利方程：$\frac{dy}{dx} + P(x)y = Q(x)y^n \quad (n \neq 0,1)$

可降阶的高阶微分方程

$y^{(n)} = f(x)$
$y'' = f(x, y')$
$y'' = f(y, y')$

高阶线性微分方程

二阶常系数齐次线性方程

形式：$y'' + py' + qy = 0$ 特征方程：$r^2 + pr + q = 0$ 通解：

两个不等实根 $r_1, r_2$：$y = C_1e^{r_1x} + C_2e^{r_2x}$
两个相等实根 $r_1 = r_2$：$y = (C_1 + C_2x)e^{r_1x}$
共轭复根 $r = \alpha \pm i\beta$：$y = e^{\alpha x}(C_1\cos\beta x + C_2\sin\beta x)$

泰勒展开式

常用函数的麦克劳林展开式（到 $n$ 阶）

指数函数

$$ e^x = 1 + x + \frac{x^2}{2!} + \frac{x^3}{3!} + \cdots + \frac{x^n}{n!} + o(x^n) $$

三角函数

正弦函数： $$ \sin x = x - \frac{x^3}{3!} + \frac{x^5}{5!} - \cdots + (-1)^n \frac{x^{2n+1}}{(2n+1)!} + o(x^{2n+2}) $$

余弦函数： $$ \cos x = 1 - \frac{x^2}{2!} + \frac{x^4}{4!} - \cdots + (-1)^n \frac{x^{2n}}{(2n)!} + o(x^{2n+1}) $$

对数函数

$$ \ln(1+x) = x - \frac{x^2}{2} + \frac{x^3}{3} - \cdots + (-1)^{n-1} \frac{x^n}{n} + o(x^n) $$

二项式展开

$$ (1+x)^\alpha = 1 + \alpha x + \frac{\alpha(\alpha-1)}{2!}x^2 + \cdots + \frac{\alpha(\alpha-1)\cdots(\alpha-n+1)}{n!}x^n + o(x^n) $$

几何级数

$$ \frac{1}{1-x} = 1 + x + x^2 + x^3 + \cdots + x^n + o(x^n) $$

其他重要展开

反正切函数： $$ \arctan x = x - \frac{x^3}{3} + \frac{x^5}{5} - \cdots + (-1)^n \frac{x^{2n+1}}{2n+1} + o(x^{2n+2}) $$

反正弦函数： $$ \arcsin x = x + \frac{1}{6}x^3 + \frac{3}{40}x^5 + \cdots + o(x^{2n+1}) $$

微分学

微分学重要补充公式

微分公式与法则

$dy = f'(x)dx$
$d(C) = 0$
$d(x^\mu) = \mu x^{\mu-1} dx$
$d(\sin x) = \cos x dx$
$d(\cos x) = -\sin x dx$
$d(e^x) = e^x dx$
$d(\ln x) = \frac{1}{x} dx$

高阶导数公式

$(x^n)^{(n)} = n!$
$(\sin x)^{(n)} = \sin\left(x + \frac{n\pi}{2}\right)$
$(\cos x)^{(n)} = \cos\left(x + \frac{n\pi}{2}\right)$
$(e^x)^{(n)} = e^x$
$(\ln x)^{(n)} = (-1)^{n-1} \frac{(n-1)!}{x^n}$
莱布尼茨公式：$(uv)^{(n)} = \sum\limits_{k=0}^{n} C_n^k u^{(n-k)} v^{(k)}$

微分中值定理

罗尔定理：若 $f(x)$ 在 $[a,b]$ 连续，$(a,b)$ 可导，且 $f(a) = f(b)$，则存在 $\xi \in (a,b)$，使 $f'(\xi) = 0$
拉格朗日中值定理：若 $f(x)$ 在 $[a,b]$ 连续，$(a,b)$ 可导，则存在 $\xi \in (a,b)$，使 $f(b) - f(a) = f'(\xi)(b-a)$
柯西中值定理：若 $f(x), g(x)$ 在 $[a,b]$ 连续，$(a,b)$ 可导，且 $g'(x) \neq 0$，则存在 $\xi \in (a,b)$，使 $\frac{f(b)-f(a)}{g(b)-g(a)} = \frac{f'(\xi)}{g'(\xi)}$

函数单调性与凹凸性

单调性判别：若 $f'(x) > 0$，则 $f(x)$ 单调递增；若 $f'(x) < 0$，则 $f(x)$ 单调递减
凹凸性判别：若 $f''(x) > 0$，则 $f(x)$ 凹；若 $f''(x) < 0$，则 $f(x)$ 凸

HTML入门指导

Sun, 18 Jan 2026 00:00:00 GMT

html学习笔记

近期学习了html，做了一些笔记，拿出来分享一下，学过的同学可以拿来查漏补缺，没有学过的同学也可以作为入门参考。

开发工具-Trae AI编辑器
浏览器和调试工具
HTML初体验
- 01 创建项目文件夹
- 02 快速编写代码
- 03 浏览器预览
常用配置设置
- 编辑器字体大小
- 代码字体大小
- 设置字符缩进
- 保存自动格式化代码
html简介
- 什么是HTML?
- 标签语法
html文档
- 文档类型
- html元素
- <head> 元素
- 字符集
- 移动端页面适配
- title元素
- body元素
标签关系以及AI工具排错
- 标签关系
- AI工具排错
标题和段落标签以及语义化
- html的标题和段落
- 语义化介绍
强调重要性标签
注释标签
块级元素和内联元素
- 块级元素
- 内联元素
图像标签以及常见格式
- 图像标签 img
- 常见图片格式
路径分类
- 相对路径
- 绝对路径
音视频标签
- 视频标签
- 音频标签
创建超级链接以及锚点链接
- 语法
- 其他属性
- 最佳链接实践
- 锚点链接
布局标签
- 网站结构标签
- 无语义标签
列表标签
- 无序列表 ul
- 有序列表 ol
- 描述列表 dl
表格标签和AI合并单元格
- 表格语法
- 表格合并单元格
表单
- 表单容器
- 表单控件
- 辅助标签-label
字符实体

开发工具-Trae AI编辑器

字节跳动旗下的AI代码编辑器。

Trae与AI深度集成，提供:

智能问答
代码自动补全
基于Agent的AI自动编程能力等

现阶段主要是AI辅助开发:

根据提示自动生成代码
根据错误检查修复代码
代码解读和分析
生成注释和代码优化
AI技术测评
……

浏览器和调试工具

在浏览器中打开调试工具:

右击页面空白处 → 检查。
快捷键 F12

HTML初体验

01 创建项目文件夹

所有相关素材都放到这个文件夹里面，这个文件夹也称为 根目录

02 快速编写代码

快捷生成代码并编写，可以使用编辑器自带的Emmet语法

03 浏览器预览

通过浏览器插件 live Server 在编辑器中直接打开浏览器预览效果

常用配置设置

编辑器字体大小

ctrl + + 放大
ctrl + - 缩小

代码字体大小

文件→首选项→设置（ctrl+,）→Editor设置→Font Size

设置字符缩进

常用设置→ tabSize
为了和后面Vue衔接，tab缩进2个字符。

保存自动格式化代码

文本格式化→格式化→Format on Save

html简介

什么是HTML?

超文本标记语言 ---- HyperText Markup Language，是一种用来告知浏览器如何组织页面的标记语言。

知识点：

HTML 由一系列的标签组成。
标记也称为标签（元素）。
大小写都可以，建议小写。

简单说，学习HTML就是学习标签

标签语法

标签组成

符号：标签用 <> 尖括号表示
组成：开始标签、结束标签和内容
别称：标签也称为元素

标签分类

大部分都是双标签
少数单标签

开发技巧

Trae编辑器中直接写标签，然后按Tab或者回车即可

html文档

文档类型

<!DOCTYPE html>

HTML5 的文档类型声明，它告诉浏览器当前页面是使用 HTML5 规范编写的

html元素

<html>

在元素中，lang用于声明网页的主要语言，帮助浏览器、搜索引擎等正确处理页面内容。

en代表英语，这意味着该页面的主要语言是英语
zh-CN代表中文。

`<head>` 元素

头部元素。包含了文档的元（meta）数据。
主要保存供机器处理的信息，而非人类可读信息

字符集

<meta charset="UTF-8">

该文档的字符集设置为UTF-8

UTF-8 包括绝大多数人类书面语言的大多数字符。

有了这个设置，页面现在可以处理它可能包含的任何文本内容，如果不加这句话可能会引起乱码。

移动端页面适配

<meta name="viewport" content="width=device-width,initial-scale=1.0">

开发者能确保网页在移动设备上以最佳状态呈现，提升用户浏览体验。

title元素

这设置了页面的标题，也就是出现在该页面加载的浏览器标签中的内容

body元素

包含了页面所有显示在页面上的内容，包含文本、图片、视频、游戏、播放音频轨道等等

标签关系以及AI工具排错

标签关系

并列关系

也称为兄弟关系

<head></head>
<body></body>

嵌套关系

也称为父子关系

<head>
  <title></title>
</head>

AI工具排错

实际开发中多层嵌套最容易出问题。
但是我们可以利用小技巧或者AI工具帮助我们理清标签的关系

标题和段落标签以及语义化

html的标题和段落

标题标签 h

场景：在新闻和文章的页面中，都离不开标题，用来突出显示文章主题

语法

<h1>一级标题</h1>
<h2>二级标题</h2>
<h3>三级标题</h3>
<h4>四级标题</h4>
<h5>五级标题</h5>
<h6>六级标题</h6>

显示特点

显示特点 标题文字会加粗显示，并且每行只显示一个

h1 唯一性 最好只对每个页面使用一次
<h1>——这是顶级标题
如：新闻的标题、网页的logo部分

层次性 在现有的六个标题层次中，除非觉得有必要否则应该争取每页使用不超过三个

段落标签 p

HTML 元素表示文本的一个段落。

语法：

<p>里面是段落文本</p>

每行只显示一个，文字显示不会自动换行

段落的相关样式请用 CSS 设置。

语义化介绍

指根据内容结构和含义选择恰当的html元素 语义化的好处：

更清晰的代码结构
对搜索引擎更友好
更好的可访问性...

语义性：

HTML 的主要工作之一是赋予文本结构，使浏览器能够按照开发者的意图显示 HTML 文档。本文介绍了如何使用 HTML 通过定义标题和段落来提供基本的页面结构。

实现结构所涉及的元素具体代表什么，完全取决于作者编辑的内容，只要层次结构是合理的。在创建此类结构时，只需要记住一条最佳实践。

为什么我们需要结构化？这是因为元素有素给内容结构，所以浏览器不知道什么是标题，什么是段落。

用户在阅读网页时，往往会快速浏览以查找相关内容，经常是阅读开头的标题（我们通常在一个网页上会花费很少的时间）。如果用户不能在几秒内看到一些有用的内容，他们很可能会感到沮丧并离开。

为什么我们需要语义？我们需要确保使用了正确的元素来给予内容正确的含义、作用以及外形。在这里，h1 元素也是一个语义元素。它所包裹的文本具有“页面上的顶级标题”的作用（或意义）。

一般来说，浏览器会给它一个更大的字形来让它看上去像个标题。更重要的是，它的语义将以多种方式被使用，比如通过上文提到的搜索引擎和屏幕阅读器。

强调重要性标签

HTML 也提供了相应的标签，使其具有加粗、倾斜、下划线等效果，来着重强调某些文字。

带有语义现在更推荐使用

标签	作用
`<strong></strong>`	加粗
`<em></em>`	倾斜
`<ins></ins>`	下划线
`<del></del>`	删除线

无语义，不推荐使用，除非特殊情况

标签	作用
`<b></b>`	加粗
`<i></i>`	倾斜
`<u></u>`	下划线
`<s></s>`	删除线

注释标签

在 HTML 中，注释标签用于添加不会在浏览器中显示的注释或说明。

语法：

<!-- 这里是注释内容 -->

快捷键：ctrl + /

特点：

注释内容不会显示在网页上
可以跨越多行
常用于代码说明、临时禁用代码或给其他开发者留言

块级元素和内联元素

HTML标签分类：
在 HTML 中有两种元素类别：
块级元素和内联元素。
分类不同决定着展示形式不一样。

块级元素

块级元素独占一行
它可以嵌套其他元素
常见的比如p、h、div等

内联元素

可以一行放多个，通常与文本一起使用
不能嵌套块级元素，可以嵌套其他内联元素
常见比如 strong、em、a 等

注意事项：
p里面不能嵌套其他块级元素
段落里面主要放文字相关，比如内联元素

但是元素分类不是一直不可更改的，后面的CSS可以通过display改变他们显示模式

图像标签以及常见格式

图像标签 img

作用：在网页中显示图片
语法：

<img src="图片路径" alt="图片描述">

语法说明: 单标签（空元素）

默认包含两个属性：src 和 alt

src 属性

指向要插入到页面的图像地址

alt 属性

备选文本，用于在图片无法显示或者因为网速慢情况下显示的文字

注意：

属性采取键值对形式：属性="值"
属性之间没有必要的先后顺序
但是属性之间必须有空格分隔

其他属性：

属性	作用
width	设置图片宽度（建议css修改）
height	设置图片高度（建议css修改）
title	图像标题。鼠标悬停显示的文本

图片属性总结：

属性	作用
src	指向要插入到页面的图像地址
alt	备选文本。图片无法显示提示的文字
width	设置图片宽度（建议css修改）
height	设置图片高度（建议css修改）
title	图像标题。鼠标悬停显示的文本

注意：

属性采取键值对形式：属性="值"
属性之间没有必要的先后顺序，但属性之间必须有空格分隔

常见图片格式

常见图片格式对照表

格式	特点	适用场景
jpeg / jpg	有损压缩技术，放大会变得模糊或有锯齿	摄影照片、网页图片（非透明背景）
png	无损压缩，支持透明度	Logo、网页图形、需要透明度的图像
gif	支持动画，最多256色（索引色）；支持简单动画和透明背景	简单动画、表情包、低色彩图形
webp	Google 开发的现代格式；支持有损/无损压缩、透明度和动画	网页优化（替代 JPEG/PNG/GIF），代表：淘宝等
avif	基于 AV1 视频编码，支持高压缩率和 HDR；压缩效率优于 WebP	未来网页优化，需高性能编码的场景（B站、京东等）

路径分类

路径：
在html中，路径用于指定文件（如图像，样式表现或其他网页）的位置
白话：图片相对于html文件的位置，html怎么找到图片

相对路径

相对于当前文件位置的路径

图片路径引用

1.同一目录

说明：直接使用文件名即可，./ 表示当前文件夹（可省略）
示例：

<img src="pig.jpg" alt="这是佩奇">
<img src="./pig.jpg" alt="这是佩奇">

2.下级子目录

说明：使用 目录名/文件名 的形式
示例：

<img src="img/pig.jpg" alt="这是佩奇">

3.上级目录

说明：使用 ../ 返回上一级目录
示例：

<img src="../pig.jpg" alt="这是佩奇">

绝对路径

绝对路径是从根目录开始的完整路径，包含完整的URL地址

图片路径引用

1.从盘符开始（本地绝对路径）
适用于本地文件的完整路径，直接写盘符开头的文件位置。
示例：

<img src="E:\HTML5\代码\pic.jpg" alt="示例图片">

2.完整网络地址（URL）
适用于互联网上的图片，直接写完整的 HTTP/HTTPS 地址。
示例：

<img src="https://www.example.com/images/pic.jpg" alt="示例图片">

音视频标签

视频标签

使网页变得更加丰富多彩，吸引用户语法：

<video src=""></video>  
<video src="video.mp4" controls width="300"></video>

核心属性：

src 属性：指向要插入到页面的视频地址
controls：显示浏览器自带播放控件
width/height 属性：设置视频的宽度和高度

视频标签其他属性：

属性	作用
autoplay	自动播放
loop	循环播放
muted	静音
poster	预览图像

视频标签兼容性写法：

不同浏览器支持的视频格式有所差异

浏览器	MP4	WebM	Ogg
Internet Explorer	YES	NO	NO
Chrome	YES	YES	YES
Firefox	YES	YES	YES
Safari	YES	NO	NO
Opera	YES (从 Opera 25 起)	YES	YES

为了视频尽可能兼容不同浏览器，建议使用以下兼容性写法：

<video controls controls muted loop poster="poster.jpg">  
  <source src="video.ogg" type="video/ogg">  
  <source src="video.mp4" type="video/mp4">  
  <source src="video.webm" type="video/webm">  
  <p>您的浏览器不支持 HTML 5 Video 标签，请升级浏览器。</p>  
</video>

核心原理：

将 src 属性放在几个单独的 <source> 元素当中，这些元素分别指向各自的资源。
浏览器会检查 <source> 元素，并且播放第一个与其自身相匹配的媒体。
每个 <source> 元素都含有 type 属性，浏览器也会通过检查这个属性来迅速跳过那些不支持的格式。如果没有添加 type 属性，浏览器会尝试加载每一个文件，直到找到一个能正确播放的格式，但这样会消耗大量的时间和资源。

音频标签

使网页变得更加丰富多彩，吸引用户
语法：

<audio src=""></audio>  
<audio src="audio.mp3" controls></audio>

核心属性：

src 属性：指向要插入到页面的音频地址
controls：显示浏览器自带播放控件

音频标签其他属性：

属性	作用
autoplay	自动播放
loop	循环播放
muted	静音

音频标签兼容性写法：

不同浏览器支持的音频格式有所差异

浏览器	MP3	WAV	Ogg
Internet Explorer	YES	NO	NO
Chrome	YES	YES	YES
Firefox	YES	YES	YES
Safari	YES	NO	NO
Opera	YES (从 Opera 25 起)	YES	YES

音频标签其他兼容性写法：

<audio controls controls muted loop>  
  <source src="audio.mp3" type="audio/mpeg">  
  <source src="audio.wav" type="audio/wav">  
  <source src="audio.ogg" type="audio/ogg">  
  <p>您的浏览器不支持 HTML 5 Audio 标签，请升级浏览器。</p>  
</audio>

核心原理：和视频标签的兼容性写法类似，只是将视频标签的 <source> 元素替换为音频标签的 <source> 元素。

创建超级链接以及锚点链接

超链接使我们能够将我们的文档链接到任何其他文档（或其他资源），也可以链接到文档的指定部分。

语法

<a href=""></a>  
<a href="https://www.deepseek.com/">DeepSeek官网</a>

核心属性：

href 属性（也称为超文本引用或目标）：它将包含一个网址，用来创建一个基本链接。

链接内容：
链接可以包含除了自身之外的其他元素，比如文字、标题、图片、视频等。

其他属性

title 属性

作用：鼠标悬停时的提示文字
示例：

<a href="https://www.example.com/" title="这是示例网站">示例链接</a>

target 属性

作用：控制链接打开的页面方式
常用取值：
- _self：当前窗口打开（默认值）
- _blank：新窗口打开
- _parent：父窗口打开
- _top：顶部窗口打开

最佳链接实践

空连接

在HTML中，空连接通常指的是没有实际指向目标的超链接，符号是#

<a href="#">商品列表</a>

下载链接

如果是exe或者压缩包点击是下载

<a href="download.exe">下载window版本</a>

邮件链接

某些简单场景或个人使用情况下使用。
公司或者流量大的网站慎用，有垃圾邮件等风险，其他方案替代。

<a href="mailto:pig@mozilla.org">给我发邮件</a>

锚点链接

锚点链接允许用户在同一个页面内跳转到指定位置。
非常适合长页面导航。

锚点链接实现步骤

定义锚点目标
使用id属性创建锚点目标
比如：

<h2 id="1">第一部分</h2>

创建跳转链接
使用#标记锚点目标
比如：

<a href="#1">跳转到第一部分</a>

多学一招

想要点击链接之后，页面具有滑动效果。
请在<head>标签中添加一下css代码。

<style>
html {
  scroll-behavior: smooth;
}
</style>

布局标签

网站结构标签

网页的外观多种多样，但是大概都包含：页眉、导航栏、主内容、侧边栏、页脚等

标签	作用
`<header>`	网页页眉(头部)
`<main>`	网页内容。每个页面只能有一个
`<nav>`	导航栏
`<article>`	文章相关
`<section>`	分块
`<aside>`	侧边栏
`<footer>`	页面页脚(底部)

这些标签受浏览器兼容性问题影响，PC端根据公司需求，移动端放心使用

无语义标签

没有合适语义标签时，在进行一些布局时候可以选择：div 和 span 标签

div标签

特点：

块级元素：默认独占一行，前后会自动换行。
通常用于布局结构，作为其他元素的容器。
可以包含其他块级或行内元素。
默认没有语义。

span标签

特点：

行内元素：不会换行，仅包裹内容的一部分。
用于对文本或行内元素的局部样式或操作。
默认没有语义。

列表标签

HTML 列表是网页内容组织的重要元素。可以让我们显示内容更加整齐有序（后面的笔记会有详细内容）

列表标签

无序列表 ul

顺序无关紧要的列表
无序列表是我们布局中非常常用，常用于一些整齐对齐的模块中使用

场景

基本语法

<ul>
  <li>猪爸爸</li>
  <li>猪妈妈</li>
  <li>佩奇</li>
  <li>乔治</li>
</ul>

渲染效果

猪爸爸
猪妈妈
佩奇
乔治

标签说明
<ul>

定义列表的容器
只能包含 <li> 元素

<li>

定义列表的选项
里面可以放其他HTML元素

有序列表 ol

顺序有关紧要的列表
有序列表再布局中较少，了解即可，实际开发即使有顺序，我们一般也是用其他属性

有序列表ol

基本语法

<ol>
  <li>看视频</li>
  <li>写代码</li>
  <li>做笔记</li>
  <li>多复习</li>
</ol>

渲染效果

看视频
写代码
做笔记
多复习

标签说明
<ol>

定义列表的容器
只能包含 <li> 元素

<li>

定义列表的选项
里面可以放其他HTML元素

描述列表 dl

标记一组项目及相关描述
描述列表再我们布局中主要是在页面底部

场景

描述列表dl

基本语法

<dl>
  <dt>家电</dt>
  <dd>电视</dd>
  <dd>冰箱</dd>
  <dd>空调</dd>
  <dd>烟灶</dd>
</dl>

渲染效果
家电电视冰箱空调烟灶

标签说明
<dl>

定义列表的容器
只能包含 <dt> 和 <dd> 元素

<dt>

定义被描述的术语
通常显示为左对齐或加粗
一个 <dt> 可以对应多个 <dd>

<dd>

包含术语的定义或描述
通常显示为缩进形式
可以包含段落、图片、链接等其他HTML元素

表格标签和AI合并单元格

表格作用：以结构化的方式展示行列数据，使信息清晰，易读且便于对比
网页场景：主要用于数据展示或者后台管理系统的信息展示

场景

表格语法

表格基本语法

<table border="1">
  <!--border属性：表格边框属性(现阶段用来看效果，后期用css替代)-->
    <tr>
      <th>姓名</th>
      <th>年龄</th>
    </tr>
    <tr>
      <td>佩奇</td>
      <td>6</td>
    </tr>
</table>

表格基本组成

标签	作用
`<table>`	表格容器标签
`<tr>`	行标签
`<td>`	单元格标签
`<th>`	表头单元格（可以让里面的文字水平和垂直居中）
`<border>`	表格边框属性(现阶段用来看效果，后期用css替代)

表格结构标签：增强表格语义，让表格结构更加清晰

标签	作用
`<thead>`	定义表格的头部区域
`<tbody>`	定义表格的主体内容
`<tfoot>`	定义表格的底部区域

示例：

<table border="1">
  <!--border属性：表格边框属性(现阶段用来看效果，后期用css替代)-->
  <thead>
    <!--thead标签：定义表格的头部区域-->
    <tr>
      <th>姓名</th>
      <th>年龄</th>
    </tr>
  </thead>
  <tbody>
    <!--tbody标签：定义表格的主体内容-->
    <tr>
      <td>佩奇</td>
      <td>6</td>
    </tr>
  </tbody>
  <tfoot>
    <!--tfoot标签：定义表格的底部区域-->
    <tr>
      <td colspan="2">合计1人</td>
      <!--colspan属性：合并列单元格-->
    </tr>
  </tfoot>
</table>

表格合并单元格

表格开发中很少使用合并，因为会导致表格难以维护，且可能影响响应式适配（尤其在移动端）。如果特殊情况，可以借助于AI。

表格合并原理

确定合并类型：跨行（rowspan）或跨列（colspan）
遵循左上原则，找到目标单元格并填写合并数量
删除合并后多余的单元格

示例：

<table border="1">
  <tr>
    <th>姓名</th>
    <th>年龄</th>
    <th>性别</th>
    <th>爱好</th>
    <th>居住地</th>
  </tr>
  <tr>
    <td>张三</td>
    <td>18</td>
    <td>男</td>
    <td>足球</td>
    <td>北京</td>
  </tr>
  <tr>
    <td>李四</td>
    <td>20</td>
    <td>女</td>
    <td>篮球</td>
    <td></td>
  </tr>
  <tr>
    <td>王五</td>
    <td>22</td>
    <td>男</td>
    <td>篮球</td>
    <td>深圳</td>
  </tr>
  <tr>
    <td colspan="5">日期：2023年10月1日</td>
  </tr>
</table>

渲染效果

表单

表单：是用于收集用户输入数据，并将数据提交到后端进行处理场景：

用户登录/注册
搜索框
联系表单
问卷调查
订单支付
文件上传

表单的核心标签有三部分组成：

表单容器
<form>：

定义表单的容器，包裹所有表单控件。
默认包含action属性

表单控件

包含 <input> 通用输入控件、<textarea>：多行文本输入框 <select> 下拉选择框、<button>：自定义按钮等

辅助标签
<label>：

关联输入控件的文本标签，提升可访问性（点击标签可聚焦输入框）
更好的提高表单的用户体验

表单容器

form 标签 作用：定义表单的容器，包裹所有表单控件。

<form action=""></form>

action 属性定义了在提交表单时，应该把所收集的数据送给谁（URL）去处理。

目前我们还不涉及数据交互，所以这里暂且为空即可

表单控件

input表单：通用输入控件，包含输入框、单选框、复选框等 textarea表单：多行文本输入框 select下拉表单：下拉选择框 button按钮：自定义按钮

表单控件-input

输入标签<input>是最常用的表单元素之一，它可以创建文本输入框、密码框、单选框、复选框等。
type属性定义了输入框的类型

type属性值	说明
text	单行文本框
password	密码框
radio	单选框
checkbox	复选框
file	文件域

1.单行文本框和密码框(text/password)

场景

type属性值

type属性值	说明
text	单行文本框
password	密码框

其他属性

其他属性	说明
placeholder	提示信息
name	元素的名称
maxlength	允许的最大字符数
accesskey	使元素获得焦点的快捷键(按下指定的键组合，即可将焦点移动到该元素)<br/>win系统：alt+键值<br/>mac系统：option+键值
autocomplete	用于控制表单的自动填充行为，帮助浏览器决定是否根据用户历史输入自动填充字段值<br>取值 on / off

示例

<form action="">
  <ul>
    <li>
    账号：<input type="text" name="username" placeholder="请输入账号" accesskey="u">
    <!--accesskey属性：使元素获得焦点的快捷键(win系统：alt+键值，mac系统：option+键值)-->
    </li>
    <li>
    密码：<input type="password" name="password" placeholder="请输入密码" maxlength="12">
    </li>
  </ul>
</form>

2.单选框和复选框(radio/checkbox)

场景

type属性值

type属性值	说明
radio	单选框
checkbox	复选框

其他属性

其他属性	说明
name	表单名称实现分组
value	表单值
checked	是否默认选中

示例

<form action="">
  <ul>
    <!-- 2. 单选框 复选框和文件域 -->
    <li>
      性别:
      <input type="radio" name="gender" value="0" checked> 女
      <input type="radio" name="gender" value="1"> 男
    </li>
    <li>
      爱好:
      <input type="checkbox" name="hobby" value="0" checked> 足球
      <input type="checkbox" name="hobby" value="1"> 篮球
      <input type="checkbox" name="hobby" value="2"> 双色球
    </li>
  </ul>
</form>

3.文件域(file)

场景

type属性值

type属性值	说明
file	文件域

其他属性

其他属性	说明
multiple	允许选择多个文件
accept	规定选择的文件类型，多个类型中间用逗号分割

示例

<form action="">
  <ul>
    <li>
      头像:
      <input type="file" name="file" multiple accept=".jpg,.png,.webp">
    </li>
  </ul>
</form>

accept常用属性值补充

accept属性值	说明
image/*	只允许选择图片文件
audio/*	只允许选择音频文件
video/*	只允许选择视频文件
application/*	只允许选择应用程序文件

表单控件-textarea

<textarea> HTML 元素是一个多行纯文本编辑控件，适用于允许用户输入大量自由格式文本的场景，例如评论或反馈表单。
textarea 多行文本框也称为文本域。

场景

基本语法

<textarea></textarea>

常见属性

常见属性	说明
name	表单名称
placeholder	提示信息
rows	文本行数，正整数，默认为2
cols	文本列数，正整数，默认20

文本域textarea利用CSS来设定样式，比如宽高边框等

示例

<form action="">
  留言:
  <textarea name="msg" cols="30" rows="10" placeholder="请输入留言"></textarea>
</form>

表单控件-select

HTML<select>元素表示一个提供选项菜单的控件

场景

语法示例

<select name="" id="">
  <option value="北京">北京</option>
  <option value="深圳">深圳</option>
  <option value="上海" selected>上海</option>
  <option value="广州">广州</option>
</select>

<select> 元素是容器，<option>是每一个选项标签，每个选项要跟一个值
要想默认选中一个选项，可以添加 selected 属性。

因为select很难修改为好看的效果，大部分下拉列表可以通过其他标签模拟实现

表单控件-button

HTML <button> 标签定义一个按钮，元素内部可以放置内容，比如文本或图像

场景

语法示例

<!--中间文字写什么，按钮就显示什么-->
  <button>搜索</button>
  <button>登录</button>

disabled属性可以禁用按钮，禁用后的按钮不能点击，如下图

辅助标签-label

<label> 表示用户界面中某个元素的说明，提升可访问性（点击标签可聚焦输入框）

场景

两种使用方式：

方式一： 利用for和id相关联

<label for="nan">男</label>
<input type="radio" id="nan" name="sex">

方式二： 直接包含

<label>男
  <input type="radio" name="sex">
</label>

通过label标签也可以实现单击标签就可以锁定输入框的效果
示例

<label>
  用户名:
  <input type="text" name="username">
</label>

字符实体

字符实体是一段以连字号（&）开头、以分号（;）结尾的文本（字符串）。
常用于显示保留字符和不可见的字符（如“不换行空格”）

常用字符实体对照表

字符	实体	说明
`&`	`&`	与符号
`<`	`<`	小于号
`>`	`>`	大于号
`"`	`"`	引号
	` `	不换行空格
`–`	`–`	短破折号
`—`	`—`	长破折号
`©`	`©`	版权符号
`®`	`®`	注册商标符号
`™`	`™`	商标符号
`≈`	`≈`	近似等于符号
`≠`	`≠`	不等于符号
`£`	`£`	英镑符号
`€`	`€`	欧元符号
`°`	`°`	度符号

markdown综合教程

Mon, 29 Dec 2025 00:00:00 GMT

一.标题语法

“#” + 空格 + 标题名称，一个“#”表示一级标题，以此类推，一、二级标题有使用若干“=”，“-”分割的特殊表示方法

代码示例：

# 一级标题
## 二级标题
### 三级标题
#### 四级标题
##### 五级标题
###### 六级标题
一级标题
=======
二级标题
-------

效果预览：

一级标题

二级标题

三级标题

四级标题

五级标题

六级标题

一级标题

二级标题

二.段落语法

要分割段落，只需要在两个段落之间添加空白行即可

代码示例：

我喜欢你，
你喜欢我吗

我不喜欢你，
我们还是算了吧

效果预览：

我喜欢你，你喜欢我吗

我不喜欢你，我们还是算了吧

三.markdown换行语法

1.空格换行

在内容末尾敲击至少两个空格，在回车，即可换行

代码示例：

有你在的今天  
今天本是平凡的一天  
却成为了还不错的一天

效果预览：
有你在的今天
今天本是平凡的一天
却成为了还不错的一天

2.标签换行

在内容末尾添加 标签即可

代码示例：

虽然没有什么特别的事<br>
但只要有你在就足够了<br>

效果预览：
虽然没有什么特别的事 但只要有你在就足够了

四.强调语法

1.粗体

(1).星号加粗

在文字两端都添加两个星号* 代码示例：

**直到现在**

效果预览：
直到现在

(2).下划线加粗

在文字两端都添加两个下划线_

代码示例：

__你依然是我的光__

效果预览：
你依然是我的光

注：要在中间部分加粗最好使用星号

2.斜体

(1).星号

在文字两端都添加一个星号*
代码示例：

*你啊*

效果预览： 你啊

(2).下划线

在文字两端都添加一个下划线_
代码示例：

_在不知不觉中已经成为了我每天的日常了_

效果预览： 在不知不觉中已经成为了我每天的日常了

3.同时使用

可以有很多种组合方式，效果都是一样的

代码示例：

***和你说话时***
_**和你说话时**_
*_和你说话时__*

效果预览：
和你说话时

注.在中间使用强调语法强调一律使用星号

五.引用语法

1.块引用

> + 空格 + 引用内容 代码示例：

> 总觉得每天都会变得开心一点

效果预览：

总觉得每天都会变得开心一点

2.多个段落的块引用

在段落之间的空白行添加>即可

代码示例：

> hello world
>
> say hello

效果预览：

hello world

say hello

3.嵌套块引用

引用也是可以嵌套的

代码示例：

> 这是一个引用
>
>>这是引用中的引用
>>
>>>这是引用中的引用中的引用

效果预览：

这是一个引用

这是引用中的引用

这是引用中的引用中的引用

4.带有其他元素的块引用

部分语法不支持，请自行尝试

代码示例：

> # 一级标题
> **粗体**  
> _斜体_  
> - 无序列表

效果预览：

一级标题

粗体
斜体

无序列表

六.列表语法

1.有序列表

n. + 空格 + 内容
列表也支持嵌套

每日计划

代码示例：

1. 吃饭
    1. 吃早饭
    2. 吃午饭
    3. 吃晚饭
2. 睡觉
    1. 早上睡
    2. 中午睡
    3. 晚上睡
        1. 做个好梦
        2. 做个噩梦

效果预览：

吃饭
1. 吃早饭
2. 吃午饭
3. 吃晚饭
睡觉
1. 早上睡
2. 中午睡
3. 晚上睡
  1. 做个好梦
  2. 做个噩梦

2.无序列表

代码示例：

# 1.加号
+ 学习C语言
     + 数据类型
     + 常量变量
     + 作用域
     + 操作符

# 2.减号
- 背1000个单词
  - 500个四级单词
  - 500个六级单词
      - 以a开头的单词

# 3.星号
* 跑1000m路程

效果预览：

学习C语言
- 数据类型
- 常量变量
- 作用域
- 操作符

背1000个单词
500个四级单词
500个六级单词
- 以a开头的单词

跑1000m路程

注:列表中同样可以使用其他语法格式

七.代码语法

可以将自己写的代码放进代码块中，这样更加美观

1.反引号

代码示例：

`print(hello world)`

效果预览：
print(hello world)

2.转义反引号

需要在代码块里面写出反引号，要在外部额外添加反引号

代码示例：

``print(`hello world`)``

效果预览：
print(`hello world`)

3.代码块

(1).缩进式代码块

给所写的代码每一行添加四个空格
代码示例：

    #include <stdio.h>
    int main()
    {
        print(hello world);
        
        return 0;
    }

效果预览：

#include <stdio.h>
int main()
{
    print(hello world);
    
    return 0;
}

(2).反引号代码块

代码示例： 在代码上下使用首尾呼应的三反引号```，在第一个部分可添加代码语言名称，用来显示高亮的代码

```py
print(hello world)



**效果预览：**
```py
print(hello world)

(3).波浪号代码块

使用三波浪号~~~，与反引号同理 代码示例：

~~~python
print(hello world)
~~~

效果预览：

print(hello world)

八.分割线语法

使用三个及以上的星号(***).破折号(---).或下划线(___)

代码示例：

***

---

___

效果预览：

注:为了兼容性，请在分割线前后均添加空白行

九.链接语法

链接文本放在中括号内，链接地址放在后面的括号中，链接title可选。

1.无title

代码示例：

[仙鹤的学习小窝](http://47.108.140.232)

效果预览：
仙鹤的学习小窝

2.有title

代码示例：

[仙鹤的学习小窝](http://47.108.140.232 "坚持学习，无限进步")

效果预览：
仙鹤的学习小窝

3.尖括号链接

使用尖括号可以很方便地把URL或者email地址变成可点击的链接

代码示例：

<http://47.108.140.232/>  
<xkl51920@gmail.com>

效果预览：
http://47.108.140.232/
xkl51920@gmail.com

4. 带格式化的链接

(1).强调链接, 在链接语法前后增加星号

代码示例：

**[仙鹤的学习小窝](http://47.108.140.232)**

效果预览：
仙鹤的学习小窝

(2)要将链接表示为代码，请在方括号中添加反引号

代码示例：

[`仙鹤的学习小窝`](http://47.108.140.232)

效果预览：
仙鹤的学习小窝

5. 引用链接

分为两部分

代码示例：

[仙鹤的学习小窝][1]  

[1]: http://47.108.140.232 "坚持学习，无限进步"

效果预览：
仙鹤的学习小窝

(1).第一部分

尽管不是必需的，可以在第一组和第二组括号之间包含一个空格。第二组括号中的标签不区分大小写，可以包含字母，数字，空格或标点符号。

(2).第二部分

引用类型链接的第二部分使用以下属性设置格式：

放在括号中的标签，其后紧跟一个冒号和至少一个空格（例如[label]:）。
链接的URL，可以选择将其括在尖括号中。
链接的可选标题，可以将其括在双引号，单引号或括号中。

注：第二部分的上一行不能有任何内容

[1]: http://47.108.140.232
[1]: http://47.108.140.232 "坚持学习，无限进步"
[1]: http://47.108.140.232 '坚持学习，无限进步'
[1]: http://47.108.140.232 (坚持学习，无限进步)
[1]: <http://47.108.140.232> "坚持学习，无限进步"
[1]: <http://47.108.140.232> '坚持学习，无限进步'
[1]: <http://47.108.140.232> (坚持学习，无限进步)

链接最佳实践

不同的 Markdown 应用程序处理URL中间的空格方式不一样。
为了兼容性，请尽量使用%20代替空格。
[仙鹤的学习小窝](http://%2047.108.140.232%20)

十.图片语法

1.基本图片语法

要添加图像，请使用感叹号 (!), 然后在方括号增加替代文本，图片链接放在圆括号里，括号里的链接后可以增加一个可选的图片标题文本。

代码示例：

![一只可爱的特莉波卡](/images/posts/markdown_guide/小波卡.jpg)

效果预览：

2.链接图片语法

给图片增加链接，请将图像的Markdown括在方括号中，然后将链接添加在圆括号中。

代码示例：

[![特莉波卡-冬日](https://image.emoera.cn:443/uploads/ubpY6WS-s3X8.webp)](https://image.emoera.cn:443/uploads/ubpY6WS-s3X8.webp)

效果预览：

来自E时代图床

十一.转义字符语法

1.基本的转义语法

要显示原本用于格式化Markdown文档的字符，请在字符前面添加反斜杠字符 \ 。

代码示例：

\`E时代是CDTU最强算法开发社团\`

效果预览：
`E时代是CDTU最强算法开发社团`

2.可做转义的字符

代码示例：

\ 
\` 
\* 
\_ 
\{\}
\[\]
\()
\# 
\+ 
\- 
\. 
\! 
\|

效果预览：
\ ` * _ {} [] () # + - . ! |

一.表格

1.基础表格

要添加表，请使用三个或多个连字符（---）创建每列的标题，并使用管道（|）分隔每列。您可以选择在表的任一端添加管道

代码示例：

| 类型关键字 | 中文名称 | 字节大小 |
|-------|------|------|
| char  | 字符型  | 1    |
| int   | 整型   | 4    |

效果预览：

类型关键字	中文名称	字节大小
char	字符型	1
int	整型	4

2.表格对齐

您可以通过在标题行中的连字符的左侧，右侧或两侧添加冒号（:），将列中的文本对齐到左侧，右侧或中心

代码示例：

| 类型关键字 | 中文名称 | 字节大小 |
|:------|:----:|-----:|
| short | 短整型  |    2 |
| long  | 长整型  |  4/8 |

效果预览：

类型关键字	中文名称	字节大小
short	短整型	2
long	长整型	4/8

3.格式化表格中的文字

您可以在表格中设置文本格式。例如，您可以添加链接，代码（仅反引号（`）中的单词或短语，而不是代码块）和强调。

您不能添加标题，块引用，列表，水平规则，图像或HTML标签。

表格中的格式化

代码示例：

| 可以使用  | 不可以使用  |
|-------|--------|
| 添加链接  | 添加标题   |
| 反引号代码 | 代码块    |
| 强调    | 标题     |
|       | 块引用    |
|       | 列表     |
|       | 水平规则   |
|       | 图像     |
|       | HTML标签 |

效果预览：

可以使用	不可以使用
添加链接	添加标题
反引号代码	代码块
强调	标题
	块引用
	列表
	水平规则
	图像
	HTML标签

4.在表中转义管道字符

您可以使用表格的HTML字符代码（|）,或者使用反斜杠（\）转义的方式,在表中显示竖线（|）字符.

代码示例：

|   表头   |
|:------:|
|   \|   |
| &#124; |

效果预览：

表头
\|
\|

二.围栏代码块

1.反引号代码块

代码示例：

```c
#include <stdio.h>
int main() 
{
    int a = 0;
    int b = 0;
    a = 10;             /*给a赋值
    b = 20;             给b赋值*/
    printf("a+b=%d\n", a + b);

    return 0;
}
```

效果预览：

#include <stdio.h>
int main() 
{
    int a = 0;
    int b = 0;
    a = 10;             /*给a赋值
    b = 20;             给b赋值*/
    printf("a+b=%d\n", a + b);

    return 0;
}

2.波浪号代码块

代码示例：

~~~c
#include <stdio.h>
int main() 
{
    int a = 0;
    int b = 0;
    a = 10;             /*给a赋值*/
    b = 20;             /*给b赋值*/
    printf("a+b=%d\n", a + b);

    return 0;
}
~~~

效果预览：

#include <stdio.h>
int main() 
{
    int a = 0;
    int b = 0;
    a = 10;             /*给a赋值*/
    b = 20;             /*给b赋值*/
    printf("a+b=%d\n", a + b);

    return 0;
}

3.语法高亮

要添加语法突出显示，请在受防护的代码块之前的反引号旁边指定一种语言

代码示例：

```python
print("hello world")
```

```json
{
  "firstName": "John",
  "lastName": "Smith",
  "age": 25
}
```

效果预览：

print("hello world")

{
  "firstName": "John",
  "lastName": "Smith",
  "age": 25
}

三.脚注

代码示例：

这是一个脚注[^1]，用来解释内容

[^1]: 这是一个解释，用来解释脚注标记的内容

效果预览：
这是一个脚注^1，用来解释内容

注有的编辑器可能不支持脚注，会将其识别为链接

四.标题编号

第一部分：在标题后面添加空格和中括号，并且在中括号填写地址名称

第二部分：在中括号填写展示的文本，在小括号填写地址，即可通过点击文字进行跳转

代码示例：

# 四.标题编号
[四.标题编号](#标题一)

效果预览：
四.标题编号

注:有的编辑器可能不支持这种扩展格式，而是这样的

代码示例：

# 四.标题编号
[点击跳转到语法综合文档](#markdown教程)

效果预览：

点击跳转到语法综合文档

五.定义列表

包括术语和定义两部分

核心用途

整理术语表(如技术文档中的概念解释)
编写FAQ回答(问题 = 术语，答案 = 定义)
说明功能/参数(功能名称 = 术语，用法 = 定义)
替代表格的简单"两列结构"，排版更简洁

示例

代码示例：

Markdown
: 一种轻量级标记语言，用于快速编写格式化文档，语法简洁易记。

Typora
: 一款支持实时预览的 Markdown 编辑器，  
  支持定义列表.表格.公式等扩展语法，  
  排版美观且操作直观。

锚点跳转
: 通过 `[链接文字](#ID)` 语法，实现页面内快速跳转的功能，  
常用于长文档的目录导航。

效果预览：

Markdown : 一种轻量级标记语言，用于快速编写格式化文档，语法简洁易记。

Typora : 一款支持实时预览的 Markdown 编辑器，
支持定义列表.表格.公式等扩展语法，
排版美观且操作直观。

锚点跳转 : 通过 [链接文字](#ID) 语法，实现页面内快速跳转的功能，
常用于长文档的目录导航。

六.删除线

您可以通过在单词中心放置一条水平线来删除单词。结果看起来像这样。此功能使您可以指示某些单词是一个错误，要从文档中删除。若要删除单词，请在单词前后使用两个波浪号~~。

代码示例：

~~世界是平坦的。~~ 我们现在知道世界是圆的。

效果预览：
~~世界是平坦的。~~ 我们现在知道世界是圆的。

七.任务列表

代码示例：

未完成：- [ ] 内容 中括号填写空格
已完成：- [×] 内容 中括号填写小写“x”


## 今日计划
- [ ] 吃饭
- [ ] 睡觉
- [x] 做作业

效果预览：

今日计划

[ ] 吃饭
[ ] 睡觉
[x] 做作业

八.使用Emoji表情

1.复制粘贴表情符号

在大多数情况下，您可以简单地从Emojipedia (opens new window)等来源复制表情符号并将其粘贴到文档中。许多Markdown应用程序会自动以Markdown格式的文本显示表情符号。从Markdown应用程序导出的HTML和PDF文件应显示表情符号。

Tip: 如果您使用的是静态网站生成器，请确保将HTML页面编码为UTF-8。

2.使用表情符号简码

一些Markdown应用程序允许您通过键入表情符号短代码来插入表情符号。这些以冒号开头和结尾，并包含表情符号的名称

代码示例：

:tent:  
:joy:

效果预览：
:tent:
:joy:

九.自动网址链接

许多Markdown处理器会自动将URL转换为链接。这意味着如果您输入http://47.108.140.232/，即使您未使用方括号，您的Markdown处理器也会自动将其转换为链接

代码示例：

http://47.108.140.232

效果预览：
http://47.108.140.232

禁用自动网址链接

通过反引号代码来解决

代码示例：

`http://47.108.140.232/`

效果预览：
http://47.108.140.232/

变通教程

下划线

Markdown 原生不支持下划线，但如果你的 Markdown 处理器支持 HTML，可以使用 <ins> 标签：

代码示例：

一些文字 <ins>将被加下划线</ins>。

效果预览：
一些文字 <ins>将被加下划线</ins>。

缩进

Markdown里的空格和制表符有特殊用途，比如创建换行或代码块。如果你想用Tab缩进段落，可以使用 

代码示例：

&nbsp;&nbsp;&nbsp;&nbsp;这是一个缩进的段落。

效果预览：
这是一个缩进的段落。

文字居中

Markdown 没有文本对齐的语法，但可以使用 HTML 标签 ~~<center>~~（已废弃）或 CSS 解决：

代码示例：

<p style="text-align:center">这段文字居中显示。</p>

效果预览：
这段文字居中显示。

文字颜色

Markdown 不支持更改文字颜色，但 HTML 可以：

代码示例：

<font color="red">这段文字是红色的！</font>  
<p style="color:blue">这段文字是蓝色的。</p>

效果预览：
这段文字是红色的！
这段文字是蓝色的。

仙鹤的学习小窝

数据结构（综述）

数据结构

第一章 绪论

1.0 开篇——数据结构在学什么？

1.1 数据结构的基本概念

1. 什么是数据

2. 数据元素、数据项

3. 数据结构、数据对象

4. 数据结构的三要素

5. 数据类型、抽象数据类型（ADT）

1.2.1 算法的基本概念

1.2.2 算法的时间复杂度

1.2.3 算法的空间复杂度

小结

第二章 线性表

2.1 线性表的定义和基本操作

2.2.1 顺序表的定义

2.2.2_1 顺序表的插入和删除

2.2.2_2 顺序表的查找

2.3.1 单链表的定义

2.3.2_1 单链表的插入和删除

2.3.2_2 单链表的查找

Java 核心与 AI 开发进阶

Java核心与AI开发进阶

第十二章：集合高级

一、集合体系结构

二、Collection 接口的使用

三、集合的通用遍历方式

四、List 接口

4.1 并发修改异常

五、数据结构

5.1 栈（Stack）

5.2 队列（Queue）

5.3 数组（Array）

5.4 链表（Linked List）

六、ArrayList 类

6.1 长度可变原理

6.2 源码解析

6.3 LinkedList 类

七、泛型（Generics）

7.1 泛型的好处

7.2 泛型类

7.3 泛型方法

7.4 泛型接口

7.5 泛型通配符 ?

集合高级（2）

一、Set 集合介绍

二、TreeSet 集合

2.1 底层数据结构演进

2.2 两种排序方式

三、HashSet 集合

3.1 hashCode 与 equals 配合流程

3.2 HashSet 底层原理

四、LinkedHashSet 集合

五、Collections 工具类

5.1 可变参数（Varargs）

六、Map 集合介绍

6.1 常见 API

6.2 三种遍历方式

七、Map 集合的实现类

7.1 HashMap 底层原理

7.2 LinkedHashMap

7.3 TreeMap

八、Set / List / Map 选择速查

九、练习：统计字符出现次数

第十三章：Stream 流

一、Stream 流思想三步骤

二、获取 Stream 流对象

三、Stream 中间操作方法

四、Stream 终结操作方法

五、Stream 收集操作

5.1 收集到 Map 示例

5.2 综合练习：演员信息处理

第十四章：异常

一、异常体系

1.1 Exception 两大类

二、异常的默认处理流程

三、异常处理方式

3.1 try...catch：捕获异常

第一章绪论

第二章线性表

7.5 泛型通配符 `?`

3.1 `hashCode` 与 `equals` 配合流程

3.1 `try...catch`：捕获异常

3.2 `throws`：抛出异常

3.4 `throw` vs `throws`

4.1 找出所有 `.java` 文件（含子目录）