《JAVA學習指南》學習筆記

第二章宣告和控制訪問

1.原始檔，包宣告，匯入語句規範（省略）。

2.格式化 main（）方法例項：

class Myclass{

public static void main{String whatever} { }

}

3.interface介面設計：介面=合約。規則：

a.所有介面方法隱含為公有的和抽象的。

b.介面中的變數必須是公有的，最終的，靜態的，即只能是常量(只讀值)，不能是例項變數。

public final static int LOW_VALUE =1;

c.JAVA類只可以擴充套件一個類，但是可以實現多個介面（C++能extend多個類，即為 c++的多型繼承）：

public class bus extend car interface bounceable ,serieable{

}

d.介面可以擴充套件別的介面，但是不能設計任何內容（不能修改父類中的任何內容）：

public class bounceable extern moveable{

}

第三章運算子和賦值

1.賦值：

1.1 原始賦值：兩個byte資料相加型別為int ;byte a =byte_b +byte_c; (錯誤)

1.2 引用變數賦值：Button b =new Button();

2.原始轉換：隱含轉換、顯式轉換（=C++的強制轉換）:short a =(short)b;

當擴充套件轉換髮生時會出現隱含轉換；當需要縮小轉換時需要顯示轉換。

3.傳遞物件引用變數：void dostaff( Foo g) { g =new Fool() ; }相當於對被傳遞的 g物件進行重定義。

4.變數就像一個具有指定型別的位容器。

第四章流程控制和異常處理、斷言

1.標號的for while迴圈 break continue語句： break outer;

2.異常層次結構：

3.斷言機制：assert(i<1);

a.assert作為關鍵字，不可用作標示符。

b.斷言可以被開啟，也可以關閉，預設為被禁用的（關閉）

啟用：java -ea/-enableassertions com.geeksamnoymous.Testclass

禁用：java -da/-disableassertions com.geeksamnoymous.Testclass

第五章物件導向、過載和重寫、建構函式及返回型別

1.HAS-A IS-A 的關係。

2.重寫與過載的關係。

重寫方法不能有比被重寫方法限制更嚴格的訪問修飾符，public >protect>private.

重寫方法要比被重寫方法丟擲更少或者更有限的異常。

重寫方法和被重寫方法需要相同的形參，相同的返回值型別。

過載需要不同的形參列表，可以改變返回值型別，訪問修飾符，不同的異常。

過載只不過是名稱重用，

3.建構函式：

4.合法返回的型別，原則：

第六章 java.lang—Math類、字串和封裝器

java.lang類，基礎類，自動匯入，不需import。

1.String類（靜態的，不變的）

a.語法：

String s =new String{“abcdef”};String物件–字串定義及初始化；

String s = “abcdef”;

String物件是不變的，但是其引用物件不是的，可以引用不同的值：

s =s.concat{“more ref”}; 與 s.concat{“more ref”}; 兩個語句完全不同；

b.成員方法：public char charAt(int index);…

2.StringBuffer類（可擦寫的，變化的，重複賦值的）
a.重要方法：

public synochonized StringBuffer append(String s);…

3.Math類:

abs;ceil;floor;max;random;round;sin;cos;tan;sqrt;toDegree;toRadians;

4.封裝器類：

Boolean;

Byte;

Charater;

Double;

Float;

Integer;

Long;

Short;

Interger i1 =new Integer{42};

Interger i1 =new Integer{“42”};

5.封裝器類的轉換功能：

xxxValue;

parseXxx;

valueOf;

toString;

toXxxString;String s3 =Integer.toHexString{254};

6.equal()比較方法概述:(只比較物件，返回布林值，ture.false,)

比較變數；引用變數比較equal()；原始變數比較==;

比較物件：equal()：x1.equal(x2);

第七章物件和集合

1.Object 的類部分方法：

equals(Object obj)

finalize() 不能被使用的物件，垃圾蒐集器。。。

hashCode() 表示物件的雜湊程式碼int的值??

notify() 喚醒正在等待該物件鎖定的一個執行緒

notifyAll()

wait()

toString() 返回物件的文字表示。

2.重寫equals():

物件比較，必須要重寫此方法，因為不同型別的物件，比較的KEY VALUE都是有差異的：eg:

