软件设计师-案例分析1

案例分析与设计

整体分析：

1-4分值 15 或者 20  总分55 分
5-6 选做一题 15 
总时间150分钟
	第一题 15分 15分钟，建议拿满分；
	第二题 15分 15分钟，建议拿满分；
	第三题 15分 15分钟，建议拿满分； 36-45分；
	第四题 15分 20分钟，都建议多拿分数；一般是5空，每空3分；
	第五题 15分 选做题 c++ 后者 java 

结构化方法分析与设计

基础知识

技术流图的基本概念：
DFD图 = （Data Flow Diagram）数据流图
数据流、数据存储D、加工P、外部实体E 这四部分组成；

四个核定元素的概念及说明：

涉及图

数据字典：
数据字典是对数据流的一个补充说明；

数据流图平衡原则：

父图与子图之间的平衡
子图内部的平衡：
	针对某个加工而言，
	只有输入没有输出不对；（黑洞）
	只有输出没有输出不对；（奇迹）
	输入输出信息不匹配；

实战法宝

真题中涉及到的内容：

上下文流数据图（顶层数据流图）
第0层数据流图
实体 = E = 人 组织 系统；
数据流 = 数据（用户数据....）
数据存储 = D = 通过数据流分析得到
模块 = P = 加工 有起点和终点

分析与设计步骤：

1. 确定系统边界，画出系统环境图；
// 确定实体
2. 自顶向下，画出各层数据流图；
// 包括第0层数据流图
3. 定义数据字典；
// 数据项、数据结构、数据流、数据存储、处理逻辑。
4. 定义加工说明；
// 也即就是处理逻辑 = 模块
6. 将图、字典以及加工组成分析模型；

题型及做题要点：

数据流的缺失：
	1. 数据流图平衡原则
	对比顶层数据流图与第0层数据流图之间的数据流差异；
	假设顶层数据流图正确的话，可以通过判断实体的输入输出数量来填充第0层图缺失的数据流；
	2. 查看加工；
	对比输入输出数量是否匹配；是否只有输入；是否只有输出；
	3. 对比题干
	题干文字是否与数据流图一一对应；
数据流在哪里存在？
	数据流存在于哪两者之间：外部实体与加工、加工与加工、加工与数据存储、数据存储与数据存储；
	实体之间不能直接有数据流；
填充实体、数据存储的名称：
	1. 实体 = 名词，任务角色、组织机构、外部系统；
	2. 数据存储 = xxx关键词，其中关键词包括：表、库、文件、清单、档案；
	或者直接写题目中给出的：批改后的作业/作业等信息
加工的分解：
	补充加工
	加工一般采用“动词+名词”的形式；
添加外部实体：
	需要明确该实体的输入与输出；
结构化语言描述加工逻辑：
	常用逻辑符号：
		if xxxx then
			xxxx
		else
			xxxx
		endif		
综合要点：
	所有填写内容尽量不采用新词，均采用题干中已知的信息；

数据库分析与设计

基础知识

数据库设计过程：

四个部分：
	需求分析，产物：数据流图、数据字典、需求说明书；
	概念结构设计，产物：ER图；
	逻辑结构设计阶段，产物：关系模式，表结构的形式展示；
	物理设计，产物：表；

E-R模型

概念：
	实体（长方形）、弱实体（长方形多两个竖线）、属性（椭圆形）、联系（菱形）；
联系的类型：
	一对一联系；一对多联系；多对多联系；
ER图向关系模式转变：
	原则：实体和联系转换成关系，属性则转换成相应关系的属性；
	ER图到关系模式转换，联系怎么处理？
		一对一联系； 可以并到任意一端；
		一对多联系； 并到多的一端；
		多对多联系； 单独写；
		多元联系；	多个实体，

实战法宝

常见题型

找联系
	实体（长方形）联系（菱形）属性（圆角长方形）
	弱实体（长方形中间有两个竖线）
	实体a与实体b存在弱实体关系，则也是一个联系
		遇到1：n的联系，需要考虑将联系放入多的那侧；
		1：1联系要看已知关系模式是否已经添加，没有添加要完成添加；
将ER图转成关系模式
	ER图：由实体、属性、联系等组成的图形；
		已知关系模式找ER图中某个实体的属性，要去除其余实体的外键；
	关系模式：每一个实体都需要一个数据行，两个实体之间的联系并到多的这行中；
		关系模式填写属性的时候，不一定一个空格中只有一个属性，可能有多个；
		如果是组合键，也不要自己手动加括号；
