java面向?qū)ο罂偨Y(jié)

1、Java面向?qū)ο罂偨Y(jié)面向?qū)ο蟮娜蠡咎卣鳎豪^承性，封裝性，多態(tài)性一、關(guān)于java面向?qū)ο蟾拍畹睦斫鈩e人問你對象是什么，類是什么？你會怎么回答？對于基本概念，自己的心里要有一個思路要了解對象要先知道類，引用一句書本的概念：類用于描述客觀世界里某一類對象的共同特征，而對象則是類的具體存在。所以你的回答可以是：許多對象的共同特征的抽象概念就是類，而對象則是類的具體存在。用代碼來，解釋一下：比如People類，有類成員：變量name和方法eat（）；這里的People類只是一個抽象的概念，不能有實際的行為，這時候就需要實例化對象來表現(xiàn)實際的行為。實例化：People xiaoming=new Peo

2、ple（）；怎么理解這個表達(dá)式呢？左邊是實例化還是右邊是實例化呢？其實右邊才是實例化，然后把實例化的東西，賦值給左邊的People類對象然后就有了People類的實例化對象xiaoming對象就可以有實際行為了： = ”小明 ”;xiaoming.eat() ;這里實例化就會運行類的構(gòu)造方法，比如你在另一個類的方法里面只編寫new People（），即使沒有賦值對象，也會運行People里面的構(gòu)造方法，重寫一下People的構(gòu)造方法，并在里面輸出一句話，運行，就可以看到輸出的語句。借助網(wǎng)上一個例子解釋，面向?qū)ο蟮乃枷耄核^面向?qū)ο?，書上說的都是關(guān)于對象的概念，這東西很

3、抽象，難以理解，很簡單的一個思路，如，我要木頭，從建材市場這個對象拿，調(diào)用建材市場這個對象中出售木頭這個方法，返回我一個木頭。至于建材市場的木頭哪來的，我不知道，也不用知道，這個社會有各行各業(yè)，他們?nèi)际菍ο螅加幸粋€方法，返回該職業(yè)能返回給社會的事物，之所以說面向?qū)ο蟾咏谌说恼Ｋ季S，妙處就在這，我們把能拿到我們想要的東西的出處抽取成一個對象，我們直接訪問它，拿到我們要的東西，它又從它該拿到東西的對象處拿東西，看似互不相干，卻又有很多關(guān)系，這就是面向?qū)ο?，記住，每一個對象，一個方法，只做它自己該做的事，其他的，交給其他的方法，其他的對象，層次理清楚，你能寫出很棒的程序。二、面向?qū)ο笾R點

4、總結(jié)面向?qū)ο笾饕膬?nèi)容：類和對象的關(guān)系，封裝（機箱故事），繼承，多態(tài)，構(gòu)造函數(shù)，this，supper，static，內(nèi)部類（用處很少），抽象類，接口面向?qū)ο笫且环N思想，能讓復(fù)雜的問題簡單化，讓我們角色從執(zhí)行者變成指揮者，不要知道過程，只要知道結(jié)果。（一切皆對象。）對象的特點在于封裝數(shù)據(jù)，數(shù)據(jù)包含著屬性和行為。一般一個程序可以由很多個類組成，也可以有多個主函數(shù)，但一般有一個主函數(shù)就可以。格式：引用類名 對象名=new 構(gòu)造函數(shù)名（參數(shù)）；例：class DuiXiang則建立對象為：DuiXiang mingZi=new DuiXiang（）；如果要實現(xiàn)功能，則格式為：mingZi。變量或函數(shù)

5、名（）； 面向?qū)ο笾庋b函數(shù)是最小的封裝體。類也是一個封裝體。private:私有的，權(quán)限修飾符，用來修飾類中的成員（成員變量 、成員函數(shù)），其只在本類中有效。每個成員變量通常都會對應(yīng)兩個訪問方式：一個設(shè)置，一個獲取。注意：私有僅是封裝的一種表現(xiàn)形式。因為語句都必須在函數(shù)內(nèi)，所以，私有化后，再提供訪問方式，就可以在訪問方式的函數(shù)內(nèi)實現(xiàn)變量控制。這樣就提高代碼的健壯性。一般進(jìn)行封裝，要對類中的大部分屬性都隱藏，最低權(quán)限是private。類里有一個setXxx函數(shù)（一般返回值是void，保存數(shù)據(jù)，要帶參數(shù)）和getXxx函數(shù)（有返回值類型，但一般沒參數(shù),getXxx之后一般用一個變量來接收:str

