软件工程师中级考试-上午知识点总结（下）

6. 知识产权和标准化

1. 软件著作权客体：指的是受软件著作权保护的对象，即计算机程序和相关文档。
2. 知识产权具有严格的地域性。
3. 不受保护期限制：著名权、修改权、保护作品完整权；注意的是，发表权受保护期限制。
4. 专利权在期满之前如出现：没有按照规定交纳年费，专利权人以书面形式放弃专利权的，专利权会提前终止。
5. 注册商标的有效期为十年，但是可以延长（通过续展）。
6. 委托开发软件时，如没有做明确约定，著作权归开发方所有。
7. 两人以上分别就同样的发明专利申请专利时，谁先申请谁拥有。
8. 我国保护计算机软件著作权的两个基态法律：《中华人民共和国著作权法》和《计算机软件保护条例》。
9. 兼职也属于职务相关，属于职务作品，所以相关软件著作权属于兼职公司。
10. 职务作品著作权全部属于公司所有，个人只有署名权。
11. 商标申请，谁先申请归谁，同时申请，谁先使用归谁，同时使用抽签决定。

7. 软件工程

7.1 软件工程基础知识

1. 软件工程基本要素：方法、工具、过程。
2. 考过的零碎知识点：
   • 构建软件系统确定人数时需要考虑：系统的规模、技术复杂性、项目计划、开发人员的技术背景。
   • 确定软件体系结构：是在软件设计阶段进行的。（项目范围不是系统设计的范围）
   • I/O软件隐藏了I/O操作实现的细节，向用户提供的是逻辑接口，方便用户使用。
   • 软件变量控制是变更管理的重要内容，要有效进行变更控制，需要借助配置数据库和基线的概念。
   • 决策树和决策表适用于数据流程图中涉及多个逻辑条件的情况。
   • 逆向工程在软件维护时，由于缺少文档资料，而对软件的一种分析。（可以认为是在需求分析阶段进行的）
   • 软件维护工具不包括配置管理。
   • 软件过程改进框架包括：评估，计划，改进，监控。
   • 用户与系统分析人员联系方式：可行性分析报告、总体规划报告、系统开发合同、系统方案说明书
   • 系统分析人员与项目管理人员联系方式：系统开发计划（任务分解表、PERT图、GANT图）、系统开发月报、系统开发总结报告。

7.2 软件能力成熟度模型集成（CMMI）

1. 连续式模型

   级别1：初始级，特点是混乱和不可预测；

   级别2：重复级，特点是项目得到管理监控和跟踪，有稳定的策划和产品基线 ；

   级别3：确定级，通过软件过程的定义和制度化确保对产品质量的控制 ；

   级别4：管理级,，特点是产品质量得到策划，软件过程基于度量的跟踪（关注产品和过程的质量） ；

   级别5：优化级，特点是持续的过程能力改进。

2. 统一过程模型（UP）

   UP的每一次迭代都是一次完整的软件开发过程，包括整个软件开发生命周期，有五个核心工作流（需求、分析、设计、实现、测试)。

7.3 瀑布模型

1. 只适用于需求明确或者二次开发(需求稳定、变更少)。
2. 强调开发的阶段早期计划及需求调查和产品测试。
3. 容易理解，管理成本低。
4. 当需求不明确时该模型有很大的缺陷。

7.4 增量模型

1. 首先开发核心功能模块，优先级高的服务最先交付。
2. 具有瀑布模型的所有优点，第一个增量往往是核心的产品。
3. 第一个可交付版本所需要的成本和时间很少，快速支付。
4. 可以减少用户需求的变更，不必等到整个系统开发完成就可以使用。
5. 适用于商业产品的创新模式。
6. 缺点：模块划分是一个难点而不是优点，同时不适合大规模项目。

7.5 演化模型

1. 特别适用于对软件需求缺乏准确认识的情况。

7.6 原型模型。

1. 适合于用户需求不明确、需求经常变化的情况。
2. 当系统规模不是很大，也不是太复杂时，采用这个方法比较好。

7.7 螺旋模型

1. 适用于复杂的大型模型，同时加入了风险分析。
2. 支持用户需求的动态变化，但是过多的迭代次数会增加开发成本，延迟提交时间。

7.8 喷泉模型

