面向对象的思想

面向对象的思想（精选9篇）

面向对象的思想 篇1

摘要：从计算机软件理论中的面向对象思想出发,分析汉字的抽象性、封装性、继承性、多态性等性质,提出汉字是一种面向对象的文字,并给出了解决汉字总量无限增长危机的方法。

关键词：面向对象,汉字,汉字特征

0 引言

现在世界上存在的人类自然语言文字可以分为两种:字母文字和象形文字[1]。一般学者们认为人类语言文字的进化过程是从结绳记事、刻画符号、象形文字到字母文字的进化过程。现代汉字和甲骨文的体系结构没有发生本质变化,由此得出汉字是人类早期的文字之一,所以汉字应该走世界文字发展的共同方向:字母文字。人类进入信息化时代后,汉字又面临受到前所未有的挑战:汉字表达不准确、汉语不易编程。汉字真的要走世界文字发展的共同方向吗?汉字的特征是怎样的?汉字与现存的其他主要文字有什么本质的区别?对于这些问题的解释,学者们往往是站在自然语言本身和民族的立场,让人们信服的力度不够强。

自然语言和计算机语言在基本思想上是相通的,本文将在软件理论中寻求答案。在过去的半个世纪里,计算机编程语言经历了机器语言、汇编语言、面向过程语言、面向对象语言四个发展阶段。面向过程语言和面向对象语言称为高级语言,它们接近人的语言思维。特别是软件危机出现时,出现了一门新兴学科:软件工程学。软件工程方法学的核心是面向对象方法学[2]。面向对象编程(OOP)是通过模仿人类建立现实世界模型的方法,包括概念、分类、抽象、归纳等进行软件开发的一种新的设计方法。它具有以下基本特性:抽象、封装、继承、多态[3,4]。模式设计中有面向对象三大基本原则:针对接口编程,而不是针对实现编程、优先使用对象组合而不是类继承、封装变化点[5]。下面将运用面向对象的思想逐步分析汉字的抽象性、封装性、继承性、多态性,然后结合面向对象的三大原则对汉字综合分析研究。

1 汉字面向对象性质

1.1 汉字的抽象性

象形者,画成其物,随体诘诎,日、月是也[6]。象形字,就是对客观世界中可见可摸的具体事物物体,抽象出其共同的外部特征。象形字是文字的第一层抽象,是文字抽象的第一步。如:日、月、山、水、川、刀。鸟(鳥)字像一只活休憩在枝头侧身小鸟;龟(龜)字像一只龟的侧面形状;马(馬)字就是一匹有马鬣、有四腿的马;鱼(魚)是一尾有鱼头、鱼身、鱼尾的游鱼,门(門)字就是左右两扇门的形状;日字的甲骨文字体是一个圆形加中间一点,圆形恰是太阳的形态,中间一点好似太阳黑子。“人”字,以最简洁方式抽象出世界上人的共同的特征:直立行走,这个字是人类一个伟大的发明。

指事字是在象形字的基础上加着符号以表示抽象事物的造字方法,也就是当没有、或不方便用具体形象画出来时,就用一种抽象的符号来表示,例如“上”、“下”、“凶”……等等。在甲骨文中用横线“一”为界,在横线上用一点或较短的短线指出上方的位置,就是“上”字;而在横线下面画符号,则是“下”字。“凶”字是指地上有一个深坑,走路的人没看见而踏空掉进坑里,“ㄩ”代表深坑,中间的“×”符号就是象征掉下坑的那种惊吓的感觉和危险的情形[7]。

会意字是用几个偏旁义组合成一个新义的造字方法。会意是为了补救象形和指事的局限而创造出来的造字方法。和象形、指事相比,会意法具有明显的优越性:第一,它可以表示很多抽象的意义;第二,它的造字功能强。《说文解字》收会意字1167个,比象形字、指事字多得多。因为会意字是两个或两个以上的形体的会合,所以可以表示许多抽象的、用象形或指事的方法难以表示的意义。如“木”和“木”可以组合为“林、森”[7]。

下面重点解说一下三个典型的抽象字:王、法、时。

“王”是贯穿“天”“地”“人”三者之物,才可为“王”。《说文解字》这样记载:“古之造文者,三画而连其中谓之王。三者,天、地、人也,而参通之者王也。”

“法”是会意字,是一个更加抽象的概念,繁体字“灋”。“水”,表示法律、法度公平如水;“廌”(zhì),神话传说中的一种神兽,它能辨别曲直,在审理案件时,它能用角触理曲的人;“去”,表示去除不好的部分。基本义:通过刑具(廌)来去除有罪人的不好的部分,对所以人像水一样公平,就是“法”的本意,与今天的法律基本思想是一致的。

时间概念极为复杂,很难抽象出时间概念的本质。英文单词“time”就像一段密码,只记录了语音,并没有给出时间概念本质特性。甲骨文中“时”字是“旹”,上“之”下“日”,“之”表示脚本,日表示太阳,合起来就是太阳的脚步,后来加了一个“寸”表示刻度。2008北京奥运会开幕出现了中国古代计时工具:日晷,时间就是太阳行走的刻度。直到今天,人们对时间的定义还是以太阳为参照。汉字非常巧妙地将复杂的时间概念抽象为一个简单的形象的汉字“時”。

简而言之,象形字是对具体事物外部共同特征的抽象,指事字会意字是对复杂事物内部涵义的抽象。从另一方面分析,名词类汉字多是数据抽象,动词类汉字多是行为抽象。可见汉字的抽象能力很强,且抽象度适中,较英语更适合人们生活中使用。英文单词对事物的抽象度把握得不好,没有抽象出事物的共同属性。

1.2 汉字的封装性

(1)字型的封装每个汉字就是一个独立的模块,与其他汉字自然分开,就像是一个个准备好的部件。而英语单词的封装性较差,单词随着词形时态变化而变化,单词长度也随之变化。单词与单词不能自然分开,需要添加一个字母的空间来区分不同的单词。由于汉字良好封装性,人们不需要在不同词汇间再添冗余的空格来进行标识。由于当前技术所限,计算机对汉语分词技术较英语分词技术低一些。汉语书写方式非常灵活,可以从上向下、从左向右、从右向左书写,甚至可以顺时针方向书写。英文书写方式较为单一,在一些特殊空间给书写带来了不便,比如空间有限的建筑上从左向右书写的空间更小。

(2)属性和动作封装核心汉字都可以看作一个抽象类,每个基本汉字就好比一个类。“人”具有的属性和操作都被隐藏起来了,从字面上看不出的。人={人的属性,人的动作},人的属性={姓名,地址,年龄,手机号,单位},人的动作={看,说,吃,听}。人的一个实例是“我”,“我”具有“吃”的动作。需要时可以直接调用该动作,我吃饭=我.吃(饭)=吃(我,饭);“吃”是个抽象类,人和其他动物共享此抽象动作。

1.3 汉字的继承性

大部分汉字从字形上看,很容易发现存在着继承关系。特别是汉字中占了90%的形声字,继承性表现的更为突出。形声字是合体字,对象形字的继承,同时继承了“语义”和“语音”,即是双继承。形声字对语音的继承可以单独讨论,这里不考虑对语音的继承,只研究对语义的继承。这样的话,汉字的继承关系就是单继承关系。

以鱼类为例,“鱼”一个抽象概念,是鱼类的总称。鱼类可以分为淡水鱼和海水鱼。淡水鱼类有鳊、鲢、鳙、鲤、鲫、鲶、鳢、鲥、鲋、鲈……,其中每个字代表一种鱼,也就是“鱼”的一个子类,这是自明的。

以鸟类为例,“鸟”的概念是个抽象类,是对所有鸟类的总称。中国先人创造出这个抽象的“鸟”字,后来顺着对自然认识的加深,已经可以区别一些常见鸟,于是就造造出了常见的鸟字:鸡、鸭、鹅、鸽、鹰、鹊……。由动物学鸟类的族谱关系如图1所示,为了方便起见,使用向下的箭头表示分类和继承的树型关系。

上古时期中国的先人们,识别一种新的鸟类时就会造出对应的汉字来标识。新的汉字继承了“鸟”字,从字形上人们就能知道是一种鸟,比如:鹏(传说中最大的鸟)、鸾(传说凤凰一类的鸟)、鸷(凶猛的鸟,如鹰、雕、等)、枭(本义:指一种恶鸟,捕捉后悬头树上以示众)、鸱(古书上指鹞鹰)。对应其他语言就没有明显的继承性,如英文中的bird与chook、duck、goose看不出继承关系。

再以树木为例,古汉语中树木概念为抽象为“木”,所以具体树木子类造字就必须继承“木”字。由植物学树木分类如图2所示。

继承性的例子很多,再比如“车”、“牛”、“马”、“女”、“金”、“气”……。这种继承性造字方法比英语中词根构词法功能强大,造出的字易读语义性也强,系统性强。有了汉字继承的方法,在对新事物命名时就有章可循,减少了随意盲目依个人喜好对事物命名。对新生事物进行分析,找到他所属于的类别,在类的继承树上即可找到恰当的命名。比如人类最近发现的质子数为109的新元素,通过分析知道这是一种过渡金属元素,依照继承原理中国人造出了汉字“钅麦”(读音是对英语读音的继承,暂不讨论)。后来又发现了110号元素,命名为“钅达”。

1.4 汉字的多态性

钱能:“若语言不支持多态,则不能称面向对象的[3]。”可见多态性对语言分类时的重要性。所以,如果某种文字不具有多态性,那么就可以断定其不是真正的面向对象的文字。人的思维方式也是自然的多态形式,面向对象编程的多态性就是用软件形式也模拟人思维的多态性。人类的语言是思维的外在物资表现,应该也具有多态性。汉语的多态性可以分为两类,一是表达多种状态的事物,二是表达事物的多种状态。

