Java语言程序设计讲义第六章.docx
- 文档编号:18105631
- 上传时间:2023-08-13
- 格式:DOCX
- 页数:30
- 大小:26.23KB
Java语言程序设计讲义第六章.docx
《Java语言程序设计讲义第六章.docx》由会员分享,可在线阅读,更多相关《Java语言程序设计讲义第六章.docx(30页珍藏版)》请在冰点文库上搜索。
Java语言程序设计讲义第六章
第六章面向对象程序设计
主要内容:
面向对象程序设计的基本概念、Java语言中的类、对象、包、接口和修饰符。
6.1面向对象程序设计的发展
●Simula67
●并发Pascal、Ada和Modula-2
●Smalltalk-72、Smalltalk80
●C++、ObjectPasal、Delphi、Java
●它与传统的、结构化的程序设计的主要区别:
它将数据和对数据的操作放到了一个数据结构中。
后者则将数据和对数据的操作分开,需要向过程和函数传递数据结构以便操作它们。
●它是按照现实世界的特点来管理复杂的事物,把它们抽象为对象,具有自己的状态和行为,通过对消息的反应来完成一定的任务。
6.2面向对象方法的主要概念
1.对象
●对象是对现实世界中事物的一个抽象表示。
●一个对象就是变量和相关方法的集合,其中变量表明对象的状态,方法表明对象所具有的行为。
●具有静态特征和动态特征。
即:
属性(成员变量):
描述对象静态特征的一个数据项。
方法(服务、成员函数):
描述对象动态特征(行为)的一个操作序列。
●对象的属性域可以是简单类型数据,也可以是另一个对象。
●所有对象属性可以是简单类型的数据,也可以是对象引用。
2.类
●类是抽象思想的运用。
●其内部包括属性和方法两个主要部分。
●类的作用是定义对象,类称为对象的模板(template)。
●一个对象又称作类的一个实例(instance)。
●类与对象的关系,类似于非面向对象语言中类型(type)和变量(varible)。
类型用于定义数据,类用于定义对象。
类是一个类型定义,对象是一个变量声明。
一旦建立了类,就可以基于类创建对象。
●实例化对象/创建类实例(由类创建对象)。
●通过类的定义可以实现代码的复用。
3封装
●封装是指把对象的属性和方法结合成一个独立的系统单位,尽可能隐蔽对象的内部细节,只保留有限的对外接口使之与外部发生联系。
●其思想是将对象内部的信息屏蔽,人们只能通过对象界面上的允许操作对对象进行动作,改变对象的属性及状态。
●通过对对象的封装,实现了模块化和信息隐藏,有利于程序的可移植性和安全性,同时也利于对复杂对象的管理。
4继承
●继承本身就是软件复用。
也是可复用性、可扩充性的体现。
●特殊类的对象拥有其一般类的全部属性与方法,这称作特殊类对一般类的继承。
●通过父类和子类,实现了类的的层次,可以从最一般的类开始,逐步特殊化,定义一系列的子类。
●一个类可以是多个一般类的特殊类,它可从多个一般类中继承属性和方法,这种继承模式叫作多重继承。
●Java语言只支持单一继承,大大降低了复杂度。
●在Java语言中通过接口可以实现多重继承。
接口不仅限于继承,它可以使多个不相关的类具有相同的方法。
5.消息
●在面向对象的系统中,对象间的相互作用是通过消息传送进行。
●消息就是向对象发出的服务请求,含有下述信息:
提供服务的对象标识、服务标识、输入信息和回答信息。
●一个消息包含三个方面的内容:
(1)消息的接收者。
(2)接收对象应采用的方法。
(3)方法所需要的参数。
6.多态性
●特殊类继承一般类中定义的属性或方法后,可以具有不同的数据类型或表现出不同的行为。
即,对父类的方法重写或重新定义实现多态。
使用同名方法所在类的类名来区分。
例:
父类Bank中定义方法setRate(),
调用时使用Bank.setRate();
子类BankAccount中定义了方法setRate(),
调用时使用BankAccount.setRate();
●在同一类中定义多个同名的不同方法。
这种多态称“重载”。
例:
同一类Bank中定义了方法:
voidsetRate();和voidsetRate(floatrate);
则调用时会有两种情况:
(1)Bank.setRate();
(2)Bank.setRate(0.225);
总结:
(1)对象作为事物的抽象表示。
(2)事物的静态特征用对象的属性表示,即用一些数据来表达的特征。
动态特征用方法表示。
(3)封装性,把对象的属性和方法结合成一个独立的系统单位。
(4)分类,具有相同属性和方法的对象归为一类。
(5)抽象原则,忽略部分差异,得到类、子类,即继承。
(6)消息,对象之间通过消息进行通信。
6.3Java的类
●类是组成Java语言程序的基本要素。
它封装了一类对象的属性和方法,是这一类对象的原型。
●一个类的实现包含两部分的内容:
类的说明{
类体
}
1.类声明
(1)一个最简单的类声明如下:
classclassName{
……
}
(2)类声明的格式:
[modifiers]classClassName[extendsSuperClassName][implementsInterfaceList]
其中:
●modifiers指类的特性。
public\private\abstract\final
●extends指明此类的父类,SuperClassName是父类名。
●implements指出本类调用的接口,InterfaceList是一个由逗号隔开的接口名字的表。
(3)类体
●类体是类的主体内容。
定义了该类所有的变量和该类所支持的方法。
●类体包括两部分内容:
变量说明和方法。
●类的成员变量须在类体中定义,但不能包含在某个方法中。
●通常变量在方法前定义,Java中没有独立的函数和过程,所有的子程序都是作为类方法定义的。
如下所示:
classclassName{
memberVariableDeclarations
methodDeclarations
}
例6.1.定义了一个Point类,且声明了它的两个变量x、y同时实现init()方法对x、y赋初值。
classPonit{
intx,y;
voidinit(intix,intiy){
x=ix;
y=iy;
}
}
●类中所定义的变量和方法都是类的成员。
对类的成员能以一定访问权限,来限定其它对象对它的访问。
访问权限有以下几种:
private,protected,public,friendly。
同时,对类的成员来说,又可以分为实例成员和类成员两种。
(4)成员变量
●成员变量的格式:
[variableModifier]typevariableName;
例:
finaldoublePI=3.1415927;
staticStringBufferrecentName;//静态的成员变量
Stringn-name;//非静态的成员变量
●成员变量的类型可以是Java语言中的任意数据类型,包括简单类型、数组、类和接口。
●在一个类中,成员变量应该是唯一的,但是成员变量的名字可以和类中某个方法的名字相同。
●类的成员变量和在方法中所声明的局部变量是不同的,成员变量的作用域是整个类,而局部变量的作用域只是方法内部。
●对一个成员变量,可以限定它的访问权限(见6.8节);可以用static限定它为类变量(见6.5节);可以用修饰符来限定。
例如修饰符final。
Java的类、变量和方法均可带有final修饰符。
(2)方法
●方法的结构
[modifiers]typemethodName(para1,para2,…)
{
methodBody
}
其中,
1modifiers表示访问权限。
Public,private,protected,privateprotected。
2若方法是默认型方法,则它可以被同一包中的类访问。
3type是返回参数类型。
若无返回参数,则写成void。
4入口参数的个数和类型在圆括号中表示出来。
●方法的调用
调用格式:
Object.methodName(para1,para2,…);
●有关方法的几点说明:
1调用方法的入口参数的个数和类型必须与方法中定义的参数的个数和类型相同。
2在一个类中,允许几个方法用同一个名字。
但要求:
这些方法的返回值必须是相同的数据类型,且它们的参数必须不同。
●this和super在方法中的作用
1两者用在方法体中作为特殊的变量前缀和方法前缀。
2this用来指明当前对象的成员变量或方法,以区别同名的局部变量和其他同名的方法。
3super用于指出父类的变量和方法。
在子类中,当需要调用父类的同名方法或使用父类的同名变量时,可用关键字super作前缀指明父类的成员变量和方法。
例1:
classThreeColor{
inth,s,b;
ThreeColor(inth,ints,intb){
this.h=h;
this.s=h;
this.b=b;
}
}
例2:
classSuperCa{
intx;
SuperCa(){
X=5;
System.out.println(“SuperCax=”+x);
}
voiddoCa(){
System.out.println(“SuperCa.doCa()”);
}
}
classSubCaextendsSuperCa{
intx;
SubCa(){
Super();//调用父类的构造方法
X=8;
System.out.println(“SubCax=”+x);
}
voiddoCa(){
super.doCa();//调用父类的方法
System.out.println(“inSubCa.doCa()”);
System.out.println(“super.x=”+super.x);
}
}
(3)多态
●Java语言通过方法重写和方法重载来实现多态。
●方法重载,在Java类中可创建名字相同,但参数和返回值不同的几个方法。
Java系统通过参数和返回值来分辨具体是哪一个方法。
●方法重写,子类可以重新实现父类的某些方法,使其具有自己的特征。
(4)构造方法
●每个类都包括一个特殊用途的方法,即构造方法(constructor)。
它和类名永远相同,且无返回值。
●用new建立对象就是在调用构造函数。
建完之后,类的成员变量和方法就可以用“.”来访问。
●Java中的每个类都有构造方法,用来初始化该类的一个新的对象。
即,为对象分配资源,并返回对象的一个实例。
●在构造方法的实现中,可进行方法重写。
●Java语言支持方法重载,所以类可有多个共享同一个名字的构造方法,可以通过参数的类型和数目区分。
●构造方法使用它的参数初始化新对象的状态,当创建对象时,应该选择其参数最能反映所初始化的新对象的构造方法。
例6.4
classpoint{
intx,y;
point(){
x=0;
y=0;
}
point(intx,inty){
this.x=x;
this.y=y;
}
}
●用构造方法进行初始化,可避免在生成对象后,每次都要调用对象的初始化方法。
●若无实现类的构造方法,Java运行时系统会自动提供缺省的构造方法,它没有任何参数。
例在构造方法中用this和super调用其他构造方法
(1)classBeeextendsQueen{
inta;
Bee(inta){
this.a=a
}
Bee(){
this(25);
}
}
(2)classBeeextendsQueen{
intb;
Bee(intb){
super(16);
this.b=b;
}
●调用构造方法遵循的规则:
1从一个类创建对象,可以调用此类的父类的构造方法.
2一个构造方法用this语句调用本类的另一个构造方法时,若被调用的构造方法又是调用父类的构造方法而没用super语句,则编译器自动认为它含有super()语句.
3若某个类的构造方法第一个语句是:
用this来调用本类的另一个构造方法,则Java系统,就不再默认该构造方法调用的是父类的构造方法。
4若某个类的构造方法第一个语句没有用super,来调用其父类的构造方法,则编译器也默认为在构造方法中,用super()语句调用父类的不带参数的构造方法。
例:
publicclassFirst{
inta;
publicFirst(){
a=12;
}
}
publicclassSecondextendsFirst{
intx,y;
publicSecond(intx,inty){
this.x=x;
this.y=y;
}
publicSecond(){
this(2,6);
……
}
……
}
(5)方法finalize()
●用来释放构造函数分配的资源。
有时在类不再有用之后,有些无用单元收集机制不能处理的资源需要特殊清理。
●方法finalize()在类java.lang.Object中实现。
不能将时间相关的代码加入finalize。
(6)方法main()
●Java的每个应用程序一定包含main()。
●Java解释器运行字节码文件时,首先寻找main(),以此作为程序的入口开始运行。
●当main()结束时(语句块的结束或用System.exit语句),程序也运行结束。
●main()没有返回参数,其入口参数就是应用程序运行时命令行给出的参数。
6.4继承
●预先定义一个包含公用变量和公用方法的类作为父类,在此基础上创建具有专用变量和专用方法的子类。
●子类将自动继承父类的所有特性(成员变量)和行为(方法)。
此外,子类可以增加父类中没有的变量和方法,也可以再定义父类中已有的变量和方法。
●父类中除专用型变量/方法不能被子类调用外,其他均可由子类调用。
●继承只能是增加行为和属性,子类不可能比父类具有更少的行为和属性。
●变量隐藏。
子类继承父类中,若子类的成员变量与父类的同名,称子类隐藏了父类的成员变量。
此时,子类使用的是它自己的变量。
若要调用父类的变量,必须用关键字super。
●方法置换
●Java的继承机制
(1)使用extends
(2)使用this和super(super()、this()、)
例:
MammalClass具有DogClass和ManClass的共同特性。
packageOOP1;
publicclassMammalClass{
Stringname,eyeColor;
intage;
publicMammalClass(){
name="TheName";
eyeColor="Black";
age=0;
}
}
例:
重写DogClass和ManClass,来说明利用继承的好处:
packageOOP1;
publicclassDogClassextendsMammalClass{
booleanhasTail;
publicDogClass(){
name="Chase";
eyeColor="Black";
age=2;
hasTail=true;
}
packageOOP1;
publicclassManClassextendsMamalClass{
booleanisMarried;
publicManClass(){
Name="Casey";
eyeColor="Blue";
age=1;
isMarried=true;
}
}
例:
publicclassA{
intx;
voidboy(){
System.out.printin(“100”);
}
}
publicclassBextendsA{
intx;
voidboy(){
super.boy();
System.out.printin(“200”);
}
voidtype(){
x=super.x–2;
//也可写成this.x=super.x–2;
System.out.printin(“inClassA,x=”+super.x);
System.out.printin(“inClassB,x=”+this.x);
}
}
6.5Java的对象
1.对象的生成(创建)
包括声明、建立和初始化三方面的内容。
(1)对象的声明(定义)
格式:
typeobjectName,
说明:
type为类名,指出对象所属的类
例如:
PointmyObject;
(2)对象的建立(将类进行实例化)
通过new调用对应类的构造方法,来完成内存分配,返回对该对象的一个引用(即该对象所在的内存地址)。
myObject=newPoint(6,2)
myObject=newPoint();
(3)对象的初始化
执行构造方法,进行初始化。
由于构造方法可重写,所以通过给出不同个数或类型的参数会分别调用不同的构造方法。
上述三步也可用一步完成:
PointmyObject=newPoint();
PointmyObject=newPoint(6,2);
PointmyObject=newPoint(4,8,5);
PointmyObject=newPoint(2.5,3.5,7.5,8.5);
例
classPoint{
intx,y;
Stringname="apoint";
Point(){
x=0;
y=0;
}
Point(intx,inty,Stringname){
this.x=x;
this.y=y;
this.name=name;
}
intgetX(){
returnx;
}
intgetY(){
returny;
}
voidmove(intnewX,intnewY){
x=newX;
y=newY;
}
PointnewPoint(Stringname){
PointnewP=newPoint(-x,-y,name);
ReturnnewP;
}
booleanequal(intx,inty){
if(this.x==x&&this.y==y)
returntrue;
else
returnfalse;
}
voidprint(){
System.out.println(name+":
x="+x+"y="+y);
}
}
publicclassUsingObject{
publicstaticvoidmain(Stringargs[]){
Pointp=newPoint();
p.print();//callmethodofanobject
p.move(50,50);
System.out.println("**aftermoving**");
System.out.println("Getxandydirectly");
//accessvariablesofanobject
System.out.println("x="+p.x+"y="+p.y);
System.out.println("orGetxandybycallingmethod");
System.out.println("x="+p.getX()+"y="+p.getY());
if(p.equal(50,50))
System.out.println("Ilikethispoint!
!
!
!
");
else
System.out.println("Ihateit!
!
!
!
!
");
p.newPoint("anewpoint").print();
newPoint(10,15,"anothernewpoint").print();
}
}
通过运算符“·”可以实现对对象的引用(对变量的访问和方法的调用),变量和方法还可以设定一定的访问权限。
2.引用对象的变量
(1)实例变量
格式为:
objectReference.variable
例如:
Pointp=newPoint();
p.x;p.y;p.x=10;p.y=20;tx=newpoint().x;
(2)类变量:
3.调用对象的方法
(1)实例方法:
调用对象的某个实例方法,其格式为:
objectReference.method()
例:
if(p.equal(20,30)){……}
例:
px=p.newPoint().x或px=p.newPoint().getX();
(2)类方法:
即static方法
类方法不能被重设;类方法只能使用类变量和类方法。
类方法调用时,用类名调用。
类和对象的小结:
Java中,类的主要作用是创建对象和允许继承。
类可以:
创建对象;被子类继承,类可以从已存在的类中继承;实现接口;存在类方法、类变量;定义实例方法、变量;发消息。
对象可以:
从一个类创建;存在实例变量;发消息;执行实例方法;存在许多拷贝,从相同的类产生的对象。
6.6接口
●Java语言中的接口机制是为了取代多重继承机制。
●接口的功能与抽象类相似,但一个重要的区别:
接口不能包含代码和成员变量(可以包含常量)。
允许声明常量和声明方法,但是不能实现方法,接口中不允许写代码。
●创建接口与创建类一样。
接口的格式为:
接口说明{
接口体
}
(1)接口说明
[public]interfaceinterfaceName[extendsSuperInterfaceList]{…..}
(2)接口体(包括常量定义和方法定义)
●接口中的常量都默认为是final和static属性。
●接口中的方法没有方法体。
●接口中所有的方法都默认为是abstract属性。
例:
publicinterfaceStack{
publicfinalstaticdoublePI=3.14159;
publicabstractvoidpush(intx);
publicvoidpop();
}
classAimplementsStack{
……
publicabstractvoidpush(intx){
……
}
publicvoidpop(){
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- Java 语言程序设计 讲义 第六
![提示](https://static.bingdoc.com/images/bang_tan.gif)