JAVA网站制作之第三讲 Java言语中的面向对象特征

自己的整个学习思路完全被老师的讲课思路所牵制，这样几节课听下来，恐怕自己的见解都应该是书里的知识点了，根本谈不上自身发现问题，分析问题，和解决问题能力的切实提高。对象【课前思索】
　　1．甚么是对象？甚么是类？甚么是包？甚么是接口？甚么是外部类？
　　2．面向对象编程的特征有哪三个？它们各自又有哪些特征？
　　3．你晓得java言语在面向对象编程方面有何共同的特性吗？

难点：
　　1．了解办法重载和办法重写，不要搅浑了二者的利用。
　　2．类变量和类办法的利用。
　　3．接口的利用。
3．1面向对象手艺基本

3．1．1面向对象的基础观点
　　面向对象的基础头脑
　　面向对象是一种新兴的程序计划办法,大概是一种新的程序计划标准(paradigm),其基础头脑是利用对象、类、承继、封装、动静等基础观点来举行程序计划。从实际天下中客不雅存在的事物（即对象）动身来机关软件体系，而且在体系机关中尽量使用人类的天然头脑体例。开辟一个软件是为懂得决某些成绩，这些成绩所触及的营业局限称作该软件的成绩域。其使用范畴不单单是软件，另有盘算机系统布局和野生智能等。

1．对象的基础观点
　　对象是体系顶用来形貌客不雅事物的一个实体，它是组成体系的一个基础单元。一个对象由一组属性和对这组属性举行操纵的一组服务构成。

自动对象是一组属性和一组服务的封装体，个中最少有一个服务不必要吸收动静就可以自动实行（称作自动服务）。
2．类的基础观点
类是具有不异属性和服务的一组对象的汇合，它为属于该类的一切对象供应了一致的笼统形貌，其外部包含属性和服务两个次要部分。在面向对象的编程言语中，类是一个自力的程序单元，它应当有一个类名并包含属性申明和服务申明两个次要部分。

3．动静

动静就是向对象收回的服务哀求，它应当包括下述信息：供应服务的对象标识、服务标识、输出信息和回覆信息。服务一般被称为办法或函数。

3．1．2面向对象的基础特性

1．封装性
　　封装性就是把对象的属性和服务分离成一个自力的不异单元，并尽量潜伏对象的外部细节，包括两个寄义：
　　◇把对象的全体属性和全体服务分离在一同，构成一个不成支解的自力单元（即对象）。
　　◇信息潜伏，即尽量潜伏对象的外部细节，对形状成一个界限〔大概说构成一道屏蔽〕，只保存无限的对外接口使之与内部产生接洽。
　　封装的准绳在软件上的反应是：请求使对象之外的部分不克不及随便存取对象的外部数据（属性），从而无效的制止了内部毛病对它的"交织传染"，使软件毛病可以部分化，年夜年夜削减查错和排错的难度。

2．承继性
　　特别类的对象具有其一样平常类的全体属性与服务，称作特别类对一样平常类的承继。

一个类能够是多个一样平常类的特别类，它从多个一样平常类中承继了属性与服务，这称为多承继。

在java言语中，一般我们称一样平常类为父类（superclass,超类），特别类为子类(subclass)。

3．多态性
　　对象的多态性是指在一样平常类中界说的属性或服务被特别类承继以后，能够具有分歧的数据范例或体现出分歧的举动。这使得统一个属性或服务在一样平常类及其各个特别类中具有分歧的语义。比方："多少图形"的"画图"办法，"椭圆"和"多边形"都是"多少图"的子类，其"画图"办法功效分歧。
3．1．3面向对象程序计划办法
　　OOA－ObjectOrientedAnalysis　　　　面向对象的剖析
　　OOD－ObjectOrientedDesign　　　　　面向对象的计划
　　OOI－ObjectOrientedImplementation　面向对象的完成
3．2Java言语的面向对象特征

3．2．1类
　　类是java中的一种主要的复合数据范例，是构成java程序的基础要素。它封装了一类对象的形态和办法，是这一类对象的本相。一个类的完成包含两个部分：类声明和类体

