JAVA网页编程之JAVA编程头脑 课程停顿 一

用winrar打包j2ee的程序和用IDE打包应用程序是一样的。按照你的想法，你是不是也希望服务器都整合由一家公司提供呢？编程第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关头字形貌一个还没有完成的办法――作为一个“根”利用，指出：“这是合用于从这个类承继的一切范例的一个接口函数，但今朝尚没有对它举行任何情势的完成。”笼统办法大概只能在一个笼统类里创立。承继了一个类后，谁人办法就必需完成，不然承继的类也会酿成“笼统”类。经由过程创立一个笼统办法，我们能够将一个办法置进接口中，不用再为谁人办法供应大概毫偶然义的主体代码。
interface（接口）关头字将笼统类的观点更延长了一步，它完整克制了一切的函数界说。“接口”是一种相称无效和经常使用的工具。别的假如本人乐意，亦可将多个接口都兼并到一同（不克不及从多个一般class或abstractclass中承继）。

1.7对象的创立和存在工夫
从手艺角度说，OOP（面向对象程序计划）只是触及笼统的数据范例、承继和多形性，但另外一些成绩也大概显得十分主要。本节迁就这些成绩举行切磋。
最主要的成绩之一是对象的创立及损坏体例。对象必要的数据位于哪儿，怎样把持对象的“存在工夫”呢？针对这个成绩，办理的计划是各别其趣的。C++以为程序的实行效力是最主要的一个成绩，以是它同意程序员作出选择。为取得最快的运转速率，存储和存在工夫可在编写程序时决意，只需将对象安排在仓库（偶然也叫作主动或定域变量）大概静态存储地区便可。如许便为存储空间的分派和开释供应了一个优先级。某些情形下，这类优先级的把持长短常有代价的。但是，我们同时也就义了天真性，由于在编写程序时，必需晓得对象的正确的数目、存在工夫、和范例。假如要办理的是一个较惯例的成绩，如盘算机帮助计划、仓储办理大概空中交通把持，这一办法就显得太范围了。
第二个办法是在一个内存池中静态创立对象，该内存池亦叫“堆”大概“内存堆”。若接纳这类体例，除非进进运转期，不然基本不晓得究竟必要几个对象，也不晓得它们的存在工夫有多长，和正确的范例是甚么。这些参数都在程序正式运转时才决意的。若需一个新对象，只需在必要它的时分在内存堆里复杂地创立它便可。因为存储空间的办理是运转时代静态举行的，以是在内存堆里分派存储空间的工夫比在仓库里创立的工夫长很多（在仓库里创立存储空间一样平常只必要一个复杂的指令，将仓库指针向下或向下挪动便可）。因为静态创立办法使对象原本就偏向于庞大，以是查找存储空间和开释它所需的分外开支不会为对象的创立形成分明的影响。除此之外，更年夜的天真性关于惯例编程成绩的办理是相当主要的。
C++同意我们决意是在写程序时创立对象，仍是在运转时代创立，这类把持办法加倍天真。人人也许以为既然它云云天真，那末不管怎样都应在内存堆里创立对象，而不是在仓库中创立。但还要思索别的一个成绩，亦即对象的“存在工夫”大概“保存工夫”（Lifetime）。若在仓库大概静态存储空间里创立一个对象，编译器会判别对象的延续工夫有多长，到时会主动“损坏”大概“扫除”它。程序员可用两种办法来损坏一个对象：用程序化的体例决意什么时候损坏对象，大概使用由运转情况供应的一种“渣滓搜集器”特征，主动寻觅那些不再利用的对象，并将其扫除。固然，渣滓搜集器显得便利很多，但请求一切使用程序都必需容忍渣滓搜集器的存在，并能默许随渣滓搜集带来的分外开支。但这其实不切合C++言语的计划主旨，以是未能包含到C++里。但Java的确供应了一个渣滓搜集器（Smalltalk也有如许的计划；只管Delphi默许为没有渣滓搜集器，但可选择安装；而C++亦可以使用一些由其他公司开辟的渣滓搜集产物）。
本节剩下的部分将会商利用对象时要思索的另外一些要素。

