BlogJava-自由,平等,开源,分享-文章分类-概念,术语,基础http://www.blogjava.net/shisanfeng/category/30562.html闻道有先后，术业有专攻，如是而已zh-cnSat, 31 May 2008 06:02:15 GMTSat, 31 May 2008 06:02:15 GMT60云计算（Cloud Computing，CC）http://www.blogjava.net/shisanfeng/articles/204000.html龙震龙震Fri, 30 May 2008 01:17:00 GMThttp://www.blogjava.net/shisanfeng/articles/204000.htmlhttp://www.blogjava.net/shisanfeng/comments/204000.htmlhttp://www.blogjava.net/shisanfeng/articles/204000.html#Feedback0http://www.blogjava.net/shisanfeng/comments/commentRss/204000.htmlhttp://www.blogjava.net/shisanfeng/services/trackbacks/204000.html
基本原理

　　云计算（Cloud Computing）是分布式处理（Distributed Computing）、并行处理（Parallel Computing）和网格计算（Grid Computing）的发展，或者说是这些计算机科学概念的商业实现。
　　云计算的基本原理是，通过使计算分布在大量的分布式计算机上，而非本地计算机或远程服务器中，企业数据中心的运行将更与互联网相似。这使得企业能够将资源切换到需要的应用上，根据需求访问计算机和存储系统。
　　这可是一种革命性的举措，打个比方，这就好比是从古老的单台发电机模式转向了电厂集中供电的模式。它意味着计算能力也可以作为一种商品进行流通，就像煤气、水电一样，取用方便，费用低廉，最大的不同在于，它是通过互联网进行传输的。
　　云计算的蓝图已经呼之欲出：在未来，只需要一台笔记本或者一个手机，就可以通过网络服务来实现我们需要的一切，甚至包括超级计算这样的任务。从这个角度而言，最终用户才是云计算的真正拥有者。
　　云计算的应用包含这样的一种思想，把力量联合起来，给其中的每一个成员使用。

“云计算”时代

　　目前，PC 依然是我们日常工作生活中的核心工具，我们用 PC 处理文档、存储资料，通过电子邮件或 U 盘与他人分享信息。但如果 PC 硬盘坏了，我们会因为资料丢失而束手无策。
　　而在“云计算”时代，“云”会替我们做存储和计算的工作。“云”就是计算机群，每一群包括了几十万台、甚至上百万台计算机。“云”的好处还在于，其中的计算机可以随时更新，保证“云”长生不老。
　　届时，我们只需要一台能上网的电脑，不需关心存储或计算发生在哪朵“云”上，但一旦有需要，我们可以在任何地点用任何设备，如电脑、手机等，快速地计算和找到这些资料。我们再也不用担心资料丢失。
　　“云计算”就仿佛银行的自动取款机（ATM），我们出门再也不用随身携带大量现钞，可以根据需要随时取用。
　　PC 时代好比每个人要用电，都得自己购买发电机；而“云计算”时代，每个人不必拥有发电机，直接从大型发电厂买电就好。
　　“云计算”其实并不是一个新概念，“云计算”之前，还有“网格计算”（Grid Computing）等等，理念都是关于计算机如何协同发挥作用。
　　云计算是一种新兴的共享基础架构的方法，它可以将巨大的系统池连接在一起以提供各种 IT 服务。很多因素推动了对这类环境的需求，其中包括连接设备、实时数据流、 SOA 的采用以及搜索、开放协作、社会网络和移动商务等这样的 Web 2.0 应用的急剧增长。
　　另外，数字元器件性能的提升也使IT环境的规模大幅度提高，从而进一步加强了对一个由统一的云进行管理的需求。
　　“云计算+Always-On”设备被评为“25 年来最具影响力的十大 IT 技术组合”。

　　云计算正在成为一个大众化的词语。但是，问题是似乎每个人对于云计算的理解各不相同。作为一个对互联网的比喻，“云”是很容易理解的。但是一旦同“计算”联系起来，它的意义就扩展了，而且开始变得模糊起来。有些分析师和公司把云计算仅仅定义为计算的升级版，基本上就是互联网上提供的众多虚拟服务器。另外一些人把云计算定义的更加宽泛，他们认为用户在防火墙保护之外消费的任何事物都处于“云”之中。
　　云计算被人们关注是在人们考虑 IT 业到底需要什么之后，人们需要找到一种办法能够在不增加新的投资，新的人力和新的软件的情况下增加互联网的能力和容量。而云计算正好提供了这种可能。

云计算形式

　　01. SaaS（软件即服务）
　　这种类型的云计算通过浏览器把程序传给成千上万的用户。在用户眼中看来，这样会省去在服务器和软件授权上的开支；从供应商角度来看，这样只需要维持一个程序就够了，这样能够减少成本。SaaS 在人力资源管理程序和 ERP 中比较常用。
　　02. 实用计算（Utility Computing）
　　这个主意很早就有了，但是知道最近才在提供存储服务和虚拟服务器的公司中新生。这种云计算是为 IT 行业创造虚拟的数据中心使得其能够把内存、I/O 设备、存储和计算能力集中起来成为一个虚拟的资源池来为整个网络提供服务。
　　03. 网络服务
　　同 SaaS 关系密切，网络服务提供者们能够提供 API 让开发者能够开发更多基于互联网的应用，而不是提供单机程序。
　　04. 平台即服务
　　另一种 SaaS，这种形式的云计算把开发环境作为一种服务来提供。你可以使用中间商的设备来开发自己的程序并通过互联网和其服务器传到用户手中。
　　05. MSP（管理服务提供商）
　　最古老的云计算运用之一。这种应用更多的是面向 IT 行业而不是终端用户，常用于邮件病毒扫描、程序监控等等。
　　06. 商业服务平台
　　SaaS 和 MSP 的混合应用，该类云计算为用户和提供商之间的互动提供了一个平台。比如用户个人开支管理系统，能够根据用户的设置来管理其开支并协调其订购的各种服务。
　　07. 互联网整合
　　将互联网上提供类似服务的公司整合起来，以便用户能够更方便的比较和选择自己的服务供应商。

云计算特点

　　首先，云计算提供了最可靠、最安全的数据存储中心，用户不用再担心数据丢失、病毒入侵等麻烦。很多人觉得数据只有保存在自己看得见、摸得着的电脑里才最安全，其实不然。你的电脑可能会因为自己不小心而被损坏，或者被病毒攻击，导致硬盘上的数据无法恢复，而有机会接触你的电脑的不法之徒则可能利用各种机会窃取你的数据。此前轰动一时的“艳照门”事件据报道不也是因为电脑送修而造成个人数据外泄的吗？
　　反之，当你的文档保存在类似 Google Docs 的网络服务上，当你把自己的照片上传到类似 Google Picasa Web 的网络相册里，你就再也不用担心数据的丢失或损坏。因为在“云”的另一端，有全世界最专业的团队来帮你管理信息，有全世界最先进的数据中心来帮你保存数据。同时，严格的权限管理策略可以帮助你放心地与你指定的人共享数据。这样，你不用花钱就可以享受到最好、最安全的服务，甚至比在银行里存钱还方便。

　　其次，云计算对用户端的设备要求最低，使用起来也最方便。大家都有过维护个人电脑上种类繁多的应用软件的经历。为了使用某个最新的操作系统，或使用某个软件的最新版本，我们必须不断升级自己的电脑硬件。为了打开朋友发来的某种格式的文档，我们不得不疯狂寻找并下载某个应用软件。
　　为了防止在下载时引入病毒，我们不得不反复安装杀毒和防火墙软件。所有这些麻烦事加在一起，对于一个刚刚接触计算机，刚刚接触网络的新手来说不啻一场噩梦！如果你再也无法忍受这样的电脑使用体验，云计算也许是你的最好选择。你只要有一台可以上网的电脑，有一个你喜欢的浏览器，你要做的就是在浏览器中键入 URL，然后尽情享受云计算带给你的无限乐趣。
　　你可以在浏览器中直接编辑存储在“云”的另一端的文档，你可以随时与朋友分享信息，再也不用担心你的软件是否是最新版本，再也不用为软件或文档染上病毒而发愁。因为在“云”的另一端，有专业的 IT 人员帮你维护硬件，帮你安装和升级软件，帮你防范病毒和各类网络攻击，帮你做你以前在个人电脑上所做的一切。

