面向对象的思考过程 (马特·魏斯费尔德 著)

第1章 面向对象的概念简介 (已看)

　　1.1 基本概念

　　1.2 对象及遗留系统

　　1.3 过程式编程与面向对象编程

　　1.4 由面向过程开发过渡道面向对象开发

　　　　1.4.1 过程式编程

　　　　1.4.2 面向对象编程

　　1.5 究竟什么是对象

　　　　1.5.1 对象数据

　　　　1.5.2 对象行为

　　1.6 究竟什么是类

　　　　1.6.1 创建对象

　　　　1.6.2 属性

　　　　1.6.3 方法

　　　　1.6.4 消息

　　　　　　消息是对象之间的通信机制.例如,当对象A调用了对象B的一个方法,对象A向对象B发送了一个消息.

　　1.7 使用类图作为可视化工具

　　1.8 封装和数据隐藏

　　　　1.8.1 接口

　　　　　　在大多数面向对象的语言中,访问修饰符指定为public的方法属于接口

　　　　1.8.2 实现

　　　　　　只有公共属性和方法被认为是接口

　　　　1.8.3 接口/实现范式的一个真实示例

　　　　1.8.4 接口/实现范式的模型

　　1.9 继承 (is-a)

　　　　1.9.1 超类和子类

　　　　1.9.2 抽象

　　　　1.9.3 is-a关系

　　1.10 多态

　　　　尽管多态与继承是紧耦合的关系,但它通常单独作为面向对象技术中最强大的优点之一.

　　　　重载(overriding)的基本释义是子类覆盖父类中的一个实现

　　1.11 组合 (has-a)

　　　　使用其他对象来构建或结合成新的对象,这种方式就是组合

　　　　1.11.1 抽象

　　　　1.11.2 has-a关系

　　1.12 结语

　　1.13 本章中使用的示例代码

　　　　1.13.1 C#.NET版本的TestPerson类

　　　　1.13.2 TestShape类

第2章 如何以面向对象的方式进行思考 (已看)

　　2.1 清楚接口和实现之间的区别

　　　　2.1.1 接口

　　　　　　作为一个通用的规则,一个类的接口应该只包含需要用户知道的东西

　　　　2.1.2 实现

　　　　　　实现细节对于用户是隐藏的,我们必须时刻牢记关于实现的一个目标,那就是修改实现不需要变动用户代码

　　　　2.1.3 一个接口/实现示例

　　　　　　最小接口

　　　　　　　　在极限情况下,保证最小接口是刚开始不给用户提供任何公共接口,当然,这样的类是无用的.

　　　　　　　　然而,这强制用户主动找你说:"我需要这个功能".然后你们可以协商,这样保证你只在需要的情况下增加接口,绝不要假设用户需要什么东西

　　　　　　对象持久化

　　　　　　　　对象持久化,意思即保存对象的状态以便稍后可以恢复和使用,因为没有持久化的对象在其生命周期之外就会被销毁掉.

　　　　　　　　例如,对象的状态可以保存在数据库中

　　2.2 使用抽象思维设计接口

　　2.3 尽可能提供最小化的用户接口

　　　　2.3.1 确定用户

　　　　2.3.2 对象行为

　　　　2.3.3 环境约束

　　　　2.3.4 识别公共接口

　　　　2.3.5 识别实现

　　　　　　接口代表了用户如何看待对象,实现则是对象的具体细节.实现包含了代表对象状态的代码

　　2.4 结语

　　2.5 引用

第3章 高级的面向对象概念 (已看)

　　3.1 构造函数

　　　　3.1.1 什么是构造函数调用

　　　　3.1.2 构造函数中包含什么

　　　　3.1.3 默认构造函数

　　　　3.1.4 使用多个构造函数

　　　　　　方法签名可能包含返回值类型,也可能不包含返回值类型,这取决于不同的语言.

　　　　3.1.5 设计构造函数

　　3.2 错误处理

　　　　3.2.1 忽略问题

　　　　3.2.2 检查问题并中止应用程序

　　　　3.2.3 检查问题并试图恢复

　　　　3.2.4 抛出异常

　　3.3 作用域的重要性

　　　　3.3.1 局部属性

　　　　3.3.2 对象属性

　　　　3.3.3 类属性

　　3.4 操作符重载

　　3.5 多重继承

　　3.6 对象操作

　　　　深拷贝和浅拷贝

　　　　　　追踪所有的引用,并对所有引用对象都创建拷贝,这种方式称为深拷贝.深拷贝会拥有很多层级.

　　　　　　一个对象引用了很多对象,而这些被引用的对象也可能引用其他对象.拷贝本身开销巨大.

