● 初始化和清除是程序設計安全性的兩個最重要的問題

● 創建對象時：1.分配空間    2.調用構造函數對這個對象進行初始化    3.然后把初始化完了對象交給那個引用

● 重載
在日常生活中，我們用相同的詞表達多種不同的含義，即詞的“重載”。
大多數程序設計語言要求我們為每個函數都設定一個獨一無二的標識符。
但是構造函數的出現要求函數名也要能夠“重載”。
即函數名相同，參數不同的構造函數
使用時各自調用不同的參數構造函數。

構造函數名與類名相同

● 缺省構造函數
如果一個類沒有定義構造函數，則編譯程序會幫我們自動創建一個缺省構造函數。
但是一旦定義了一個，就不會幫我們自動生成一個。

● this
this關鍵字可以為已調用了其方法的那個對象生成相應的句柄。
調用這個函數的那個對象--this，即這個函數要作用在哪個對象之上。
在一個構造函數中可以調用一次另一個構造函數，用this(參數)

● 垃圾收集機制
垃圾收集機制只知道怎樣釋放由new分配的內存，所以它不知道如何釋放對象的“特殊”內存。一旦垃圾收集機制準備好釋放對象中占用的存儲空間，他首先調用finalize()。
finalize() 由Object定義

在構造函數內只進行基本的初始化

定義初始化：
一個直接的做法是在定義數據成員的同時也為其賦值
可以調用一個方法進行初始化
在構造函數之前就進行定義初始化

用一個類創建類的對象時，先分配一個空間，依次做成員變量的定義初始化，再調用構造函數。

● 靜態數據初始化
靜態的東西屬于類。
類Class與類對象。
如果一個變量是一個靜態變量的話，所有對象里的這個變量的值是同一個。
靜態數據成員只在這個類的第一個對象要創建的時候初始化（裝載這個類的時候）。

運行java命令后，啟動jvm，找到類的定義文件，找到類的定義文件之后，裝載；裝載完成之后在內存里形成了一個類對象來代表這個類，然后要對這個類對象里的靜態成員變量進行初始化

初始化順序
1.類型為Dog的一個對象首次創建時，或者Dog類的靜態方法/數據首次訪問時，Java解釋器必須找到Dog.class。
2.找到Dog.class后，它的所有的靜態初始化模塊都會運行。因此，靜態初始化僅發生一次。
3.創建一個new Dog()時，new語句首先會在堆里分配一個足夠的空間。
4.這個空間將會被清除為零，因此Dog中所有的數據成員都得到了缺省值。
5.執行定義初始化。
6.執行構造函數。
先靜態后動態；先定義初始化后構造函數。

● 顯式初始化
靜態初始化塊，地位相當于一條靜態初始化語句
定義初始化塊，地位相當于一條定義初始化語句

● 數組
數組代表一系列對象或者基本數據類型，所有相同類型的對象都封裝在一起——采用一個統一的標識符名稱。
數組變量實際上是一個指向數組的句柄（引用），所以推薦使用int[] a這樣的書寫方式
通常情況下java的數組通過new出來： a1=new int[5]，表示a1是一個引用，指向一個int型數組
使用length

對象數組
對于對象數組，數組的成員實際上是句柄（對象的引用）
對象數組也可以定義初始化
Integer i;   i 為對對象的引用

● 隱藏實施過程——訪問控制
面向對象程序設計的一個概念：隱藏盡可能多的東西
庫創建者應聲明哪些是客戶程序員可以使用的，哪些是不可一使用的

● 包：庫單元
用import來引入包或包里的成員。
import java.util.*;    java.util 表示包名  *號表示包里的所有類
import java.util.Vector;      類的全名
目的是在所有對象范圍內唯一的標識一個類
之所以要這樣的引入，是為了提供一種特殊的機制，來實現命名空間的管理

● 編譯單元
每個編譯單元必須是以.java結尾的文件名稱，在一個編譯單元里，可以有一個 public的類，這個類的名字必須與文件的名字相同。在一個單元內，可以有多個類，但只能有一個public的類。
編譯一個.java文件時，對應于文件中的每一個類，會得到一個.class文件，文件名與類的名字相同。一個程序是一堆.class文件。

● 定義包
一個庫是一堆這樣的.class文件，它們被定義為一個包，但是并不真正地合并在一個文件中。
包沒有什么管理機制，包只要聲明就可以了
   package mypackage;
   public class MyClass;  //MyClass這個類就屬于mypackage這個包
現在，如果客戶程序員想要使用MyClass，就要用import來引入mypackage包，或者是使用MyClass的全名。
    import mypackage;    //引入mypackage包
    MyClass m = new MyClass(); mypackage.MyClass m = new mypackage.MyClass();
//使用MyClass的全名

rt.jar   java基礎類庫的所有包
使用jar命令來查看   |more

