JAVA入门教程:第六章

2019-11-17 06:26:00

字体：大中小

来源：转载

供稿：网友

　　郁欣　孙元　王曦东　王克宏

在前面几章中 ,我们对 java的简单数据类型、数组、运算符和表达式以及流控制方法
作了详细的介绍。从现在开始 ,我们要深入到面向对象的编程技术 ,深入到 Java最吸引人的
地方。本章中 ,我们首先讲述面向对象程序设计的基本概念及特点 ,然后讨论 Java中的类、
对象、包和接口 ,最后进行小结 ,给出一个完整的 Java文件的格式。

§ 6.1 面向对象的程序设计

面向过程的程序设计方法从解决问题的每一个步骤入手 ,它适合于解决比较小的简单
问题。 C语言采用面向过程的程序设计模型 ,但是由于 C本身几乎没有支持代码重用的语言
结构 ,并且缺乏统一的接口 ,使得当程序的规模达到一定程度时 ,程序员很难控制其复杂性
。

面向对象的程序设计方法则按照现实世界的特点来管理复杂的事物 ,把它们抽象为对
象 ,具有自己的状态和行为 ,通过对消息的反应来完成一定的任务。

6.1.1 对象、类和消息

一个对象就是变量和相关的方法的集合 ,其中变量表明对象的状态 ,方法表明对象所
具有的行为 ,下图表示了一个对象的特征 :

从图中可以看出 ,一个对象的变量构成这个对象的核心 ,包围在它外面的方法使这个
对象和其它对象分离开来。例如 :我们可以把汽车抽象为一个对象 ,用变量来表示它当前的
状态 ,如速度、油量、型号、所处的位置等 ,它的行为则可以有加速、刹车、换挡等。我
们操纵汽车时 ,不用去考虑汽车内部各个零件如何运作的细节 ,而只需根据汽车可能的行
为使用相应的方法即可。实际上 ,面向对象的程序设计实现了对对象的封装 ,使我们不必
关心对象的行为是如何实现的这样一些细节。通过对对象的封装 ,实现了模块化和信息隐
藏 ,有利于程序的可移植性和安全性 ,同时也利于对复杂对象的管理。

对象之间必须要进行交互来实现复杂的行为。例如 ,要使汽车加速 ,必须发给它一个
消息 ,告诉它进行何种动作 (这里是加速 )以及实现这种动作所需的参数 (这里是需要达到的
速度等 )。下图表示了对象 A与对象 B间的消息传递过程。

从图中可以看出 ,一个消息包含三个方面的内容 :

● 　消息的接收者

● 　接收对象应采用的方法

● 　方法所需要的参数。

同时 ,接收消息的对象在执行相应的方法后 ,可能会给发送消息的对象返回一些信息
(如上例中 ,汽车的仪表上会出现已经达到的速度等 )。

由于任何一个对象的所有行为都可以用方法来描述 ,通过消息机制就可以完全实现对
象之间的交互 ,同时 ,处于不同处理过程甚至不同主机的对象间也可以通过消息实现交互
。

上面所说的对象是一个具体的事物 ,例如每辆汽车都是一个不同的对象。但是多个对
象常常具有一些共性 ,如所有的汽车都有轮子、方向盘、常具有一些共性 ,如所有的汽车
都有轮子、方向盘、刹车装置等。于是我们抽象出一类对象的共性 ,这就是类。类中定义
一类对象共有的变量和方法。把一个类实例化即生成该类的一个对象。比如我们可以定
义一个汽车类来描述所有汽车的共性。通过类的定义人们可以实现代码的复用。我们不
用去描述每一个对象 (如某辆汽车 ),而是通过创建类 (如汽车类 )的一个实例来创建该类的一
个对象 ,这大大减化了软件的设计。

6.1.2 继承

通过对象、类 ,我们实现了封装 ,通过子类我们可以实现继承。

对于上例来说 ,公共汽车、出租车、货车等都是汽车 ,但它们是不同的汽车 ,除了具有
汽车的共性外 ,它们还具有自己的特点 (如不同的操作方法 ,不同的用途等 )。这时我们可以
把它们作为汽车的子类来实现 ,它们继承父类 (汽车 )的所有状态和行为 ,同时增加自己的状
态和行为。通过父类和子类 ,我们实现了类的的层次 ,可以从最一般的类开始 ,逐步特殊化
,定义一系列的子类。同时 ,通过继承也实现了代码的复用 , 使程序的复杂性线性地增长 ,而
不是呈几何级数增长。

