Java编程思想笔记——对象入门

抽象过程

所有编程语言的最终目的都是提供一种“抽象”方法。

汇编语言

汇编语言是对基础机器的少量抽象。

“命令式”语言

“命令式”语言（如FORTRAN，BASIC 和 C）是对汇编语言的一种抽象。但抽象原理依然要求我们着重考虑计算机的结构，而非考虑问题本身的结构。

为要解决的问题制作模型

世界的某些特定视图

LISP：所有问题最终都是列表
APL：所有问题最终都是算法形式的
PROLOG ：所有问题都归纳为决策链
这些语言，我们认为它们一部分是面向基于“强制”的编程，另一部分则是专为处理图形符号设计的，不能解决问题。

面向对象编程

表达问题空间内的元素，不必受限于特定类型的问题。
“对象”（Object）：问题空间中的元素以及它们在方案空间的表示物，与现实世界的“对象”或者“物体”相比，编程“对象”与它们也存在共通的地方：它们都有自己的特征和行为。

Smalltalk(公认的第二个面向对象编程语言)作者提出的“纯粹”的面向对象程序设计方法:
(1) 万物皆对象。
(2) 程序是对象的集合，他们通过发送消息来告知彼此所要做的事。
(3) 每个对象都有自己的存储空间，可容纳其他对象。
(4) 每个对象都有一种类型。
(5) 同一类所有对象都能接收相同的消息。

每个对象一个接口

类

亚里士多德或许是认真研究“类型”概念的第一人，他曾谈及“鱼类和鸟类”的问题。在世界首例面向对象语言Simula-67 中，第一次用到了这样的一个概念：
所有对象——尽管各有特色——都属于某一系列对象的一部分，这些对象具有通用的特征和行为。在Simula-67 中，首次用到了class 这个关键字，它为程序引入了一个全新的类型（class 和 type 通常可互换使用)。

在计算机程序中，能用独一无二的实体分别表示“银行出纳员”这样的经典问题中的出纳员、客户、帐号以及交易，这个实体便是“对象”，而且每个对象都隶属一个特定的“类”，那个类具有自己的通用特征与行为。

问题空间的元素和解空间的对象创建一一对应的映射。

接口

每个对象仅能接受特定的请求。我们向对象发出的请求是通过它的“接口”（Interface）“定义的，对象的“类型”或“类”则规定了它的接口形式。“类型”与“接口”的等价或对应关系是面向对象程序设计的基础。

每个对象都提供服务

“接口”（Interface）规定了可对一个特定的对象发出哪些请求。把对象想象成“服务提供者”，提高内聚性，不试图做更多的事。

隐藏的实现

访问控制

防止客户程序员接触他们不该接触的东西
允许库设计人员修改内部结构

关键字

关键字	适用范围
public	任何类可用
private	仅自己可以访问
protected	继承的类可以访问
default	同一包下可以访问

复用具体实现

组合

将某个类的一个对象置入一个新类。我们把这叫作“创建一个成员对象”。新类可由任意数量和类型的其他对象构成。无论如何，只要新类达到了设计要求即可。这个概念叫作“组合”——在现有类的基础上组合一个新类，我们也将组合称作“包含”关系。
对象的组合具有极大的灵活性。

继承

编译器对通过继承创建的类加以限制。

继承

在 Java 语言中，继承是通过 extends 关键字实现的使用继承时，相当于创建了一个新类。
将新得的衍生类与原来的基础类区分开的两种做法：
1.为衍生类添加新函数（功能）
2.改变基础类一个现有函数，我们将其称作 “覆盖”(overriding)那个函数，目标是：“尽管使用的函数接口未变，
但它的新版本具有不同的表现”。

“是一个”与“像一个”的关系

“是一个”

继承只改善原基础类的函数，衍生类型就是与基础类完全相同的类型，因为都拥有完全相同的接口，完全能够将衍生类的一个对象换成基础类的一个对象，可将其想象成一种“纯替换”

“像一个”

为衍生类型加入新的接口元素

伴随多态的可互换对象

我们将常喜欢把一个对象不当作它所属的特定类型来对待，而是将其当作基础类的一个对象对待，令其忽略类型的特定细节，只与基础类打交道，可以编写出不依赖于特定类型的代码。
通过继承增添了一种新类型，新类型编写的代码会象在旧类型里一样良好地工作。所以说程序具备了“扩展能力”，具有“扩展性”。