6、ing x=p.getXxx），那代表一定有一個私有化屬性。成員變量都有初始化值， 局部變量可以沒有。舉例：class XueShengprivate String name；public void setName(String name)/這個函數(shù)方便以后賦值=name;public String getName()/這個函數(shù)是方便以后有需要調(diào)用的，比如以后要打印name的值return name;構(gòu)造函數(shù)：函數(shù)名與類名一致，不用返回值類型，不可以用return，主要用來初始化對象。對象一建立，就默認(rèn)調(diào)用其構(gòu)造函數(shù)。一個對象一建立，就有其默認(rèn)的屬性和行為。（如一個人剛出生就

7、會呼吸，哭.）。如果我們沒有指認(rèn)，那么類建立就會默認(rèn)建一個構(gòu)造函數(shù)（類名（），不然對象無法初始化，也就無法建立。（注意：只要我們有重寫，那么就不會使用默認(rèn)的建構(gòu)造函數(shù)）其與普通函數(shù)的區(qū)別除了寫法上之外：1，構(gòu)造函數(shù)只在對象建立時運行一次，不再運行了，而普通函數(shù)可以調(diào)用多次，另外，構(gòu)造函數(shù)是用來初始化對象的，而一般方法是用來添加對象具備的功能。何時我們要手動添加構(gòu)造函數(shù)：當(dāng)我們分析事物時，該事物存在一些特性或行為，那么我們就給其定義一個構(gòu)造函數(shù)，如果有變量參與運算，那么我們就給構(gòu)造函數(shù)定義一個參數(shù)。構(gòu)造函數(shù)寫法舉例：class PersonPerson(String name,int age)/

8、注意：在新建一個對象時要加上參數(shù)進(jìn)行區(qū)分，因為一個類可以放很多個構(gòu)造方法。/比如調(diào)用方式：Person p =new Person（"fada",20）/構(gòu)造函數(shù)已經(jīng)被重寫了，默/認(rèn)的構(gòu)造方法已經(jīng)不存在了，再調(diào)用 Person p=new Person（）；會報錯 = name;this.age = age;初始化代碼塊：（不怎么用）1，所有對象在建立時都先執(zhí)行構(gòu)造代碼塊初始化，再執(zhí)行構(gòu)造函數(shù)初始化。2，作用：當(dāng)所有對象有共性時，那么就可以定義一個構(gòu)造代碼塊（例如：所有小孩先出來就是哭，然后才有其它的屬性）構(gòu)造代碼塊的寫法(就是在類里面用一個大括號)舉例：

9、class PersonSystem.out.print("fada")/這樣一寫，那么以后每次建立一個構(gòu)造函數(shù)時便先初始化這個構(gòu)造代碼塊this關(guān)鍵字的用法This在類中就是三個代表：代表對象的成員變量，在函數(shù)中代表對象調(diào)用函數(shù)，代表類中的構(gòu)造函數(shù)。格式：this.變量=變量；this是用來區(qū)分局部變量和成員變量同名時的關(guān)鍵字，因為如果在構(gòu)造函數(shù)里比如（name=name），那么其是賦值給他本身，而不是賦值給類里面的name。何是用this？當(dāng)定義類中的函數(shù)時，需要調(diào)用該函數(shù)的對象時，這個時候就用this來表示這個對象。但凡本類功能內(nèi)部使用到了本類對象，用this表示。看

10、到this就是有代表對象，代表哪個對象就看其所在功能被哪個對象調(diào)用。這樣就知道誰在參與運算。例：class Personprivate String name;Person(String name) = name;/=；class PersonDemo3 public static void main(String args) Person p1 = new Person("fada");this的應(yīng)用之定義類中函數(shù)的調(diào)用：當(dāng)定義類中功能時，該函數(shù)內(nèi)部要用到調(diào)用該函數(shù)的對象時，這時用this來表示這個對象。但凡本類功能內(nèi)部使

11、用了了本類對象，都用this表示。例：class Personprivate String name;Person(String name) = name;/=；this.fada();/其實就=p1.fada();/這里寫這p1是因為p1這個對象在調(diào)用這個函數(shù)。一句話，誰調(diào)用它就在代表誰。private int age;Person(int age)this.age = age;public void fada()System.out.println("fada");/*需求：給人定義一個用于比較年齡是否相同的功能。也就是

12、是否是同齡人。*/public boolean compare(Person p) return this.age=p.age;class PersonDemopublic static void main(String args) Person p1 = new Person(20);Person p2 = new Person(25);/因為是兩個人比，所以要先建立兩人的對象boolean b = pare(p2);/這里定義了一個布爾型變量去接收p1調(diào)用compare函數(shù)的值System.out.println(b);另一種this用法：格式this（變量）用于構(gòu)造函數(shù)間的相互調(diào)用，而且

