4章.docx

4章.docx

《4章.docx》由会员分享，可在线阅读，更多相关《4章.docx（20页珍藏版）》请在冰豆网上搜索。

4章

第4章类和对象

本章主要介绍Java语言中类的定义及类的访问控制、成员的定义及成员的访问控制、对象的创建、数组的创建及使用。

第4章类和对象

4.1OO（Object-oriented）基本概念

4.2类的定义

4.3域（成员变量/字段）声明

4.4方法的定义

4.5类变量的初始化形式

4.6类对象的初始化形式

4.7数组

4.7.1数组的创建形式

4.7.2（一组）数组的应用

4.7.3多维数组

4.8对象的撤消（清除）

4.9小结

4.1OO（Object-oriented）基本概念

1.类（Class）

类是一组具有共同的属性特征和行为特征的对象的抽象。

（1）属性（Attribute）

是描述对象静态特征的一个数据项。

（2）服务（Service）

是描述对象动态特征（行为）的一个操作序列。

2.对象（Object）

对象是一组数据（属性）及对这组数据属性的一组操作（行为）构成的有标识的独立实体。

类与对象的关系:

抽象与具体的关系。

类是产生对象的模板，而对象是类的一个实例。

3.封装（encapsulation）

是指通过类机制把对象的数据和对数据的操作（行为）封装在一起成为一个独立的系统单位。

4.2类的定义

4.1.1类的定义形式

Java程序由类构成，类由类头和类体组成，其一般形式为：

[<修饰符>]class<类名>

{<每个字段的声明>

<每个方法的定义>

}//类定义结束

其中类的修饰符有2种：

（1）访问控制符

public、private或缺省来指定类的访问权限。

如:

publicclassObject{....}

（2）非访问控制符

abstract、final分别用来声明抽象类和最终类。

如：

publicfinalclassSystem{....}

下面我们定义一个平面上的点类Point，如下：

//文件名：

Point.java

publicclassPoint

{privateintx,y;//坐标

publicvoidsetPoint（inta,intb）

{x=a;y=b;}

publicvoidmove（intdx,intdy）

{x+=dx;y+=dy;}

publicintgetX（）{returnx;}

publicintgetY（）{returny;}

publicStringtoString（）

{return“（“+x+”,”+y+”）”;}

}

4.1.2类的访问控制修饰符及访问权限

和C++不同，访问权限有二层,外层为类的访问权限,由类访问控制符来指定。

内层是成员的访问权限,由成员访问控制符指定。

类的访问控制符有：

（1）public及公有访问权限

如：

publicclassA{...}

classC

{Aobj=newA（）;...}

公有类可被任何程序包中的所有类引用。

引用是指在类中或者在它们的方法体内，都可以创建该类的对象、访问这个类内可见的成员变量和调用它的方法。

（2）缺省及包访问权限

如：

classB{...}//B是友类

classD

{Bobj=newB（）;...}

缺省时声明的类称友类，友类具有包访问权限。

友类只可被同一个程序包内的所有类引用。

一般将相关的类放到同一个程序包内，在包内它们能自由访问，对外隐藏，可实现“内外有别”的封装机制。

说明1点：

同一个编译单元（Java源文件）的类属于同一个程序包。

（3）private及私有访问权限（后续介绍）

私有类具有私有访问权限。

私有类只能被外部类访问。

因此，只有内部类才允许声明为私有类，而普通类或包含内部类的外部类是不允许声明为私有类。

classOuter

{Innerobj=newInner（）;//合法

privateclassInner//私有的内部类

{.....}

}

classX

{Outer.Innerobj;...}//非法

4.3域/成员变量/字段（field）

4.3.1域（field）的声明

一般来说，类体包括一个或几个域的声明。

域的声明形式:

[访问控制修饰符][修饰符]<类型><变量名表>;

其中[]中的项可以省略。

4.3.2域的访问控制符及访问权限

（1）public

公有域可被任何类访问。

即在其它类体内或者是方法体内，可以对该成员变量进行读或写。

（2）protected

保护域可被本类访问，也可被同一包内的其它类访问，还可被其它包内的该类的子类访问。

备注：

包及包的使用方法在下一章介绍。

（3）缺省

缺省域可被本类及同一包内的其它类访问。

（4）private

私有域只能被本类的所有方法访问。

它常用来描述那些需要隐藏起来的数据信息，其他类只有通过调用该类的公有方法才能访问到它们，这就是所谓的面向对象的“数据封装和信息隐藏”的基本思想。