● CLASSPATH
-  .表示當前目錄     d:";.  d盤根下是一個搜索的根
- CLASSPATH包含一個或多個目錄，它們作為一種特殊的根使用，從這里展開對.class文件的搜索

● 類成員的訪問屬性
“Friendly” （缺省包）
public: 界面訪問 (accessor/mutator)
private: 不能接觸!
protected: "某種友好"  包內可以訪問，子類也可以訪問。子類和父類不在一個包的情況下。

● 類的訪問控制
一個編譯單元（文件）中只能有一個public的類。因此一個編譯單元只有一個唯一的公共界面，其余的類都是"friendly"的。 public類的名字必須和文件的名字一樣。
可以，盡管很少見，一個編譯單元沒有一個public類，所有的類都是"friendly"的，那么文件名可以任意起。

● 繼承
class ThisClass extends SuperClass {
??? //??? class body
}
ThisClass是第三人稱彈數，extend要加s---extends

● 傳遞構造參數
先初始化父類的部分，在初始化自己的
-缺省構造函數
-super(…)  調用父類的一個構造函數并且傳遞參數

● 初始化和類的裝載
-先父類靜態，后子類靜態
-先父類定義初始化，父類構造函數
-后子類定義初始化，子類構造函數

● Upcasting
-子類和父類之間的關系是： The new class is a type of the existing class.
-Upcasting是安全的.

● Method call binding
-早綁定（靜態綁定））  晚綁定（動態綁定）
-Java中所有的綁定都是晚綁定，除了final的方法
-早綁定有早綁定的優點，晚綁定有晚綁定的優點。但是，晚綁定帶來了多態性。
-多態性就是把一個子類的對象當作父類的對象來看待，然后讓它執行父類所能執行的函數。
靜態綁定：若方法類型為priavte static final 編譯器會準確知道該調用哪個方法
動態綁定：是很重要的特性,它能使程序變得可擴展而不需要重編譯已存代碼

● 多態性
多態性就是指父類的某個方法被其子類重寫時，可以各自產生自己的功能行為

● final
final : This cannot be changed
-final for data
-final for methods
-final for a class

● Final data
-只能被賦值一次的變量
-可以看作是常量
final Value v2 -- final的Value類的引用v2，final保護了對象的引用v2不被改變（這個引用的本身不能被改變）但是Value所指的對象是可以改變的

● Final Methods
-有兩種final方法：
1.在方法上加上一把鎖，防止繼承者改變它的意義。
2.編譯器把對該方法的調用變成inline（嵌入）調用。
-Private is Final，不存在override問題

● Final classes
-Final classes是不允許被繼承的。為防止他人從你的類上派生新類，此類是不可擴展的。主要是安全上的作用。

● abstract類和abstract方法（抽象類和抽象方法）
可以定義某個類是抽象的（只制造概念）
-一個類的作用僅僅是表達接口，而不是具體的實現細節
-抽象的方法是不完全的，它只是一個聲明，沒有方法體
-包含一個抽象方法的類被稱作抽象類
-不能制造抽象類的對象
-從抽象類繼承的類必須override所有父類的抽象方法，否則子類本身成為一個抽象類
-可以聲明一個抽象類但是里面沒有一個抽象方法
關鍵字abstract定義抽象類
做這樣類的目的是禁止產生這樣類的對象

abstract類不能用new運算符創建對象，必須產生其子類，由子類創建對象。
對于abstract方法，只允許聲明，而不允許實現
如果一個類是一個abstract類的子類，它必須具體實現父類的abstract方法
如果一個類中含有abstract方法，那么這個類必須用abstract來修飾（abstract也可以沒有abstract方法）
一個abstract類只關心它的子類是否具有某種功能，而不關心功能的具體行為，功能的具體行為由子類負責實現

● Interface 
——totally abstract class（完全抽象的類）
-Interface在java中的地位和class一樣  可以繼承
-Interface沒有body（也沒有構造函數），只表達概念  
-在Interface中所有的方法都是public的，即使你沒有聲明它是public的。
-在Interface中所有的數據成員都是public static final的，即使你沒有聲名。但不能是blank final
使用implements，表示實現了什么功能
-Interface編譯后也生成一個class文件。其實Interface也是class，只不過是一種完全抽象的類

● 實現interface
-實現interface的類，其interface中所有的方法必須被“實現”，否則這個類成為一個抽象類。
-所有實現interface中的方法必須被申明為public
-Interface可以從多個Interface得到繼承，但是不能繼承類。

