第一篇：JAVA總結專題

在這忙忙碌碌的這段時間里，經過老師的輔導，迅速的將一點沒有學的JAVA基礎搞定了！有了基礎學習還是好，萬事開頭難這句話說的太對了，學計算機語言我覺得記憶好的方法就是多打代碼，課前預習，課堂上認真聽講，把現學的方法把以前所做的作業用最簡便的方法再一次鞏固，創新最重要，在后續的學習中，得要加倍努力學習。

其實學java有不懂，要先自己思考。想清楚這句代碼是什么意思。為什么要寫在這，等等之類的。等你真的搞不明白的時候，就一定要向老師咨詢，不要感到有什么丟人的。因為不會是很正常的事。并不是每個人都是天才，一學就會，一學就能運用自如的。學java有一點是非常重要的，就是練習。一段代碼要不停的敲，多敲幾遍，尤其是自己不熟悉或者不熟練的代碼，更要敲。不要感覺到厭煩，其實我感覺敲代碼挺好玩的，并不是一件很枯燥的事。

老師平常布置的課后上機練習題一定要做，課后的練習題能夠讓你把新學到的知識鞏固一遍，能夠加深記憶，不會讓你在以后做題的時候感到沒一點思路。

當感覺到不會的時候，千萬不要氣餒，因為這很正常，現在的學習就是為了培養你有一個邏輯思維，為了以后開發軟件的時候有個完整，清晰的思路。

其實，總體來說。學習java很快樂。尤其是當你遇到一道自己不會的題，然后，又通過自己的努力解決了，那時候，那種心情不是用言語來表達的。就好像你遇到一個數學難題，自己解決了之后那種成就感一樣。

學java的時候一定要，放松心情，輕輕松松的來學，隨時讓自己快樂著，這樣能夠讓你能夠更快的接受java，千萬不要有什么心理負擔，因為java的特點之一就是--簡單易懂。只要自己努力到了，就一定能夠學好java。

學完了JAVA今天我們用項目案例：迷你DVD管理器來鞏固了我們所學的所有內容，通過這項目的操練，首先，1、項目用到了會使用順序、分支、循環、跳轉語句編寫程序，2、要會使用數組、操作字符串，3、會使用帶參的方法；

4、會定義類、創建和使用對象，看到這些腦袋里一片迷茫啊！不知道怎樣寫，然后想到早寫晚寫都一樣，就照著書上寫起來了，到現在還是弄不懂的就是那個對象數組，不知道怎樣去理解，抽象的把我抽暈了，有望老師來給我們補補這一章，在實現DVD的業務處理時，計算時差還是不懂，照著書上打了一遍，可還是得不到想要的結果，經過網上的搜尋與老師講解，現在已略懂一二了，在做完這項目后，真不知道當時是怎樣敲出來的，難道這就是所說的靈感！感覺很高興，現在已習慣了代碼報錯，其實代碼報錯是一件值得鼓勵的事，因為沒有錯就覺得自己什么都懂了，在學習中相信每一個人都遇到過挫折吧！但一定要想方法戰勝挫折！我的戰勝挫折方法就是不懂思考后還不懂就問，懂了以后就筆記本記下當時的解決方案！學習剛開始！后面的路很長，慢慢的去磨煉了！總結完畢！

第二篇：Java總結

Java實驗

1.調試HelloWorld程序

2.this,super,get ,set,把課本90頁程序4.7中的name改成私有變量

3.繼承，重寫，父類引用指向子類對象

4.驗證數組Arrays類和Collection類

5.編寫一個自己的異常類并捕獲之。

6.編寫一個類，將該類的幾個對象裝入TreeSet容器中，并將該容器的內容通過輸出流寫入文件中。

前三章重點

0.java的數據類型：四類八種-（1）布爾類型Boolean;(2)字符類型char;(3)整數byte,short,int,long;(4)浮點類型：float,double;1.面向對象的3個基本特征：封裝，繼承，多態。

2.構造方法和普通方法的區別：對構造方法而言，它有以下特性---（1）方法名必須與要創建對象的類名相同。（2）不允許聲明返回類型，即使聲明為void也不被允許。

