第5子类与继承

1、主要内容 子类与父类 子类的继承性 子类对象的特点 成员变量的隐藏和方法重写 super关键字 final关键字 对象的上转型对象 继承与多态 abstract类与abstract方法 面向抽象编程 开-闭原则难点 成员变量的隐藏和方法重写 开-闭原则当我们准备编写一个类的时候，发现某个类已经有当我们准备编写一个类的时候，发现某个类已经有了我们所需要的成员变量和方法，假如我们想复用了我们所需要的成员变量和方法，假如我们想复用这个类中的成员变量和方法，即在所编写的类中不这个类中的成员变量和方法，即在所编写的类中不用声明成员变量就相当于有了这个成员变量，不用用声明成员变量就相当于有了这个成员变量，

2、不用定义方法就相当于有了这个方法，那么我们可以将定义方法就相当于有了这个方法，那么我们可以将编写的类声明为这个类的子类。编写的类声明为这个类的子类。在类的声明中，通过使用关键字在类的声明中，通过使用关键字extendsextends来声明一个来声明一个类的子类，格式如下：类的子类，格式如下： class class 子类名子类名 extends extends 父类名父类名 什么叫继承呢？所谓子类继承父类的成员变量作什么叫继承呢？所谓子类继承父类的成员变量作为自己的一个成员变量，就好像它们是在子类中为自己的一个成员变量，就好像它们是在子类中直接声明一样，可以被子类中自己定义的任何实直接声明一样

3、，可以被子类中自己定义的任何实例方法操作例方法操作所谓子类继承父类的方法作为子类中的一个方法，所谓子类继承父类的方法作为子类中的一个方法，就像它们是在子类中直接定义了一样，可以被子就像它们是在子类中直接定义了一样，可以被子类中自己定义的任何实例方法调用。也就是说，类中自己定义的任何实例方法调用。也就是说，如果子类中定义的实例方法不能操作父类的某个如果子类中定义的实例方法不能操作父类的某个成员变量或方法，那么该成员变量或方法就没有成员变量或方法，那么该成员变量或方法就没有被子类继承。被子类继承。子类不仅可以从父类继承成员变量和方法，而且子类不仅可以从父类继承成员变量和方法，而且根据需要还可以声明

4、它自己的新成员变量、定义根据需要还可以声明它自己的新成员变量、定义新的方法。新的方法。访问限制修饰符不仅限制了对象对自己成员变量的访问限制修饰符不仅限制了对象对自己成员变量的操作和方法的调用，也限制了继承性。操作和方法的调用，也限制了继承性。当子类和父当子类和父类在同一个包中时，父类中的类在同一个包中时，父类中的privateprivate访问权限的成访问权限的成员变量不会被子类继承员变量不会被子类继承，也就是说，子类继承父类，也就是说，子类继承父类中的除中的除privateprivate访问权限以外的其他成员变量作为子访问权限以外的其他成员变量作为子类的成员变量；同样，子类继承父类中的除类的

5、成员变量；同样，子类继承父类中的除privateprivate访问权限以外的其他方法作为子类的方法。访问权限以外的其他方法作为子类的方法。例例5-15-1public class people public class people double height=170,weight=67.9; double height=170,weight=67.9; protected void tellheightandweight() protected void tellheightandweight() system.out.printf( system.out.printf(我的体重和身我的体重

6、和身高高:%2.2fkg,%2.2fcmn,weight,height);:%2.2fkg,%2.2fcmn,weight,height); public class student public class student extendsextends people people int number; int number; void tellnumber( ) void tellnumber( ) system.out.println( system.out.println(我的学号是我的学号是:+number); :+number); int add(int x,int y) int

7、add(int x,int y) return x+y; return x+y; int sub(int x,int y) int sub(int x,int y) return x-y; return x-y; public class universtudent public class universtudent extendsextends student student int multi(int x,int y) int multi(int x,int y) return x return x* *y; y; double div(double x,double y) double

8、 div(double x,double y) return x/y; return x/y; public class example5_1 public class example5_1 public static void main(string args) public static void main(string args) int x=12,y=18; int x=12,y=18; student zhang = new student(); student zhang = new student(); zhang.weight=73.8; zhang.weight=73.8;

