第一篇：java總結-2011-12-7

一、面向對象的語言特性： 封裝，多態，繼承

二、hashtable和hashmap的區別：

hashtable是dictionary的子類，hashmap是map接口中的一個實現類

hashtable中的方法是同步的，hashmap中的方法在缺省情況下是非同步的 hashmap允許將null作為key值或value值，hashtable不允許

三、方法重寫和方法重載的區別：

方法重載：方法名相同，參數不同。重載時權限沒有嚴格要求。發生在同一個類中。可以改變返回值類型 方法重寫：方法名相同，參數相同。重寫時被重寫的方法不能擁有更嚴格的權限。重寫發生在繼承類中

四、面向對象的具體特征： 封裝性，多態性，繼承性

封裝的目的是：高內聚，低耦合

五、什么是多態性：

多態性就是“一種接口，多種方法”，可以為一組相關的動作設計一個通用的接口。重載就是一種多態

六、String和StringBuffer的區別： String類是一個final類，一旦生成對象便不可一改變它的值，如果改變這個對象則相當于生成了一個新的對象。

StringBuffer類則可以創建和操作動態字符串，系統可以自動的為對象擴展內存以容納新增的文本。

String 是一個只讀的，不可改變的。StringBuffer是可變的。

StringBuffer中的函數length()只是代表其中的字符串的長度，而capcity()代表了StringBuffer的真正長度。

StringBuffer的字符串內容即使和String的相同，他們兩者也不能用==比較，必須將StringBuffer用toString()轉化后才能相等

七、JSP頁面的對象有哪些？四個作用域分別是什么？ 九大對象：

Page

頁面對象 Request

請求對象 Session

會話對象

Application

應用程序對象 Response

響應對象 Out

輸出對象 Config

配置對象

Pagecontext

頁面上下文對象 Exception

例外對象、四個作用域： Page Request Session Application

八、JSP的兩種跳轉方式，及其區別 服務器端跳轉：在服務器內部完成的跳轉，可能有多個資源參與一個請求的處理 重定向：在客戶端完成的跳轉，每次訪問都是一個請求，請求一次響應一次，一個資源參與一個請求的處理。

九、vector，linkedlist，arraylist的區別：

ArrayList底層采用數組完成，而LinkedList是以雙向鏈表完成的

ArrayList在遍歷時的性能高于LinkedList，但是LinkedList在增加，刪除時的性能高于ArrayList Vector的方法都是多線程安全的，而ArrayList的方法則是非多線程安全的

十、寫出五個常見的異常：

ArithmeticException

運算異常；NullPointerExcetion

空指針異常；

ClassCastException

強制轉換異常；IndexOutOfBoundsException 索引越界異常；

BufferOverFlowException

緩沖區限制異常

十一、map，list，set的區別：

List是有序可重復的；set是無序不可重復的；map是鍵值形式的，一個key對應一個value

十二、equles和==的區別：

“==”表示的數值的比較，對象引用的比較 “equals”是對象的引用的值的比較

基本數據類型進行==比較時，只是比較兩個變量的值。

十三、Collection與Collections的區別：

Collection是java.util下的接口，它是各種集合的父接口。Collections是java.util下的類，是針對集合的幫助類，提供一系列靜態方法實現對各種集合的搜索、排序、線程安全化等操作。

十四、session和request的會話區別：

Request范圍是請求級別的范圍，客戶端發送一次請求服務器響應一次，request對象只在本次請求中有效

Session范圍是會話級別，一次會話可能有多次請求

十五、public，private，proceted的作用域：

Public：同一個類，一個包中的不同類，不同包中的父類，不同包中的不同類 Private：同一個類

Proceted：同一個，一個包中的不同類，不同包中的父類

十六、&與&&的區別：

&是位運算符，表示按位與；&&是邏輯運算符，表示and

十七、運行時異常和一般異常有何異同：

Java編譯器要求方法必須聲明拋出可能發生的非運行時異常，但并不要求必須拋出未捕獲的運行時異常