第一类多态:一个汉字接口,表达多种状态的事物。汉语的名词没有明显的性、格、数的变化,这正是多态性的表现,最典型的例子是三种人称代词。第一人称代词“我”字,无论是表示主语还是宾语都是汉字“我”,而英语中主格我的概念是“I”,宾格我的概念是“me”。“我”字性别是自明的,性别取值为{男,女,不确定}。第二人称代词“你”字,可是多种状态的“你”,男性的“你”或者女性的“你”,主体的“你”或者客体的“你”。有个特殊的汉字“妳”[8,9],“你”的异体字,表示第二人称是女性的你。“妳”是冗余的、原始的汉字,现在基本已经淘汰了。古汉语中的“他”字和现在汉语中的“他”有点差别,古汉语中的“他”泛指第三方,可表男女及一切事物,如“他山之石”、“他乡”、“其他”……。现代汉语中的“他”则用于称代自己和对方以外的男性第三者,近似于英语中的单词he。可见古汉语中的“他”较今天的“他”更具有多态性。为什么会出现倒退现象呢,这与“她”字有关。古汉语中“她”[9]字原本是“姐”的异体字,现在汉语中的“她”表示女性的第三方。英语第三人称有若干单词:he、she、it、they、her、him、them……,也许是受其影响,认为这样表达准确,上世纪初刘半农赋予“她”同英语单词her同样的语义。当信息时代到来,互联网个人资料需要保密,人们需要表达泛指的第三人称的概念时,却发现找不到对应的汉字了,只好使用拼音“ta”。(英语中没有泛指的第三人称单词,用he or she来表达)。所以使用“妳”、“她”字并不是表示对女性的尊重,相反是对女性的歧视。汉字中的“人”字(人字旁)不专指男人,是对男女的统称,对人类的抽象标识。正因为“妳”和“她”的出现,“你”和“他”的概念范围缩小,专指男人。而英语中的男人单词“man”,可以表示为男人和人类的概念。中国人的祖先的思维是真正的多态形式,他们将这个世界拟人化,分为你我他。正如Unix系统把一切设备看作文件来处理,意义深远。

前面说的是名词,其实动词的多态性更加明显,这就是第二类多态:一个汉字接口,表达事物的多种状态。汉语中的动词没有时态变化,时空观是相对的时间观,不是绝对的时空观。汉语的时空观较英语的时空观更为科学,因为宇宙中一切物质是运动的物质,从现代物理学中得知绝对时空观是相对时空观的一个特例。所以对世界中的运动可以从总体出发,抽象出本质特征,而不是局限于特定的时空,这样的“运动”或者“状态”就应该具有世界本源的多态性。

比如“吃”这一动作,汉语句子“A吃B”就具有最常见到多态性,“我吃饭”、“你吃馒头”、“他吃苹果”、“狼吃羊”、“羊吃草”……。对于中国人来说只要是可以食用固态物质就可以使用“A吃B”句式,思维方式是多态的,人们不会考虑因为“吃”的主体或者客体的不同而使用不同状态的“吃”,就连药片人们也说“吃药”。而英语世界的人们就要根据“吃”的不同状态使用不同的“吃”:老虎吃肉(Tigers eat meat)、吃早餐(break one's fast、to have breakfast)、吃晚饭(sup on、to have dinne)、吃火锅(blocked shot)、吃快餐(snack)、吃草(browse)……。就连eat也有多种状态变化,其他的英语动词就不用说了。ate,eaten,eating,eats,一个汉语动词对应多个状态的英文动词或短语,这就是多态性最直接的表现。名词可以看作是对象,动词就是对象的方法,动词的意义是以对应名词所产生的。比如“我吃苹果”用面向对象的方法表示是“我.吃(苹果)”,可以看出动词“吃”就是对象“我”的方法。“我”是人的一个实例,人是动物的一个子类。“吃”的方法是对动物抽象出的一个统一方法,每个具体动物都对“吃”操作进行了重写,也就是说他们有着自己“吃”的实现方式。“吃”的具体含义是有主体动态确定的,这就是后绑定,人们在使用时已经感觉不到具体实现的细节了。其他就不用举例了。

1.5 三大基本原则分析

回顾一下计算机软件中面向对象语言的发展:在OO开发的早期,继承被过度地使用;随着时间的发展,人们发现优先使用组合可以获得重用性与简单性更佳的设计,当然可以通过继承,以扩充可用的组合类集。因此组合与继承可以一起工作,但是基本法则是“优先使用对象组合,而非(类)继承”,这就是模式设计中建议使用的原则。

从上面的分析可以看到,汉字已经初步具有了面向对象的性质。但是存在一个问题:与计算机软件中面向对象语言发展类似,由于继承性被过分使用导致汉字的总数是无限增加的。东汉《说文解字》收字9千多,清《康熙字典》收4万多,到1994年《中华字海》收字竟8万多。如果元素周期表中的元素是成千上万个,那么就要造上万个汉字来表示吗?这里要指出人们的一种误解:语言的词汇总量与语言的精确性成正比。汉字总数的增加并不能说明汉语表达能力的增强,字词的无限增加恰恰说明了这种语言的低效性。汉语是怎么解决这个汉字总数无限增加的危机呢?

先分析一个实例。如果为国家建立一个本体,会有货币这一概念。世界上有200多个国家,货币的种类繁多。如果按照上面的分析,首先可以抽象出所以货币的父类“元”,然后为各国货币名称造一个字,继承抽象货币“元”,也就是生成一个子类。这样的话货币名称层次明显、可读性会大大增强,但是要增加100多个汉字。在汉语中,可以发现有这些货币名称:人民币元(华元)、欧元、韩元、日元、美元、缅甸元、加拿大元、澳大利亚元、新加坡元、新西兰元、津巴布韦元、港元、澳门元……。从这可以发现一个尚未形成的规律,既是国名(区名)+元。也可以看到,汉语已经为世界部分国家的货币名称定义好了接口,货币接口不变,具体内部实现可以由该国新政府去完成。比如华元是接口,内部实现是人民币,美元是对外接口,dollar是内部实现,屏蔽具体细节。这和面向对象的基本原则之一基于接口编程的基本思想是一致的。更重要的,应该看到这是继承和组合的规律完美的结合。世界货币词汇如图3所示。

纵向看,是继承关系,欧元、美元都是元的子类;横向看是使用组合规律,这恰恰是面向对象的基本原则:优先使用对象组合,而不是继承。这种结合方式没有增加汉字,货币名称可读性强,语义明显。名称有规律可循,代码重用率高。如果有某个国家改朝换代了或者说这个国家需要更改货币名称,不需要关心该国内部细节,该国家进行内部修改,但对外接口一样不变,仍然可以正常使用。再比如,当出现一个新的国家时(最近几年确实也出现过几个新国家),那么该国家的货币怎么命名呢,世界货币怎么扩展?这里要用到开闭原则,对扩展开放,对修改封闭。

这是解决汉字无限增加最高效的方法。重新分析前面的提到的继承的几个实例,对“鱼”、“鸟”、“木”类进行扩展,加入新的子类,构词树如图4-图6所示。

上面的例子是单独一个类的词汇树研究,下面分析多棵树组成的词汇网络图。首先给出几个基本概念。由前面的鸟类可以找到抽象的“鸡”的概念,鸡的子类是公鸡、母鸡、小鸡、家鸡、野鸡等等。从cattle、moggy、moo-cow、ox、cow、bull抽象出父类“牛”。公鸡(chanticleer、cock、rooster)、公鸭(drake)、公牛(ox)、公猪(boar)、公猫(tomcat)、公兔(Buck)、公驴(jackass)、公羊(ram、tup)、公山羊(bill goat)、公山羊的(capric、caprine)等等概念,与之对应的是母鸡(hen)、母狗(bitch)、母牛(cow)、母驴(jennet)、母羊(ewe)……等概念。从这些概念中可以抽象出“公”、“母”两个概念,用于区分动物性别,在汉语中也确实存在对应的汉字。可以再从鹿肉(venison)、鸡肉(chicken)、鹅肉(geese)、牛肉(beef、beeves)、羊肉(mutton)、猪肉(pork)、果肉(sarcocarp)肉汤(broth)肉店(shambles)……概念中可以抽象出“肉”的概念,对应汉字是“肉”。“鸡”、“牛”、“公”、“肉”四个大类的关系如图7所示。

国家汉字标准(GB2312-80)只收录了6763个汉字[10],常用汉字2500个,汉字总数不在多而在精。汉语言空间下世界是一个有着固定网络分层结构概念世界,这是一个有机空间,任何一个新概念都有着对应空间位置,而不是新概念随意存放。顶层概念是这个世界的基本元素,把这个世界分成了若干个基本词汇树,顶层概念提供了统一的造字构词接口,以最大限度高效重复使用代码。从纵向看,上层概念与下层概念都有着继承关系;从横向看,每个新概念是以类的组合形式构成。这样一种有机结构使得汉语词汇有着很强的扩展性和自明性。

2结论

本文运用计算机软件理论中面向对象的思想对汉字进行了初步分析,重点分析汉字的抽象性、封装性、继承性和多态性。可以得出这样的结论:汉字是一种面向对象的文字。汉语中的构词系统符合模式设计中推荐的面向对象三大原则,从而最大程度解决了词汇无限增长的趋势。这些都是对现代汉字研究有着抛砖引玉的作用,为汉字研究寻找到一个新的道路。接下来将继续研究中文编程等问题。

由于这是初步尝试用新理论来研究汉字,一些地方存在着不足,如汉字的封装性解释得不到位、可以参考文献较少,这有待进一步研究。

参考文献

[1]http://www.china-language.gov.cn/.

[2]张海潘.软件工程][M].北京:清华大学出版社,2008.

[3]钱能.C++程序设计教程[M].2版.北京:清华大学出版社,2005.

[4]朱喜福,赵敏.Java程序设计[M].北京:人民邮电出版社,2005.

[5]Erich Gamma,Richard Helm,Ralph Johnson,et al.Design Patterns El-ements of Reusable Object-Oriented Software Pearson Education,2002.

[6](东汉)许慎.说文解字[M].中华书局.2005.

[7]百度百科.http://baike.baidu.com/.

[8]现代汉语词典(2002年增补版)[M].北京:商务印书馆.

[9]古代汉语大字典[M].上海辞书出版社,2007.

[10]中华人民共和国信息交换汉字编码国家标准(GB2312-80)[S].

面向对象的思想 篇2

OOP 达到了软件工程的三个主要目标：重用性、灵活性和扩展性。为了实现整体运算，每个对象都能够接收信息、处理数据和向其它对象发送信息。

面向对象有三大特性，分别是：封装、继承、多态。封装是隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，以特定的访问权限来使用类的成员。任何类都可以从另外一个类继承，即这个类拥有它所继承类的所有成员。被继承的类称为父类或基类。C# 只支持单继承，不支持多重继承，即在C# 中一次只允许继承一个类，不能同时继承多个类。在C# 中，接口允许多继承，可以通过继承多个接口来实现类似于C++中的多重继承。

多态是同一个类在不同场合下表现出不同的行为特征。

使用抽象方法与虚方法都可以实现多态性。抽象方法是一个未实现的方法，使用abstract关键字修饰，含有抽象方法的类必然是抽象类。抽象方法要在其子方法中通过override关键字重写。

面向对象编程思想解析 篇3

面向对象的思想不仅仅局限于软件设计, 它已经拓展到更多的领域, 如分布式系统、应用平台、交互式界面、数据库系统、人工智能、嵌入式软件系统等领域。作为计算机专业的求学者和从业人员, 不管钻研或从事哪个方向的, 都应该对面向对象编程思想有所了解。