9、zhang.height=177; zhang.height=177; zhang.number=100101; zhang.number=100101; zhang.tellheightandweight(); zhang.tellheightandweight(); zhang.tellnumber(); zhang.tellnumber(); system.out.print(zhang system.out.print(zhang会做加减：会做加减：);); int result=zhang.add(x,y); int result=zhang.add(x,y); system.out

10、.printf(%d+%d=%dt,x,y,result); system.out.printf(%d+%d=%dt,x,y,result); result=zhang.sub(x,y); result=zhang.sub(x,y); system.out.printf(%d-%d=%dn,x,y,result); system.out.printf(%d-%d=%dn,x,y,result); universtudent geng = new universtudent(); universtudent geng = new universtudent(); geng.number=6609

11、; geng.number=6609; geng.tellheightandweight(); geng.tellheightandweight(); geng.tellnumber(); geng.tellnumber(); system.out.print(geng system.out.print(geng会做加减乘除：会做加减乘除：);); result=geng.add(x,y); result=geng.add(x,y); system.out.printf(%d+%d=%dt,x,y,result); system.out.printf(%d+%d=%dt,x,y,result)

12、; result=geng.sub(x,y); result=geng.sub(x,y); system.out.printf(%d-%d=%dt,x,y,result); system.out.printf(%d-%d=%dt,x,y,result); result=geng.multi(x,y); result=geng.multi(x,y); system.out.printf(%d system.out.printf(%d%d=%dt,x,y,result); %d=%dt,x,y,result); double re=geng.div(x,y); double re=geng.div

13、(x,y); system.out.printf(%d system.out.printf(%d%d=%fn,x,y,re); %d=%fn,x,y,re); 当子类和父类不在同一个包中时，父类中的当子类和父类不在同一个包中时，父类中的privateprivate和友好访问权限的成员变量不会被子类继承，和友好访问权限的成员变量不会被子类继承，也就也就是说，子类只继承父类中的是说，子类只继承父类中的protectedprotected和和publicpublic访问权访问权限的成员变量作为子类的成员变量限的成员变量作为子类的成员变量；同样，子类只；同样，子类只继承父类中的继承父类中的protec

14、tedprotected和和publicpublic访问权限的方法作为访问权限的方法作为子类的方法。子类的方法。现在需要对现在需要对protectedprotected总结得更全面些：总结得更全面些：a-b, b-c, c-da-b, b-c, c=200) if(total=200) system.out.println( system.out.println(考分考分+total+total+达到大学最低录取达到大学最低录取线线);); else else system.out.println( system.out.println(考分考分+total+total+未达到大学最低录未达到

15、大学最低录取线取线);); public class importantuniversity public class importantuniversity extendsextends university university void enterrule(double math,double english,double chinese) void enterrule(double math,double english,double chinese) double total=math+english+chinese; double total=math+english+chines

16、e; if(total=245) if(total=245) system.out.println( system.out.println(考分考分+total+total+达到重点大学最低达到重点大学最低录取线录取线);); else else system.out.println( system.out.println(考分考分+total+total+未达到重点大学最未达到重点大学最低录取线低录取线);); public class example5_4 public class example5_4 public static void main(string args) public

17、 static void main(string args) double math=64,english=76.5,chinese=66; double math=64,english=76.5,chinese=66; importantuniversity univer = new importantuniversity(); importantuniversity univer = new importantuniversity(); univer.enterrule(math,english,chinese); / univer.enterrule(math,english,chine

18、se); /调用重写的方调用重写的方法法 math=89;math=89; english=80; english=80; chinese=86; chinese=86; univer = new importantuniversity(); univer = new importantuniversity(); univer.enterrule(math,english,chinese); / univer.enterrule(math,english,chinese); /调用重写的方调用重写的方法法 class a class a float computer(float x,float

19、 y) float computer(float x,float y) return x+y; return x+y; public int g(int x,int y) public int g(int x,int y) return x+y; return x+y; class b extends a class b extends a float computer(float x,float y) float computer(float x,float y) return x return x* *y;y; public class example5_5 public class ex

20、ample5_5 public static void main(string args) public static void main(string args) b b=new b(); b b=new b(); double result=puter(8,9); /b double result=puter(8,9); /b调用重写的方法调用重写的方法 system.out.println(system.out.println(调用重写方法得到的结果调用重写方法得到的结果:+result); :+result); int m=b.g(12,8); /b int m=b.g(12,8);