十八、final，finally，finalize的區別：

Final用于聲明屬性，方法和類，分別表示屬性不可變，方法不可覆蓋，類不可繼承。

Finally 是異常處理語句結構的一部分，表示總是執行 Finalize 是object類的一個方法

十九、正則的功能：

測試字符串的某個模式；替換文本

二十、最有效率的算出2乘以8等于幾的方法： 2<<3 二十一、八種基本數據類型： 字符型：char(16)整型：byte(8)，short(16)，int(32)，long(64)浮點型：float(32)，double(64)布爾型：boolean Java中，整型默認的是int，浮點型默認的是double，boolean型默認的是false 基本數據對應的類型我們稱為包裝類，char-character,int-Integer,double-Double,long-Long,float-Float 二

十二、servlet的生命周期：

事物的生命周期指的是從事物的產生，生存，發展到消亡的過程。

init()調用一次，一般第一次訪問Servlet時調用。默認調用有參數的，除非只有無參數的。

service()調用多次，每次訪問時調用。

destroy()調用一次，應用程序關閉時調用

二十三、抽象類和接口的區別：

1、abstract class在java中表示一種繼承關系，一個類只能使用一次繼承關系。但是一個類可以實現多個接口interface。

2、在abstract class中可以有自己的數據成員，也可以有非abstract的成員方法，而在interface中，只能有靜態的不能被修改的數據成員，所有的成員方法都是abstract的

3、Abstract class和interface所反映的設計理念不同。Abstract class表示的是“is-a”的關系；interface表示的是“like-a”的關系

4、實現抽象類和接口的類必須實現其中的所有方法。抽象類中可以有非抽象方法。接口中不能有實現方法。

5、接口中定義的變量默認是public static final 類型，且必須給其初值，所以實現類中不能重新定義，也不能改變其值。

6、抽象類中的變量默認是friendly類型，其值可以在子類中重新定義，也可以重新賦值。

7、接口中的方法默認都是public，abstract類型的。

第二篇：JAVA總結專題

在這忙忙碌碌的這段時間里，經過老師的輔導，迅速的將一點沒有學的JAVA基礎搞定了！有了基礎學習還是好，萬事開頭難這句話說的太對了，學計算機語言我覺得記憶好的方法就是多打代碼，課前預習，課堂上認真聽講，把現學的方法把以前所做的作業用最簡便的方法再一次鞏固，創新最重要，在后續的學習中，得要加倍努力學習。

其實學java有不懂，要先自己思考。想清楚這句代碼是什么意思。為什么要寫在這，等等之類的。等你真的搞不明白的時候，就一定要向老師咨詢，不要感到有什么丟人的。因為不會是很正常的事。并不是每個人都是天才，一學就會，一學就能運用自如的。學java有一點是非常重要的，就是練習。一段代碼要不停的敲，多敲幾遍，尤其是自己不熟悉或者不熟練的代碼，更要敲。不要感覺到厭煩，其實我感覺敲代碼挺好玩的，并不是一件很枯燥的事。

老師平常布置的課后上機練習題一定要做，課后的練習題能夠讓你把新學到的知識鞏固一遍，能夠加深記憶，不會讓你在以后做題的時候感到沒一點思路。

當感覺到不會的時候，千萬不要氣餒，因為這很正常，現在的學習就是為了培養你有一個邏輯思維，為了以后開發軟件的時候有個完整，清晰的思路。

其實，總體來說。學習java很快樂。尤其是當你遇到一道自己不會的題，然后，又通過自己的努力解決了，那時候，那種心情不是用言語來表達的。就好像你遇到一個數學難題，自己解決了之后那種成就感一樣。

學java的時候一定要，放松心情，輕輕松松的來學，隨時讓自己快樂著，這樣能夠讓你能夠更快的接受java，千萬不要有什么心理負擔，因為java的特點之一就是--簡單易懂。只要自己努力到了，就一定能夠學好java。