在 C++中支持多重继承 ,即一个类可以继承多个父类 ,这使得对象的实现变得非常复杂
且不可预料 (设想多个父类拥有某些相同的变量和方法 )。 Java则只支持单一继承 ,大大降低
了复杂度。在 Java中通过接口可以实现多重继承 ,但接口的概念更简单 ,使用更方便 ,而且不
仅仅限于继承 ,它使多个不相关的类可以具有相同的方法。

6.1.3 多态

Java通过方法重写和方法重载来实现多态。

通过方法重写 ,一个类中可以有多个具有相同名字的方法 , 由传递给它们的不同个数
和类型的参数来决定使用哪种方法 ,这就是多态。例如 ,对于一个作图的类 ,它有一个
draw()方法用来画图或输出文字 ,我们可以传递给它一个字符串、一个矩形、一个圆形 ,甚
至还可以再指定作图的初始位置、图形的颜色等 ,对于每一种实现 ,只需实现一个新的
draw()方法即可 ,而不需要新起一个名字 , 这样大大简化了方法的实现和调用 ,程序员和用户
都不需要记住很多的方法名 ,只需要传入相应的参数即可。

通过方法重载 ,子类可以重新实现父类的某些方法 ,使其具有自己的特征。例如对于
汽车类的加速方法 ,其子类 (如赛车 )中可能增加了一些新的部件来改善提高加速性能 ,这时
可以在赛车类中重载父类的加速方法。重载隐藏了父类的方法 ,使子类拥有自己具体实现
,更进一步表明了与父类相比 ,子类所具有的特殊性。

本节中 ,我们对面向对象程序设计的一些基本内容作了讲解 ,下面我们就分别讲述
Java是如何实现这些内容的。

§ 6.2 类

类是组成 Java程序的基本要素。它封装了一类对象的状态和方法 ,是这一类对象的原
型。在前几章的例子中 ,我们已经定义了一些简单的类 ,如 Hellowo rldApp类。

public class HelloWorldApp{
public static void main( String args[ ] ){
System.out.PRintln("Hello World !");
}
}
可以看出,一个类的实现包含两部分的内容:
classDeclaration {
classBody
}

下面我们分别对每一部分详细讲述。

6.2.1 类声明

一个最简单的类声明如下 :

class className {
……
}
例如:
class Point{
……
}

同时 ,在类声明中还可以包含类的父类 ,类所实现的接口以及修饰符 public、 abstract或
final。　我们将分别在后面的几节中介绍。

6.2.2 类体

类体中定义了该类所有的变量和该类所支持的方法。通常变量在方法前定义 (并不一
定要求 ),如下所示 :

class className {
memberVariableDeclarations
methodDeclarations
}

下例定义了一个 Point类 ,并且声明了它的两个变量 x、 y坐标 ,同时实现 init()方法对 x、 y赋
初值。

例 6.1

class Ponit {
int x,y;
void init(int ix, int iy){
x=ix;
y=iy;
}
}

类中所定义的变量和方法都是类的成员。对类的成员可以设定访问权限 ,来限定其它
对象对它的访问 ,访问权限所以有以下几种 :private, protected, publi c, friendly。我们将在 § 6.6中详细
讨论。

同时 ,对类的成员来说 ,又可以分为实例成员和类成员两种。我们在 § 6.8中详细讨论。

6.2.3 成员变量

最简单的成员变量的声明为 :

type variableName;

如在例 6.1中所声明的变量 ,int x,y;

成员变量的类型可以是 Java中的任意数据类型包括简单类型、数组、类和接口。在一
个类中 ,成员变量应该是唯一的 ,但是成员变量的名字可以和类中某个方法的名字相同 ,例
如 :

class Point{
int x,y;
int x(){
return x;
}
}

其中 ,方法 x()和变量 x具有相同的名字。

类的成员变量和在方法中所声明的局部变量是不同的 ,成员变量的作用域是整个类
,而局部变量的作用域只是方法内部。