21、/b调用继承的方法调用继承的方法 system.out.println(system.out.println(调用继承方法得到的结果调用继承方法得到的结果:+m); :+m); 例例5-5在在jdk 1.5jdk 1.5版本之后，版本之后，允许重写方法的类型允许重写方法的类型可以是父类方法的类型的子类型，即不必可以是父类方法的类型的子类型，即不必完全一致完全一致（jdk 1.5jdk 1.5版本之前要求必须一版本之前要求必须一致），也就是说，如果父类的方法的类型致），也就是说，如果父类的方法的类型是是“类类” ” ，重写方法的类型可以是，重写方法的类型可以是“子子类类”。3 3jdk 1.5j

22、dk 1.5对重写的改进对重写的改进例例5-65-6public class homeeletricity public class homeeletricity int weight; int weight; public void setweight(int w) public void setweight(int w) weight=w; weight=w; public void showmess() public void showmess() system.out.println( system.out.println(我是家用电器我是家用电器);); public class t

23、elevision extends homeeletricity public void showmess() system.out.println(我是电视机,重量是+weight+kg); public class icebox extends homeeletricity public void showmess() system.out.println(我是冰箱,重量是+weight+kg); class factory class factory public homeeletricity make() / public homeeletricity make() /方法的类型是方法

24、的类型是homeeletricityhomeeletricity类类 homeeletricity machine=new homeeletricity();homeeletricity machine=new homeeletricity(); return machine; return machine; class tvfactory extends factory class tvfactory extends factory public television make() / public television make() /重写方法的类型是重写方法的类型是homeeletric

25、ityhomeeletricity类的子类类的子类:television:television television tv=new television(); television tv=new television(); tv.setweight(21); tv.setweight(21); return tv; return tv; class iceboxfactory extends factory class iceboxfactory extends factory public icebox make() / public icebox make() /重写方法的类型是重写方法的

26、类型是homeeletricityhomeeletricity类的子类类的子类:icebox:icebox icebox icebox=new icebox(); icebox icebox=new icebox(); icebox.setweight(67); icebox.setweight(67); return icebox; return icebox; public class example5_6 public class example5_6 public static void main(string args) public static void main(string

27、args) tvfactory factory1=new tvfactory(); tvfactory factory1=new tvfactory(); television tv=factory1.make(); /factory1 television tv=factory1.make(); /factory1调用重写的方法调用重写的方法 tv.showmess(); tv.showmess(); iceboxfactory factory2=new iceboxfactory(); iceboxfactory factory2=new iceboxfactory(); icebox i

28、cebox=factory2.make(); /factory2 icebox icebox=factory2.make(); /factory2调用重写的方法调用重写的方法 icebox.showmess(); icebox.showmess(); 重写父类的方法时，不可以降低方法的访重写父类的方法时，不可以降低方法的访问权限。下面的代码中问权限。下面的代码中，子类重写父类的，子类重写父类的方法方法f f，该方法在父类中的访问权限是，该方法在父类中的访问权限是protectedprotected级别，子类重写时不允许级别低于级别，子类重写时不允许级别低于protectedprotected4

29、重写的注意事项class aclass a protected float f(float x,float y)protected float f(float x,float y) return x-y; return x-y; class b extends aclass b extends a float f(float x,float y)float f(float x,float y) return x+y; return x+y; 5.5. 1 5.5. 1 用用supersuper操作被隐藏的成员变量和方法操作被隐藏的成员变量和方法子类一旦隐藏了继承的成员变量，那么子类创建的子类一

30、旦隐藏了继承的成员变量，那么子类创建的对象就不再拥有该变量，该变量将归对象就不再拥有该变量，该变量将归关键字关键字supersuper所所有有，同样子类一旦隐藏了继承的方法，那么子类创，同样子类一旦隐藏了继承的方法，那么子类创建的对象就不能调用被隐藏的方法，建的对象就不能调用被隐藏的方法，该方法的调用该方法的调用由关键字由关键字supersuper负责负责。因此，。因此，如果在子类中想使用被如果在子类中想使用被子类隐藏的成员变量或方法就需要使用关键字子类隐藏的成员变量或方法就需要使用关键字supersuper。例例5-75-7public class bank public class ban