學完了JAVA今天我們用項目案例：迷你DVD管理器來鞏固了我們所學的所有內容，通過這項目的操練，首先，1、項目用到了會使用順序、分支、循環、跳轉語句編寫程序，2、要會使用數組、操作字符串，3、會使用帶參的方法；

4、會定義類、創建和使用對象，看到這些腦袋里一片迷茫啊！不知道怎樣寫，然后想到早寫晚寫都一樣，就照著書上寫起來了，到現在還是弄不懂的就是那個對象數組，不知道怎樣去理解，抽象的把我抽暈了，有望老師來給我們補補這一章，在實現DVD的業務處理時，計算時差還是不懂，照著書上打了一遍，可還是得不到想要的結果，經過網上的搜尋與老師講解，現在已略懂一二了，在做完這項目后，真不知道當時是怎樣敲出來的，難道這就是所說的靈感！感覺很高興，現在已習慣了代碼報錯，其實代碼報錯是一件值得鼓勵的事，因為沒有錯就覺得自己什么都懂了，在學習中相信每一個人都遇到過挫折吧！但一定要想方法戰勝挫折！我的戰勝挫折方法就是不懂思考后還不懂就問，懂了以后就筆記本記下當時的解決方案！學習剛開始！后面的路很長，慢慢的去磨煉了！總結完畢！

第三篇：Java總結

Java實驗

1.調試HelloWorld程序

2.this,super,get ,set,把課本90頁程序4.7中的name改成私有變量

3.繼承，重寫，父類引用指向子類對象

4.驗證數組Arrays類和Collection類

5.編寫一個自己的異常類并捕獲之。

6.編寫一個類，將該類的幾個對象裝入TreeSet容器中，并將該容器的內容通過輸出流寫入文件中。

前三章重點

0.java的數據類型：四類八種-（1）布爾類型Boolean;(2)字符類型char;(3)整數byte,short,int,long;(4)浮點類型：float,double;1.面向對象的3個基本特征：封裝，繼承，多態。

2.構造方法和普通方法的區別：對構造方法而言，它有以下特性---（1）方法名必須與要創建對象的類名相同。（2）不允許聲明返回類型，即使聲明為void也不被允許。

3.this關鍵字:是一個引用，this引用指向的是其本身所在方法的當前對象。this的使用方法:(1)調用成員變量；（2）可以用this()調用其他構造函數。

4.java中只對類成員變量進行自動初始化，而方法內部的局部變量在使用前必須手動初始化。

5.static 關鍵字：可用來修飾類的成員變量和成員方法，需要注意兩點--（1）靜態方法不能調用類的非靜態方法，不能訪問類的非靜態變量。（2）靜態方法和靜態變量（非私有的）可以有兩種調用方式，一是實例對象調用，二是類名直接調用。

6.類成員訪問控制修飾符public、private、default(可不寫，即缺省狀態)、protected的使用：public-公用的；private-私有的，只在定義它的類內部使用；default-可以被同一包中的類訪問；protected-既可以被同一包中的類訪問，也可以被不在同一包中的子類訪問。

7.方法的重載：指方法名相同，而方法的參數列表不相同。參數列表不同有三層意思：（1）參數類型不同。（2）參數順序不同。（3）參數個數不同。另外需注意，在同一個類中，當方法名和參數列表都相同時，訪問控制修飾符或方法返回類型不相同并不是方法的重載，而且這種情況在java中是不被允許的。

第四五章重點

1.繼承：需使用關鍵字extends.在使用繼承時需注意--（1）每個子類只能定義一個超類（父類），即extends后面應且僅應跟一個類名作為該類的父類。（2）父類中的私有屬性和私有方法不能被繼承。

2.方法的重寫：即子類對超類中的方法保持方法名、返回類型和參數列表不變，重寫了方法體，使子類和超類完成不同的工作。重寫需注意下面幾個關鍵點：（1）超類中的私有方法不能被重寫。（2）訪問限制符強度由低到高依次是：public、protected、default、private,在重寫過程中，如果子類和父類中方法的返回值、方法名及方法的參數列表都相同，這時，要求子類中該方法的訪問限制符強度不能超過父類的。即如果父類中為public時，子類也只能為public,而不能是余下的三種。