13、只能放在構(gòu)造函數(shù)的第一行。然后先初始化其this調(diào)用的構(gòu)造函數(shù)，再初始化本身的構(gòu)造函數(shù)。其實this(變量)；=new 構(gòu)造函數(shù)名（變量）；（因為所有構(gòu)造函數(shù)名是一樣的，都是重載函數(shù)，所以，通過變量來標(biāo)記構(gòu)造函數(shù)，用this去引用）例：class Personprivate String name;private int age;Person()System.out.println("person run");Person(String name)This(); =name;二、super    super關(guān)鍵和this作用類

14、似，是被屏蔽的成員變量或者成員方法或變?yōu)榭梢姡蛘哒f用來引用被屏蔽的成員變量和成員成員方法。不過super是用在子類中，目的是訪問直接父類中被屏蔽的成員，注意是直接父類（就是類之上最近的超類）。下面是一個綜合運用super的例子，有兩個類：一個Father類，一個Father類的子類Son，通過這兩個類完全演示了super的用法，一下是代碼： public class Father  public String v="Father" public String x="輸出了Father類的public成員變量x!" 

15、; public Father()   System.out.println("Father構(gòu)造方法被調(diào)用!");   public Father(String v)  this.v="Father類的帶參數(shù)構(gòu)造方法!運行了."  public void outinfo()  System.out.println("Father的outinfo方法被調(diào)用");   public stat

16、ic void main(String args)   / TODO 自動生成方法存根   public class Son extends Father public String v="Son"  public Son()   super();      /調(diào)用超類的構(gòu)造方法,只能放到第一行.  System.out.println("Son無參數(shù)構(gòu)造方法被調(diào)用!"); &

17、#160;/super();      /錯誤的,必須放到構(gòu)造方法體的最前面.    public Son(String str)  super(str);  System.out.println("Son帶參數(shù)構(gòu)造方法被調(diào)用!");  /覆蓋了超類成員方法outinfo() public void outinfo()   System.out.println("So

18、n的outinfo()方法被調(diào)用");    public void test()    String v="哈哈哈哈!"   /局部變量v覆蓋了成員變量v和超類變量v    System.out.println("-1-");  System.out.println(v);   /輸出局部變量v  System.out.pri

19、ntln(this.v);  /輸出(子類)成員變量v  System.out.println(super.v); /輸出超類成員變量v     System.out.println("-2-");  System.out.println(x);   /輸出超類成員變量v,子類繼承而來  System.out.println(super.x); /輸出超類成員變量v  

20、0; System.out.println("-3-");  outinfo();   /調(diào)用子類的outinfo()方法  this.outinfo();  /調(diào)用子類的outinfo()方法  super.outinfo(); /調(diào)用父類的outinfo()方法    public static void main(String args)   new Son().test();&#

21、160;   子類Son運行結(jié)果： Father構(gòu)造方法被調(diào)用!Son無參數(shù)構(gòu)造方法被調(diào)用!-1-哈哈哈哈!SonFather-2-輸出了Father類的public成員變量x!輸出了Father類的public成員變量x!-3-Son的outinfo()方法被調(diào)用Son的outinfo()方法被調(diào)用Father的outinfo方法被調(diào)用     說明：例子僅僅為了說明super的用法，實際在設(shè)計類的時候一般都盡可能私有(private)化。    通過上面的例子，

22、下面總結(jié)一下super的用法：   第一、在子類構(gòu)造方法中要調(diào)用父類的構(gòu)造方法，用“super(參數(shù)列表)”的方式調(diào)用，參數(shù)不是必須的。同時還要注意的一點是：“super(參數(shù)列表)”這條語句只能用在子類構(gòu)造方法體中的第一行。   第二、當(dāng)子類方法中的局部變量或者子類的成員變量與父類成員變量同名時，也就是子類局部變量覆蓋父類成員變量時，用“super.成員變量名”來引用父類成員變量。當(dāng)然，如果父類的成員變量沒有被覆蓋，也可以用“super.成員變量名”來引用父類成員變量，不過這是不必要的。   第三、當(dāng)子

23、類的成員方法覆蓋了父類的成員方法時，也就是子類和父類有完全相同的方法定義（但方法體可以不同），此時，用“super.方法名(參數(shù)列表)”的方式訪問父類的方法。   this、super的用法也不過這些，只有理解了其中的原理，才不會跌入陷阱！Static（靜態(tài)）關(guān)鍵字：static是一個修飾符：三種修飾：修飾類的變量、方法和構(gòu)造代碼塊。靜態(tài)方法只能直接引用和訪問靜態(tài)變量和方法注意（函數(shù)即方法，對象也叫實例）有時你希望定義一個類成員，使它的使用完全獨立于該類的任何對象。通常情況下，類成員必須通過它的類的對象訪問，但是可以創(chuàng)建這樣一個成員，它能夠被它自己使用，而不必引用