1．类声明：
　　[public][abstract|final]classclassName[extendssuperclassName][implementsinterfaceNameList]
　　{……}
　　个中，润色符public,abstract,final申明了类的属性，className为类名，superclassName为类的父类的名字，interfaceNameList为类所完成的接口列表。
　2．类体
　　类体界说以下：
　　classclassName
　　{[public|protected|private][static]
　　[final][transient][volatile]type
　　variableName;　　　　　　　　　　　　　　　　　//成员变量
　　[public|protected|private][static]
　　[final|abstract][native][synchronized]
　　returnTypemethodName([paramList])[throwsexceptionList]
　　　{statements}　　　　　　　　　　　　　　　//成员办法
　　}
　3．成员变量
　　成员变量的声明体例以下：
　　[public|protected|private][static]
　　[final][transient][volatile]type
　　variableName;　　　　　　　　　　　　　　　　//成员变量
　　个中，
　　static:静态变量（类变量）；相对实例变量
　　final:常量
　　transient:临时性变量，用于对象存档，用于对象的串行化，见对象的串行化一节
　　volatile:奉献变量，用于并发线程的共享
　4．成员办法
　　办法的完成包含两部份内容：办法声明和办法体。
　　[public|protected|private][static]
　　[final　|abstract][native][synchronized]
　　returnTypemethodName([paramList])
　　[throwsexceptionList]　　　　　　　　　　　//办法声明
　　　{statements}　　　　　　　　　　　　　　　//办法体
　　办法声明中的限制词的寄义：
　　static:类办法，可经由过程类名间接挪用
　　abstract:笼统办法，没无方法体
　　final:办法不克不及被重写
　　native:集成别的言语的代码
　　synchronized:把持多个并发线程的会见
　　◇办法声明
　　办法声明包含办法名、前往范例和内部参数。个中参数的范例能够是复杂数据范例，也能够是复合数据范例（又称援用数据范例）。
　　关于复杂数据范例来讲，java完成的是值传送，办法吸收参数的值，但不克不及改动这些参数的值。假如要改动参数的值，则用援用数据范例，由于援用数据范例传送给办法的是数据在内存中的地点，办法中对数据的操纵能够改动数据的值。
　　例3-1申明了复杂数据范例与援用数据的区分。
【例3-1】
　　importjava.io.*;
　　publicclassPassTest{
　　floatptValue;
　　publicstaticvoidmain(Stringargs[]){
　　intval;
　　PassTestpt=newPassTest();
　　val=11;
　　System.out.println("OriginalIntValueis:"+val);
　　pt.changeInt(val);　　　　　　　　　　　　　　　　　　//值参数
　　System.out.println("IntValueafterChangeis:"+val);/*值参数
　　　　　　　　　　　　　　　　　　　值的修正，没有影响值参数的值*/
　　pt.ptValue=101f;
　　System.out.println("OriginalptValueis:"+pt.ptValue);
　　pt.changeObjValue(pt);//援用范例的参数
　　System.out.println("ptValueafterChangeis:"+pt.ptValue);/*援用参数值的修正，改动了援用参数的值*/
　　}
　　publicvoidchangeInt(intvalue){
　　value=55;　　　　　　　　　　　//在办法外部对值参数举行了修正
　　}
　　publicvoidchangeObjValue(PassTestref){
　　ref.ptValue=99f;　　　　　　//在办法外部对援用参数举行了修正
　　　　}
　　}

◇办法体
　　办法体是对办法的完成，它包含部分变量的声明和一切正当的Java指令。办法体中声明的部分变量的感化域在该办法外部。若部分变量与类的成员变量同名，则类的成员变量被埋没。
为了区分参数和类的成员变量，我们必需利用this。this-----用在一个办法中援用以后对象，它的值是挪用该办法的对象。前往值须与前往范例分歧，大概完整不异，或是其子类。当前往范例是接口时，前往值必需完成该接口。
5．办法重载
　办法重载是指多个办法享有不异的名字，可是这些办法的参数必需分歧，大概是参数的个数分歧，大概是参数范例分歧。前往范例不克不及用来辨别重载的办法。
　　参数范例的辨别度必定要充足，比方不克不及是统一复杂范例的参数，如int与long。编译器会依据参数的个数和范例来决意以后所利用的办法。

