书籍详情

面向对象编程导论(原书第3版)

面向对象编程导论(原书第3版)

作者:(美)Timothy A.Budd著;黄明军,李桂杰译

出版社:机械工业出版社

出版时间:2003-09-01

ISBN:9787111126669

定价:¥45.00

购买这本书可以去
内容简介
  本书通过对象、方法、继承(包括多重继承)和多态等概念,以独立于编程语言的方式介绍了面向对象编程的原理。书中所列举的实例涉及多种编程语言,其中包括Java、C++、C#、Delphi、Python、CIDS、Eiffel、Objective-C、Smalltalk等。通过研究这些编程语言,读者可以更好地理解隐藏在各种语言语法之后的基本原理。此外,作者还从面向对象的角度对这些语言进行了分析比较。 本书内容全面,特别适合作为计算机专业本科高年级和研究生一年级的教材,同时也可以供那些从传统的面向过程编程转向面向对象编程、想要了解面向对象基本概念的初学者使用。 本书是经典面向对象技术教材的最新版,原版己被哥伦比亚大学、佛罗里达大学、南非大学、罗马大学等众多世界名校用做教材。书中通过对象、方法、继承(包括多重继承)和多态等概念,以独立于编程语言的方式介绍了面向对象的原理。书中所列举的实例涉及多种编程语言,其中包括Java、C++、C#、Delphi、Python,CLOS、Eiffel、Objective—C、Smalltalk等。通过研究这些编程语言,读者可以更好地理解隐藏在各种语言语法之后的基本原理。定义了面向对象编程术语提供了Java、C++和C#语言之间的大量比较通过案例研究,讨论了面向对象语言是如何应用各种多态技术的,并说明了如何使用多态来建立软件框架 深入研究了多种面向对象语言中的多重继承技术,包括多重接口和嵌套类介绍了子类/子类型之间的差异集成并使用了UML表示法和图表涵盖了设计模式、反射和内省、网络编程以及面向对象语言的实现技术等高级主题教辅材料、样章、勘误表可通过下列网址下载:ftp.cs.orst.edu/pub/budd/oopintro/3rdEdition/info.html 作者简介:Timothy Budd是美国俄勒冈州立大学计算机科学系的副教授。许多程序员都受益于他所著的书籍,除本书外,他还撰写了Classic Data Structures in Java、Understanding Object-Oriented Programming with Java、C++ for Java Programmers、Data Structures in C++ Using the Standard Template Library、Classic Data Structures in C++、Multiparadigm Programming in Leda和A Little Smalltalk,所有这些书都是由Addison-Wesley出版的。
作者简介
  Timothy Budd是美国俄勒冈州立大学计算机科学系的副教授。许多程序员都受益于他所著的书籍,除本书外,他还撰写了Classic Data Structures in Java、Understanding Object-Oriented Programming with Java、C++ for Java Programmers、Data Structures in C++ Using the Standard Template Library、Classic Data Structures in C++、Multiparadigm Programming in Leda和A Little Smalltalk,所有这些书都是由Addison-Wesley出版的。
