java面向对象初学文档.docx

上传人:b****9 文档编号:26127230 上传时间:2023-06-17 格式:DOCX 页数:38 大小:59.36KB
下载 相关 举报
java面向对象初学文档.docx_第1页
第1页 / 共38页
java面向对象初学文档.docx_第2页
第2页 / 共38页
java面向对象初学文档.docx_第3页
第3页 / 共38页
java面向对象初学文档.docx_第4页
第4页 / 共38页
java面向对象初学文档.docx_第5页
第5页 / 共38页
点击查看更多>>
下载资源
资源描述

java面向对象初学文档.docx

《java面向对象初学文档.docx》由会员分享,可在线阅读,更多相关《java面向对象初学文档.docx(38页珍藏版)》请在冰豆网上搜索。

java面向对象初学文档.docx

java面向对象初学文档

-------------------------------------------------

本教程由yyc,spirit整理

-------------------------------------------------

第1章对象入门

“为什么面向对象的编程会在软件开发领域造成如此震憾的影响?

面向对象编程(OOP)具有多方面的吸引力。

对管理人员,它实现了更快和更廉价的开发与维护过程。

对分析与设计人员,建模处理变得更加简单,能生成清晰、易于维护的设计方案。

对程序员,对象模型显得如此高雅和浅显。

此外,面向对象工具以及库的巨大威力使编程成为一项更使人愉悦的任务。

每个人都可从中获益,至少表面如此。

如果说它有缺点,那就是掌握它需付出的代价。

思考对象的时候,需要采用形象思维,而不是程序化的思维。

与程序化设计相比,对象的设计过程更具挑战性——特别是在尝试创建可重复使用(可再生)的对象时。

过去,那些初涉面向对象编程领域的人都必须进行一项令人痛苦的选择:

(1)选择一种诸如Smalltalk的语言,“出师”前必须掌握一个巨型的库。

(2)选择几乎根本没有库的C++(注释①),然后深入学习这种语言,直至能自行编写对象库。

①:

幸运的是,这一情况已有明显改观。

现在有第三方库以及标准的C++库供选用。

事实上,很难很好地设计出对象——从而很难设计好任何东西。

因此,只有数量相当少的“专家”能设计出最好的对象,然后让其他人享用。

对于成功的OOP语言,它们不仅集成了这种语言的语法以及一个编译程序(编译器),而且还有一个成功的开发环境,其中包含设计优良、易于使用的库。

所以,大多数程序员的首要任务就是用现有的对象解决自己的应用问题。

本章的目标就是向大家揭示出面向对象编程的概念,并证明它有多么简单。

本章将向大家解释Java的多项设计思想,并从概念上解释面向对象的程序设计。

但要注意在阅读完本章后,并不能立即编写出全功能的Java程序。

所有详细的说明和示例会在本书的其他章节慢慢道来。

1.1抽象的进步

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

一种较有争议的说法是:

解决问题的复杂程度直接取决于抽象的种类及质量。

这儿的“种类”是指准备对什么进行“抽象”?

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

后来的许多“命令式”语言(如FORTRAN,BASIC和C)是对汇编语言的一种抽象。

与汇编语言相比,这些语言已有了长足的进步,但它们的抽象原理依然要求我们着重考虑计算机的结构,而非考虑问题本身的结构。

在机器模型(位于“方案空间”)与实际解决的问题模型(位于“问题空间”)之间,程序员必须建立起一种联系。

这个过程要求人们付出较大的精力,而且由于它脱离了编程语言本身的范围,造成程序代码很难编写,而且要花较大的代价进行维护。

由此造成的副作用便是一门完善的“编程方法”学科。

为机器建模的另一个方法是为要解决的问题制作模型。

对一些早期语言来说,如LISP和APL,它们的做法是“从不同的角度观察世界”——“所有问题都归纳为列表”或“所有问题都归纳为算法”。

PROLOG则将所有问题都归纳为决策链。

对于这些语言,我们认为它们一部分是面向基于“强制”的编程,另一部分则是专为处理图形符号设计的。

每种方法都有自己特殊的用途,适合解决某一类的问题。

但只要超出了它们力所能及的范围,就会显得非常笨拙。

面向对象的程序设计在此基础上则跨出了一大步,程序员可利用一些工具表达问题空间内的元素。