24、特定的實例。在成員的聲明前面加上關(guān)鍵字static(靜態(tài)的)就能創(chuàng)建這樣的成員。如果一個成員被聲明為static，它就能夠在它的類的任何對象創(chuàng)建之前被訪問，而不必引用任何對象。你可以將方法和變量都聲明為static。static 成員的最常見的例子是main( ) 。因為在程序開始執(zhí)行時必須調(diào)用main() ，所以它被聲明為static。 聲明為static的變量稱為靜態(tài)變量或類變量?？梢灾苯油ㄟ^類名引用靜態(tài)變量，也可以通過實例名來引用靜態(tài)變量，但最好采用前者，因為后者容易混淆靜態(tài)變量和一般變量。靜態(tài)變量是跟類相關(guān)聯(lián)的，類的所有實例共同擁有一個靜態(tài)變量。 關(guān)鍵點：靜態(tài)變量與實例變量的區(qū)別：靜態(tài)

25、變量也叫類變量，為所有對象所共有，所以一個對象的變量值改變，那么所有對象的值一起發(fā)生改變。而實例變量則是各自獨立的不受影響。聲明為static的方法稱為靜態(tài)方法或類方法。靜態(tài)方法可以直接調(diào)用靜態(tài)方法，訪問靜態(tài)變量，但是不能直接訪問實例變量和實例方法。靜態(tài)方法中不能使用this關(guān)鍵字，因為靜態(tài)方法不屬于任何一個實例。靜態(tài)方法不能被子類的靜態(tài)方法覆蓋。特有屬性隨著對象存儲于堆內(nèi)存中，而static修飾后的屬性，存在于方法區(qū).什么時候使用靜態(tài)修飾符？當(dāng)對象中出現(xiàn)共享數(shù)據(jù)時，使用靜態(tài)修飾。但對象內(nèi)的特有數(shù)據(jù)要定義成非靜態(tài)存在于堆內(nèi)存中。而對于方法時：當(dāng)功能內(nèi)部沒有訪問到非靜態(tài)數(shù)據(jù)時，（即對象的特有數(shù)據(jù)

26、）那么可以使用靜態(tài)修飾。靜態(tài)代碼塊：用于給類做初始化的。不管有沒有對象都執(zhí)行，只要調(diào)用了類里面成員或方法，就會執(zhí)行，而且優(yōu)先于主函數(shù)，優(yōu)先執(zhí)行級別最高。例：class JingTaistatic int age;static String name;static/靜態(tài)代碼塊初始化類的，所以最先運行。System.out.println("name="+name);/下面是構(gòu)造代碼塊，第二個運行System.out.println("age="+age);public static void jing(int x)/被對象調(diào)用，第三個運行。x =age+1

27、;/因為age是靜態(tài)的，所以能調(diào)用System.out.println("x="+x);class FaDapublic static void main(String args)JingTai p =new JingTai();p.jing(2);繼承繼承就是將兩個類的共性描述提取出來，單獨進(jìn)行描述，從而簡化代碼，提高復(fù)用性。格式：class 子類名 extends 父類名關(guān)健字為extends ：繼承判斷兩個類是否有所屬關(guān)系，那么我們就繼承一下，看父類所具有的內(nèi)容屬性，子類是否全都需要具備。如果是，那么他們所屬關(guān)系成立，就是繼承。注意：千萬不要為了獲取其他類的功能，簡化

28、代碼而繼承。必須是類與類之間有所屬關(guān)系才可以繼承。所屬關(guān)系 is a。例如：class A /void demo1()void demo2()class B /void demo1()void demo3()我們可以讓B繼承下A，但發(fā)現(xiàn)，A中還具有demo2這個方法是B所不具備的，所以他們倆的繼承關(guān)系不成立，但我們可以把兩個類的共性提取出來，成為一個class Cvoid demo1()那么A和B就能夠繼承C，這樣就實現(xiàn)在代碼的簡化和復(fù)用。Java語言中：java只支持單繼承，不支持多繼承。因為多繼承容易帶來安全隱患:當(dāng)多個父類中定義了相同功能，當(dāng)功能內(nèi)容不同時，子類對象不確定要運行哪一個。但

29、是java保留這種機制。并用另一種體現(xiàn)形式來完成表示。多實現(xiàn)。聚集：事物與事物的另一種關(guān)系，比如（類與類，對象與對象）聚合:例如：一個班里的有很多學(xué)生，那么班級和學(xué)生就是聚合關(guān)系。就是包含。組合：組合與聚合區(qū)別在于，組合各成員是不可分割的，否則會缺少功能，但聚合里的成員可以脫離，對整體沒有影響。子父類出現(xiàn)后，類成員的特點：類中成員：1，變量。2，函數(shù)。3，構(gòu)造函數(shù)。1,變量如果子類中出現(xiàn)非私有的同名成員變量時，子類要訪問本類中的變量，用this子類要訪問父類中的同名變量，用super。super的使用和this的使用幾乎一致。this代表的是本類對象的引用。super代表的是父類對象的引用。例

