第一章对象引论

 

1:抽象过程        

       所有编程语言都提供抽象机制。(abstraction)
       (我认为任何语言都有这种特性。只可言传不可意会的语境或文明与精神....)
       目的是解决问题：
       取决于抽象的类型和质量。
       Imperative：命令式：
       还要基于计算机的结构，而不是基于你要试图要解决的问题的结构来考量。
       Machine Model-----Problem Model
       两者之间建立mapping。最后形成软件。
       solution space 内 machine model 
       problem space 内 problem model

       Object-oriented approach.:
       程序可以通过添加新类型的对象是自身适用与某个特定问题。
       都具有：Characteristic and behavior.
       smalltalk：
       1:万物皆是对象。(every is object)
       2:程序是对象的集合，他们彼此通过发送消息来调用对方。
       3:每个对象都拥有由其他对象所构成的存储。
       4:每个对象都拥有其类型(Type)
       5:某个特定类型的所有对象都可以接受(Receive)同样的信息。
       具体分析：
        (1): every is object
        (2): send message for start.
        (3): 
        (4): type。每个类中最重要的区别与其他类的特性就是“你可以发送

       什么消息给他”
        (5): for example:
        circle extends shape:
        所以一个circle对象一定能accept发送给shape对象的消息。 

       可替代性：substitutability

        对象就拥有：state ， behaviour ， Identity（标识）。
        每个对象在内存中都有一个唯一的地址。(具有局限性)
2:每个对象都有一个接口

每个对象都有一个接口
The class of fishes and class of birds .
所有的对象都是唯一的，但同时也是具有相同的特性和行为的对象所归属的类的一部分。
创建抽象数据类型(类)是面向对象程序设计的基本概念之一。
创建对象---发送请求---执行请求。
Type equal class。
一个特殊的概念：
entity class：
 每个对象都属于定义了特性和行为的某个特定的类。

类的定义：
具有相同特性(数据元素)和行为(功能)的对象集合，那么一个类就确实是一个数据类型，就像所有浮点型数字具有相同特性和行为集合一样。
区别：
 程序员通过定义类来适应问题，而不在被强制只能使用现有的被设计用来表示在机器中的存储单元的数据类型。因此做到了扩展性。
Type-checking。
3:每个对象都提供服务

将对象想象成 Service Provider
 最好是在现有代码库中寻找能够提供理想的服务来解决问题的对象集合。
****************************************************
将问题分解为对象集合的一种合理方式。
3 questions：
 对于那些不存在的对象，他们看起来怎么样？
 他们能够提供哪些服务？
 他们需要哪些对象才能履行他们的义务？
advantage：
1：cohesiveness---高内聚
2：fit together

实现方法：
三个或多个类来实现
1：接口
2：实现接口的类
3：调用1和2完成服务。
4:被隐藏的具体实现

(1): class creator     : 创建新数据类型的程序员
 创建类，只向client programmer 暴露必须得部分。
  减少bug(乱操作)
(2): client programmer  : rapid application development

1：访问控制的第一个存在原因就是让客户端程序员无法触及他们不应该触及的部分，并让人能更容易快速的的看懂。
2：访问控制的第二个存在原因就是允许类库设计者可以改变类内部的工作方式而不用担心是否会影响到客户端程序员。

access specifier:访问指定词
 同一个类中|同一包中 |子孙类中 |其他包
private       R |     W |     W |     W  
protect       R |      R |      R |     W 
default       R |      R |     W |     W
public       R |      R |      R |      R

protected 的使用 ，继承后不能直接使用。
inheritance：
inheriting class：
5:复用具体实现

复用性：reusability
组合：composition
聚合：aggregation
在使用现有的类合成新的类，成为composition，如果composition是动态发生的，那么它被称为aggregation。
composition经常被视为：has-a关系。
for example:
The car has a engine。
The airplane has a wing.
6:继承：复用接口
 is - a or is - like - a

base class , super class , parent class发生变动时，被修改的“副本”(被称为导出类(derived class)，继承类(inherited class)或子类(subclass ，child class))也会反映出这些变动。

类型不仅仅只是描述了作用于一个对象集合之上的约束条件，同时还有与其他类型之间的关系。
两个类型可以有相同的特性和行为，但是其中一个类型可能比另一个含有更多的特性，并且可以处理更多的信息(或一不同的方式来处理信息)。
一个基类包含其所有导出类共享的特性和行为。你可以创建一个基类来表示系统中某些对象的核心概念，从积累中导出其他的类，来表示此核心可以被实现的各种不同方式。