找主键、外键
	主键，唯一标识实体；
	外键，在本实体中不是主键，但是另一个实体的主键；
是不是全码、候选码
加一个实体
	补充联系、关系模式、主键、外键等
关系模式存在的问题及解决方式：
	数据冗余、更新异常、删除异常、插入异常；
		采用“一对多”方式修改，就是分解关系模式，再分解出来一个表；
		

ER图案例：

关系模式：

面向对象分析与设计UML

UML(Unified Modeling Language)，即统一建模语言。
常见的是用例图和类图。

基础知识

基础图示
用例图、类图与对象图、顺序图、活动图、状态图、通信图、构件图、部署图。

用例图

描述一组用例（功能）（椭圆形）、参与者及它们之间的关系；
用例之间的关系包括：包含、扩展、泛化；
	包含：两个或以上的用例提取公共行为，这个公共行为就是包含关系；
		A→B，说明A包含B；
	扩展：一个用例明显可以分成多个不同场景，可以分成多个不同的分支，就可以分成基础用例和扩展用例；
	泛化：类似继承，子用例图继承父用例的所有结构、行为、关系；多个用例具有类似的结构和行为
用例建模的流程：
	识别参与者；
	合并需求获得用例；
	细化用例描述；
	调整用例模型；

包含、扩展、泛化图解：

类图与对象图

类图(class diagram):类图描述一组类、接口、协作和它们之间的关系。
	一般需要填写类名、方法名、属性名；
	四种关系：依赖关系、泛化关系、关联关系（组合关系、聚合关系）、实现关系。
	泛化关系 = 继承；
	聚合关系 = 整体与部分，部分离开整体还可以用；
	
对象图(object diagram):对象图描述一组对象及它们之间的关系。
	对象图描述了在类图中建立的事物实例的静态快照；
	需要填写多重度，一个类的实例与另一个类的实例之间的关系；
		1：表示一个集合中的一个对象对应另一个集合中的一个对象；
		0..*：表示一个集合中的一个对象对应另一个集合中的0个或多个对象；（可以0个）
		1..*：表示一个集合中的一个对象对应另一个集合中的1个或多个对象；（至少一个）
		*：表示一个集合中的一个对象对应另一个集合中的多个对象；

类图示例：

顺序图

顺序图 = 序列图 = 交互图，是强调消息的时间次序。

活动图

活动图 = 将进程或其他计算结构展示为计算内部一步步的控制流和数据流；
专注于系统的动态视图；
实现：点到点的结束；

状态图

状态图，描述的是一个状态机，由状态、转移、世间、活动组成，也是一个动态视图；
也是点到点的实现；

通信图

交互图，强调收发消息的对象或参与者的结构组织；
	通信图与时序图表达了类似的概念，前者强调对象之间的组织结构，后者强调时序；

构件图

构件图 = 描述一个封装的类和它的接口、端口，以及由内嵌的构建和连接件构成的内部结构；

部署图

描述对运行时的处理节点，及在其中生存的构建的配置；
静态图；

实战法宝

类图填写注意事项：
	填写类名，需要都是名词；
类与属性匹配：
	文字分析；
用例图填写注意事项：
	描述用例的扩展关系，需要进行这样描述：
		当xxxx情况下，没有xxxx，就需要用扩展用例“xxx”来完成xxxx。
类的设计模式总结？
	

数据结构与算法应用

基础知识

常见算法：分治法、回溯法、贪心法、动态规划法；

分治法-分而治之

概念：
	一个规模为n的问题，如果简单则直接解决；否则分解成k个子问题；
	这些子问题互相独立且与原问题形式相同，递归解决这些子问题，然后将各个问题的解合并可以得到原问题的解。
	递归 = 在运行过程中调用自己；
	自下而上；
具体代码：
	

案例：
递归技术–斐波那契数列 = 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, …
二分查找–从数组中查询元素 = 只针对顺序排列的数组；

回溯法

概念：
	优先搜索算法，按优先条件向前搜索，已达到目标。当搜索到某一步时，发现原先选择不是最优，就退回一步重新选择。
特点：
	可以求得问题的所有最优解；