1.7.1汇合与承继器
针对一个特定成绩的办理，假如事前不晓得必要几个对象，大概它们的延续工夫有多长，那末也不晓得怎样保留那些对象。既然云云，如何才干晓得那些对象请求几空间呢？事前上基本没法提早晓得，除非进进运转期。
在面向对象的计划中，年夜多半成绩的办理举措仿佛都有些草率――只是复杂地创立另外一品种型的对象。用于办理特定成绩的新型对象包容了指向其他对象的句柄。固然，也能够用数组来做一样的事变，那是年夜多半言语都具有的一种功效。但不克不及只看到这一点。这类新对象一般叫作“汇合”（亦叫作一个“容器”，但AWT在分歧的场所使用了这个术语，以是本书将一向相沿“汇合”的称号。在必要的时分，汇合会主动扩大本人，以便顺应我们在个中置进的任何工具。以是我们事前不用晓得要在一个汇合里容下几工具。只需创立一个汇合，今后的事情让它本人卖力好了。
侥幸的是，计划优秀的OOP言语都配套供应了一系列汇合。在C++中，它们是以“尺度模板库”（STL）的情势供应的。ObjectPascal用本人的“可视组件库”（VCL）供应汇合。Smalltalk供应了一套十分完全的汇合。而Java也用本人的尺度库供应了汇合。在某些库中，一个惯例汇合即可满意人们的年夜多半请求；而在另外一些库中（出格是C++的库），则面向分歧的需求供应了分歧范例的汇合。比方，能够用一个矢量一致对一切元素的会见体例；一个链接列表则用于包管一切元素的拔出一致。以是我们能依据本人的必要选择得当的范例。个中包含集、行列、散列表、树、仓库等等。
一切汇合都供应了响应的读写功效。将某样工具置进汇合时，接纳的体例是非常分明的。有一个叫作“推”（Push）、“增加”（Add）或其他相似名字的函数用于做这件事变。但将数据从汇合中掏出的时分，体例却其实不老是那末分明。假如是一个数组情势的实体，好比一个矢量（Vector），那末大概能用索引运算符或函数。但在很多情形下，如许做常常会无功而返。别的，单选定函数的功效长短常无限的。假如想对汇合中的一系列元素举行利用或对照，而不是仅仅面向一个，这时候又该怎样办呢？
举措就是利用一个“持续器”（Iterator），它属于一种对象，卖力选择汇合内的元素，并把它们供应给承继器的用户。作为一个类，它也供应了一级笼统。使用这一级笼统，可将汇合细节与用于会见谁人汇合的代码断绝开。经由过程承继器的感化，汇合被笼统成一个复杂的序列。承继器同意我们遍历谁人序列，同时毋需体贴基本布局是甚么――换言之，不论它是一个矢量、一个链接列表、一个仓库，仍是其他甚么工具。如许一来，我们就能够天真地改动基本数据，不会对程序里的代码形成搅扰。Java最入手下手（在1.0和1.1版中）供应的是一个尺度承继器，名为Enumeration（列举），为它的一切汇合类供应服务。Java1.2新增一个更庞大的汇合库，个中包括了一个名为Iterator的承继器，能够做比老式的Enumeration更多的事变。
从计划角度动身，我们必要的是一个全功效的序列。经由过程对它的利用，应当能办理本人的成绩。假如一品种型的序列便可满意我们的一切请求，那末完整没有需要再换用分歧的范例。有两方面的缘故原由促使我们必要对汇合作出选择。起首，汇合供应了分歧的接口范例和内部举动。仓库的接口与举动与行列的分歧，而行列的接口与举动又与一个集（Set）或列表的分歧。使用这个特性，我们办理成绩时便有更年夜的天真性。
其次，分歧的汇合在举行特定操纵时常常有分歧的效力。最好的例子即是矢量（Vector）和列表（List）的区分。它们都属于复杂的序列，具有完整分歧的接口和内部举动。但在实行一些特定的义务时，必要的开支倒是完整分歧的。对矢量内的元素举行的随机会见（存取）是一种常时操纵；不管我们选择的选择是甚么，必要的工夫量都是不异的。但在一个链接列表中，若想各处挪动，并随机选择一个元素，就需支付“惨痛”的价值。并且假定某个元素位于列表较远的中央，找到它所需的工夫也会长很多。但在另外一方面，假如想在序列中部拔出一个元素，用列表就比用矢量划算很多。这些和其他操纵都有分歧的实行效力，详细取决于序列的基本布局是甚么。在计划阶段，我们能够先从一个列表入手下手。最初调剂功能的时分，再依据情形把它换成矢量。因为笼统是经由过程承继器举行的，以是能在二者便利地切换，对代码的影响则显得微乎其微。
最初，记着汇合只是一个用来安排对象的蕴藏所。假如谁人蕴藏所能满意我们的一切必要，就完整没需要体贴它详细是怎样完成的（这是年夜多半范例对象的一个基础观点）。假如在一个编程情况中事情，它因为其他要素（好比在Windows下运转，大概由渣滓搜集器带来了开支）发生了内涵的开支，那末矢量和链接列表之间在体系开支上的差别就也许不是一个年夜成绩。我们大概只必要一品种型的序列。乃至能够设想有一个“完善”的汇合笼统，它能依据本人的利用体例主动改动下层的完成体例。