由于这种表达非常普遍,所以不必受限于特定类型的问题。

我们将问题空间中的元素以及它们在方案空间的表示物称作“对象”(Object)。

当然,还有一些在问题空间没有对应体的其他对象。

通过添加新的对象类型,程序可进行灵活的调整,以便与特定的问题配合。

所以在阅读方案的描述代码时,会读到对问题进行表达的话语。

与我们以前见过的相比,这无疑是一种更加灵活、更加强大的语言抽象方法。

总之,OOP允许我们根据问题来描述问题,而不是根据方案。

然而,仍有一个联系途径回到计算机。

每个对象都类似一台小计算机;它们有自己的状态,而且可要求它们进行特定的操作。

与现实世界的“对象”或者“物体”相比,编程“对象”与它们也存在共通的地方:

它们都有自己的特征和行为。

AlanKay总结了Smalltalk的五大基本特征。

这是第一种成功的面向对象程序设计语言,也是Java的基础语言。

通过这些特征,我们可理解“纯粹”的面向对象程序设计方法是什么样的:

(1)所有东西都是对象。

可将对象想象成一种新型变量;它保存着数据,但可要求它对自身进行操作。

理论上讲,可从要解决的问题身上提出所有概念性的组件,然后在程序中将其表达为一个对象。

(2)程序是一大堆对象的组合;通过消息传递,各对象知道自己该做些什么。

为了向对象发出请求,需向那个对象“发送一条消息”。

更具体地讲,可将消息想象为一个调用请求,它调用的是从属于目标对象的一个子例程或函数。

(3)每个对象都有自己的存储空间,可容纳其他对象。

或者说,通过封装现有对象,可制作出新型对象。

所以,尽管对象的概念非常简单,但在程序中却可达到任意高的复杂程度。

(4)每个对象都有一种类型。

根据语法,每个对象都是某个“类”的一个“实例”。

其中,“类”(Class)是“类型”(Type)的同义词。

一个类最重要的特征就是“能将什么消息发给它?

”。

(5)同一类所有对象都能接收相同的消息。

这实际是别有含义的一种说法,大家不久便能理解。

由于类型为“圆”(Circle)的一个对象也属于类型为“形状”(Shape)的一个对象,所以一个圆完全能接收形状消息。

这意味着可让程序代码统一指挥“形状”,令其自动控制所有符合“形状”描述的对象,其中自然包括“圆”。

这一特性称为对象的“可替换性”,是OOP最重要的概念之一。

一些语言设计者认为面向对象的程序设计本身并不足以方便解决所有形式的程序问题,提倡将不同的方法组合成“多形程序设计语言”(注释②)。

②:

参见TimothyBudd编著的《MultiparadigmProgramminginLeda》,Addison-Wesley1995年出版。

1.2对象的接口

亚里士多德或许是认真研究“类型”概念的第一人,他曾谈及“鱼类和鸟类”的问题。

在世界首例面向对象语言Simula-67中,第一次用到了这样的一个概念:

所有对象——尽管各有特色——都属于某一系列对象的一部分,这些对象具有通用的特征和行为。

在Simula-67中,首次用到了class这个关键字,它为程序引入了一个全新的类型(clas和type通常可互换使用;注释③)。

③:

有些人进行了进一步的区分,他们强调“类型”决定了接口,而“类”是那个接口的一种特殊实现方式。

Simula是一个很好的例子。

正如这个名字所暗示的,它的作用是“模拟”(Simulate)象“银行出纳员”这样的经典问题。

在这个例子里,我们有一系列出纳员、客户、帐号以及交易等。

每类成员(元素)都具有一些通用的特征:

每个帐号都有一定的余额;每名出纳都能接收客户的存款;等等。

与此同时,每个成员都有自己的状态;每个帐号都有不同的余额;每名出纳都有一个名字。

所以在计算机程序中,能用独一无二的实体分别表示出纳员、客户、帐号以及交易。

这个实体便是“对象”,而且每个对象都隶属一个特定的“类”,那个类具有自己的通用特征与行为。

因此,在面向对象的程序设计中,尽管我们真正要做的是新建各种各样的数据“类型”(Type),但几乎所有面向对象的程序设计语言都采用了“class”关键字。