　　此外，云计算可以轻松实现不同设备间的数据与应用共享。大家不妨回想一下，你自己的联系人信息是如何保存的。一个最常见的情形是，你的手机里存储了几百个联系人的电话号码，你的个人电脑或笔记本电脑里则存储了几百个电子邮件地址。为了方便在出差时发邮件，你不得不在个人电脑和笔记本电脑之间定期同步联系人信息。买了新的手机后，你不得不在旧手机和新手机之间同步电话号码。
　　对了，还有你的 PDA 以及你办公室里的电脑。考虑到不同设备的数据同步方法种类繁多，操作复杂，要在这许多不同的设备之间保存和维护最新的一份联系人信息，你必须为此付出难以计数的时间和精力。这时，你需要用云计算来让一切都变得更简单。在云计算的网络应用模式中，数据只有一份，保存在“云”的另一端，你的所有电子设备只需要连接互联网，就可以同时访问和使用同一份数据。
　　仍然以联系人信息的管理为例，当你使用网络服务来管理所有联系人的信息后，你可以在任何地方用任何一台电脑找到某个朋友的电子邮件地址，可以在任何一部手机上直接拨通朋友的电话号码，也可以把某个联系人的电子名片快速分享给好几个朋友。当然，这一切都是在严格的安全管理机制下进行的，只有对数据拥有访问权限的人，才可以使用或与他人分享这份数据。
　　最后，云计算为我们使用网络提供了几乎无限多的可能，为存储和管理数据提供了几乎无限多的空间，也为我们完成各类应用提供了几乎无限强大的计算能力。想像一下，当你驾车出游的时候，只要用手机连入网络，就可以直接看到自己所在地区的卫星地图和实时的交通状况，可以快速查询自己预设的行车路线，可以请网络上的好友推荐附近最好的景区和餐馆，可以快速预订目的地的宾馆，还可以把自己刚刚拍摄的照片或视频剪辑分享给远方的亲友…
　　离开了云计算，单单使用个人电脑或手机上的客户端应用，我们是无法享受这些便捷的。个人电脑或其他电子设备不可能提供无限量的存储空间和计算能力，但在“云”的另一端，由数千台、数万台甚至更多服务器组成的庞大的集群却可以轻易地做到这一点。个人和单个设备的能力是有限的，但云计算的潜力却几乎是无限的。当你把最常用的数据和最重要的功能都放在“云”上时，我们相信，你对电脑、应用软件乃至网络的认识会有翻天覆地的变化，你的生活也会因此而改变。

展望未来

　　互联网的精神实质是自由、平等和分享。作为一种最能体现互联网精神的计算模型，云计算必将在不远的将来展示出强大的生命力，并将从多个方面改变我们的工作和生活。无论是普通网络用户，还是企业员工，无论是 IT 管理者，还是软件开发人员，他们都能亲身体验到这种改变。

　　另外，云计算编程技术将成为基准的下一代计算机编程结构。



龙震 2008-05-30 09:17 发表评论
]]>软件即服务（Software as a Service，SaaS）http://www.blogjava.net/shisanfeng/articles/203970.html龙震龙震Thu, 29 May 2008 17:29:00 GMThttp://www.blogjava.net/shisanfeng/articles/203970.htmlhttp://www.blogjava.net/shisanfeng/comments/203970.htmlhttp://www.blogjava.net/shisanfeng/articles/203970.html#Feedback0http://www.blogjava.net/shisanfeng/comments/commentRss/203970.htmlhttp://www.blogjava.net/shisanfeng/services/trackbacks/203970.html
　　软件即服务（Software as a Service，SaaS）是随着互联网技术的发展和应用软件的成熟，而在 21 世纪开始兴起的一种完全创新的软件应用模式。

　　它与 On-Demand Software（按需软件)、The Application Service Provider(ASP，应用服务提供商)、Hosted Software（托管软件）具有相似的含义。
　　它是一种通过 Internet 提供软件的模式，厂商将应用软件统一部署在自己的服务器上，客户可以根据自己实际需求，通过互联网向厂商定购所需的应用软件服务，按定购的服务多少和时间长短向厂商支付费用，并通过互联网获得厂商提供的服务。
　　用户不用再购买软件，而改用向提供商租用基于 Web 的软件，来管理企业经营活动，且无需对软件进行维护，服务提供商会全权管理和维护软件，软件厂商在向客户提供互联网应用的同时，也提供软件的离线操作和本地数据存储，让用户随时随地都可以使用其定购的软件和服务。
　　对于许多小型企业来说，SaaS 是采用先进技术的最好途径，它消除了企业购买、构建和维护基础设施和应用程序的需要。
　　在这种模式下，客户不再象传统模式那样花费大量投资用于硬件、软件、人员，而只需要支出一定的租赁服务费用，通过互联网便可以享受到相应的硬件、软件和维护服务，享有软件使用权和不断升级，这是网络应用最具效益的营运模式。

　　SaaS 服务模式与传统的销售软件永久许可证的方式有很大的不同，它是未来管理软件的发展趋势。

　　SaaS 不仅减少或取消了传统的软件授权费用，而且厂商将应用软件部署在统一的服务器上，免除了最终用户的服务器硬件、网络安全设备和软件升级维护的支出，客户不需要除了个人电脑和互联网连接之外的其它 IT 投资就可以通过互联网获得所需要软件和服务。
　　此外，大量的新技术，如 Web Service，提供了更简单、更灵活、更实用的 SaaS。
　　另外，SaaS 供应商通常是按照客户所租用的软件模块来进行收费的，因此用户可以根据需求按需订购软件应用服务，而且 SaaS 的供应商会负责系统的部署、升级和维护，而传统管理软件通常是买家需要一次支付一笔可观的费用才能正式启动。

　　SaaS 服务提供商为中小企业搭建信息化所需要的所有网络基础设施及软件、硬件运作平台，并负责所有前期的实施、后期的维护等一系列服务，企业无需购买软硬件、建设机房、招聘 IT 人员，只需前期支付一次性的项目实施费和定期的软件租赁服务费，即可通过互联网享用信息系统。
　　服务提供商通过有效的技术措施，可以保证每家企业数据的安全性和保密性。
　　企业采用 SaaS 服务模式在效果上与企业自建信息系统基本没有区别，但节省了大量用于购买 IT 产品、技术和维护运行的资金，且像打开自来水龙头就能用水一样，方便地利用信息化系统，从而大幅度降低了中小企业信息化的门槛与风险。

　　具体来说 SaaS 可以为客户带来如下的价值：

　　　　01. 服务的收费方式风险小，灵活选择模块，备份，维护，安全，升级
　　　　02. 让客户更专注核心业务
　　　　03. 灵活启用和暂停，随时随地都可使用
　　　　04. 按需定购，选择更加自由
　　　　05. 产品更新速度加快
　　　　06. 市场空间增大
　　　　07. 实现年息式的循环收入模式
　　　　08. 有效降低营销成本
　　　　09. 准面对面使用指导
　　　　10. 在全球各地，7*24 全天候网络服务
　　　　11. 不需要额外增加专业的 IT 人员
　　　　12. 大大降低客户的总体拥有成本



龙震 2008-05-30 01:29 发表评论
]]>搜索引擎中的召回率（查全率）与精度（查准率）http://www.blogjava.net/shisanfeng/articles/199128.html龙震龙震Thu, 08 May 2008 01:22:00 GMThttp://www.blogjava.net/shisanfeng/articles/199128.htmlhttp://www.blogjava.net/shisanfeng/comments/199128.htmlhttp://www.blogjava.net/shisanfeng/articles/199128.html#Feedback0http://www.blogjava.net/shisanfeng/comments/commentRss/199128.htmlhttp://www.blogjava.net/shisanfeng/services/trackbacks/199128.html .thint,.thint td{border:1px #000 solid;border-collapse:collapse} .thint{margin:0 0 0 50px} .thint td{padding:5px;font-size:12px}

　　召回率（Recall Rate）（查全率）：是检索出的相关文档数和文档库中所有的相关文档数的比率，衡量的是检索系统的查全率。
　　精度（Precision）（查准率）：是检索出的相关文档数与检索出的文档总数的比率，衡量的是检索系统的查准率。

　　对于一个检索系统来讲，召回率和精度不可能两全其美：召回率高时，精度低，精度高时，召回率低。
　　所以常常用 11 种召回率下 11 种精度的平均值来衡量一个检索系统的精度。
　　对于搜索引擎系统来讲，因为没有一个搜索引擎系统能够搜集到所有的 Web 网页，所以召回率很难计算。
　　目前的搜索引擎系统都非常关心精度。

