第一篇：Java的內(nèi)存泄漏 總結(jié)分析
Java的內(nèi)存泄漏
歐陽辰(yeekee@sina.com), 周欣(mailto:zhouxin@sei.pku.edu.cn), 簡介： Java的一個重要優(yōu)點就是通過垃圾收集器(Garbage Collection，GC)自動管理內(nèi)存的回收，程序員不需要通過調(diào)用函數(shù)來釋放內(nèi)存。因此，很多程序員認(rèn)為Java不存在內(nèi)存泄漏問題，或者認(rèn)為即使有內(nèi)存泄漏也不是程序的責(zé)任，而是GC或JVM的問題。其實，這種想法是不正確的，因為Java也存在內(nèi)存泄露，但它的表現(xiàn)與C++不同。本文的標(biāo)簽： j2se, java, java內(nèi)存泄露, 內(nèi)存, 內(nèi)存泄漏, 內(nèi)存泄露 標(biāo)記本文！
發(fā)布日期： 2002 年 10 月 21 日 級別： 初級
訪問情況： 18862 次瀏覽
評論： 4(查看 | 添加評論-登錄)平均分(59個評分)為本文評分
問題的提出
Java的一個重要優(yōu)點就是通過垃圾收集器(Garbage Collection，GC)自動管理內(nèi)存的回收，程序員不需要通過調(diào)用函數(shù)來釋放內(nèi)存。因此，很多程序員認(rèn)為Java不存在內(nèi)存泄漏問題，或者認(rèn)為即使有內(nèi)存泄漏也不是程序的責(zé)任，而是GC或JVM的問題。其實，這種想法是不正確的，因為Java也存在內(nèi)存泄露，但它的表現(xiàn)與C++不同。
隨著越來越多的服務(wù)器程序采用Java技術(shù)，例如JSP，Servlet，EJB等，服務(wù)器程序往往長期運(yùn)行。另外，在很多嵌入式系統(tǒng)中，內(nèi)存的總量非常有限。內(nèi)存泄露問題也就變得十分關(guān)鍵，即使每次運(yùn)行少量泄漏，長期運(yùn)行之后，系統(tǒng)也是面臨崩潰的危險。
回頁首
Java是如何管理內(nèi)存
為了判斷Java中是否有內(nèi)存泄露，我們首先必須了解Java是如何管理內(nèi)存的。Java的內(nèi)存管理就是對象的分配和釋放問題。在Java中，程序員需要通過關(guān)鍵字new為每個對象申請內(nèi)存空間(基本類型除外)，所有的對象都在堆(Heap)中分配空間。另外，對象的釋放是由GC決定和執(zhí)行的。在Java中，內(nèi)存的分配是由程序完成的，而內(nèi)存的釋放是有GC完成的，這種收支兩條線的方法確實簡化了程序員的工作。但同時，它也加重了JVM的工作。這也是Java程序運(yùn)行速度較慢的原因之一。因為，GC為了能夠正確釋放對象，GC必須監(jiān)控每一個對象的運(yùn)行狀態(tài)，包括對象的申請、引用、被引用、賦值等，GC都需要進(jìn)行監(jiān)控。
監(jiān)視對象狀態(tài)是為了更加準(zhǔn)確地、及時地釋放對象，而釋放對象的根本原則就是該對象不再被引用。
為了更好理解GC的工作原理，我們可以將對象考慮為有向圖的頂點，將引用關(guān)系考慮為圖的有向邊，有向邊從引用者指向被引對象。另外，每個線程對象可以作為一個圖的起始頂點，例如大多程序從main進(jìn)程開始執(zhí)行，那么該圖就是以main進(jìn)程頂點開始的一棵根樹。在這個有向圖中，根頂點可達(dá)的對象都是有效對象，GC將不回收這些對象。如果某個對象(連通子圖)與這個根頂點不可達(dá)(注意，該圖為有向圖)，那么我們認(rèn)為這個(這些)對象不再被引用，可以被GC回收。
以下，我們舉一個例子說明如何用有向圖表示內(nèi)存管理。對于程序的每一個時刻，我們都有一個有向圖表示JVM的內(nèi)存分配情況。以下右圖，就是左邊程序運(yùn)行到第6行的示意圖。
Java使用有向圖的方式進(jìn)行內(nèi)存管理，可以消除引用循環(huán)的問題，例如有三個對象，相互引用，只要它們和根進(jìn)程不可達(dá)的，那么GC也是可以回收它們的。這種方式的優(yōu)點是管理內(nèi)存的精度很高，但是效率較低。另外一種常用的內(nèi)存管理技術(shù)是使用計數(shù)器，例如COM模型采用計數(shù)器方式管理構(gòu)件，它與有向圖相比，精度行低(很難處理循環(huán)引用的問題)，但執(zhí)行效率很高。
回頁首
什么是Java中的內(nèi)存泄露
下面，我們就可以描述什么是內(nèi)存泄漏。在Java中，內(nèi)存泄漏就是存在一些被分配的對象，這些對象有下面兩個特點，首先，這些對象是可達(dá)的，即在有向圖中，存在通路可以與其相連；其次，這些對象是無用的，即程序以后不會再使用這些對象。如果對象滿足這兩個條件，這些對象就可以判定為Java中的內(nèi)存泄漏，這些對象不會被GC所回收，然而它卻占用內(nèi)存。
在C++中，內(nèi)存泄漏的范圍更大一些。有些對象被分配了內(nèi)存空間，然后卻不可達(dá)，由于C++中沒有GC，這些內(nèi)存將永遠(yuǎn)收不回來。在Java中，這些不可達(dá)的對象都由GC負(fù)責(zé)回收，因此程序員不需要考慮這部分的內(nèi)存泄露。
通過分析，我們得知，對于C++，程序員需要自己管理邊和頂點，而對于Java程序員只需要管理邊就可以了(不需要管理頂點的釋放)。通過這種方式，Java提高了編程的效率。
因此，通過以上分析，我們知道在Java中也有內(nèi)存泄漏，但范圍比C++要小一些。因為Java從語言上保證，任何對象都是可達(dá)的，所有的不可達(dá)對象都由GC管理。
對于程序員來說，GC基本是透明的，不可見的。雖然，我們只有幾個函數(shù)可以訪問GC，例如運(yùn)行GC的函數(shù)System.gc()，但是根據(jù)Java語言規(guī)范定義，該函數(shù)不保證JVM的垃圾收集器一定會執(zhí)行。因為，不同的JVM實現(xiàn)者可能使用不同的算法管理GC。通常，GC的線程的優(yōu)先級別較低。JVM調(diào)用GC的策略也有很多種，有的是內(nèi)存使用到達(dá)一定程度時，GC才開始工作，也有定時執(zhí)行的，有的是平緩執(zhí)行GC，有的是中斷式執(zhí)行GC。但通常來說，我們不需要關(guān)心這些。除非在一些特定的場合，GC的執(zhí)行影響應(yīng)用程序的性能，例如對于基于Web的實時系統(tǒng)，如網(wǎng)絡(luò)游戲等，用戶不希望GC突然中斷應(yīng)用程序執(zhí)行而進(jìn)行垃圾回收，那么我們需要調(diào)整GC的參數(shù)，讓GC能夠通過平緩的方式釋放內(nèi)存，例如將垃圾回收分解為一系列的小步驟執(zhí)行，Sun提供的HotSpot JVM就支持這一特性。下面給出了一個簡單的內(nèi)存泄露的例子。在這個例子中，我們循環(huán)申請Object對象，并將所申請的對象放入一個Vector中，如果我們僅僅釋放引用本身，那么Vector仍然引用該對象，所以這個對象對GC來說是不可回收的。因此，如果對象加入到Vector后，還必須從Vector中刪除，最簡單的方法就是將Vector對象設(shè)置為null。
Vector v=new Vector(10);for(inti=1;i<100;i++){
} Object o=new Object();v.add(o);o=null;
//此時，所有的Object對象都沒有被釋放，因為變量v引用這些對象。
回頁首
如何檢測內(nèi)存泄漏
最后一個重要的問題，就是如何檢測Java的內(nèi)存泄漏。目前，我們通常使用一些工具來檢查Java程序的內(nèi)存泄漏問題。市場上已有幾種專業(yè)檢查Java內(nèi)存泄漏的工具，它們的基本工作原理大同小異，都是通過監(jiān)測Java程序運(yùn)行時，所有對象的申請、釋放等動作，將內(nèi)存管理的所有信息進(jìn)行統(tǒng)計、分析、可視化。開發(fā)人員將根據(jù)這些信息判斷程序是否有內(nèi)存泄漏問題。這些工具包括Optimizeit Profiler，JProbe Profiler，JinSight , Rational 公司的Purify等。
下面，我們將簡單介紹Optimizeit的基本功能和工作原理。
Optimizeit Profiler版本4.11支持Application，Applet，Servlet和Romote Application四類應(yīng)用，并且可以支持大多數(shù)類型的JVM，包括SUN JDK系列，IBM的JDK系列，和Jbuilder的JVM等。并且，該軟件是由Java編寫，因此它支持多種操作系統(tǒng)。Optimizeit系列還包括Thread Debugger和Code Coverage兩個工具，分別用于監(jiān)測運(yùn)行時的線程狀態(tài)和代碼覆蓋面。
當(dāng)設(shè)置好所有的參數(shù)了，我們就可以在OptimizeIt環(huán)境下運(yùn)行被測程序，在程序運(yùn)行過程中，Optimizeit可以監(jiān)視內(nèi)存的使用曲線(如下圖)，包括JVM申請的堆(heap)的大小，和實際使用的內(nèi)存大小。另外，在運(yùn)行過程中，我們可以隨時暫停程序的運(yùn)行，甚至強(qiáng)行調(diào)用GC，讓GC進(jìn)行內(nèi)存回收。通過內(nèi)存使用曲線，我們可以整體了解程序使用內(nèi)存的情況。這種監(jiān)測對于長期運(yùn)行的應(yīng)用程序非常有必要，也很容易發(fā)現(xiàn)內(nèi)存泄露。
在運(yùn)行過程中，我們還可以從不同視角觀查內(nèi)存的使用情況，Optimizeit提供了四種方式：
? 堆視角。這是一個全面的視角，我們可以了解堆中的所有的對象信息(數(shù)量和種類)，并進(jìn)行統(tǒng)計、排序，過濾。了解相關(guān)對象的變化情況。
? 方法視角。通過方法視角，我們可以得知每一種類的對象，都分配在哪些方法中，以及它們的數(shù)量。
? 對象視角。給定一個對象，通過對象視角，我們可以顯示它的所有出引用和入引用對象，我們可以了解這個對象的所有引用關(guān)系。
? 引用圖。給定一個根，通過引用圖，我們可以顯示從該頂點出發(fā)的所有出引用。在運(yùn)行過程中，我們可以隨時觀察內(nèi)存的使用情況，通過這種方式，我們可以很快找到那些長期不被釋放，并且不再使用的對象。我們通過檢查這些對象的生存周期，確認(rèn)其是否為內(nèi)存泄露。在實踐當(dāng)中，尋找內(nèi)存泄露是一件非常麻煩的事情，它需要程序員對整個程序的代碼比較清楚，并且需要豐富的調(diào)試經(jīng)驗，但是這個過程對于很多關(guān)鍵的Java程序都是十分重要的。
綜上所述，Java也存在內(nèi)存泄露問題，其原因主要是一些對象雖然不再被使用，但它們?nèi)匀槐灰?。為了解決這些問題，我們可以通過軟件工具來檢查內(nèi)存泄露，檢查的主要原理就是暴露出所有堆中的對象，讓程序員尋找那些無用但仍被引用的對象。
第二篇：初探j(luò)ava內(nèi)存機(jī)制_堆和棧
初探j(luò)ava內(nèi)存機(jī)制_堆和棧
問題的引入：
問題一：
String str1 = “abc”;
String str2 = “abc”;
System.out.println(str1==str2);//true
問題二：
String str1 =new String(“abc”);
String str2 =new String(“abc”);
System.out.println(str1==str2);// false
問題三：
String s1 = “ja”;
String s2 = “va”;
String s3 = “java”;
String s4 = s1 + s2;
System.out.println(s3 == s4);//false
System.out.println(s3.equals(s4));//true
由于以上問題讓人含糊不清，于是特地搜集了一些有關(guān)java內(nèi)存分配的資料,以下是網(wǎng)摘：
Java 中的堆和棧
Java把內(nèi)存劃分成兩種：一種是棧內(nèi)存，一種是堆內(nèi)存。
在函數(shù)中定義的一些基本類型的變量和對象的引用變量都在函數(shù)的棧內(nèi)存中分配。
當(dāng)在一段代碼塊定義一個變量時，Java就在棧中為這個變量分配內(nèi)存空間，當(dāng)超過變量的作用域后，Java會自動釋放掉為該變量所分配的內(nèi)存空間，該內(nèi)存空間可以立即被另作他用。
堆內(nèi)存用來存放由new創(chuàng)建的對象和數(shù)組。
在堆中分配的內(nèi)存，由Java虛擬機(jī)的自動垃圾回收器來管理。
在堆中產(chǎn)生了一個數(shù)組或?qū)ο蠛?，還可以在棧中定義一個特殊的變量，讓棧中這個變量的取值等于數(shù)組或?qū)ο笤诙褍?nèi)存中的首地址，棧中的這個變量就成了數(shù)組或?qū)ο蟮囊米兞俊?/p>
引用變量就相當(dāng)于是為數(shù)組或?qū)ο笃鸬囊粋€名稱，以后就可以在程序中使用棧中的引用變量來訪問堆中的數(shù)組或?qū)ο蟆?/p>
具體的說：
棧與堆都是Java用來在Ram中存放數(shù)據(jù)的地方。與C++不同，Java自動管理棧和堆，程序員不能直接地設(shè)置?；蚨选?/p>
Java的堆是一個運(yùn)行時數(shù)據(jù)區(qū),類的(對象從中分配空間。這些對象通過new、newarray、anewarray和multianewarray等指令建立，它們不需要程序代碼來顯式的釋放。堆是由垃圾回收來負(fù)責(zé)的，堆的優(yōu)勢是可以動態(tài)地分配內(nèi)存大小，生存期也不必事先告訴編譯器，因為它是在運(yùn)行時動態(tài)分配內(nèi)存的，Java的垃圾收集器會自動收走這些不再使用的數(shù)據(jù)。但缺點是，由于要在運(yùn)行時動態(tài)分配內(nèi)存，存取速度較慢。
棧的優(yōu)勢是，存取速度比堆要快，僅次于寄存器，棧數(shù)據(jù)可以共享。但缺點是，存在棧中的數(shù)據(jù)大小與生存期必須是確定的，缺乏靈活性。棧中主要存放一些基本類型的變量（,int, short, long, byte, float, double, boolean, char）和對象句柄。
棧有一個很重要的特殊性，就是存在棧中的數(shù)據(jù)可以共享。假設(shè)我們同時定義：
int a = 3;
int b = 3；
編譯器先處理int a = 3；首先它會在棧中創(chuàng)建一個變量為a的引用，然后查找棧中是否有3這個值，如果沒找到，就將3存放進(jìn)來，然后將a指向3。接著處理int b = 3；在創(chuàng)建完b的引用變量后，因為在棧中已經(jīng)有3這個值，便將b直接指向3。這樣，就出現(xiàn)了a與b同時均指向3的情況。這時，如果再令a=4；那么編譯器會重新搜索棧中是否有4值，如果沒有，則將4存放進(jìn)來，并令a指向4；如果已經(jīng)有了，則直接將a指向這個地址。因此a值的改變不會影響到b的值。要注意這種數(shù)據(jù)的共享與兩個對象的引用同時指向一個對象的這種共享是不同的，因為這種情況a的修改并不會影響到b, 它是由編譯器完成的，它有利于節(jié)省空間。而一個對象引用變量修改了這個對象的內(nèi)部狀態(tài)，會影響到另一個對象引用變量。
String是一個特殊的包裝類數(shù)據(jù)?？梢杂茫?/p>
String str = new String(“abc”);
String str = “abc”;
兩種的形式來創(chuàng)建，第一種是用new()來新建對象的，它會在存放于堆中。每調(diào)用一次就會創(chuàng)建一個新的對象。
而第二種是先在棧中創(chuàng)建一個對String類的對象引用變量str，然后查找棧中有沒有存放“abc”，如果沒有，則將“abc”存放進(jìn)棧，并令str指向”abc”，如果已經(jīng)有”abc” 則直接令str指向“abc”。
比較類里面的數(shù)值是否相等時，用equals()方法；當(dāng)測試兩個包裝類的引用是否指向同一個對象時，用==，下面用例子說明上面的理論。
String str1 = “abc”;
String str2 = “abc”;
System.out.println(str1==str2);//true
可以看出str1和str2是指向同一個對象的。
String str1 =new String(“abc”);
String str2 =new String(“abc”);
System.out.println(str1==str2);// false
用new的方式是生成不同的對象。每一次生成一個。
因此用第二種方式創(chuàng)建多個”abc”字符串,在內(nèi)存中其實只存在一個對象而已.這種寫法有利與節(jié)省內(nèi)存空間.同時它可以在一定程度上提高程序的運(yùn)行速度，因為JVM會自動根據(jù)棧中數(shù)據(jù)的實際情況來決定是否有必要創(chuàng)建新對象。而對于String str = new String(“abc”)；的代碼，則一概在堆中創(chuàng)建新對象，而不管其字符串值是否相等，是否有必要創(chuàng)建新對象，從而加重了程序的負(fù)擔(dān)。
另一方面, 要注意: 我們在使用諸如String str = “abc”；的格式定義類時，總是想當(dāng)然地認(rèn)為，創(chuàng)建了String類的對象str。擔(dān)心陷阱！對象可能并沒有被創(chuàng)建！而可能只是指向一個先前已經(jīng)創(chuàng)建的對象。只有通過new()方法才能保證每次都創(chuàng)建一個新的對象。由于String類的immutable性質(zhì)，當(dāng)String變量需要經(jīng)常變換其值時，應(yīng)該考慮使用StringBuffer類，以提高程序效率。
java中內(nèi)存分配策略及堆和棧的比較
2.1 內(nèi)存分配策略
按照編譯原理的觀點,程序運(yùn)行時的內(nèi)存分配有三種策略,分別是靜態(tài)的,棧式的,和堆式的.靜態(tài)存儲分配是指在編譯時就能確定每個數(shù)據(jù)目標(biāo)在運(yùn)行時刻的存儲空間需求,因而在編譯時就可以給他們分配固定的內(nèi)存空間.這種分配策略要求程序代碼中不允許有可變數(shù)據(jù)結(jié)構(gòu)(比如可變數(shù)組)的存在,也不允許有嵌套或者遞歸的結(jié)構(gòu)出現(xiàn),因為它們都會導(dǎo)致編譯程序無法計算準(zhǔn)確的存儲空間需求.棧式存儲分配也可稱為動態(tài)存儲分配,是由一個類似于堆棧的運(yùn)行棧來實現(xiàn)的.和靜態(tài)存儲分配相反,在棧式存儲方案中,程序?qū)?shù)據(jù)區(qū)的需求在編譯時是完全未知的,只有到運(yùn)行的時候才能夠知道,但是規(guī)定在運(yùn)行中進(jìn)入一個程序模塊時,必須知道該程序模塊所需的數(shù)據(jù)區(qū)大小才能夠為其分配內(nèi)存.和我們在數(shù)據(jù)結(jié)構(gòu)所熟知的棧一樣,棧式存儲分配按照先進(jìn)后出的原則進(jìn)行分配。
靜態(tài)存儲分配要求在編譯時能知道所有變量的存儲要求,棧式存儲分配要求在過程的入口處必須知道所有的存儲要求,而堆式存儲分配則專門負(fù)責(zé)在編譯時或運(yùn)行時模塊入口處都無法確定存儲要求的數(shù)據(jù)結(jié)構(gòu)的內(nèi)存分配,比如可變長度串和對象實例.堆由大片的可利用塊或空閑塊組成,堆中的內(nèi)存可以按照任意順序分配和釋放.2.2 堆和棧的比較
上面的定義從編譯原理的教材中總結(jié)而來,除靜態(tài)存儲分配之外,都顯得很呆板和難以理解,下面撇開靜態(tài)存儲分配,集中比較堆和棧:
從堆和棧的功能和作用來通俗的比較,堆主要用來存放對象的，棧主要是用來執(zhí)行程序的.而這種不同又主要是由于堆和棧的特點決定的:在編程中，例如C/C++中，所有的方法調(diào)用都是通過棧來進(jìn)行的,所有的局部變量,形式參數(shù)都是從棧中分配內(nèi)存空間的。實際上也不是什么分配,只是從棧頂向上用就行,就好像工廠中的傳送帶(conveyor belt)一樣,Stack Pointer會自動指引你到放東西的位置,你所要做的只是把東西放下來就行.退出函數(shù)的時候，修改棧指針就可以把棧中的內(nèi)容銷毀.這樣的模式速度最快, 當(dāng)然要用來運(yùn)行程序了.需要注意的是,在分配的時候,比如為一個即將要調(diào)用的程序模塊分配數(shù)據(jù)區(qū)時,應(yīng)事先知道這個數(shù)據(jù)區(qū)的大小,也就說是雖然分配是在程序運(yùn)行時進(jìn)行的,但是分配的大小多少是確定的,不變的,而這個“大小多少”是在編譯時確定的,不是在運(yùn)行時.堆是應(yīng)用程序在運(yùn)行的時候請求操作系統(tǒng)分配給自己內(nèi)存，由于從操作系統(tǒng)管理的內(nèi)存分配,所以在分配和銷毀時都要占用時間，因此用堆的效率非常低.但是堆的優(yōu)點在于,編譯器不必知道要從堆里分配多少存儲空間，也不必知道存儲的數(shù)據(jù)要在堆里停留多長的時間,因此,用堆保存數(shù)據(jù)時會得到更大的靈活性。事實上,面向?qū)ο蟮亩鄳B(tài)性,堆內(nèi)存分配是必不可少的,因為多態(tài)變量所需的存儲空間只有在運(yùn)行時創(chuàng)建了對象之后才能確定.在C++中，要求創(chuàng)建一個對象時，只需用 new命令編制相關(guān)的代碼即可。執(zhí)行這些代碼時，會在堆里自動進(jìn)行數(shù)據(jù)的保存.當(dāng)然，為達(dá)到這種靈活性，必然會付出一定的代價:在堆里分配存儲空間時會花掉更長的時間！這也正是導(dǎo)致我們剛才所說的效率低的原因,看來列寧同志說的好,人的優(yōu)點往往也是人的缺點,人的缺點往往也是人的優(yōu)點(暈~).2.3 JVM中的堆和棧
JVM是基于堆棧的虛擬機(jī).JVM為每個新創(chuàng)建的線程都分配一個堆棧.也就是說,對于一個Java程序來說，它的運(yùn)行就是通過對堆棧的操作來完成的。堆棧以幀為單位保存線程的狀態(tài)。JVM對堆棧只進(jìn)行兩種操作:以幀為單位的壓棧和出棧操作。
我們知道,某個線程正在執(zhí)行的方法稱為此線程的當(dāng)前方法.我們可能不知道,當(dāng)前方法使用的幀稱為當(dāng)前幀。當(dāng)線程激活一個Java方法,JVM就會在線程的 Java堆棧里新壓入一個幀。這個幀自然成為了當(dāng)前幀.在此方法執(zhí)行期間,這個幀將用來保存參數(shù),局部變量,中間計算過程和其他數(shù)據(jù).這個幀在這里和編譯原理中的活動紀(jì)錄的概念是差不多的.從Java的這種分配機(jī)制來看,堆棧又可以這樣理解:堆棧(Stack)是操作系統(tǒng)在建立某個進(jìn)程時或者線程(在支持多線程的操作系統(tǒng)中是線程)為這個線程建立的存儲區(qū)域，該區(qū)域具有先進(jìn)后出的特性。
每一個Java應(yīng)用都唯一對應(yīng)一個JVM實例，每一個實例唯一對應(yīng)一個堆。應(yīng)用程序在運(yùn)行中所創(chuàng)建的所有類實例或數(shù)組都放在這個堆中,并由應(yīng)用所有的線程共享.跟C/C++不同，Java中分配堆內(nèi)存是自動初始化的。Java中所有對象的存儲空間都是在堆中分配的，但是這個對象的引用卻是在堆棧中分配,也就是說在建立一個對象時從兩個地方都分配內(nèi)存，在堆中分配的內(nèi)存實際建立這個對象，而在堆棧中分配的內(nèi)存只是一個指向這個堆對象的指針(引用)而已。
從上面的講述中大概理清了最初三個問，希望高人能再補(bǔ)充一些您覺得重要的知識點，謝謝！
第三篇：java web 文件上傳下載分析總結(jié)
個人理解：
上傳下載文件根本是對流的處理，最基礎(chǔ)的是不使用任何框架，直接對流進(jìn)行獲取和解析（對request.getInputStream()進(jìn)行解析處理）。
其次用一些框架進(jìn)行處理，目前文件上傳的(框架)組件： Apache—-fileuploadOrialiy – COS，Jsp-smart-upload。以fileupload為例，提供了工具類解析request，不需要自己去解析流。
最后是使用一些J2EE流行框架，使用框架內(nèi)部封裝好的來完成上傳下載。這些框架大體集成了fileupload等框架，在后者基礎(chǔ)上進(jìn)一步封裝，不需要處理request就獲取了封裝好的文件，只需處理封裝后的文件就可。
Struts2使用了fileupload,Springmvc則提供了commonsmultipartresolver進(jìn)行解析。
在開發(fā)過程中文件的上傳下載很常用。這里簡單的總結(jié)一下: 1.文件上傳必須滿足的條件:
a、頁面表單的method必須是post 因為get傳送的數(shù)據(jù)太小了 b、頁面表單的enctype必須是multipart/form-data類型的 c、表單中提供上傳輸入域
代碼細(xì)節(jié)：客戶端表單中:
第二步：遍歷list publicclassUp3ServletextendsHttpServlet { publicvoiddoPost(HttpServletRequest request, HttpServletResponse response)throwsServletException, IOException { request.setCharacterEncoding(”UTF-8“);String path = getServletContext().getRealPath(”/up“);//聲明disk
DiskFileItemFactory disk = newDiskFileItemFactory();disk.setSizeThreshold(1024*1024);disk.setRepository(new File(”d:/a“));//聲明解析requst的servlet
ServletFileUpload up = newServletFileUpload(disk);try{ //解析requst
List
List
String fileName = file.getName();fileName = fileName.substring(fileName.lastIndexOf(”“)+1);String fileType = file.getContentType();InputStream in = file.getInputStream();int size = in.available();//使用工具類
FileUtils.copyInputStreamToFile(in,new File(path+”/“+fileName));mm.put(”fileName“,fileName);mm.put(”fileType“,fileType);mm.put(”size“,”“+size);
ups.add(mm);file.delete();} request.setAttribute(”ups“,ups);//轉(zhuǎn)發(fā)
request.getRequestDispatcher(”/jsps/show.jsp“).forward(request, response);
}catch(Exception e){ e.printStackTrace();} } } 如上就是上傳文件的常用做法?，F(xiàn)在我們在來看看fileupload的其他查用API.判斷一個fileItem是否是file（type=file）對象或是text(type=text|checkbox|radio)對象： booleanisFormField()如果是text|checkbox|radio|select這個值就是true.6.處理帶說明信息的圖片
publicclassUpDescServletextendsHttpServlet { publicvoiddoPost(HttpServletRequest request, HttpServletResponse response)throwsServletException, IOException { request.setCharacterEncoding(”UTF-8“);//可以獲取中文的文件名 String path = getServletContext().getRealPath(”/up“);DiskFileItemFactory disk = newDiskFileItemFactory();disk.setRepository(new File(”d:/a“));try{ ServletFileUpload up = newServletFileUpload(disk);List
if(file.isFormField()){ String fileName = file.getFieldName();//=desc
String value = file.getString(”UTF-8“);//默認(rèn)以ISO方式讀取數(shù)據(jù)
System.err.println(fileName+”=“+value);}else{//說明是一個文件
String fileName = file.getName();fileName = fileName.substring(fileName.lastIndexOf(”“)+1);file.write(new File(path+”/“+fileName));System.err.println(”文件名是:“+fileName);System.err.println(”文件大小是：“+file.getSize());file.delete();} } }catch(Exception e){ e.printStackTrace();} } } 7.文件上傳的性能提升
在解析request獲取FileItem的集合的時候，使用: FileItemIterator it=up.getItemIterator(request);
比使用 List
性能上要好的多。示例代碼:
publicclassFastServletextendsHttpServlet {
publicvoiddoPost(HttpServletRequest request, HttpServletResponse response)throwsServletException, IOException { request.setCharacterEncoding(”UTF-8“);String path = getServletContext().getRealPath(”/up“);DiskFileItemFactory disk = newDiskFileItemFactory();disk.setRepository(new File(”d:/a“));try{ ServletFileUpload up = newServletFileUpload(disk);//以下是迭代器模式
FileItemIterator it= up.getItemIterator(request);while(it.hasNext()){ FileItemStream item = it.next();String fileName = item.getName();fileName=fileName.substring(fileName.lastIndexOf(”“)+1);InputStream in = item.openStream();FileUtils.copyInputStreamToFile(in,new File(path+”/“+fileName));} }catch(Exception e){ e.printStackTrace();}
} } 8.文件的下載
既可以是get也可以是post。
publicvoiddoPost(HttpServletRequestreq, HttpServletResponseresp)throwsServletException, IOException { req.setCharacterEncoding(”UTF-8“);String name = req.getParameter(”name“);//第一步：設(shè)置響應(yīng)的類型
resp.setContentType(”application/force-download“);//第二讀取文件
String path = getServletContext().getRealPath(”/up/“+name);InputStreamin = newFileInputStream(path);//設(shè)置響應(yīng)頭
//對文件名進(jìn)行url編碼
name = URLEncoder.encode(name, ”UTF-8“);resp.setHeader(”Content-Disposition“,”attachment;filename=“+name);resp.setContentLength(in.available());
//第三步：開始文件copy
OutputStreamout = resp.getOutputStream();byte[] b = newbyte[1024];intlen = 0;while((len=in.read(b))!=-1){ out.write(b,0,len);} out.close();in.close();}
在使用J2EE流行框架時，使用框架內(nèi)部封裝好的來完成上傳下載更為簡單: Struts2完成上傳.在使用Struts2進(jìn)行開發(fā)時，導(dǎo)入的jar包不難發(fā)現(xiàn)存在 commons-fileupload-1.3.1.jar 包。通過上面的學(xué)習(xí)我們已經(jīng)可以使用它進(jìn)行文件的上傳下載了。但Struts2在進(jìn)行了進(jìn)一步的封裝。view
Controller FileUploadActionextendsActionSupport { private String username;
//注意，file并不是指前端jsp上傳過來的文件本身，而是文件上傳過來存放在臨時文件夾下面的文件 private File file;
//提交過來的file的名字
//struts會自動截取上次文件的名字注入給該屬性 private String fileFileName;//getter和setter此時為了節(jié)約篇幅省掉 @Override
public String execute()throws Exception { //保存上傳文件的路徑
String root = ServletActionContext.getServletContext().getRealPath(”/upload“);//獲取臨時文件輸入流
InputStream is = newFileInputStream(file);//輸出文件
OutputStreamos = newFileOutputStream(new File(root, fileFileName));//打印出上傳的文件的文件名
System.out.println(”fileFileName: “ + fileFileName);
// 因為file是存放在臨時文件夾的文件，我們可以將其文件名和文件路徑打印出來，看和之前的fileFileName是否相同
System.out.println(”file: “ + file.getName());System.out.println(”file: “ + file.getPath());
byte[] buffer = newbyte[1024];int length = 0;
while(-1!=(length = is.read(buffer, 0, buffer.length))){ os.write(buffer);}
os.close();is.close();
return SUCCESS;} }
首先我們要清楚一點，這里的file并不是真正指代jsp上傳過來的文件，當(dāng)文件上傳過來時，struts2首先會尋找struts.multipart.saveDir(這個是在default.properties里面有)這個name所指定的存放位置(默認(rèn)是空)，我們可以在我們項目的struts2中來指定這個臨時文件存放位置。
如果沒有設(shè)置struts.multipart.saveDir，那么將默認(rèn)使用javax.servlet.context.tempdir指定的地址，javax.servlet.context.tempdir的值是由服務(wù)器來確定的，例如：假如我的web工程的context是abc，服務(wù)器使用Tomcat，那么savePath就應(yīng)該是%TOMCAT_HOME%/work/Catalina/localhost/abc_，臨時文件的名稱類似于upload__1a156008_1373a8615dd__8000_00000001.tmp，每次上傳的臨時文件名可能不同，但是大致是這種樣式。而且如果是使用Eclipse中的Servers里面配置Tomcat并啟動的話，那么上面地址中的%TOMCAT_HOME%將不會是系統(tǒng)中的實際Tomcat根目錄，而會是Eclipse給它指定的地址，例如我本地的地址是這樣的：/home/wang/EclipseJavaCode/.metadata/.plugins/org.eclipse.wst.server.core/tmp0/work/Catalina/localhost/abc/upload__1a156008_1373a8615dd__8000_00000001.tmp。Struts2完成下載.struts2的文件下載更簡單，就是定義一個輸入流，然后將文件寫到輸入流里面就行，關(guān)鍵配置還是在struts.xml這個配置文件里配置：
publicclassFileDownloadActionextendsActionSupport { //要下載文件在服務(wù)器上的路徑 private String path;//要下載文件的文件名
private String downloadFileName;//寫入getter和setter
publicInputStreamgetDownloadFile(){ return ServletActionContext.getServletContext().getResourceAsStream(path);} @Override
public String execute()throws Exception { //當(dāng)前action默認(rèn)在valuestack的棧頂 setDownloadFileName(xxx);return SUCCESS;} }
action只是定義了一個輸入流downloadFile，然后為其提供getter方法就行，接下來我們看看struts.xml的配置文件:
attachment;fileName=”${downloadFileName}“
downloadFile
struts.xml配置文件有幾個地方我們要注意，首先是result的類型，type一定要定義成stream類型_，告訴action這是文件下載的result，result元素里面一般還有param子元素，這個是用來設(shè)定文件下載時的參數(shù)，inputName這個屬性就是得到action中的文件輸入流，名字一定要和action中的輸入流屬性名字相同，然后就是contentDisposition屬性，這個屬性一般用來指定我們希望通過怎么樣的方式來處理下載的文件，如果值是attachment，則會彈出一個下載框，讓用戶選擇是否下載，如果不設(shè)定這個值，那么瀏覽器會首先查看自己能否打開下載的文件，如果能，就會直接打開所下載的文件，(這當(dāng)然不是我們所需要的)，另外一個值就是filename這個就是文件在下載時所提示的文件下載名字。在配置完這些信息后，我們就能過實現(xiàn)文件的下載功能了。
SpringMVC完成上傳：
view于struts2示例中的完全一樣。此出不在寫出。Controller: @Controller @RequestMapping(value=”fileOperate“)publicclassFileOperateAction { @RequestMapping(value=”upload“)public String upload(HttpServletRequest request,@RequestParam(”file“)MultipartFilephotoFile){ //上傳文件保存的路徑
String dir = request.getSession().getServletContext().getRealPath(”/“)+”upload“;//原始的文件名
String fileName = photoFile.getOriginalFilename();//獲取文件擴(kuò)展名
String extName = fileName.substring(fileName.lastIndexOf(”.“));//防止文件名沖突，把名字小小修改一下
fileName = fileName.substring(0,fileName.lastIndexOf(”.“))+ System.nanoTime()+ extName;FileUtils.writeByteArrayToFile(new File(dir,fileName),photoFile.getBytes());return”success“;} }
SpringMVC完成下載：
@RequestMapping(”/download“)public String download(String fileName, HttpServletRequest request, HttpServletResponse response){ response.setCharacterEncoding(”utf-8“);response.setContentType(”multipart/form-data“);response.setHeader(”Content-Disposition“, ”attachment;fileName=“
+ fileName);try { InputStreaminputStream = newFileInputStream(new File(文件的路徑);
OutputStreamos = response.getOutputStream();byte[] b = newbyte[2048];int length;while((length = inputStream.read(b))>0){ os.write(b, 0, length);}
// 這里主要關(guān)閉。
os.close();
inputStream.close();} catch(FileNotFoundException e){ e.printStackTrace();} catch(IOException e){ e.printStackTrace();} // 返回值要注意，要不然就出現(xiàn)下面這句錯誤！
//java+getOutputStream()has already been called for this response returnnull;}
另附Spring mvc的三種上傳文件方法
前臺：
<%@ page language=”java“contentType=”text/html;charset=utf-8“
pageEncoding=”utf-8“%>
第四篇：java總結(jié)
調(diào)用父類構(gòu)造方法
? 在子類的構(gòu)造方法中可使用super(argument_list)語句調(diào)用父類的構(gòu)造方法
? 如果子類的構(gòu)造方法中沒有顯示地調(diào)用父類構(gòu)造方法，也沒有使用this關(guān)鍵字調(diào)用重載的其它構(gòu)造方法，則系統(tǒng)默認(rèn)調(diào)用父類無參數(shù)的構(gòu)造方法
? 如果子類構(gòu)造方法中既未顯式調(diào)用父類構(gòu)造方法，而父類中又沒有無參的構(gòu)造方法，則編譯出錯
1public class Person {
3private String name;
4private int age;private Date birthDate;
7public Person(String name, int age, Date d){ 8this.name = name;
9this.age = age;
10this.birthDate = d;
11}
12public Person(String name, int age){ 13this(name, age, null);
14}
15public Person(String name, Date d){ 16this(name, 30, d);
17}
18public Person(String name){
19this(name, 30);}
21// ……
22}
1public class Student extends Person {
2private String school;
4public Student(String name, int age, String s){ 5super(name, age);
6school = s;
7}
8public Student(String name, String s){
9super(name);
10school = s;
11}
12public Student(String s){ // 編譯出錯: no super()13school = s;
14}
15}
對象構(gòu)造和初始化細(xì)節(jié)
? 分配存儲空間并進(jìn)行默認(rèn)的初始化
? 按下述步驟初始化實例變量
1.綁定構(gòu)造方法參數(shù)
2.如有this()調(diào)用，則調(diào)用相應(yīng)的重載構(gòu)造方法，然后跳轉(zhuǎn)到步驟5
3.顯式或隱式追溯調(diào)用父類的構(gòu)造方法(Object類除外)
4.進(jìn)行實例變量的顯式初始化操作
5.執(zhí)行當(dāng)前構(gòu)造方法的方法體
==操作符與equals方法
==操作符與equals方法的區(qū)別：
? 引用類型比較引用；基本類型比較值；
? equals()方法只能比較引用類型，“==”可以比較引用類型及基本類型；
? 特例：當(dāng)用equals()方法進(jìn)行比較時，對類File、String、Date及封裝類（Wrapper Class）來說，是比較類型及內(nèi)容而不考慮引用的是否是同一個實例；
? 用“==”進(jìn)行比較時，符號兩邊的數(shù)據(jù)類型必須一致(可自動轉(zhuǎn)換的基本數(shù)據(jù)類型除外)，否則編譯出錯；
由裝箱引發(fā)的——Integer比較的來龍去脈
前置知識： 眾所周之，java是保留了int，char等基本數(shù)據(jù)類型的，也就是說int類型的并不是對象，然而有些方法卻需要object 類型的變量，所以java使用了裝箱機(jī)制，我們可一自豪的這樣聲明一個整型變量：Integer a = new Integer(10);那么整型的a也就是對象了，那這句是什么意思呢：Integer a= 10;java中可以這樣聲明一個對象嗎？當(dāng)然不是，從jdk1.5后，java實現(xiàn)了自動裝箱，也就是自動將Integer a =10 中的int類型的10轉(zhuǎn)化為了 Integer類型。好，有了前面的只是我們且先看一個題目：
Integer a = 127;
Integer b = 127;
Integer c = 128;
Integer d = 128;
System.out.println(a==b);
System.out.println(c==d);
答案是什么呢？ 如果您回答true，false，那么很遺憾的告訴你，哈哈，其實你答對了！！
那我們暈了就相差1的兩個數(shù)為啥走向了“反目成仇”的地步呢？憑啥127等于127，我128就不等于128呢？且聽我慢慢道來，Integer a =127,Integer a=128。
127，128應(yīng)該不會造成什么差異吧，難道是自動裝箱的過程有貓膩？找下源碼看看：
private static class IntegerCache {
private IntegerCache(){}
static final Integer cache[] = new Integer[-(-128)+ 127 + 1];static {
for(int i = 0;i < cache.length;i++)
cache[i] = new Integer(i128);
}
這是用一個for循環(huán)對數(shù)組cache賦值，cache[255] = new Integer(255-128),也就是newl一個Integer(127),并把引用賦值給cache[255],好了，然后是Integer b= 127,流程基本一樣，最后又到了cache[255] = new Integer(255-128),這一句，那我們迷糊了，這不是又new了一個對象127嗎，然后把引用賦值給cache[255]，我們比較這兩個引用（前面聲明a的時候也有一個）,由于是不同的地址，所以肯定不會相等，應(yīng)該返回false?。『呛?，這么想你就錯了，請注意看for語句給cache[i]初始化的時候外面還一個{}呢，{}前面一個大大的static關(guān)鍵字大咧咧的杵在哪呢，對靜態(tài)的，那么我們就可以回想下static有什么特性了，只能初始化一次，在對象間共享，也就是不同的對象共享同一個static數(shù)據(jù)，那么當(dāng)我們Integer b = 127的時候，并沒有new出一個新對象
來，而是共享了a這個對象的引用，記住，他們共享了同一個引用?。?，那么我們進(jìn)行比較a==b時，由于是同一個對象的引用（她們在堆中的地址相同），那當(dāng)然返回true了?。?/p>
然后我們在看Integer c = 128;Integer d = 128;這兩句?，F(xiàn)在不用我說就應(yīng)該能明白了吧，當(dāng)數(shù)據(jù)不再-128到127之間時，是不執(zhí)行return
IntegerCache.cache[i + offset];這句的，也就是不會返回一個static的引用，而是執(zhí)行了return new Integer(i);于是當(dāng) Integer d = 128 時，又會重新返回一個引用，兩個不同的引用
在做c==d 的比較時當(dāng)然返回false了！
下面附上本程序的字節(jié)碼以供喜歡底層的讀者參考：
Compiled from “CompareInteger.java”
public class CompareInteger extends java.lang.Object{
public CompareInteger();
Code:
0:aload_0
1:invokespecial#1;//Method java/lang/Object.“
public static void main(java.lang.String[]);
Code:
0:bipush 127
2:invokestatic#2;//Method
java/lang/Integer.valueOf:(I)Ljava/lang/Int
eger;
5:astore_1
6:bipush 127
8:invokestatic#2;//Method
java/lang/Integer.valueOf:(I)Ljava/lang/Int
eger;
11: astore_2
12: sipush 128
15: invokestatic#2;//Method
java/lang/Integer.valueOf:(I)Ljava/lang/Int
eger;
18: astore_3
19: sipush 128
22: invokestatic#2;//Method
java/lang/Integer.valueOf:(I)Ljava/lang/Int
eger;
25: astore 4
27: getstatic#3;//Field
java/lang/System.out:Ljava/io/PrintStream;
30: aload_1
31: aload_2
32: if_acmpne39
35: iconst_1
36: goto40
39: iconst_0
40: invokevirtual#4;//Method java/io/PrintStream.println:(Z)V43: getstatic#3;//Field
java/lang/System.out:Ljava/io/PrintStream;
46: aload_3
47: aload4
49: if_acmpne56
52: iconst_1
53: goto57
56: iconst_0
57: invokevirtual#4;//Method java/io/PrintStream.println:(Z)V60: return
}
評論：呵呵，這么想你就錯了，請注意看for語句給cache[i]初始化的時候外面還一個{}呢，{}前面一個大大的static關(guān)鍵字大咧咧的杵在哪呢，對靜態(tài)的，那么我們就可以回想下static有什么特性了，只能初始化一次，在對象間共享，也就是不同的對象共享同一個static數(shù)據(jù)，那么當(dāng)我們Integer b = 127的時候，并沒有new出一個新對象來，而是共享了a這個對象的引用，記住，他們共享了同一個引用?。?/p>
呵呵，博主我被你這句話小小的誤導(dǎo)了一下，其實你這里說的原理沒錯，但是把位置說錯了，這段代碼只是初始化cache：
static {
for(int i = 0;i < cache.length;i++)
cache[i] = new Integer(i-128);
}
但真正讓cache[i]為static變量的是這句代碼：
static final Integer cache[] = new Integer[-(-128)+ 127 + 1];
第五篇：Java總結(jié)
Java實驗
1.調(diào)試HelloWorld程序
2.this,super,get ,set,把課本90頁程序4.7中的name改成私有變量
3.繼承，重寫，父類引用指向子類對象
4.驗證數(shù)組Arrays類和Collection類
5.編寫一個自己的異常類并捕獲之。
6.編寫一個類，將該類的幾個對象裝入TreeSet容器中，并將該容器的內(nèi)容通過輸出流寫入文件中。
前三章重點
0.java的數(shù)據(jù)類型：四類八種-（1）布爾類型Boolean;(2)字符類型char;(3)整數(shù)byte,short,int,long;(4)浮點類型：float,double;1.面向?qū)ο蟮?個基本特征：封裝，繼承，多態(tài)。
2.構(gòu)造方法和普通方法的區(qū)別：對構(gòu)造方法而言，它有以下特性---（1）方法名必須與要創(chuàng)建對象的類名相同。（2）不允許聲明返回類型，即使聲明為void也不被允許。
3.this關(guān)鍵字:是一個引用，this引用指向的是其本身所在方法的當(dāng)前對象。this的使用方法:(1)調(diào)用成員變量；（2）可以用this()調(diào)用其他構(gòu)造函數(shù)。
4.java中只對類成員變量進(jìn)行自動初始化，而方法內(nèi)部的局部變量在使用前必須手動初始化。
5.static 關(guān)鍵字：可用來修飾類的成員變量和成員方法，需要注意兩點--（1）靜態(tài)方法不能調(diào)用類的非靜態(tài)方法，不能訪問類的非靜態(tài)變量。（2）靜態(tài)方法和靜態(tài)變量（非私有的）可以有兩種調(diào)用方式，一是實例對象調(diào)用，二是類名直接調(diào)用。
6.類成員訪問控制修飾符public、private、default(可不寫，即缺省狀態(tài))、protected的使用：public-公用的；private-私有的，只在定義它的類內(nèi)部使用；default-可以被同一包中的類訪問；protected-既可以被同一包中的類訪問，也可以被不在同一包中的子類訪問。
7.方法的重載：指方法名相同，而方法的參數(shù)列表不相同。參數(shù)列表不同有三層意思：（1）參數(shù)類型不同。（2）參數(shù)順序不同。（3）參數(shù)個數(shù)不同。另外需注意，在同一個類中，當(dāng)方法名和參數(shù)列表都相同時，訪問控制修飾符或方法返回類型不相同并不是方法的重載，而且這種情況在java中是不被允許的。
第四五章重點
1.繼承：需使用關(guān)鍵字extends.在使用繼承時需注意--（1）每個子類只能定義一個超類（父類），即extends后面應(yīng)且僅應(yīng)跟一個類名作為該類的父類。（2）父類中的私有屬性和私有方法不能被繼承。
2.方法的重寫：即子類對超類中的方法保持方法名、返回類型和參數(shù)列表不變，重寫了方法體，使子類和超類完成不同的工作。重寫需注意下面幾個關(guān)鍵點：（1）超類中的私有方法不能被重寫。（2）訪問限制符強(qiáng)度由低到高依次是：public、protected、default、private,在重寫過程中，如果子類和父類中方法的返回值、方法名及方法的參數(shù)列表都相同，這時，要求子類中該方法的訪問限制符強(qiáng)度不能超過父類的。即如果父類中為public時，子類也只能為public,而不能是余下的三種。
3.重載（overload）和覆蓋（override）的區(qū)別：(1)重載—發(fā)生在一個類的內(nèi)部或子類與父類之間，要求方法名相同而參數(shù)列表不一樣。（2）覆蓋—只能發(fā)生在繼承過程中，要求子類方法的返回類型，方法名和參數(shù)列表同父類的都相同，而方法體不一樣。
4.構(gòu)造器的調(diào)用順序：先祖先，再客人，最后自己。
5.多態(tài)：指在類繼承中子類和父類中可以有同名但意義或?qū)崿F(xiàn)方式不同的屬性和方法。分為：覆蓋和重載。多態(tài)的優(yōu)點：因為多態(tài)，可以在程序中對類進(jìn)行擴(kuò)展，而不需改變那些操作基類接口的方法。
6.動態(tài)綁定：指在代碼執(zhí)行期間，判斷所引用對象的實際類型，根據(jù)其實際類型調(diào)用相應(yīng)方法。動態(tài)綁定存在的三個必要條件--（1）要有繼承；（2）要有重寫（覆蓋）；（3）父類引用指向子類對象（向上轉(zhuǎn)型）。
7.Object中常用的方法總結(jié)：toString();wait();equals();notify();notifyAll();hashCode();getClass();clone();finalize();（呵呵，盡可能記幾個，以防老師讓咱們列舉）注：java中Object類是所有類的父類，即java中所有的類都有上述9種方法。
8.對象的比較：注意關(guān)鍵字instanceof的使用。
9.抽象類：
抽象方法—用關(guān)鍵字abstract修飾的方法，該方法只需方法的聲明，而不需方法的實現(xiàn)（即無方法體）。
抽象類——至少包含一個抽象方法的類，也用abstract關(guān)鍵字聲明。（注：（1）抽象類中可以有一些具體方法。（2）抽象類不能實例化。（3）子類繼承抽象類必須實現(xiàn)其抽象方法。）
10.接口：
（1）可以看成是高度抽象的抽象類，但是接口不是類。
（2）用關(guān)鍵字interface來聲明接口，用關(guān)鍵字imlpements來實現(xiàn)接口。
（3）接口不能有具體方法，不能有實例數(shù)據(jù)，但可以定義常量。
（4）實現(xiàn)接口的非抽象類必須實現(xiàn)接口的所有方法。
（5）每個類可以實現(xiàn)多個接口，這些接口用逗號隔開，同時，一個接口可以被多個類實現(xiàn)。
第六章：重點看一下實驗四
1.容器——Collection(接口)和Map（接口）.Collection——Set(接口)和List(接口)。其中，List必須保持元素的特定順序，常見的實現(xiàn)類有ArrayList和LinkedList；Set不能有重復(fù)元素,常見的實現(xiàn)類有HashSet和TreeSet。
Map——一組成對的“鍵值對”對象，即其元素是成對的對象，常見的實現(xiàn)類有HashMap和TreeMap。
第七章 1.異常類的根類是Throwable類，它的兩個直接子類是Error類和Exception類。
2.異常中常用的5個關(guān)鍵字為：try,catch,finally,throw,throws.其中，try和catch:用于捕獲異常；finally:無論try塊中的異常是否拋出，finally中的代碼塊總能被執(zhí)行；throw:拋出異常；throws：聲明異常。
3.“未被檢查的異常（Unchecked Exceptions）”和“受檢查的異常(Checked Exceptions)”——
Unchecked Exceptions :編譯器不檢查方法是否處理或拋出的異常，即不做處理，編譯時不報錯。
Checked Exceptions：受編譯器檢查的異常，即不做處理編譯時通不過。
4.常見的幾種Checked Exceptions：ClassNotFoundExceptionIOExceptionInterruptedExceptionFileNotFoundException.(盡可能的記幾個吧，以防不測)第八章
1.流--字節(jié)流和字符流；
流--節(jié)點流和處理流。
2.所有的輸入流都是從抽象類InputStream和Reader繼承而來。所有輸出流都是從抽象類OutputStream和Writer繼承而來。3．字節(jié)流：InputStream和OutputStream;字符流：Reader和Writer；
4.節(jié)點流：直接與文件等底層打交道，如FileInputStreamFileOutputStreamFileReaderFileWriter.處理流：相當(dāng)于包裝流，套在節(jié)點流上，方便數(shù)據(jù)處理。相關(guān)一些用法，具體參考最后一次實驗。
點擊咨詢 