第1章  软件开发概述

  1.1  程序与软件

    1.1.1  从程序到软件

    1.1.2  软件类型

    1.1.3  程序设计与软件开发

  1.2  软件生存周期

    1.2.1  使用角度的软件生存周期

    1.2.2  开发角度的软件生存周期

  1.3  软件开发过程

    1.3.1  瀑布式开发过程

    1.3.2  增量开发模型

    1.3.3  个体软件过程

  1.4  敏捷开发

    1.4.1  概述

    1.4.2  Scrum方法

  1.5  软件构造

    1.5.1  有关概念

    1.5.2  构造与开发过程

    1.5.3  主要内容

    1.5.4  软件构造的重要性

  1.6  为什么不直接编写软件？

    1.6.1  软件开发语言

    1.6.2  编程工具与集成化开发环境

    1.6.3  软件运行环境

    1.6.4  软件开发的最佳实践

    1.6.5  开发过程与管理

  1.7  案例导读

  1.8  思考与练习题

第2章  模块化软件构造

  2.1  分解与模块化

    2.1.1  分解的含义

    2.1.2  模块化与结构化

  2.2  数据结构与算法

    2.2.1  数据结构与算法的关系

    2.2.2  选择与设计数据结构

    2.2.3  选择与设计算法

  2.3  模块化设计理论初步

    2.3.1  模块化原则

    2.3.2  模块的内聚性

    2.3.3  模块间的耦合性

  2.4  测试程序

    2.4.1  测试需求

    2.4.2  测试设计与测试用例

  2.5  调试程序

    2.5.1  缺陷的相关术语

    2.5.2  调试基础

  2.6  案例分析与实践

    2.6.1  案例程序的初始构造

    2.6.2  无相同算式的基础构造

    2.6.3  编程实现测试

  2.7  讨论与提高

    2.7.1  软件质量

    2.7.2  软件测试的其他观点

    2.7.3  测试设计

    2.7.4  编程风格

  2.8  思考与练习题

第3章  面向对象的软件构造

  3.1  抽象与封装

    3.1.1  模块产生与合成

    3.1.2  抽象与封装

    3.1.3  抽象数据类型

  3.2  认识面向对象

    3.2.1  设计类

    3.2.2  设计操作

    3.2.3  分类

  3.3  面向对象的设计

    3.3.1  面向对象的设计符号

    3.3.2  案例设计一

    3.3.3  案例设计二

  3.4  调试的基本技术

    3.4.1  单步调试源程序

    3.4.2  检查/更改变量的值

    3.4.3  设置监视点观察变量

    3.4.4  上下移动调用栈

  3.5  软件自动化测试

    3.5.1  初识JUnit

    3.5.2  编写JUnit测试代码

  3.6  案例分析与实践

    3.6.1  分析

    3.6.2  构造

  3.7  讨论与提高

    3.7.1  对调试的进一步认识

    3.7.2  设计原则与设计模式

    3.7.3  面向对象的设计原则

  3.8  思考与练习题

第4章  数据处理的软件构造

  4.1  数据及其持久性

  4.2  文件与输入/输出流

    4.2.1  文件

    4.2.2  输入/输出流

    4.2.3  数据序列化

    4.2.4  CSV格式的文本文件

  4.3  编写健壮的程序

    4.3.1  防御性编程

    4.3.2  使用断言

  4.4  字符串处理与正则表达式

  4.5  程序中数据集的使用

    4.5.1  算式基

    4.5.2  表驱动编程

  4.6  基于程序结构的测试

    4.6.1  语句覆盖测试

    4.6.2  程序控制流图

    4.6.3  逻辑覆盖测试

    4.6.4  路径覆盖测试

  4.7  运用JUnit

    4.7.1  异常测试

    4.7.2  参数化测试

    4.7.3  测试套件

    4.7.4  JUnit的断言

    4.7.5  JUnit使用指南

  4.8  案例分析与实践

    4.8.1  批量生成100以内算式的习题

    4.8.2  批改练习并存储

    4.8.3  算式基的构造与应用

  4.9  讨论与提高

    4.9.1  应用表驱动编程

    4.9.2  使用文件还是数据库

    4.9.3  契约式编程

  4.1 0 思考与练习题

