源代码：https://blog.csdn.net/k_young1997/article/details/73480766
 
 
 
 
 
 
 
XXXX大学
 
 
 
C语言课程设计报告
 
 
 
 
 
 
 
 
 
 
 
题    目            图书管理系统设计         
 
专业班级     XXXX级计算机科学与技术本科X班 
 
组    别            计科第29组               
 
学生姓名          XXX、XXX、XXX           
 
院 （系）           信息工程系               
 
指导教师（职称）       XXX（教授）          
 
完成时间            xxxx年x月xx日          
 
 
 
XXX大学
 
课程设计任务书
 
 
 
题目                图书管理系统设计                  
 
班级              xxxx级计算机科学与技术本科x班     
 
学号         xxxxxxxxxxxx         姓名      xxx      
 
学号         xxxxxxxxxxxx         姓名      xxx      
 
学号         xxxxxxxxxxxx         姓名      xxx      
 
一、主要内容：
 
本课程设计结合本学期所学C语言知识，数组、函数、结构体、指针、链表、文件读取操作等等，准备设计开发一个简单的图书管理系统。设计开发这个系统需要用到链表、文件读取操作、结构体、函数、指针、等C语言知识。本课程设计将会实现对图书信息的账号登录、注册账号、密码修改、密码查找、查找、输出、排序、备份、恢复、图书借阅和归还功能。本着简单、易用的设计原则，本课程设计在尽量优化界面在保证输入输出美观的同时又不失友好的交互界面。
 
本次设计主要学习内容包括：
 
（一）进一步学习并熟练掌握C语言语法和编程思想。
 
（二）学习C语言提供的库函数，熟悉CodeBlocks的开发工具。
 
（三）学习C语言函数、链表、结构体、文件读取、指针等知识。
 
（四）学习软件的设计与开发过程中所需要思想和细节。
 
二、基本要求：
 
（一）质量要求
 
(1)图书管理系统的基本功能模块的设计应包括：账号登录和修改、图书信息的浏览和保存、图书的借阅和归还。
 
(2)对图书管理系统设计并进行调试、修复、完善、测试。测试图书信息的输入输出是否正确、测试文件的读取与存储是否正常、测试账号切换后是否各项功能是否正常运行、测试评估界面是否合理，友好。
 
(3)定期主动向指导教师汇报任务进度，认真填写相关报告文档。
 
(4)按时完成各阶段工作，不突击，不抄袭。
 
（二）进度要求
 
(2)明确课程设计任务，搜集资料：xxxx年x月xx日—x月xx日。
 
(3)完成程序的设计与实现，撰写课程设计论文初稿：xxxx年x月xx日—x月xx日。
 
(4)与指导教师沟通，完成课程设计论文定稿：xxxx年x月xx日—xxxx年x月xx日。
 
(5)进入课程设计论文审阅阶段，准备答辩：xxxx年x月xx日—x月xx日。
 
 
 
三、主要参考资料：
 
[1] 甘勇,李晔,卢冰.中国铁道出版.《C语言程序设计(第二版) 》 
 
[2] 河南工业大学同学的图书管理系统的功能的借鉴。
 
[3] 啊哈磊.人民邮电出版社.《啊哈!算法》
 
[4] 程杰，清华大学出版社.《大话数据结构》
 
 
 
 
 
 完 成 期 限：     xxxx年x月xx日 
 
指导教师签名：                 
 
 
 
年   月   日
 
 
 
 
 
目   录
 
1概述.1
 
1.1 设计思想. 1
 
1.2 设计原则. 1
 
1.3 课程设计报告内容及分工情况. 1
 
1.3.1 课程设计报告内容. 1
 
1.3.2 课程设计分工情况. 2
 
2总体设计.3
 
2.1 功能模块图. 3
 
2.2 主函数 main()3
 
2.3 程序流程图. 4
 
3详细设计.5
 
3.1函数.5
 
3.2函数流程图.7
 
4运行结果与调试.13
 
4.1 运行结果. 13
 
4.2 软件调试. 15
 
结束语.17
 
参考资料.18
 
附录.19
 
 
 
1概述
 
 
 
1.1设计思想
 
(1)该系统的设计分成几个相对独立的模块，这些模块都进行集中式管理。
 
(2)分层的模块化程序设计思想，整个系统采用模块化结构设计作为应用程序，有较强的可操作性和扩展性。
 
(3)合理的数据设计，在应用系统设计中，相对独立的模块间以数据相互连接，使各模块间的耦合性较低，方便系统运行，提高系统安全性 。     
 
1.2设计原则
 
为了使本系统功能齐全完备，操作简便，最大限度的提高用户的使用的体验，从而满足用户的实际需要，在设计开发过程中遵循了如下原则：
 
(1)合法性原则：规范录入各种图书信息和各种数据，对用户的账号信息进行规范保存。
 
(2)实用性原则：根据用户对图书信息浏览和借阅的基本需求设计各种功能，并能够处理一些特殊情况的要求，此外，尽可能预留空间，以便扩充功能。
 
(3)易操作原则：要求设计的系统功能齐全，界面友好，操作方便，必要的地方进行提示。
 
(4)源程序可读性原则：为了便于其他设计，维护人员读懂代码或以后的代码修改，软件升级维护，即可能做好代码注释工作。
 
 
 
1.3 课程设计报告内容及分工情况
 
1.3.1课程设计报告内容
 
(1)系统功能模块结构图和程序流程图
 
(2)数据结构设计及用法说明
 
(3)程序结构（画功能模块图或流程图）
 
(4)各模块的功能
 
(5).实验结果（包括输入数据和输出结果）
 
(6)设计体会
 
(7)参考文献
 
 
 
1.3.2 课程设计分工情况
 
本组共有3人，具体分工情况如下：
 
（1）学号：xxxxxxxxxxx，姓名：xxx，具体负责xxxxxx。
 
（2）学号：xxxxxxxxxxx，姓名：xxx，具体负责xxxxxx。
 
（3）学号：xxxxxxxxxxx，姓名：xxx，具体负责xxxxxx。
 
 
 
 
 
2总体设计
 