　　影响一个搜索引擎系统的性能有很多因素，最主要的是信息检索模型，包括文档和查询的表示方法、评价文档和用户查询相关性的匹配策略、查询结果的排序方法和用户进行相关度反馈的机制。

　　从一个大规模数据集合中检索文档的时，可把文档分成四组：

　　　　※　系统检索到的相关文档（A）
　　　　※　系统检索到的不相关文档（B）
　　　　※　相关但是系统没有检索到的文档（C）
　　　　※　相关但是被系统检索到的文档（D）

相关 不相关
检索到 A B
未检索到 C D

　　直观的说，一个好的检索系统检索到的相关文档越多越好，不相关文档越少越好。

　　召回率 R：用检索到相关文档数作为分子，所有相关文档总数作为分母，即 R=A/(A+C)。
　　精度 P：用检索到相关文档数作为分子，所有检索到的文档总数作为分母，即 P=A/(A+B)。

　　举例：一个数据库有 500 个文档，其中有 50 个文档符合定义的问题；系统检索到 75 个文档，但其中只有 45 个文档符合定义。

　　　　召回率：R=45/50=90%。
　　　　精度：P=45/75=60%。

　　上例中：系统检索是比较有效的，召回率为 90%；但是结果有很大的噪音，有近一半的检索结果是不相关。

　　研究表明：在不牺牲精度的情况下，获得一个高召回率是很困难的；召回率越高，精度下降的很快，而且这种趋势不是线性的。



龙震 2008-05-08 09:22 发表评论
]]>Java 继承机制http://www.blogjava.net/shisanfeng/articles/191375.html龙震龙震Mon, 07 Apr 2008 14:44:00 GMThttp://www.blogjava.net/shisanfeng/articles/191375.htmlhttp://www.blogjava.net/shisanfeng/comments/191375.htmlhttp://www.blogjava.net/shisanfeng/articles/191375.html#Feedback0http://www.blogjava.net/shisanfeng/comments/commentRss/191375.htmlhttp://www.blogjava.net/shisanfeng/services/trackbacks/191375.html
1　继承的概念

　　如果类 B 具有类 A 的全部属性和方法，而且又具有自己特有的某些属性和方法，则把类 A 称作一般类，把类 B 称作特殊类。

　　在面向对象程序设计中运用继承原则，就是在每个由一般类和特殊类形成的一般 - 特殊结构中，把一般类的对象实例和所有特殊类的对象实例都共同具有的属性和操作一次性地在一般类中进行显式的定义，在特殊类中不再重复地定义一般类中已经定义的东西，但是在语义上，特殊类却自动地、隐含地拥有它的一般类（以及所有更上层的一般类）中定义的属性和操作。
　　特殊类的对象拥有其一般类的全部或部分属性与方法，称作特殊类对一般类的继承。

　　继承所表达的就是一种对象之间的相交关系，它使得某类对象可以继承另外一类对象的数据成员和成员方法。
　　若类 B 继承类 A 时，则属于 B 的对象便具有类 A 的全部或部分性质（数据属性）和功能（操作）。
　　我们称被继承的类 A 为基类、父类或超类，而称继承类 B 为 A 的派生类或子类。

　　继承避免了对一般类和特殊类之间共同特征进行的重复描述。

2　继承的特征

　　继承关系是传递的。继承是在一些比较一般的类的基础上构造、建立和扩充新类的最有效的手段。
　　继承简化了人们对事物的认识和描述，能清晰体现相关类间的层次结构关系。
　　提供软件复用功能。
　　通过增强一致性来减少模块间的接口和界面，大大增加程序的易维护性。
　　提供多重继承机制。从理论上说，一个类可以是多个一般类的特殊类，它可以从多个一般类中继承属性和方法，这便是多重继承。而 Java 出于安全性和可靠性的考虑，仅支持单重继承，而通过使用接口机制来实现多重继承。

3　Java 用 extends 指明继承关系

　　在 Java 程序设计中，继承是通过 extends 关键字来实现的。
　　在定义类时使用 extends 关键字指明新定义类的父类，新定义的类称为指定父类的子类，这样就在两个类之间建立起了继承关系。
　　这个新定义的子类可以从父类那里继承所有非 private 的属性和方法作为自己的成员。
　　实际上，在定义一个类而不给出 extends 关键字及父类名时，默认这个类是系统类 Object 的子类。

3.1　数据成员的继承

　　子类可以继承父类的所有非私有的数据成员。

3.2　数据成员的隐藏

　　数据成员的隐藏是指在子类中重新定义一个与父类中已经定义的数据成员名完全相同的数据成员，即子类拥有了两个相同名字的数据成员，一个是继承父类的，另一个是自己定义的。
　　当子类引用这个同名的数据成员时，默认操作是它自己定义的数据成员，而把从父类那里继承来的数据成员“隐藏”起来。
　　当子类要引用继承自父类的同名数据成员时，可使用关键字 super 引导。

3.3　成员方法的继承

　　子类可以继承父类的非私有成员方法。

3.4　成员方法的覆盖（Overload）

　　子类可以重新定义与父类同名的成员方法，实现对父类方法的覆盖。

　　方法的覆盖与数据成员的隐藏的不同之处在于：

　　　　子类隐藏父类的数据成员只是使之不可见，父类同名的数据成员在子类对象中仍然占有自己独立的内存空间；
　　　　子类方法对父类同名方法的覆盖将清除父类方法占用的内存，从而使父类方法在子类对象中不复存在。

　　需要注意的是：子类在重新定义父类已有的方法时，应保持与父类完全相同的方法名、返回值类型和参数列表，否则就不是方法的覆盖，而是子类定义自己特有的方法，与父类的方法无关。

4　this 与 super

4.1　this 的使用场合

　　在方法内借助 this 来明确表示引用的是类的数据成员，而不是形参或局部变量，从而提高程序的可读性。
　　简单地说，this 代表了当前对象的一个引用，可将其理解为对象的另一个名字，通过这个名字可以顺利地访问对象、修改对象的数据成员、调用对象的方法。

　　this 的使用场合主要有以下三种：

　　　　用来访问当前对象的数据成员：

this.数据成员

　　　　用来访问当前对象的成员方法：

this.成员方法(参数)

　　　　当有重载的构造方法时，用来引用同类的其他构造方法：

this(参数)

4.2　super 的使用场合

　　super 表示的是当前对象的直接父类对象，是当前对象的直接父类对象的引用。
　　所谓直接父类是相对于当前对象的其他“祖先”类而言。
　　若子类的数据成员或成员方法名与父类的数据成员或成员方法名相同时，当要调用父类的同名方法或使用父类的同名数据成员，则可用关键字 super 来指明父类的数据成员和方法。

　　super 的使用场合有三种：

　　　　用来访问直接父类隐藏的数据成员：

super.数据成员

　　　　用来调用直接父类中被覆盖的成员方法：

super.成员方法(参数)

　　　　用来调用直接父类的构造方法：

super(参数)

5　构造方法的重载与继承

5.1　构造方法的重载

　　一个类的若干个构造方法之间可以相互调用。
　　当一个构造方法需要调用另一个构造方法时，可以使用关键字 this，同时这个调用语句应该是整个构造方法的第一个可执行语句。
　　使用关键字 this 来调用同类的其他构造函数时，优点同样是可以最大限度地提高对已有代码的利用程度，提高程序的抽象度和封装性，减少程序的维护工作量。

5.2　构造方法的继承

　　子类可以继承父类的构造方法，构造方法的继承遵循以下的原则：

　　　　子类无条件地继承父类的不含参数的构造方法。
　　　　如果子类自己没有构造方法，则它将继承父类的无参数构造方法作为自己的构造方法；如果子类自己定义了构造方法，则在创建新对象时，它将先执行继承自父类的无参数构造方法，然后再执行自己的构造方法。
　　　　对于父类含参数的构造方法，子类可以通过在自己的构造方法中使用 super 关键字来调用它，但这个调用语句必须是子类构造方法的第一个可执行语句。

6　向方法传递对象

　　传递给方法的参数可以是表达式（如常量、变量）、对象等。
　　传递给方法的参数若是变量，则只能由实参传递给形参，而不能由形参带回，它是一种单向值传递。
　　在方法的引用过程中，对于形参变量值的修改并不影响实参变量的值。
　　但是，传递给方法的参数若是对象，则方法可以对其做永久性修改。

7　类转换

　　类转换就是指父类对象与子类对象之间在一定条件下的相互转换。

　　父类对象与子类对象之间相互转换规则如下：

