《子類與繼承》PPT課件.ppt

1、第5章子類與繼承,主要內(nèi)容 子類與父類 子類的繼承性 子類對象的特點 成員變量的隱藏和方法重寫 super關(guān)鍵字 final關(guān)鍵字 對象的上轉(zhuǎn)型對象 繼承與多態(tài) abstract類與abstract方法 面向抽象編程 開-閉原則 難點 成員變量的隱藏和方法重寫 開-閉原則,導(dǎo)讀,當我們準備編寫一個類的時候，發(fā)現(xiàn)某個類已經(jīng)有了我們所需要的成員變量和方法，假如我們想復(fù)用這個類中的成員變量和方法，即在所編寫的類中不用聲明成員變量就相當于有了這個成員變量，不用定義方法就相當于有了這個方法，那么我們可以將編寫的類聲明為這個類的子類,5.1 子類與父類,在類的聲明中，通過使用關(guān)鍵字extends來聲明一個

2、類的子類，格式如下： class 子類名 extends 父類名,什么叫繼承呢？所謂子類繼承父類的成員變量作為自己的一個成員變量，就好像它們是在子類中直接聲明一樣，可以被子類中自己定義的任何實例方法操作 所謂子類繼承父類的方法作為子類中的一個方法，就像它們是在子類中直接定義了一樣，可以被子類中自己定義的任何實例方法調(diào)用。也就是說，如果子類中定義的實例方法不能操作父類的某個成員變量或方法，那么該成員變量或方法就沒有被子類繼承。 子類不僅可以從父類繼承成員變量和方法，而且根據(jù)需要還可以聲明它自己的新成員變量、定義新的方法,5.2 子類的繼承性,訪問限制修飾符不僅限制了對象對自己成員變量的操作和方法

3、的調(diào)用，也限制了繼承性。當子類和父類在同一個包中時，父類中的private訪問權(quán)限的成員變量不會被子類繼承，也就是說，子類繼承父類中的除private訪問權(quán)限以外的其他成員變量作為子類的成員變量；同樣，子類繼承父類中的除private訪問權(quán)限以外的其他方法作為子類的方法,5.2.1 子類和父類在同一包中的繼承性,例5-1,public class People double height=170,weight=67.9; protected void tellHeightAndWeight() System.out.printf(我的體重和身高:%2.2fkg,%2.2fcmn,weight,

4、height);,public class Student extends People int number; void tellNumber( ) System.out.println(我的學號是:+number); int add(int x,int y) return x+y; int sub(int x,int y) return x-y;,public class UniverStudent extends Student int multi(int x,int y) return x*y; double div(double x,double y) return x/y;,pub

5、lic class Example5_1 public static void main(String args) int x=12,y=18; Student zhang = new Student(); zhang.weight=73.8; zhang.height=177; zhang.number=100101; zhang.tellHeightAndWeight(); zhang.tellNumber(); System.out.print(zhang會做加減：); int result=zhang.add(x,y); System.out.printf(%d+%d=%dt,x,y,

6、result); result=zhang.sub(x,y); System.out.printf(%d-%d=%dn,x,y,result); UniverStudent geng = new UniverStudent(); geng.number=6609; geng.tellHeightAndWeight(); geng.tellNumber(); System.out.print(geng會做加減乘除：); result=geng.add(x,y); System.out.printf(%d+%d=%dt,x,y,result); result=geng.sub(x,y); Syst

7、em.out.printf(%d-%d=%dt,x,y,result); result=geng.multi(x,y); System.out.printf(%d%d=%dt,x,y,result); double re=geng.div(x,y); System.out.printf(%d%d=%fn,x,y,re);,當子類和父類不在同一個包中時，父類中的private和友好訪問權(quán)限的成員變量不會被子類繼承，也就是說，子類只繼承父類中的protected和public訪問權(quán)限的成員變量作為子類的成員變量；同樣，子類只繼承父類中的protected和public訪問權(quán)限的方法作為子類的方法,

