计算机程序设计 第3版PDF电子书下载

目录 1

第1章 计算机和编程逻辑概述 1

1.1 理解计算机的组件和操作 1

1.2 理解程序设计过程 4

1.2.1 理解问题 5

1.2.2 设计逻辑 5

1.2.3 编写程序代码 6

1.2.4 把程序转换成机器语言 6

1.2.5 测试程序 7

1.2.6 将程序投入生产 8

1.3 理解数据的层次结构 8

1.4 使用流程表符号和伪代码语句 10

1.5 使用和命名变量 13

1.6 使用标记值终止程序 15

1.7 使用连接符 16

1.8 把值赋给变量 17

1.9 理解数据类型 18

1.10 理解编程技术的发展 19

1.11 复习题 20

1.12 练习题 22

第2章 理解结构 26

2.1 理解非结构化的意大利面条式代码的功能 26

2.2 3种基本的结构 27

2.3 使用预读取 33

2.4 理解结构化 37

2.5 识别结构 39

2.6 两种特殊的结构——case和do until 42

2.6.1 case结构 42

2.6.2 do until循环 44

2.7 复习题 46

2.8 练习题 48

第3章 模块、层次图和文档 52

3.1 模块、子例程、过程、函数或者方法 52

3.1.1 模块化提供抽象 52

3.1.2 模块化允许多个程序员解决同一问题 53

3.1.3 模块化允许重用自己的工作成果 53

3.1.4 模块化使结构易于识别 54

3.2 把程序模块化 55

3.3 模块调用其他模块 58

3.4 声明变量 59

3.5 创建层次图 61

3.6 理解文档 63

3.7 输出文档 63

3.8 输入文档 69

3.9 完成文档 73

3.10 复习题 74

3.11 练习题 76

第4章 编写和设计完整的程序 82

4.1 理解贯穿程序的主线逻辑流 82

4.2 内务管理任务 85

4.2.1 声明变量 85

4.2.2 打开文件 89

4.2.3 一次性任务——输出标题 90

4.2.4 读取第一条输入记录 90

4.3 编写主循环 92

4.4 执行工作结束任务 96

4.5 需要设计良好编程的原因 98

4.6 把程序组件存储在独立的文件中 98

4.7 选择变量和模块名 100

4.8 设计清晰的模块语句 101

4.8.1 避免混乱的行中断 101

4.8.2 使用临时变量表达较长的语句 102

4.8.3 在适当情况下使用常量 102

4.9 保持良好的编程习惯 103

4.10 复习题 103

4.11 练习题 105

第5章 选择结构 108

5.1 评估布尔表达式以做比较 108

5.2 使用逻辑比较运算符 110

5.3 了解AND逻辑 113

5.3.1 编写嵌套式AND选择结构以提高效率 116

5.3.2 在AND选择结构中结合判断 118

5.3.3 避免AND选择中的常见错误 120

5.4 了解OR逻辑 121

5.4.1 避免OR选择中的常见错误 122

5.4.2 编写OR判断语句以提高效率 125

5.4.3 在OR选择结构中结合判断 126

5.4.4 在范围内使用选择 127

5.4.5 使用范围检查的常见错误 129

5.5 了解结合AND和OR选择时的优先级 131

5.6 了解case结构 133

5.7 使用决策表 134

5.8 复习题 140

5.9 练习题 143

第6章 循环 149

6.1 了解循环的优点 149

6.2 以循环控制变量的方式使用while循环 150

6.3 使用计数器控制循环 151

6.4 具有变量标记值的循环 155

6.5 通过减值进行循环 156

6.6 避免常见的循环错误 157

6.6.1 忽视初始化循环控制变量 157

6.6.2 忽视改变循环控制变量 158

6.6.3 对循环控制变量使用错误的比较 158

6.6.4 在循环内部包含属于循环外部的语句 159

6.6.5 初始化不要求初始化的变量 160