6．机关办法
　　◇机关办法是一个特别的办法。Java中的每一个类都有机关办法，用来初始化该类的一个对象。
　　◇机关办法具有和类名不异的称号，并且不前往任何数据范例。
　　◇重载常常用于机关办法。
　　◇机关办法只能由new运算符挪用

3．2．2对象
　　类实例化可天生对象，对象经由过程动静传送来举行交互。动静传送即激活指定的某个对象的办法以改动其形态或让它发生必定的举动。一个对象的性命周期包含三个阶段：天生、利用和打消。

对象的扫除
　　当不存在对一个对象的援用时，该对象成为一个无用对象。Java的渣滓搜集器主动扫描对象的静态内存区，把没有援用的对象作为渣滓搜集起来并开释。
　　System.gc();　　System.exit();//terminatethecurrentJVM
　　当体系内存用尽或挪用System.gc()请求渣滓接纳时，渣滓接纳线程与体系同步运转。
3．2．3面向对象特征
　　java言语中有三个典范的面向对象的特征：封装性、承继性和多态性。

1．封装性
　　java言语中，对象就是对一组变量和相干办法的封装，个中变量标明了对象的形态，办法标明了对象具有的举动。经由过程对象的封装，完成了模块化和信息埋没。经由过程对类的成员施以必定的会见权限，完成了类中成员的信息埋没。
◇java类中的限制词
　　java言语中有四种分歧的限制词，供应了四种分歧的会见权限。
　　1）private
　　类中限制为private的成员，只能被这个类自己会见。
　　假如一个类的机关办法声明为private,则别的类不克不及天生该类的一个实例。
　　2）default
　　类中不加任何会见权限限制的成员属于缺省的（default）会见形态：friend，能够被这个类自己和统一个包中的类所会见。
3）protected
　　类中限制为protected的成员，能够被这个类自己、它的子类（包含统一个包中和分歧包中的子类）和统一个包中的一切其他的类会见。
4）public
　　类中限制为public的成员，能够被一切的类会见。
【表3-1】　java中类的限制词的感化局限对照


统一个类
统一个包
分歧包的子类
分歧包非子类

private
*




default
*
*



protected
*
*
*


public
*
*
*
*




2．承继性
　　经由过程承继完成代码复用。Java中一切的类都是经由过程间接或直接地承继java.lang.Object类失掉的。承继而失掉的类称为子类，被承继的类称为父类。子类不克不及承继父类中会见权限为private的成员变量和办法。子类能够重写父类的办法，及定名与父类同名的成员变量。但Java不撑持多重承继，即一个类从多个超类派生的才能。
◇成员变量的埋没和办法的重写
　　子类经由过程埋没父类的成员变量和重写父类的办法，能够把父类的形态和举动改动为本身的形态和举动。
比方：
　　classSuperClass{
　　　　intx;…
　　　　voidsetX(){x=0;}…
　　}
　　classSubClassextendsSuperClass{
　　　　intx;　　//埋没了父类的变量x
　　　　…
　　　　voidsetX(){//重写了父类的办法setX()
　　　　x=5;}….
　　}
　　注重：子类中重写的办法和父类中被重写的办法要具有不异的名字，不异的参数表和不异的前往范例，只是函数体分歧。
　　◇super
　　java中经由过程super来完成对父类成员的会见，super用来援用以后对象的父类。Super的利用有三种情形：
　　1）会见父类被埋没的成员变量，如：
　　　　super.variable;
　　2）挪用父类中被重写的办法，如：
　　　　super.Method([paramlist]);
　　3）挪用父类的机关函数，如：
　　　　super([paramlist]);

【例3-5】
　　importjava.io.*;
　　classSuperClass{
　　　　intx;
　　　　SuperClass(){
　　　　　x=3;
　　　　　System.out.println("inSuperClass:x="+x);
　　　　}
　　　　　voiddoSomething(){
　　　　　System.out.println("inSuperClass.doSomething()");
　　　　}
　　}
　　classSubClassextendsSuperClass{
　　　　intx;
　　　　SubClass(){
　　　　　super();　　　//挪用父类的机关办法
　　　　　x=5;　　　　　　//super()要放在办法中的第一句
　　　　　System.out.println("inSubClass:x="+x);
　　　　}
　　　　　voiddoSomething(){
　　　　　super.doSomething();//挪用父类的办法
　　　　　System.out.println("inSubClass.doSomething()");
　　　　　System.out.println("super.x="+super.x+"sub.x="+x);
　　　　}
　　}
　　publicclassInheritance{
　　　　　publicstaticvoidmain(Stringargs[]){
　　　　　SubClasssubC=newSubClass();
　　　　　subC.doSomething();
　　　　}
　　}