-為了克服單繼承的缺點，Java使用了接口，一個類可以實現多個接口
-接口體中只進行方法的聲明，不許提供方法的實現，所以，方法的定義沒有方法體，且用分號結尾
-一個類通過使用implements聲明自己使用一個或多個接口，如使用多個接口，用逗號隔開接口名
- 要注意的是，接口中的方法被默認是public的，所以類在實現接口方法時，一定要用public來修飾。另外，如接口方法的返回類型不是void的，那 么在類中實現該接口方法時，方法體至少要有一個return語句；如果是void型，類體除了兩個大括號外，也可以沒有任何語句。
-Java為我們提供的接口都在相應的包中，通過引入包可以使用Java提供的接口，也可以自己定義接口，一個Java源文件就是由類和接口組成的。

● Inner class（內部類）
-In Java 1.1, it is possible to place a class definition within another class definition.
-所謂內部類就是定義在另外一個類內部的類（某個類的定義，在另一個類的內部）
 新的消息機制需要有一個類能夠訪問另外一個類的私有成員
 為了解決因為多類類同時繼承一個很小的類時，所帶來的命名問題。
-什么是使用一個類或訪問一個類：用這個類去制造對象
-類里面除了有成員變量、成員函數，還有成員類，實際上內部類可以稱之為成員類，成員類也具有成員函數和成員變量一樣的屬性。成員類可以訪問私有變量，成員類里面的所有的成員函數可以訪問內部類外面那個類的所有私有變量。
-內部類什么時候被初始化？編譯時生成幾個class文件？
 每個內部類生成一個class文件

1.一個內部類的對象能夠訪問創建它的對象的實現，包括私有數據
2.對于同一個包中的其他類來說,內部類能夠隱藏起來
3.匿名內部類可以很方便的定義回調
4.使用內部類可以非常方便的編寫事件驅動程序

● Private inner class
Inner classes可以完全被封閉起來，不被外界所看到

● Why inner classes?
兩個理由要在方法和scope中定義inner class:
-我們準備實現某種形式的interface，使自己能創建和返回一個句柄。
-要解決一個復雜的問題，并希望創建一個類，用來輔助自己的程序，同時不愿意把類的細節公開。

在函數里面定義的類都加一個數字（序號），從1開始
有變量有函數就是一個類，這個類沒有名字，是匿名類，生成一個“父類名$序號”的class文件
子類送參數給父類的構造函數：在子類的構造函數里用super

如何讓內部類訪問外部類，被訪問的
匿名類沒有名字，也就沒有構造函數，定義初始化塊相當于匿名類的構造函數

● Outter class?
inner classer擁有訪問外部類的所有成員的能力，這是使用inner類的主要理由

父類與子類函數與函數之間的關系，如果函數名相同，參數表相同，則構成override的關系。
私有的為靜態綁定
inner class 與 inner class 之間不會構成override關系。

● Exception機制處理
但是如果你完全檢查任何時刻的錯誤，你的代碼就會變成無法閱讀的夢魘。
所有的函數調用的返回值都要判斷，但是可能發生由于嵌套過多而造成代碼閱讀和維護困難，所以java里使用了try...catch，每一個catch針對一種錯誤，將事務邏輯與錯誤處理分開
-使用異常機制，讀、寫和調試代碼變得清晰。它把處理錯誤的代碼和正常的代碼分開。

● Throw an exception
-throw new NullPointerException();
-throw new NullPointerException("HERE!");
異常發生時，你不能解決問題，所以必須扔(throw)出一個異常。
1.一個異常對象建立起來了。
2.當前運行的路徑被停止，異常對象被彈出(eject)。
3.異常處理機制接管，開始尋找一個合適的地方來繼續執行。

● Catch an exception
Java的異常機制的好處就在于它使我們在一個地方將精力集中在要解決的問題上，而在另一個地方處理來自那部分代碼的異常情況。
  try {      //   code that may make exception
  } catch ( Type1 id1) {
  } catch ( Type2 id2) {
  }
catch的匹配不是一種精確匹配，只要這個對象是那個類的對象就可以了
catch不管再多，只需滿足一個就結束了。

● Catch all kind of exception
一個捕捉任何異常的捕捉器是一個捕捉基本類型異常的捕捉器。
catch ( Exception e) {
 System.out.println("caught an exception")
}
捕捉任何異常的catch

● Interface: Throwable
String getMessage();
String toString();
void printStackTrace();
void printStackTrace(PrintStream);

● Re-throwing
catch (Exception e) {
 throw e;
}
-關于fillInStackTrace()
-也可以拋出一個與接收到的異常不同的異常

● Announce for exception
通知客戶程序員自己寫的方法中可能拋出什么樣的異常是一種文明的做法。
 void f() throws tooBig, tooSmall, oldStyle { // Body of f() }
如果你要從你的方法中拋出某種異常，你必須申明。
但是你可以撒謊申明你并不真正拋出的異常。

● Override of exception
當你override一個方法，你只能申明和拋出不比它的父類版本中申明的異常多的異常

● finally