下面定义的是时间类Time。

classTime

{privateinthour,minute,second;

publicTime（）{hour=minute=second=0;}

publicTime（inth,intm,ints）

{setTime（h,m,s）;}

publicvoidsetHour（inth）//设置小时

{hour=h>=0&&h<24?

h:

0;}

publicvoidsetMinute（intm）//设置分

{minute=m>=0&&m<60?

m:

0;}

publicvoidsetSecond（ints）//设置秒

{second=s>=0&&s<60?

s:

0;}

publicvoidsetTime（inth,intm,ints）

{setHour（h）;setMinute（m）;setSecond（s）;}

publicintgetHour（）{returnhour;}

publicintgetMinute（）{returnminute;}publicintgetSecond（）{returnsecond;}

}//Time定义结束

4.3.3成员变量（域）的类型

2种：

静态域（类变量）和非静态域（实例变量）

用static声明的域称类变量，未用static声明的域称实例变量。

注意：

不同的对象关于静态域只有一个副本，在程序加载时系统就为它分配内存了，而不同的对象关于实例变量有不同的副本，在对象创建时才生成。

下面是圆类Circle的定义：

publicclassCircle

{publicfinalstaticdoublePI=Math.PI;//类变量

privateintradius;//实例变量

publicstaticdoublegetPI（）{returnPI;}

publicvoidsetRadius（intr）{radius=r;}

publicintgetRadius（）{returnradius;}

publicdoublegetArea（）

{returnPI*radius*radius;}

}

关于成员变量说明2点：

（1）有两种访问类变量的方法：

类名.类变量名

对象名.类变量名

下面是访问实例变量的唯一方式：

对象名.实例变量名

（2）两种成员变量都可以在声明的同时赋初值。

当没有赋初值时，系统将用缺省值对其初始化，见教材P.67。

成员变量的默认初值

类型

默认初值

boolean

false

char

'\u0000'

byte、short

（byte）0、（short）0

int、long

0、0L

float、double

+0.0f、+0.0

引用型变量

null

4.3.4最终域

最终域就是指用final声明的成员变量。

最终域初始化后不能被修改。

如：

publicclassCircle

{publicstaticfinaldoublePI=Math.PI;...

//该方法体内不能有setPI（）

}

用final声明域时，要注意以下2点：

（1）同时需要指出tatic。

4.3.5域的作用域

域的作用域开始于声明处，结束于类的右花括号处。

域的作用域大于形参（是自动变量）的作用域，如：

classPoint

{privateintx,y;

//……

publicvoidsetPoint（intx,inty）

{this.x=x;this.y=y;}

}

4.3.6域的数据类型

域（成员变量）的数据类型可以是两种：

基本数据类型和引用类型（类、接口、数组等）。

4.4方法的定义

一般地说,方法的定义形式为:

[<访问控制修饰符>][<修饰符>]<返回类型>

<方法名>（<形参表>）

{<语句序列>

}

4.4.1方法的访问控制符及访问权限

同成员变量，有四种:

public、protected、缺省、private。

让我们来回忆一下这四种访问权限。

4.4.2构造方法和创建对象

（1）构造方法

用于初始化类对象的实例变量。

注意构造方法常被重载。

如：

为Point类定义构造方法。

classPoint

{privateintx,y;//坐标

publicPoint（）{x=0;y=0;}

publicPoint（inta,intb）{x=a;y=b;}

publicPoint（Pointr）{x=r.a;y=r.b;}

//....

}

说明3点:

（a）当类中没有定义任何构造函数时，编译器自动产生一个函数体为空的缺省构造函数如下。

一般来说，应该为类定义构造函数。

publicX（）{}

（b）当用已存在的对象初始化正在创建的对象时,将调用拷贝构造函数,其一般形式为:

publicX（Xp）{每个实例变量间的拷贝操作}

（c）与C++不同,Java不产生缺省拷贝构造函数,若程序中要用时,必须自行定义拷贝构造函数。

（2）创建对象

对象创建的一般形式：

new<构造方法名>（<实参表>）

上述表达式创建的对象是匿名的，返回值为被创建对象的引用，要访问创建的对象，必须建立对象和对象引用变量（简称引用或句柄）的连接。

形式如下：

<类名><引用变量名>=new<构造方法名>（<实参表>）;

或

<类名><引用变量名表>;

……

<引用名>=new<构造方法名>（<实参表>）;