1. 喷泉模型克服了瀑布模型不支持软件重用和多项开发活动的集成的局限性。
2. 在迭代过程中不断的完善软件系统（迭代性）。
3. 各开发活动之间不存在明显的边界（无间隙性）。

7.9 敏捷开发方法

1. 敏捷开发过程典型的方法：极限编程（XP）、水晶法（Crystl）、并列争球法（Scrum）、自适应软件开发（ASD）、敏捷统一过程（AUP）。
2. 极限编程
   • 4大价值：沟通、简单性、反馈和勇气。
3. 水晶法（Crystl）：认为每一个不同的项目都需要一套不同的策略、约定和方法论。
4. 并列争球法（Scrum）：使用迭代的方法，其中，把每30天一次的迭代称为一个冲刺。
5. 敏捷统一过程（AUP）：采用在大型上连续以及在小型上迭代的原理来构造软件系统。

7.10 其他开发方法

1. 结构化方法：适合面向数据流，处理规模不大且不复杂，需求明确的项目。
2. Jackson方法：面向数据结构的开发方法，适合于小规模的项目。
3. 原型方法：适合于需求不明确的开发，以原型模型为代表。

7.11 需求分析

1. 功能需求（开发软件必须具备什么样的功能）
2. 非功能需求（软件的属性、品质，eg:可靠性、性能、响应时间、扩展性）、设计约束（对解决方案的约束条件）。
3. 需求分析阶段的输出包括：数据流图、实体联系图、状态迁移图、数据字典。

7.12 系统设计

1. 设计软件系统总体结构，将一个复杂的系统按功能划分成模块。
2. 详细设计：对每个模块进行详细的算法设计。

7.13 系统测试

1. 意义：系统测试是为了发现错误而执行程序的过程，成功的测试是发现了至今尚未发现的错误。
2. 目的：以最少的人力和时力发现潜在的各种错误和缺陷。
3. 系统测试包括：软件测试、硬件测试、网络测试。
4. 系统测试阶段的测试目标来自于需求分析阶段。
5. 如果选择机器测试，一般用白盒法。
6. 每个模块测试时需要两种开发模块：（①驱动模块：相当于一个主程序，②桩模块：代替测试模块中所调用的模块）。
7. 组装测试
   • 自顶向下集成测试：不用编写驱动模块，需要编写桩模块。
   • 自底向上集成测试：不用编写桩模块，需要编写驱动模块。
   • 回归测试：用于软件变更后，防止软件变更后带来的错误。

7.14 McCabe度量法