6.7 使用for循环 160

6.8 使用do until循环 162

6.9 识别由所有循环共享的特性 165

6.10 嵌套循环 166

6.11 使用循环累积总数 169

6.12 复习题 171

6.13 练习题 174

第7章 控制改变 178

7.1 了解控制改变逻辑 178

7.2 执行单级控制改变以启动新页 179

7.3 在控制改变模块的标题内使用控制数据 184

7.4 在控制改变模块的页脚内使用控制数据 185

7.5 以总计执行控制改变 188

7.6 执行多级控制改变 192

7.7 执行分页符 197

7.8 复习题 201

7.9 练习题 204

第8章 数组 208

8.1 了解数组 208

8.2 数组如何占用计算机内存 209

8.3 操作数组以取代嵌套式判断 209

8.4 声明和初始化数组 217

8.5 运行时数组和编译时数组 219

8.6 从文件中载入数组 221

8.7 在数组中搜索精确的匹配 223

8.8 使用并行数组 225

8.9 保持在数组边界内 227

8.10 使用早期退出提高搜索效率 229

8.11 在数组中搜索范围匹配 229

8.12 复习题 232

8.13 练习题 235

第9章 高级数组操作 240

9.1 了解排序记录的必要性 240

9.2 如何交换两个值 241

9.3 使用冒泡排序 242

9.3.1 通过使用数组大小变量精化冒泡排序 247

9.3.2 排序变量大小列表 249

9.3.3 通过减少不必要的比较精化冒泡排序 252

9.3.4 通过排除不必要的比较而精化冒泡排序 252

9.4 使用插入排序 255

9.5 使用选择排序 257

9.6 使用索引文件 258

9.7 使用链接列表 260

9.8 使用多维数组 261

9.9 复习题 265

9.10 练习题 267

第10章 使用菜单并验证输入的有效性 270

10.1 使用交互式程序 270

10.2 使用单级菜单 271

10.3 把模块编码成黑箱 274

10.4 改进菜单程序 279

10.5 使用case结构来管理菜单 282

10.6 使用多层菜单 285

10.7 验证输入的有效性 291

10.8 了解数据有效性的类型 292

10.8.1 验证数据类型的有效性 293

10.8.2 验证数据的范围 293

10.8.3 验证数据的合理性和一致性 293

10.8.4 验证数据的存在 294

10.9 复习题 294

10.10 练习题 296

第11章 合并、匹配和更新顺序文件 300

11.1 了解顺序文件和对顺序文件的需要 300

11.2 为合并程序创建主线和housekeeping()逻辑 301

11.3 为合并程序创建mainLoop()和finishUp()模块 303

11.4 修改合并程序中的housekeeping()模块以检查eof 307

11.5 主文件和事务文件处理 308

11.6 将文件与主文件记录中的更新字段匹配 309

11.7 允许单一主文件记录拥有多项事务 314

11.8 更新顺序文件中的记录 314

11.9 复习题 324

11.10 练习题 326

第12章 高级模块化技术 331

12.1 理解本地变量、全局变量和封装 331

12.2 把单一值传递给模块 336

12.3 把多个值传递给模块 340

12.4 从模块返回值 342

12.5 使用预先编写的内置模块 344

12.6 使用IPO图 346

12.7 封装的优点 347

12.8.1 减少耦合性 348

12.8 减少耦合性和增加内聚性 348

12.8.2 增加内聚性 350

12.9 复习题 352

12.10 练习题 354

第13章 面向对象编程 357

13.1 面向对象编程概述 357

13.2 定义类 358

13.3 实例化并使用对象 361

13.4 理解继承性 362

13.5 理解多态性 365

13.6 理解构造函数方法和析构函数方法 367

13.7 使用预定义的类创建GUI对象 369

13.8 面向对象编程的优点 370

13.9 复习题 371

13.10 练习题 373