3.this關鍵字:是一個引用，this引用指向的是其本身所在方法的當前對象。this的使用方法:(1)調用成員變量；（2）可以用this()調用其他構造函數。

4.java中只對類成員變量進行自動初始化，而方法內部的局部變量在使用前必須手動初始化。

5.static 關鍵字：可用來修飾類的成員變量和成員方法，需要注意兩點--（1）靜態方法不能調用類的非靜態方法，不能訪問類的非靜態變量。（2）靜態方法和靜態變量（非私有的）可以有兩種調用方式，一是實例對象調用，二是類名直接調用。

6.類成員訪問控制修飾符public、private、default(可不寫，即缺省狀態)、protected的使用：public-公用的；private-私有的，只在定義它的類內部使用；default-可以被同一包中的類訪問；protected-既可以被同一包中的類訪問，也可以被不在同一包中的子類訪問。

7.方法的重載：指方法名相同，而方法的參數列表不相同。參數列表不同有三層意思：（1）參數類型不同。（2）參數順序不同。（3）參數個數不同。另外需注意，在同一個類中，當方法名和參數列表都相同時，訪問控制修飾符或方法返回類型不相同并不是方法的重載，而且這種情況在java中是不被允許的。

第四五章重點

1.繼承：需使用關鍵字extends.在使用繼承時需注意--（1）每個子類只能定義一個超類（父類），即extends后面應且僅應跟一個類名作為該類的父類。（2）父類中的私有屬性和私有方法不能被繼承。

2.方法的重寫：即子類對超類中的方法保持方法名、返回類型和參數列表不變，重寫了方法體，使子類和超類完成不同的工作。重寫需注意下面幾個關鍵點：（1）超類中的私有方法不能被重寫。（2）訪問限制符強度由低到高依次是：public、protected、default、private,在重寫過程中，如果子類和父類中方法的返回值、方法名及方法的參數列表都相同，這時，要求子類中該方法的訪問限制符強度不能超過父類的。即如果父類中為public時，子類也只能為public,而不能是余下的三種。

3.重載（overload）和覆蓋（override）的區別：(1)重載—發生在一個類的內部或子類與父類之間，要求方法名相同而參數列表不一樣。（2）覆蓋—只能發生在繼承過程中，要求子類方法的返回類型，方法名和參數列表同父類的都相同，而方法體不一樣。

4.構造器的調用順序：先祖先，再客人，最后自己。

5.多態：指在類繼承中子類和父類中可以有同名但意義或實現方式不同的屬性和方法。分為：覆蓋和重載。多態的優點：因為多態，可以在程序中對類進行擴展，而不需改變那些操作基類接口的方法。

6.動態綁定：指在代碼執行期間，判斷所引用對象的實際類型，根據其實際類型調用相應方法。動態綁定存在的三個必要條件--（1）要有繼承；（2）要有重寫（覆蓋）；（3）父類引用指向子類對象（向上轉型）。

7.Object中常用的方法總結：toString();wait();equals();notify();notifyAll();hashCode();getClass();clone();finalize();（呵呵，盡可能記幾個，以防老師讓咱們列舉）注：java中Object類是所有類的父類，即java中所有的類都有上述9種方法。

8.對象的比較：注意關鍵字instanceof的使用。

9.抽象類：

抽象方法—用關鍵字abstract修飾的方法，該方法只需方法的聲明，而不需方法的實現（即無方法體）。

抽象類——至少包含一個抽象方法的類，也用abstract關鍵字聲明。（注：（1）抽象類中可以有一些具體方法。（2）抽象類不能實例化。（3）子類繼承抽象類必須實現其抽象方法。）

10.接口：

（1）可以看成是高度抽象的抽象類，但是接口不是類。

（2）用關鍵字interface來聲明接口，用關鍵字imlpements來實現接口。

（3）接口不能有具體方法，不能有實例數據，但可以定義常量。

（4）實現接口的非抽象類必須實現接口的所有方法。

（5）每個類可以實現多個接口，這些接口用逗號隔開，同時，一個接口可以被多個類實現。

第六章：重點看一下實驗四