当您看到“type”这个字的时候,请同时想到“class”;反之亦然。

建好一个类后,可根据情况生成许多对象。

随后,可将那些对象作为要解决问题中存在的元素进行处理。

事实上,当我们进行面向对象的程序设计时,面临的最大一项挑战性就是:

如何在“问题空间”(问题实际存在的地方)的元素与“方案空间”(对实际问题进行建模的地方,如计算机)的元素之间建立理想的“一对一”对应或映射关系。

如何利用对象完成真正有用的工作呢?

必须有一种办法能向对象发出请求,令其做一些实际的事情,比如完成一次交易、在屏幕上画一些东西或者打开一个开关等等。

每个对象仅能接受特定的请求。

我们向对象发出的请求是通过它的“接口”(Interface)定义的,对象的“类型”或“类”则规定了它的接口形式。

“类型”与“接口”的等价或对应关系是面向对象程序设计的基础。

下面让我们以电灯泡为例:

Lightlt=newLight();

lt.on();

在这个例子中,类型/类的名称是Light,可向Light对象发出的请求包括包括打开(on)、关闭(off)、变得更明亮(brighten)或者变得更暗淡(dim)。

通过简单地声明一个名字(lt),我们为Light对象创建了一个“句柄”。

然后用new关键字新建类型为Light的一个对象。

再用等号将其赋给句柄。

为了向对象发送一条消息,我们列出句柄名(lt),再用一个句点符号(.)把它同消息名称(on)连接起来。

从中可以看出,使用一些预先定义好的类时,我们在程序里采用的代码是非常简单和直观的。

1.3实现方案的隐藏

为方便后面的讨论,让我们先对这一领域的从业人员作一下分类。

从根本上说,大致有两方面的人员涉足面向对象的编程:

“类创建者”(创建新数据类型的人)以及“客户程序员”(在自己的应用程序中采用现成数据类型的人;注释④)。

对客户程序员来讲,最主要的目标就是收集一个充斥着各种类的编程“工具箱”,以便快速开发符合自己要求的应用。

而对类创建者来说,他们的目标则是从头构建一个类,只向客户程序员开放有必要开放的东西(接口),其他所有细节都隐藏起来。

为什么要这样做?

隐藏之后,客户程序员就不能接触和改变那些细节,所以原创者不用担心自己的作品会受到非法修改,可确保它们不会对其他人造成影响。

④:

感谢我的朋友ScottMeyers,是他帮我起了这个名字。

“接口”(Interface)规定了可对一个特定的对象发出哪些请求。

然而,必须在某个地方存在着一些代码,以便满足这些请求。

这些代码与那些隐藏起来的数据便叫作“隐藏的实现”。

站在程式化程序编写(ProceduralProgramming)的角度,整个问题并不显得复杂。

一种类型含有与每种可能的请求关联起来的函数。

一旦向对象发出一个特定的请求,就会调用那个函数。

我们通常将这个过程总结为向对象“发送一条消息”(提出一个请求)。

对象的职责就是决定如何对这条消息作出反应(执行相应的代码)。

对于任何关系,重要一点是让牵连到的所有成员都遵守相同的规则。

创建一个库时,相当于同客户程序员建立了一种关系。

对方也是程序员,但他们的目标是组合出一个特定的应用(程序),或者用您的库构建一个更大的库。

若任何人都能使用一个类的所有成员,那么客户程序员可对那个类做任何事情,没有办法强制他们遵守任何约束。

即便非常不愿客户程序员直接操作类内包含的一些成员,但倘若未进行访问控制,就没有办法阻止这一情况的发生——所有东西都会暴露无遗。

有两方面的原因促使我们控制对成员的访问。

第一个原因是防止程序员接触他们不该接触的东西——通常是内部数据类型的设计思想。

若只是为了解决特定的问题,用户只需操作接口即可,毋需明白这些信息。

我们向用户提供的实际是一种服务,因为他们很容易就可看出哪些对自己非常重要,以及哪些可忽略不计。

进行访问控制的第二个原因是允许库设计人员修改内部结构,不用担心它会对客户程序员造成什么影响。

例如,我们最开始可能设计了一个形式简单的类,以便简化开发。

以后又决定进行改写,使其更快地运行。

