Java编程思想（一）--对象导论

抽象发展过程：

汇编语言，是对底层机器语言的轻微抽象。

命令式语言（如c），对汇编语言的抽象

早期编程语言（如LISP，APL），对待解决问题进行建模

面向对象的语言，通过建立与问题相对应的对象来解决问题。

 

第一个成功的面向对象语言（smalltalk）的基本特性：

1、万物皆对象。即，每个事物都有属性和作用。事物可以定义为类，属性可以定义为类中的变量，作用可以定义为类中的方法。

2、程序是对象的集合，他们通过发送消息（调用方法）来告知彼此要做什么。

3、每个对象都有自己的由其他对象所构成的存储。即，每个对象可以包含其他对象的引用，形成组合。

4、每个对象都拥有其类型。一个类就是一种数据类型。对象是类的实例，一种数据类型的实例。一个类就是一种数据类型

5、同一特定类型的所有对象都可以接受同样的消息。

 

什么是类：

类是一种数据类型，是对实际事物的抽象。通过这种方式，我们可以不用局限于基本数据类型，而创造我们想要的类型来适应问题。这可以帮助我们把复杂问题简单化，让我们的程序更易（被人）理解。

类的实现：

光定义数据类型还不够，还需要实现它（创建一个实例，即对象）。就“像”你定义了一个int类型，但你不能直接使用int写程序，你需要实现int，即定义inta = 1；而你能使用的就是这个a（实例），而不是int。

 

而一个类不只有变量（属性），还有方法（行为）。而这些方法是由对象的接口（interface）定义的。

 

在进行程序设计或读程序时，最好将对象当成服务提供者。

第一，这样可以更好的让你对事物进行抽象，软件提供服务，而对象给软件提供服务。

第二，可以提高对象的内聚性，即高度相关的事物都在同一对象中。低耦合，高内聚是程序设计的基本质量要求。

 

为什么要隐藏具体实现？

就好比int，你不需要关心它是如何实现的，你只需要使用它。

防止类被修改，从而导致出现bug。

类创建者只需要在保持接口功能不变的情况下，修改类的实现。

 

由此出现了访问控制：

private：只允许在该类的内部使用，其他都不可用，甚至是子类。

public：对任何人可用。

protect：只对该类和该类的子类的内部使用。

default：若不加修饰符，则是该类型，代表只在该包内可用。

 

类的复用：

1、创建实例。

2、使用组合，即在一个类中包含其他类的引用。（应该首先考虑组合）

3、使用继承。

 

继承的由来：

在创建一个类之后，如果有一个新的类与这个类相似，那么我们就需要重新创建一遍。然而，如果我们能够把相同的部分提取出来，新建一个类，然后这两个类继承这个提取出来的类，即拥有基类的所有成员和接口。提取出来的类就是基类（父类），继承出来的类就是导出类（子类）。

 

向上转型：子类转为父类

向下转型：父类转为子类

 

基类和导出类往往会有差异，可以有两种方法来实现这种差异

1、在导出类中添加新方法。子类与父类之间的关系：is like a 关系

2、重写基类的方法--覆盖。子类与父类之间的关系：is a关系

 

什么是多态：

即将子类当成父类看待，向上转型。例如父类是几何形，子类是圆形，那么就是把圆形当成几何形来用。

为什么要多态：

在使用多态后，我们可以写出不依赖特定类型的代码。例如，我们只需关心几何形的接口，如绘制。而不需要关心其子类圆形的具体实现。如果我们还有其他几何形，那么我们只需要继承几何形这个父类，然后重写方法。大大提高了软件的可扩展性。

实现多态的问题：

如果要调用泛化的基类的方法，那么在编译期间，编译器是不知道应该执行哪段代码的。

例如几何形中有这样一个方法

void doSomething(Shape shape) {

shape.create();

}

编译器期望的编译结果是调用父类Shape的create()方法。然而实际上可能传过来的是子类圆形，希望调用的是圆形的create()方法。

以前的编译器的编译模式：

前期绑定：即在编译期间就确定所要调用的方法。

Java所采用的的编译模式：

后期绑定（动态绑定）：在程序调用这个方法时才会真正确定是哪个方法。

 

Java采用单一继承结构

所有对象都有一个共用接口，都可以算是相同的基本类型。

都具备某些功能，比如说可以被垃圾收集装置收集，比如说反射。

 

为什么要有容器：

在实际中我们往往一开始不知道有多少个对象（运行时才会知道），这样我们就不能创建出定长的数组。这就需要一个随时可以改变大小的容器。

容器为什么有这么多种：

不同的容器有不同的作用与特性。使用于不同的场合。

 

什么是泛型：

List<Shape> list = newArrayList<Shape>();

这个<...>就是泛型。通过泛型我们可以指定容器只能装取Shape类型的对象。

为什么要有泛型：

在泛型出现之前，容器中装的都是Object类型。由于所有对象都是Object的子类，所以都可以放入容器中。然而在取出容器后，需要对Object进行向下转型才能获得我们存进容器的类型。

而除非我们知道所要转型的类型，向下转型几乎是不安全的。我们必须记住我们存进容器时的类型。

向下转型和运行时的检查需要额外的程序运行时间，也需要程序员付出更多的心血。

因此，泛型出现了。

 

Java如何创建对象：

Java把内存分为

heap（堆）：存放new出来的对象

stack（栈）：存放局部变量

data segment（静态变量区）：存放static（静态）变量

code segment（代码区）：存放代码

Java在heap（堆）中动态创建对象。即，直到运行时才知道需要多少对象，他们的生命周期，具体类型。

然而这样就会有一个问题：即编译器不会知道对象的生命周期，不能手动释放内存。所以Java使用了垃圾收集机制，即自动的处理内存释放问题。这是建立在单根继承Object和只能在heap（堆）上建立对象的基础上的。

 

异常处理：

专门用来处理错误的一种机制，必须处理。Java内建异常处理。异常处理相当于程序有两条线，一条是正常线，一条是异常线。当异常发生时，程序就会从主线跳至异常线。所以异常线不会对主线产生影响。

 

并发编程：

人们经常想要程序在同一时刻处理多个任务。即程序能够停下当前任务，执行其他任务，其他任务执行完成后再回到原先任务中。

在早期，程序员利用底层硬件知识，中断来编写这样的程序。但这种做法难度大，而且不同机器底层不同，不易移植。

但我们大部分时候都只是想同时运行多个的程序，从而提高程序的响应能力。在程序中，这些彼此独立运行的部分称为线程，上述概念称为“并发”。

但是使用线程会产生一个问题，即，共享资源可能会被多个同时运行的线程所修改，从而产生数据错误。