1.容器——Collection(接口)和Map（接口）.Collection——Set(接口)和List(接口)。其中，List必須保持元素的特定順序，常見的實現類有ArrayList和LinkedList；Set不能有重復元素,常見的實現類有HashSet和TreeSet。

Map——一組成對的“鍵值對”對象，即其元素是成對的對象，常見的實現類有HashMap和TreeMap。

第七章 1.異常類的根類是Throwable類，它的兩個直接子類是Error類和Exception類。

2.異常中常用的5個關鍵字為：try,catch,finally,throw,throws.其中，try和catch:用于捕獲異常；finally:無論try塊中的異常是否拋出，finally中的代碼塊總能被執行；throw:拋出異常；throws：聲明異常。

3.“未被檢查的異常（Unchecked Exceptions）”和“受檢查的異常(Checked Exceptions)”——

Unchecked Exceptions :編譯器不檢查方法是否處理或拋出的異常，即不做處理，編譯時不報錯。

Checked Exceptions：受編譯器檢查的異常，即不做處理編譯時通不過。

4.常見的幾種Checked Exceptions：ClassNotFoundExceptionIOExceptionInterruptedExceptionFileNotFoundException.(盡可能的記幾個吧，以防不測)第八章

1.流--字節流和字符流；

流--節點流和處理流。

2.所有的輸入流都是從抽象類InputStream和Reader繼承而來。所有輸出流都是從抽象類OutputStream和Writer繼承而來。3．字節流：InputStream和OutputStream;字符流：Reader和Writer；

4.節點流：直接與文件等底層打交道，如FileInputStreamFileOutputStreamFileReaderFileWriter.處理流：相當于包裝流，套在節點流上，方便數據處理。相關一些用法，具體參考最后一次實驗。

第三篇：java總結

調用父類構造方法

? 在子類的構造方法中可使用super(argument_list)語句調用父類的構造方法

? 如果子類的構造方法中沒有顯示地調用父類構造方法，也沒有使用this關鍵字調用重載的其它構造方法，則系統默認調用父類無參數的構造方法

? 如果子類構造方法中既未顯式調用父類構造方法，而父類中又沒有無參的構造方法，則編譯出錯

1public class Person {

3private String name;

4private int age;private Date birthDate;

7public Person(String name, int age, Date d){ 8this.name = name;

9this.age = age;

10this.birthDate = d;

11}

12public Person(String name, int age){ 13this(name, age, null);

14}

15public Person(String name, Date d){ 16this(name, 30, d);

17}

18public Person(String name){

19this(name, 30);}

21// ……

22}

1public class Student extends Person {

2private String school;

4public Student(String name, int age, String s){ 5super(name, age);

6school = s;

7}

8public Student(String name, String s){

9super(name);

10school = s;

11}

12public Student(String s){ // 編譯出錯: no super()13school = s;

14}

15}

對象構造和初始化細節

? 分配存儲空間并進行默認的初始化

? 按下述步驟初始化實例變量

1.綁定構造方法參數

2.如有this()調用，則調用相應的重載構造方法，然后跳轉到步驟5

3.顯式或隱式追溯調用父類的構造方法(Object類除外)

4.進行實例變量的顯式初始化操作

5.執行當前構造方法的方法體

==操作符與equals方法

==操作符與equals方法的區別：

? 引用類型比較引用；基本類型比較值；

? equals()方法只能比較引用類型，“==”可以比較引用類型及基本類型；

? 特例：當用equals()方法進行比較時，對類File、String、Date及封裝類（Wrapper Class）來說，是比較類型及內容而不考慮引用的是否是同一個實例；

? 用“==”進行比較時，符號兩邊的數據類型必須一致(可自動轉換的基本數據類型除外)，否則編譯出錯；

由裝箱引發的——Integer比較的來龍去脈

前置知識： 眾所周之，java是保留了int，char等基本數據類型的，也就是說int類型的并不是對象，然而有些方法卻需要object 類型的變量，所以java使用了裝箱機制，我們可一自豪的這樣聲明一個整型變量：Integer a = new Integer(10);那么整型的a也就是對象了，那這句是什么意思呢：Integer a= 10;java中可以這樣聲明一個對象嗎？當然不是，從jdk1.5后，java實現了自動裝箱，也就是自動將Integer a =10 中的int類型的10轉化為了 Integer類型。好，有了前面的只是我們且先看一個題目：