1. 环路复杂性的公式为：V(G）= m-n+2或V(G）= 闭合区域+1。其中m是G中的有向弧数（边数）（有头有尾方可算入），n是G中的节点数。
2. 软件复杂性取决于代码行的数量。

7.15 黑盒测试

1. 分类
   软件测试方法分为两种：静态测试和动态测试。
   静态测试：被测试程序不在机器上运行，而是采用人工检测和计算机辅助静态分析的手段对程序进行检测。
   动态测试：通过运行程序发现错误。（测试用例由测试输入数据和与之对应的与其输出结构构成。在设计测试用例时，应当包括合理的输入条件和不合理的输入条件。）
2. 黑盒测试（功能测试）：在完全不考虑软件的内部结构和特性的情况下，测试软件的外部特性。
3. 常用黑盒测试技术
   • 等价类划分：假如输入的结果都是错的，就不是一个合适的测试用例。（需要考虑有效等价类和无效等价类）。
   • 边界值分析：输入有效等价类的边界值。

7.16 白盒测试

1. 白盒测试（结构测试）：根据程序的内部结构和逻辑来设计测试用例。
2. 常用白盒测试技术：逻辑覆盖，循环覆盖，基本路径测试。
3. 逻辑覆盖：主要有6大逻辑标准。如下：
   • 语句覆盖：测试路径中每条语句至少执行一次。
   • 判定覆盖（分支覆盖）：每个判定式中的真、假都至少执行一次。
   • 条件覆盖：每个判定式中的每个逻辑条件的真假都至少执行一次。
   • 判定/条件覆盖：每个判定式的真假和判定式中的每个逻辑条件的真假都至少执行一次。
   • 条件组合覆盖：每个判定式条件的各种可能值的组合都至少出现一次。
   • 路径覆盖：覆盖被测试程序中所有可能的路径。

7.17 系统维护

1. 系统可维护性的评价指标：可理解性、可测试性、可修改性。
2. 软件文档是软件可维护性的决定因素，每一个阶段都应该考虑并提高软件可维护性。
3. 文档是产品的一部分，没有文档就不是软件；文档对产品有重要意义，只好不坏。
4. 软件维护主要有四大方面：
   • 正确性维护：开发存在错误，测试未发现
   • 适应性维护：为适应变化而修改（被动进行）
   • 完善性保护：扩充功能，改善性能的修改（改进/改善）
   • 预防性保护：为适应未来而变化（主动出击）
5. 软件的质量特性：可靠性、可用性、可维护性
   • 可靠性：无失效运行的概率=MTTF÷（1+MTTF）（MTTF平均无故障时间）
   • 可用性：正确运行的概率=MTBF÷（1+MTBF）（MTBF平均失效间隔时间）
   • 可维护性：=1÷（1+MTTR）（MTTR平均修复时间）

7.18 成本估算

1. 基本COCOMO模型：是一种静态单变模型。
2. 中级COCOMO模型：是一种静态多变模型。
3. 详细COCOMO模型：它将软件系统分为系统、子系统和模块3个层次。
4. COCOMOII模型的3个阶段：
   • 应用组装模型：对象点。
   • 早期设计阶段模型：功能点。
   • 体系结构阶段模型：代码行。

7.19 进度管理

1. Gantt图：清晰描述何时开始、结束、以及并行关系，但是不能表现依赖关系。
2. PERT图：可以表现出依赖关系，但不能反映并行关系。
3. 正推相较取最大值，逆推相较取最小值

7.20 风险管理

1. 两大特性： 不确定性和损失
2. 三大风险如下：
   • 项目风险：项目复杂度、规模及结构不确定性
   • 技术风险：技术的不确定性、技术陈旧以及"前沿"技术
   • 商业风险：开发软件的生存能力
3. 风险管理过程如下：
   • 风险识别：识别出项目中已知和可预测的风险，形成一个风险列表。
   • 风险预测（风险估算）：（从风险可能发生的可能性或概率，风险产生的后果两方面预测）（评估风险影响→受整体风险显露度(RE)=P×C的影响）
   • 风险评估：定义风险参照水准，将识别出来的风险评估分类。（成本、进度、性能三种典型的水准）
   • 风险控制：辅助项目组建立处理风险的策略，包括风险避免，风险监控，RMMM计划（风险管理及意外事件计划）。应对风险最好的办法就是主动避险。

7.21 软件质量特性

1. McCall质量模型 ：
   • 运行：正确性、可靠性、效率、完整性、使用性
   • 修正：维护性、测试性、灵活性
   • 转移：转移性、复用性、共运行性
2. 设计质量评审内容：是否合乎用户的要求、可靠性、可测试性、可复用性、保密性、性能实现情况、可修改性。
3. 程序质量评审内容：功能结构、功能的通用性、模块的层次、模块结构（①控制流结构、②数据流结构、③模块结构与功能之间的对应关系）、处理过程的结构。

7.22 软件配置管理

1、软件配置管理主要目标：变更标识、变更控制、版本控制、确保变更正确地实现、变更报告。

2、软件配置主要内容（版本1）：版本管理、配置管理、变更支持、过程支持、团队支持、审计支持、变化报告。

3、软件配置主要内容（版本2）：软件配置标识、变更管理、版本控制、系统建立、配置审核、配置状态报告。

4、配置数据库分为以下三类：开发库、受控库、产品库。

7.23 甘特图

进度管理工具Gantt图：

优点：能清晰地描述每个任务从何时开始，到何时结束 ，以及各个任务之间的并行性 。

缺点：不能清晰地反映出各任务之间的依赖关系 ，难以确定整个项目的关键所在，也不能反映计划中有潜力的部分。

8. 结构化开发

8.1 系统设计基本原理

1. 模块独立：希望每个模块都是"高内聚、低耦合"（模块内要团结，模块间少牵扯）
2. 耦合
   

• 无直接耦合：模块间没有直接关系，分别从属于不同模块的控制和调用。
• 数据耦合：两个模块之间有调用关系，传递的是简单的数据值。
• 标记耦合：两个模块之间传递的是数据结构。
• 控制耦合：传递的是控制变量。
• 外部耦合：模块间通过软件之外的环境联结（I/O）。
• 公共耦合：通过一个公共数据环境相互作用的耦合。
• 内容耦合：一个模块直接使用另一个模块的内部数据，或通过非正常入口转入另一个模块内部时。

8.2 内聚

• 偶然内聚（巧合内聚·）：一个模块内的各处理元素之间没有任何联系。
• 逻辑内聚：模块内执行若干个逻辑上相似的功能，通过参数确定该模块完成哪一个功能。
• 时间内聚：把需要同时执行的动作组合在一起形成的模块。
• 过程内聚：一个模块完成多个任务，这些任务必须按指定的过程执行。
• 通信内聚：指模块内的所有处理元素都在同一个数据结构上操作，或者各处理使用相同输入数据或产生相同的输出数据。
• 顺序内聚：指一个模块中的各个处理元素都密切相关同一功能且必须顺序执行。
• 功能内聚：完成一个单一功能，各个部分协同工作，缺一不可。

8.3 系统总统设计结构

设计原则：

• 明确性原则。每个模块必须功能能明确、接口明确、消除多重功能和无用接口。
• 模块之间的耦合尽可能小，模块的内聚度尽可能高。
• 模块的扇入系数和扇出系数要合理。（尽量减少高扇出结构）
• 模块的规模适当。（不能过大或者过小）重点
• 模块的作用范围应该在其控制范围之内。

MVC分层架构解耦之后，有利于代码重用、提高系统可维护性、提高系统开发效率（但是无法提高系统的运行效率）。

8.4 系统文档

1. 用户与系统分析人员联系方式
   可行性分析报告、总体规划报告、①系统开发合同、②系统方案说明书（①②构成了开发计划）。
2. 系统开发人员与项目管理人员联系方式
   系统开发计划（任务分解表、PERT图、Gant图）、系统开发月报、系统开发总结报告。

8.5 结构化开发方法

1. 数据流的起点和终点必须有一个是加工。
2. .数据字典（DD）分为四类：数据流条目、数据存储条目、加工条目（不用将实现加工的具体流程说出来）、数据项条目（数据项是组成数据流和数据存储的最小元素）。
3. 结构通常分为内层和外层（顺序结构、选择结构、重复结构）。

8.6 零碎知识点

1.设计子系统不用考虑数据结构与算法（过程设计所考虑的）。

2.界面设计的3条黄金原则：用户操纵控制、减少用户记忆负担、保持界面一致。

3.结构图的基本成分：模块、调用、数据。

9. 数据结构

9.1 时间复杂度

O(1）<O(log2n）<O(n）<O(nlog2n）<O(n²）<O(n^3）<O(2n）<O(n！）

9.2 线性结构

1. 顺序存储结构（常量级=O(1)，只要没说最好、最坏复杂度均取平均复杂度）。
2. 顺序存储：（静态存储结构）

• 元素在存储空间的相对位置来表示元素间的逻辑关系。
• 优点：可以访问任意指定序号的元素。
• 缺点：插入和删除需要移动大量元素。

3. 链式存储结构（链式存储不需要移动元素，仅改变指向就行）
4. 链表删除结点：
   删除尾结点：时间复杂度O(n)。（需要找到倒数第二个结点，此时复杂度为O(n))
   删除头结点：时间复杂度O(1)。

9.3 栈（先进后出的线性表）

1. 只有打印所有元素需要遍历，其余不需要
2. 栈的存储结构
   顺序存储：预先申请栈空间，栈满则元素不能入栈。
   链式存储：无头结点，链表的头指针就是栈顶元素
3. 栈的应用：表达式求值、括号匹配、递归。

9.4 队列（先进先出的线性表）

1. 入队和出队都不需要移动队列中的其他元素（队尾、对头指针的存在）
2. 用循环单链表做队列时，头部有头结点，尾部有尾结点，所以都不需要遍历。
3. 若队列的数据规模确定，则采用顺序存储比链式存储的效率更高。
4. 循环队列（队空的条件head=tail；队满的条件(tail+1)%size=head）
5. 循环队列的队长：(Q.rear-Q.front+M)%M。
6. 无论是循环单链表队列还是链表队列，入队和出队均不需要遍历元素
7. 对于n个不同元素的进栈序列，合法的出栈序列种数为：
   

9.5 串

1. 空格也算长度，里面不包含任何字符才是空串(长度为零).
2. 朴素的模式匹配

• 时间复杂度最好情况O(m)，
• 最坏情况比较(n-m+1)×m次，即O(m*n)
• 平均情况O(n+m)

9.6 树

1. 结点的度：此结点的子结点数
2. 树的度：树中节点的最大度
3. 叶子结点：度为0的结点
4. 内部节点：度不为0的结点，也称为分支结点或非终端结点
5. 层次：根结点为第一层，之后层数依次加1

9.7 二叉树

1. 二叉树知识点

2. 二叉树遍历

四种主要的遍历思想为：

前序遍历：根结点 ---> 左子树 ---> 右子树

中序遍历：左子树---> 根结点 ---> 右子树

后序遍历：左子树 ---> 右子树 ---> 根结点

层次遍历：只需按层次遍历即可

案例：

例如，求下面二叉树的各种遍历

遍历结果如下：

前序遍历：1 2 4 5 7 8 3 6

中序遍历：4 2 7 5 8 1 3 6

后序遍历：4 7 8 5 2 6 3 1

层次遍历：1 2 3 4 5 6 7 8

3. 最优二叉树（哈夫曼树）

给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树，哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。

4. 二叉排序树

5. 平衡二叉树

9.8 图的遍历

无向完全图：若一个无向图具有n个顶点，而每个顶点与其他n-1个顶点之间都有边，则称之为无向完全图。无向完全图共有n(n-1)/2条边 。

有向完全图：有n个顶点的有向完全图中弧的数目为n(n-1)，即任意两个不同顶点之间都有方向相反的两个弧存在。

有向图的邻接矩阵不一定对称。

无向图的邻接矩阵是对称的。

9.9 最小生成树

9.10 拓扑排序

9.11 查找

二分查找：

public class BinarySearchExample {
    public static int binarySearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;

        while (left <= right) {
            int mid = left + (right - left) / 2; // 防溢出写法[5,12](@ref)
            if (arr[mid] == target) {
                return mid; // 找到目标，返回索引
            } else if (arr[mid] < target) {
                left = mid + 1; // 目标在右半区
            } else {
                right = mid - 1; // 目标在左半区
            }
        }
        return -1; // 未找到
    }

    public static void main(String[] args) {
        int[] arr = {1, 4, 10, 16, 17, 18, 23, 29, 33, 40, 50, 51};
        int target = 17;
        int index = binarySearch(arr, target);
        System.out.println("元素17的索引位置：" + index); // 输出：元素17的索引位置：4
    }
}

哈希查找：

冲突的解决方法：随机探测再散列、线性探测（当哈希冲突发生时，顺序检查下一个位置（步长为1），直到找到空闲槽）。

9.12 排序

1. 直接插入排序

思想：每次从未排序的数组中取出一个，与之前排好序的数组逐一比较大小，并插入到适当位置，直到未排序的数组为空。

public void toInsertSort(int []arr) {
	for(int i = 1; i<arr.length;i++) {	    //i是当前数
		for(int j = i-1 ; j>=0;j--) {	   //j是从i-1开始向前移动，并每次与arr[i]判断大小
			if(arr[i]<arr[j]) {		     //如果arr[i]小于arr[j]说明arr[i]当前至少是要插入到arr[j]的前面
				int temp = arr[j];
				arr[j] = arr[i];
				arr[i] = temp;
				i = j-1;		     //互换后i也要向前移动一位
			}
			else{
				break;              //直到arr[i]比arr[j]大，因为前面从小到大已经排好序，所以没有必要继续向前判断了					
			}
		}
	}
}

9.13 几种算法设计方法

1. 回溯方法：回溯法的实质是在包含问题的所有解的解空间树中，按照深度优先的策略，从根节点出发搜索解空间树。
2. 分治法：治的思路是将一个难以直接解决的大问题分解成一些规模较小的相同问题，以便各个击破，分而治之。
3. 动态规划：思想和动态规划算法与分治法类似。与分治法不同的是，适合于用动态规划法求解的问题，经分解得到的子问题往往不是独立的。以获取问题最优解为目标。

9.14 零碎知识

1. 排序算法的稳定性是指排序后关键字相同的元素保持原顺序中的相对位置不变。

10. 面向对象技术

10.1 基本概念

1. 对象的特性：具有清晰的边界、良好定义的行为、可扩展性。
2. 类可以分为三种：实体类、接口类（边界类）、控制类，具体职责为：
   • 实体类主要负责数据和业务逻辑；
   • 边界类负责和用户进行交互，即用户界面；
   • 控制类则负责实体类和界面类的交互。
3. 封装：是一种信息隐蔽技术。目的是使对象的使用者和生产者分离。
4. 一个子类继承父类的属性和操作（不必再重复定义，但前提是非私有化private）。
5. 子类可以创建自己的属性和操作，从而覆盖父类的行为。
6. 多态：不同对象收到同一个消息可以产生完全不同的结果（由继承机制来支持）
7. 绑定：在编译时绑定叫做静态绑定，在运行时绑定叫做动态绑定。
8. 函数重载：与覆盖要区分开，函数重载与子类父类无关，且函数是同名不同参数。
9. 面向对象五大设计原则：
   • 单一责任原则：就一个类而言，应该仅有一个引起它变化的原因。
   • 开放-封闭原则：软件实体应该是可以扩展开放的；但是不可修改的 ，即封闭的。
   • 里氏替换原则：子类型必须能够替换掉它们的基类型，基类出现的地方子类一定可以出现。
   • 依赖倒置原则：细节依赖于抽象但不依赖于细节。（高层模块不应该依赖于底层模块，二者都应该依赖于抽象）
   • 接口分离原则：依赖于抽象而不依赖于实体。

10.2 UML概述

1. UML3种构造块：事物（对模型中最具有代表性的成分的抽象）、关系（把事务结合在一起）、图（聚集了相关的事物）。
2. UML中有4种事物：结构事物、行为事物、分组事物、注释事物。
   • 结构事物：是UML模型的静态部分，描述概念或物理元素。（包括：类、接口、协作、用例、主动类、构件、制品、结点）
   • 行为事物：是UML模型的动态部分，描述了跨越时间和空间的行为。（包括：交互、状态、活动）
   • 分组事物：是UML模型的组织部分。最主要的分组事物是包（Package）。
   • 注释事物：是UML模型的解释部分。注解是一种主要的注释事物。

10.3 面向对象方法中的关系

关系的强弱顺序：泛化 = 实现 > 组合 > 聚合 > 关联 > 依赖。

• 依赖：一个事物变化会影响另一个事物（带箭头的虚线，指向被使用者）。
• 关联：对象之间的连接。
  组合：部分不可以脱离整体存在（生命周期相同）。
  聚合：部分可以脱离整体存在。
• 泛化：是一种特殊和一般的关系（类似继承，带三角箭头的实线，特例指向基类）。
• 实现：一个类指定另一个类，保证执行的契约（带三角箭头的虚线，箭头指向父类）。

10.3 参数传递

• 传值调用是将实参的值传给被调用函数的形参，因此实参可以是常量、变量、表达式或函数调用；
• 传地址调用(或引用调用)的实质是将实参的地址传给被调用函数的形参，因此实参必须具有地址，

10.4 4种程序设计范型

• 命令式（过程式）范型：通过指定计算步骤的顺序实现逻辑，强调"如何做"的过程控制。对应语言是C。
• 面向对象范型：以对象为中心，通过封装、继承和多态组织程序逻辑。对应语言是C++，Java。
• 函数式范型：以数学函数为基础，强调"表达式求值"而非状态改变。对应语言是Scala。
• 逻辑式范型：基于谓词逻辑和规则推理，描述"做什么"而非具体步骤。对应语言是SQL。

10.5 面向对象方法中的四种多态

核心特征最重要。

1. 动态多态与静态多态的区分：包含多态属于运行时动态绑定，参数/过载/强制多态属于编译时静态绑定。
2. 多态与设计模式的结合：如工厂模式依赖包含多态，模板方法模式结合参数多态。
3. UML类图中的应用：包含多态通过泛化关系（空心三角箭头）表示，过载多态可能涉及接口实现。

10.6 四种UML图的区别（学会看图）

UML类图、组件图、通信图和部署图各自刻画系统的不同方面

10.7 零碎知识点

1. 面向对象开发方法有Booch方法、Coad方法和OMT方法 。Jackson方法是一种面向数据结构的开发方法。

11. 程序语言基础知识

11.1 程序语言概述

1. 程序设计语言规定在源程序中的数据都必须具有类型（无注释和关键字）。
2. 源程序不能在计算机上运行，需要将高级语言通过编译程序翻译成目标程序才能执行。
   • 编译程序：
     翻译时将源程序翻译成独立保存的目标程序。
     机器上运行的是与源程序等价的目标程序。
     源程序和编译程序都不在参与目标程序的运行过程。
   • 解释程序：
     翻译源程序时不生成独立的目标程序。
     解释程序和源程序要参与到程序的运行过程中。
3. 程序语言的分类
   • C语言：（指针操作能力强，高效）（指针变量存储空间都相同）（链表空间采用堆存储分配策略）。
   • Java语言（面向对象，中间代码，跨平台，通用的程序设计语言台）。
   • Python（面向对象，解释型程序设计语言，通用的脚本语言）。
   • 重点：
     C/C++常被用于操作系统开发；javascript、python是（脚本、解释型、动态语言）。
     Java、c、c++、属于静态语言。

11.2 解释程序原理

1. 原理：编译程序的功能是把某高级语言书写的源程序翻译成与之等价的目标程序（由机器码构成，计算机能直接运行的程序）。
2. 编译方式：词法分析、语法分析、语义分析、中间代码生成、代码优化、目标代码生成（编译程序不参与用户程序的控制）。
3. 解释方式：词法分析、语法分析、语义分析（解释程序参与用户程序的控制）。
4. 编译器：代码生成、代码优化不是必要的，可省略 。（先翻译后执行，执行效率高但可移植性差）。
5. 解释器：不产生目标程序、执行效率低（反复扫描源程序）（边翻译边执行，执行效率低但可移植性好）。

11.3 编译程序原理

1. 词法分析：分析构造程序字符、符号是否符合程序语言的规定。
2. 语法分析：发现程序中所有的语法错误，（判断程序语句的形式），分析句子结构是否正确。
3. 语义分析：语法分析阶段不能发现所有的语义错误（eg：动态语义（变量0作除数），运行时才能发现）。
4. 中间代码生成：不考虑机器的特性，与机器无关、可移植性高、跨平台性。

11.4 正规式与正规集

11.5 琐碎知识点

1. 编程是将高级语言源程序翻译成机器语言程序，反编程是编程的逆过程。反编程不能将可执行文件还原成高级语言源代码，只能还原成等价的汇编程序。
2. 汇编程序输入的是汇编语言书写的源代码，输出的是机器语言表示的目标函数。
3. 软件开发小组的沟通路径最多有**（n×（n-1）/2)**
4. 编译过程中为变量分配存储单元所用的地址是逻辑地址 ，程序运行时再映射为物理地址。
5. 程序运行时内存空间划分为（代码区、静态数据区、栈区、堆区），其中栈区和堆区是动态数据区。全局变量的存储空间在静态数据区。
6. 运行时结合是动态绑定 ，编译时绑定是静态绑定。

12. 设计模式

设计模式分类

工厂方法模式

意图：定义一个用于创建对象的接口，让子类决定将哪一个类实例化，使一个类的实例化延迟到其子类。

桥接模式

• 桥接模式模式属于结构型对象模式，可以将抽象部分与其实现部分分离，使它们都可以独立的变化。
• 适用于不希望在抽象和它的实现部分之间有一个固定判定关系。

访问者模式

访问者模式(Visitor),表示一个作用于某对象结构中各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

适配器（adapter）模式

适配器模式将一个接口转换成客户希望的另一个接口，从而使接口不兼容的那些类可以一起工作。适配器模式既可以作为类结构型模式，也可以作为对象结构型模式。在类适配器模式中，通过使用一个具体类将适配者适配到目标接口中；在对象适配器模式中，一个适配器可以将多个不同的适配者适配到同一个目标。

装饰（decorator）模式

装饰模式是一种对象结构型模式，可动态地给一个对象增加一些额外的职责，就增加对象功能来说，装饰模式比生成子类实现更为灵活。通过装饰模式，可以在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责；当需要动态地给一个对象增加功能，这些功能可以再动态地被撤销时可使用装饰模式；当不能采用生成子类的方法进行扩充时也可使用装饰模式。

代理（proxy）模式

代理模式是一种对象结构型模式，可为某个对象提供一个代理，并由代理对象控制对原对象的引用。代理模式能够协调调用者和被调用者，能够在一定程度上降低系统的耦合度，其缺点是请求的处理速度会变慢，并且实现代理模式需要额外的工作。

组合设计模式

将对象组合成树形结构以表示"部分一整体"的层次结构，使得客户对单个对象和组合对象的使用具有一致性。