2.1功能模块图
 
       本图书管理系统分为三个功能模块，分别是账号管理功能、图书信息管理功能、图书借还管理功能。账号管理功能可以进行账号登录、注册账号、找回密码、修改密码：图书信息管理功能可以对图书信息进行查找、排序、修改、恢复、和备份功能：图书借还管理功能可以查询用户的借书记录、借书、还书功能。功能模块图如图2-1所示。
 
 
 
 
 
 
图2-1图书管理系统模块图
 
2.2主函数 main()                                        
 
函数的功能：用于联系各个功能函数模块，以及退出程序时的退出画面提示。
 
函数的入口：整个程序是从主函数开始的。
 
函数的出口：当从main()的ove函数开始中进入，即显示出欢迎使用界面;跳出while循环，然后退出main()函数，即：退出整个程序。
 
函数调用关系：该函数不被其它函数调用。
 
 
 
2.3程序流程图
 
       本图书管理系统在启动后会先进入登录界面进行登录或各种账号操作，然后进入图书信息管理、图书借还管理等实用性功能的操作。程序流程图如图2-2所示。
 

 
图2-2图书管理系统流程图
 
3       详细设计
 
3.1      函数
 
(1)功能函数ling()
 
函数的功能：登录账号
 
函数的入口：从main()中进入。
 
函数调用关系：被主函数调用。
 
函数的出口：当账号登录成功返回1然后结束该函数，或输入密码错误超过三次结束结束整个程序。
 
(2)功能函数FindByNum()
 
函数的功能：按书号对图书进行查找并输出。
 
函数的入口：程序从Find()的switch()开关结构中进入，即sclele的值为1时，开始进入该函数，进入函数后，在存储图书信息的stu结构数组中进行查找，找到后进行输出，若没找到则输出“未找到该数”。
 
函数调用关系：被Find()函数调用。由switch()开关结构中进入，并在文中无返回值的空值void函数。
 
函数的出口：当输出结果信息用printf()标准输出到屏幕上，然后结束该函数，而执行Find()函数中“break;”跳出switch()开关函数，继续执行while循环结构。
 
(3)功能函数SortByScore()
 
函数的功能：对所有图书信息按书名的首字母进行排序，并保存到文件“缓存区”中。
 
函数的入口：从Sort()的switch()开关结构中进入，即sexh的值为1的时侯，进入该函数，开始对图书信息按书名的首字母进行排序，然后将排序结果保存到文件“缓存区”中。
 
函数调用关系：被Sort()函数调用。由switch()开关结构中进入，并在文中无返回值的空值void函数。
 
函数的出口：把“排序完成”用printf()标准输出到屏幕上，然后结束该函数，而执行Sort()函数中“break;”跳出switch()开关函数，继续执行while循环结构。
 
(4)功能函数output()
 
函数的功能：输出所有图书信息
 
函数的入口：从Find()的switch()开关结构中进入，即sclele的值为4时，进入该函数。并调用PrintRecord()函数对每一条图书信息进行输出。
 
函数调用关系：被Find()函数调用。由switch()开关结构中进入，并在文中无返回值的空值void函数。
 
函数的出口：将所有图书信息都输入到屏幕上后，执行Find()函数中“break;”跳出switch()开关函数，继续执行while循环结构。
 
(5)功能函数Huifu ()
 
函数的功能：将所有图书的信息恢复至备份时的状态
 
函数的入口：从Menu()的switch()开关结构中进入，即select的值为4时，进入该函数。用freopen("图书信息库.txt","r",stdin)将里边的所有图书信息都存入内存，然后再调用save()将所有图书信息都存入到“缓存区”中。
 
函数调用关系：被Menu()函数调用。由switch()开关结构中进入，并在文中无返回值的空值void函数。
 
函数的出口：将所有图书信息都存入到“缓存区”中后，执行Menu()函数中“break;”跳出switch()开关函数，继续执行while循环结构。
 
(6)功能函数BorrowBook()
 
函数的功能：借阅图书
 
函数的入口：从Borrow()的switch()开关结构中进入，即shl的值为2时，进入该函数。之后对用户的信誉值进行判断，若低于60将无法借书。然后调用FindByName()函数对所借图书进行搜索，若存在则输入借书时间，否则借书失败。
 
函数调用关系：被Borrow()函数调用。由switch()开关结构中进入，并在文中无返回值的空值void函数。
 
函数的出口： 将借书结果输入到屏幕上后，执行Borrow ()函数中“break;”跳出switch()开关函数，继续执行while循环结构。
 
(7)功能函数SendBook ()
 
函数的功能：归还图书     
 
函数的入口：从Borrow ()的switch()开关结构中进入，即shl的值为3时，进入该函数。之后先判断该用户是否有借书记录，并调用FindByName()函数找到还的图书并对其数量进行修改，最后判断是否按期归还图书和图书有无破损。
 
函数调用关系：被Borrow ()函数调用。由switch()开关结构中进入，并在文中无返回值的空值void函数。
 
函数的出口： 还书完成后后，执行Borrow()函数中“break;”跳出switch()开关函数，继续执行while循环结构。
 
3.2      函数流程图
 
(1)账号登录流程如图3-1所示。
 

 
图3-1 账号登录流程图
 
(2)按书号查找图书流程如图3-2所示。
 

 
 图3-2按书号查找流程图
 
(3)按书名首字母排序流程图如图3-3所示 。
 

 
图3-3按书名首字母排序流程图
 
(4)输出所有图书信息流程如图3-4所示。
 

 
图3-4输出所有图书信息流程图
 
(5)恢复备份功能流程如图3-5所示。
 

 
图3-5恢复备份流程图
 
(6)借阅图书流程如图3-6所示。
 
 
 
       图3-6借阅图书流程图
 
(7)归还图书流程如图3-7所示。
 

 
        图3-7归还图书流程图
 
 
 
 
 
 4、运行结果与调试
 
4.1运行结果
 
(1)在程序开始是进入登录界面进行登录界面或选择切换账号时输出登录界面。该界面可以进行登录操作、注册新账号、找回账号密码、修改密码和退出系统。
 
账号登录界面如图4-1所示。
 
    
     
 
图4-1 账号登陆界面
 