　　　　父类对象与子类对象之间可以隐式转换（也称默认转换），也可以显式转换（也称强制转换）。
　　　　处于相同类层次的类的对象不能进行转换。
　　　　子类对象可以转换成父类对象，但对数据成员的引用必须使用强制转换。

　　类转换格式如下：

(子类)父类

　　或

(父类)子类

8　继承与封装的关系

　　在面向对象系统中，封装性主要指的是对象的封装性，即将属于某一类的一个具体对象封装起来，使其数据和操作成为一个整体。
　　在引入了继承机制的面向对象系统中，对象依然是封装得很好的实体，其他对象与它进行通讯的途径仍然只有一条，那就是发送消息。
　　类机制是一种静态机制，不管是基类还是派生类，对于对象来说，它仍然是一个类的实例，既可能是基类的实例，也可能是派生类的实例。
　　因此，继承机制的引入丝毫没有影响对象的封装性。

　　继承和封装机制还具有一定的相似性，它们都是一种共享代码的手段。
　　继承是一种静态共享代码的手段，通过派生类对象的创建，可以接收某一消息，启动其基类所定义的代码段，从而使基类和派生类共享了这一段代码。
　　封装机制所提供的是一种动态共享代码的手段，通过封装，我们可将一段代码定义在一个类中，在另一个类所定义的操作中，我们可以通过创建该类的实例，并向它发送消息而启动这一段代码，同样也达到共享的目的。



龙震 2008-04-07 22:44 发表评论
]]>Java 多态机制http://www.blogjava.net/shisanfeng/articles/191374.html龙震龙震Mon, 07 Apr 2008 14:32:00 GMThttp://www.blogjava.net/shisanfeng/articles/191374.htmlhttp://www.blogjava.net/shisanfeng/comments/191374.htmlhttp://www.blogjava.net/shisanfeng/articles/191374.html#Feedback0http://www.blogjava.net/shisanfeng/comments/commentRss/191374.htmlhttp://www.blogjava.net/shisanfeng/services/trackbacks/191374.html
　　多态描述的是同名方法可以根据发送消息的对象传送参数的不同，采取不同的行为方式的特性。
　　面向对象系统中采用多态，大大提高了程序的抽象程度和简洁性，更重要的是，它最大限度地降低了类和程序模块之间的耦合性，提高了类模块的封闭性，使得它们不需了解对方的具体细节，就可以很好地共同工作。
　　这一点对程序的设计、开发和维护都有很大的好处。

1　多态的概念

　　多态是指一个程序中同名的不同方法共存的情况。
　　这些方法同名的原因是它们的最终功能和目的都相同，但是由于在完成同一功能时，可能遇到不同的具体情况，所以需要定义含不同的具体内容的方法，来代表多种具体实现形式。

　　Java 提供两种多态机制：重载与覆盖。

2　方法重载

　　在同一类中定义了多个同名而不同内容的成员方法时，我们称这些方法是重载（Override）的方法。
　　重载的方法主要通过形式参数列表中参数的个数、参数的数据类型和参数的顺序等方面的不同来区分的。
　　在编译期间，Java 编译器检查每个方法所用的参数数目和类型，然后调用正确的方法。

3　覆盖

　　由于面向对象系统中的继承机制，子类可以继承父类的方法。
　　但是，子类的某些特征可能与从父类中继承来的特征有所不同，为了
体现子类的这种个性，Java 允许子类对父类的同名方法重新进行定义，即在子类中定义与父类中已定义的相同名而内容不容的方法。
　　这种多态被称为覆盖（Overload）。

　　由于覆盖的同名方法是存在于子类对父类的关系中，所以只需在方法引用时指明引用的是父类的方法还是子类的方法，就可以很容易地把它们区分开来。



龙震 2008-04-07 22:32 发表评论
]]>Java 访问控制http://www.blogjava.net/shisanfeng/articles/191372.html龙震龙震Mon, 07 Apr 2008 14:30:00 GMThttp://www.blogjava.net/shisanfeng/articles/191372.htmlhttp://www.blogjava.net/shisanfeng/comments/191372.htmlhttp://www.blogjava.net/shisanfeng/articles/191372.html#Feedback0http://www.blogjava.net/shisanfeng/comments/commentRss/191372.htmlhttp://www.blogjava.net/shisanfeng/services/trackbacks/191372.html
　　一个类总能够访问自己的数据成员和成员方法。
　　但是，其他类是否能访问这个类的数据成员或成员方法，是由该类的访问控制符及该类数据成员和成员方法的访问控制符决定的。
　　访问控制符是一组限定类、数据成员或成员方法是否可以被其他类访问的修饰符。
　　类的访问控制符只有 public 一个，缺省访问控制符时具有“友好访问”的特性。
　　数据成员和成员方法的访问控制符有 public、private、protected 和缺省访问控制符等几种。

1　公共访问控制符 public

　　Java 的类是通过包的概念来组织的，定义在同一个程序文件中的所有类都属于同一个包。
　　处于同一个包中的类都是可见的，即可以不需要任何说明而方便地互相访问和引用。
　　而对于不同包中的类，一般说来，它们相互之间是不可见的，当然也不可能互相引用。
　　当一个类被声明为 public 时，只要在其他包的程序中使用 import 语句引入这个 public 类，就可以访问和引用这个类，创建这个类的对象，访问这个类内部可见的数据成员和引用它的可见的方法。

　　当一个类的访问控制符为 public 时，表明这个类作为整体对其他类是可见和可使用的，这个类就具有了被其他包中的类访问的可能性。
　　但是，处于不同包中的 public 类作为整体对其他类是可见的，并不代表该类的所有数据成员和成员方法也同时对其他类是可见的，这得由这些数据成员和成员方法的修饰符来决定。
　　只有当 public 类的数据成员和成员方法的访问控制符也被声明为 public 时，这个类的所有用 public 修饰的数据成员和成员方法也同时对其他类是可见的。
　　在程序设计时，如果希望某个类能作为公共工具供其他的类和程序使用，则应该把类本身和类内的方法都定义成 public。

　　需要注意的是，数据成员和成员方法的访问控制符被声明为 public 时，会造成安全性和封装性的下降，所以一般应尽量少用。

2　缺省访问控制符

　　若一个类没有访问控制符，说明它具有缺省的访问控制特性，这种缺省的访问控制特性称为“友好访问”。
　　友好访问规定只有在同一个包中的对象才能访问和引用这些类，因此，又称为包访问性。
　　同理，类内的数据成员和成员方法如果没有访问控制符来限定，也具有“友好访问”特性，它们也具有包访问性，可以被同一个包中的其他类所访问和引用。

3　私有访问控制符 private

　　用 private 修饰的数据成员或成员方法只能被该类自身所访问和修改，而不能被任何其他类（包括该类的子类）来访问和引用。
　　它提供了最高的保护级别。
　　当其他类希望获取或修改私有成员时，需要借助于类的方法来实现。

4　保护访问控制符 protected

　　用 protected 修饰的成员变量可以被三种类引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类。
　　使用 protected 修饰符的主要作用是允许其他包中的它的子类来访问父类的特定属性。



龙震 2008-04-07 22:30 发表评论
]]>Java 消息http://www.blogjava.net/shisanfeng/articles/191334.html龙震龙震Mon, 07 Apr 2008 10:48:00 GMThttp://www.blogjava.net/shisanfeng/articles/191334.htmlhttp://www.blogjava.net/shisanfeng/comments/191334.htmlhttp://www.blogjava.net/shisanfeng/articles/191334.html#Feedback0http://www.blogjava.net/shisanfeng/comments/commentRss/191334.htmlhttp://www.blogjava.net/shisanfeng/services/trackbacks/191334.html
　　在面向对象系统中，对象间的相互作用是通过一个对象向另一个对象发送消息的方式来体现的。

　　在面向对象的程序中，消息就是数据成员及成员方法的引用。

1　消息的概念

　　在面向对象的系统中，把“请求”或“命令”抽象成“消息”，对象之间的联系是通过消息传递来实现的。
　　当系统中的其他对象请求这个对象执行某个服务时，它就响应这个请求，完成指定的服务。
　　通常，我们把发送消息的对象称为发送者，把接收消息的对象称为接收者。
　　对象间的联系，只能通过消息传递来进行。
　　对象也只有在收到消息时，才被激活，去完成消息要求的功能。

　　消息就是向对象发出服务请求，是对数据成员和成员方法的引用。

　　它应该含有下述信息：

　　　　提供服务的对象标识 - 对象名
　　　　服务标识 - 方法名
　　　　输入信息 - 实际参数
　　　　回答信息 - 返回值或操作结果