30、如：class Fu int num = 4;class Zi extends Fuint num = 5;void show()System.out.println(super.num);/有super對象調(diào)用函數(shù)打印結(jié)果是4，沒有打印結(jié)果是5子父類中的函數(shù)另一個特性：函數(shù)的重寫(覆蓋)當(dāng)子類繼承父類，沿襲了父類的功能，這時不但可以保留父類的功能定義，還可以重寫功能內(nèi)容。覆蓋要注意的關(guān)健點：1，子類覆蓋父類，必須保證子類訪問權(quán)限大于等于父類權(quán)限，才可以覆蓋，否則編譯失敗。（權(quán)限修飾符沒設(shè)的時候為默認(rèn)權(quán)限，介于public與private之間。）例如：class Fuvoid show()Sy

31、stem.out.println("fu show");class Zi extends Fuvoid show()System.out.println("java");/這里我即可以改變，也可以增加。增加時我們不用重寫一遍父類函數(shù)的內(nèi)容，只雖要super.函數(shù)名（）就可以。2，靜態(tài)只能覆蓋靜態(tài)。注意：重載：只看同名函數(shù)的參數(shù)列表。重寫：子父類方法要一模一樣。子父類中的構(gòu)造函數(shù)之特點：子類中的構(gòu)造函數(shù)會默認(rèn)調(diào)用父類中的函數(shù)中的默認(rèn)構(gòu)造函數(shù)，因為子類的構(gòu)造函數(shù)默認(rèn)第一行有一條隱式的語句 super();但有幾個地方要注意：例：class Fu Fu()注意