阅读下面的程序并写出程序输出。

public class Test

{ public static void main（String[] args）

{ String foo=newString（"blue"）; 

//String foo="blue";   

String bar=foo;    foo="green"; 

System.out.println（bar）; 

 } 

   } 

说明3点：

（1）对象引用和其指向的对象是两个实体。

对象是匿名的，只能通过对象引用来访问。

（2）建立对象和其引用间的连接。

（3）对象和指向它的对象引用应属于同一种类类型，不同类型的对象引用和对象间一般无法直接建立连接的。

4.4.3静态方法（类方法）和非静态方法（实例方法）

用static声明的方法称类方法，是每个对象所共享的方法。

否则称实例方法，它是某个具体类对象（实例）的方法。

注意3点：

（1）调用类方法时，应用类名做前缀，最好不用对象名做前缀。

（2）在类方法内，不能直接访问实例成员，只能访问类成员。

classB

{intx=0;

staticpublicvoidfun（）

{x=1;//非法，不能访问实例变量x

}...

}

（3）实例方法体内，既可以访问实例成员（实例变量和实例方法），也可以访问类成员。

4.4.4方法的重载

指重新定义已有的方法，得到的方法称重载方法。

对方法重载时必须遵循函数名相同，但参数表不同（个数不同或参数类型不同）。

如：

classPoint

{privateintx,y;//坐标

publicvoidsetPoint（inta,intb）重载方法1

{x=a;y=b;}

publicvoidsetPoint（Pointp）//重载方法2

{x=p.x;y=p.y;}

……

}

4.4.5this引用（变量）和实例方法

类的实例方法都有一个隐含的引用变量,称为this引用变量，简称this引用。

当1个对象调用某个实例方法时，它的this就指向那个对象。

在实例方法内访问的实例成员，都是this所指对象的实例成员；所以this引用往往省略。

如：

classPoint

{privateintx,y;//坐标

publicvoidsetPoint（Pointp）

{x=p.x;y=p.y;}//省略了this

publicvoidsetPoint（intx,inty）//重载

{this.x=x;this.y=y;}//此处的this不能省略

publicvoidmove（intdx,intdy）

{x+=dx;y+=dy;}//省略了this

publicdoublegetX（）{returnx;}

publicdoublegetY（）{returny;}

publicStringtoString（）

{return“（“+x+”,”+y+”）”;}

}

在使用时注意3点：

（1）类方法没有this，所以在类方法体内不能访问实例变量及实例方法；

（2）当实例变量与实例方法的自动变量同名时，必须显式使用this,见上面的例子。

（3）对于重载的构造方法，可以在一个构造方法体内使用“this（参数表）；”形式来调用本类另一个构造方法。

如：

classPoint

{privateintx,y;//坐标

publicPoint（）{this（0,0）;}

//this代表本类名，该语句必须是第一行语句

publicPoint（inta,intb）{x=a;y=b;}

……

}

4.5类变量的初始化形式

有2种形式：

（1）在声明类变量的同时指定初始值，若未指定则用缺省值。

publicclassCircle

{publicfinalstaticdoublePI=3.1415926;

//省略其它成员

}

（2）在类中用static开头的语句块（静态初始化块）对类变量初始化，格式为：

static

{<语句序列>

}

如：

publicclassA

{publicstaticinta=1,b=0;

static

{a=0;b=1;

System.out.println（"a="+a+"b="+b）;

a=10;b=10;

}

publicstaticvoidmain（Stringargs[]）

{System.out.println（"a="+a+"b="+b）;}

}

说明3点：

（1）静态初始化器在它所属的类加载到内存时由系统执行。

（2）一个类允许有多个静态初始化器，按它们出现的先后次序被执行。

（3）静态初始化器中的语句不能访问实例成员。

4.6类对象的初始化形式

对象的实例变量的初始化形式有3种：

（1）在声明实例变量的同时指定初始值，若未指定则用缺省值。

例如：

publicclassCircle

{publicfinalstaticdoublePI=Math.PI;

privateintradius=1;

privateintx=0,y;

publicintgetRadius（）{returnradius;}

publicintsetRadius（intr）{radius=r;}

...

}

指出newCircle（）的执行过程。

（2）用初始化块

publicclassCircle

{publicfinalstaticdoublePI=3.1415926;

privateintradius=1;

privateintx=0,y;

{x=1;y=0;}//初始化块允许有其它的语句

...

}

指出newCircle（）的执行过程。

（3）用构造方法初始化（必须定义）