　　消息具有三个性质：

　　　　同一对象可接收不同形式的多个消息，产生不同的响应。
　　　　相同形式的消息可以发送给不同对象，所做出的响应可以是截然不同的。
　　　　消息的发送可以不考虑具体的接收者，对象可以响应消息，也可以对消息不予理会，对消息的响应并不是必须的。

2　公有消息和私有消息

　　在面向对象系统中，消息分为两类：公有消息和私有消息。

　　当有一批消息同属于一个对象时：由外界对象直接发送给这个对象的消息称为公有消息；对象自己发送给本身的消息称为私有消息。
　　私有消息对外是不开放的，外界不必了解它。
　　外界对象只能向此对象发送公有消息，而不能发送私有消息，私有消息是由对象自身发送的。

3　特定于对象的消息

　　将所有能支持此对象可接收消息的方法集中在一起，形成一个大消息，成为特定于对象的消息。
　　这些消息让对象执行这个方法而不管它可能做什么及怎么做。

　　特定于对象的消息可分为三种类型：

　　　　可以返回对象内部状态的消息。
　　　　可以改变对象内部状态的消息。
　　　　可以做一些特定操作，改变系统状态的消息。



龙震 2008-04-07 18:48 发表评论
]]>Java 类的成员方法http://www.blogjava.net/shisanfeng/articles/191333.html龙震龙震Mon, 07 Apr 2008 10:43:00 GMThttp://www.blogjava.net/shisanfeng/articles/191333.htmlhttp://www.blogjava.net/shisanfeng/comments/191333.htmlhttp://www.blogjava.net/shisanfeng/articles/191333.html#Feedback0http://www.blogjava.net/shisanfeng/comments/commentRss/191333.htmlhttp://www.blogjava.net/shisanfeng/services/trackbacks/191333.html
　　成员方法描述对象所具有的功能或操作，反映对象的行为，是具有某种相对独立功能的程序模块。
　　它与过去所说的子程序、函数等概念相当。
　　一个类或对象可以有多个成员方法，对象通过执行它的成员方法对传来的消息作出响应，完成特定的功能。
　　成员方法一旦定义，便可在不同的程序段中多次调用，故可增强程序结构的清晰度，提高编程效率。

1　成员方法的分类

　　从成员方法的来源看，可将成员方法分为：

　　　　类库成员方法。这是由 Java 类库提供的，用户只要按照 Java 提供的调用格式去使用这些成员方法即可。
　　　　用户自定义的成员方法。这是为了解决用户的特定问题，由用户自己编写的成员方法。程序设计的主要工作就是编写用户自定义类、自定义成员方法。

　　从成员方法的形式看，可将成员方法分为：

　　　　无参数成员方法。
　　　　带参数成员方法。

2　声明成员方法的格式

　　在 Java 程序中，成员方法的声明只能在类中进行，格式如下：

[修饰符] 返回值的类型 成员方法名(形式参数表) throw [异常表]
{
  // 说明部分
  // 执行语句部分
}

　　成员方法的声明包括成员方法头和成员方法体两部分。

　　　　成员方法头确定成员方法的名字、形式参数的名字和类型、返回值的类型、访问限制和异常处理等；
　　　　成员方法体由包括在花括号内的说明部分和执行语句部分组成，它描述该方法功能的实现。

　　在成员方法头中：

　　　　修饰符。可以是公共访问控制符 public、私有访问控制符 private、保护访问控制符 protected 等访问权限修饰符，也可以是静态成员方法修饰符 static、最终成员方法修饰符 final、本地成员方法修饰符 native、抽象成员方法修饰符 abstract等非访问权限修饰符。访问权限修饰符指出满足什么条件时该成员方法可以被访问。非访问权限修饰符指明数据成员的使用方式。
　　　　返回值的类型。返回值的类型用 Java 允许的的各种数据类型关键字（int、float 等）指明成员方法完成其所定义的功能后，运算结果值的数据类型。若成员方法没有返回值，则在返回值的类型处应写上 void 关键字，以表明该方法无返回值。
　　　　成员方法名。是用户遵循标识符定义规则命名的标识符。
　　　　形式参数表。成员方法可分为带参成员方法和无参成员方法两种。对于无参成员方法来说则无形式参数表这一项，但成员方法名后的一对圆括号不可省略；对于带参成员方法来说，形式参数表指明调用该方法所需要的参数个数、参数的名字及其参数的数据类型，其格式为：

(形式参数类型1 形式参数名1,形式参数类型2 形式参数名2,)

　　　　throw [异常表]。它指出当该方法遇到一些方法设计者未曾想到的问题时如何处理。

3　方法体中的局部变量

　　在方法体内可以定义本方法所使用的变量，这种变量是局部变量，它的生存期与作用域是在本方法内。也就是说，局部变量只能在本方法内有效或可见，离开本方法则这些变量被自动释放。

　　方法体内定义变量时，变量前不能加修饰符。
　　局部变量在使用前必须明确赋值，否则编译时会出错。
　　在一个方法内部，可以在复合语句中定义变量，这些变量只在复合语句中有效，这种复合语句也被称为程序块。

4　成员方法的返回值

　　若方法有返回值，则在方法体中用 return 语句指明要返回的值。

　　其格式为：

return 表达式;

　　或

return(表达式);

　　　　表达式可以是常量、变量、对象等。

　　return 语句后面表达式的数据类型必须与成员方法头中给出的“返回值的类型”一致。

5　形式参数与实际参数

　　一般来说，可以通过以下方式来引用成员方法：

成员方法名(实参列表)

　　在引用成员方法时应注意：

　　　　对于无参成员方法来说，是没有实际参数列表的，但方法名后的括弧不能省略。
　　　　对于带参数的成员方法来说，实参的个数、顺序以及它们的数据类型必须与形式参数的个数、顺序以及它们的数据类型保持一致，各个实参间用逗号分隔。实参名与形参名可以相同也可以不同。
　　　　实参也可以是表达式，此时一定要注意使表达式的数据类型与形参的数据类型相同，或者使表达式的类型按 Java 类型转换规则达到形参指明的数据类型。
　　　　实参变量对形参变量的数据传递是“值传递”，即只能由实参传递给形参，而不能由形参传递给实参。程序中执行到引用成员方法时，Java 把实参值拷贝到一个临时的存储区（栈）中，形参的任何修改都在栈中进行，当退出该成员方法时，Java 自动清除栈中的内容。

6　成员方法的引用方式

6.1　方法语句

　　成员方法作为一个独立的语句被引用。

6.2　方法表达式

　　成员方法作为表达式中的一部分，通过表达式被引用。

6.3　方法作为参数

　　一个成员方法作为另一个成员方法的参数被引用。更为典型的是，在递归的成员方法中，一个成员方法作为它自身的参数被引用。

6.4　通过对象来引用

　　这里有两重含义，一是通过形如“对象名.方法名”的形式来引用对象，二是当一个对象作为成员方法的参数时，通过这个对象参数来引用对象的成员方法。

7　引用成员方法时应注意的事项

　　当一个方法引用另一个方法时，这个被引用的方法必须是已经存在的方法。
　　另外，还要视被引用的成员方法存在于何处而做不同的处理。

　　如果被引用的方法存在于本文件中，而且是本类的方法，则可直接引用。
　　如果被引用的方法存在于本文件中，但不是本类的方法，则要考虑类的修饰符与方法的修饰符来决定是否能引用。
　　如果被引用的方法不是本文件的方法而是 Java 类库的方法，则必须在文件的开头处用 import 命令将引用有关库方法所需要的信息写入本文件中。
　　如果被引用的方法是用户在其他的文件中自己定义的方法，则必须通过加载用户包的方式来引用。

8　成员方法的递归引用

　　成员方法的递归引用就是指在一个方法中直接或间接引用自身的情况。

9　static 修饰的静态方法

　　用 static 修饰符修饰的方法被称为静态方法，它是属于整个类的类方法。
　　不用 static 修饰符限定的方法，是属于某个具体类对象的方法。

　　static 方法使用特点如下：

　　　　static 方法是属于整个类的，它在内存中的代码段将随着类的定义而分配和装载。而非 static 的方法是属于某个对象的方法，当这个对象被创建时，在对象内存中拥有这个方法的专用代码段。
　　　　引用静态方法时，可以使用对象名做前缀，也可以使用类名做前缀。
　　　　static 方法只能访问 static 数据成员，不能访问非 static 数据成员，但非 static 方法可以访问 static 数据成员。
　　　　static 方法只能访问 static 方法，不能访问非 static 方法，但非 static 方法可以访问 static 方法。
　　　　main 方法是静态方法。在 Java 的每个 Application 程序中，都必须有且只有一个 main 方法，它是 Application 程序运行的入口点。