32、：如果沒有這一個空參數(shù)的構(gòu)造函數(shù)，但又有我們指認(rèn)的非空參數(shù)的構(gòu)造函數(shù)，那么我們知道默認(rèn)那個空參數(shù)構(gòu)造函數(shù)也不會生成，這個時候子類就會編譯失敗。這個時候就不能讓子類默認(rèn)獲取super（）；而要指認(rèn)super（x）num= 60;System.out.println("fu run");Fu(int x)System.out.println("fu ."+x);class Zi extends FuZi()super(); /不管父類有幾個構(gòu)造函數(shù)，只要沒有指認(rèn)，那么就默認(rèn)這一個super();/super(4);System.out.println(&qu

33、ot;zi run");Zi(int x)super();super(3);System.out.println("zi."+x);調(diào)用構(gòu)造函數(shù)用super（）；（括號里面是參數(shù)），而調(diào)用一般函數(shù)用super.函數(shù)名（）一個構(gòu)造函數(shù)中只能要么有this要么有super，而且必須放在第一行子類中至少會有一個構(gòu)造函數(shù)會訪問父類中的構(gòu)造函數(shù)。extends Object：java中的頂極父類，也就是任何沒標(biāo)明父類的類的默認(rèn)父類。final : “最終”修飾符：1，可以修飾類，函數(shù)，變量。2，被final修飾的類不可以被繼承。作用：為了避免被繼承，被子類復(fù)寫功能。3，被f

34、inal修飾的方法不可以被復(fù)寫。4，被final修飾的變量是一個常量只能賦值一次，既可以修飾成員變量，有可以修飾局部變量。當(dāng)在描述事物時，一些數(shù)據(jù)的出現(xiàn)值是固定的，那么這時為了增強閱讀性，都給這些值起個名字。方便于閱讀。而這個值不需要改變，所以加上final修飾。作為常量：常量的書寫規(guī)范所有字母都大寫，如果由多個單詞組成，單詞間通過_連接。5，內(nèi)部類定義在類中的局部位置上是，只能訪問該局部被final修飾的局部變量。例如：final int x=4；那么x永遠(yuǎn)等于4，不可以被賦值，就成了常量，之所以不直接定常量，是因為要給數(shù)值起個名，增強閱讀性，以后也好調(diào)用。抽象修飾符，abstract：只能

35、修飾類和方法：特點：1，修飾的類不能創(chuàng)建對象（實例）。2，修飾的對象只有功能，沒有內(nèi)容。3，抽象方法和抽象類都必須被abstract關(guān)鍵字修飾，也就是抽象方法一定在抽象類中， 但抽象類不一定要有抽象方法.4，抽象類中的抽象方法要被使用，必須由子類復(fù)寫起所有的抽象方法后，建立子類對象調(diào)用。如果子類只覆蓋了部分抽象方法，那么該子類還是一個抽象類。因為抽象方法和抽象類都必須被abstract關(guān)鍵字修飾（如果只復(fù)寫了一個，那么子類必然還繼承了其它的抽象方法，根據(jù)抽象方法必須在抽象類中，則這個類還是個抽象類）。應(yīng)用：1，建立不可創(chuàng)建對象的類。2，如果子類中需要的方法內(nèi)容不一樣，但又同樣都要這么方法，那么

36、就可以創(chuàng)建一個抽象類。例如：創(chuàng)建一個學(xué)校成員，有學(xué)生，有老師，都有姓名，年齡，都要上課，但老師上課是教學(xué)，學(xué)生上課是學(xué)習(xí)。所以可以這樣寫：class XueXiaoprivate String name;private int age；XueXiao(String name,int age) = name;this.age = age;public abstract void work();/子類需要這個功能，但內(nèi)容不一樣，所以用抽象。class Student extends EmployeeStudent(String name,int age)super(name,ag

37、e);/直接調(diào)用父類構(gòu)造函數(shù)。public void work()System.out.println("shangke");class LaoShi extends EmployeeLaoShi(String name,int age)super(name,age);/直接調(diào)用父類構(gòu)造函數(shù)。public void work()System.out.println("laoshi");模版方法設(shè)計模式：什么是模版方法呢？在定義功能時，功能的一部分是確定的，但是有一部分是不確定，而確定的部分在使用不確定的部分，那么這時就將不確定的部分暴露出去。由該類的子類

38、去完成。abstract class GetTimepublic final void getTime()/這個類是不需要改變的，所以就用final最終修飾。long start = System.currentTimeMillis();runcode();long end = System.currentTimeMillis();System.out.println("毫秒："+(end-start);public abstract void runcode();/這個函數(shù)主體要設(shè)成不確定，這樣記算任何函數(shù)的運行時間：我只要把要算的函數(shù)定義成這個的內(nèi)容就行了。所以設(shè)成抽象

39、類的方法。class SubTime extends GetTimepublic void runcode()for(int x=0; x<4000; x+)System.out.print(x);要調(diào)用計時這個功能，我們就在要在類中新健一個SubTime的對象。再調(diào)用getTime函數(shù)的就可以（SubTime類繼承了父類，所以有g(shù)etTime函數(shù)。）接口：接口：初期理解，可以認(rèn)為是一個特殊的抽象類當(dāng)抽象類中的方法都是抽象的，那么該類可以通過接口的形式來表示。class用于定義類關(guān)健字：interface 用于定義接口。接口定義時，格式特點：1，接口中常見定義：常量，抽象方法。2，接口中

40、的成員都有固定修飾符，（不寫也會自動生成）。常量：public static final方法：public abstract 記?。航涌谥械某蓡T都是public的。接口：是不可以創(chuàng)建對象的，因為有抽象方法。需要被子類實現(xiàn)，子類對接口中的抽象方法全都覆蓋后，子類才可以實例化。否則子類是一個抽象類。原因和抽象類一樣，有抽象則為抽象類。接口可以被類多實現(xiàn)，也是對多繼承不支持的轉(zhuǎn)換形式。java支持多實現(xiàn)。1，類可以實現(xiàn)多個接口，用關(guān)健字：implements 如：class Test implements JieKou,JieKou22，類繼承后，仍可以實現(xiàn)多個接口，如：class Test ext

41、ends Demo implements JieKou,JieKou23，接口在可以實現(xiàn)多繼承,如：interface Test extends A,B例：abstract class Studentabstract void study();學(xué)生都要學(xué)習(xí)，所以可以作為父類來給子類繼承。interface Smokingvoid smoke();/抽煙不是所有學(xué)生都會，所以，不可以繼承，不然所有學(xué)生都抽煙了，所以定義為接口，讓需要的類實現(xiàn)就行。class ZhangSan extends Student implements Smoking/繼承后再實現(xiàn)，這樣就實現(xiàn)了功能的擴(kuò)展。void st

42、udy()public void smoke()/記得要復(fù)寫,因為父類是抽象的。class Lisi extends Student void study()System.out.prtintln("study")多態(tài)：1，多態(tài)的體現(xiàn)父類的引用指向了自己的子類對象。父類的引用也可以接收自己的子類對象。2，多態(tài)的前提必須是類與類之間有關(guān)系。要么繼承，要么實現(xiàn)。通常還有一個前提：存在覆蓋。3，多態(tài)的好處多態(tài)的出現(xiàn)大大的提高程序的擴(kuò)展性。4，多態(tài)的弊端：提高了擴(kuò)展性，但是只能使用父類的引用訪問父類中的成員。 如何要訪問子類特有對象必須強制轉(zhuǎn)換為子類對象。abstract clas

43、s Animalabstract void eat();class Cat extends Animalpublic void eat()多態(tài)還有一個前提：存在覆蓋。不然沒有意義，只是繼承了一個空方法。System.out.println("吃魚");public void catchMouse()但是只能使用父類的引用訪問父類中的成員。因為父類中并沒有catchMouse方法，所以多態(tài)無法實現(xiàn)catchMouseSystem.out.println("抓老鼠");class Dog extends Animalpublic void eat()Syst

44、em.out.println("吃骨頭");public static void function(Animal a)/Animal a = new Cat();父類的引用指向了自己的子類對象。父類的引用也可以接收自己的子類對象。前題：必須是類與類之間有關(guān)系。要么繼承，要么實現(xiàn)。Animal是動物，Cat是它的子類。a.eat();class DuoTaiDemo public static void main(String args) function(new Cat();function(new Dog();提高了擴(kuò)展性，不用再去新建一個對象，再引用對象的功能。繼承何為

45、繼承，有何作用繼承就是將兩個類的共性描述提取出來，單獨進(jìn)行描述，從而簡化代碼，提高復(fù)用性。格式：class 子類名 extends 父類名關(guān)健字為extends ：繼承判斷兩個類是否有所屬關(guān)系，那么我們就繼承一下，看父類所具有的內(nèi)容屬性，子類是否全都需要具備。如果是，那么他們所屬關(guān)系成立，就是繼承。注意：千萬不要為了獲取其他類的功能，簡化代碼而繼承。必須是類與類之間有所屬關(guān)系才可以繼承。所屬關(guān)系 is a。例如：class A /void demo1()void demo2()class B /void demo1()void demo3()我們可以讓B繼承下A，但發(fā)現(xiàn)，A中還具有demo2這

46、個方法是B所不具備的，所以他們倆的繼承關(guān)系不成立，但我們可以把兩個類的共性提取出來，成為一個class Cvoid demo1()那么A和B就能夠繼承C，這樣就實現(xiàn)在代碼的簡化和復(fù)用。Java語言中：java只支持單繼承，不支持多繼承。因為多繼承容易帶來安全隱患:當(dāng)多個父類中定義了相同功能，當(dāng)功能內(nèi)容不同時，子類對象不確定要運行哪一個。但是java保留這種機制。并用另一種體現(xiàn)形式來完成表示。多實現(xiàn)。java支持多層繼承。也就是一個繼承體系如何使用一個繼承體系中的功能呢？想要使用體系，先查閱體系父類的描述，因為父類中定義的是該體系中共性功能。通過了解共性功能，就可以知道該體系的基本功能。那么這個

47、體系已經(jīng)可以基本使用了。那么在具體調(diào)用時，要創(chuàng)建最子類的對象，為什么呢？一是因為有可能父類不能創(chuàng)建對象，二是創(chuàng)建子類對象可以使用更多的功能，包括基本的也包括特有的。簡單一句話：查閱父類功能，創(chuàng)建子類對象使用功能。Object類:是所有對象的直接后者間接父類.該類中定義的是所有對象都具備的功能。如果自定義類中需要的功能是Object含有的，那么沒有必要重新定義，只要沿襲父類中的功能，建立自己特有比較內(nèi)容，覆蓋即可。常用的有比較功能：public boolean equals(Object obj)/這里要是Object對象，所以這里相當(dāng)于：Object obj =new 自定義類（）.這里寫其自

48、定義的內(nèi)容，如果這里要有自定義類里的特有功能，那么要強轉(zhuǎn)對象格式是：自定義類 x = （自定義類）obj；下面有些只是應(yīng)用較少，或者涉及到的知識會有點復(fù)雜，可以根據(jù)自己的興趣了解。內(nèi)部類(應(yīng)用中很少用，不詳細(xì)講解)特點：1，內(nèi)部類可以直接訪問外部類中的成員，包括私有。 （原因：內(nèi)部類中持有了一個外部類的引用，格式：外部類名.this） 2，外部類要訪問內(nèi)部類，必須建立內(nèi)部類對象。 3, 當(dāng)內(nèi)部類在成員位置上，就可以被成員修飾符所修飾。匿名內(nèi)部類: (應(yīng)用中很少用，不詳細(xì)講解)特點：1，匿名內(nèi)部類其實就是內(nèi)部類的簡寫格式。2，定義匿名內(nèi)部類的前提：內(nèi)部類必須是繼承一個類或者實現(xiàn)接口。3，匿名內(nèi)部

49、類的格式： new 父類或者接口()定義子類的內(nèi)容4，其實匿名內(nèi)部類就是一個匿名子類對象。而且這個對象有點胖?？梢岳斫鉃閹?nèi)容的對象。5，匿名內(nèi)部類中定義的方法最好不要超過3個。異常：把程序運行中出的問題通過java的類的形式進(jìn)行描述，并封裝成對象，這個對象的體現(xiàn)就是異常.好處在于：將問題進(jìn)行封裝，從而將正常流程代碼和問題處理代碼相分離，方便于閱讀。異常有兩種，嚴(yán)重的和不嚴(yán)重的。對于嚴(yán)重的，java通過Error類進(jìn)行描述。對于Error一般不編寫針對性的代碼對其進(jìn)行處理。對與非嚴(yán)重的，java通過Exception類進(jìn)行描述。對于Exception可以使用針對性的處理方式進(jìn)行處理。無論Err

50、or或者Exception都具有一些共性內(nèi)容。比如：不正常情況的信息，引發(fā)原因等。Throwable|-Error|-Exception2,異常的處理java 提供了特有的固定語句進(jìn)行處理。try需要被檢測的代碼；catch(異常類 變量)處理異常的代碼；(處理方式)finally/這句可以沒有。一定會執(zhí)行的語句；通常用于關(guān)閉資源。(不管用了return，還是continue，還是break，其都會運行。注意：當(dāng)你在捕獲到異常的處理代碼里加上：System.exit(0);這樣的話finally的代碼塊 是不會執(zhí)行的。捕獲異常的規(guī)則是盡量優(yōu)先捕獲具體的異常。System.exit(0)和Sys

51、tem.exit(1)什么區(qū)別？ 凡是非零都表示異常退出!0表示正常退出!)3，對捕獲到的異常對象進(jìn)行常見方法操作。String getMessage()：獲取異常信息。在函數(shù)上聲明異常。便于提高安全性，讓調(diào)用出進(jìn)行處理。不處理編譯失敗對多異常的處理。1，聲明異常時，建議聲明更為具體的異常。這樣處理的可以更具體。2，對方聲明幾個異常，就對應(yīng)有幾個catch塊。不要定義多余的catch塊。如果多個catch塊中的異常出現(xiàn)繼承關(guān)系，父類異常catch塊放在最下面。建立在進(jìn)行catch處理時，catch中一定要定義具體處理方式。不要簡單定義一句 e.printStackTrace(),也不要簡單的就

52、書寫一條輸出語句。自定義異常：必須是自定義類繼承Exception，因為異常體系有一個特點就是異常類和異常對象都被拋出，他們要具備可拋性，而這個可拋性是Throwable這個體系中獨有特點。只有這個體系中的類和對象才可以被throws和throw操作，二者區(qū)別是：throws使用在函數(shù)上用，用來拋出異常，告訴調(diào)用者這里有可能會出現(xiàn)異常。throw使用在函數(shù)內(nèi)用來拋出異常對象讓調(diào)用者處理。 throws后面跟的異常類?？梢愿鄠€。用逗號隔開。throw后跟的是異常對象。Exceptoin中有一個特殊的子類異常RuntimeException： 運行時異常。 如果在函數(shù)內(nèi)容拋出該異常，函數(shù)上可以不

53、用聲明，編譯一樣通過。 如果在函數(shù)上聲明了該異常。調(diào)用者可以不用進(jìn)行處理。編譯一樣通過；之所以不用在函數(shù)聲明，是因為不需要讓調(diào)用者處理，當(dāng)該異常發(fā)生，希望程序停止，對代碼進(jìn)行修正。自定義異常時，如果該異常的發(fā)生，無法處理讓其再繼續(xù)進(jìn)行運算，必須修正代碼，就讓自定義異常繼承RuntimeException，如可以處理，則繼承Exception。對于異常分兩種：1，編譯時被檢測的異常，那么不要么就catch處理它，不然就必須聲名。2，編譯時不被檢測的異常(運行時異常。RuntimeException以及其子類)。應(yīng)用舉例：人用電腦辦公。 比如問題是電腦藍(lán)屏：重啟可以修正錯誤，繼續(xù)上班，則繼承Exc

54、eption停電了：無法修正錯誤，只能停下來等電力供應(yīng)恢復(fù)。要對問題進(jìn)行描述，封裝成對象。class LanPingException extends ExceptionLanPingException(String message)super(message);/直接調(diào)用父類方法，用來返回此 throwable 的詳細(xì)消息字符串class TingDianException extends RuntimeExceptionTingDianException(String message)super(message);class Computerprivate int state = 2;public void run()throws LanPingExceptionif(state=2)throw new LanPingException("藍(lán)屏了");if(state=3)throw new TingDianException(" 停電了");System.out.println("電腦運行");public void reset()state = 1;System.out.prin