31、k int savedmoney; int savedmoney; int year; int year; double interest; double interest; public double computerinterest() public double computerinterest() interest=year interest=year* *0.0350.035* *savedmoney;savedmoney; system.out.printf(%d system.out.printf(%d元存在银行元存在银行%d%d年的利年的利息息:%f:%f元元n,n, save

32、dmoney,year,interest); savedmoney,year,interest); return interest; return interest; public class constructionbank extends bank public class constructionbank extends bank double year; double year; public double computerinterest() public double computerinterest() super.year=(int)year; super.year=(int)

33、year; double remainnumber=year-(int)year; double remainnumber=year-(int)year; int day=(int)(remainnumber int day=(int)(remainnumber* *1000);1000); interest=puterinterest()+dayinterest=puterinterest()+day* *0.00010.0001* *sasavedmoney;vedmoney; system.out.printf(%d system.out.printf(%d元存在建设银行元存在建设银行%

34、d%d年零年零%d%d天天的利息的利息:%f:%f元元n,n, savedmoney,super.year,day,interest);savedmoney,super.year,day,interest); return interest; return interest; public class bankofdalian extends bank double year; public double computerinterest() super.year=(int)year; double remainnumber=year-(int)year; int day=(int)(rema

35、innumber*1000); interest=puterinterest()+day*0.00012*savedmoney; system.out.printf(%d元存在大连银行%d年零%d天的利息:%f元n, savedmoney,super.year,day,interest); return interest; public class example5_7 public static void main(string args) int amount=5000; constructionbank bank1=new constructionbank(); bank1.savedm

36、oney=amount; bank1.year=5.216; double interest1=puterinterest(); bankofdalian bank2=new bankofdalian(); bank2.savedmoney=amount; bank2.year=5.216; double interest2=puterinterest(); system.out.printf(两个银行利息相差%f元n,interest2-interest1); 当用子类的构造方法创建一个子类的对象时，子当用子类的构造方法创建一个子类的对象时，子类的构造方法总是先调用父类的某个构造方法，类的构

37、造方法总是先调用父类的某个构造方法，也就是说，也就是说，如果子类的构造方法没有明显地指明如果子类的构造方法没有明显地指明使用父类的哪个构造方法，子类就调用父类的不使用父类的哪个构造方法，子类就调用父类的不带参数的构造方法，即如果在子类的构造方法中，带参数的构造方法，即如果在子类的构造方法中，没有明显地写出没有明显地写出supersuper关键字来调用父类的某个构关键字来调用父类的某个构造方法，那么默认地有：造方法，那么默认地有：super( );super( );子类不继承父类的构造方法子类不继承父类的构造方法，因此，子类在其构，因此，子类在其构造方法中需使用造方法中需使用supersuper

38、来调用父类的构造方法，来调用父类的构造方法，而而且且supersuper必须是子类构造方法中的头一条语句。必须是子类构造方法中的头一条语句。例例5-85-8public class card public class card string title;string title; card( ) card( ) title = title = 新年快乐新年快乐!;!; card(string title) card(string title) this.title = title; this.title = title; public string gettitle() public stri

39、ng gettitle() return title; return title; public class christmascard extends card string content; /子类新增的子类新增的contentcontent christmascard(string title,string content) super(title); /调用父类的构造方法，即执行调用父类的构造方法，即执行card(title) this.content = content; public void showcard() system.out.println(*+gettitle()+*

40、); system.out.printf(%s,content); public class example5_8 public static void main(string args) string title = happy new year to you; string content = t牛年耕耘nt谷穗满仓nt出生牛犊nt喜迎虎年n; christmascard card=new christmascard(title,content); card.showcard(); finalfinal关键字可以关键字可以修饰类修饰类、成员变量成员变量和方法中的和方法中的局部局部变量。变量

41、。可以使用可以使用finalfinal将类声明为将类声明为finalfinal类。类。finalfinal类不能被继类不能被继承，即不能有子类承，即不能有子类。如：。如： final class a final class a a a就是一个就是一个finalfinal类，将不允许任何类声明成类，将不允许任何类声明成a a的子的子类。有时候是出于安全性的考虑，将一些类修饰类。有时候是出于安全性的考虑，将一些类修饰为为finalfinal类。例如，类。例如，javajava提供的提供的stringstring类类，它对于编，它对于编译器和解释器的正常运行有很重要的作用，对它译器和解释器的正常运行