垃圾回收机
trash-recycling machine
type hierarchy 类型层次结构。
基类是shape，可以导出具体的几何形状--例如：圆，正方形，三角形等

type equivalence:类型等价。
通过继承而产生的type equivalence。
由于基类和导出类具有相同的基础接口，所有伴随接口的必定有某些具体实现。

有两种方法可以使基类与导出类产生差异。
第一种方法非常直接：直接在导出类中添加新方法。
*
扩展接口并创建新的类型。这种替代并不完美，因为基类无法访问你新添加的方法。
可以描述为：is like a 的关系新类型具有旧类型的接口，但还有其他方法。
第二种方法是导出类和基类之间产生差异的方法是改变现有基类的方法的行为。overriding
*
for example:
此时我正在使用相同的接口方法，但是我想在新类型中做些不同的事情。
纯粹替代：pure substitution：你可以用一个导出类对象来完全替代一个基类对象。
替代法则：substitution principle
以上情况下的基类与导出类之间的关系称为“is a”关系。
例如：“一个圆形就是一个集合形状” the circle is a shape
用这个来判断是否是继承。
7:伴随多态的可互换对象
 抽象基类和接口

type hierarchy
不受新类型的影响。

编译器原理：(oop)
non-oop编译器产生的函数调用会引起所谓的early binding
linker(链接器)将这个(一个具体函数名字的调用)解析到将要被执行代码的绝对地址(absolute address)。在OOP种，程序知道运行时刻才能够确定代码的地址，所以当消息发送到一个泛化对象是，必须要采用其他的机制。
为了解决这个问题，面向对象设计语言使用了"后期绑定(late binding)"的概念。当你向对象发送信息时，被调用的代码直到运行时刻才能被确定。编译器确保被调用方法存在，并对调用参数(argument)和返回值(return value)执行类型检查(无法提供此类保证的语言被称为是弱类型的weakly typed)，但是并不知道将会执行的确切代码。
       为了执行后期绑定，java使用一小段特殊的代码来替代绝对地址调用。这段代码使用在对象种存储的信息来计算方法体的地址。这样，根据这一小段代码的内容，每一个对象都可以具有不同的行为表现。
在java中，动态绑定是缺省行为，你不需要添加额外的关键字来实现多态(polymorphism)

向上转型(upcasting)：
 继承图：基类在顶部，而导出类在下部散开。
 向上转型就是在继承图中向上移动。
anonymous:匿名
********************************|*
多态：向上转型(多态)的如何去做。 |*
********************************|*
抽象基类和接口
interface：它提供了接口与实现的完美分离。不能继承类或抽象类。
abstract class：
可以认为interface是abstract class的特殊情况。
public abstract ：interface会默认添加，但abstract class不能只能自己去添加abstract 。
接口只能继承接口。并且能多个继承。唯一的一种。

8:对象的创建，使用和生命周期。
    集合(collection)与迭代器(iterator)
从技术讲：OOP只是涉及抽象数据类型，继承和多态。

对象最重要的一个要素就是他们的生成和销毁。
对象的数据位于何处？
(1):这种方式将存储空间分配和释放置于优先考虑的位置。追求最大的执行速度。对象的存      储空间和生命周期可以可以在编写程序中确定，这可以将对象放置于堆栈(automatic      variable or scoped variable )或静态存储区域内来实现。（感觉十分受限制。）
(2):第二种是在heap的内存池中动态的创建对象。在这种方式中，你只有在运行中才知道需要多少个对象。对象的生命周期如何？对象的具体类型是什么？只有在这个时刻才能确定。
java完全采用第二种方式：使用new 关键字来构建此对象的动态实例。

怎样控制对象的生命周期？
 对于可以允许在堆栈上创建对象的语言，编译器可以确定对象存活的时间有多久，并可以自动销毁它。
 然而在heap上创建对象，因为有 Gc所以使用变得简单。
***********************
动态方式的逻辑假设: 对象趋向与变得复杂，所以在查找和释放存储空间的开销不会对对象造成重大冲击。
****************************************************************************
如果不知道需要多少个对象，或存活多久，如何解决使用问题？
答：创建另一种对象的类型。解决这个特定问题的新的对象类型持有对其他对象的引用。
就是用容器container或集合collection来实现。（生命周期也变得可控：删除（销毁），添加（创建），修改（改变））。
 只需要创建一个容器对象，然后让他处理所有细节。