通俗地讲, 面向对象编程思想可以概括如下:系统中的一切事物都是对象;将属性和对属性执行的操作封装成为整体, 这个封装体即是对象;属性和操作相同的对象抽象成为类, 对象则是类的实体;发送消息可以使对象执行相应的操作;在现有类的基础上增加属性或操作可以构成另一个类, 这是类的继承。

2 面向过程编程思想所存在的问题

2.1 可维护性差

用传统的面向过程方法所开发出的软件, 由于可修改性较差, 维护时产生的费用仍很高, 造成其可维护性差。

2.2 重用性差

重用性指软件不用修改或略加修改就能重复使用。面向过程程序设计阶段软件重用性极差, 引起软件危机, 软件工程这一学科由此而诞生, 提高重用性是软件工程的重要目标, 而面向对象的继承机制很好地解决了软件重用性这一问题。

2.3 软件功能与用户需求不一致

用传统的结构化方法开发大型软件系统涉及各种不同领域的知识, 在开发需求模糊或需求动态变化的系统时, 所开发出的软件系统往往不能真正满足用户的需要。

3 面向对象的重要概念

3.1 类

类是属性与操作相同的对象的抽象。因此, 类是对象的抽象, 对象是类的实例。例如“人”是所有人的一个抽象的总称, 他是一个类, “鲁迅”是具体的一个人, 这就是个对象。再如“班级”是个抽象的类名, “计算机系13级软件1班”是具体的一个班级对象。

类的属性用来表示对象的各种特征, 用数据结构来描述。如长方体有三个基本属性长、宽、高;时间有三个基本属性小时、分、妙;人的基本属性有姓名、年龄、性别、工作单位等。在不同的处理需求下对于同一事物的属性描述是不一样的。

类的操作是对于对象行为的描述, 包括操作的名称和操作实现过程。

3.2 对象

对象是任何被人类研究的实物, 不管是简单的实数还是结构复杂的核潜艇都可以认为是对象。除了具体的事物, 对象还能表示抽象的规则、计划。

3.3 对象的属性和操作

对象的属性用各类数据描述。如一个餐桌的属性包括长、宽、高、材质和颜色, 前三种属性值用实型数据表示, 后两种属性值用字符串表示。对象的操作用于改变或访问对象的属性。如一个餐桌对象有一个求桌面面积的操作, 这个操作需要访问此餐桌的长和宽。对象将其属性值与操作结合在一起形成一个整体, 将这个整体封装在对象中。

3.4 消息和方法

当要求对象执行某种操作时, 必须由外界向对象发送一条消息, 消息包括对象名和方法名, 有时还要加若干参数。类中操作的实现过程叫做方法, 一个方法有方法名、参数、方法体。

3.5 类与类的特殊关系

在现实世界中存在很多类, 有些类之间是毫无关联的, 但有些类之间具有一定的特殊关系, 有两种这样的关系:继承关系和组合关系。

如果现有一个定义好的类是“人”, 还需要再定义一个“男人”类, 可以不用对“男人”类进行重新定义, 而是选择在“人”这个类的基础上增加一个性别属性即可。“人”称为父类或基类, “男人”称为子类或派生类, 这两个类的关系叫做继承, 可以说这两个类是一种“是”的关系, 即男人是人。

如果现有一个“日期”类, 还要定义一个“学生”类, 属性中要体现出生日期, 那也可以不用在“学生”类中重新定义出生日期这一属性, 可以直接用已有的“日期”类来定义生日, 这两个类的关系叫做类的组合, 可以说这两个类是一种“有”的关系, 即每个学生都有生日, 而生日是日期信息。

4 面向对象的显著特征

4.1 封装

封装很好地实现了信息隐藏, 可以达到数据保护的目的, 即对象的属性一般不被外界直接访问, 而是通过对象的方法来访问, 从而保护了对象的属性, 为软件的模块性提供了保证。另外, 类定义将外部接口 (用户可见) 与内部实现 (外界不可见) 分离, 对象的方法其内部实现细节对外界是不可见的, 用户只管调用外部接口完成对象的一系列操作。

4.2 继承

子类继承父类的所有属性和方法, 避免了许多重复性的工作, 在一个现有类的基础上新增一些属性或方法级大地减少了软件设计的工作量。继承是面向对象编程语言区别于面向过程编程语言的最显著的特点。如果子类只有一个父类称为单继承, 子类存在多个父类叫做多重继承。在软件设计工作中, 继承是信息分类与组织的切实可行的方法, 它简化了创建类的过程, 提高了软件的可重用性, 使得软件的可扩充性大大加强。

4.3 多态

多态指相同的方法作用于类型不同的对象上可以得到不一样的结果。每个对象通过满足自身意愿的方式响应同样的消息。例如在听到统一的上课铃声后, 老师们各自进入自己任课的班级, 而不是进入同一个班级, 并且所讲的内容也都不同。多态性使得软件的可重用性和灵活性进一步增强了。

5 结语

面向对象编程思想以其独特的形式将数据以及在数据之上的操作细节封装在类中, 改变了面向过程编程思路的程序结构和整体格局, 由于其继承性可以加快软件开发速度, 并增强软件可重用性, 便于软件扩充功能, 多态性可提高软件设计的灵活性, 故从过去较长时间至今一直以来仍占据着程序设计的主流地位, 也一直是衡量各层次程序员与计算机从业人员业务素质的标准。

参考文献

[1]彭莉芬、陈俊生.浅析面向对象的三大特征[J].福建电脑, 2010 (05) .

[2]谭大海、刘兴勇.面向对象分析与设计[J].科技信息, 2014 (10) .

面向对象的思想 篇4

参赛学员：方钱有 获奖奖项：二等奖 什么面向对象: 个人分析觉得：在程序设计里,面向对象是一种相对说法，相对于面向过程而言的； 面向“对象“：即重点在于“对象”；而面向过程：则重点在于“过程”，简单说：就是我我们看待事物在眼光上注重点不一样；比如说：我们评判一个女孩漂亮与否，有的人看重外表，有的人则看重“心灵”，只是侧重点不一样。举个例子：把大象装进冰箱！

面向过程

面向对象

（注重一系列动作即过程）

（注重动作所操作的承受者［“对象”］）

“打开”冰箱

“冰箱”打开

“装入”大象

“大象”装入

“关闭”冰箱

“冰箱”关闭

类：通俗的说类就是“一类事物的简称”，并且这些事物至少具有一点“共同的”特征.比如说：动物就是一个类

对象：就是某一类中一个具体的（就是可以具体描述出来的）东西，比如：动物(类)里的“狗”就是一个对象。(个人觉得对象相对于类而言的,因为狗又可以分好多种，‘狗’相对于‘哈士奇’是一个类,‘哈士奇’是‘狗’类的一个具体对象)

在生活中就拿描述汽车来说，我们都知道汽车都有4个轮子； 都有跑的功能 可以如下描述:

类

汽车

属性： 4个轮

功能： 跑

那么怎么在Java中描述汽车这类呢？ class car{

int wheel=4;//属性： 4个轮

void run(){//方法(功能)： 跑

System.out.println(“是汽车都会跑”);

} } 那么可见“出租车”应当是“汽车”这类的一个具体化（实实在在的例子即“实例”）对象，那自然出租车也就具备了汽车这类所具备的“共有”属性功能！

如何创建一个出租车对象呢？java中通过new关键字来创建一个类的实例即对象，也叫类的实例化，就是把类具体化成一个实例嘛！格式：类名

对象名 = mew 类名

()

Car

texi =

new Car();创建了“出租车”对象（实例）之后那么它也就有了如下“自己”的属性和功能。

int wheel=4;//属性： 4个轮

void run(){//功能： 跑

System.out.println(“我是出租车我也会跑”);

} 我们如何来访问对象中的它自己的属性和方法呢？ 格式：对象.属性；

对象.方法名();

这一点也验证了面向对象编程的侧重点在于“对象”上；

texi.wheel;

texi.run()*********************************************************************************************************************************************************************************************************************************************

1.封装：

从字面可以解读为将东西封起来再装好。要想拿到里面的东西就得有相应的方法打开，才能拿到。

举例来说：一个房间的门如果没有上锁，那么大家都可以进去拿东西，但现在我们不想让谁都进来拿东西，我们可以将房门上锁，只对外提供一把钥匙，只有有钥匙的人才能进来，这就是“封装”现象！

在java程序中，“封装”现象如何实现呢？

可以这样实现：将类中的一些属性和方法用private关键字修饰，将他们“私有化（即不对外直接公开）”,使外部其他类不能通过创建该类对象或通过类名直接访问这些属性和方法;只对外提供公有的方法，外部其他类必须通过该类对外提供的公有方法来访问该类的相应成员；例如： class Person{

private String name;//将name属性私有化（封装）［相当于了上锁］使外部其他类不能直接访问到

public SetName(String name){//对外提供公有方法（相当于房门钥匙）供外部其他类访问到本类属性

this.name=name;

} }

2.继承：

从字面来说继承就是子父类关系的简称，就是儿子（女儿也行，好吧）会继承老爸的一些属性和行为

在java中如何描述继承关系呢？

注意：

第一得知道在java中继承是类与类之间或者是接口与接口之间才有继承关系；通过extends关键字来描述继承关系 例如：老爸这个类 class Dad{

String sex=man;

void smoke(){

System.out.println(“老子会抽烟！”);

} } 那么我们怎么来让儿子这个类继承老爸这个类呢？

class Son extends Dad{//通过extends关键字儿子这个类就继承老爸这个类了

String name;//定义自己的属性

String sex=man;//继承过来的属性，无须再定义，这里写出来是为了好理解

void smoke(){//继承过来的方法，无须再定义，这里写出来是为了好理解

System.out.println(“老子会抽烟！”);

}

void playBall(){//定义自己的方法

System.out.println(“儿子即会打球又会抽烟！”);

}

void somke(){//重写的方法

System.out.println(“我不抽20块以下的烟”);

}

void smoke(int n){//重载的方法

System.out.println(“我抽了+n+”年的烟了“);

} } 那么具有继承关系的两个类有什么特点呢？

1）子类会将父类的属性和方法继承过来，当然子类也可以自己定义的属性和方法 2）当子类自己定义的方法和父类继承过来的方法相同时会发生“重写“现象！3）父类用private关键字私有的方法是不能被继承的！4）子类可以使用super访问父类的属性和方法 5）子类通过重写父类方法，修改父类的功能 6）子类构造器一定调用父类的无参构造器 7）构造器不能继承

3.多态：

字面意思就是多种形态,也就是说一种事物同时局部多种形态.注意：要出现多态情况，那么类和类之间一定得是继承关系，或者类和接口是实现关系 我觉得：在java中多态是相对于一个对象而言的，就是父类型引用变量引用子类对象，并且父类型引用变量可以接受不同子类的对象 例如：拿上面的举例

