JAVA的面向對象編程--------課堂筆記
面向對象主要針對面向過程。
面向過程的基本單元是函數。
什麼是對象：EVERYTHING IS OBJECT（萬物皆對象）
所有的事物都有兩個方面：
有什麼（屬性）：用來描述對象。
能夠做什麼（方法）：告訴外界對象有那些功能。
後者以前者爲基礎。
大的對象的屬性也可以是一個對象。
爲什麼要使用面向對象：
首先，面向對象符合人類看待事物的一般規律。
對象的方法的實現細節是屏蔽的，只有對象方法的實現者瞭解細節。
方法的定義非常重要。方法有參數，也可能有返回值。
注意區分：對象（本身）、對象的實現者、對象的調用者。
分析對象主要從方法開始。
我們通過類來看待對象，類是對象的抽象。
其次，採用面向對象方法可以使系統各部分各司其職、各盡所能。
對象之間的耦合性一定要低（比如不同硬盤和不同主板之間的關係）。這樣才能使每個對象本身做成最好的。
對於對象的要求：高內聚、低耦合，這樣容易拼裝成爲一個系統。
實現高內聚就是要最大限度低提高複用性（複用性好是因爲高內聚）。
可複用性是OOP的基礎。
比較面向過程的思想和麪向對象的思想：
面向過程的思想：由過程、步驟、函數組成，以過程爲核心；
面向對象的思想：以對象爲中心，先開發類，得到對象，通過對象之間相互通信實現功能。
面向過程是先有算法，後有數據結構。
面向對象是先有數據結構，然後再有算法。
在用面向對象思想開發的過程中，可以複用對象就進行復用，如無法進行復用則開發新的對象。
開發過程是用對個簡單的對象的多個簡單的方法，來實現複雜的功能 。
從語法上來看，一個類是一個新的數據類型。
在面向對象編程中，除了簡單數據類型，就是對象類型。
定義類的格式：
class Student{
代碼
}
注意類名中單詞的首字母大寫。
實例變量：定義在類中但在任何方法之外。（New出來的均有初值）
局部變量：定義在方法之中的變量。
局部變量要先賦值，再進行運算，而實例變量均已經賦初值。這是局部變量和實例變量的一大區別。
實例變量的對象賦值爲null。
局部變量不允許範圍內定義兩個同名變量。實例變量的作用域在本類中完全有效，當被其他的類調用的時候也可能有效。
實例變量和局部變量允許命名衝突。
書寫方法的格式：
修飾符 返回值 方法名 調用過程中 方法體
可能出現的例外
public int/void addNumber(參數) throw Excepion {}
例：
public int addNumber(int a,int b){
}
注：方法名中的參數int a,int b爲局部變量
類方法中的一類特殊方法：構造方法。
構造方法是當用類生成對象時，系統在生成對象的過程中利用的方法。
注意：構造方法在生成對象的時候會被調用，但並不是構造方法生成了對象。
構造方法沒有返回值。格式爲：public 方法名。
構造方法的方法名與類名相同。
構造方法是在對象生成的過程中自動調用，不可能利用指令去調用。
在一個對象的生成周期中構造方法只用一次，一旦這個對象生成，那麼這個構造方法失效。
用類來生成對象的語句：
Student s=new Student()。
第一個Student表示這是用Student類進行定義。“Student()”表示調用一個無參數的構造方法。
如果()中有參數，則系統構造對象的過程中調用有參的方法。
此時S稱爲一個對象變量。
Student s的存儲區域存放的是地址：一個對象在硬盤上佔有一個連續地址，首地址賦予s空間。
S稱爲對象Student的引用。
注意：在對象變量中存放的是引用（地址）；在簡單變量中存放的是數值。
可以構造多個構造方法，但多個構造方法的參數表一定不同，參數順序不同即屬於不同的構造方法：
public student(string name,int a){
}
public student(int a,string name){
}
爲兩個不同的構造方法。
如果我們未給系統提供一個構造方法，那麼系統會自動提供一個爲空的構造方法。
練習：寫一個類，定義一個對象，定義兩個構造方法：一個有參，一個無參。
（編寫一個程序驗證對象的傳遞的值爲地址）
注意下面這種形式：
static void changename(student stu){stu.setName “LUCY”}
注意生成新的對象與舊對象指向無關，生成新對象生命消亡與舊對象無關。
面向對象方法的重載（overloading）和覆蓋（overriding）。
在有些JAVA書籍中將overriding稱爲重載，overloading稱爲過載。
Overloading在一個類中可以定義多個同名方法，各個方法的參數表一定不同。但修飾詞可能相同，返回值也可能相同。
在程序的編譯過程中根據變量類型來找相應的方法。因此也有人認爲 overloading是編譯時的多態，以後我們還會學到運行時多態。
爲什麼會存在overloading技術呢？作爲應對方法的細節。
利用類型的差異來影響對方法的調用。
吃（）可以分爲吃肉，吃菜，吃藥，在一個類中可以定義多個吃方法。
構造方法也可以實現overloading。例：
public void teach(){};
public void teach(int a){};
public void teach(String a){}爲三種不同的方法。
Overloading方法是從低向高轉。
Byte—short—float—int—long—double。
在構造方法中，this表示本類的其他構造方法：
student(){};
student(string n){
this();//表示調用student()
}
如果調用student(int a)則爲this(int a)。
特別注意：用this調用其他構造方法時，this必須爲第一條語句，然後纔是其他語句。
This表示當前對象。
Public void printNum(){
Int number=40；
System.out.println(this.number);
}
此時打印的是實例變量，而非局部變量，即定義在類中而非方法中的變量。
This.number表示實例變量。
誰調用this.number那麼誰即爲當前(this)對象的number方法。
封裝：使對象的屬性儘可能私有，對象的方法儘可能的公開。用private表示此成員屬性爲該類的私有屬性。
Public表示該屬性（方法）公開；
Private表示該屬性（方法）爲只有本類內部可以訪問（類內部可見）。
（想用private還要用set和get方法供其他方法調用，這樣可以保證對屬性的訪問方式統一，並且便於維護訪問權限以及屬性數據合法性）
如果沒有特殊情況，屬性一定私有，方法該公開的公開。
如果不指明誰調用方法，則默認爲this。
區分實例變量和局部變量時一定要寫this。
11.29
繼承：
父類（SuperClass）和 子類（SonClass）。
父類的非私有化屬性和方法可以默認繼承到子類。
Class Son extends Father{
}
而如果父類中的私有方法被子類調用的話，則編譯報錯。
父類的構造方法子類不可以繼承，更不存在覆蓋的問題。（非構造方法可以）
如果子類訪問父類的構造方法，則在編譯的時候提示訪問不到該方法。
JAVA中不允許多繼承，一個類有且只有一個父類（單繼承）。
JAVA的數據結構爲樹型結構，而非網狀。（JAVA通過接口和內部類實現多繼承）
方法的覆蓋（overriding）
方法的重載並不一定是在一個類中：子類可以從父類繼承一個方法，也可以定義一個同名異參的方法，也稱爲overloading。
當子類從父類繼承一個無參方法，而又定義了一個同樣的無參方法，則子類新寫的方法覆蓋父類的方法，稱爲覆蓋。（注意返回值類型也必須相同，否則編譯出錯。）
如果方法不同，則成重載。
對於方法的修飾詞，子類方法要比父類的方法範圍更加的寬泛。
父類爲public，那麼子類爲private則出現錯誤。
之所以構造方法先運行父類再運行子類是因爲構造方法是無法覆蓋的。
以下範圍依次由嚴到寬：
private ：本類訪問；
default ：表示默認，不僅本類訪問，而且是同包可見。
Protected：同包可見+不同包的子類可見
Public ：表示所有的地方均可見。
當構造一個對象的時候，系統先構造父類對象，再構造子類對象。
構造一個對象的順序：（注意：構造父類對象的時候也是這幾步）
① 遞歸地構造父類對象；
② 順序地調用本類成員屬性賦初值語句；
③ 本類的構造方法。
Super()表示調用父類的構造方法。
Super()也和this一樣必須放在第一行。
This()用於調用本類的構造方法。
如果沒有定義構造方法，那麼就會調用父類的無參構造方法，即super()。
要養成良好的編程習慣：就是要加上默認的父類無參的構造方法。
思考：可是如果我們沒有定義無參的構造方法，而在程序中構造了有參的構造方法，那麼如果方法中沒有參數，那麼系統還會調用有參的構造方法麼？應該不會。
多態：多態指的是編譯時類型變化，而運行時類型不變。
多態分兩種：
① 編譯時多態：編譯時動態重載；
② 運行時多態：指一個對象可以具有多個類型。
對象是客觀的，人對對象的認識是主觀的。
例：
Animal a=new Dog()；查看格式名稱；
Dog d=(Dog)a。聲明父類來引用子類。
（思考上面的格式）
運行時多態的三原則：（應用時爲覆蓋）
1、 對象不變；（改變的是主觀認識）
2、 對於對象的調用只能限於編譯時類型的方法，如調用運行時類型方法報錯。
在上面的例子中：Animal a=new Dog()；對象a的編譯時類型爲Animal，運行時類型爲dog。
注意：編譯時類型一定要爲運行時類型的父類（或者同類型）。
對於語句：Dog d=(Dog)a。將d強制聲明爲a類型，此時d爲Dog()，此時d就可以調用運行時類型。注意：a和d指向同一對象。
3、 在程序的運行時，動態類型判定。運行時調用運行時類型，即它調用覆蓋後的方法。
關係運算符：instanceof
a instanceof Animal;(這個式子的結果是一個布爾表達式)
a爲對象變量，Animal是類名。
上面語句是判定a是否可以貼Animal標籤。如果可以貼則返回true，否則返回false。
在上面的題目中： a instanceof Animal返回 True，
a instanceof Dog也返回 True，
instanceof用於判定是否將前面的對象變量賦值後邊的類名。
Instanceof一般用於在強制類型轉換之前判定變量是否可以強制轉換。
如果Animal a=new Animal()；
Dog d=Dog()a;
此時編譯無誤，但運行則會報錯。
Animal a=new Dog()相當於下面語句的功能：
Animal a=getAnimal()；
Public static Animal.getAnimal;
Return new Dog()；
封裝、繼承、多態爲面向對象的三大基石（特性）。
運行時的動態類型判定針對的是方法。運行程序訪問的屬性仍爲編譯時屬性。
Overloading針對的是編譯時類型，不存在運行時的多態。
習題：建立一個shape類，有circle和rect子類。
Shape類有zhouchang()和area()兩種方法。
（正方形）squ爲rect子類，rect有cha()用於比較長寬的差。
覆蓋時考慮子類的private及父類的public（考慮多態），之所以這樣是避免調用A時出現實際調用B的情況。而出現錯誤。
11.29下午講的是教程上的Module6
Module6-7包括：面向對象高級、內部類、集合、反射（暫時不講）、例外。
面向對象高級、集合和例外都是面向對象的核心內容。
面向對象高級： 修飾符：
static:①可修飾變量（屬性）；②可修飾方法；③可修飾代碼塊。
Static int data語句說明data爲類變量，爲一個類的共享變量，屬於整個類。
Int data爲實例變量。
例：
static int data;
m1.data=0;
m1.data++的結果爲1,此時m2.data的結果也爲1。
Static定義的是一塊爲整個類共有的一塊存儲區域，其發生變化時訪問到的數據都時經過變化的。
其變量可以通過類名去訪問：類名.變量名。與通過訪問對象的編譯時類型訪問類變量爲等價的。
Public static void printData(){}
表明此類方法爲類方法（靜態方法）
靜態方法不需要有對象，可以使用類名調用。
靜態方法中不允許訪問類的非靜態成員，包括成員的變量和方法，因爲此時是通過類調用的，沒有對象的概念。This.data是不可用的。
一般情況下，主方法是靜態方法，所以可調用靜態方法，主方法爲靜態方法是因爲它是整個軟件系統的入口，而進入入口時系統中沒有任何對象，只能使用類調用。
覆蓋不適用於靜態方法。
靜態方法不可被覆蓋。（允許在子類中定義同名靜態方法，但是沒有多態，嚴格的講，方法間沒有多態就不能稱爲覆蓋）
當static修飾代碼塊時（注：此代碼塊要在此類的任何一個方法之外），那麼這個代碼塊在代碼被裝載進虛擬機生成對象的時候可被裝載一次，以後再也不執行了。
一般靜態代碼塊被用來初始化靜態成員。
Static通常用於Singleton模式開發：
Singleton是一種設計模式，高於語法，可以保證一個類在整個系統中僅有一個對象。
11.30
final可以修飾類、屬性、方法。
當用final修飾類的時候，此類不可被繼承，即final類沒有子類。這樣可以用final保證用戶調用時動作的一致性，可以防止子類覆蓋情況的發生。
當利用final修飾一個屬性（變量）的時候，此時的屬性成爲常量。
JAVA利用final定義常量（注意在JAVA命名規範中常量需要全部字母都大寫）：
Final int AGE=10；
常量的地址不可改變，但在地址中保存的值（即對象的屬性）是可以改變的。
Final可以配合static使用。 ？
Static final int age=10；
在JAVA中利用public static final的組合方式對常量進行標識（固定格式）。
對於在構造方法中利用final進行賦值的時候，此時在構造之前系統設置的默認值相對於構造方法失效。
常量（這裏的常量指的是實例常量：即成員變量）賦值：
①在初始化的時候通過顯式聲明賦值。Final int x=3；
②在構造的時候賦值。
局部變量可以隨時賦值。
利用final定義方法：這樣的方法爲一個不可覆蓋的方法。
Public final void print(){}；
爲了保證方法的一致性（即不被改變），可將方法用final定義。
如果在父類中有final定義的方法，那麼在子類中繼承同一個方法。
如果一個方法前有修飾詞private或static，則系統會自動在前面加上final。即private和static方法默認均爲final方法。
注：final並不涉及繼承，繼承取決於類的修飾符是否爲private、default、protected還是public。也就是說，是否繼承取決於這個方法對於子類是否可見。
Abstract(抽象)可以修飾類、方法
如果將一個類設置爲abstract，則此類必須被繼承使用。此類不可生成對象，必須被繼承使用。
Abstract可以將子類的共性最大限度的抽取出來，放在父類中，以提高程序的簡潔性。
Abstract雖然不能生成對象，但是可以聲明，作爲編譯時類型，但不能作爲運行時類型。
Final和abstract永遠不會同時出現。
當abstract用於修飾方法時，此時該方法爲抽象方法，此時方法不需要實現，實現留給子類覆蓋，子類覆蓋該方法之後方法才能夠生效。
注意比較：
private void print(){}；此語句表示方法的空實現。
Abstract void print()； 此語句表示方法的抽象，無實現。
如果一個類中有一個抽象方法，那麼這個類一定爲一個抽象類。
反之，如果一個類爲抽象類，那麼其中可能有非抽象的方法。
如果讓一個非抽象類繼承一個含抽象方法的抽象類，則編譯時會發生錯誤。因爲當一個非抽象類繼承一個抽象方法的時候，本着只有一個類中有一個抽象方法，那麼這個類必須爲抽象類的原則。這個類必須爲抽象類，這與此類爲非抽象衝突，所以報錯。
所以子類的方法必須覆蓋父類的抽象方法。方法才能夠起作用。
只有將理論被熟練運用在實際的程序設計的過程中之後，才能說理論被完全掌握！
爲了實現多態，那麼父類必須有定義。而父類並不實現，留給子類去實現。此時可將父類定義成abstract類。如果沒有定義抽象的父類，那麼編譯會出現錯誤。
Abstract和static不能放在一起，否則便會出現錯誤。（這是因爲static不可被覆蓋，而abstract爲了生效必須被覆蓋。）
例：（本例已存在\CODING\abstract\TestClass.java文件中）
public class TestClass{
public static void main(String[] args){
SuperClass sc=new SubClass();
Sc.print();
}
Abstract class SuperClass{
Abstract void print();}
}
class SubClass extends SuperClass(){
void print(){
System.out.println(“print”);}
}
JAVA的核心概念：接口（interface）
接口與類屬於同一層次，實際上，接口是一種特殊的抽象類。
如:
interface IA{
}
public interface：公開接口
與類相似，一個文件只能有一個public接口，且與文件名相同。
在一個文件中不可同時定義一個public接口和一個public類。
一個接口中，所有方法爲公開、抽象方法；所有的屬性都是公開、靜態、常量。
一個類實現一個接口的格式：
class IAImple implements IA{
};
一個類實現接口，相當於它繼承一個抽象類。
類必須實現接口中的方法，否則其爲一抽象類。
實現中接口和類相同。
接口中可不寫public，但在子類中實現接口的過程中public不可省。
（如果剩去public則在編譯的時候提示出錯：對象無法從接口中實現方法。）
注：
① 一個類除繼承另外一個類，還可以實現接口；
class IAImpl extends java.util.Arrylist implement IA{}
繼承類 實現接口
這樣可以實現變相的多繼承。
② 一個類只能繼承另外一個類，但是它可以繼承多個接口，中間用“，”隔開。
Implements IA,IB
所謂實現一個接口，就是指實現接口中的方法。
③ 接口和接口之間可以定義繼承關係，並且接口之間允許實現多繼承。
例：interface IC extends IA,IB{};
接口也可以用於定義對象
IA I=new IAImpl();
實現的類從父類和接口繼承的都可做運行時類型。
IAImple extends A implement IA,IB
IB I=new IAImple();
I instance of IAImple;
I instance of A;
I instance of IA;
I instance of IB;
返回的結果均爲true.
接口和多態都爲JAVA技術的核心。
接口往往被我們定義成一類XX的東西。
接口實際上是定義一個規範、標準。
① 通過接口可以實現不同層次、不同體系對象的共同屬性；
通過接口實現write once as anywhere.
以JAVA數據庫連接爲例子：JDBC制定標準；數據廠商實現標準；用戶使用標準。
接口通常用來屏蔽底層的差異。
②接口也因爲上述原因被用來保持架構的穩定性。
JAVA中有一個特殊的類： Object。它是JAVA體系中所有類的父類（直接父類或者間接父類）。
此類中的方法可以使所的類均繼承。
以下介紹的三種方法屬於Object:
(1) finalize方法：當一個對象被垃圾回收的時候調用的方法。
(2) toString():是利用字符串來表示對象。
當我們直接打印定義的對象的時候，隱含的是打印toString()的返回值。
可以通過子類作爲一個toString()來覆蓋父類的toString()。
以取得我們想得到的表現形式，即當我們想利用一個自定義的方式描述對象的時候，我們應該覆蓋toString()。
(3)equal
首先試比較下例：
String A=new String(“hello”);
String A=new String(“hello”);
A==B(此時程序返回爲FALSE)
因爲此時AB中存的是地址，因爲創建了新的對象，所以存放的是不同的地址。
附加知識：
字符串類爲JAVA中的特殊類，String中爲final類，一個字符串的值不可重複。因此在JAVA VM（虛擬機）中有一個字符串池，專門用來存儲字符串。如果遇到String a=”hello”時（注意沒有NEW，不是創建新串），系統在字符串池中尋找是否有”hello”，此時字符串池中沒有”hello”，那麼系統將此字符串存到字符串池中，然後將”hello”在字符串池中的地址返回a。如果系統再遇到String b=”hello”，此時系統可以在字符串池中找到 “hello”。則會把地址返回b，此時a與b爲相同。
String a=”hello”;
System.out.println(a==”hello”);
系統的返回值爲true。
故如果要比較兩個字符串是否相同（而不是他們的地址是否相同）。可以對a調用equal:
System.out.println(a.equal(b));
equal用來比較兩個對象中字符串的順序。
a.equal(b)是a與b的值的比較。
注意下面程序：
student a=new student(“LUCY”,20);
student b=new student(“LUCY”,20);
System.out.println(a==b);
System.out.println(a.equal(b));
此時返回的結果均爲false。
以下爲定義equal（加上這個定義，返回ture或false）
public boolean equals(Object o){
student s=(student)o;
if (s.name.equals(this.name)&&s.age==this.age)
else return false;
}如果equals()返回的值爲
以下爲實現標準equals的流程：
public boolean equals(Object o){
if (this==o) return trun; //此時兩者相同
if (o==null) return false;
if (! o instanceof strudent) return false; //不同類
studeng s=(student)o; //強制轉換
if (s.name.equals(this.name)&&s.age==this.age) return true;
else return false;
}
以上過程爲實現equals的標準過程。
練習：建立一個employee類，有String name,int id,double salary.運用get和set方法，使用toString，使用equals。
封裝類：
JAVA爲每一個簡單數據類型提供了一個封裝類，使每個簡單數據類型可以被Object來裝載。
除了int和char，其餘類型首字母大寫即成封裝類。
轉換字符的方式：
int I=10;
String s=I+” ”;
String s1=String.valueOf(i);
Int I=10;
Interger I_class=new integer(I);
看javadoc的幫助文檔。
附加內容：
“==”在任何時候都是比較地址，這種比較永遠不會被覆蓋。
程序員自己編寫的類和JDK類是一種合作關係。（因爲多態的存在，可能存在我們調用JDK類的情況，也可能存在JDK自動調用我們的類的情況。）
注意：類型轉換中double\interger\string之間的轉換最多。
12.01
內部類：
（注：所有使用內部類的地方都可以不用內部類，使用內部類可以使程序更加的簡潔，便於命名規範和劃分層次結構）。
內部類是指在一個外部類的內部再定義一個類。
內部類作爲外部類的一個成員，並且依附於外部類而存在的。
內部類可爲靜態，可用PROTECTED和PRIVATE修飾。（而外部類不可以：外部類只能使用PUBLIC和DEFAULT）。
內部類的分類：
成員內部類、
局部內部類、
靜態內部類、
匿名內部類（圖形是要用到，必須掌握）。
① 成員內部類：作爲外部類的一個成員存在，與外部類的屬性、方法並列。
內部類和外部類的實例變量可以共存。
在內部類中訪問實例變量：this.屬性
在內部類訪問外部類的實例變量：外部類名.this.屬性。
成員內部類的優點：
⑴內部類作爲外部類的成員，可以訪問外部類的私有成員或屬性。（即使將外部類聲明爲PRIVATE，但是對於處於其內部的內部類還是可見的。）
⑵用內部類定義在外部類中不可訪問的屬性。這樣就在外部類中實現了比外部類的private還要小的訪問權限。
注意：內部類是一個編譯時的概念，一旦編譯成功，就會成爲完全不同的兩類。
對於一個名爲outer的外部類和其內部定義的名爲inner的內部類。編譯完成後出現outer.class和outer$inner.class兩類。
（編寫一個程序檢驗：在一個TestOuter.java程序中驗證內部類在編譯完成之後，會出現幾個class.）
成員內部類不可以有靜態屬性。（爲什麼？）
如果在外部類的外部訪問內部類，使用out.inner.
建立內部類對象時應注意：
在外部類的內部可以直接使用inner s=new inner();（因爲外部類知道inner是哪個類，所以可以生成對象。）
而在外部類的外部，要生成（new）一個內部類對象，需要首先建立一個外部類對象（外部類可用），然後在生成一個內部類對象。
Outer.Inner in=Outer.new.Inner()。
錯誤的定義方式：
Outer.Inner in=new Outer.Inner()。
注意：當Outer是一個private類時，外部類對於其外部訪問是私有的，所以就無法建立外部類對象，進而也無法建立內部類對象。
② 局部內部類：在方法中定義的內部類稱爲局部內部類。
與局部變量類似，在局部內部類前不加修飾符public和private，其範圍爲定義它的代碼塊。
注意：局部內部類不僅可以訪問外部類實例變量，還可以訪問外部類的局部變量（但此時要求外部類的局部變量必須爲final）？？
在類外不可直接生成局部內部類（保證局部內部類對外是不可見的）。
要想使用局部內部類時需要生成對象，對象調用方法，在方法中才能調用其局部內部類。
③ 靜態內部類：（注意：前三種內部類與變量類似，所以可以對照參考變量）
靜態內部類定義在類中，任何方法外，用static定義。
靜態內部類只能訪問外部類的靜態成員。
生成（new）一個靜態內部類不需要外部類成員：這是靜態內部類和成員內部類的區別。靜態內部類的對象可以直接生成：
Outer.Inner in=new Outer.Inner()；
而不需要通過生成外部類對象來生成。這樣實際上使靜態內部類成爲了一個頂級類。
靜態內部類不可用private來進行定義。例子：
對於兩個類，擁有相同的方法：
People
{
run();
}
Machine{
run();
}
此時有一個robot類：
class Robot extends People implement Machine.
此時run()不可直接實現。
注意：當類與接口（或者是接口與接口）發生方法命名衝突的時候，此時必須使用內部類來實現。
用接口不能完全地實現多繼承，用接口配合內部類才能實現真正的多繼承。
④ 匿名內部類（必須掌握）：
匿名內部類是一種特殊的局部內部類，它是通過匿名類實現接口。
IA被定義爲接口。
IA I=new IA(){};
注：一個匿名內部類一定是在new的後面，用其隱含實現一個接口或實現一個類，沒有類名，根據多態，我們使用其父類名。
因其爲局部內部類，那麼局部內部類的所有限制都對其生效。
匿名內部類是唯一一種無構造方法類。
匿名內部類在編譯的時候由系統自動起名Out$1.class。
如果一個對象編譯時的類型是接口，那麼其運行的類型爲實現這個接口的類。
因匿名內部類無構造方法，所以其使用範圍非常的有限。
（下午：）Exception（例外/異常）（教程上的MODEL7）
對於程序可能出現的錯誤應該做出預案。
例外是程序中所有出乎意料的結果。（關係到系統的健壯性）
JAVA會將所有的錯誤封裝成爲一個對象，其根本父類爲Throwable。
Throwable有兩個子類：Error和Exception。
一個Error對象表示一個程序錯誤，指的是底層的、低級的、不可恢復的嚴重錯誤。此時程序一定會退出，因爲已經失去了運行所必須的物理環境。
對於Error錯誤我們無法進行處理，因爲我們是通過程序來應對錯誤，可是程序已經退出了。
我們可以處理的Throwable對象中只有Exception對象（例外/異常）。
Exception有兩個子類：Runtime exception（未檢查異常）
非Runtime exception（已檢查異常）
（注意：無論是未檢查異常還是已檢查異常在編譯的時候都不會被發現，在編譯的過程中檢查的是程序的語法錯誤，而異常是一個運行時程序出錯的概念。）
在Exception中，所有的非未檢查異常都是已檢查異常，沒有另外的異常！！
未檢查異常是因爲程序員沒有進行必要的檢查，因爲他的疏忽和錯誤而引起的異常。一定是屬於虛擬機內部的異常（比如空指針）。
應對未檢查異常就是養成良好的檢查習慣。
已檢查異常是不可避免的，對於已檢查異常必須實現定義好應對的方法。
已檢查異常肯定跨越出了虛擬機的範圍。（比如“未找到文件”）
如何處理已檢查異常（對於所有的已檢查異常都要進行處理）：
首先了解異常形成的機制：
當一個方法中有一條語句出現了異常，它就會throw（拋出）一個例外對象，然後後面的語句不會執行返回上一級方法，其上一級方法接受到了例外對象之後，有可能對這個異常進行處理，也可能將這個異常轉到它的上一級。
對於接收到的已檢查異常有兩種處理方式：throws和try方法。
注意：出錯的方法有可能是JDK，也可能是程序員寫的程序，無論誰寫的，拋出一定用throw。
例：public void print() throws Exception.
對於方法a，如果它定義了throws Exception。那麼當它調用的方法b返回異常對象時，方法a並不處理，而將這個異常對象向上一級返回，如果所有的方法均不進行處理，返回到主方法，程序中止。（要避免所有的方法都返回的使用方法，因爲這樣出現一個很小的異常就會令程序中止）。
如果在方法的程序中有一行throw new Exception()，返回錯誤，那麼其後的程序不執行。因爲錯誤返回後，後面的程序肯定沒有機會執行，那麼JAVA認爲以後的程序沒有存在的必要。
對於try……catch格式：
try {可能出現錯誤的代碼塊} catch(exception e){進行處理的代碼} ；
對象變量的聲明
用這種方法，如果代碼正確，那麼程序不經過catch語句直接向下運行；
如果代碼不正確，則將返回的異常對象和e進行匹配，如果匹配成功，則處理其後面的異常處理代碼。（如果用exception來聲明e的話，因爲exception爲所有exception對象的父類，所有肯定匹配成功）。處理完代碼後這個例外就完全處理完畢，程序會接着從出現異常的地方向下執行（是從出現異常的地方還是在catch後面呢？利用程序進行驗證）。最後程序正常退出。
Try中如果發現錯誤，即跳出try去匹配catch，那麼try後面的語句就不會被執行。
一個try可以跟進多個catch語句，用於處理不同情況。當一個try只能匹配一個catch。
我們可以寫多個catch語句，但是不能將父類型的exception的位置寫在子類型的excepiton之前，因爲這樣父類型肯定先於子類型被匹配，所有子類型就成爲廢話。JAVA編譯出錯。
在try，catch後還可以再跟一子句finally。其中的代碼語句無論如何都會被執行（因爲finally子句的這個特性，所以一般將釋放資源，關閉連接的語句寫在裏面）。
如果在程序中書寫了檢查（拋出）exception但是沒有對這個可能出現的檢查結果進行處理，那麼程序就會報錯。
而如果只有處理情況（try）而沒有相應的catch子句，則編譯還是通不過。
如何知道在編寫的程序中會出現例外呢
1． 調用方法，查看API中查看方法中是否有已檢查錯誤。
2． 在編譯的過程中看提示信息，然後加上相應的處理。
Exception有一個message屬性。在使用catch的時候可以調用：
Catch(IOException e){System.out.println(e.message())};
Catch(IOException e){e.printStackTrace()};
上面這條語句回告訴我們出錯類型所歷經的過程，在調試的中非常有用。
開發中的兩個道理：
①如何控制try的範圍：根據操作的連動性和相關性，如果前面的程序代碼塊拋出的錯誤影響了後面程序代碼的運行，那麼這個我們就說這兩個程序代碼存在關聯，應該放在同一個try中。
② 對已經查出來的例外，有throw(積極)和try catch（消極）兩種處理方法。
對於try catch放在能夠很好地處理例外的位置（即放在具備對例外進行處理的能力的位置）。如果沒有處理能力就繼續上拋。
當我們自己定義一個例外類的時候必須使其繼承excepiton或者RuntimeException。
Throw是一個語句，用來做拋出例外的功能。
而throws是表示如果下級方法中如果有例外拋出，那麼本方法不做處理，繼續向上拋出。
Throws後跟的是例外類型。
斷言是一種調試工具（assert）
其後跟的是布爾類型的表達式，如果表達式結果爲真不影響程序運行。如果爲假系統出現低級錯誤，在屏幕上出現assert信息。
Assert只是用於調試。在產品編譯完成後上線assert代碼就被刪除了。
方法的覆蓋中，如果子類的方法拋出的例外是父類方法拋出的例外的父類型，那麼編譯就會出錯：子類無法覆蓋父類。
結論：子類方法不可比父類方法拋出更多的例外。子類拋出的例外或者與父類拋出的例外一致，或者是父類拋出例外的子類型。或者子類型不拋出例外。
如果父類型無throws時，子類型也不允許出現throws。此時只能使用try catch。
練習：寫一個方法：int add(int a,int b)
{
return a+b；
}
當a+b=100;拋出100爲異常處理。
12.02
集合（從本部分開始涉及API）
集合是指一個對象容納了多個對象，這個集合對象主要用來管理維護一系列相似的對象。
數組就是一種對象。（練習：如何編寫一個數組程序，並進行遍歷。）
java.util.*定義了一系列的接口和類，告訴我們用什麼類NEW出一個對象，可以進行超越數組的操作。
（注：JAVA1.5對JAVA1.4的最大改進就是增加了對範型的支持）
集合框架接口的分類：（分collection接口 和 map接口）
Collection接口 Map接口
List接口 Set接口 SortedMap接口
SortedSet接口
JAVA中所有與集合有關的實現類都是這六個接口的實現類。
Collection接口：集合中每一個元素爲一個對象，這個接口將這些對象組織在一起，形成一維結構。
List接口代表按照元素一定的相關順序來組織（在這個序列中順序是主要的），List接口中數據可重複。
Set接口是數學中集合的概念：其元素無序，且不可重複。（正好與List對應）
SortedSet會按照數字將元素排列，爲“可排序集合”。
Map接口中每一個元素不是一個對象，而是一個鍵對象和值對象組成的鍵值對（Key-Value）。
Key-Value是用一個不可重複的key集合對應可重複的value集合。（典型的例子是字典：通過頁碼的key值找字的value值）。
例子：
key1—value1;
key2—value2;
key3—value3.
SortedMap：如果一個Map可以根據key值排序，則稱其爲SortedMap。（如字典）
!!注意數組和集合的區別：數組中只能存簡單數據類型。Collection接口和Map接口只能存對象。
以下介紹接口：
List接口：（介紹其下的兩個實現類：ArrayList和LinkedList）
ArrayList和數組非常類似，其底層①也用數組組織數據，ArrayList是動態可變數組。
① 底層：指存儲格式。說明ArrayList對象都是存在於數組中。
注：數組和集合都是從下標0開始。
ArrayList有一個add(Object o)方法用於插入數組。
ArrayList的使用：（完成這個程序）
先import java.util.*；
用ArrayList在一個數組中添加數據，並遍歷。
ArrayList中數組的順序與添加順序一致。
只有List可用get和size。而Set則不可用（因其無序）。
Collection接口都是通過Iterator()（即迭代器）來對Set和List遍歷。
通過語句：Iterator it=c.iterator(); 得到一個迭代器，將集合中所有元素順序排列。然後可以通過interator方法進行遍歷，迭代器有一個遊標（指針）指向首位置。
Interator有hasNext()，用於判斷元素右邊是否還有數據，返回True說明有。然後就可以調用next動作。Next()會將遊標移到下一個元素，並把它所跨過的元素返回。（這樣就可以對元素進行遍歷）
練習：寫一個程序，輸入對象信息，比較基本信息。
集合中每一個元素都有對象，如有字符串要經過強制類型轉換。
Collections是工具類，所有方法均爲有用方法，且方法爲static。
有Sort方法用於給List排序。
Collections.Sort()分爲兩部分，一部分爲排序規則；一部分爲排序算法。
規則用來判斷對象；算法是考慮如何排序。
對於自定義對象，Sort不知道規則，所以無法比較。這種情況下一定要定義排序規則。方式有兩種：
① java.lang下面有一個接口：Comparable（可比較的）
可以讓自定義對象實現一個接口，這個接口只有一個方法comparableTo(Object o)
其規則是當前對象與o對象進行比較，其返回一個int值，系統根據此值來進行排序。
如 當前對象>o對象，則返回值>0；（可將返回值定義爲1）
如 當前對象=o對象，則返回值=0；
如 當前對象<o對象，則返回值〈0。（可將返回值定義爲-1）
看TestArraylist的java代碼。
我們通過返回值1和-1位置的調換來實現升序和降序排列的轉換。
② java.util下有一個Comparator(比較器)
它擁有compare()，用來比較兩個方法。
要生成比較器，則用Sort中Sort（List,List(Compate)）
第二種方法更靈活，且在運行的時候不用編譯。
注意：要想實現comparTo()就必須在主方法中寫上implement comparable.
練習：生成一個EMPLOYEE類，然後將一系列對象放入到ArrayList。用Iterator遍歷，排序之後，再進行遍歷。
集合的最大缺點是無法進行類型判定（這個缺點在JAVA1.5中已經解決），這樣就可能出現因爲類型不同而出現類型錯誤。
解決的方法是添加類型的判斷。
LinkedList接口（在代碼的使用過程中和ArrayList沒有什麼區別）
ArrayList底層是object數組，所以ArrayList具有數組的查詢速度快的優點以及增刪速度慢的缺點。
而在LinkedList的底層是一種雙向循環鏈表。在此鏈表上每一個數據節點都由三部分組成：前指針（指向前面的節點的位置），數據，後指針（指向後面的節點的位置）。最後一個節點的後指針指向第一個節點的前指針，形成一個循環。
雙向循環鏈表的查詢效率低但是增刪效率高。所以LinkedList具有查詢效率低但增刪效率高的特點。
ArrayList和LinkedList在用法上沒有區別，但是在功能上還是有區別的。
LinkedList經常用在增刪操作較多而查詢操作很少的情況下：隊列和堆棧。
隊列：先進先出的數據結構。
堆棧：後進先出的數據結構。
注意：使用堆棧的時候一定不能提供方法讓不是最後一個元素的元素獲得出棧的機會。
LinkedList提供以下方法：（ArrayList無此類方法）
addFirst();
removeFirst();
addLast();
removeLast();
在堆棧中，push爲入棧操作，pop爲出棧操作。
Push用addFirst()；pop用removeFirst()，實現後進先出。
用isEmpty()--其父類的方法，來判斷棧是否爲空。
在隊列中，put爲入隊列操作，get爲出隊列操作。
Put用addFirst()，get用removeLast()實現隊列。
List接口的實現類（Vector）（與ArrayList相似，區別是Vector是重量級的組件，使用使消耗的資源比較多。）
結論：在考慮併發的情況下用Vector（保證線程的安全）。
在不考慮併發的情況下用ArrayList（不能保證線程的安全）。
面試經驗（知識點）：
java.util.stack（stack即爲堆棧）的父類爲Vector。可是stack的父類是最不應該爲Vector的。因爲Vector的底層是數組，且Vector有get方法（意味着它可能訪問到並不屬於最後一個位置元素的其他元素，很不安全）。
對於堆棧和隊列只能用push類和get類。
Stack類以後不要輕易使用。
！！！實現堆棧一定要用LinkedList。
（在JAVA1.5中，collection有queue來實現隊列。）
Set-HashSet實現類：
遍歷一個Set的方法只有一個：迭代器（interator）。
HashSet中元素是無序的（這個無序指的是數據的添加順序和後來的排列順序不同），而且元素不可重複。
在Object中除了有final()，toString()，equals()，還有hashCode()。
HashSet底層用的也是數組。
當向數組中利用add(Object o)添加對象的時候，系統先找對象的hashCode：
int hc=o.hashCode(); 返回的hashCode爲整數值。
Int I=hc%n;（n爲數組的長度），取得餘數後，利用餘數向數組中相應的位置添加數據，以n爲6爲例，如果I=0則放在數組a[0]位置，如果I=1,則放在數組a[1]位置。如果equals()返回的值爲true，則說明數據重複。如果equals()返回的值爲false，則再找其他的位置進行比較。這樣的機制就導致兩個相同的對象有可能重複地添加到數組中，因爲他們的hashCode不同。
如果我們能夠使兩個相同的對象具有相同hashcode，才能在equals()返回爲真。
在實例中，定義student對象時覆蓋它的hashcode。
因爲String類是自動覆蓋的，所以當比較String類的對象的時候，就不會出現有兩個相同的string對象的情況。
現在，在大部分的JDK中，都已經要求覆蓋了hashCode。
結論：如將自定義類用hashSet來添加對象，一定要覆蓋hashcode()和equals()，覆蓋的原則是保證當兩個對象hashcode返回相同的整數，而且equals()返回值爲True。
如果偷懶，沒有設定equals()，就會造成返回hashCode雖然結果相同，但在程序執行的過程中會多次地調用equals()，從而影響程序執行的效率。
我們要保證相同對象的返回的hashCode一定相同，也要保證不相同的對象的hashCode儘可能不同（因爲數組的邊界性，hashCode還是可能相同的）。例子：
public int hashCode(){
return name.hashcode()+age;
}
這個例子保證了相同姓名和年齡的記錄返回的hashCode是相同的。
使用hashSet的優點：
hashSet的底層是數組，其查詢效率非常高。而且在增加和刪除的時候由於運用的hashCode的比較開確定添加元素的位置，所以不存在元素的偏移，所以效率也非常高。因爲hashSet查詢和刪除和增加元素的效率都非常高。
但是hashSet增刪的高效率是通過花費大量的空間換來的：因爲空間越大，取餘數相同的情況就越小。HashSet這種算法會建立許多無用的空間。
使用hashSet接口時要注意，如果發生衝突，就會出現遍歷整個數組的情況，這樣就使得效率非常的低。
練習：new一個hashset，插入employee對象，不允許重複，並且遍歷出來。
添加知識點：
集合對象存放的是一系列對象的引用。
例：
Student S
Al.add(s);
s.setName(“lucy”);
Student s2=(Student)(al.get(o1));
可知s2也是s。
12.05
SortedSet可自動爲元素排序。
SortedSet的實現類是TreeSet:它的作用是字爲添加到TreeSet中的元素排序。
練習：自定義類用TreeSet排序。
與HashSet不同，TreeSet並不需要實現HashCode()和equals()。
只要實現compareable和compareTo()接可以實現過濾功能。
（注：HashSet不調用CompareTo()）。
如果要查詢集合中的數據，使用Set必須全部遍歷，所以查詢的效率低。使用Map，可通過查找key得到value，查詢效率高。
集合中常用的是：ArrayList，HashSet，HashMap。其中ArrayList和HashMap使用最爲廣泛。
使用HashMap，put()表示放置元素，get()表示取元素。
遍歷Map，使用keySet()可以返回set值，用keySet()得到key值，使用迭代器遍歷，然後使用put()得到value值。
上面這個算法的關鍵語句：
Set s=m.keySet();
Interator it=new interator();
Object key=it.next();
Object value=m.get(key);
注意：HashMap與HashCode有關，用Sort對象排序。
如果在HashMap中有key值重複，那麼後面一條記錄的value覆蓋前面一條記錄。
Key值既然可以作爲對象，那麼也可以用一個自定義的類。比如：
m.put(new sutdent(“Liucy”,30),”boss”)
如果沒有語句來判定Student類對象是否相同，則會全部打印出來。
當我們用自定義的類對象作爲key時，我們必須在程序中覆蓋HashCode()和equals()。
注：HashMap底層也是用數組，HashSet底層實際上也是HashMap，HashSet類中有HashMap屬性（我們如何在API中查屬性）。HashSet實際上爲(key.null)類型的HashMap。有key值而沒有value值。
正因爲以上的原因，TreeSet和TreeMap的實現也有些類似的關係。
注意：TreeSet和TreeMap非常的消耗時間，因此很少使用。
我們應該熟悉各種實現類的選擇——非常體現你的功底。
HashSet VS TreeSet：HashSet非常的消耗空間，TreeSet因爲有排序功能，因此資源消耗非常的高，我們應該儘量少使用，而且最好不要重複使用。
基於以上原因，我們儘可能的運用HashSet而不用TreeSet，除非必須排序。
同理：HashMap VS TreeMap:一般使用HashMap，排序的時候使用TreeMap。
HashMap VS Hashtable（注意在這裏table的第一個字母小寫）之間的區別有些類似於ArrayList和Vector，Hashtable是重量級的組件，在考慮併發的情況，對安全性要求比較高的時候使用。
Map的運用非常的多。
使用HashMap()，如果使用自定義類，一定要覆蓋HashCode()和equals()。
重點掌握集合的四種操作：增加、刪除、遍歷、排序。
Module8—12利用兩天的時間完成。
Module8：圖形界面
Module9：事件模型（在本部分最重要）
Module10：AWT
Module11：Swing
Module12：Applet（這個技術基本已經被淘汰）
軟件應用的三個發展階段：
單機應用
網絡應用（C/S結構）
BS結構：B表示瀏覽器，S表示server端。即利用瀏覽器作爲客戶端，因此對於圖形界面的要求已經不高，現在的發展趨勢是不使用安裝，即不用任何的本地應用，圖形很快就會被服務器構件開發所取代。
經驗之談：Swing的開發工作會非常的累，而且這項技術正在走向沒落。避免從事有這種特徵的工作。
AWT也即將被取代。
Module8—Module11所使用的技術都將被JSF技術所取代。
JSF是服務器端的Swing：目前技術已經成熟，但是開發環境（工具）還不成熟。
Module12的Applet技術也將被WebStart所取代。
Module9爲重點，所謂事件模型是指觀察者設計模式的JAVA應用。事件模型是重點。
Module8：圖形界面（java.awt.*）
Awt：抽象窗口工具箱，它由三部分組成：
①組件：界面元素；
②容器：裝載組件的容器（例如窗體）；
③佈局管理器：負責決定容器中組件的擺放位置。
圖形界面的應用分四步：
① 選擇一個容器：
⑴window:帶標題的容器（如Frame）；
⑵Panel:面板
通過add()想容器中添加組件。
Java的圖形界面依然是跨平臺的。但是在調用了一個窗體之後只生成一個窗體，沒有事件的處理，關閉按鈕並不工作。此時只能使用CTRL+C終止程序。
②設置一個佈局管理器：用setLayout()；
③向容器中添加組件；
③ 添加組件的事務處理。P198
P204：Panel也是一種容器：但是不可見的。在設置容易的時候不要忘記設置它們的可見性。
Panel pan=new Panel;
Fp.setLayout(null);表示不要佈局管理器。
五種佈局管理器：
P206：Flow Layout(流式佈局)：按照組件添加到容器中的順序，順序排放組件位置。默認爲水平排列，如果越界那麼會向下排列。排列的位置隨着容器大小的改變而改變。
Panel默認的佈局管理器爲Flow Layout。
Border Layout：會將容器非常五個區域：東西南北中。
語句：
Button b1=new Botton(“north”);//botton上的文字
f.add(b1,”North”);//表示b1這個botton放在north位置
注：一個區域只能放置一個組件，如果想在一個區域放置多個組件就需要使用Panel來裝載。
Frame和Dialog的默認佈局管理器是Border Layout。
Grid Layout：將容器生成等長等大的條列格，每個塊中放置一個組件。
f.setLayout GridLayout(5,2,10,10)//表示條列格爲5行2類，後面爲格間距。
CardLayout:一個容器可以放置多個組件，但每次只有一個組件可見（組件重疊）。
使用first()，last()，next()可以決定哪個組件可見。可以用於將一系列的面板有順序地呈現給用戶。
重點：GridBag Layout:在Grid中可指定一個組件佔據多行多列，GridBag的設置非常的煩瑣。
Module9:AWT:事件模型
事件模型指的是對象之間進行通信的設計模式。
對象1給對象2發送一個信息相當於對象1引用對象2的方法。
模型即是一種設計模式（約定俗成）
對象對爲三種：
①事件源：發出事件者；
②事件對象：發出的事件本身；
④ 事件監聽器：提供處理事件指定的方法。
Java AWT事件模型也稱爲授權事件模型，指事件可以和監聽器之間事先建立一種關係：約定那些事件如何處理，由誰去進行處理。這種約定稱爲授權。
一個事件源可以授權多個監聽者（授權也稱爲監聽者的註冊）；
多個事件源也可以註冊多個事件監聽器。
監聽者對於事件源的發出的事件作出響應。
在java.util中有EventListener接口：所有事件監聽者都要實現這個接口。
java.util中有EventObject類：所有的事件都爲其子類。
事件範例在\CoreJava\Girl.java文件中。(文件已加註釋)
注意：接口因對不同的事件監聽器對其處理可能不同，所以只能建立監聽的功能，而無法實現處理。
下面程序建立監聽功能：
//監聽器接口要定義監聽器所具備的功能，定義方法
{
void WhatIdoWhenGirlHappy(EmotionEvent e);
void WhatIdoWhenGirlSad(EmotionEvent e);
}
注意查看參考書：事件的設置模式，如何實現授權模型。
事件模式的實現步驟：
開發事件對象（事件發送者）——接口——接口實現類——設置監聽對象
一定要理解透徹Gril.java程序。
重點：學會處理對一個事件源有多個事件的監聽器（在發送消息時監聽器收到消息的排名不分先後）。
事件監聽的響應順序是不分先後的，不是誰先註冊誰就先響應。
事件監聽由兩個部分組成（接口和接口的實現類）。
事件源 事件對象 事件監聽
gril EmotinEvent EmotionListener(接口)、Boy(接口的實現類)
鼠標事件：MouseEvent，接口：MouseListener。
P235 ActionEvent。
注意在寫程序的時候：import java.awt.*;以及import java.awt.event.*注意兩者的不同。
在生成一個窗體的時候，點擊窗體的右上角關閉按鈕激發窗體事件的方法：窗體Frame爲事件源，WindowsListener接口調用Windowsclosing()。
爲了配合後面的實現，我們必須將WindowsListener所有的方法都實現，除了Windowsclosing方法，其餘的方法均爲空實現。
（練習：寫一個帶button窗體，點關閉按鈕退出。）
上面程序中實現了許多不必要的實現類，雖然是空實現。
爲了避免上面那些無用的實現，可以利用WindowEvent的一個WindowEvent類，還是利用windowsListener。還有WindowAdapter類，它已經實現了WindowsListener。它給出的全部都是空實現，那就可以只寫想要實現的類，去覆蓋其中的類，就不用寫空實現。
注意：監聽過多，會拋tooManyListener例外。
12.06
Module 10
Canvas組件：畫布，可以實現動畫操作。
TextArea：文本域。
在單行文本域中回車會激發ActionEvent。
用CheckBoxGroup實現單選框功能。
Java中，單選框和複選框都是使用CheckBox實現。
菜單：new MenuBar()，MenuBar表示菜單條。
菜單中的每一項爲MenuItem，一般級聯菜單不應該超過三級。
練習：
設計一個計算器：注意設置一個boolean值（append）來判斷輸入數字是位於第一個數的後面還是屬於輸入的第二個數。
設置一個變量來存放“+”，點完運算符後，將append設置爲false。
String number1
Char operator 存放運算符。
Module 11 Swing
AWT是Java最早出現的圖形界面，但很快就被Swing所取代。
Swing纔是一種真正的圖形開發。
AWT在不同平臺所出現的界面可能有所不同：因爲每個OS都有自己的UI組件庫，java調用不同系統的UI。
注意AWT爲重量級組件，相當消耗資源，且不同系統的組件可能不同。因爲這個問題使得AWT開發的軟件難以作到跨平臺。
更爲要命的是：不同OS的組件庫都存在BUG。必須多種平臺進行測試，並且AWT的組件庫並不豐富。
爲解決以上問題，SUN和IBM以及NETSCAPE聯合開發出JAVA基礎類包Swing：注意JAVA的基礎類以Swing爲核心。
注意引用：javax.swing.*;javax表示JAVA的擴展。
我們在學習JDBC的時候會過度到J2EE。
在Swing的組件中，基本上都是在AWT組件的名稱前面加“J”。
一般情況下，除了Choise等組件:
import javax.swing.*;好要加上：import java.awt.*以及import java.awt.event.*。
Swing與AWT的最大區別是Swing爲JAVA自身的組件。已經不是對等實體，與底層的OS無關。
（JBUILDER就是使用Swing寫的）
Swing與AWT在事件模型處理上是一致的。
Jframe實際上是一堆窗體的疊加。
Swing比AWT更加複雜且靈活。
在JDK1.4中，給JFRAME添加Button不可用jf.add(b)。而是使用jf.getContentPane().add(b)。
content是先申請面板。不過在JDK1.5中可以使用add.。
Jpanel支持雙緩衝技術。
在Jbutton中可以添加圖標。
JscrollPane可以管理比屏幕還要大的組件。
TextArea只有裝入JscrollPane中才能實現滾動條。
JeditorPane用於顯示瀏覽器。
注意：Tabbed Panel與Border的比較。
進度條：ProgressBar。
JcomboBox：下拉菜單：在AWT中同類組件是choice。
JlistPanel：選擇列表
BorderPanel：設置邊框
JsplitPanel：可將容器分爲兩個部分，其中一個部分有Jtree。
TextBox：也是一種新的容器，可以設置組件的間距。
TextFileChoose：文件選擇器。
ColorChoose：顏色選擇器
Module 12 Applet
Applet爲Panel的子類
Applet是java的自動執行方式（這是它的優勢，主要用於HTML）。
工作四種語法：init()，start()，stop()，destory()。
Swing中有一個Japplet，如使用Swing組件。
Applet消亡的原因：
①java爲安全起見對Applet有所限制：Applet不允許訪問本地文件信息、敏感信息，不能執行本地指令（比如FORMAT），不能訪問初原服務器之外的其他服務器。
② IE不支持新版本的Applet。
Applet的優勢：
網絡傳輸，自動下載。
Application的優勢：沒有執行限制。
WebStart：可在網絡傳輸，並且在本地無限制。因此前景光明。
練習：
使用Swing實現一個界面，分爲上下兩個部分，南邊爲JtextField組件，可編輯，上面爲JtextArea組件，不可編輯，在JtextField組件輸入字符，按回車，就可以將內容輸入到JtextArea組件。(AREA區域可以滾動)
12.07
多線程
進程：任務
任務併發執行是一個宏觀概念，微觀上是串行的。
進程的調度是有OS負責的（有的系統爲獨佔式，有的系統爲共享式，根據重要性，進程有優先級）。
由OS將時間分爲若干個時間片。
JAVA在語言級支持多線程。
分配時間的仍然是OS。
參看P377
線程由兩種實現方式：
第一種方式：
class MyThread extends Thread{
public void run(){
需要進行執行的代碼，如循環。
}
}
public class TestThread{
main(){
Thread t1=new Mythread();
T1.start();
}
}
只有等到所有的線程全部結束之後，進程才退出。
第二種方式：
Class MyThread implements Runnable{
Public void run(){
Runnable target=new MyThread();
Thread t3=new Thread(target);
Thread.start();//啓動線程
}
}
P384:通過接口實現繼承
練習：寫兩個線程：
① 輸入200個“###”②輸入200個“***”
下面爲線程中的7中非常重要的狀態：（有的書上也只有認爲前五種狀態：而將“鎖池”和“等待隊列”都看成是“阻塞”狀態的特殊情況：這種認識也是正確的，但是將“鎖池”和“等待隊列”單獨分離出來有利於對程序的理解）
① ⑴
② ⑵
③ ⑶ run()結束
Start()
OS分配CPU
CPU時間片結束
yield() o.wait()
等待鎖標記
notify()
注意：圖中標記依次爲
①輸入完畢；②wake up③t1退出
⑴如等待輸入（輸入設備進行處理，而CUP不處理），則放入阻塞，直到輸入完畢。
⑵線程休眠sleep（）
⑶t1.join()指停止main()，然後在某段時間內將t1加入運行隊列，直到t1退出，main()才結束。
特別注意：①②③與⑴⑵⑶是一一對應的。
進程的休眠：Thread sleep(1000);//括號中以毫秒爲單位
當main()運行完畢，即使在結束時時間片還沒有用完，CPU也放棄此時間片，繼續運行其他程序。
Try{Thread.sleep(1000);}
Catch(Exception e){e.printStackTrace(e);}
T1.join()表示運行線程放棄執行權，進入阻塞狀態。
當t1結束時，main()可以重新進入運行狀態。
T1.join實際上是把併發的線程編程並行運行。
線程的優先級：1-10，越大優先級越高，優先級越高被OS選中的可能性就越大。（不建議使用，因爲不同操作系統的優先級並不相同，使得程序不具備跨平臺性，這種優先級只是粗略地劃分）。
注：程序的跨平臺性：除了能夠運行，還必須保證運行的結果。
一個使用yield()就馬上交出執行權，回到可運行狀態，等待OS的再次調用。
下午：
程序員需要關注的線程同步和互斥的問題。
多線程的併發一般不是程序員決定，而是由容器決定。
多線程出現故障的原因：
兩個線程同時訪問一個數據資源（臨界資源），形成數據發生不一致和不完整。
數據的不一致往往是因爲一個線程中的兩個關聯的操作只完成了一步。
避免以上的問題可採用對數據進行加鎖的方法
每個對象除了屬性和方法，都有一個monitor（互斥鎖標記），用來將這個對象交給一個線程，只有拿到monitor的線程才能夠訪問這個對象。
Synchronized:這個修飾詞可以用來修飾方法和代碼塊
Object obj;
Obj.setValue(123);
Synchronized用來修飾方法，表示當某個線程調用這個方法之後，其他的事件不能再調用這個方法。只有拿到obj標記的線程才能夠執行代碼塊。
注意：Synchronized一定使用在一個方法中。
鎖標記是對象的概念，加鎖是對對象加鎖，目的是在線程之間進行協調。
當用Synchronized修飾某個方法的時候，表示該方法都對當前對象加鎖。
給方法加Synchronized和用Synchronized修飾對象的效果是一致的。
一個線程可以拿到多個鎖標記，一個對象最多隻能將monitor給一個線程。
Synchronized是以犧牲程序運行的效率爲代價的，因此應該儘量控制互斥代碼塊的範圍。
方法的Synchronized特性本身不會被繼承，只能覆蓋。
線程因爲未拿到鎖標記而發生的阻塞不同於前面五個基本狀態中的阻塞，稱爲鎖池。
每個對象都有自己的一個鎖池的空間，用於放置等待運行的線程。
這些線程中哪個線程拿到鎖標記由系統決定。
鎖標記如果過多，就會出現線程等待其他線程釋放鎖標記，而又都不釋放自己的鎖標記供其他線程運行的狀況。就是死鎖。
死鎖的問題通過線程間的通信的方式進行解決。
線程間通信機制實際上也就是協調機制。
線程間通信使用的空間稱之爲對象的等待隊列，則個隊列也是屬於對象的空間的。
Object類中又一個wait()，在運行狀態中，線程調用wait()，此時表示着線程將釋放自己所有的鎖標記，同時進入這個對象的等待隊列。
等待隊列的狀態也是阻塞狀態，只不過線程釋放自己的鎖標記。
Notify()
如果一個線程調用對象的notify()，就是通知對象等待隊列的一個線程出列。進入鎖池。如果使用notifyall()則通知等待隊列中所有的線程出列。
注意：只能對加鎖的資源進行wait()和notify()。
釋放鎖標記只有在Synchronized代碼結束或者調用wait()。
注意鎖標記是自己不會自動釋放，必須有通知。
注意在程序中判定一個條件是否成立時要注意使用WHILE要比使用IF要嚴密。
WHILE會放置程序饒過判斷條件而造成越界。
補充知識：
suspend（）是將一個運行時狀態進入阻塞狀態（注意不釋放鎖標記）。恢復狀態的時候用resume()。Stop()指釋放全部。
這幾個方法上都有Deprecated標誌，說明這個方法不推薦使用。
一般來說，主方法main()結束的時候線程結束，可是也可能出現需要中斷線程的情況。對於多線程一般每個線程都是一個循環，如果中斷線程我們必須想辦法使其退出。
如果主方法main()想結束阻塞中的線程（比如sleep或wait）
那麼我們可以從其他進程對線程對象調用interrupt()。用於對阻塞（或鎖池）會拋出例外Interrupted Exception。
這個例外會使線程中斷並執行catch中代碼。
多線程中的重點：實現多線程的兩種方式，Synchronized,以及生產者和消費者問題（ProducerConsumer.java文件）。
練習：
① 存車位的停開車的次序輸出問題；
② 寫兩個線程，一個線程打印1-52，另一個線程答應字母A-Z。打印順序爲12A34B56C……5152Z。通過使用線程之間的通信協調關係。
注：分別給兩個對象構造一個對象o，數字每打印兩個或字母每打印一個就執行o.wait()。在o.wait()之前不要忘了寫o.notify()。
補充說明：通過Synchronized，可知Vector較ArrayList方法的區別就是Vector所有的方法都有Synchronized。所以Vector更爲安全。
同樣：Hashtable較HashMap也是如此。
12.08
Module 10：I/O流（java如何實現與外界數據的交流）
Input/Output：指跨越出了JVM的邊界，與外界數據的源頭或者目標數據源進行數據交換。
輸出
輸入
注意：輸入/輸出是針對JVM而言。
File類（java.io.*）可表示一個文件，也有可能是一個目錄（在JAVA中文件和目錄都屬於這個類中，而且區分不是非常的明顯）。
Java.io下的方法是對磁盤上的文件進行磁盤操作，但是無法讀取文件的內容。
注意：創建一個文件對象和創建一個文件在JAVA中是兩個不同的概念。前者是在虛擬機中創建了一個文件，但卻並沒有將它真正地創建到OS的文件系統中，隨着虛擬機的關閉，這個創建的對象也就消失了。而創建一個文件纔是在系統中真正地建立一個文件。
例如：File f=new File(“11.txt”);//創建一個名爲11.txt的文件對象
f.CreateNewFile(); //真正地創建文件
f.CreateMkdir()：創建目錄
f.delete()；刪除文件
f.deleteOnExit();在進程退出的時候刪除文件，這樣的操作通常用在臨時文件的刪除。
對於命令：File f2=new file(“d:\\abc\\789\\1.txt”)
這個命令不具備跨平臺性，因爲不同的OS的文件系統很不相同。
如果想要跨平臺，在file類下有separtor()，返回鎖出平臺的文件分隔符。
File.fdir=new File(File.separator);
String str=”abc”+File.separator+”789”;
使用文件下的方法的時候一定注意是否具備跨平臺性。
List()：顯示文件的名（相對路徑）
ListFiles()：返回Files類型數組，可以用getName()來訪問到文件名。
使用isDirectory()和isFile()來判斷究竟是文件還是目錄。
練習：
寫一個javaTest程序，列出所有目錄下的*.java文件，把子目錄下的JAVA文件也打印出來。
使用I/O流訪問file中的內容。
JVM與外界通過數據通道進行數據交換。
分類：
按流分爲輸入流和輸出流；
按傳輸單位分爲字節流和字符流；
還可以分爲節點流和過濾流。
節點流：負責數據源和程序之間建立連接；
過濾流：用於給節點增加功能。
過濾流的構造方式是以其他流位參數構造（這樣的設計模式稱爲裝飾模式）。
字節輸入流：io包中的InputStream爲所有字節輸入流的父類。
Int read();讀入一個字節（每次一個）；
可先使用new byte[]=數組，調用read(byte[] b)
read (byte[])返回值可以表示有效數；read (byte[])返回值爲-1表示結束。
字節輸出流：io包中的OutputStream位所有字節輸入流的父類。
Write和輸入流中的read相對應。
在流中close()方法由程序員控制。因爲輸入輸出流已經超越了VM的邊界，所以有時可能無法回收資源。
原則：凡是跨出虛擬機邊界的資源都要求程序員自己關閉，不要指望垃圾回收。
以Stream結尾的類都是字節流。
如果構造FileOutputStream的同時磁盤會建立一個文件。如果創建的文件與磁盤上已有的文件名重名，就會發生覆蓋。
用FileOutputStream中的boolean，則視，添加情況，將數據覆蓋重名文件還是將輸入內容放在文件的後面。（編寫程序驗證）
DataOutputStream:輸入數據的類型。
因爲每中數據類型的不同，所以可能會輸出錯誤。
所有對於：DataOutputStream
DataInputStream
兩者的輸入順序必須一致。
過濾流：
bufferedOutputStream
bufferedInputStream
用於給節點流增加一個緩衝的功能。
在VM的內部建立一個緩衝區，數據先寫入緩衝區，等到緩衝區的數據滿了之後再一次性寫出，效率很高。
使用帶緩衝區的輸入輸出流的速度會大幅提高，緩衝區越大，效率越高。（這是典型的犧牲空間換時間）
切記：使用帶緩衝區的流，如果數據數據輸入完畢，使用flush方法將緩衝區中的內容一次性寫入到外部數據源。用close()也可以達到相同的效果，因爲每次close都會使用flush。一定要注意關閉外部的過濾流。
（非重點）管道流：也是一種節點流，用於給兩個線程交換數據。
PipedOutputStream
PipedInputStream
輸出流：connect(輸入流)
RondomAccessFile類允許隨機訪問文件
GetFilepoint()可以知道文件中的指針位置，使用seek()定位。
Mode(“r”:隨機讀；”w”：隨機寫；”rw”：隨機讀寫)
練習：寫一個類A，JAVA A file1 file2
file1要求是系統中已經存在的文件。File2是還沒有存在的文件。
執行完這個命令，那麼file2就是file1中的內容。
字符流：reader\write只能輸純文本文件。
FileReader類：字符文件的輸出
字節流與字符流的區別：
字節流的字符編碼：
字符編碼把字符轉換成數字存儲到計算機中，按ASCii將字母映射爲整數。
把數字從計算機轉換成相應的字符的過程稱爲解碼。
編碼方式的分類：
ASCII（數字、英文）:1個字符佔一個字節（所有的編碼集都兼容ASCII）
ISO8859-1（歐洲）：1個字符佔一個字節
GB-2312/GBK：1個字符佔兩個字節
Unicode: 1個字符佔兩個字節（網絡傳輸速度慢）
UTF-8：變長字節，對於英文一個字節，對於漢字兩個或三個字節。
原則：保證編解碼方式的統一，才能不至於出現錯誤。
Io包的InputStreamread稱爲從字節流到字符流的橋轉換類。這個類可以設定字符轉換方式。
OutputStreamred:字符到字節
Bufferread有readline()使得字符輸入更加方便。
在I/O流中，所有輸入方法都是阻塞方法。
Bufferwrite給輸出字符加緩衝，因爲它的方法很少，所以使用父類printwrite，它可以使用字節流對象，而且方法很多。
練習：做一個記事本
swing/JfileChoose: getSelect file()
InputStreeamReader：把字節變爲字符
JAVA中對字符串長無限制 bufferedReader（ir）
12.09
class ObjectOutputStream也是過濾流，使節點流直接獲得輸出對象。
最有用的方法：WriteObject(Object b)
用流傳輸對象稱爲對象的序列化，但並不使所有的對象都可以進行序列化的。只有在實現類時必須實現一個接口：IO包下的Serializable(可序列化的)。此接口沒有任何的方法，這樣的接口稱爲標記接口。
Class Student implements Serializable
把對象通過流序列化到某一個持久性介質稱爲對象的可持久化。
Hibernate就是研究對象的可持久化。
ObuectInputStream in =new ObjectInputStream;
Object o1=in.readObuect();
Student s1=(Student)o1；
注意：因爲o1是一個對象，因爲需要對其進行保存。
Transient用來修飾屬性。
Transient int num;
表示當我們對屬性序列化時忽略這個屬性（即忽略不使之持久化）。
所有屬性必須都是可序列化的，特別是當有些屬性本身也是對象的時候，要尤其注意這一點。
判斷是否一個屬性或對象可序列化：Serialver。
Serialver TestObject（TestObject必須爲已經編譯）
執行結果：如果不可序列化；則出現不可序列化的提示。如果可以序列化，那麼就會出現序列化的ID：UID。
java.until.*有
StringTokenizer（參數1，參數2）按某種符號隔開文件
StringTokenizer(s,”:”) 用“：”隔開字符，s爲對象。
練習：將一個類序列化到文件，然後讀出。下午：
1、 網絡基礎知識
2、 JAVA網絡編程
網絡與分佈式集羣系統的區別：每個節點都是一臺計算機，而不是各種計算機內部的功能設備。
Ip:具有全球唯一性，相對於internet，IP爲邏輯地址。
端口(port)：一臺PC中可以有65536個端口，進程通過端口交換數據。連線的時候需要輸入IP也需要輸入端口信息。
計算機通信實際上的主機之間的進程通信，進程的通信就需要在端口進行聯繫。
192.168.0.23:21
協議：爲了進行網絡中的數據交換（通信）而建立的規則、標準或約定。
不同層的協議是不同的。
網絡層：尋址、路由（指如何到達地址的過程）
傳輸層：端口連接
TCP模型：應用層/傳輸層/網絡層/網絡接口
端口是一種抽象的軟件結構，與協議相關：TCP23端口和UDT23端口爲兩個不同的概念。
端口應該用1024以上的端口，以下的端口都已經設定功能。
套接字(socket)的引入：
Ip+Port=Socket（這是個對象的概念。）
Socket爲傳輸層概念，而JSP是對應用層編程。例：
java.net.*;
(Server端定義順序)
ServerSocket(intport)
Socket.accept()；//阻塞方法，當客戶端發出請求是就恢復
如果客戶端收到請求：
則Socket SI=ss.accept()；
注意客戶端和服務器的Socket爲兩個不同的socket。
Socket的兩個方法：
getInputStream()：客戶端用
getOutputStream() 服務器端用
使用完畢後切記Socket.close()，兩個Socket都關，而且不用關內部的流。
在client端，Socket s=new Socket(“127.0.0.1”,8000);
127.0.0.1爲一個默認本機的地址。
練習：
1、 客戶端向服務器發出一個字符串，服務器轉換成大寫傳回客戶端。
大寫的函數：String.toUpperCase()
2、 服務器告訴客戶端：“自開機以來你是第n 個用戶”。
12.12
UDP編程：
DatagramSocket（郵遞員）：對應數據報的Socket概念，不需要創建兩個socket，不可使用輸入輸出流。
DatagramPacket（信件）：數據包，是UDP下進行傳輸數據的單位，數據存放在字節數組中。
UDP也需要現有Server端，然後再有Client端。
兩端都是DatagramPacket（相當於電話的概念），需要NEW兩個DatagramPacket。
InetAddress:網址
這種信息傳輸方式相當於傳真，信息打包，在接受端準備紙。
模式：
發送端：Server:
DatagramPacket inDataPacket=new DatagramPacket ((msg,msg.length); InetAdress.getByName(ip),port);
接收端：
clientAddress=inDataPack.getAddress();//取得地址
clientPort=inDataPack.getPort();//取得端口號
datagramSocket.send; //Server
datagramSocket.accept; //Client
注意比較：
http://Localhost:8080/directory //查找網絡服務器的目錄
file://directory //查找本地的文件系統
java的開發主要以http爲基礎。
反射：主要用於工具和框架的開發。
反射是對於類的再抽象；通過字符串來抽象類。
JAVA類的運行：classLoader:加載到虛擬機（vm）
Vm中只能存儲對象（動態運行時的概念），.class文件加載到VM上就成爲一個對象，同時初始靜態成員及靜態代碼（只執行一次）。
Lang包下有一個類爲Class：在反射中使用。此類中的每個對象爲VM中的類對象，每個類都對應類類的一個對象（class.class）。
例：對於一個Object類，用getClass()得到其類的對象，獲得類的對象就相當於獲得類的信息，可以調用其下的所有方法，包括類的私有方法。
注意：在反射中沒有簡單數據類型，所有的編譯時類型都是對象。
反射把編譯時應該解決的問題留到了運行時。