《子类与继承》ppt课件

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 extends People public class Student extends People int number; int number; void tellNumber( ) void tellNumber( ) System.out.println( System.out.println(我的学号是我的学号是:+number); :+number); int add(int x,int y) i

7、nt 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 extends Student public class UniverStudent extends 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) do

8、uble 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

9、.8; 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

10、.out.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=

11、6609; 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,res

12、ult); 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

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

14、otectedprotected和和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 extends Universitypublic class ImportantUniversity extends 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+ch

16、inese; 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) pu

17、blic 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,c

18、hinese); /调用重写的方调用重写的方法法 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,

19、float 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 cla

20、ss Example5_5 public static void main(String args) public static void main(String args) B b=new B(); B b=new B(); double result=bputer(8,9); /b double result=bputer(8,9); /b调用重写的方法调用重写的方法 System.out.println( System.out.println(调用重写方法得到的结果调用重写方法得到的结果:+result); :+result); int m=b.g(12,8); /b int m=b.g

21、(12,8); /b调用承继的方法调用承继的方法 System.out.println( System.out.println(调用承继方法得到的结果调用承继方法得到的结果:+m); :+m); 例例5-5在在JDK 1.5JDK 1.5版本之后，允许重写方法的类型版本之后，允许重写方法的类型可以是父类方法的类型的子类型，即不用可以是父类方法的类型的子类型，即不用完全一致完全一致JDK 1.5JDK 1.5版本之前要求必需一版本之前要求必需一致，也就是说，假设父类的方法的类型致，也就是说，假设父类的方法的类型是是“类类 ，重写方法的类型可以是，重写方法的类型可以是“子类子类。3 3JDK 1.

22、5JDK 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

23、 Television 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() /重写方法的类型是重写方法的类型是HomeElet

25、ricityHomeEletricity类的子类类的子类: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(Stri

27、ng 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(); Icebo

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

29、ed4重写的本卷须知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

31、Bank 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, s

32、avedMoney,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=(i

33、nt)year; double remainNumber=year-(int)year; double remainNumber=year-(int)year; int day=(int)(remainNumber int day=(int)(remainNumber* *1000);1000); interest=superputerInterest()+dayinterest=superputerInterest()+day* *0.00010.0001* *savedMsavedMoney;oney; 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 d

35、ay=(int)(remainNumber*1000); interest=superputerInterest()+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 ConstructionBa

36、nk(); bank1.savedMoney=amount; bank1.year=5.216; double interest1=bank1puterInterest(); BankOfDalian bank2=new BankOfDalian(); bank2.savedMoney=amount; bank2.year=5.216; double interest2=bank2puterInterest(); System.out.printf(两个银行利息相差%f元n,interest2-interest1); 当用子类的构造方法创建一个子类的对象时，子当用子类的构造方法创建一个子类的对

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

38、类在其构造方法中需运用造方法中需运用supersuper来调用父类的构造方法，而来调用父类的构造方法，而且且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

39、String getTitle() public String getTitle() return title; return title; public class ChristmasCard extends Card String content; /子类新增的content 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(

44、 System.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);

45、 a.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; void showBodyMess() void

48、 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:+height+cm+ bodyWeight:+we

49、ight+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 args) People people=nu

50、ll; 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.mustDoingThing(); Chinese zhang = n

51、ew 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; zhang.speakChinese(); 当

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

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.out.println(zhua.zhua

54、.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 cautionSound() void cautionSound

55、() 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是警车的上转型对象是警车的上转型对象 car.caution

56、Sound(); 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(); 用关键字用关键字abstractabstract修饰的类称为修饰的类称为abstracta

57、bstract类笼统类。类笼统类。如：如： abstract class A abstract class A 用关键字用关键字abstractabstract修饰的方法称为修饰的方法称为abstractabstract方法笼统方法笼统方法，对于方法，对于abstractabstract方法，只允许声明，不允许实方法，只允许声明，不允许实现，而且不允许运用现，而且不允许运用finalfinal和和abstractabstract同时修饰一个方同时修饰一个方法法和普通的类相比，和普通的类相比，abstractabstract类可以有类可以有abstractabstract方法笼方法笼统方法也可以

58、有非统方法也可以有非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运算符创建该类的对象。假设一个非笼统类是某个笼统类的子类，那么它必需重写父类的笼统方法，给出方法体，这就是为什么不允许运用final和abstract同时修饰一个方法的缘由。注：abstract类也可以没有abstract方法。注：假设

59、一个abstract类是abstract类的子类，它可以重写父类的abstract方法，也可以承继这个abstract方法。2 2abstractabstract类不能用类不能用newnew运算创建对象运算创建对象abstract class A abstract class 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 exten

60、ds 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 class Example5_12 public static void main(String args) public static void main(String args) B b=new B(); B b=new B(); int sum=b.sum(30,20); / int sum=b.sum(30,20); /