若接口与实现方法早已隔离开,并分别受到保护,就可放心做到这一点,只要求用户重新链接一下即可。

Java采用三个显式(明确)关键字以及一个隐式(暗示)关键字来设置类边界:

public,private,protected以及暗示性的friendly。

若未明确指定其他关键字,则默认为后者。

这些关键字的使用和含义都是相当直观的,它们决定了谁能使用后续的定义内容。

“public”(公共)意味着后续的定义任何人均可使用。

而在另一方面,“private”(私有)意味着除您自己、类型的创建者以及那个类型的内部函数成员,其他任何人都不能访问后续的定义信息。

private在您与客户程序员之间竖起了一堵墙。

若有人试图访问私有成员,就会得到一个编译期错误。

“friendly”(友好的)涉及“包装”或“封装”(Package)的概念——即Java用来构建库的方法。

若某样东西是“友好的”,意味着它只能在这个包装的范围内使用(所以这一访问级别有时也叫作“包装访问”)。

“protected”(受保护的)与“private”相似,只是一个继承的类可访问受保护的成员,但不能访问私有成员。

继承的问题不久就要谈到。

1.4方案的重复使用

创建并测试好一个类后,它应(从理想的角度)代表一个有用的代码单位。

但并不象许多人希望的那样,这种重复使用的能力并不容易实现;它要求较多的经验以及洞察力,这样才能设计出一个好的方案,才有可能重复使用。

许多人认为代码或设计方案的重复使用是面向对象的程序设计提供的最伟大的一种杠杆。

为重复使用一个类,最简单的办法是仅直接使用那个类的对象。

但同时也能将那个类的一个对象置入一个新类。

我们把这叫作“创建一个成员对象”。

新类可由任意数量和类型的其他对象构成。

无论如何,只要新类达到了设计要求即可。

这个概念叫作“组织”——在现有类的基础上组织一个新类。

有时,我们也将组织称作“包含”关系,比如“一辆车包含了一个变速箱”。

对象的组织具有极大的灵活性。

新类的“成员对象”通常设为“私有”(Private),使用这个类的客户程序员不能访问它们。

这样一来,我们可在不干扰客户代码的前提下,从容地修改那些成员。

也可以在“运行期”更改成员,这进一步增大了灵活性。

后面要讲到的“继承”并不具备这种灵活性,因为编译器必须对通过继承创建的类加以限制。

由于继承的重要性,所以在面向对象的程序设计中,它经常被重点强调。

作为新加入这一领域的程序员,或许早已先入为主地认为“继承应当随处可见”。

沿这种思路产生的设计将是非常笨拙的,会大大增加程序的复杂程度。

相反,新建类的时候,首先应考虑“组织”对象;这样做显得更加简单和灵活。

利用对象的组织,我们的设计可保持清爽。

一旦需要用到继承,就会明显意识到这一点。

1.5继承:

重新使用接口

就其本身来说,对象的概念可为我们带来极大的便利。

它在概念上允许我们将各式各样数据和功能封装到一起。

这样便可恰当表达“问题空间”的概念,不用刻意遵照基础机器的表达方式。

在程序设计语言中,这些概念则反映为具体的数据类型(使用class关键字)。

我们费尽心思做出一种数据类型后,假如不得不又新建一种类型,令其实现大致相同的功能,那会是一件非常令人灰心的事情。

但若能利用现成的数据类型,对其进行“克隆”,再根据情况进行添加和修改,情况就显得理想多了。

“继承”正是针对这个目标而设计的。

但继承并不完全等价于克隆。

在继承过程中,若原始类(正式名称叫作基础类、超类或父类)发生了变化,修改过的“克隆”类(正式名称叫作继承类或者子类)也会反映出这种变化。

在Java语言中,继承是通过extends关键字实现的

使用继承时,相当于创建了一个新类。

这个新类不仅包含了现有类型的所有成员(尽管private成员被隐藏起来,且不能访问),但更重要的是,它复制了基础类的接口。

也就是说,可向基础类的对象发送的所有消息亦可原样发给衍生类的对象。

根据可以发送的消息,我们能知道类的类型。

这意味着衍生类具有与基础类相同的类型!

为真正理解面向对象程序设计的含义,首先必须认识到这种类型的等价关系。