1.7.2单根布局
在面向对象的程序计划中，因为C++的引进而显得尤其凸起的一个成绩是：一切类终极是不是都应从独自一个基本类承继。在Java中（与其他几近一切OOP言语一样），对这个成绩的谜底都是一定的，并且这个终级基本类的名字很复杂，就是一个“Object”。这类“单根布局”具有很多方面的长处。
单根布局中的一切对象都有一个通用接口，以是它们终极都属于不异的范例。另外一种计划（就象C++那样）是我们不克不及包管一切工具都属于不异的基础范例。从向后兼容的角度看，这一计划可与C模子更好地共同，并且能够以为它的限定更少一些。但假期我们想举行地道的面向对象编程，那末必需构建本人的布局，以期取得与内建到其他OOP言语里的一样的便当。需增加我们要用到的各类新类库，还要利用另外一些不兼容的接口。天经地义地，这也必要支付分外的精神使新接口与本人的计划计划共同（大概还必要多重承继）。为失掉C++分外的“天真性”，支付如许的价值值得吗？固然，假如真的必要――假如早已经是C专家，假如对C有难舍的情结――那末就真的很值得。但假设你是一位老手，初次打仗这类计划，象Java那样的交换计划大概会更费事一些。
单根布局中的一切对象（好比一切Java对象）都能够包管具有一些特定的功效。在本人的体系中，我们晓得对每一个对象都能举行一些基础操纵。一个单根布局，加上一切对象都在内存堆中创立，能够极年夜简化参数的传送（这在C++里是一个庞大的观点）。
使用单根布局，我们能够更便利地完成一个渣滓搜集器。与此有关的需要撑持可安装于基本类中，而渣滓搜集器可将得当的动静发给体系内的任何对象。假如没有这类单根布局，并且体系经由过程一个句柄来利用对象，那末完成渣滓搜集器的路子会有很年夜的分歧，并且会晤临很多停滞。
因为运转期的范例信息一定存在于一切对象中，以是永久不会碰到判别不出一个对象的范例的情形。这对体系级的操纵来讲显得出格主要，好比背例把持；并且也能在程序计划时取得更年夜的天真性。
但人人也大概发生疑问，既然你把优点说得这么信口开河，为何C++没有接纳单根布局呢？现实上，这是初期在效力与把持上衡量的一种了局。单根布局会带来程序计划上的一些限定。并且更主要的是，它加年夜了新程序与原有C代码兼容的难度。只管这些限定仅在特定的场所会真的形成成绩，但为了取得最年夜的天真水平，C++终极决意保持接纳单根布局这一做法。而Java不存在上述的成绩，它是全新计划的一种言语，不用与现有的言语坚持所谓的“向后兼容”。以是很天然地，与其他年夜多半面向对象的程序计划言语一样，单根布局在Java的计划计划中很快就落实上去。

1.7.3汇合库与便利利用汇合
因为汇合是我们常常都要用到的一种工具，以是一个汇合库是非常需要的，它应当能够便利地反复利用。如许一来，我们就能够便利地取用各类汇合，将其拔出本人的程序。Java供应了如许的一个库，只管它在Java1.0和1.1中都显得十分无限（Java1.2的汇合库则无疑是一个佳构）。