函数调用

编译器不可能产生传统意义上的函数调用。
前期绑定：一个非面向对象编程的编译器产生的函数调用，编译器将产生对一个具体函数名字的调用，而运行时将这个调用解析到将要被执行的代码的绝对地址。
后期绑定：当对象发送消息时，被调用的代码直到运行时才能确定。编译器要确保被调用方法存在，并对调用参数和返回值执行类型检查。java使用一小段特殊代码使用在对象中存储的信息来计算方法体中的地址。

java中动态绑定是默认的，不需要使用其他关键来实现多态，c++需要virtual关键字。

public class Shape {
    public void draw(){
        System.out.println("drawing......");
    }
}

public class Circle extends Shape{
    @Override
    public void draw(){
        System.out.println("circle drawing......");
    }
}

public class Triangle extends Shape{
    @Override
    public void draw(){
        System.out.println("triangle drawing......");
    }
}

public class Line extends Shape{
    @Override
    public void draw(){
        System.out.println("line drawing......");
    }
}

public class Test {
    public static void main(String agrs[]){
        Circle circle = new Circle();
        Triangle triangle = new Triangle();
        Line line = new Line();
        doSomething(circle);
        doSomething(triangle);
        doSomething(line);
    }
    private static void doSomething(Shape shape){
        shape.draw();
    }
}

结果：
circle drawing……
triangle drawing……
line drawing……

由于Circle可以被doSomething看作是Shape，也就是说，doSomething发送给Shape任何消息，也都能被Circle接收到。将导出类看作是它基类的过程叫做向上转型（upcasting）。

单根继承结构

在Java(事实上还包括除了c++以外的所有OOP语言)中，所有类最终都继承自单一的基类Object。
单根继承有以下几点好处：
1.保证所有对象都具备某些功能
2.极大简化参数传递
3.容易实现垃圾回收

容器

容器：在任何需要时都可以扩充自己以容纳你置于其中的所有东西，因此不需要知道将来会把多少个对象置于容器中，只需要创建一个容器对象，然后让它处理所有细节。
List：存储序列
Map：关联数组
Set：集合

从设计角度来看，单一容器类别可以满足所有需求，则不需要设计不同种类的序列。然而还是需要对容器有所选择：
1.不同类型的容器提供不同类型的接口和外部行为
2.不同的容器对于某些操作具有不同的效率

泛型

容器的存储对象都只具有Java中的通用类型：Object。
当向容器存储对象时，对象向上转型为Object，丢失其身份，向上转型是安全的。
当从容器中取回对象时，会用到向下转型，所以除非确切的知道所要处理的对象的类型，否则向下转型几乎是不安全的。
那么创建一个知道自己所保存的对象的类型的容器，从而不需要向下转型以及消除犯错误的可能，这种解决方案被称为参数化类型机制，在Java中称为泛型。

对象的创建和生命周期

C++追求最大的执行速度，对象的存储空间和生命周期可以在编写程序时确定，对象置于堆栈或静态存储区域中。
Java则存储在堆的内存池中，因为存储空间是在运行时被动态管理的，所以需要大量的时间在堆中分配存储空间，这可能远远大于在堆栈中创建存储空间的时间。
逻辑假设：
对象趋向于变得复杂，所以查找和释放存储空间的开销不会对对象的创建造成重大冲击。动态方式多带来的更大的灵活性正是解决一般化编程问题的要点所在。
Java完全采用了动态内存分配方式，使用new关键字来创建对象的动态实例。

垃圾回收器

自动发现对象何时不再被使用，并继而销毁它，减少了所必须考虑的议题和必须编写的代码。垃圾回收器提供了更高层的保障，可以避免暗藏的内存泄漏问题。
Java的垃圾回收器被设计用来处理内存释放问题，垃圾回收器知道对象何时不被使用，并自动释放对象占用的内存。

异常处理：处理错误

异常处理将错误处理直接置于编程语言中，有时甚至置于操作系统中。
“抛出”“捕获”
异常提供了一种从错误状况进行可靠恢复的途径，不在只是退出程序，我们可以经常进行校正，并恢复程序的执行，这些都有助于编写出更健壮的程序。
Java内置了异常处理，并且强制使用，是唯一可接受的错误报告方式。