第14章 使用图形用户界面的事件驱动编程 375

14.1 了解事件驱动编程 375

14.2 用户启动动作和GUI组件 376

14.3 设计图形用户界面（GUI） 378

14.3.1 界面应该是自然的、可预测的 378

14.3.2 屏幕的设计应该是吸引人的、易于使用掌握的 378

14.3.3 最好制定自己的应用程序 379

14.3.4 程序应该是容错的 379

14.3.5 GUI是惟一的结束途径 379

14.4 改进GUI组件的属性 379

14.5 开发事件驱动应用程序的步骤 380

14.5.1 了解问题 381

14.5.2 创建情节串联图标 381

14.5.3 定义对象库中的对象 381

14.5.4 定义用户屏幕之间的连接 382

14.5.5 计划逻辑 383

14.6 面向对象的错误处理：抛出异常 383

14.7 复习题 387

14.8 练习题 389

第15章 使用UML系统建模 391

15.1 了解系统建模的需求 391

15.2 什么是UML 392

15.3 使用用例图 393

15.4 使用类图和对象图 397

15.5 使用序列图和协作图 400

15.6 使用状态图 402

15.7 使用活动图 402

15.8 使用组件图和配置图 403

15.10 复习题 405

15.9 选择合适的UML图 405

15.11 练习题 407

第16章 使用关系数据库 408

16.1 了解关系数据库的基础 408

16.2 创建数据库和表说明 410

16.2.1 标识主键 411

16.2.2 了解数据库结构表示法 413

16.2.3 在表中添加、删除和修改记录 413

16.2.4 对表中的记录排序 413

16.2.5 创建查询 414

16.3 了解表之间的关系 415

16.3.1 了解一对多关系 416

16.3.2 了解多对多关系 417

16.3.3 了解一对一关系 420

16.4 识别拙劣的表设计 420

16.5.1 第一范式 422

16.5 了解异常、范式和规范化过程 422

16.5.2 第二范式 424

16.5.3 第三范式 426

16.6 数据库的性能问题和安全问题 428

16.6.1 提供数据完整性 428

16.6.2 恢复丢失数据 429

16.6.3 避免并发更新问题 429

16.6.4 提供验证和许可 429

16.6.5 提供加密 430

16.7 复习题 430

16.8 练习题 432

第17章 Java和Java编程环境简介 436

17.1 Java编程语言 436

17.4 下载J2SE（标准版Java 2平台）1.4.2 437

17.2 Java程序的3种类型 437

17.3 面向对象术语简介 437

17.5 Java程序的结构 438

17.6 Java开发过程 439

17.6.1 编写Java源代码 440

17.6.2 编译Java程序 440

17.6.3 执行Java程序 441

17.6.4 练习1：了解Java实用程序 441

17.6.5 实验1：编译并执行Java程序 441

第18章 变量、运算符及使用顺序语句编写程序 443

18.1 变量 443

18.1.1 变量名 443

18.1.2 Java数据类型 444

18.1.3 练习1：使用Java变量、数据类型和关键字 444

18.2.1 练习2：声明和初始化Java变量 445

18.2 声明和初始化变量 445

18.2.2 实验1：声明和初始化Java变量 446

18.3 算法运算符和赋值运算符 446

18.3.1 算法运算符 446

18.3.2 赋值运算符和赋值语句 447

18.3.3 优先级和组合规则 448

18.3.4 练习3：理解运算符优先级和组合规则 448

18.3.5 实验2：使用算法运算符和赋值运算符 449

18.4 Java注释 450

18.5 顺序语句 450

18.5.1 练习4：理解顺序语句 452

18.5.2 实验3：在Java程序中使用顺序语句 453

19.1 布尔运算符 455

19.1.1 关系运算符 455

第19章 编写判断程序 455

19.1.2 逻辑运算符 456

19.2 比较字符串 457

19.3 选择语句 458

19.3.1 if语句 459