1.下溯外型与模板／通用性
为了使这些汇合可以反复利用，大概“再生”，Java供应了一种通用范例，之前曾把它叫作“Object”。单根布局意味着、一切工具归根结柢都是一个对象”！以是包容了Object的一个汇合实践能够包容任何工具。这使我们对它的反复利用变得十分烦琐。
为利用如许的一个汇合，只需增加指向它的对象句柄便可，今后能够经由过程句柄从头利用对象。但因为汇合只能包容Object，以是在我们向汇合里增加对象句柄时，它会上溯外型成Object，如许便丧失了它的身份大概标识信息。再次利用它的时分，会失掉一个Object句柄，而非指向我们新近置进的谁人范例的句柄。以是如何才干偿还它的原本相貌，挪用新近置进汇合的谁人对象的有效接口呢？
在这里，我们再次用到了外型（Cast）。但这一次不是在分级布局中上溯外型成一种更“通用”的范例。而是下溯外型成一种更“特别”的范例。这类外型办法叫作“下溯外型”（Downcasting）。举个例子来讲，我们晓得在上溯外型的时分，Circle（圆）属于Shape（多少外形）的一品种型，以是上溯外型是平安的。但我们不晓得一个Object究竟是Circle仍是Shape，以是很难包管下溯外型的平安举行，除非切实地晓得本人要操纵的是甚么。
但这也不是相对伤害的，由于假设下溯外型成毛病的工具，会失掉我们称为“背例”（Exception）的一种运转期毛病。我们稍后即会对此举行注释。但在从一个汇合提取对象句柄时，必需用某种体例正确地记着它们是甚么，以包管下溯外型的准确举行。
下溯外型和运转期反省都请求花分外的工夫来运转程序，并且程序员必需支付分外的精神。既然云云，我们能不克不及创立一个“智能”汇合，令其晓得本人包容的范例呢？如许做可打消下溯外型的需要和潜伏的毛病。谜底是一定的，我们能够接纳“参数化范例”，它们是编译器能主动定制的类，可与特定的范例共同。比方，经由过程利用一个参数化汇合，编译器可对谁人汇合举行定制，使其只承受Shape，并且只提取Shape。
参数化范例是C++一个主要的构成部分，这部分是C++没有单根布局的原因。在C++中，用于完成参数化范例的关头字是template（模板）。Java今朝还没有供应参数化范例，由于因为利用的是单根布局，以是利用它显得有些愚笨。但这其实不能包管今后的版本不会完成，由于“generic”这个词已被Java“保存到未来完成”（在Ada言语中，“generic”被用来完成它的模板）。Java接纳的这类关头字保存机制实在常常让人摸不着思想，很难判定今后会产生甚么事变。

1.7.4扫除时的窘境：由谁卖力扫除？
每一个对象都请求资本才干“保存”，个中最使人注视的资本是内存。假如不再必要利用一个对象，就必需将其扫除，以便开释这些资本，以便其他对象利用。假如要办理的长短常复杂的成绩，怎样扫除对象这个成绩其实不显得很凸起：我们创立对象，在必要的时分挪用它，然后将其扫除大概“损坏”。但在另外一方面，我们平常碰到的成绩常常要比这庞大很多。
举个例子来讲，假定我们要计划一套体系，用它办理一个机场的空中交通（一样的模子也大概适于办理一个堆栈的货柜、大概一套影带出租体系、大概宠物店的宠物房。这初看仿佛非常复杂：机关一个汇合用来包容飞机，然后创立一架新飞机，将其置进汇合。对进进空中交通控制区的一切飞机都云云处置。至于扫除，在一架飞机分开这个地区的时分把它复杂地删往便可。
但事变并没有这么复杂，大概还必要另外一套体系来纪录与飞机有关的数据。固然，和把持器的次要功效分歧，这些数据的主要性大概一入手下手其实不显现出来。比方，这笔记录反应的多是分开机场的一切小飞机的航行企图。以是我们失掉了由小飞机构成的另外一个汇合。一旦创立了一个飞机对象，假如它是一架小飞机，那末也必需把它置进这个汇合。然后在体系余暇时代，需对这个汇合中的对象举行一些背景处置。
成绩如今显得更庞大了：怎样才干晓得甚么工夫删除对象呢？用完对象后，体系的其他某些部分大概仍旧要发扬感化。一样的成绩也会在其他大批场所呈现，并且在程序计划体系中（如C++），在用完一个对象以后必需明白地将其删除，以是成绩会变得非常庞大（正文⑥）。