Dad uncle=new Son();父类引用变量uncle即具备Son类的成员又具备父类的成员；这也称为“向上造型”； 多态时的特点

1）多态时访问成员变量，如uncle.name;编译时看等号左边，父类有该成员变量则编译通过，否则编译出错！运行时也看等号左边，有则运行结果 2）多态时访问方法,如uncle.smoke()编译时看等号左边，父类有该成员方法则编译通过，否则编译出错！运行时看等号右边，父类有该方法，子类没有该方法执行父类方法；父类有该方法，子类也有该方法执行子类方法 3）多态时访问静态方法 编译运行都看等号左边

******************************************************************************************************************************************************************************************************************************************************************

4.抽象(有争议)：

什么是抽象？

抽象就是不具体。

一般我们把不能具体描述的东西约定俗成为“抽象”的东西。例如：我们说一个人长得很“抽象”,n你想你能具体形容描述出来么？ 在JAVA中如何描述抽象这个概念呢？

我觉得在java中抽象类是由抽象方法而衍生出来的，为什么呢？

因为Java规定一个类中定义了抽象方法那这个类就跟着必须定义为抽象类，而不是因为先定义抽象类再跟着规定抽象类中的方法必须是抽象的，可能最后理解的结果是一样的但性质是不一样的（个人理解）简单说：就是有抽象方法的类一定是抽象类，但是抽象类中不一定都是抽象方法，也可以有具体方法。首先就是当我要在一个类定义一个方法时，暂时我不知道该方法具体功能是什么；等我想好了我在用他实现一个功能时我再具体描述他功能，这样我们就可以将这个方法用abstract关键字修饰定义为抽象方法

（还有一点也就是什么时候定义抽象类的？也可以说抽象类是向上抽取而来的，就是几个类据有共同的属性和方法，不想每个类都定义一次，那么定义一个公有类（即抽象类）其他类只要继承抽象类再重写方法就行！）

例如：我有一百块钱，现在我不知道怎么用，等我想好了在具体怎么用！abstract class Money{//因为有了抽象方法所以必须定义为抽象类

public abstract void buySomthing();//现在不知道怎么用，那就把它的功能代码体去掉 } //现在我饿了，想买东西吃了，我就知道怎么用了 class Hungry extends Money{

void buySomething(){

System.out.println(”我饿了，现在我要买东西吃！“)

} } 抽象类的特点

1）抽象类不能实例化 2）抽象类可以继承抽象类

3）继承抽象类必须得重写抽象方法

5.抽象类，接口，普通类 的不同点和相同点？

1）不同点：

普通类

接口

抽象类 可以直接实例化对象

不可以直接实例化对象

不可以直接实例化对象

可以定义任何成员

只能定义抽象成员方法和常量

成员方法必须定义为抽象其他和普通类相同

可以被继承

类可以实现接口，且可以实现多个接口

可以被继承

接口可以继承多个接口

抽象类有构造方法，接口中不能有

抽象类有普通成员变量，接口中没有

抽象类可以有非抽象方法，接口中不能有

抽象类可以用public、protected修饰，接口中只能public（默认public）

抽象类包含静态方法，接口中没有

接口中的变量只能是public static final，抽象类中可以是任意类型修饰

2)相同点：都可以用于描述(封装)事物的，内部类分为哪几种？分别如何创建对象？ 分为 局部内部类，匿名内部类...3种

1）外部类名.内部类名 对象名＝new 外部类名（）.new 内部类名（）2）外部类名.内部类名 对象名＝外部类名.new 内部类名（）3）....不记得了第3种 匿名内部类

二、集合集合的定义？

集合：用来保存一组数据的数据结构

集合的父接口，实现接口，实现类，实现类的常用方法是什么？(建议以树状图画出来，便于加深印象)。

Collection

list

set

Arraylist

LinkedList

HashSet TreeSet

1.List集合

List集合的特征是元素可重复且有序 ；我们可以把他看成是一个动态数组，一般通过下标访问

ArrayList和LinkedList最常用的两个子类实现 1)list可以使用for循环遍历 for（int i=;i

list.get(i);} 2)list的浅层复制

调用ArraryList.clone()方法

注意：不能使用list.clone(),clone()方法是Object类的方法,list是接口是不能继承Object类的

2.Set集合： 不重复且无序集

遍历set只能迭代器，用迭代器遍历集合遵循的操作原则:先问后取。问一次取一次。Iterator it=set.iterator();while(it.hashnext()){

E e=it.next();} 3)map表

Map存储数据使用key-value(键-值)对的形式存储数据的。

对于Map而言，要求key值是唯一的。value值可以重复

获取数据时，使用key可以获取其对应的value 遍历map有3种方法 1）遍历key

Set keySet = map.keySet();

for(String key:keySet){

System.out.println(”key：“ + key);

//可以根据每一个key获取其对应的value值

int value = map.get(key);2)遍历value Collection values = map.values();

Iterator it = values.iterator();

while(it.hasNext()){

int value = it.next();//不能采用 map.next()

System.out.println(”value:“ + value);注意：通过迭代器在遍历集合的过程中，不能通过集合(即不能采用 map.next())去改变集合元素数量

3)遍历键值对

Set> entries= map.entrySet();