8、5.2.2 子類和父類不在同一包中的繼承性,現(xiàn)在需要對protected總結(jié)得更全面些： A-B, B-C, C-D 如果用D類在D中創(chuàng)建了一個對象，那么該對象總是可以通過“.”運算符訪問繼承的或自己定義的protected變量和protected方法的，但是，如果在另外一個類中，如在Other類中用D類創(chuàng)建了一個對象object，該對象通過“.”運算符訪問protected變量和protected方法的權(quán)限如下列（1）、（2）所述,5.2.3 protected的進一步說明,1）對于子類D中聲明的protected成員變量和方法，如果object要訪問這些protected成員變量和方法，只

9、要Other類和D類在同一個包中就可以了。 （2）如果子類D的對象的protected成員變量或protected方法是從父類繼承的，那么就要一直追溯到該protected成員變量或方法的“祖先”類，即A類，如果Other類和A類在同一個包中，那么object對象能訪問繼承的protected變量和protected方法,如果一個類是另一個類的子類，那么UML通過使用一個實線連接兩個類的UML圖來表示二者之間的繼承關(guān)系，實線的起始端是子類的UML圖，終點端是父類的UML圖，但終點端使用一個空心的三角形表示實線的結(jié)束,5.2.4 繼承關(guān)系（Generalization）的UML圖,instanc

10、eof是雙目運算符，其左面的操作元是對象，右面的操作元是類，當左面的操作元是右面的類或子類所創(chuàng)建的對象時，instanceof運算的結(jié)果是true，否則是false,5.2.5 關(guān)于instanceof運算符,當用子類的構(gòu)造方法創(chuàng)建一個子類的對象時，不僅子類中聲明的成員變量被分配了內(nèi)存，而且父類的成員變量也都分配了內(nèi)存空間，但只將其中一部分（子類繼承的那部分）作為分配給子類對象的變量。也就是說，父類中的private成員變量盡管分配了內(nèi)存空間，也不作為子類對象的變量，即子類不繼承父類的私有成員變量,5.3 子類對象的特點,同樣，如果子類和父類不在同一包中，盡管父類的友好成員變量分配了內(nèi)存空間，

11、但也不作為子類的成員變量，即如果子類和父類不在同一包中，子類不繼承父類的友好成員變量,例5-2,public class A private int x; public void setX(int x) this.x=x; public int getX() return x;,public class B extends A double y=12; public void setY(int y) /this.y=y+x; 非法，子類沒有繼承x public double getY() return y;,public class Example5_2 public static void