目录
第1章  面向对象思想                  
 1. 1  为什么OOP这么流行                  
 1. 2  语言和思维                  
 1. 2. 1  爱斯基摩人和雪                  
 1. 2. 2  关于计算机语言的一个例子                  
 1. 2. 3  丘奇猜想和沃夫假说                  
 1. 3  一个新的范例                  
 1. 4  一种观察世界的方式                  
 1. 4. 1  代理和团体                  
 1. 4. 2  消息和方法                  
 1. 4. 3  责任                  
 1. 4. 4  类和实例                  
 1. 4. 5  类的层次--继承                  
 1. 4. 6  方法绑定与改写                  
 1. 4. 7  面向对象概念总结                  
 1. 5  模拟计算                  
 1. 5. 1  隐喻的力量                  
 1. 5. 2  避免无限回归                  
 1. 6  一段简史                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第2章  抽象                  
 2. 1  抽象层次                  
 2. 2  抽象的其他形式                  
 2. 2. 1  部分分化                  
 2. 2. 2  封装和互换性                  
 2. 2. 3  接口和实现                  
 2. 2. 4  服务视角                  
 2. 2. 5  复合法                  
 2. 2. 6  特化分层                  
 2. 2. 7  模式                  
 2. 3  抽象机制的发展简史                  
 2. 3. 1  汇编语言                  
 2. 3. 2  过程                  
 2. 3. 3  模块                  
 2. 3. 4  抽象数据类型                  
 2. 3. 5  以服务为中心的观点                  
 2. 3. 6  消息. 继承和多态                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第3章  面向对象设计                  
 3. 1  责任意味着无干扰                  
 3. 2  小项目编程与大项目编程                  
 3. 3  为什么从行为开始                  
 3. 4  一个RDD实例                  
 3. 4. 1  交互式智能厨房助手                  
 3. 4. 2  通过场景工作                  
 3. 4. 3  组件的标识                  
 3. 5 CRC卡--记录责任                  
 3. 5. 1  给组件一个物理表示                  
 3. 5. 2  "什么/谁"循环                  
 3. 5. 3  文档                  
 3. 6  组件和行为                  
 3. 6. 1  延迟决定                  
 3. 6. 2  为变化做准备                  
 3. 6. 3  继续场景                  
 3. 6. 4  交互图表                  
 3. 7  软件组件                  
 3. 7. 1  行为和状态                  
 3. 7. 2  实例和类                  
 3. 7. 3  耦合性和内聚性                  
 3. 7. 4  接口和实现--Parnas原则                  
 3. 8  形式化接口                  
 3. 9  设计表现                  
 3. 10  实现组件                  
 3. 11  组件集成                  
 3. 12  维护和升级                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第4章  类和方法                  
 4. 1  封装                  
 4. 2  类定义                  
 4. 2. 1  C++. Java和C#语言                  
 4. 2. 2 Apple Object Pascal和Delphi Pascal语言                  
 4. 2. 3  Smalltalk语言                  
 4. 2. 4  其他语言                  
 4. 3  方法                  
 4. 3. 1  类中方法的声明次序                  
 4. 3. 2  常量或不可变数据字段                  
 4. 3. 3  定义和实现的分离                  
 4. 4  关于类主题的变化                  
 4. 4. 1  Oberon语言中不属于类的方法                  
 4. 4. 2  接口                  
 4. 4. 3  属性                  
 4. 4. 4  向前定义                  
 4. 4. 5  内部类(或嵌套类)                  
 4. 4. 6  类的数据字段                  
 4. 4. 7  作为对象的类                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第5章  消息. 实例和初始化                  
 5. 1  消息传递语法                  
 5. 2  静态类型语言和动态类型语言                  
 5. 3  从方法内部存取接收器                  
 5. 4  对象的创建                  
 5. 5  指针和内存分配                  
 5. 6  构造函数                  
 5. 6. 1  正统规范的类形式                  
 5. 6. 2  常数值                  
 5. 7  析构函数和终止器                  
 5. 8  Smalltalk语言中的元类                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第6章  案例研究:八皇后问题                  
 6. 1  八皇后问题                  
 6. 2  使用生成器                  
 6. 2. 1  初始化                  
 6. 2. 2  找到解决方案                  
 6. 2. 3  前进到下一位置                  
 6. 3  用几种语言实现八皇后问题                  
 6. 3. 1  用Object Pascal语言实现八皇后问题                  
 6. 3. 2  用C++语言实现八皇后问题                  
 6. 3. 3  用Java语言实现八皇后问题                  
 6. 3. 4  用Obieetive-C语言实现八皇后问题                  
 6. 3. 5  用Smalltalk语言实现八皇后问题                  
 6. 3. 6  用Ruby语言实现八皇后问题                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第7章  案例研究:台球游戏                  
 7. 1  台球元素                  
 7. 2  图形对象                  
 7. 2. 1  桌壁图形对象                  
 7. 2. 2  洞口图形对象                  
 7. 2. 3  球图形对象                  
 7. 3  主程序                  
 7. 4  使用继承                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第8章  继承与替换                  
 8. 1  关于继承的直观描述                  
 8. 1. 1  "是一个"检验                  
 8. 1. 2  使用继承的原因                  
 8. 2  不同语言中的继承                  
 8. 3  子类. 子类型和替换                  
 8. 4  改写和虚拟方法                  
 8. 5  接口和抽象类                  
 8. 6  继承的形式                  
 8. 6. 1  特化子类化(子类型化)                  
 8. 6. 2  规范子类化                  
 8. 6. 3  构造子类化                  
 8. 6. 4  泛化子类化                  
 8. 6. 5  扩展子类化                  
 8. 6. 6  限制子类化                  
 8. 6. 7  变体子类化                  
 8. 6. 8  结合子类化                  
 8. 6. 9  各种继承形式小结                  
 8. 7  关于继承的变体                  
 8. 7. 1  Java语言中的匿名类                  
 8. 7. 2  继承和构造函数                  
 8. 7. 3  虚拟析构函数                  
 8. 8  继承的优点                  
 8. 8. 1  软件可复用性                  
 8. 8. 2  代码共享                  
 8. 8. 3  接口的一致性                  
 8. 8. 4  软件组件                  
 8. 8. 5  快速原型法                  
 8. 8. 6  多态和框架                  
 8. 8. 7  信息隐藏                  
 8. 9  继承的代价                  
 8. 9. 1  程序执行速度                  
 8. 9. 2  程序大小                  
 8. 9. 3  消息传递的开销                  
 8. 9. 4  程序复杂性                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第9章  案例研究:纸牌游戏                  
 9. 1  PlayingCard类                  
 9. 2  数据类和视图类                  
 9. 3  游戏                  
 9. 4  牌堆--使用继承                  
 9. 4. 1  缺省牌堆                  
 9. 4. 2  花色堆                  
 9. 4. 3  待用堆                  
 9. 4. 4  丢弃堆                  
 9. 4. 5  桌面堆                  
 9. 5  多种形式的游戏                  
 9. 6  图形用户界面                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第10章  子类和子类型                  
 10. 1  可替换性                  
 10. 2  子类型                  
 10. 3  可替换性悖论                  
 10. 4  构造子类化                  
 10. 5  动态类型语言                  
 10. 6  前置条件和后置条件                  
 10. 7  改进语义                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第11章  静态行为和动态行为                  
 11. 1  静态类型化和动态类型化                  
 11. 2  静态类和动态类                  
 11. 2. 1  运行时类型决定                  
 11. 2. 2  向下造型(反多态)                  
 11. 2. 3  非语言支持的运行时测试                  
 11. 2. 4  检验是否理解消息                  
 11. 3  静态方法绑定和动态方法绑定                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第12章  替换的本质                  
 12. 1  内存布局                  
 12. 1. 1  最小静态空间分配                  
 12. 1. 2  最大静态空间分配                  
 12. 1. 3  动态内存分配                  
 12. 2  赋值                  
 12. 3  复制和克隆                  
 12. 3. 1  Smalltalk语言和Objective-C语言中的复制                  
 12. 3. 2  C++语言中的拷贝构造函数                  
 12. 3. 3  Java语言中的克隆                  
 12. 4  相同                  
 12. 4. 1  相同和同一                  
 12. 4. 2  相同检验的悖论                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第13章  多重继承,                   
 13. 1  分类化继承                  
 13. 2  多重继承带来的问题                  
 13. 2. 1  名称歧义                  
 13. 2. 2  对替换的影响                  
 13. 2. 3  Eiffel语言中的重定义                  
 13. 2. 4  CLOS语言的类排序解决方案                  
 13. 3  接口的多重继承                  
 13. 4  继承于公共祖先                  
 13. 5  内部类                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第14章  多态及软件复用                  
 14. 1  编程语言中的多态                  
 14. 2  软件复用机制                  
 14. 2. 1  使用组合                  
 14. 2. 2  使用继承                  
 14. 2. 3  组合和继承的比较                  
 14. 3  效率和多态                  
 14. 4  软件复用的普及会成为现实吗                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第15章  重载                  
 15. 1  类型签名和范畴                  
 15. 2  基于范畴的重载                  
 15. 3  基于类型签名的重载                  
 15. 4  重定义                  
 15. 5  多价                  
 15. 6  多方法                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第16章  改写                  
 16. 1  标识改写                  
 16. 2  代替与改进                  
 16. 2. 1  Smalltalk语言中的代替                  
 16. 2. 2  Beta语言中的改进                  
 16. 2. 3  改进与子类/子类型之间的差异                  
 16. 2. 4  CADS语言中的封装                  
 16. 3  延迟方法                  
 16. 4  改写与遮蔽                  
 16. 5  协方差与反协方差                  
 16. 6  改写的变体                  
 16. 6. 1  Java语言中的final方法                  
 16. 6. 2  C#语言中的版本化                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第17章  多态变量                  
 17. 1  简单多态变量                  
 17. 2  接收器变量                  
 17. 2. 1  多态变量在框架中的作用                  
 17. 2. 2  Smalltalk语言中的端点比较                  
 17. 2. 3  self和super                  
 17. 3  向下造型                  
 17. 4  纯多态                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第18章  泛型                  
 18. 1  模板函数                  
 18. 2  模板类                  
 18. 3  模板参数中的继承                  
 18. 4  案例研究:结合分离的类                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第19章  容器类                  
 19. 1  动态类型语言中的容器                  
 19. 2  静态类型语言中的容器                  
 19. 2. 1  类型化和复用之间的关系                  
 19. 2. 2  替换和向下造型                  
 19. 2. 3  使用替换和改写                  
 19. 2. 4  参数化类                  
 19. 3  限制元素类型                  
 19. 4  元素遍历                  
 19. 4. 1  迭代器循环                  
 19. 4. 2  访问器方法                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第20章  案例研究:标准模板库                  
 20. 1  迭代器                  
 20. 2  函数对象                  
 20. 3  样例程序--库存系统                  
 20. 4  样例程序--图表                  
 20. 4. 1  最短路径算法                  
 20. 4. 2  开发数据结构                  
 20. 5  词汇索引                  
 20. 6  OOP的未来                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第21章  框架                  
 21. 1  复用和特化                  
 21. 1. 1  高级抽象和低级抽象                  
 21. 1. 2  倒置库                  
 21. 2  样例框架                  
 21. 2. 1  Java Applet APl                  
 21. 2. 2  模拟框架                  
 21. 2. 3  事件驱动的模拟框架                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第22章  框架实例:AWT和Swing                  
 22. 1  AWT的类继承层次                  
 22. 2  布局管理器                  
 22. 3  监听器                  
 22. 4  用户界面组件                  
 22. 5  案例研究:颜色显示                  
 22. 6  Swing组件库                  
 22. 6. 1  导入库                  
 22. 6. 2  不同的组件                  
 22. 6. 3  不同的绘制协议                  
 22. 6. 4  为窗口增加组件                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第23章  对象互连                  
 23. 1  耦合和内聚                  
 23. 1. 1  耦合的种类                  
 23. 1. 2  内聚的种类                  
 23. 1. 3  德墨特尔法则                  
 23. 1. 4  类级别可视性与对象级别可视性                  
 23. 1. 5  活动值                  
 23. 2  子类客户和用户客户                  
 23. 3  存取控制和可视性                  
 23. 3. 1  Smalltalk语言中的可视性                  
 23. 3. 2  ObiectPascal语言中的可视性                  
 23. 3. 3  C++语言中的可视性                  
 23. 3. 4  Java语言中的可视性                  
 23. 3. 5  Obiective-C语言中的可视性                  
 23. 4  有意依赖性                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第24章  设计模式                  
 24. 1  控制信息流                  
 24. 2  描述模式                  
 24. 3  迭代器                  
 24. 4  软件工厂                  
 24. 5  策略                  
 24. 6  单件                  
 24. 7  组合                  
 24. 8  装饰器                  
 24. 9  双调度模式                  
 24. 10  享元                  
 24. 11  代理                  
 24. 12  外观                  
 24. 13  观察者                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第25章  反射和内省                  
 25. 1  理解机制                  
 25. 1. 1  类对象                  
 25. 1. 2  字符串形式的类名称                  
 25. 1. 3  检测对象类                  
 25. 1. 4  通过类建立实例                  
 25. 1. 5  检测对象是否理解消息                  
 25. 1. 6  类行为                  
 25. 2  作为对象的方法                  
 25. 3  修改机制                  
 25. 3. 1  Smalltalk语言中的方法编辑,                   
 25. 3. 2  Java语言中的动态类加载                  
 25. 4  元类                  
 小结                  
 进一步阅读材料                  
 自学提问                  
                   
 第26章  分布式对象                  
 26. 1  地址. 端口和套接字                  
 26. 2  一个简单的客户朋艮务器程序                  
 26. 3  多客户端                  
 26. 4  通过网络传输对象                  
 26. 5  更复杂的技术                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
                   
 第27章  实现                  
 27. 1  编译器和解释器                  
 27. 2  作为参数的接收器                  
 27. 3  继承方法                  
 27. 3. 1  多重继承的问题                  
 27. 3. 2  裁剪问题                  
 27. 4  改写方法                  
 27. 5  名称编码                  
 27. 6  分派表                  
 27. 7  字节码解释器                  
 27. 8  即时编译                  
 小结                  
 进一步阅读材料                  
 自学提问                  
 练习                  
 附录A  八皇后问题的源代码                  
 附录B  台球游戏的源代码                  
 附录C  纸牌游戏的源代码                  
 术语表                  
 参考文献                  

猜您喜欢

读书导航