第5章  用户交互的软件构造

  5.1  程序及其功能的使用

    5.1.1  程序的两个观察视角

    5.1.2  多个功能程序的整合

    5.1.3  多个功能的组织与呈现

    5.1.4  基于菜单式功能选择的用户交互

  5.2  用户交互概述

    5.2.1  基本概念

    5.2.2  交互设备

    5.2.3  交互风格

    5.2.4  交互界面

    5.2.5  交互设计的原则

  5.3  用户交互的开发

    5.3.1  交互设计基本过程

    5.3.2  快速原型法

  5.4  静态测试

    5.4.1  程序的可用性与静态测试

    5.4.2  桌面检查

    5.4.3  代码走查

    5.4.4  正式审查

    5.4.5  同行评审

    5.4.6  检查表

    5.4.7  静态程序分析

  5.5  软件集成与测试

    5.5.1  驱动模块和桩模块

    5.5.2  集成策略

    5.5.3  回归测试

    5.5.4  集成测试与策略

  5.6  案例分析与实践

    5.6.1  分析与设计

    5.6.2  案例程序的菜单式用户交互的构造

    5.6.3  循环语句的路径测试

  5.7  讨论与提高

    5.7.1  软件建模

    5.7.2  基于模型的测试

    5.7.3  执行函数名符号串的表驱动编程

    5.7.4  持续集成

  5.8  思考与练习题

第6章  软件重构与交付

  6.1  代码重构

    6.1.1  代码重构的案例研究

    6.1.2  代码重构概述

  6.2  软件交付

    6.2.1  构建与打包

    6.2.2  实现构建自动化的工具

    6.2.3  Java程序的打包与交付

  6.3  案例分析与实践

    6.3.1  代码重构的案例分析

    6.3.2  代码重构实践

    6.3.3  提交案例程序

  6.4  讨论与提高

    6.4.1  测试层次

    6.4.2  测试驱动开发

    6.4.3  软件交付及其发展

  6.5  思考与练习题

第7章  GUI软件构造

  7.1  GUI简介

    7.1.1  GUI发展轨迹

    7.1.2  Java GUI的构造工具

  7.2  GUI的基本元素与设计规范

    7.2.1  GUI的基本元素

    7.2.2  GUI基本设计规范

  7.3  Java GUI设计模式

    7.3.1  观察者模式

    7.3.2  MVC模式

  7.4  事件驱动编程

    7.4.1  事件捕捉与处理

    7.4.2  焦点事件和Tab顺序

    7.4.3  实例讲解

  7.5  案例分析与实践

    7.5.1  探路的GUI构造任务

    7.5.2  重构GUI构造任务

  7.6  讨论与提高

    7.6.1  GUI的设计原则

    7.6.2  GUI的测试

  7.7  思考与练习题

第8章  应用数据库

  8.1  数据库概述

    8.1.1  关系数据库

    8.1.2  关系数据库的数据模型

  8.2  结构化查询语言SQL

    8.2.1  SQL概述

    8.2.2  创建基本表的

  语句

    8.2.3  插入元组的INSERT语句

    8.2.4  删除元组的DELETE语句

    8.2.5  更新元组的UPDATE语句

    8.2.6  选择元组的SELECT语句

  8.3  数据库的开发过程

  8.4  编程操作数据库

    8.4.1  连接数据库

    8.4.2  查询数据库

  8.5  案例分析与实践

    8.5.1  分析与设计

    8.5.2  设计数据库

    8.5.3  开发数据库应用程序

  8.6  讨论与提高

    8.6.1  事务与并发