对一个成员变量 ,我们还可以限定它的访问权限 (见 § 6.6),用 static限定它为类变量 (见 §
6.7),或者用以下的修饰符限定 :

final:用来声明一个常量 ,如 :

class FinalVar{
final int CONSTANT = 50;
……
}

例中声明了常量 CONSTANT, 并赋值为 50。对于用 final限定的常量 ,在程序中不能改变它
的值。通常常量名用大写字母。

? (未完待续 )6.2.6 构造方法

构造方法是一种特殊的方法。 Java中的每个类都有构造方法 ,用来初始化该类的一个
新的对象。构造方法具有和类名相同的名称 ,而且不返回任何数据类型 ,在构造方法的实
现中 ,也可以进行方法重写。

例6.5
class point {
int x,y;
point (){
x=0; y=0;
}
point (int x, int y){
this.x=x; this.y=y;
}
}

上例中 ,我们对类 Point实现了两个构造方法 ,方法名均为 Poin t,与类名相同。而且我们使
用了方法重写 ,根据不同的参数分别对点的 x、 y坐标赋与不同的初值。

回忆在例 6.2中 ,我们曾用 init()方法对点的 x、 y坐标进行初始化。二者完成相同的功能
,那么用构造方法的好处在哪里呢 ?

当用运算符 new为一个对象分配内存时 ,要调用对象的构造方法 ,而当创建一个对象时
,必须用 new为它分配内存。因此用构造方法进行初始化避免了在生成对象后每次都要调
用对象的初始化方法。如果没有实现类的构造方法 ,则 Java运行时系统会自动提供缺省的
构造方法 ,它没有任何参数。

另外 ,构造方法只能由 new运算符调用。我们将在 § 6.3中进行详细介绍。对构造方法同
样也有访问权限的限制 (见 § 6.6)。

6.2.7 finalize()方法

在对对象进行垃圾收集前 ,Java运行时系统回自动调用对象的 finalize()方法来释放系统资
源 ,如打开的文件或 socket。该方法的声明必须如下所示 :

protected void finalize() throws throwable

finalize()方法在类 java.lang.Object中实现。如果要在一个所定义的类中实现该方法以释放
该类所占用的资源 (即要重载父类的 finalize()方法 ),则在对该类所使用的资源进行翻译后 ,一
般要调用父类的 finalize()方法以清除对象使用的所有资源 ,包括由于继承关系而获得的资源
。通常的格式应为 :

protected void finalize () throws throwable{
…… // clean up code for this class
super. finalize();
}

该例中 ,通过 super来调用其父类的 finalize()方法 ,有关 super我们将在 § 6.4中讲述 ,对类
java.lang.Ob-ject,我们也将在 § 6.4中讲述。

§ 6.3 对象

把类实例化 ,我们可以生成多个对象 ,这些对象通过消息传递来进行交互 (消息传递即
激活指定的某个对象的方法以改变其状态或让它产生一定的行为 ),最终完成复杂的任务
。

一个对象的生命期包括三个阶段 :生成、使用和清除。下面我们分别讲述 :

6.3.1 对象的生成

对象的生成包括声明、实例化和初始化三方面的内容。通常的格式为 :

type objectName = new type ( [paramlist] );

1. type objectName; 声明了一个类型为 type的对象。其中 type是组合类型 (包括类和接口 )。
对象的声明并不为对象分配内存空间。

2. 运算符 new为对象分配内存空间 ,实例化一个对象。 new调用对象的构造方法 ,返回对
该对象的一个引用 (即该对象所在的内存地址 )。用 new可以为一个类实例化多个不同的对
象。这些对象分别占用不同的内存空间 ,因此改变其中一个对象的状态不会影响其它对象
的状态。

3. 生成对象的最后一步是执行构造方法 ,进行初始化。由于对构造方法可以进行重写
,所以通过给出不同个数或类型的参数会分别调用不同的构造方法。

以例 6.5中所定义的类 Point 为例 ,我们生成类 Point的对象 :

Point p1 = new Point();

Point p2 = new Point(5,10);