由于基础类和衍生类具有相同的接口,所以那个接口必须进行特殊的设计。

也就是说,对象接收到一条特定的消息后,必须有一个“方法”能够执行。

若只是简单地继承一个类,并不做其他任何事情,来自基础类接口的方法就会直接照搬到衍生类。

这意味着衍生类的对象不仅有相同的类型,也有同样的行为,这一后果通常是我们不愿见到的。

有两种做法可将新得的衍生类与原来的基础类区分开。

第一种做法十分简单:

为衍生类添加新函数(功能)。

这些新函数并非基础类接口的一部分。

进行这种处理时,一般都是意识到基础类不能满足我们的要求,所以需要添加更多的函数。

这是一种最简单、最基本的继承用法,大多数时候都可完美地解决我们的问题。

然而,事先还是要仔细调查自己的基础类是否真的需要这些额外的函数。

1.5.1改善基础类

尽管extends关键字暗示着我们要为接口“扩展”新功能,但实情并非肯定如此。

为区分我们的新类,第二个办法是改变基础类一个现有函数的行为。

我们将其称作“改善”那个函数。

为改善一个函数,只需为衍生类的函数建立一个新定义即可。

我们的目标是:

“尽管使用的函数接口未变,但它的新版本具有不同的表现”。

1.5.2等价与类似关系

针对继承可能会产生这样的一个争论:

继承只能改善原基础类的函数吗?

若答案是肯定的,则衍生类型就是与基础类完全相同的类型,因为都拥有完全相同的接口。

这样造成的结果就是:

我们完全能够将衍生类的一个对象换成基础类的一个对象!

可将其想象成一种“纯替换”。

在某种意义上,这是进行继承的一种理想方式。

此时,我们通常认为基础类和衍生类之间存在一种“等价”关系——因为我们可以理直气壮地说:

“圆就是一种几何形状”。

为了对继承进行测试,一个办法就是看看自己是否能把它们套入这种“等价”关系中,看看是否有意义。

但在许多时候,我们必须为衍生类型加入新的接口元素。

所以不仅扩展了接口,也创建了一种新类型。

这种新类型仍可替换成基础类型,但这种替换并不是完美的,因为不可在基础类里访问新函数。

我们将其称作“类似”关系;新类型拥有旧类型的接口,但也包含了其他函数,所以不能说它们是完全等价的。

举个例子来说,让我们考虑一下制冷机的情况。

假定我们的房间连好了用于制冷的各种控制器;也就是说,我们已拥有必要的“接口”来控制制冷。

现在假设机器出了故障,我们把它换成一台新型的冷、热两用空调,冬天和夏天均可使用。

冷、热空调“类似”制冷机,但能做更多的事情。

由于我们的房间只安装了控制制冷的设备,所以它们只限于同新机器的制冷部分打交道。

新机器的接口已得到了扩展,但现有的系统并不知道除原始接口以外的任何东西。

认识了等价与类似的区别后,再进行替换时就会有把握得多。

尽管大多数时候“纯替换”已经足够,但您会发现在某些情况下,仍然有明显的理由需要在衍生类的基础上增添新功能。

通过前面对这两种情况的讨论,相信大家已心中有数该如何做。

1.6多形对象的互换使用

通常,继承最终会以创建一系列类收场,所有类都建立在统一的接口基础上。

我们用一幅颠倒的树形图来阐明这一点(注释⑤):

⑤:

这儿采用了“统一记号法”,本书将主要采用这种方法。

对这样的一系列类,我们要进行的一项重要处理就是将衍生类的对象当作基础类的一个对象对待。

这一点是非常重要的,因为它意味着我们只需编写单一的代码,令其忽略类型的特定细节,只与基础类打交道。

这样一来,那些代码就可与类型信息分开。

所以更易编写,也更易理解。

此外,若通过继承增添了一种新类型,如“三角形”,那么我们为“几何形状”新类型编写的代码会象在旧类型里一样良好地工作。

所以说程序具备了“扩展能力”,具有“扩展性”。

以上面的例子为基础,假设我们用Java写了这样一个函数:

voiddoStuff(Shapes){

s.erase();

//...

s.draw();

}