Integer a = 127;

Integer b = 127;

Integer c = 128;

Integer d = 128;

System.out.println(a==b);

System.out.println(c==d);

答案是什么呢？ 如果您回答true，false，那么很遺憾的告訴你，哈哈，其實你答對了！！

那我們暈了就相差1的兩個數為啥走向了“反目成仇”的地步呢？憑啥127等于127，我128就不等于128呢？且聽我慢慢道來，Integer a =127,Integer a=128。

127，128應該不會造成什么差異吧，難道是自動裝箱的過程有貓膩？找下源碼看看：

private static class IntegerCache {

private IntegerCache(){}

static final Integer cache[] = new Integer[-(-128)+ 127 + 1];static {

for(int i = 0;i < cache.length;i++)

cache[i] = new Integer(i128);

}

這是用一個for循環對數組cache賦值，cache[255] = new Integer(255-128),也就是newl一個Integer(127),并把引用賦值給cache[255],好了，然后是Integer b= 127,流程基本一樣，最后又到了cache[255] = new Integer(255-128),這一句，那我們迷糊了，這不是又new了一個對象127嗎，然后把引用賦值給cache[255]，我們比較這兩個引用（前面聲明a的時候也有一個）,由于是不同的地址，所以肯定不會相等，應該返回false啊！呵呵，這么想你就錯了，請注意看for語句給cache[i]初始化的時候外面還一個{}呢，{}前面一個大大的static關鍵字大咧咧的杵在哪呢，對靜態的，那么我們就可以回想下static有什么特性了，只能初始化一次，在對象間共享，也就是不同的對象共享同一個static數據，那么當我們Integer b = 127的時候，并沒有new出一個新對象

來，而是共享了a這個對象的引用，記住，他們共享了同一個引用！！，那么我們進行比較a==b時，由于是同一個對象的引用（她們在堆中的地址相同），那當然返回true了！！

然后我們在看Integer c = 128;Integer d = 128;這兩句。現在不用我說就應該能明白了吧，當數據不再-128到127之間時，是不執行return

IntegerCache.cache[i + offset];這句的，也就是不會返回一個static的引用，而是執行了return new Integer(i);于是當 Integer d = 128 時，又會重新返回一個引用，兩個不同的引用

在做c==d 的比較時當然返回false了！

下面附上本程序的字節碼以供喜歡底層的讀者參考：

Compiled from “CompareInteger.java”

public class CompareInteger extends java.lang.Object{

public CompareInteger();

Code:

0:aload_0

1:invokespecial#1;//Method java/lang/Object.“”:()V4:return

public static void main(java.lang.String[]);

Code:

0:bipush 127

2:invokestatic#2;//Method

java/lang/Integer.valueOf:(I)Ljava/lang/Int

eger;

5:astore_1

6:bipush 127

8:invokestatic#2;//Method

java/lang/Integer.valueOf:(I)Ljava/lang/Int

eger;

11: astore_2

12: sipush 128

15: invokestatic#2;//Method

java/lang/Integer.valueOf:(I)Ljava/lang/Int

eger;

18: astore_3

19: sipush 128

22: invokestatic#2;//Method

java/lang/Integer.valueOf:(I)Ljava/lang/Int

eger;

25: astore 4

27: getstatic#3;//Field

java/lang/System.out:Ljava/io/PrintStream;

30: aload_1

31: aload_2

32: if_acmpne39

35: iconst_1

36: goto40

39: iconst_0

40: invokevirtual#4;//Method java/io/PrintStream.println:(Z)V43: getstatic#3;//Field

java/lang/System.out:Ljava/io/PrintStream;

46: aload_3

47: aload4

49: if_acmpne56

52: iconst_1

53: goto57

56: iconst_0

57: invokevirtual#4;//Method java/io/PrintStream.println:(Z)V60: return

}

評論：呵呵，這么想你就錯了，請注意看for語句給cache[i]初始化的時候外面還一個{}呢，{}前面一個大大的static關鍵字大咧咧的杵在哪呢，對靜態的，那么我們就可以回想下static有什么特性了，只能初始化一次，在對象間共享，也就是不同的對象共享同一個static數據，那么當我們Integer b = 127的時候，并沒有new出一個新對象來，而是共享了a這個對象的引用，記住，他們共享了同一個引用！！

呵呵，博主我被你這句話小小的誤導了一下，其實你這里說的原理沒錯，但是把位置說錯了，這段代碼只是初始化cache：

static {

for(int i = 0;i < cache.length;i++)

cache[i] = new Integer(i-128);

}

但真正讓cache[i]為static變量的是這句代碼：

static final Integer cache[] = new Integer[-(-128)+ 127 + 1];

第四篇：Java個人總結參考

1、Java中取消指針運算防止了內存泄露的可能性。Java中的引用其實就是指針。JAVA語言不支持C++友元方法或友類。

2、編寫完java源代碼后，首先將其編譯為一種中間狀態字的字節碼，然后Java虛擬機上的解釋器來解釋執行，“一次編程，到處運行”，Java是文本文件，編輯代碼。

3、Window系統對于DOS命令中字符大小寫不敏感；Java編譯器和解釋器對大小寫敏感；保存源文件時，文件名一定要和源文件中公開類的類名一致。

4、習慣上，變量名以小寫字母開頭，類名以大寫字母開頭，常量名中所有的字符均大寫。

5、final常量：初始化后不再重新賦值，在類繼承時不允許子類覆蓋。

6、類實例化就成為對象。

7、類繼承：繼承父類的屬性和方法（關鍵字extends）

定義抽象類：關鍵字abstract

類聲明：P62

類成員：P63

8、Java接口中聲明了一組抽象方法，它構成了實現該接口的不同類共同遵守的約定。在類的定義中可以用關鍵字implements來指定其實現的接口。

9、Java接口與類的重要區別：Java接口中不存在構建器。

10、包的作用（P105）；Java中類的訪問控制符（P77）；操作符優先級（P38）

11、包的命名：網絡域名的逆序

包的使用：關鍵字import

12、異常處理（P119.120.125）：FileNotFoundException：代表文件未找到；SQLException：代表有關JDBC的異常；NullPointerException：表示試圖引用null對象的方法或屬性；IndexOutOfBoundException：表示數組越界的異常。

13、框架的默認關閉程序：f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

14、setIconImage用于設定框架的圖標；setLocation用于設定框架在屏幕上的位置。

15、取得框架的內容窗格：Container contentPane=f.getContnetPane();

16、面板的默認布局管理器是FlowLayout。setBownds(x,y,w,h)設置x，y坐標以及寬和高

17、內容窗格的默認布局管理器是邊框布局（BorderLayout）

18、網格布局（GridLayout）將容器劃分為大小相同的網格。

19、網格袋布局（GridBagLayout）是最靈活，也是最復雜的布局管理器。20、對話框 P180

showMessageDialog：消息對話框

showInputDialog：輸入對話框

showConfirmDialog：確認對話框

showOptionDialog：選項對話框

21、類File有三種常用構建器：

File（String fileName）

File（String directory ,String fileName）File（File directory ,String fileName）

22、位于java.io包中的類包含兩組獨立的類層次結構：一個用于讀取字節，成為字節流；一個用于讀寫字符，稱為字符流。區別在于它們處理數據的方式，字節流按字節（一個8位組）來處理。字節流（P243）字符流（P245）

23、System.in 表示系統標準輸入流，指向鍵盤輸入；System.out 表示系統標準輸出流，指向屏幕輸出；System.err 表示系統標準錯誤輸出流，指向屏幕輸出；

24、文件的讀寫工作包括三個步驟：①、打開文件輸入流或輸出流；②、文件讀或寫操作；③、關閉文件輸入流或輸出流；

25、定制線程類：①、繼承線程類Thread；②、實現Runnable接口；

#約定俗成的命名規則#

1、類名首字母必須大寫

2、方法和屬性必須小寫

3、由多個單詞組成的類名或方法必須采用駝峰標識

如：類名：StudentAdmin 方法或屬性：studentName

*Equal 匹配

*equalIgnoreCase 匹配時忽略大小寫 *Indexof 包含

*getMetaDate 獲取元數據 *精度轉換

*面向對象三大特性：封裝、繼承、多態 *界面邏輯、業務邏輯、數據邏輯 *三層架構總結：

1、開發人員可以只關注整個結構中的其中某一層

2、可以很容易用新的實現來替換原有層次的實現

3、可以降低層與層之間的依賴

4、有利于標準化

5、利于各層邏輯的復用

第五篇：Java筆記總結

1、Java是一種可以編譯 跨平臺、面向對象的高級計算機語言。

2、Java語言的特點：簡單、安全、跨平臺、面向對象、支持多線程。

3、Java的三個技術平臺分別是 JavaSE、JavaEE、JavaME。

4、Java程序的運行環境簡稱為 JDK。

5、編譯Java程序需要使用 javac 命令。

6、javac.exe和java.exe這兩個可執行程序存放在JDK安裝目錄的bin目錄下。

7、PATH環境變量用來存儲Java的編譯和運行工具所在的路徑；CLASSPATH環境變量 則用來保存Java虛擬機要運行的“.calss”文件。

8、.class文件在 java.exe 文件啟動的JVM中運行。

9、JRE與JDK之間的區別：

a)JRE（Java Runtime Environment）提供java程序運行所需要的基本條件（如JVM）和許多基礎類。