具体代码：
	试探部分 = 满足除规模之外的所有条件，则扩大规模；
	回溯部分 = 当前规模解不是合法解时回溯；求完一个解，要求下一个解时，也要回溯；

贪心算法

概念：
	做出当前来说是最好的选择，而并不从整体上加以考虑，即当前步骤的局部最优选择，但从整体来说不一定是最优的选择。
	因为其不必寻找最优解而穷尽所有可能解，消耗时间较少，可以快速得到满意的解，但得不到最优解。

动态规划法

概念：
	对每一步决策，列出各种可能的局部解，再依据某种判定条件，舍弃肯定不能得到最优解的局部解，在每一步都筛选，以每一步都是最优解来保证去全局最优解。

特点：
	肯定可以求得问题的一个最优解；
	

时间复杂度

$O(lo{g}_{2}n)$ 求树的深度；
$O(nlo{g}_{2}n)$ 求大顶堆和小顶堆
O(n²) 两层循环嵌套

常量级时间复杂度：O(1)
	单个语句；
	整个程序没有循环语句，或复杂函数的调用；
O(n)：
	单层循环，循环次数是n
O(n^2^):
	双层循环，每层循环都是n
O(n^3^):
	三层循环，每层循环都是n
$O(log_2n)$：
	求树的深度，由结点数构成；
$O(nlog_2n)$ ：
	堆排序，每次重建堆的时间复杂度是log_2n，n个元素就是(nlog_2n)；	

实战法宝

常考题型：
	程序属于哪一种算法：
		就是常见算法的四种：分治法、回溯法、贪心法、动态规划法；
		分治法：代码中会存在递归调用；
	求时间复杂度：
		
	程序初始化：	
		

分治+回溯+动态规划

相同点：
	递归思想：将原问题分成若干个同类子问题；
	最优子结构：分治 动态规划 都要求原问题的解决方案通过子问题的最优解方案构建出来；
不同点：
	分治：
		原问题分解成若干个子问题，解决完所有子问题，合并子问题的解就是原问题的解；
		适用于子问题之间不存在相互重叠子问题的情况；
		如斐波那契数列、归并排序、快速排序、矩阵乘法、大整数乘法、汉诺塔；
	回溯：
		系统搜索一个问题的所有解或任一解；
		分步解决一个问题，如果发现分步答案不能有效解决问题，则撤销上一步，换另一个可能的分支继续执行；
		主要在搜索空间中寻找问题的所有可能解，常见于约束问题中；
		常见问题=N皇后问题，迷宫求解，生成括号匹配序列、背包问题；
	动态规划：
		分解为子问题，把子问题的解使用数组存储，利用查询子问题的解合并构成原问题的解；
		适用于子问题之间有重叠性质，将子问题的解合并构成原问题的解；
		常见问题=斐波那契数列、矩阵乘法、背包问题、最长公共子序列、最短路径问题等。	
	贪心算法：
		用于求满意度，局部最优，但整体不一定最优；
		常见问题=背包问题、多机调度、找零钱问题；

希尔排序

概念：

希尔排序的实质就是分组插入排序，该方法又称递减增量排序算法.
希尔排序是非稳定的排序算法。
实现逻辑：
	① 先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。
	② 所有距离为d1的倍数的记录放在同一个组中，在各组内进行直接插入排序。
	③ 取第二个增量d2小于d1重复上述的分组和排序，直至所取的增量dt=1(dt小于dt-l小于...小于d2小于d1)，即所有记录放在同一组中进行直接插入排序为止。

案例：

直接插入排序

