面向对象程序设计实用教程

第一章  计算机与程序设计                  
     1. 1  计算机的基本结构                  
     1. 1. 1  计算机硬件的基本组成                  
     1. 1. 2  计算机的工作过程                  
     1. 2  程序设计语言                  
     1. 3  面向过程程序设计                  
     1. 3. 1  模块化                  
     1. 3. 2  抽象                  
     1. 3. 3  信息隐藏和局部化                  
     1. 3. 4  模块独立                  
     1. 3. 5  结构程序设计技术                  
     1. 4  面向对象程序设计                  
     1. 4. 1  面向对象方法概述                  
     1. 4. 2  面向对象方法的主要优点                  
     1. 5  小结                  
     习题一                  
   第二章  面向对象方法学导论                  
     2. 1  对象                  
     2. 1. 1  对象的形象表示                  
     2. 1. 2  对象的定义                  
     2. 1. 3  对象的特点                  
     2. 2  其他面向对象的概念                  
     2. 3  面向对象建模                  
     2. 4  对象模型                  
     2. 4. 1  表示类一＆—对象的图形符号                  
     2. 4. 2  表示结构的图形符号                  
     2. 4. 3  例子                  
     2. 5  面向对象分析                  
     2. 5. 1  确定类一＆—对象                  
     2. 5. 2  确定关联                  
     2. 5. 3  确定属性                  
     2. 5. 4  识别继承关系                  
     2. 5. 5  确定服务                  
     2. 6  面向对象设计                  
     2. 6. 1  模块化                  
     2. 6. 2  抽象                  
     2. 6. 3  信息隐藏                  
     2. 6. 4  弱耦合                  
     2. 6. 5  强内聚                  
     2. 6. 6  可重用                  
     2. 7  面向对象实现                  
     2. 8  小结                  
     习题二                  
   第三章  一个面向对象的C++程序实例                  
     3. 1  面向对象分析与设计                  
     3. 1. 1  需求陈述                  
     3. 1. 2  面向对象分析                  
     3. 1. 3  面向对象设计                  
     3. 2  用C++语言实现                  
     3. 2. 1  定义类                  
     3. 2. 2  说明数据成员                  
     3. 2. 3  说明和定义成员函数                  
     3. 2. 4  完整的C++程序                  
     3. 3  小结                  
     习题三                  
   第四章  数据成员                  
     4. 1  数据类型                  
     4. 1. 1  基本数据类型                  
     4. 1. 2  复合数据类型                  
     4. 1. 3  指针和引用                  
     4. 2  const数据成员                  
     4. 3  静态数据成员                  
     4. 4  动态数据成员与对象生存期                  
     4. 4. 1  动态数据成员                  
     4. 4. 2  对象生存期与数据成员作用域                  
     4. 5  小结                  
     习题四                  
   第五章  成员函数                  
     5. 1  成员函数的概念                  
     5. 2  成员函数的定义与调用                  
     5. 2. 1  成员函数的定义                  
     5. 2. 2  成员函数的调用                  
     5. 2. 3  内联函数                  
     5. 3  运算符和表达式                  
     5. 3. 1  运算符及运算符优先级                  
     5. 3. 2  表达式                  
     5. 3. 3  数据类型的转换                  
     5. 4  控制结构                  
     5. 4. 1  顺序结构                  
     5. 4. 2  选择结构(又称分支结构)                  
     5. 4. 3  循环结构                  
     5. 5  函数参数的传递机制                  
     5. 5. 1  传值调用                  
     5. 5. 2  引用调用                  
     5. 6  函数的参数                  
     5. 6. 1  函数参数的求值顺序                  
     5. 6. 2  数组作为函数参数                  
     5. 6. 3  带缺省值的函数                  
     5. 7  静态成员函数                  
     5. 8  函数的重载                  
     5. 9  两种特殊函数                  
     5. 9. 1  构造函数                  
     5. 9. 2  析构函数                  
     5. 10  小结                  
     习题五                  
   第六章  封装性                  
     6. 1  C++类与对象                  
     6. 1. 1  定义类的语法                  
     6. 1. 2  定义类的例子                  
     6. 1. 3  说明和使用对象                  
     6. 2  封装的好处                  
     6. 3  对象成员                  
     6. 4  const对象和const成员                  
     6. 4. 1  const对象和只读成员函数                  
     6. 4. 2  const对象成员                  
     6. 5  对象数组                  
     6. 6  自引用指针this                  
     6. 7  友元                  
     6. 8  小结                  
     习题六                  
   第七章  继承性                  
     7. 1  继承的好处                  
     7. 2  C++定义派生类的语法                  
     7. 2. 1  定义派生类的语法                  
     7. 2. 2  访问权修饰符                  
     7. 3  基类成员的访问属性                  
     7. 3. 1  同名成员                  
     7. 3. 2  静态成员                  
     7. 3. 3  访问声明                  
     7. 4  派生类对象的初始化                  
     7. 5  多重继承                  
     7. 5. 1  语法                  
     7. 5. 2  同名引出的二义性                  
     7. 5. 3  公共基类带来的二义性                  
     7. 5. 4  多重继承应用举例                  
     7. 5. 5  虚基类                  
     7. 6  基类与派生类之间的转换                  
     7. 6. 1  赋值兼容规则                  
     7. 6. 2  赋值兼容规则应用举例                  
     7. 7  小结                  
     习题七                  
   第八章  重载                  
     8. 1  重载的好处                  
     8. 2  对运算符重载的限制                  
     8. 3  运算符重载的语法                  
     8. 3. 1  用成员函数重载运算符                  
     8. 3. 2  用成员函数重载运算符之例                  
     8. 3. 3  用友员函数重载运算符                  
     8. 3. 4  用友员函数重载运算符之例                  
     8. 4  重载赋值运算符                  
     8. 4. 1  指针悬挂问题                  
     8. 4. 2  重载赋值运算符解决指针悬挂问题                  
     8. 5  重载++和——运算符                  
     8. 6  重载运算符的规则                  
     8. 7  类类型的转换                  
     8. 7. 1  用构造函数完成类类型转换                  
     8. 7. 2  类类型转换函数                  
     8. 8  小结                  
     习题八                  
   第九章  多态性                  
     9. 1  静态联编与动态联编                  
     9. 1. 1  静态联编                  
     9. 1. 2  动态联编                  
     9. 2  虚函数的声明与使用                  
     9. 2. 1  声明虚函数                  
     9. 2. 2  使用虚函数                  
     9. 2. 2  动态联遍的实现                  
     9. 3  虚函数应用实例之一                  
     9. 4  纯虚函数                  
     9. 5  虚函数应用实例之二                  
     9. 6  多态性带来的好处                  
     9. 7  小结                  
     习题九                  
   第十章  I／0流                  
     10. 1  C++流库概述                  
     10. 2  预定义类型的输入／输出                  
     10. 2. 1  istream流类                  
     10. 2. 2  ostl. Pam流类                  
     10. 2. 3  输入运算符                  
     10. 2. 4  输出运算符                  
     10. 3  格式控制                  
     10. 3. 1  用ios类成员函数控制格式                  
     10. 3. 2  用控制符控制格式                  
     10. 4  自定义类型的输入／输出                  
     10. 4. 1  重载输入运算符                  
     lo. 4. 2  重载输出运算符                  
     lo. 5  文件的输入／输出                  
     10. 5. 1  面向文件的流                  
     10. 5. 2  文件的读写                  
     10. 6  小结                  
     习题十                  
   第十一章  模板                  
     11. 1  从类属到模板                  
     11. 2  函数模板与模板函数                  
     11. 2. 1  概念                  
     11. 2. 2  重载                  
     11. 3  类模板与模板类                  
     11. 3. 1  定义类模板                  
     11. 3. 2  使用类模板                  
     11. 3. 3  类模板的派生                  
     11. 4  模板应用实例                  
     11. 4. 1  用类模板实现类属链表                  
     11. 4. 2  派生出集合类模板和集合类                  
     11. 5  小结                  
     习题十一                  
   第十二章  基于Windows的面向对象语言(一)——VC++                  
     12. 1  WindoWs的编程模式                  
     12. 2  Microsoft基本类库MFC及应用程序框架                  
     12. 3  Microsoft基本类库的消息映射                  
     12. 4  VC++的文档——视图模型                  
     12. 5  VC++程序设计实例                  
     12. 5. 1  面向对象分析                  
     12. 5. 2  面向对象设计                  
     12. 6  小结                  
     习题十二                  
   第十三章  基于Windows的面向对象语言(二)——Java                  
     13. 1  Java语言的特点                  
     13. 2  Java语言简介                  
     13. 2. 1  Java中类的定义                  
     13. 2. 2  Java类中的数据与方法                  
     13. 2. 3  Java中的继承性                  
     13. 2. 4  Java中的多态性                  
     13. 3  Java语言与C++语言的不同                  
     13. 4  JVM的概念与规范                  
     13. 5  Java语言的应用                  
     13. 6  小结                  
     习题十三                  
   主要参考文献