b)JDK（Java Development Kit）是Java程序開發工具包——包含編譯工具、解釋工具、打包工具等開發工具。

10、JVM——Java虛擬機，相當于一個虛擬的操作系統，負責運行javac.exe生成的 字節碼（二進制）文件。java.exe執行”.class”，就是java.exe啟動JVM運行”.class”文件。

11、標識符命名規則：

a)包名所有字母一律小寫。

b)類名和接口名每個單詞首字母大寫。

c)常量名所有字母都大寫，單詞之間用下劃線分開。

d)變量名和方法名的第一個單詞小寫，之后的每個單詞首字母大寫。

12、強制類型轉換：

a)格式：目標類型 變量名 =（目標類型）值

b)int類型轉換成byte類型 很容易造成 精度丟失。因為int類型變量是32位，byte類型只有8位，所以在轉換過程中會丟失int類型的高3位字節。

c)在用”雙字符“型運算符（+=、-=之類的）運算時，強制類型會自動完成，不用程序顯示的聲明。

13、三元運算符：判斷條件？表達式1：表達式2；——若條件成立，執行表達式1，否則執行表達式2。

14、跳轉語句：

a)break：

i.用于switch語句，終止某case并跳出switch結構。ii.用于循環語句，跳出循環語句，執行后面的程序。