publicclassCircle

{publicfinalstaticdoublePI=3.1415926;

privateintradius,x,y;

{x=1;y=1;}

publicCircle（）{radius=1;x=0;y=0;}

publicCircle（intr,intx,inty）

{radius=r;this.x=x;this.y=y;}

...

}

试分析表达式：

newCircle（2,2,2）的执行过程。

4.7数组

4.7.1数组的创建形式

在Java中，数组被当成一种对象来处理，因此数组的创建也是用new操作符。

数组元素的类型可以是基本数据类型、类、接口等。

在Java中，创建数组有如下3种方式：

1.先声明数组的引用再创建数组

（1）声明数组引用

形式如下:

<元素类型>[]<数组引用>；//<数据类型><数组引用>[];

注意：

声明时不能指定数组的大小。

例如：

int[]oneDim;//intoneDim[];

oneDim[0]=0;//不能通过编译

（2）创建数组

形式：

<数组引用>=new<数组元素类型>[<元素个数>]；

例如：

oneDim=newint[6];//每个元素取0值

注意：

数组创建后，系统用缺省值初始化每个数组元素。

2.声明引用的同时创建数组

<元素类型>[]<数组引用>=new<元素类型>[<元素个数>]；

注意：

每个元素取缺省值。

例如：

intoneDim[]=newint[6];

StringcountryName[]=newString[3];

//创建对象数组

byte[]twoDim[]=newbyte[2][3];

3.声明、创建数组的同时初始化数组元素

如：

intoneDim[]={1,2,3,4,5,6};//省略了newint[]

String[]yellow={"blue","green","red"};//省newString[]

byte[]twoDim[]={{1,2,3},{4,5,6}};//省newbyte[][]

关于数组说明4点：

（1）所有的数组都有一个成员变量length，表示数组的长度，其值不能修改,在程序中用oneDim.length查询数组的大小。

（2）初始值可以是常量、变量或复杂表达式。

（3）对象数组的元素必须有一个确定值。

（4）若访问数组下标越界,JVM将抛出ArrayIndexOutOfBoundsException类型的异常，然后中止程序执行。

4.7.2（一组）数组的应用

一个数组经声明、创建或初始化后就可以存取它，下面介绍数组的2个重要的使用场合：

一是作为方法的形参,二是作为方法的返回值。

1．数组引用作为方法的参数

在方法调用发生时，把数组引用传递给被调用方法，在被调用的方法体内就可以读/写每个数组元素。

例如，编写一个程序，实现数组的转置。

publicclassInvertArray

{publicstaticvoidinvert（inta[]）

{for（inti=0;i

{inttemp=a[i];a[i]=a[a.length-1-i];

a[a.length-1-i]=temp;

}

}

publicstaticvoidmain（Stringargs[]）

{intb[]={1,3,5,7,9,11};

for（inti=0;i

System.out.print（b[i]+"\t"）;

System.out.println（）;

invert（b）;

for（intelem:

b）

System.out.print（elem+"\t"）;

}

}

说明：

数组引用作为方法的形参，在使用时和C++基本上没有区别。

2．数组引用作为方法的返回值

方法的返回值是数组引用时，调用方法应该用与方法返回值类型相同的数组引用，接收被调方法的返回结果。

见下例的求斐波那契数列的Application程序。

publicclassCalFibonacci

{publicstaticlong[]reFibonacci（intm）//m≥2

{long[]fibonacci=newlong[m];

 fibonacci[0]=0L;

fibonacci[1]=1L;

for（intn=2;n

fibonacci[n]=fibonacci[n-1]+fibonacci[n-2];

returnfibonacci;

}

publicstaticvoidmain（String[]args）

{finalintn=25;intnum=1;

longfib[]=reFibonacci（n）;//求前25个数列项

　　　System.out.println（“斐波那契数列前25个项:

”）;

for（longe:

fib）

{System.out.print（e+""）;

if（num%9==0）System.out.println（）;//一行9个

num++;

}

 }

}

//下面是一个完成等价功能的Applet程序

importjava.awt.Graphics;

publicclassReturnArrayextendsjava.applet.Applet

{publicvoidpaint（Graphicsg）

{intn=25;

longfib[]=reFibonacci（n）;//求前25个数

paintArray（g,fib）;

 }

long[]reFibonacci（intm）

{longfibonacci[]=newlong[m];

 fibonacci[0]=0L;

fibonacci[1]=1L;

for（intn=2;n