for(Entry entry : entries){

//获取一组键值对的键和值

String key = entry.getKey();

int value = entry.getValue();

System.out.println(key + ”=" + value);

Collection接口方法的定义

这里我主要列举 Iterator iterator()方法的使用

Collection提供的方法 Iterator iterator()方法来获取迭代器 Iterator是一个接口，定义了遍历集合应有的方法。

使用迭代器遍历集合遵循的操作原则:先问后取。问一次取一次。

问：boolean hashNext()

取：Object next()

迭代器可以将取出的数据删除掉

删：remove()将当前获取的元素删除掉。

注意：1)删除的是next()取出的元素。且只能删除一次！

面向对象的思想 篇5

关键词：面向对象,设计模式,模块化,映射

在手机开发平台中,从硬件到软件,采用了分层架构设计,整个系统分成Hardware、BIOS、OS、GUI和APP等层结构,并进行了合理地封装。每一层构成了功能完备的子系统,并为上层提供服务。层与层之间采用消息的方式进行通信,很好地保证了子系统之间的信息隔离。同时,按照功能的需求对子系统又可以进行进一步划分。在模块划分过程中,按照粒度粗细可以将整个系统分成三个级别的模块:子系统(粗粒度)、模块(中粒度)和组件(细粒度),每个子系统可以划分为各个模块,在模块内部又可细分为各个组件。在不同级别模块的划分上,存在不同的特点与难点。针对上述手机平台功能性需求比较复杂,数据量相对少而简单,但对系统的实时性和效率要求较高的情况,可以把面向对象的分析和设计方式引用到手机开发平台设计中,利用模块化的设计思想提供良好设计公共接口,进行接口与实现的分离,从而实现手机软件开发的模块化,并且有利于后期整个系统的扩展和维护。

C语言是一种面向过程的程序设计语言[1],在C语言的基础上建立的C++语言是一种面向对象的程序设计语言。如果在开发C语言程序的同时,使用面向对象分析方法,这样开发的程序将会具有面向地对象程序的设计优点[2]。C语言运用比较灵活,执行效率高,与汇编语言联系紧密,可以开发出非常精巧的软件系统,但C语言没有名字空间和类的概念,缺少封装机制和访问级别,数据和操作各自分离,给模块化工作和维护带来较大难题,为此本文使用一个映射机制将对象的分析模型转换到过程设计模型,即对象映射到组件,从而实现模块化编程。

1面向对象分析设计思想

利用面向对象的方式进行思考[3],既可以提高软件开发的模块化,又符合人类思维的特点,它是人类认识世界的方式。对象包括数据和对数据进行操作的行为。对象在收到请求或消息后,执行相应的操作。请求或消息是使对象执行操作的唯一方法,操作又是对象改变内部数据的唯一方法。由于这些限制,对象的内部状态是被封装的,它不能被直接访问,它的表示对于对象外界是不可见的,外界只能通过其公开的接口(操作)访问对象的数据以及相关的操作。将面向对象的分析设计方式引用到手机软件开发中,可以提高手机软件开发的模块化,增加可理解性和可维护性。在手机运行环境中,存在大量的功能性需求。在进行模块的划分工作后,每个组件对应一个对象,而每个功能性需求对应对象的一个具体行为。由于在手机运行环境中,功能要求复杂,数据结构相对简单;同时,数据内容具有不断更新的特点。为了避免对象创建和销毁时不必要的开销,保证数据传输的实时性,提高运行效率,可以采用SINGLETON的设计模式[4]。在这种模式下,每个对象只需保证一个实例,而且可以严格控制客户怎样、以及何时访问它,提高运行效率,满足手机运行时所需要的功能性需求。因此,可以为对象提供一个全局变量,供对象的所有操作进行访问,而这些操作可以由组件中的函数实现。如图1所示,介绍了不同阶段从建模到实现的关系。

将对象的数据和操作映射为组件的数据和函数后,需要提供组件的封装和访问机制。对于每一个组件,针对三个级别的模块划分,相应需要提供三种级别的封装和访问机制[5]:public、internal 和private,参见表1。public 提供了模块外访问的接口,可以被其他模块使用,在子系统设计时划分模块的过程中就已经确定;internal 提供了模块内部访问的接口,是模块内其他组件通信的桥梁,由模块的设计者提供并实现;而private 是组件内部使用的一些私有接口,提供了进行内部操作的辅助行为。

这些机制为对象的封装和访问提供了良好的方法,充分保留了模块设计和实现时的信息,降低了不同人员交流的难度,增加了模块的可理解性与可维护性。

2结构化开发环境的编码实现

在结构化开发环境中,由于实现方法是非面向对象的,需要使用一个映射把面向对象的分析模型转换到过程设计模型,即需要将对象映射到组件(每个源代码文件)。在每个组件中,对象的数据封装到一个structure 结构中。由于考虑手机开发的特点并采用SINGLETON 设计模式,每个对象只需保证一个数据备份,因此可使用一个全局变量记录这个结构的数据,以便在对象的操作中共享这一个全局变量,为提高对象的模块化,其访问级别应该设为private。同时,使用public 访问机制向模块外公开其访问接口或使用internal 访问机制向模块内公开其访问接口,其中,对数据的访问采用公开的Set 和Get 方法进行。

利用C语言[6]开发环境的特点,可以在组件中将对象的封装与访问通过三个文件File.i、File.h和File.c 实现,这三个文件的关系见图2。隐藏或暴露一个接口的方式只需将这个接口的声明从一个文件移动到另外一个文件中。将模块中的所有组件组织成一个包后,可以定义一个统一的模块接口文件module.i,其内容包含了该模块中所有的File.i 文件。模块接口文件在所属的子系统中定义,由模块中的组件实现,并供其他模块使用,整个子系统中各模块间的关系如图3所示,图3中的虚线显示了各模块和各组件间的依赖关系。

从图3中可见,在子系统设计中进行了模块的划分,将模块组织为包,声明了模块的接口module.i,并指出了各模块间的依赖关系。在模块设计中,进一步划分了各个组件,将module.i中的接口分布在各个File.i 中得以实现,模块的可理解性[7]和可维护性都得到了提高。

3源代码开发示例

以“用户来电”这一场景进行分析,“用户来电”的时序图如图4所示,从时序图片断中可以看出各模块间的交互关系,这些交互关系定义了每个模块对其他模块的外部接口。其中CallLog 模块的外部接口有:接口1——存储来电记录(StoreCallLog ToQueue),接口2——查看来电记录(Display CurrentCallLog),接口3——显示号码(Display PhoneNumber)等。

这些接口可大致分为两类:接口1 与Data 直接相关;接口2 和接口3 与UI 直接相关,而后者又与Data 间接相关,即需要访问Data 的某些接口。因此在Call Log 子模块——allLogData中,接口被分为三个层次,如图5所示。图中符号“+”代表该接口可被外部模块访问,“#”代表该接口可被模块内部其他子模块访问,“-”代表仅能在该子模块内部访问,其中包含相关的数据信息。

从图5可知:CallLogData 子模块中必须被维护的外部接口为StoreCallLogToQueue 函数,该函数被Call 模块所调用;-CALLLOGITEM 数据结构被局限于CallLog 模块内部访问,可以被CallLogUI 子模块引用;而_CALLLOGQUEUE 数据结构被局限于CallLogData 子模块内部访问,不能被其他任何文件引用等。这些信息在分析与设计阶段已经被充分考虑,此处以源代码的形式在实现阶段保留下来,分别被不同的开发人员所理解和维护。

4结束语

本文通过前述三种封装和访问机制,保证了架构中各个模块接口的实现和模块的独立性[8],应用面向对象思想和三级封装和访问机制之后,模块与模块之间的依赖通过.i文件进行,内部依赖通过.h文件进行操作,相互依赖性减少,模块的独立性增加;系统设计信息和模块设计信息分离,分级暴露数据结构和全局变量的定义;另外模块接口不变,内部接口的修改对其他模块没有影响,修改代码也少。总之,在结构化编程语言中采用面向对象思想进行设计,一方面需要有面向对象分析的思想,另一方面需要提供恰当的封装和访问机制,这样才能更好地实现模块化,提高手机开发平台的可扩展性和可维护性。

参考文献

[1]黄锡伟,胡建彰.一种基于面向对象思想和结构化技术的软件开发方法.小型微型计算机系统,1996;17(4):17—24

[2] Erich G,Helm R,Ralph J,et al.设计模式—可复用面向对象软件的基础.李英军,马晓星,蔡敏,等译.北京:机械工业出版社;2000

[3]车万方,张凤鸣,宋志平.基于UML的C3I系统体系结构的面向对象分析和设计方法.系统工程理论与实践,2003;23(7):88—94

[4]赵慧.面向对象技术模式之Singleton及其应用.南通职业大学学报,2004;18(2):43—46

[5]龙鹏飞,张芳.面向对象方法在嵌入式应用软件开发中的应用.计算机应用与软件,2007;24(8):53—56

[6]谭浩强.C程序设计(第四版).北京:清华大学出版社,2010

[7]何昭.基于面向对象框架的软件开发方法.计算机工程,2002;28(4):5—6

面向对象的思想 篇6

软件无线电系统具有开放、标准、可扩展的特性,同时具有较高数据吞吐率的硬件体系结构[1],已被广泛应用于雷达、电子战、测控等军事网络系统。随着此类系统工程的日益庞大,传统从下而上的大系统集成设计方式,已经无法满足应 用体系的 构建需求。 系统体系 (SystemofSystem,SOS),又称“系统的系统”,为此类大 型应用系 统的开发提供了一种解决方案。

系统体系将系统描述成由众多组件系统(ComponentSystem)集结而成[2]、组织关系松散的自适应体系,尤其适合于构建软件无线电系统这样一个由若干个天线、数字接收机、信号处理机、控制计算机和数传板等有限硬件和大量信号处理软件组件集成的相互协作的复杂系统。

在以往软件无线电系统产品的研发过程中,通常采用面向过程的设计方法。由于面向过程的设计方法倾向于针对特定需求开发一种相对稳定的集成系统体系结构(内向型体系结构),而软件无线电的应用领域十分宽泛,应用的作战环境复杂、作战使命千变万化,系统组成日益复杂,使用面向过程的开发思想,显然已难以满足软件无线电系统体系设计的要求。相对于传统的设计方法,面向对象的设计方法自始至终保 持连贯可 重用性,具备良好 的扩展性,这种自底向上归纳和自顶而下分解相结合的方法,更适用于软件无线电系统体系设计。

本文将面向对象的思想引入软件无线电系统体系设计中,以系统建 模语言 (SystemModelingLanguage,SysML)为建模工具,举例说明一个典型的软件无线电系统体系的设计过程。通过分析这种面向对象思想的设计方法,指出其应用价值。

1软件无线电系统体系

系统体系是一系列以任务为导向的专用系统的集合,集合而成的新系统不只是原有组件系统功能和性能的简单堆砌,而是能够根据系统目标和不断变化的需求进行重组,完成固定系统所不能达到的系统目标。系统体系具有组件系统自治管理、相互协作、松耦合集成的特点,并具有能够根据需求变化柔性应对的特性。本文将系统体系的概念引入软件无线电系统设计中,目的就是根据软件无线电的特点寻找一种适合软件无线电系统体系的设计方法。将软件无线电的组件系统定义为各自独立的分系统,将整个系统体系视为使用方,每个组件分系统视为提供方,则一个具备SOS特性的典型的总线式软件无线电体系结构可用图1来表示。

从图1可以看出,标准组件提供方负责建立、维护、升级和发布标准组件库,如适应不同工作性能、状态和环境的信号处理组件。所有组件系统均按照技术标准保证技术实现,并分类、分层管理,定期发布组件索引库,提供指标、接口和能力等条件的搜索接口。

使用方在搭建软件无线电系统时,首先根据系统需求明确执行的技术标准、接口协议和总线系统,分析系统需要的组件类,并分解、计算出组件接口和指标,然后根据这些因素在组件系统指标库中搜索适用的标准组件,通过搭积木的方式实现系统。

由此可见,使用方不需要关注组件的具体实现细节,只需将设计重点放在分析系统的技术标准、接口和指标能力上,从标准组件库中选择最优的模块组合,从而实现软件无线电系统体系根据需求状态而“柔性”变化。同时,相对统一的组件系统指标库和技术标准,也可以保证不同软件无线电系统之间的横向复用性。

2面向对象设计过程

2.1面向对象思想与建模语言

起源于软件工程领域的面向对象思想,强调从客观世界固有的事物出发,用人们认知世界和描述客观事物的思维习惯,强调客观事物的对象映射,对象与对象之间的关系如实地反映客观事物及其关系。使用面向对象方法可以保证系统设计的可重用性、可扩展性和可维护性。

SysML是在UML2.0基础上外扩的一种面向对象建模语言,支持包括 美军的国 防部体系 结构框架 (DepartmentOfDefenseArchitectureFramework,DODAF)和我军的C4ISR (Command、Control、Communications、Computers、Intelligence、Surveillance、Reconnaissance)系统在内的系统体系架构标准。SysML能对系统工程的各种问题进行建模,适用于系统工程的不同阶段,特别是在系统工程的详细说明阶段和设计阶段,使用SysML来说明需求、系统结构、功能行为和分配非常有效[3]。因此,可以使用SysML对具有面向对象思想的软件无线电系统体系进行建模。

SysML的图形分类如图2所示,共定义了9种视图,分为4类,即需求图、结构图、行为图和参数图。行为图包括活动图、时序图、状态图和用例图;结构图包括块图、内部块图和包图。在完成系统建模的过程中,可以根据需要选取SysML中9种视图中的任意组合进行分析描述。

2.2软件无线电系统体系的面向对象设计过程

众所周知,面向对象设计方法具有抽象性、封装性、继承性和多态性。利用其抽象性,将每个组件系统视为一个类或者对象,从而确保组件系统的管理独立;利用其封装性,保证组件系统独立操作的能力;利用其继承性保证组件系统的演化发展;利用其多态性保证组件系统在不同软件无线电系统中的呈现行为;面对对象的设计方法对组件系统的地理位置无特殊要求。通过以上分析可以看出,面向对象的以上四大特性可以满足系统体系的五大特征,因此,在复杂的软件无线电系统设计过程中,使用面向对象的设计方法,能够始终保持系统体系的“柔性”特征。

使用面向对象的方法进行软件无线电系统体系开发,须遵循两个基本原则:“自顶向下,宽度适当”和“基于信息的交互”[4]。体系结构产品描述的首要原则就是“自顶向下,宽度一致”[5]。所谓的自顶向下就是将软件无线电系统视为一个“黑箱”,依据对其应用需求的分析,将这个“黑箱”划分为天线、接收机,处理机和控制台等顶层组件,再分别对这些组件逐层分解成二级组件、三级组件……随着分解层数的增加,分解的组件成几何级数增长,将导致管理和研制成本的急剧增加,因此要根据项目的技术特性适度控制分级的层数;同时,为了避免分解层次的“烟囱式结构”,也需要控制分解粒度,即控制每一个组件组成的横向宽度。一个软件无线电系统被自顶而下地从系统级分解到分系统级,从分系统级分解到单机级,再从单机级分解到独立的子模块级,在完成系统体系架构的同时,也保证了系统的纵向重用性和横向扩展性。

按照面向对象方法,系统体系中每个模块可以抽象为一个类。系统设计师在构建软件无线电系统时,以无线电信息的获取、处理、传输和应用为主线,将系统工作过程中涉及的模块映射为一个个相互交互的类或者对象,依据模块的接口、能力等确定类的输入和输出元素,使用对象、类之间基于数据的交互机制来实现软件无线电系统内部组件之间的信息交互。

基于以上设计原则,使用SysML建模语言和面向对象的设计方法来描述软件无线电系统体系的设计过程,可以分为4个步骤:建立需求模型、确定结构模型、明确模块之间的交互模型、设置参数模型。本文以图1中所示的总线式软件无线电系统体系为例,描述面向对象方法进行系统设计的4个步骤。按照系统特性和关键技术要求等因素可以对软件无线电系统的组件系统进行进一步分解,在分解建模的过程中,可以选取SysML中9种视图中的任意组合进行分析描述。

2.2.1系统需求模型建立

利用需求模型建立系统需求是系统设计的第一步,一个简易的软件无线电 系统需求 可以描述 为如图3所示。需求模型按照层次化的方式描述系统需求之间、需求与其它需求之间的关系。

如图3所示,一个简易的软件无线电系统需求包括总体需求、功能需求、性能需求和资源需求等基本需求,并可以在基本需求的基础上从横向和纵向上扩展,丰富系统的需求描述。

2.2.2系统结构建模

系统需求描述完以后需要进行系统结构建模。可以使用SysML中的块定义图 和内部块 定义图对 系统结构模型进行描述。块定义图是对系统组成结构和系统结构层级化的可视化定义 和展示,模块层级 化关系包 括组合关系、聚合关系和泛 化关系等。内 部块图从 模块组件 如何相互连接的角度来描述模块的内部结构情况和联系方式。一个简易的软件无线电系统的 块视图如 图4所示,图中顶层为软件无线电系统(系统),其中数传系统、控制计算机、信号处理机、数字接收机和天线是其固有资源(资源),信号分析处理机可以在不同系统中应用是其临时资源(实体)。

2.2.3系统交互模型确立

系统需求和结构特征固化了以后,系统设计的重点就是要明确系统组件之间的行为关系。SysML中提供了活动图、用例图、状态图和时序图4种视图来表示系统的行为特征。根据软件无线电系统体系的特点,可以选时序图作为内部组件交互关系的主要视图描述。

2.2.4系统参数模型设置

系统设计的最后一步是设计参数结构及关系,以表示各个组件属性值之间的耦合关系,以及各属性值的变化对其它属性的影响程度,如软件无线电系统中采样速率和带宽之间的参数关系。借助于SysML建模方法,可以使用SysML的参数图来描述系统性能指标参数方面的要 求、约束及关系、定义系统属性以及属性之间的关系。

通过以上4个步骤完成软件无线电系统体系的分解,建立需求模型、结构模型、交互模型和参数模型,分别从不同的角度对总线式软件无线电系统进可视化描述,实现系统的总体架构设计。

3面向对象软件无线电系统体系设计应用价值

使用面向对象软件无线电系统体系的设计方法,可以使系统设计人员只关注某个层次的组件设计、组件属性和组件之间的关系,而不需要深入到各个组件的内部详细设计。与传统设计方法相比,采用面向对象系统体系设计方法具有广泛的优势,两者特性比较如表1所示。

从表1可以看出,面向对象体系系统设计方法,将系统组件抽象成一个类或者对象,保证了系统的封装性和继承性。其系统体系特性具备扩展性,子系统之间能够实现松耦合、动态组合和自治管理。这种设计方式非常适用于软件无线电系统应用领域,能够满足越来越复杂的系统架构和需求多变性要求。

4结语

本文将系统体系的概念和面向对象的设计思想引入软件无线电系统开发中,提出了一种软件无线电系统的设计方法。以一个总线式软件无线电系统为例,从系统顶层开始分解,将组件系统抽象成一个独立的类或者对象,使用当前流行的系统建模语言SysML进行系统建模。利用这种逐层分解、分析建模的设计方法,可以使软件无线电系统体系的设计具有面向对象的特性。对比分析表明,这种设计方法具有较好的应用前景。

摘要：为了适应并促进软件无线电应用系统的发展,提出一种基于系统体系(System Of System,SOS)的概念和面向对象思想的设计方法。通过对软件无线电系统体系和面向对象设计方法特性的分析,确定使用面向对象设计方法的合理性。以一个简要的软件无线电系统体系设计为例,使用系统建模语言(System Modeling Language,SysML),介绍面向对象设计具体步骤。

从面向过程到面向对象的变革 篇7

1“软件危机”与面向过程方法

20世纪60年代中期,随着计算机技术的逐步成熟,计算机应用范围的逐渐扩大,软件开发领域急剧膨胀,这时,软件开发人员开始面临一个十分严峻的问题——“软件危机”。

“软件危机”主要表现为三点:第一,开发出来的软件的功能和用户的需求往往“牛头不对马嘴”;第二,软件系统的规模和复杂度的扩大让开发人员力不从心,开发过程中的一些错误已经达到开发人员无法掌控的地步;第三,开发出的软件可维护性很差,要复用已有成果或者对其进行扩展都很困难,软件的进化也很难跟上硬件发展的速度。

追究“软件危机”产生的原因,固然有一部分是因为开发者缺乏对大规模软件的管理经验,缺乏正确的方法学指导或者是开发工具的支持(杨健,张晓玲,周少,2006,135-136),但是最关键的问题在于——当时大多数软件开发工作的全过程,包括分析,设计以及编程实现等,都采用面向过程方法。具体来说,在分析阶段,开发人员根据面临的情况,如用户的需求,软件要求的功能等,做出一个物理模型,其次转换成逻辑模型,再通过数据流分析,把这个模型转化数据流图,记录数据字典。在设计阶段,开发人员根据数据流图划分数据类型,并映射到不同的程序模块类型,通过这样完成分析模型到设计模型的转变,并设计出数据结构图。然后,开发人员在此基础上详细的设计每个程序模块内部的结构和算法。常常是把大模块又分成很多小模块,多次分解,最后再设计完成每个小模块的内容。在实现阶段,利用面向过程的编程语言(如C语言等)进行编程,具体实现整个软件系统。

之所以说这一套方法是导致“软件危机”的关键,是因为它不论是在分析和设计上,还是在编程实现上都存在很大的弊端。

第一,面向过程方法的分析手段是不够妥当的。整个分析和设计阶段可以概括为“需求-数据流-程序模块”的模式,所以对于需要解决的问题,在分析阶段并不能直观的显示出各种事物及其关系,而是映射到数据流中进行分析。因此,当系统比较复杂的时候,很难判断基于数据的分析是否有偏差,是否相对于原本的实际问题有出入,或是否存在理解上的错误。也正是因为所有的分析工作是基于数据流的,开发人员在分析阶段就面临和用户沟通上的困难,他们很难和用户解释数据流图中的内容代表了什么,很难通过沟通发现分析结果和用户需求的差距在哪。并且,如果用户在开发工作的中途想改变一些需求或是外界条件发生了变化,开发人员也不能直接改动分析结果,必须重新映射到数据上再做调整。

第二,从分析阶段到设计阶段的转化是有很大的隐患的。所谓的“数据—程序模块”的转型就是依照一些对应原则,把数据流图转化成程序模块,这两种不同的体系之间的转换是否正确,是否合理是没有保障的。这种“需求-数据流-程序模块”的模式就像多人传话一样,第一个人传话给第二个人,第二个人根据自己的理解把话传给第三个人,第三个人再加上自己的理解,得到的结果和原话已经不是一个意思。原本的内容经每个步骤都被不同的体系“转义”了一遍,这样很可能导致设计出的结果和软件需求的本来面貌相差甚远。

第三,由于面向过程的程序语言本身存在很多不足,导致软件开发的实现阶段出现了很多问题。首先,程序的安全性缺乏保障。很多关键的数据既可以被作用于它们的操作访问,也可以被其他的操作访问。并且,面向过程的程序操作都属于“白盒操作”,所有细节都被暴露在外。一个疏忽的数据修改或者程序调用都可能导致整个系统崩溃。其次,程序员的工作非常繁杂。由于数据和函数是分开来处理的,程序员在编程的时候要考虑的因素就很多,每次编写一个函数都必须把详细的注释添加到数据字典中,对于不同类的数据进行一种操作或者同一类数据进行不同操作都必须写不同的代码。这种编程对程序员的水平要求非常高,仅仅让数据和函数一直保持兼容就已经是程序员沉重的负担。在团体合作中,一个程序员要接手另一个程序员的工作往往需要阅读数十页的数据字典,不同的程序员编写的程序可能还存在着名称重复,风格迥异等冲突,这些问题在复杂的系统中将凭空地加大程序员的工作量。再次,软件的可维护性很差。由于数据和函数代码的分离,每当数据发生改动,所有相关的函数都要重写,想对整个程序进行扩充,升级,或者移植到别的背景下重用都面临着大量的代码修改。

2 面向对象方法

我们可以看到,面向过程方法确实给软件开发工作带来了很多困扰,而面向对象方法正是在这种情况下诞生的。面向对象总的来说有三大特点的:封装性,继承性和多态性。

封装性是面向对象最基本的特点,因为它体现了面向对象最基本的思想:客观世界是由各种对象组成的,复杂的对象可以由比较简单的对象以某种方式组合而成(符于江,2008,451-456)。所有的对象都具有静态属性和动态行为,把相似对象的属性和行为抽象出来,用这些共同的属性(数据)和行为(方法)构成类,作为创建具体对象的模板。封装性就是指把关于一个类的所有数据和方法一起封装在类的内部,只通过一些方法作为对外沟通的接口,外界只能通过这些接口和对象进行联系,而对象内部的很多数据和具体操作是对外不可见的。

继承性是指对于一些具有一般意义的类,可以创建它们的子类,子类可以继承一般类的所有属性和方法,同时可以根据自己的特性,修改继承得来的属性和方法或者添加自己独有的属性和方法。比如对于一般类“亚洲人”,我们可以创建子类“中国人”,“韩国人”等。

多态性有两种形式。第一种是一个类中同名字的方法可以接受不同类型的参数,对于不同类型的参数的处理是不同的。比如在一个类中定义“add”方法实现数的相加,它既可以处理整形的参数,也可以处理浮点型的参数,还可以处理一些自定义类的参数,但是针对每个类型都有各自的处理操作。第二种多态和继承性有关。由于某个父类可以有多个子类,每个子类都可以根据自己的特征修改父类中的属性和方法,当把这些子类当成父类来用的时候(如JAVA中的上转型对象或是接口回调),相同的父类方法就会有不同的实现方式。例如一个JAVA程序中,对于父类“动物”中的方法“叫”,用子类“狗”的上转型对象实现该方法则输出“汪汪”,用子类“猫”的上转型对象实现该方法则输出“喵喵”。

基于以上三大特点,面向对象方法导致了对整个软件开发过程的彻底变革。在软件开发的分析,设计和实现阶段都和面向过程方法截然不同。开发人员首先按照需求分析出软件的每个必备功能。然后归纳属性,确定对象及对象之间的关系。再进一步把功能分配给每个对象,构建对象的行为。接下来对每个对象的方法和对象之间的交互作进一步的细化。再接着确定可重用的类和部件,用结构图画出各个类,部件的结构和相互依赖关系。最后再对软硬件的相互依赖关系进行描述。在以上分析和设计工作完成之后,开发人员利用面向对象程序语言进行编程来达到软件功能的实现。

3 面向对象方法的优越性

面向对象方法之所以能把软件开发带入了一片新天地,是因为它在以下三个方面都有卓越之处。

3.1 整体开发思维

抛开具体操作流程不说,面向对象方法首先对解决问题的整体思维进行了人性化的革新。其人性化主要体现在以下四点:首先,人们生活的现实世界是个体,群体及各种关系组成的,面向对象的系统也是如此。对象代表个体,类代表群体,对象之间,类之间,类与对象之间通过方法调用建立各种关系。其次,从大众个体中总结出一类共同的属性和行为,从而形成类的手段正是人类抽象思维的应用。抽象思维是人类最基本,最习惯的思维之一。再次,面向对象允许开发人员一开始只拟定系统的大致框架,即确定主要的类及其关系,之后再逐步对其进行细化和拓展。这和人类逐步深入的思考习惯是相一致的。最后,面向对象方法大大简化了开发人员思考问题的复杂度。比如对于一个子类,开发人员可以理所当然的认定它已经拥有父类的所有一般特征,只要把精力放在思考子类的特性上就可以了。面向过程要求程序员必须从数据流动的角度思考待解决的问题,而面向对象的这些人性化因素让开发人员摆脱了这种被迫的“机器化”思考的尴尬境地,用自然贴切的思维考虑问题。

3.2 分析和设计

面向对象方法是分析和设计阶段的合理性有了很好的改善。面向对象的分析和设计采用的是“需求-对象-类”的模式,用对象和类直观地描述系统中的事物及其关系,这样就解决了面向过程方法所导致的一系列问题。在分析过程中,这种直观性原本的保留了所有事物及其关系的原貌,因此在构建对象和抽象出类的时候,很容易被发现在理解上的偏差。同时,开发人员也很容易向用户解释各个类和对象的含义,可以及时得到用户的反馈。处理需求的改变或是外部条件的改变时,也可以直接修改相应的类和对象。除此之外,对于问题的描述和对于问题的解决都应用同一套类和对象系统,因此软件开发的分析工作和设计工作是连续的,甚至是部分重叠的,不存在面向过程中从数据流到程序模块的转化,不用担心因为一个系统到另一个系统的映射不当导致结果和目标的偏离。

3.3 编程实现

面向对象编程语言的应用使得软件工程的实现过程有了很大的改进。

首先,程序的安全性有了明显的提高。由于类的封装,对象中只有少数的成员和方法可以被外接直接调用,对象内部的实现细节也是被隐藏的。这样有效降低了程序各部分间的依赖性,整个系统一般不会因为某处变动而引发整体混乱。

其次,面向对象把开发人员的编程工作变得比较轻松和方便。每个对象的数据和操作都被封装在一起,因此开发人员很容易保持数据和方法的兼容性,并且编程时只需要对每个类进行说明,不需把对于每个数据,每个方法的描述都写进数据字典。对于被封装的方法,只要依据访问规则就可以使用,不必了解实现细节。类中描述了一类个体的共有特征,在创建对象的时候这些描述不需要一遍又一遍的重复。类和对象的设置还易于分类,管理和查找。这些改变都在很大程度上降低了开发工作对程序员编程水平的要求。

再次,面向对象让团体合作的编程更加顺畅。归功与类和对象的直观性,当某程序员利用别人的成果时不必面临复杂的查阅,学习过程。继承性和多态性允许开发团队先行确定主要的类及关系,事先统一编程标准和风格,然后再把具体的细节交给不同的人员实现,这样最终得到的结果不会面临很多麻烦的冲突问题。

最后,面向对象语言最强大之处表现为可复用性和可扩充性。通过继承已有的类可以实现可复用性,让很多类的性质可以被共享。在开发过程中,复用自己或是他人已有的成果,等于是站在巨人的肩膀上,省去了大量的工作,加速了开发进程。另外,被重用过的代码都是经过测试的,这样大大减少了编程中发生错误的机会。面向对象的三大特点使程序具有良好的可扩充性。封装性使程序各部分间的独立性很强,继承性使类程序具有层次结构,多态性是程序能够实现问题的复杂多样。当开发人眼对已有的问题有了新的认识的时候,通过继承和多态的方式,无需修改原来的父类代码,就可以再创建新的子对象类的过程中增加新属性,或删除过时无用的属性,操作或对象,达到高效的功能扩充。可复用性和可扩充性让整个软件有很强的可维护性。在修改程序的过程中,修改某个对象对别的对象影响很小,新增或修改某功能对其他功能的影响很小。同时,开发出的软件也有很好的可移植性。对于不同的使用条件,只要修改很少的代码就可以让软件重装上阵。

4 面向对象方法的局限

虽然说面向对象方法给软件工程带来了很多好处,但是它也存在自己的局限性。第一,面向对象方法对支撑它的工具和环境的要求比较高。第二,利用对象和类对问题的描述存在不足。由于客观世界中很多事物的界限并不是很清晰,这给创建对象和抽象出类的正确性和精准性都带来了困难。并且,对于同一个客观事物,不同的人从不同的角度观察分析可能会映射出不同的对象属性和方法,有的时候开发团队之间或是开发人员与用户之间可能存在分歧。第三,面向对象程序的运行效率可能比较低,由于通过继承引入了层级,过多的祖宗类和父类势必会影响运行效率。所以在实现软件的时候应该遵循“多组合,少继承”的原则。第四,封装性带来的程序内部不可见可能给软件的维护带来不便。

由于这些局限性,在处理问题的时候不能盲目采用面向对象方法,必须先分析要解决的问题类型来决定是采用面向对象方法,面向过程方法还是其他方法,或是几种方法的综合运用。

参考文献

[1]郑莉,董源,张瑞丰.C++程序设计[M].3版.北京:清华大学出版社,2004.

[2]耿祥义,张跃平.Java面向对象程序设计[M].北京:清华大学出版社,2010.

[3]张孝祥.Java就业培训教程[M].北京:清华大学出版社,2003.

[4]杨健,张晓玲,周少云.软件危机及其应对措施探讨[J].电脑知识与技术,2006(35):135-136.

[5]符于江.程序设计中结构化方法和面向对象方法的比较[J].电脑知识与技术,2008(21):451-456.

[6]郭溪川.对比分析面向对象方法与结构化方法[J].农业网络信息,2006(11):100-104.

[7]张莉,裘国永.结构化方法与面向对象方法的比较分析[J].陕西师范大学学报:自然科学版,2006(6):29-32.

面向对象的软件测试 篇8

1 面向对象测试与传统测试技术的异同

首先, 这两种技术的测试过程是相同的。都要对整个测试进行计划, 设计出测试用例, 运行测试用例, 根据结果进行测试分析, 最后是用户验收。其次, 这两种技术的测试目标也是相同的。测试的目的都是为了使得设计出来的软件能够达到期望的功能。再次, 测试也是为了用尽可能少的工作量测试出软件尽可能多的错误, 虽然在这三个方面这两种技术都是相同的, 但是在测试计划和设计测试用例的时候是有很大的区别的, 这主要是归结于面向对象软件和传统的软件的设计思路不同。传统的软件是由各个功能模块组成的, 那么在测试计划和设计测试用例的时候就要注意的就是这些功能模块之间的关系。他们之间的关系, 它们之间是调用的关系。而面向对象的软件, 它更加注重的是对象之间的相互交流。它们是通过对象来传递它们之间的消息。这也是在测试计划和设计测试用例的时候需要考虑的, 怎样的测试用例才能够更好使得软件的功能的优缺点体现出来。

2 面向对象测试的意义与现状

类是面向对象软件中最重要的概念, 也是面向对象程序的最基本的组成要素。传统的软件是面向过程的, 软件的推进必须是一个过程完结的输出作为下一个过程的输入, 必须这样按部就班的进行下去。计算机的功能就是模拟人的行为的。这样的一种软件的方法是不能达到前面讲的效果的。人是一种群体动物, 必须是在一个团体下才能够使得事情向更好的方向发展。也就是在团体的作用之下才能使资源更优, 而面向对象方法的出现就是应了这样的需求。类就是实现这种需求的最好方法, 它既可以是对象又可以是事件, 通过类之间的相互作用也达到了这种消息之间的传递。这是因为这种软件方法的改变也就造就了软件测试的改变, 传统的软件测试方法完全不能达到用小的工作量来测试软件的错误。针对软件方法面向对象的软件测试也就应运而生了。而面向对象测试是势在必然的。

3 面向对象测试

3.1 面向对象的测试模型

大家比较熟悉的软件开发模型就是瀑布模型, 它包括了需求分析, 设计, 实现和测试。面向对象的开发模型变为了面向对象分析 (OOA) 、面向对象设计 (OOD) 和面向对象编程 (OOP) 3个阶段。面向对象分析阶段需要做的就是将整个问题总结出来, 转换成计算机能够识别的语言, 那么在这个阶段就需要选择使用什么样的编程语言。在面向对象设计阶段则需要的是选择什么样的类结构, 也就是需要些什么类, 这些类能够完成些什么工作。最后的面向对象编程阶段, 用选定的编程语言来实现设计出来的类结构。这种方法有个很大的优点就是在用户需求发生变化的时候, 能够不改变原有程序。测试模型如图1所示:

从上面的图中可以看出, 对面向对象开发模型的各个阶段都进行了测试的, 对面向对象分析的测试和面向对象设计的测试是非常必要的。如果把软件的前期工作做好了, 那么后续的工作进行的才有意义, 进行完了面向对象编程测试以后, 还有三个非常重要的测试, 就是面向对象单元测试, 面向对象集成测试和面向对象系统测试。其中面向对象单元测试和面向对象集成测试是两个工作量比较大的地方。而最后的面向对象系统测试就是要参考前面两个阶段测试结果了, 主要是以用户的需求为主的。六个阶段的测试是相辅相成的, 但是在每个阶段又有不同, 它们采用的方法也会不尽相同。下面就分别介绍单元测试, 集成测试和系统测试。

3.2 面向对象的单元测试

3.2.1 基础类测试

什么是基础类, 就是我们在面向对象设计时, 设计的类, 这些类可能是些对象, 也可能是些事件, 这里并不包括那些需要继承的类, 就是一些独立的类, 没有任何的消息传递。软件的测试就是要构造测试用例, 构造的这些测试用例必须满足两个条件:前置条件和后置条件。所谓前置条件就是发生这些测试用例要满足什么样的条件, 后置条件就是使用了这些测试用例会产生什么样的后果。测试用例既要满足前置条件又要满足后置条件。在设计测试用例的时候需要根据状态转换图, 因为状态转换图中的节点代表的是状态, 而节点与节点之间的连线则表示的是一个动作, 而测试用例就是需要了解如何促使这些动作发生。满足这些动作的发生应该是在一定的范围进行的, 那么对于临界值的设计是至关重要的, 在选择测试用例的时候临界值是非常好的一个标志。设计好了测试用例需要的是怎样来使它运行, 那么就还需要一个测试用例驱动程序。测试用例驱动程序主要的工作就是运行测试用例和得到运行结果。目前用的最多的测试驱动程序是Tester类。Tester类是抽象的概念, 使用这个类的最大好处就是能够为所有的测试人员提供默认的实现。测试人员可能会有如下的操作:运行其他所有类的测试驱动程序的公共函数, 记录下这些测试用例的结果, 必须运行所有要测试的类的测试用例, 检查所有类的所有常量。具体的Tester类主要负责实现测试用例的方法, 并将它们作为测试系列不可缺少的一部分来运行。

3.2.2 交互对象测试

面向对象的程序顾名思义就是由很多的对象构成的, 这些对象相互作用来解决某类问题的。程序中的这些对象有条不紊的相互工作这是这个程序成功的关键。完成了上面提到的单元类的测试, 那么交互对象测试则是为了这些单元类之间的消息传递能够正常的进行。交互测试有两种方法:一种是把设计的测试用例嵌入到程序的交互对象中去, 另一种方法则是用上面提到的Tester类提供的测试环境, 在这个环境下使得对象之间相互作用。这种测试的前提条件就是发送对象能不能够满足接受对象的要求。单位类测试的时候采用了临界值的方法, 这里是一些动作的发发生, 临界值的方法不并不适用。如果采用穷举的方法, 那么工作量将会变得很大, 也有可能出现无穷的情况, 交互对象的测试采用的是正交阵列的方法, 这种方法就是从影响交互对象的所有因素中选出那些对所有交互对象都有影响的子集中来确定测试用例。

如何选出这个子集是正交阵列提供的一种特殊方法, 该方法首先要设计出交互对象配对的方法, 选择的组合方式必须要限制组合数量的急剧递增。正交阵列就如下表1所示是一个数值矩阵。表中的每一行都是一个变量, 这个变量在测试的软件中就是表示的那些具有相同特性的类群。变量则会有一定的取值, 每一个取值则代表了某一个特定的类。把每个变量的所有取值都列举出来就成为了一个矩阵, 也列举出了所有可能的情况。

3.2.3 层次结构类测试

面向对象程序有一个很重要的特征就是继承, 继承的好处可以减少工作量, 不会使得工作变得冗余, 大大的提高程序的性能, 这是因为这些特点也使得继承具有一定的缺点, 那就是错误的传播率提高。继承是面向对象软件新出的概念, 那么在测试的时候对这一部分怎样设计测试用例是新的问题。如果对某个类的父类已经做了完整的测试, 那么对它的子类如何进行测试呢, 为了达到测试的目标就是用尽可能少的工作量来完成测试, 那么就需要复制对父类的某些测试部分, 又因为子类不仅仅继承了父类还有自己一些新的动作或者规范, 因此除去复制的部分再添加一些对新的动作或规范起作用的测试部分即可。这样就会大大的提供工作效率。

3.3 面向对象的集成测试

面向对象的集成测试即涉及到面向对象的结构集成又涉及到面向对象的功能集成。要实现结构和功能的集成则会有类之间的关联、聚合、多态、继承。那么在测试的时候可以分成以下几种情况:

1) 关联和聚合关系的测试:将所有具有关联和聚合关系的类放到一起, 这里不需要涉及新的测试用例, 只需要找到这些类中哪个类是最开始发出动作的, 最先发出动作类的测试用例作为这种关系的测试用例, 应用驱动程序来运行这个测试用例, 观察类之间的消息传递情况。