3.重載（overload）和覆蓋（override）的區別：(1)重載—發生在一個類的內部或子類與父類之間，要求方法名相同而參數列表不一樣。（2）覆蓋—只能發生在繼承過程中，要求子類方法的返回類型，方法名和參數列表同父類的都相同，而方法體不一樣。

4.構造器的調用順序：先祖先，再客人，最后自己。

5.多態：指在類繼承中子類和父類中可以有同名但意義或實現方式不同的屬性和方法。分為：覆蓋和重載。多態的優點：因為多態，可以在程序中對類進行擴展，而不需改變那些操作基類接口的方法。

6.動態綁定：指在代碼執行期間，判斷所引用對象的實際類型，根據其實際類型調用相應方法。動態綁定存在的三個必要條件--（1）要有繼承；（2）要有重寫（覆蓋）；（3）父類引用指向子類對象（向上轉型）。

7.Object中常用的方法總結：toString();wait();equals();notify();notifyAll();hashCode();getClass();clone();finalize();（呵呵，盡可能記幾個，以防老師讓咱們列舉）注：java中Object類是所有類的父類，即java中所有的類都有上述9種方法。

8.對象的比較：注意關鍵字instanceof的使用。

9.抽象類：

抽象方法—用關鍵字abstract修飾的方法，該方法只需方法的聲明，而不需方法的實現（即無方法體）。

抽象類——至少包含一個抽象方法的類，也用abstract關鍵字聲明。（注：（1）抽象類中可以有一些具體方法。（2）抽象類不能實例化。（3）子類繼承抽象類必須實現其抽象方法。）

10.接口：

（1）可以看成是高度抽象的抽象類，但是接口不是類。

（2）用關鍵字interface來聲明接口，用關鍵字imlpements來實現接口。

（3）接口不能有具體方法，不能有實例數據，但可以定義常量。

（4）實現接口的非抽象類必須實現接口的所有方法。

（5）每個類可以實現多個接口，這些接口用逗號隔開，同時，一個接口可以被多個類實現。

第六章：重點看一下實驗四

1.容器——Collection(接口)和Map（接口）.Collection——Set(接口)和List(接口)。其中，List必須保持元素的特定順序，常見的實現類有ArrayList和LinkedList；Set不能有重復元素,常見的實現類有HashSet和TreeSet。

Map——一組成對的“鍵值對”對象，即其元素是成對的對象，常見的實現類有HashMap和TreeMap。

第七章 1.異常類的根類是Throwable類，它的兩個直接子類是Error類和Exception類。

2.異常中常用的5個關鍵字為：try,catch,finally,throw,throws.其中，try和catch:用于捕獲異常；finally:無論try塊中的異常是否拋出，finally中的代碼塊總能被執行；throw:拋出異常；throws：聲明異常。

3.“未被檢查的異常（Unchecked Exceptions）”和“受檢查的異常(Checked Exceptions)”——

Unchecked Exceptions :編譯器不檢查方法是否處理或拋出的異常，即不做處理，編譯時不報錯。

Checked Exceptions：受編譯器檢查的異常，即不做處理編譯時通不過。

4.常見的幾種Checked Exceptions：ClassNotFoundExceptionIOExceptionInterruptedExceptionFileNotFoundException.(盡可能的記幾個吧，以防不測)第八章

1.流--字節流和字符流；

流--節點流和處理流。

2.所有的輸入流都是從抽象類InputStream和Reader繼承而來。所有輸出流都是從抽象類OutputStream和Writer繼承而來。3．字節流：InputStream和OutputStream;字符流：Reader和Writer；

4.節點流：直接與文件等底層打交道，如FileInputStreamFileOutputStreamFileReaderFileWriter.處理流：相當于包裝流，套在節點流上，方便數據處理。相關一些用法，具體參考最后一次實驗。