12、main(String args) B b=new B(); b.setX(888); System.out.println(子類對象未繼承的x的值是:+b.getX(); b.y=12.678; System.out.println(子類對象的實例變量y的值是:+b.getY();,5.4.1 成員變量的隱藏 子類對象以及子類自己聲明定義的方法操作與父類同名的成員變量是指子類重新聲明定義的這個成員變量。 需要注意的是，子類對象仍然可以調(diào)用從父類繼承的方法操作隱藏的成員變量,5.4 成員變量的隱藏和方法重寫,例5-3,public class Goods public double weigh

13、t; public void oldSetWeight(double w) weight=w; System.out.println(double型的weight=+weight); public double oldGetPrice() double price = weight*10; return price;,public class CheapGoods extends Goods public int weight; public void newSetWeight(int w) weight=w; System.out.println(int型的weight=+weight);

14、public double newGetPrice() double price = weight*10; return price;,public class Example5_3 public static void main(String args ) CheapGoods cheapGoods=new CheapGoods(); cheapGoods.weight=198.98; cheapGoods.newSetWeight(198); System.out.println(對象cheapGoods的weight的值是:+cheapGoods.weight); System.out.

15、println(cheapGoods用子類新增的優(yōu)惠方法計算價格：+ cheapGoods.newGetPrice(); cheapGoods.oldSetWeight(198.987); /子類對象調(diào)用繼承的方法操作隱藏的double型變量weight System.out.println(cheapGoods使用繼承的方法（無優(yōu)惠）計算價格：+ cheapGoods.oldGetPrice();,1重寫的語法規(guī)則 方法重寫是指：子類中定義一個方法，這個方法的類型和父類的方法的類型一致或者是父類的方法的類型的子類型（所謂子類型是指：如果父類的方法的類型是“類”，那么允許子類的重寫方法的類型是

16、“子類”），并且這個方法的名字、參數(shù)個數(shù)、參數(shù)的類型和父類的方法完全相同。子類如此定義的方法稱作子類重寫的方法（不屬于新增的方法,5.4.2 方法重寫（Override,2重寫的目的 子類通過方法的重寫可以隱藏繼承的方法，子類通過方法的重寫可以把父類的狀態(tài)和行為改變?yōu)樽陨淼臓顟B(tài)和行為。如果父類的方法f可以被子類繼承，子類就有權(quán)利重寫f，一旦子類重寫了父類的方法f，就隱藏了繼承的方法f，那么子類對象調(diào)用方法f調(diào)用的一定是重寫方法f。 重寫方法既可以操作繼承的成員變量、繼承的方法，也可以操作子類新聲明的成員變量、新定義的其他方法，但無法操作被子類隱藏的成員變量和方法。如果子類想使用被隱藏的方法或成

17、員變量，必須使用關(guān)鍵字super,例5-4,public class University void enterRule(double math,double english,double chinese) double total=math+english+chinese; if(total=200) System.out.println(考分+total+達到大學最低錄取線); else System.out.println(考分+total+未達到大學最低錄取線);,public class ImportantUniversity extends University void ente

18、rRule(double math,double english,double chinese) double total=math+english+chinese; if(total=245) System.out.println(考分+total+達到重點大學最低錄取線); else System.out.println(考分+total+未達到重點大學最低錄取線);,public class Example5_4 public static void main(String args) double math=64,english=76.5,chinese=66; ImportantUn

19、iversity univer = new ImportantUniversity(); univer.enterRule(math,english,chinese); /調(diào)用重寫的方法 math=89; english=80; chinese=86; univer = new ImportantUniversity(); univer.enterRule(math,english,chinese); /調(diào)用重寫的方法,class A float computer(float x,float y) return x+y; public int g(int x,int y) return x+y

20、; class B extends A float computer(float x,float y) return x*y; public class Example5_5 public static void main(String args) B b=new B(); double result=puter(8,9); /b調(diào)用重寫的方法 System.out.println(調(diào)用重寫方法得到的結(jié)果:+result); int m=b.g(12,8); /b調(diào)用繼承的方法 System.out.println(調(diào)用繼承方法得到的結(jié)果:+m);,例5-5,在JDK 1.5版本之后，允許重寫

21、方法的類型可以是父類方法的類型的子類型，即不必完全一致（JDK 1.5版本之前要求必須一致），也就是說，如果父類的方法的類型是“類” ，重寫方法的類型可以是“子類,3JDK 1.5對重寫的改進,例5-6,public class HomeEletricity int weight; public void setWeight(int w) weight=w; public void showMess() System.out.println(我是家用電器);,public class Television extends HomeEletricity public void showMess(

22、) System.out.println(我是電視機,重量是+weight+kg); public class Icebox extends HomeEletricity public void showMess() System.out.println(我是冰箱,重量是+weight+kg);,class Factory public HomeEletricity make() /方法的類型是HomeEletricity類 HomeEletricity machine=new HomeEletricity(); return machine; class TVFactory extends

23、Factory public Television make() /重寫方法的類型是HomeEletricity類的子類:Television Television tv=new Television(); tv.setWeight(21); return tv; class IceboxFactory extends Factory public Icebox make() /重寫方法的類型是HomeEletricity類的子類:Icebox Icebox icebox=new Icebox(); icebox.setWeight(67); return icebox; public cla

24、ss Example5_6 public static void main(String args) TVFactory factory1=new TVFactory(); Television tv=factory1.make(); /factory1調(diào)用重寫的方法 tv.showMess(); IceboxFactory factory2=new IceboxFactory(); Icebox icebox=factory2.make(); /factory2調(diào)用重寫的方法 icebox.showMess();,重寫父類的方法時，不可以降低方法的訪問權(quán)限。下面的代碼中，子類重寫父類的方法f

25、，該方法在父類中的訪問權(quán)限是protected級別，子類重寫時不允許級別低于protected,4重寫的注意事項,class A protected float f(float x,float y) return x-y; class B extends A float f(float x,float y) return x+y;,5.5. 1 用super操作被隱藏的成員變量和方法 子類一旦隱藏了繼承的成員變量，那么子類創(chuàng)建的對象就不再擁有該變量，該變量將歸關(guān)鍵字super所有，同樣子類一旦隱藏了繼承的方法，那么子類創(chuàng)建的對象就不能調(diào)用被隱藏的方法，該方法的調(diào)用由關(guān)鍵字super負責。因此，

26、如果在子類中想使用被子類隱藏的成員變量或方法就需要使用關(guān)鍵字super,5.5 super關(guān)鍵字,例5-7,public class Bank int savedMoney; int year; double interest; public double computerInterest() interest=year*0.035*savedMoney; System.out.printf(%d元存在銀行%d年的利息:%f元n, savedMoney,year,interest); return interest;,public class ConstructionBank extends

27、Bank double year; public double computerInterest() super.year=(int)year; double remainNumber=year-(int)year; int day=(int)(remainNumber*1000); interest=puterInterest()+day*0.0001*savedMoney; System.out.printf(%d元存在建設(shè)銀行%d年零%d天的利息:%f元n, savedMoney,super.year,day,interest); return interest;,public clas

28、s BankOfDalian extends Bank double year; public double computerInterest() super.year=(int)year; double remainNumber=year-(int)year; int day=(int)(remainNumber*1000); interest=puterInterest()+day*0.00012*savedMoney; System.out.printf(%d元存在大連銀行%d年零%d天的利息:%f元n, savedMoney,super.year,day,interest); retu

29、rn interest;,public class Example5_7 public static void main(String args) int amount=5000; ConstructionBank bank1=new ConstructionBank(); bank1.savedMoney=amount; bank1.year=5.216; double interest1=puterInterest(); BankOfDalian bank2=new BankOfDalian(); bank2.savedMoney=amount; bank2.year=5.216; dou

30、ble interest2=puterInterest(); System.out.printf(兩個銀行利息相差%f元n,interest2-interest1);,當用子類的構(gòu)造方法創(chuàng)建一個子類的對象時，子類的構(gòu)造方法總是先調(diào)用父類的某個構(gòu)造方法，也就是說，如果子類的構(gòu)造方法沒有明顯地指明使用父類的哪個構(gòu)造方法，子類就調(diào)用父類的不帶參數(shù)的構(gòu)造方法，即如果在子類的構(gòu)造方法中，沒有明顯地寫出super關(guān)鍵字來調(diào)用父類的某個構(gòu)造方法，那么默認地有： super( ); 子類不繼承父類的構(gòu)造方法，因此，子類在其構(gòu)造方法中需使用super來調(diào)用父類的構(gòu)造方法，而且super必須是子類構(gòu)造方法中的頭一

31、條語句,5.5.2 使用super調(diào)用父類的構(gòu)造方法,例5-8,public class Card String title; Card( ) title = 新年快樂!; Card(String title) this.title = title; public String getTitle() return title;,public class ChristmasCard extends Card String content; /子類新增的content ChristmasCard(String title,String content) super(title); /調(diào)用父類的構(gòu)造

32、方法，即執(zhí)行Card(title) this.content = content; public void showCard() System.out.println(*+getTitle()+*); 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 Chr

33、istmasCard(title,content); card.showCard();,final關(guān)鍵字可以修飾類、成員變量和方法中的局部變量,5.6 final關(guān)鍵字,可以使用final將類聲明為final類。final類不能被繼承，即不能有子類。如： final class A A就是一個final類，將不允許任何類聲明成A的子類。有時候是出于安全性的考慮，將一些類修飾為final類。例如，Java提供的String類，它對于編譯器和解釋器的正常運行有很重要的作用，對它不能輕易改變，它被修飾為final類,5.6.1 final類,如果用final修飾父類中的一個方法，那么這個方法不允許子

34、類重寫，也就是說，不允許子類隱藏可以繼承的final方法（老老實實繼承，不許做任何篡改,5.6.2 final方法,如果成員變量或局部變量被修飾為final，那么它就是常量。常量在聲明時沒有默認值，所以在聲明常量時必須指定該常量的值，而且不能再發(fā)生變化,5.6.3 常量,class A final double PI=3.1415926;/ PI是常量 public double getArea(final double r) return PI*r*r; public final void speak() System.out.println(您好，Hows everything here

35、?); public class Example5_9 public static void main(String args) A a=new A(); System.out.println(面積：+a.getArea(100); a.speak();,假設(shè)，A類是B類的父類，當用子類創(chuàng)建一個對象，并把這個對象的引用放到父類的對象中時，如： A a; a=new B(); 或 A a; B b=new B(); a=b; 這時，稱對象a是對象b的上轉(zhuǎn)型對象（就像說：“美國人是人”）。 對象的上轉(zhuǎn)型對象的實體是子類負責創(chuàng)建的，但上轉(zhuǎn)型對象會失去原對象的一些屬性和功能（上轉(zhuǎn)型對象相當于子類對象的

36、一個“簡化”對象,5.7 對象的上轉(zhuǎn)型對象,1）上轉(zhuǎn)型對象不能操作子類新增的成員變量（失掉了這部分屬性）；不能調(diào)用子類新增的方法（失掉了一些功能）。 （2）上轉(zhuǎn)型對象可以訪問子類繼承或隱藏的成員變量，也可以調(diào)用子類繼承的方法或子類重寫的實例方法。上轉(zhuǎn)型對象操作子類繼承的方法或子類重寫的實例方法，其作用等價于子類對象去調(diào)用這些方法。因此，如果子類重寫了父類的某個實例方法后，當對象的上轉(zhuǎn)型對象調(diào)用這個實例方法時一定是調(diào)用了子類重寫的實例方法,上轉(zhuǎn)型對象具有如下特點（重要,例5-10,public class People int height; double weight; void showBo

37、dyMess() System.out.printf(*n); void mustDoingThing() System.out.println(吃飯、睡覺. .飲水);,public class American extends People void showBodyMess() System.out.println(bodyHeight:+height+cm+ bodyWeight:+weight+kg); void speakEnglish() System.out.println(I am Amerian);,public class Chinese extends People v

38、oid 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=null; American Johnson = new American(); people = Johnson ; /people是Johnson對象的上轉(zhuǎn)型對象。 people.height = 18

39、7; /同于Johnson.height=187 people.weight = 78.67; people.showBodyMess(); /等同于Johnson調(diào)用重寫的showBodyMess()方法 /people.speakEnglish(); /非法,因為speakEnglish()是子類新增的方法 people.mustDoingThing(); Chinese zhang = new Chinese(); people = zhang ; /people是zhang對象的上轉(zhuǎn)型對象。 people.height = 177; /同于zhang.height=187 people

40、.weight = 68.59; people.showBodyMess(); /等同于Johnson調(diào)用重寫的showBodyMess()方法 /people.speakChinese(); /非法,因為speakChinese()是子類新增的方法 people.mustDoingThing(); zhang = (Chinese)people; zhang.speakChinese();,當一個類有很多子類時，并且這些子類都重寫了父類中的某個實例方法，那么當我們把子類創(chuàng)建的對象的引用放到一個父類的對象中時，就得到了該對象的一個上轉(zhuǎn)型對象，那么這個上轉(zhuǎn)型對象在調(diào)用這個實例方法時就可能具有多種

41、形態(tài)，因為不同的子類在重寫父類的實例方法時可能產(chǎn)生不同的行為。多態(tài)性就是指父類的某個實例方法被其子類重寫時，可以各自產(chǎn)生自己的功能行為,5.8 繼承與多態(tài),5-11,class EspecialCar void cautionSound() class PoliceCar extends EspecialCar void cautionSound() System.out.println(zhua.zhua.zhua.); class AmbulanceCar extends EspecialCar void cautionSound() System.out.println(jiu.jiu.

42、jiu.); class FireCar extends EspecialCar void cautionSound() System.out.println(huo.huo.huo.); public class Example5_11 public static void main(String args) EspecialCar car=new PoliceCar(); /car是警車的上轉(zhuǎn)型對象 car.cautionSound(); car=new AmbulanceCar(); /car是救護車的上轉(zhuǎn)型對象 car.cautionSound(); car=new FireCar()

43、; /car是消防車的上轉(zhuǎn)型對象 car.cautionSound();,用關(guān)鍵字abstract修飾的類稱為abstract類（抽象類）。如： abstract class A 用關(guān)鍵字abstract修飾的方法稱為abstract方法（抽象方法），對于abstract方法，只允許聲明，不允許實現(xiàn)，而且不允許使用final和abstract同時修飾一個方法,5.9 abstract類和abstract方法,和普通的類相比，abstract類可以有abstract方法（抽象方法）也可以有非abstract方法,1abstract類中可以有abstract方法,abstract class A

44、abstract int min(int x,int y); int max(int x,int y) return xy?x:y;,對于abstract類，我們不能使用new運算符創(chuàng)建該類的對象。如果一個非抽象類是某個抽象類的子類，那么它必須重寫父類的抽象方法，給出方法體，這就是為什么不允許使用final和abstract同時修飾一個方法的原因。 注：abstract類也可以沒有abstract方法。 注：如果一個abstract類是abstract類的子類，它可以重寫父類的abstract方法，也可以繼承這個abstract方法,2abstract類不能用new運算創(chuàng)建對象,abstrac

45、t class A abstract int sum(int x,int y); int sub(int x,int y) return x-y; class B extends A int sum(int x,int y) /子類必須重寫父類的sum方法 return x+y; public class Example5_12 public static void main(String args) B b=new B(); int sum=b.sum(30,20); /調(diào)用重寫的方法 int sub=b.sub(30,20); /調(diào)用繼承的方法 System.out.println(sum

46、=+sum); /輸出結(jié)果為sum=50 System.out.println(sum=+sub); /輸出結(jié)果為sum=10,在設(shè)計程序時，經(jīng)常會使用abstract類，其原因是，abstract類只關(guān)心操作，但不關(guān)心這些操作具體實現(xiàn)的細節(jié)，可以使程序的設(shè)計者把主要精力放在程序的設(shè)計上，而不必拘泥于細節(jié)的實現(xiàn)（將這些細節(jié)留給子類的設(shè)計者），即避免設(shè)計者把大量的時間和精力花費在具體的算法上。 在設(shè)計一個程序時，可以通過在abstract類中聲明若干個abstract方法，表明這些方法在整個系統(tǒng)設(shè)計中的重要性，方法體的內(nèi)容細節(jié)由它的非abstract子類去完成,5.10 面向抽象編程,使用多態(tài)進

47、行程序設(shè)計的核心技術(shù)之一是使用上轉(zhuǎn)型對象，即將abstract類聲明對象作為其子類的上轉(zhuǎn)型對象，那么這個上轉(zhuǎn)型對象就可以調(diào)用子類重寫的方法。 所謂面向抽象編程，是指當設(shè)計一個類時，不讓該類面向具體的類，而是面向抽象類，即所設(shè)計類中的重要數(shù)據(jù)是抽象類聲明的對象，而不是具體類聲明的對象,小例題,public class Circle double r; Circle(double r) this.r=r; public double getArea() return 3.14*r*r;,public class Pillar Circle bottom; dobule height; Pillar(Circle bottom,double height) this.bottom=bottom;this.height=height; public double getVolume() return bottom.getArea()*height;,分析,當用戶要把柱體的底改變的時候，則Pillar類無法適應(yīng)該需求 可以抽象出一個抽象的圖像類 public abstract class