ch05java高级类特性.docx
《ch05java高级类特性.docx》由会员分享，可在线阅读，更多相关《ch05java高级类特性.docx（47页珍藏版）》请在冰豆网上搜索。
ch05java高级类特性
第5章高级类特性
第一节抽象类与抽象方法
一、类的类型
类的类型：
最终类（final）、抽象类（abstract）、默认类。
抽象类（abstract）一个abstract类不能直接创建对象,必须通过其子类才能创建对象。
最终类（final）一个最终类不能再派生子类。
默认类可以有子类，也可以生成对象。
二、抽象（abstract）类
1.抽象方法
抽象方法是指只给出定义,但不包含实现语句的方法。
抽象方法它没有大括号，有大括号但大括号中没有任何内容的方法，仍不是抽象方法。
如：
publicabstractvoidlx（）;
2.抽象类的概念
用abstract修饰的类称为抽象类。
一般的抽象类都包括抽象方法.
这种类不能创建对象，因为它的完整实现还没有定义。
只能由其创建子类（抽象类是专门用来作为其它类的父类的）。
3.抽象类的定义
在类定义的class关键词前放置关键词abstract即可。
格式：
abstractclass类名
如：
publicabstractclassStudent{
Stringid;
Stringname;
Stringspeciality;
publicStudent（Stringid,
Stringname,Stringspeciality）{
this.id=id;
this.name=name;
this.speciality=speciality;
}
//publicStudent（）{
//this.id=null;
//this.name=null;
//this.speciality=null;
//
//
//
//}
publicvoidsetId（Stringid）{
this.id=id;
}
publicStringgetId（）{
returnid;
}
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicStringgetSpeciality（）{
returnspeciality;
}
publicvoidsetSpeciality（Stringspeciality）{
this.speciality=speciality;
}
publicStringgetStudentInfo（）{
return"id="+getId（）
+"name="+getName（）
+"speciality="+getSpeciality（）;
}
publicabstractintsum（）;
}
publicclassAgricultureStudentextendsStudent{
privateintbotany;
privateintgengzuo;
publicAgricultureStudent（Stringid,
Stringname,Stringspeciality,intbotany,intgengzuo）{
/*父类没定义构造方法或有无参构造方法
super（）;//super可省略
//this.id=id;
//this.name=name;
//this.speciality=speciality;
//this.botany=botany;
*/
//父类有参数时
super（id,name,speciality）;
this.botany=botany;
this.gengzuo=gengzuo;
}
publicintgetBotany（）{
returnbotany;
}
publicvoidsetBotany（intbotany）{
this.botany=botany;
}
@Override
publicStringgetStudentInfo（）{
returnsuper.getStudentInfo（）
+"score="+getBotany（）;
}
@Override
publicintsum（）{
returngengzuo+botany;
}
}
publicclassStudentTest{
publicstaticvoidmain（Stringargs[]）{
AgricultureStudentagicultureStudent=newAgricultureStudent（"123",
"li","agriculture",90,67）;
System.out.println（"id"+agicultureStudent.getId（）
+"sum="+agicultureStudent.sum（））;
}
}
/**
*没有抽象方法的抽象类
*@authortai
*/
publicabstractclassABDemo{
intage=10;
voidsetAge（inta）{
age=a;
}
publicstaticvoidmain（Stringa[]）{
ABDemoa1=newABDemo（）;//此命令会出错,抽象类不能生成对象
}
}
4、实例
publicclassPolymorphism
{
publicstaticvoidmain（Stringargs[]）
{
Trianglet=newTriangle（5.0,2.0）;
t.show_area（）;
Rectangler=newRectangle（3.0,4.0）;
r.show_area（）;
Circlec=newCircle（10.0）;
c.show_area（）;
}
}
abstractclassFigure
{
protecteddoublex=10.0,y=5.0;
abstractvoidshow_area（）;
}
classTriangleextendsFigure
{
Triangle（doublea,doubleb）
{
x=a;
y=b;
}
voidshow_area（）
{
System.out.println（"triangle:
"+（0.5*x*y））;
}
}
classRectangleextendsFigure
{
Rectangle（doublea,doubleb）
{
x=a;
y=b;
}
voidshow_area（）
{
System.out.println（"rectangle:
"+（x*y））;
}
}
classCircleextendsFigure
{
Circle（doublea）{x=a;}
finaldoublepi=3.1416;
voidshow_area（）
{
System.out.println（"circle:
"+（pi*x*x））;
}
}
实例二、
publicabstractclassMath{
intanswer;
voidshow（）{
System.out.print（"answer"+answer）;
}
abstractvoidadd（inta,intb）;//计算a+b
abstractvoidsub（inta,intb）;//计算a-b
abstractvoidmul（inta,intb）;//计算a+b
abstractvoiddiv（inta,intb）;//a/b
}
classComputeextendsMath{
//在此类里继承了show
voidadd（inta,intb）{
answer=a+b;
}
voidsub（inta,intb）{
answer=a-b;
}
voidmul（inta,intb）{
answer=a*b;
}
voiddiv（inta,intb）{
answer=a/b;
}
}
publicclassApp{
publicstaticvoidmain（Stringargs[]）{
Computecmp=newCompute（）;
cmp.add（3,5）;
cmp.show（）;
}
}
强调：
抽象类的子类必须在类中实现抽象类中的抽象方法，即给出抽象方法的定义,它才不是抽象类。
5、强调
将类Triangle方法中的show_area（）去掉，前必须加abstract关键字，为什么?
因为类Triangle没有对show_area（）进行重写，而是直接继承了抽象方法
publicclassPolymorphism
{
publicstaticvoidmain（Stringargs[]）
{
Trianglet=newTriangle（5.0,2.0）;
t.show_area（）;
Rectangler=newRectangle（3.0,4.0）;
r.show_area（）;
Circlec=newCircle（10.0）;
c.show_area（）;
}
}
abstractclassFigure
{
protecteddoublex=10.0,y=5.0;
abstractvoidshow_area（）;
}
abstractclassTriangleextendsFigure
{
Triangle（doublea,doubleb）
{
x=a;
y=b;
}
}
classRectangleextendsFigure
{
Rectangle（doublea,doubleb）
{
x=a;
y=b;
}
voidshow_area（）
{
System.out.println（"rectangle:
"+（x*y））;
}
}
classCircleextendsFigure
{
Circle（doublea）{x=a;}
finaldoublepi=3.1416;
voidshow_area（）
{
System.out.println（"circle:
"+（pi*x*x））;
}
}
强调：
不使用抽象类，如果子类没有覆盖超类中的非抽象方法，也不会出错，但没有意义
抽象类可否有自己的构造方法?
答案是:
抽象类中允许有自己的构造方法,但是该构造方法并不能直接实例化自己的对象.如果在抽象类中存在有参构造方法,则必须在子类中明确的使用super（[参数列表]）指明要调用父类中的哪个构造方法.
四、为什么要使用抽象类
1、抽象类是规范
为了使抽象类的子类在完成相同或相似的功能时，具有相同的方法名。
（
在规化类库时，在抽象类中定义出抽象方法，使实现它的子类的程序员去实现。
2、代码重用
可以继承.
3、多态
为了实现多态。
第二节抽象类与多态
一、实例一
abstractclassFigure
{
protecteddoublex=10.0,y=5.0;
abstractvoidshow_area（）;
}
classTriangleextendsFigure
{
Triangle（doublea,doubleb）
{
x=a;
y=b;
}
voidshow_area（）
{
System.out.println（"triangle:
"+（0.5*x*y））;
}
}
classRectangleextendsFigure
{
Rectangle（doublea,doubleb）
{
x=a;
y=b;
}
voidshow_area（）
{
System.out.println（"rectangle:
"+（x*y））;
}
}
classCircleextendsFigure
{
Circle（doublea）{x=a;}
finaldoublePI=3.1416;
voidshow_area（）
{
System.out.println（"circle:
"+（PI*x*x））;
}
}
测试一：
publicclassTest1
{
publicstaticvoidmain（Stringargs[]）
{
//Figuref=newTriangle（5.0,2.0）;
//f.show_area（）;
//f=newRectangle（3.0,4.0）;
//f.show_area（）;
//f=newCircle（10.0）;
//f.show_area（）;
}
}
测试二：
publicclassTest2
{
publicstaticvoidmain（Stringargs[]）
{
Figuref[]=newFigure[3];//为什么
f[0]=newTriangle（5.0,2.0）;
f[1]=newRectangle（6.0,87.0）;
f[2]=newCircle（100.0）;
for（Figuref1:
f）
f1.show_area（）;
}
}
测试三：
publicclassTest3{
publicstaticvoidshow（Figuref）{
f.show_area（）;
}
publicstaticvoidmain（Stringargs[]）{
Triangletriangle=newTriangle（5.0,2.0）;
Rectanglerectangle=newRectangle（3.0,4.0）;
Circlecircle=newCircle（10.0）;
show（triangle）;
show（circle）;
show（rectangle）;
}
}
测试四：
publicclassTest4{
publicstaticvoidshow（Rectanglerec[]）{
for（Rectanglerectangle:
rec）{
rectangle.show_area（）;
}
}
publicstaticvoidmain（Stringargs[]）{
Rectanglerectangle[]=newRectangle[2];
rectangle[0]=newRectangle（3.0,4.0）;
rectangle[1]=newRectangle（5.0,4.0）;
show（rectangle）;
}
}
二、实例二
abstractclassFigure
{
protecteddoublex=10.0,y=5.0;
abstractdoublearea（）;
}
classRectangleextendsFigure
{
Rectangle（doublea,doubleb）
{
x=a;
y=b;
}
doublearea（）
{
return（x*y）;
}
}
classTriangleextendsFigure
{
doublez;
Triangle（doublea,doubleb,doublec）
{
x=a;
y=b;
z=c;
}
doublearea（）
{
doublep=（x+y+z）/2;
returnMath.sqrt（p*（p-x）*（p-y）*（p-z））;
}
classCircleextendsFigure
{
Circle（doublea）{x=a;}
doublearea（）
{
returnMath.PI*x*x;
}
}
测试一：
publicclassTest4{
publicstaticdoubletotalArea1（Figuref[]）{
doubletotalArea=0;
for（Figuref1:
f）{
totalArea+=f1.area（）;
}
returntotalArea;
}
publicstaticvoidmain（Stringargs[]）{
Figuref[]=newFigure[3];//为什么
f[0]=newTriangle（5.0,6.0,7.0）;
f[1]=newRectangle（6.0,87.0）;
f[2]=newCircle（100.0）;
doubletotalArea=0;
for（Figuref1:
f）{
totalArea+=f1.area（）;
}
System.out.println（"totalarea="+totalArea）;
System.out.println（"totalarea1="+totalArea1（f））;
}
}
测试二：
importjavax.swing.JOptionPane;
/**
*
*@authortai
*/
publicclassTest5{
publicstaticdoubletotalArea1（Figuref[]）{
doubletotalArea=0;
for（Figuref1:
f）{
totalArea+=f1.area（）;
}
returntotalArea;
}
publicstaticvoidmain（Stringargs[]）{
Figuref[]=newFigure[3];//为什么
f[0]=newTriangle（5.0,6.0,7.0）;
f[1]=newRectangle（6.0,87.0）;
Stringinput=JOptionPane.showInputDialog（"输入圆的半径"）;
doubler=Double.parseDouble（input）;
f[2]=newCircle（r）;
doubletotalArea=0;
for（Figuref1:
f）{
totalArea+=f1.area（）;
}
JOptionPane.showMessageDialog（null,"totalarea="+totalArea）;
JOptionPane.showMessageDialog（null,"totalarea1="+totalArea1（f））;
}
}
测试三：
importjavax.swing.JOptionPane;
/**
*
*@authortai
*/
publicclassTest6{
publicstaticdoubletotalArea1（Figuref[]）{
doubletotalArea=0;
for（Figuref1:
f）{
totalArea+=f1.area（）;
}
returntotalArea;
}
publicstaticvoidmain（Stringargs[]）{
Figuref[]=newFigure[3];//为什么
f[0]=newTriangle（5.0,6.0,7.0）;
f[1]=newRectangle（6.0,87.0）;
doubler;
try{
Stringinput=JOptionPane.showInputDialog（"输入圆的半径"）;
r=Double.parseDouble（input）;
}catch（NumberFormatExceptione）{
r=0.0;
}
f[2]=newCircle（r）;
doubletotalArea=0;
for（Figuref1:
f）{
totalArea+=f1.area（）;
}
JOptionPane.showMessageDialog（null,"totalarea="+totalArea）;
JOptionPane.showMessageDialog（null,"totalarea1="+totalArea1（f））;
}
}
作业：
第三节接口（interface）
一、接口的概念
接口是和类一种相似又有区别的一种结构，接口的设计和调用也是Java程序设计的重要技术。
接口是一种特殊的抽象类
接口是一种完全没有实现的类。
接口用关键字interface来定义，而不是class；
接口中定义的变量都是公用的最终的静态变量（即常量用publicstaticfinal修饰）；
接口中没有构造方法，而且定义的方法全是抽象方法（即在方法中只提供方法的定义，而没有提供方法的实现语句），接口中的方法是用publicabstract修饰的。
接口采用多重继承机制，而不是采用类的单一继承机制。
二、接口的声明
接口的格式如下：
interface接口名
{
常量的定义
方法的说明
}
三、接口的使用---类对接口的继承（实现）
class类名implements接口名
实例一、
publicclassInterfaceDemo
{
publicstaticvoidmain（Stringargs[]）
{
//Aa=newA（）;//接口不能生成对象
Bb=newB（）;
b.show（）;
}
}
publicinterfaceA{
doubleg=9.8;
voidshow（）;
}
publ
升级会员 