　　　　　　浅拷贝只会简单地拷贝引用,而不会深入层级

　　3.7 结语

　　3.8 引用

　　3.9 本章中使用的示例代码

第4章 类剖析 (已看)

　　4.1 类名

　　4.2 注释

　　4.3 属性

　　4.4 构造函数

　　4.5 访问器

　　4.6 公共接口方法

　　4.7 私有实现方法

　　4.8 结语

　　4.9 引用

　　4.10 本章中使用的示例代码

第5章 类设计指导 (已看)

　　5.1 对现实世界系统建模

　　　　对现实世界系统建模

　　　　　　面向对象编程的主要目标是按照人们实际所想的相似方式对现实世界系统建模.

　　　　　　以面向对象的方式设计类来创建这些模型.

　　　　　　使用过程化或自上而下的方式时,数据和行为在逻辑上是分离的实体

　　　　　　而面向对象的方式把数据和行为封装到可以相互交互的对象里.

　　　　　　我们处理问题时不会再以一系列事件或者程序来操作独立的数据文件.

　　　　　　原因在于类真正代表了现实世界的对象的模型,而且展示了这些对象如何与现实世界中其他的对象交互

　　5.2 识别公共接口

　　　　5.2.1 最小化公共接口

　　　　5.2.2 隐藏实现

　　5.3 设计健壮的构造函数(以及析构函数)

　　5.4 在类中设计错误处理

　　　　5.4.1 使用注释给类加上文档

　　　　5.4.2 构造可以合作的对象

　　　　　　我们可以放心地说,几乎没有完全隔离的类.几乎没有任何原因来构建一个需要与其他类交互的类。

　　　　　　这是基于类生命周期中的一个事实.即类将服务其他类,它也会请求其他类的服务　

　　5.5 设计时请考虑重用

　　5.6 设计时请考虑扩展性

　　　　5.6.1 使用描述性的名称

　　　　5.6.2 抽象不可移植的代码

　　　　5.6.3 提供一种方式来复制和比较对象

　　　　5.6.4 保持尽可能小的作用域

　　　　5.6.5 类的职责与自身高度相关

　　5.7 设计时请考虑可维护性

　　　　高度耦合的类

　　　　　　高度依赖其他类的行为被称为高度耦合.即如果修改一个类会强迫修改另一个类,那么这两个类则可以说是高度耦合的.

　　　　　　没有这样依赖的类则拥有低级别的耦合

　　　　5.7.1 在开发过程中使用迭代

　　　　5.7.2 测试接口

　　5.8 使用对象持久化

　　5.9 结语

　　5.10 引用

　　5.11 本章中使用的示例代码

第6章 使用对象进行设计 (已看)

　　系统可以被定义为相互交互的类

　　6.1 设计指导

　　　　6.1.1 提供正确的分析

　　　　6.1.2 编写工作陈述文档

　　　　6.1.3 收集需求

　　　　6.1.4 开发用户接口的原型

　　　　6.1.5 识别类

　　　　6.1.6 确定每个类的职责

　　　　6.1.7 确定类之间如何协作

　　　　6.1.8 创建类模型来描述系统

　　　　6.1.9 建立用户接口原型

　　6.2 对象包装

　　　　6.2.1 结构化代码

　　　　6.2.2 包装结构化代码

　　　　6.2.3 包装不可移植的代码

　　　　6.2.4 包装已有类

　　6.3 结语

　　6.4 引用

第7章 精通继承和组合 (已看)

　　7.1 重用对象

　　7.2 继承

　　　　7.2.1 通用和特例

　　　　7.2.2 设计决策

　　7.3 组合

　　　　一个特定的对象由其他对象组合而成,而且这些对象被作为对象属性,那么这个新的对象被称为混合(或者聚合,或者综合)对象

　　7.4 为什么封装是面向对象的本质

　　　　7.4.1 继承如何减弱封装

　　　　7.4.2 关于多态的一个具体例子

　　　　7.4.3 对象职责

　　　　7.4.4 抽象类,虚方法和协议

　　7.5 结语

　　7.6 引用

　　7.7 本章中使用的示例代码

第8章 框架和重用:使用接口和抽象类进行设计 (已看)

　　8.1 代码:重用还是不重用

　　8.2 什么是框架

　　8.3 什么是契约

　　　　8.3.1 抽象类

　　　　8.3.2 接口

　　　　8.3.3 综合运用

　　　　8.3.4 编译器佐证

　　　　8.3.5 创建契约

　　　　8.3.6 系统插接点

　　8.4 一个电子商务示例