if((o instanceof Moof) && (((Moof) o).getMoofvalue()= this.moofValue))

{ return true;}

else

{ return false;}

a.equals() toString() haseCode() 都是公有的，注意是要重寫，不是過載；

b.equals()約定：

自反性，對稱性；可傳遞性；一致性；x.equals(null)應該返回false。

3.重寫haseCode()-----設計思想參考資料結構的雜湊表機制。(難點)

a.雜湊碼----物件的ID號。HashMap HashSet；

如果兩個物件相等，它們的雜湊碼也必須相等。

提高搜尋速度是雜湊碼設計的預定目標。

b.設計hashCode()

class HasHash{

public int x;

HasHash{int xVal}{

x =xVal;}

public boolean equals{ Object o}{

HasHash h =(HasHash) o;

if(h.x ==this.x){

return true; }

else{

return false; }

}

public int hasCode{} {

return (x *17); }

}

4.集合 (Java.util中的 Collections Framework)

a.集合的操作：

物件新增到集合；集合中刪除物件；查詢一個物件是否位於集合中；

從集合中檢索物件；遍歷集合，一個一個的查詢每個元素（物件）。

b.集合架構的主要介面和類：

核心介面：Collection ;Set ;Sorted Set ;LIst; Map ;Sorted Map.

核心具體設計類：

HashMap ; HashSet ; ArrayList ; Hashtable ; LinkedHashSet ; Vector;

TreeMap ; TreeSet ; LinkedLIst; LinkedHashMap .

具體架構關係示意圖：

c.集合的三種基本形式：Lists ;Maps :Sets.

d.分類和排序

e.集合具體設計類的特徵對比描述:

5.垃圾蒐集

a.基礎概念：

Java的垃圾蒐集器為記憶體管理提供的一種自動解決方案，缺點是不能完全控制它什麼時候執行以及什麼時候不執行。

使用記憶體時，通常處理棧、堆，Java中的常量池和方法區域。

堆是Java物件所在的記憶體部分，堆是垃圾蒐集器處理的所涉及的一個也是唯一一塊記憶體。

當沒有任何活執行緒能夠訪問一個物件時，該物件就符合垃圾蒐集條件。

b.編寫程式碼使物件符合垃圾蒐集條件

空引用：StringBuffer sb;…; sb =null; //sb符合垃圾蒐集條件

重新為引用變數賦值：StringBuffer a =“hello”;StringBuffer b =“world”; a =b ; //"hello"符合垃圾蒐集條件

隔離引用：隔離島、物件島：一組物件，相互引用，但是任何活執行緒都無法訪問他們，即它們與外界隔離。

c.強制執行垃圾蒐集請求
Runtime物件為直接和虛擬機器通訊提供了一種機制。Runtime.getRuntime();返回Runtime物件Singleton.

垃圾蒐集的最簡單的方法：System.gc();

d.垃圾蒐集前進行清理–finalize()方法

Java提供的一種機制，可以使物件在被垃圾蒐集刪除之前執行某些程式碼。這些程式碼位於finalize()方法中；

由於垃圾蒐集沒有做出任何保證，放入類重寫方法中的finalize() 任何程式碼無法保證執行，建議不要放入任何實質程式碼；

finalize()方法的兩點特性：

對於任何指定物件，finalize()方法只會被執行一次；

呼叫finalize()方法，編寫某個物件的引用傳遞給另外一個物件，可以有效避免其被垃圾蒐集器刪除。

6.Java 2中的高階垃圾蒐集

a.引用類派生於抽象類Reference，是更復雜的記憶體管理，是WeakReference（弱引用）的子類，WeakReference和

PhantomReference 類位於Java.lang.ref包中；

b.引用排序：

強引用（預設引用為強引用）：軟引用：弱引用：幻影引用：

c.物件排序：

強可到達：軟可到達：弱可到達：幻影可到達：不可到達：

第八章內部類

1.編寫”常規“內部類程式碼：

a.例項化內部類方法：

從外部類程式碼內例項化內部類；

從外部類例項程式碼之外建立內部類物件；(如果想建立內部類例項，必須先建立外部類例項)

MyOuter mo =new MyOuter();

MyOuter.MyInner inner =mo.new MyInner();

或者：