2) 继承关系的测试:在前面的层次结构类中提到了继承关系的测试, 参照前面的方法即可。

3) 多态/动态绑定的测试:面向对象中的多态增加了程序的运行路径的多样性, 那么在设计测试用例的时候就要考虑到这个因素, 由于运行的轨迹不同那么测试用例的设计可能就会出现变化。那么测试用例的数量就会发生变化, 应该包括所有的执行路径。

3.4 面向对象的系统测试

面向对象的系统测试和传统的系统测试是一样的, 都是为了验证设计出来的软件有没有达到用户的需求, 在满足了用户需求的前提下再考虑软件的性能是不是满足了最开始面向对象分析时提出的要求。系统测试的时候可以采用传统的系统测试的方法, 但是在设计测试用例的时候还是会有不同的, 测试用例的设计还是需要考虑从对象入手。

4 总结

通过对面向对象测试过程方法的分析, 根据本文中的图1就可以了解到测试并不是和开发过程分开的, 它们之间是密不可分的。在整个开发过程要随时都做到随时测试, 这样做的好处就是能够尽早的发现问题, 这样就会及时作出修改。该文中提到了很多解决不同阶段的测试方法, 但是这些都是在理论层次的探讨, 在实施的过程中仍然会遇到这样或那样的问题, 因此后面的研究就着重在如何使理论和实际达到高度的统一。