这里 ,我们为类 Point生成了两个对象 p1、 p2,它们分别调用不同的构造方法 ,p1调用缺省
的构造方法 (即没有参数 ),p2则调用带参数的构造方法。 p1、 p2 分别对应于不同的内存空间
, 它们的值是不同的 ,可以完全独立地分别对它们进行操作。

虽然 new运算符返回对一个对象的引用 ,但与 C、 C++中的指针不同 ,对象的引用是指向
一个中间的数据结构 ,它存储有关数据类型的信息以及当前对象所在的堆的地址 ,而对于
对象所在的实际的内存地址是不可操作的 ,这就保证了安全性。

6.3.2 对象的使用

对象的使用包括引用对象的成员变量和方法 ,通过运算符 ? 可以实现对变量的访问和
方法的调用 ,变量和方法可以通过设定一定的访问权限 (见 § 6.6) 来允许或禁止其它对象对
它的访问。

我们先定义一个类 Point,它在例 6.5的定义中添加了一些内容。

例6.6
class Point{
int x,y;
String name = "a point";
Point(){
x = 0;
y = 0;
}
Point( int x, int y, String name ){
this.x = x;
this.y = y;
this.name = name;
}
int getX(){
return x;
}
int getY(){
return y;
}
void move( int newX, int newY ){
x = newX;
y = newY;
}
Point newPoint( String name ){
Point newP = new Point( -x, -y, name );
return newP;
}
boolean equal( int x, int y ){
if( this.x==x && this.y==y )
return true;
else
return false;
}
void print(){
System.out.println(name+" : x = "+x+" y = "+y);
}
}
public class UsingObject{
public static void main( String args[] ){
Point p = new Point();
p.print(); //call method of an object
p.move( 50, 50 );
System.out.println("** after moving **");
System.out.println("Get x and y directly");
System.out.println("x = "+p.x+" y = "+p.y); //access variabl

es of an object
System.out.println("or Get x and y by calling method");
System.out.println("x = "+p.getY()+" y = "+p.getY());
if( p.equal(50,50) )
System.out.println("I like this point!!!! ");
else
System.out.println("I hate it!!!!! ");
p.newPoint( "a new point" ).print();
new Point( 10, 15, "another new point" ).print();
}
}
运行结果为:
C:java UsingObject
a point : x = 0 y = 0
**** after moving *****
Get x and y directly
x = 50 y = 50
or Get x and y by calling method
x = 50 y = 50
I like this point!!!!
a new point : x = -50 y = -50
another new point : x = 10 y = 15

1. 引用对象的变量

要访问对象的某个变量 ,其格式为 :

objectReference.variable

其中 objectReference是对象的一个引用 ,它可以是一个已生成的对象 ,也可以是能够生成对
象引用的表达式。

例如 :我们用 Point p=new Point();生成了类 Point的对象 p后 ,可以用 p.x,p.y来访问该点的 x、 y坐
标 ,如

p.x = 10; p.y = 20;

或者用 new生成对象的引用 ,然后直接访问 ,如 :

tx = new point().x;

2. 调用对象的方法

要调用对象的某个方法 ,其格式为 :

objectReference.methodName ( [paramlist] );

例如我们要移动类 Point的对象 p,可以用

p.move(30,20);

虽然我们可以直接访问对象的变量 p.x、 p.y来改变点 p的坐标 ,但是通过方法调用的方
式来实现能更好地体现面向对象的特点 ,建议在可能的情况下尽可能使用方法调用。

同样 ,也可以用 new生成对象的引用 ,然后直接调用它的方法 ,如

new point(). move (30,20);

前面已经讲过 ,在对象的方法执行完后 ,通常会返回指定类型的值 ,我们可以合法地使
用这个值 ,如 :例 6.6中类 Point的方法 equal返回布尔值 ,我们可以用它来作为判断条件分别执行
不同的分支。如 :

if (p.equal (20,30)){
…… //statements when equal
}else {
…… //statements when unequal
}

另外 ,类 Point的方法 newPoint返回该点关于原点的对称点 ,返回值也是一个 Point类型 , 我们
可以访问它的变量或调用它的方法 ,如 :

px = p.newPoint().x 或
px = p.newPoint(). getX();

上一篇：JAVA入门教程:第五章

下一篇：JAVA入门教程:第三章