第四篇：java總結

調用父類構造方法

? 在子類的構造方法中可使用super(argument_list)語句調用父類的構造方法

? 如果子類的構造方法中沒有顯示地調用父類構造方法，也沒有使用this關鍵字調用重載的其它構造方法，則系統默認調用父類無參數的構造方法

? 如果子類構造方法中既未顯式調用父類構造方法，而父類中又沒有無參的構造方法，則編譯出錯

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}

對象構造和初始化細節

? 分配存儲空間并進行默認的初始化

? 按下述步驟初始化實例變量

1.綁定構造方法參數

2.如有this()調用，則調用相應的重載構造方法，然后跳轉到步驟5

3.顯式或隱式追溯調用父類的構造方法(Object類除外)

4.進行實例變量的顯式初始化操作

5.執行當前構造方法的方法體

==操作符與equals方法

==操作符與equals方法的區別：

? 引用類型比較引用；基本類型比較值；

? equals()方法只能比較引用類型，“==”可以比較引用類型及基本類型；

? 特例：當用equals()方法進行比較時，對類File、String、Date及封裝類（Wrapper Class）來說，是比較類型及內容而不考慮引用的是否是同一個實例；

? 用“==”進行比較時，符號兩邊的數據類型必須一致(可自動轉換的基本數據類型除外)，否則編譯出錯；

由裝箱引發的——Integer比較的來龍去脈

前置知識： 眾所周之，java是保留了int，char等基本數據類型的，也就是說int類型的并不是對象，然而有些方法卻需要object 類型的變量，所以java使用了裝箱機制，我們可一自豪的這樣聲明一個整型變量：Integer a = new Integer(10);那么整型的a也就是對象了，那這句是什么意思呢：Integer a= 10;java中可以這樣聲明一個對象嗎？當然不是，從jdk1.5后，java實現了自動裝箱，也就是自動將Integer a =10 中的int類型的10轉化為了 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的兩個數為啥走向了“反目成仇”的地步呢？憑啥127等于127，我128就不等于128呢？且聽我慢慢道來，Integer a =127,Integer a=128。

127，128應該不會造成什么差異吧，難道是自動裝箱的過程有貓膩？找下源碼看看：

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循環對數組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的時候也有一個）,由于是不同的地址，所以肯定不會相等，應該返回false啊！呵呵，這么想你就錯了，請注意看for語句給cache[i]初始化的時候外面還一個{}呢，{}前面一個大大的static關鍵字大咧咧的杵在哪呢，對靜態的，那么我們就可以回想下static有什么特性了，只能初始化一次，在對象間共享，也就是不同的對象共享同一個static數據，那么當我們Integer b = 127的時候，并沒有new出一個新對象

來，而是共享了a這個對象的引用，記住，他們共享了同一個引用！！，那么我們進行比較a==b時，由于是同一個對象的引用（她們在堆中的地址相同），那當然返回true了！！

然后我們在看Integer c = 128;Integer d = 128;這兩句。現在不用我說就應該能明白了吧，當數據不再-128到127之間時，是不執行return

IntegerCache.cache[i + offset];這句的，也就是不會返回一個static的引用，而是執行了return new Integer(i);于是當 Integer d = 128 時，又會重新返回一個引用，兩個不同的引用

在做c==d 的比較時當然返回false了！

下面附上本程序的字節碼以供喜歡底層的讀者參考：

Compiled from “CompareInteger.java”

