【文档说明】5Java面向对象程序设计Java语言程序设计汇总课件.ppt，共(71)页，482.501 KB，由小橙橙上传

转载请保留链接：https://www.ichengzhen.cn/view-44818.html

以下为本文档部分文字说明：

5.1类（class）类是组成Java程序的基本元素，它封装了一系列的变量（即数据成员，也称为“域（field）”）和方法（即成员方法method），是一类对象的原型。创建一个新的类，就是创建一个新的数据类型。实例化一个类，就得到一个对象。因此，对

象就是一组变量和相关方法的集合，其中变量表明对象的状态、属性，方法表明对象所具有的行为。5.1.1类定义对一个用户自定义的类，要为类取一个名字，并指明类中包含哪些变量和方法以及相应的类型、实现等，这称为类的定义。类定义语句的一般形式为：[修饰符]class类名[exten

ds父类名][implements接口名表]{成员变量声明//类体方法成员声明}其中class、extends和implements都是Java的关键字。修饰符、extends(表示继承)和i

mplements(表示接口)等内容，以后逐渐介绍。类定义中必须要写的内容是类名，应该使用Java语言合法的标识符来对自定义的类命名。在大括号中定义类体，指明该类中包含的数据成员和成员方法。在Java语言中也允许定义没有任何成员的空类。【例5.1】定义一

个名为Rect表示长方形的类，它仅包含double类型的长length和宽width两个数据成员。classRect{doublelength;doublewidth;}在类的定义中，可加入对数据成员进行操作的方法成员

。【例5.2】定义一个名为Rectangle表示长方形的类，它包含double类型的长length和宽width两个数据成员和设置长方形长宽值的方法setDim()、计算长方形面积的方法area()。classRectangle{dou

blelength;doublewidth;doublearea(){returnlength*width;}voidsetDim(doublew,doublel){width=w;length=l;}}在一个程序中，有时需要定义多个类。多个类的

定义形式有两种：并列和嵌套。常见的多个类定义形式为并列定义，即一个类接着一个类进行定义，它们之间是并列的关系。另一种形式为嵌套定义，即在一个类中定义另外的类，它们之间是包含和被包含的关系，可分别称为包含

类和内部类（或嵌套类）。采用何种形式定义多个类，由类之间的访问关系确定。类定义了一个类型（type）。与Java语言提供的几种基本类型一样，类型用来声明、定义该类型的变量。例如，下面的语句：Rectrect1；

声明变量rect1的类型为类Rect。类型为类的变量与基本类型变量有所不同，类是一种引用（reference）类型。实际上，rect1是一个对类型为类Rect的对象的引用,rect1不是对象本身，可理解为

一个指针，上述声明仅生成一个空（null）引用。5.1.2类对象一旦定义了所需的类，就可以创建该类的变量，创建类的变量称为类的实例化，类的变量也称为类对象、类的实例等。类的对象是在程序运行中创建生成的，其所占的空间在程序运行中动态分配。当一个类的对象完成了它的使命，为节省资源，Java的

垃圾收集程序就会自动收回这个对象所占的空间。即类对象有自己的生命周期。1.创建对象创建类的对象需用new运算符，一般形式为：对象名=new类名()new运算符用指定的类在内存中分配空间，并将存储空间的引用存入语句中的对象变量。例如：rect1=newRect();new运算符也

可以与类声明一起使用来创建类的对象。例如：Rectrect1=newRect();2.引用对象在创建了类的对象后，就可以对对象的各个成员进行访问，进行各种处理。访问对象成员的一般形式为：对象名.数据成员名对象名

.成员方法名()//方法名带圆括号运算符“.”在这里称为成员运算符，在对象名和成员名)之间起到连接的作用，指明是哪个对象的哪个成员。例如：设已经定义了例5.2中的Rectangle类，可以用如下的方

法来引用对象的成员：Rectangler=newRectangle();//定义类的对象r.length,r.width//引用对象的数据成员r.area()//引用对象的成员方法【例5.3】利用例5.1定义的类Rect，计算长和宽分别为20和10的长

方形面积。classRectDemo{publicstaticvoidmain(Stringargs[]){Rectrect1=newRect();//为对象rect1分配存储空间doublearea;rect1.width=20;//向数据成员赋值rec

t1.length=10;area=rect1.width*rect1.length;//对数据成员运算System.out.println("长方形面积是："+area);}}本程序由两个类构成，设已经编译类Rect文件Rect.class和RectDemo.class，程

序的运行结果如下：长方形面积是：200.0【例5.5】用例5.2中定义的类Rectangle分别计算长、宽分别为20、10和6、3的两个长方形面积。classRectDemo2{publicstaticvoidmain(Stri

ngargs[]){Rectanglerect1=newRectangle();Rectanglerect2=newRectangle();doublear;rect1.setDim(20,10);//初始化每个长方形rect2.setDim(6,3);ar=rect1.ar

ea();System.out.println("第一个长方形的面积是："+ar);ar=rect2.area();System.out.println("第二个长方形的面积是："+ar);}}程序运行结果如下：第一个长方形的面积是：200.0第二个长方形的面积是：18

.05.1.3构造方法在Java中，任何变量在被使用前都必须先设置初值。Java提供了为类的成员变量赋初值的专门功能：构造方法（constructor）。构造方法是一种特殊的成员方法，它的特殊性反映在如下几个方面：(1)构

造方法名与类名相同。(2)构造方法不返回任何值，也没有返回类型。(3)每一个类可以有零个或多个构造方法。(4)构造方法在创建对象时自动执行，一般不能显式地直接调用。【例5.6】分别计算长、宽分别为20、10和6、3的两个长方形面积。本程序用构造方法来初始化长方形的大小。clas

sRectConstructor{doublelength;doublewidth;doublearea(){returnlength*width;}RectConstructor(doublel,doublew){

length=l;width=w;}}classRectDemo3{publicstaticvoidmain(Stringargs[]){RectConstructorrect1=newRectConstructor(20,10);RectConstructorrect2

=newRectConstructor(6,3);doublear;ar=rect1.area();System.out.println("第一个长方形的面积是："+ar);ar=rect2.area();

System.out.println("第二个长方形的面积是："+ar);}}程序运行结果如下：第一个长方形的面积是：200.0第二个长方形的面积是：18.05.1.4类和成员的修饰符在类和类的成员定

义时可以使用一些修饰符（modifier）来对类和成员的使用作某些限定。一般将修饰符分为两类：访问控制符和非访问控制符。访问控制符有public、protected、private等，它们的作用是给予对象一定的访问权限，实现类和类中成员的信息隐藏。非访问控制符作用各不相同，有static

、final、native、volatile、abstract等。某些修饰符只能应用于类的成员，某些修饰符既可应用于类也可应用于类的成员。1.static修饰符使用static修饰符来修饰类的成员

变量和方法成员，使它们成为静态成员，也称为类成员。静态成员存储于类的存储区，属于整个类，而不属于一个具体的类对象。因为静态成员属于整个类，所以它被所有该类对象共享。在不同的类对象中访问静态成员，访问的是同一个。对静态成员的使用要注意两点：(1)静态方法不能访问属于某个

对象的成员变量，而只能处理属于整个类的成员变量。即静态方法只能处理静态变量。(2)可以用两种方式调用静态成员，它们的作用相同。变量：类名.变量、类对象.变量。方法：类名.方法名()、类对象.方法名()。【例5.8】静态成员的使用。classStaticDemo

{staticinta=42;staticintb=99;staticvoidcallme(){System.out.println("a="+a);}}classStaticByName{publicstaticvoidmain(Stringargs[]){

StaticDemo.callme();System.out.println("b="+StaticDemo.b);}}程序运行结果如下：a=42b=992.final修饰符final修饰符可

应用于类、方法和变量。final的意义为终极或最终。final类不能被继承，即final类无子类。final方法不能被覆盖，即子类的方法名不能与父类的final方法名相同。final变量实际上是Java语言的符号常量，可在定义时赋初值或在定义后的其他地方赋初值，

但不能再次赋值，习惯上使用大写的标识符表示final变量。例如：finaldoublePI=3.1416;finaldoubleG=9.18;因为final变量不能改变，没有必要在每个对象中进行存储，可以将final变量

声明为静态的，以节省存储空间。例如：staticfinaldoublePI=3.1416;3.abstract修饰符abstract修饰符可应用于类和方法，称为抽象类和抽象方法。抽象类需要继承、抽象方法需要在子类中实现才有意义。进一步的讨论见5.2.2抽象类和抽象方法。4.n

ative修饰符native修饰符一般用来声明用其他语言如C、C++、FORTRAN、汇编等书写方法体并具体实现方法功能的特殊方法。由于native方法的方法体使用其他语言编写。所以所有的native方法都没有方法体。native方法可

应用于实时性强、执行效率高，运行速度要求较高的场合。5.synchronized修饰符synchronized修饰符可应用于方法或块，在多线程程序中，对用于共享的方法和块加互斥锁，使得任一时刻，synchronized方法或块只能由一个线程执行或操作。5.1.5类的使用1.私有成

员的访问为了降低类间的耦合性，可以为类成员指定private修饰符，表示该成员只能在该类内部访问。若需要在其他类中访问私有成员，只能通过取数和送数的方法来访问。这样的方法常命名为getXxx()和setXxx()等。【例5.9】私有成员的访问。

classRectangleRC{privatedoublelength;privatedoublewidth;doublegetLength(){//定义取长方形边长的方法returnlength

;}doublegetWidth(){returnwidth;}RectangleRC(doublel,doublew){length=l;width=w;}}classRectDemo5{publicstaticvoidmain(Stringargs[]){R

ectangleRCrect1=newRectangleRC(8,7);doublear=rect1.getLength()*rect1.getWidth();System.out.println("长方形的面积是："+a

r);}}程序运行结果如下：长方形的面积是：56.02.方法参数是类的对象在Java语言中，方法的参数类型除了可以是基本类型外，还可以是引用类型－类。因为在类的对象中实际存储为对象的引用，因此在调用类参数时方法间传送的是

引用。尽管Java采用值传送，引用从调用方法单向传送到被调方法，但由于调用方法与被调方法对应类参数的引用相同，它们引用同一对象，所以，若在被调方法中修改了引用类型形式参数的取值，则调用方法对应的实际参数也将发生相应的变化。即调用方法与被调方法之间是“引用单向传送，数据双向传送”

。应用引用类型的方法参数，可在方法间传送数据。【例5.10】引用类型的方法参数是方法间传送数据的桥梁。classRefParameter{doublewidth,length,area;RefParameter(doublew,doublel){width=w;

length=l;}voidcalArea(RefParameterr){r.area=r.width*r.length;}}classPassObject{publicstaticvoidmain(Stringargs[]){RefParame

terrr=newRefParameter(10,20);rr.calArea(rr);System.out.println("长方形面积为："+rr.area);}}程序运行结果如下：长方形面积为：200.03.方法返

回值为类的对象在Java语言中，方法的返回值类型也可以为引用类型，例如：类。【例5.11】方法的返回值类型为引用类型。classRetClass{doublewidth,length,area;Re

tClass(doublew,doublel){width=w;length=l;}RetClasscalArea(RetClassr){r.area=r.width*r.length;returnr;}}classReturnObject{publicstaticvo

idmain(Stringargs[]){RetClassrr=newRetClass(10,20);rr=rr.calArea(rr);System.out.println("长方形面积为："+rr.area);}}程序运行结果如下：长方形面积为：200.04.类对象作为类的

成员类的数据成员也可以是引用类型的数据，如数组、字符串和类等。若一个类的对象是一个类的成员时，要用new运算符为这个对象分配存储空间。在包含类数据成员的类及类的实例中可以访问类数据成员的成员。【例5.12】类对象作为类的成

员。classRectC{doublewidth,length;RectC(doublew,doublel){width=w;length=l;}}classRectangleC{//具有两个成员的类RectCr=new

RectC(10,20);//类成员要分配空间doublearea;//基本类型成员}classClassMember{publicstaticvoidmain(Stringargs[]){RectangleCrr=newRect

angleC();rr.area=rr.r.width*rr.r.length;System.out.println("长方形面积为："+rr.area);}}程序运行结果如下：长方形面积为：200.05.内部类（Innerclass）内

部类，也称为嵌套类，被附加到JDK1.1及更高版本中。内部类允许一个类定义被放到另一个类定义里、一个语句块里或一个表达式内部。内部类是一个有用的特征，因为它们允许将逻辑上同属性的类组合到一起，并在另一个类中控制一个类的可视性。【

例5.13】在一个类中定义类（内部类）。classRectDemo6{publicstaticvoidmain(Stringargs[]){doublear;classRectangleR{doublelength;doublewidt

h;doublearea(){returnlength*width;//返回面积}voidsetDim(doublew,doublel){width=w;length=l;}}RectangleRrect1=n

ewRectangleR();RectangleRrect2=newRectangleR();rect1.setDim(10,20);//初始化每个长方形rect2.setDim(3,6);ar=rect1.area();System.out.println

("第一个长方形面积是："+ar);ar=rect2.area();System.out.println("第二个长方形面积是："+ar);}}程序运行结果如下：第一个长方形面积是：200.0第二个长方形面积是：18.0因为内部类定义

在一个类中，因此内部类的名称不能与所嵌套的类相同，而且只能在定义的范围中使用。内部类具有下面一些特性：(1)内部类可以被定义在方法中。它可以访问嵌套类的方法的final变量。(2)内部类可以使用所嵌套类的类变量和实例

变量以及所嵌套的块中的本地变量。(3)内部类可以被定义为abstract抽象类。(4)内部类可以被声明为private或protected，以便防护它们不受来自外部类的访问。访问保护不阻止内部类使用其他类的任何成员。(5)一个内部类可以作为一个接口，由另一个

内部类实现。(6)声明为static的内部类成为顶层类。这些内部类失去了在本地范围和其他内部类中使用数据或变量的能力。(7)内部类不能声明任何static成员，只有顶层类可以声明static成员。因此，一个需求static成员的内部

类必须使用来自顶层类的成员。5.2类的继承(inheritance)继承是面向对象程序设计的另一个重要特色，类继承也称为类派生，是指一个类可以继承其他类的非私有成员，实现代码复用。被继承的类称为父类或超类，父类

包括所有直接或间接被继承的类；继承父类或超类后产生的类称为派生类或子类。Java语言以Object类作为所有类的父类，所有的类都是直接或间接地继承Object类得到的。Java还提供不同层次的标准类，使用

户可根据需要派生自己的类。在Java语言中，只允许单继承。所谓单继承是指每个类只有一个父类，不允许有多个父类。但一个类允许同时拥有多个子类，这时这个父类实际上是所有子类的公共成员变量和公共方法成员的集合，而每一个子类

则是父类的特殊化，是对公共成员变量和方法成员的功能、内涵方面的扩展和延伸。Java语言的多继承可通过接口来实现。类继承不改变成员的访问权限，父类中的成员为公有的或被保护的，则其子类的成员访问权限也继承为公有的或被保护的。5.2.1类

继承的实现Java中的继承是通过extends关键字来实现的，在定义新类时使用extends关键字指明新类的父类，就在两个类之间建立了继承关系。1.定义子类通过继承系统类定义子类的例子已经见过的有例1.2的

小程序和例3.32的自定义异常处理程序，其类头分别为：publicclassHelloAppletextendsApplet{......}classMyExceptionextendsException{.....

.}一般地，在类声明中，加入extends子句来创建一个类的子类。extends后即为父类名，若父类名又是某个类的子类，则定义的类也是该类的（间接）子类。若无extends子句，则该类为java.lang.Object的子类。2.类继承的传递性类继

承具有传递性，即子类继承父类的所有非私有成员，也继承父类的父类直至祖先所有的所有非私有成员。3.类的成员覆盖在类的继承中，若子类（派生类）新增的成员名称与父类（超类）成员相同，则称为成员覆盖（overriding）。在子类中定义与父类同名成员的目的是修改父类的属性和

行为。(1)成员变量的覆盖若子类声明了与父类同名的变量，则父类的变量被隐藏起来，直接使用的是子类的变量，但父类的变量仍占据空间，可通过super或父类名来访问。【例5.14】在子类中定义了与父类同名的变量，从而隐藏了父类成员

变量，这种隐藏变量可加super前缀来访问。classA{intx=100;}classBextendsA{intx=200;voidprint(){System.out.println("Subclass:"+x);System

.out.println("Superclass:"+super.x);}publicstaticvoidmain(Stringargs[]){(newB()).print();}}程序运行结果如下：Subclass:200Superclass:100(2)成

员方法覆盖与子类可以定义与父类同名的成员变量，实现对父类成员变量的隐藏的情况一样，子类也可以定义与父类同名的方法，实现对父类方法的覆盖。方法成员的覆盖与成员变量的隐藏的不同之处在于：子类隐藏父类的成员变量只是使得它不可见，父类的同名成员

变量在子类对象中仍然占据自己的存储空间；而子类成员方法对父类同名方法的覆盖将清除父类方法占用的内存空间，从而使得父类的方法在子类对象中不复存在。方法的覆盖中需注意的是：子类在重新定义父类已有的方法时，应保持与父类完全相同的方法头声明，即应与父类有

完全相同的方法名、返回值和参数列表。否则就不是方法的覆盖。而是在子类定义自己的与父类无关的成员方法，父类的方法未被覆盖，所以仍然存在。下述规则适用于覆盖方法：覆盖方法的返回类型必须与它所覆盖的方法相同。覆盖方法不能比它所覆盖的方

法访问性差。覆盖方法不能比它所覆盖的方法抛出更多的异常。4.派生类的初始化在创建派生类的对象时，使用派生类的构造方法对其初始化，不但要对自身的成员变量赋初值，还要对父类的的成员变量赋初值。因为成员变量赋初值通常在构造方法中完成，因此在Jav

a语言中，允许派生类继承父类的构造方法。构造方法的继承遵循如下的原则：(1)若父类是无参数的构造方法，则子类无条件的继承该构造方法。(2)若子类无自己的构造方法，则它将继承父类的无参构造方法作为自己的构造方法；若子类有自己的构造方法，则在创建子类对象时，它将先执行继承自

父类的无参构造方法，然后再执行自己的构造方法。(3)若父类是有参数的构造方法，子类可以通过在自己的构造方法中使用super关键字来调用它，但这个调用语句必须是子类构造方法的第一个可执行语句。【例5.15】继承例5.6中的类RectConstru

ctor时对父类的成员变量赋初值。classCubeextendsRectConstructor{doubleheight;Cube(doublel,doublew,doubleh){super(l,w);height=h;}voidvol(){System.out.print

ln("长方体体积="+area()*height);}}publicclassCubeDemo{publicstaticvoidmain(Stringargs[]){Cubec=newCube(7,6,5)

;c.vol();}}程序运行结果如下：长方体体积=210.05.2.2抽象类和抽象方法abstract修饰的抽象类需要子类继承，在派生类中实现抽象类中的抽象方法。抽象类被派生、抽象方法被子类实现后，才有实际意义。抽象方法是只有返回值类型、方法名、方法参数而不定

义方法体的一种方法。抽象方法的方法体在子类中才编写实现。注意不能用abstract修饰构造方法、静态方法和私有(private)方法，也不能覆盖父类中的抽象方法。抽象方法必须定义在抽象类中。抽象类是一种未实现的类，抽象类不能用new实例化一个对象。【例5.16】计算

底面半径为2高为3的圆柱体体积和长、宽、高分别为3、2、4的长方形体积。abstractclassShape{//定义抽象类Shapedoubleradius,length,width,height;abstra

ctdoublevol();//抽象方法volShape(doubler,doubleh){//定义构造方法radius=r;height=h;}Shape(doublel,doublew,doubleh){len

gth=l;width=w;height=h;}}classCircleextendsShape{Circle(doubler,doubleh){super(r,h);}doublevol()

{//在抽象类的子类中实现抽象方法return(3.1416*radius*radius*height);}}classRectangleextendsShape{Rectangle(doublel,double

w,doubleh){super(l,w,h);}doublevol(){return(length*width*height);}classAbstractClassDemo{publicstati

cvoidmain(Stringargs[]){Circlec=newCircle(2,3);Rectangler=newRectangle(3,2,4);System.out.println(

"圆柱体体积="+c.vol());System.out.println("长方体体积="+r.vol());}}程序的运行结果如下：圆柱体体积=37.6992长方体体积=24.05.2.3类对

象之间的类型转换与基本数据类型之间的强制类型转换类似，在Java语言中，有继承关系的父类对象和子类对象之间也可以在一定条件下相互转换。父类对象和子类对象的转换需要注意以下原则：(1)子类对象可以被视为是其父类的一个对象，反之则不可。(2)若一个方法的形式参数定义的是父类的对象，则调

用该方法的实际参数可以使用子类对象。(3)若父类对象引用指向的实际是一个子类对象（在以前的某个时候根据（1）将子类对象的引用赋值给这个父类对象的引用），则这个父类对象的引用可以用强制类型转换转化成子类对象的引用。5.3接口（interface）接口是若干完成某

一特定功能的没有方法体的方法（抽象方法）和常量的集合。接口仅提供了方法协议的封装。为了获取接口功能和真正实现接口功能需要使用类来继承该接口。在继承接口的类中，通过定义接口中抽象方法的方法体（即抽象方法的覆盖）来实现接口功能。Java语言使用接口来实现类间多重继承的功能，从而弥补了J

ava语言只支持类间单重继承，描述复杂实际问题处理不方便的不足。5.3.1接口的定义和实现1.接口的定义在Java语言中，用关键字interface来定义接口。接口有类似类的结构，其定义格式如下：[修饰符]interface接口名[extend

s父接口名表]{//接口体}接口定义包括定义接口名和接口体。接口名是一合法的标识符。接口体同抽象类相似，为变量和抽象方法的集合，但没有构造方法和静态初始化代码。接口体中定义的变量均为终极（final）的、静态（static）的和公共（public）的。接口

体中定义的方法均为抽象的和公共的。由于接口所有成员均具有这些特性，相关的修饰符可以省略。2.接口的实现在某个继承接口的派生类中为接口中的抽象方法书写语句并定义实在的方法体称为实现这个接口。派生类实现哪个或哪些接口用implements说明，不能用ex

tends说明。派生类在实现接口时，还要注意：若实现接口的类不是抽象类，则在该类的定义部分必须实现指定接口的所有抽象方法。方法体可以由java语言书写，也可以由其他语言书写。因为是覆盖方式，所以方法头部分应该与接口中的定义完全一致，即有完全相同

的参数表和返回值。【例5.17】接口的实现。interfaceIrect{doublew=3,l=4;voidcompute();}classCrectimplementsIrect{publicvoidcompute()

{System.out.println("边长分别为3和4的长方形面积为："+w*l);}}publicclassInterfaceDemo{publicstaticvoidmain(Stringargs[]){Cre

ctr=newCrect();r.compute();}}程序运行结果如下：边长分别为3和4的长方形面积为：12.05.3.2接口的继承和组合接口也可以通过关键字extends继承其他接口。子接口将继承父接口中所有的常量和抽象方法。此时，子接口的非抽象派生类不

仅需实现子接口的抽象方法，而且需实现继承来的抽象方法。不允许存在未被实现的接口方法。【例5.18】接口的继承。interfaceA{Stringa="在接口A中";voidshowA();}inter

faceBextendsA{Stringb="在接口B中";voidshowB();}interfaceCextendsB{Stringc="在接口C中";voidshowC();}classInterfaceABCimplementsC{publicvoidshowA

(){System.out.println(a);}publicvoidshowB(){System.out.println(b);}publicvoidshowC(){System.out.print

ln(c);}}publicclassUseInterface2{publicstaticvoidmain(Stringargs[]){InterfaceABCi=newInterfaceABC();i.showA();i.showB();i.showC();}

}程序运行结果如下：在接口A中在接口B中在接口C中5.3.3接口的多态接口的使用使得方法的描述说明和方法功能的实现分开考虑，这有助于降低程序的复杂性，使程序设计灵活，便于扩充修改。这也是Java面向对象程序设计方法中多态特性的体现。【例5.19】定义接口并实现接口，说明接

口的多态。interfaceOneToN{intdisp(intn);}classSumimplementsOneToN{publicintdisp(intn){ints=0,i;for(i=1;i<=n;i++)s+=i;retu

rns;}}classProimplementsOneToN{//继承接口publicintdisp(intn){//实现接口中的disp方法intm=1,i;for(i=1;i<=n;i++)m*=i;returnm;}}publicclassUseIn

terface{publicstaticvoidmain(Stringargs[]){intn=10;Sums=newSum();Prop=newPro();System.out.println("1至n的和="+s.disp(n));S

ystem.out.println("1至n的积="+p.disp(n));}}程序的运行结果如下：1至n的和=551至n的积=36288005.3.4接口类型的使用接口可以作为一种引用类型来使用。任何实现接口的类的实例都可以存储在该接口类型的变

量中。通过这些变量可以访问类所实现的接口中的方法。Java运行时系统动态地确定应该使用哪个类中的方法。【例5.20】接口类型的使用（结果同例5.12）。publicclassUseInterface1{p

ublicstaticvoidmain(Stringargs[]){intn=10;OneToNotn;Sums=newSum();otn=s;System.out.println("1至n的和="+otn.disp(n));Prop=newPro();o

tn=p;System.out.println("1至n的积="+otn.disp(n));}}5.4包（package）一组相关的类和接口集合称为包。包体现了Java语言面向对象特性中的封装机制，包将java语言的类和接口有机地组织成层次结构，这个层次结构与具体

的文件系统的目录树结构层次一致。因此，Java包就是具有一定相关性在文件系统中可准确定位的Java文件的集合。5.4.1创建包包由包语句package创建，其语法格式如下：package[包名1[.包名2[.[...]

]]]关键字package后是不同层次的包名,在包名1下允许有次一级的子包－包名2，包名2下可以有更次一级的子包－包名3等等。各级包名之间用“.”号分隔。通常情况下，包名称的元素被整个地小写。在Java程序中，packag

e语句必须是程序的第一条非空格、非注释语句。通过package语句，可将Java程序分层次地存放在不同的目录下，目录名称与包的名称相同。【例5.21】在例5.1的类定义前加语句package创建包(例5.1的程序代码保持不变)。packagech05;

编译程序完成生成Rect.class文件后，可将当前目录的Rect.class文件复制或移动到创建的ch05子目录中。若在编译上述程序时，带d编译参数来进行编译，即使用编译命令：javac-d目录名Rect.j

ava来进行编译，java系统自动在命令行中d参数指定的目录(该目录已经存在)中创建ch05(与程序中的包名相同)子目录，然后自动将生成的类文件Rect.class存放其中。5.4.2使用包将类组织为包的目的是为了更好地利用包中的类。一般情况下，一个类只能引用与它在同一个包中的

类。在Java程序中，若要用到某些包中的类或接口，一种方法是在程序的开始部分写出相应的引入（import）语句，指出要引入哪些包的哪些类。另一种方法不用引入语句，直接在要引入的类和接口前给出其所在包名。无论采用哪种方法，使用系统类的前

提是这个系统类应该是用户程序可见的类。1.使用import语句import语句用于灵活地实现在编译单元中使用外部类和接口的引入机制，引入语句不必考虑类和接口的引入顺序和是否被多次引入。import语句的格式如下：import包名；import包名.标识符

；import包名.*；2.直接使用包这种方法一般用在程序中引用类和接口次数较少的时候，在要引入的类和接口前直接给出其所在包名。例如：java.applet.Appletap=newjava.applet.Applet();

在一些Java程序中，还使用全局唯一包名（GloballyUniquePackageName）的引用形式。全局是相对于Internet和Intranet而言的。全局唯一包名通常以一个Internet域名经过将域名前后颠倒的简单变换

来命名。例如：com.sun.java.io.*;3.使用CLASSPATH环境变量CLASSPATH环境变量的作用与DOS的PATH和APPEND命令作用类似，当一个程序找不到它所需要的其他类的.clas

s文件时，系统会自动到CLASSPATH环境变量所指明的路径中去查找。通过SET命令设置CLASSPATH，可设置程序对类的搜索路径。若设置错误，Java程序将不能正常执行。下面是一个设置CLASSPATH的SET命令：SETCLASSPATH=

.;c:\jdk1.5\lib;c:\jdk1.5\lib\classes.zip它将Java类搜索路径设置为当前目录、c:\jdk1.5\lib目录和c:\jdk1.5\lib\classes.z

ip。对Java应用程序，还可以通过设置Java解释器开关参数来指定类文件的搜索路径。例如，对于Sun公司的JaveSDK解释器java.exe，有开关参数-classpath。例如，若需要解释执行的Hello.class文件

不在当前目录，而在D盘根目录下jfile目录中，则可以使用如下的命令行语句来执行SDK解释器：javaHello-classpathd:\jfile【例5.22】对例5.3中类RectDemo引用例5.21中的ch05包中的类Rect的使用。可在例5.3

的类定义前添加语句：packagech05;importch05.*;编译完成产生class文件后将其从当前目录复制或移动到ch05子目录下，可在当前目录下用如下的命令来执行：javach05.RectDemo程序运行结果同例5.3一样。5.4.3类及类成员的访问权限Java程序

将数据和对数据的处理代码封装为类，并以类为程序的基本单位，但类又被封装在包中。要访问类或封装在类中的数据和代码，必须清楚在什么情况下，它们是可访问的。一个类总可以访问和调用自己的变量和方法，但这个类之外的程序其他部分是否能访问这些变量和方法，则由该变量和方法以及它们所属类

的访问控制符决定。1.类成员的访问权限Java将类的成员可见性（可访问性）划分为五种情况，按照可见性的范围大小从小到大列出如下：(1)仅在本类内可见。(2)在本类及其子类可见。(3)在同一包内可见。(4)在同一包内及其子类（不同包）可见。(

5)在所有包内可见。类成员的可访问性与定义时所用的修饰符private（私有）、protected（保护）、privateprotected（私有保护）和public（公共）有关。声明为private的类成员仅能在本类内被访问；声明为prote

cted的类成员可以在本类、本包、本类的子类被访问；声明为privateprotected的类成员可以在本类、本类的子类被访问；声明为public的类成员可以在所有包内被访问；未用修饰符声明的类成员，则隐含为在本包内可被访

问。2.类的访问权限类通常只用两种访问权限：缺省和public。类声明为public时，可以被任何包的代码访问；缺省时，可被本包的代码访问。因为类封装了类成员，因此，类成员的访问权限也与类的访问权限有关。5.4.4Java的应用程序接口（API）Java的

应用程序接口API是以包的形式提供的，每个包内包含大量相关的类、接口和异常。(1)java.langJava语言的核心包，有Java程序所需要的最基本的类和接口，包括Object类、基本数据类型包装类、数学类、异常处理类、线程类、字符串处理类、系统与运行类和类操作类等。这个包由编译器自

动引入。(2)java.applet用来实现运行于Internet浏览器中的JavaApplet的工具类库，它包含少量的几个接口和一个非常有用的类java.applet.Applet。(3)java.awt是Java抽象窗口

工具箱包，包含许多字体和颜色设置、几何绘图、图像显示、图形用户接口操作的类和接口。(4)java.io是Java语言的标准输入/输出类库，包含实现Java程序与操作系统、外部设备以及其他Java程序做数据交换所使用的类，例如基本输入/输

出流、文件输入/输出流、过滤输入/输出流、管道输入/输出流、随机输入/输出流等。还包含了目录和文件管理类等。(5)java.net是Java网络包，实现网络功能。(6)java.util包含了Java语言中的一些低级的实用工具，如处理

时间的Date类，处理变长数组的Vector类，实现栈和杂凑表的Stack类和HashTable类等。使用包中系统类的方法有三种：一种是继承系统类，在用户程序中创建系统类的子类，例如JavaApple

t程序的主类作为java.applet包中Applet类的子类；第二种方法是创建系统类的对象，例如创建包装类的对象；最后一种方法是直接使用系统类，例如程序中常用的System.out.println()方法，就是系统类S

ystem的静态属性out的方法。