⑥：注重这一点只对内存堆里创立的对象建立（用new命令创立的）。但在另外一方面，对这儿形貌的成绩和其他一切罕见的编程成绩来讲，都请求对象在内存堆里创立。

在Java中，渣滓搜集器在计划时已思索到了内存的开释成绩（只管这其实不包含扫除一个对象触及到的其他方面）。渣滓搜集器“晓得”一个对象在甚么时分不再利用，然后会主动开释谁人对象占有的内存空间。接纳这类体例，别的加上一切对象都从单个根类Object承继的现实，并且因为我们只能在内存堆中以一种体例创立对象，以是Java的编程要比C++的编程复杂很多。我们只必要作出大批的决定，便可克制本来存在的大批停滞。

1.渣滓搜集器对效力及天真性的影响
既然这是云云好的一种手腕，为何在C++里没有失掉充实的发扬呢？我们固然要为这类编程的便利性支付必定的价值，价值就是运转期的开支。正如新近提到的那样，在C++中，我们可在仓库中创立对象。在这类情形下，对象会得以主动扫除（但不具有在运转时代为所欲为创立对象的天真性）。在仓库中创立对象是为对象分派存储空间最无效的一种体例，也是开释那些空间最无效的一种体例。在内存堆（Heap）中创立对象大概要支付高贵很多的价值。假如老是从统一个基本类承继，并使一切函数挪用都具有“同质多形”特性，那末也不成制止地必要支付必定的价值。但渣滓搜集器是一种特别的成绩，由于我们永久不克不及断定它甚么时分启动大概要花多长的工夫。这意味着在Java程序实行时代，存在着一种不联贯的要素。以是在某些特别的场所，我们必需制止用它――好比在一个程序的实行必需坚持不乱、联贯的时分（一般把它们叫作“及时程序”，只管并非一切及时编程成绩都要这方面的请求――正文⑦）。

⑦：依据本书一些手艺性读者的反应，有一个现成的及时Java体系（www.newmonics.com）的确可以包管渣滓搜集器的效能。

C++言语的计划者已经向C程序员收回哀求（并且做得十分乐成），不要但愿在可使用C的任何中央，向言语里到场大概对C++的速率或利用形成影响的任何特征。这个目标到达了，但价值就是C++的编程不成制止地庞大起来。Java比C++复杂，但支付的价值是效力和必定水平的天真性。但对年夜多半程序计划成绩来讲，Java无疑都应是我们的首选。

1.8背例把持：办理毛病
从最陈旧的程序计划言语入手下手，毛病把持一向都是计划者们必要办理的一个年夜成绩。因为很难计划出一套完善的毛病把持计划，很多言语爽性将成绩复杂地疏忽失落，将其转嫁给库计划职员。对年夜多半毛病把持计划来讲，最次要的一个成绩是它们严峻依附程序员的警悟性，而不是依附言语自己的强迫尺度。假如程序员不敷小心――若对照匆仓促，这几近是一定会产生的――程序所依附的毛病把持计划便会生效。
“背例把持”将毛病把持计划内置到程序计划言语中，偶然乃至内建到操纵体系内。这里的“背例”（Exception）属于一个特别的对象，它会从发生毛病的中央“扔”或“掷”出来。随后，这个背例会被计划用于把持特定范例毛病的“背例把持器”捕捉。在情形变得不合错误劲的时分，大概有几个背例把持器并行捕捉对应的背例对象。因为接纳的是自力的实行路径，以是不会搅扰我们的惯例实行代码。如许便使代码的编写变得加倍复杂，由于不用常常性强迫反省代码。除此之外，“掷”出的一个背例分歧于从函数前往的毛病值，也分歧于由函数设置的一个标记。那些毛病值或标记的感化是唆使一个毛病形态，是能够疏忽的。但背例不克不及被疏忽，以是一定能在某个中央失掉处理。最初，使用背例可以牢靠地从一个糟的情况中恢复。此时一样平常不必要加入，我们能够接纳某些处置，恢复程序的一般实行。明显，如许体例出来的程序显得加倍牢靠。
Java的背例把持机制与年夜多半程序计划言语都有所分歧。由于在Java中，背例把持模块是从一入手下手就封装好的，以是必需利用它！假如没有本人写一些代码来准确地把持背例，就会失掉一条编译期堕落提醒。如许可包管程序的联贯性，使毛病把持变得加倍简单。
注重背例把持其实不属于一种面向对象的特征，只管在面向对象的程序计划言语中，背例一般是用一个对象暗示的。早在面向对象言语问世之前，背例把持就已存在了。