10　数学函数类方法

　　Java 类库提供的实现常用数学函数运算的标准数学函数方法，这些方法都是 static 方法。

　　标准数学函数方法在 Java.lang.Math 类中，使用方法比较简单，格式如下：

类名.数学函数方法名(实参列表)

11　final 修饰的最终方法

　　用 final 修饰符修饰的方法称为最终方法，如果某个方法被 final 修饰符所限定，则该类的子类就不能覆盖父类的方法，即不能再重新定义与此方法同名的自己的方法，而仅能使用从父类继承来的方法。
　　使用 final 修饰方法，就是为了给方法“上锁”，防止任何继承类修改此方法，保证了程序的安全性和正确性。

　　注意：final 修饰符也可用于修饰类，而当用 final 修饰符修饰类时，所有包含在 final 类中的方法，都自动成为 final 方法。

12　native 修饰的本地方法

　　修饰符 native 修饰的方法称为本地方法，此方法使用的目的是为了将其他语言（如 C、C++、Fortran、汇编等）嵌入到 Java 语言中。
　　这样，Java 可以充分利用已经存在的其他语言的程序功能模块，避免重复编程。

　　在 Java 程序中使用 native 方法时应该特别注意平台问题。
　　由于 native 方法嵌入其他语言书写的模块是以非 Java 字节码的二进制代码形式嵌入 Java 程序的，而这种二进制代码通常只能运行在编译生成它的平台上，所以整个 Java 程序的跨平台性能将受到限制或破坏，除非 native 方法引入的代码也是跨平台的。



龙震 2008-04-07 18:43 发表评论
]]>Java 类的数据成员http://www.blogjava.net/shisanfeng/articles/191245.html龙震龙震Mon, 07 Apr 2008 06:10:00 GMThttp://www.blogjava.net/shisanfeng/articles/191245.htmlhttp://www.blogjava.net/shisanfeng/comments/191245.htmlhttp://www.blogjava.net/shisanfeng/articles/191245.html#Feedback0http://www.blogjava.net/shisanfeng/comments/commentRss/191245.htmlhttp://www.blogjava.net/shisanfeng/services/trackbacks/191245.html
1　数据成员的声明

　　数据成员是用来描述事物的静态特征的。
　　一般情况下，声明一个数据成员必须做的事是给出这个数据成员的标识符并指明它所属的数据类型。
　　声明数据成员时，还可以用修饰符对数据成员的访问权限作出限制。

　　数据成员声明格式：

[修饰符] 数据成员类型 数据成员名表;

　　　　修饰符是可选的，它是指访问权限修饰符 public、private、protected 和非访问权限修饰符 static、final 等；
　　　　数据成员类型就是诸如 int、float 等 Java 允许的各种定义数据类型的关键字；
　　　　数据成员名表是指一个或多个数据成员名，即用户自定义标识符，当同时声明多个数据成员名时，彼此间用逗号分隔。

2　static 修饰的静态数据成员

　　用 static 修饰符修饰的数据成员是不属于任何一个类的具体对象，而是属于类的静态数据成员。

　　其特点如下：

　　　　它被保存在类的内存区的公共存储单元中，而不是保存在某个对象的内存区中。因此，一个类的任何对象访问它时，存取到的都是相同的数值。
　　　　可以通过类名加点操作符访问它。
　　　　static 类数据成员仍属于类的作用域，还可以使用 public static、private static 等进行修饰。修饰符不同，可访问的层次也不同。

3　静态数据成员的初始化

　　静态数据成员的初始化可以由用户在定义时进行，也可以由静态初始化器来完成。
　　静态初始化器是由关键字 static 引导的一对花括号括起的语句块，其作用是在加载类时，初始化类的静态数据成员。

　　静态初始化器与构造方法不同，它有以下特点：

　　　　静态初始化器用于对类的静态数据成员进行初始化。而构造方法用来对新创建的对象进行初始化。
　　　　静态初始化器不是方法，没有方法名、返回值和参数表。
　　　　静态初始化器是在它所属的类加载到内存时由系统调用执行的，而构造方法是在系统用 new 运算符产生新对象时自动执行的。

　　静态初始化器的格式：

static
{
  // 初始化静态数据成员
}

4　final 修饰的最终数据成员

　　如果一个类的数据成员用 final 修饰符修饰，则这个数据成员就被限定为最终数据成员。
　　最终数据成员可以在声明时进行初始化，也可以通过构造方法赋值，但不能在程序的其他地方赋值，它的值在程序的整个执行过程中是不能改变的。
　　因此，也可以说用 final 修饰符修饰的数据成员是标识符常量。

　　用 final 修饰符说明常量时，需要注意以下几点：

　　　　需要说明常量的数据类型并指出常量的具体值。
　　　　若一个类有多个对象，而某个数据成员是常量，最好将此常量声明为 static，即用 static final 两个修饰符修饰，这样做可节省空间。



龙震 2008-04-07 14:10 发表评论
]]>Java 封装机制http://www.blogjava.net/shisanfeng/articles/191219.html龙震龙震Mon, 07 Apr 2008 04:07:00 GMThttp://www.blogjava.net/shisanfeng/articles/191219.htmlhttp://www.blogjava.net/shisanfeng/comments/191219.htmlhttp://www.blogjava.net/shisanfeng/articles/191219.html#Feedback0http://www.blogjava.net/shisanfeng/comments/commentRss/191219.htmlhttp://www.blogjava.net/shisanfeng/services/trackbacks/191219.html
　　封装是面向对象系统的一个重要特性，是抽象数据类型思想的具体体现。
　　在面向对象的程序设计中，抽象数据类型是用“类”这种结构来代表的，而“类”又是面向对象的工具可理解和操纵的。

1　封装的概念

　　封装也称为信息隐藏，是指利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。
系统的其他部分只有通过包裹在数据外面的被授权的操作来与这个抽象数据类型交流与交互。
也就是说，用户无需知道对象内部方法的实现细节，但可以根据对象提供的外部接口（对象名和参数）访问该对象。

　　封装具有下述特征：

　　　　在类的定义中设置访问对象属性（数据成员）及方法（成员方法）的权限，限制本类对象及其他类的对象使用的范围。
　　　　提供一个接口来描述其他对象的使用方法。
　　　　其他对象不能直接修改本对象所拥有的属性和方法。

　　封装反映了事物的相对独立性。
　　封装在编程上的作用是使对象以外的部分不能随意存取对象的内部数据（属性），从而有效地避免了外部错误对它的“交叉感染”。
　　另一方面，当对象的内部做了某些修改时，由于它只通过少量的接口对外提供服务，因此大大减少了内部的修改对外部的影响。

　　面向对象系统的封装单位是对象，类概念本身也具有封装的意义，因为对象的特性是由它所属的类说明来描述的。

2　类的严谨定义

[类修饰符] class 类名 [extends 父类名] [implements 接口列表]
{
  数据成员
  成员方法
}

　　合理地使用这些可选项，可以充分地展示封装、继承和信息隐藏等面向对象特性。

　　　　类修饰符（Qualifier）：用于规定类的一些特殊性，主要是说明对它的访问限制。
　　　　extends 父类名：指明新定义的类是由已存在的父类派生出来的。
　　　　implements 接口列表：Java 本来只支持单继承，为了给多重继承的软件开发提供方便，它提供了这一接口机制。

3　类修饰符

　　类的修饰符用于说明对它的访问限制，一个类可以没有修饰符，也可以有 public、final、abstract 等几种不同的修饰符。

3.1　无修饰符的情况

　　如果一个类前无修饰符，则这个类只能被同一个包里的类使用。
　　Java 规定，同一个程序文件中的所有类都在同一个包中。
　　无修饰符的类可以被同一个程序文件中的类使用，但不能被其他程序文件中的其他包中的类使用。

3.2　public 修饰符

　　如果一个类的修饰符是 public，则这个类是公共类。
　　公共类不但可供它所在包中的其他类使用，也可供其他包中的类使用。
　　在程序中可以用 import 语句引用其他包中的 public 类。
　　Java 规定，在一个程序文件中，只能定义一个 public 类，其余的类可以是无修饰符的类，也可以是用 final 修饰符定义的最终类，否则编译时会报错。

3.3　final 修饰符

