第一篇：學習java需要什么基礎范文
學習java需要什么基礎
學習Java成為了很多大學生提升自己專業(yè)技能的主流方式，而很多同學在自學了一段時間后毅然選擇Java培訓機構來學習Java。有心參加Java培訓是件好事，而做好充分的準備也是必須的。4G夢工場建議大家不妨來看看學習java需要什么基礎。
1.了解Java，明確自己的學習目標
學習Java的優(yōu)勢在那里？Java技術運用于哪些行業(yè)？在學之前，最好去找一點IT市場上Java技術的發(fā)展狀況吧。清楚Java的過去與未來將對你的Java學習有著很大的好處，有助于你在以后的學習和工作中有一個明確的目標。
2.做好花時間花精力學習Java的準備
如果你確定了學習java，你需要明白的是接下來的時間你將會被各種代碼，各類項目開發(fā)所包圍，日復一日地敲代碼學技術，在學習過程中累計經(jīng)驗，拓展知識面。如果你能夠調(diào)整好自我，以積極向上的心態(tài)堅持下去，你一定能夠圓你的IT夢。如果你準備三天打魚兩天曬網(wǎng)，那么會導致你知識結構不全面，對你日后的拓展也起著阻礙作用，成Java工程師還將會花上更長的時間。
3.做好拓展學習的準備
想要在Java開發(fā)上有成就，就不能局限于只學習一些java技術。在學好Java技術的同時，你還需要掌握更多的知識，花上更多的時間來學習多方面的技術知識。
以上是4G夢工場的老師給大家的幾點建議，大家可以參考一下。學習java需要什么基礎，其實只有心態(tài)好，學習java其實很簡單的。如果真的想學習java的話，不妨找一個好的培訓學校學習，4G夢工場在武漢是很多同學選擇的，大家不妨考慮下。
第二篇：JAVA學習需要什么基礎
JAVA學習需要什么基礎
隨著Java這種語言的廣泛運用，越來越多從事開發(fā)的人員開始學習接觸這門課程，那么，Java學習需要什么基礎？Java剛剛入門應該接觸哪些知識呢？Java入門應該學習什么內(nèi)容呢？
首先要說明的，JAVA有三個大的方向（J2se,J2me,J2ee），走不同的方向可能學的技術和要花費的時間可能有所不同。我是搞web方向的（J2ee），我學Java除了以前一些簡單的C語言語法外，沒有太多的編程基礎，我以前一直認為編程要有很強的數(shù)學和英語功底，現(xiàn)在看來這也不是必需，只要有一定的邏輯思維能力和掌握一些常見的計算機詞匯，還需要具備一定的自學能力，因為軟件開發(fā)工作是需要不斷學習的。
其次，我想說下我的學習過程，我在網(wǎng)上下載了JAVA教學視頻，將Java基礎從頭到尾看了一遍，將上面的代碼基本上跟著敲了一遍，然后我把Java基礎的書看了一遍，一本書看完包括上面的習題大概做一遍差不多一個月。這時你對Java的語法和基本知識應該都有比較充分的認識和了解了。
然后，再做一些小項目，跟著視頻上的步驟做，最好能自己獨立再寫寫，能寫多少是多少。一般網(wǎng)上比較新的免費的項目庫很不好找，因為項目庫是需要實時更新以保證適合市場需要的，而它的升級和更新是需要錢的，所以去報一個培訓中心利用它強大的項目庫進行實戰(zhàn)操作是個很好的選擇。
操作一段時間之后，你對Java已經(jīng)有了一定的感覺，就要開始選擇你的發(fā)展方向了。我選擇了J2ee，如果你也是想走這條路，你可以接著看關于J2ee的視頻，先是html+Js+css,然后Jsp+serverlet，再看struts+spring+hibernate等一些框架。同時可以看一些大的培訓機構的關于設計模式的視頻，最好是IT牛人錄制的，當然數(shù)據(jù)庫也得學下，然后加上做項目的經(jīng)驗累積，半年就差不多可以出去工作了。
如果你做其他方向的話我不是很了解。再說下我個人的看法，J2me和J2se好像前景沒J2ee好，不過我有同事是做android平臺開發(fā)的，這個不需要J2ee的知識，你可以去買本android的看看，這個方向貌似很有前途，你應該也常聽說android平臺的手機，如果走這方向可以再學一下linux知識和c的知識，因為這個平臺底層是這些，這也不是必要。
說了這么多希望對大家能有所幫助。最后再說一句，學東西，最重要的是動手，只有動手做了才能深深的理解，牢牢的記住。
（PS：本文檔由北大青鳥廣安門收集自互聯(lián)網(wǎng)，僅作分享之用。）
第三篇：Java學習_基礎總結
現(xiàn)在學習JAVA的人越來越多！但是學的好的，能用到工作中去的卻很少很少，下面就是我為大家總結歸納的一些JAVA學習基礎，希望大家少走彎路，盡快投入到工作中去！
Java 學習基礎總結歸納！
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用于保證程序最基本、關鍵的正確性。assertion檢查通常在開發(fā)和測試時開啟。為了提高性能，在軟件發(fā)布后，assertion檢查通常是關閉的
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運算結果是int型，需要強制轉換類型）short s1= 1;s1 += 1;（可以正確編譯）
10、Java有沒有goto
答：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 表示一種設計或實現(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)建一個變量，其類型是一個抽象類，并讓它指向具體子類的一個實例。不能有抽象構造函數(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)編將生效。引用可以轉換到接口類型或從接口類型轉換，instanceof 運算符可以用來決定某對象的類是否實現(xiàn)了接口
18、abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized
答：都不能
19、接口是否可繼承接口? 抽象類是否可實現(xiàn)(implements)接口? 抽象類是否可繼承實體類(concrete class)
答：接口可以繼承接口。抽象類可以實現(xiàn)(implements)接口，抽象類是否可繼承實體類，但前提是實體類必須有明確的構造函數(shù)
20、構造器Constructor是否可被override
答：構造器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ù)傳遞到一個方法后，此方法可改變這個對象的屬性，并可返回變化后的結果，那么這里到底是值傳遞還是引用傳遞
答：是值傳遞。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是否正確?
答:不正確。精度不準確,應該用強制類型轉換，如下所示：float f=(float)3.4
31、介紹JAVA中的Collection FrameWork(包括如何寫自己的數(shù)據(jù)結構)?
答：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、談談final, finally, finalize的區(qū)別
答：final—修飾符（關鍵字）如果一個類被聲明為final，意味著它不能再派生出新的子類，不能作為父類被繼承。因此一個類不能既被聲明為 abstract的，又被聲明為final的。將變量或方法聲明為final，可以保證它們在使用中不被改變。被聲明為final的變量必須在聲明時給定初值，而在以后的引用中只能讀取，不可修改。被聲明為final的方法也同樣只能使用，不能重載 finally—再異常處理時提供 finally 塊來執(zhí)行任何清除操作。如果拋出一個異常，那么相匹配的 catch 子句就會執(zhí)行，然后控制就會進入 finally 塊（如果有的話）finalize—方法名。Java 技術允許使用 finalize()方法在垃圾收集器將對象從內(nèi)存中清除出去之前做必要的清理工作。這個方法是由垃圾收集器在確定這個對象沒有被引用時對這個對象調(diào)用的。它是在 Object 類中定義的，因此所有的類都繼承了它。子類覆蓋 finalize()方法以整理系統(tǒng)資源或者執(zhí)行其他清理工作。finalize()方法是在垃圾收集器刪除對象之前對這個對象調(diào)用的
35、面向對象的特征有哪些方面
答：主要有以下四方面：
1.抽象：抽象就是忽略一個主題中與當前目標無關的那些方面，以便更充分地注意與當前目標有關的方面。抽象并不打算了解全部問題，而只是選擇其中的一部分，暫時不用部分細節(jié)。抽象包括兩個方面，一是過程抽象，二是數(shù)據(jù)抽象。
2.繼承：繼承是一種聯(lián)結類的層次模型，并且允許和鼓勵類的重用，它提供了一種明確表述共性的方法。對象的一個新類可以從現(xiàn)有的類中派生，這個過程稱為類繼承。新類繼承了原始類的特性，新類稱為原始類的派生類（子類），而原始類稱為新類的基類（父類）。派生類可以從它的基類那里繼承方法和實例變量，并且類可以修改或增加新的方法使之更適合特殊的需要。
3.封裝：封裝是把過程和數(shù)據(jù)包圍起來，對數(shù)據(jù)的訪問只能通過已定義的界面。面向對象計算始于這個基本概念，即現(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ù)結構存儲，當引用類型和原始類型用作某個類的實例數(shù)據(jù)時所指定的缺省值。對象引用實例變量的缺省值為 null，而原始類型實例變量的缺省值與它們的類型有關
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不支持多繼承，而有可能某個類或對象要使用分別在幾個類或對象里面的方法或屬性，現(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關鍵字引發(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，它們是可變大小的列表，比較適合構建、存儲和操作任何類型對象的元素列表。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 進行排序所得結果為l e f t + m i d d l e + r i g h t
47、JAVA語言如何進行異常處理，關鍵字：throws，throw，try，catch，finally分別代表什么意義？在try塊中可以拋出異常嗎？
答：Java通過面向對象的方法進行異常處理，把各種不同的異常進行分類，并提供了良好的接口。在Java中，每個異常都是一個對象，它是Throwable類或其它子類的實例。當一個方法出現(xiàn)異常后便拋出一個異常對象，該對象中包含有異常信息，調(diào)用這個對象的方法可以捕獲到這個異常并進行處理。Java的異常處理是通過5個關鍵詞來實現(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ù)結構時有可能會出現(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)絡之間。序列化是為了解決在對對象流進行讀寫操作時所引發(fā)的問題。序列化的實現(xiàn)：將需要被序列化的類實現(xiàn)Serializable接口，該接口沒有需要實現(xiàn)的方法，implements Serializable只是為了標注該對象是可被序列化的，然后使用一個輸出流(如：FileOutputStream)來構造一個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零基礎學習資料
JAVA零基礎學習資料
1、linux系統(tǒng)中的簡單命令操作 1)文件系統(tǒng)：只有一個根目錄“/”
目錄=文件夾（window）
2）用戶的主目錄：可以做任何的操作 3）pwd: 顯示當前的工作目錄
ls : 顯示當前工作目錄的內(nèi)容
4）相對路徑：相對當前的工作目錄：
cd home
絕對路徑：一切以根目錄作為參照：
cd /home 5)cd ： 切換當前的工作目錄
cd.: 當前的工作目錄
cd..: 上層工作目錄
cd / : 切換到根目錄
cd ~ ：切換到主目錄
cd /目錄名： 切換到絕對路徑下的目錄
cd 目錄名： 切換到相對路徑下的目錄
（要切換的目錄必須在當前目錄的下層）
6)mkdir 創(chuàng)建目錄
mkdir demo 在當前的目錄下面來創(chuàng)建demo、編程語言歷史
1）機器語言 ：直接跟硬件操作
01000101 00001111 2）匯編語言 ：
Add 3）中級語言：
C語言
4）高級語言：
C++-->java，c#，php------->000100
web開發(fā)：java，c#，php java運行機制 先編譯然后再解釋
Demo1.java ———》Demo1.class———》001001...（就是機器語言）
編譯
解釋
4、變量：就是內(nèi)存中一塊存儲區(qū)域，用來保存數(shù)據(jù)
1）變量基本知識
確定變量的類型，確定變量名字
整數(shù)類型 ： int
變量名：
num
格式： 數(shù)據(jù)類型 變量名；
eg ：int num；
2）給變量賦值
a 賦值符號：“=”
把“=”右邊的數(shù)值賦值給左邊的變量
eg ：int num;
num = 12;
b 最后一次的賦值會覆蓋掉前面的值 eg ：num = 13;、java中的命名規(guī)范
1）名字必須以“字母”或
只能包含“字母”或“_”
2）java當中嚴格的區(qū)分大小寫
eg ： int a ； int A；
3）命名一定不能跟關鍵字（4）最好見名知意
5）注意縮進
6、把已有的java工程導入到
第一步：點擊File----->點擊或“$”開頭或“$”或“數(shù)字 int）重復eclipseImport ,里面 ”
“_”
軟件中：
第二步：雙擊General
第三步：雙擊上圖那個位置
Eclipse簡單的介紹，在工程區(qū)域右擊新建包名和類名，在上圖中最下方有個小的console窗口，是運行java文件后輸出的結果。右擊java文件名找到run as，再點擊Java application 就有運行。
第四步：雙擊Browse，找到想要打開的java文件
第五步：把Copy那個紅線處勾上導入完成了。最后點擊finish就完成了。
第五篇：Java基礎學習知識點總結
黑馬程序員_畢向東_Java基礎視頻教程
Java基礎學習知識點總結 2016年01月06日
day01
一、基礎知識：軟件開發(fā)
1、什么是軟件？軟件：一系列按照特定順序組織的計算機數(shù)據(jù)和指令的集合。
2、常見的軟件：系統(tǒng)軟件：如：DOS，Windows，Linux等。應用軟件：如：掃雷，迅雷，QQ等。
3、什么是開發(fā)？制作軟件。
二、基礎知識：人機交互方式
4、軟件的出現(xiàn)實現(xiàn)了人與計算機之間的更好的交互。
5、交互方式：圖形化界面：這種方式簡單直觀，使用者易于接受，容易上手操作。命令行方式：需要有一個控制臺，輸入特定的指令，讓計算機完成一些特定的操作。較為麻煩，需要記錄住一些命令。
三、基礎知識：常用的DOS命令
6、點擊開始在運行欄輸入“cmd”進入dos操作界面。
7、課程中常見的命令：
dir：列出當前目錄下的文件以及文件夾。md：創(chuàng)建目錄。rd：刪除目錄。
cd：進入指定目錄。d：進入盤符。cd..：退回到上一級目錄。cd/：退回到根目錄。del：刪除文件。
exit：退出dos命令行。
8、在dos命令行操作文件夾時，如忘記文件夾全稱，可以輸文件夾前幾個名稱后面用*代替。
四、基礎知識：計算機語言
9、通過DOS命令行的演示，發(fā)現(xiàn)原來操作計算機就如同和計算機說話一樣。
10、我們告訴它做什么，它就可以做什么。前提是，我們和它說的內(nèi)容它必須識別才可以。這就是計算機語言。
11、什么是計算機語言？語言：是人與人之間用于溝通的一種方式。例如：中國人與中國人用中文溝通。而中國人要和韓國人交流，就要學習韓語。
12、計算機語言：人與計算機交流的方式。如果人要與計算機交流，那么就要學習計算機語。計算機語言有很多種，如：C，C++，Java等。這里，我們選擇其中一種：Java語言。
五、基礎知識：Java語言介紹
13、Java語言概述。是SUN（Stanford University Network，斯坦福大學網(wǎng)絡公司）1995年推出的一門高級編程語言。是一種面向Internet的編程語言。隨著Java技術在Web方面的不斷成熟，已經(jīng)成為Web應用程序的首選開發(fā)語言。是簡單易學，完全面向對象，安全可靠，與平臺無關的編程語言。
14、Java語言的三種技術架構。J2EE（Java 2 Platform Enterprise Edition）企業(yè)版（現(xiàn)更名：JAVAEE）：是為開發(fā)企業(yè)環(huán)境下的應用程序提供一套解決方案。該技術體系中包含的技術如Servlet Jsp等，主要針對于Web應用程序開發(fā)。J2SE（Java 2 Platform Standard Edition）標準版（現(xiàn)更名：JAVASE）：是為開發(fā)普通桌面和商務應用程序提供的解決方案。該技術體系是其他兩者的基礎，可以完成一些桌面應用程序的開發(fā)。比如Java版的掃雷。J2ME（Java 2 Platform Micro Edition）小型版（現(xiàn)更名：JAVAME）：是為開發(fā)電子消費產(chǎn)品和嵌入式設備提供的解決方案。該技術體系主要應用于小型電子消費類產(chǎn)品，如手機中的應用程序等。
15、Java語言的特點：跨平臺性。什么是跨平臺性？通過Java語言編寫的應用程序在不同的系統(tǒng)平臺上都可以運行。原理是什么？只要在需要運行Java應用程序的操作系統(tǒng)上，先安裝一個Java虛擬機（JVM Java Virtual Machine）即可。由JVM來負責Java程序在該系統(tǒng)中的運行。
16、Java語言的特點：跨平臺性。Java程序：Windows系統(tǒng)：Win版的JVM；Linux系統(tǒng)：lin版的JVM；MAC系統(tǒng)：mac版的JVM。因為有了JVM，所以同一個Java程序在三個不同的操作系統(tǒng)中都可以執(zhí)行。這樣就實現(xiàn)了Java程序的跨平臺性。也稱為Java具有良好的可移植性。
六、基礎知識：Java語言的環(huán)境搭建
17、明確什么是JRE，JDK；下載JDK；安裝JDK；配置環(huán)境變量；驗證是否成功。
18、什么是JRE，JDK？JRE（Java Runtime Environment Java運行環(huán)境）：包括Java虛擬機（JVM Java Virtual Machine）和Java程序所需的核心類庫等，如果想要運行一個開發(fā)好的Java程序，計算機中只需要安裝JRE即可。JDK（Java Development Kit Java開發(fā)工具包）：JDK是提供給Java開發(fā)人員使用的，其中包含了Java的開發(fā)工具，也包括了JRE。所以安裝了JDK，就不用再單獨安裝JRE了。其中的開發(fā)工具：編譯工具（java.exe）打包工具（jar.exe）等。簡單而言：使用JDK開發(fā)完成的Java程序，交給JRE去運行。
19、Java6.0 Platform
20、下載JCK（Java Development Kit Java開發(fā)工具包）。官方網(wǎng)址：www.tmdps.cn、java.sun.com。下載完成后，安裝在電腦上。然后打開DOS命令行，效驗文件是否安裝完畢，并利用DOS進行Javac.exe運行測試。為了更方便的使用Java開發(fā)工具，需要進行環(huán)境變量配置。配置成功后就可以進行Java程序的開發(fā)了。
21、環(huán)境變量配置。方法一：圖形界面操作。我的電腦——屬性——高級——環(huán)境變量；編輯Path環(huán)境變量，在變量值開始處加上Java工具所在目錄，后面用分號和其他值分隔開即可；打開DOS命令行，任意目錄下敲入javac；如果出現(xiàn)javac的參數(shù)信息，配置成功。這種配置方式，一勞永逸。具體流程：右鍵點擊我的電腦打開屬性，點擊高級系統(tǒng)設置，點擊高級，點擊環(huán)境變量，找到系統(tǒng)變量，新建系統(tǒng)變量（變量名：JAVA_HOME，變量值：安裝JKD的地址。如：D:ProgramStudioJDK1.7）點擊確定，找到變量名為Path的變量，點擊編輯，在變量值欄的最前面（放到前面時，先尋找）加入%JAVA_HOME%bin用分號隔開。方法二：DOS界面操作（可用于臨時環(huán)境變量配置，借助別人的電腦開發(fā)Java程序）。具體流程：利用set命令：設置、查看環(huán)境變量的值。Set path：查看path的值。配置Java工具包：set path=D:ProgramStudioJDK1.7bin;%path%回車。測試javac。只對當前窗口有效。定義class路徑：Set classpath=.;c:myclass。
七、基礎知識：Java程序開發(fā)體驗
22、Hello World。將Java代碼編寫到擴展名為.java的文件中；通過javac命令對該java文件進行編譯；通過java命令對生成的class文件進行運行。Java文件——javac.exe編譯——class文件——java運行——結果。
23、對于初學者，可以用記事本編寫。按部就班，一步一步寫代碼。打開記事本。Java代碼是以類的形式來體現(xiàn)的。代碼如下： class TestFirstOne //Java定義類+類名（首字母大寫）{ public static void main(String[] args)//主函數(shù)（保證類的獨立運行）
{
System.out.println(“hello world”);//輸出打印語句
} }
23、classpath配置。臨時配置方式：dos配置。Set Classpath=代碼路徑。回車。Classpath先在環(huán)境變量中找，然后在當前路徑（結尾沒帶分號不找）。Path先在當前路徑查找，然后去環(huán)境變量中查找。一勞永逸方法和上面JDK環(huán)境變量配置方法一樣。
24、Hello World組成部門。class是java程序中的關鍵字（關鍵字只能是小寫）。{}類的區(qū)間用大括號定義（類中的內(nèi)容為了增加閱讀性，需要有階梯感，如使用tab鍵）。public static void main(String[] args)定義主函數(shù)（使用大括號確定函數(shù)的內(nèi)容）。
25、注釋。三種方式：//單行注釋，符號以后直到回車鍵的內(nèi)容；/*多行注釋，符號開始到符號結束以內(nèi)的內(nèi)容*/；/**java注釋符號，可被提取出來制作軟件開發(fā)手冊*/。注釋的作用：增加程序的閱讀性；調(diào)試程序。
26、寫代碼要養(yǎng)成寫注釋的習慣。在寫代碼前注釋相關信息。例如： /* 需求：定義一個Hello World小程序。思路： 1，2，步驟：
1，通過class關鍵字定義一個類。將代碼都編寫到該類中。
2，為了保證該的獨立運行。在類中定義個主函數(shù)。格式public static void main(String[] args)3，保存成一個擴展名為java的文件。
4，在dos控制臺中通過javac工具對java文件進行編譯。5，在通過java命令對生成的class文件進行執(zhí)行。作者：ZC 版本：v1.0 日期：2016.01.06 copyright：ZC */ 2016年01月07日
day02
一、基礎知識：Java語言基礎組成
1、組成：關鍵字、標識符、注釋、常量和變量、運算符、語句、函數(shù)、數(shù)組
二、基礎知識：關鍵字
2、關鍵字的定義和特點：定義：被Java語言賦予了特殊含義的單詞。特點：關鍵字中所有字母都為小寫。
3、用于定義數(shù)據(jù)類型的關鍵字：class、interface、byte、short、int、long、float、double、char、boolean、void。
4、用于定義數(shù)據(jù)類型值的關鍵字：true、false、null。
5、用于定義流程控制的關鍵字：if、else、switch、case、default、while、do、for、break、continue、return。
6、用于定義訪問權限修飾的關鍵字：private、protected、public。
7、用于定義類，函數(shù)，變量修飾的關鍵字：abstract、final、static、synchronized。
8、用于定義類與類之間關系的關鍵字：extends、implements。
9、用于定義建立實例以及引用實例，判斷實例的關鍵字：new、this、super、instanceof。
10、用于異常處理的關鍵字：try、catch、finally、throw、throws。
11、用于包的關鍵字：package、import。
12、其他修飾符關鍵字：native、strictfp、transient、volatile、assert。
三、基礎知識：標識符
13、標識符：在程序中自定義的一些名稱；由26個英文字母大小寫，數(shù)字：0-9，符號_$組成；定義合法標識符規(guī)則：數(shù)字不可以開頭、不可以使用關鍵字；Java中嚴格區(qū)分大小寫；注意：在起名時，為了提高閱讀性，要盡量有意義。
14、Java中的名稱規(guī)范：包名：多單詞組成時所有都小寫，如：xxxyyyzzz；類名接口名：多單詞組成時，所有單詞的首字母大寫，如：XxxYyyZzz；變量名和函數(shù)名：多單詞組成時，第一個單詞首字母小寫，第二個單詞開始每個單詞首字母大寫，如：xxxYyyZzz；常量名：所有字母都大寫，多單詞時每個單詞用下劃線連接，如：XXX_YYY_ZZZ。
四、基礎知識：注釋
15、注釋：對于單行和多行注釋，被注釋的文字，不會被JVM（Java虛擬機）解釋執(zhí)行；對于文檔注釋，是Java特有的注釋，其中注釋內(nèi)容可以被JDK提供的工具javadoc所解析，生成一套以網(wǎng)頁文件形式體現(xiàn)的該程序的說明文檔；注釋是一個程序員必須要具有的良好編程習慣；初學者編寫程序可以養(yǎng)成習慣；先寫注釋再寫代碼；將自己的思想通過注釋先整理出來，再用代碼去體現(xiàn)；因為代碼僅僅是思想的一種體現(xiàn)形式而已；用于注解說明解釋程序的文字就是注釋；提高了代碼的閱讀性。
16、Java中的注釋格式：單行注釋：格式：//注釋文字；多行注釋：格式：/*注釋文字*/；文檔注釋：格式：/**注釋文字*/。
五、基礎知識：常量
17、常量表示不能改變的數(shù)值。
18、Java中常量的分類：整數(shù)常量：所有整數(shù)；小數(shù)常量：所有小數(shù)；布爾型常量：較為特有，只有兩個數(shù)值：true和false；字符常量：將一個數(shù)字字母或者符號用單引號（’’）標識；字符串常量：將一個或者多個字符用雙引號（””）標識；null常量：只有一個數(shù)值就是null。
19、對于整數(shù)：Java有三種表現(xiàn)形式：十進制：0-9，滿10進1；八進制：0-7，滿8進1，用0表示開頭；十六進制：0-9，A-F，滿16進1，用0x開頭表示。
六、基礎知識：進制轉換
20、進制的轉換特點：八位二進制表示一個字節(jié)（基本的數(shù)據(jù)單元）。三個二進制位表一個八進制位。四個二進制位表示一個十六進制位。ASCII碼編碼表。
21、二進制和十進制之間的轉換：十進制轉二進制：原理：對十進制數(shù)進行除2運算（除二取余法）；二進制轉十進制：原理：二進制乘以2的N次的過程。
22、快捷方法：8421法則。
23、負數(shù)的二進制表現(xiàn)形式：對應的正數(shù)二進制取反加1。負數(shù)的最高位都是1。
七、基礎知識：變量
24、變量的概念：內(nèi)存中的一個存儲區(qū)域；該區(qū)域有自己的名稱（變量名）和類型（數(shù)據(jù)類型）；該區(qū)域的數(shù)據(jù)可以在同一類型范圍內(nèi)不斷變化；理解：變量就如同數(shù)學中的未知數(shù)；變量：就是將不確定的數(shù)據(jù)進行存儲，也就是需要在內(nèi)存中開辟一個空間。
25、為什么要定義變量：用來不斷的存放同一類型的常量，并可以重復使用。
26、使用變量注意：變量的作用范圍（一對{}之間有效）；初始化值。
27、定義變量的格式：數(shù)據(jù)類型變量名=初始化值；注：格式是固定的、記住格式，以不變應萬變。
28、Java語言是強類型語言，對于每一種數(shù)據(jù)都定義了明確的具體數(shù)據(jù)類型，在內(nèi)存總分配了不同打小的內(nèi)存空間。數(shù)據(jù)類型：基本數(shù)據(jù)類型（數(shù)值型（整數(shù)類型（byte，short，int，long）；浮點類型（float，double））；字符型（char）；布爾型（boolean））；引用數(shù)據(jù)類型（類（class）；接口（interface）；數(shù)據(jù)（[]））。注意：整數(shù)默認：int，小數(shù)默認：double。
29、數(shù)據(jù)類型空間：byte 8位二進制（一個8位二進制或1個字節(jié)）；short 16位二進制（二個8位二進制或2個字節(jié)）；int 32位二進制（四個8位二進制或4個字節(jié)）；long 64位二進制（八個8位二進制或8個字節(jié)）；float（單精度）32位二進制（四個8位二進制或4個字節(jié)）；double（雙精度）64位二進制（八個8位二進制或8個字節(jié)）；char 取值：0-65535；boolean取值：true，false。
30、類型轉換。不同類型的數(shù)據(jù)不能進行運算。需要進行數(shù)據(jù)類型提升，從小往大提升，自動數(shù)據(jù)類型提升。強制類型轉換：格式：變量=（類型名）（需轉換的數(shù)據(jù)）；什么時候使用強制轉換：如：小數(shù)保留整數(shù)部分。
31、表達式的數(shù)據(jù)類型自動提升：所有的byte型、short型和char的值將被提升到int型；如果一個操作數(shù)是long型，計算結果就是long型；如果一個操作數(shù)是float型，計算結果就是float型；如果一個操作數(shù)是double型，計算結果就是double型。分析：system.out.println（‘a(chǎn)’）與system.out.println（‘a(chǎn)’+1）的區(qū)別。
八、基礎知識：運算符
32、算數(shù)運算符：+正號，-負號，+加，-減，*乘，/除，%取模，++自增（前），++自增（后），--自減（前），--自減（后），+字符串相加（字符串數(shù)據(jù)和任何數(shù)據(jù)使用+都是相連接，最終都會變成字符串）。
33、轉義字符：通過 來轉變后面字母或者符號的含義。在Linux系統(tǒng)中換行是一個字符來表示n，windows系統(tǒng)中，換行由nr實現(xiàn)。n:換行。b:退格。相當于backspace鍵。r:按下回車鍵。t:制表符。相當于tab鍵。
34、賦值運算符：符號：=：賦值，+=：a+=5等價于a=a+5，-=，*=，/=，%=。
35、比較運算符：==：相等于；！=：不等于；<：小于；>：大于；<=：小于等于；>=：大于等于；instanceof：檢查是否是類的對象。注意：比較運算符的結果都是boolean型，也就是要么是true，要么是false；比較運算符“==”不能誤寫成“=”。
36、邏輯運算符：&：AND（與）兩邊的boolean表達式結果，有一個為false，那么結果就是false，只要兩邊都為true，結果為true；|：OR（或）兩邊的boolean表達式結果，只要有一個為true，結果為true，只有兩邊都有false，結果為false；^：XOR（異或）兩邊的boolean表達式結果相同結果為false，兩邊不同結果為true；！：NOT（非）；&&：AND（短路）；||OR：（短路）。邏輯運算符用于連接boolean類型的表達式。&和&&的特點：&：無論左邊是真是假，右邊都運算；&&：當左邊為假時，右邊不運算。|和||的特點：|：兩邊都做運算；||：但左邊為真時，右邊不運算。
37、位運算符：<<：左移，如：3<<2=12等價于3*2^2=12；>>：右移，如：6>>2=1等價于6/2^2=1；>>>：無符號右移，如：3>>>1=1；&：與運算，如：6&3=2；|：或運算，如：6|3=7；^：異或運算，如：6^3=5；~：反碼，如：~6=-7；位運算是直接對二進制進行運算。<<：其實就是乘以2的移動的位數(shù)次冪；>>：就是除以2的移動的位數(shù)次冪。>>：最高位補什么由原有數(shù)據(jù)的最高位值而定；如果最高位0，右移后，用0補空位；如果最高位1，右移后，用1補空位。>>>：無論最高位是什么，右移后，都用0補。一個數(shù)異或同一個數(shù)兩次，結果還是拿個數(shù)。
38、三元運算符：格式：（條件表達式）？表達式1：表達式2；如果條件為true，運算后的結果是表達式1；如果條件為false，運算后的結果是表達式2。如：獲取兩個數(shù)中大數(shù)，int x=3,y=4,z;z=(x>y)?x:y//z變量存儲的就是兩個數(shù)的大數(shù)。
九、基礎知識：if語句
39、程序流程控制：順序結構，判斷結構，選擇結構，循環(huán)結構。
40、判斷結構：if語句三種格式：一層判斷：if(條件表達式){執(zhí)行語句;}；兩層判斷：if(條件表達式){執(zhí)行語句;}else{執(zhí)行語句;}；多層判斷：if(條件表達式){執(zhí)行語句;}else if(條件表達式){執(zhí)行語句;}else{執(zhí)行語句;}。
41、if else結構間歇格式：變量=（條件表達式）？表達式1：表達式2；三元運算符：好處：可以簡化if else代碼；弊端：因為是一個運算符，所以運算完畢需要有一個結果。
42、解決DOS命令下，編譯無法識別GDK碼方法：方法一：使用-encoding參數(shù)指明編碼方式：javac-encoding UTF-8 XX.java。方法二：保存java文件時，選擇編碼格式為ANSI。
十、基礎知識：switch語句
43、選擇結構：switch語句：格式：switch(表達式){case 取值1：執(zhí)行語句；break；case 取值2：執(zhí)行語句；break；??default：執(zhí)行語句；//break；}
44、switch（表達式）：表達式只接收四種類型：byte，short，int，char。
45、if語句與switch語句的區(qū)別：if除了能判斷數(shù)值，還能判斷具體區(qū)間，switch判斷區(qū)間很累；對于數(shù)字是布爾型時，只有if能判斷。
46、if語句與switch語句的用法：如果要對具體數(shù)字進行判斷，數(shù)值不多，而且符合byte、short、int、char這四種類型，雖然兩個語句都可以使用，建議用switch完成。因為效率稍高。其他情況一般用if。當結果為布爾型或區(qū)間時，用if完成。If的使用范圍更廣。2016年01月08日day03
一、基礎知識：while語句
1、循環(huán)結構：代表語句：while、do while、for。
2、while語句格式：while（條件表達式）{執(zhí)行語句；}。
3、do while語句格式：do{執(zhí)行語句；}while（條件表達式）。Do while特點是條件無論是否滿足，循環(huán)體至少被執(zhí)行一次。
4、while和do while的區(qū)別：while：先判斷條件，只有條件滿足才執(zhí)行循環(huán)體。do while：先執(zhí)行循環(huán)體，再判斷條件，條件滿足，再繼續(xù)執(zhí)行循環(huán)體。簡單一句話：do while：無論條件是否滿足，循環(huán)體至少執(zhí)行一次。
二、基礎知識：for語句
5、for語句格式：for（初始化表達式；循環(huán)條件表達式；循環(huán)后的操作表達式）{執(zhí)行語句；}。注意：a：for里面的連個表達式運行的順序，初始化表達式只讀一次，判斷循環(huán)條件，為真就執(zhí)行循環(huán)體，然后再執(zhí)行循環(huán)后的操作表達式，接著繼續(xù)判斷循環(huán)條件，重復找個過程，直到條件不滿足為止。b：while與for可以互換，區(qū)別在于for為了循環(huán)而定義的變量在for循環(huán)結束就是在內(nèi)存中釋放。而while循環(huán)使用的變量在循環(huán)結束后還可以繼續(xù)使用。c：最簡單無限循環(huán)格式：while（true），for（；；），無限循環(huán)存在的原因是并不知道循環(huán)多少次，而是根據(jù)某些條件，來控制循環(huán)。
6、for和while的區(qū)別：a：變量有自己的作用域。對于一個變量來將，如果這個變量僅僅用于控制循環(huán)的次數(shù)，用作循環(huán)增量時用for語句。循環(huán)結束時，該變量在內(nèi)存被釋放。用于優(yōu)化內(nèi)存。b：for和while可以進行互換，如果定義循環(huán)增量，用for更為合適。
7、什么時候使用循環(huán)結構？當要多某些語句執(zhí)行很多次時，就是用循環(huán)結構。
8、循環(huán)注意：一定要明確哪些語句需要參與循環(huán)，哪些不需要。
9、兩種思想：累加思想：原理：通過變量記錄住每次變化的結果。通過循環(huán)的形式，進行累加動作。計數(shù)器思想：原理：通過一個變量記錄住數(shù)據(jù)的狀態(tài)變化。也通過循環(huán)完成。
10、循環(huán)嵌套：語句嵌套形式，其實就是語句中含有語句。
11、其他流程控制語句：break（跳出），continue（繼續(xù)）。Break語句：應用范圍：選擇結構和循環(huán)結構。Continue語句：應用于循環(huán)結構。注意：a：這兩個語句離開應用范圍，存在是沒有意義的。b：這兩個語句單獨存在下面都不可以有語句，因為執(zhí)行不到。c：continue語句是結束本次循環(huán)繼續(xù)下次循環(huán)。d：標號的出現(xiàn)，可以讓這兩個語句作用于指定的范圍。
12、注意：標號只能用于循環(huán)語句上，給循環(huán)起名字。
13、continue：只能作用于循環(huán)結構。繼續(xù)循環(huán)。特點：結束本次循環(huán)，繼續(xù)下一次循環(huán)。
14、總結：a：break和continue語句作用的范圍。b：break和continue單獨存在時，下面可以有任何語句。因為都執(zhí)行不到。
三、基礎知識：函數(shù)
15、函數(shù)的定義：什么是函數(shù)？函數(shù)就是定義在類中的具有特定功能的一段獨立小程序；函數(shù)也稱為方法。
16、函數(shù)的格式：修飾符返回值類型函數(shù)名（參數(shù)類型形式參數(shù)1，參數(shù)類型形式參數(shù)2，?）{執(zhí)行語句；return返回值；}。返回值類型：函數(shù)運行后的結果的數(shù)據(jù)類型。參數(shù)形式：是形式參數(shù)的數(shù)據(jù)類型。形式參數(shù)：是一個變量，用于存儲調(diào)用函數(shù)時傳遞給函數(shù)的實際參數(shù)。實際參數(shù)：傳遞給形式參數(shù)的具體數(shù)值。Return：用于結束函數(shù)。返回值：該值會返回給調(diào)用者。
17、函數(shù)的特點：定義函數(shù)可以將功能代碼進行封裝；便于對該功能進行復用；函數(shù)只有被調(diào)用才會被執(zhí)行；函數(shù)的出現(xiàn)提高了代碼的復用性；對于函數(shù)沒有具體返回值的情況，返回值類型用關鍵字void表示，那么該函數(shù)中的return語句如果在最后一行可以省略不寫。注意：函數(shù)中只能調(diào)用函數(shù)，不可以在函數(shù)內(nèi)部定義函數(shù)；定義函數(shù)時，函數(shù)的結果應該返回給調(diào)用者，交由調(diào)用者處理。
18、重點：函數(shù)的應用。如何定義一個函數(shù)呢？a：既然函數(shù)是一個獨立的功能，那么該功能的運算結果是什么先明確。因為這是在明確函數(shù)的返回值類型。b：再明確在定義該功能的過程中是否需要未知的內(nèi)容參與運算。因為是在明確函數(shù)的參數(shù)列表（參數(shù)的類型和參數(shù)的個數(shù)）。
19、函數(shù)的重載（overload）：重載的概念：在同一個類中，允許存在一個以上的同名函數(shù)，只要它們的參數(shù)個數(shù)或者參數(shù)類型不同即可。重載的特點：與返回值無關，只看參數(shù)列表。重載的好處：方便與閱讀，優(yōu)化了程序設計。重載示例：//返回兩個整數(shù)的和int add(int x,int y){return x+y;}；//返回三個整數(shù)的和int add(int x,int y,int z){return x+y+z;}；//返回兩個小數(shù)的和double add(double x,double y){return x+y;}。
20、什么時候用重載？當定義的功能相同，但參與運算的未知內(nèi)容不同。那么，這時就定義一個函數(shù)名稱以表示其功能，方便閱讀，而通過參數(shù)列表的不同來區(qū)分多個同名函數(shù)。
四、基礎知識：數(shù)組
21、數(shù)組的定義：概念：同一種數(shù)據(jù)類型的集合。其實數(shù)組就是一個容器。數(shù)組的好處：可以自動給數(shù)組中的元素從0開始編號，方便操作這些元素。關鍵字：new：用來在內(nèi)存中產(chǎn)生一個容器實體。格式一：元素類型[]數(shù)組名=new元素類型[元素個數(shù)或數(shù)組長度]；示例：int [] arr=new int[5]；格式二：元素類型[]數(shù)組名=new元素類型[]{元素，元素，?}；示例：int[] arr=new int[]{3,5,1,7}；int[] arr={3,5,1,7}。
22、內(nèi)存結構：Java程序在運行時，需要在內(nèi)存中分配空間。為了提高運行效率，又對空間進行了不同區(qū)域的劃分，因為每一片區(qū)域都有特定的處理數(shù)據(jù)方式和內(nèi)存的管理方式。A：棧內(nèi)存（棧區(qū)）：用于存儲局部變量，當數(shù)據(jù)使用完，所占空間會自動釋放。B：堆內(nèi)存（堆區(qū)）：數(shù)組和對象，通過new建立的實例都存放在堆內(nèi)存中。每一個實體都有內(nèi)存地址。實體中的變量都有默認初始化值。實體不在被使用，會在不確定的時間內(nèi)被垃圾回收器回收。C：方法區(qū)，本地方法區(qū)，寄存器。2016年01月09日
day04
一、基礎知識：數(shù)組
1、獲取數(shù)組中的元素。通常會用到遍歷。
2、數(shù)組中有一個屬性可以直接獲得到數(shù)組元素個數(shù)。length。使用方式：數(shù)組名稱.length。
3、數(shù)組排序：選擇排序：內(nèi)循環(huán)結束一次，最值出現(xiàn)頭角標位置。冒泡排序：第一圈：最值出現(xiàn)在了最后位。
4、java中排序工具：import.java.util.*；Array.sort(arr)。java中已經(jīng)定義好的一種排序方式。開發(fā)中，對數(shù)組排序，要使用該句代碼。
5、二維數(shù)組：數(shù)組中的數(shù)組：格式一：int[][] arr=new int[3][2]；定義了名稱為arr的二維數(shù)組；二維數(shù)組中有3個一維數(shù)組；每一個一維數(shù)組中有2個元素；一維數(shù)組的名稱分別為arr[0]，arr[1]，arr[2]；給第一個一維數(shù)組1腳標位賦值為78寫法是：arr[0][1]=78。格式二：int[][] arr=new int[3][]；二維數(shù)組中有3個一維數(shù)組；每個一維數(shù)組都是默認初始值null；可以對這個三個一維數(shù)組分別進行初始化：arr[0]=new int[3]；arr[1]=new int[1]；arr[2]=new int[2]。
2016年01月10日
day05
一、面向對象：概述
1、理解面向對象：面向對象是相對面向過程而言；面向對象和面向過程都是一種思想；面向過程：強調(diào)的是功能行為；面向對象：將功能封裝進對象，強調(diào)了具備了功能的對象；面向對象是基于面向過程的。讓我們的角色從執(zhí)行者變?yōu)橹笓]者。面向過程是面向對象的基礎。
2、一切皆對象，境界：萬物皆對象。
3、寫程序時：先考慮對象。有對象時，直接用。沒對象時，自己造一個對象。
4、人開門：名稱提煉法。事物：人、門。示例：人{開門（門）{門。開（）；}}；門{開（）{操作門軸等。}}。
5、面向對象的三個特征：封裝，繼承，多態(tài)。
6、以后的開發(fā)：其實就是找對象使用。沒有對象，就創(chuàng)建一個對象。
7、找對象，建立對象，使用對象，維護對象的關系。
8、類和對象的關系：類就是：對現(xiàn)實生活中事物的描述。對象：就是這類事物，實實在在的個體。映射到java中，描述就是class定義的類。具體對象就是對于java在堆內(nèi)存中用new建立實體。
9、類與對象示例：圖紙：汽車，汽車，汽車。可以理解為：類就是圖紙；汽車就是堆內(nèi)存中的對象。
10、描述事物其實就在是描述事物的屬性和行為。
11、屬性對應是類中的變量，行為對應的類中的函數(shù)（方法）。其實定義類，就是在描述事物，就是在定義屬性和行為。屬性和行為共同成為類中的成員（成員變量和成員函數(shù)（方法））。
12、引用變量：類類型變量。記住：類類型變量指向對象。
13、就需要該對象做使用，在java指揮方式是：對象.對象成員。
14、成員變量和局部變量：作用范圍：成員變量作用于整個類中。局部變量作用于函數(shù)中，或者語句中。在內(nèi)存中的位置：成員變量：在堆內(nèi)存中，因為對象的存在，才在內(nèi)存中存在。局部變量：存在棧內(nèi)存中。
15、匿名對象：匿名對象是對象的簡化形式；匿名對象兩種使用情況：當對對象方法僅進行一次調(diào)用的時；匿名對象可以作為實際參數(shù)進行傳遞。
二、面向對象：封裝
16、封裝的定義：是指隱藏對象的屬性和實現(xiàn)細節(jié)，僅對外提供公共訪問方式。
17、封裝的好處：將變化隔離；便于使用；提高重用性；提高安全性。
18、封裝原則：將不需要對外提供的內(nèi)容隱藏起來；把屬性都隱藏，提供公共方法對其訪問。
19、函數(shù)是最小的封裝體；類是較小的封裝體；包是中級封裝體；框架是較大的封裝體。20、關鍵字private：私有，權限修飾符：用于修飾類中的成員（成員變量，成員函數(shù)）。在類中隱藏。私有只在本類中有效。
21、注意：私有僅僅是封裝的一種表現(xiàn)形式。
22、之所以對外提供訪問方式，就是因為可以在訪問方式中加入邏輯判斷語句。對訪問的數(shù)據(jù)進行操作。提高代碼健壯性。
23、關鍵字private：將成員變量私有化。對外提供對應的set，get方法對其進行訪問。提高對數(shù)據(jù)訪問的安全性。
三、面向對象：構造函數(shù)
24、構造函數(shù)的特點：函數(shù)名與類名相同；不用定義返回值類型；不可以寫return語句。
25、構造函數(shù)的作用：給對象進行初始化。注意：默認構造函數(shù)的特點；多個構造函數(shù)是以重載的形式存在的。
26、構造函數(shù)：對象一建立就會調(diào)用與之對應的構造函數(shù)。構造函數(shù)的作用：可以用于給對象進行初始化。
27、構造函數(shù)的小細節(jié)：當一個類中沒有定義構造函數(shù)時，那么系統(tǒng)會默認給該類假如一個空參數(shù)的構造函數(shù)。當在類中自定義了構造函數(shù)后，默認的構造函數(shù)就沒有了。
28、構造函數(shù)和一般方法（函數(shù)）的區(qū)別：A：構造函數(shù)和一般函數(shù)在寫法上有不同。B：在運行上也有不同。構造函數(shù)是在對象一建立就運行。就對象初始化。而一般方法是對象調(diào)用才執(zhí)行，是給對象添加對象具備的功能。C：一個對象建立，構造函數(shù)只運行一次。而一般方法可以被該對象調(diào)用多次。
29、什么時候定義構造函數(shù)呢：當分析事物時，該事物存在具備一些特征或者行為，那么將這些內(nèi)容定義在構造函數(shù)中。30、構造代碼塊：作用：給對象進行初始化。對象一建立就運行，而且優(yōu)先于構造函數(shù)執(zhí)行。
31、構造代碼塊和構造函數(shù)區(qū)別：構造代碼塊是給所有對象進行統(tǒng)一初始化，而構造函數(shù)是給對應的對象進行初始化。
32、構造代碼塊中定義的是不同對象共性的初始化內(nèi)容。
四、面向對象：this關鍵字
33、關鍵字this：看上去，是用于區(qū)分局部變量和成員變量同名情況。
34、關鍵字this的特點：就代表本類的對象，到底代表哪一個呢？this代表它所在函數(shù)所屬對象的引用。簡單說：哪個對象在調(diào)用this所在的函數(shù)，this就代表哪個對象。
35、this的應用：當定義類中功能時，該函數(shù)內(nèi)部要用到該函數(shù)的對象時，這時用this來表示這個對象。但凡本類功能內(nèi)部使用到了本類對象，都用this代替。
36、this語句：用于構造函數(shù)之間函數(shù)互相調(diào)用。this語句：只能定義在構造函數(shù)的第一行。因為初始化要先執(zhí)行。
37、this語句只能用于構造函數(shù)間，不能用于一般函數(shù)。
2016年01月11日
day06
一、面向對象：static關鍵字
1、static（靜態(tài)）關鍵字：用于修飾成員（成員變量和成員函數(shù)）。被修飾后的成員具備以下特點：隨著類的加載而加載；優(yōu)先于對象存在；被所有對象所共享；可以直接被類名調(diào)用。使用注意：靜態(tài)方法只能訪問靜態(tài)成員；靜態(tài)方法中不可以寫this，super關鍵字；主函數(shù)是靜態(tài)的。
2、用法：是一個修飾符，用于修飾成員（成員變量，成員函數(shù)）。當成員被靜態(tài)修飾后，就多了一個調(diào)用方式，除了可以被對象調(diào)用外，還可以直接被類名用。類名.成員變量。
3、實例變量和類變量的區(qū)別：A，存放位置：類變量隨著類的加載而存在于方法區(qū)中。實例變量隨著對象的建立存在于堆內(nèi)存中。B，生命周期：類變量生命周期最長，隨著類的消失而消失。實例變量隨著對象的消失而消失。
4、靜態(tài)使用注意事項：A，靜態(tài)方法只能訪問靜態(tài)成員。非靜態(tài)方法既可以訪問靜態(tài)也可以訪問非靜態(tài)。B，靜態(tài)方法中不可以定義thsi，super關鍵字。因為靜態(tài)優(yōu)先于對象存在，所有靜態(tài)方法中不可以出現(xiàn)this。C，主函數(shù)是靜態(tài)的。
5、靜態(tài)優(yōu)缺點：優(yōu)：對對象的共享數(shù)據(jù)進行單獨空間的存儲，節(jié)省空間。沒有必要每個對象中都存儲一份。可以直接被類名調(diào)用。缺：生命周期過長。訪問出現(xiàn)局限性。（靜態(tài)雖好，只能訪問靜態(tài)。）
6、public static void main(String[] args)主函數(shù)：是一個特殊的函數(shù)，作用程序的入口，可以被jvm調(diào)用。
7、主函數(shù)的定義：public：代表著該函數(shù)訪問權限是最大的。static：代表主函數(shù)隨著類的加載就已經(jīng)存在了。void：代表主函數(shù)沒有具體的返回值。main：不是關鍵字，但是是一個特殊的單詞，可以被jvm識別。（String[] args）：函數(shù)的參數(shù)，參數(shù)類型是一個數(shù)組，該數(shù)組中的元素是字符串。字符串類型的數(shù)組。
8、主函數(shù)是固定格式的：jvm識別。jvm在調(diào)用主函數(shù)時，傳人的是new String[0]。
9、什么時候使用靜態(tài)？要從兩方面下手：因為靜態(tài)修飾的內(nèi)容有成員變量和函數(shù)。什么時候定義靜態(tài)變量（類變量）呢？當對象中出現(xiàn)共享數(shù)據(jù)時，該數(shù)據(jù)靜態(tài)所修飾。對象中的特有數(shù)據(jù)要定義成非靜態(tài)存在于堆內(nèi)存中。
10、什么時候定義靜態(tài)函數(shù)呢？當功能內(nèi)部沒有訪問到非靜態(tài)數(shù)據(jù)（對象的特有數(shù)據(jù)），那么該功能可以定義成靜態(tài)的。
11、靜態(tài)的應用：A每一個應用程序中都有共性的功能，可以將這些功能進行抽取，獨立封裝。以便復用。B雖然可以通過建立ArrayTool的對象使用這些工具方法，對數(shù)組進行操作。但是：1，對象是用于封裝數(shù)據(jù)的，可以ArrayTool對象并未封裝特特有數(shù)據(jù)。2，操作數(shù)組的每一個方法都沒有用到ArrayTool對象中的特有數(shù)據(jù)。C這時就考慮，讓程序更嚴謹，是不需要對象的。可以將ArrayTool中的方法都定義成static的，直接通過類名調(diào)用即可。D將方法都靜態(tài)后，可以方便于使用，但是該類還是可以被其他程序建立對象的。為了更為嚴謹，強制讓該類不能建立對象。可以通過將構成函數(shù)私有化完成。
12、接下來，將ArrayTool.class文件發(fā)送給其他人，其他人只要將該文件設置到classpath路徑下，就可以使用該工具類。但是，很遺憾，該類中到底定義了多少個方法，對方不清楚。因為該類并沒有使用說明書。開始制作程序的說明書。java的說明書通過文檔注釋來完成。
13、注釋符號：/***/；@author作者；@version版本；@param參數(shù)；@return返回值。
14、靜態(tài)代碼塊。格式：static{靜態(tài)代碼塊中的執(zhí)行語句。}。
15、靜態(tài)代碼塊的特點：隨著類的加載而執(zhí)行，只執(zhí)行一次,并優(yōu)先于主函數(shù)。用于給類進行初始化的。
16、重點：對象的初始化過程：Person p=new Person(“zhangsan”,20);該句話都做了什么事情？A因為new用到了Person。Class。所有會先找到Person。Class文件并加載到內(nèi)存中。B執(zhí)行該類中的static代碼塊，如果有的話，給Person.class類進行初始化。C在堆內(nèi)存中開辟空間，分配內(nèi)存地址。D在堆內(nèi)存中建立對象的特有屬性，并進行默認初始化。E對屬性進行顯示初始化。F對對象進行構造代碼塊初始化。G對對象進行對應的構造函數(shù)初始化。H將內(nèi)存地址付給棧內(nèi)存中的p變量。
二、面向對象：單例設計模式
17、設計模式：解決某一類問題最行之有效的方法。java中23中設計模式：單例設計模式：解決一個類在內(nèi)存只存在一個對象。
18、想要保證對象唯一。1，為了避免其他程序過多建立該類對象。先禁止其他程序建立該類對象。2，還為了讓其他程序可以訪問到該類對象，只好在本類中，自定義一個對象。3，為了方便其他程序對自定義對象的訪問，可以對外提供一些訪問方式。
19、這三步怎么用代碼體現(xiàn)呢？1，將構造函數(shù)私有化。2，在類中創(chuàng)建一個本類對象。3，提供一個方法可以獲取到該對象。
20、對于事物該怎么描述，還怎么描述。當需要將該事物的對象保證在內(nèi)存中唯一時，就將以上的三部加上即可。
21、單例設計方法一：這個是先初始化對象。稱為：餓漢式。Single類一進內(nèi)存，就已經(jīng)創(chuàng)建好了對象。開發(fā)一般用餓漢式：安全、簡單。
22、單例設計方法二：對象被調(diào)用時，才初始化，也叫做對象的延時加載。稱為：懶漢式。Single類進內(nèi)存，對象還沒有存在，只有調(diào)用了getInstance方法時，才建立對象。
23、記住原則：定義單例，建議使用餓漢式。但面試時：考懶漢式的多。特別是如何解決懶漢式的缺點。2016年01月12日
day07
一、面向對象：繼承
1、繼承：1，提高代碼的復用性。2，讓類與類之間產(chǎn)生了關系。有了這個關系，才有了多態(tài)的特性。關鍵字：extends。
2、注意：千萬不要為了獲取其他類的功能，簡化代碼而繼承。必須是類與類之間有所屬關系才可以繼續(xù)。所屬關系is a。
3、java語言中：java只支持單繼承，不支持多繼承。原因：因為多繼承容易帶來安全隱患：當多個父類中定義了相同功能，當功能內(nèi)容不同時，子類對象不確定要運行哪一個。但是java保留這種機制，并用另一種體現(xiàn)形式來完成表示，多實現(xiàn)。
4、java支持多層繼承。也就是一個繼承體系。如何使用一個繼承體系中的功能呢？想要使用體系，先查閱父類的描述，因為父類中定義的是該體系中共性功能。通過了解共性功能，就可以知道該體系的基本功能。那么這個體系已經(jīng)可以基本使用了。
5、那么在具體調(diào)用時，要創(chuàng)建最子類的對象，為什么呢？一是因為有可能父類不能創(chuàng)建對象，二是創(chuàng)建子類對象可以使用更多的功能，包括基本的也包括特有的。
6、簡單一句話：查閱父類功能，創(chuàng)建子類對象使用功能。
7、this代表本類對象的引用，super代編父類對象的引用。
8、子父類出現(xiàn)后，類成員的特點：類中成員：A，變量。B，函數(shù)。C，構造函數(shù)。
9、子父類中的變量：如果子類中出現(xiàn)非私有的同名變量時，之類要訪問本類中的同名變量，用this子類要訪問父類中的同名變量，用super。super的使用和this的使用幾乎一致。this代表的是本類對象的引用。super代表的是父類對象的引用。
10、子父類中的函數(shù)：當子類出現(xiàn)和父類一模一樣的函數(shù)時，當子類對象調(diào)用該函數(shù)，會運行子類函數(shù)的內(nèi)容。如同父類的函數(shù)被覆蓋一樣。這種情況是函數(shù)的另一個特性：重寫（覆蓋）。
11、修改以往的源碼絕對是災難。
12、單子類繼承父類，沿襲了父類的功能，到子類中，但是子類雖具備該功能，但是功能的內(nèi)容卻和父類不一致，這時，沒有必要定義新功能，而是使用覆蓋特殊，保留父類的功能定義，并重寫功能內(nèi)容。
13、注意：覆蓋：子類覆蓋父類，必須保證子類權限大于等于父類權限，才可以覆蓋，否則編譯失敗。靜態(tài)只能覆蓋靜態(tài)。
14、記住大家：重載：只看同名函數(shù)的參數(shù)列表。重寫：子父類方法要一模一樣。
15、子父類中的構造函數(shù)：發(fā)現(xiàn)在對子類對象進行初始化時，父類的構造函數(shù)也會運行。那是因為子類的構造函數(shù)默認第一行有一條隱式的語句super（）；super（）；會訪問父類中空參數(shù)的構造函數(shù)。而且子類中所有的構造函數(shù)默認第一行都是super（）。
16、為什么子類一定要訪問父類中的構造函數(shù)：因為父類中的數(shù)據(jù)子類可以直接獲取，所有之類對象在建立時，需要先查看父類是如何對這些數(shù)據(jù)進行初始化的。所有之類在對象初始化時，要先訪問一下父類中的構造函數(shù)。如果要訪問父類中指定的構造函數(shù)，可以通過手動定義super語句的方式來指定。注意：super語句一定一定在子類構造函數(shù)第一行。
17、子類的實例化過程。結論：子類的所有的構造函數(shù)默認都會訪問父類中空參數(shù)的構造函數(shù)。因為子類每一個構造函數(shù)內(nèi)的每一行都有一句隱式的super（）；當父類中沒有空參數(shù)的構造函數(shù)時，子類必須手動通過super語句或者this語句形式來指定要訪問父類中的構造函數(shù)。當然：子類的構造函數(shù)第一行也可以收到指定this語句來訪問本類中的構造函數(shù)。子類中至少會有一個構造函數(shù)會訪問父類中的構造函數(shù)。
18、關鍵字：final：final可以修飾類，方法（函數(shù)），變量；final修飾的類不可以被繼承；final修飾的方法（函數(shù)）不可以被覆蓋；final修飾的變量是一個常量，只能被賦值一次；內(nèi)部類只能訪問被final修飾的局部變量。
二、面向對象：抽象類
19、當多個類中出現(xiàn)相同功能，但是功能主體不同，這時也可以進行向上抽取。這時，只抽取功能定義，而不抽取功能主體。20、抽象：看不懂。
21、抽象類的特點：A，抽象方法一定定義在抽象類中。B，抽象方法和抽象類都必須被abstract關鍵字修飾。C，抽象類不可以被new創(chuàng)建對象。因為調(diào)用抽象方法沒意義。D，抽象類中的抽象方法要被使用，必須由子類復寫其所有的抽象方法后，建立子類對象調(diào)用。
22、如果子類只覆蓋了部分抽象方法，那么該子類還是一個抽象類。
23、抽象類和一般類沒有太大的不同。該如何描述事物，就如何描述事物，只不過，該事物中出現(xiàn)了一些看不懂的東西。這些不確定的部分，也是該事物的功能，需要明確出現(xiàn)，但是無法定義主體。通過抽象方法來表示。
24、抽象類比一般類多了抽象方法（函數(shù)）。就是在類中可以定義抽象方法。抽象類不可以實例化（即不可以new）。特殊：抽象類中可以不定義抽象方法，這樣做僅僅是不讓該類建立對象。
25、什么是模板方法呢？在定義功能時，功能的一部分是確定的，但是有一部分是不確定，而確定的部分在使用不確定的部分。那么這時就將不確定的部分暴露出去。由該類的子類去實現(xiàn)。
三、面向對象：接口
26、接口：格式：interface{}。接口中的成員修飾符是固定的。成員常量：public static final；成員函數(shù)：public abstract。接口的出現(xiàn)將“多繼承”通過另一種形式體現(xiàn)出來，即“多實現(xiàn)”。
26、接口：初期理解：可以認為是一個特殊的抽象類。當抽象類中的方法都是抽象的，那么該類可以通過接口的形式來表示。class用于定義類。interface用于定義接口。
27、接口：是不可以創(chuàng)建對象的，因為有抽象方法。需要被子類實現(xiàn)，子類對接口中的抽象方法全部覆蓋后，子類才可以實例化。否則子類是一個抽象類。接口可以被類多實現(xiàn)，也是對多繼承不支持的轉換形式。java支持多實現(xiàn)。用關鍵字：implements。
28、接口與接口之間支持多繼承，類與類之間只支持單繼承。
29、接口的特點：接口是對外暴露的規(guī)則；接口是程序的功能擴展；接口可以用來多實現(xiàn)；類與接口之間是實現(xiàn)關系，而且類可以繼承一個類的同時實現(xiàn)多個接口；接口與接口之間可以有繼承關系。2016年01月13日
day08
一、面向對象：多態(tài)
1、多態(tài)的定義：某一類事物的多種存在形態(tài)，例：動物中貓，狗。貓這個對象對應的類型是貓類型：貓x=new 貓（）；同時貓也是動物中的一種，也可以把貓稱為動物。動物y=new 貓（）；動物是貓和狗具體事物中抽取出來的父類型；父類型引用指向了子類對象。
2、多態(tài)的體現(xiàn)：父類的引用指向了自己的子類對象。父類的引用也可以接收自己的子類對象。
3、多態(tài)的前提：必須是類與類之間有關系。要么繼承，要么實現(xiàn)。通常還有一個前提：存在覆蓋。
4、多態(tài)的弊端：提高了擴展性，但是只能使用父類的引用訪問父類中的成員。
5、多態(tài)的好處：多態(tài)的出現(xiàn)大大的提高了程序的擴展性。
6、引用數(shù)據(jù)類型轉換：類型提升。向上轉型。如果想要調(diào)用貓的特有方法時，如何操作？強制將父類的引用，轉成子類類型。向下轉型。注意：千萬不要出現(xiàn)這樣的操作，就是將父類對象轉成子類類型。我們能轉換的是父類引用指向了自己的子類對象時，該引用可以被提升，也可以被強制轉換。多態(tài)自始至終都是子類對象在做著變量。
7、關鍵字：instanceof。判斷引用數(shù)據(jù)類型是否一致。
8、在多態(tài)中成員函數(shù)的特點：在編譯時期：參閱引用型變量所屬的類中是否有調(diào)用的方法。如果有，編譯通過，如果沒有編譯失敗。在運行時期：參閱對象所屬的類中是否有調(diào)用的方法。簡單總結就是：成員函數(shù)在多態(tài)調(diào)用時，編譯看左邊，運行看右邊。
9、在多態(tài)中，成員變量的特點：無論編譯和運行，都參考左邊（引用型變量所屬的類）。
10、object類：是所有對象的直接或者間接父類，傳說中的上帝。該類中定義的肯定是所有對象都具備的功能。
11、Object類中已經(jīng)提供了對對象是否相同的比較方法。如果自定義類中也有比較相同的功能，沒有必要重新定義。只要沿襲父類中的功能，建立自己特有的比較內(nèi)容即可。這就是覆蓋。
2016年01月15日
day09
一、面向對象：內(nèi)部類
1、內(nèi)部類的定義：將一個類定義在另一個類的里面，對里面那個類就稱為內(nèi)部類（內(nèi)置類，嵌套類）。
2、內(nèi)部類訪問特點：內(nèi)部類可以直接訪問外部類中的成員，包括私有成員。之所以可以直接訪問外部類中的成員，是因為內(nèi)部類中持有了一個外部類的引用，格式：外部類名.this。而外部類要訪問內(nèi)部類中的成員必須要建立內(nèi)部類的對象。
3、訪問格式：當內(nèi)部類定義在外部類的成員位置上，而且非私有，可以在外部其他類中。可以直接建立內(nèi)部類對象。格式：外部類名.內(nèi)部類名變量名=外部類對象.內(nèi)部類對象；Outer.Inner in=new Outer().new Inner()。
4、當內(nèi)部類在成員位置上，就可以被成員修飾符所修飾。比如，private：將內(nèi)部類在外部類中進行封裝。static：內(nèi)部類就具備了static的特性。當內(nèi)部類被static修飾后，只能直接訪問外部類中的static成員。出現(xiàn)了訪問局限。
5、在外部其他類中，如何直接訪問static內(nèi)部類的非靜態(tài)成員呢？new Outer.Inner().function()。在外部其他類中，如何直接訪問static內(nèi)部類的靜態(tài)成員呢？Outer.Inner().function()。
6、注意：當內(nèi)部類中定義了靜態(tài)成員，該內(nèi)部類必須是static的。當外部類中的靜態(tài)方法訪問內(nèi)部類時，內(nèi)部類也必須是static的。
7、當描述事物時，事物的內(nèi)部還有事物，該事物用內(nèi)部類來描述。因為內(nèi)部事物在使用外部事物的內(nèi)容。
8、內(nèi)部類定義在局部時，1，不可以被成員修飾符修飾；2，可以直接訪問外部類中的成員，因為還持有外部類中的引用；但是不可以訪問它所在的局部中的變量。只能訪問被final修飾的局部變量。
9、匿名內(nèi)部類：1，匿名內(nèi)部類其實就是內(nèi)部類的簡寫格式。2，定義匿名內(nèi)部類的前提：內(nèi)部類必須繼承一個類或者實現(xiàn)接口。3，匿名內(nèi)部類的格式：new 父類或者接口（）{定義子類的內(nèi)容}。4，其實匿名內(nèi)部類就是一個匿名子類對象。而且這個對象有點胖。可以理解為帶內(nèi)容的對象。5，匿名內(nèi)部類中定義的方法最好不要超過3個。
二、面向對象：異常
10、異常：異常的體系：Throwable：（Error：通常出現(xiàn)重大問題如：運行的類不存在或者內(nèi)存溢出等；不編寫針對代碼對其處理。Exception：在運行時運行出現(xiàn)的一起情況，可以通過try catch finally）。Exception和Error的子類名稱都是以父類名作為后綴。
11、異常：就是程序在運行時出現(xiàn)不正常情況。
12、異常由來：問題也是現(xiàn)實生活中一個具體的事物，也可以通過java的類的形式進行描述，并進行封裝。其實就是java對不正常情況進行描述后的對象體現(xiàn)。
13、對于問題的劃分：兩種：一種是嚴重的問題。一種是非嚴重的問題。對于Error一般不編寫針對性的代碼對其進行處理。對于嚴重的，java通過Error類進行描述。對于非嚴重的，java通過Exception類進行描述。對于Exception可以使用針對性的處理方式進行處理。
14、無論Error或者Exception都具體有一些共性內(nèi)容。比如：不正常情況的信息，引發(fā)原因等。
15、異常的處理：java提供了特有的語句進行處理。Try{需要被檢測的代碼；}catch{異常類變量}{處理異常的代碼：（處理方式）}finally{一定會執(zhí)行的語句；}。
15、throws Exception//在功能上通過throws的關鍵字聲明了該功能有可能會出現(xiàn)問題。在函數(shù)上聲明異常。便于提高安全性，讓調(diào)用者進行處理。不處理編譯失敗。
16、對多異常的處理。1，聲明異常時，建議聲明更為具體的異常。這樣處理得可以更具體。2，對聲明幾個異常，就對應有幾個catch塊。不要定義多余的catch塊。如果多個catch塊中的異常出現(xiàn)繼承關系，父類異常catch塊放在最下面。
17、建議在進行catch處理時，catch中一定要定義具體處理方式。不要簡單定義一句 e.printStackTrace()，也不要簡單的就書寫一條輸出語句。
18、自定義異常：因為項目中會出現(xiàn)特有的問題，而這些問題并未被java所描述并封裝對象。所有對于這些特有的問題可以按照java的對問題封裝的思想。將特有的問題，進行自定義的異常封裝。
19、當在函數(shù)內(nèi)部出現(xiàn)了throw拋出了異常對象，那么就必須要給對應的處理動作。要么在內(nèi)部try catch處理。要么在函數(shù)上聲明讓調(diào)用者處理。20、如何定義異常信息呢？因為父類中已經(jīng)把異常信息的操作都完成了。所有子類只要在構造時，將異常信息傳遞給父類通過super語句。那么就可以直接通過getMessage方法獲取自定義的異常信息。
21、自定義異常：必須是自定義類繼承Exception。繼承Exception原因：異常體系有一個特點：因為異常類和異常對象都被拋出。他們都具備可拋性。這個可拋性是Throwable這個體系中獨有特點。
22、只有這個體系中的類和對象才可以被throws和throw操作。
23、throws和throw的區(qū)別：throws使用在函數(shù)上。throw使用在函數(shù)內(nèi)。throws后面跟的異常類。可以跟多個。用逗號隔開。throw后跟的是異常對象。
24、Exception中有一個特殊的子類異常RuntimeException運行時異常。如果在函數(shù)內(nèi)容拋出該異常，函數(shù)上可以不用聲明，編譯一樣通過。如果在函數(shù)上聲明了該異常。調(diào)用者可以不用進行處理，編譯一樣通過。
25、之所以不用在函數(shù)聲明，是因為不需要讓調(diào)用者處理。當該異常發(fā)生，希望程序停止。因為在運行時，出現(xiàn)了無法繼續(xù)運算的情況，希望停止程序。對代碼進行修正。
26、自定義異常時：如果該異常的發(fā)生，無法在繼續(xù)進行運算，就讓自定義異常繼承RuntimeException。
27、對于異常分兩種：1，編譯時被檢測的異常。2，編譯時不被檢測的異常（運行時異常，RuntimeException以及其子類）。
2016年01月16日
day10
一、面向對象：異常
1、finally中存放的是一定會被執(zhí)行的代碼。
2、finally代碼塊：定義一定執(zhí)行的代碼。通常用于關閉資料。
3、記住一點：catch是用于處理異常。如果沒有catch就代表沒有被處理過，如果該異常時檢測時的異常，就必須聲明出去。
4、異常在子父類覆蓋中的體現(xiàn)：A，子類在覆蓋父類時，如果父類的方法拋出異常，那么子類的覆蓋方法，只能拋出父類的異常或者該異常的子類。B，如果父類方法拋出多個異常，那么子類在覆蓋該方法時，只能拋出父類異常的子集。C，如果父類或者接口的方法中沒有異常拋出，那么子類在覆蓋方法時，也不可以拋出異常。如果子類方法發(fā)生了異常。就必須要進行try處理。絕對不能拋。
5、異常：是什么？是對問題的描述，將問題進行對象的封裝。
6、異常體系：Throwable：|--Error；|--Exception（|--RuntimeException）。
7、異常體系的特點：異常體系中的所有類以及建立的對象都具備可拋性。也就是說可以被throw和throws關鍵字所操作。只有異常體系具備這個特點。
8、throw和throws的用法：throw定義在函數(shù)內(nèi)，用于拋出異常對象。throws定義在函數(shù)上，用于拋出異常類，可以拋出多個用逗號隔開。
9、當函數(shù)內(nèi)容有throw拋出異常對象，并未進行try處理。必須要在函數(shù)上聲明，都在編譯失敗。注意：RuntimeException除外。也就是說，函數(shù)內(nèi)如果拋出的RuntimeException異常，函數(shù)上可以不用聲明。
10、如果函數(shù)聲明了異常，調(diào)用者需要進行處理。處理方法可以throws和try。
11、異常有兩種：編譯時被檢測異常：該異常在編譯時，如果沒有處理（沒有拋也沒有try），編譯失敗。該異常被標識，代表著可以被處理。運行時異常（編譯時不檢測）：在編譯時，不需要處理，編譯器不檢查。該異常的發(fā)生，建立不處理，讓程序停止。需要對代碼進行修正。
12、異常處理語句：try（需要被檢測的代碼；）catch（處理異常的代碼；）finally（一定會執(zhí)行的代碼；）。有三種結合格式：try catch；try finally；try catch finally。注意：A，finally中定義的通常是關閉資源代碼。因為資源必須釋放。B，finally只有一種情況不會執(zhí)行。當執(zhí)行到System.exit(0);finally不會執(zhí)行。
13、自定義異常：定義類繼續(xù)Exception或者RuntimeException。A，為了讓該自定義類具備可拋性。B，讓該類具備操作異常的共性方法。當要定義自定義異常的信息時，可以使用父類已經(jīng)定義好的功能。異常異常信息傳遞給父類的構成函數(shù)。class MyException extends Exception{MyException(String message){super(message);}}。
14、自定義異常：按照java的面向對象思想，將程序中出現(xiàn)的特有問題進行封裝。
15、異常的好處：A，將問題進行封裝。B，將正常流程代碼和問題處理代碼相分離，方便于閱讀。
16、異常的處理原則：A，處理方式有兩種：try或者throws。B，調(diào)用到拋出異常的功能時，拋出幾個，就處理幾個。一個try對應多個catch。C，多個catch，父類的catch放到最下面。D，catch內(nèi)需要定義針對性的處理方式。不要簡單的定義printStackTrace,輸出語句。也不要不寫。當捕獲到的異常，本功能處理不了時，可以繼續(xù)在catch中拋出。
17、異常的注意事項：在子父類覆蓋時：A，子類拋出的異常必須是父類異常的子類或者子集。B，如果父類或者接口沒有異常拋出時，子類覆蓋出現(xiàn)異常，只能try不能拋。
二、面向對象：包
18、包（package）：對類文件進行分類管理。給類提供多層命名空間。寫在程序文件的第一行。類名的全稱的格式是：包名.類名。包也是一種封裝形式。
19、關鍵字protected：/*保護*/權限。權限修飾符。可用于修飾包里的父類。
20、總結：包與包之間進行訪問，被訪問的包中的類以及類中的成員，需要public修飾。不同包中的子類還可以訪問直接父類中被protected權限修飾的成員。
21、包與包之間可以使用的權限只有兩種，public protected。
22、public
protected
default
private 同一個類中可以可以可以可以 同一個包中可以
可以可以 不可以 子類可以
可以不可以不可以 不同包中 可以不可以不可以不可以。
23、為了簡化類名的書寫，使用一個關鍵字import。import導入的是包中的類。建議，不要寫通配符*，需要用到包中的哪個類，就導入哪個類。
24、建議定義包名不要重復，可以使用url來完成定義，url是唯一的。
25、jar包：java的壓縮包：方便項目的攜帶。方便于使用，只要在classpath設置jar路徑即可。數(shù)據(jù)庫驅動，SSH框架等都以jar包體現(xiàn)的。2016年01月17日
day11
一、多線程：概述
1、進程：是一個正在執(zhí)行中的程序。每一個進程執(zhí)行都有一個執(zhí)行順序。該順序是一個執(zhí)行路徑，或者叫一個控制單元。
2、線程：就是進程中的一個獨立的控制單元。線程在控制著進程的執(zhí)行。一個進程中至少有一個線程。
3、Java VM 啟動的時候會有一個進程java.exe。該進程中至少有一個線程負責java程序的執(zhí)行。而且這個線程運行的代碼存在于main方法中。該線程稱之為主線程。擴展：其實更細節(jié)說明jvm，jvm啟動不止一個線程，還有負責垃圾回收機制的線程。
4、如何在自定義的代碼中，自定義一個線程呢？通過對API的查找，java已經(jīng)提供了對線程這類事物的描述。就是Thread類。
5、創(chuàng)建線程的第一種方式：繼承Thread類。步驟：1，定義類繼承Thread。2，復寫Thread類中的run方法。目的：將自定義代碼存儲在run方法中，讓線程運行。3，調(diào)用線程的start方法，該方法有兩個作用：啟動線程；調(diào)用run方法。
6、發(fā)現(xiàn)運行結果每一次都不同：因為多個線程都獲取cpu的執(zhí)行權。cpu執(zhí)行到誰，誰就運行。明確一點，在某一時刻，只能有一個程序在運行。（多核除外）cpu在做著快速的切換，以達到看上去是同時運行的效果。我們可以形象把多線程的運行形容為在互相搶奪cpu的執(zhí)行權。這就是多線程的一個特性：隨機性。誰搶到誰執(zhí)行，至于執(zhí)行多長，cpu說了算。
7、為什么要覆蓋run方法呢？Thread類用于描述線程。該類就定義了一個功能，用于存儲線程要運行的代碼，該存儲功能就是run方法。也就是說Thread類中的run方法，用于存儲線程要運行的代碼。
8、原來線程都有自己默認的名稱。Thread-編號。該編號從0開始。static Thread currentThread()：獲取當前線程對象。getName()：獲取線程名稱。設置線程名稱：setName或者構造函數(shù)。
9、創(chuàng)建線程的第二種方式：實現(xiàn)Runnable接口。
步驟：1，定義類實現(xiàn)Runnable接口。2，覆蓋Runnable接口中的run方法。目的：將線程要運行的代碼存放在run方法中。3，通過Thread類建立線程對象。4，將Runnable接口的子類對象作為實際參數(shù)傳遞給Thread類的構造函數(shù)。為什么要將Runnable接口的子類對象傳遞給Thread的構造函數(shù)？因為，自定義的run方法所屬的對象時Runnable接口的子類對象。所有要讓線程去指定指定對象的run方法。就必須明確該run方法所屬對象。5，調(diào)用Thread類的start方法開啟線程并調(diào)用Runnable接口子類的run方法。
10、實現(xiàn)方式和基礎方法有什么區(qū)別呢？實現(xiàn)方式好處：避免了單繼承的局限性。在定義線程時，建議使用實現(xiàn)方式。兩種方式區(qū)別：繼承Thread：線程代碼存放在Thread子類run方法中。實現(xiàn)Runnable：線程代碼存放在接口的子類的run方法中。
二、多線程：同步
11、多線程的運行出現(xiàn)了安全問題：問題的原因：當多條語句在操作同一個線程共享數(shù)據(jù)時，一個線程對多條語句只執(zhí)行了一部分，汗沒有執(zhí)行完，另一個線程參與進來執(zhí)行。導致共享數(shù)據(jù)的錯誤。解決辦法：對多條操作共享數(shù)據(jù)的語句，只能讓一個線程都執(zhí)行完。在執(zhí)行過程過，其他線程不可以參與執(zhí)行。java對于多線程的安全問題提供了專業(yè)的解決方式。就是同步代碼塊。synchronized(對象){需要被同步的代碼；}。
12、對象如同鎖。持有鎖的線程可以在同步中執(zhí)行。沒有鎖的線程即使獲取了cpu的執(zhí)行權，也進不去，因為沒有獲取鎖。
13、同步的前提：1，必須要有兩個或者兩個以上的線程。2，必須是多個線程使用同一個鎖。必須保證同步中只能有一個線程在運行。
14、好處：解決了多線程的安全問題。弊端：多個線程需要判斷鎖，較為消耗資源。
15、多線程安全問題：如何找到問題：1，明確哪些代碼是多線程運行代碼。2，明確共享數(shù)據(jù)。3，明確多線程運行代碼中哪些語句是操作共享數(shù)據(jù)的。
16、同步函數(shù)：將關鍵字synchronized放到函數(shù)名稱前。即把synchronized當作修飾符使用。
17、同步函數(shù)用的是哪一個鎖呢？函數(shù)需要被對象調(diào)用。那么函數(shù)都有一個所屬對象引用。就是this。所有同步函數(shù)使用的鎖是this。
18、如果同步函數(shù)被靜態(tài)修飾后，使用的鎖是什么呢？通過驗證，發(fā)現(xiàn)不再是this。因為靜態(tài)方法中也不可以定義this。靜態(tài)進內(nèi)存時，內(nèi)存中沒有本類對象，但是一定有該類對應的字節(jié)碼文件對象。類名.class 該對象的類型是Class。靜態(tài)的同步方法，使用的鎖是該方法所在類的字節(jié)碼文件對象。類名.class。
19、死鎖：同步中嵌套同步。而鎖卻不同。
2016年01月18日
day12
一、多線程：線程間通信
1、wait()，notify()，notifyALL()，用來操作線程為什么定義在了Object類中？這些方法存在于同步中。使用這些方法時必須要標識所屬的同步的鎖。鎖可以是任意對象，所以任意對象調(diào)用的方法一定定義Object類中。
2、wait()和sleep()有什么區(qū)別？wait()：釋放資源，釋放鎖。sleep()：釋放資源，不釋放鎖。
3、wait：notify：notifyALL：都被使用在同步中，因為要對持有監(jiān)視器（鎖）的線程操作。所有要使用在同步中，因為只有同步才具有鎖。
4、為什么這些操作線程的方法要定義在Object類中呢？因為這些方法在操作同步中線程時，都必須要標識他們所操作線程只有的鎖。只有同一個鎖上的被等待線程，可以被同一個鎖上notify喚醒。不可以對不同鎖中的線程進行喚醒。也就是說，等待和喚醒必須是同一個鎖。而鎖可以是任意對象，所有可以被任意對象調(diào)用的方法定義在Object類中。
5、JDK1.5 中提供個多線程升級解決方案。將同步synchronized替換成現(xiàn)實Lock操作。將Object中的wait，notify，notifyAll，替換了condition對象。該對象可以Lock鎖，進行獲取。
二、多線程：其他操作
6、停止線程：A：定義循環(huán)結束標記：因為線程運行代碼一般都是循環(huán)，只要控制了循環(huán)即可。B：使用interrupt（中斷）方法：該方法時結束線程的凍結狀態(tài)，使線程回到運行狀態(tài)中來。注意：stop方法已經(jīng)過時不再使用。
7、如何停止線程？只有一種，run方法結束。開啟多線程運行，運行代碼通常是循環(huán)結構。只要控制住循環(huán)，就可以讓run方法結束，也就是線程結束。特殊情況：當線程處于了凍結狀態(tài)。就不會讀取到標記。那么線程就不會結束。
8、當沒有指定的方式讓凍結的線程恢復到運行狀態(tài)時，這時需要對凍結進行清除。強制讓線程恢復到運行狀態(tài)中來。這樣就可以操作標記讓線程結束。Thread類中提供該方法：interrupt方法。
9、join方法：當A線程執(zhí)行到了B線程的.join()方法時，A就會等待。等B線程都執(zhí)行完，A才會執(zhí)行。join可以用來臨時加入線程執(zhí)行。
2016年01月19日
day13
一、String類：概述
1、String類：字符串是一個特殊的對象。字符串一旦初始化就不可以被改變。String str=”abc”；String str1=new String(“abc”)。Str和str1的區(qū)別：str在內(nèi)存中有一個對象。Str1在內(nèi)存中有兩個對象。
二、***重點：String類：常見操作
常見的操作有哪些？ “abcd” 1，獲取。
1.1 字符串中包含的字符數(shù)，也就是字符串的長度。
int length()：獲取長度。
1.2 根據(jù)位置獲取位置上某個字符。
char charAt(int index)：獲取位置上某個字符。
1.3 根據(jù)字符獲取該字符在字符串中位置。
int indexOf(int ch)：獲取該字符在字符串中位置。返回的是ch在字符串中第一次出現(xiàn)的位置。
int indexOf(int ch,int fromIndex)：從fromIndex指定位置開始，獲取ch在字符串中出現(xiàn)的位置。
int indexOf(String str)：返回的是str在字符串中第一次出現(xiàn)的位置。
int indexOf(String str,int fromIndex)：從fromIndex指定位置開始，獲取str在字符串中出現(xiàn)的位置。
int lastIndexOf(int ch)：反向索引。2，判斷。
2.1 字符串中是否包含某一個子串。
boolean contains(str);
特殊之處：indexOf(str)：可以索引str第一次出現(xiàn)位置，如果返回-1,表示該str不在字符串中存在。
2.2 2.3 2.4 2.5 2.6 所以，也可以用于對指定判斷是否包含。
if(str.indexOf(“aa”)!=-1)而且該方法既可以判斷又可以獲取出現(xiàn)的位置。字符串是否有內(nèi)容。
boolean isEmpty(str)：原理就是判斷長度是否為0。字符串是否是以指定內(nèi)容開頭。boolean startsWith(str);字符串是否是以指定內(nèi)容結尾。boolean endsWith(str);判斷字符串的內(nèi)容是否相同。復寫了Object類中的equals方法。boolean equals(str);判斷內(nèi)容是否相同，并忽略大小寫。boolean equalsIgnoreCass();3，轉換。
3.1 將字符數(shù)組轉成字符串。
構造函數(shù)：String(char[])
String(char[],offset,count)：將字符數(shù)組中的一部分轉成字符串。
靜態(tài)方法：static String copyValueOf(char[]);
static String copyValueOf(char[] data,int offset,int count);
static String valueOf(char[]);
3.2 將字符串轉成字符數(shù)組。//重點**。
char[] toCharArray();3.3 將字節(jié)數(shù)組轉成字符串。
String(byte[])String(byte[],offset,count)：將字節(jié)數(shù)組中的一部分轉成字符串。3.4 將字符串轉成字節(jié)數(shù)組。
byte[] getBytes();3.5 將基本數(shù)據(jù)類型轉成字符串。
static String valueOf(int)
static String valueOf(double)
//3+“";//String.valueOf(3);
特殊：字符串和字節(jié)數(shù)組在轉換過程中，是可以指定編碼表的。4，替換。
String replace(oldchar,newchar);5，切割。
String[] split(regex);6，子串。獲取字符串中的一部分。
String substring(begin);String substring(begin,end);7，轉換，去除空格，比較。
7.1 將字符串轉成大寫或者小寫。
String toUpperCase();
String toLowerCase();7.2 將字符串兩端的多個空格去除。
String trim();7.3 對兩個字符串進行自然順序的比較。
int compareTo(string);
三、String類：StringBuffer
8、StringBuffer類：字符串的注組成原理就是通過該類實現(xiàn)的。StringBuffer可以對字符串內(nèi)容進行增刪。StringBuffer是一個容器。很多方法與String相同。StringBuffer是可變長度的。
9、StringBuffer是字符串緩沖區(qū)。是一個容器。
10、緩沖區(qū)的特點：1，而且長度是可變化的。2，可以直接操作多個數(shù)據(jù)類型。3，最終會通過toString方法變成字符串。
11、StringBuffer常見操作： C create U update R read D delete 1，存儲。
StringBuffer append()：將指定數(shù)據(jù)作為參數(shù)添加到已有數(shù)據(jù)的結尾處。
StringBuffer insert(index,數(shù)據(jù))：可以將數(shù)據(jù)插入到指定index位置。2，刪除。
StringBuffer delete(start,end)：刪除緩沖區(qū)中的數(shù)據(jù)，包含start，不包含end。
StringBuffer deleteCharAt(index)：刪除指定index位置的字符。3，獲取。
char charAt(int index);int indexOf(String str);int lastIndexOf(String str);int length();String substring(int start,int end);4，修改。
StringBuffer replace(start,end,string);void setCharAt(int index,char ch);5，反轉。
StringBuffer reverse();6，將緩沖區(qū)中指定數(shù)據(jù)存儲到指定字符數(shù)組中。
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)。
12、JDK1.5版本之后出現(xiàn)了StringBuilder。
StringBuffer是線程同步。單線程使用StringBuffer效率較低。多線程使用StringBuffer保證了安全性。
StringBuilder是線程不同步。單線程使用StringBuilder提高了效率。多線程使用StringBuilder可能存在安全問題，但可以通過自定義鎖來解決安全問題。以后開發(fā)，建議使用StringBuilder。
13、升級三個因素：1，提高效率。2，簡化書寫。3，提高安全性。
四、基本數(shù)據(jù)類型對象包裝類
14、基本數(shù)據(jù)類型對象包裝類的最常見作用：就是用于基本數(shù)據(jù)類型和字符串類型之間做轉換。
15、數(shù)據(jù)類型轉換：
A：基本數(shù)據(jù)類型轉成字符串。
基本數(shù)據(jù)類型+”“ 基本數(shù)據(jù)類型.toString(基本數(shù)據(jù)類型值);如：Integer.toString(34);//將34整數(shù)變成”34“。B：字符串轉成基本數(shù)據(jù)類型。
靜態(tài)：基本數(shù)據(jù)類型包裝類.parseInt(字符串);如：xxx a=Xxx.parseXxx(String);
int a=Integer.parseInt(”123“);
double d=Double.parseDouble(”12.23“);
boolean b=Boolean.parseBoolean(”true“);非靜態(tài)：
Integer i=new Integer(”123");
int num=i.intValue();C：十進制轉成其他進制。
toBinaryString();toHexString();toOctalString();D：其他進制轉成十進制。
parseInt(string,radix)。
2016年01月22日
day14
一、集合框架：概述
1、集合類：為什么會出現(xiàn)集合類？面向對象語言對事物的體現(xiàn)都是以對象的形式，所有為了方便對多個對象的操作，就對對象進行存儲，集合就是存儲對象最常用的一種方式。
2、數(shù)組和集合類同是容器，有何不同？數(shù)組雖然也可以存儲對象，但長度是固定的；集合長度是可變的，數(shù)組中可以存儲基本數(shù)據(jù)類型，集合只能存儲對象。
3、集合類的特點：集合只用于存儲對象，集合長度是可變的，集合可以存儲不同類型的對象。
4、為什么會出現(xiàn)這么多的容器呢？因為每一個容器對數(shù)據(jù)的存儲方式有所不同。這個存儲方式稱之為：數(shù)據(jù)結構。
5、add方法的參數(shù)類型是Object。以便于接收任意類型對象。集合中存儲的都是對象的引用（地址）。
6、什么是迭代器呢？其實就是集合的取出元素的方式。
二、集合框架：List類
7、List: 特有方法。凡是可以操作角標的方法都是該體系特有的方法。增
add(index,element);addAll(index,Collection);刪
remove(index);改
set(index,element);查
get(index);subList(from,to);listIterator();
8、List集合特有的迭代器。ListIterator是Iterator的子接口。在迭代時，不可以通過集合對象的方法操作集合中的元素。因為會發(fā)生ConcurrentModificationException異常。所有，在迭代器時，只能用迭代器的方法操作元素，可以Iterator方法時優(yōu)先的，只能對元素進行判斷，取出，刪除的操作，如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。該接口只能通過List集合的ListIterator方法獲取。
9、Collection |--List:元素是有序的，元素可以重復。因為該集合體系有索引。
|--ArrayList:底層的數(shù)據(jù)結構使用的是數(shù)組結構。特點：查詢速度很快。但是增刪稍慢。線程不同步。
|--LinkedList:底層使用的是鏈表數(shù)據(jù)結構。特點：增刪速度很快，查詢速度稍慢。
|--Vector:底層是數(shù)據(jù)數(shù)據(jù)結構。線程同步。被ArrayList替代了。
|--Set:元素是無序的，元素不可以重復。
10、枚舉就是Vector特有的取出方式。發(fā)現(xiàn)枚舉和迭代器很像。其實枚舉和迭代是一樣的。因為枚舉的名稱以及方法的名稱都過長。所有被迭代器取代了。枚舉郁郁而終了。
11、LinkedList：特有方法： addFirst();addLast();
getFirst();getLast();獲取元素，但是不刪除元素。如果集合中沒有元素，會出現(xiàn)NoSuchElementException。
removeFirst();removeLast();獲取元素，但是元素被刪除。如果集合中沒有元素，會出現(xiàn)NoSuchElementException。
在JDK1.6出現(xiàn)了替代方法。offerFirst();offerLast();
peekFirst();peekLast();獲取元素，但是不刪除元素。如果集合中沒有元素，會返回null。
pollFirst();pollLast();獲取元素，但是元素被刪除。如果集合中沒有元素，會返回null。
三、集合框架：Set類
12、HaseSet是如何保證元素唯一性的呢？是通過元素的兩個方法，hashCode和equals來完成。如果元素的hashCode值相同，才會判斷equals是否為true。如果元素的hashCode值不同，不會調(diào)用equals。
13、注意：對于判斷元素是否存在，以及刪除操作，依賴的方法時元素的hashcode和equals方法。
2016年1月23日
day15
一、集合框架：Set類
1、Set：無序，不可以重復元素。
|--HashSet：數(shù)據(jù)結構是哈希表。線程是非同步的。
保證元素唯一性的原理：判斷元素的hashCode值是否相同。
如果相同，還會繼續(xù)判斷元素的equals方法，是否為true。
|--TreeSet：可以對Set集合中的元素進行排序。
底層數(shù)據(jù)結構是二叉樹。
保證元素唯一性的依據(jù)：
compareTo方法和return 0。
2、TreeSet排序的第一種方式：讓元素自身具備比較性。元素需要實現(xiàn)comparable接口，覆蓋comparaeTo方法。這種方式也稱為元素的自然順序，或者默認順序。
3、TreeSet排序的第二種方式：當元素自身不具備比較性時，或者具備的比較性不是所需要的。這時就需要讓集合自身具備比較性。在集合初始化時，就有了比較方式。
4、當元素自身不具備比較性，或者具備的比較性不是所需要的。這時需要讓容器自身具備比較性。定義了比較器，將比較器對象作為參數(shù)傳遞給TreeSet集合的構造函數(shù)。
5、當兩種排序都存在時，以比較器為主。定義一個類，實現(xiàn)Comparator接口，覆蓋compare方法。
二、集合框架：泛型
6、泛型：JDK1.5版本以后出現(xiàn)的新特性。用于解決安全問題，是一個類型安全機制。
7、泛型的好處：好處：1，將運行時期出現(xiàn)問題ClassCastException，轉移到了編譯時期。方便于程序員解決問題。讓運行時期問題減少。更加安全。2，避免了強制轉換麻煩。
8、泛型格式：通過<>來定義要操作的引用數(shù)據(jù)類型。在使用java提供的對象時，什么時候寫泛型呢？通常在集合框架中很常見。只要見到<>就要定義泛型。其實<>就是用來接收類型的。當使用集合時，將集合中要存儲的數(shù)據(jù)類型作為參數(shù)傳遞到<>即可。
9、什么時候定義泛型類？當類中要操作的引用數(shù)據(jù)類型不確定的時候，早期定義Object來完成擴展。現(xiàn)在定義泛型來完成擴展。
10、泛型類定義的泛型，在整個類中有效。如果被方法使用，那么泛型類的對象明確要操作的具體類型后，所有要操作的類型就已經(jīng)固定了。為了讓不同方法可以操作不同類型，而且類型還不確定，那么可以將泛型定義在方法上。
11、特殊之處：靜態(tài)方法不可以訪問類上定義的泛型。如果靜態(tài)方法操作的引用數(shù)據(jù)類型不確定，可以將泛型定義在方法上。
12、? 通配符。也理解為占位符。泛型的限定：
？ extends E：可以接收E類型或者E的子類型。上限。？ super E：可以接收E類型或者E的父類型。下限。
2016年01月24日
day16
一、集合：Map概述
1、Map集合：該集合存儲鍵值對。一對一對往里存，而且要保證鍵的唯一性。
2、Map框架：
1，添加。
put(K key,V value)
putAll(Map m)2，刪除。
clear()
remove(Object key)3，判斷。
containsValue(Object value)
containsKey(Object key)
isEmpty()4，獲取。
get(Object key)
size()
values()
entrySet()
keySet()
3、Map |--HashTable：底層是哈希表數(shù)據(jù)結構，不可以存入null鍵null值，該集合是線程同步的。JDK1.0。效率低。
|--HashMap：底層是哈希表數(shù)據(jù)結構，允許使用null鍵和null值，該集合是不同步的。JDK1.2。效率高。|--TreeMap：底層是二叉樹數(shù)據(jù)結構，線程不同步，可以用于給map集合中的鍵進行排序。
4、和Set很像。其實大家，Set底層就是使用了Map集合。
5、map集合的兩種取出方式：1，keySet：將map中所有的鍵存入到Set集合。因為Set具備迭代器。所以可以迭代方式取出所有的鍵，在根據(jù)get方法，獲取每一個鍵對應的值。Map集合的取出原理：將map集合轉成set集合。在通過迭代器取出。2，Set
6、Map.Entey 其實Entry也是一個接口，它是Map接口中的一個內(nèi)部接口。
7、什么時候使用map集合呢？當數(shù)據(jù)之間存在映射關系時，就要先想到map集合。
8、map擴展知識：map集合被使用是因為具備映射關系。
2016年01月26日
day17
一、集合：Collections
1、fill方法可以將list集合中所有元素替換成指定元素。
二、集合：Arrays
2、Arrays：用于操作數(shù)組的工具類。里面都是靜態(tài)方法。
3、asList：將數(shù)組變成list集合。
4、把數(shù)組變成list集合有什么好處？可以使用集合的思想和方法來操作數(shù)組中的元素。注意：將數(shù)組變成集合，不可以使用集合的增刪方法。因為數(shù)據(jù)的長度是固定的。如果你增刪，那么會發(fā)生UnsupportedOperationException。
5、數(shù)組變集合：如果數(shù)組中的元素都是對象。那么變成集合時，數(shù)組中的元素就直接轉成集合中的元素。如果數(shù)組中的元素都是基本數(shù)據(jù)類型，那么會將該數(shù)組作為集合中的元素存在。
6、集合變數(shù)組：指定類型的數(shù)組到底要定義多長呢？當指定類型的數(shù)組長度小于了集合的size，那么該方法內(nèi)部會創(chuàng)建一個新的數(shù)組，長度為集合的size。當指定類型的數(shù)組長度大于了集合的size，就不會新創(chuàng)建數(shù)組，而是使用傳遞進來的數(shù)組。所以創(chuàng)建一個剛剛好的數(shù)組最優(yōu)。
7、為什么要講集合變數(shù)組？為了限定對元素的操作。不需要進行增刪了。
8、高級for循環(huán)：格式：for（數(shù)據(jù)類型變量名：被遍歷的集合（Collection）或者數(shù)組）｛｝。
9、高級for循環(huán)、迭代器、ListIterator的區(qū)別：
高級for循環(huán)對集合進行遍歷。只能獲取集合元素，但是不能對集合進行操作。迭代器除了遍歷，還可以進行remove集合中元素的動作。
如果使用ListIterator，還可以在遍歷過程中對集合進行增刪改查的操作。
10、傳統(tǒng)for和高級for有什么區(qū)別呢？高級for有一個局限性：必須有被遍歷的目標。建議在遍歷數(shù)組的時候，還是希望使用傳統(tǒng)for。因為傳統(tǒng)for可以定義角標。
11、JDK1.5版本出現(xiàn)的新特性：可變參數(shù)：其實就是上一種數(shù)組參數(shù)的簡寫形式。不用每一次都手動的建立數(shù)組對象。只要將要操作的元素作為參數(shù)傳遞即可。隱式將這些參數(shù)封裝成了數(shù)組。
12、方法的可變參數(shù)。在使用時注意：可變參數(shù)一定要定義在參數(shù)列表最后面。
13、import static：靜態(tài)導入：例如：import static java.lang.System.*;//導入了System類中所有靜態(tài)成員。注意：當類名重名時，需要制定具體的包名。當方法重名時，指定具備所屬的對象或者類。
2016年01月28日
day18
一、其他對象：System
1、System:類中的方法和屬性都是靜態(tài)的。out:標準輸出，默認是控制臺。int:標準輸入，默認是鍵盤。描述系統(tǒng)一些信息。
2、獲取系統(tǒng)屬性信息：Properties getProperties()。因為Properties是Hashtable的子類，也就是Map集合的一個子類對象。那么可以通過map的方法取出該集合中的元素。該集合中存儲都是字符串。沒有泛型定義。
3、Runtime對象：該類并沒有提供構造函數(shù)。說明不可以new對象。那么會直接想到該類中的方法都是靜態(tài)的。發(fā)現(xiàn)該類中還有非靜態(tài)方法。說明該類肯定會提供方法獲取本類對象。而且該方法是靜態(tài)的，并返回值類型是本類類型。由這個特點可以看出該類使用了單例設計模式完成。該方式的static Runtime getRuntime()。
4、Math類：ceil方法：返回大于指定數(shù)據(jù)的最小整數(shù)。floor方法：返回小于指定數(shù)據(jù)的最大整數(shù)。round方法：四舍五入。pow方法：冪運算。random：返回0-1之間的隨機數(shù)。
二、IO流：概述
5、IO(Input Outpu)流：IO流用來處理設備之間的數(shù)據(jù)傳輸。Java對數(shù)據(jù)的操作是通過流的方式。Java用于操作流的對象都在IO包中。流按操作數(shù)據(jù)分為兩種：字節(jié)流與字符流。流按流向分為：輸入流，輸出流。
6、IO流常用基類：字節(jié)流的抽象基類：InputStream，OutputStream。字節(jié)流的抽象基類：Reader，Writer。注：由這四個類派生出來的子類名稱都是以其父類名作為子類名的后綴（如：InputStream的子類FilelnputStream，如：Reader的子類FileReader。）。
7、字符流和字節(jié)流：字節(jié)流兩個基類：InputStream
OutputStream。字符流兩個基類：Reader Writer。先學習字符流的特點：既然IO流是用于操作數(shù)據(jù)的，那么數(shù)據(jù)的最常見體現(xiàn)形式是：文件。2016年01月30日
day19
一、IO流：Buffered緩沖區(qū)
1、字符流的緩沖區(qū)：緩沖區(qū)的出現(xiàn)提高了對數(shù)據(jù)的讀寫效率。對應類：BufferedWriter；BufferedReader。緩沖區(qū)要結合流才可以使用。在流的基礎上對流的功能進行了增強。
2、緩沖區(qū)的出現(xiàn)是為了提高流的操作效率而出現(xiàn)的。所以在創(chuàng)建緩沖區(qū)之前，必須要先有流對象。該緩沖區(qū)中提供了一個跨平臺的換行符。newLine()。
3、字符讀取流緩沖區(qū)：該緩沖區(qū)提供了一次讀一行的方法readLine()，方便于對文本數(shù)據(jù)的獲取。當返回null時，表示讀到文件末尾。
4、readLine方法返回的時候只返回回車符之前的數(shù)據(jù)內(nèi)容。并不返回回車符。
5、裝飾設計模式：當想要對已有的對象進行功能增強時，可以定義類，將已有對象傳入，基于已有的功能，并提供加強功能。那么自定義的該類稱為裝飾類。
6、裝飾類通常會通過構造方法接收被裝飾的對象。并基于被裝飾的對象的功能，提供更強的功能。
7、裝飾模式比繼承要靈活，避免了繼承體系臃腫。而且降低了類與類之間的關系。裝飾類因為是增強已有對象，具備的功能和已有的是相同的，只不過提供了更強功能。所以裝飾類和被裝飾類通常是都屬于一個體系中的。
二、IO流：字節(jié)流
8、字符流： FileReader FileWriter BufferedReader BufferedWriter 字節(jié)流：
InputStream
OutputStream BufferedInputStream
BufferedOutputStream
9、流操作的基本規(guī)律：
最痛苦的就是流對象有很多，不知道該用哪一個。通過兩個明確來完成。1，明確源和目的。
源：輸入流。InputStream Reader。
目的：輸出流。OutputStream Writer。2，明確操作的數(shù)據(jù)是否是純文本。
是：字符流。
不是：字節(jié)流。
3，當體系明確后，再明確要使用哪個具體的對象。
通過設備來進行區(qū)分：
源設備：內(nèi)存，硬盤，鍵盤。目的設備：內(nèi)存，硬盤，控制臺。
2016年01月31日
day20
一、IO流：File類
1、File類：用來將文件或者文件夾封裝成對象。方便對文件與文件夾進行操作。File對象可以作為參數(shù)傳遞給流的構造函數(shù)。了解File類中的常用方法。
2、File類常見方法： 1，創(chuàng)建。
boolean createNewFile()；在指定位置創(chuàng)建文件，如果該文件已經(jīng)存在，則不創(chuàng)建，返回false。
和輸出流不一樣，輸出流對象一建立創(chuàng)建對象。而且文件已經(jīng)存在，會覆蓋。
boolean mkdir();創(chuàng)建一級文件夾。
boolean mkdirs();創(chuàng)建多級文件夾。2，刪除。
boolean delete();刪除失敗返回false。
void deleteOnExit();在程序退出時刪除指定文件。3，判斷。
boolean exists();文件是否存在。
boolean isFile();判斷是否是文件。
boolean isDirectory();判斷是否是文件夾。
boolean isHidden();判斷是否是隱藏文件。
boolean isAbsolute();判斷是否是絕對路徑。4，獲取信息。
String getName();獲取文件名稱。
String getPath();獲取文件相對路徑。
String getParent();該方法返回的是絕對路徑中的父目錄。如果獲取的是相對路徑，返回null。
如果相對路徑中有上一層目錄那么該目錄就是返回結果。
getAbsolute();獲取文件絕對路徑。
lastModified();返回文件最后一次被修改的時間。
length()。
3、因為目錄中還有目錄，只要使用同一個列出目錄功能的函數(shù)完成即可。在列出過程中出現(xiàn)的還是目錄的話，還可以再次調(diào)用本功能。也就是函數(shù)自身調(diào)用自身。這種表現(xiàn)形式，或者編程手法，稱為遞歸。
遞歸要注意：1，限定條件。2，要注意遞歸的次數(shù)。盡量避免內(nèi)存溢出。
4、練習：將一個指定目錄下的java文件的絕對路徑，存儲到一個文本文件中。建立一個java文件列表文件。思路：1，對指定的目錄進行遞歸。2，獲取遞歸過程所有的java文件的路徑。3，將這些路徑存儲到集合中。4，將集合中的數(shù)據(jù)寫入到一個文件中。
二、IO流：Properties類
5、Properties是hashtable的子類。也就是說它具備map集合的特點。而且它里面存儲的鍵值對都是字符串。是集合中和IO技術相結合的集合容器，該對象的特點：可以用于鍵值對形式的配置文件。
6、那么在加載數(shù)據(jù)時，需要數(shù)據(jù)有固定格式：鍵=值。
三、IO流：其他類
7、打印流：PrintWriter與PrintStream：可以直接操作輸入流和文件。打印流：
該流提供了打印方法，可以將各種數(shù)據(jù)類型的數(shù)據(jù)都原樣打印。字節(jié)打印流：PrintStream 構造函數(shù)可以接收的參數(shù)類型： 1，file對象。File。
2，字符串路徑。String。
3，字節(jié)輸出流。OutputStream。字符打印流：PrintWriter 構造函數(shù)可以接收的參數(shù)類型： 1，file對象。File。
2，字符串路徑。String。
3，字節(jié)輸出流。OutputStream。4，字符數(shù)出來：Writer。
8、序列流：SequenceInputStream：對多個流進行合并。
9、操作對象：ObjectInputStream與ObjectOutputStream：被操作的對象需要實現(xiàn)Serializable（標記接口）。
2016年02月01日
day21
一、IO流：其他類
1、RandomAccessFile：隨機訪問文件，自身具備讀寫的方法。通過skipBytes(int x),seek(int x)來達到隨機訪問。
2、管道流：PipedInputStream和PipedOutputStream：輸入輸出可以直接進行連接，通過結合線程使用。
3、RandomAccessFile：該類不算是IO體系中子類。而是直接繼承自Object。但是它是IO包中成員。因為它具備讀和寫功能。內(nèi)部封裝了一個數(shù)組，而且通過指針對數(shù)據(jù)的元素進行操作。可以通過getFilePointer獲取指針位置。同時可以通過seek改變指針的位置。其實完成讀寫的原理就是內(nèi)部封裝了字節(jié)輸入流和輸出流。通過構造函數(shù)可以看出，該類只能操作文件。而且操作文件還有模式：只讀r，讀寫rw等。
4、如果模式為只讀r。不會創(chuàng)建文件。會去讀取一個已存在文件，如果該文件不存在，則會出現(xiàn)異常。如果模式為讀寫rw。操作的文件不存在，會自動創(chuàng)建。如果存在則不會覆蓋。
5、IO包中的其他類：
操作基本數(shù)據(jù)類型：DataInputStream與DataOutputStream。
操作字節(jié)數(shù)組：ByteArrayInputStream與ByteArrayOutputStream。操作字符數(shù)組：CharArrayReader與CharArrayWrite。操作字符串：StringReader與StringWriter。
6、用于操作字節(jié)數(shù)組的流對象。
ByteArrayInputStream ：在構造的時候，需要接收數(shù)據(jù)源，而且數(shù)據(jù)源是一個字節(jié)數(shù)組。ByteArrayOutputStream ：在構造的時候，不用定義數(shù)據(jù)目的，因為該對象中已經(jīng)內(nèi)部封裝了可變長度的字節(jié)數(shù)組。這就是數(shù)據(jù)目的地。因為這兩個流對象都操作的數(shù)組，并沒有使用系統(tǒng)資源。所以，不用進行close關閉。在流操作規(guī)律講解時： 源設備：
鍵盤 System.in，硬盤 FileStream，內(nèi)存 ArrayStream。目的設備：
控制臺 System.out，硬盤 FileStream，內(nèi)存 ArrayStream。用流的讀寫思想來操作數(shù)組。
二、IO流：字符編碼
7、字符編碼：字符流的出現(xiàn)為了方便操作字符。更重要是的加入了編碼轉換。通過子類轉換流來完成：InputStreamReader；OutputStreamWriter。在兩個對象進行構造的時候可以加入字符集。
8、編碼表的由來：計算機只能識別二進制數(shù)據(jù)，早期由來是電信號。為了方便應用計算機，讓它可以識別各個國家的文字。就將各個國家的文字用數(shù)字來表示，并一一對應，形成一張表。這就是編碼表。
9、常見的編碼表：
ASCII：美國標準信息交換碼。用一個字節(jié)的7位可以表示。ISO8859-1：拉丁碼表。歐洲碼表。用一個字節(jié)的8位表示。GBK2312：中國的中文編碼表。用兩個字節(jié)的16位來表示。GBK：中國的中文編碼表升級，融合了更多的中文文字符號。
Unicode：國際標準碼，融合了多種文字。所有文字都用兩個字節(jié)來表示，Java語言使用的就是Unicode。
UTF-8：最多用三個字節(jié)來表示一個字符。??
10、編碼：字符串變成字節(jié)數(shù)組。解碼：字節(jié)數(shù)組變成字符串。String-->byte[];str.getBytes(charsetName);byte[]-->String;new String(byte[],charsetName)。2016年02月02日
day22
一、GUI：概述
1、GUI：圖形用戶界面。
GUI：Graphical User Interface（圖形用戶接口）。用圖形的方式，來顯示計算機操作的界面，這樣更方便跟直觀。
CLI：Command line User Inteface（命令行用戶接口）。就是常見的Dos命令行操作。需要記憶一些常用的命令，操作不直觀。
舉例：比如：創(chuàng)建文件夾，或者刪除文件夾等。
Java為GUI提供的對象都存在java.Awt和javax.Swing兩個包中。
2、Awt與Swing：
java.Awt：Abstract Window ToolKit（抽象窗口工具包），需調(diào)用本地系統(tǒng)方法實現(xiàn)功能。屬重量級控件。
javax.Swing：在Awt的基礎上，建立的一套圖形界面系統(tǒng)，其中提供了更多的組件，而且完全由Java實現(xiàn)。增強了移植性，屬輕量級控件。
3、繼承關系圖：
4、布局管理器：
容器中的組件的排放方式，就是布局。常見的布局管理器：
FlowLayout（流式布局管理器）
從左到右的順序排列。
Panel默認的布局管理器。BorderLayout（邊界布局管理器）
東，南，西，北，中。
Frame默認的布局管理器。GridLayout（網(wǎng)格布局管理器）
規(guī)則的矩陣。
CardLayout（卡片布局管理器）
選項卡。
GridBagLayout（網(wǎng)格包布局管理器）
非規(guī)則的矩陣。
5、創(chuàng)建圖形化界面： 1，創(chuàng)建frame窗體。
2，對窗體進行基本設置。
比如：大小、位置、布局。3，定義組件。
4，將組件通過窗體的add方法添加到窗體中。5，讓窗體顯示，通過setVisible(true)來完成。
6、建立一個簡單的窗體：
Container常用子類：Window Panel（面板，不能單獨存在。）Window常用子類：Frame Dialog。簡單的窗體創(chuàng)建過程：
Frame f = new Frame(“my window”);f.setLayout(new FlowLayout());f.setSize(500,400);//設置窗體大小。
f.setLocation(300,200);//設置窗體出現(xiàn)在屏幕的位置。f.setVisible(true)。
二、GUI：事件監(jiān)聽機制
7、事件監(jiān)聽機制組成：事件源（組件）；事件（Event）；監(jiān)聽器（Listener）；事件處理（引發(fā)事件后處理方式）。
8、事件監(jiān)聽機制流程圖：
9、事件監(jiān)聽機制的特點： 1，事件源。2，事件。3，監(jiān)聽器。4，事件處理。
事件源：就是awt或者swing包中的那些圖形界面組件。事件：每一個事件源都有自己特有的對應事件和共性事件。
監(jiān)聽器：將可以觸發(fā)某一個事件的動作（不止一個動作）都已經(jīng)封裝到了監(jiān)聽器中。以上三者，在java中都已經(jīng)定義好了。直接獲取其對象來用就可以了。我們要做的事情是，就是對產(chǎn)生的動作進行處理。
2016年02月03日
day23
一、網(wǎng)絡編程：概述
1、網(wǎng)絡編程：
網(wǎng)絡模型：OSI參考模型。TCP/IP參考模型。網(wǎng)絡通訊要素：IP地址。端口號。傳輸協(xié)議。
2、網(wǎng)絡參考模型：
3、網(wǎng)絡通訊要素： IP地址：網(wǎng)絡中設備的標識。不易記憶，可用主機名。本地回環(huán)地址：127.0.0.1主機名：localhost。端口號：用于標識進程的邏輯地址，不同進程的標識。有效端口：0~65535，其中0~1024系統(tǒng)使用或保留端口。
傳輸協(xié)議：通訊的規(guī)則。常見協(xié)議：TCP，UDP。
4、UDP和TCP： UDP：
將數(shù)據(jù)及源和目的封裝成數(shù)據(jù)包中，不需要建立連接。每個數(shù)據(jù)報的大小在限制在64k內(nèi)。因無連接，是不可靠協(xié)議。不需要建立連接，速度快。
特點：面向無連接。數(shù)據(jù)會被封包。不可靠。速度快。比如：聊天，視頻會議，桌面共享。TCP：
建立連接，形成傳輸數(shù)據(jù)的通道。
在連接中進行大數(shù)據(jù)量傳輸。
通過三次握手完成連接，是可靠協(xié)議。
必須建立連接，效率會稍低。
特點：面向連接。可大數(shù)據(jù)量傳輸。比較可靠。稍微有點慢。比如：下載。
5、Socket：
Socket就是為網(wǎng)絡服務提供的一種機制。通信的兩端都有Socket。
網(wǎng)絡通信其實就是Socket間的通信。數(shù)據(jù)在兩個Socket間通過IO傳輸。
二、網(wǎng)絡編程：UDP
6、UDP傳輸：
DatagramSocket與DatagramPacket。建立發(fā)送端，接收端。建立數(shù)據(jù)包。
調(diào)用Socket的發(fā)送接收方法。關閉Socket。
發(fā)送端與接收端是兩個獨立的運行程序。
三、網(wǎng)絡編程：TCP
7、TCP傳輸：
Socket和ServerSocket。建立客戶端和服務器端。
建立連接后，通過Socket中的IO流進行數(shù)據(jù)的傳輸。關閉socket。
同樣，客戶端與服務器端是兩個獨立的應用程序。2016年02月04日
day24
一、網(wǎng)絡編程：瀏覽器客戶端
1、視頻演示講解。
2016年02月6日
day25
一、正則表達式
1、正則表達式：符合一定規(guī)則的表達式。作用：用于專門操作字符串。
2、正則表達式：符合一定規(guī)則的表達式。
作用：用于專門操作字符串。
特點：用一些特定的符號來表示一些代碼操作。這樣就簡化了書寫。
所以學習正則表達式，就是在學習一些特殊符號的使用。
好處：可以簡化對字符串的復雜操作。
弊端：符號定義越多，正則越長，閱讀性越差。
3、具體操作功能：
1，匹配：String matchess();方法。用規(guī)則匹配整個字符串，只要有一處不符合規(guī)則，就匹配結束，返回false。2，切割：String split();3，替換：String replaceAll();4，獲取：將字符串中符合規(guī)則的子串取出。
4、獲取：操作步驟：
1，將正則表達式封裝成對象。
2，讓正則對象和要操作的字符串相關聯(lián)。3，關聯(lián)后，獲取正則匹配引擎。
4，通過引擎對符合規(guī)則的子串進行操作，比如取出。
點擊咨詢 