(2)该界面为主界面，在登录完成后或者从下一级界面返回后输出该界面。该主界面可以选择图书信息管理功能、图书借还功能、查看系统功能介绍、开发人员信息和退出系统的操作。主界面如图4-2所示。
 
  
   
 
图4-2 主界面
 
(3)该界面为图书管理功能的主界面，可以选择执行查找、排序、修改、恢复图书信息、备份图书信息的操作、返回上一级菜单的功能。图书信息管理功能界面如图4-3所示。
 
 
      
 
图4-3图书信息管理功能界面
 
(4)该界面可以实现图书信息查找功能，可以按书号查找、按书名查找、按作者查找、查看全部图书信息、返回上一级菜单的功能。查找功能界面如图4-4所示。
 
            
 
      图4-4 查找功能界面
 
(5)该界面可以进行排序的操作。可以进行按书名首字母排序、按图书单价升序排序、按图书单价降序排序，还可以返回上一级菜单。排序功能是在内存中进行，所以不进行输出。排序功能界面如图4-5所示。
 
             
 
    图4-5排序功能界面
 
(6)该界面可以实现添加图书、删除图书、删除全部图书信息、返回上一级菜单的功能。修改功能界面如图4-6所示。
 
          
 
图4-6修改功能界面
 
(7)该界面可以实现对用户借书记录查询、图书借阅、图书归还、返回上一级菜单的功能。图书借还管理功能界面如图4-7所示。
 
            
 
图4-7图书借还管理功能界面
 
4软件调试
 
(1)每个选择界面之后，前一屏幕的内容依旧存在，影响界面的美观；经过老会长的帮助及上网搜索，发现利用“system(“cls”);”可以消去前一屏幕的内容；然而接下来又出现新的问题：每次在执行完讲数据保存到文件的函数后都会输出紊乱。经过多次调试和修改后，发现把是因为freopen（”CON”,stdout）运行不稳定导致，在更换了保存数据的方法后结决了此问题。
 
(2)在增加了切换账号功能后，在创建新账号后保存到文件的用户借还书记录总是出错但内存中没错，经过调试发现是因为在新增账号时用于存储新账号借还书记录的指针名与一个变量名相同造成每次都判断错误。最后更换了变量名，并使该指针每次使用前都指向NULL。
 
(3)在借书时不能判断是因为图书数量不足导致不能借阅还是因为没用该图书导致的不能借阅，最后给每种情况标记变量都设置了一不同的值来区分两种不同的情况。
 
(4)最开始在每次关闭程序后在下次使用前需要手动恢复文件中的数据，不能连续的使用数据，最后加了一个文件来保存各类数据的数量以使数据能够连续自主的调用，不需要再人工修改。
 
 
 
 
 
结束语
 
 
 
本系统包含51个函数，实现了图书管理系统所需的基本功能。系统功能大致分为三个模块，分别是登录模块、图书信息管理模块和图书借还模块。启动程序后首先执行的是登录功能。在此功能中可以实现账号登录、注册账号、找回账号密码、修改账号密码功能。登录时，若输入密码错误次数达到三次系统将自动关闭。在注册账号时若注册的账号已存在则不能再进行注册。修改密码时增加了验证码功能。在图书信息管理模块中可以进行图书的查找、排序、添加、删除、备份图书信息、恢复图书信息和切换账号功能。在图书借还功能模块可以进行图书的借阅、归还、借书记录查询功能。本系统在信息存储时采用了两种方式。在存储图书信息和账号信息时用的是结构数组，在存储用户借书记录时用的是链表。通过此次图书管理系统的设计熟练了结构数组、链表、文件的操作，同时对编写小型的系统有了一定的了解，对于细节方面考虑的比以前有很大提升。
 
 
 
xxx：在该设计中主要完成了所有代码的实现，并最终调试实现了该图书管理系统的全部功能并完成了大部分的设计报告。在设计的过程中熟练了对文件的各种操作，链表和结构数组的使用，清屏函数和暂停函数的使用，对做一个项目的过程有了一个大概的认识，知道了大致的规划。在设计过程中发现一些文件的操作和清屏函数会有冲突，通过改变对文件的操作解决了此问题；
 
xxx：除了xxx设计的这个图书管理系统，我自己也尝试着设计了一个图书管理系统的功能，因此也发现了很多问题，比如说：在用add()函数添加新增图书信息时，我就忘了字符型数据本身会吃掉回车的这一特点，忘了在%c前面加上空格，导致程序在循环的过程中一直无法正常显示结果。但是，通过仔细耐心的检查与对错误的分析，又在课本的相关章节进行了查阅，最终发现了这一问题。同时，我更加熟悉了结构体的使用，对函数的调用方式更加清楚。还有就是初步了解了函数指针的概念，能够使用基础的函数指针。同时，这也是我第一次尝试画各种各样的流程图，虽然画的不好，但这确实是我的第一次尝试，也觉得充满了乐趣。
 
xxx：在本系统的设计中我参加设计了少量函数语句以及制作流程图等任务，在这次的设计前我原本对函数和结构体等了解并不太清楚，通过这次的设计我清楚了这些语句的运用，并且我学会了文件的操作，在文件的修改等地方出现了问题，后来通过查阅资料和讨论解决了这个问题。
 
参考资料
 
 
 
[1] 《C语言程序设计（第二版）》，甘勇等编著，中国铁道出版社，2015年9月
 
 
 
[2] 《C语言程序设计》，苏小红等主编，高等教育出版社，2011年
 
[3] 《C和指针》，徐波译，人民邮电出版社，2008年
 
[4] 《C Primer Plus第6版 中文版》，姜佑 译，人民邮电出版社，2016年
 
[5] 《大话数据结构》，程杰，清华大学出版社，2011年6月
 
[6] 《啊哈！算法》，啊哈磊，人民邮电出版社
 
 
 
 
 
附录
 
 
 
