第一篇：java 基礎(chǔ)要點總結(jié) 學習java必看
Java基礎(chǔ)
1.JAVA程序是由1個或者N個CLASS組成的程序
2.編寫---javac進行編譯------java進行執(zhí)行
3.類名的命名：規(guī)范：第一個字母要大寫 第一字母必須是字母 下劃線美圓符號 人民幣符號//
4.不是第一個字母的話 可以是數(shù)字
5.文件名和類名的關(guān)系 如果class前面沒有public 是可以不一樣的 但是如果有的話 必須一樣
6.兩個BYTE SHORT類型進行加減乘除的時候 返回的結(jié)果是int類型
/*
需求：定義一個hello world小程序。
步驟：
1，通過class關(guān)鍵字定義一個類。將代碼都編寫到該類中。
2，為了保證該的獨立運行。在類中定義個主函數(shù)。格式public static void main(String[] args)3,保存成一個擴展名為java的文件。
4，在dos控制臺中通過javac工具對java文件進行編譯。
5，在通過java命令對生成的class文件進行執(zhí)行。
*/
class Demo//定義一個類。
{
//主函數(shù)。
public static void main(String[] args)
{
//輸出語句。
System.out.println(“hello haha”);
}
}
6.字符串數(shù)據(jù)和任何數(shù)據(jù)使用+都是相連接，最終都會變成字符串。
System.out.println(“5+5”+(5+5));//“5+5=55”
轉(zhuǎn)義字符：通過 來轉(zhuǎn)變后面字母或者符號的含義。
n:換行。
b:退格。相當于backspace。
r:按下回車鍵。window系統(tǒng)，回車符是由兩個字符來表示rn.t:制表符。相當于tab鍵。
7.if else 結(jié)構(gòu) 簡寫格式： 變量 =(條件表達式)?表達式1：表達式2；
三元運算符：
好處：可以簡化if else代碼。
弊端：因為是一個運算符，所以運算完必須要有一個結(jié)果。
class OperateDemo
{
public static void main(String[] args)
{
int x= 7;
//邏輯運算符用于連接boolean類型的表達式。
//x>3 & x<6 = true & true = true;
/*
true & true = true;
true & false = false;
false & true = false;
false & false = false;
& : 只要兩邊的boolean表達式結(jié)果，有一個為false。那么結(jié)果就是false。只有兩邊都為true，結(jié)果為true。
true | true = true;
true | false = true;
false | true = true;
false | false = false;
| : 兩邊只要有一個為true，結(jié)果為true。
只有兩邊都有false，結(jié)果為false。
^ : 異或；就是和|有點不一樣。當true ^ true = false;
true ^ true = false;
true ^ false = true;
false ^ true = true;
false ^ false = false;
^ : 兩邊相同結(jié)果是false。
兩邊不同結(jié)果是true。
&和&&的特點：
&:無論左邊是true是false。右邊都運算。
&&:當左邊為false時，右邊不運算。
|：兩邊都參與運算。
||：當左邊為true。右邊不運算。
int n = 3,m = 8;
System.out.println(“n=”+n+“,m=”+m);
1,通過第三方變量。
/*int temp;temp = n;n = m;m = temp;
2不用第三方變量。= 3 +8;3 = 113;n = n + m;//如果n和m的值非常大，容易超出int范圍。m = nm;n = n ^ m;m = n ^ m;//(n^m)^m;n = n ^ m;//n ^(n ^ m)System.out.println(“n=”+n+“,m=”+m);
if和switch語句很像。
具體什么場景下，應用哪個語句呢？
如果判斷的具體數(shù)值不多，而是符合byte short int char這四種類型。雖然兩個語句都可以使用，建議使用swtich語句。因為效率稍高。
其他情況：對區(qū)間判斷，對結(jié)果為boolean類型判斷，使用if，if的使用
范圍更廣。
第二篇：Java學習_基礎(chǔ)總結(jié)
現(xiàn)在學習JAVA的人越來越多！但是學的好的，能用到工作中去的卻很少很少，下面就是我為大家總結(jié)歸納的一些JAVA學習基礎(chǔ)，希望大家少走彎路，盡快投入到工作中去！
Java 學習基礎(chǔ)總結(jié)歸納！
1、作用域public,private,protected,以及不寫時的區(qū)別
答：區(qū)別如下：
作用域
當前類
同一package
子孫類
其他package public
√
√
√
√
protected
√
√
√
×
friendly
√
√
×
×
private
√
×
×
×
不寫時默認為friendly
2、Anonymous Inner Class(匿名內(nèi)部類)是否可以extends(繼承)其它類，是否可以implements(實現(xiàn))interface(接口)
答：匿名的內(nèi)部類是沒有名字的內(nèi)部類。不能extends(繼承)其它類，但一個內(nèi)部類可以作為一個接口，由另一個內(nèi)部類實現(xiàn)
3、Static Nested Class 和 Inner Class的不同
答：Nested Class（一般是C++的說法），Inner Class(一般是JAVA的說法)。Java內(nèi)部類與C++嵌套類最大的不同就在于是否有指向外部的引用上。注： 靜態(tài)內(nèi)部類（Inner Class）意味著1創(chuàng)建一個static內(nèi)部類的對象，不需要一個外部類對象，2不能從一個static內(nèi)部類的一個對象訪問一個外部類對象
4、&和&&的區(qū)別
答：&是位運算符，表示按位與運算，&&是邏輯運算符，表示邏輯與（and）
5、Collection 和 Collections的區(qū)別
答：Collection是集合類的上級接口，繼承與他的接口主要有Set 和List.Collections是針對集合類的一個幫助類，他提供一系列靜態(tài)方法實現(xiàn)對各種集合的搜索、排序、線程安全化等操作
6、什么時候用assert
答：assertion(斷言)在軟件開發(fā)中是一種常用的調(diào)試方式，很多開發(fā)語言中都支持這種機制。在實現(xiàn)中，assertion就是在程序中的一條語句，它對一個boolean表達式進行檢查，一個正確程序必須保證這個boolean表達式的值為true；如果該值為false，說明程序已經(jīng)處于不正確的狀態(tài)下，系統(tǒng)將給出警告或退出。一般來說，assertion用于保證程序最基本、關(guān)鍵的正確性。assertion檢查通常在開發(fā)和測試時開啟。為了提高性能，在軟件發(fā)布后，assertion檢查通常是關(guān)閉的
7、String s = new String(“xyz”);創(chuàng)建了幾個String Object
答：兩個，一個字符對象，一個字符對象引用對象
8、Math.round(11.5)等於多少? Math.round(-11.5)等於多少
答: Math.round(11.5)==12;Math.round(-11.5)==-11;round方法返回與參數(shù)最接近的長整數(shù)，參數(shù)加1/2后求其floor
9、short s1 = 1;s1 = s1 + 1;有什么錯? short s1 = 1;s1 += 1;有什么錯
答：short s1 = 1;s1 = s1 + 1;（s1+1運算結(jié)果是int型，需要強制轉(zhuǎn)換類型）short s1= 1;s1 += 1;（可以正確編譯）
10、Java有沒有g(shù)oto
答：java中的保留字，現(xiàn)在沒有在java中使用
11、數(shù)組有沒有l(wèi)ength()這個方法? String有沒有l(wèi)ength()這個方法
答：數(shù)組沒有l(wèi)ength()這個方法，有l(wèi)ength的屬性。String有有l(wèi)ength()這個方法
12、Overload和Override的區(qū)別。Overloaded的方法是否可以改變返回值的類型
答：方法的重寫Overriding和重載Overloading是Java多態(tài)性的不同表現(xiàn)。重寫Overriding是父類與子類之間多態(tài)性的一種表現(xiàn)，重載Overloading是一個類中多態(tài)性的一種表現(xiàn)。如果在子類中定義某方法與其父類有相同的名稱和參數(shù)，我們說該方法被重寫(Overriding)。子類的對象使用這個方法時，將調(diào)用子類中的定義，對它而言，父類中的定義如同被“屏蔽”了。如果在一個類中定義了多個同名的方法，它們或有不同的參數(shù)個數(shù)或有不同的參數(shù)類型，則稱為方法的重載(Overloading)。Overloaded的方法是可以改變返回值的類型
13、Set里的元素是不能重復的，那么用什么方法來區(qū)分重復與否呢? 是用==還是equals()? 它們有何區(qū)別
答：Set里的元素是不能重復的，那么用iterator()方法來區(qū)分重復與否。equals()是判讀兩個Set是否相等 equals()和==方法決定引用值是否指向同一對象equals()在類中被覆蓋，為的是當兩個分離的對象的內(nèi)容和類型相配的話，返回真值
14、給我一個你最常見到的runtime exception
答：常見的運行時異常有如下這些ArithmeticException, ArrayStoreException, BufferOverflowException, BufferUnderflowException, CannotRedoException, CannotUndoException, ClassCastException, CMMException, ConcurrentModificationException, DOMException, EmptyStackException, IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException, IllegalStateException, ImagingOpException, IndexOutOfBoundsException, MissingResourceException, NegativeArraySizeException, NoSuchElementException, NullPointerException, ProfileDataException, ProviderException, RasterFormatException, SecurityException, SystemException, UndeclaredThrowableException, UnmodifiableSetException, UnsupportedOperationException
15、error和exception有什么區(qū)別 答：error 表示恢復不是不可能但很困難的情況下的一種嚴重問題。比如說內(nèi)存溢出。不可能指望程序能處理這樣的情況 exception 表示一種設(shè)計或?qū)崿F(xiàn)問題。也就是說，它表示如果程序運行正常，從不會發(fā)生的情況
16、List, Set, Map是否繼承自Collection接口
答： List，Set是，Map不是
17、abstract class和interface有什么區(qū)別
答：聲明方法的存在而不去實現(xiàn)它的類被叫做抽象類（abstract class），它用于要創(chuàng)建一個體現(xiàn)某些基本行為的類，并為該類聲明方法，但不能在該類中實現(xiàn)該類的情況。不能創(chuàng)建abstract 類的實例。然而可以創(chuàng)建一個變量，其類型是一個抽象類，并讓它指向具體子類的一個實例。不能有抽象構(gòu)造函數(shù)或抽象靜態(tài)方法。Abstract 類的子類為它們父類中的所有抽象方法提供實現(xiàn)，否則它們也是抽象類為。取而代之，在子類中實現(xiàn)該方法。知道其行為的其它類可以在類中實現(xiàn)這些方法接口（interface）是抽象類的變體。在接口中，所有方法都是抽象的。多繼承性可通過實現(xiàn)這樣的接口而獲得。接口中的所有方法都是抽象的，沒有一個有程序體。接口只可以定義static final成員變量。接口的實現(xiàn)與子類相似，除了該實現(xiàn)類不能從接口定義中繼承行為。當類實現(xiàn)特殊接口時，它定義（即將程序體給予）所有這種接口的方法。然后，它可以在實現(xiàn)了該接口的類的任何對象上調(diào)用接口的方法。由于有抽象類，它允許使用接口名作為引用變量的類型。通常的動態(tài)聯(lián)編將生效。引用可以轉(zhuǎn)換到接口類型或從接口類型轉(zhuǎn)換，instanceof 運算符可以用來決定某對象的類是否實現(xiàn)了接口
18、abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized
答：都不能
19、接口是否可繼承接口? 抽象類是否可實現(xiàn)(implements)接口? 抽象類是否可繼承實體類(concrete class)
答：接口可以繼承接口。抽象類可以實現(xiàn)(implements)接口，抽象類是否可繼承實體類，但前提是實體類必須有明確的構(gòu)造函數(shù)
20、構(gòu)造器Constructor是否可被override
答：構(gòu)造器Constructor不能被繼承，因此不能重寫Overriding，但可以被重載Overloading
21、是否可以繼承String類
答：String類是final類故不可以繼承
22、try {}里有一個return語句，那么緊跟在這個try后的finally {}里的code會不會被執(zhí)行，什么時候被執(zhí)行，在return前還是后
答：會執(zhí)行，在return前執(zhí)行
23、用最有效率的方法算出2乘以8等於幾 答：2 << 3
24、兩個對象值相同(x.equals(y)== true)，但卻可有不同的hash code，這句話對不對
答：不對，有相同的hash code
25、當一個對象被當作參數(shù)傳遞到一個方法后，此方法可改變這個對象的屬性，并可返回變化后的結(jié)果，那么這里到底是值傳遞還是引用傳遞
答：是值傳遞。Java 編程語言只有值傳遞參數(shù)。當一個對象實例作為一個參數(shù)被傳遞到方法中時，參數(shù)的值就是對該對象的引用。對象的內(nèi)容可以在被調(diào)用的方法中改變，但對象的引用是永遠不會改變的
26、swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上
答：witch（expr1）中，expr1是一個整數(shù)表達式。因此傳遞給 switch 和 case 語句的參數(shù)應該是 int、short、char 或者 byte。long,string 都不能作用于swtich
27、ArrayList和Vector的區(qū)別,HashMap和Hashtable的區(qū)別
答：就ArrayList與Vector主要從二方面來說.一.同步性:Vector是線程安全的，也就是說是同步的，而ArrayList是線程序不安全的，不是同步的二.數(shù)據(jù)增長:當需要增長時,Vector默認增長為原來一培，而ArrayList卻是原來的一半就HashMap與HashTable主要從三方面來說。一.歷史原因:Hashtable是基于陳舊的Dictionary類的，HashMap是Java 1.2引進的Map接口的一個實現(xiàn)二.同步性:Hashtable是線程安全的，也就是說是同步的，而HashMap是線程序不安全的，不是同步的三.值：只有HashMap可以讓你將空值作為一個表的條目的key或value
28、char型變量中能不能存貯一個中文漢字?為什么? 答：是能夠定義成為一個中文的，因為java中以unicode編碼，一個char占16個字節(jié)，所以放一個中文是沒問題的
29、GC是什么? 為什么要有GC
答：GC是垃圾收集的意思（Gabage Collection）,內(nèi)存處理是編程人員容易出現(xiàn)問題的地方，忘記或者錯誤的內(nèi)存回收會導致程序或系統(tǒng)的不穩(wěn)定甚至崩潰，Java提供的GC功能可以自動監(jiān)測對象是否超過作用域從而達到自動回收內(nèi)存的目的，Java語言沒有提供釋放已分配內(nèi)存的顯示操作方法。
30、float型float f=3.4是否正確?
答:不正確。精度不準確,應該用強制類型轉(zhuǎn)換，如下所示：float f=(float)3.4
31、介紹JAVA中的Collection FrameWork(包括如何寫自己的數(shù)據(jù)結(jié)構(gòu))?
答：Collection FrameWork如下： Collection ├List │├LinkedList │├ArrayList │└Vector │ └Stack └Set Map ├Hashtable ├HashMap └WeakHashMap Collection是最基本的集合接口，一個Collection代表一組Object，即Collection的元素（Elements）Map提供key到value的映射
32、抽象類與接口？
答：抽象類與接口都用于抽象，但是抽象類(JAVA中)可以有自己的部分實現(xiàn)，而接口則完全是一個標識(同時有多重繼承的功能)。JAVA類實現(xiàn)序例化的方法是實現(xiàn)java.io.Serializable接口 Collection框架中實現(xiàn)比較要實現(xiàn)Comparable 接口和 Comparator 接口
33、String與StringBuffer的區(qū)別。
答：STRING的長度是不可變的，STRINGBUFFER的長度是可變的。如果你對字符串中的內(nèi)容經(jīng)常進行操作，特別是內(nèi)容要修改時，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toString()方法
34、談?wù)刦inal, finally, finalize的區(qū)別
答：final—修飾符（關(guān)鍵字）如果一個類被聲明為final，意味著它不能再派生出新的子類，不能作為父類被繼承。因此一個類不能既被聲明為 abstract的，又被聲明為final的。將變量或方法聲明為final，可以保證它們在使用中不被改變。被聲明為final的變量必須在聲明時給定初值，而在以后的引用中只能讀取，不可修改。被聲明為final的方法也同樣只能使用，不能重載 finally—再異常處理時提供 finally 塊來執(zhí)行任何清除操作。如果拋出一個異常，那么相匹配的 catch 子句就會執(zhí)行，然后控制就會進入 finally 塊（如果有的話）finalize—方法名。Java 技術(shù)允許使用 finalize()方法在垃圾收集器將對象從內(nèi)存中清除出去之前做必要的清理工作。這個方法是由垃圾收集器在確定這個對象沒有被引用時對這個對象調(diào)用的。它是在 Object 類中定義的，因此所有的類都繼承了它。子類覆蓋 finalize()方法以整理系統(tǒng)資源或者執(zhí)行其他清理工作。finalize()方法是在垃圾收集器刪除對象之前對這個對象調(diào)用的
35、面向?qū)ο蟮奶卣饔心男┓矫?/p>
答：主要有以下四方面：
1.抽象：抽象就是忽略一個主題中與當前目標無關(guān)的那些方面，以便更充分地注意與當前目標有關(guān)的方面。抽象并不打算了解全部問題，而只是選擇其中的一部分，暫時不用部分細節(jié)。抽象包括兩個方面，一是過程抽象，二是數(shù)據(jù)抽象。
2.繼承：繼承是一種聯(lián)結(jié)類的層次模型，并且允許和鼓勵類的重用，它提供了一種明確表述共性的方法。對象的一個新類可以從現(xiàn)有的類中派生，這個過程稱為類繼承。新類繼承了原始類的特性，新類稱為原始類的派生類（子類），而原始類稱為新類的基類（父類）。派生類可以從它的基類那里繼承方法和實例變量，并且類可以修改或增加新的方法使之更適合特殊的需要。
3.封裝：封裝是把過程和數(shù)據(jù)包圍起來，對數(shù)據(jù)的訪問只能通過已定義的界面。面向?qū)ο笥嬎闶加谶@個基本概念，即現(xiàn)實世界可以被描繪成一系列完全自治、封裝的對象，這些對象通過一個受保護的接口訪問其他對象。4.多態(tài)性：多態(tài)性是指允許不同類的對象對同一消息作出響應。多態(tài)性包括參數(shù)化多態(tài)性和包含多態(tài)性。多態(tài)性語言具有靈活、抽象、行為共享、代碼共享的優(yōu)勢，很好的解決了應用程序函數(shù)同名問題。
36、String是最基本的數(shù)據(jù)類型嗎
答：基本數(shù)據(jù)類型包括byte、int、char、long、float、double、boolean和short。java.lang.String類是final類型的，因此不可以繼承這個類、不能修改這個類。為了提高效率節(jié)省空間，我們應該用StringBuffer類
37、int 和 Integer 有什么區(qū)別
答：Java 提供兩種不同的類型：引用類型和原始類型（或內(nèi)置類型）。Int是java的原始數(shù)據(jù)類型，Integer是java為int提供的封裝類。Java為每個原始類型提供了封裝類。原始類型封裝類
booleanBoolean,charCharacter,byteByte,shortShort,intInteger,longLong,floatFloat,doubleDouble 引用類型和原始類型的行為完全不同，并且它們具有不同的語義。引用類型和原始類型具有不同的特征和用法，它們包括：大小和速度問題，這種類型以哪種類型的數(shù)據(jù)結(jié)構(gòu)存儲，當引用類型和原始類型用作某個類的實例數(shù)據(jù)時所指定的缺省值。對象引用實例變量的缺省值為 null，而原始類型實例變量的缺省值與它們的類型有關(guān)
38、運行時異常與一般異常有何異同
答：異常表示程序運行過程中可能出現(xiàn)的非正常狀態(tài)，運行時異常表示虛擬機的通常操作中可能遇到的異常，是一種常見運行錯誤。java編譯器要求方法必須聲明拋出可能發(fā)生的非運行時異常，但是并不要求必須聲明拋出未被捕獲的運行時異常。
39、說出ArrayList,Vector, LinkedList的存儲性能和特性
答：ArrayList和Vector都是使用數(shù)組方式存儲數(shù)據(jù)，此數(shù)組元素數(shù)大于實際存儲的數(shù)據(jù)以便增加和插入元素，它們都允許直接按序號索引元素，但是插入元素要涉及數(shù)組元素移動等內(nèi)存操作，所以索引數(shù)據(jù)快而插入數(shù)據(jù)慢，Vector由于使用了synchronized方法（線程安全），通常性能上較ArrayList差，而LinkedList使用雙向鏈表實現(xiàn)存儲，按序號索引數(shù)據(jù)需要進行前向或后向遍歷，但是插入數(shù)據(jù)時只需要記錄本項的前后項即可，所以插入速度較快。
40、HashMap和Hashtable的區(qū)別
答：HashMap是Hashtable的輕量級實現(xiàn)（非線程安全的實現(xiàn)），他們都完成了Map接口，主要區(qū)別在于HashMap允許空（null）鍵值（key）,由于非線程安全，效率上可能高于Hashtable。HashMap允許將null作為一個entry的key或者value，而Hashtable不允許。HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因為contains方法容易讓人引起誤解。Hashtable繼承自Dictionary類，而HashMap是Java1.2引進的Map interface的一個實現(xiàn)。最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多個線程訪問Hashtable時，不需要自己為它的方法實現(xiàn)同步，而HashMap 就必須為之提供外同步。Hashtable和HashMap采用的hash/rehash算法都大概一樣，所以性能不會有很大的差異。
41、heap和stack有什么區(qū)別
答：棧是一種線形集合，其添加和刪除元素的操作應在同一段完成。棧按照后進先出的方式進行處理。堆是棧的一個組成元素
42、Java的接口和C++的虛類的相同和不同處
答：由于Java不支持多繼承，而有可能某個類或?qū)ο笠褂梅謩e在幾個類或?qū)ο罄锩娴姆椒ɑ驅(qū)傩裕F(xiàn)有的單繼承機制就不能滿足要求。與繼承相比，接口有更高的靈活性，因為接口中沒有任何實現(xiàn)代碼。當一個類實現(xiàn)了接口以后，該類要實現(xiàn)接口里面所有的方法和屬性，并且接口里面的屬性在默認狀態(tài)下面都是public static,所有方法默認情況下是public.一個類可以實現(xiàn)多個接口。
43、Java中的異常處理機制的簡單原理和應用
答：當JAVA程序違反了JAVA的語義規(guī)則時，JAVA虛擬機就會將發(fā)生的錯誤表示為一個異常。違反語義規(guī)則包括2種情況。一種是JAVA類庫內(nèi)置的語義檢查。例如數(shù)組下標越界,會引發(fā)IndexOutOfBoundsException;訪問null的對象時會引發(fā)NullPointerException。另一種情況就是JAVA允許程序員擴展這種語義檢查，程序員可以創(chuàng)建自己的異常，并自由選擇在何時用throw關(guān)鍵字引發(fā)異常。所有的異常都是java.lang.Thowable的子類。
43、垃圾回收的優(yōu)點和原理。并考慮2種回收機制
答：Java語言中一個顯著的特點就是引入了垃圾回收機制，使c++程序員最頭疼的內(nèi)存管理的問題迎刃而解，它使得Java程序員在編寫程序的時候不再需要考慮內(nèi)存管理。由于有個垃圾回收機制，Java中的對象不再有“作用域”的概念，只有對象的引用才有“作用域”。垃圾回收可以有效的防止內(nèi)存泄露，有效的使用可以使用的內(nèi)存。垃圾回收器通常是作為一個單獨的低級別的線程運行，不可預知的情況下對內(nèi)存堆中已經(jīng)死亡的或者長時間沒有使用的對象進行清楚和回收，程序員不能實時的調(diào)用垃圾回收器對某個對象或所有對象進行垃圾回收。回收機制有分代復制垃圾回收和標記垃圾回收，增量垃圾回收。
44、你所知道的集合類都有哪些？主要方法？
答：最常用的集合類是 List 和 Map。List 的具體實現(xiàn)包括 ArrayList 和 Vector，它們是可變大小的列表，比較適合構(gòu)建、存儲和操作任何類型對象的元素列表。List 適用于按數(shù)值索引訪問元素的情形。Map 提供了一個更通用的元素存儲方法。Map 集合類用于存儲元素對（稱作“鍵”和“值”），其中每個鍵映射到一個值。
45、描述一下JVM加載class文件的原理機制?
答：JVM中類的裝載是由ClassLoader和它的子類來實現(xiàn)的,Java ClassLoader 是一個重要的Java運行時系統(tǒng)組件。它負責在運行時查找和裝入類文件的類。
46、排序都有哪幾種方法？請列舉
答： 排序的方法有：插入排序（直接插入排序、希爾排序），交換排序（冒泡排序、快速排序），選擇排序（直接選擇排序、堆排序），歸并排序，分配排序（箱排序、基數(shù)排序）快速排序的偽代碼。/ /使用快速排序方法對a[ 0 :n-1 ]排序從a[ 0 :n-1 ]中選擇一個元素作為m i d d l e，該元素為支點把余下的元素分割為兩段left 和r i g h t，使得l e f t中的元素都小于等于支點，而right 中的元素都大于等于支點遞歸地使用快速排序方法對left 進行排序遞歸地使用快速排序方法對right 進行排序所得結(jié)果為l e f t + m i d d l e + r i g h t
47、JAVA語言如何進行異常處理，關(guān)鍵字：throws，throw，try，catch，finally分別代表什么意義？在try塊中可以拋出異常嗎？
答：Java通過面向?qū)ο蟮姆椒ㄟM行異常處理，把各種不同的異常進行分類，并提供了良好的接口。在Java中，每個異常都是一個對象，它是Throwable類或其它子類的實例。當一個方法出現(xiàn)異常后便拋出一個異常對象，該對象中包含有異常信息，調(diào)用這個對象的方法可以捕獲到這個異常并進行處理。Java的異常處理是通過5個關(guān)鍵詞來實現(xiàn)的：try、catch、throw、throws和finally。一般情況下是用try來執(zhí)行一段程序，如果出現(xiàn)異常，系統(tǒng)會拋出（throws）一個異常，這時候你可以通過它的類型來捕捉（catch）它，或最后（finally）由缺省處理器來處理。用try來指定一塊預防所有“異常”的程序。緊跟在try程序后面，應包含一個catch子句來指定你想要捕捉的“異常”的類型。throw語句用來明確地拋出一個“異常”。throws用來標明一個成員函數(shù)可能拋出的各種“異常”。Finally為確保一段代碼不管發(fā)生什么“異常”都被執(zhí)行一段代碼。可以在一個成員函數(shù)調(diào)用的外面寫一個try語句，在這個成員函數(shù)內(nèi)部寫另一個try語句保護其他代碼。每當遇到一個try語句，“異常”的框架就放到堆棧上面，直到所有的try語句都完成。如果下一級的try語句沒有對某種“異常”進行處理，堆棧就會展開，直到遇到有處理這種“異常”的try語句。
48、一個“.java”源文件中是否可以包括多個類（不是內(nèi)部類）？有什么限制？
答：可以。必須只有一個類名與文件名相同。
49、java中有幾種類型的流？JDK為每種類型的流提供了一些抽象類以供繼承，請說出他們分別是哪些類？
答：字節(jié)流，字符流。字節(jié)流繼承于InputStream OutputStream，字符流繼承于InputStreamReader OutputStreamWriter。在java.io包中還有許多其他的流，主要是為了提高性能和使用方便。
50、java中會存在內(nèi)存泄漏嗎，請簡單描述。
答：會。自己實現(xiàn)堆載的數(shù)據(jù)結(jié)構(gòu)時有可能會出現(xiàn)內(nèi)存泄露，可參看effective java.51、java中實現(xiàn)多態(tài)的機制是什么？
答：方法的重寫Overriding和重載Overloading是Java多態(tài)性的不同表現(xiàn)。重寫Overriding是父類與子類之間多態(tài)性的一種表現(xiàn)，重載Overloading是一個類中多態(tài)性的一種表現(xiàn)。
52、垃圾回收器的基本原理是什么？垃圾回收器可以馬上回收內(nèi)存嗎？有什么辦法主動通知虛擬機進行垃圾回收
答：對于GC來說，當程序員創(chuàng)建對象時，GC就開始監(jiān)控這個對象的地址、大小以及使用情況。通常，GC采用有向圖的方式記錄和管理堆(heap)中的所有對象。通過這種方式確定哪些對象是“可達的”，哪些對象是“不可達的”。當GC確定一些對象為“不可達”時，GC就有責任回收這些內(nèi)存空間。可以。程序員可以手動執(zhí)行System.gc()，通知GC運行，但是Java語言規(guī)范并不保證GC一定會執(zhí)行。
53、靜態(tài)變量和實例變量的區(qū)別？ 答：static i = 10;//常量 class A a;a.i =10;//可變
54、什么是java序列化，如何實現(xiàn)java序列化？
答：序列化就是一種用來處理對象流的機制，所謂對象流也就是將對象的內(nèi)容進行流化。可以對流化后的對象進行讀寫操作，也可將流化后的對象傳輸于網(wǎng)絡(luò)之間。序列化是為了解決在對對象流進行讀寫操作時所引發(fā)的問題。序列化的實現(xiàn)：將需要被序列化的類實現(xiàn)Serializable接口，該接口沒有需要實現(xiàn)的方法，implements Serializable只是為了標注該對象是可被序列化的，然后使用一個輸出流(如：FileOutputStream)來構(gòu)造一個ObjectOutputStream(對象流)對象，接著，使用ObjectOutputStream對象的writeObject(Object obj)方法就可以將參數(shù)為obj的對象寫出(即保存其狀態(tài))，要恢復的話則用輸入流。
55、是否可以從一個static方法內(nèi)部發(fā)出對非static方法的調(diào)用？
答：不可以,如果其中包含對象的method()；不能保證對象初始化.56、寫clone()方法時，通常都有一行代碼，是什么？
答：Clone 有缺省行為，super.clone();他負責產(chǎn)生正確大小的空間，并逐位復制。
57、在JAVA中，如何跳出當前的多重嵌套循環(huán)？
答：用break;return 方法。
58、List、Map、Set三個接口，存取元素時，各有什么特點？
答：List 以特定次序來持有元素，可有重復元素。Set 無法擁有重復元素,內(nèi)部排序。Map 保存key-value值，value可多值。
59、說出一些常用的類，包，接口，請各舉5個
答：常用的類：BufferedReader BufferedWriter FileReader FileWirter String Integer 常用的包：java.lang java.awt java.io java.util java.sql 常用的接口：Remote List Map Document NodeList
第三篇：Java基礎(chǔ)總結(jié)(必看)
一、基礎(chǔ)知識：
1、JVM、JRE和JDK的區(qū)別：
JVM(Java Virtual Machine):java虛擬機，用于保證java的跨平臺的特性。
java語言是跨平臺，jvm不是跨平臺的。
JRE(Java Runtime Environment):java的運行環(huán)境,包括jvm+java的核心類庫。
JDK(Java Development Kit):java的開發(fā)工具,包括jre+開發(fā)工具
2、環(huán)境變量path和classpath的作用是什么？
(1)path是配置Windows可執(zhí)行文件的搜索路徑，即擴展名為.exe的程序文件所在的目錄，用于指定DOS窗口命令的路徑。
(2)Classpath是配置class文件所在的目錄，用于指定類搜索路徑，JVM就是通過它來尋找該類的class類文件的。
3、變量有什么用？為什么要定義變量？什么時候用？
答：變量的作用：用來存儲數(shù)據(jù)。
為什么要定義變量：用來不斷的存放同一類型的常量，并可以重復使用
4、&和&&的區(qū)別? 答：（1）&&會出現(xiàn)短路，如果可以通過第一個表達式判斷出整個表達式的結(jié)果，則不繼續(xù)后面表達式的運算；
只能操作boolean類型數(shù)據(jù)；
（2）&不會出現(xiàn)短路，將整個表達式都運算。既可以操作boolean數(shù)據(jù)還可以操作數(shù)。
5、標示符命名規(guī)則：
由數(shù)字(0-9)，大小寫英文字母，以及_和$組成。
不能以數(shù)字開頭。
不能使用關(guān)鍵字來自定義命名。
6、數(shù)據(jù)類型：
(1)基本數(shù)據(jù)類型(4類8種)：
整數(shù)類型：byte、short、int、long
浮點數(shù)類型：float、double
字符類型：char
布爾類型：boolean(ture false)(2)引用數(shù)據(jù)類型：
類
接口
數(shù)組
7、類型轉(zhuǎn)換
精度從高到低
double float long int short(char)byte
(1)自動類型轉(zhuǎn)換
將一個低精度---?高精度(2)強制類型轉(zhuǎn)換
將一個高精度---?低精度(精度會下降)
8、java語言的三種技術(shù)架構(gòu)
J2EE：企業(yè)版
是為開發(fā)企業(yè)環(huán)境下的應用程序提供的一套解決方案。
該技術(shù)體系中包含的技術(shù)如 Servlet、Jsp等，主要針對于Web應用程序開發(fā)。
J2SE：標準版
是為開發(fā)普通桌面和商務(wù)應用程序提供的解決方案。
該技術(shù)體系是其他兩者的基礎(chǔ)，可以完成一些桌面應用程序的開發(fā)。
比如Java版的掃雷。
J2ME：小型版
是為開發(fā)電子消費產(chǎn)品和嵌入式設(shè)備提供的解決方案。
該技術(shù)體系主要應用于小型電子消費類產(chǎn)品，如手機中的應用程序等。
9、java的跨平臺性：
通過Java語言編寫的應用程序在不同的系統(tǒng)平臺上都可以運行。
跨平臺的原因：
只要在需要運行java應用程序的操作系統(tǒng)上，先安裝一個Java虛擬機(JVM Java Virtual Machine)即可。
由JVM來負責Java程序在該系統(tǒng)中的運行。
10、有符號數(shù)據(jù)的表示法(次重點)原碼，反碼(原碼取反)，補碼(反碼+1)。
11、函數(shù)
定義：函數(shù)就是定義在類中的具有特定功能的一段獨立小程序。
特點：
定義函數(shù)可以將功能代碼進行封裝
便于對該功能進行復用
函數(shù)只有被調(diào)用才會被執(zhí)行
函數(shù)的出現(xiàn)提高了代碼的復用性
對于函數(shù)沒有具體返回值的情況，返回值類型用關(guān)鍵字void表示，那么該函數(shù)中的return語句如果在最后一行可以省略不寫。
函數(shù)的應用兩個明確：
明確要定義的功能最后的結(jié)果是什么？
明確在定義該功能的過程中，是否需要未知內(nèi)容參與運算
12、重載：
概念：在同一個類中，允許存在一個以上的同名函數(shù)，只要它們的參數(shù)個數(shù)或者參數(shù)類型不同即可。
特點：與返回值類型無關(guān)，只看參數(shù)列表(參數(shù)類型以及參數(shù)個數(shù))。
好處：方便于閱讀，優(yōu)化了程序設(shè)計。
13、數(shù)組： 概念：同一種數(shù)據(jù)類型的集合。
好處：可以自動給數(shù)組中的元素從0開始編號，方便操作這些元素。
14、內(nèi)存結(jié)構(gòu)：
棧內(nèi)存：用于存儲局部變量，當數(shù)據(jù)使用完，所占空間會自動釋放。
堆內(nèi)存：數(shù)組和對象，通過new建立的實例都存放在堆內(nèi)存中。
方法區(qū)：靜態(tài)成員、構(gòu)造函數(shù)、常量池、線程池
本地方法區(qū)：window系統(tǒng)占用
寄存器：
二、面向?qū)ο?/p>
1、面向?qū)ο笏枷耄?/p>
(1)概述：面向?qū)ο笫窍鄬τ诿嫦蜻^程而言的，面向過程強調(diào)的是功能，面向?qū)ο髲娬{(diào)的是將功能封裝進對象，強調(diào)具備功能的對象；
(2)思想特點：
A:是符合人們思考習慣的一種思想；
B:將復雜的事情簡單化了；
C:將程序員從執(zhí)行者變成了指揮者；
比如我要達到某種結(jié)果，我就尋找能幫我達到該結(jié)果的功能的對象，如我要洗衣服我就買洗衣機，至于怎么洗我不管。
(3)特征：
封裝：隱藏對象的屬性和實現(xiàn)細節(jié)，僅對外提供公共訪問方式
繼承: 多個類中存在相同屬性和行為時，將這些內(nèi)容抽取到單獨一個類中，那么多個類無需再定義
這些屬性和行為，只要繼承那個類即可。
多態(tài): 一個對象在程序不同運行時刻代表的多種狀態(tài)，父類或者接口的引用指向子類對象
2、類和對象：
類：對現(xiàn)實世界中某類事物的描述,是抽象的，概念上的定義。
對象：事物具體存在的個體。
3：成員變量和局部變量的區(qū)別(重點)(1)作用域
成員變量：針對整個類有效。
局部變量：只在某個范圍內(nèi)有效。(一般指的就是方法,語句體內(nèi))(2)存儲位置
成員變量：隨著對象的創(chuàng)建而存在，隨著對象的消失而消失，存儲在堆內(nèi)存中。
局部變量：在方法被調(diào)用，或者語句被執(zhí)行的時候存在，存儲在棧內(nèi)存中。
當方法調(diào)用完，或者語句結(jié)束后，就自動釋放。
(3)初始值
成員變量：有默認初始值。
局部變量：沒有默認初始值，使用前必須賦值。
4、匿名對象
(1)匿名對象就是沒有名字的對象。是對象的一種簡寫形式。
(2)應用場景
A:只調(diào)用一次類中的方法。
B:可以作為實際參數(shù)在方法傳遞中使用
5、封裝：
指隱藏對象的屬性和實現(xiàn)細節(jié)，僅對外提供公共訪問方式；比如電腦機箱、筆記本等
好處：
將變化隔離；
方便使用；
提高復用性；
提高安全性
6、關(guān)鍵字private：封裝在代碼中的體現(xiàn)
(1)私有的意思，權(quán)限修飾符
(2)用來修飾成員變量和成員函數(shù)
(3)用private修飾的成員只在本類中有效
(4)私有是封裝的一種體現(xiàn)
7、構(gòu)造方法：
(1)特點：
方法名與類名相同
沒有返回類型
沒有返回值
(2)作用：構(gòu)造函數(shù)是用于創(chuàng)建對象，并對其進行初始化賦值，對象一建立就自動調(diào)用相對應的構(gòu)造函數(shù)，(3)構(gòu)造方法的注意事項:
A:如果一個自定義類沒有構(gòu)造方法，系統(tǒng)會默認給出一個無參構(gòu)造方法。
B:如果一個自定義類提供了構(gòu)造方法，那么，系統(tǒng)將不再給出無參構(gòu)造方法。
這個時候，你可以不使用無參構(gòu)造方法。
如果你想使用，那么，就必須手動給出無參構(gòu)造方法。
建議：一般情況下，我們的自定義類都要手動給出無參構(gòu)造方法。
(4)構(gòu)造方法和成員方法的區(qū)別
A:格式區(qū)別
構(gòu)造方法和類名相同，并且沒有返回類型，也沒有返回值。
普通成員方法可以任意起名，必須有返回類型，可以沒有返回值。
B:作用區(qū)別
構(gòu)造方法用于創(chuàng)建對象，并進行初始化值。
普通成員方法是用于完成特定功能的。
C:調(diào)用區(qū)別
構(gòu)造方法是在創(chuàng)建對象時被調(diào)用的，一個對象建立，只調(diào)用一次相應構(gòu)造函數(shù)
普通成員方法是由創(chuàng)建好的對象調(diào)用，可以調(diào)用多次
8、構(gòu)造代碼塊：
(1)作用：給對象進行初始化，對象一建立就執(zhí)行，而且優(yōu)先于構(gòu)造函數(shù)執(zhí)行
(2)構(gòu)造代碼塊和構(gòu)造函數(shù)的區(qū)別：
構(gòu)造代碼塊是給所有不同對象的共性進行統(tǒng)一初始化
構(gòu)造函數(shù)是給對應的對象進行初始化
9、this關(guān)鍵字
(1)this關(guān)鍵字代表本類對象的一個引用，誰調(diào)用this所在的方法，this就代表誰
(2)this的使用場景
A:用于區(qū)分同名成員變量和局部變量；
B:在定義函數(shù)時，該函數(shù)內(nèi)部要用到調(diào)用該函數(shù)的對象時，因為此時對象還沒建立，故this代表此對象
B:構(gòu)造函數(shù)間調(diào)用
**這個時候，this(參數(shù))必須作為第一條語句存在。
10、Person p = new Person();在內(nèi)存中做了哪些事情。
(1)將Person.class文件加載進內(nèi)存中。
(2)如果p定義在主方法中，那么，就會在棧空間開辟一個變量空間p。
(3)在堆內(nèi)存給對象分配空間。
(4)對對象中的成員進行默認初始化。
(5)對對象中的成員進行顯示初始化。
(6)調(diào)用構(gòu)造代碼塊對對象進行初始化。(如果沒有就不執(zhí)行)(7)調(diào)用構(gòu)造方法對對象進行初始化。對象初始化完畢。
(8)將對象的內(nèi)存地址賦值給p變量，讓p變量指向該對象。
11、static關(guān)鍵字：
(1)靜態(tài)的意思，用來修飾成員變量和成員函數(shù)
(2)靜態(tài)的特點:
隨著類的加載而加載
優(yōu)先于對象存在 對所有對象共享
可以被類名直接調(diào)用
(3)靜態(tài)的注意事項
A:靜態(tài)方法只能訪問靜態(tài)成員
為什么：因為靜態(tài)的內(nèi)容是隨著類的加載而加載，它是先進內(nèi)存的。
B:靜態(tài)方法中不能使用this,super關(guān)鍵字
C:主方法是靜態(tài)的public static void main(String[] args)
public:公共的意思，是最大權(quán)限修飾符。
static:由于jvm調(diào)用main方法的時候，沒有創(chuàng)建對象。
只能通過類名調(diào)用。所以，main必須用static修飾。
void:由于main方法是被jvm調(diào)用，不需要返回值。用void修飾。main:main是主要的意思，所以jvm采用了這個名字。是程序的入口。
String[]:字符串數(shù)組
args:數(shù)組名
在運行的時候，通過java命令給args數(shù)組賦值。
格式：java MainTest hello world itcast(4)靜態(tài)變量和成員變量的區(qū)別
A：調(diào)用方式
靜態(tài)變量也稱為類變量，可以直接通過類名調(diào)用。也可以通過對象名調(diào)用。
這個變量屬于類。
成員變量也稱為實例變量，只能通過對象名調(diào)用。這個變量屬于對象。
B：存儲位置
靜態(tài)變量存儲在方法區(qū)長中的靜態(tài)區(qū)。
成員變量存儲在堆內(nèi)存。
C：生命周期
靜態(tài)變量隨著類的加載而存在，隨著類的消失而消失。生命周期長。
成員變量隨著對象的創(chuàng)建而存在，隨著對象的消失而消失。
D：與對象的相關(guān)性
靜態(tài)變量是所有對象共享的數(shù)據(jù)。
成員變量是每個對象所特有的數(shù)據(jù)。
(5)靜態(tài)的優(yōu)點和弊端
優(yōu)點：
對對象的共享數(shù)據(jù)進行單獨空間的存儲，節(jié)省內(nèi)存，沒有必要每個對象都存儲一份
可直接被類名調(diào)用
弊端：
生命周期過長，隨著類的消失而消失
訪問出現(xiàn)權(quán)限，即靜態(tài)雖好但只能訪問靜態(tài)
(6)什么使用使用靜態(tài)呢？
A:當所有對象共享某個數(shù)據(jù)的時候，就把這個成員變量定義為靜態(tài)修飾的。
B:當某個方法沒有訪問該類中的非靜態(tài)成員，就可以把這個方法定義為靜態(tài)修飾。
靜態(tài)的生命周期比較長，所以一般不推薦使用。
(7)靜態(tài)代碼塊
A:它只執(zhí)行一次，它比main還先執(zhí)行。
B:執(zhí)行順序
靜態(tài)代碼塊--構(gòu)造代碼塊--構(gòu)造方法
12、制作API(次重點)API(全拼):Application Program Interface 應用程序編程接口。
(1)類中的內(nèi)容需要用文檔注釋。
(2)使用JDKbin目錄下的javadoc工具。
格式:javadoc-d 目錄-author-version ArrayTool.java
13、單例設(shè)計模式：
(1)設(shè)計模式：
解決某類問題行之有效的方法，是一種思想，是規(guī)律的總結(jié)
(2)用來保證某個類在內(nèi)存中只有一個對象
(3)保證唯一性的思想及步驟
**為了避免其他程序建立該類對象，先禁止其他程序建立該類對象，即將構(gòu)造函數(shù)私有化
**為了其他程序訪問到該類對象，須在本類中創(chuàng)建一個該類私有對象
**為了方便其他程序訪問到該類對象，可對外提供一個公共訪問方式
比如API中的Runtime類就是單例設(shè)計模式。(4)單例設(shè)計模式的兩種方式
A:餓漢式 當類加載的時候，就創(chuàng)建對象。
class Student {
private Student(){}
private static final Student s = new Student();
public static Student getInstance()
{
return s;
} }
B:懶漢式 當使用的使用，才去創(chuàng)建對象。class Student { private Student(){}
} private static final Student s = null;
public static Student getInstance(){ if(s==null)
{
//線程1就進來了，線程2就進來了。
s = new Student();} return s;} 餓漢式和懶漢式的區(qū)別：
**
餓漢式是類一加載進內(nèi)存就創(chuàng)建好了對象；
懶漢式則是類才加載進內(nèi)存的時候，對象還沒有存在，只有調(diào)用了getInstance()方法時，對象才開始創(chuàng)建。
**
懶漢式是延遲加載，如果多個線程同時操作懶漢式時就有可能出現(xiàn)線程安全問題，解決線程安全問題
可以加同步來解決。但是加了同步之后，每一次都要比較鎖，效率就變慢了，所以可以加雙重判斷來提高程序效率。
注：開發(fā)常用餓漢式，因為餓漢式簡單安全。懶漢式多線程的時候容易發(fā)生問題
14、Math類的使用(重點)(1)數(shù)學操作類:該類沒有構(gòu)造函數(shù)，方法均為靜態(tài)的(2)掌握內(nèi)容
A:成員變量
**E：比任何其他值都更接近e（即自然對數(shù)的底數(shù)）的double值。
**PI：比任何其他值都更接近pi（即圓的周長與直徑之比）的double值。
B:成員方法
**static double abs(double a)
返回 double 值的絕對值。返回絕對值
**static double ceil(double a)
返回最小的（最接近負無窮大）double 值，該值大于等于參數(shù)，并等于某個整數(shù)。
**static double floor(double a)
返回最大的（最接近正無窮大）double 值，該值小于等于參數(shù)，并等于某個整數(shù)。
**max：返回兩個值中較大的那個
**min：返回兩個值中較小的那個
**static long round(double a)返回最接近參數(shù)的 long。
static int round(float a)返回最接近參數(shù)的 int。
**static double random()
返回帶正號的 double 值，該值大于等于 0.0 且小于 1.0。
**static double pow(double a, double b)
返回第一個參數(shù)的第二個參數(shù)次冪的值。
**static double sqrt(double a)
返回正確舍入的 double 值的正平方根。
15、Random類的使用(重點)(1)產(chǎn)生隨機數(shù)的類
(2)掌握內(nèi)容
A:構(gòu)造方法
**Random()創(chuàng)建一個新的隨機數(shù)生成器。
**Random(long seed)使用單個 long 種子創(chuàng)建一個新的隨機數(shù)生成器。
B:成員方法
**int nextInt()返回下一個偽隨機數(shù)，它是此隨機數(shù)生成器的序列中均勻分布的 int 值。
**int nextInt(int n)返回一個偽隨機數(shù)，它是取自此隨機數(shù)生成器序列的、在 0（包括）和指定值（不包括）之間均勻分布的 int 值。
16、Scanner類的使用
(1)可以獲取從鍵盤的輸入數(shù)據(jù)
(2)掌握內(nèi)容
構(gòu)造方法：
Scanner(InputStream source)構(gòu)造一個新的 Scanner，它生成的值是從指定的輸入流掃描的。
如：Scanner sc = new Scanner(System.in);
方法摘要
sc.nextInt();獲取整型數(shù)據(jù)
sc.nextLine();獲取字符串數(shù)據(jù)
17、繼承(重點)(1)把很多類的相同特征和行為進行抽取，用一個類來描述。讓多個類和這個類產(chǎn)生一個關(guān)系。
這樣的話，多個類就可以省略很多代碼。這個關(guān)系就是繼承。java中用extends關(guān)鍵字表示。
(2)繼承的體系結(jié)構(gòu)
A:多個具體的對象，不斷的向上抽取共享的內(nèi)容，最終形成了一個體系。這個體系叫做繼承體系。
B:繼承體系的學習和使用原則
**學習頂層的內(nèi)容。因為他是整個體系的共性內(nèi)容。
**創(chuàng)建子類使用。也就是使用底層的具體對象。
(3)繼承的特點:
A:java中只能單繼承，沒有多繼承。
B:java可以有多重(層)繼承。
(4)繼承的好處：
繼承的出現(xiàn)提高了代碼的復用性。
繼承的出現(xiàn)讓類與類之間產(chǎn)生了關(guān)系，提供了多態(tài)的前提。
(5)子父類中的成員關(guān)系
A:成員變量
在子類方法中使用一個變量時：
首先，在方法的局部變量中找這個變量，有則使用。
否則，在本類中找成員變量，有則使用。
否則，在父類中找成員變量，有則使用。
否則，報錯。
B:成員方法
用子類對象使用一個方法時。
首先，在子類中找這個方法，有則使用。
否則，在父類中找這個方法，有則使用。
否則，報錯。
重寫和重載的區(qū)別？
重載：在同一類中。方法名相同，參數(shù)列表不同。重載可以改變返回類型。
重寫：在不同類中(子父類中)。
方法聲明相同(返回類型，方法名，參數(shù)列表均相同)。重寫需要注意：
**子類方法的訪問權(quán)限要大于等于父類方法的訪問權(quán)限。
**靜態(tài)只能重寫靜態(tài)。但是這種情況一般不會出現(xiàn)。
構(gòu)造方法
**子類的實例化過程
***子類創(chuàng)建對象時，會先去創(chuàng)建父類的對象。
默認是去調(diào)用父類的無參構(gòu)造方法。
***子類構(gòu)造方法中，第一行默認是super()
***為什么子類中第一行會默認有super()
因為他繼承父類的成員使用，使用前這些成員必須初始化，而他們是父類的成員，所以，必須通過父類進行初始化。
所以，會先創(chuàng)建一個父類的對象。
**當父類沒有無參構(gòu)造方法時
必須使用this或者super調(diào)用其他的構(gòu)造方法。
(6)this和super的區(qū)別
this:代表本類對象的引用。
super:代表父類的存儲空間。
18、final關(guān)鍵字(重點)(1)最終的意思，可以用于修飾類，方法，變量。
(2)final修飾的類不能被繼承。
final修飾的方法不能被重寫。
final修飾的變量是一個常量。只能被賦值一次。
內(nèi)部類只能訪問被final修飾的局部變量。
19、抽象類(重點)(1)多個類有相同的方法聲明，但是方法體不一樣。這個時候，我們考慮把方法聲明進行抽取。
讓子類繼承后，自己去實現(xiàn)方法體。沒有方法體的方法，我們需要用抽象標志下。
抽象的關(guān)鍵字是：abstract。
(2)抽象類：
該方法稱為抽象方法，包含抽象方法的類就是抽象類。
(3)抽象類的特點：
A:抽象類和抽象方法都要用abstract進行修飾
B:抽象類不能被實例化
C:抽象類中不一定有抽象方法，但是，有抽象方法的類一定是抽象類。
(4)抽象類中數(shù)據(jù)的特點
A:成員變量
抽象類中可以有變量，也可以有常量。
B:成員方法
抽象類中可以有抽象方法，也可以有非抽象方法。
C:構(gòu)造方法
抽象類是一個類，所以，它有構(gòu)造方法。
雖然本身不能實例化。但是可以給子類實例化使用。(5)抽象類中的問題
A:抽象類中是否有構(gòu)造方法？能不能被實例化？如果不能，為什么有構(gòu)造方法？
抽象類有構(gòu)造方法。
抽象類不能被實例化。
抽象類中的構(gòu)造方法供子類實例化調(diào)用。
B:抽象關(guān)鍵字abstract不可以和哪些關(guān)鍵字共存？
**private:
私有內(nèi)容子類繼承不到，所以，不能重寫。
但是abstract修飾的方法，要求被重寫。兩者沖突。
**final
final修飾的方法不能被重寫。
而abstract修飾的方法，要求被重寫。兩者沖突。
**static
假如一個抽象方法能通過static修飾，那么這個方法，就可以直接通過類名調(diào)用。
而抽象方法是沒有方法體的，這樣的調(diào)用無意義。所以，不能用static修飾。
C:抽象類中可不可以沒有抽象方法？如果可以，這樣的類有什么用嗎？
抽象類可以沒有抽象方法。
抽象類中沒有抽象方法的作用，只是為了不讓別的類建立該抽象類對象。這個在awt中有體現(xiàn)。20、接口interface(1)當一個類中的方法都是抽象的時候，java提供了另一種表示方式，叫接口。
用interface關(guān)鍵字表示。類與接口關(guān)系用implements表示。
(2)接口的成員特點
A:成員變量
是常量，默認修飾 public static final
B:成員方法
都是抽象的，默認修飾 public abstract
(3)關(guān)系
A:類與類的關(guān)系
是繼承關(guān)系。類與類只能單繼承，可以多重繼承。
B:類和接口的關(guān)系
是實現(xiàn)關(guān)系。類可以多實現(xiàn)接口。
類在繼承一個類的同時，可以實現(xiàn)多個接口。
C:接口和接口的關(guān)系
是繼承關(guān)系。接口可以多繼承接口。
(4)接口的特點
A:是對外暴露的規(guī)則
B:是功能的擴展
C:接口的出現(xiàn)降低耦合性。
耦合(類與類之間的關(guān)系)
內(nèi)聚(類完成功能的能力)
編程規(guī)范：低耦合，高內(nèi)聚。
D:接口可以多實現(xiàn)。如：CPU和主板、筆記本的USB插口、插座
(5)接口和抽象類的區(qū)別
A：抽象類只能被單繼承
接口可以多實現(xiàn),接口的出現(xiàn)避免了多繼承的局限性。
B：抽象類中的數(shù)據(jù)特點：
成員變量：可以是變量，也可以是常量
成員方法：可以是抽象方法，也可以是非抽象方法
構(gòu)造方法：有構(gòu)造方法
接口中的數(shù)據(jù)特點：
成員變量：是常量。默認修飾 public static final
成員方法：都是抽象方法。都有默認修飾 public abstract
構(gòu)造方法：沒有構(gòu)造方法
C：抽象類中定義的是繼承體系中的共性功能。
接口中定義的是繼承體系中的擴展功能。
D：抽象類被繼承是“is a”關(guān)系:xx是yy的一種
接口被實現(xiàn)是“l(fā)ike a”關(guān)系:xx像yy的一種
21、多態(tài)：
(1)同一個對象，在程序不同時刻的多種運行狀態(tài)。舉例：動物，狗是狗，狗是動物。水(氣態(tài)，液態(tài)，固態(tài))(2)多態(tài)前提
A:存在著繼承或者實現(xiàn)關(guān)系
B:有方法的重寫
C:父類(接口)引用指向子類(實現(xiàn))對象
(3)多態(tài)的好處和弊端：
好處：多態(tài)的存在提高了程序的擴展性和后期可維護性
弊端：雖然可以預先使用，但是只能訪問父類中已有的功能，運行的是后期子類的功能內(nèi)容。
不能預先使用子類中定義的特有功能。
(4)多態(tài)中對象調(diào)用成員的特點
Fu f = new Zi();
A:成員變量
編譯看左邊，運行看左邊
B:成員方法
編譯看左邊，運行看右邊
C:靜態(tài)方法
編譯看左邊，運行看左邊
(5)多態(tài)的思想
指揮同一批對象做事情。舉例：帶兵打仗，下課等。
22、instanceof關(guān)鍵字
A:用于判斷某個對象是否是某種類型。
B:格式
對象名 instanceof 子類(實現(xiàn))名
23、Object類：
(1)是所有類的根類，超類。
java中提供的類以及我們自定義的類都直接或者間接的繼承自O(shè)bject類。
(2)Object類中的方法
A:void finalize()
當垃圾回收器確定不存在對該對象的更多引用時，由對象的垃圾回收器調(diào)用此方法。
B:Class getClass()
獲取對象的字節(jié)碼文件的描述類，后面再講反射的時候還會在說這個類。
String name = s.getClass().getName();C:int hashCode()
獲取對象的哈希值。其實就是對象的內(nèi)存地址值十進制表示 D:String toString()
返回對象的字符串表示。
表示格式：
getClass().getName()+“@”+Integer.toHexString(hashCode());
一般我們輸出對象名的時候，其實底層調(diào)用的就是該對象的toString()方法。
這種返回沒有意義，所以，我們會重寫這個方法，顯示類的成員變量信息。E:boolean equals(Object obj)
用于比較兩個對象的地址值是否相同。
我們獲取對象后，比較它的地址值意義不大。所以也會對這個方法進行重寫。
重寫要完成什么功能，是根據(jù)需求定的。
(3)==和equals的用法：
A:==怎么用？
**可以用于比較基本數(shù)據(jù)類型，比較的就是基本數(shù)據(jù)類型的值是否相等。
**可以用于比較引用數(shù)據(jù)類型，比較的是對象的地址值是否相等。
B:equals怎么用？
equals只能用于比較引用數(shù)據(jù)類型的。
**Object提供的equals是用于比較對象地址值是否相同。
**自定義類中，如果重寫了equals方法，那么就是按照你自己的需求來比較的。
24、package關(guān)鍵字
(1)包：其實就是文件夾。用于區(qū)分不同包下相同的類名。
(2)好處：
A：對類文件進行分類管理。
B：給類提供了多層命名空間
aaa.Demo
bbb.Demo
C：寫在程序文件的第一行。
D：包也是一種封裝形式。
25、import關(guān)鍵字
(1)導入包的關(guān)鍵字
(2)格式：
import 包名;(3)注意：
A:一個程序文件中只有一個package，可以有多個import。
B:用來導包中的類，不導入包中的包。
C:通常寫import mypack.Demo，明確自己使用的類。
(4)關(guān)鍵字的順序
類，包，導包這些關(guān)鍵的順序。
包--> 到包--> 類
26、不同修飾符可以修飾哪些內(nèi)容
本類中 同一個包中 不同包中的子類中 不同包中
private OK
默認
OK Ok
protected OK Ok
OK public OK Ok
OK
類 構(gòu)造方法 private
OK 默認
Ok Ok protected OK public
Ok static
final Ok
abstract Ok
OK Ok OK
Ok
成員變量 成員方法 OK OK Ok
OK
OK Ok OK OK Ok OK OK 一般格式：
成員變量：
權(quán)限修飾符+static/final+數(shù)據(jù)類型+成員變量名
public static final int NUM = 10;
成員方法：
權(quán)限修飾符+static/final/abstract+返回類型+方法名
27、內(nèi)部類(次重點)(1)把一個類定義在某個類中的，這個類就被稱為內(nèi)部類，內(nèi)置類，嵌套類。
(2)訪問特點：
A:內(nèi)部類可以直接訪問外部類中的成員，因為內(nèi)部類持有外部類的引用，格式為：外部類名.this
B:外部類要想訪問內(nèi)部類的成員，必須創(chuàng)建對象訪問。
(3)內(nèi)部類的訪問格式：
A:當內(nèi)部類定義在外部類的成員位置，而且非私有，則可以在其他外部類中直接建立內(nèi)部類對象
格式：外部類名.內(nèi)部類名
變量名 = new 外部類對象.內(nèi)部類對象
如：Outer.Inner in = new Outer().new Inner()
B:當內(nèi)部類在外部類成員位置，且被static修飾時
**外部其他類可直接訪問靜態(tài)內(nèi)部類的非靜態(tài)成員
格式：new 外部類名.內(nèi)部類名().內(nèi)部類成員
如：new Outer.Inner().function();
**外部其他類可直接訪問靜態(tài)內(nèi)部類的靜態(tài)成員
格式：new 外部類名.內(nèi)部類名.內(nèi)部類成員
如：new Outer.Inner.function();(4)什么使用時候內(nèi)部類呢？
假如有A類和B類，A類想直接訪問B類的成員，B類訪問A類成員的時候，需要創(chuàng)建A類對象進行訪問，這個時候，就可以把A類定義為B類的內(nèi)部類。
(5)內(nèi)部類的位置
A:成員位置
**可以被private修飾(Body，Heart)
**可以被static修飾。(它訪問的外部類的成員必須是靜態(tài)的)
B:局部位置
**可以直接訪問外部類中的成員，因為還持有外部類的持用
也可以直接訪問局部成員，但是局部成員要用final修飾。
注意：局部內(nèi)部類不能用private和static修飾
(6)通過class文件我們就可以區(qū)分是否帶有內(nèi)部類，以及內(nèi)部類的位置
Outer$Inner:成員內(nèi)部類
Outer$1Inner:局部內(nèi)部類
28、匿名內(nèi)部類(局部內(nèi)部類的簡寫)(重點)
(1)前提：繼承一個類或者實現(xiàn)一個接口
(注意不要弄混匿名內(nèi)部類的前提和多態(tài)的前提)
(2)格式：
new 父類名或者接口名()
{
重寫父類方法或者實現(xiàn)接口中的方法。
也可以自定義其他方法。
};
(3)什么時候定義匿名內(nèi)部類？
匿名內(nèi)部類只是為了簡化書寫，匿名內(nèi)部類有局限，通常定義匿名內(nèi)部類時，該類方法不超過3個
(4)匿名內(nèi)部類的好處和弊端：
好處：簡化代碼書寫
弊端：
不能直接調(diào)用自己的特有方法
不能執(zhí)行強轉(zhuǎn)換動作
如果該類里面方法較多，不允許使用匿名內(nèi)部類
29、模板設(shè)計模式：
在定義功能時，功能的一部分是確定的，有一部分是不確定的，而且確定的部分在使用不確定的部分，可將不確定的部分暴露出去，由該類的子類去完成。如：求一段程序的運行時間例子。30、異常
(1)程序運行過程中的不正常現(xiàn)象就叫異常。
(2)導致程序運行不正常的現(xiàn)象有很多，所以，就有很多的異常對象。
而這些異常對象存在著共性的內(nèi)容，所以，可以不斷的進行抽取。最終形成了異常的體系結(jié)構(gòu)。
異常體系的根類是:Throwable
Throwable：
|--Error:重大的問題，我們處理不了。也不需要編寫代碼處理。比如說內(nèi)存溢出。
|--Exception:一般性的錯誤，是需要我們編寫代碼進行處理的。
|--RuntimeException:運行時異常，這個我們也不需要處理。
其實就是為了讓他在運行時出問題，然后我們回來修改代碼。
(3)異常的分類
異常有兩種：
編譯時被檢測異常：
該異常在編譯時，如果沒有處理(沒有拋也沒有try)，編譯失敗。
該異常被標識，代表這可以被處理。
運行時異常(編譯時不檢測)
在編譯時，不需要處理，編譯器不檢查。
該異常的發(fā)生，建議不處理，讓程序停止。需要對代碼進行修正。
(4)異常體系的特點：
異常體系中的所有類及其子類對象都具備可拋性。也就是說可以被throw和throws關(guān)鍵字所操作。
(5)main方法是如何處理異常的。
A:在main里面編寫代碼進行處理
B:交給jvm自己進行處理。采用的是jvm的默認處理方式。
其實就是相當于調(diào)用了異常對象的printStackTrace()方法。
(6)Throwable類的學習
getMessage():獲取異常信息，返回字符串。
toString():獲取異常類名和異常信息，返回字符串。
printStackTrace():獲取異常類名和異常信息，以及異常出現(xiàn)在程序中的位置。返回值void。
(7)異常的處理·
A:try...catch...finally
基本格式：
try {
可能出現(xiàn)異常的代碼
} catch(異常對象){
異常處理代碼
}
finally { 釋放資源 } 變形格式：
try...catch try...catch...catch...try...catch...catch...finally **多個異常同時被捕獲的時候，記住一個原則：
先逮小的，再逮大的。
**finally:永遠被執(zhí)行，除非退出jvm。System.exit(0);面試題2個。
***：final,finally,finalize區(qū)別。
final是最終的意思。它可以用于修飾類，成員變量，成員方法。
它修飾的類不能被繼承，它修飾的變量時常量，它修飾的方法不能被重寫。
finally:是異常處理里面的關(guān)鍵字。
它其中的代碼永遠被執(zhí)行。特殊情況：在執(zhí)行它之前jvm退出。System.exit(0);
finalize:是Object類中的一個方法。
它是于垃圾回收器調(diào)用的方式。
***：假如catch中有return語句，finally里中的代碼會執(zhí)行嗎？
是在return前，還是在return后呢？
會，在return前執(zhí)行finally里面的代碼。
(8)Exception和RuntimeException的區(qū)別
A:Exception:一般性的錯誤，是需要我們編寫代碼進行處理的。
B:RuntimeException:運行時異常，這個我們也不需要處理。
其實就是為了讓他在運行時出問題，然后我們回來修改代碼。
在用throws拋出一個的時候，如果這個異常是屬于RuntimeException的體系的時候，我們在調(diào)用的地方可以不用處理。(RuntimeException和RuntimeException的子類)
在用throws拋出一個的時候，如果這個異常是屬于Exception的體系的時候，我們在調(diào)用的地方必須進行處理或者繼續(xù)拋出。
(9)自定義異常
定義類繼承Exception或者RuntimeException
1,為了讓該自定義類具備可拋性。
2，讓該類具備操作異常的共性方法。
class MyExcepiton extends Exception
{
} MyExcepiton(){} MyExcepiton(String message){ super(message);} class MyException extends RuntimeException { MyExcepiton(){}
} MyExcepiton(String message){ super(message);}(10)throws和throw的區(qū)別
A：有throws的時候可以沒有throw。
有throw的時候，如果throw拋的異常是Exception體系，那么必須有throws在方法上聲明。
B：throws用于方法的聲明上，其后跟的是異常類名，后面可以跟多個異常類，之間用逗號隔開
throw用于方法體中，其后跟的是一個異常對象名
三、多線程：
1、進程和線程：
進程：正在進行的程序。每一個進程執(zhí)行都有一個執(zhí)行順序，該順序是一個執(zhí)行路徑，或者叫一個控制單元。
線程：進程內(nèi)部的一條執(zhí)行路徑或者一個控制單元。
兩者的區(qū)別：
一個進程至少有一個線程
進程在執(zhí)行過程中擁有獨立的內(nèi)存單元，而多個線程共享內(nèi)存；
2、jvm多線程的啟動是多線程嗎？
java的虛擬機jvm啟動的是單線程，就有發(fā)生內(nèi)存泄露的可能，而我們使用java程序沒出現(xiàn)這樣的問題，也就是jvm啟動至少有兩個線程，一個執(zhí)行java程序，一個執(zhí)行垃圾回收。所以是多線程。
2、多線程的優(yōu)勢：
解決了多部分同時運行的問題，提高效率
3、線程的弊端：
線程太多會導致效率的降低，因為線程的執(zhí)行依靠的是CPU的來回切換。
4、什么叫多線程：
一個進程中有多個線程，稱為多線程。
5、實現(xiàn)多線程的方法：
實現(xiàn)多線程可以通過繼承Thread類和實現(xiàn)Runnable接口。
(1)繼承Thread
定義一個類繼承Thread類
復寫Thread類中的public void run()方法，將線程的任務(wù)代碼封裝到run方法中
直接創(chuàng)建Thread的子類對象，創(chuàng)建線程
調(diào)用start()方法，開啟線程(調(diào)用線程的任務(wù)run方法)
//另外可以通過Thread的getName()獲取線程的名稱。
(2)實現(xiàn)Runnable接口；
定義一個類，實現(xiàn)Runnable接口；
覆蓋接口的public void run()的方法，將線程的任務(wù)代碼封裝到run方法中；
創(chuàng)建Runnable接口的子類對象
將Runnabl接口的子類對象作為參數(shù)傳遞給Thread類的構(gòu)造函數(shù)，創(chuàng)建Thread類對象
（原因：線程的任務(wù)都封裝在Runnable接口子類對象的run方法中。
所以要在線程對象創(chuàng)建時就必須明確要運行的任務(wù)）。
調(diào)用start()方法，啟動線程。
兩種方法區(qū)別：
(1)實現(xiàn)Runnable接口避免了單繼承的局限性
(2)繼承Thread類線程代碼存放在Thread子類的run方法中
實現(xiàn)Runnable接口線程代碼存放在接口的子類的run方法中；
在定義線程時，建議使用實現(xiàn)Runnable接口，因為幾乎所有多線程都可以使用這種方式實現(xiàn)
6、創(chuàng)建線程是為什么要復寫run方法？
Thread類用于描述線程。Thread類定義了一個功能，用于存儲線程要運行的代碼，該存儲功能就是run方法。
7、start()和run方法有什么區(qū)別？
調(diào)用start方法方可啟動線程，而run方法只是thread的一個普通方法，調(diào)用run方法不能實現(xiàn)多線程；
Start()方法:
start方法用來啟動線程,實現(xiàn)了多線程運行,這時無需等待run方法體代碼執(zhí)行完畢而直接繼續(xù)執(zhí)行下面的 代碼。通過調(diào)用Thread類的start()方法來啟動一個線程,這時此線程處于就緒(可運行)狀態(tài)，并沒有運行，一旦得到cpu時間片(執(zhí)行權(quán)),就開始執(zhí)行run()方法,這里方法run()稱為線程體，它包含了要執(zhí)行的這個線程的內(nèi)容，Run方法運行結(jié)束,此線程隨即終止。
Run()方法:
run()方法只是Thread類的一個普通方法,如果直接調(diào)用Run方法,程序中依然只有主線程這一個線程，其程序執(zhí)行路徑還是只有一條，還是要等待run方法體執(zhí)行完畢后才可繼續(xù)執(zhí)行下面的代碼，這樣就沒有達到多線程的目的。
8、線程的幾種狀態(tài)：
新建：new一個Thread對象或者其子類對象就是創(chuàng)建一個線程，當一個線程對象被創(chuàng)建，但是沒有開啟，這個時候，只是對象線程對象開辟了內(nèi)存空間和初始化數(shù)據(jù)。
就緒：新建的對象調(diào)用start方法，就開啟了線程，線程就到了就緒狀態(tài)。
在這個狀態(tài)的線程對象，具有執(zhí)行資格，沒有執(zhí)行權(quán)。
運行：當線程對象獲取到了CPU的資源。
在這個狀態(tài)的線程對象，既有執(zhí)行資格，也有執(zhí)行權(quán)。
凍結(jié)：運行過程中的線程由于某些原因(比如wait,sleep)，釋放了執(zhí)行資格和執(zhí)行權(quán)。
當然，他們可以回到運行狀態(tài)。只不過，不是直接回到。
而是先回到就緒狀態(tài)。
死亡：當線程對象調(diào)用的run方法結(jié)束，或者直接調(diào)用stop方法，就讓線程對象死亡，在內(nèi)存中變成了垃圾。
9、sleep()和wait()的區(qū)別：
(1)這兩個方法來自不同的類，sleep()來自Thread類，和wait()來自O(shè)bject類。
(2)sleep是Thread的靜態(tài)類方法，誰調(diào)用的誰去睡覺，即使在a線程里調(diào)用了b的sleep方法，實際上還是a去睡覺，要讓b線程睡覺要在b的代碼中調(diào)用sleep。而wait()是Object類的非靜態(tài)方法
(3)sleep()釋放資源不釋放鎖，而wait()釋放資源釋放鎖；
(4)使用范圍：wait,notify和notifyAll只能在同步控制方法或者同步控制塊里面使用,而sleep可以在任何地方使用
10、多線程安全問題：
(1)原因:當程序的多條語句在操作線程共享數(shù)據(jù)時(如買票例子中的票就是共享資源)，由于線程的隨機性導致
一個線程對多條語句，執(zhí)行了一部分還沒執(zhí)行完，另一個線程搶奪到cpu執(zhí)行權(quán)參與進來執(zhí)行，此時就導致共享數(shù)據(jù)發(fā)生錯誤。比如買票例子中打印重票和錯票的情況。
(2)解決方法:對多條操作共享數(shù)據(jù)的語句進行同步，一個線程在執(zhí)行過程中其他線程不可以參與進來
11、Java中多線程同步是什么？
同步是用來解決多線程的安全問題的，在多線程中，同步能控制對共享數(shù)據(jù)的訪問。如果沒有同步，當一個線程在 修改一個共享數(shù)據(jù)時，而另外一個線程正在使用或者更新同一個共享數(shù)據(jù)，這樣容易導致程序出現(xiàn)錯誤的結(jié)果。
12、什么是鎖?鎖的作用是什么? 鎖就是對象
鎖的作用是保證線程同步，解決線程安全問題。
持有鎖的線程可以在同步中執(zhí)行，沒有鎖的線程即使獲得cpu執(zhí)行權(quán)，也進不去。
13、同步的前提:(1)必須保證有兩個以上線程
(2)必須是多個線程使用同一個鎖，即多條語句在操作線程共享數(shù)據(jù)
(3)必須保證同步中只有一個線程在運行
14、同步的好處和弊端
好處：同步解決了多線程的安全問題
弊端：多線程都需要判斷鎖，比較消耗資源
15、同步的兩種表現(xiàn)形式：
(1)同步代碼塊:
可以指定需要獲取哪個對象的同步鎖,使用synchronized的代碼塊同樣需要鎖,但他的鎖可以是任意對象
考慮到安全問題，一般還是使用同一個對象，相對來說效率較高。
注意：
**雖然同步代碼快的鎖可以使任何對象，但是在進行多線程通信使用同步代碼快時，必須保證同步代碼快的鎖的對象和，否則會報錯。
**同步函數(shù)的鎖是this，也要保證同步函數(shù)的鎖的對象和調(diào)用wait、notify和notifyAll的對象是
同一個對象，也就是都是this鎖代表的對象。
格式：
synchronized(對象)
{
需同步的代碼;
}(2)同步函數(shù)
同步方法是指進入該方法時需要獲取this對象的同步鎖，在方法上使用synchronized關(guān)鍵字，使用this對象作為鎖，也就是使用了當前對象，因為鎖住了方法，所以相對于代碼塊來說效率相對較低。
注:靜態(tài)同步函數(shù)的鎖是該方法所在的類的字節(jié)碼文件對象，即類名.class文件
格式：
修飾詞 synchronized 返回值類型 函數(shù)名(參數(shù)列表)
{
需同步的代碼;
}
在jdk1.5后，用lock鎖取代了synchronized，個人理解也就是對同步代碼塊做了修改，并沒有提供對同步方法的修改，主要還是效率問題吧。
16、多線程的單例設(shè)計模式：保證某個類中內(nèi)存中只有一個對象
(1)餓漢式:
class Single
{
private Single(){}//將構(gòu)造函數(shù)私有化，不讓別的類建立該類對象
private static final Single s=new Single();//自己建立一個對象
public static Single getInstance()//提供一個公共訪問方式
{
return s;
} }(2)懶漢式：
class Single {
private Single(){}
private static Single s;
public static Single getInstance()
{
if(s==null)
s=new Single();
return s;
} } 餓漢式和懶漢式的區(qū)別：
**
餓漢式是類一加載進內(nèi)存就創(chuàng)建好了對象；
懶漢式則是類加載進內(nèi)存的時候，對象還沒有存在，只有調(diào)用了getInstance()方法時，對象才開始創(chuàng)建。
**
懶漢式是延遲加載，如果多個線程同時操作懶漢式時就有可能出現(xiàn)線程安全問題，解決線程安全問題
可以加同步來解決。但是加了同步之后，每一次都要比較鎖，效率就變慢了，所以可以加雙重判斷來提高程序效率。
如將上述懶漢式的Instance函數(shù)改成同步：
public static Single getInstance()
{
if(s==null)
{
synchronized(Single.class)
{
if(s==null)
s=new Single();
}
}
return s;
}
17、死鎖
兩個線程對兩個同步對象具有循環(huán)依賴時，就會發(fā)生死鎖。即同步嵌套同步，而鎖卻不同。
18、wait()、sleep()、notify()、notifyAll()wait():使一個線程處于等待狀態(tài)，并且釋放所持有的對象的lock。
sleep():使一個正在運行的線程處于睡眠狀態(tài)，是一個靜態(tài)方法，調(diào)用此方法要捕捉InterruptedException異常。
notify():喚醒一個處于等待狀態(tài)的線程，注意的是在調(diào)用此方法的時候，并不能確切的喚醒某一個等待狀態(tài)的線程，而是由JVM確定喚醒哪個線程(一般是最先開始等待的線程)，而且不是按優(yōu)先級。
Allnotity():喚醒所有處入等待狀態(tài)的線程，注意并不是給所有喚醒線程一個對象的鎖，而是讓它們競爭。
18、為什么wait()、notify()、notifyAll()這些用來操作線程的方法定義在Object類中？
(1)這些方法只存在于同步中；
(2)使用這些方法時必須要指定所屬的鎖，即被哪個鎖調(diào)用這些方法；
(3)而鎖可以是任意對象，所以任意對象調(diào)用的方法就定義在Object中。
19、多線程間通訊：
多線程間通訊就是多個線程在操作同一資源,但是操作的動作不同.(1)為什么要通信
多線程并發(fā)執(zhí)行的時候, 如果需要指定線程等待或者喚醒指定線程, 那么就需要通信.比如生產(chǎn)者消費者的問題，生產(chǎn)一個消費一個,生產(chǎn)的時候需要負責消費的進程等待,生產(chǎn)一個后完成后需要喚醒負責消費的線程，同時讓自己處于等待，消費的時候負責消費的線程被喚醒，消費完生產(chǎn)的產(chǎn)品后又將等待的生產(chǎn)線程喚醒，然后使自己線程處于等待。這樣來回通信，以達到生產(chǎn)一個消費一個的目的。
(2)怎么通信
在同步代碼塊中, 使用鎖對象的wait()方法可以讓當前線程等待, 直到有其他線程喚醒為止.使用鎖對象的notify()方法可以喚醒一個等待的線程，或者notifyAll喚醒所有等待的線程.多線程間通信用sleep很難實現(xiàn)，睡眠時間很難把握。
20、Lock和Condition 實現(xiàn)提供比synchronized方法和語句可獲得的更廣泛的鎖的操作，可支持多個相關(guān)的Condition對象
Lock是個接口
鎖是控制多個線程對共享數(shù)據(jù)進行訪問的工具。
JDK1.5中提供了多線程升級的解決方案：
將同步synchonized替換成了顯示的Lock操作，將Object中的wait、notify、notifyAll替換成了Condition對象。
該對象可以Lock鎖進行獲取
Lock的方法摘要：
void lock()獲取鎖。
Condition newCondition()返回綁定到此 Lock 實例的新 Condition 實例。
void unlock()釋放鎖。
Condition方法摘要：
void await()造成當前線程在接到信號或被中斷之前一直處于等待狀態(tài)。
void signal()喚醒一個等待線程。
void signalAll()喚醒所有等待線程。
21、停止線程：
stop方法已經(jīng)過時，如何停止線程？
停止線程的方法只有一種，就是run方法結(jié)束。如何讓run方法結(jié)束呢？
開啟多線程運行，運行代碼通常是循環(huán)體，只要控制住循環(huán)，就可以讓run方法結(jié)束，也就是結(jié)束線程。
特殊情況：當線程屬于凍結(jié)狀態(tài)，就不會讀取循環(huán)控制標記，則線程就不會結(jié)束。
為解決該特殊情況，可引入Thread類中的Interrupt方法結(jié)束線程的凍結(jié)狀態(tài)；
當沒有指定的方式讓凍結(jié)線程恢復到運行狀態(tài)時，需要對凍結(jié)進行清除，強制讓線程恢復到運行狀態(tài)
22、interrupt: void interrupt()中斷線程:
中斷狀態(tài)將被清除，它還將收到一個 InterruptedException
22、守護線程(后臺線程)setDaemon(boolean on):將該線程標記為守護線程或者用戶線程。
當主線程結(jié)束，守護線程自動結(jié)束，比如圣斗士星矢里面的守護雅典娜，在多線程里面主線程就是雅典娜，守護線程就是圣斗士，主線程結(jié)束了，守護線程則自動結(jié)束。
當正在運行的線程都是守護線程時，java虛擬機jvm退出；所以該方法必須在啟動線程前調(diào)用；
守護線程的特點：
守護線程開啟后和前臺線程共同搶奪cpu的執(zhí)行權(quán)，開啟、運行兩者都沒區(qū)別，但結(jié)束時有區(qū)別，當所有前臺線程都結(jié)束后，守護線程會自動結(jié)束。
23、多線程join方法：
void join()等待該線程終止。
void join(long millis)等待該線程終止的時間最長為 millis 毫秒。
throws InterruptedException
特點：當A線程執(zhí)行到B線程的join方法時，A就會等待B線程都執(zhí)行完，A才會執(zhí)行
作用: join可以用來臨時加入線程執(zhí)行；
24、多線程優(yōu)先級：yield()方法
yield():暫停當前正在執(zhí)行的線程對象，并執(zhí)行其他線程
setPriority(int newPriority):更改線程優(yōu)先級
int getPriority()返回線程的優(yōu)先級。
String toString()返回該線程的字符串表示形式，包括線程名稱、優(yōu)先級和線程組
(1)MAX_PRIORITY:最高優(yōu)先級(10級)(1)Min_PRIORITY:最低優(yōu)先級(1級)(1)Morm_PRIORITY:默認優(yōu)先級(5級)
25、什么是ThreadLocal類,怎么使用它？
ThreadLocal類提供了線程局部(thread-local)變量。是一個線程級別的局部變量，并非“本地線程”。
ThreadLocal 為每個使用該變量的線程,提供了一個獨立的變量副本，每個線程修改副本時不影響其它線程對象的副本
下面是線程局部變量(ThreadLocal variables)的關(guān)鍵點：
一個線程局部變量(ThreadLocal variables)為每個線程方便地提供了一個單獨的變量。
ThreadLocal 實例通常作為靜態(tài)的私有的(private static)字段出現(xiàn)在一個類中，這個類用來關(guān)聯(lián)一個線程。
當多個線程訪問 ThreadLocal 實例時，每個線程維護 ThreadLocal 提供的獨立的變量副本。
常用的使用可在 DAO 模式中見到，當 DAO 類作為一個單例類時，數(shù)據(jù)庫鏈接(connection)被每一個線程獨立的維護，互不影響。(基于線程的單例)
26、什么時候拋出InvalidMonitorStateException異常?為什么？
調(diào)用 wait()/notify()/notifyAll()中的任何一個方法時，如果當前線程沒有獲得該對象的鎖，那么就會拋出 IllegalMonitorStateException 的異常
也就是說程序在沒有執(zhí)行對象的任何同步塊或者同步方法時，仍然嘗試調(diào)用 wait()/notify()/notifyAll()時。由于該異常是 RuntimeExcpetion 的子類，所以該異常不一定要捕獲(盡管你可以捕獲只要你愿意
作為 RuntimeException，此類異常不會在 wait(),notify(),notifyAll()的方法簽名提及。
27、在靜態(tài)方法上使用同步時會發(fā)生什么事？
同步靜態(tài)方法時會獲取該類的“Class”對象，所以當一個線程進入同步的靜態(tài)方法中時，線程監(jiān)視器獲取類本身的對象鎖，其它線程不能進入這個類的任何靜態(tài)同步方法。
它不像實例方法，因為多個線程可以同時訪問不同實例同步實例方法。
28、當一個同步方法已經(jīng)執(zhí)行，線程能夠調(diào)用對象上的非同步實例方法嗎？
可以，一個非同步方法總是可以被調(diào)用而不會有任何問題。
實際上，Java 沒有為非同步方法做任何檢查，鎖對象僅僅在同步方法或者同步代碼塊中檢查。
如果一個方法沒有聲明為同步，即使你在使用共享數(shù)據(jù)Java照樣會調(diào)用，而不會做檢查是否安全，所以在這種情況下要特別小心。一個方法是否聲明為同步取決于臨界區(qū)訪問(critial section access)，如果方法不訪問臨界區(qū)(共享資源或者數(shù)據(jù)結(jié)構(gòu))就沒必要聲明為同步的。
29、在一個對象上兩個線程可以調(diào)用兩個不同的同步實例方法嗎？
不能，因為一個對象已經(jīng)同步了實例方法，線程獲取了對象的對象鎖。
所以只有執(zhí)行完該方法釋放對象鎖后才能執(zhí)行其它同步方法。30、什么是線程餓死，什么是活鎖？ 線程餓死和活鎖雖然不像死鎖一樣是常見的問題，但是對于并發(fā)編程的設(shè)計者來說就像一次邂逅一樣。
當所有線程阻塞，或者由于需要的資源無效而不能處理，不存在非阻塞線程使資源可用。
JavaAPI 中線程活鎖可能發(fā)生在以下情形：
當所有線程在程序中執(zhí)行 Object.wait(0)，參數(shù)為 0 的 wait 方法。
程序?qū)l(fā)生活鎖直到在相應的對象上有線程調(diào)用 Object.notify()或者 Object.notifyAll()。
當所有線程卡在無限循環(huán)中。
四、集合框架
1：String類：字符串(重點)(1)多個字符組成的一個序列，叫字符串。
生活中很多數(shù)據(jù)的描述都采用的是字符串的。而且我們還會對其進行操作。
所以，java就提供了這樣的一個類供我們使用。
(2)創(chuàng)建字符串對象
A:String():無參構(gòu)造
**舉例：
String s = new String();
s = “hello”;
sop(s);
B:String(byte[] bys):傳一個字節(jié)數(shù)組作為參數(shù) ***** **舉例
byte[] bys = {97,98,99,100,101};
String s = new String(bys);
sop(s);C:String(byte[] bys,int index,int length):把字節(jié)數(shù)組的一部分轉(zhuǎn)換成一個字符串
**舉例
byte[] bys = {97,98,99,100,101};
String s = new String(bys,1,2);
sop(s);D:String(char[] chs):傳一個字符數(shù)組作為參數(shù) ***** **舉例
char[] chs = {'a','b','c','d','e'};
String s = new String(chs);
sop(s);E:String(char[] chs,int index,int length):把字符數(shù)組的一部分轉(zhuǎn)換成一個字符串
**舉例
char[] chs = {'a','b','c','d','e'};
String s = new String(chs,1,2);
sop(s);
*****
*****
F:String(String str):把一個字符串傳遞過來作為參數(shù)
char[] chs = {'a','b','c','d','e'};
String ss = new String(s);
sop(ss);G:直接把字符串常量賦值給字符串引用對象(最常用)***** **舉例
String s = “hello”;
sop(s);(3)面試題
A:請問String s = new String(“hello”);創(chuàng)建了幾個對象。
兩個。一個“hello”字符串對象，在方法區(qū)的常量池；一個s對象，在棧內(nèi)存。
B:請寫出下面的結(jié)果
String s1 = new String(“abc”);
Strign s2 = new String(“abc”);
String s3 = “abc”;
String s4 = “abc”;
sop(s1==s2);//false
sop(s1==s3);//false
sop(s3==s4);//true
C:字符串對象一旦被創(chuàng)建就不能被改變。
指的是字符串常量值不改變。
(4)字符串中各種功能的方法
A:判斷
**** boolean equals(Object anObject):判斷兩個字符串的內(nèi)容是否相同，復寫了Object的方法
**** boolean equalsIgnoreCase(String anotherString):判斷兩個字符串的內(nèi)容是否相同，不區(qū)分大小寫
**** boolean contains(String s):判斷一個字符串中是否包含另一個字符串
注意：判斷字符串是否包含特殊字符.直接表示為str.contains(“.”)
boolean endsWith(String suffix):測試此字符串是否以指定的后綴結(jié)束
boolean startsWith(String suffix):測試此字符串是否以指定的前綴開始
boolean isEmpty():測試字符串是否為空
B:獲取
***** int length():返回此字符串的長度
***** char charAt(int index):返回指定索引處的 char值
***** int indexOf(int ch):返回指定字符在此字符串中第一次出現(xiàn)處的索引。
int indexOf(int ch, int fromIndex):返回在此字符串中第一次出現(xiàn)指定字符處的索引，從指定的索引開始搜索。
int indexOf(String str):返回指定子字符串在此字符串中第一次出現(xiàn)處的索引。
int indexOf(String str, int fromIndex):返回指定子字符串在此字符串中第一次
出現(xiàn)處的索引，從指定的索引開始。
*** int lastIndexOf(int ch)：返回指定字符在此字符串中最后一次出現(xiàn)處的索引。
int lastIndexOf(int ch, int fromIndex)
返回指定字符在此字符串中最后一次出現(xiàn)處的索引,從指定的索引處開始進行反向搜索。
int lastIndexOf(String str)
返回指定子字符串在此字符串中最右邊出現(xiàn)處的索引。
int lastIndexOf(String str, int fromIndex)
返回指定子字符串在此字符串中最后一次出現(xiàn)處的索引，從指定的索引開始反向搜索。
***** String substring(int beginIndex)(注意：該方法substring的String是小寫！！)
返回一個新的字符串，它是此字符串的一個子字符串。
String substring(int beginIndex, int endIndex)(注意該方法的String是小寫！！)
返回一個新字符串，它是此字符串的一個子字符串,包含頭不包含尾。
C:轉(zhuǎn)換
***** byte[] getBytes()：(很常用！)從字符串到字節(jié)數(shù)組的方法
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
將字符從此字符串復制到目標字符數(shù)組。
***** char[] toCharArray()：(很常用！)從字符串到字符數(shù)組的方法 **** static String copyValueOf(char[] data)
返回指定數(shù)組中表示該字符序列的 String。
static String copyValueOf(char[] data, int offset, int count)
數(shù)組
返回指定數(shù)組中表示該字符序列的 String。
***** static String valueOf(數(shù)據(jù)類型):把該數(shù)據(jù)類型的數(shù)據(jù)轉(zhuǎn)換成字符串。*** String toLowerCase()：把字符串轉(zhuǎn)換成小寫
String toUpperCase()：把字符串轉(zhuǎn)換成大寫 *** 字符串的連接
String concat(String str):將指定字符串連接到此字符串的結(jié)尾。D:替換
String replace(char oldChar, char newChar):用新字符替換舊字符(替換所有)String replace(String target, String replacement):用新的子串換舊串 E:分割
String[] split(String regex)：根據(jù)指定的字符串把一個字符串分割成一個字符串F:
String trim():去除字符串的前后空格
G:
int compareTo(String anotherString)
按字典順序比較兩個字符串。
int compareToIgnoreCase(String str)
按字典順序比較兩個字符串，不考慮大小寫。
(5)練習
1:模擬登錄,給三次機會,并提示還有幾次.默認的用戶名和密碼為admin。區(qū)分大小寫。
自己從鍵盤輸入用戶名和密碼。
2:給定一個字符串統(tǒng)計,統(tǒng)計大寫字母,小寫字母,數(shù)字出現(xiàn)的個數(shù).***注意:不包括特殊字符
從鍵盤輸入一個不包含特殊字符的字符串(只有26個字母和0-9組成)。3:給定一個字符串,把它變成首字母大寫,其他字母小寫的字符串.從鍵盤輸入一個字符串，全部26個字母組成的。
4:子串在整串中出現(xiàn)的次數(shù)。
也就是說:獲取一個字符串中,指定的字串在該字符串中出現(xiàn)的次數(shù).例如: “nbasdnbafllgnbahjnbakqqqqlnba” 在這個字符串中，多有個nba.5:對字符串中字符進行自然順序排序。“basckd”-->“abcdks” 先留做思考內(nèi)容：
6:兩個字符串的最大相同子串。兩個字符串的最大相同子串。比如: “sadabcdfghjkl” werabcdtyu“ 2：StringBuffer(1)字符串的緩沖區(qū)，是一個容器。
(2)它和String的區(qū)別
它是緩沖區(qū)可變長度的。
(3)構(gòu)造方法
StringBuffer()構(gòu)造一個其中不帶字符的字符串緩沖區(qū)，初始容量為 16 個字符。
StringBuffer(int num)構(gòu)造一個不帶字符，但具有指定初始容量的字符串緩沖區(qū)。
StringBuffer(String str)構(gòu)造一個字符串緩沖區(qū)，并將其內(nèi)容初始化為指定的字符串內(nèi)容。
(4)常用方法
A:增加數(shù)據(jù)
**append ：添加各種類型的數(shù)據(jù)
**insert : 在容器指定位置插入各種類型的數(shù)據(jù)。
B:刪除數(shù)據(jù)
**deleteCharAt : 刪除指定位置的字符
**delete 還可以用于清空StringBuffer的緩沖區(qū)
C:替換
**replace
D:獲取
**charAt
E:長度和容量
**length()元素的個數(shù)
**capacity 元素的理論值 F:獲取元素的位置
**indexOf **lastIndexOf G:截取
**substring(int start)**substring(int start,int end)
H:反轉(zhuǎn)
**reverse(5)字符串和StringBuffer的轉(zhuǎn)換
String-->StringBuffer通過構(gòu)造:
如:StringBuffer sb = new StringBuffer(String str)
StringBuffer--String通過toString方法
如:StringBuffer sb = new StringBuffer();
sb.toString();
3：StringBuilder 和StringBuffer的功能是一樣的，但是有區(qū)別：
StringBuffer(JDK1.0)是線程安全的。
StringBuilder(JDK1.5)不保證線程安全。
一般來說，我們寫的程序都是單線程的，所以，用StringBuilder，效率高。
JDK版本的升級原則： A:提高效率 B:提高安全性 C:簡化書寫
4：基本數(shù)據(jù)類型的對象包裝類
(1)為了更方便的操作每個基本數(shù)據(jù)類型，java對其提供了很多的屬性和方法供我們使用。
(2)用途：
**將基本數(shù)據(jù)類型封裝成對象的好處在于可以在對象中定義更多的功能操作該數(shù)據(jù)。
**常用的操作之一：用于基本數(shù)據(jù)類型與字符串之間的轉(zhuǎn)換。
A:方便操作
B:用于和字符串進行相互轉(zhuǎn)換
(3)基本數(shù)據(jù)類型和對象類型的對應
byte Byte
short Short
int Integer
long Long
float double boolean char Float Double Boolean Character(4)構(gòu)造方法
字段摘要：
static int MAX_VALUE 值為 2^31-1 的常量，它表示 int 類型能夠表示的最大值
static int MIN_VALUE 值為-2^31 的常量，它表示 int 類型能夠表示的最小值
static Class
Integer(int value)構(gòu)造一個新分配的Integer對象，它表示指定的int值。
Inreger(String s)注意：s必須是純數(shù)字的字符串。否則會有異常NumberFormatException
(5)幾個常用的方法
Integer.toBinaryString();
以二進制（基數(shù) 2）無符號整數(shù)形式返回一個整數(shù)參數(shù)的字符串表示形式。
Integer.toOctalString();以八進制（基數(shù) 8）無符號整數(shù)形式返回一個整數(shù)參數(shù)的字符串表示形式。Integer.toHexString();
以十六進制（基數(shù) 16）無符號整數(shù)形式返回一個整數(shù)參數(shù)的字符串表示形式。
static int Integer.parseInt(String s)將字符串參數(shù)作為有符號的十進制整數(shù)進行解析，字符串必須是int型范圍內(nèi)的數(shù)字字符串
static int Integer.parseInt(String s,int basic)
使用第二個參數(shù)指定的基數(shù),將字符串參數(shù)解析為有符號的整數(shù).字符串必須是int型范圍內(nèi)的數(shù)字字符串
short shortValue()以short類型返回該Integer的值。
int intValue()以int類型返回該Integer的值。
static Integer valueOf(int num)返回一個表示指定的 int 值的 Integer 實例。
static Integer valueOf(String s)返回保存指定的String的值的Integer對象。
static Integer valueOf(String s, int radix)
返回一個Integer對象，該對象中保存了用第二個參數(shù)提供的基數(shù)進行
解析時從指定的String中提取的值。
(6)類型轉(zhuǎn)換
int--Integer
int num = 20;
A:Integer i = new Integer(num);
B:Integer i = Integer.valueOf(num);
Integer--int
Integer i = new Integer(20);
A:int num = i.intValue();
int--String int num = 20;A:String s = String.valueOf(num);B:String s = ”“+num;C:String s = Integer.toString(num);String--int String s = ”20“;A:int num = Integer.parseInt(s);
B:Integer i = new Integer(s);或者Integer i = Integer.valueOf(s);
int num = i.intValue();
6、集合框架：
(1)為什么出現(xiàn)集合類？
面向?qū)ο髮κ挛锏捏w現(xiàn)都是以對象的形式，為了方便對多個對象的操作，就對對象進行存儲。
集合就是存儲對象最常用的一種方式.(2)數(shù)組和集合都是容器，兩者有何不同？
**數(shù)組長度固定，而集合長度是可變的**數(shù)組值可以存儲對象，還可以存儲基本數(shù)據(jù)類型;而集合只能存儲對象
**數(shù)組存儲數(shù)據(jù)類型是固定的，而集合存儲的數(shù)據(jù)類型不固定
(3)集合類的特點：
集合只能存儲對象
集合的長度是可變的 集合可以存儲不同類型的對象
(4)集合類框架(重要！！要分清幾種容器間的區(qū)別)：
**Collection:頂層接口
|--->List:列表，元素是有序的(元素帶角標索引)，可以有重復元素,可以有null元素。
|--->ArrayList(JDK1.2):底層的數(shù)據(jù)結(jié)構(gòu)是數(shù)組數(shù)據(jù)結(jié)構(gòu)，特點是查詢速度快(因為帶角標)，但是增刪速度稍慢,因為當元素多時，增刪一個元素則所有元素的角標都得改變
線程不同步。默認長度是10，當超過長度時，按50%延長集合長度。
|--->LinkedList(JDK1.2):底層數(shù)據(jù)結(jié)構(gòu)式鏈表數(shù)據(jù)結(jié)構(gòu)(即后面一個元素記錄前一個)，特點：查詢速度慢，因為每個元素只知道前面一個元素，但增刪速度快
因為元素再多，增刪一個，只要讓其前后的元素重新相連即可
線程是不同步的。
|--->Vector(JDK1.0):底層數(shù)據(jù)結(jié)構(gòu)是數(shù)組數(shù)據(jù)結(jié)構(gòu).特點是查詢和增刪速度都很慢。
默認長度是10，當超過長度時,按100%延長集合長度。
線程同步。
(Vector功能跟ArrayList功能一模一樣，已被ArrayList替代)
**List使用注意！
|--->ArrayList:(1)當往ArrayList里面存入元素沒什么要求時，即只要求有序就行時；
(2)當往ArrayList里面存入元素要求不重復時，比如存入學生對象，當同名同姓時
視為同一個人，則不往里面存儲。則定義學生對象時，需復寫equals方法
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
return false;
Student stu =(Student)obj;
return this.name.equals(stu.name)&&this.age==stu.age;
}
則往ArrayList集合通過add存入學生對象時，集合底層自己會調(diào)用學生類的equals方法，判斷重復學生則不存入。
注：對于List集合，無論是add、contains、還是remove方法，判斷元素是否相同，都是通過復寫equals方法來判斷！
|--->LinkedList
(1)LinkLedist的特有方法：
boolean offerFirst(E e)在此列表的開頭插入指定的元素。
boolean offerLast(E e)在此列表末尾插入指定的元素。
E peekFirst()獲取但不移除此列表的第一個元素；如果此列表為空，則返回 null。
E peekLast()獲取但不移除此列表的最后一個元素；如果此列表為空，則返回 null。
E pollFirst()獲取并移除此列表的第一個元素；如果此列表為空，則返回 null。
E pollLast()獲取并移除此列表的最后一個元素；如果此列表為空，則返回 null。
(2)通過LinkLedist的特有方法，可以實現(xiàn)某些數(shù)據(jù)特殊方式的存取，比如堆棧和隊列。
一般情況下，使用哪種List接口下的實現(xiàn)類呢？
如果要求增刪快，考慮使用LinkedList
如果要求查詢快，考慮使用ArrayList
如果要求線程安全，考慮使用Vector。
|--->Set:集合，元素是無序的(因為沒有索引)，元素不可以重復。可以有null元素。
|--->HashSet(JDK1.2):底層數(shù)據(jù)結(jié)構(gòu)是哈希表、存取速度快、元素唯
一、線程不同步。
保證性元素唯一的原理:
先判斷元素的hashCode值是否相同，再判斷兩元素的equals方法是否為true
(往HashSet里面存的自定義元素要復寫hashCode和equals方法，以保證元素的唯一性！)
|--->TreeSet:底層數(shù)據(jù)結(jié)構(gòu)式二叉樹。可以對Set集合中的元素進行排序。元素有序、線程不同步。
保證元素唯一性的依據(jù)：compareTo方法return 0
TreeSet排序的第一種方式:讓元素自身具備比較性，比如八種基本數(shù)據(jù)類型或則字符串，實現(xiàn)Compareble接口,覆蓋compareTo方法，此方式是元素的自然順序
TreeSet排序的第一種方式:當元素自身不具備比較性(比如存儲學生對象時)或者具備的比較性不是我們所需要的比較性時(比如想字符串的長度排序)，此時就需要讓集合自身具備自定義的比較性。
那如何讓集合自身具備比較性呢？可在集合初始化時，就讓集合具備比較方式。即定義一個類，實現(xiàn)Comparator接口，覆蓋compare方法。
**Set集合使用注意事項：
(1)HashSet:
通過new的方式往HashSet里面存的元素的hashCode都不同，但通常我們定義對象，比如學生對象時，雖然是new的兩個學生對象，但是當他們name和age一樣時，我們認為是
同一個對象，所以為了保證元素的唯一性，我們通常在往HashSet集合里面存儲元素時，在定義對象的類中通常復寫hashCode和equals方法。
public int hashCode()
{
return name.hashCode()+age*39;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
return false;
Student stu =(Student)obj;
return this.name.equals(stu.name)&&this.age==stu.age;
}
HashSet是如何保證元素唯一性的呢？
**如果兩元素的hashCode值不同，則不會調(diào)用equals方法
**如果兩元素的hashCode值相同，則繼續(xù)判斷equals是否返回true；
**hashCode和equals方法雖然定義在自定義對象類里面，但不是我們手動調(diào)用
而是往HashSet集合里面存儲元素的時候，集合底層自己調(diào)用hashCode和equals
它自己拿對象去判斷，自己判斷兩元素是否是同一個元素。
(2)TreeSet:
TreeSet要求往里面存的元素具備比較性，否則會報錯。
TreeSet排序的第一種方式:讓元素自身具備比較性
定義對象類，實現(xiàn)Compareble接口,復寫compareTo方法，此方式是元素的自然順序
class Student implements Comparable
{
private String name;
private int age;
public Student(String name,int age)
{
this.name=name;
this.age=age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public int compareTo(Object obj)
{
if(!(obj instanceof Student))
throw new RuntimeException(”不是學生對象！“);
Student stu =(Student)obj;
int num = this.age-stu.age;
if(num==0)
}
}
return this.name.compareTo(stu.name);return num;
TreeSet排序的第一種方式:讓集合具備比較性
當元素自身不具備比較性(比如存儲學生對象時)或者具備的 比較性不是我們所需要的比較性時(比如想字符串的長度排序)，此時就需要讓集合自身具備自定義的比較性。
那如何讓集合自身具備比較性呢？可在集合初始化時，就讓集合具備比較方式。即定義一個類，實現(xiàn)Comparator接口，覆蓋compare方法。
class StringLengthComparator implements Comparator
{
public int compare(Object obj1,Object obj2)
{
String s1 =(String)obj1;
String s2 =(String)obj2;
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num==0)
return s1.compareTo(s2);
return num;
}
}
class TreeSetTest
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new StringLengthComparator());
ts.add(”addfg“);
ts.add(”dfg“);
ts.add(”agtuug“);
ts.add(”vgjkg“);
sop(ts);
}
}
基本數(shù)據(jù)類型或字符串對象均實現(xiàn)了Comparable接口，故同種類型基本數(shù)據(jù)間具備比較性，即自然順序。
**Map:頂層接口,該集合存儲的是鍵值對,而且鍵是唯一的,Map和Set很像,Set集合底層就是使用了Map集合。
Map集合沒有迭代器，要取出元素必須先將Map集合轉(zhuǎn)換成Set集合才能遍歷元素
|--->HashTable(JDK1.0):
底層是哈希表數(shù)據(jù)結(jié)構(gòu)；
不可以使用null鍵和null值；
用作鍵的對象必須實現(xiàn)hashCode和equals方法來保證鍵的唯一性
線程同步，效率低
|--->HashMap(JDK1.2):
底層是哈希表數(shù)據(jù)結(jié)構(gòu)；
允許使用null鍵和null值；
線程不同步，效率高；
保證元素唯一性的:
原理：先判斷元素的hashCode值是否相同，再判斷兩元素的equals方法是否為true
(往HashSet里面存的自定義元素要復寫hashCode和equals方法，以保證元素的唯一性！)
class Student {
private String name;
private int age;
public Student(String name, int age){
super();
this.name = name;
this.age = age;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
@Override
public int hashCode(){
return name.hashCode()+age*34;
}
@Override
public boolean equals(Object obj){
if(!(obj instanceof Student))
return false;
Student stu =(Student)obj;
return this.name.equals(stu.name)&&this.age==stu.age;
} public class HashMapDemo1 {
public static void main(String[] args){
Map
hmap.put(new Student(”001“,20), ”beijing“);
hmap.put(new Student(”002“,25), ”hebei“);
hmap.put(new Student(”003“,50), ”hainan“);
hmap.put(new Student(”001“,20), ”beijing“);
System.out.println(hmap.size());
Set
Iterator
while(it.hasNext()){
Student stu = it.next();
String addr = hmap.get(stu);
System.out.println(stu.getName()+”..“+stu.getAge()+”::“+addr);
}
}
}
|--->TreeMap(JDK1.0):
底層是二叉樹結(jié)構(gòu)；
允許使用null鍵和null值；
線程不同步；
可以給Map集合中的鍵進行排序.TreeMap排序的第一種方式:讓元素自身具備比較性，比如八種基本數(shù)據(jù)類型或則字符串，實現(xiàn)Compareble接口,覆蓋compareTo方法，此方式是元素的自然順序
TreeMap排序的第一種方式:當元素自身不具備比較性(比如存儲學生對象時)或者具備的比較性不是我們所需要的比較性時(比如想字符串的長度排序)，此時就需要讓集合自身具備自定義的比較性。
那如何讓集合自身具備比較性呢？可在集合初始化時，就讓集合具備比較方式。即定義一個類，實現(xiàn)Comparator接口，覆蓋compare方法。
class Student implements Comparable
private String name;
private int age;
public Student(String name, int age){
} super();this.name = name;this.age = age;} public int getAge(){ return age;} public void setAge(int age){ this.age = age;} public String getName(){ return name;} public void setName(String name){ this.name = name;} @Override public int compareTo(Student stu){ int num = new Integer(this.age).compareTo(new Integer(stu.age));if(num==0)
return this.name.compareTo(stu.name);return num;}
public class HashMapDemo1 { public static void main(String[] args){
Map
tmap.put(new Student(”001“,20), ”beijing“);
tmap.put(new Student(”002“,25), ”hebei“);
tmap.put(new Student(”003“,50), ”hainan“);
tmap.put(new Student(”001“,20), ”beijing“);
System.out.println(tmap.size());
Set
Iterator
while(it1.hasNext()){
Student stu = it1.next();
String addr = tmap.get(stu);
System.out.println(stu.getName()+”..“+stu.getAge()+”::“+addr);
} } }
**Iterator：對collection進行迭代的迭代器.迭代器取代了Enumeration。
迭代器和枚舉的區(qū)別：
迭代器允許調(diào)用者利用定義良好的語義在迭代期間從迭代器所指向的collection移除元素
方法名稱得到了改進，簡化書寫
**LisIterator：系列表迭代器，允許程序員按任一方向遍歷列表、迭代期間修改列表
**Comparable：此接口強行對實現(xiàn)它的每個類的對象進行整體自然排序。使元素具備比較性
**Comparator：強行對某個對象collection進行整體排序的比較函數(shù)，使集合具備比較性
**Collections：此類完全由在 collection 上進行操作或返回 collection 的靜態(tài)方法組成。
**Arrays：此類包含用來操作數(shù)組(比如排序和搜索)的各種靜態(tài)方法
7、集合類各容器方法：
**接口Collection方法摘要(沒有構(gòu)造方法)
a)添加：
i.boolean add(E e)
j.boolean addAll(Collection c)b)刪除：
i.void clear():清空容器
j.boolean remove(Objec object):
k.boolean removeAll(Collection c):
c)判斷：
i.boolean contains(Object object):判斷是否包含此元素
j.boolean containsAll(Collection c):判斷是否包含一堆元素
k.boolean equals(Object object):比較此collection與指定對象是否相等
m.boolean isEmpty():判斷是否集合為空
d)獲取：
h.Iterator iterator():取出
i.int hashCode():返回此collection的哈希值
j.int size():返回此collection中元素的個數(shù)
k.boolean retainAll(Collection c):取交集
m.Object toArray():返回此collection中所有元素的數(shù)組
n.T[] toArray(T[] a):返回包含此collection中所有元素的數(shù)值。*****List集合子類及其方法
(1)List接口是Collection接口的一個子接口。
(2)List接口中的元素有如下特點(對角標的操作都是特有方法，因為有序)：
A:元素有序(存儲順序和取出順序一致)
B:元素可以重復
(3)List接口中的特有方法
A:add(int index,Object obj):在指定位置加入元素
B:remove(int index):移除指定位置的元素
C:set(int index,Object obj):修改指定位置的元素
D:get(int index):獲取指定位置的元素
E:indexOf(Object obj):獲取指定元素的位置
F:subList(int start,int end):從一個大的List中截取一個小的List
G:listIterator():返回一個List接口特有的迭代器(1)、ArrayList：
|--->構(gòu)造方法摘要：(少用，不是重點)ArrayList()：構(gòu)造一個初始容量為 10 的空列表。
ArrayList(Collection c)： 構(gòu)造一個包含指定 collection 的元素的列表，ArrayList(int initialCapacity)： 構(gòu)造一個具有指定初始容量的空列表。
|--->方法摘要：
|--->添加：
boolean add(E e)： 將指定的元素添加到此列表的尾部。
void add(int index, E element)： 將指定的元素插入此列表中的指定位置。
boolean addAll(Collection c):按照指定 collection 的迭代器所返回的元素順序，將該 collection 中的所有元素添加到此列表的尾部
boolean addAll(int index, Collection c)： 從指定的位置開始，將指定 collection
中的所有元素插入到此列表中。
|--->刪除：
void clear(): 移除此列表中的所有元素。
E remove(int index): 移除此列表中指定位置上的元素。
boolean remove(Object o): 移除此列表中首次出現(xiàn)的指定元素（如果存在）。
protected void removeRange(int fromIndex, int toIndex):
移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之間的所有元素。
boolean removeAll(Collection c): 從列表中移除指定 collection 中包含的其所有元素
|--->獲取：
E get(int index): 返回此列表中指定位置上的元素。
int indexOf(Object o): 返回此列表中首次出現(xiàn)的指定元素的索引，或如果此列表不包含元素，則返回-1。
int lastIndexOf(Object o)返回此列表中最后一次出現(xiàn)的指定元素的索引，或如果此列表不包含索引，則返回-1。
public List
和 toIndex（不包括）之間的部分視圖。
Iterator
ListIterator
|--->修改：(特有方法！)
E set(int index, E element): 用指定的元素替代此列表中指定位置上的元素。
(2)LinkedList: |--->構(gòu)造方法摘要：
LinkedList(): 構(gòu)造一個空列表。
LinkedList(Collection c): 構(gòu)造一個包含指定 collection 中的元素的列表，這些元素按其 collection 的迭代器返回的順序排列。
|--->方法摘要:(特有的)
|--->添加
void addFirst(E e): 將指定元素插入此列表的開頭。
void addLast(E e): 將指定元素添加到此列表的結(jié)尾。
|--->獲取元素，但不刪除元素
E get(int index): 返回此列表中指定位置處的元素。
E getFirst(): 返回此列表的第一個元素。
E getLast(): 返回此列表的最后一個元素。
|--->獲取元素且刪除元素
E remove()： 獲取并移除此列表的頭（第一個元素）。
E remove(int index)： 移除此列表中指定位置處的元素。
boolean remove(Object o)： 從此列表中移除首次出現(xiàn)的指定元素（如果存在）。
E removeFirst()： 移除并返回此列表的第一個元素。
E removeLast(): 移除并返回此列表的最后一個元素。
|--->修改
E set(int index, E element)將此列表中指定位置的元素替換為指定的元素。
(3)Vector |--->構(gòu)造方法摘要：
Vector(): 構(gòu)造一個空向量，使其內(nèi)部數(shù)據(jù)數(shù)組的大小為 10，其標準容量增量為零。
Vector(Collection c): 構(gòu)造一個包含指定 collection 中的元素的向量，這些元素按其 collection 的迭代器返回元素的順序排列。
|--->方法摘要：
|--->添加：
boolean add(E e): 將指定元素添加到此向量的末尾。
void add(int index, E element): 在此向量的指定位置插入指定的元素。
boolean addAll(Collection c):
將指定 Collection 中的所有元素添加到此向量的末尾，按照指定 collection 的迭代器所返回的順序添加這些元素。
boolean addAll(int index, Collection c): 在指定位置將指定 Collection 中的所有元素插入到此向量中。
|--->獲取:
Enumeration
Vector特有的取出方式:
枚舉和迭代器很像，其實枚舉和迭代器是一樣的，只是因為枚舉的名稱和方法的名稱
名字都過長，所以枚舉被迭代器取代了。
|--->枚舉Enumeration的方法摘要：
boolean hasMoreElements(): 測試此枚舉是否包含更多的元素。
E nextElement(): 如果此枚舉對象至少還有一個可提供的元素，則返回此枚舉的下一個元素。
*****Set集合子類及其方法
(1)HashSet:它不保證set的迭代順序;特別是它不保證該順序恒久不變.此類允許使用null元素。
|--->構(gòu)造方法：
HashSet()構(gòu)造一個新的空 set，其底層 HashMap 實例的默認初始容量是 16，加載因子是 0.75。
HashSet(Collection c)構(gòu)造一個包含指定 collection 中的元素的新 set。
|--->方法摘要：
boolean add(E e)如果此 set 中尚未包含指定元素，則添加指定元素。
void clear()從此 set 中移除所有元素。
Object clone()返回此 HashSet 實例的淺表副本：并沒有復制這些元素本身。
boolean contains(Object o)如果此 set 包含指定元素，則返回 true。
boolean isEmpty()如果此 set 不包含任何元素，則返回 true。
Iterator
boolean remove(Object o)如果指定元素存在于此 set 中，則將其移除。
int size()返回此 set 中的元素的數(shù)量（set 的容量）。
(2)TreeSet:使用元素的自然順序?qū)υ剡M行排序，或者根據(jù)創(chuàng)建 set 時提供的 Comparator 進行排序.|--->構(gòu)造方法：
TreeSet()構(gòu)造一個新的空 set，該set根據(jù)其元素的自然順序進行排序。
TreeSet(Collection c)
構(gòu)造一個包含指定 collection 元素的新 TreeSet，它按照其元素的自然順序進行排序。
TreeSet(Comparator comparator)構(gòu)造一個新的空 TreeSet，它根據(jù)指定比較器進行排序。
|--->方法摘要：
添加：
boolean add(E e)將指定的元素添加到此 set（如果該元素尚未存在于 set 中）。
boolean addAll(Collection c)將指定 collection 中的所有元素添加到此 set 中。
刪除：
void clear()移除此 set 中的所有元素。
boolean remove(Object o)將指定的元素從 set 中移除（如果該元素存在于此 set 中）。
E pollFirst()獲取并移除第一個（最低）元素；如果此 set 為空，則返回 null。
E pollLast()獲取并移除最后一個（最高）元素；如果此 set 為空，則返回 null。
獲取：
Iterator
E first()返回此 set 中當前第一個（最低）元素。
E last()返回此 set 中當前最后一個（最高）元素。
int size()返回 set 中的元素數(shù)（set 的容量）。
判斷：
boolean isEmpty()如果此 set 不包含任何元素，則返回 true。
boolean contains(Object o)如果此 set 包含指定的元素，則返回 true。
**Map:將鍵映射到值的對象。Map集合沒有迭代器！Map集合特點：該集合存儲鍵值對。而且鍵是唯一的。
|--->方法摘要：
|--->添加：
V put(K key, V value)將指定的值與此映射中的指定鍵關(guān)聯(lián)（可選操作）。
void putAll(Map m)從指定映射中將所有映射關(guān)系復制到此映射中
|--->刪除：
void clear()從此映射中移除所有映射關(guān)系（可選操作）。
V remove(Object key)如果存在一個鍵的映射關(guān)系，則將其從此映射中移除（可選操作）。
|--->判斷
boolean containsKey(Object key)如果此映射包含指定鍵的映射關(guān)系，則返回 true。
boolean containsValue(Object value)如果此映射將一個或多個鍵映射到指定值，則返回 true。
boolean isEmpty()如果此映射未包含鍵-值映射關(guān)系，則返回 true。
|--->獲取
int size()返回此映射中的鍵-值映射關(guān)系數(shù)。
Collection
重點：Map集合沒有迭代器，以下是Map的兩種取出方式：
第一種：Set
返回此映射中包含的鍵的Set視圖，將Map集合中所有的鍵存入Set集合，然后再通過Set集合的 迭代器取出所有的鍵，再根據(jù)get方法獲取每個鍵的值；
第二種：Set
返回此映射中包含的映射關(guān)系的Set視圖，將Map集合中的映射關(guān)系存入到Set集合中，這個映射關(guān)系的數(shù)據(jù)類型是Map.entry,再通過Map.Entry類的方法再要取出關(guān)系里面的鍵和值
Map.Entry的方法摘要：
boolean equals(Object o)比較指定對象與此項的相等性。
K getKey()返回與此項對應的鍵。
V getValue()返回與此項對應的值。
int hashCode()返回此映射項的哈希碼值。
V setValue(V value)用指定的值替換與此項對應的值(特有！！)。
8、Map集合和Collection集合的區(qū)別？
1，Map中一次存儲是鍵值對。
Collection中一次存儲是單個元素。2，Map的存儲使用的put方法。
Collection存儲使用的是add方法。
3，Map集合沒有迭代器，Map的取出，是將Map轉(zhuǎn)成Set，在使用迭代器取出。
Collection取出，使用就是迭代器。
4，如果對象很多，必須使用集合存儲。
如果元素存在著映射關(guān)系，可以優(yōu)先考慮使用Map存儲或者用數(shù)組，如果沒有映射關(guān)系，可以使用Collection存儲。
8、迭代器：Iterator(Map集合沒有迭代器)(1)迭代器就是取出集合元素的方式
(2)迭代器的作用
因為每個集合中元素的取出方式都不一樣，于是就把元素的取出方式進行抽取，并定義在集合內(nèi)部，這樣取出方式就可以直接訪問集合內(nèi)部的元素；
而每個容器的數(shù)據(jù)結(jié)構(gòu)不同，所以取出動作的細節(jié)也不一樣，但是有共性內(nèi)容：判斷和取出。
那么就將共性內(nèi)容進行抽取，從而形成了接口Iterater(3)獲取迭代器的方法：
Iterator
Iterator
(3)迭代器方法：
boolean hasNext()如果仍有元素可以迭代,則返回 true。
E next()返回迭代的下一個元素。
void remove()從迭代器指向的collection中移除迭代器返回的最后一個元素（可選操作）。
9、列表迭代器：ListIterator(1)List集合特有的迭代器ListIterator是Iterator的子接口，在迭代時，不可以通過集合對象的 方法操作集合中的元素，因為會發(fā)生ConcurrentModificationException(當方法檢測到對象的并發(fā)修改，但不允許這種修改時，拋出此異常)(2)Iterator方法有限，只能對元素進行判斷、取出和刪除的操作
ListIterator可以對元素進行添加和修改動作等。
(3)獲取列表迭代器方法：
ListIterator
ListIterator
返回此列表中的元素的列表迭代器（按適當順序），從列表中指定位置開始。
(4)列表迭代器方法：
void add(E e)將指定的元素插入列表（可選操作）。
boolean hasPrevious()如果以逆向遍歷列表，列表迭代器有多個元素，則返回 true。
int nextIndex()返回對 next 的后續(xù)調(diào)用所返回元素的索引。
E previous()返回列表中的前一個元素。
int previousIndex()返回對 previous 的后續(xù)調(diào)用所返回元素的索引。
void set(E e)用指定元素替換 next 或 previous 返回的最后一個元素（可選操作）。
10、堆棧和隊列
堆棧：先進后出，比如杯子里的水
隊列：先進先出，比如水管的水
11、集合類各種容器的使用注意細節(jié)：
(1)迭代器：
**迭代器的next方法是自動向下取元素，要避免出現(xiàn)NoSuchElementException。
也就是在迭代循環(huán)中調(diào)用一次next方法一次就要hasNext判斷一次，比如語句
sop(it.next()+”..."+it.next())會發(fā)生上述異常。
**迭代器的next方法返回值類型是Object，所以要記得類型轉(zhuǎn)換,應用泛型后就不用強轉(zhuǎn)
(2)List集合：
**List集合里面的元素因為是帶角標，所以List集合里面的元素都是有序的，另外List集合可以包含重復元素，也可以包含null。
**List集合有迭代器Iterator，還有一個特有迭代器列表ListIterator
**List集合中判斷元素是否相同都是用equals方法，無論contains、remove都依賴equals方法
比如往ArrayList集合里面存放學生，同名同年齡視為同一個人，此時就需要在學生類復寫Object類
里面的equals方法(非常重要！！要注意！)(3)Set集合：
**Set接口里面存放的是元素是無序的，不可以有重復元素，可以包含null
**Set集合只有一種取出方式，就是迭代器Iterator
**Set集合功能和Collection是一致的，沒有特殊方法
|--->HashSet:
**集合里面存放的元素是無序的，唯一的 **底層數(shù)據(jù)結(jié)構(gòu)是哈希表，哈希表結(jié)構(gòu)的數(shù)據(jù)都是無序的，哈希表結(jié)構(gòu)的操作效率都高效
**線程不同步
**保證元素唯一性的原理是：通過復寫hashCode和equals方法
****如果兩元素的hashCode值相同，則繼續(xù)判斷兩元素equals是否為真
****如果兩元素的hashCode值不同，則不會調(diào)用equals方法。
**當我們往HashSet集合存放自定義的元素時(比如學生對象)，通常都要復寫hashCode和equals方法，而且hashCode和equals方法不通過我們調(diào)用，HashSet集合底層內(nèi)部自己調(diào)用，自己拿元素去比較
|--->TreeSet
**TreeSet集合可以對存放的元素進行排序，彌補了Set集合元素無序的缺點，且元素是唯一的 **底層數(shù)據(jù)結(jié)構(gòu)是二叉樹，二叉樹結(jié)構(gòu)都是有序的 **線程不同步
**TreeSet集合要求往集合里存放的元素自身具備比較性，否則會報錯
**TreeSet集合保證元素唯一性的依據(jù)是：通過compareTo或者compare方法中的來保證元素的唯一性。
TreeSet排序的第一種方式:讓元素自身具備比較性，定義元素類實現(xiàn)Compareble接口，覆蓋compare方法，此方式是元素的自然順序。
TreeSet排序的第二種方式:讓集合具備比較性
當元素自身不具備比較性或者具備的比較性不是
我們所需要的比較性時，此時就需要讓集合具備自定義的比較性。
那如何讓集合自身具備比較性呢？
可在集合初始化時，就讓集合具備比較方式。
即定義一個類，實現(xiàn)Comparator接口，覆蓋compare方法。
注：
**判斷元素唯一時，當主要條件一樣時，判斷次要條件
**兩種排序方式都在時，以比較器為主！！
(4)Map集合：
|--Hashtable
底層是哈希表結(jié)構(gòu)
線程安全的，并且鍵和值不能為null。|--HashMap
底層是哈希表結(jié)構(gòu)
線程不安全的，鍵和值可以為null。
|--LinkedHashMap
底層是鏈表和哈希表
線程不安全
|--TreeMap
底層是二叉樹
線程不安全的
12、如果你想將一組對象按一定順序存取，在不考慮并發(fā)訪問的情況下會使用____C_____ ，反之則會使用____A_____；如果你想存儲一組無序但唯一的對象，你會使用___B______;
如果你想按關(guān)鍵字對對象進行存取，在不考慮并發(fā)訪問的情況下會使用___D______ ,反之則會使用_____E____。A.Vector B.HashSet C.ArrayList D.HashMap E.Hashtable
13、泛型：
(1)為什么會出現(xiàn)泛型？
因為集合存放的數(shù)據(jù)類型不固定，故往集合里面存放元素時，存在安全隱患，如果在定義集合時，可以想定義數(shù)組一樣指定數(shù)據(jù)類型，那么就可以解決該類安全問題。
JDK1.5后出現(xiàn)了泛型，用于解決集合框架的安全問題。
泛型是一個類型安全機制。
(2)泛型定義格式：通過<>來定義要操作的引用數(shù)據(jù)類型
ArrayList
**將運行時期出現(xiàn)的ClassCastException(類型轉(zhuǎn)換異常)問題轉(zhuǎn)移到編譯時期；
**避免了強制轉(zhuǎn)換的麻煩
(4)什么時候定義泛型？
泛型在集合框架中很常見，只要見到<>就要定義泛型。其實<>就是用來接收類型的。
當使用集合時，將集合中要存儲的數(shù)據(jù)類型作為參數(shù)傳遞到<>中即可
(5)泛型的形式
**泛型類：即自定義泛型類
A：當類中要操作的引用數(shù)據(jù)類型不確定時，早起定義Object來完成擴展，現(xiàn)在定義泛型來完成B：局限性：泛型類定義的泛型，在整個類中有效，如果該泛型類的方法被調(diào)用，當泛型類的對象明確要操作的類型后，所有要操作的類型就被固定。
**泛型方法：泛型放在返回值前面，修飾符的后面
A:為了避免泛型類的局限性，讓不同方法可以操作不同的類型，而且類型還不確定，則可以將泛型定義在方法上
B:特殊之處：靜態(tài)方法不可以反問類上定義的泛型
如果靜態(tài)方法操作的應用數(shù)據(jù)類型不確定，可以講泛型定義在靜態(tài)方法上
**泛型接口：
當泛型定義在接口上時，則子類中要指定實現(xiàn)接口類型，同時還可以子類也可以定義為泛型類
(6)泛型的高級應用：？通配符
**當指定兩種泛型的集合，則迭代時也要定義兩種泛型的迭代器，麻煩，此時可通過將迭代器的泛型
改為？，如Iterator it=al.iterator();
**兩種泛型限定
向上限定： ? extends E;E可以接收E類型或者E的子類
向下限定： ? super E;E可以接收E類型或者E的父類
14、高級for循環(huán)
(1)JDK1.5新特性，代替迭代器使用時的不爽，簡化書寫，底層原理是迭代器凡是支持迭代器的都支持高級for循環(huán)
高級for循環(huán)，只用于集合和數(shù)組的遍歷，集合只能用Collection不能用Map集合 只能把Map集合轉(zhuǎn)化成Set集合，才能用for循環(huán)。
(2)格式
for(數(shù)據(jù)類型 變量名:被遍歷的集合(Collection)或者數(shù)組)
{
}
(3)局限性：
必須要有遍歷的目標
對集合或者數(shù)組進行遍歷時，只能獲取集合元素，不能對集合元素進行操作
迭代器除了遍歷，還可以進行remove操作集合中的元素
列表迭代器還可以在遍歷過程中進行增刪改查的操作
(4)傳統(tǒng)for循環(huán)和高級for循環(huán)的區(qū)別
高級for循環(huán)有一個局限性，就是必須要有遍歷的目標(集合或者數(shù)組)
遍歷數(shù)組時建議使用傳統(tǒng)for循環(huán)，因為可以定義角標，比如打印100次helloworld時用傳統(tǒng)for循環(huán)方便
15、可變參數(shù)
(1)數(shù)組的可變參數(shù)
格式：
int...arr(3)方法的可變參數(shù)
格式：
public static void show(String str，int...arr)
{
}
注意：可變參數(shù)一定要放在參數(shù)列表的最后面
16、靜態(tài)導入：
**import static java.util.Arrays.* 導入的是Arrays這個類中所有的靜態(tài)方法
**當類名重名時，需要制定具體的報名
**當方法重名時，需要制定具體所屬的對象或者類
17、Collections類：
(1)此類完全由在 collection 上進行操作或返回 collection 的靜態(tài)方法組成。
(2)靜態(tài)方法摘要：
static
將所有指定元素添加到指定 collection 中。
static
使用指定元素替換指定列表中的所有元素。
static
使用另一個值替換列表中出現(xiàn)的所有某一指定值。
static void reverse(List list)
反轉(zhuǎn)指定列表中元素的順序。
static
返回一個比較器，它強行逆轉(zhuǎn)實現(xiàn)了 Comparable 接口的對象 collection 的自然順序
static
返回一個比較器，它強行逆轉(zhuǎn)指定比較器的順序。
(3)Collections類特牛的方法：
集合有一個共同的缺點，那就是線程不安全，被多線程操作時，容易出現(xiàn)問題，雖然可以自己加鎖
但是麻煩。Collections提供特牛的方法，就是給它一個不同步的集合，它返回一個同步的安全的集合
static
返回指定 collection 支持的同步（線程安全的）collection。
static
返回指定列表支持的同步（線程安全的）列表。
static
返回由指定映射支持的同步（線程安全的）映射。
static
返回指定 set 支持的同步（線程安全的）set。
static
返回指定有序映射支持的同步（線程安全的）有序映射。
static
返回指定有序 set 支持的同步（線程安全的）有序 set。
18、Arrays類：
此類包含用來操作數(shù)組（比如排序和搜索）的各種方法。里面都是靜態(tài)方法。
如果指定數(shù)組引用為 null，則此類中的方法都會拋出 NullPointerException。
(1)靜態(tài)方法摘要：
static
返回一個受指定數(shù)組支持的固定大小的列表。
注意：
A:該方法將一個數(shù)組變成集合后，不可以使用集合的增刪方法，因為數(shù)組的長度是固定的！
如果增刪，則發(fā)生UnsupportedOprationException(不支持操作異常)
B:如果數(shù)組中的元素都是基本數(shù)據(jù)類型，則該數(shù)組變成集合時，會將該數(shù)組作為集合的一個
元素出入集合C:如果數(shù)組中的元素都是對象，如String，那么數(shù)組變成集合后，數(shù)組中的元素就直接轉(zhuǎn)成集合中的元素
19、數(shù)組變集合以及集合變數(shù)組的對比：
(1)數(shù)組變集合：
方法：static
好處：可以使用集合的思想和方法操作數(shù)組中的元素，數(shù)組是一個對象，但是數(shù)組中的功能很少
(2)集合變數(shù)組：
方法：Collction中的toArray方法
好處：可以限定對集合元素的操作，防止對集合的元素進行增刪，因為數(shù)組長度是固定的。
20、Collections類和Arrays類的使用。(重點)A:Collections
排序
二分查找
發(fā)轉(zhuǎn)
B:Arrays
第四篇：Java初學者如何學習(必看)（本站推薦）
這篇文章是我無意中在網(wǎng)上看到的，很有感觸，感覺對初學者肯定會有幫助，打算整理一下再發(fā)出來的，可是改了半天，還是沒人家原本的內(nèi)容連貫，有邏輯性。所以直接拿過來了。希望想學習java朋友可以花點時間看看，看完肯定會有所收獲的，我不多說了，趕緊看看牛人的建議吧。JAVA交流群四一八，三五五，加上五三一。給初學者之一：淺談java及應用 學java不知不覺也已經(jīng)三年了
每次上網(wǎng)，泡bbs逛論壇，沒少去java相關(guān)的版面 總體感覺初學者多，高手少，精通的更少
很多人對java感到茫然，不知所措，不懂java能做什么 即便知道了java很有用，也不清楚該從哪里入手 所以就有了 java入門難 這一說法
ok，那我們就從java到底能做什么聊起 先說什么是java java是一種面向?qū)ο笳Z言，真正的面向?qū)ο螅魏魏瘮?shù)和變量都以類(class)封裝起來 至于什么是對象什么是類，我就不廢話了
關(guān)于這兩個概念的解釋任何一本面向?qū)ο笳Z言的教材里面都有 知道了什么是java，那自然就會對java能干什么感興趣
在說java能做什么之前，先說java作為一個真正面向?qū)ο笳Z言的優(yōu)點 首先第一個，既然是真正的面向?qū)ο螅蔷鸵龅綇氐椎姆庋b
這是java和c++最大的不同，java所有的源碼以及編譯后的文件都以類的形式存在
java沒有所謂的類外部定義，所有的函數(shù)（方法）以及變量（屬性）都必須在類內(nèi)部定義 這樣就不會出現(xiàn)一個類被切割成這里一塊那里一塊的情況，c++就可以，不是么？ 這樣做使得整個程序的結(jié)構(gòu)異常清晰，明了
其次第二個，最讓人歡呼雀躍的是完全屏蔽了指針，同時引入了垃圾回收機制 任何一個寫過c/c++代碼的人，都會對內(nèi)存管理深惡痛絕 因為這使得我們不能把主要精力放在我們關(guān)心的事情上 而需要考慮計算機內(nèi)部的一些事情，作為一個軟件工程師
我想沒有一個人愿意把大量的時間花在內(nèi)存管理上，畢竟我們不是電子工程師 此時java的優(yōu)勢體現(xiàn)出來了，它完全屏蔽了內(nèi)存管理
也就是說，如果你用java寫程序，寫出來的任何一個程序內(nèi)存上的開銷，都不受你控制 乍一看，似乎你受到了束縛，但實際上不是這樣
因為雖然你的程序無法對內(nèi)存進行管理，降低了一定的速度 但你的程序會非常非常的安全，因為你無法調(diào)用一個空指針 而不像以前寫c的時候那樣，成天因為空指針而擔驚受怕
當然，如果你深入了解這一行，就會發(fā)現(xiàn)java其實也無法保證程序不去調(diào)用空的指針 但是它會在最大程度上避免空指針的調(diào)用
這已經(jīng)很好了，安全，這是java的最突出的優(yōu)點
第三個，虛擬機跨平臺，這是java最大的特點，跨平臺 可能所有人都知道windows，但是不是所有人都知道unix 和java一樣，很多人都不知道unix這種操作系統(tǒng)干什么用
我不想多說unix的應用，這不是主要，但是我要說，大部分小型機 工作站，都跑在unix一族的操作系統(tǒng)上，比如linux/solaris unix比起windows有一個最顯著的特點，穩(wěn)定，這就好比思科和華為 思科的機器慢但穩(wěn)定，華為的機器快但不穩(wěn)定，作為服務(wù)器這一端來說還是非常有市場的 而且很重要的windows不安全，在ms的宣傳中我想所有人都很少看到安全二字 因為windows操作系統(tǒng)針對的是pc用戶，pc死機就死機咯，大不了重啟 最經(jīng)常冒出來的就是藍屏，在服務(wù)器這一端上因為ms沒有自己的芯片
所以要做系統(tǒng)有些力不從心啊。扯遠了，那么java可以做到在windows上編譯 然后在unix上運行，這是c/c++做不到的 那么說到這里，java能做什么逐漸清晰起來 剛才說到了，java程序有一個的特點是安全
這個安全是針對你的系統(tǒng)來說得，系統(tǒng)在跑了java程序之后會特別地穩(wěn)定
而且還能跨平臺，那么很明顯，java主要應用于除了windows操作系統(tǒng)以外所有的平臺 比如手機，服務(wù)器
想想看，如果你寫的程序要跑在手機上，而手機有多少款用的是windows? 就算有，那如果你用c/c++，是不是要針對每一款手機寫一套程序呢？ 累死，那跨平臺的java就不用，做到編譯一次，隨時運行
同樣，在服務(wù)器這一端，如果我想給一個網(wǎng)絡(luò)門戶站點，比如sina 寫一個應用程序，pc的性能肯定無法滿足sina這樣大站點并發(fā)數(shù)量的要求 那么它就需要買服務(wù)器，那么服務(wù)器ms沒有市場，而且windows很不安全 那么十之八九會買一個sun/ibm的機器，或者hp，但不管是誰的機器
它裝的操作系統(tǒng)也不會是windows，因為windows太不安全了，而且多核的支持太差了 這個有空再說，那么如果你要寫一個程序在這樣的機器上跑
難道我們就在這個機器上做開發(fā)么？當然不可能，一般程序員開發(fā)用的都是pc，windows 那么該怎么辦？寫一個程序，然后再拿到服務(wù)器上去編譯，去調(diào)試？ 肯定不可能，所以我們就希望找到一個語言，編譯完生成程序之后
在pc上調(diào)試，然后直接移植到服務(wù)器上去，那么此時，我們就會毫不猶豫地選擇java 因為在跨平臺以及安全性來說，java永遠是第一選擇 ok，下面說java的缺點
一慢，這其實是一種誤區(qū)，這就好比goto語句一樣
java也拋棄了指針，雖然看上去似乎變慢了，但是在這個兩三年硬件性能就能翻番的年代 速度已經(jīng)不是我們關(guān)心的問題了，而且對于企業(yè)級的應用來說
沒有什么比安全穩(wěn)定更重要的，換句話說，我們可以忍受慢，但是不能忍受死機和藍屏 而且越大型的應用，這種慢的劣勢體現(xiàn)得越模糊
因為當系統(tǒng)項目越做越大，任何一個環(huán)節(jié)做不好都可能影響全局的情況下 安全尤其重要，而且就像goto語句一樣
這種過分追求速度的主張會給系統(tǒng)開發(fā)和糾錯以及維護帶來無可挽回甚至不可避免的損失 把內(nèi)存交給計算機去管理吧，這種代價值得
我們做的不是pc游戲，沒必要把內(nèi)存的那一點點消耗當親爹
二難看，又是一個誤區(qū)，很多人甚至拿出java swing控件畫出的界面來說 呵呵，其實java不是不能畫得好看，IDEA就是java寫的IDE，挺漂亮的
但為什么難看呢，是因為swing控件它本身就是unix時代的產(chǎn)物，swing控件貼近unix界面
老外看unix界面其實挺順眼的，他們就是吃unix飯長大的
而unix又是吃百家飯的，不像ms那么唯利是圖，所以不怎么對中國人友好 加上我國又沒有公司在做操作系統(tǒng)，所以看上去是不怎么順眼 其實玩過unix的人都知道，unix對中文的支持一直不怎么好 給初學者之二：從JDK說起
在知道了java有什么優(yōu)點，能做什么之后 就該說一下java該如何去學了
在說java如何去學之前，有必要把java的幾個大方向做一個簡單說明 早在99年的時候
sun公司做出了一個決定，將java應用平臺做一個劃分 畢竟在不同領(lǐng)域，語言應用特性是有區(qū)別的
針對不同領(lǐng)域內(nèi)的應用,sun公司可以發(fā)布相關(guān)高端標準來統(tǒng)一規(guī)范代碼 這三大塊就是J2SE,J2EE以及J2ME 這個舉措今天看來無疑是非常了不起的
正是由于這次革命性的發(fā)展，使java從一種小打小鬧游戲性的語言 發(fā)展成為今天企業(yè)級應用的基礎(chǔ)
這里要特別說明一下J2SE J2EE J2ME中2的意思 其實2就是英文單詞to的諧音，就是to的意思
而不是second edition，當然java 2本身版本號就是1.2，也有點2nd edition的味道 說點題外的，sun公司發(fā)布的java版本很有意思
雖然總是寫是1.X但其實外界對這種版的說法也就是X.0 比如java 2,其實就是java 1.2 1.3其實就是3.0，1.4就是4.0，現(xiàn)在所說的5.0 其實就是1.5 只是以前我們更習慣叫1.X而已
可能到了5.0以后，就全改叫X.0而不是1.X了
所以以后聽到別人說java 5.0，千萬別驚訝，其實就是1.5 在這三個J2*E中J2SE是基礎(chǔ)，就是java 2的標準版(java 2 standard edition)也就是最基礎(chǔ)的java語言部分，無論學什么java技術(shù)，J2SE都是必須掌握的 要使用J2SE就必須安裝JDK（java development kit）
JDK在sun公司的主頁上可以免費下載，下載后需要安裝，具體安裝流程看教材 JDK包含有五個部分：核心API，集成API，用戶界面API，發(fā)布技術(shù)還有java虛擬機（JVM）先說運行環(huán)境，運行環(huán)境最主要要說的就是java虛擬機（JVM）
前面我們說過java是跨平臺的語言，那么如何做到跨平臺呢？畢竟每種操作系統(tǒng)都是不同的
java的設(shè)計者們提出了一個虛擬機的概念
在操作系統(tǒng)之上建立一個統(tǒng)一的平臺，這個平臺必須實現(xiàn)某些功能以支持程序的運行 如下圖：
------| program |------| JVM |------| UNIX | Windows | Linux | Solaris |..------程序員所寫的每一個程序都先運行在虛擬機上 所有操作都必須經(jīng)過虛擬機才能和操作系統(tǒng)交互
這樣做不僅統(tǒng)一了所有操作系統(tǒng)，同時也保證了操作系統(tǒng)的安全 要死機的話，死的是虛擬機（JVM）而操作系統(tǒng)并不會受此影響 而我們所說的java運行環(huán)境指的主要是JVM，其他的不說了，省略
下面說說JDK(java development kit)的API，其實用JDK來包括運行環(huán)境以及開發(fā)工具 個人感覺是不恰當?shù)模驗檫@三個單詞僅能說明開發(fā)工具，也就是幾個標準的API 而沒有讓人感覺到有運行環(huán)境的意思在里面，這是題外 那么什么是API? 簡單地說就是Application Programming Interface，應用程序編程接口 在java里面，就是一些已經(jīng)寫好了的類打成的包
這又要解釋什么是類什么是包了，簡單說一下，包就是類的集合 一個包包含零個或多個類，嗯，具體的可以去看書
這些類是java的基礎(chǔ)類，常用的類，可以簡單理解成java的工具集 最后說一下JDK的發(fā)布技術(shù)，其實按我的理解，講白了就是編譯器將.java文件轉(zhuǎn)換成.class文件的一種技術(shù)
這三部分組成了JDK，有了JDK，就可以開發(fā)出J2SE應用軟件了 最原始的只要用一個記事本寫幾行代碼就可以了
但一般來說我們會使用效果比較好的開發(fā)工具，也就是IDE 在J2SE這一塊，特別推薦JCreator這款I(lǐng)DE sun公司的產(chǎn)品，與JDK結(jié)合得幾乎是天衣無縫，非常適合初學者使用
教材方面中文的推薦電子工業(yè)出版社出版的《java教程》初級與高級篇各一本 還有就是《21天學通java》雖然有人說21天系列是爛書，但個人感覺
對于j2se，這本書翻譯得已經(jīng)很不錯了，基本沒有什么語法錯誤，語句也很通順 最后要說的就是《thinking in java》
這本書自然很經(jīng)典，說得比較細，只是我覺得不太適合初學者，其實也不難
初學者直接看也不成問題，但個人感覺還是找本教材也就是前面推薦的兩款來看比較好 基本概念的理解還是用教材的，畢竟thinking in java有的版本翻譯得很爛 而且個人建議還是看原版比較好，當然這幾本都看最好了，但如果沒時間 至少精讀其中一本，然后再看其他兩本就可以，其實三本書內(nèi)容也差不多
但看問題的角度方式以及面向的讀者也都不同，嗯，怎么說呢，找適合自己的吧 最后要說的是
由于虛擬機的存在，J2SE的大多數(shù)軟件的使用會比一般桌面軟件慢一些 效果不盡如人意，現(xiàn)在大概只有swing控件還在使用吧，其它沒怎么聽說 J2EE&J2ME 這是java應用的重中之重，如果想拿高薪，最好把J2EE學好
記得以前在csdn上看過一個調(diào)查，月薪上萬的程序員主要從事哪方面的工作 十個中有八個是做J2EE的，其他兩個一個做J2ME，還有一個做嵌入式 也許有些夸張，但也從某一方面說明J2EE人才的稀缺以及應用的廣泛
所以如果想學java，只精通j2se是永遠不夠的，至少還需要時間去了解其它兩個J2*E
給初學者之三：java企業(yè)級應用之硬件篇
總算講到企業(yè)級應用了，內(nèi)容開始逐漸有趣起來 java企業(yè)級應用分為硬件篇和軟件篇
重點在軟件，硬件是外延，嚴格地說與java沒有必然聯(lián)系 但是，由于java是網(wǎng)絡(luò)語言，不了解硬件的一些基礎(chǔ)知識
軟件知道再多也沒什么用，不要上了戰(zhàn)場還不知道為什么而打仗
硬件是軟件的基礎(chǔ)，在這個前提下，有必要專門花一點點篇幅來聊一下硬件 硬件，簡單地說就是我們實際生活中看得見摸得著的東西，也就是那些冰冷的機器，比如服務(wù)器，個人電腦還有網(wǎng)絡(luò)交換機，路由器等等,那么先拋開網(wǎng)絡(luò)設(shè)備不談，先來說說計算機電腦的歷史
在很早很早以前，人類創(chuàng)造了第一臺電腦，那時候的電腦只是一臺用來計算的機器 無比大，無比重，無比傻，除了算其它屁事不會做，沒有所謂的人工智能與計算機網(wǎng)絡(luò) 但是總算是誕生了，雖然以今天的眼光去看那時候的機器巨傻無比 只配叫做計算器而不是電腦，沒有邏輯思維能力，只會死算 但千里之行，始于足下，反正是造出來了 然后隨著時間的推移，制造業(yè)發(fā)展發(fā)展發(fā)展
電腦性能逐漸得到提升，速度快了起來，成本也逐漸低了下來
于是人們造出了第二臺，第三臺，第四臺，第五臺……第n臺計算機 人們就造出了無數(shù)臺計算機并使其成為一種產(chǎn)品
逐漸應用于許多復雜計算領(lǐng)域，不僅僅是科研，許多生產(chǎn)領(lǐng)域也開始出現(xiàn)計算機的影子 然后又隨著時間的推移，人們發(fā)現(xiàn)不可能把所有的計算機都做成一個樣子 因為各行各業(yè)對計算機性能的要求各不相同
于是開始把計算機劃分檔次，最簡單地是按照計算機的大小劃分 就是教科書上寫的大型機，中型機，小型機
//個人感覺這樣分純粹扯淡，還以為是小孩子玩球，分為大球，中球和小球 但是不管怎樣，計算機不再是千篇一律一個樣子了
按照性能的不同，在不同領(lǐng)域，出現(xiàn)了滿足符合不同要求的計算機 幾乎在同時，人們也開始考慮計算機之間通訊問題
人們開始考慮將不同的計算機連接起來，于是網(wǎng)線出現(xiàn)了，網(wǎng)絡(luò)出現(xiàn)了 又隨著網(wǎng)絡(luò)的發(fā)展，出現(xiàn)了一下專門為了尋址而存在的機器 這就是路由器和交換機，然后又出現(xiàn)了一些公益性的組織或團體 他們制定了一系列的標準來規(guī)范以及管理我們的網(wǎng)絡(luò) 于是3w出現(xiàn)了，計算機的網(wǎng)絡(luò)時代來臨了
嗯，說到這里，計算機發(fā)展到今天的歷史大概說完了，我們來詳細說說網(wǎng)絡(luò)時代的計算機以及各個硬件供應商之間的關(guān)系
前面說到了，計算機分為大型機，中型機和小型機……
但是現(xiàn)在市場上沒有人這樣分，要是出去買機器，對硬件供應商說
我要買一款中型機，或者說，我要買一款小型機，硬件供應商肯定會問問題
他們會問你買機器干什么用的？科學計算啊還是居家用，是作服務(wù)器啊還是圖形設(shè)計 但不管怎樣，簡單地說大中小型機已經(jīng)沒有什么意義了 我們按照使用范疇來劃分 簡單劃分為
服務(wù)器，工作站還有微機 服務(wù)器（server）
服務(wù)器涵蓋了幾乎所有的大型機以及大部分中型機甚至一些小型機 用通俗點話說??衿骶褪悄掣齬??4小時不間斷運行提供服務(wù)的機器 比如賣飛機票（中航信），比如酒店預定（攜程）
比如提供門戶站點相關(guān)服務(wù)（sina），比如電子商務(wù)（ebay，amazon，阿里巴巴）這些服務(wù)對機器都有一些特定的要求，尤其強調(diào)安全和穩(wěn)定 工作站（workstation）
工作站其實是圖形工作站的簡稱，說白了，就是某種功能極其強大的計算機 用于特定領(lǐng)域，比如工程設(shè)計，動畫制作，科學研究等 個人電腦/微機（pc）
計算機網(wǎng)絡(luò)的最末端，這個應該不用我說太多了 網(wǎng)絡(luò)時代的pc已經(jīng)普及到千家萬戶
說完了分類，我們就來說說各個硬件供應商 首先是服務(wù)器還有工作站
這兩類硬件供應商主要是以下三家 Sun,IBM還有HP(惠普)然后是PC 以前IBM還有PC事業(yè)部，現(xiàn)在被聯(lián)想吞并了（蛇吞象）
現(xiàn)在國際市場上有聯(lián)想和DELL(戴爾)，目前戴爾還是國際老大 還有HP康柏
然后是網(wǎng)絡(luò)，也就是路由器和交換機
這塊市場嘛，Cisco(思科)Brocade(博科)還有McDATA三足鼎立 內(nèi)核(CPU)PC內(nèi)核
主要是AMD和Intel，前者最近與Sun公司合作，Sun也有一部分單雙核服務(wù)器用的是AMD的
服務(wù)器與工作站內(nèi)核 這一塊與硬件廠商綁定
還是Sun,IBM,HP三家自己生產(chǎn) 題外
在一些大型主機應用市場，比如賣飛機票
德國的漢莎，中國的中航信，香港的國泰用的都是尤利（美國的公司，英文名我忘了）其它用的是IBM的機器，現(xiàn)在能做大型機的感覺似乎只有IBM可以
尤利已經(jīng)快倒了，技術(shù)太落后了，現(xiàn)在他們的系統(tǒng)還是fortran寫的，連c都不支持 要特別說明的是，一個超大型主機然后多個小終端/pc的結(jié)構(gòu)現(xiàn)在越來越?jīng)]市場了 將來的趨勢是用一整個包含多個服務(wù)器的分布式操作系統(tǒng)來取代這些大型主機 因為大型主機更新?lián)Q代極其困難，一旦數(shù)據(jù)量超過了主機的處理能力 那么就要換主機，這個成本是極大的，但是如果用分布式操作系統(tǒng) 那就只需要增加小服務(wù)器就行了
硬件就大概說到這里，與大多數(shù)人沒什么關(guān)系
因為大多數(shù)人壓根不可能進入這些硬件領(lǐng)域，除非做銷售 說了這么多，只是為了給軟件部分打基礎(chǔ)而已 //做嵌入式的除外
給初學者之四：java企業(yè)級應用之軟件篇 嗯，說過了硬件就該是軟件了 這篇是這個系列的重中之重
首先我們來說說什么是軟件，統(tǒng)一一下概念 所謂軟件通俗地說就是一套計算機程序 實現(xiàn)了某些功能的計算機程序
在很早很早以前，一臺計算機的軟件是不分層次結(jié)構(gòu)的
一臺計算機只有一個系統(tǒng)，這個系統(tǒng)既是操作系統(tǒng)又是應用軟件，與硬件緊密綁定 后來經(jīng)過許多年的發(fā)展發(fā)展發(fā)展 人們把一些與硬件緊密相連的又經(jīng)常用到必不可少的功能做到一套程序中去 這一套程序就被人們稱做操作系統(tǒng)
另外一些可有可無的，不同工作適應不同環(huán)境的功能封裝到另外一套程序中去 而這一系列程序被人們稱作應用軟件 如下圖：
------------|應用軟件：falshgat/IE/realplayer/winamp..|------------|操作系統(tǒng)：UNIX/Windows/Linux/Solaris...|------------前一篇我們知道，硬件分為服務(wù)器工作站與pc 其實無論哪種硬件的軟件，都有操作系統(tǒng)與應用軟件 ok，那下面我們來談應用軟件
在現(xiàn)在企業(yè)級應用中，我們的應用軟件一般分為三層 三層分別是表示層，業(yè)務(wù)邏輯層，數(shù)據(jù)持久層------------------------------|表示層|業(yè)務(wù)邏輯層|數(shù)據(jù)持久層|------------------------------我們來說說三層中的代表軟件 表示層
這一層一般在客戶端pc機上，最常見的是IE瀏覽器，這就是表示層的軟件 表示層是直接與使用者交互的軟件 業(yè)務(wù)邏輯層
這一層一般在服務(wù)器端，顧名思義，所有業(yè)務(wù)邏輯處理都在這一層完成
最典型的是appserver，比如IBM的websphere，BEA的weblogic還有tomcat/jboss等 這一層也是三層中的重點，我們要說的大部分內(nèi)容都是關(guān)于這一層的，這個等會再說 這一層就叫做中間層 數(shù)據(jù)持久層
這一層典型的就是數(shù)據(jù)庫，一般也在服務(wù)器端 但該服務(wù)器一般與裝業(yè)務(wù)邏輯層軟件的服務(wù)器分開 當然你也可以用IO輸入輸出流往硬盤上寫東西
但沒人會建議你這么做，因為這樣做你的數(shù)據(jù)缺乏管理，不管怎樣 這一層要做的就是保存數(shù)據(jù)，業(yè)務(wù)邏輯層軟件一般不負責保留數(shù)據(jù)
或者說業(yè)務(wù)邏輯層只負責暫時儲存數(shù)據(jù)，一關(guān)機，業(yè)務(wù)邏輯層數(shù)據(jù)全部over了 那么數(shù)據(jù)的持久化（也就是儲存數(shù)據(jù)）就必須要在這一層完成下面放著這些概念不談，我們來說說將來的趨勢 趨勢一：
瘦客戶端，很早很早以前，當時C/S模式也就是client/server 客戶端軟件大行其道的年代，一個pc用戶，是采用一個傻終端連接到服務(wù)器上 然后進行相應的操作，最典型的就是我們上bbs經(jīng)常用的c-term 這就是那個時代的產(chǎn)物，同樣還有我國現(xiàn)行的機票定座用的e-term 后來呢，瀏覽器變得非常流行，人們發(fā)現(xiàn)，瀏覽器也能傳遞一些數(shù)據(jù) 雖然這些數(shù)據(jù)并不像那些終端那樣準確，但應付大多數(shù)日常需求足夠了
于是人們就提出一個瘦客戶端概念，也就是說，將來表示層所有的其他軟件疾揮? 我們唯一需要的就是一個網(wǎng)頁瀏覽器，然后通過瀏覽器輸入ip地址連接到服務(wù)器 然后進行相關(guān)的操作，由于網(wǎng)頁瀏覽器一般每個操作系統(tǒng)都有自帶一個 這樣做就達到了給我們客戶端瘦身的目的（不需要安裝額外軟件）這樣模式被稱作B/S模式，也就是browser/server模式
但需要指出的是，雖然瘦客戶端是趨勢，但并不代表胖客戶端沒有市場 尤其是一些復雜的業(yè)務(wù)操作，還是瀏覽器這種簡單軟件無法勝任的趨勢二：
傻數(shù)據(jù)庫，ok，首先，我承認，這個名詞是我發(fā)明的，但我實在無法找到一個更好的表達 什么是傻數(shù)據(jù)庫，如果誰對數(shù)據(jù)庫有所了解的話，就知道，以前的數(shù)據(jù)庫
有自己的一套管理體系，甚至有自己的客戶端，比如oracle,mysql,sqlserver都有 在某個管理工具上寫什么sql語句查詢數(shù)據(jù)庫是我們以前常做的事 那么將來我們提倡的是：將所有的業(yè)務(wù)邏輯封裝到業(yè)務(wù)邏輯層去 管理的事情由軟件來做，由業(yè)務(wù)邏輯層的軟件來做 所謂傻數(shù)據(jù)庫就是說，將來的數(shù)據(jù)庫什么事都不用做
只用把數(shù)據(jù)給我保存好就行了，那些復雜的業(yè)務(wù)邏輯什么外鍵什么關(guān)聯(lián) 都沒數(shù)據(jù)庫什么事了，都交給業(yè)務(wù)邏輯層軟件來做
這樣做的好處就是：我們就不需要這些該死難懂又復雜的數(shù)據(jù)庫系列管理工具了 而且這些工具每個數(shù)據(jù)庫都有自己的工具，完全不一樣，亂七八糟，沒有人喜歡面對他們 除了數(shù)據(jù)庫維護人員，也就是DBA，我們是軟件工程師，維護的事讓他們?nèi)プ?/p>
而且嚴禁數(shù)據(jù)庫維護人員改動數(shù)據(jù)庫的數(shù)據(jù)，他們只做備份，必要時候恢復一下就是了 了解了這兩個趨勢之后，是不是有種砍頭去尾保中間的感覺？
沒錯，未來的趨勢就是中間件時代，中間件工程師將是未來計算機應用的主流 那再次統(tǒng)一一下概念，什么是中間件？
記得我上學的時候，看ibm的教材，看了半天中間件定義，就看懂記住一句話 中間件是做別人不愿意去做的事情，現(xiàn)在想想，狗屁定義，呵呵 什么是中間件，中間件是業(yè)務(wù)邏輯層的應用軟件 是處理業(yè)務(wù)數(shù)據(jù)與客戶端之間業(yè)務(wù)邏輯的一種應用軟件 一種提供網(wǎng)絡(luò)服務(wù)的服務(wù)器端應用軟件
舉個非常簡單的例子，網(wǎng)上銀行，某個人想用IE進入工行的賬戶，然后轉(zhuǎn)帳 在這個例子中，客戶端表示層顯然是IE，數(shù)據(jù)持久層顯然是銀行的核心數(shù)據(jù)庫 那么中間件是什么？中間件就是提供這種服務(wù)的系統(tǒng) 這三層的劃分如下
------------------------------|表示層 | 業(yè)務(wù)邏輯層 | 數(shù)據(jù)持久層 |------------------------------| IE | 網(wǎng)上銀行 | 數(shù)據(jù)庫 |------------------------------給初學者之五：企業(yè)級應用之中間件 前面一篇簡單介紹了一下應用軟件的分層
下面重點介紹一下中間件，也就是業(yè)務(wù)邏輯層的軟件結(jié)構(gòu) 從本系列第二篇我們知道，java程序是跑在虛擬機之上的 大致結(jié)構(gòu)如下：------------| grogram |------------| 虛擬機 |------------| 操作系統(tǒng) |------------也就是說操作系統(tǒng)先運行一個java虛擬機，然后再在虛擬機之上運行java程序 這樣做的好處前面也說過了，就是安全，一旦出現(xiàn)病毒或是其他什么東西 掛掉的是虛擬機，操作系統(tǒng)并不會受多大影響
這時候有人可能會問，為什么非要虛擬機？把操作系統(tǒng)當成虛擬機為什么不行？ 可以，當然可以，但是這樣做某一個應用軟件的bug就可能造成整個操作系統(tǒng)的死亡 比如說我們在某個服務(wù)器上安裝了一個收發(fā)電子郵件的軟件和java虛擬機 那么一旦黑客通過收發(fā)電子郵件的軟件入侵系統(tǒng)，那么操作系統(tǒng)就整個玩完 那么如果黑客通過java程序進行攻擊的話，那么死的將會是虛擬機而不是操作系統(tǒng) 大不了虛擬機崩潰，而操作系統(tǒng)正常運行不受任何影響
舉個簡單例子，比如說最常見的是將數(shù)據(jù)庫(DB)與中間件放在同一臺服務(wù)器上------------------------| program | |-----------| DB | | 虛擬機 | |------------------------| 操作系統(tǒng) |------------------------那么此時如果沒有虛擬機，黑客病毒攻擊中間件系統(tǒng)，就有可能造成操作系統(tǒng)的死亡 那此時數(shù)據(jù)庫也有可能跟著一起玩完，那損失可就大咯
那如果此時有虛擬機，那么一旦被攻擊，死的是虛擬機，操作系統(tǒng)與數(shù)據(jù)庫不受任何影響 嗯，回顧完虛擬機，再來介紹中間件
在很早很早以前，任何一家企業(yè)，想要搭建一個局域網(wǎng)系統(tǒng)，他需要請許多個工程師 比如說我們想搭建一個網(wǎng)上銀行，客戶端用瀏覽器,后臺數(shù)據(jù)庫比如說用oracle 那么搭建這樣一個網(wǎng)上銀行，可能需要用到多少個工程師，我們來算一算
首先，由于客戶端用的是瀏覽器，我們需要一些了解網(wǎng)絡(luò)通訊協(xié)議以及一些瀏覽器標準的網(wǎng)絡(luò)工程師
其次，由于后臺數(shù)據(jù)庫用的是oracle，那我們還需要請oracle的工程師，因為數(shù)據(jù)庫這一層每個數(shù)據(jù)庫公司的接口什么都不 一樣
然后，我們還需要一些操作系統(tǒng)的工程師，因為我們的系統(tǒng)需要跟操作系統(tǒng)直接交互 最后，我們需要一些設(shè)計網(wǎng)上銀行系統(tǒng)及其相關(guān)業(yè)務(wù)的工程師
太多了太多了，這樣一個中間件隊伍實在太龐大了，制作維護成本實在太高了 不僅如此，這樣一個中間件就算做出來，他們所寫的代碼也只能滿足這一家公司使用 其它公司統(tǒng)統(tǒng)不能再用，代碼重用率極低，近乎不可能重用 畢竟這個系統(tǒng)中改動任何一個部分都有可能涉及到整個系統(tǒng)的改動 那么如何降低成本？ 我舉出了四組的工程師：
網(wǎng)絡(luò)工程師，數(shù)據(jù)庫工程師，操作系統(tǒng)工程師以及設(shè)計網(wǎng)上銀行系統(tǒng)的業(yè)務(wù)工程師 除了最后一組設(shè)計網(wǎng)上銀行的業(yè)務(wù)工程師之外，前面三組工程師是不是每一個項目都需要的？
就算不是每一個項目都需要，至少也是絕大多數(shù)項目需要的吧？
哪個項目能夠脫離網(wǎng)絡(luò)，數(shù)據(jù)庫和操作系統(tǒng)？不可能，在這個時代已經(jīng)很少很少了 好，那既然每個項目都需要，我們是不是可以用一個產(chǎn)品來取代這三組的工程師呢？ 我們的業(yè)務(wù)工程師只需要遵循這個產(chǎn)品所提供的接口，進行相應的開發(fā)就行了 人們提出了一種叫做appserver也就是應用服務(wù)器的東西
應用服務(wù)器是干什么的？按官方的說法，應用服務(wù)器是包括有多個容器的軟件服務(wù)器 那容器是什么？容器(Container)到底是個什么東西我想多數(shù)人還是不清楚 在說這個之前，先介紹一下組件
什么是組件，組件是什么？組件其實就是一個應用程序塊 但是它們不是完整的應用程序，不能單獨運行 就有如一輛汽車，車門是一個組件，車燈也是一個組件 但是光有車燈車門沒有用，它們不能跑上公路
在java中這些組件就叫做javabean，有點像微軟以前的com組件 要特別說明的是，由于任何一個java文件編譯以后都是以類的形式存在 所以javabean肯定也是一個類，這是毫無疑問的 好，那么容器里裝載的是什么呢？就是這些組件 而容器之外的程序需要和這些組件交互必須通過容器
舉個例子，IE發(fā)送了一個請求給容器，容器通過調(diào)用其中的一個組件進行相關(guān)處理之后 將結(jié)果反饋給IE，這種與客戶端軟件交互的組件就叫做servlet 但是組件有很多種，那么如何區(qū)分這些組件呢？
有多種管理辦法，比如同是同樣是servlet，有些是通過jsp生成的
而有些是開發(fā)人員自己寫的，那么通過jsp生成的servlet集中放在一個地方 而開發(fā)人員自己寫的則需要在xml里面配置一些基本的參數(shù)
同時，不同組件有可能還需要繼承一些特定的父類或者接口，這也是容器管理的需要 還有其他的一些組件，這里就不一一說明舉例了 那么容器有很多種，按照他們裝載的組件類型劃分
比如有裝ejb的ejb容器，有裝servlet與jsp還有靜態(tài)頁面的web容器等等 //這種只含有web容器的應用服務(wù)器也被叫做web服務(wù)器 當表示層的應用軟件通過網(wǎng)絡(luò)向appserver發(fā)送一個請求的時候
appserver自動找到相應容器中的組件，執(zhí)行組件中的程序塊，把得到結(jié)果返還給客戶 而我們要做的事就是寫組件也就是javabean，然后放到appserver里面去就可以了 至于怎樣與IE通訊，怎樣截獲網(wǎng)絡(luò)上的請求，怎樣控制對象的數(shù)量等等
這些繁瑣而無味的工作我們都不管，都由appserver去做吧，把注意力集中在業(yè)務(wù)邏輯上 appserver與其他相關(guān)軟件的關(guān)系如下圖：
------------------------| 表示層 | 業(yè)務(wù)邏輯層 | 數(shù)據(jù)持久層 |------------------------| |-----------------| | | IE | | javabean | | | |->------------------> DB | | client <-appserver <-| | |-------------------------| | | | 虛擬機 | | |--------------|-------------------------|------------| | Windows | Linux/Saloris |LinuxSaloris| |--------------|-------------------------|------------| 圖上可以看出：虛擬機負責處理中間件與操作系統(tǒng)之間的交互 appserver則負責組件的管理以及與其他兩層的業(yè)務(wù)交互
要說明的是上圖中還包含有應用程序客戶端容器(Application client container)管理應用程序客戶端組件的運行，應用程序客戶端和它的容器運行在客戶機 這種情況比較復雜一般說的是兩個server之間的通訊
比如jsp/servlet容器在一個服務(wù)器上，而ejb容器在另外一個服務(wù)器上等等 這是分布式操作系統(tǒng)大面積應用的基礎(chǔ)，這個以后再說 嗯，那么話題再回到中間件上去，什么是中間件？
appserver就是所謂的中間件，但是中間件不僅有appserver，還有其他的東西 換句話說，appserver只是中間件的一種
而關(guān)于中間件有諸多規(guī)范以及遵循這些規(guī)范的模型 最流行的規(guī)范無非兩種，一個是j2ee還有一個是.net 但是.net幾乎只有微軟在用，所以很多人把.net這個規(guī)范就當成是微軟的中間件產(chǎn)品 也不為過，畢竟沒幾個公司喜歡跟著微軟屁股后面跑的 給初學者之六：java企業(yè)級應用之綜合篇 我們知道中間件有很多種規(guī)范以及相關(guān)的模型 最流行的一個是j2ee還有一個是.net 那么各大公司關(guān)于這兩套規(guī)范各有什么產(chǎn)品以及周邊呢？ j2ee: 黃金組合
操作系統(tǒng)：Solaris 應用服務(wù)器：Weblogic 數(shù)據(jù)庫：Oracle 開發(fā)工具：JBuilider/IntelliJ IDEA 優(yōu)點：性能一級棒，大企業(yè)大公司做系統(tǒng)的首選，世界五百強幾乎都是這套組合 缺點：極貴 超級組合，也是最安全最酷的黃金組合，硬件采用SUN公司的機器 但是SUN的服務(wù)器很貴，同等價格不如去買IBM的機器
SUN的服務(wù)器支持Solaris的效果自然不用說，Solaris號稱是世界上最安全的操作系統(tǒng) Oracle也是世界上最安全，性能最優(yōu)的數(shù)據(jù)庫，Weblogic是當今性能最優(yōu)的appserver JBuilder和IDEA各有所長，JBuilder是Borland公司的招牌之一
是當今世界上最流行的java IDE，用delphi寫的，但網(wǎng)絡(luò)上評價似乎不是很好 IDEA擁有插件功能，界面在所有java IDE中最為漂亮，東歐人開發(fā)的產(chǎn)品 東歐人嚴謹?shù)淖黠L在這個產(chǎn)品上體現(xiàn)得尤為突出，用java寫的
IDEA甚至號稱自己被業(yè)界公認為是最好的IDE//個人保留意見，沒有最好只有更好 但我用JBuilder的時候發(fā)現(xiàn)了不少bug，而至今還沒有在IDEA上發(fā)現(xiàn)什么bug 個人推薦IDEA 價格方面，Solaris開源，但是SUN的服務(wù)器比較貴，Weblogic最高是34萬 oracle標準版要18.6萬，企業(yè)版要49萬，JBuilder要2.7萬左右 IDEA零售價大概是500美金，也就是5000多元
另外，雖然理論上這些產(chǎn)品的綜合性能要高于其他選擇，但是必須看到
由于產(chǎn)商之間的利益沖突，比如oracle也有自己的appserver，但是性能不怎樣 使得這幾種產(chǎn)品之間協(xié)作的性能要比預想中的要差一點點--開源系列 操作系統(tǒng)：-應用服務(wù)器：JBoss 數(shù)據(jù)庫：MySql 開發(fā)工具：Netbeans 優(yōu)點：便宜，性能未必最佳，但是對付中小企業(yè)足夠了 缺點：出了問題自己抗吧
嗯，這是java陣營最大的特色，免費免費，還有在開發(fā)工具這一欄Eclipse也是免費的 但后面要說，算了，換個有代表性的開源產(chǎn)品來
tomcat僅有web容器而沒有ejb容器，而jboss已經(jīng)集成了tomcat 也就是說下載了jboss之后，啟動的同時也就啟動了tomcat jboss在tomcat基礎(chǔ)之上多加了一個ejb容器，使得jboss+tomcat成為和weblogic websphere之外又一個得到廣泛應用的appserver 現(xiàn)在大概是這樣，中小型企業(yè)多用jboss，如果應用小一點就用tomcat 只有給那些大型企業(yè)做的項目，才會花錢去上一個weblogic或者websphere mysql也是開源的數(shù)據(jù)庫，做得非常不錯，如果系統(tǒng)對數(shù)據(jù)庫要求不高 或者安全要求不是非常嚴格，mysql是一個非常不錯的選擇 開發(fā)工具方面，netbeans是sun公司極力推廣的一種IDE 聽說在北美市場使用量已經(jīng)超過eclipse了
操作系統(tǒng)，軟件再不用錢，服務(wù)器也要錢，看這臺機器上跑什么操作系統(tǒng)就用什么了--IBM套餐 操作系統(tǒng)：Linux 應用服務(wù)器：Websphere 數(shù)據(jù)庫：DB2 開發(fā)工具：Eclipse/WebSphere Studio 優(yōu)點：服務(wù)好，IBM可以提供全套服務(wù)，也可以替客戶承擔風險 缺點：把機器數(shù)據(jù)全部交給IBM，安全什么的都由不得你了 呵呵，IBM全套產(chǎn)品，甚至包括硬件設(shè)備IBM的服務(wù)器 由于是一個公司的產(chǎn)品，各產(chǎn)品之間的協(xié)作自然不錯
價格方面，Linux，DB2，Eclipse都是開源產(chǎn)品，Websphere目前零售價是33.8萬人民幣 IBM服務(wù)器不錯，可以考慮--.net： 微軟陣營
操作系統(tǒng)：Windows 應用服務(wù)器：.net應用服務(wù)器(好像叫IIS)數(shù)據(jù)庫：SqlServer 開發(fā)工具：MS Visual Studio 優(yōu)點：客戶端的用戶體驗良好，和客戶端諸多微軟產(chǎn)品的兼容性強 缺點：離開了微軟，寸步難行，和其他任何一家公司的產(chǎn)品都不兼容 微軟的東西，怎么說呢，太專橫了 微軟所有的東西都是圍繞著windows來做的
.net其實已經(jīng)可以實現(xiàn)跨平臺了，但是微軟出于自身商業(yè)考慮 在其應用服務(wù)器跨平臺的實現(xiàn)上設(shè)置了種種障礙 而且針對windows，微軟做了大量的優(yōu)化，可以這么看.net就是與windows捆綁的一套產(chǎn)品
所以有些人說，微軟的產(chǎn)品離開了windows，就是渣
而且.net開源選擇也少，安全性方面考慮，windows本身就有一堆補丁要打了 sqlserver也不安全，至于.net到底安全不安全我不清楚，畢竟我沒怎么用過 但整體考慮，感覺.net不是大企業(yè)的首選，鑒于其濃厚的商業(yè)背景 也不是中小企業(yè)的首選，但是必須看到
客戶端也就是微機pc市場已經(jīng)完全被windows所壟斷
所以在一些快速開發(fā)，還有和微軟產(chǎn)品兼容性要求較高的領(lǐng)域，.net還是比較有市場的 最后一個visual studio對它之前的版本兼容，且支持c,c++,c#,vb等語言 在其傳統(tǒng)領(lǐng)域，比如寫一些桌面軟件等客戶端應用上，.net還是第一選擇--最后要說明的是 這些組合不是固定不變的
由于J2EE得到了絕大多數(shù)IT企業(yè)的支持以及JAVA跨平臺的特性 我們可以自由地定制個性化的組合
比如我可以選擇windows+jboss+eclipse+oracle 也可以選擇solaris+websphere+IDEA+mysql 等等，這些自由組合都是可以的，但是有一點必須說明 微軟的東西，一般來說離開了windows就不能用
比如你選擇了.net應用服務(wù)器，那操作系統(tǒng)就必須是windows 你選擇了sqlserver，那就必須在windows上用
還有就是遵循j2ee規(guī)范的所有的組件都可以在不同的應用服務(wù)器上互相移植 比如你可以在測試的時候用jboss 而在正式投產(chǎn)上線的時候使用websphere，只需要在配置文件中作相應改動即可 給初學者之七：java企業(yè)級應用之術(shù)語篇
在了解完J2ee的相關(guān)周邊產(chǎn)品之后需要深入J2ee規(guī)范內(nèi)部去了解一下到底這些規(guī)范 這里介紹幾個最常用的規(guī)范 再繼續(xù)說下去之前有必要說幾個常識
下面進入正題 再談容器
前面介紹過容器，我覺得有必要再補充一點
容器從某種意義上說其實就是一個可運行的java寫的應用程序 猶如c++/c編譯后生成的.exe文件
不同的是java編譯后的文件需要用命令行或者腳本啟動執(zhí)行 由于容器是由java寫的，所以容器都能夠跨平臺
雖說如此，似乎大部分容器都針對不同的操作系統(tǒng)提供了不同的版本 但可以肯定的一點是，相同容器間的移植組件不需要重新編譯 Servlet web容器組件
Servlet確切地說，就是web容器運行的java組件
與普通javabean不同的是，Servlet定義了一系列方法//比如init()和destroy()供容器調(diào)用，調(diào)用的主要目的是為了管理
當一個request請求被web容器截獲之后，容器分析該請求地址 然后通過一個配置文件中的映射表//web.xml 調(diào)用相應的Servlet組件處理后將結(jié)果返還給客戶端 JSP//Java Server Page web容器組件
Servlet出現(xiàn)了之后，人們發(fā)現(xiàn)幾乎沒有辦法用一個非常直觀的方式去編寫頁面 畢竟頁面是html語言編寫的
而讓我們用一種流程式的處理方式去逐行教計算機如何寫html代碼太困難 在這種情況下JSP應運而生，JSP將java代碼嵌入html代碼內(nèi)部
然后存成.jsp文件，再由計算機編譯生成Servlet儲存起來//注意這個過程
所以JSP和Servlet對于web容器來說其實是一種東西，雖然它們編寫遵循的標準有所不同 極大地簡化了代碼同時增加了代碼的可讀性，生產(chǎn)維護成本下降 值得一提的是，在制定JSP規(guī)范的過程中，借鑒了ASP的很多規(guī)范 寫過ASP并熟悉Java語言的人應該能很快掌握JSP EJB//Enterprise JavaBean ejb容器組件
隨著時間的推移，人們發(fā)現(xiàn)普通的JavaBean似乎并不能滿足企業(yè)級應用的需要 最典型的就是虛擬機提供的垃圾回收收集機制也就是GC不夠完善 可以優(yōu)化的余地極大，在這種情況下，EJB應運而生 EJB和其它組件一樣，不過遵循了某些規(guī)范而已
但是這些規(guī)范更多的是為充分利用機器并提高性能為主要目的的 舉個簡單例子
比如某個web服務(wù)器有100個用戶同時連接上
由于網(wǎng)絡(luò)連接是瞬時連接，所以很多時候并發(fā)數(shù)并沒有100那么大 前一秒有可能有30個請求被發(fā)送過來并被處理 后一秒可以只有10個請求被發(fā)送過來并被處理
只有在非常非常極端的情況下才有可能發(fā)生100個請求同時被發(fā)送過來并被處理的情況 那么我們是否需要保留100個那么多個對象在服務(wù)器的內(nèi)存里面去處理這些請求呢？ 很顯然，不需要，大多數(shù)時候//甚至可以說是所有時候，我不相信有那么極端的情況 我們只需要保存其中的10-30%就夠了，那么什么時候需要20%，什么時候需要50% 甚至100%，這個過程就交給容器去管理，這就是ejb容器每天在干的事 管理內(nèi)存中活躍的對象
恩，必須強調(diào)的一點是，由于使用的不成熟 我們經(jīng)常把規(guī)范以及具體的應用兩個名詞混用
舉個簡單例子，我們說Servlet，極有可能說的是Servlet規(guī)范 也有可能說的是一個具體的Servlet，這個就要看情況而定了 EJB，JSP也是如此
JDBC 和數(shù)據(jù)庫的連接
這個嚴格說來是數(shù)據(jù)庫產(chǎn)商需要關(guān)心的事 關(guān)于AppServer如何與數(shù)據(jù)庫的連接
但是也需要開發(fā)人員做一點事，因為AppServer不知道什么時候組件需要用到數(shù)據(jù)庫 同時也需要開發(fā)人員告訴AppServer他們使用的是什么數(shù)據(jù)庫，ip地址等等 JDBC就是關(guān)于這一套東東的規(guī)范 包括數(shù)據(jù)庫的產(chǎn)商應提供什么樣的接口 AppServer應用服務(wù)器應該如何去連接 開發(fā)人員應該如何去配置這些連接等等
還有一些數(shù)據(jù)源，連接池等概念參考相關(guān)數(shù)據(jù)在此就不再贅述 其它的規(guī)范比如JMX等確切地說與開發(fā)人員關(guān)聯(lián)并不大了 這類高級應用只對AppServer應用服務(wù)器產(chǎn)商重要 也不再羅嗦了---------記得聽說過這樣一種說法
大一時候不知道自己不知道 大二時候知道自己不知道 大三時候不知道自己知道 大四時候知道自己知道 為什么呢，因為大
一時候剛進大學，什么都不懂，很正常，大家都一樣 大二或者大三時候開始接觸知識，雖然還是不懂，但慢慢地開始學習，開始積累 過了一段時間，知道自己知道了//也就是前一種說法的大四，后一種說法的大三 開始屁癲，開始拽得不得了，覺得自己懷才不遇，千里馬難尋伯樂的那種感覺 有些人是大四畢業(yè)了以后開始拽，悟性高一點的，大三就開始拽，因人而異 這幾乎是每一個初學者經(jīng)過一段時間學習后的必然階段 不管如何，總之開始入門了，這也不是壞事
但最后每個人都會知道自己不知道的，也就是后一種說法的大四階段 //前一種說法里面的那些家伙估計要到工作以后才能明白 因為任何一門學科都博大精深，要是能在兩三年之內(nèi)就統(tǒng)統(tǒng)搞懂 那不是在吹牛就是坐井觀天，java如此，c如此，c++也是如此 那么到了本系列的第七集，可愛的讀者應該處在什么階段呢？ 恭喜，在看完這篇文章之后，你就基本處于知道自己不知道的那種階段 離拽起來還有那么一段距離，因為你們畢竟還沒有學習和積累一定的基礎(chǔ)知識 但是騙騙外行，蒙蒙國企那些吃閑飯的管理人員問題不大
給初學者之八：java高級應用之框架篇 沒錯，我沒敲錯
之所以不再聲稱是企業(yè)級應用而稱之為高級應用 是因為下面要講的東西屬于純民間性質(zhì) 是java具體應用的上層建筑，可用可不用，沒有人強迫你用 首先給框架//framework 下一個定義
我想讀者你可能聽說過.net framework這個概念
沒錯，我們將要說的framework也和這個framework差不多 所不同的是.net framework的競爭對象是j2ee那一系列標準 而我們將要說到的幾個框架則應用在j2ee的不同層面 單就單個框架而言，沒有.net framework管得那么多
但是卻要比它精專多了，而且總量加起來，也遠比微軟那一套框架要廣泛得多 回到正題，框架是什么？
軟件工程之所以被叫做軟件工程就是因為有那么一批人覺得可以用工程學里面 那些管理Project的方法來管理軟件從開發(fā)到維護這一系列流程 那么在建筑工程里面框架是什么？
現(xiàn)在建筑多采用鋼筋混凝土結(jié)構(gòu)，注意里面一個很重要的詞匯：鋼筋 托福閱讀中曾有一題聽力就是關(guān)于鋼筋結(jié)構(gòu)的誕生，在美國 恩，現(xiàn)代建筑中多在建筑起來之前，先用鋼筋搭建出一個框架出來 然后往鋼筋中間填入混凝土，從而形成一個完成的建筑 而今天要說到的框架就是這么一個東西在每一個軟件中間的實現(xiàn)
框架就是那么一個通過預先寫好代碼從而幫我們建立起一個軟件結(jié)構(gòu)的這么一個東西 這里提一下框架與規(guī)范//主要指J2ee規(guī)范也就是官方標準的區(qū)別 從某種意義上說，J2ee規(guī)范本身就是一個框架 無論是web容器也好，還是ejb容器也好，它們都開發(fā)了一部分通用的代碼 并且?guī)椭覀兇罱ㄆ饋砹艘粋€軟件結(jié)構(gòu)，我們要做的就是往里面填入組件 比如ejb/servlet/jsp等等
沒錯，要這么理解也沒錯，但是為了避免混亂，我們還是嚴格區(qū)分開來 本文中將要提到的框架如無特別說明，就是指的是非官方標準的框架 規(guī)范是規(guī)范，而框架是建立在規(guī)范之上的一種東西
可以說是標準的延續(xù)，或者說是民間的嘗試，總之是這么一個非官方的東西 說到這里順便提一下JCP組織也就是Java Community Process/Java社區(qū) 當初Sun公司在java發(fā)布之初，為了提倡開源和共項
同時也出于一個提出合理的標準的目的，而讓廣大的開發(fā)者參與標準的制定 而成立了這樣一個社區(qū)，現(xiàn)在還健在，網(wǎng)址是jcp.org 每一個新的規(guī)范發(fā)布之前都會在這個社區(qū)廣泛討論，最終對規(guī)范的制定產(chǎn)生巨大的影響 其中就包括企業(yè)級的參與者，相當有名的JBoss以及我國的金碟公司都是其中的成員 下面介紹一下幾個相當著名的框架，必須要指出的是，雖然框架大多開源 但并不代表所有的框架都開源，比如.net framework，但是java框架大多數(shù)開源 言歸正傳
Struts 表示層框架，名字來源于飛機的金屬框架 可能有讀者會提問了 表示層不是客戶端么？
沒錯，但是語言這東西，眾口爍金，別人都這么說你就不好不這么說了 最早表示層說的是客戶端，后來隨著時間的發(fā)展 人們也把服務(wù)器端直接與客戶端//比如IE 打交道的那部分也稱為表示層//JSP+Servlet 那么表示層框架是干什么的呢？
早先大規(guī)模應用JSP的時候，人們發(fā)現(xiàn)，JSP里面充斥著邏輯代碼與數(shù)據(jù) 可讀性極差，于是人們借用很早很早以前的MVC模式的思想 把表示層組件分為V-Viewer，也就是JSP M-Model模型，一般來說是一個JavaBean C-Controller控制器，一般來說是一個Servlet 所有人通過JSP和服務(wù)器打交道，發(fā)送請求，Viewer把這個請求轉(zhuǎn)發(fā)給Controller Controller通過調(diào)用一個Model來處理該請求，然后返回數(shù)據(jù)到Viewer 這么一個過程，從而達到數(shù)據(jù)與邏輯的剝離，增強代碼可讀性，降低維護成本 而幫助人們實現(xiàn)這一系列東西的就是Struts框架，就是這么一個東西 Struts的競爭對手主要是產(chǎn)商們極力倡導的JSF也就是Java Server Faces 但是由于Struts出道時間早，所以應用比較多 JSF則是產(chǎn)商們大力支持，前景看好
對于這一層來說，在JSP的html代碼中出現(xiàn)的java語句越少越好 因為java代碼越少說明頁面處理的業(yè)務(wù)邏輯越少，也越合理 這也是Struts最初的目的，記住這話
Spring 大名鼎鼎的Spring框架
有人曾說2005年一片叫春之聲，指的就是該框架
Spring起源于Rod Johnson的《Expert One-on-One J2EE Design and Development》一書 Rod Johnson認為，J2ee里面的那一套//尤其是ejb 太重了，對于單機的系統(tǒng)來說，沒有必要使用那么復雜的東西 于是就開始設(shè)計并引導Spring小組開發(fā)出這樣一個構(gòu)架
不能不說他是個天才，因為的的確確不是所有的系統(tǒng)都是跨多服務(wù)器的 沒有必要把一個簡單的系統(tǒng)設(shè)計得那么復雜//天才的那幾個共性又體現(xiàn)出來了 Spring從誕生之日起就是針對EJB的，力爭在不少應用上取代EJB 而它也確實達到了這個目的
現(xiàn)在包括WebLogic等主流應用服務(wù)器還有主流IDE都開始逐漸接受該框架 并提供相應支持
提到Spring就不能不說控制反轉(zhuǎn)Ioc//Inversion of Control 和依賴注射DI//Dependency Injection 什么叫控制反轉(zhuǎn)呢？
套用好萊塢的一句名言就是：你呆著別動，到時我會找你。
Hibernate 名字取材自O(shè)RM最早的一句玩笑話//ORM就是OR-Mapping 說用了ORM之后，程序員就可以去冬眠了，而不需要操心那么多事
這里不得不說的是，該框架由于做得太好，以至于被J2ee招安，成為EJB3.0的一部分 替代原有EJB2.X里面關(guān)于Entity Bean而成為EJB ORM的工具 這里解釋一下ORM//OR-Mapping 中文名對象關(guān)系映射
什么意思呢？我們知道傳統(tǒng)的數(shù)據(jù)庫都是關(guān)系型的
一條條記錄以表格的形式儲存，而表與表之間充斥著是關(guān)系/關(guān)聯(lián)
比如說一個人，名字zhaoce，性別男，年齡23那么數(shù)據(jù)庫中是這么儲存的 姓名 性別 年齡 zhaoce m 23 某女 f 22 而實際應用服務(wù)器中的實體都是以對象的形式存在，一個個對象 zhaoce是以這種形式存在的 Human human=new Human();human.setName(“zhaoce”)human.setSex(“m”);human.setAge(23);這樣的，那么我們知道，傳統(tǒng)的JDBC是通過一個二維字符串將數(shù)據(jù)取出 需要我們自己將其包裝成對象，在存入的時候，我們還需要將對象拆開 放入sql語句中//Insert into Huamn values('zhaoce','m',23)然后執(zhí)行該sql語句
太麻煩太麻煩，ORM理念的提出改變了這一切，ORM認為，這些東西應該由框架來做 而不是程序員，程序員做他該做的，不要為這種破事分心，還測試半天 于是就出現(xiàn)了Hibernate，JDO，TopLink等等，甚至.net里面也有ADO.net 過去一段時間是Hibernate和JDO爭風，現(xiàn)在看來Hibernate逐漸成為主流并被官方接納 成為規(guī)范標準之一，替代掉原來EJB2.X的ORM EntityBean TopLink則是Oracle公司推出和Oracle數(shù)據(jù)庫結(jié)合的一種ORM 商業(yè)用軟件，貴且復雜，不過正在逐漸開放
而象表示層一樣，這一種專門面對數(shù)據(jù)層的代碼也被稱為數(shù)據(jù)持久層 所以數(shù)據(jù)持久層這一概念有時不僅僅指代數(shù)據(jù)庫
關(guān)于ORM，最高的境界應該是在java代碼中不出現(xiàn)任何一句的sql語句 注意，是不包括sql語句，Hibernate的hql以及ejb的ejb-ql不算在內(nèi)
至于出現(xiàn)不出現(xiàn)hql/ejb-ql等替代ql，這要視具體情況而定，不過最好也是不出現(xiàn) 當然最后所說的過分理想的情況往往不現(xiàn)實，總之一句話
以sql為代表的ql/*還有hql,ejbql等*/語句在代碼中出現(xiàn)得越少越好 記住這話，現(xiàn)在未必能夠理解，學了以后就懂了
這三個是目前最為常用的框架 而目前光已公布的框架就>500 還在不停增加中，不可能一一列舉，有興趣的可以去看相應文檔 要指出的是框架不是應用程序
只是一堆組件的有序復合，應用時不能脫離于應用服務(wù)器單獨存在給初學者之九：收尾 最后一篇介紹幾個常見的概念 設(shè)計模式
這可不僅是java獨有
我看的書就是c++和smalltalk例子的 先說說什么是設(shè)計模式
模式是什么？模式是經(jīng)驗的總結(jié)，潛規(guī)則的抽象
什么意思呢？比如說我們坐飛機，上飛機前需要經(jīng)過幾個步驟 什么安檢領(lǐng)取登機牌之類的，這一套流程能不能改呢？
可以，但為什么幾乎全世界的航空公司登機前都是這一套流程呢？ 因為航空公司經(jīng)過長期實踐之后得出了一堆結(jié)論和經(jīng)驗 并認為這樣做才是最安全，或說是最有效率的 這就是模式，模式是編程高手之間交流的橋梁 兩個編程高手通過統(tǒng)一命名的模式了解對方的思想
當然不借助模式可不可以？當然可以，只是模式無處不在，你不知道而已
又比如吃飯，每吃一口飯，我們要先端碗，拿筷子，張嘴，塞飯入口，咀嚼最后吞咽 這就是一套模式，我們給這套模式命名為吃飯 那么當老爸叫吃飯的時候，我們就能明白什么意思
而不用老爸進來囈囈啊啊并比畫上半天，啞語也不是這么用的 這就是模式，已知的模式有400多種//好象更多，不記得了 比如數(shù)據(jù)庫有數(shù)據(jù)庫的設(shè)計模式，編程有編程的模式等等
面向?qū)ο笥谐Ｓ玫?1種模式，需要掌握，主要分為創(chuàng)建，行為，結(jié)構(gòu)三類 J2ee有J2ee的模式，Sun公司出了一本書叫《J2EE核心模式》可以拿來看看 必需要指明的是，模式不是規(guī)范，比如吃飯模式
沒有人規(guī)定你吃飯非得要那么吃，你可以端碗，上拋，張嘴在下落后連碗一起吞咽 這也可以，只要你愿意，同樣，只要你愿意，你就可以不遵循模式
模式之外還有反模式，學模式不可定勢，不要學死，活學活用，無招勝有招才是最高境界 JavaDoc 文檔工具，極其好用
可以根據(jù)注釋自動生成HTML文檔 Ant 98年，有一位程序員在從歐洲飛回美國的飛機上想到了這么一個東西 從而改變了整個世界，他的名字叫James Duncan Davidson 組織管理工具，可以這么描述它
比如你想在編譯之后自動再次生成JavaDoc 那么你只需要編輯Ant腳本//對，就像Windows腳本那樣 然后批處理就可以了，不過現(xiàn)在Ant已經(jīng)廣泛集成到IDE中去 不需要自己手動編寫，不過如果想要炫炫，據(jù)說此招百試不爽 JUnit 測試工具，Unit家族可不只有JUnit 還有其它版本的，這個不細說，具體實踐一下就明白了 POJO //Plain Old Java Object 就是傳統(tǒng)的Java對象，也就是一個JavaBean 由虛擬機來掌握其生死
常用的兩個管理構(gòu)架/規(guī)范是Spring和EJB容器 命名由來是某人//名字我忘了
覺得我們使用了太多的規(guī)范，以至于我們都忘記了純粹的java對象 以至于我們都忽略了它的存在，所以叫了這么一個名字 以喚醒人們的記憶，這個意義上來說EJB其實不能算是POJO 畢竟遵循了一堆的接口，但是不管怎樣，接口歸接口，還是沒有繼承類 沒有被強加什么//遵循可以寫空方法假遵循 所以說還是POJO也對 但是由于這種東西缺乏管理，不象Servlet有專門的容器管理并繼承了一定的類 而沒有管理的對象在虛擬機中是很危險的，因為垃圾回收機制各個虛擬機不同 而且也不怎樣，極有可能長時間不回收，這樣在企業(yè)級的應用中呢 就有可能造成內(nèi)存大量被占用從而死機，毫無疑問，這種機制需要優(yōu)化 這種優(yōu)化就是通過EJB容器或者Spring構(gòu)架來實現(xiàn) 這么做還有一個好處就是迫使程序員對每一個類做封裝
強迫他做管理，以達到防止內(nèi)存泄露的目的，內(nèi)存泄露最經(jīng)常出現(xiàn)的錯誤就是 引用未釋放，引用最典型體現(xiàn)在new這個關(guān)鍵字上，new得越多引用得越多 隨著時間地增長，有可能導致循環(huán)，不停new new new new new.....其中哪怕只要有一個new處理不當，虛擬機無法回收內(nèi)存 那就極有可能完蛋，而且這種小bug越是在大的項目越是難以找到 有可能因為一個人而影響整個項目組，所以不妨記住我的一條經(jīng)驗 好的系統(tǒng)框架不應該在業(yè)務(wù)邏輯流程中出現(xiàn)new關(guān)鍵字 現(xiàn)在不理解也無所謂，將來有一天會明白的 SOA 面向服務(wù)的構(gòu)架
不說太多，這個屬于上上層建筑
不過不妨記住我的一句話，可以幫助理解這個概念 面向什么就是對什么做封裝 面向?qū)ο缶褪菍ο笞龇庋b 面向服務(wù)類似，剩下的靠悟性 反射
1.4新增功能，非常強大
通過反射，程序可以解析出類本身的屬性也就是變量
/注意這里說的屬性不是.net里面的屬性，我不喜歡微軟造的新名詞，亂 還有行為也就是方法，然后通過invoke()方法調(diào)用該方法 甚至可以新增對象等，java首創(chuàng)，本是其它語言所沒有的
后來被微軟抄了去，利用該功能，開源框架廣泛受益并大量采用，近乎瘋狂地使用 具體就不說了，最后要指出的是，有一種說法是利用反射會降低效率 在早期的時候，的確是，現(xiàn)在不會了，放心使用 容器
5.0以后的版本在J2SE中都出現(xiàn)了容器 各位甚至可以自己嘗試用標準庫去使用容器 書籍
《Thinking in Java》 //實話說，一般，尤其是翻譯后的版本，原版還行 《Java教程》 //電子工業(yè)出版社出版的那本，上下冊，很厚，但翻譯得不錯 《21天學通Java》 //入門極好，但是《21天學通j2ee》極爛，不要買 《Mastering EJB》 //翻譯過的書質(zhì)量我不清楚，估計不怎樣，請看原版書籍 《精通Hibernate》 //看清楚作者，孫衛(wèi)琴，其它人的別買
其它的可以不用了，網(wǎng)絡(luò)上的遠比書上來得多，來得好，雖然也來得雜 最后的建議 一，不要做一個浮躁的人 二，學好英語，很重要 三，閱讀源代碼和文檔
四，共享源代碼，不要做一個功利的人 五，熱愛Java 相信能看到這里的朋友都是真心想學習java，在編程的路上你已經(jīng)成功的走出了第一步，接下來就是努力的走下去。。加Java學習群四一八，三五五，五三一。
第五篇：JAVA基礎(chǔ)總結(jié)
JAVA基礎(chǔ)總結(jié)
轉(zhuǎn)眼間，已經(jīng)來到這里學習半年了，而現(xiàn)在我們對于JAVA學習才算是真正的開始。一開始接觸的時候我發(fā)現(xiàn)這個和C語言的基本語法幾乎一模一樣的，老師說：JAVA語言本來就是C++語言發(fā)展過來的，而C++是從C語言發(fā)展來的，C C++ 還有JAVA雖然是不同的三種語言，但是其實他們的基本語法是一樣的，但是它們卻有巨大的區(qū)別，這個區(qū)別主要是體現(xiàn)在思想上。
都說C語言是面向過程的語言,C++ C#和JAVA是面向?qū)ο蟮木幊蹋鋵嵕褪撬季S方式稍微改了一下子，面向過程的語言主要是著重于算法，面向?qū)ο笾赜谶壿嫸选?/p>
這個教我們的老師是張成峰老師，張成峰是個很負責的老師，雖然JAVA基礎(chǔ)其實和C語言基礎(chǔ)差不多，但是仔細學學還是能找出很多不同的細節(jié)的，于是大家的問題就很多，張老師幾乎就是手把手的教我們，所以整體來說JAVA基礎(chǔ)學得挺扎實的。
我在這本書的學習不是挺好，聯(lián)系得少了，所以對代碼也不是特別熟悉。而且JAVA是一門重概念的書，對于我來說，概念是我的要害，理論知識也是我最怕學習的，所以學習這本書對我來說很是艱難，聽了很久的課，代碼寫得出來，但是理論知識幾乎一點也不明白，結(jié)果就造成了這次筆試考的不好。
筆試考的不好，機試也因為我的粗心沒有考好，所以這次的成績不好。
學習JAVA基礎(chǔ)后，還要在學習的過程中對每個知識都要用心和細心，當然最該注重的地方就是應該提高我對理論知識的學習，要多看書，也要多敲敲代碼，這些就是提高學習知識全面的方法。
下一本書學習的是JAVAOO算是JAVA的一個重要的內(nèi)容了，這才會真正的接觸JAVA的核心課程，在這本書里我要好好的理解理論知識，仔細的學習每個知識。
點擊咨詢 