概念：将元素插入到已排好序的数组中，从而得到一个新的数组。
可视化理解：将x插入arr【n】的数组中，需要进行n次插入；第1次插入假定第一个元素是一个有序子数组，将x插入其中；
复杂度：时间O（n2） 空间复杂度O（1）
代码理解：
// 循环索引变量两个，待插入元素索引，遍历有序序列中元素的索引
    public static void main(String[] args) {
        int arr[] = {2,1,5,3,6,4,9,8,7}; // 原始数组
        int temp; // 整个假设按照从小到大排列
        for (int i=1;i<arr.length;i++){ // 要排序的元素的索引，除第1个元素外的所有元素
            //待排元素小于有序序列的最后一个元素时，向前插入
            if (arr[i]<arr[i-1]){ // 小于有序序列的最大元素
                temp = arr[i]; // 暂存当前要插入元素
                for (int j=i;j>=0;j--){ 
                    if (j>0 && arr[j-1]>temp) { // 将有序序列中元素 满足条件的情况下 向后移动
                        arr[j]=arr[j-1];
                    }else { 
                        arr[j]=temp;
                        break;
                    }
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

折半插入排序

概念：是直接插入排序的一种改良方案，

面向对象程序设计

基础知识

C++
C++中是允许多继承的；
.h是头文件，.app是实现文件；
两个冒号是作用域分辨符；
虚函数有virtual关键词；
纯虚函数是虚函数，即参数体没有，和Java中的抽象函数相同；
含有纯虚函数的是抽象类；
具有对象指针和对象引用的概念；
对象指针是 类名 *对象指针名；
对象引用是 类名 &对象引用名 = 被引用对象；

Java
Java不允许多继承；
java类定义：
类修饰符 class 类名 extends超类 implements接口名
修饰符：public abstract、final、private
java中所有的类都继承子object
抽象方法外的必定是抽象类；abstract标识抽象类；
接口定义：
修饰符 interface 接口名

设计模式

23种设计模式。

创建型模式

包括：抽象工厂模式、单例模式、建造者模式、原型模式
工厂方法模式

	**简单工厂模式**，创建对象的类，用它来封装实例化对象的行为；
		缺点：违背开闭原则，对象的创建依赖于工厂类，如果想拓展程序，就必须修改工厂类；可以创建抽象方法，创建不同的抽象类来实现该抽象方法，新增功能，就新增工厂类即可；
	**工厂方法模式**，创建对象的抽象方法，由子类决定要实例化的类，将对象的实例化推迟到子类；
		缺点：当子类产生变化，创建对象也会跟着变，增加了用户操作的复杂性；解决：将工厂类抽象成接口，用户根据自己需求创建实现类创建对象；
	**抽象工厂模式**，创建一个接口用于创建相关或有依赖关系的对象簇；

单例模式

	确保一个类最多只有一个实例，并提供一个全局访问点；
	有两种类型：预加载 和 懒加载，前者 单例对象没有使用时就加载到内存中；后者 用到该单例对象再创建；

生成器模式

	封装一个复杂对象构造过程，并允许按步骤构造。

结构型模式

包括：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

桥接模式

概念：
	将抽象部分与它的实现部分分离，使它们都可以独立地变化。
案例：
	增加一款新的手机软件，需要在所有手机品牌类下添加对应的手机软件类。
	方式1：手机实现某功能a，继承手机类的应用商店类也会继承某功能a，则修改手机类会影响继承该类的其他类；
	方式2：采用桥接模式，将手机和软件分开创建接口，然后将某功能添加到软件接口实现类中。

组合模式

概念：
	又叫作部分-整体模式，它是一种将对象组合成树状的层次结构的模式，用来表示“部分-整体”的关系，使用户对单个对象和组合对象具有一致的访问性。
	希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。
案例：
	两个对象的构建，可以抽象出来一个组件，构建基础的实现功能。

学习博客：
https://blog.csdn.net/A1342772/article/details/91349142

行为模式

包括：共十一种，分为：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
行为模式：不仅描述对象或类的模式，还描述它们之间的通信模式。这些模式刻画了在运行时难以跟踪的复杂的控制流。

访问者模式

概念：
	访问者模式表示一个作用于某对象结构中的各元素的操作。它使在不改变各元素的类的前提下可以定义作用于这些元素的新操作。
注意：
	四个核心接口/类，抽象访问者接口、具体访问者类；抽象元素接口、具体元素类。
	抽象元素接口有accept()方法；
	具体元素类的方法accept()，具体访问者类对象调用其visit()方法。

策略模式

概念：
	Strategy 模式的设计意图是，定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。此模式使得算法可以独立于使用它们的客户而变化。

例如：

Context的有参构造方法，通过不同分支的选择，创建不同的Cashxxx对象。

注意事项

注意具体属性、成员方法填写的规范，如果：题目中有public则答案中就不写；题目中有分号，则答案中也不写；

真题练习

09下-结构化分析

解答练习：

第一题：
	E1 = 非信用卡客户；E2 = 信用卡客户； E3 = 银行；
第二题：
	信用卡申请表 E1 P0
	激活请求 E2 P0
	交易信息 P0 E2
第三题：
	激活请求 E2 P3
	信用卡申请表 E1 P4
第四题：
	P4 信用卡申请
	P3 信用卡激活
	P2 信用卡客户信息管理
	P4 交易信息查询

09下-数据库分析

回答1：
	1 = 1  2 = 1 3 = m 4 = 1 5 = m
问题2：
	A = 用户名 b= 邮件号、发件人地址 c= 邮件号
问题3-1：
	地址簿主键= 联系人编号 邮件主键= 邮件号 附件主键= （邮件号、附件号）
	附件中的外键是：邮件号
	# 地址簿中的外键：用户名
	# 邮件中的外键：收件人地址/发件人地址；原因：邮件关系模式的主键为“邮件号”，外键为“发件人地址”或“收件人地址”，因为当用户向其他人发邮件的时候，“发件人地址”是参考邮件账号关系模式的“邮件地址”的主键。
问题3-2：
	附件不属于弱实体，弱实体应该是某个实体的一种特殊形式，而附件不属于邮件的一种特殊形式。例如：员工和领导之间，领导就属于一种弱实体，它本质属于员工的一个特殊实例。
	# 附件属于弱实体，因为附件的存在必须以邮件的存在为前提，即附件总是依附于某邮件。

09下-面向对象的分析与设计

回答1：
	A1= 工资系统 A2= 菜单管理员
问题2：
	员工= 查看今日特价
	顾客= 注册工资支付 # 注册工资支付 参与者是：顾客和工资系统（A1）
	餐厅员工= 生成付费请求 # 生成付款请求参与者是：餐厅员工和工资系统（A1）
	菜单管理员（A2）= 管理菜单
问题3：
	根据说明中的描述, 给出图 (b) 中（1)〜（4)处对应的活动名称或图形符号。
	（1）=订餐 （2）=进行登录 （3）=确认订餐 （4）= 打印送餐说明
	# (1) 菱形判断符号  （3）和（4）发送 E-mail 和通知餐厅员工为并行活动,需要在前后有同步条。
问题4：
	员工与顾客之间的关系是：泛化关系。员工是父类，顾客是子类，顾客是员工的特殊对象。
	# 泛化关系描述了一个参与者可以完成另一个参与者同样的任务，并可补充额外的角色功能。

09下-算法-回溯背包问题

回答1：
	（1） = fw=0    # k=1 
	（2） = cw ⬅ cw + w[k]
	（3） = break   # k ⬅ k - 1
	（4） = k ⬅ k - 1 # k ⬅ k + 1
	
	// 分析：回溯法从第一项物品开始考虑是否应该装入背包中，因此当前考虑的物品编号k从1开始，即k←1。然后逐项往后检查，若能全部放入背包则将该项放入背包，此时背包的重量应该是当前的重量加上当前考虑物品的重量，即cw←cw+wk]，当然背包中物品的价值也为当前的价值加上当前考虑物品的价值。若已经考虑完了所有的物品，则得到一个解，判断该解是否为当前最优，若为最优，则将该解的信息放入变量 、fw 和X中。若还没有考虑完所有的物品，意味着有些物品不能放入背包，此时先判断若不将当前的物品放入背包中，则其余物品放入背包是否可能得到比当前最优解更优的解，若得不到则回溯:否则继续考虑其余的物品。
回答2：
	（5） = 物品2和物品3
	（6） = 35
	（7） = 8  #15
	（8） = 6  #8
	// 分析：根据问题1中给出的伪代码运行该实例，可以很容易得到此0-1背包问题的最优解，应该选择物品2和物品3，此时背包的重量为10+10=20,获得的价值为17+18=35。
	// 若采用穷举法搜索整个解空间，即要构造一颗完全二叉树，此时搜索树的结点数应为24-1=15,而采用了上述回溯法，搜索树的结点数仅为8个，如上图所示。

09下-代码-组合模式

回答：
	（1）= public abstract  # abstract
	（2）= new List<AbstractFile> # null
	（3）= List
	（4）= childList
	（5）= system.out.println(file.name)  # printTree(file)

09上-结构化分析

问题1：
	E3=连锁超市；E2=采购部门；E4=配送部门；E1=财务部门
	D1=采购清单记录文件  D2=商品库存记录文件 D3=商品配送记录文件 D4=供货清单记录文件
问题2：
	错误的流：
	起点=D4 终点=供货请求处理 数据流=供货请求
	起点=D2 终点=采购处理 数据流=入库信息
	起点=D3 终点=E4 数据流=配送信息
	起点=E1 终点=E2 数据流=付款通知

	补充的流：
	起点=供货请求处理 终点=D4 数据流=供货请求
	起点=E2 终点=采购处理 数据流=采购通知
	起点=采购处理 终点=D2 数据流=入库信息

09上-数据库分析

解题练习：

问题1：
	商场与部门，1：n，联系1；
	部门与员工，1：n，联系2；
	经理与部门，1:1，联系3；
	经理与员工，应该是弱实体的关系；
经理属于员工，则经理实体属于弱实体；

问题2：
	a 商场编号；b 部门编号；c 员工编号，部门编号；
	部门关系模式：主键=部门编号，外键=商场编号
	员工关系模式：主键=员工编号，外键=部门编号；
	经理关系模式：主键=（员工编号，部门编号），外键=员工编号，部门编号；
	
问题3：
	（1）需要添加的实体：急联系人 ； 紧急联系人实体与员工实体存在1：n的联系；
	（2）关系模式：
	紧急联系人（员工编号，姓名，联系电话）
	1：n的联系，这个联系需要并到多的那侧，也就是员工关系模式中；
	员工（员工编号、员工姓名、岗位、电话号码、工资、部门编号、紧急联系人编号）

09上-面向对象分析与设计

回答1：
	A1=读卡器CardReader；A2=客户Customer  
	# A1=Customer；A2=bank
	U1=Insert Card  U2=Invalid PIN Process  U3=Transaction 
	# U1=Session
	（1）= extend  
	# <<extend>>
回答2：
	6 readPIN（） 7 PIN
	8 create（atm，this，card，pin） 9 performTransaction（）
回答3：
	U3与Winthdraw、Deposit等这些用例之间的关系是：包含关系，即这四个用例属于用例U3.
	# U3与Winthdraw、Deposit等这些用例之间的关系是：泛化关系。Transaction是一个抽象泛化用例，具有其他事务类型共有的属性和行为，每个具体的事务类型继承它，并实现适合自己的特定的操作。

09上-算法-最短路径

问题1：

回答1：
	1 = k=0 to n
	# k=1 to n  
	// 分析：已知代码中存在k-1这样的表达，则k不能从0开始，k-1的值整体是从0开始，那么k具体最小得从1开始。
	2 = Dij = min(dij-(k-1)，dik-（k-1）-dkj-(k-1))
	# dij（k） = dij(k-1)
	// 题目中该语句的条件是，dij-(k-1) 《= dik-（k-1）+ dkj-(k-1)，也就是ij顶点之间
	3 = Dij = dij
	# dij-k = dik-(k-1)+dkj-(k-1)
	4 = SP[i] = SP[i]+Dij
	# SP[i] = SP[i]+Dij(n)
	5 = xxx
	# min_v =1
	# 6 = min_v
	// 个人觉得56这两个空有点问题。
问题2：
	O(n^3^)

09上-代码-桥接模式

回答：
1 this.imp
2 ImageImp
3 imp.doPaint(m)
4 new BMP()
5 new WinImp()
6 image1.setImp(imageImp1)

15下-面向对象分析与设计

解答：

问题1：
	用户实例：1=添加出版物到购物车 2=结账 3=选择收货地址 4=选择付款方式；
问题2：
	当选择收货地址时，没有地址信息，则使用扩展用例“添加新地址”来完成新地址的添加；
	当选择付款方式时，没有付款方式信息，则使用扩展用例“添加新付款方式”来完成新付款方式的添加；
问题3：
	3=学术出版物 4=论文 5=学术报告 6=讲座资料 1=出版物目录 2=待购买的出版物 7=订单

15下-结构化分析

问题1：

问题2：

问题3：

问题4：

回答1：
	E1=学生 E2=讲师 E3=教务人员
问题2：
	D1=提交作业信息表 D2=学生表 D3=讲师表 D4=已批改作业信息表
	参考答案：D1=作业 D4=批改后的作业
问题3：
	# 数据流：通知 起点：1提交系统 终点：E1
	数据流：分数和评价 起点：5分数与评价 终点：D2 
	# 数据流：通知 起点：5分数与评价 终点：E1
	数据流：抽检报告 起点：7作业抽检 终点：E2
问题4：
	图1-1中需要再添加Email，去除从在线作业批改系统发出的通知，改成从该系统发送给Email，再由Email分别发送给学生和讲师；
	图1-2中需要添加一个Email加工过程，将从1提交作业发给讲师的通知，发送给Email，再由其发送给讲师；同理，将5记录分数与评价发送给学生的通知，发送给Email，再由其发送给学生。

	# 增加外部实体“第三方 Email”，两条“通知”数据流合并为一条“通知”，数据流，终点为“第三方Email”。

15下-数据库分析

问题1：

问题2：

问题3：

回答1：
	联系1 岗位与员工：1：n；
	联系2 员工与消息：m：n；
	联系3 公告与部门：1：n；
	联系4 公告与员工：m：n；
回答2：
	（1）：a=部门号、名称；b=（编号、接收人）、内容；c=编号、标题；d=（公告编号、员工编号）
	# b = 编号、内容、接收人 # d=员工号、消息编号（我认为这个不正确）
	（2）：消息-主键：（编号、接收人）；外键=接收人 #发送人
		  阅读公告-主键（公告编号、员工编号），外键（公告编号、员工编号）；
 回答3：
 	消息和公告中的“编号”属性，不属于命名冲突。
 	# 命名冲突是指在合并 ER 模型时产生的冲突，包括:(1)同名异义，指不同意义对象有相同名称。(2)异名同义(一义多名),指具有相同意义的对象使用不同名称。在本题中，本就是不同对象的属性，所以不存在冲突的说法。

15下-算法-公共最长子串

回答1：
	（1）：x == y 
	 # x[i-1]==y[j-1]
	（2）：max = c[i][j]
	（3）：c[i][j] = 0
	# (4): i = maxi-max 题目中并没有该空
回答2：
	（5）：动态规划
	（6）：O（n的平方）
	# O（mn）
回答3：
	（7）：2
	# 输出的是AB

15下-代码-策略模式

回答：
	（1）：double accptCash（double money）
	(2): cs = new CashNormal();
	(3): cs = new CashReturn(300.0,100.0);
	#  cs = new CashReturn(300,100);
	# 有参构造方法的参数是double，可以传递整数类型的实参。
	(4): cs = new CashDiscount(0.8);
	(5): cs.accptCash(money);
	# return cs.accptCash(money);

15上-结构化分析

问题1：

问题2：

问题3：

问题4：

回答1：
	E1= 教师 E2=学生
问题2：
	D1=试题  D2=学生信息 D3=考试信息 D4=解答结果
问题3：
	试题信息 起点D1 终点显示并接收解答；
	试题信息 起点D1 终点处理解答；
	# 数据流名称 题目 起点D1 终点2显示并接收解答；
	# 数据流名称 答案 起点D1 终点3处理解答；
问题4：
	分解加工：创建通知 和 发送通知两个加工；
	数据报告 起点生成成绩报告 终点 创建通知
	学生通知 起点创建通知 终点 发送通知
	通知 起点发送通知 终点 学生E1
	
	成绩单数据 起点生成成绩单 终点 创建通知
	教师通知 起点创建通知 终点 发送通知
	通知 起点发送通知 终点 教师E2

	# 分解为  创建通知数据、发送通知给学生或教师
	# 数据流 通知数据 起点：创建通知数据 终点：发送通知给学生或教师；

15上-数据库分析

问题1：

问题2：

问题3：

 回答1：
 	球员与球队 效力关系，1：1；
 	球队与比赛，1：1；
 	# 球队与比赛，m：n；
 	比赛应该具有的属性为：比赛编码，主队编号，客队编号，主裁判身份证号，比分，日期；
 	# 比赛应该具有的属性为：比赛编码，比分，日期；
问题2：
	（1）=球队编号 （2）=球队编号
问题3：
	新增实体是：赞助商；
	赞助商与球队 = 赞助联系：1：n；
	赞助商与球员 = 代言联系：m：n；

15上-面向对象分析与设计

问题1：

问题2：

问题3：

回答1：
	1=C5拍卖参与者 2=C7个人参与者 3=C9团体参与者
	4=成交方式C6 5=C8 线下成交 6=C10 线上成交
	7=C2拍卖品
	# 正确答案中2和3的内容反了一下；
回答2：
	M1属于C5；M2属于C2；M3属于C3； M4属于C4；M5属于C11；M6属于C8；M7属于C10；M8属于C10；M9属于C1；M10属于C3；
	# M4：C3  M5：C3  M9：C12   M10：C1
问题3：
	# 组合模式，本题中，由于拍卖者分为个人参与者和团体参与者两种，而团体也可以组成新的团体参与拍卖活动，这样的整体部分关系适合于使用组合模式表。

15上-算法-n皇后问题

#include <stdio.h>
#include <math.h>
#define N4
/*判断第k个皇后目前放置位置是否与前面的皇后冲突*/
in isplace(int pos[], int k) {
	int i;
	for(i=1; i<k; i++) {
		if( （1） || fabs(i-k) ══ fabs(pos[i] - pos[k])) {
			return();
		}
	}
	return 1;
}

int main() {
	int i,j,count=1;
	int pos[N+1];
	//初始化位置
	for(i=1; i<=N; i++) {
		pos[i]=0;
	}
	（2） ；
	while(j>=1) {
		pos[j]= pos[j]+1；
		/*尝试摆放第i个皇后*/
		while(pos[j]<=N&& （3）_) {
			pos[j]= pos[j]+1;
		}
		/*得到一个摆放方案*/
		if(pos[j]<=N&&j══ N) {
			printf("方案%d: ",count++);
			for(i=1; i<=N; i++){
				printf("%d ",pos[i]);
			}	
			printf("\n");
		}
		/*考虑下一个皇后*/
		if(pos[j]<=N&& （4） ) {
			j=j+1;
		} else{ //返回考虑上一个皇后
			pos[j]=0;
			（5） ;
		}
	}
	return 1;
}

回答1：
	（1）= pos[i] == pos[k]
	（2）= i = 1;  # j=1
	（3） = isplace（pos，i） # isplace（pos，j）==0
	（4）= j 《= N    # j《N
	（5） = i = i-1   # j=j-1
回答2：
	回溯算法
回答3：
	22
	# 方案1 2413
	# 方案2 3142

15上-代码-访问者模式

import java.util.*;
interface LibraryVisitor {
	　（1）　 :
	　（2）　　 :
	void printSum();
}

class LibrarySumPrintVisitor implements LibraryVisitor { //打印总页数
	private int sum = 0;
	public void visit(Book p_book) {
		sum = sum + p_book.getNumberOfPages();
	}
	public void visit(Article p_article) {
		sum = sum + p_article.getNumberOfPages();
	}
// 1-2 实现关系，则实现visit方法，两个方法参数不一样。

	public void printSum(){
		System.out.println("SUM = " + sum);
	}
}
interface LibraryItemInterface {
	(3) ;
}
// 


class Article implements LibraryItemInterface{
	private String m_title; //价仑文名 。
	private String m_author; //仑文作者
	private int m_start_page;
	private int m_end_page;
	public Article(String p_author, String p_title,int p_start_page,int p_end_page){
		m_title=p_title;
		m_author= p_author;
		m_end_page=p_end_page;
	}
	public int getNumbelOfPages(){
		rctum m_end_page - m_start_page;
	}
	public void acccpt(LibraryVisitor Visitor){
		(4) ：
	}
}

class Book implements LibraryItemInterface{
	private String m_title; //书名
	private String m_author; //书作者
	private int m_pages; //页教
	public Book(String p_author, String p_title,int p_ pages){
		m_title= p_title;
		m_author= p_author;
		m_pages= p_pages;
	}
	
	public int getNumberOfPages(){
		return m_pages; 
	}
	
	public void accept(LibraryVisitor visitor){
		(5)___；
	}
}

回答：
	（1）：private int sum；  # void visit （Book p_book）;
	（2）：void visit（Book p_book）;  # void visit(Article p_article);
	(3)：
		private String m_title; //价仑文名 。
		private String m_author; //仑文作者
		int getNumberOfPages();
		void accept(LibraryVisitor visitor);
		# void accept(LibraryVisitor Visitor);
		// 疑惑？为什么只有accept方法，但没有getNumberOfPages。
		// 访问者模式中，抽象元素中要有accept方法。
	(4):
		System.out.println(Visitor.getNumbelOfPages());
		# visitor.visit(this);
		// 特殊的调用方式。调用实现接口类中的visit方法。
	(5):
		System.out.println(Vistior.getNumbelOfPages());
		# visitor.visit(this);