list map set queue tree stack and so on.

容器的缺点：single-selection受限。
question1：如果你想操作或是比较容器种的一组元素时，用什么方式来替代single-selection呢。
解决方案是iterator。
iterator：他是一个用来选取容器中的元素，并将它呈现给iterator用的对象。
 容器通过iterator被抽象为仅仅是一个序列(sequence ).
question2：有两个原因使得你需要对容器有所选择？
 1：不同容器提供了不同类型的接口和外部类。
 2：不同的容器对于某些操作具有不同的效率。
for example：
 linkedList和ArrayList区别？
ArrayList中随机访问元素时一个固定时间的操作，
LinkedList选取元素需要在列表中移动，其代价是高昂的，越到最后越慢。

9:单根继承结构

所有的类最终都继承自单一的基类：这个终极基类的名字是：Object。
即所有的对象都具有一个共同的接口。
优点：
保证所有的对象都具有某些功能。
单根继承结构以及heap上创建所有对象，极大地简化参数传递。
所有对象都保具有运行时刻类型信息run time type ingormation，不会因无法确定对象的类型而陷入僵局。（对异常处理有好处）
why?
GC的支持功能可以置于基类，这样就可以发送恰当的消息给系统中的每一个对象。

10:向下转型(downcasting)与模板/泛型(template/generic)

单根继承结构意味着所有anything is object。所以可以存储Object的容器可以存储任何东西。
因为容器只存储Object，所以将object reference置于容器时，必须被upcasting向上转型为Object,所以他会丢失其身份type。当你取回时，你获取了一个对Object对象的应用，而不是对你置于时的那个类型对象的引用。所以需要再度转型downcasting。
downcasting的原理以及方法：
      当你从容器中取出对象引用object reference是=时，还要必须要有某种方式来记住这些他们究竟是什么类型，这样你才能执行正确的向下转型downcasting。
      解决方案：创建知道自己所保存对象的类型的容器(parameterized type)机制。从而消除向下转型的需求和犯错误的可能。for example: templategeneric泛型，只接纳取出定类型的对象的容器。
11:确保正确清除

GC被设计用来处理内存释放问题(不包括清楚对象的其他方面)。
12:垃圾回收与效率和灵活性

为编程的方便付出代价，这个代价就是运行时刻的开销。
java程序的执行速度会有前后不一致的情况。（不适合为实时程序）
原因：堆heap上创建对象，单根继承结构。
13:异常处理：处理错误

以往处理方式：
1：忽略此问题。
异常是一个对象，
异常处理就像是与程序正常执行路径并行的，在错误发生时执行的另一条路径。
并且是完全分离的执行路径，所以他不会干扰正常的执行代码。
被抛出的异常不想方法返回它保证一定会在某处被处理。
*
异常提供了一种从错误状况进行可靠恢复的途径。
异常处理在面向对象语言出现之前就已经存在了。
14:并发(concurrency)

同一时刻处理多个任务的思想。
thread
multithreading
for example:界面。（按下一个按钮，快速得到一个响应）

隐患：共享资源。同时访问同一块资源。
线程安全：某个线程锁定某项资源，完成其任务，然后释放资源锁，是其他线程可以使用这项资源。（）
创建一个表示锁的对象，所有线程在访问资源之前先检查这个对象。
synchronized。
我不知道的知识点：可以锁定任何对象所占用的内存（毕竟这也算是某种资源），使得同一时刻只能有一个线程在使用它。
15:持久性

当你创建一个对象之后，只要你需要他，他就一直存活，程序结束时终止。
Persistent ：将对象声明为持久的。
Object serialization 和 object data object来实现。
16:Java与Internet
      Web是什么？
      客户端编程
      服务器端编程

surfing ， presence表现， home page
   client/server
*客户/服务器计算技术。
*核心思想：系统具有一个中央信息存储池(central repository of information)，用来存储某种数据，它通常存在于数据库中，你可以根据需要将它分发给某个及其集群。
*关键在于信息存储池的位置集中于中央，这时的他可以被修改，并且这些修改的信息将传递给消费者。
transaction processing
使用中间件middleware将负载分散给服务器端的其他机器。（中间件也被提高可维护性maintainability）
Web就是一台巨型服务器。
 客户端编程
 服务器端编程
17:java为什么成功。
     系统已于表达，易于理解。
     通过类库得到最大的支持。
     错误处理
     大型程序设计
18:java与C++