b)continue——只用于循環語句中：終止本次循環，執行下一次循環。

15、方法重載：

a)2個條件：方法名相同、參數個數或參數類型不同。b)與返回值類型無關。

16、數組：

a)定義數組：

i.類型[ ] 數組名 = new 類型[ 數組長度 ] //這種定義方式只指定了長度，元素的初值由系統自動賦0。（動態初始化）

ii.類型[ ] 數組名 = new 類型[ ]{元素，元素，......} iii.類型[ ] 數組名 = {元素，元素，......} //這2種稱為 靜態初始化。

17、冒泡排序：

a)若有n個元素，則進行n-1輪排序（n-1次外循環）

b)第1輪排序，元素之間進行n-1次比較；第2輪排序進行n-2次排序......最后1輪只進行1次比較。c)外循環條件：i < arr.length d)內循環條件：j < arr.length1

18、二維數組：

a)定義方式1：類型[ ][ ] 變量名 = new 類型[ 幾行 ][ 幾列 ];b)可理解為數組的 數組——例arr[0][1]-->數組名arr[0]，第二個元素[1];c)二維數組的 長度 由”[ 幾行 ]“確定！

d)定義方式2：類型[ ][ ] 變量名 = new 類型[ 幾行 ][ ];//行數確定，列數不確定——每行可以隨便 賦值。