3．多态性
　　在java言语中，多态性表现在两个方面：由办法重载完成的静态多态性（编译时多态）和办法重写完成的静态多态性（运转时多态）。
　　1）编译时多态
　　在编译阶段，详细挪用哪一个被重载的办法，编译器会依据参数的分歧来静态断定挪用响应的办法。
　　2）运转时多态
　　因为子类承继了父类一切的属性（公有的除外），以是子类对象能够作为父类对象利用。程序中但凡利用父类对象的中央，都能够用子类对象来取代。一个对象能够经由过程援用子类的实例来挪用子类的办法。
　　◇重写办法的挪用准绳：java运转时体系依据挪用该办法的实例，来决意挪用哪一个办法。对子类的一个实例，假如子类重写了父类的办法，则运转时体系挪用子类的办法；假如子类承继了父类的办法（未重写），则运转时体系挪用父类的办法。
在例3-6中，父类对象a援用的是子类的实例，以是，java运转时挪用子类B的callme办法。

【例3-6】
　　importjava.io.*;
　　classA{
　　　　　voidcallme(){
　　　　　　System.out.println("InsideAscallme()method");
　　　　　}
　　}
　　classBextendsA{
　　　　　voidcallme(){
　　　　　　System.out.println("InsideBscallme()Method");
　　　　　}
　　}
　　publicclassDispatch{
　　　　　publicstaticvoidmain(Stringargs[]){
　　　　　　Aa=newB();
　　　　　　a.callme();
　　　　　}
　　}
◇办法重写时应遵守的准绳：
　　1）改写后的办法不克不及比被重写的办法有更严厉的会见权限（能够不异）。
　　2）改写后的办法不克不及比重写的办法发生更多的破例。
4．别的
　　◇final关头字
　　final关头字能够润色类、类的成员变量和成员办法，但final的感化分歧。
　　1）final润色成员变量：
　　final润色变量,则成为常量，比方
　　finaltypevariableName;
　　润色成员变量时，界说时同时给出初始值，且今后不克不及被修正，而润色部分变量时不做请求。
　　2）final润色成员办法：
　　final润色办法，则该办法不克不及被子类重写
　　finalreturnTypemethodName(paramList){
　　…
　　}