　　　　8.4.1 一个电子商务问题

　　　　8.4.2 非重用方式

　　　　8.4.3 电子商务解决方案

　　　　8.4.4 UML对象模型

　　8.5 结语

　　8.6 引用

　　8.7 本章中使用的示例代码

第9章 创建对象及面向对象设计 (已看)

　　9.1 组合关系

　　　　使用组合的原因是通过组合可以降低构建系统的复杂性.这是人们解决问题的通用方式.

　　9.2 分阶段构建

　　9.3 组合类型

　　　　9.3.1 聚合

　　　　9.3.2 联合

　　　　9.3.3 同时使用联合和聚合

　　　　　　没有绝对答案

　　　　　　　　事实上,进行设计决策事并不一定有一个绝对正确的答案.设计并不是一门精密的科学.

　　　　　　　　不过我们可以使用一些通用规则,这些规则不难使用,而且能帮助我们快速开始.

　　9.4 避免依赖

　　9.5 基数

　　　　9.5.1 多个对象联合

　　　　9.5.2 可选的联合

　　9.6 一个综合性示例

　　9.7 结语

　　9.8 引用

第10章 创建对象模型 (已看)

　　10.1 什么是UML

　　10.2 类图结构

　　10.3 属性和方法

　　　　10.3.1 属性

　　　　10.3.2 方法

　　10.4 访问符号

　　10.5 继承

　　10.6 接口

　　10.7 组合

　　　　10.7.1 聚合

　　　　10.7.2 联合

　　10.8 基数

　　10.9 结语

　　10.10 引用

第11章 对象和可移植数据:XML和JSON (已看)

　　11.1 可移植数据

　　11.2 XML

　　11.3 XML与HTML

　　11.4 XML和面向对象的语言

　　11.5 在企业间共享数据

　　11.6 使用DTD验证文档

　　11.7 将DTD集成到XML文档中

　　11.8 使用层叠样式表

　　11.9 JavaScript对象标记

　　11.10 结语

　　11.11 引用

第12章 持久化对象:序列化,封送和关系型数据库 (已看)

　　12.1 持久化对象基础

　　12.2 将对象保存到平面文件中

　　　　12.2.1 序列化文件

　　　　12.2.2 再次讨论实现接口

　　　　12.2.3 为什么不保存方法

　　12.3 序列化过程中使用XML

　　12.4 写入关系型数据库

　　12.5 结语

　　12.6 引用

　　12.7 本章中使用的示例代码

第13章 Web服务,移动应用及混合应用中的对象 (已看)

　　13.1 分布式计算的演进

　　13.2 基于对象的脚本语言

　　13.3 JavaScript验证示例

　　13.4 网页中的对象

　　　　13.4.1 JavaScript对象

　　　　13.4.2 网页控制器

　　　　13.4.3 声音播放器

　　　　13.4.4 电影播放器

　　　　13.4.5 Flash动画

　　13.5 分布式对象及企业

　　　　13.5.1 公共对象请求代理体系结构

　　　　13.5.2 Web服务的定义

　　　　13.5.3 Web服务代码

　　　　13.5.4 表征状态转移

　　13.6 结语

　　13.7 引用

第14章 对象及客户端/服务端应用程序 (已看)

　　14.1 客户端/服务器端方式

　　14.2 私有方式

　　　　14.2.1 序列化对象代码

　　　　14.2.2 客户端代码

　　　　14.2.3 服务器端代码

　　　　14.2.4 运行该私有的客户端/服务器端示例

　　14.3 非私有方式

　　　　14.3.1 对象定义代码

　　　　14.3.2 客户端代码

　　　　14.3.3 服务器端代码

　　　　14.4.4 运行非私有客户端/服务器端示例

　　14.4 结语

　　14.5 引用

　　14.6 本章中使用的示例代码

第15章 设计模式 (已看)

　　15.1 为什么使用设计模式

　　15.2 Smalltalk的模型/视图/控制器

　　15.3 设计模式类型

　　　　创建型模式　　帮你创建对象,你无需直接实例化对象.你可以根据给定的条件创建对象.这给程序带来更大的灵活性

　　　　结构型模式　　将一组对象组合成更复杂的结构,比如复杂的用户接口或者账单数据

　　　　行为型模式　　定义系统中对象之间的通信方式,控制复杂程序中的流向

　　　　15.3.1 创建型模式

　　　　15.3.2 结构型模式

　　　　15.3.3 行为型模式

　　15.4 反模式

　　15.5 结语

　　15.6 引用

　　15.7 本章中使用的示例代码

转载于:https://www.cnblogs.com/revoid/p/9418306.html