e)定義方式3：類型[ ][ ] 變量名 = { { ,...,...,...}，{ }，{ }，......} //這種行數、列數都不確定。大括號 內的每個 大括號 代表 一行 的元素，每行有多少個元素 取決于 內大括號 中元素的個數。

19、面向對象的特點：封裝性、繼承性、多態性。

20、在創建變量后，JVM運行程序時，會自動初始化變量。引用型變量 為 null。

21、垃圾對象——沒有變量引用的對象。

22、類的封裝：將類中的屬性 私有化。外界訪問私有屬性時 只能通過該屬性的 getxxx（）方法。

a)//擇Generate getter and setter--> 自動生成

set和get方法。

23、構造方法：實例化對象。

a)可以用 帶參數的構造方法 在實例化對象時就 給私有屬性 賦值。b)好的程序員 應該為每個類 寫一個 無參構造方法。c)定義構造方法的條件：

i.方法名與類名相同。ii.沒有返回值的 聲明。

iii.方法中 不能有return 返回值。

24、this關鍵字

a)this指代 該類實例化的 對象。所以可以用 this.xx的方式調用 成員。b)在成員方法中使用this關鍵字，避免參數名與屬性名相同。c)用this關鍵字調用 構造方法

i.只能在構造方法中 用this調用其他構造方法； ii.此時this語句必須位于第1行，并且只能出現一次 iii.不能在一個類的兩個構造方法中互相調用。

25、static關鍵字

a)靜態變量：

i.用static修飾的變量 ii.靜態變量被所有實例共享

iii.可以使用“類名.變量名”的形式來訪問。iv.只能修飾 成員變量 b)靜態方法

i.希望在不創建對象的情況下也能條用 類中的 某個方法，那就用static關鍵字休息這個方法 ii.靜態方法 只能訪問 靜態成員！

//因為非靜態成員 必須先創建對象才能訪問，而靜態方法在被調用的時候可以 不創建對象——那么就沒有非靜態成員可供訪用。

c)靜態代碼塊

i.當類被加載時，靜態代碼會執行一次。而類只會被加載一次，所以靜態代碼塊只會被執行一次。

ii.通常會用靜態代碼塊對類的成員變量進行初始化。d)單例模式

i.private static 類名 INSTANCE = new 類名();量——自己創建一個對象。private 類名(){};

//私有的 構造方法，只能內部訪問

}

//私有成員變public static 類名 getInstance(){ return INSTANCE;//定義靜態方法，返回自己的實例對象。ii.第二種單例模式創建方法。

1.Private 類名(){} 調用。

2.public static fianl 類名 INSTANCE = new 類名();的不能被修改的 靜態成員對象。

26、內部類——定義在類里面的 類

a)成員內部類

i.相當于成員方法，可以訪問外部類的所有成員；

ii.因為成員內部類相當于 成員方法，所以想要創建內部類對象時，必須得用外部類的對象 去創建內部類對象：

1.外部類名.內部類名 變量名 = new 外部類名().new 內部類名();b)靜態內部類

i.用static修飾的成員內部類，也相當于靜態方法。只能訪問外部類的靜態成員。

ii.因為靜態，所以在創建內部類對象時，可以不用先創建外部類對象：

1.外部類名.內部類名 變量名 = new 外部類名.內部類名();iii.靜態內部類中 可以定義靜態成員，非靜態內部類則不可。c)方法內部類

i.在方法中定義的類，只能在當前方法中被使用。

27、當一個對象被當成垃圾從內存中釋放時，它的 finalize（）方法會被自動調用。

//公有

//私有的 構造方法，只能在類的內部被

28、繼承

a)繼承關鍵字：extends。b)格式：Class A extends B{} c)單繼承——一個類只能有一個直接父類。

29、重寫父類方法

a)條件：方法名、參數、返回值類型 3個都相同。

b)重寫之后，子類調用被重寫的方法時，就是調用自己寫的方法。c)重寫應用：

i.應用對象 是父類的 公有方法。重載 應用的對象是 類本身的 方法。ii.重寫父類 不適合子類的 方法 iii.實現接口。