摘要：软件的测试时软件开发的重要部分, 是保证软件质量提高软件性能的关键。面向对象的软件测试具有它自己的特点, 需要与传统的软件测试相区别, 因此面向对象的软件测试则被分成不同的阶段, 本文将面向对象软件测试层次划分为六个个层次, 主要介绍了面向对象软件测试的以下三个层次:类测试、集成测试和系统测试。

关键词：面向对象,单元测试,集成测试,系统测试

参考文献

[1]武海丽.面向对象的软件测试[J].中国高新技术企业, 2008 (12) .

[2]李伟龙.面向对象的软件测试[J].科技资讯, 2008 (26) .

[3]刘维光.面向对象软件测试的方法研究[J].电脑知识与技术, 2006 (29) .

浅析面向对象的建模方法 篇9

面向对象方法学也称为面向对象的开发方法, 它属于软件工程的范畴。面向对象方法学的出发点和基本原则是尽可能模拟人类习惯的思维方式, 使开发软件的方法与过程接近人类认识世界解决问题的方法与过程。也就是说, 面向对象方法是一种崭新的思维方法, 它是把程序看作是相互协作而又彼此独立的对象的集合。由于对象的独立封装, 模块的可构造性、可扩充性、可重用性也大大加强, 从而面向对象的软件工程能够胜任当今大规模复杂、易变软件系统开发应用的要求。