MyOuter.MyInner inner =new MyInner().new MyInner();

b.從內部類中引用內部或者外部例項：

引用內部類自身： this

從內部類程式碼內引用(外部 this、外部類例項），使用.this

2.方法本地內部類

方法本地內部類只能在定義該內部類的方法內例項化。

內部類不能使用該內部類所在方法的區域性變數，除非該變數定義為final。

3.匿名內部類

a.第一種形式的普通舊匿名內部類：(建立指定型別類的子類)

class Popcorn {

public void pop(){ System.out.printIn(“popcortn”) ;}

}

Class Food{

Popcorn p =new Popcorn() {

public void pop()｛

System.out.printIn(“annoyymous popcortn”) ;}

public void sizeze()｛

System.out.printIn(“annoyymous sizeze”) ;}

} ;//如果再內部類引用上呼叫父類定義中沒有的方法，編譯器都會報錯。

} ;//匿名內部類:定義新類為 Popcorn的子類，重寫pop()方法。賦值給物件p.

public void pop()｛

p.pop(); //success

p.sizeze();//fail //如果再內部類引用上呼叫父類定義中沒有的方法，編譯器都會報錯。

}

}

b.第二種形式的普通舊匿名內部類：(建立指定介面型別的匿名設計類)

c.引數定義的匿名內部類

class MyWonderfulClass{

void go() {

Bar b =new Bar();

b.doStuff(new Foo() {

public void foof () {

System.out.printIn(“foofy”); }

});

}

}

interface Foo {

void foof();

}

class Bar {

void doStuff(Foo f){ }

}

4.靜態巢狀類(頂級巢狀類/靜態內部類)：

靜態類的內部成員，不是一個內部類；

因為是靜態的，所以不需要封裝類的任何例項；不和封裝類的任何例項共享一種特殊的關係。

class BigOuter {

static class Nested {}

}

class Broom {

public static void main(String [] args) {

BigOuter.Nested n =new BigOuter.Nested();

}

第九章執行緒

1.定義、例項化和啟動執行緒：Java.lang.Thread.

a.基礎概念：

一個Thread例項----其實是一個物件。

呼叫棧和執行緒一一對應著。

Java.lang.Thread的重要方法：

start()

yield()

sleep()

run()

b.定義執行緒\例項化執行緒\啟動執行緒：

擴充套件Thread類：

class MyThread extends Thread {

public void run (){

System.out.printIn(“abc 0”);

}

public void run (String s){

System.out.printIn("String in run is "+s);}

}

MyThread t =new MyThread();//例項化執行緒

t.start();//啟動執行緒

重寫run()方法、設計java.lang.Runnable：

class MyRunnable implements Runnable {

public void run() {

System.out.printIn(“abc”);}

}

MyRunnable r =new MyRunnable();/./例項化執行緒

Thread tt = new Thread® ;

tt.start();//啟動執行緒

Thread 建構函式：

Thread()

Thread(Runnable target)

Thread(Runnable target,String name)

Thread(String name)

Thread(ThreadGroup group,Runnable target)

Thread(ThreadGroup group,Runnable target ,String name)

Thread(ThreadGroup group,String name)

c.啟動執行緒：

啟動和執行多個執行緒：一旦執行緒死去，將永遠無法重新啟動。

執行緒排程程式：可執行執行緒被選擇執行的順序是沒有保障的。

執行緒狀態：

2.阻止執行緒執行:

sleep(); 因為靜態的，一個執行緒不能讓另外的執行緒睡眠。當sleep() 呼叫時，是讓當前正在執行的執行緒睡眠。

yield(); 靜態的，使當前執行的執行緒回到可執行狀態，以讓具有相同優先順序的執行緒獲得執行機會

join(); 非靜態的，讓一個執行緒加入另一個執行緒的尾部。

a.睡眠:

Thread.sleep(5601000);//靜態方法//sleep for 5s

b.執行緒的優先順序和讓步:

設定執行緒的優先順序：

t.setPriority(8);

Thread.MIN_PRIORITY (1)

Thread.NORM_PRIORITY (5)

Thread.MAX_PRIORITY (10)

c.其他三種情況可能使執行緒離開執行狀態：

run();

在物件上呼叫wait();

執行緒不能在物件上獲得鎖定，它正試圖執行該物件的方法程式碼。

3.同步程式碼

使用同步等待、通知和通知所有的編寫程式碼，以保護併發訪問和執行緒之間的通訊。

private synchronizedvoid makeWithdrawal(){//使用同步，可以避免查詢和取款被打斷，保持為原子操作。

if(acc.getBalance()>= amt){

System.Out.printIn(Thread.currentThread.getName()+“is goning to withdraw”);

try {

Thread.sleep(500); }

acct.withdraw(amt);

System.Out.printIn(Thread.currentThread.getName()+“complete withdraw”);}

else {

System.Out.printIn(Thread.currentThread.getName()+"not enough cash "); }

}

}