19.3.2 练习1：理解if语句 460

19.3.3 实验1：使用if语句 461

19.3.4 if else语句 461

19.3.5 练习2：理解if else语句 462

19.3.6 实验2：使用if else语句 463

19.3.7 嵌套式if语句 463

19.3.8 练习3：理解嵌套式if语句 464

19.3.9 实验3：使用嵌套式if语句 465

19.4 使用选择语句完成多重比较 466

19.4.1 使用AND逻辑 466

19.4.3 练习4：在选择语句中完成多重比较 467

19.4.2 使用OR逻辑 467

19.4.4 实验4：在选择语句中完成多重比较 468

第20章 编写使用循环的程序 470

20.1 递增运算符（＋＋）和递减运算符（－－） 470

练习1：使用递增和递减运算符 471

20.2 在Java中编写while循环 472

20.2.1 练习2：使用while循环 473

20.2.2 使用计数器控制循环 473

20.2.3 练习3：使用计数器控制的while循环 474

20.2.4 实验1：使用计数器控制的while循环 475

20.2.5 使用标记值控制循环 475

20.2.6 练习4：使用标记值控制while循环 476

20.2.7 实验2：使用标记值控制while循环 476

20.2.8 使用事件控制循环 477

20.2.9 练习5：使用事件控制while循环 478

20.2.10 实验3：使用事件控制while循环 479

20.3 在Java中编写for循环 479

20.3.1 练习6：使用for语句 480

20.3.2 实验4：使用for循环 481

20.4 在Java中编写do while循环 481

20.4.1 练习7：使用do while循环 482

20.4.2 实验5：使用do while循环 482

20.5 嵌套循环 483

20.5.1 练习8：嵌套循环 484

20.5.2 实验6：嵌套循环 484

20.6 在循环中累加总数 485

20.6.1 练习9：在循环中累加总数 486

20.6.2 实验7：在循环中累加总数 487

21.1.1 导入软件包和类 488

21.1 输入文件 488

第21章 编写控制改变程序，从输入文件中读取数据 488

21.1.2 打开文件 489

21.1.3 从输入文件中读取数据 489

21.1.4 使用循环和EOF读取数据 490

21.1.5 练习1：打开文件和执行文件输入 490

21.1.6 实验1：使用输入文件 491

21.2 在单级控制改变程序中累加总数 491

21.2.1 练习2：在单级控制改变程序中累加总数 495

21.2.2 实验2：在单级控制改变程序中累加总数 495

第22章 在Java程序中使用数组 497

22.1 数组基础 497

22.1.1 明数组 497

22.1.2 初始化数组 498

22.1.4 停留在数组边界中 499

22.1.3 访问数组元素 499

22.1.5 练习1：使用数组基础 500

22.1.6 实验1：使用数组 500

22.2 搜索数组以寻找精确匹配 500

22.2.1 练习2：搜索数组以寻找精确匹配 501

22.2.2 实验2：搜索数组以寻找精确匹配 502

22.3 并行数组 503

22.3.1 练习3：使用并行数组 504

22.3.2 实验3：使用并行数组 504

第23章 排序数据和高级数组操作 506

23.1 为什么需要排序数据 506

23.2 交换数据值 506

23.2.1 练习1：交换值 507

23.2.2 实验1：交换值 507

23.3.1 housekeeping()模块 508

23.3 使用冒泡排序 508

23.3.2 sortScores()模块和switchValues()模块 510

23.3.3 finishUp()模块 512

23.3.4 练习2：使用冒泡排序 512

23.3.5 实验2：使用冒泡排序 513

23.4 多维数组 513

23.4.1 练习3：使用多维数组 515

23.4.2 实验3：使用多维数组 515

第24章 使用菜单并执行数据的有效性验证 517

24.1 switch语句 517

24.1.1 练习1：使用switch语句 518

24.1.2 实验1：使用switch语句 519