　　用 final 修饰符修饰的类被称为最终类。
　　最终类是不能被任何其他类所继承的。

　　定义最终类的目的有三：

　　　　用来完成某种标准功能。将一个类定义为 final 类，则可以将它的内容、属性和功能固定下来，与它的类名形成稳定的映射关系，从而保证引用这个类时所实现的功能是正确无误的。
　　　　提高程序的可读性。从父类派生子类，再从子类派生子类，使软件变得越来越复杂。而在必要的层次上设置 final 类，可以提高程序的可读性。
　　　　提高安全性。病毒的闯入途径之一是在一些处理关键信息的类中派生子类，再用子类去替代原来的类。由于用 final 修饰符定义的类不能再派生子类，截断了病毒闯入的途径，因而提高了程序的安全性。

3.4　abstract 修饰符

　　用 abstract 修饰符修饰的类称为抽象类。
　　抽象类刻画了研究对象的公有行为特征，并通过继承机制将这些特征传送给它的派生类。
　　其作用在于将许多有关的类组织在一起，提供一个公共的基类，为派生具体类奠定基础。
　　此外，当一个类中出现一个或多个用 abstract 修饰符定义的方法时，则必须在这个类的前面加上 abstract 修饰符，将其定义为抽象类。

3.5　类修饰符使用注意事项

　　可以同时使用两个修饰符来修饰一个类，当使用两个修饰符修饰一个类时，这些修饰符之间用空格分开，写在关键字 class 之前，修饰符的顺序对类的性质没有任何影响。

　　需要注意的是：一个类可以为修饰为 public abstract，也可以被修饰为 public final，但不能被修饰为 abstract final，这是因为 abstract 类自身没有对象，需要派生子类后再创建子类的对象，而 final 类不能派生子类，所以不存在用 abstract final 两个修饰符修饰的类。



龙震 2008-04-07 12:07 发表评论
]]>Java 类与对象的概念http://www.blogjava.net/shisanfeng/articles/191023.html龙震龙震Sun, 06 Apr 2008 05:10:00 GMThttp://www.blogjava.net/shisanfeng/articles/191023.htmlhttp://www.blogjava.net/shisanfeng/comments/191023.htmlhttp://www.blogjava.net/shisanfeng/articles/191023.html#Feedback0http://www.blogjava.net/shisanfeng/comments/commentRss/191023.htmlhttp://www.blogjava.net/shisanfeng/services/trackbacks/191023.html
　　在一个面向对象系统中：

　　　　对象是对现实世界中事物的抽象，是 Java 程序的基本封装单位，是类的实例；
　　　　类是对象的抽象，是数据和操作的封装体；
　　　　属性是事物静态特征的抽象，在程序中用数据成员加以描述；
　　　　操作是事物动态特征的抽象，在程序中用成员方法来实现。

　　把客观世界中的事物映射到面向对象的程序设计中就是对象。
　　对象是面向对象程序设计中用来描述客观事物的程序单位。
　　客观世界中的许多对象，无论其属性还是其行为常常有许多共同性，抽象出这些对象的共同性便可以构成类。
　　类是对象的抽象和归纳，对象是类的实例。

1.　抽象原则

　　抽象（Abstraction）就是从被研究对象中舍弃个别的、非本质的、或与研究主旨无关的次要特征，而抽取与研究工作有关的实质性内容加以考察，形成对所研究问题正确的、简明扼要的认识。

1.1　过程抽象

　　软件开发者可以把任何一个完成确定功能的操作序列都看作是一个单一的实体，尽管它实际上可能是由一系列更低级的操作完成的。
　　过程抽象可以把复杂的功能一层层分解为更简单的子模块，这样开发者可在不同层次上考虑问题，如在高层上就不必关心低层的细节问题。

　　面向过程的程序设计采用的是过程抽象方法。

　　过程抽象有利于控制、降低整个程序的复杂度，但是，这种方法允许在全系统的范围内进行功能的描述，本身自由度大，难于规范化和标准化，不易保证软件的质量，而且操作起来也有一定难度。

1.2　数据抽象

　　数据抽象把系统中需要处理的数据和施加于这些数据之上的操作结合在一起，根据功能、性质、作用等因素抽象成不同的抽象数据类型。
　　每个抽象数据类型既包含了数据，也包含了针对这些数据的授权操作，并限定数据的值只能由这些操作来观察和修改。
　　因此，数据抽象是相对于过程抽象更为严格、更为合理的抽象方法。

　　面向对象程序设计就是采用数据抽象这一方法来构建程序中的类和对象的。
　　它强调把数据和操作结合为一个不可分的系统单位 - 对象，对象的外部只需要知道这个对象能做什么，而不必知道它是如何做的。

2.　对象

　　把客观世界这一事实映射到面向对象的程序设计中，则把问题域中的事物抽象成了对象（Object），事物的静态特征（属性）用一组数据来描述，事物的动态特征（行为）则用一组方法来刻画。

　　对象具有以下特征：

　　　　对象标识：即对象的名字，是用户和系统识别它的唯一标志。对象标识有“外部标识”和“内部标识”之分。外部标识供对象的定义者或使用者用，内部标识供系统内部唯一地识别每一个对象。在计算机世界中，可以把对象看成计算机存储器中一块可标识的区域，它能保存固定或可变数目的数据（或数据的集合）。

　　　　属性：即一组数据，用来描述对象的静态特征。在 Java 程序中，把这一组数据称为数据成员。

　　　　方法：也称为服务或操作，它是对象动态特征（行为）的描述。每一个方法确定对象的一种行为或功能。在 Java 程序中称为成员方法。

　　在 Java 程序中，类是创建对象的模板，对象是类的实例，任何一个对象都是隶属于某个类的。
　　Java 程序设计是从类的设计开始的。

3.　类

　　在面向对象的编程语言中，类是一个独立的程序单位，是具有相同属性和方法的一组对象的集合。
　　类的概念使我们能对属于该类的全部对象进行统一的描述。

　　在定义对象之前应先定义类。

　　描述一个类需要指明下述三个方面内容：

　　　　类标识：类的一个有别于其他类的名字。

　　　　属性说明：用来描述相同对象的静态特征。

　　　　方法说明：用来描述相同对象的动态特征。

4.　类与对象的关系

　　类给出了属于该类的全部对象的抽象定义，而对象则是符合这种定义的一个实体。
　　可以把类与对象之间的关系看成是抽象与具体的关系。
　　在面向对象的程序设计中，对象被称作类的一个实例（Instance），而类是对象的模板（Template）。
　　类是多个实例的综合抽象，而实例又是类的个体实物。

　　由于对象是类的实例，因此在定义对象之前应先定义类。在定义了类之后，才可以在类的基础上创建对象。

5.　定义类的一般格式

　　进行 Java 程序设计，实际上就是定义类的过程。
　　一个 Java 源程序文件往往是由许多个类组成的。

　　从用户的角度看，Java 源程序中的类分为两种：

　　　　系统定义的类：即 Java 类库，它是系统定义好的类。Java 语言由语法规则和类库两部分组成，语法规则确定 Java 程序的书写规范；类库则提供了 Java 程序与运行它的系统软件（Java 虚拟机）之间的接口。

　　　　用户自定义类：系统定义的类虽然实现了许多常见的功能，但是用户程序仍然需要针对特定问题的特定逻辑来定义自己的类。

　　在 Java 程序中，用户自定义类的一般格式如下：

class 类名
{
  数据成员
  成员方法
}

　　　　类的结构是由类说明和类体两部分组成的。
　　　　类的说明部分由关键字 class 与类名组成，类名的命名遵循 Java 标识符的定义规则。
　　　　类体是类声明中花括号所包括的全部内容，它又是由数据成员（属性）和成员方法（方法）两部分组成。
　　　　数据成员描述对象的属性；成员方法则刻画对象的行为或动作，每一个成员方法确定一个功能或操作。

6.　Java 类库

　　Java 的类库是系统提供的已实现的标准类的集合，是 Java 编程的 API（Application Program Interface），它可以帮助开发者方便、快捷地开发 Java 程序。
　　Java 基础类库（JFC）是由 Sun 公司提供的，也有少量则是由其他软件开发商以商品形式提供的。

　　学习 Java 语言程序设计，一是要学习其语法规则中的基本数据类型、基本运算和基本语句等，这是编写 Java 程序的基本功；二是要学习使用类库，这是提高编程效率和质量的必由之路，甚至从一定程度上来说，能否熟练自如地掌握尽可能多的 Java 类库，决定了一个 Java 程序员编程能力的高低。