面向对象的软件工程要求首先对系统建立模型是对现实的简化, 它提供了系统的蓝图。一个好的模型只需抓住影响事物发展的主要矛盾, 而忽略那些次要矛盾。每个系统可以从不同方面用不同的模型来描述。因而每个模型都是在语义上闭合的系统抽象。通过建模可以按照实际情况对系统进行可视化模型详细地说明了系统结构或行为, 指导我们构造系统模板。

二、面向对象建模方法

建模是构造软件系统最基本的步骤, 在软件工程学科中提供了多种多样的建模方法和高效的工具, 其目的是为了在软件开发过程的早期就发现设计中可能隐含的缺陷和错误, 对于今日的大型软件系统, 采用一种合适的建模方法, 建立一个良好的模型是成功的关键。在市场上已有一些公司, 如Rationa1, Cayenne, Platinum等开始提供商品化的建模工具, 即通常所谓的CASE工具, 使得建模过程实现了一定的自动化的标准化, 并逐步走向实用, 而这些工具的后面, 便是具有不同特色的建模方法。

(一) Booch方法

Booch方法是由Grady Booch提出的, 是一种主要面向设计的方法, 它通过二维图形来建立面向对象的分析和设计模型, 强调设计过程的不断反复知道满足要求为止。Booch方法特别注重对系统内对象之间相互行为的描述, 注重可交流性和图示表达。但在方法学上并不注重严格的过程, 既不推荐软件设计人员该做什么, 只是指出了其可做的工作。Booch方法把几类不同的图表有机地结合起来, 以反映系统的各个方面是如何可相互联系而又相互影响的。这些图贯穿于逻辑设计到物理实现的开发过程中, 包括类图、状态图、对象图、交互图、模块图和进程图。

(二) OMT方法

OMT (Object Modeling Technology对象建模技术) 是由James Rumbaugh等人提出的。OMT方法包含了一整套的面向对象的概念和独立于语言的图示符号。它可用于分析问题需求, 设计问题的解法以及用程序设计语言或数据库来实现这个解法。OMT方法用一致的概念和图示贯穿于软件开发的全过程, 这样软件开发人员不必在每一开发阶段便换新的表示方法。

OMT方法从对象模型、动态模型、功能模型3个不同但又相关的角度来进行系统建模。这3个角度各自用不同的观点抓住了系统的实质, 全面地反映了系统的需求。其中, 对象模型表示了静态的、结构化的系统数据性质, 动态模型表示了瞬时的、行为化的系统的控制性质, 功能模型则表示了变化的系统的功能性质。在软件开发的周期中, 这3种模型都在逐渐发展:在分析阶段, 构造出不考虑最终设计的应用域模型;在设计阶段, 求解域的结构被加入到模型中;在实现阶段, 应用域及求解域的结构被编码。

(三) OOSE方法

OOSE (Object_Oriented Software Engineering面向对象软件工程) 是由Ivar Jacobson提出的。它可较好的描述系统与其用户之间的信息交换机制, 即用于向软件系统提出需求后, 软件系统完成这项需求的过程。OOSE方法遵循瀑布式的软件开发过程, 首先是描述与系统交互有关的用户视图, 然后建立分析模型, 最后的构造过程则完成交互设计、实现和测试。OOSE开发过程可在规定的顺序步骤指导下完成, 其间允许少量的阶段反复。

三、UML进行系统软件建模的过程

用UML建模之初要描述总体需求。在这一阶段中主要是建立用例模型和静态模型, 以搭建系统体系结构。用例图是系统的高级视图, 要求按照面向对象的原则, 站在功能划分的角度将系统要实现的行为划分为用例;以用例之间的动态交互及交互时间为依据产生顺序图;接下来就在用例图的基础上抽象出系统的类, 明确各模块之间的关系以适当的粒度画出类图, 其中也包括了与用例图的相互迭代修改在分析完模块的静态交互关系后继而要绘制出构件图。以上这些过程中均不考虑系统的具体实现, 如建立什么样的数据库或采用什么语言编码等, 最好是以使用者的眼光去分析系统功能。为建立完整的系统模型, 还要对模块交互和构件细节做进一步分析, 补充状态图、活动图、协作图和实施图等, 从尽可能多的角度对复杂系统进行描述。在模型确定后就可以借助相应的支撑软件将模型导出为相关代码, 形成编码所需的初步框架。

四、结束语

UML用一种统一的基本表示来组织数据和它专有的处理, 能够无痕地支持OOA、OOD各阶段的工作特征, 使传统软件开发的两条鸿沟消失。UML的出现是面向对象技术发展的重要成果, UML成为可视化建模语言事实上的工业标准, 代表了面向对象方法的软件开发技术的发展方向。

参考文献

[1]马光毅等:面向对象方法研究《华南师范大学学报》。