a.同步和鎖定

同步通過鎖定來工作；

JAVA的每個物件都有唯一一個內建鎖；當一個執行緒獲得該鎖，其他執行緒就無法進入被同步的程式碼，直到鎖被釋放。

可以同步方法，也可以同步程式碼塊，不能同步變數。

阻塞：如果執行緒試圖進入同步方法，但是其鎖已經被鎖定，則說該執行緒在物件鎖上被阻塞。

b.執行緒死鎖

如果兩個執行緒被阻塞，每個執行緒都在等待對方的鎖時，就發生死鎖。

如果發生死鎖，程式就死掉。

4.執行緒互動

定義當執行同步等待、通知和通知所有時執行緒和物件鎖之間的互動。???//待細讀。。。

wait();

notify(); //單執行緒等待時使用

notifyAll();//當多個執行緒等待時使用

第十一章編碼標準

1.間隔標準：縮排、行長度、換行和間距。

2.正確處理大括號

3.註釋說明：隱藏註釋。

4.宣告：順序、位置和初始化、大寫。避免影子變數。

第十二章清晰性和可維護性

1.常規程式設計風格注意事項。

變數範圍儘可能小；

避免設計沒有方法的類；

使用設計模型；

儘可能降低內容可見性；

使用過載而不是邏輯；

避免長引數列表；

不要從建構函式呼叫可能重寫的方法；

編寫介面程式碼；

當需要繼承的時候使用抽象類；

使完成的物件符合垃圾蒐集條件；

不要超過需要建立太多的物件；

避免深度巢狀和複雜邏輯；

使用符合JavaBean命名規範的讀取器和設定器；

不要做物件導向領域的程式導向的程式設計師：避免使用大而全的大功能類（程式導向的思想）

儘可能時變數和類成為自解釋型；

使用核心API；

如果找不到需要的異常類，就開發自己的異常類；

不要返回錯誤程式碼；

使異常具備字串建構函式引數；

2.遵守基本的物件導向的設計原則：

隱藏實現細節；

使用合適的類粒度；

限制再分子類；

使用合適的方法粒度；

使用封裝；

隔離可能改變的程式碼；

3。不要重新開發輪子

使用核心API；

使用標準設計模型；

4、正確的處理錯誤

不要返回錯誤程式碼；

不要傳送太多的命令列訊息；

在適當的地方使用對話方塊；

正確的丟擲檢查異常；

合適的建立和丟擲自己的異常；

捕獲低階實現異常，而要丟擲高階業務異常；

是自己定製的異常類具有一個String建構函式(以獲得詳細資訊)；

永遠不要吃掉異常；

宣告所以異常，而不只是它們的子型別。

第十三章設計圖形使用者介面

1.建立可用、可擴充套件的GUI：

對終端使用者，設計為可用的，友好的；

對開發，設計為可靠的，可維護性的；

a.Swing元件，Jtable元件;

b.模型-檢視-控制器（MVC: Model-View-Controller）

c.錯誤處理、監聽器和內部類

3.使用案例和業務功能

4.良好的螢幕設計原則：

平衡和混亂

邏輯組和工作流

導航和命令

5.選擇什麼元件：(Swing元件/Jtable元件)

6.專案的螢幕佈局

7.選單和導航

8.訊息、反饋和對話方塊

9.GUI中怎樣使用顏色

10.怎麼樣測試GUI：

設計測試：專案設計階段，和客戶共同定義，反覆修改

程式碼測試：編碼階段完成後，測試

原文：https://blog.csdn.net/cbk861110/article/details/7768696