42、有很重要的作用，对它不能轻易改变，它被修饰为不能轻易改变，它被修饰为finalfinal类。类。如果用如果用finalfinal修饰父类中的一个方法，那么修饰父类中的一个方法，那么这个方法这个方法不允许子类重写不允许子类重写，也就是说，不允许子类隐藏可以，也就是说，不允许子类隐藏可以继承的继承的finalfinal方法（方法（老老实实继承，不许做任何篡老老实实继承，不许做任何篡改改）。）。如果成员变量或局部变量被修饰为如果成员变量或局部变量被修饰为finalfinal，那么，那么它就它就是常量是常量。常量在声明时没有默认值，所以在。常量在声明时没有默认值，所以在声明常声明常量时必须指定该常量的

43、值，而且不能再发生变化量时必须指定该常量的值，而且不能再发生变化。class a class a final double pi=3.1415926;/ pi final double pi=3.1415926;/ pi是常量是常量 public double getarea(final double r) public double getarea(final double r) return pi return pi* *r r* *r; r; public final void speak() public final void speak() system.out.println( s

44、ystem.out.println(您好，您好，hows everything here ?);hows everything here ?); public class example5_9 public class example5_9 public static void main(string args) public static void main(string args) a a=new a(); a a=new a(); system.out.println( system.out.println(面积：面积：+a.getarea(100);+a.getarea(100); a

45、.speak(); a.speak(); 假设，假设，a a类是类是b b类的父类类的父类，当用子类创建一个对象，并当用子类创建一个对象，并把这个对象的引用放到父类的对象中时把这个对象的引用放到父类的对象中时，如：，如：a a;a a;a=new b();a=new b();或或 a a;a a;b b=new b();b b=new b();a=b;a=b;这时，这时，称对象称对象a a是对象是对象b b的上转型对象的上转型对象（就像说：（就像说：“美国美国人是人人是人”）。）。对象的上转型对象的实体是子类负责创建的对象的上转型对象的实体是子类负责创建的，但上转型，但上转型对象会失去原对象的

46、一些属性和功能（上转型对象相当对象会失去原对象的一些属性和功能（上转型对象相当于子类对象的一个于子类对象的一个“简化简化”对象）。对象）。（1 1）上转型对象不能操作子类新增的成员变量上转型对象不能操作子类新增的成员变量（失掉了这部分属性）；（失掉了这部分属性）；不能调用子类新增的不能调用子类新增的方法方法（失掉了一些功能）。（失掉了一些功能）。（2 2）上转型对象可以访问子类继承或隐藏的成）上转型对象可以访问子类继承或隐藏的成员变量，也可以调用子类继承的方法或子类重员变量，也可以调用子类继承的方法或子类重写的实例方法。写的实例方法。上转型对象操作子类继承的方上转型对象操作子类继承的方法或子类

47、重写的实例方法，其作用等价于子类法或子类重写的实例方法，其作用等价于子类对象去调用这些方法。对象去调用这些方法。因此，如果子类重写了因此，如果子类重写了父类的某个实例方法后，当对象的上转型对象父类的某个实例方法后，当对象的上转型对象调用这个实例方法时一定是调用这个实例方法时一定是调用了子类重写的调用了子类重写的实例方法实例方法。上转型对象具有如下特点（上转型对象具有如下特点（重要重要）例例5-105-10public class people public class people int height; int height; double weight; double weight; vo

48、id showbodymess() void showbodymess() system.out.printf( system.out.printf(* * * * * * * * * *n); n); void mustdoingthing() void mustdoingthing() system.out.println( system.out.println(吃饭、睡觉吃饭、睡觉. . .饮水饮水);); public class american extends people void showbodymess() system.out.println(bodyheight:+hei

49、ght+cm+ bodyweight:+weight+kg); void speakenglish() system.out.println(i am amerian); public class chinese extends people void showbodymess() system.out.printf(身高:%5dcmt体重:%3.2fkgn,height,weight); void speakchinese() system.out.println(我是中国人); public class example5_10 public static void main(string

50、args) people people=null; american johnson = new american(); people = johnson ; /people是johnson对象的上转型对象。 people.height = 187; /同于johnson.height=187 people.weight = 78.67; people.showbodymess(); /等同于johnson调用重写的showbodymess()方法 /people.speakenglish(); /非法,因为speakenglish()是子类新增的方法 people.mustdoingthin

51、g(); chinese zhang = new chinese(); people = zhang ; /people是zhang对象的上转型对象。 people.height = 177; /同于zhang.height=187 people.weight = 68.59; people.showbodymess(); /等同于johnson调用重写的showbodymess()方法 /people.speakchinese(); /非法,因为speakchinese()是子类新增的方法 people.mustdoingthing(); zhang = (chinese)people; z

52、hang.speakchinese(); 当一个类有很多子类时，并且这些子类都当一个类有很多子类时，并且这些子类都重写了重写了父类中的某个实例方法，那么当我父类中的某个实例方法，那么当我们把子类创建的对象的引用放到一个父类们把子类创建的对象的引用放到一个父类的对象中时，就得到了该对象的一个的对象中时，就得到了该对象的一个上转上转型对象型对象，那么这个，那么这个上转型对象在调用这个上转型对象在调用这个实例方法时就可能具有多种形态实例方法时就可能具有多种形态，因为不，因为不同的子类在重写父类的实例方法时可能产同的子类在重写父类的实例方法时可能产生不同的行为。生不同的行为。多态性就是指父类的某个多态

53、性就是指父类的某个实例方法被其子类重写时，可以各自产生实例方法被其子类重写时，可以各自产生自己的功能行为。自己的功能行为。5-115-11class especialcar class especialcar void cautionsound() void cautionsound() class policecar extends especialcar class policecar extends especialcar void cautionsound() void cautionsound() system.out.println(zhua.zhua.zhua.); system

54、.out.println(zhua.zhua.zhua.); class ambulancecar extends especialcar class ambulancecar extends especialcar void cautionsound() void cautionsound() system.out.println(jiu.jiu.jiu.); system.out.println(jiu.jiu.jiu.); class firecar extends especialcar class firecar extends especialcar void cautionsou

55、nd() void cautionsound() system.out.println(huo.huo.huo.); system.out.println(huo.huo.huo.); public class example5_11 public class example5_11 public static void main(string args) public static void main(string args) especialcar car=new policecar(); /car especialcar car=new policecar(); /car是警车的上转型对

56、象是警车的上转型对象 car.cautionsound(); car.cautionsound(); car=new ambulancecar(); /car car=new ambulancecar(); /car是救护车的上转型对象是救护车的上转型对象 car.cautionsound(); car.cautionsound(); car=new firecar(); /car car=new firecar(); /car是消防车的上转型对象是消防车的上转型对象 car.cautionsound(); car.cautionsound(); 用用关键字关键字abstractabstrac

57、t修饰的类称为修饰的类称为abstractabstract类类（抽象类）。（抽象类）。如：如： abstract class a abstract class a 用关键字用关键字abstractabstract修饰的方法称为修饰的方法称为abstractabstract方法（抽象方法（抽象方法），方法），对于对于abstractabstract方法，只允许声明，不允许实方法，只允许声明，不允许实现，而且不允许使用现，而且不允许使用finalfinal和和abstractabstract同时修饰一个方同时修饰一个方法法和普通的类相比，和普通的类相比，abstractabstract类可以有类可

58、以有abstractabstract方法（抽方法（抽象方法）也可以有非象方法）也可以有非abstractabstract方法方法。1 1abstractabstract类中可以有类中可以有abstractabstract方法方法abstract class aabstract int min(int x,int y);int max(int x,int y)return xy?x:y;对于abstract类，我们不能使用new运算符创建该类的对象。如果一个非抽象类是某个抽象类的子类，如果一个非抽象类是某个抽象类的子类，那么它必须重写父类的抽象方法，给出方法体那么它必须重写父类的抽象方法，给出方

59、法体，这就是为什么不允许使用final和abstract同时修饰一个方法的原因。注：注：abstractabstract类也可以没有类也可以没有abstractabstract方法。方法。注：如果一个注：如果一个abstractabstract类是类是abstractabstract类的子类，它类的子类，它可以重写父类的可以重写父类的abstractabstract方法，也可以继承这个方法，也可以继承这个abstractabstract方法方法。2 2abstractabstract类不能用类不能用newnew运算创建对象运算创建对象abstract class a abstract clas

60、s a abstract int sum(int x,int y); abstract int sum(int x,int y); int sub(int x,int y) int sub(int x,int y) return x-y; return x-y; class b extends a class b extends a int sum(int x,int y) / int sum(int x,int y) /子类必须重写父类的子类必须重写父类的sumsum方法方法 return x+y;return x+y; public class example5_12 public cla