这个函数可与任何“几何形状”(Shape)通信,所以完全独立于它要描绘(draw)和删除(erase)的任何特定类型的对象。

如果我们在其他一些程序里使用doStuff()函数:

Circlec=newCircle();

Trianglet=newTriangle();

Linel=newLine();

doStuff(c);

doStuff(t);

doStuff(l);

那么对doStuff()的调用会自动良好地工作,无论对象的具体类型是什么。

这实际是一个非常有用的编程技巧。

请考虑下面这行代码:

doStuff(c);

此时,一个Circle(圆)句柄传递给一个本来期待Shape(形状)句柄的函数。

由于圆是一种几何形状,所以doStuff()能正确地进行处理。

也就是说,凡是doStuff()能发给一个Shape的消息,Circle也能接收。

所以这样做是安全的,不会造成错误。

我们将这种把衍生类型当作它的基本类型处理的过程叫作“Upcasting”(上溯造型)。

其中,“cast”(造型)是指根据一个现成的模型创建;而“Up”(向上)表明继承的方向是从“上面”来的——即基础类位于顶部,而衍生类在下方展开。

所以,根据基础类进行造型就是一个从上面继承的过程,即“Upcasting”。

在面向对象的程序里,通常都要用到上溯造型技术。

这是避免去调查准确类型的一个好办法。

请看看doStuff()里的代码:

s.erase();

//...

s.draw();

注意它并未这样表达:

“如果你是一个Circle,就这样做;如果你是一个Square,就那样做;等等”。

若那样编写代码,就需检查一个Shape所有可能的类型,如圆、矩形等等。

这显然是非常麻烦的,而且每次添加了一种新的Shape类型后,都要相应地进行修改。

在这儿,我们只需说:

“你是一种几何形状,我知道你能将自己删掉,即erase();请自己采取那个行动,并自己去控制所有的细节吧。

1.6.1动态绑定

在doStuff()的代码里,最让人吃惊的是尽管我们没作出任何特殊指示,采取的操作也是完全正确和恰当的。

我们知道,为Circle调用draw()时执行的代码与为一个Square或Line调用draw()时执行的代码是不同的。

但在将draw()消息发给一个匿名Shape时,根据Shape句柄当时连接的实际类型,会相应地采取正确的操作。

这当然令人惊讶,因为当Java编译器为doStuff()编译代码时,它并不知道自己要操作的准确类型是什么。

尽管我们确实可以保证最终会为Shape调用erase(),为Shape调用draw(),但并不能保证为特定的Circle,Square或者Line调用什么。

然而最后采取的操作同样是正确的,这是怎么做到的呢?

将一条消息发给对象时,如果并不知道对方的具体类型是什么,但采取的行动同样是正确的,这种情况就叫作“多形性”(Polymorphism)。

对面向对象的程序设计语言来说,它们用以实现多形性的方法叫作“动态绑定”。

编译器和运行期系统会负责对所有细节的控制;我们只需知道会发生什么事情,而且更重要的是,如何利用它帮助自己设计程序。

有些语言要求我们用一个特殊的关键字来允许动态绑定。

在C++中,这个关键字是virtual。

在Java中,我们则完全不必记住添加一个关键字,因为函数的动态绑定是自动进行的。

所以在将一条消息发给对象时,我们完全可以肯定对象会采取正确的行动,即使其中涉及上溯造型之类的处理。

1.6.2抽象的基础类和接口

设计程序时,我们经常都希望基础类只为自己的衍生类提供一个接口。

也就是说,我们不想其他任何人实际创建基础类的一个对象,只对上溯造型成它,以便使用它们的接口。

为达到这个目的,需要把那个类变成“抽象”的——使用abstract关键字。

若有人试图创建抽象类的一个对象,编译器就会阻止他们。

这种工具可有效强制实行一种特殊的设计。

亦可用abstract关键字描述一个尚未实现的方法——作为一个“根”使用,指出:

“这是适用于从这个类继承的所有类型的一个接口函数,但目前尚没有对它进行任何形式的实现。

”抽象方法也许只能在一

展开阅读全文
相关资源
猜你喜欢
相关搜索

当前位置:首页 > 总结汇报 > 学习总结

copyright@ 2008-2022 冰豆网网站版权所有

经营许可证编号:鄂ICP备2022015515号-1