　　3）final类：
　　final润色类，则类不克不及被承继
　　finalclassfinalClassName{
　　…
　　}
　　◇实例成员和类成员
　　用static关头字能够声明类变量和类办法，其格局以下：
　　statictypeclassVar;
　　staticreturnTypeclassMethod({paramlist}){
　　…
　　}
　假如在声明时不必static关头字润色，则声明为实例变量和实例办法。
　　1）实例变量和类变量
　　每一个对象的实例变量都分派内存，经由过程该对象来会见这些实例变量，分歧的实例变量是分歧的。
　　类变量仅在天生第一个对象时分派内存，一切实例对象共享统一个类变量，每一个实例对象对类变量的改动城市影响到别的的实例对象。类变量可经由过程类名间接会见，无需师长教师成一个实例对象，也能够经由过程实例对象会见类变量。
　　2）实例办法和类办法
　　实例办法能够对以后对象的实例变量举行操纵，也能够对类变量举行操纵，实例办法由实例对象挪用。
　　但类办法不克不及会见实例变量，只能会见类变量。类办法能够由类名间接挪用，也可由实例对象举行挪用。类办法中不克不及利用this或super关头字。
　　例3-7是关于实例成员和类成员的例子。
【例3-7】
　　classMember{
　　　　staticintclassVar;
　　　　intinstanceVar;
　　　　staticvoidsetClassVar(inti){
　　　　　classVar=i;
　　　　　//instanceVar=i;//类办法不克不及会见实例变量
　　　　}
　　　　staticintgetClassVar()
　　　　　{returnclassVar;}
　　　　voidsetInstanceVar(inti)
　　　　　{classVar=i;//实例办法不仅能够会见类变量，也能够实例变量
　　　　　instanceVar=i;}
　　　　　intgetInstanceVar()
　　　　　{returninstanceVar;}
　　　　}
　　　　publicclassMemberTest{
　　　　　publicstaticvoidmain(Stringargs[]){
　　　　　　　　Memberm1=newmember();
　　　　　　　　Memberm2=newmember();
　　　　　　　　m1.setClassVar(1);
　　　　　　　　m2.setClassVar(2);
　　　　　　　　System.out.println("m1.classVar="+m1.getClassVar()+"
　　　　　　　　　　　　　　　　　　m2.ClassVar="+m2.getClassVar());
　　　　　　　　m1.setInstanceVar(11);
　　　　　　　　m2.setInstanceVar(22);
　　　　　　　　System.out.println("m1.InstanceVar="+m1.getInstanceVar
　　　　　　　　　　　　　　()+"m2.InstanceVar="+m2.getInstanceVar());
　　　　　}
　　　　}
◇类java.lang.Object
　　类java.lang.Object处于java开辟情况的类条理的根部，别的一切的类都是间接或直接地承继了此类。该类界说了一些最基础的形态和举动。上面，我们先容一些经常使用的办法。
　　equals()：对照两个对象(援用)是不是不异。
　　getClass()：前往对象运转时所对应的类的暗示，从而可失掉响应的信息。
　　toString()：用来前往对象的字符串暗示。
　　finalize()：用于在渣滓搜集前扫除对象。
　　notify(),notifyAll(),wait()：用于多线程处置中的同步。

3．2．4笼统类和接口

　1．笼统类
　　java言语中，用abstract关头字来润色一个类时，这个类叫做笼统类，用abstract关头字来润色一个办法时，这个办法叫做笼统办法。格局以下：
　　abstractclassabstractClass{…}//笼统类
　　abstractreturnTypeabstractMethod([paramlist])//笼统办法
　　笼统类必需被承继，笼统办法必需被重写。笼统办法只需声明，无需完成；笼统类不克不及被实例化，笼统类纷歧定要包括笼统办法。若类中包括了笼统办法，则该类必需被界说为笼统类。

若一个类承继了一个笼统类，则笼统类的笼统办法必需被完成，不然子类必需声明为abstract.
　2．接口
　　接口是笼统类的一种，只包括常量和办法的界说，而没有变量和办法的完成，且其办法都是笼统办法。它的用途表现鄙人面几个方面：
　　◇经由过程接话柄现不相干类的不异举动,而无需思索这些类之间的干系。
　　◇经由过程接口指明多个类必要完成的办法。
　　◇经由过程接口懂得对象的交互界面,而无需懂得对象所对应的类。
1）接口的界说
　　接口的界说包含接口声明和接口体。
　　接口声明的格局以下：
　　[public]interfaceinterfaceName[extendslistOfSuperInterface]{…}
　extends子句与类声明的extends子句基础不异，分歧的是一个接口可有多个父接口，用逗号离隔，而一个类只能有一个父类。
　　接口体包含常量界说和办法界说
　　常量界说格局为：typeNAME=value;该常量被完成该接口的多个类共享;具有public,final,static的属性。在接口中只能声明常量，不成以声明变量。
　　办法体界说格局为：(具有public和abstract属性，不克不及声明为protected)
　　returnTypemethodName([paramlist])；

注重：在接口的完成类中，完成的接口办法必需声明为public，由于接口中界说的办法为public（默许）。以是实在现必需声明为public.不然编译不会经由过程。
2）接口的完成
　　在类的声明顶用implements子句来暗示一个类利用某个接口，在类体中可使用接口中界说的常量，并且必需完成接口中界说的一切办法。一个类能够完成多个接口,在implements子句顶用逗号分隔。
3）接口范例的利用
　　接口作为一种援用范例来利用。任何完成该接口的类的实例都能够存储在该接口范例的变量中，经由过程这些变量能够会见类所完成的接口中的办法。
3．2．5外部类

　1．外部类的界说和利用：
　　外部类是在一个类的外部嵌套界说的类，它能够是别的类的成员，也能够在一个语句块的外部界说，还能够在表达式外部匿名界说。
　　外部类有以下特征：
　　◇一样平常用在界说它的类或语句块以内,在内部援用它时必需给出完全的称号.名字不克不及与包括它的类名不异。
　　◇可使用包括它的类的静态和实例成员变量,也能够利用它地点办法的部分变量。
　　◇能够界说为abstract。
　　◇能够声明为private或protected。
　　◇若被声明为static,就酿成了顶层类,不克不及再利用部分变量。
　　◇若想在InnerClass中声明任何static成员,则该InnerClass必需声明为static。
例3-8】
　　importjava.awt.*;
　　importjava.awt.event.*;
　　publicclassTwoListenInner{
　　　　privateFramef;
　　　　privateTextFieldtf;
　　　　　　publicstaticvoidmain(Stringargs[]){
　　　　　　　TwoListenInnerthat=newTwoListenInner();
　　　　　　　that.go();
　　　　}
　　　　publicvoidgo(){
　　　　　　　f=newFrame("Twolistenersexample");
　　　　　　　f.add("North",newLabel("Clickanddragthemouse"));
　　　　　　　tf=newTextField(30);
　　　　　　　f.add("South",tf);
　　　　　　　f.addMouseMotionListener(newMouseMotionHandler());
　　　　　　　f.addMouseListener(newMouseEventHandler());
　　　　　　　f.setSize(300,300);
　　　　　　　f.setVisible(true);
　　　　}
　　　　publicclassMouseMotionHandlerextendsMouseMotionAdapter{
　　　　　　publicvoidmouseDragged(MouseEvente){
　　　　　　　Strings="Mousedragging:X="+e.getX()+"Y="+e.getY();
　　　　　　　tf.setText(s);
　　　　　　}
　　　　}
　　　　publicclassMouseEventHandlerextendsMouseAdapter{
　　　　　　publicvoidmouseEntered(MouseEvente){
　　　　　　　Strings="Themouseentered";
　　　　　　　tf.setText(s);
　　　　　　}
　　　　　　publicvoidmouseExited(MouseEvente){
　　　　　　　Strings="Themouseleftthebuilding";
　　　　　　　tf.setText(s);
　　　　　　}
　　　　}
　　}

申明：Frame类的add办法来自于其先人类Container类，addMouseMotionListener和addMouseListener办法来自于其先人类Component,addMouseListener办法的参数为MouseListener接口，MouseAdapter类是完成了MouseListener接口的类。可见图形界面临于内部事务的呼应是经由过程增加listener完成的
2．匿名类的界说和利用：
　　匿名类是一种特别的外部类，它是在一个表达式外部包括一个完全的类界说。经由过程对例6-7中go()部分语句的修正，我们能够看到匿名类的利用情形。
　　publicvoidgo(){
　　　　　　　　　f=newFrame("Twolistenersexample");
　　　　　　　　　f.add("North",newLabel("Clickanddragthemouse"));
　　　　　　　　　tf=newTextField(30);
　　　　　　　　　f.add("South",tf);
　　　　　　　　　f.addMouseMotionListener(newMouseMotionHandler(){
　　　　　　　　　/*界说了一个匿名类，类名没有显式地给出，只是该类是
　　　　　　　　　　MouseMotionHandler类的子类*/
　　　　　　　　　　　publicvoidmouseDragged(MouseEvente){
　　　　　　　　　　　　　Strings="Mousedragging:X="+e.getX()+"Y
　　　　　　　　　　　　　="+e.getY();
　　　　　　　　　　　　　tf.setText(s);
　　　　　　　　　　　}
　　　　　　　　　});
　　　　　　　　　f.addMouseListener(newMouseEventHandler());
　　　　　　　　　f.setSize(300,300);
　　　　　　　　　f.setVisible(true);
　　　　　　　　　}
　3．外部类的优弱点：
　　◇长处:节俭编译后发生的字节码文件的巨细
　　◇弱点:使程序布局不分明

习题：

1：外型不成以从父类向子类外型，只能从子类向父类外型。不然编译时能够经由过程，实行时会报错

如：SubClasssc=newSubClass();BaseClassbc=(BaseClass)sc;---是准确的

而BaseClassbc=newBaseClass();SubClasssc=(SubClass)bc;---是毛病的

BaseClassbc=newSubClass()也是准确的，而且在挪用bc中的办法时实行的办法体是子类的办法体，但该办法必需同时在子类，父类中同时存在，若子类中有，而父类中没有，则不成以如许挪用bc.subMethod();

若两个类都承继于统一个类(必需是间接承继，不然不合错误)，则这两个类能够相互赋值，如：Panel和Frame同承继于Container，以是Panelp=newFrame()；和Framef=newPanel()都是准确的，



ruby里有这些工具吗？又要简单多少？我没有用过这两门语言，我估计在这些语言力没有很统一的这种标准，或者根本就没有提供。

你一定会高兴地说，哈哈，原来成为Java高手就这么简单啊!记得Tomjava也曾碰到过一个项目经理，号称Java很简单，只要三个月就可以学会。

另外编写和运行Java程序需要JDK(包括JRE)，在sun的官方网站上有下载，thinking in java第三版用的JDK版本是1.4,现在流行的版本1.5（sun称作J2SE 5.0，汗），不过听说Bruce的TIJ第四版国外已经出来了，是专门为J2SE 5.0而写的。

你现在最缺的是实际的工作经验，而不是书本上那些凭空想出来的程序。

是一种由美国SUN计算机公司(Sun Microsystems, Inc.)所研究而成的语言

《JAVA语言程序设计》或《JAVA从入门到精通》这两本书开始学，等你编程有感觉的时候也可以回看一下。《JAVA读书笔记》这本书，因为讲的代码很多，也很容易看懂，涉及到面也到位。是你学习技术巩固的好书，学完后就看看《JAVA编程思想》这本书，找找一个自己写的代码跟书上的代码有什么不一样。

[url]http://www.jdon.com/[/url]去下载，或到同济技术论坛的服务器[url]ftp://nro.shtdu.edu.cn[/url]去下，安装上有什么问题，可以到论坛上去提问。

Java是一个纯的面向对象的程序设计语言，它继承了 C++语言面向对象技术的核心。Java舍弃了C ++语言中容易引起错误的指针（以引用取代）、运算符重载（operator overloading）

[url]http://www.jdon.com/[/url]去下载，或到同济技术论坛的服务器[url]ftp://nro.shtdu.edu.cn[/url]去下，安装上有什么问题，可以到论坛上去提问。

是一种由美国SUN计算机公司(Sun Microsystems, Inc.)所研究而成的语言

是一种将安全性(Security)列为第一优先考虑的语言

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

是一种使网页(Web Page)产生生动活泼画面的语言

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

是一种使用者不需花费很多时间学习的语言

你快去找一份Java的编程工作来做吧（如果是在校学生可以去做兼职啊），在实践中提高自己，那才是最快的。不过你得祈祷在公司里碰到一个高手，而且他 还愿意不厌其烦地教你，这样好象有点难哦！还有一个办法就是读开放源码的程序了。我们知道开放源码大都出自高手，他们设计合理，考虑周到，再加上有广大的程序员参与，代码的价值自然是字字珠叽，铿锵有力（对不起，偶最近《金装四大才子》看多了）。

Java语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocket等。Java的RMI（远程方法激活）机制也是开发分布式应用的重要手段。

Sun公司看见Oak在互联网上应用的前景，于是改造了Oak，于1995年5月以Java的名称正式发布。Java伴随着互联网的迅猛发展而发展，逐渐成为重要的网络编程语言。

让你能够真正掌握接口或抽象类的应用，从而在原来的Java语言基础上跃进一步，更重要的是，设计模式反复向你强调一个宗旨：要让你的程序尽可能的可重用。

当然你也可以参加一些开源项目，一方面可以提高自己，另一方面也是为中国软件事业做贡献嘛！开发者在互联网上用CVS合作开发，用QQ,MSN,E-mail讨论联系，天南海北的程序员分散在各地却同时开发同一个软件，是不是很有意思呢？