24.2 在Java中编写菜单驱动程序 520

24.2.1 startUp()模块 520

24.2.2 looping()模块 521

24.2.3 cleanUp()模块 524

24.2.4 练习2：使用菜单驱动程序 524

24.2.5 实验2：菜单驱动程序 525

24.3 验证输入的有效性 525

24.3.1 测试精确匹配 525

24.3.2 验证数据类型 526

24.3.3 验证数据范围 528

24.3.4 验证数据的合理性和一致性 529

24.3.5 验证数据存在 529

24.3.6 练习3：验证用户输入 530

24.3.7 实验3：验证用户输入 530

第25章 VB.NET入门 532

25.1 Visual Studio.NET IDE 532

25.2.2 Designer窗口 534

25.2.1 解决方案文件夹 534

25.2 研究VB.NET解决方案的组件 534

25.2.3 代码窗口 536

25.3 设计时和运行时操作模式 536

25.4 启动和终止解决方案 536

25.5 复习题 537

第26章 修改解决方案 538

26.1 复制文件夹 538

26.2 测试解决方案 538

26.3 打开Code窗口 539

26.4 检查代码 540

26.4.1 内部文档 540

26.4.2 变量声明 540

26.4.3 过程头和过程脚 540

26.5 修改代码 540

26.5.3 更正逻辑错误 541

26.5.1 修改题头 541

26.5.2 理解代码 541

26.6 修改数据类型 542

26.7 获得硬拷贝 542

26.8 复习题 543

26.9 练习题 543

第27章 读取记录 544

27.1 使用记事本检查文本文件 544

27.2 读取顺序文件 545

27.2.1 了解Plus100解决方案 545

27.2.2 修改Plus100解决方案 546

27.2.3 Form Load事件处理程序 547

27.3 输入整条记录 548

27.4 了解TwoNames解决方案 549

27.5 复习题 550

第28章 读取文件 552

28.1 数据处理范例 552

28.2 研究INVENTORY文件 552

28.3 研究Inventory Reader的代码 553

28.3.1 EOF功能的实现 554

28.3.2 完成过程 554

28.4 设置属性值 555

28.5 创建自己的过程 556

28.6 复习题 557

28.7 练习题 557

第29章 解决方案的模块化 559

29.1 过程的两个类型 559

29.2 编写模块化解决方案 560

29.2.1 用等号组合算术运算符 561

29.2.2 从报告输出内容 562

29.3 函数 562

29.4 报表生成程序的过程 563

29.5 复习题 564

29.6 练习题 565

第30章 选择结构程序设计 567

30.1 编写双向选择代码 567

30.2 编写单向选择代码 568

30.3 编写AND运算符 569

30.4 编写OR运算符 570

30.5 使用case结构 570

30.6 嵌套式选择 572

30.7 练习题 573

31.1 循环 575

31.2 WHILE循环 575

第31章 循环结构程序设计 575

31.3 WHILE循环代码 576

31.4 编写过程代码 577

31.5 计数器的运行 577

31.6 DO UNTIL循环 577

31.7 FOR循环 578

31.8 Label Maker程序 579

31.8.1 开始解决方案 579

31.8.2 外层循环 579

31.8.3 内层循环 580

31.9 复习题 581

31.10 练习题 581

第32章 数组 583

32.1 累加总数 583

32.2 使用累加器 584

32.3 瓶罐回收报告 585

32.4 case选择代码块 586

32.5 使用数组 587

32.6 复习题 588

32.7 练习题 589

第33章 合并顺序文件 590

33.1 读取和写入顺序文件 590

33.1.1 比较VB.NET文件和Notepad文件 590

33.1.2 读取文件 591

33.1.3 将信息写入文件 592

33.2 合并客户文件 593

33.2.1 了解合并 593

33.2.2 编写合并代码 593

33.3 保存合并后的文件 695

33.4 复习题 696

33.5 练习题 697