1.9多线程
在盘算机编程中，一个基础的观点就是同时对多个义务加以把持。很多程序计划成绩都请求程序可以停动手头的事情，改成处置其他一些成绩，再前往主历程。能够经由过程多种路子到达这个目标。最入手下手的时分，那些具有呆板初级常识的程序员编写一些“中止服务例程”，主历程的停息是经由过程硬件级的中止完成的。只管这是一种有效的办法，但编出的程序很难移植，由此形成了另外一类的价值奋发成绩。
有些时分，中止对那些及时性很强的义务来讲是很有需要的。但还存在其他很多成绩，它们只需求将成绩分别进进自力运转的程序片段中，使全部程序能更敏捷地呼应用户的哀求。在一个程序中，这些自力运转的片段叫作“线程”（Thread），使用它编程的观点就叫作“多线程处置”。多线程处置一个罕见的例子就是用户界面。使用线程，用户可按下一个按钮，然后程序会当即作出呼应，而不是让用户守候程序完成了以后义务今后才入手下手呼应。
最入手下手，线程只是用于分派单个处置器的处置工夫的一种工具。但假设操纵体系自己撑持多个处置器，那末每一个线程都可分派给一个分歧的处置器，真正进进“并交运算”形态。从程序计划言语的角度看，多线程操纵最有代价的特征之一就是程序员不用体贴究竟利用了几个处置器。程序在逻辑意义上被支解为数个线程；假设呆板自己安装了多个处置器，那末程序会运转得更快，毋需作出任何特别的调校。
依据后面的叙述，人人大概感到线程处置十分复杂。但必需注重一个成绩：共享资本！假如有多个线程同时运转，并且它们试图会见不异的资本，就会碰到一个成绩。举个例子来讲，两个历程不克不及将信息同时发送给一台打印机。为办理这个成绩，对那些可共享的资本来讲（好比打印机），它们在利用时代必需进进锁定形态。以是一个线程可将资本锁定，在完成了它的义务后，再解开（开释）这个锁，使其他线程能够接着利用一样的资本。
Java的多线程机制已内建到言语中，这使一个大概较庞大的成绩变得复杂起来。对多线程处置的撑持是在对象这一级撑持的，以是一个实行线程可表达为一个对象。Java也供应了无限的资本锁定计划。它能锁定任何对象占用的内存（内存实践是多种共享资本的一种），以是统一工夫只能有一个线程利用特定的内存空间。为到达这个目标，必要利用synchronized关头字。其他范例的资本必需由程序员明白锁定，这一般请求程序员创立一个对象，用它代表一把锁，一切线程在会见谁人资本时都必需反省这把锁。

1.10永世性
创立一个对象后，只需我们必要，它就会一向存鄙人往。但在程序停止运转时，对象的“保存期”也会宣布停止。只管这一征象外表上十分公道，但深切究查就会发明，假设在程序中断运转今后，对象也能持续存在，并能保存它的全体信息，那末在某些情形下将是一件十分有代价的事变。下次启动程序时，对象仍旧在那边，内里保存的信息仍旧是程序上一次运转时的那些信息。固然，能够将信息写进一个文件大概数据库，从而到达不异的效果。但只管可将一切工具都看做一个对象，假如能将对象声明成“永世性”，并令其为我们照看其他一切细节，无疑也是一件相称便利的事变。
Java1.1供应了对“无限永世性”的撑持，这意味着我们可将对象复杂地保留到磁盘上，今后任什么时候间都可取回。之以是称它为“无限”的，是因为我们仍旧必要明白收回挪用，举行对象的保留和取回事情。这些事情不克不及主动举行。在Java将来的版本中，对“永世性”的撑持无望加倍周全。
你对java乐观有点盲目。java的关键就是在服务器上表现优异，而且它提供了整个开发所需要的工具。应该是说，看哪天。net有没有机会赶上java。