public class CompareInteger extends java.lang.Object{

public CompareInteger();

Code:

0:aload_0

1:invokespecial#1;//Method java/lang/Object.“”:()V4:return

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關鍵字大咧咧的杵在哪呢，對靜態的，那么我們就可以回想下static有什么特性了，只能初始化一次，在對象間共享，也就是不同的對象共享同一個static數據，那么當我們Integer b = 127的時候，并沒有new出一個新對象來，而是共享了a這個對象的引用，記住，他們共享了同一個引用！！

呵呵，博主我被你這句話小小的誤導了一下，其實你這里說的原理沒錯，但是把位置說錯了，這段代碼只是初始化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個人總結參考

1、Java中取消指針運算防止了內存泄露的可能性。Java中的引用其實就是指針。JAVA語言不支持C++友元方法或友類。

2、編寫完java源代碼后，首先將其編譯為一種中間狀態字的字節碼，然后Java虛擬機上的解釋器來解釋執行，“一次編程，到處運行”，Java是文本文件，編輯代碼。

3、Window系統對于DOS命令中字符大小寫不敏感；Java編譯器和解釋器對大小寫敏感；保存源文件時，文件名一定要和源文件中公開類的類名一致。

4、習慣上，變量名以小寫字母開頭，類名以大寫字母開頭，常量名中所有的字符均大寫。

5、final常量：初始化后不再重新賦值，在類繼承時不允許子類覆蓋。

6、類實例化就成為對象。

7、類繼承：繼承父類的屬性和方法（關鍵字extends）

定義抽象類：關鍵字abstract

類聲明：P62

類成員：P63

8、Java接口中聲明了一組抽象方法，它構成了實現該接口的不同類共同遵守的約定。在類的定義中可以用關鍵字implements來指定其實現的接口。

9、Java接口與類的重要區別：Java接口中不存在構建器。

10、包的作用（P105）；Java中類的訪問控制符（P77）；操作符優先級（P38）

11、包的命名：網絡域名的逆序

包的使用：關鍵字import

12、異常處理（P119.120.125）：FileNotFoundException：代表文件未找到；SQLException：代表有關JDBC的異常；NullPointerException：表示試圖引用null對象的方法或屬性；IndexOutOfBoundException：表示數組越界的異常。

13、框架的默認關閉程序：f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

14、setIconImage用于設定框架的圖標；setLocation用于設定框架在屏幕上的位置。

15、取得框架的內容窗格：Container contentPane=f.getContnetPane();

16、面板的默認布局管理器是FlowLayout。setBownds(x,y,w,h)設置x，y坐標以及寬和高

17、內容窗格的默認布局管理器是邊框布局（BorderLayout）

18、網格布局（GridLayout）將容器劃分為大小相同的網格。

19、網格袋布局（GridBagLayout）是最靈活，也是最復雜的布局管理器。20、對話框 P180

showMessageDialog：消息對話框

showInputDialog：輸入對話框

showConfirmDialog：確認對話框

showOptionDialog：選項對話框

21、類File有三種常用構建器：

File（String fileName）

File（String directory ,String fileName）File（File directory ,String fileName）

22、位于java.io包中的類包含兩組獨立的類層次結構：一個用于讀取字節，成為字節流；一個用于讀寫字符，稱為字符流。區別在于它們處理數據的方式，字節流按字節（一個8位組）來處理。字節流（P243）字符流（P245）

23、System.in 表示系統標準輸入流，指向鍵盤輸入；System.out 表示系統標準輸出流，指向屏幕輸出；System.err 表示系統標準錯誤輸出流，指向屏幕輸出；

24、文件的讀寫工作包括三個步驟：①、打開文件輸入流或輸出流；②、文件讀或寫操作；③、關閉文件輸入流或輸出流；

25、定制線程類：①、繼承線程類Thread；②、實現Runnable接口；

#約定俗成的命名規則#

1、類名首字母必須大寫

2、方法和屬性必須小寫

3、由多個單詞組成的類名或方法必須采用駝峰標識

如：類名：StudentAdmin 方法或屬性：studentName

*Equal 匹配

*equalIgnoreCase 匹配時忽略大小寫 *Indexof 包含

*getMetaDate 獲取元數據 *精度轉換

*面向對象三大特性：封裝、繼承、多態 *界面邏輯、業務邏輯、數據邏輯 *三層架構總結：

1、開發人員可以只關注整個結構中的其中某一層

2、可以很容易用新的實現來替換原有層次的實現

3、可以降低層與層之間的依賴

4、有利于標準化

5、利于各層邏輯的復用