30、super關鍵字

a)調用父類成員變量和成員方法：

i.super.成員變量;ii.super.成員方法（參數1,參數2,...）;b)調用父類的構造方法

i.super（參數1,參數2,...）;ii.必須位于子類的構造方法的第一行，且只能出現一次。

iii.在實例化子類時，系統會在 子類的構造方法中 調用

父類的構造方法——如果子類的構造方法中 沒有調用 父類的構造方法，系統會自動調用父類的無參構造方法。所以 每個類的 無參構造方法 一定不要漏了！子類也可以顯示的調用 父類的有參或無參構造法方法。c)解決 重寫了父類方法之后，不能調用父類方法的問題。

31、final關鍵字

a)final修飾的類 不能被繼承 b)final修飾的方法 不能被子類重寫

c)final修飾的變量 是常量，不能被修改，且必須在定義時 為變量賦值。

32、抽象類

a)關鍵字 abstract b)抽象方法：abstract void shout（）{}；——沒有方法體。

c)包含抽象方法的類必須聲明為 abstract類：abstract class Animal{} d)抽象類可以 不包含任何抽象方法，只需用abstract修飾。e)抽象方法不能直接實例化，只能讓 子類實例化。

33、接口

a)定義關鍵字：interface——interface Animal{} b)接口中的方法 被默認修飾為：public abstract——抽象方法。c)接口中的變量 被默認修飾為 :public static final —— 全局常量

i.所以變量最好用

全大寫

表示。

d)因為方法都是抽象的，所以必須定義一個類 來實現（implements）接口——Class A implements B{} e)接口之間可以繼承——interface C extends B{} f)一個類可以實現多個接口，接口直接間用逗號隔開。g)一個類可以在繼承一個類的同時，實現其它的接口。

h)如果一個類去實現接口的話，那么這個類必須實現接口中所有的方法。

34、多態

a)方法上的多態

i.類內部方法的重載 ii.子類對父類方法的重寫 b)對象上的多態性

i.假設父類：A；子類B B b = new B();ii.對象的自動向上轉型：A a = b;//子類對象，變成了父類對象。

1.雖然a指向A的對象，但是如果B重寫了A的方法，那a調用的還是B中的方法。

iii.對象的強制向下轉型

1.若 A a = new A();2.B b =(B)a;

//父類對象變成了 子類對象。3.這時對象b調用的是 子類的重寫的方法。

4.注意：對象發生強制向下轉型之前，必須保證已經發生了向上轉型，否則會出異常。

35、異常

a)異常類分為：編譯時異常、運行時異常 b)異常處理機制： i.try...catch...finally 1.try代碼包含可能發生異常的Java語句，catch塊中包含針對一場進行處理的代碼。

2.當發生異常時，系統將異常信息封裝成一個異常對象傳遞給catch代碼塊。所以catch需要定義1個對應的異常類 變量。3.finally代碼塊包含，無論發生什么異常都要執行的代碼。常用于關閉系統資源。

ii.throws關鍵字聲明拋出異常，調用者對其處理。這種方法能通過編譯，但是發生異常后就會終止運行。

c)自定義異常

i.首先定義 一個繼承Exception異常的 異常類；異常類中 編寫一個無參構造方法（調用父類無參構造方法），再編寫一個 帶String參數的構造方法（也調用父類的帶Stirng參數的構造方法）。ii.再定義一個 測試類，定義要調用的方法，并在此方法后面用 throws關鍵字 聲明拋出自定義異常；再在 方法體 內判斷什么時候 用throw new 自定義異常（“要打印的信息”）。//聲明自定義異常對象。

iii.最后在 測試類的main 方法中，iv.try{...}

catch(...){ System.out.printlan(e.getMessage)}

finally{...}

36、線程的創建： a)繼承Thread類，并重寫run（）方法。然后new Thread（）.start;開啟線程。

b)實現Runnable接口，重寫run（）方法。然后new Thread（new myRunnable）.start開啟線程。

37、兩種實現多線程的比較——實現Runnable接口的方法更好

a)可以讓多個線程共享資源。——售票系統需要。b)避免單繼承。38、36、