所以现在应用最广泛又最好学的就是J2EE了。 J2EE又包括许多组件，如Jsp,Servlet,JavaBean,EJB,JDBC,JavaMail等。要学习起来可不是一两天的事。那么又该如何学习J2EE呢？当然Java语法得先看一看的，I/O包，Util包，Lang包你都熟悉了吗？然后再从JSP学起。

象、泛型编程的特性，广泛应用于企业级Web应用开发和移动应用开发。

应用在电视机、电话、闹钟、烤面包机等家用电器的控制和通信。由于这些智能化家电的市场需求没有预期的高，Sun公司放弃了该项计划。随着1990年代互联网的发展

还好，SUN提供了Javabean可以把你的JSP中的 Java代码封装起来，便于调用也便于重用。

多重继承（以接口取代）等特性，增加了垃圾回收器功能用于回收不再被引用的对象所占据的内存空间，使得程序员不用再为内存管理而担忧。在 Java 1.5 版本中，Java 又引入了泛型编程（Generic Programming）、类型安全的枚举、不定长参数和自动装/拆箱等语言特性。

自从Sun推出Java以来，就力图使之无所不包，所以Java发展到现在，按应用来分主要分为三大块：J2SE,J2ME和J2EE,这也就是Sun ONE(Open Net Environment)体系。J2SE就是Java2的标准版，主要用于桌面应用软件的编程；J2ME主要应用于嵌入是系统开发，如手机和PDA的编程；J2EE是Java2的企业版，主要用于分布式的网络程序的开发，如电子商务网站和ERP系统。

一直感觉JAVA很大，很杂，找不到学习方向，前两天在网上找到了这篇文章，感觉不错，给没有方向的我指了一个方向，先不管对不对，做下来再说。

科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。

是一种为 Internet发展的计算机语言

仓酷云

你可以去承接一些项目做了，一开始可能有些困难，可是你有技术积累，又考虑周全，接下项目来可以迅速作完，相信大家以后都会来找你的，所以Money就哗啦啦的。。。。。。

吧，现在很流行的Structs就是它的一种实现方式，不过Structs用起来实在是很繁，我们只要学习其精髓即可，我们完全可以设计自己的MVC结构。然后你再研究一下软件Refactoring (重构)和极限XP编程，相信你又会上一个台阶。 做完这些，你不如整理一下你的Java代码，把那些经典的程序和常见的应用整理出来，再精心打造一番，提高其重用性和可扩展性。你再找几个志同道合的朋友成立一个工作室吧

应用在电视机、电话、闹钟、烤面包机等家用电器的控制和通信。由于这些智能化家电的市场需求没有预期的高，Sun公司放弃了该项计划。随着1990年代互联网的发展

多重继承（以接口取代）等特性，增加了垃圾回收器功能用于回收不再被引用的对象所占据的内存空间，使得程序员不用再为内存管理而担忧。在 Java 1.5 版本中，Java 又引入了泛型编程（Generic Programming）、类型安全的枚举、不定长参数和自动装/拆箱等语言特性。

关于设计模式的资料，还是向大家推荐banq的网站 [url]http://www.jdon.com/[/url]，他把GOF的23种模式以通俗易懂的方式诠释出来，纯Java描述，真是经典中的经典。

任职于太阳微系统的詹姆斯·高斯林等人于1990年代初开发Java语言的雏形，最初被命名为Oak，目标设置在家用电器等小型系统的程序语言

如果要向java web方向发展也要吧看看《Java web从入门到精通》学完再到《Struts2.0入门到精通》这样你差不多就把代码给学完了。有兴趣可以看一些设计模块和框架的包等等。

我大二，Java也只学了一年，觉得还是看thinking in java好，有能力的话看英文原版(中文版翻的不怎么好)，还能提高英文文档阅读能力。

多重继承（以接口取代）等特性，增加了垃圾回收器功能用于回收不再被引用的对象所占据的内存空间，使得程序员不用再为内存管理而担忧。在 Java 1.5 版本中，Java 又引入了泛型编程（Generic Programming）、类型安全的枚举、不定长参数和自动装/拆箱等语言特性。