源代码
 
 
 
 
 
 

 
首先了解了计算机系统的组成和程序的基本结构并开始初步编译程序。
 
 
进而学习顺序结构程序设计，并开始解决问题
 A 解决问题基本步骤
 a 了解问题
 b 考虑解决方案
 c 程序语句描述方案
 d 调试运行
 B 语句的学习
 cout语句（实现输出功能的语句）
 cin语句 （实现输入功能的语句）
 赋值语句（注意：单等号赋值，双等号相等）
 C 注意细节问题
 a 常量，变量(变量名：只能包括字母，数字和下划线，并且开头只能是字母或下划线）
 b 算术运算符（整数/整数=整数，%含义是模，任何表达式都有值）
 c 字符，字符串（c语言与c++字符串方法不一样）
 d 复合运算符（自加，自减中i+++i容易出现二异性，要加上括号）
 e 赋值<关系<算数
 
3 感悟
 刚开始接触c++语言，在学习上有较大障碍，无法流畅的表达清楚。
 但c++让我见识了新的天地，在这个现代化的信息时代，学会用信息化的语言是无比重要的。
 要更加努力，多看，多练。

Spring的概述
 
什么是Spring？
 
我们可以从度娘上看到这样有关Spring的介绍：
 
 说得更加详细一点，Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为J2EE应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核心是控制反转（IoC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EEfull-stack（一站式）轻量级开源框架。
 为什么说Spring是一个一站式的轻量级开源框架呢？EE开发可分成三层架构，针对JavaEE的三层结构，每一层Spring都提供了不同的解决技术。
 
 从对Spring的简要介绍中，我们知道了Spring的核心有两部分：
 
IoC：即控制反转。举例来说，在之前的操作中，比方说有一个类，我们想要调用类里面的方法（不是静态方法），就要创建该类的对象，使用对象调用方法来实现。但对于Spring来说，Spring创建对象的过程，不是在代码里面实现的，而是交给Spring来进行配置实现的；
AOP：即面向切面编程。之前，讲Struts2框架的拦截器时，我们就已稍微讲了一下，在Spring后续的学习过程中，我们会着重来讲它，但是本文并不会过多阐述它。
 
为什么学习Spring？
 
在度娘上查看有关Spring的介绍时，我们可以找到如下一系列Spring的优点，这就是我们要学习Spring框架的原因。
 
 
Spring的快速入门
 
Spring的版本
 
需要说明的是，本系列入门Spring的教程使用的版本是spring-framework-4.2.4.RELEASE。
 
IoC概述
 
什么是IoC？
 
IoC即Inversion of Control，反应过来就是控制反转。啥是控制反转啊？控制反转指的就是将对象的创建权反转给（交给）了Spring，其作用是实现了程序的解耦合。也可这样解释：获取对象的方式变了，对象创建的控制权不是"使用者"，而是"框架"或者"容器"。用更通俗的话来说，IoC就是指对象的创建，并不是在代码中用new操作new出来的，而是通过Spring进行配置创建的。
 
Spring的IoC的底层实现原理
 
这里先给出结论：Spring的IoC的底层实现原理是工厂设计模式+反射+XML配置文件。 就拿持久层（也即dao层，data access object，数据访问对象）的开发来说，官方推荐做法是先创建一个接口，然后再创建接口对应的实现类。所以，这里，我会以dao层的开发为例来证明Spring的IoC的底层实现原理就是工厂设计模式+反射+XML配置文件。
 首先，创建一个Userdao接口。
 
public interface UserDao {
	public void add();
}
 
然后，再创建Userdao接口的一个实现类（UserDaoImpl.java）。
 
public class UserDaoImpl implements UserDao {
    public void add() {
	    balabala......
    }
}
 
接着，我们在service层中调用dao层，核心代码如下：
 
// 接口 实例变量 = new 实现类
UserDao dao = new UserDaoImpl();
dao.add();
 
这时我们便可发现一个缺点：service层和dao层耦合度太高了，即接口和实现类有耦合（它俩之间的联系过于紧密），一旦切换底层实现类，那么就需要修改源代码，这真的不是一个好的程序设计，好的程序设计应当满足OCP原则（也即开闭原则），即在尽量不修改程序源代码的基础上对程序进行扩展。说到这里，我就不得不稍微讲一下面向对象设计的七大原则了，它不必强记，重在理解。
 
 出现的这个问题该如何解决呢？解决方法是使用工厂设计模式进行解耦合操作。所以，我们需要创建一个工厂类，在工厂类中提供一个方法，返回实现类的对象。
 
public class BeanFactory {
    // 提供返回实现类对象的方法
    public static UserDao getUserDao() {
        return new UserDaoImpl();
    }
}
 
这样，在service层中调用dao层的核心代码就变为了下面的样子。
 
UserDao dao = BeanFactory.getUserDao();
dao.add();
 
如若这样做，会发现又产生了一个缺点：现在接口和实现类之间是没有耦合了，但是service层和工厂类耦合了。如果真正想实现程序之间的解耦合，那么就需要使用到工厂设计模式+反射+XML配置文件了。所以，我们这里提供一个XML配置文件，并且该配置文件中有如下配置信息。
 
<bean id="userDao" class="com.meimeixia.dao.impl.UserDaoImpl" />
 
然后再来创建一个工厂类，在工厂类中提供一个返回实现类对象的方法，但并不是直接new实现类，而是使用SAX解析配置文件，根据标签bean中的id属性值得到对应的class属性值，使用反射创建实现类对象。
 
public class BeanFactory {
    public static Object getBean(String id) {
        // 1.使用SAX解析得到配置文件内容
        // 直接根据id值userDao得到class属性值
        String classvalue = "class属性值";
        // 2.使用反射得到对象
        Class clazz = Class.forName(classvalue);
        UserDaoImpl userDaoImpl = (UserDaoImpl)lazz.newInstance();
        return userDaoImpl;
    }
}
 
以上就是Spring的IoC的底层实现原理。
 
Spring的IoC入门
 
下载Spring的开发包
 
Spring的官网是https://spring.io/，Spring的开发包的下载地址是https://repo.spring.io/libs-release-local/org/springframework/spring/，上面说过，我下载的是spring-framework-4.2.4.RELEASE这个版本的Spring。解压缩之后，可发现Spring开发包的目录结构如下。
 
 
创建web项目，引入Spring的开发包
 
首先创建一个动态web项目，例如spring_demo01，然后导入Spring框架相关依赖jar包，要导入哪些jar包呢？这是一个问题。
 
 由于我们只是初次入门Spring，所以也只是使用到了Spring的基本功能，从上图红框框中的部分可知，我们需要使用到下面的这4个jar包。
 
 除此之外，还要导入Spring支持的日志jar包，也就是下面两个jar包。
 
 关于以上两个jar包，我稍微做一下解释，com.springsource.org.apache.commons.logging-1.1.1.jar它里面都是一些接口，有接口，那当然要有实现类了，恰好，com.springsource.org.apache.log4j-1.2.15.jar里面就是那些接口的实现类。使用Log4j，我们可以查看到当前运行程序中对象创建的过程，也可以看到更详细的信息，Log4j适合使用在程序调试中。
 导入完日志相关的jar包之后，我们还要导入日志记录文件，即在src目录下引入Log4j的配置文件（log4j.properties），该文件内容如下：
 
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###
# error warn info debug trace
log4j.rootLogger= info, stdout
 
对以上日志记录文件，我会粗略讲解一下。
 
 从上图可知，log4j.rootLogger就是用于设置日志的输出级别，那么日志的输出级别有几种呢？有如下5种。
 
 
创建接口和实现类
 
首先，在src目录下创建一个com.meimeixia.spring.demo01包，并在该包下创建一个名为UserDao的接口。
 
package com.meimeixia.spring.demo01;

/**
 * 用户管理的dao层的接口
 * @author liayun
 *
 */
public interface UserDao {

	public void save();
	
}
 
然后，在com.meimeixia.spring.demo01包下创建UserDao接口的一个实现类——UserDaoImpl.java。
 
package com.meimeixia.spring.demo01;

/**
 * 用户管理的dao层接口的实现类
 * @author liayun
 *
 */
public class UserDaoImpl implements UserDao {

	@Override
	public void save() {
		System.out.println("UserDaoImpl中的save方法执行了......");
	}
	
}
 
将实现类交给Spring管理
 
首先，我们需要创建Spring的配置文件，Spring配置文件的名称和位置没有固定要求，一般建议把该文件放到src目录下面，名称可随便写，官方建议写成applicationContext.xml。然后我们还需要在配置文件中引入约束，Spring学习阶段的约束是schema约束。那么问题来了，这个约束又该怎么写呢？可参考docs\spring-framework-reference\html目录下的xsd-configuration.html文件，在其内容最后面找到如下内容。
 
 将其复制黏贴到配置文件applicationContext.xml中，这样applicationContext.xml文件的内容就是下面的样子了。
 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">
        
</beans>
 
最后，咱还要将实现类交给Spring来管理，即在配置文件中配置对象的创建。
 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">
        
	<!-- Spring入门的配置 -->
	<bean id="userDao" class="com.meimeixia.spring.demo01.UserDaoImpl"></bean>
	
</beans>
 
编写测试类
 
我们要在Spring中写代码来实现获取applicationContext.xml文件中配置的对象，这段代码不要求大家重点掌握，只是用在测试中而已。这段代码主要用来解析Spring配置文件得到对象，但这个过程不需要我们写代码来实现了，Spring已经封装了一个对象来帮我们进行了这些操作，这个对象叫ApplicationContext，它就能实现这个功能。于是，我们需要在com.meimeixia.spring.demo01包下创建一个SpringDemo01的单元测试类。
 
package com.meimeixia.spring.demo01;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

/**
 * Spring的入门
 * @author liayun
 *
 */
public class SpringDemo01 {
	
	/*
	 * 传统方式的调用
	 */
	@Test
	public void demo01() {
		UserDao userDao = new UserDaoImpl();
		userDao.save();
	}
	
	/*
	 * Spring的方式的调用
	 */
	@Test
	public void demo02() {
		//先要创建Spring的工厂
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");// classpath就是类路径，src目录下的文件最终要编译到类路径下
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		userDao.save();
	}

}
 
然后，运行以上demo02单元测试方法，Eclipse控制台就会打印如下内容。
 
 
Spring IoC和DI的区别
 
IoC上面我已经讲过了，它指的就是将对象的创建权反转给（交给）了Spring。那DI又是什么鬼呢？DI，即Dependency Injection，翻译过来就是依赖注入，它指的就是Spring在管理某个类的时候会将该类依赖的属性注入（设置）进来，也就是说在创建对象的过程中，向类里面的属性中设置值。注意：依赖注入不能单独存在，须在控制反转基础之上完成，用更通俗点的话来说，就是注入类里面的属性值，不能直接注入，须创建类的对象再完成注入。
 你还记得在面向对象设计的时候，类和类之间有几种关系吗？有3种，它们分别是：
 
依赖，由于下图中B类的方法用到了A类，所以此时就可以说B类依赖于A类；
 
继承（is a），这种关系我们应该是见的要吐了；
 
聚合（has a），它有松散和紧密之分。例如，球队得有一个守门员，即使这个球队没有了这个守门员，它也还是一个球队，所以它是松散的；人得有一个脑袋，此时它就是紧密的。
 
说了这么多，咱就通过一个案例来看看DI在程序的体现。现在，我们想要给UserDaoImpl这个实现类里面的某一个属性（例如String类型的name）设置值，该咋怎呢？首先，将UserDaoImpl这个实现类修改成下面这个样子。
 
package com.meimeixia.spring.demo01;

/**
 * 用户管理的dao层接口的实现类
 * @author liayun
 *
 */
public class UserDaoImpl implements UserDao {
	
	private String name;
	
	//提供set方法
	public void setName(String name) {
		this.name = name;
	}

	@Override
	public void save() {
		System.out.println("UserDaoImpl中的save方法执行了......" + name);
	}
	
}
 
如果使用传统的方式来为UserDaoImpl实现类的name属性设置值，那么SpringDemo01单元测试类中的demo01方法就应该写成下面这个样子。
 
package com.meimeixia.spring.demo01;

import org.junit.Test;

/**
 * Spring的入门
 * @author liayun
 *
 */
public class SpringDemo01 {
	
	/*
	 * 传统方式的调用
	 */
	@Test
	public void demo01() {
		/*
		 * 我想给这个类里面的某一个属性设置值，挺麻烦的！
		 * 
		 * 1. 不能面向接口编程了
		 * 2. 你还得手动调用set方法，也得去改变程序的源代码
		 */
		UserDaoImpl userDao = new UserDaoImpl();
		userDao.setName("李二");
		userDao.save();
	}

}
 
这样写，就有两个缺点，一是不能面向接口编程了，二是咱还得手动调用对象的set方法，这必然就涉及到要改变程序的源代码了，这是我们不能接受的！
 如果使用了依赖注入，即在applicationContext.xml文件中为配置好的UserDaoImpl实现类的name属性注入一个值，那么情况就完全不同了，以上两个缺点也就不复存在了。
 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">
        
	<!-- Spring入门的配置 -->
	<bean id="userDao" class="com.meimeixia.spring.demo01.UserDaoImpl">
		<!-- DI：依赖注入 -->
		<property name="name" value="李二" />
	</bean>
	
</beans>
 
此时，SpringDemo01单元测试类中的demo02方法依然不变，如下。
 
package com.meimeixia.spring.demo01;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

/**
 * Spring的入门
 * @author liayun
 *
 */
public class SpringDemo01 {
	
	/*
	 * 传统方式的调用
	 */
	@Test
	public void demo01() {		
		/*
		 * 我想给这个类里面的某一个属性设置值，挺麻烦的！
		 * 
		 * 1. 不能面向接口编程了
		 * 2. 你还得手动调用set方法，也得去改变程序的源代码
		 */
		UserDaoImpl userDao = new UserDaoImpl();
		userDao.setName("李二");
		userDao.save();
	}
	
	/*
	 * Spring的方式的调用
	 */
	@Test
	public void demo02() {
		//先要创建Spring的工厂
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		userDao.save();
	}

}
 
运行以上demo02单元测试方法，Eclipse控制台就会打印出如下内容。
 
 
Spring的工厂类
 
Spring工厂类的结构图
 

 从上图可以看出ApplicationContext（接口）继承自BeanFactory（接口）。
 
BeanFactory：老版本的工厂类
 
BeanFactory是老版本的工厂类，稍微了解一下就好，这个类在实际开发中我们并不需要用到。需要说明的一点是，它只有在调用getBean方法的时候，才会生成Spring所管理的类的实例。
 
ApplicationContext：新版本的工厂类
 
ApplicationContext是新版本的工厂类，它在加载配置文件的时候，就会将Spring所管理的类都实例化。ApplicationContext这个接口有两个实现类，如下图所示。
 
 ClassPathXmlApplicationContext这个实现类前面用过了，下面咱就来用一下FileSystemXmlApplicationContext这个实现类。首先，拷贝一份applicationContext.xml文件到C盘下，其内容做一点点修改。
 
 然后，在SpringDemo01单元测试类中编写如下一个demo03方法。
 
package com.meimeixia.spring.demo01;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

/**
 * Spring的入门
 * @author liayun
 *
 */
public class SpringDemo01 {
	
	/*
	 * 传统方式的调用
	 */
	@Test
	public void demo01() {	
		/*
		 * 我想给这个类里面的某一个属性设置值，挺麻烦的！
		 * 
		 * 1. 不能面向接口编程了
		 * 2. 你还得手动调用set方法，也得去改变程序的源代码
		 */
		UserDaoImpl userDao = new UserDaoImpl();
		userDao.setName("李二");
		userDao.save();
	}
	
	/*
	 * Spring的方式的调用
	 */
	@Test
	public void demo02() {
		//先要创建Spring的工厂
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		userDao.save();
	}
	
	/*
	 * 加载磁盘上的配置文件
	 */
	@Test
	public void demo03() {
		//先要创建Spring的工厂
		ApplicationContext applicationContext = new FileSystemXmlApplicationContext("C:\\applicationContext.xml");
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		userDao.save();
	}

}
 
最后，运行以上demo03单元测试方法，Eclipse控制台就会打印出如下内容。
 

5.1 结构化设计的概念
 
5.1.1 设计的定义
 
何谓设计：
 
 
 
一种软件开发活动，定义实现需求规约所需的软件结构
 
 
目标：
 
 
 
依据需求规约在一个抽象层上建立系统软件模型，包括软件体系结构（数据和程序结构），以及详细的处理算法。
给出软件解决方案，产生设计规格说明书。
 
 
结构化设计分为：
 
 
 
总体设计：确定系统的整体模块结构（即系统实现所需要的软件模块以及这些模块间的调用关系）。
详细设计：详细描述模块。
 
 
5.1.2 整体框架：
 

  

 
 
体系结构设计（MSD）：定义软件模块及其之间的关系，从分析模型（如数据流图）导出。
接口设计：
 
 
外部接口设计（依据分析模型中的顶层数据流图得来，包括用户界面、目标系统与其他硬件设备、软件系统的外部接口）
内部接口设计（指系统内部各种元素间的接口）。
 
 
数据设计：根据数据字典确定软件涉及的文件系统的结构及数据库的表结构。
 
 
5.1.3 对设计方法的需求：
 
 
 
提供可体现“原理/原则”的一组术语（符号）。
给出软件模型工具。
给出设计的过程指导。
 
 
5.1.4 总体设计层概述
 
① 引入两个术语/符号：
 

  

② 引入模块结构图（MSD）:
 例：
 

  

③ 过程指导
 
 
 
如何将DFD转化为初始的MSD
如何将初始的MSD转化为最终可供详细设计使用的MSD。
 
 
总体设计分为三个阶段：
 
 
 
第一阶段：初始设计。在对给定的数据流图进行复审和精化的基础上，将其转化为初始的模块结构图。根据穿越系统边界的数据流初步确定系统与外部的接口。
第二阶段：精化设计。依据模块“高内聚低耦合”的原则，精化初始的模块结构图，并设计其中的全局数据结构和每一模块的接口。
第三阶段：设计复审阶段，对前两个阶段得到的高层软件结构进行复审，必要时还可能需要对软件结构做一些精化工作。
 
 
5.2 初始模块结构图的设计
 
5.2.1 数据流图分类：
 
变换型数据流图：
 

  
 
   
 

 
 
具有较明显的输入部分和变化部分之间的界面、变化部分和输出部分之间界面的数据流图。
 
 
事务型数据流图：
 

  

 
 
数据到达一个加工，该加工根据输入数据的值，在其后的若干动作序列（称为一个事务）中选出一个来执行，这类数据流图称为事务型数据流图。
 
 
两类数据流图的区别：
 

  

 
 
原则上所有DFD都可以看成是变换型DFD。
可以在变换型数据流图的基础上，局部采用事务型数据流图。
对于事务型数据流图而言，一般接收一个输入数据，分成多条路径。
 
 
5.2.2 变换设计的基本步骤
 
以下图为例：
 

  

【第一步】复审并精化系统模型：
 
 
 
检查数据流图是否精确。
 
 
【第二步】确定输入、变换、输出这三部分之间的边界：
 
 
 
确定系统的逻辑输入和逻辑输出。
 
 
【第三步】系统模块结构图顶层和第一层的设计：
 

  


  

【第四步】自顶向下逐步求精：
 

  

 
 
此时已经从结构化需求层次转换到了结构化解决方案层次。
 
 
5.2.3 事务设计的基本步骤
 
以下图为例：
 

  

【第一步】复审并精化系统模型：
 
 
 
检查数据流图是否精确。
 
 
【第二步】确定事务处理中心：
 
 
 
即多个数据流集中处理于的地方。
 
 
【第三步】系统模块结构图顶层和第一层的设计：
 
 
 
首先为事务中心设计一个主模块
然后为每一条活动路径设计一个事务处理模块
对其输入部分设计一个输入模块
如果一个事务数据流图的活动路径集中于一个加工，则设计一个输出模块，否则第一层不设计输出模块。
 
 
【第四步】自顶向下逐步求精
 

  

5.3 初始模块结构图精化的原则
 
5.3.1 精化的概念
 
 
 
基于模块化原理“高内聚，低耦合”将初始的MSD转化为最终可供详细设计使用的MSD。
 
 
5.3.2 模块和模块化
 
区别：
 
 
 
模块：执行一个特殊任务的一组例程和数据结构。
模块化：把系统分解成若干模块的过程，使得程序能够被理性的管理。
 
 
模块化的目的：
 
 
 
解决一个较为复杂的问题的工作量，大于将这个问题分而治之的工作量之和。
 
 
 
 
注：不可能无限制的划分问题来减小工作量，因为随着模块数量的增长，集成模块所需党的工作量也在增长。
 
 
5.3.3 高内聚 低耦合
 
耦合的定义：
 
 
 
不同模块间相互依赖程度的度量。
 
 

  

耦合的强度所依赖的因素：
 
 
 
模块间的引用
模块间传递的数据量
模块间的施加控制量
模块间接口复杂度
 
 
耦合类型（由高到低）：
 
 
 
内容耦合：一个模块直接修改或操作另一个模块的数据。
公共耦合：两个及以上的模块共引用一个全局数据项。
控制耦合：一个模块向另一个模块传递控制信号。
标记耦合：两个模块至少有一个通过界面传递的公共参数，包含内部数据，如数组，字符串等。
数据耦合：模块间通过参数传递基本类型的数据。
 
 

  

 
 
所以：如果模块间必须存在耦合，尽量使用数据耦合，少用控制耦合，限制公共耦合的范围，坚决避免使用内容耦合。
 
 
内聚的定义：
 
 
 
一个模块之内各成分之间相互依赖程度的度量。
 
 
内聚类型（由低到高）：
 
 
 
偶然内聚：一个模块之内各成分之间没有任何关系。
逻辑内聚：几个逻辑上相关的功能放在同一模块中。
时间内聚：一个模块完成的功能必须在同一时间内完成，而这些功能只是因为时间因素关联在一起。
过程内聚：处理成分必须以特定的次序执行。
通信内聚：各成分都操作在同一数据集或生成同一数据集。
顺序内聚：各成分与一个功能相关，且一个成分的输出作为另一成分的输入。
功能内聚：模块的所有成分对完成单一功能是最基本的，且该模块对完成这一功能而言是充分必要的。
 
 
5.4 初始化模块结构图精化的启发式规则
 
5.4.1 常见的启发式规则
 
什么叫启发式规则：
 
 
 
根据设计准则，从长期的软件开发实践中，总结出来的规则。
 
 
常见的六种启发式规则：
 
① 改进软件结构，提高模块独立性：
 
 
 
如：多个模块公用的子功能可以独立形成一个模块，供这些模块调用。
 
 
② 模块规模适中，每页60行语句：
 
 
 
模块语句>30之后，可理解性迅速下降。
方法：进一步分解过大的模块，将频繁调用的小模块合并到上级模块中。
 
 
③ 深度、宽度、扇入扇出适中：
 
 
 
深度：控制的层数。
宽度：同一层次上的模块总数的最大值。
扇入：表示直接调用本模块的上层模块的数量，在不违背模块独立性的条件下，越大越好。
扇出：一个模块直接控制（调用）的下级模块数目，越大意味着过分复杂，典型的3~4个最优，好的系统一般呈顶层扇出高，中层扇出少，底层扇入高，的“葫芦”型。
 
 

  

④ 模块的作用域力争在控制域之内:
 
 
 
作用域：受该模块内一个判定影响的所有模块的集合。
控制域：模块本身和所有直接或间接从属于它的模块的集合。
如果超出控制域，等同于发生了控制耦合，应尽量避免。
 
 
⑤ 降低模块接口的复杂性：
 
 
 
接口过于复杂或不一致往往会导致紧耦合和低内聚
 
 
⑥ 模块功能应该可以预测：
 
 
 
如果模块带有内部状态，而输出取决于内部状态，则称为功能不可预测。
 
 
5.4.2 总体设计案例
 
数字仪表板系统：
 

  

【第一步】确定逻辑输入和逻辑输出
 

  

【第二步】确定顶层模块结构图
 

  

【第三步】输入部分细化
 

  

【第四步】输出部分细化
 

  

【第五步】输入部分精化
 

  


  

【第六步】输出部分精化
 

  

 
 
将相同或类似的物理输入（“显示”模块）合并为一个模块，以减少模块间的关联。
 
 
【第七步】变换部分的精化
 

  

 
 
变换部分的精化没有固定的准则，对经验要求较高。
 
 
5.5 接口设计
 
5.5.1 接口设计的分类
 
三个方面：
 
 
 
模块或软件构件间的接口设计
软件与其他软硬件系统间的接口设计
软件与人（用户）之间的交互设计
 
 
 
 
系统的接口设计（包括用户界面设计及与其他系统的接口设计）是由穿过系统边界的数据流定义的。
在最终的系统中，数据流将成为用户界面中的表单、报表或与其他系统进行交互的文件或通信。
 
 
5.5.2 人机交互界面
 
设计者需要了解到：
 
 
 
用户界面应具有的特性？
使用软件的用户是什么人？
用户怎样学习与新的计算机系统进行交互？
用户需要完成哪些工作？
 
 
用户界面应具备的特性：
 
 
 
可使用性：使用简单、界面一致、拥有help帮助功能、快速的系统响应和低的系统成本、容错能力等。
灵活性：考虑到用户的特点、能力和知识水平，应该使用户接口满足不同用户的要求，对于不同的用户使用不同的界面形式。
可靠性：指无故障使用的间隔时间，用户界面应当能够保证用户正确、可靠地使用系统，保证有关程序和数据的安全性。
 
 
用户类型：
 
 
 
外行型：对计算机系统认知很少或毫无了解。
初学型：对计算机有一定经验，对系统的认识不足或经验很少，需要很多界面支持。
熟练型：对一个系统有很多经验，需要较少的界面支持，但不能处理意外错误。
专家型：了解系统的内部构造，需要为他们提供能够修改和扩充系统能力的复杂界面。
 
 
5.5.3 设计原则
 
遵循的原则：
 
 
 
一致性：指界面风格一致。
操作步骤少
不要“哑播放”：指使用进度条，加载条等能够证明系统正在运行的标志。
提供Undo功能：指“取消”等能够撤销用户错误操作的功能。
减少人脑的记忆负担：指“记住密码”，“从上次的地方开始播放”等功能。
提高学习效率：指用户能够很容易的学会交互的方法
 
 
5.6 数据设计
 
 
 
在设计阶段必须对要存储的数据及其格式进行设计。
 
 
5.6.1 文件设计
 
适用于文件存储的情况：
 
 
 
数据量较大的非结构化数据，如多媒体信息。
数据量大，信息松散，如历史记录，档案文件等。
非关系层次化数据。如系统配置文件
对数据的存取速度要求极高。
临时存放的数据。
 
 
文件设计的主要工作：
 
 
 
根据：
 使用要求、处理方式、存储的信息量、数据的活动性、所提供的设备条件等。
 
 
 
 
确定：
 文件类型、选择文件媒体，文件组织方式，文件记录格式，文件容量。
 
 
5.6.2 数据库设计
 
设计要领：
 
 
 
数据对象的映射
关系的映射
 
 
5.7 详细设计工具
 
5.7.1 概览
 
详细设计的任务：
 
 
 
引入关于三种动作控制结构的术语：顺序，选择，循环来定义每一模块。
 
 
要求：
 
 
 
一个程序的代码块仅仅通过顺序、选择和循环三种基本控制结构进行连接。
每个代码块只有一个入口和一个出口。
 
 
5.7.2 伪码（PDL）
 
 
 
顺序：begin s1;s2;…sn end;
选择：if 条件表达式 then s1 else s2;
循环：while 条件表达式 do s;
 
 
优点：
 
 
 
既可作为设计工具，也可作为注释工具，直接插在源程序中间，以保持文档和程序的一致性，提高了文档质量。
 
 
缺点：
 
 
 
不如图形工具那样形象直观。
当描述复杂的条件组合与动作间的对应关系时，不如判定表和判定树那样清晰简单。
 
 
5.7.3 程序流程图
 

  

优点：
 
 
 
对控制流程的描绘很直观，便于初学者掌握。
 
 
缺点：
 
 
 
不是一种逐步求精的工具，程序员过早地考虑程序的控制流程，而不是全局结构。
所表达的控制流，可以不受约束随意转移。
不易表示数据结构。
 
 
5.7.4 问题分析图（PAD）
 

  

支持逐步求精：
 

  

 
 
s3可逐步定义为s4，s5，s6的过程。
 
 
优点：
 
 
 
支持自顶向下逐步求精的结构化详细设计，
PAD图最左边的竖线是程序的主线，随着程序层次的增加，逐步向右延伸，每增加一个层次，图形向右扩展一条竖线，表现的处理逻辑易读、易懂、易记。
 
 
5.7.5 结构化流程图（N-S）
 

  

支持逐步求精设计：
 

  

优点：
 
 
 
支持自顶向下逐步求精的结构化详细设计，并且严格限制了控制从一个处理到另一个处理的转移。
 
 
5.7.6 判定表和判定树
 
 
 
当算法中包含多重嵌套的条件选择时，可以选择判定表来表达复杂的条件组合与应做的动作之间的对应关系。
 
 
5.8 软件设计规约
 
5.8.1 概念和组成
 
什么是软件设计规约：
 
 
 
对软件的组织或其组成部分的内部结构的描述，满足系统需求规约所指定的全部功能及性能要求。
 
 
组成部分：
 
 
 
概要设计规约。
详细设计规约。
 
 
5.8.2 概要设计规约
 
作用：
 
 
 
主要作为软件项目管理人员、系统分析人员与设计人员之间交流的媒体。
 
 
主要内容：
 ① 系统环境
 
 
 
硬件、软件接口与人机界面
外部定义的数据库
与设计有关的限定条件
 
 
② 设计描述
 
 
 
数据流和主要数据结构
软件模块的结构
模块间的接口
 
 
③ 对每个模块的描述
 
 
 
处理过程外部行为
界面定义
数据结构
必要的注释
 
 
④ 文件结构和全局数据
 
 
 
文件的逻辑结构、记录描述以及访问方式
交叉引用信息
 
 
⑤ 软件测试方面的要求和说明
 
5.8.3 详细设计规约
 
作用：
 
 
 
主要作为软件设计人员与程序员之间交流的媒体。
 
 
主要内容：
 
 
 
各处理过程的算法
算法所涉及的全部数据结构的描述，对主要数据结构往往包括与算法实现有关的描述。
 
 
5.8.4 设计规约格式
 

  


  


  


  


  


  


  


  

（完）