　　在 Java 系统中，系统定义好的类根据实现的功能不同，可以划分成不同的集合。每个集合称为一个包，所有包称为类库。根据功能的不同，Java 类库的每个包中都有若干个具有特定功能和相互关系的类和接口。

　　使用类库中系统定义好的类有三种方式：一是直接使用系统类；二是继承系统类，在用户程序里创建系统类的子类；三是创建系统类的对象。
　　无论采用哪种方式，使用系统类的前提条件是这个系统类应该是用户程序可见的类。为此用户程序需要用 import 语句引入它所用到的系统类或系统类所在的包。

　　类库包中的程序都是字节码形式的程序，利用 import 语句将一个包引入到程序里，就相当于在编译过程中将该包中的所有系统类的字节码加入到用户的 Java 程序中，这样用户的 Java 程序就可以使用这些系统类及其中的各种功能了。

　　Java 程序常用的包：

　　java.lang 包

　　　　Java 语言的核心类库，包含了运行 Java 程序必不可少的系统类，如基本数据类型、基本数学函数、字符串处理、线程、异常处理类等。
　　　　每个 Java 程序运行时，系统都会自动地引入 java.lang 包，所以这个包的加载是缺省的。

　　java.io 包

　　　　包含了实现 Java 程序与操作系统、用户界面以及其他 Java 程序之间进行数据交换所使用的类，如基本输入/输出流、文件输入/输出流、过滤输入/输出流、管道输入/输出流、随机输入/输出流等。
　　　　凡是需要完成与操作系统有关的较底层的输入/输出操作的 Java 程序，都要用到 java.io 包。

　　java.awt 包

　　　　它是 Java 语言用来构建图形用户界面（GUI）的类库，包括了许多界面元素和资源。
　　　　java.awt 包主要在三个方面提供界面设计支持：一是低级绘图操作；二是图形界面组件和布局管理；三是界面用户交互控制和事件响应。

　　java.awt.event 包

　　　　它是对 JDK 1.0 版本中原有的 Event 类的一个扩充，它使得程序可以用不同的方式来处理不同类型的事件，并使每个图形界面的元素本身可以拥有处理它上面事件的能力。

　　java.awt.image 包

　　　　用来处理和操作来自于网上的图片的 Java 工具类库。

　　java.applet 包

　　　　用来实现运行于 Internet 浏览器中的 Java Applet 的工具类库，它仅包含少量几个接口和一个非常有用的类 java.applet.Applet。

　　java.net 包

　　　　它是 Java 语言用来实现网络功能的类库。
　　　　目前已经实现的 Java 网络功能主要有：底层网络通信；编写用户自己的 Telnet、FTP、邮件服务等实现网上通信的类；用于访问 Internet 上资源和进行 CGI 网关调式的类。
　　　　利用 java.net 包中的类，开发者可以编写自己的具有网络功能的程序。

　　java.rmi 包、java.rmi.registry 包和 java.rmi.server 包

　　　　这三个包用来实现 RMI（Remote Method Invocation，远程方法调用）功能。
　　　　利用 RMI 功能，用户程序可以在远程计算机（服务器）上创建对象，并在本地计算机（客户机）上使用这个对象。

　　java.util 包

　　　　包括了 Java 语言中的一些低级的实用工具，如时间的处理、变长数组的处理、栈和哈希（散列）表的处理。

　　java.sql 包

　　　　它是实现 JDBC（Java Database Connection）的类库。
　　　　利用这个包可以使 Java 程序具有访问不同种类的数据库的功能。
　　　　只要安装了合适的驱动程序，同一个 Java 程序不需要修改就可以存取、修改这些不同的数据库中的数据。
　　　　JDBC 的这种功能，再加上 Java 程序本身具有的平台无关性，大大拓宽了 Java 程序的应用范围，特别是商业应用的使用领域。

　　java.security 包、java.security.acl 包、java.security.interfaces 包

　　　　这三个包提供更完善的 Java 程序安全性控制和管理，利用它们可以对 Java 程序加密，也可以把特定的 Java Applet 标记为“可信赖的”，使它能够具有与 Java Application 相近的安全权限。

　　java.awt.peer 包

　　　　它是实现 Java 语言跨平台特性的手段之一。
　　　　其作用是将不同的平台包裹、隐藏起来，使这些平台在用户程序面前呈现基本相同的面貌。

　　java.util.zip 包

　　　　用来实现文件压缩功能。

　　java.awt.datatransfer 包

　　　　提供了处理数据传输的工具类，如剪贴版、字符串发送器等。

　　java.lang.reflect 包

　　　　提供了用于反射对象的工具，反射允许程序监视一个正在运行的对象并获得它的构造函数、方法和属性。

　　java.corba 包、java.corba.orb 包

　　　　这两个包将 CORBA（Common Object Request Broker Architecture，一种标准化接口体系）嵌入到 Java 环境中，使得 Java 程序可以存取、调用 CORBA 对象，并与 CORBA 对象共同工作。
　　　　这样，Java 程序就可以方便、动态地使用已经存在的由 Java 或其他面向对象语言开发的部件，简化软件的开发。

7.　创建对象

7.1　声明对象

　　声明对象就是确定对象的名称，并指明该对象所属的类。
　　声明格式如下：

类名 对象名表;

　　　　类名是指对象所属类的名字，它是在声明类时定义的；
　　　　对象名表是指一个或多个对象名，若为多个对象名时，用逗号进行分隔。

　　声明对象的作用是为将来的编译过程提供必要的信息。

7.2　建立对象

　　建立对象，实际上就是用 Java 提供的 new 关键字为对象分配存储空间。
　　在声明对象时，只确定了对象的名称和它所属的类，并没有为对象分配存储空间，此时对象还不是类的实例。
　　只有通过建立对象这一步，才为对象分配内存，使该对象成为类的实例。
　　建立对象的格式如下：

对象名=new 构造方法();

　　也可以在声明对象的同时建立对象，这称为创建一个对象，其格式如下：

类名 对象名=new 构造方法();

　　关键字 new 的作用是建立对象，为对象分配存储空间。

7.3　初始化对象

　　初始化对象是指由一个类生成对象时，为这个对象确定初始状态，即为它的数据成员赋初始值的过程，当然，它主要由一些赋值语句组成。
　　由于初始化操作是最常用的操作之一，为简化这一过程，Java 还提供了专用的方法来完成它，这个方法被称为构造方法。

8　使用对象

　　一个对象可以有许多属性和多个方法。
　　在面向对象的系统中，一个对象的属性和方法被紧密地结合成一个整体，二者是不可分割的，并且限定一个对象的属性值只能由这个对象或它的方法来读取和修改。
　　当一个对象被创建后，这个对象就拥有了自己的数据成员和成员方法，我们可以通过引用对象的成员来使用对象。

　　对象的数据成员的引用方式如下：

对象名.数据成员名;

　　对象的成员方法的引用方式如下：

对象名.成员方法名(参数表);

9　对象的初始化与构造方法

　　构造方法是一个类的方法中方法名与类名相同的类方法。
　　每当使用 new 关键字创建一个对象，为新建对象开辟了内存空间之后，Java 系统将自动调用构造方法初始化这个新建对象。

　　构造方法是类的一种特殊方法，它的特殊性主要体现在以下几个方面：

　　　　构造方法的方法名与类名相同。
　　　　构造方法是类的方法，它能够简化对象数据成员的初始化操作。
　　　　不能对构造方法指定类型，它有隐含的返回值，该值由系统内部使用。
　　　　构造方法一般不能由编程人员显式地直接调用，在创建一个类的对象的同时，系统会自动调用该类的构造方法将新对象初始化。
　　　　构造方法可以重载，即可定义多个具有不同参数的构造方法。
　　　　构造方法可以继承，即子类可以继承父类的构造方法。
　　　　如果用户在一个自定义类中未定义该类的构造方法，系统将为这个类定义一个缺省的空构造方法。这个空构造方法没有形式参数，也没有具体语句，不能完成任何操作。但在创建一个类的新对象时，系统要调用该类的构造方法将新对象初始化。

　　特殊情况下，构造方法中的参数名可能与数据成员名相同，此时，在构造方法中可用下面两种形式之一来区分数据成员名与参数名：

　　　　默认法。当构造方法的参数名与数据成员名相同时，将赋值号左边的标识符默认为对象的数据成员名，而赋值号右边的标识符为参数。
　　　　使用代表本类对象的关键字 this 指出数据成员名之所在。



龙震 2008-04-06 13:10 发表评论
]]>