第一篇：Java基礎學習知識點總結

黑馬程序員_畢向東_Java基礎視頻教程

Java基礎學習知識點總結 2016年01月06日

day01

一、基礎知識：軟件開發

1、什么是軟件？軟件：一系列按照特定順序組織的計算機數據和指令的集合。

2、常見的軟件：系統軟件：如：DOS，Windows，Linux等。應用軟件：如：掃雷，迅雷，QQ等。

3、什么是開發？制作軟件。

二、基礎知識：人機交互方式

4、軟件的出現實現了人與計算機之間的更好的交互。

5、交互方式：圖形化界面：這種方式簡單直觀，使用者易于接受，容易上手操作。命令行方式：需要有一個控制臺，輸入特定的指令，讓計算機完成一些特定的操作。較為麻煩，需要記錄住一些命令。

三、基礎知識：常用的DOS命令

6、點擊開始在運行欄輸入“cmd”進入dos操作界面。

7、課程中常見的命令：

dir：列出當前目錄下的文件以及文件夾。md：創建目錄。rd：刪除目錄。

cd：進入指定目錄。d：進入盤符。cd..：退回到上一級目錄。cd/：退回到根目錄。del：刪除文件。

exit：退出dos命令行。

8、在dos命令行操作文件夾時，如忘記文件夾全稱，可以輸文件夾前幾個名稱后面用*代替。

四、基礎知識：計算機語言

9、通過DOS命令行的演示，發現原來操作計算機就如同和計算機說話一樣。

10、我們告訴它做什么，它就可以做什么。前提是，我們和它說的內容它必須識別才可以。這就是計算機語言。

11、什么是計算機語言？語言：是人與人之間用于溝通的一種方式。例如：中國人與中國人用中文溝通。而中國人要和韓國人交流，就要學習韓語。

12、計算機語言：人與計算機交流的方式。如果人要與計算機交流，那么就要學習計算機語。計算機語言有很多種，如：C，C++，Java等。這里，我們選擇其中一種：Java語言。

五、基礎知識：Java語言介紹

13、Java語言概述。是SUN（Stanford University Network，斯坦福大學網絡公司）1995年推出的一門高級編程語言。是一種面向Internet的編程語言。隨著Java技術在Web方面的不斷成熟，已經成為Web應用程序的首選開發語言。是簡單易學，完全面向對象，安全可靠，與平臺無關的編程語言。

14、Java語言的三種技術架構。J2EE（Java 2 Platform Enterprise Edition）企業版（現更名：JAVAEE）：是為開發企業環境下的應用程序提供一套解決方案。該技術體系中包含的技術如Servlet Jsp等，主要針對于Web應用程序開發。J2SE（Java 2 Platform Standard Edition）標準版（現更名：JAVASE）：是為開發普通桌面和商務應用程序提供的解決方案。該技術體系是其他兩者的基礎，可以完成一些桌面應用程序的開發。比如Java版的掃雷。J2ME（Java 2 Platform Micro Edition）小型版（現更名：JAVAME）：是為開發電子消費產品和嵌入式設備提供的解決方案。該技術體系主要應用于小型電子消費類產品，如手機中的應用程序等。

15、Java語言的特點：跨平臺性。什么是跨平臺性？通過Java語言編寫的應用程序在不同的系統平臺上都可以運行。原理是什么？只要在需要運行Java應用程序的操作系統上，先安裝一個Java虛擬機（JVM Java Virtual Machine）即可。由JVM來負責Java程序在該系統中的運行。

16、Java語言的特點：跨平臺性。Java程序：Windows系統：Win版的JVM；Linux系統：lin版的JVM；MAC系統：mac版的JVM。因為有了JVM，所以同一個Java程序在三個不同的操作系統中都可以執行。這樣就實現了Java程序的跨平臺性。也稱為Java具有良好的可移植性。

六、基礎知識：Java語言的環境搭建

17、明確什么是JRE，JDK；下載JDK；安裝JDK；配置環境變量；驗證是否成功。

18、什么是JRE，JDK？JRE（Java Runtime Environment Java運行環境）：包括Java虛擬機（JVM Java Virtual Machine）和Java程序所需的核心類庫等，如果想要運行一個開發好的Java程序，計算機中只需要安裝JRE即可。JDK（Java Development Kit Java開發工具包）：JDK是提供給Java開發人員使用的，其中包含了Java的開發工具，也包括了JRE。所以安裝了JDK，就不用再單獨安裝JRE了。其中的開發工具：編譯工具（java.exe）打包工具（jar.exe）等。簡單而言：使用JDK開發完成的Java程序，交給JRE去運行。

19、Java6.0 Platform

20、下載JCK（Java Development Kit Java開發工具包）。官方網址：www.tmdps.cn、java.sun.com。下載完成后，安裝在電腦上。然后打開DOS命令行，效驗文件是否安裝完畢，并利用DOS進行Javac.exe運行測試。為了更方便的使用Java開發工具，需要進行環境變量配置。配置成功后就可以進行Java程序的開發了。

21、環境變量配置。方法一：圖形界面操作。我的電腦——屬性——高級——環境變量；編輯Path環境變量，在變量值開始處加上Java工具所在目錄，后面用分號和其他值分隔開即可；打開DOS命令行，任意目錄下敲入javac；如果出現javac的參數信息，配置成功。這種配置方式，一勞永逸。具體流程：右鍵點擊我的電腦打開屬性，點擊高級系統設置，點擊高級，點擊環境變量，找到系統變量，新建系統變量（變量名：JAVA_HOME，變量值：安裝JKD的地址。如：D:ProgramStudioJDK1.7）點擊確定，找到變量名為Path的變量，點擊編輯，在變量值欄的最前面（放到前面時，先尋找）加入%JAVA_HOME%bin用分號隔開。方法二：DOS界面操作（可用于臨時環境變量配置，借助別人的電腦開發Java程序）。具體流程：利用set命令：設置、查看環境變量的值。Set path：查看path的值。配置Java工具包：set path=D:ProgramStudioJDK1.7bin;%path%回車。測試javac。只對當前窗口有效。定義class路徑：Set classpath=.;c:myclass。

七、基礎知識：Java程序開發體驗

22、Hello World。將Java代碼編寫到擴展名為.java的文件中；通過javac命令對該java文件進行編譯；通過java命令對生成的class文件進行運行。Java文件——javac.exe編譯——class文件——java運行——結果。

23、對于初學者，可以用記事本編寫。按部就班，一步一步寫代碼。打開記事本。Java代碼是以類的形式來體現的。代碼如下： class TestFirstOne //Java定義類+類名（首字母大寫）{ public static void main(String[] args)//主函數（保證類的獨立運行）

{

System.out.println(“hello world”);//輸出打印語句

} }

23、classpath配置。臨時配置方式：dos配置。Set Classpath=代碼路徑。回車。Classpath先在環境變量中找，然后在當前路徑（結尾沒帶分號不找）。Path先在當前路徑查找，然后去環境變量中查找。一勞永逸方法和上面JDK環境變量配置方法一樣。

24、Hello World組成部門。class是java程序中的關鍵字（關鍵字只能是小寫）。{}類的區間用大括號定義（類中的內容為了增加閱讀性，需要有階梯感，如使用tab鍵）。public static void main(String[] args)定義主函數（使用大括號確定函數的內容）。

25、注釋。三種方式：//單行注釋，符號以后直到回車鍵的內容；/*多行注釋，符號開始到符號結束以內的內容*/；/**java注釋符號，可被提取出來制作軟件開發手冊*/。注釋的作用：增加程序的閱讀性；調試程序。

26、寫代碼要養成寫注釋的習慣。在寫代碼前注釋相關信息。例如： /* 需求：定義一個Hello World小程序。思路： 1，2，步驟：

1，通過class關鍵字定義一個類。將代碼都編寫到該類中。

2，為了保證該的獨立運行。在類中定義個主函數。格式public static void main(String[] args)3，保存成一個擴展名為java的文件。

4，在dos控制臺中通過javac工具對java文件進行編譯。5，在通過java命令對生成的class文件進行執行。作者：ZC 版本：v1.0 日期：2016.01.06 copyright：ZC */ 2016年01月07日

day02

一、基礎知識：Java語言基礎組成

1、組成：關鍵字、標識符、注釋、常量和變量、運算符、語句、函數、數組

二、基礎知識：關鍵字

2、關鍵字的定義和特點：定義：被Java語言賦予了特殊含義的單詞。特點：關鍵字中所有字母都為小寫。

3、用于定義數據類型的關鍵字：class、interface、byte、short、int、long、float、double、char、boolean、void。

4、用于定義數據類型值的關鍵字：true、false、null。

5、用于定義流程控制的關鍵字：if、else、switch、case、default、while、do、for、break、continue、return。

6、用于定義訪問權限修飾的關鍵字：private、protected、public。

7、用于定義類，函數，變量修飾的關鍵字：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個英文字母大小寫，數字：0-9，符號_$組成；定義合法標識符規則：數字不可以開頭、不可以使用關鍵字；Java中嚴格區分大小寫；注意：在起名時，為了提高閱讀性，要盡量有意義。

14、Java中的名稱規范：包名：多單詞組成時所有都小寫，如：xxxyyyzzz；類名接口名：多單詞組成時，所有單詞的首字母大寫，如：XxxYyyZzz；變量名和函數名：多單詞組成時，第一個單詞首字母小寫，第二個單詞開始每個單詞首字母大寫，如：xxxYyyZzz；常量名：所有字母都大寫，多單詞時每個單詞用下劃線連接，如：XXX_YYY_ZZZ。

四、基礎知識：注釋

15、注釋：對于單行和多行注釋，被注釋的文字，不會被JVM（Java虛擬機）解釋執行；對于文檔注釋，是Java特有的注釋，其中注釋內容可以被JDK提供的工具javadoc所解析，生成一套以網頁文件形式體現的該程序的說明文檔；注釋是一個程序員必須要具有的良好編程習慣；初學者編寫程序可以養成習慣；先寫注釋再寫代碼；將自己的思想通過注釋先整理出來，再用代碼去體現；因為代碼僅僅是思想的一種體現形式而已；用于注解說明解釋程序的文字就是注釋；提高了代碼的閱讀性。

16、Java中的注釋格式：單行注釋：格式：//注釋文字；多行注釋：格式：/*注釋文字*/；文檔注釋：格式：/**注釋文字*/。

五、基礎知識：常量

17、常量表示不能改變的數值。

18、Java中常量的分類：整數常量：所有整數；小數常量：所有小數；布爾型常量：較為特有，只有兩個數值：true和false；字符常量：將一個數字字母或者符號用單引號（’’）標識；字符串常量：將一個或者多個字符用雙引號（””）標識；null常量：只有一個數值就是null。

19、對于整數：Java有三種表現形式：十進制：0-9，滿10進1；八進制：0-7，滿8進1，用0表示開頭；十六進制：0-9，A-F，滿16進1，用0x開頭表示。

六、基礎知識：進制轉換

20、進制的轉換特點：八位二進制表示一個字節（基本的數據單元）。三個二進制位表一個八進制位。四個二進制位表示一個十六進制位。ASCII碼編碼表。

21、二進制和十進制之間的轉換：十進制轉二進制：原理：對十進制數進行除2運算（除二取余法）；二進制轉十進制：原理：二進制乘以2的N次的過程。

22、快捷方法：8421法則。

23、負數的二進制表現形式：對應的正數二進制取反加1。負數的最高位都是1。

七、基礎知識：變量

24、變量的概念：內存中的一個存儲區域；該區域有自己的名稱（變量名）和類型（數據類型）；該區域的數據可以在同一類型范圍內不斷變化；理解：變量就如同數學中的未知數；變量：就是將不確定的數據進行存儲，也就是需要在內存中開辟一個空間。

25、為什么要定義變量：用來不斷的存放同一類型的常量，并可以重復使用。

26、使用變量注意：變量的作用范圍（一對{}之間有效）；初始化值。

27、定義變量的格式：數據類型變量名=初始化值；注：格式是固定的、記住格式，以不變應萬變。

28、Java語言是強類型語言，對于每一種數據都定義了明確的具體數據類型，在內存總分配了不同打小的內存空間。數據類型：基本數據類型（數值型（整數類型（byte，short，int，long）；浮點類型（float，double））；字符型（char）；布爾型（boolean））；引用數據類型（類（class）；接口（interface）；數據（[]））。注意：整數默認：int，小數默認：double。

29、數據類型空間：byte 8位二進制（一個8位二進制或1個字節）；short 16位二進制（二個8位二進制或2個字節）；int 32位二進制（四個8位二進制或4個字節）；long 64位二進制（八個8位二進制或8個字節）；float（單精度）32位二進制（四個8位二進制或4個字節）；double（雙精度）64位二進制（八個8位二進制或8個字節）；char 取值：0-65535；boolean取值：true，false。

30、類型轉換。不同類型的數據不能進行運算。需要進行數據類型提升，從小往大提升，自動數據類型提升。強制類型轉換：格式：變量=（類型名）（需轉換的數據）；什么時候使用強制轉換：如：小數保留整數部分。

31、表達式的數據類型自動提升：所有的byte型、short型和char的值將被提升到int型；如果一個操作數是long型，計算結果就是long型；如果一個操作數是float型，計算結果就是float型；如果一個操作數是double型，計算結果就是double型。分析：system.out.println（‘a’）與system.out.println（‘a’+1）的區別。

八、基礎知識：運算符

32、算數運算符：+正號，-負號，+加，-減，*乘，/除，%取模，++自增（前），++自增（后），--自減（前），--自減（后），+字符串相加（字符串數據和任何數據使用+都是相連接，最終都會變成字符串）。

33、轉義字符：通過 來轉變后面字母或者符號的含義。在Linux系統中換行是一個字符來表示n，windows系統中，換行由nr實現。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的移動的位數次冪；>>：就是除以2的移動的位數次冪。>>：最高位補什么由原有數據的最高位值而定；如果最高位0，右移后，用0補空位；如果最高位1，右移后，用1補空位。>>>：無論最高位是什么，右移后，都用0補。一個數異或同一個數兩次，結果還是拿個數。

38、三元運算符：格式：（條件表達式）？表達式1：表達式2；如果條件為true，運算后的結果是表達式1；如果條件為false，運算后的結果是表達式2。如：獲取兩個數中大數，int x=3,y=4,z;z=(x>y)?x:y//z變量存儲的就是兩個數的大數。

九、基礎知識：if語句

39、程序流程控制：順序結構，判斷結構，選擇結構，循環結構。

40、判斷結構：if語句三種格式：一層判斷：if(條件表達式){執行語句;}；兩層判斷：if(條件表達式){執行語句;}else{執行語句;}；多層判斷：if(條件表達式){執行語句;}else if(條件表達式){執行語句;}else{執行語句;}。

41、if else結構間歇格式：變量=（條件表達式）？表達式1：表達式2；三元運算符：好處：可以簡化if else代碼；弊端：因為是一個運算符，所以運算完畢需要有一個結果。

42、解決DOS命令下，編譯無法識別GDK碼方法：方法一：使用-encoding參數指明編碼方式：javac-encoding UTF-8 XX.java。方法二：保存java文件時，選擇編碼格式為ANSI。

十、基礎知識：switch語句

43、選擇結構：switch語句：格式：switch(表達式){case 取值1：執行語句；break；case 取值2：執行語句；break；??default：執行語句；//break；}

44、switch（表達式）：表達式只接收四種類型：byte，short，int，char。

45、if語句與switch語句的區別：if除了能判斷數值，還能判斷具體區間，switch判斷區間很累；對于數字是布爾型時，只有if能判斷。

46、if語句與switch語句的用法：如果要對具體數字進行判斷，數值不多，而且符合byte、short、int、char這四種類型，雖然兩個語句都可以使用，建議用switch完成。因為效率稍高。其他情況一般用if。當結果為布爾型或區間時，用if完成。If的使用范圍更廣。2016年01月08日day03

一、基礎知識：while語句

1、循環結構：代表語句：while、do while、for。

2、while語句格式：while（條件表達式）{執行語句；}。

3、do while語句格式：do{執行語句；}while（條件表達式）。Do while特點是條件無論是否滿足，循環體至少被執行一次。

4、while和do while的區別：while：先判斷條件，只有條件滿足才執行循環體。do while：先執行循環體，再判斷條件，條件滿足，再繼續執行循環體。簡單一句話：do while：無論條件是否滿足，循環體至少執行一次。

二、基礎知識：for語句

5、for語句格式：for（初始化表達式；循環條件表達式；循環后的操作表達式）{執行語句；}。注意：a：for里面的連個表達式運行的順序，初始化表達式只讀一次，判斷循環條件，為真就執行循環體，然后再執行循環后的操作表達式，接著繼續判斷循環條件，重復找個過程，直到條件不滿足為止。b：while與for可以互換，區別在于for為了循環而定義的變量在for循環結束就是在內存中釋放。而while循環使用的變量在循環結束后還可以繼續使用。c：最簡單無限循環格式：while（true），for（；；），無限循環存在的原因是并不知道循環多少次，而是根據某些條件，來控制循環。

6、for和while的區別：a：變量有自己的作用域。對于一個變量來將，如果這個變量僅僅用于控制循環的次數，用作循環增量時用for語句。循環結束時，該變量在內存被釋放。用于優化內存。b：for和while可以進行互換，如果定義循環增量，用for更為合適。

7、什么時候使用循環結構？當要多某些語句執行很多次時，就是用循環結構。

8、循環注意：一定要明確哪些語句需要參與循環，哪些不需要。

9、兩種思想：累加思想：原理：通過變量記錄住每次變化的結果。通過循環的形式，進行累加動作。計數器思想：原理：通過一個變量記錄住數據的狀態變化。也通過循環完成。

10、循環嵌套：語句嵌套形式，其實就是語句中含有語句。

11、其他流程控制語句：break（跳出），continue（繼續）。Break語句：應用范圍：選擇結構和循環結構。Continue語句：應用于循環結構。注意：a：這兩個語句離開應用范圍，存在是沒有意義的。b：這兩個語句單獨存在下面都不可以有語句，因為執行不到。c：continue語句是結束本次循環繼續下次循環。d：標號的出現，可以讓這兩個語句作用于指定的范圍。

12、注意：標號只能用于循環語句上，給循環起名字。

13、continue：只能作用于循環結構。繼續循環。特點：結束本次循環，繼續下一次循環。

14、總結：a：break和continue語句作用的范圍。b：break和continue單獨存在時，下面可以有任何語句。因為都執行不到。

三、基礎知識：函數

15、函數的定義：什么是函數？函數就是定義在類中的具有特定功能的一段獨立小程序；函數也稱為方法。

16、函數的格式：修飾符返回值類型函數名（參數類型形式參數1，參數類型形式參數2，?）{執行語句；return返回值；}。返回值類型：函數運行后的結果的數據類型。參數形式：是形式參數的數據類型。形式參數：是一個變量，用于存儲調用函數時傳遞給函數的實際參數。實際參數：傳遞給形式參數的具體數值。Return：用于結束函數。返回值：該值會返回給調用者。

17、函數的特點：定義函數可以將功能代碼進行封裝；便于對該功能進行復用；函數只有被調用才會被執行；函數的出現提高了代碼的復用性；對于函數沒有具體返回值的情況，返回值類型用關鍵字void表示，那么該函數中的return語句如果在最后一行可以省略不寫。注意：函數中只能調用函數，不可以在函數內部定義函數；定義函數時，函數的結果應該返回給調用者，交由調用者處理。

18、重點：函數的應用。如何定義一個函數呢？a：既然函數是一個獨立的功能，那么該功能的運算結果是什么先明確。因為這是在明確函數的返回值類型。b：再明確在定義該功能的過程中是否需要未知的內容參與運算。因為是在明確函數的參數列表（參數的類型和參數的個數）。

19、函數的重載（overload）：重載的概念：在同一個類中，允許存在一個以上的同名函數，只要它們的參數個數或者參數類型不同即可。重載的特點：與返回值無關，只看參數列表。重載的好處：方便與閱讀，優化了程序設計。重載示例：//返回兩個整數的和int add(int x,int y){return x+y;}；//返回三個整數的和int add(int x,int y,int z){return x+y+z;}；//返回兩個小數的和double add(double x,double y){return x+y;}。

20、什么時候用重載？當定義的功能相同，但參與運算的未知內容不同。那么，這時就定義一個函數名稱以表示其功能，方便閱讀，而通過參數列表的不同來區分多個同名函數。

四、基礎知識：數組

21、數組的定義：概念：同一種數據類型的集合。其實數組就是一個容器。數組的好處：可以自動給數組中的元素從0開始編號，方便操作這些元素。關鍵字：new：用來在內存中產生一個容器實體。格式一：元素類型[]數組名=new元素類型[元素個數或數組長度]；示例：int [] arr=new int[5]；格式二：元素類型[]數組名=new元素類型[]{元素，元素，?}；示例：int[] arr=new int[]{3,5,1,7}；int[] arr={3,5,1,7}。

22、內存結構：Java程序在運行時，需要在內存中分配空間。為了提高運行效率，又對空間進行了不同區域的劃分，因為每一片區域都有特定的處理數據方式和內存的管理方式。A：棧內存（棧區）：用于存儲局部變量，當數據使用完，所占空間會自動釋放。B：堆內存（堆區）：數組和對象，通過new建立的實例都存放在堆內存中。每一個實體都有內存地址。實體中的變量都有默認初始化值。實體不在被使用，會在不確定的時間內被垃圾回收器回收。C：方法區，本地方法區，寄存器。2016年01月09日

day04

一、基礎知識：數組

1、獲取數組中的元素。通常會用到遍歷。

2、數組中有一個屬性可以直接獲得到數組元素個數。length。使用方式：數組名稱.length。

3、數組排序：選擇排序：內循環結束一次，最值出現頭角標位置。冒泡排序：第一圈：最值出現在了最后位。

4、java中排序工具：import.java.util.*；Array.sort(arr)。java中已經定義好的一種排序方式。開發中，對數組排序，要使用該句代碼。

5、二維數組：數組中的數組：格式一：int[][] arr=new int[3][2]；定義了名稱為arr的二維數組；二維數組中有3個一維數組；每一個一維數組中有2個元素；一維數組的名稱分別為arr[0]，arr[1]，arr[2]；給第一個一維數組1腳標位賦值為78寫法是：arr[0][1]=78。格式二：int[][] arr=new int[3][]；二維數組中有3個一維數組；每個一維數組都是默認初始值null；可以對這個三個一維數組分別進行初始化：arr[0]=new int[3]；arr[1]=new int[1]；arr[2]=new int[2]。

2016年01月10日

day05

一、面向對象：概述

1、理解面向對象：面向對象是相對面向過程而言；面向對象和面向過程都是一種思想；面向過程：強調的是功能行為；面向對象：將功能封裝進對象，強調了具備了功能的對象；面向對象是基于面向過程的。讓我們的角色從執行者變為指揮者。面向過程是面向對象的基礎。

2、一切皆對象，境界：萬物皆對象。

3、寫程序時：先考慮對象。有對象時，直接用。沒對象時，自己造一個對象。

4、人開門：名稱提煉法。事物：人、門。示例：人{開門（門）{門。開（）；}}；門{開（）{操作門軸等。}}。

5、面向對象的三個特征：封裝，繼承，多態。

6、以后的開發：其實就是找對象使用。沒有對象，就創建一個對象。

7、找對象，建立對象，使用對象，維護對象的關系。

8、類和對象的關系：類就是：對現實生活中事物的描述。對象：就是這類事物，實實在在的個體。映射到java中，描述就是class定義的類。具體對象就是對于java在堆內存中用new建立實體。

9、類與對象示例：圖紙：汽車，汽車，汽車。可以理解為：類就是圖紙；汽車就是堆內存中的對象。

10、描述事物其實就在是描述事物的屬性和行為。

11、屬性對應是類中的變量，行為對應的類中的函數（方法）。其實定義類，就是在描述事物，就是在定義屬性和行為。屬性和行為共同成為類中的成員（成員變量和成員函數（方法））。

12、引用變量：類類型變量。記住：類類型變量指向對象。

13、就需要該對象做使用，在java指揮方式是：對象.對象成員。

14、成員變量和局部變量：作用范圍：成員變量作用于整個類中。局部變量作用于函數中，或者語句中。在內存中的位置：成員變量：在堆內存中，因為對象的存在，才在內存中存在。局部變量：存在棧內存中。

15、匿名對象：匿名對象是對象的簡化形式；匿名對象兩種使用情況：當對對象方法僅進行一次調用的時；匿名對象可以作為實際參數進行傳遞。

二、面向對象：封裝

16、封裝的定義：是指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式。

17、封裝的好處：將變化隔離；便于使用；提高重用性；提高安全性。

18、封裝原則：將不需要對外提供的內容隱藏起來；把屬性都隱藏，提供公共方法對其訪問。

19、函數是最小的封裝體；類是較小的封裝體；包是中級封裝體；框架是較大的封裝體。20、關鍵字private：私有，權限修飾符：用于修飾類中的成員（成員變量，成員函數）。在類中隱藏。私有只在本類中有效。

21、注意：私有僅僅是封裝的一種表現形式。

22、之所以對外提供訪問方式，就是因為可以在訪問方式中加入邏輯判斷語句。對訪問的數據進行操作。提高代碼健壯性。

23、關鍵字private：將成員變量私有化。對外提供對應的set，get方法對其進行訪問。提高對數據訪問的安全性。

三、面向對象：構造函數

24、構造函數的特點：函數名與類名相同；不用定義返回值類型；不可以寫return語句。

25、構造函數的作用：給對象進行初始化。注意：默認構造函數的特點；多個構造函數是以重載的形式存在的。

26、構造函數：對象一建立就會調用與之對應的構造函數。構造函數的作用：可以用于給對象進行初始化。

27、構造函數的小細節：當一個類中沒有定義構造函數時，那么系統會默認給該類假如一個空參數的構造函數。當在類中自定義了構造函數后，默認的構造函數就沒有了。

28、構造函數和一般方法（函數）的區別：A：構造函數和一般函數在寫法上有不同。B：在運行上也有不同。構造函數是在對象一建立就運行。就對象初始化。而一般方法是對象調用才執行，是給對象添加對象具備的功能。C：一個對象建立，構造函數只運行一次。而一般方法可以被該對象調用多次。

29、什么時候定義構造函數呢：當分析事物時，該事物存在具備一些特征或者行為，那么將這些內容定義在構造函數中。30、構造代碼塊：作用：給對象進行初始化。對象一建立就運行，而且優先于構造函數執行。

31、構造代碼塊和構造函數區別：構造代碼塊是給所有對象進行統一初始化，而構造函數是給對應的對象進行初始化。

32、構造代碼塊中定義的是不同對象共性的初始化內容。

四、面向對象：this關鍵字

33、關鍵字this：看上去，是用于區分局部變量和成員變量同名情況。

34、關鍵字this的特點：就代表本類的對象，到底代表哪一個呢？this代表它所在函數所屬對象的引用。簡單說：哪個對象在調用this所在的函數，this就代表哪個對象。

35、this的應用：當定義類中功能時，該函數內部要用到該函數的對象時，這時用this來表示這個對象。但凡本類功能內部使用到了本類對象，都用this代替。

36、this語句：用于構造函數之間函數互相調用。this語句：只能定義在構造函數的第一行。因為初始化要先執行。

37、this語句只能用于構造函數間，不能用于一般函數。

2016年01月11日

day06

一、面向對象：static關鍵字

1、static（靜態）關鍵字：用于修飾成員（成員變量和成員函數）。被修飾后的成員具備以下特點：隨著類的加載而加載；優先于對象存在；被所有對象所共享；可以直接被類名調用。使用注意：靜態方法只能訪問靜態成員；靜態方法中不可以寫this，super關鍵字；主函數是靜態的。

2、用法：是一個修飾符，用于修飾成員（成員變量，成員函數）。當成員被靜態修飾后，就多了一個調用方式，除了可以被對象調用外，還可以直接被類名用。類名.成員變量。

3、實例變量和類變量的區別：A，存放位置：類變量隨著類的加載而存在于方法區中。實例變量隨著對象的建立存在于堆內存中。B，生命周期：類變量生命周期最長，隨著類的消失而消失。實例變量隨著對象的消失而消失。

4、靜態使用注意事項：A，靜態方法只能訪問靜態成員。非靜態方法既可以訪問靜態也可以訪問非靜態。B，靜態方法中不可以定義thsi，super關鍵字。因為靜態優先于對象存在，所有靜態方法中不可以出現this。C，主函數是靜態的。

5、靜態優缺點：優：對對象的共享數據進行單獨空間的存儲，節省空間。沒有必要每個對象中都存儲一份。可以直接被類名調用。缺：生命周期過長。訪問出現局限性。（靜態雖好，只能訪問靜態。）

6、public static void main(String[] args)主函數：是一個特殊的函數，作用程序的入口，可以被jvm調用。

7、主函數的定義：public：代表著該函數訪問權限是最大的。static：代表主函數隨著類的加載就已經存在了。void：代表主函數沒有具體的返回值。main：不是關鍵字，但是是一個特殊的單詞，可以被jvm識別。（String[] args）：函數的參數，參數類型是一個數組，該數組中的元素是字符串。字符串類型的數組。

8、主函數是固定格式的：jvm識別。jvm在調用主函數時，傳人的是new String[0]。

9、什么時候使用靜態？要從兩方面下手：因為靜態修飾的內容有成員變量和函數。什么時候定義靜態變量（類變量）呢？當對象中出現共享數據時，該數據靜態所修飾。對象中的特有數據要定義成非靜態存在于堆內存中。

10、什么時候定義靜態函數呢？當功能內部沒有訪問到非靜態數據（對象的特有數據），那么該功能可以定義成靜態的。

11、靜態的應用：A每一個應用程序中都有共性的功能，可以將這些功能進行抽取，獨立封裝。以便復用。B雖然可以通過建立ArrayTool的對象使用這些工具方法，對數組進行操作。但是：1，對象是用于封裝數據的，可以ArrayTool對象并未封裝特特有數據。2，操作數組的每一個方法都沒有用到ArrayTool對象中的特有數據。C這時就考慮，讓程序更嚴謹，是不需要對象的。可以將ArrayTool中的方法都定義成static的，直接通過類名調用即可。D將方法都靜態后，可以方便于使用，但是該類還是可以被其他程序建立對象的。為了更為嚴謹，強制讓該類不能建立對象。可以通過將構成函數私有化完成。

12、接下來，將ArrayTool.class文件發送給其他人，其他人只要將該文件設置到classpath路徑下，就可以使用該工具類。但是，很遺憾，該類中到底定義了多少個方法，對方不清楚。因為該類并沒有使用說明書。開始制作程序的說明書。java的說明書通過文檔注釋來完成。

13、注釋符號：/***/；@author作者；@version版本；@param參數；@return返回值。

14、靜態代碼塊。格式：static{靜態代碼塊中的執行語句。}。

15、靜態代碼塊的特點：隨著類的加載而執行，只執行一次,并優先于主函數。用于給類進行初始化的。

16、重點：對象的初始化過程：Person p=new Person(“zhangsan”,20);該句話都做了什么事情？A因為new用到了Person。Class。所有會先找到Person。Class文件并加載到內存中。B執行該類中的static代碼塊，如果有的話，給Person.class類進行初始化。C在堆內存中開辟空間，分配內存地址。D在堆內存中建立對象的特有屬性，并進行默認初始化。E對屬性進行顯示初始化。F對對象進行構造代碼塊初始化。G對對象進行對應的構造函數初始化。H將內存地址付給棧內存中的p變量。

二、面向對象：單例設計模式

17、設計模式：解決某一類問題最行之有效的方法。java中23中設計模式：單例設計模式：解決一個類在內存只存在一個對象。

18、想要保證對象唯一。1，為了避免其他程序過多建立該類對象。先禁止其他程序建立該類對象。2，還為了讓其他程序可以訪問到該類對象，只好在本類中，自定義一個對象。3，為了方便其他程序對自定義對象的訪問，可以對外提供一些訪問方式。

19、這三步怎么用代碼體現呢？1，將構造函數私有化。2，在類中創建一個本類對象。3，提供一個方法可以獲取到該對象。

20、對于事物該怎么描述，還怎么描述。當需要將該事物的對象保證在內存中唯一時，就將以上的三部加上即可。

21、單例設計方法一：這個是先初始化對象。稱為：餓漢式。Single類一進內存，就已經創建好了對象。開發一般用餓漢式：安全、簡單。

22、單例設計方法二：對象被調用時，才初始化，也叫做對象的延時加載。稱為：懶漢式。Single類進內存，對象還沒有存在，只有調用了getInstance方法時，才建立對象。

23、記住原則：定義單例，建議使用餓漢式。但面試時：考懶漢式的多。特別是如何解決懶漢式的缺點。2016年01月12日

day07

一、面向對象：繼承

1、繼承：1，提高代碼的復用性。2，讓類與類之間產生了關系。有了這個關系，才有了多態的特性。關鍵字：extends。

2、注意：千萬不要為了獲取其他類的功能，簡化代碼而繼承。必須是類與類之間有所屬關系才可以繼續。所屬關系is a。

3、java語言中：java只支持單繼承，不支持多繼承。原因：因為多繼承容易帶來安全隱患：當多個父類中定義了相同功能，當功能內容不同時，子類對象不確定要運行哪一個。但是java保留這種機制，并用另一種體現形式來完成表示，多實現。

4、java支持多層繼承。也就是一個繼承體系。如何使用一個繼承體系中的功能呢？想要使用體系，先查閱父類的描述，因為父類中定義的是該體系中共性功能。通過了解共性功能，就可以知道該體系的基本功能。那么這個體系已經可以基本使用了。

5、那么在具體調用時，要創建最子類的對象，為什么呢？一是因為有可能父類不能創建對象，二是創建子類對象可以使用更多的功能，包括基本的也包括特有的。

6、簡單一句話：查閱父類功能，創建子類對象使用功能。

7、this代表本類對象的引用，super代編父類對象的引用。

8、子父類出現后，類成員的特點：類中成員：A，變量。B，函數。C，構造函數。

9、子父類中的變量：如果子類中出現非私有的同名變量時，之類要訪問本類中的同名變量，用this子類要訪問父類中的同名變量，用super。super的使用和this的使用幾乎一致。this代表的是本類對象的引用。super代表的是父類對象的引用。

10、子父類中的函數：當子類出現和父類一模一樣的函數時，當子類對象調用該函數，會運行子類函數的內容。如同父類的函數被覆蓋一樣。這種情況是函數的另一個特性：重寫（覆蓋）。

11、修改以往的源碼絕對是災難。

12、單子類繼承父類，沿襲了父類的功能，到子類中，但是子類雖具備該功能，但是功能的內容卻和父類不一致，這時，沒有必要定義新功能，而是使用覆蓋特殊，保留父類的功能定義，并重寫功能內容。

13、注意：覆蓋：子類覆蓋父類，必須保證子類權限大于等于父類權限，才可以覆蓋，否則編譯失敗。靜態只能覆蓋靜態。

14、記住大家：重載：只看同名函數的參數列表。重寫：子父類方法要一模一樣。

15、子父類中的構造函數：發現在對子類對象進行初始化時，父類的構造函數也會運行。那是因為子類的構造函數默認第一行有一條隱式的語句super（）；super（）；會訪問父類中空參數的構造函數。而且子類中所有的構造函數默認第一行都是super（）。

16、為什么子類一定要訪問父類中的構造函數：因為父類中的數據子類可以直接獲取，所有之類對象在建立時，需要先查看父類是如何對這些數據進行初始化的。所有之類在對象初始化時，要先訪問一下父類中的構造函數。如果要訪問父類中指定的構造函數，可以通過手動定義super語句的方式來指定。注意：super語句一定一定在子類構造函數第一行。

17、子類的實例化過程。結論：子類的所有的構造函數默認都會訪問父類中空參數的構造函數。因為子類每一個構造函數內的每一行都有一句隱式的super（）；當父類中沒有空參數的構造函數時，子類必須手動通過super語句或者this語句形式來指定要訪問父類中的構造函數。當然：子類的構造函數第一行也可以收到指定this語句來訪問本類中的構造函數。子類中至少會有一個構造函數會訪問父類中的構造函數。

18、關鍵字：final：final可以修飾類，方法（函數），變量；final修飾的類不可以被繼承；final修飾的方法（函數）不可以被覆蓋；final修飾的變量是一個常量，只能被賦值一次；內部類只能訪問被final修飾的局部變量。

二、面向對象：抽象類

19、當多個類中出現相同功能，但是功能主體不同，這時也可以進行向上抽取。這時，只抽取功能定義，而不抽取功能主體。20、抽象：看不懂。

21、抽象類的特點：A，抽象方法一定定義在抽象類中。B，抽象方法和抽象類都必須被abstract關鍵字修飾。C，抽象類不可以被new創建對象。因為調用抽象方法沒意義。D，抽象類中的抽象方法要被使用，必須由子類復寫其所有的抽象方法后，建立子類對象調用。

22、如果子類只覆蓋了部分抽象方法，那么該子類還是一個抽象類。

23、抽象類和一般類沒有太大的不同。該如何描述事物，就如何描述事物，只不過，該事物中出現了一些看不懂的東西。這些不確定的部分，也是該事物的功能，需要明確出現，但是無法定義主體。通過抽象方法來表示。

24、抽象類比一般類多了抽象方法（函數）。就是在類中可以定義抽象方法。抽象類不可以實例化（即不可以new）。特殊：抽象類中可以不定義抽象方法，這樣做僅僅是不讓該類建立對象。

25、什么是模板方法呢？在定義功能時，功能的一部分是確定的，但是有一部分是不確定，而確定的部分在使用不確定的部分。那么這時就將不確定的部分暴露出去。由該類的子類去實現。

三、面向對象：接口

26、接口：格式：interface{}。接口中的成員修飾符是固定的。成員常量：public static final；成員函數：public abstract。接口的出現將“多繼承”通過另一種形式體現出來，即“多實現”。

26、接口：初期理解：可以認為是一個特殊的抽象類。當抽象類中的方法都是抽象的，那么該類可以通過接口的形式來表示。class用于定義類。interface用于定義接口。

27、接口：是不可以創建對象的，因為有抽象方法。需要被子類實現，子類對接口中的抽象方法全部覆蓋后，子類才可以實例化。否則子類是一個抽象類。接口可以被類多實現，也是對多繼承不支持的轉換形式。java支持多實現。用關鍵字：implements。

28、接口與接口之間支持多繼承，類與類之間只支持單繼承。

29、接口的特點：接口是對外暴露的規則；接口是程序的功能擴展；接口可以用來多實現；類與接口之間是實現關系，而且類可以繼承一個類的同時實現多個接口；接口與接口之間可以有繼承關系。2016年01月13日

day08

一、面向對象：多態

1、多態的定義：某一類事物的多種存在形態，例：動物中貓，狗。貓這個對象對應的類型是貓類型：貓x=new 貓（）；同時貓也是動物中的一種，也可以把貓稱為動物。動物y=new 貓（）；動物是貓和狗具體事物中抽取出來的父類型；父類型引用指向了子類對象。

2、多態的體現：父類的引用指向了自己的子類對象。父類的引用也可以接收自己的子類對象。

3、多態的前提：必須是類與類之間有關系。要么繼承，要么實現。通常還有一個前提：存在覆蓋。

4、多態的弊端：提高了擴展性，但是只能使用父類的引用訪問父類中的成員。

5、多態的好處：多態的出現大大的提高了程序的擴展性。

6、引用數據類型轉換：類型提升。向上轉型。如果想要調用貓的特有方法時，如何操作？強制將父類的引用，轉成子類類型。向下轉型。注意：千萬不要出現這樣的操作，就是將父類對象轉成子類類型。我們能轉換的是父類引用指向了自己的子類對象時，該引用可以被提升，也可以被強制轉換。多態自始至終都是子類對象在做著變量。

7、關鍵字：instanceof。判斷引用數據類型是否一致。

8、在多態中成員函數的特點：在編譯時期：參閱引用型變量所屬的類中是否有調用的方法。如果有，編譯通過，如果沒有編譯失敗。在運行時期：參閱對象所屬的類中是否有調用的方法。簡單總結就是：成員函數在多態調用時，編譯看左邊，運行看右邊。

9、在多態中，成員變量的特點：無論編譯和運行，都參考左邊（引用型變量所屬的類）。

10、object類：是所有對象的直接或者間接父類，傳說中的上帝。該類中定義的肯定是所有對象都具備的功能。

11、Object類中已經提供了對對象是否相同的比較方法。如果自定義類中也有比較相同的功能，沒有必要重新定義。只要沿襲父類中的功能，建立自己特有的比較內容即可。這就是覆蓋。

2016年01月15日

day09

一、面向對象：內部類

1、內部類的定義：將一個類定義在另一個類的里面，對里面那個類就稱為內部類（內置類，嵌套類）。

2、內部類訪問特點：內部類可以直接訪問外部類中的成員，包括私有成員。之所以可以直接訪問外部類中的成員，是因為內部類中持有了一個外部類的引用，格式：外部類名.this。而外部類要訪問內部類中的成員必須要建立內部類的對象。

3、訪問格式：當內部類定義在外部類的成員位置上，而且非私有，可以在外部其他類中。可以直接建立內部類對象。格式：外部類名.內部類名變量名=外部類對象.內部類對象；Outer.Inner in=new Outer().new Inner()。

4、當內部類在成員位置上，就可以被成員修飾符所修飾。比如，private：將內部類在外部類中進行封裝。static：內部類就具備了static的特性。當內部類被static修飾后，只能直接訪問外部類中的static成員。出現了訪問局限。

5、在外部其他類中，如何直接訪問static內部類的非靜態成員呢？new Outer.Inner().function()。在外部其他類中，如何直接訪問static內部類的靜態成員呢？Outer.Inner().function()。

6、注意：當內部類中定義了靜態成員，該內部類必須是static的。當外部類中的靜態方法訪問內部類時，內部類也必須是static的。

7、當描述事物時，事物的內部還有事物，該事物用內部類來描述。因為內部事物在使用外部事物的內容。

8、內部類定義在局部時，1，不可以被成員修飾符修飾；2，可以直接訪問外部類中的成員，因為還持有外部類中的引用；但是不可以訪問它所在的局部中的變量。只能訪問被final修飾的局部變量。

9、匿名內部類：1，匿名內部類其實就是內部類的簡寫格式。2，定義匿名內部類的前提：內部類必須繼承一個類或者實現接口。3，匿名內部類的格式：new 父類或者接口（）{定義子類的內容}。4，其實匿名內部類就是一個匿名子類對象。而且這個對象有點胖。可以理解為帶內容的對象。5，匿名內部類中定義的方法最好不要超過3個。

二、面向對象：異常

10、異常：異常的體系：Throwable：（Error：通常出現重大問題如：運行的類不存在或者內存溢出等；不編寫針對代碼對其處理。Exception：在運行時運行出現的一起情況，可以通過try catch finally）。Exception和Error的子類名稱都是以父類名作為后綴。

11、異常：就是程序在運行時出現不正常情況。

12、異常由來：問題也是現實生活中一個具體的事物，也可以通過java的類的形式進行描述，并進行封裝。其實就是java對不正常情況進行描述后的對象體現。

13、對于問題的劃分：兩種：一種是嚴重的問題。一種是非嚴重的問題。對于Error一般不編寫針對性的代碼對其進行處理。對于嚴重的，java通過Error類進行描述。對于非嚴重的，java通過Exception類進行描述。對于Exception可以使用針對性的處理方式進行處理。

14、無論Error或者Exception都具體有一些共性內容。比如：不正常情況的信息，引發原因等。

15、異常的處理：java提供了特有的語句進行處理。Try{需要被檢測的代碼；}catch{異常類變量}{處理異常的代碼：（處理方式）}finally{一定會執行的語句；}。

15、throws Exception//在功能上通過throws的關鍵字聲明了該功能有可能會出現問題。在函數上聲明異常。便于提高安全性，讓調用者進行處理。不處理編譯失敗。

16、對多異常的處理。1，聲明異常時，建議聲明更為具體的異常。這樣處理得可以更具體。2，對聲明幾個異常，就對應有幾個catch塊。不要定義多余的catch塊。如果多個catch塊中的異常出現繼承關系，父類異常catch塊放在最下面。

17、建議在進行catch處理時，catch中一定要定義具體處理方式。不要簡單定義一句 e.printStackTrace()，也不要簡單的就書寫一條輸出語句。

18、自定義異常：因為項目中會出現特有的問題，而這些問題并未被java所描述并封裝對象。所有對于這些特有的問題可以按照java的對問題封裝的思想。將特有的問題，進行自定義的異常封裝。

19、當在函數內部出現了throw拋出了異常對象，那么就必須要給對應的處理動作。要么在內部try catch處理。要么在函數上聲明讓調用者處理。20、如何定義異常信息呢？因為父類中已經把異常信息的操作都完成了。所有子類只要在構造時，將異常信息傳遞給父類通過super語句。那么就可以直接通過getMessage方法獲取自定義的異常信息。

21、自定義異常：必須是自定義類繼承Exception。繼承Exception原因：異常體系有一個特點：因為異常類和異常對象都被拋出。他們都具備可拋性。這個可拋性是Throwable這個體系中獨有特點。

22、只有這個體系中的類和對象才可以被throws和throw操作。

23、throws和throw的區別：throws使用在函數上。throw使用在函數內。throws后面跟的異常類。可以跟多個。用逗號隔開。throw后跟的是異常對象。

24、Exception中有一個特殊的子類異常RuntimeException運行時異常。如果在函數內容拋出該異常，函數上可以不用聲明，編譯一樣通過。如果在函數上聲明了該異常。調用者可以不用進行處理，編譯一樣通過。

25、之所以不用在函數聲明，是因為不需要讓調用者處理。當該異常發生，希望程序停止。因為在運行時，出現了無法繼續運算的情況，希望停止程序。對代碼進行修正。

26、自定義異常時：如果該異常的發生，無法在繼續進行運算，就讓自定義異常繼承RuntimeException。

27、對于異常分兩種：1，編譯時被檢測的異常。2，編譯時不被檢測的異常（運行時異常，RuntimeException以及其子類）。

2016年01月16日

day10

一、面向對象：異常

1、finally中存放的是一定會被執行的代碼。

2、finally代碼塊：定義一定執行的代碼。通常用于關閉資料。

3、記住一點：catch是用于處理異常。如果沒有catch就代表沒有被處理過，如果該異常時檢測時的異常，就必須聲明出去。

4、異常在子父類覆蓋中的體現：A，子類在覆蓋父類時，如果父類的方法拋出異常，那么子類的覆蓋方法，只能拋出父類的異常或者該異常的子類。B，如果父類方法拋出多個異常，那么子類在覆蓋該方法時，只能拋出父類異常的子集。C，如果父類或者接口的方法中沒有異常拋出，那么子類在覆蓋方法時，也不可以拋出異常。如果子類方法發生了異常。就必須要進行try處理。絕對不能拋。

5、異常：是什么？是對問題的描述，將問題進行對象的封裝。

6、異常體系：Throwable：|--Error；|--Exception（|--RuntimeException）。

7、異常體系的特點：異常體系中的所有類以及建立的對象都具備可拋性。也就是說可以被throw和throws關鍵字所操作。只有異常體系具備這個特點。

8、throw和throws的用法：throw定義在函數內，用于拋出異常對象。throws定義在函數上，用于拋出異常類，可以拋出多個用逗號隔開。

9、當函數內容有throw拋出異常對象，并未進行try處理。必須要在函數上聲明，都在編譯失敗。注意：RuntimeException除外。也就是說，函數內如果拋出的RuntimeException異常，函數上可以不用聲明。

10、如果函數聲明了異常，調用者需要進行處理。處理方法可以throws和try。

11、異常有兩種：編譯時被檢測異常：該異常在編譯時，如果沒有處理（沒有拋也沒有try），編譯失敗。該異常被標識，代表著可以被處理。運行時異常（編譯時不檢測）：在編譯時，不需要處理，編譯器不檢查。該異常的發生，建立不處理，讓程序停止。需要對代碼進行修正。

12、異常處理語句：try（需要被檢測的代碼；）catch（處理異常的代碼；）finally（一定會執行的代碼；）。有三種結合格式：try catch；try finally；try catch finally。注意：A，finally中定義的通常是關閉資源代碼。因為資源必須釋放。B，finally只有一種情況不會執行。當執行到System.exit(0);finally不會執行。

13、自定義異常：定義類繼續Exception或者RuntimeException。A，為了讓該自定義類具備可拋性。B，讓該類具備操作異常的共性方法。當要定義自定義異常的信息時，可以使用父類已經定義好的功能。異常異常信息傳遞給父類的構成函數。class MyException extends Exception{MyException(String message){super(message);}}。

14、自定義異常：按照java的面向對象思想，將程序中出現的特有問題進行封裝。

15、異常的好處：A，將問題進行封裝。B，將正常流程代碼和問題處理代碼相分離，方便于閱讀。

16、異常的處理原則：A，處理方式有兩種：try或者throws。B，調用到拋出異常的功能時，拋出幾個，就處理幾個。一個try對應多個catch。C，多個catch，父類的catch放到最下面。D，catch內需要定義針對性的處理方式。不要簡單的定義printStackTrace,輸出語句。也不要不寫。當捕獲到的異常，本功能處理不了時，可以繼續在catch中拋出。

17、異常的注意事項：在子父類覆蓋時：A，子類拋出的異常必須是父類異常的子類或者子集。B，如果父類或者接口沒有異常拋出時，子類覆蓋出現異常，只能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路徑即可。數據庫驅動，SSH框架等都以jar包體現的。2016年01月17日

day11

一、多線程：概述

1、進程：是一個正在執行中的程序。每一個進程執行都有一個執行順序。該順序是一個執行路徑，或者叫一個控制單元。

2、線程：就是進程中的一個獨立的控制單元。線程在控制著進程的執行。一個進程中至少有一個線程。

3、Java VM 啟動的時候會有一個進程java.exe。該進程中至少有一個線程負責java程序的執行。而且這個線程運行的代碼存在于main方法中。該線程稱之為主線程。擴展：其實更細節說明jvm，jvm啟動不止一個線程，還有負責垃圾回收機制的線程。

4、如何在自定義的代碼中，自定義一個線程呢？通過對API的查找，java已經提供了對線程這類事物的描述。就是Thread類。

5、創建線程的第一種方式：繼承Thread類。步驟：1，定義類繼承Thread。2，復寫Thread類中的run方法。目的：將自定義代碼存儲在run方法中，讓線程運行。3，調用線程的start方法，該方法有兩個作用：啟動線程；調用run方法。

6、發現運行結果每一次都不同：因為多個線程都獲取cpu的執行權。cpu執行到誰，誰就運行。明確一點，在某一時刻，只能有一個程序在運行。（多核除外）cpu在做著快速的切換，以達到看上去是同時運行的效果。我們可以形象把多線程的運行形容為在互相搶奪cpu的執行權。這就是多線程的一個特性：隨機性。誰搶到誰執行，至于執行多長，cpu說了算。

7、為什么要覆蓋run方法呢？Thread類用于描述線程。該類就定義了一個功能，用于存儲線程要運行的代碼，該存儲功能就是run方法。也就是說Thread類中的run方法，用于存儲線程要運行的代碼。

8、原來線程都有自己默認的名稱。Thread-編號。該編號從0開始。static Thread currentThread()：獲取當前線程對象。getName()：獲取線程名稱。設置線程名稱：setName或者構造函數。

9、創建線程的第二種方式：實現Runnable接口。

步驟：1，定義類實現Runnable接口。2，覆蓋Runnable接口中的run方法。目的：將線程要運行的代碼存放在run方法中。3，通過Thread類建立線程對象。4，將Runnable接口的子類對象作為實際參數傳遞給Thread類的構造函數。為什么要將Runnable接口的子類對象傳遞給Thread的構造函數？因為，自定義的run方法所屬的對象時Runnable接口的子類對象。所有要讓線程去指定指定對象的run方法。就必須明確該run方法所屬對象。5，調用Thread類的start方法開啟線程并調用Runnable接口子類的run方法。

10、實現方式和基礎方法有什么區別呢？實現方式好處：避免了單繼承的局限性。在定義線程時，建議使用實現方式。兩種方式區別：繼承Thread：線程代碼存放在Thread子類run方法中。實現Runnable：線程代碼存放在接口的子類的run方法中。

二、多線程：同步

11、多線程的運行出現了安全問題：問題的原因：當多條語句在操作同一個線程共享數據時，一個線程對多條語句只執行了一部分，汗沒有執行完，另一個線程參與進來執行。導致共享數據的錯誤。解決辦法：對多條操作共享數據的語句，只能讓一個線程都執行完。在執行過程過，其他線程不可以參與執行。java對于多線程的安全問題提供了專業的解決方式。就是同步代碼塊。synchronized(對象){需要被同步的代碼；}。

12、對象如同鎖。持有鎖的線程可以在同步中執行。沒有鎖的線程即使獲取了cpu的執行權，也進不去，因為沒有獲取鎖。

13、同步的前提：1，必須要有兩個或者兩個以上的線程。2，必須是多個線程使用同一個鎖。必須保證同步中只能有一個線程在運行。

14、好處：解決了多線程的安全問題。弊端：多個線程需要判斷鎖，較為消耗資源。

15、多線程安全問題：如何找到問題：1，明確哪些代碼是多線程運行代碼。2，明確共享數據。3，明確多線程運行代碼中哪些語句是操作共享數據的。

16、同步函數：將關鍵字synchronized放到函數名稱前。即把synchronized當作修飾符使用。

17、同步函數用的是哪一個鎖呢？函數需要被對象調用。那么函數都有一個所屬對象引用。就是this。所有同步函數使用的鎖是this。

18、如果同步函數被靜態修飾后，使用的鎖是什么呢？通過驗證，發現不再是this。因為靜態方法中也不可以定義this。靜態進內存時，內存中沒有本類對象，但是一定有該類對應的字節碼文件對象。類名.class 該對象的類型是Class。靜態的同步方法，使用的鎖是該方法所在類的字節碼文件對象。類名.class。

19、死鎖：同步中嵌套同步。而鎖卻不同。

2016年01月18日

day12

一、多線程：線程間通信

1、wait()，notify()，notifyALL()，用來操作線程為什么定義在了Object類中？這些方法存在于同步中。使用這些方法時必須要標識所屬的同步的鎖。鎖可以是任意對象，所以任意對象調用的方法一定定義Object類中。

2、wait()和sleep()有什么區別？wait()：釋放資源，釋放鎖。sleep()：釋放資源，不釋放鎖。

3、wait：notify：notifyALL：都被使用在同步中，因為要對持有監視器（鎖）的線程操作。所有要使用在同步中，因為只有同步才具有鎖。

4、為什么這些操作線程的方法要定義在Object類中呢？因為這些方法在操作同步中線程時，都必須要標識他們所操作線程只有的鎖。只有同一個鎖上的被等待線程，可以被同一個鎖上notify喚醒。不可以對不同鎖中的線程進行喚醒。也就是說，等待和喚醒必須是同一個鎖。而鎖可以是任意對象，所有可以被任意對象調用的方法定義在Object類中。

5、JDK1.5 中提供個多線程升級解決方案。將同步synchronized替換成現實Lock操作。將Object中的wait，notify，notifyAll，替換了condition對象。該對象可以Lock鎖，進行獲取。

二、多線程：其他操作

6、停止線程：A：定義循環結束標記：因為線程運行代碼一般都是循環，只要控制了循環即可。B：使用interrupt（中斷）方法：該方法時結束線程的凍結狀態，使線程回到運行狀態中來。注意：stop方法已經過時不再使用。

7、如何停止線程？只有一種，run方法結束。開啟多線程運行，運行代碼通常是循環結構。只要控制住循環，就可以讓run方法結束，也就是線程結束。特殊情況：當線程處于了凍結狀態。就不會讀取到標記。那么線程就不會結束。

8、當沒有指定的方式讓凍結的線程恢復到運行狀態時，這時需要對凍結進行清除。強制讓線程恢復到運行狀態中來。這樣就可以操作標記讓線程結束。Thread類中提供該方法：interrupt方法。

9、join方法：當A線程執行到了B線程的.join()方法時，A就會等待。等B線程都執行完，A才會執行。join可以用來臨時加入線程執行。

2016年01月19日

day13

一、String類：概述

1、String類：字符串是一個特殊的對象。字符串一旦初始化就不可以被改變。String str=”abc”；String str1=new String(“abc”)。Str和str1的區別：str在內存中有一個對象。Str1在內存中有兩個對象。

二、***重點：String類：常見操作

常見的操作有哪些？ “abcd” 1，獲取。

1.1 字符串中包含的字符數，也就是字符串的長度。

int length()：獲取長度。

1.2 根據位置獲取位置上某個字符。

char charAt(int index)：獲取位置上某個字符。

1.3 根據字符獲取該字符在字符串中位置。

int indexOf(int ch)：獲取該字符在字符串中位置。返回的是ch在字符串中第一次出現的位置。

int indexOf(int ch,int fromIndex)：從fromIndex指定位置開始，獲取ch在字符串中出現的位置。

int indexOf(String str)：返回的是str在字符串中第一次出現的位置。

int indexOf(String str,int fromIndex)：從fromIndex指定位置開始，獲取str在字符串中出現的位置。

int lastIndexOf(int ch)：反向索引。2，判斷。

2.1 字符串中是否包含某一個子串。

boolean contains(str);

特殊之處：indexOf(str)：可以索引str第一次出現位置，如果返回-1,表示該str不在字符串中存在。

2.2 2.3 2.4 2.5 2.6 所以，也可以用于對指定判斷是否包含。

if(str.indexOf(“aa”)!=-1)而且該方法既可以判斷又可以獲取出現的位置。字符串是否有內容。

boolean isEmpty(str)：原理就是判斷長度是否為0。字符串是否是以指定內容開頭。boolean startsWith(str);字符串是否是以指定內容結尾。boolean endsWith(str);判斷字符串的內容是否相同。復寫了Object類中的equals方法。boolean equals(str);判斷內容是否相同，并忽略大小寫。boolean equalsIgnoreCass();3，轉換。

3.1 將字符數組轉成字符串。

構造函數：String(char[])

String(char[],offset,count)：將字符數組中的一部分轉成字符串。

靜態方法：static String copyValueOf(char[]);

static String copyValueOf(char[] data,int offset,int count);

static String valueOf(char[]);

3.2 將字符串轉成字符數組。//重點**。

char[] toCharArray();3.3 將字節數組轉成字符串。

String(byte[])String(byte[],offset,count)：將字節數組中的一部分轉成字符串。3.4 將字符串轉成字節數組。

byte[] getBytes();3.5 將基本數據類型轉成字符串。

static String valueOf(int)

static String valueOf(double)

//3+“";//String.valueOf(3);

特殊：字符串和字節數組在轉換過程中，是可以指定編碼表的。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類：字符串的注組成原理就是通過該類實現的。StringBuffer可以對字符串內容進行增刪。StringBuffer是一個容器。很多方法與String相同。StringBuffer是可變長度的。

9、StringBuffer是字符串緩沖區。是一個容器。

10、緩沖區的特點：1，而且長度是可變化的。2，可以直接操作多個數據類型。3，最終會通過toString方法變成字符串。

11、StringBuffer常見操作： C create U update R read D delete 1，存儲。

StringBuffer append()：將指定數據作為參數添加到已有數據的結尾處。

StringBuffer insert(index,數據)：可以將數據插入到指定index位置。2，刪除。

StringBuffer delete(start,end)：刪除緩沖區中的數據，包含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，將緩沖區中指定數據存儲到指定字符數組中。

void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)。

12、JDK1.5版本之后出現了StringBuilder。

StringBuffer是線程同步。單線程使用StringBuffer效率較低。多線程使用StringBuffer保證了安全性。

StringBuilder是線程不同步。單線程使用StringBuilder提高了效率。多線程使用StringBuilder可能存在安全問題，但可以通過自定義鎖來解決安全問題。以后開發，建議使用StringBuilder。

13、升級三個因素：1，提高效率。2，簡化書寫。3，提高安全性。

四、基本數據類型對象包裝類

14、基本數據類型對象包裝類的最常見作用：就是用于基本數據類型和字符串類型之間做轉換。

15、數據類型轉換：

A：基本數據類型轉成字符串。

基本數據類型+”“ 基本數據類型.toString(基本數據類型值);如：Integer.toString(34);//將34整數變成”34“。B：字符串轉成基本數據類型。

靜態：基本數據類型包裝類.parseInt(字符串);如：xxx a=Xxx.parseXxx(String);

int a=Integer.parseInt(”123“);

double d=Double.parseDouble(”12.23“);

boolean b=Boolean.parseBoolean(”true“);非靜態：

Integer i=new Integer(”123");

int num=i.intValue();C：十進制轉成其他進制。

toBinaryString();toHexString();toOctalString();D：其他進制轉成十進制。

parseInt(string,radix)。

2016年01月22日

day14

一、集合框架：概述

1、集合類：為什么會出現集合類？面向對象語言對事物的體現都是以對象的形式，所有為了方便對多個對象的操作，就對對象進行存儲，集合就是存儲對象最常用的一種方式。

2、數組和集合類同是容器，有何不同？數組雖然也可以存儲對象，但長度是固定的；集合長度是可變的，數組中可以存儲基本數據類型，集合只能存儲對象。

3、集合類的特點：集合只用于存儲對象，集合長度是可變的，集合可以存儲不同類型的對象。

4、為什么會出現這么多的容器呢？因為每一個容器對數據的存儲方式有所不同。這個存儲方式稱之為：數據結構。

5、add方法的參數類型是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的子接口。在迭代時，不可以通過集合對象的方法操作集合中的元素。因為會發生ConcurrentModificationException異常。所有，在迭代器時，只能用迭代器的方法操作元素，可以Iterator方法時優先的，只能對元素進行判斷，取出，刪除的操作，如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。該接口只能通過List集合的ListIterator方法獲取。

9、Collection |--List:元素是有序的，元素可以重復。因為該集合體系有索引。

|--ArrayList:底層的數據結構使用的是數組結構。特點：查詢速度很快。但是增刪稍慢。線程不同步。

|--LinkedList:底層使用的是鏈表數據結構。特點：增刪速度很快，查詢速度稍慢。

|--Vector:底層是數據數據結構。線程同步。被ArrayList替代了。

|--Set:元素是無序的，元素不可以重復。

10、枚舉就是Vector特有的取出方式。發現枚舉和迭代器很像。其實枚舉和迭代是一樣的。因為枚舉的名稱以及方法的名稱都過長。所有被迭代器取代了。枚舉郁郁而終了。

11、LinkedList：特有方法： addFirst();addLast();

getFirst();getLast();獲取元素，但是不刪除元素。如果集合中沒有元素，會出現NoSuchElementException。

removeFirst();removeLast();獲取元素，但是元素被刪除。如果集合中沒有元素，會出現NoSuchElementException。

在JDK1.6出現了替代方法。offerFirst();offerLast();

peekFirst();peekLast();獲取元素，但是不刪除元素。如果集合中沒有元素，會返回null。

pollFirst();pollLast();獲取元素，但是元素被刪除。如果集合中沒有元素，會返回null。

三、集合框架：Set類

12、HaseSet是如何保證元素唯一性的呢？是通過元素的兩個方法，hashCode和equals來完成。如果元素的hashCode值相同，才會判斷equals是否為true。如果元素的hashCode值不同，不會調用equals。

13、注意：對于判斷元素是否存在，以及刪除操作，依賴的方法時元素的hashcode和equals方法。

2016年1月23日

day15

一、集合框架：Set類

1、Set：無序，不可以重復元素。

|--HashSet：數據結構是哈希表。線程是非同步的。

保證元素唯一性的原理：判斷元素的hashCode值是否相同。

如果相同，還會繼續判斷元素的equals方法，是否為true。

|--TreeSet：可以對Set集合中的元素進行排序。

底層數據結構是二叉樹。

保證元素唯一性的依據：

compareTo方法和return 0。

2、TreeSet排序的第一種方式：讓元素自身具備比較性。元素需要實現comparable接口，覆蓋comparaeTo方法。這種方式也稱為元素的自然順序，或者默認順序。

3、TreeSet排序的第二種方式：當元素自身不具備比較性時，或者具備的比較性不是所需要的。這時就需要讓集合自身具備比較性。在集合初始化時，就有了比較方式。

4、當元素自身不具備比較性，或者具備的比較性不是所需要的。這時需要讓容器自身具備比較性。定義了比較器，將比較器對象作為參數傳遞給TreeSet集合的構造函數。

5、當兩種排序都存在時，以比較器為主。定義一個類，實現Comparator接口，覆蓋compare方法。

二、集合框架：泛型

6、泛型：JDK1.5版本以后出現的新特性。用于解決安全問題，是一個類型安全機制。

7、泛型的好處：好處：1，將運行時期出現問題ClassCastException，轉移到了編譯時期。方便于程序員解決問題。讓運行時期問題減少。更加安全。2，避免了強制轉換麻煩。

8、泛型格式：通過<>來定義要操作的引用數據類型。在使用java提供的對象時，什么時候寫泛型呢？通常在集合框架中很常見。只要見到<>就要定義泛型。其實<>就是用來接收類型的。當使用集合時，將集合中要存儲的數據類型作為參數傳遞到<>即可。

9、什么時候定義泛型類？當類中要操作的引用數據類型不確定的時候，早期定義Object來完成擴展。現在定義泛型來完成擴展。

10、泛型類定義的泛型，在整個類中有效。如果被方法使用，那么泛型類的對象明確要操作的具體類型后，所有要操作的類型就已經固定了。為了讓不同方法可以操作不同類型，而且類型還不確定，那么可以將泛型定義在方法上。

11、特殊之處：靜態方法不可以訪問類上定義的泛型。如果靜態方法操作的引用數據類型不確定，可以將泛型定義在方法上。

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：底層是哈希表數據結構，不可以存入null鍵null值，該集合是線程同步的。JDK1.0。效率低。

|--HashMap：底層是哈希表數據結構，允許使用null鍵和null值，該集合是不同步的。JDK1.2。效率高。|--TreeMap：底層是二叉樹數據結構，線程不同步，可以用于給map集合中的鍵進行排序。

4、和Set很像。其實大家，Set底層就是使用了Map集合。

5、map集合的兩種取出方式：1，keySet：將map中所有的鍵存入到Set集合。因為Set具備迭代器。所以可以迭代方式取出所有的鍵，在根據get方法，獲取每一個鍵對應的值。Map集合的取出原理：將map集合轉成set集合。在通過迭代器取出。2，Set> entrySet：將map集合中的映射關系存入到了set集合中，而這個關系的數據類型就是：Map.Entry。

6、Map.Entey 其實Entry也是一個接口，它是Map接口中的一個內部接口。

7、什么時候使用map集合呢？當數據之間存在映射關系時，就要先想到map集合。

8、map擴展知識：map集合被使用是因為具備映射關系。

2016年01月26日

day17

一、集合：Collections

1、fill方法可以將list集合中所有元素替換成指定元素。

二、集合：Arrays

2、Arrays：用于操作數組的工具類。里面都是靜態方法。

3、asList：將數組變成list集合。

4、把數組變成list集合有什么好處？可以使用集合的思想和方法來操作數組中的元素。注意：將數組變成集合，不可以使用集合的增刪方法。因為數據的長度是固定的。如果你增刪，那么會發生UnsupportedOperationException。

5、數組變集合：如果數組中的元素都是對象。那么變成集合時，數組中的元素就直接轉成集合中的元素。如果數組中的元素都是基本數據類型，那么會將該數組作為集合中的元素存在。

6、集合變數組：指定類型的數組到底要定義多長呢？當指定類型的數組長度小于了集合的size，那么該方法內部會創建一個新的數組，長度為集合的size。當指定類型的數組長度大于了集合的size，就不會新創建數組，而是使用傳遞進來的數組。所以創建一個剛剛好的數組最優。

7、為什么要講集合變數組？為了限定對元素的操作。不需要進行增刪了。

8、高級for循環：格式：for（數據類型變量名：被遍歷的集合（Collection）或者數組）｛｝。

9、高級for循環、迭代器、ListIterator的區別：

高級for循環對集合進行遍歷。只能獲取集合元素，但是不能對集合進行操作。迭代器除了遍歷，還可以進行remove集合中元素的動作。

如果使用ListIterator，還可以在遍歷過程中對集合進行增刪改查的操作。

10、傳統for和高級for有什么區別呢？高級for有一個局限性：必須有被遍歷的目標。建議在遍歷數組的時候，還是希望使用傳統for。因為傳統for可以定義角標。

11、JDK1.5版本出現的新特性：可變參數：其實就是上一種數組參數的簡寫形式。不用每一次都手動的建立數組對象。只要將要操作的元素作為參數傳遞即可。隱式將這些參數封裝成了數組。

12、方法的可變參數。在使用時注意：可變參數一定要定義在參數列表最后面。

13、import static：靜態導入：例如：import static java.lang.System.*;//導入了System類中所有靜態成員。注意：當類名重名時，需要制定具體的包名。當方法重名時，指定具備所屬的對象或者類。

2016年01月28日

day18

一、其他對象：System

1、System:類中的方法和屬性都是靜態的。out:標準輸出，默認是控制臺。int:標準輸入，默認是鍵盤。描述系統一些信息。

2、獲取系統屬性信息：Properties getProperties()。因為Properties是Hashtable的子類，也就是Map集合的一個子類對象。那么可以通過map的方法取出該集合中的元素。該集合中存儲都是字符串。沒有泛型定義。

3、Runtime對象：該類并沒有提供構造函數。說明不可以new對象。那么會直接想到該類中的方法都是靜態的。發現該類中還有非靜態方法。說明該類肯定會提供方法獲取本類對象。而且該方法是靜態的，并返回值類型是本類類型。由這個特點可以看出該類使用了單例設計模式完成。該方式的static Runtime getRuntime()。

4、Math類：ceil方法：返回大于指定數據的最小整數。floor方法：返回小于指定數據的最大整數。round方法：四舍五入。pow方法：冪運算。random：返回0-1之間的隨機數。

二、IO流：概述

5、IO(Input Outpu)流：IO流用來處理設備之間的數據傳輸。Java對數據的操作是通過流的方式。Java用于操作流的對象都在IO包中。流按操作數據分為兩種：字節流與字符流。流按流向分為：輸入流，輸出流。

6、IO流常用基類：字節流的抽象基類：InputStream，OutputStream。字節流的抽象基類：Reader，Writer。注：由這四個類派生出來的子類名稱都是以其父類名作為子類名的后綴（如：InputStream的子類FilelnputStream，如：Reader的子類FileReader。）。

7、字符流和字節流：字節流兩個基類：InputStream

OutputStream。字符流兩個基類：Reader Writer。先學習字符流的特點：既然IO流是用于操作數據的，那么數據的最常見體現形式是：文件。2016年01月30日

day19

一、IO流：Buffered緩沖區

1、字符流的緩沖區：緩沖區的出現提高了對數據的讀寫效率。對應類：BufferedWriter；BufferedReader。緩沖區要結合流才可以使用。在流的基礎上對流的功能進行了增強。

2、緩沖區的出現是為了提高流的操作效率而出現的。所以在創建緩沖區之前，必須要先有流對象。該緩沖區中提供了一個跨平臺的換行符。newLine()。

3、字符讀取流緩沖區：該緩沖區提供了一次讀一行的方法readLine()，方便于對文本數據的獲取。當返回null時，表示讀到文件末尾。

4、readLine方法返回的時候只返回回車符之前的數據內容。并不返回回車符。

5、裝飾設計模式：當想要對已有的對象進行功能增強時，可以定義類，將已有對象傳入，基于已有的功能，并提供加強功能。那么自定義的該類稱為裝飾類。

6、裝飾類通常會通過構造方法接收被裝飾的對象。并基于被裝飾的對象的功能，提供更強的功能。

7、裝飾模式比繼承要靈活，避免了繼承體系臃腫。而且降低了類與類之間的關系。裝飾類因為是增強已有對象，具備的功能和已有的是相同的，只不過提供了更強功能。所以裝飾類和被裝飾類通常是都屬于一個體系中的。

二、IO流：字節流

8、字符流： FileReader FileWriter BufferedReader BufferedWriter 字節流：

InputStream

OutputStream BufferedInputStream

BufferedOutputStream

9、流操作的基本規律：

最痛苦的就是流對象有很多，不知道該用哪一個。通過兩個明確來完成。1，明確源和目的。

源：輸入流。InputStream Reader。

目的：輸出流。OutputStream Writer。2，明確操作的數據是否是純文本。

是：字符流。

不是：字節流。

3，當體系明確后，再明確要使用哪個具體的對象。

通過設備來進行區分：

源設備：內存，硬盤，鍵盤。目的設備：內存，硬盤，控制臺。

2016年01月31日

day20

一、IO流：File類

1、File類：用來將文件或者文件夾封裝成對象。方便對文件與文件夾進行操作。File對象可以作為參數傳遞給流的構造函數。了解File類中的常用方法。

2、File類常見方法： 1，創建。

boolean createNewFile()；在指定位置創建文件，如果該文件已經存在，則不創建，返回false。

和輸出流不一樣，輸出流對象一建立創建對象。而且文件已經存在，會覆蓋。

boolean mkdir();創建一級文件夾。

boolean mkdirs();創建多級文件夾。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、因為目錄中還有目錄，只要使用同一個列出目錄功能的函數完成即可。在列出過程中出現的還是目錄的話，還可以再次調用本功能。也就是函數自身調用自身。這種表現形式，或者編程手法，稱為遞歸。

遞歸要注意：1，限定條件。2，要注意遞歸的次數。盡量避免內存溢出。

4、練習：將一個指定目錄下的java文件的絕對路徑，存儲到一個文本文件中。建立一個java文件列表文件。思路：1，對指定的目錄進行遞歸。2，獲取遞歸過程所有的java文件的路徑。3，將這些路徑存儲到集合中。4，將集合中的數據寫入到一個文件中。

二、IO流：Properties類

5、Properties是hashtable的子類。也就是說它具備map集合的特點。而且它里面存儲的鍵值對都是字符串。是集合中和IO技術相結合的集合容器，該對象的特點：可以用于鍵值對形式的配置文件。

6、那么在加載數據時，需要數據有固定格式：鍵=值。

三、IO流：其他類

7、打印流：PrintWriter與PrintStream：可以直接操作輸入流和文件。打印流：

該流提供了打印方法，可以將各種數據類型的數據都原樣打印。字節打印流：PrintStream 構造函數可以接收的參數類型： 1，file對象。File。

2，字符串路徑。String。

3，字節輸出流。OutputStream。字符打印流：PrintWriter 構造函數可以接收的參數類型： 1，file對象。File。

2，字符串路徑。String。

3，字節輸出流。OutputStream。4，字符數出來：Writer。

8、序列流：SequenceInputStream：對多個流進行合并。

9、操作對象：ObjectInputStream與ObjectOutputStream：被操作的對象需要實現Serializable（標記接口）。

2016年02月01日

day21

一、IO流：其他類

1、RandomAccessFile：隨機訪問文件，自身具備讀寫的方法。通過skipBytes(int x),seek(int x)來達到隨機訪問。

2、管道流：PipedInputStream和PipedOutputStream：輸入輸出可以直接進行連接，通過結合線程使用。

3、RandomAccessFile：該類不算是IO體系中子類。而是直接繼承自Object。但是它是IO包中成員。因為它具備讀和寫功能。內部封裝了一個數組，而且通過指針對數據的元素進行操作。可以通過getFilePointer獲取指針位置。同時可以通過seek改變指針的位置。其實完成讀寫的原理就是內部封裝了字節輸入流和輸出流。通過構造函數可以看出，該類只能操作文件。而且操作文件還有模式：只讀r，讀寫rw等。

4、如果模式為只讀r。不會創建文件。會去讀取一個已存在文件，如果該文件不存在，則會出現異常。如果模式為讀寫rw。操作的文件不存在，會自動創建。如果存在則不會覆蓋。

5、IO包中的其他類：

操作基本數據類型：DataInputStream與DataOutputStream。

操作字節數組：ByteArrayInputStream與ByteArrayOutputStream。操作字符數組：CharArrayReader與CharArrayWrite。操作字符串：StringReader與StringWriter。

6、用于操作字節數組的流對象。

ByteArrayInputStream ：在構造的時候，需要接收數據源，而且數據源是一個字節數組。ByteArrayOutputStream ：在構造的時候，不用定義數據目的，因為該對象中已經內部封裝了可變長度的字節數組。這就是數據目的地。因為這兩個流對象都操作的數組，并沒有使用系統資源。所以，不用進行close關閉。在流操作規律講解時： 源設備：

鍵盤 System.in，硬盤 FileStream，內存 ArrayStream。目的設備：

控制臺 System.out，硬盤 FileStream，內存 ArrayStream。用流的讀寫思想來操作數組。

二、IO流：字符編碼

7、字符編碼：字符流的出現為了方便操作字符。更重要是的加入了編碼轉換。通過子類轉換流來完成：InputStreamReader；OutputStreamWriter。在兩個對象進行構造的時候可以加入字符集。

8、編碼表的由來：計算機只能識別二進制數據，早期由來是電信號。為了方便應用計算機，讓它可以識別各個國家的文字。就將各個國家的文字用數字來表示，并一一對應，形成一張表。這就是編碼表。

9、常見的編碼表：

ASCII：美國標準信息交換碼。用一個字節的7位可以表示。ISO8859-1：拉丁碼表。歐洲碼表。用一個字節的8位表示。GBK2312：中國的中文編碼表。用兩個字節的16位來表示。GBK：中國的中文編碼表升級，融合了更多的中文文字符號。

Unicode：國際標準碼，融合了多種文字。所有文字都用兩個字節來表示，Java語言使用的就是Unicode。

UTF-8：最多用三個字節來表示一個字符。??

10、編碼：字符串變成字節數組。解碼：字節數組變成字符串。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命令行操作。需要記憶一些常用的命令，操作不直觀。

舉例：比如：創建文件夾，或者刪除文件夾等。

Java為GUI提供的對象都存在java.Awt和javax.Swing兩個包中。

2、Awt與Swing：

java.Awt：Abstract Window ToolKit（抽象窗口工具包），需調用本地系統方法實現功能。屬重量級控件。

javax.Swing：在Awt的基礎上，建立的一套圖形界面系統，其中提供了更多的組件，而且完全由Java實現。增強了移植性，屬輕量級控件。

3、繼承關系圖：

4、布局管理器：

容器中的組件的排放方式，就是布局。常見的布局管理器：

FlowLayout（流式布局管理器）

從左到右的順序排列。

Panel默認的布局管理器。BorderLayout（邊界布局管理器）

東，南，西，北，中。

Frame默認的布局管理器。GridLayout（網格布局管理器）

規則的矩陣。

CardLayout（卡片布局管理器）

選項卡。

GridBagLayout（網格包布局管理器）

非規則的矩陣。

5、創建圖形化界面： 1，創建frame窗體。

2，對窗體進行基本設置。

比如：大小、位置、布局。3，定義組件。

4，將組件通過窗體的add方法添加到窗體中。5，讓窗體顯示，通過setVisible(true)來完成。

6、建立一個簡單的窗體：

Container常用子類：Window Panel（面板，不能單獨存在。）Window常用子類：Frame Dialog。簡單的窗體創建過程：

Frame f = new Frame(“my window”);f.setLayout(new FlowLayout());f.setSize(500,400);//設置窗體大小。

f.setLocation(300,200);//設置窗體出現在屏幕的位置。f.setVisible(true)。

二、GUI：事件監聽機制

7、事件監聽機制組成：事件源（組件）；事件（Event）；監聽器（Listener）；事件處理（引發事件后處理方式）。

8、事件監聽機制流程圖：

9、事件監聽機制的特點： 1，事件源。2，事件。3，監聽器。4，事件處理。

事件源：就是awt或者swing包中的那些圖形界面組件。事件：每一個事件源都有自己特有的對應事件和共性事件。

監聽器：將可以觸發某一個事件的動作（不止一個動作）都已經封裝到了監聽器中。以上三者，在java中都已經定義好了。直接獲取其對象來用就可以了。我們要做的事情是，就是對產生的動作進行處理。

2016年02月03日

day23

一、網絡編程：概述

1、網絡編程：

網絡模型：OSI參考模型。TCP/IP參考模型。網絡通訊要素：IP地址。端口號。傳輸協議。

2、網絡參考模型：

3、網絡通訊要素： IP地址：網絡中設備的標識。不易記憶，可用主機名。本地回環地址：127.0.0.1主機名：localhost。端口號：用于標識進程的邏輯地址，不同進程的標識。有效端口：0~65535，其中0~1024系統使用或保留端口。

傳輸協議：通訊的規則。常見協議：TCP，UDP。

4、UDP和TCP： UDP：

將數據及源和目的封裝成數據包中，不需要建立連接。每個數據報的大小在限制在64k內。因無連接，是不可靠協議。不需要建立連接，速度快。

特點：面向無連接。數據會被封包。不可靠。速度快。比如：聊天，視頻會議，桌面共享。TCP：

建立連接，形成傳輸數據的通道。

在連接中進行大數據量傳輸。

通過三次握手完成連接，是可靠協議。

必須建立連接，效率會稍低。

特點：面向連接。可大數據量傳輸。比較可靠。稍微有點慢。比如：下載。

5、Socket：

Socket就是為網絡服務提供的一種機制。通信的兩端都有Socket。

網絡通信其實就是Socket間的通信。數據在兩個Socket間通過IO傳輸。

二、網絡編程：UDP

6、UDP傳輸：

DatagramSocket與DatagramPacket。建立發送端，接收端。建立數據包。

調用Socket的發送接收方法。關閉Socket。

發送端與接收端是兩個獨立的運行程序。

三、網絡編程：TCP

7、TCP傳輸：

Socket和ServerSocket。建立客戶端和服務器端。

建立連接后，通過Socket中的IO流進行數據的傳輸。關閉socket。

同樣，客戶端與服務器端是兩個獨立的應用程序。2016年02月04日

day24

一、網絡編程：瀏覽器客戶端

1、視頻演示講解。

2016年02月6日

day25

一、正則表達式

1、正則表達式：符合一定規則的表達式。作用：用于專門操作字符串。

2、正則表達式：符合一定規則的表達式。

作用：用于專門操作字符串。

特點：用一些特定的符號來表示一些代碼操作。這樣就簡化了書寫。

所以學習正則表達式，就是在學習一些特殊符號的使用。

好處：可以簡化對字符串的復雜操作。

弊端：符號定義越多，正則越長，閱讀性越差。

3、具體操作功能：

1，匹配：String matchess();方法。用規則匹配整個字符串，只要有一處不符合規則，就匹配結束，返回false。2，切割：String split();3，替換：String replaceAll();4，獲取：將字符串中符合規則的子串取出。

4、獲取：操作步驟：

1，將正則表達式封裝成對象。

2，讓正則對象和要操作的字符串相關聯。3，關聯后，獲取正則匹配引擎。

4，通過引擎對符合規則的子串進行操作，比如取出。

第二篇：JAVA基礎知識點總結

1)開發Java語言的公司？ Sun（Sun Microsystems）太陽微電子公司開發 2)

Java的3個版本？

J2SE(Java2 Standard Edition)標準版

J2EE(Java 2 Platform,Enterprise Edition)企業版 J2ME(Java 2 Micro Edition)微小版

在5.0以后新版本中稱作：JavaSE JavaEE JavaME 3)

Java語言的幾個主要特點？平臺無關性：能運行于不同的平臺上

安全性：去掉了指針操作，內存由操作系統分配 面向對象：利用類使程序更加利于維護

分布式：可以使用網絡文件和使用本機文件一樣容易 健壯性：檢查程序編譯和運行的錯誤 4)

Java的三大核心機制

虛擬機機制：利用虛擬機解釋字節碼執行java程序實現跨平臺 垃圾收集機制：自動內存回收

代碼安全性機制：加載代碼后校驗代碼后再執行代碼 第2章Java語言的開發環境 1)

JDK是什么？

JDK(Java Development Kit)Java開發工具包。包括了JRE，是開發Java的人員必備的開發運行Java程序的工具。2)

JRE是什么？

JRE（Java Runtime Environment）Java運行環境，運行JAVA程序所必須的環境的集合，包含JVM標準實現及Java核心類庫。3)

JVM是什么？

JVM(Java Virtual Machine)Java虛擬機，它是一個虛構出來的計算機,是通過在實際的計算機上仿真模擬各種計算機功能來實現的。4)

安裝JDK的操作系統問題？

必須針對于不同的操作系統下載安裝不同的JDK，例如windows下安裝針對于windows的JDK，linux下安裝針對于linux的JDK。

5)需要配置的相關環境變量？ path：用于搜索外部命令，例如編譯程序的javac命令，執行程序的java命令

classpath：用于搜索類，即class文件，例如可以在不同的位置執行類文件 6)

配置環境變量的方式？ 有兩種：臨時配置和持久配置

臨時配置：在命令行下用set 變量名=變量值，僅在當前命令行窗口有效

持久配置：在我的電腦——屬性中配置，持久有效 7)可以編寫Java程序的常見開發工具？ 記事本，EditPlus，ULTRAEDIT，Eclipse，Jbuilder，NetBeans 8)

Java文件的類型？

有兩種：

擴展名為java的文件：是Java源文件，屬于編譯之前的純文本文件，存儲java源代碼。

擴展名為class的文件：是Java類文件，屬于編譯之后的二進制文件，存儲字節碼。9)

Java的編譯運行原理？

首先編寫java源文件，然后編譯成class類文件，然后通過虛擬機解釋成機器碼到硬件執行。

10)Java是編譯型語言還是解釋型的語言？

既不是完全編譯型，也不是完全解釋型，是半編譯半解釋的。第3章Java程序的基本結構 1)

Java語言區分大小寫嗎？

區分，不管是數據還是標識符或者關鍵字都區分大小寫，例如public不能寫成Public，“abc”不能寫成“ABC”，int i不能寫成INT I等等。2)main方法是作什么用處的？ 這是程序的入口方法，是由虛擬機自動調用的。

3)語句必須用分號結束嗎？ 必須的，但是代碼塊{}可以用分號結束，也可以不用分號結束

4)

Java中有幾種注釋，各自的功能

有三種：

單行注釋//：加在行首只能注釋一行 多行注釋/* */：注釋多行，但不能嵌套使用

文檔注釋/***/：用于生成HTML形式的文檔，需要配合javadoc命令實現 5)Java語言的數據類型是強類型還是弱類型？ 是強類型，意味著每一個變量都必須明確聲明數據類型。6)

Java語言中數據類型的劃分？有什么區別？ 分成基本類型和引用類型兩大類。

基本類型：有8種，只能存儲單一的值，不以對象的形式存在引用類型：除了基本類型之外其他的都是引用類型，能夠存儲復雜數據類型，以對象的形式存在 7)

基本類型都有哪8種類型？ 布爾類型：boolean 占1字節 字符類型：char 占2字節

整型：byte 占1字節 short 占2字節 int 占4字節 long 占8字節

浮點型：float 占4字節double 占8字節 8)

布爾值可不可以用0或者非0數代替？

不可以，布爾值只能是true和false，不能使用數字，這和C語言是不一樣的。9)

直接寫個整數10默認是什么類型的？

整型的直接量例如10，100等默認的數據類型都是int型 10)如何讓一個整型的直接量變成long型的？ 在直接量后面加大寫L后者小寫l，例如10L 11)整型數據在程序中直接使用可以使用什么進制？ 10進制，8進制，16進制，但不能使用二進制 12)浮點運算在Java中有沒有誤差？ 有誤差，所以精密運算請使用BigDecimal類 13)直接寫一個3.14的直接量是什么數據類型的？

是double型，如果想表示是float的3.14必須寫成3.14F或者3.14f，double型的3.14也可以寫成3.14D 14)char型采取的是什么類型的字符集？

是Unicode全球統一編碼，支持任何世界上官方的語言中的字符

15)常見的轉義字符有哪些？ 轉義序列 名稱 b 退格 t 制表 n 換行 r

回車

” 雙引號 ’ 單引號 反斜杠

16)常見的Unicode字符對應的編碼？

大寫的A到Z是對應65到90，小寫的a到z是對應97到122，字符0到9是對應48到57

17)空字符是不是用’’（兩個并列的單引號）來表示？ 不是，空字符用’u0000’來表示，兩個并列的單引號什么也不是。

18)點,分號,花括號的各自的作用?

點的作用有兩個：一個是使用類或對象中的成員，用對象.成員，再一個就是包名和子包名之間的分隔符，例如頂層包名.子包名 分號的作用是表示語句結束 花括號的作用是代表一個語句塊

19)語句和關鍵字之間可以有任意的空白嗎？ 可以的，例如System.out.println(100);就是正確的語句，但是關鍵字本身不能加空白或換行

20)標識符是什么？

標識符就是指在程序中給包，類，接口，方法，變量起的名字 21)標識符有什么起名規則？ 1． 應以字母、下劃線、美元符開頭 2． 后跟字母、下劃線、美元符或數字 3． 不能用關鍵字和保留字

4． 嚴格區分大小寫 5． 名稱長度沒有限制 22)中文的變量名可以嗎？

是可以的，例如 int 數字 = 10;這個語句是正確的。因為java中采取Unicode字符集，所以任何的Unicode中的字符都可以作為標識符的名稱，但考慮字符集的支持問題推薦還是使用英文字母命名。

23)關鍵字和保留字有區別嗎？

在1.5后沒有區別，都被稱作關鍵字，但是1.5之前認為關鍵字是在Java中有特殊用途的不允許編程人員擅自改作其他用途，而保留字是在Java中沒有特殊用途但不允許編程人員擅自改作其他用途，按此說法goto和const應該是此意義上的保留字。

24)true，false，null可以用作標識符命名嗎？

不可以，這3個雖然不是關鍵字，但都是有特殊用途的值，也不能作為標識符命名

25)一條聲明語句可以聲明多個變量嗎？ 可以的，例如以下聲明都是正確的int i;int i,j;int i = 10,j;int i,j = 10;

int i = 10,j = 20;

26)變量在沒有賦值的情況下可以使用嗎？

不可以，變量沒有賦值使用會報出變量未初始化的編譯錯誤。27)常量有什么特點？

在聲明變量的時候加上final修飾符即為常量，表示這個變量只能被賦一次值。

28)算數運算符有哪些？ 基本算數運算符有+-* / % ++--

29)單目運算符，雙目運算符，三目運算符都是什么意思？ 其實也有叫一元運算符，雙元操作符，三元操作符的，指的是

有幾個操作數形成一個完整表達式，例如++就是一個單目運算符，只需要一個操作數就可以形成表達式，像i++，而+運算符就是雙目運算符，需要兩個操作數形成表達式，例如5 + 3，還有三目運算符，例如5 > 3 ? 0 :-1

30)++和--放在前面和放在后面有什么區別？

如果是在一個表達式中，那++放后面表示先運算表達式，然后再進行自增運算，如果在一個表達式中，++放前面，則表示先進行自增運算然后在運算表達式。--同樣道理。例如： int i = 10;int j = i ++;//先進行賦值運算然后再進行自增運算j的結果是10

int i = 10;

int j = ++ i;//先進行自增運算然后再進行賦值運算

j的結果是11

31)-5 % 2等于幾，5 %-2等于幾？

-5 % 2等于-1，5%-2等于1，運算得到是正數還是負數取決于第一個操作數的符號 32)5 / 2 結果是不是2.5？

不是，是2，因為5和2都是int類型，所以不可能得到double型的結果。

33)比較運算符有哪些？

有><>=<===!= 六項基本比較運算 34)任何數據類型都可以使用> < >= <=運算符嗎？

不是所有數據類型，例如true>false這個表達式就是編譯錯誤，布爾類型和引用類型的表達式只能用==和！=兩個比較運算，例如”abc” <= ”xyz” 這個表達式也是編譯錯誤的 35)’a’ > ’b’這個表達式編譯正確嗎？

編譯正確，’a’和’b’是字符類型，內部用Unicode編碼表示的話a是97，b是98，所以實際上比較的是97>98，結果為false 36)邏輯運算符有哪些？

有 &邏輯與，|邏輯或，！邏輯非，^ 異或，&& 短路與，||短路或

37)邏輯與，邏輯或和短路與，短路或有什么區別？ 邏輯與和短路與的區別是： ?

如果是邏輯與&，不管第一個表達式是true還是false，都會執行第二個表達式，例如a > b & x < y，即使a > b為false，也會執行x > y ?

如果是短路與&&，如果第一個表達式為false，將不會執行第二個表達式

例如a > b && x < y，如果a > b為false，就不會執行x > y

以此類推，邏輯或和短路或的區別是：

? 如果是邏輯或|，不管第一個表達式是true還是false，都會執行第二個表達式 ?

如果是短路或||，如果第一個表達式為true，將不會執行

第二個表達式

38)與或非三個邏輯運算符的優先級是怎么排列的？ “非”優先級最高，“與”其次，“或”優先級最低 39)原碼，反碼，補碼分別是什么意思？ ?

原碼：將數字轉換為二進制，第一位為符號位，正數為0，負數為1

例如：12的原碼是00001100-12的原碼是10001100 ?

反碼：正數的反碼和原碼相同，負數的反碼將原碼符號位之外的位逐位取反

例如：12的反碼是00001100-12的反碼是11110011 ?

補碼：正數的補碼和原碼相同，負數的補碼將反碼加1 例如：12的補碼是00001100-12的補碼是11110100 最后強調一點，計算機存儲數據用補碼形式來存儲。40)位運算符都有哪些？

&與 |或 ^異或 ~非 >>右移 <<左移 >>>無符號右移 41)1<<35怎么理解？

1是int類型是32位，所以需要把35%32=3，所以事實上是和執行1<<3等價的42)數據類型轉換需要遵循什么原則？

小類型向大類型轉換，是自動轉換的，或者說隱式轉換的 大類型向小類型轉換，是需要強制轉換的，或者說顯式轉換例如：byte b = 1;

short s = b;//自動轉換

b =(byte)s;//強制轉換

43)byte b = 10這個語句是正確的，為什么10是int型比byte大還不需要強制轉換呢？

因為在java中做了特殊處理，其中規定byte，short，char類型可以直接賦予int類型的直接量，例如： byte b = 10;short s = 10;char c = 10;

以上賦值語句都是正確的。

但是不能超出超出類型的范圍，例如以下賦值就是錯誤的： byte b = 128;

如果超出范圍，必須得作強制轉換，例如以下語句是正確的： byte b =(byte)128;

需要強調的是，必須是int類型的直接量，以下語句就是錯誤的： byte b = 10L;

10L不是int類型的直接量。

44)byte b =(byte)300;強制轉換后的結果是44，是按照什么規律得出來的？

是先把300轉換成二進制，然后根據byte類型的大小截取了后8個位

300的補碼是00000000 00000000 00000001 00101100

b的結果是：00000000 00000000 00000001 00101100 結果為44 45)byte b =(byte)true;這個轉換成立嗎？

不成立，布爾值和數字是不兼容的，不能作任何轉換。

46)int i =(int)“100”;這個轉換成立嗎？

不成立，引用類型和基本類型是不能直接強制轉換的，需要用包裝類的方法來轉換。

47)char型和short型哪個比較大？

不能說哪個大，哪個小，這兩個類型char的取值是從0~65535，而short類型的取值是-32768~32767，這個兩個類型之間的轉換都需要強制轉換。

48)字符串是不是基本類型？

不是，String是java.lang包中的一個類，是引用類型的，8種基本類型中沒有一個是String類型。49)空字符串用什么來表示？

用””（兩個并列的雙引號）表示，代表0個長度的字符串對象。50)String s = “”;和String s = null;有什么區別？

第一個表示s被賦值，指向了一個字符串對象，第二個表示s沒有指向任何對象實例，是真空

51)兩個字符串用什么運算符可以連成一個字符串？ 用+運算符，例如”abc” + “xyz”最后的結果就是“abcxyz” 52)數學運算符加法和字符串連接符都是+，怎么區分？ 是通過運算符兩邊的操作數來判斷的，如果兩邊的操作數都是數字型的基本類型，則進行數學運算，如果兩邊的操作數有一個是字符串，則把另一個操作數也轉換為則進行字符串連接運算。例如：+ 4 的結果是9 “5” + 4的結果是54

53)判斷字符串內容相同用什么方法？

用equals方法判斷內容相同，==只能判斷引用是否相同 54)提供用戶輸入使用哪個類 使用javav.util.Scanner類

55)if語句可以用if(-1)形式判斷嗎？ 不可以，數字不能代替布爾值

56)if語句和循環語句的花括號什么時候可以省略？

當執行的語句只有一句的時候 57)switch語句有哪些規則？

表達式expr的返回值必須是下述幾種類型之一：int, byte, char, short或枚舉常量；

case子句中的值必須是常量，且所有case子句中的值應是不同的，也必須是下述幾種類型之一：int, byte, char, short或枚舉常量

default子句是任選的；

break語句用來在執行完一個case分支后使程序跳出switch語句塊；

58)對于退出循環break和continue有什么區別？ break是退出整個循環

continue是退出當前循環繼續下一次循環 59)聲明數組創建數組的方法？ 以下聲明都是合法的： int [] a;int a[];String[] a;

以下創建數組對象都是合法的： int[] a = new int[3];int[] a = {1,2,3};int[] a = new int[] {1,2,3};

60)int[] x和String[] s這兩個數組對象，哪個是基本類型，哪個是引用類型？

兩個都是數組對象，都是引用類型的61)數組元素下標最小是多少，最大是多少，超出范圍會怎么樣？

最小是0，最大是數組元素個數減一，超出范圍將會出現下標越界異常

62)得到數組長度用length屬性還是length（）方法？ 是length屬性，得到字符串長度才有length方法

63)聲明int[][] a = new int[3][]，a是一個二維數組，a[0]本身

是什么類型的？

二維數組的元素都是一維數組，a[0]是int[]類型的 64)數組的大小一經創建可不可以改變大小了？ 不可以，數組是定長的，一經創建就不能再改變大小了 65)可以把2個int型，3個double型，4個String型的值放到一個數組中嗎？

不可以，數組的元素類型必須是相同類型的。66)java中的多維數組必須是要形成矩陣排列嗎？ 不一定，也可以是不規則的。67)操作數組比較方便的實用類？

java.util.Arrays類提供了很多關于數組的實用方法。第4章對象和類 1)OOP是什么意思？ Object Oriented Programming(面向對象編程)

2)

類和對象的區別？

類：對象的藍圖，生成對象的模板，是對一類事物的描述，是抽象的概念上的定義

對象：對象是實際存在的該類事物的每個個體，因而也稱為實例 3)

類之間的3種關系？ 依賴關系（uses-a）聚集關系（has-a）繼承關系（is-a）4)

一個java源文件可以寫多個類嗎？

可以，但必須只能有一個公有類，并且文件名和公有類的類名相同。5)類中有哪些成員？

有屬性（數據域），方法，構造器（構造方法）

6)

構造方法和普通方法的區別？

構造方法沒有返回值，方法名必須和類名相同，需要用new語句調用構造方法。7)

普通方法可不可以也類名作為方法名？

是可以的，因為調用普通方法的語法和調用構造器的語法不一樣。8)

一個構造器調用另外一個構造器需要用什么語法？ 用this（）語法調用另外一個重載構造器，需要注意的是調用語句必須是構造器中的第一句 9)

什么時候虛擬機會自動添加一個默認構造器？

當類中沒有顯式定義任何構造器的時候，虛擬機會自動添加一個無參的構造器

10)實例成員和靜態成員的區別？

實例成員：是屬于對象實例的，用對象.成員名稱語法調用 靜態成員：和對象實例無關，是屬于類本身的，用類名.成員名稱語法調用

11)靜態初始化塊statci{}的執行時機是什么時候？ 在類被加載的時候，僅執行一次。

12)靜態方法可不可以直接調用同一個類中的非靜態方法？ 不可以，靜態方法不能直接調用一個非靜態成員，需要用對象調用。

13)包是什么？

包實際上就是物理上的文件夾，可以把類放到不同的包中。14)把一個類放到包中，需要在類中加上什么語句？ 需要加上包聲明package語句，必須寫在源文件的第一句。15)什么時候需要導入類？用什么語句？

當使用的類和當前類并不在同一個包中的時候，用import語句導入。

16)默認包中的類可以導入嗎？

不可以，不在默認包中的類無法使用默認包中的類。17)java中哪個包中的類是自動導入的？ java.lang包

18)什么叫做完整類名？ 頂層包名.子包名.類名

19)靜態導入語句有什么作用？

在使用類中的靜態成員的時候前面不需要加類名前綴。

20)局部變量和全局變量的區別？ 區別 局部變量 全局變量

聲明位置 方法或塊內部 方法外類內部 訪問權限修飾符 沒有訪問權限 有訪問權限

默認值 沒有默認值

有默認值

使用形式 直接使用 對象調用

作用域

在方法或語句塊內部 整個類

生命周期 進入方法或語句塊創建退出方法或語句塊銷毀 隨著對象的創建而創建隨著對象的銷毀而銷毀

21)賦值語句賦給目標的是值還是引用？

如果是基本類型則賦的是值本身，引用類型則賦的是引用地址 第5章繼承和多態 1)類的繼承是誰繼承誰？

是子類繼承了父類，子類也稱為派生類，父類也稱為超類或基

類 2)子類繼承了父類的什么東西？

子類可以繼承父類的數據域（屬性），方法，但構造器不能繼

承 3)

私有成員能被子類繼承嗎？

能繼承，但是由于訪問權限的控制，在子類中不能直接使用父類的私有成員 4)

Object是什么類？

這個所有類的根類，任何類如果沒有寫顯式的繼承語句，默認都是直接繼承Object類的 5)java中是單繼承還是多繼承？

是單繼承，一個子類只能有一個父類 6)

訪問權限修飾符有幾種，訪問的范圍又是多大？ 有四種：

private：私用 只能在被類中被訪問 default：默認 只能被同一個包中的類訪問

protected：受保護的 只能被同一個包中的類和不同包中的子類

訪問

public：公有 可以被任何類訪問 7)

覆蓋方法的規則有哪些？

子類覆蓋方法和父類被覆蓋方法的方法返回類型，方法名稱，參數列表必須相同

子類覆蓋方法的訪問權限必須大于等于父類的方法的訪問權限

方法覆蓋只能存在于子類和父類之間

子類覆蓋方法不能比父類被覆蓋方法拋出更多異常 8)

參數列表是否相同從哪幾方面看？

從三方面看：參數個數，類型和順序，需要注意的是參數的名字不相同是無所謂的 9)

覆蓋方法的規則有哪些？ 方法名相同

方法的參數類型,個數,順序至少有一項不同 方法的返回類型和修飾符均不受限制

10)可變長參數的聲明格式是什么？實際上是什么類型的？ 類型 ? 變量，實際上是一個一維數組 11)this和super是作什么用處的？

this：本身代表當前的對象引用，可以用this.成員名稱調用當前對象的屬性和方法，如果屬性和局部變量重名，可以用this.屬性名和局部變量區分開。也可以用this（）語法調用本類重載構造器。

super：本事是一個特殊關鍵字，可以用super.成員名稱調用從父類繼承的屬性和方法，也可以用super（）語法調用父類構造器。

12)super代表子類中的父類對象引用嗎？

不，這個錯誤的說法，super不代表任何對象引用，僅僅是一個關鍵字

13)什么時候子類構造器會自動調用父類無參構造器？ 當子類構造器中沒有任何顯式構造器調用的時候，即既沒有this（）調用也沒有super（）調用的時候

14)一個父類類型的引用變量可以引用一個子類的實例嗎？ 可以，這個引用變量是一個多態對象 15)多態對象有什么特點？

多態對象只能使用父類的成員，但如果多態對象使用了被子類覆蓋的方法，則會動態綁定使用子類的成員，稱為虛擬方法調用

16)引用類型之間的類型轉換需要遵循哪些規則？ 自動轉換：從子類到父類的類型可以自動轉換 強制轉換：從父類到子類的類型要強制轉換 無繼承關系的類型轉換是非法的 17)instanceof操作符是作什么用處的？

可以判斷一個對象的類型是否是某一個類的類型或子類，也可以判斷這個對象的類型是否是一個接口的實現類 18)toString方法什么時候會自動被調用？

在打印語句中傳入引用類型的對象或者對象和字符串作連接時

19)默認的equals方法實現的是比較內容還是比較引用地址？

在Object中是比較引用地址。

20)覆蓋equals方法和hashCode方法有什么規則？ 必須保證當兩個對象equals比較為true的時候，返回的hashCode相同，當比較為false的時候，返回的hashCode不同21)java中有幾個包裝類？

有8個包裝類，正好對應8種基本數據類型。

分別是：Boolean Byte Short Integer Long Character Float Double 22)裝箱和拆箱分別是什么意思？

裝箱指的是把基本類型包裝成包裝類的引用類型 拆箱指的是把包裝類形式的引用類型轉換為基本類型 例如：

Integer objInt = new Integer(10);//裝箱

int i = objInt.intValue();

//拆箱

23)JDK1.4和1.5的裝箱和拆箱有什么區別?

自動拆裝箱，例如： Integer intObj = 10;//自動裝箱 int i = intObj + 5;//自動拆箱

24)final修飾符如何使用，使用了final修飾符有什么特點？ final修飾符可以修飾類，方法，變量 final類為最終類，不能被子類繼承 final方法為最終方法，不能被子類覆蓋 final變量為常量，只能賦一次值

25)abstract修飾符如何使用，使用了abstract修飾符有什么特點？

abstract修飾符可以修飾類和方法 abstract類為抽象類，是不能創建對象的abstract方法為抽象方法，只有方法的聲明，沒有具體的實現 需要注意的是：

有抽象方法的類一定是抽象類 抽象類不一定有抽象方法

抽象類也有構造器，但不能創建對象實例 26)abstract不能和哪些修飾符配合使用？ 不能和private，static，final一起使用 27)可以在非抽象方法中調用抽象方法嗎？ 可以，模板方法設計模式就是典型的這種調用 第6章 泛型程序設計 1)泛型的特點是什么？ 主要特點是類型參數化，后期綁定數據類型 2)泛型支持基本類型嗎？

不支持，只支持引用類型 3)如果沒有傳入類型參數，默認是什么類型？ 默認是Object類型

4)泛型方法有什么特點？

將泛型參數聲明在方法中，調用方法的時候綁定泛型 5)

泛型類聲明泛型參數的時候，表示什

么意思？

表示綁定的類型必須是A類型后者是A類型的子類或實現類 第7章 接口和內部類

1)聲明一個接口的關鍵字是什么？ interface關鍵字

2)

接口中的成員有什么特點？

數據域必須是（public static final修飾）公有靜態常量 方法必須是（public abstract修飾）公有抽象 沒有構造方法 3)接口能創建對象實例嗎？ 不能，接口沒有構造器，不能創建對象

4)

接口和類的關系？

接口和類之間是實現關系，一個類用implements語句實現了某接口，這個類被稱為接口的實現類，一個類可以實現多個接口，一個類實現了某接口，必須覆蓋這個接口中的所以方法，否則這個類必須是個抽象類 5)

接口和接口的關系？

接口和接口之間是繼承關系，一個接口用extends繼承另外一個接口，稱為這個接口的子接口。一個接口可以繼承多個父接口 6)

內部類如何定義？

一個類聲明在另一個類的里面，這個類就被稱為內部類，而外面的類被稱為外部類 7)

內部類可以分成幾種？

實例內部類：聲明在方法外邊沒有static修飾符 靜態內部類：聲明在方法外邊有static修飾符 局部內部類：聲明在方法里邊 8)

如何創建實例內部類的對象實例？ 需要用外部類的對象來創建 例如： class A {class B {

}

}

如果像創建B類的實例，則必須用以下語句： A a = new A();A.B b = a.new B();9)

如何在實例內部類中訪問外部類的成員？

在實例內部類中可以直接使用外部類的成員，不需要創建外部類的對象實例，但是如果在內部類中的成員名稱屏蔽隱藏了外部類的成員（即外部類和內部類的成員名相同），則需要用“外部類名.this.成員名”訪問外部類成員 第8章異常處理

1)異常的對象的根類是哪個類？ 是Throwable類

2)

Throwable類有哪兩個分支？

分成Error類和Excepion類兩個分支 Error類表示嚴重錯誤

Exception類表示可以在程序中處理的錯誤 3)

Exception類有哪兩個分支？

分成運行時異常和非運行時異常（已檢查異常）運行時異常編譯不檢查，在運行時才會發生異常

已檢查異常編譯時就會作檢查，不處理異常則通不過編譯 4)如果在try塊中發生異常，那么程序將會跳轉到哪？ 會跳轉到catch語句塊 5)catch語句可以用父類類型捕獲子類異常嗎？ 因為有多態特點，是可以的6)處理異常代碼finally語句會在什么時候執行？ finally代碼在任何時候都會執行，不管有沒有發生異常。7)

如何聲明已檢查異常，由誰來處理這個異常？ 用throws語句來聲明一個已檢查異常，由方法的調用者來處理這個異常 8)

如何拋出一個異常？ 用throw語句拋出

9)如何創建一個自定義的異常類？ 創建一個類，只要讓它繼承任何一個現有的異常類就可以了 10)覆蓋方法對于異常有什么要求？ 覆蓋方法不能比父類方法拋出更多異常 第9章反射，代理，標注

1)

獲得一個類型的Class對象有哪幾種途徑？

方法1：對象.getClass()方法2：類型名.class 方法3：Class.forName()2)

反射相關的類型都有哪些？ Class 代表一個運行時類 Field 代表一個類的屬性 Method 代表一個類的方法 Constructor 代筆一個類的構造器 3)

如何聲明一個自定義標注？ [<修飾符>] @interface <標注名>{ 返回值方法名稱（）； 返回值方法名稱（）； ?? } 例如：

public @interface MyComment { int id();String info();} 4)

java有幾個內置標注？ 有3個

@Override——用于修飾此方法覆蓋了父類的方法，而非重載。@Deprecated——用于修飾已經過時的方法。

@SuppressWarnings——用于通知Java編譯器禁止特定的警告。第10章 java常用類 1)

字符串String是可變類還是不可變類？

是不可變類，一經創建就不能修改其內容了 2)

字符串的常用方法有哪些？ charAt方法：可以返回指定位置的字符 substring方法：可以截取子字符串 length方法：返回字符串長度 indexOf方法：查找子串的位置 lastIndexOf方法：反向搜索字串的位置 replaceAll方法：替換字符串 split方法：分解字符串

toLowerCase, toUpperCase方法：字符串大小寫轉換 3)StringBuffer類和String類有什么區別？ StringBuffer是可變類，String是不可變類

4)StringBuffer類和StringBuilder類有什么區別？ StringBuffer類是線程安全的，StringBuilder類是線程不安全的5)Math類主要提供了哪些方法？

Math類提供了大量的和數學運算相關的靜態方法 6)Set集合和List集合共同的父接口是什么？ 是Collection集合7)

Set集合和List集合有什么區別？ Set: Collection的子接口，不記錄元素的保存順序，且不允許有重復元素

List: Collection的子接口，記錄元素的保存順序，且允許有重復元素 8)

ArrayList和LinkedList有什么不同？

ArrayList 的內部實現是基于內部數組Object[]，所以從概念上

講它更像數組

LinkedList的內部實現是基于一組連接的記錄，所以它更象一個鏈表 結構，所以它們在性能上有很大的差別。ArrayList 隨機訪問比較塊，但插入和刪除元素比較慢 LinkedList但插入和刪除元素比較快，但隨機訪問比較慢 9)

HashTable和HashMap有什么不同？

HashTable是線程安全的，HashMap是線程不安全的10)Vector和ArrayList有什么不同？ Vector是線程安全的ArrayList是線程不安全的 第11章 IO流 1)

流分成哪兩類？

按照單位劃分分成字節流和字符流。按輸入輸出分成輸入流和輸出流 2)

和文件流相關的有那幾個類？ FileInputStream文件輸入字節流 FileOutputStream文件輸出字節流 FileReader文件輸入字符流 FileWriter文件輸出字符流 3)

文件流操作應該用字節流還是字符流？ 如果是純文本文件應該用字符流 如果是二進制文件應該用字節流 4)

文件操作用哪個類？ 用java.io.File類 第12章 線程 1)

創建一個線程類的兩種方式？ 繼承Thread類 實現Runnable接口 2)線程體應該放在哪個方法里面？ run方法 3)啟動新的線程用什么方法？

用start方法

4)一個線程對象能夠用start多次啟動嗎？ 不可以，一個線程方法只能start一次

5)線程有哪幾種主要狀態？ 有四種，分別是：新生狀態，可運行狀態，阻塞狀態，死亡狀

態 6)

線程的同步需要用什么方法？ 舊的方法是用synchronized關鍵字

新的方法是用ReentrantLock類的lock和unlock方法

第三篇：Java基礎知識點總結-Ch1

Java基礎知識點總結

第一章 Java語言概述

1.面性對象語言的基本特征。

Java語言的特點。最大優勢。

Java語言是區分大小寫的。

2.Java虛擬機的核心。

環境變量classpath設置中的“.；”是指可以加載應用程序當前目錄及其子目錄中的類。環境變量的變量值的最后是以“rt.jar；.；”結束。

3.編寫源文件時不可以使用Word編輯器，因為他含有不可見字符。

要用記事本或Edit。源文件的擴展名是java。

4.一個Java應用程序的源文件必須有一個類含有public static void main(String args[ ])的方法，這樣類的應用程序叫做主類。

5.源文件的名稱必須與有public修飾的類的名稱相同。

若源文件有多個類，那么只能有一個是public類；

若只有一個類是 public類，那么源文件的名字必須與這個類的名字完全相同，擴展名是.java；

若源文件沒有public類，那么源文件的名字只要和某個類的名字相同即可，并且擴展名為.java。

6.編譯時，Java編譯器是什么。

進入某個文件夾的命令是“cd 目錄名”；退出某個文件夾的命令是“cd..”。

7.編譯源文件后將生成多個擴展名為.class的文件，每個擴展名是.class的文件夾存放一個類的字節碼文件，文件名與該類的類名相同。這些字節碼文件被存放在與源文件相同的目錄中。

8.運行時，Java解釋器是什么。

Java應用程序總是從主類的main方法開始執行。

9.在運行字節碼文件是不可以帶有擴展名。

當Java應用程序有多個類時，Java命令執行的類名必須是主類的名字（不帶擴展名）。

10.例子：有一個源文件名字叫Apple.java，其中包括3個類，名字分別是Apple, Banana, Orange,有1個是主類,則主類名是什么，生成多少個字節碼文件，字節碼文件名稱是什么，在編譯，運行時語句分別是怎樣的。

11.Application程序又稱什么，Applet程序又稱什么，哪一個是源文件編譯時運行的程序。

12.J開發一個Java程序要經過的三個步驟。

13.單行注釋，多行注釋的標記分別是什么

14．javac *.java的意思。

15.Allmans風格又稱什么，Kernighan風格又稱什么，兩者各自的意思是什么。

第四篇：Java學習_基礎總結

現在學習JAVA的人越來越多！但是學的好的，能用到工作中去的卻很少很少，下面就是我為大家總結歸納的一些JAVA學習基礎，希望大家少走彎路，盡快投入到工作中去！

Java 學習基礎總結歸納！

1、作用域public,private,protected,以及不寫時的區別

答：區別如下：

作用域

當前類

同一package

子孫類

其他package public

√

√

√

√

protected

√

√

√

×

friendly

√

√

×

×

private

√

×

×

×

不寫時默認為friendly

2、Anonymous Inner Class(匿名內部類)是否可以extends(繼承)其它類，是否可以implements(實現)interface(接口)

答：匿名的內部類是沒有名字的內部類。不能extends(繼承)其它類，但一個內部類可以作為一個接口，由另一個內部類實現

3、Static Nested Class 和 Inner Class的不同

答：Nested Class（一般是C++的說法），Inner Class(一般是JAVA的說法)。Java內部類與C++嵌套類最大的不同就在于是否有指向外部的引用上。注： 靜態內部類（Inner Class）意味著1創建一個static內部類的對象，不需要一個外部類對象，2不能從一個static內部類的一個對象訪問一個外部類對象

4、&和&&的區別

答：&是位運算符，表示按位與運算，&&是邏輯運算符，表示邏輯與（and）

5、Collection 和 Collections的區別

答：Collection是集合類的上級接口，繼承與他的接口主要有Set 和List.Collections是針對集合類的一個幫助類，他提供一系列靜態方法實現對各種集合的搜索、排序、線程安全化等操作

6、什么時候用assert

答：assertion(斷言)在軟件開發中是一種常用的調試方式，很多開發語言中都支持這種機制。在實現中，assertion就是在程序中的一條語句，它對一個boolean表達式進行檢查，一個正確程序必須保證這個boolean表達式的值為true；如果該值為false，說明程序已經處于不正確的狀態下，系統將給出警告或退出。一般來說，assertion用于保證程序最基本、關鍵的正確性。assertion檢查通常在開發和測試時開啟。為了提高性能，在軟件發布后，assertion檢查通常是關閉的

7、String s = new String(“xyz”);創建了幾個String Object

答：兩個，一個字符對象，一個字符對象引用對象

8、Math.round(11.5)等於多少? Math.round(-11.5)等於多少

答: Math.round(11.5)==12;Math.round(-11.5)==-11;round方法返回與參數最接近的長整數，參數加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中的保留字，現在沒有在java中使用

11、數組有沒有length()這個方法? String有沒有length()這個方法

答：數組沒有length()這個方法，有length的屬性。String有有length()這個方法

12、Overload和Override的區別。Overloaded的方法是否可以改變返回值的類型

答：方法的重寫Overriding和重載Overloading是Java多態性的不同表現。重寫Overriding是父類與子類之間多態性的一種表現，重載Overloading是一個類中多態性的一種表現。如果在子類中定義某方法與其父類有相同的名稱和參數，我們說該方法被重寫(Overriding)。子類的對象使用這個方法時，將調用子類中的定義，對它而言，父類中的定義如同被“屏蔽”了。如果在一個類中定義了多個同名的方法，它們或有不同的參數個數或有不同的參數類型，則稱為方法的重載(Overloading)。Overloaded的方法是可以改變返回值的類型

13、Set里的元素是不能重復的，那么用什么方法來區分重復與否呢? 是用==還是equals()? 它們有何區別

答：Set里的元素是不能重復的，那么用iterator()方法來區分重復與否。equals()是判讀兩個Set是否相等 equals()和==方法決定引用值是否指向同一對象equals()在類中被覆蓋，為的是當兩個分離的對象的內容和類型相配的話，返回真值

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有什么區別 答：error 表示恢復不是不可能但很困難的情況下的一種嚴重問題。比如說內存溢出。不可能指望程序能處理這樣的情況 exception 表示一種設計或實現問題。也就是說，它表示如果程序運行正常，從不會發生的情況

16、List, Set, Map是否繼承自Collection接口

答： List，Set是，Map不是

17、abstract class和interface有什么區別

答：聲明方法的存在而不去實現它的類被叫做抽象類（abstract class），它用于要創建一個體現某些基本行為的類，并為該類聲明方法，但不能在該類中實現該類的情況。不能創建abstract 類的實例。然而可以創建一個變量，其類型是一個抽象類，并讓它指向具體子類的一個實例。不能有抽象構造函數或抽象靜態方法。Abstract 類的子類為它們父類中的所有抽象方法提供實現，否則它們也是抽象類為。取而代之，在子類中實現該方法。知道其行為的其它類可以在類中實現這些方法接口（interface）是抽象類的變體。在接口中，所有方法都是抽象的。多繼承性可通過實現這樣的接口而獲得。接口中的所有方法都是抽象的，沒有一個有程序體。接口只可以定義static final成員變量。接口的實現與子類相似，除了該實現類不能從接口定義中繼承行為。當類實現特殊接口時，它定義（即將程序體給予）所有這種接口的方法。然后，它可以在實現了該接口的類的任何對象上調用接口的方法。由于有抽象類，它允許使用接口名作為引用變量的類型。通常的動態聯編將生效。引用可以轉換到接口類型或從接口類型轉換，instanceof 運算符可以用來決定某對象的類是否實現了接口

18、abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized

答：都不能

19、接口是否可繼承接口? 抽象類是否可實現(implements)接口? 抽象類是否可繼承實體類(concrete class)

答：接口可以繼承接口。抽象類可以實現(implements)接口，抽象類是否可繼承實體類，但前提是實體類必須有明確的構造函數

20、構造器Constructor是否可被override

答：構造器Constructor不能被繼承，因此不能重寫Overriding，但可以被重載Overloading

21、是否可以繼承String類

答：String類是final類故不可以繼承

22、try {}里有一個return語句，那么緊跟在這個try后的finally {}里的code會不會被執行，什么時候被執行，在return前還是后

答：會執行，在return前執行

23、用最有效率的方法算出2乘以8等於幾 答：2 << 3

24、兩個對象值相同(x.equals(y)== true)，但卻可有不同的hash code，這句話對不對

答：不對，有相同的hash code

25、當一個對象被當作參數傳遞到一個方法后，此方法可改變這個對象的屬性，并可返回變化后的結果，那么這里到底是值傳遞還是引用傳遞

答：是值傳遞。Java 編程語言只有值傳遞參數。當一個對象實例作為一個參數被傳遞到方法中時，參數的值就是對該對象的引用。對象的內容可以在被調用的方法中改變，但對象的引用是永遠不會改變的

26、swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上

答：witch（expr1）中，expr1是一個整數表達式。因此傳遞給 switch 和 case 語句的參數應該是 int、short、char 或者 byte。long,string 都不能作用于swtich

27、ArrayList和Vector的區別,HashMap和Hashtable的區別

答：就ArrayList與Vector主要從二方面來說.一.同步性:Vector是線程安全的，也就是說是同步的，而ArrayList是線程序不安全的，不是同步的二.數據增長:當需要增長時,Vector默認增長為原來一培，而ArrayList卻是原來的一半就HashMap與HashTable主要從三方面來說。一.歷史原因:Hashtable是基于陳舊的Dictionary類的，HashMap是Java 1.2引進的Map接口的一個實現二.同步性:Hashtable是線程安全的，也就是說是同步的，而HashMap是線程序不安全的，不是同步的三.值：只有HashMap可以讓你將空值作為一個表的條目的key或value

28、char型變量中能不能存貯一個中文漢字?為什么? 答：是能夠定義成為一個中文的，因為java中以unicode編碼，一個char占16個字節，所以放一個中文是沒問題的

29、GC是什么? 為什么要有GC

答：GC是垃圾收集的意思（Gabage Collection）,內存處理是編程人員容易出現問題的地方，忘記或者錯誤的內存回收會導致程序或系統的不穩定甚至崩潰，Java提供的GC功能可以自動監測對象是否超過作用域從而達到自動回收內存的目的，Java語言沒有提供釋放已分配內存的顯示操作方法。

30、float型float f=3.4是否正確?

答:不正確。精度不準確,應該用強制類型轉換，如下所示：float f=(float)3.4

31、介紹JAVA中的Collection FrameWork(包括如何寫自己的數據結構)?

答：Collection FrameWork如下： Collection ├List │├LinkedList │├ArrayList │└Vector │ └Stack └Set Map ├Hashtable ├HashMap └WeakHashMap Collection是最基本的集合接口，一個Collection代表一組Object，即Collection的元素（Elements）Map提供key到value的映射

32、抽象類與接口？

答：抽象類與接口都用于抽象，但是抽象類(JAVA中)可以有自己的部分實現，而接口則完全是一個標識(同時有多重繼承的功能)。JAVA類實現序例化的方法是實現java.io.Serializable接口 Collection框架中實現比較要實現Comparable 接口和 Comparator 接口

33、String與StringBuffer的區別。

答：STRING的長度是不可變的，STRINGBUFFER的長度是可變的。如果你對字符串中的內容經常進行操作，特別是內容要修改時，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toString()方法

34、談談final, finally, finalize的區別

答：final—修飾符（關鍵字）如果一個類被聲明為final，意味著它不能再派生出新的子類，不能作為父類被繼承。因此一個類不能既被聲明為 abstract的，又被聲明為final的。將變量或方法聲明為final，可以保證它們在使用中不被改變。被聲明為final的變量必須在聲明時給定初值，而在以后的引用中只能讀取，不可修改。被聲明為final的方法也同樣只能使用，不能重載 finally—再異常處理時提供 finally 塊來執行任何清除操作。如果拋出一個異常，那么相匹配的 catch 子句就會執行，然后控制就會進入 finally 塊（如果有的話）finalize—方法名。Java 技術允許使用 finalize()方法在垃圾收集器將對象從內存中清除出去之前做必要的清理工作。這個方法是由垃圾收集器在確定這個對象沒有被引用時對這個對象調用的。它是在 Object 類中定義的，因此所有的類都繼承了它。子類覆蓋 finalize()方法以整理系統資源或者執行其他清理工作。finalize()方法是在垃圾收集器刪除對象之前對這個對象調用的

35、面向對象的特征有哪些方面

答：主要有以下四方面：

1.抽象：抽象就是忽略一個主題中與當前目標無關的那些方面，以便更充分地注意與當前目標有關的方面。抽象并不打算了解全部問題，而只是選擇其中的一部分，暫時不用部分細節。抽象包括兩個方面，一是過程抽象，二是數據抽象。

2.繼承：繼承是一種聯結類的層次模型，并且允許和鼓勵類的重用，它提供了一種明確表述共性的方法。對象的一個新類可以從現有的類中派生，這個過程稱為類繼承。新類繼承了原始類的特性，新類稱為原始類的派生類（子類），而原始類稱為新類的基類（父類）。派生類可以從它的基類那里繼承方法和實例變量，并且類可以修改或增加新的方法使之更適合特殊的需要。

3.封裝：封裝是把過程和數據包圍起來，對數據的訪問只能通過已定義的界面。面向對象計算始于這個基本概念，即現實世界可以被描繪成一系列完全自治、封裝的對象，這些對象通過一個受保護的接口訪問其他對象。4.多態性：多態性是指允許不同類的對象對同一消息作出響應。多態性包括參數化多態性和包含多態性。多態性語言具有靈活、抽象、行為共享、代碼共享的優勢，很好的解決了應用程序函數同名問題。

36、String是最基本的數據類型嗎

答：基本數據類型包括byte、int、char、long、float、double、boolean和short。java.lang.String類是final類型的，因此不可以繼承這個類、不能修改這個類。為了提高效率節省空間，我們應該用StringBuffer類

37、int 和 Integer 有什么區別

答：Java 提供兩種不同的類型：引用類型和原始類型（或內置類型）。Int是java的原始數據類型，Integer是java為int提供的封裝類。Java為每個原始類型提供了封裝類。原始類型封裝類

booleanBoolean,charCharacter,byteByte,shortShort,intInteger,longLong,floatFloat,doubleDouble 引用類型和原始類型的行為完全不同，并且它們具有不同的語義。引用類型和原始類型具有不同的特征和用法，它們包括：大小和速度問題，這種類型以哪種類型的數據結構存儲，當引用類型和原始類型用作某個類的實例數據時所指定的缺省值。對象引用實例變量的缺省值為 null，而原始類型實例變量的缺省值與它們的類型有關

38、運行時異常與一般異常有何異同

答：異常表示程序運行過程中可能出現的非正常狀態，運行時異常表示虛擬機的通常操作中可能遇到的異常，是一種常見運行錯誤。java編譯器要求方法必須聲明拋出可能發生的非運行時異常，但是并不要求必須聲明拋出未被捕獲的運行時異常。

39、說出ArrayList,Vector, LinkedList的存儲性能和特性

答：ArrayList和Vector都是使用數組方式存儲數據，此數組元素數大于實際存儲的數據以便增加和插入元素，它們都允許直接按序號索引元素，但是插入元素要涉及數組元素移動等內存操作，所以索引數據快而插入數據慢，Vector由于使用了synchronized方法（線程安全），通常性能上較ArrayList差，而LinkedList使用雙向鏈表實現存儲，按序號索引數據需要進行前向或后向遍歷，但是插入數據時只需要記錄本項的前后項即可，所以插入速度較快。

40、HashMap和Hashtable的區別

答：HashMap是Hashtable的輕量級實現（非線程安全的實現），他們都完成了Map接口，主要區別在于HashMap允許空（null）鍵值（key）,由于非線程安全，效率上可能高于Hashtable。HashMap允許將null作為一個entry的key或者value，而Hashtable不允許。HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因為contains方法容易讓人引起誤解。Hashtable繼承自Dictionary類，而HashMap是Java1.2引進的Map interface的一個實現。最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多個線程訪問Hashtable時，不需要自己為它的方法實現同步，而HashMap 就必須為之提供外同步。Hashtable和HashMap采用的hash/rehash算法都大概一樣，所以性能不會有很大的差異。

41、heap和stack有什么區別

答：棧是一種線形集合，其添加和刪除元素的操作應在同一段完成。棧按照后進先出的方式進行處理。堆是棧的一個組成元素

42、Java的接口和C++的虛類的相同和不同處

答：由于Java不支持多繼承，而有可能某個類或對象要使用分別在幾個類或對象里面的方法或屬性，現有的單繼承機制就不能滿足要求。與繼承相比，接口有更高的靈活性，因為接口中沒有任何實現代碼。當一個類實現了接口以后，該類要實現接口里面所有的方法和屬性，并且接口里面的屬性在默認狀態下面都是public static,所有方法默認情況下是public.一個類可以實現多個接口。

43、Java中的異常處理機制的簡單原理和應用

答：當JAVA程序違反了JAVA的語義規則時，JAVA虛擬機就會將發生的錯誤表示為一個異常。違反語義規則包括2種情況。一種是JAVA類庫內置的語義檢查。例如數組下標越界,會引發IndexOutOfBoundsException;訪問null的對象時會引發NullPointerException。另一種情況就是JAVA允許程序員擴展這種語義檢查，程序員可以創建自己的異常，并自由選擇在何時用throw關鍵字引發異常。所有的異常都是java.lang.Thowable的子類。

43、垃圾回收的優點和原理。并考慮2種回收機制

答：Java語言中一個顯著的特點就是引入了垃圾回收機制，使c++程序員最頭疼的內存管理的問題迎刃而解，它使得Java程序員在編寫程序的時候不再需要考慮內存管理。由于有個垃圾回收機制，Java中的對象不再有“作用域”的概念，只有對象的引用才有“作用域”。垃圾回收可以有效的防止內存泄露，有效的使用可以使用的內存。垃圾回收器通常是作為一個單獨的低級別的線程運行，不可預知的情況下對內存堆中已經死亡的或者長時間沒有使用的對象進行清楚和回收，程序員不能實時的調用垃圾回收器對某個對象或所有對象進行垃圾回收。回收機制有分代復制垃圾回收和標記垃圾回收，增量垃圾回收。

44、你所知道的集合類都有哪些？主要方法？

答：最常用的集合類是 List 和 Map。List 的具體實現包括 ArrayList 和 Vector，它們是可變大小的列表，比較適合構建、存儲和操作任何類型對象的元素列表。List 適用于按數值索引訪問元素的情形。Map 提供了一個更通用的元素存儲方法。Map 集合類用于存儲元素對（稱作“鍵”和“值”），其中每個鍵映射到一個值。

45、描述一下JVM加載class文件的原理機制?

答：JVM中類的裝載是由ClassLoader和它的子類來實現的,Java ClassLoader 是一個重要的Java運行時系統組件。它負責在運行時查找和裝入類文件的類。

46、排序都有哪幾種方法？請列舉

答： 排序的方法有：插入排序（直接插入排序、希爾排序），交換排序（冒泡排序、快速排序），選擇排序（直接選擇排序、堆排序），歸并排序，分配排序（箱排序、基數排序）快速排序的偽代碼。/ /使用快速排序方法對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類或其它子類的實例。當一個方法出現異常后便拋出一個異常對象，該對象中包含有異常信息，調用這個對象的方法可以捕獲到這個異常并進行處理。Java的異常處理是通過5個關鍵詞來實現的：try、catch、throw、throws和finally。一般情況下是用try來執行一段程序，如果出現異常，系統會拋出（throws）一個異常，這時候你可以通過它的類型來捕捉（catch）它，或最后（finally）由缺省處理器來處理。用try來指定一塊預防所有“異常”的程序。緊跟在try程序后面，應包含一個catch子句來指定你想要捕捉的“異常”的類型。throw語句用來明確地拋出一個“異常”。throws用來標明一個成員函數可能拋出的各種“異常”。Finally為確保一段代碼不管發生什么“異常”都被執行一段代碼。可以在一個成員函數調用的外面寫一個try語句，在這個成員函數內部寫另一個try語句保護其他代碼。每當遇到一個try語句，“異常”的框架就放到堆棧上面，直到所有的try語句都完成。如果下一級的try語句沒有對某種“異常”進行處理，堆棧就會展開，直到遇到有處理這種“異常”的try語句。

48、一個“.java”源文件中是否可以包括多個類（不是內部類）？有什么限制？

答：可以。必須只有一個類名與文件名相同。

49、java中有幾種類型的流？JDK為每種類型的流提供了一些抽象類以供繼承，請說出他們分別是哪些類？

答：字節流，字符流。字節流繼承于InputStream OutputStream，字符流繼承于InputStreamReader OutputStreamWriter。在java.io包中還有許多其他的流，主要是為了提高性能和使用方便。

50、java中會存在內存泄漏嗎，請簡單描述。

答：會。自己實現堆載的數據結構時有可能會出現內存泄露，可參看effective java.51、java中實現多態的機制是什么？

答：方法的重寫Overriding和重載Overloading是Java多態性的不同表現。重寫Overriding是父類與子類之間多態性的一種表現，重載Overloading是一個類中多態性的一種表現。

52、垃圾回收器的基本原理是什么？垃圾回收器可以馬上回收內存嗎？有什么辦法主動通知虛擬機進行垃圾回收

答：對于GC來說，當程序員創建對象時，GC就開始監控這個對象的地址、大小以及使用情況。通常，GC采用有向圖的方式記錄和管理堆(heap)中的所有對象。通過這種方式確定哪些對象是“可達的”，哪些對象是“不可達的”。當GC確定一些對象為“不可達”時，GC就有責任回收這些內存空間。可以。程序員可以手動執行System.gc()，通知GC運行，但是Java語言規范并不保證GC一定會執行。

53、靜態變量和實例變量的區別？ 答：static i = 10;//常量 class A a;a.i =10;//可變

54、什么是java序列化，如何實現java序列化？

答：序列化就是一種用來處理對象流的機制，所謂對象流也就是將對象的內容進行流化。可以對流化后的對象進行讀寫操作，也可將流化后的對象傳輸于網絡之間。序列化是為了解決在對對象流進行讀寫操作時所引發的問題。序列化的實現：將需要被序列化的類實現Serializable接口，該接口沒有需要實現的方法，implements Serializable只是為了標注該對象是可被序列化的，然后使用一個輸出流(如：FileOutputStream)來構造一個ObjectOutputStream(對象流)對象，接著，使用ObjectOutputStream對象的writeObject(Object obj)方法就可以將參數為obj的對象寫出(即保存其狀態)，要恢復的話則用輸入流。

55、是否可以從一個static方法內部發出對非static方法的調用？

答：不可以,如果其中包含對象的method()；不能保證對象初始化.56、寫clone()方法時，通常都有一行代碼，是什么？

答：Clone 有缺省行為，super.clone();他負責產生正確大小的空間，并逐位復制。

57、在JAVA中，如何跳出當前的多重嵌套循環？

答：用break;return 方法。

58、List、Map、Set三個接口，存取元素時，各有什么特點？

答：List 以特定次序來持有元素，可有重復元素。Set 無法擁有重復元素,內部排序。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知識點總結（定稿）

目錄

目錄................................................................................................................................................１ 基礎篇............................................................................................................................................４

一、JDK常用的包................................................................................................................４

二、Get和Post的區別.......................................................................................................４

三、Java多態的具體體現...................................................................................................４

四、StringBuffer StringBuilder String 區別.......................................................................５

五、Hashtable與HashMap的區別....................................................................................５六、九大隱式對象...............................................................................................................５

七、Forword(請求轉發)與Redirect(重定向).....................................................................６

八、JQurey總結....................................................................................................................６

九、XML和Json的特點....................................................................................................６

十、request.getSession()、reqeust.getSession(false)和

request.getSession(true)７

十一、Page和PageContext的區別....................................................................................７

十二、Ajax總結..................................................................................................................７

十三、JSP9大隱視對象中四個作用域的大小與作用范圍................................................７

十四、List,Set,Collection,Collections..................................................................................８

十五、java的基本數據類型...............................................................................................８

十六、冒泡排序...................................................................................................................８ 十七、二分查找法.................................................................................................................９

十八、時間類型轉換.............................................................................................................９

十九、階乘.......................................................................................................................１０

二十、UE和UI的區別....................................................................................................１０ 二

十一、osi七層模型.......................................................................................................１０ 二

十二、線程和進程的區別.............................................................................................１１ 二

十三、jvm的內存結構.................................................................................................１１ 二

十四、內存泄露和內存溢出.........................................................................................１１ 二

十五、單例.....................................................................................................................１１ 二

十六、解析xml文件的幾種技術.................................................................................１３ 二

十七、項目的生命周期.................................................................................................１４

１

二十八、OSCache的判斷.................................................................................................１４ 二

十九、經常訪問的技術網站.........................................................................................１５ 三

十、項目團隊中交流的工具.........................................................................................１５ 三

十一、平時瀏覽的書籍.................................................................................................１５ 三

十二、java Exception體系結構....................................................................................１５ 三

十三、session和cookie的區別....................................................................................１６ 三

十四、字節流與字符流的區別.....................................................................................１６ 三

十五、final,finally,finalize 三者區別...........................................................................１７ 三

十六、Io流的層次結構................................................................................................１７ 三

十七、JAVA:..................................................................................................................１８ 三

十八、JavaSE JavaEE JavaME區別........................................................................１８ 三

十九、JDK JRE JVM的區別：.............................................................................１９ 四

十、報錯的狀態碼：.....................................................................................................２０ 四

十一、協議以及默認的端口號.....................................................................................２０ 四

十二、抽象類與接口的區別.........................................................................................２０ 四

十三、修飾符的作用.....................................................................................................２０ 框架篇........................................................................................................................................２１

一、Struts1的運行原理..................................................................................................２３

二、Struts2的運行原理..................................................................................................２３

三、struts2的體系結構...................................................................................................２３

四、Spring MVC運行原理.............................................................................................２４

五、Struts1.x與Struts2.x的區別...................................................................................２５

六、Spring MVC、struts1和struts2區別......................................................................２５

七、Struts2中result中的type類型...............................................................................２５

八、Struts2標簽..............................................................................................................２６

九、SSI整合....................................................................................................................２６

十、SSH整合..................................................................................................................２６

十、Spring MVC整合.....................................................................................................２７

十一、Hibernate 中get 和 load的區別.........................................................................２８

十二、Hibernate、Ibatis、Jdbc三者的區別..................................................................２８

十三、Hibernate的運行原理..........................................................................................２８

十四、Hibernate五大核心（類/接口）簡述.................................................................２８

十五、Hibernate與JDBC的區別..................................................................................２９

十六、Hibernate中的兩大配置文件................................................................................２９

十七、Hibernate事務處理..............................................................................................２９

十八、Hibernate的三種狀態以及狀態的轉換..............................................................２９

十九、分頁步驟...............................................................................................................３０

二十、hibernate緩存概述.................................................................................................３０ 二

十一、Ssh的概述：.....................................................................................................３０ 二

十二、防止表單重復提交.............................................................................................３１ 二

十三、JSP標簽：........................................................................................................３１ 二

十四、過濾器.................................................................................................................３２ 二

十五、攔截器的理解.....................................................................................................３２ 二

十六、Spring融入框架................................................................................................３３

２

數據庫篇.....................................................................................................................................３３

一、JDBC連接數據庫步驟(以MYSQL為例).............................................................３３

二、數據庫連接池...........................................................................................................３４

三、mysql的數據庫導入導出........................................................................................３５

四、jdbc分段批量提交的時候出現異常怎么處理?.....................................................３５

五、jdbc批量處理數據...................................................................................................３５

六、Oracle分頁...............................................................................................................３６

七、Oracle的基本數據類型...........................................................................................３６

八、id、rowid、rownum的區別....................................................................................３７

九、主鍵和唯一索引的區別？.......................................................................................３７

十、Preparedstatement和statement的區別...................................................................３７

十一、數據庫三范式.......................................................................................................３８

十二、視圖概述...............................................................................................................３８

十三、存儲過程概述.......................................................................................................３８

十四、索引概述...............................................................................................................３９

十五、必背的sql語句....................................................................................................４１ 業務場景篇.................................................................................................................................４４

一、Spring的概述...........................................................................................................４４

二、事務概述...................................................................................................................４５

三、權限概述...................................................................................................................４６

四、OSCache業務場景...................................................................................................４６

五、線程概述...................................................................................................................４７

六、Ajax請求Session超時問題....................................................................................４７ 七：java線程池概述.........................................................................................................４８

八、OSCache概述...........................................................................................................４９

九、OSCache+autocomplete+單例業務場景..................................................................４９

十、緩存概述...................................................................................................................５０

十一、實現頁面靜態化業務場景...................................................................................５０

十二、servlet線程安全描述...........................................................................................５１

十三、(jbpm4)工作流引擎描述:.....................................................................................５１

十四、JPBM業務場景....................................................................................................５２

十五、Ant描述................................................................................................................５２

十六、FreeMarker描述...................................................................................................５３

十七、webService描述...................................................................................................５３

十八、oracle索引概述....................................................................................................５５

十九、oracle存儲過程....................................................................................................５６

二十、Junit 業務場景.......................................................................................................５６ 二

十一、Apache+Tomcat 實現負載均衡及seesion復制...............................................５６ 二

十二、Ant業務場景......................................................................................................５７ 二

十三、maven業務場景.................................................................................................５７ 二

十四、Servlet的概述：................................................................................................５８ 優化篇........................................................................................................................................６４

一、代碼優化...................................................................................................................６４

二、業務優化...................................................................................................................６４

３

三、sql優化.....................................................................................................................６５

四、防sql注入................................................................................................................６８

基礎篇

一、JDK常用的包

java.lang： 這個是系統的基礎類，比如String、Math、Integer、System和Thread，提供常用功能。

java.io: 這里面是所有輸入輸出有關的類，比如文件操作等

java.net: 這里面是與網絡有關的類，比如URL,URLConnection等。java.util : 這個是系統輔助類，特別是集合類Collection,List,Map等。java.sql: 這個是數據庫操作的類，Connection, Statememt，ResultSet等

二、Get和Post的區別

1.get是從服務器上獲取數據，post是向服務器傳送數據，2.get傳送的數據量較小，不能大于2KB。post傳送的數據量較大，一般被默認為不受限制。

3.get安全性非常低，post安全性較高。但是執行效率卻比Post方法好。

4.在進行文件上傳時只能使用post而不能是get。

三、Java多態的具體體現

面向對象編程有四個特征：抽象，封裝，繼承，多態。

多態有四種體現形式：

1.接口和接口的繼承。2.類和類的繼承。3.重載。4.重寫。

其中重載和重寫為核心。

重載：重載發生在同一個類中，在該類中如果存在多個同名方 法，但是方法的參數類型和個數不一樣，那么說明該方法被重 載了。

重寫：重寫發生在子類繼承父類的關系中，父類中的方法被子 類繼承，方法名，返回值類型，參數完全一樣，但是方法體不 一樣，那么說明父類中的該方法被子類重寫了。

４

四、StringBuffer StringBuilder String 區別

String

字符串常量

不可變

使用字符串拼接時是不同的2個空間

StringBuffer 字符串變量

可變

線程安全

字符串拼接直接在字符串后追加 StringBuilder 字符串變量

可變

非線程安全

字符串拼接直接在字符串后追加

1.StringBuilder執行效率高于StringBuffer高于String.2.String是一個常量，是不可變的，所以對于每一次+=賦值都會創建一個新的對象，StringBuffer和StringBuilder都是可變的，當進行字符串拼接時采用append方

法，在原來的基礎上進行追加，所以性能比String要高，又因為StringBuffer 是

線程安全的而StringBuilder是線程非安全的，所以StringBuilder的效率高于

StringBuffer.3.對于大數據量的字符串的拼接，采用StringBuffer,StringBuilder.五、Hashtable與HashMap的區別

HashMap不是線程安全的，HashTable是線程安全。

HashMap允許空（null）的鍵和值（key），HashTable則不允許。

HashMap性能優于Hashtable。

Map 1.Map是一個以鍵值對存儲的接口。Map下有兩個具體的實現，分別是HashMap和HashTable.2.HashMap是線程非安全的，HashTable是線程安全的，所以HashMap的效率高于HashTable.3.HashMap允許鍵或值為空，而HashTable不允許鍵或值為空.六、九大隱式對象

輸入/輸出對象：

request

response

out 作用域通信對象： session application pageContext Servlet 對象：

page

config 錯誤對象：

exception

５

七、Forword(請求轉發)與Redirect(重定向)

1、從數據共享上

Forword是一個請求的延續，可以共享request的數據

Redirect開啟一個新的請求，不可以共享request的數據

2、從地址欄

Forword轉發地址欄不發生變化

Redirect轉發地址欄發生變化

八、JQurey總結

jquery是一個輕量級的js框架，具有跨瀏覽器的特性，兼容性好，并且封裝了很多工具，方便使用。

常用的有: 選擇器，dom操作，ajax(ajax不能跨域)，特效，工具類

九、XML和Json的特點

Xml特點：

1、有且只有一個根節點；

2、數據傳輸的載體

3、所有的標簽都需要自定義

4、是純文本文件

Json（JavaScript Object Notation）特點：

json分為兩種格式:

json對象(就是在{}中存儲鍵值對，鍵和值之間用冒號分隔，鍵 值 對之間用逗號分隔);

json數組(就是[]中存儲多個json對象，json對象之間用逗號分隔)（兩者間可以進行相互嵌套）數據傳輸的載體之一

區別：

傳輸同樣格式的數據，xml需要使用更多的字符進行描述，流行的是基于json的數據傳輸。

xml的層次結構比json更清晰。

共同點：

xml和json都是數據傳輸的載體，并且具有跨平臺跨語言的特性。

６

十、request.getSession()、reqeust.getSession(false)和

request.getSession(true)

getSession()/getSession(true)：當session存在時返回該session，否則新建一個

session并返回該對象

getSession(false)：當session存在時返回該session，否則返回null

十一、Page和PageContext的區別

Page是servlet對象；使用this關鍵字，它的作用范圍是在同一頁面。PageContext是作用域通信對象；通常使用setAttribute()和getAttribute()來設置和獲取存放對象的值。

十二、Ajax總結

AJAX 全稱： 異步JavaScript及 XML（Asynchronous JavaScript And XML）Ajax的核心是JavaScript對象XmlHttpRequest(XHR)。

Ajax的優點:

提高用戶體驗度(UE)

提高應用程序的性能

進行局部刷新

AJAX不是一種新的編程語言，而是一種用于創建更好更快以及交互性更強的 Web 應用程序的技術。

2.通過 AJAX，我們的 JavaScript 可使用JavaScript的XMLHttpRequest對象來直接與服務器進行通信。通過這個對象，我們的 JavaScript 可在不重載頁面的情況與Web服務器交換數據，即可局部刷新。

3.AJAX 在瀏覽器與 Web 服務器之間使用異步數據傳輸（HTTP 請求），這樣就可使網頁從服務器請求少量的信息，而不是整個頁面，減輕服務器的負擔，提升站點的性能。

AJAX 可使因特網應用程序更小、更快，更友好，用戶體驗（UE）好。5.Ajax是基于標準化并被廣泛支持的技術，并且不需要插件和下載小程序

十三、JSP9大隱視對象中四個作用域的大小與作用范圍

四個作用域從大到小：appliaction>session>request>page application：全局作用范圍，整個應用程序共享.生命周期為：應用程序啟動到停止。

７

session：會話作用域，當用戶首次訪問時，產生一個新的會話，以后服務器就可以記

住這個會話狀態。

request：請求作用域，就是客戶端的一次請求。

page：一個JSP頁面。

以上作用范圍使越來越小，request和page的生命周期都是短暫的，他們之間的區別就是：一個request可以包含多個page頁(include，forward)。

十四、List,Set,Collection,Collections

1.List和Set都是接口，他們都繼承于接口Collection,List是一個有序的可重復的集合，而Set的無序的不可重復的集合。Collection是集合的頂層接口，Collections是一個封裝了眾多關于集合操作的靜態方法的工具類,因為構造方法是私有的，所以不能實例化。

2.List接口實現類有ArrayList,LinkedList,Vector。ArrayList和Vector是基于數組實現的,所以查詢的時候速度快，而在進行增加和刪除的時候速度較慢LinkedList是基于鏈式存儲結構，所以在進行查詢的時候速度較慢但在進行增加和刪除的時候速度較快。又因為Vector是線程安全的，所以他和ArrayList相比而言，查詢效率要低。

十五、java的基本數據類型

數據類型 大小 byte(字節)1(8位)shot(短整型)2(16位)int(整型)4(32位)long(長整型)8(32位)float(浮點型)4(32位)double(雙精度)8(64位)char(字符型)2(16位)boolean(布爾型)1位 附加：

String是基本數據類型嗎?(String不是基本數據類型)String的長度是多少，有限制?(長度受內存大小的影響)

十六、冒泡排序

public class Sort { public static void sort(){

８

} Scanner input = new Scanner(System.in);int sort[] = new int[10];int temp;System.out.println(“請輸入10個排序的數據：”);for(int i = 0;i < sort.length;i++){

sort[i] = input.nextInt();} for(int i = 0;i < sort.lengthi1)* num;

} } public static void main(String[] args){

System.out.println(multiply(10));} }

二十、UE和UI的區別

UE 是用戶體驗度

UI 界面原型（用戶界面）（相當于買房時用的模型）

設計UI的作用：

1、幫助程序員工作（界面已由美工設計完成）

2、提前讓用戶對項目有個宏觀的了解，知道效果是什么樣子。

二十一、osi七層模型

第一層：物理層

第二層：數據鏈路層

第三層：網絡層

第四層：傳輸層

第五層：會話層 第六層：表示層 第七層：應用層

１０

二十二、線程和進程的區別

1.線程(Thread)與進程（Process）

進程定義的是應用程序與應用程序之間的邊界，通常來說一個進程就代表一個與之對應的應用程序。不同的進程之間不能共享代碼和數據空間，而同一進程的不同線程可以共享代碼和數據空間。

2.一個進程可以包括若干個線程，同時創建多個線程來完成某項任務，便是多線程。3.實現線程的兩種方式：繼承Thread類，實現Runable接口

二十三、jvm的內存結構

java虛擬機的內存結構分為堆(heap)和棧(stack),堆里面存放是對象實例也就是new出來的對象。棧里面存放的是基本數據類型以及引用數據類型的地址。

對于所謂的常量是存儲在方法區的常量池里面。

二十四、內存泄露和內存溢出

內存泄露(memory leak)，是指應用程序在申請內存后，無法釋放已經申請的內存空間.一次內存泄露危害可以忽略，但如果任其發展最終會導致內存溢出(out of memory).如讀取文件后流要進行及時的關閉以及對數據庫連接的釋放。

內存溢出（out of memory）是指應用程序在申請內存時，沒有足夠的內存空間供其使用。

如我們在項目中對于大批量數據的導入，采用分段批量提交的方式。

二十五、單例

單例就是該類只能返回一個實例。單例所具備的特點： 1.私有化的構造函數 2.私有的靜態的全局變量 3.公有的靜態的方法

單例分為懶漢式、餓漢式和雙層鎖式

１１

餓漢式: public class Singleton1 {

private Singleton1(){};

private static Singleton1 single = new Singleton1();

public static Singleton1 getInstance(){

return single;

} }

懶漢式：

public class Singleton2 {

private Singleton2(){}

private static Singleton2 single=null;

public tatic Singleton2 getInstance(){

if(single == null){

single = new Singleton2();

}

return single;

} } 線程安全：

public class Singleton3 {

private Singleton3(){}

private static Singleton3 single;

public static Singleton3 getInstance(){

if(null == single){

synchronized(single){

if(null == single){

single = new Singleton3();

}

}

}

return single;

} }

參考：

通過雙重判斷來保證單列設計模式在多線程中的安全性，并且它在性能方面提高了很多。

１２

synchronized在方法上加鎖(同步鎖)

synchronized在代碼塊內部加鎖（同步代碼塊）

synchronized(同步鎖)

使用synchronized如何解決線程安全的問題？ 1.synchronized在方法上加鎖 2.synchronized在代碼塊內部加鎖

1.懶漢

2.餓漢

3.雙重判斷

二十六、解析xml文件的幾種技術

1、解析xml的幾種技術

1.dom4j

2.sax

3.jaxb

4.jdom

5.dom 1.dom4j

dom4j是一個Java的XML API，類似于jdom，用來讀寫XML文件的。dom4j是一個非常優秀的Java XML API，具有性能優異、功能強大和極端易用使用的特點，同時它也是一個開放源代碼的軟件。

2.sax

SAX（simple API for XML）是一種XML解析的替代方法。相比于DOM，SAX是一種速度更快，更有效的方法。它逐行掃描文檔，一邊掃描一邊解析。而且相比于DOM，SAX可以在解析文檔的任意時刻停止解析，但任何事物都有其相反的一面，對于SAX來說就是操作復雜。

１３

3.jaxb

JAXB（Java Architecture for XML Binding)是一個業界的標準，是一項可以根據XML Schema產生Java類的技術。該過程中，JAXB也提供了將XML實例文檔反向生成Java對象樹的方法，并能將Java對象樹的內容重新寫到XML實例文檔。從另一方面來講，JAXB提供了快速而簡便的方法將XML模式綁定到Java表示，從而使得Java開發者在Java應用程序中能方便地結合XML數據和處理函數。

2、dom4j 與 sax 之間的對比：【注：必須掌握！】

dom4j不適合大文件的解析，因為它是一下子將文件加載到內存中，所以有可能出現內存溢出，sax是基于事件來對xml進行解析的，所以他可以解析大文件的xml

也正是因為如此，所以dom4j可以對xml進行靈活的增刪改查和導航，而sax沒有這么強的靈活性

所以sax經常是用來解析大型xml文件，而要對xml文件進行一些靈活（crud）操作就用dom4j

二十七、項目的生命周期

1.需求分析

2.概要設計

3.詳細設計(用例圖，流程圖，類圖)4.數據庫設計(powerdesigner)5.代碼開發（編寫）

6.單元測試（junit 白盒測試）(開發人員)svn版本管理工具(提交，更新代碼，文檔)7.集成測試（黑盒測試，loadrunner（編寫測試腳本）(高級測試)）

8.上線試運行（用戶自己體驗）

9.壓力測試（loadrunner）

10.正式上線

11.維護

二十八、OSCache的判斷

Object obj = CacheManager.getInstance().getObj(“oaBrandList”);//從緩存中取數據 if(null == obj){

obj = brandDao.getBrandList();

//如果為空再從數據庫獲取數據

//獲取之后放入緩存中

１４

CacheManager.getInstance().putObj(“oaBrandList”, obj);}

return(List)obj;

二十九、經常訪問的技術網站

1.csdn(詳細步驟的描述)2.iteye(詳細步驟的描述)3.oschina（開源中國獲取java開源方面的信息技術）

4.java開源大全 下載完畢，并且已經解析為DOM 樹了，但很有可能圖片還沒有加載完畢，所以例如圖片的高度和寬度這樣的屬性此時不一定有效。要解決這個問題，可以使用Jquery 中另一個關于頁面加載的方法---load()方法。Load()方法會在元素的onload 事件中綁定一個處理函數。如果處理函數綁定給window 對象，則會在所有內容(包括窗口、框架、對象和圖像等)加載完畢后觸發，如果處理函數綁定在元素上，則會在元素的內容加載完畢后觸發。Jquery 代碼如下： $(window).load(function(){ // 編寫代碼 });等價于JavaScript 中的以下代碼 Window.onload = function(){ // 編寫代碼 } 四

十五、switch默認接受的幾種數據類型

Short, int, byte, char

２１

四

十六、request 跟session的區別

1.他們的生命周期不同，request對應的是一次請求，session對應的是一次會話

2.request占用資源比較少,相對來說缺乏持續性, 而session資源消耗比較大，所以通常使用request來保存信息

四

十七、找到解決svn沖突方法

對于svn沖突，可以采用手工處理將沖突的部分進行整合，之后備份最新整合后的文件，采用覆蓋更新的方式處理完 沖突之后，再把最新整合后的文件進行提交。

四

十八、反射的描述

通過字符串可以動態創建java對象，并且可以動態訪問方法，屬性等。

我們在項目中的時候封裝過數據庫jdbc的持久層，其中就利用反射這項

技術來達到通用

和靈活的目的。

２２

框架篇

一、Struts1的運行原理

在啟動時通過前端總控制器ActionServlet加載struts-config.xml并進行解析，當用戶在jsp頁面發送請求被struts1的核心控制器ActionServlet接收，ActionServlet在用戶請求時將請求參數放到對應的ActionForm對象中的成員變量中，然后ActionServlet則會根據struts-config.xml中的映射關系找到相應的Action中的方法，將對應的ActionForm一并傳給這個Action中的方法里，然后執行相應的業務邏輯操作，最后就根據ActionMapping的findforward方法返回一個ActionForward,之后在struts-config.xml中找到與之對應的forward標簽，根據它的配置路徑找到對應的jsp頁面。

二、Struts2的運行原理

1、tomcat 啟動的時候會加載 web.xml、核心控制器 FilterDispatcher 會加載并解析 struts.xml

2、客戶端會發送一個請求到 action、FilterDispatcher 會根據后綴名進行攔截

3、FilterDispatcher根據 struts.xml 的配置文件信息 找到 某個action 對應的某個類里的指定方法

4、執行相關的業務邏輯最后返回 一個String

5、 里配置 name的屬性值與返回的String 進行匹配,跳轉到指定的jsp 頁面

三、struts2的體系結構

1、客戶端向Servlet容器（例如Tomcat）發送一個請求；

2、這個請求經過一系列的過濾器（Filter）；

3、接著FilterDispatcher被調用，FilterDispatcher詢問ActionMapper來決定這個請求是否需要調用某個Action；

4、如果ActionMapper決定需要調用某個Action，FilterDispatcher把請求的處理交給ActionProxy；

5、ActionProxy通過Configuration Manager詢問框架的配置文件，找到需要調用的Action類；

6、ActionProxy創建一個ActionInvocation的實例。

7、ActionInvocation在調用Action的過程前后，涉及到相關攔截器（Intercepter）的調用。

8、一旦Action執行完畢，ActionInvocation負責根據struts.xml中的配置找到對應的返回結果。返回結果通常是jsp或者FreeMarker的模版。（體系結構圖見下一頁）

２３

四、Spring MVC運行原理

整個處理過程從一個HTTP請求開始：

1.Tomcat在啟動時加載解析web.xml,找到spring mvc的前端總控制器DispatcherServlet,并且通過DispatcherServlet來加載相關的配置文件信息。

2.DispatcherServlet接收到客戶端請求，找到對應HandlerMapping，根據映射規則，找到對應的處理器（Handler）。

3.調用相應處理器中的處理方法，處理該請求后，會返回一個ModelAndView。

4.DispatcherServlet根據得到的ModelAndView中的視圖對象，找到一個合適的ViewResolver（視圖解析器），根據視圖解析器的配置，DispatcherServlet將要顯示的數據傳給對應的視圖，最后顯示給用戶。

２４

五、Struts1.x與Struts2.x的區別

Struts 2以WebWork為核心，采用攔截器的機制來處理用戶的請求，struts1嚴重依賴于servletAPI, 屬于侵入性框架,struts2不嚴重依賴于servletAPI,屬于非侵入型框架。線程模型方面：

Struts1的Action是單實例的, 一個Action的實例處理所有的請求。

Struts2的Action是一個請求對應一個實例（每次請求時都新new出一個對象）, 沒有線程安全方面的問題 封裝請求參數：

Struts1中強制使用ActionForm對象封裝請求的參數。

Struts2可以選擇使用POJO類來封裝請求的參數，或者直接使用Action的屬性。struts1的前端總控制器(核心總控制器)為ActionServlet, struts2的前端總控制器(核心總控制器)為FilterDispather

六、Spring MVC、struts1和struts2區別

1.spring mvc 單例 非線程安全

struts1單例 非線程安全

struts2線程安全對每個請求都產生一個實例 2.spring mvc的入口是servlet，而struts2是filter

spring 的前端總控制器為 DispatcherServlet

struts2 的前端總控制器為 FilterDispatcher

struts1 的前端總控制器為 actionServlet 3.參數傳遞：struts是在接受參數的時候，可以用屬性來接受參數，這就說明參數是讓多個方法共享的。springmvc 用方法來接受參數

4.spring mvc是基于方法的設計,而sturts是基于類

七、Struts2中result中的type類型

1.dispatcher：它是默認的，用來轉向頁面，通常處理JSP 2.redirect：將用戶重定向到一個已配置好的URL 3.redirectAction：將用戶重定向到一個已定義好的action 4.chain：將action和另外一個action鏈接起來 5.freemarker：呈現Freemarker模板

6.httpheader：返回一個已配置好的HTTP頭信息響應

7.stream：向瀏覽器發送InputSream對象對下載的內容和圖片非常有用 8.velocity：呈現Velocity模板

２５

9.xslt ：該XML可以通過XSL模板進行轉換

10.plaintext：顯示原始文件內容，例如文件源代碼

八、Struts2標簽

首先需要引用 <%@taglib prefix=“s” uri=“/struts-tags”%> 1. 判斷標簽 后面可跟 2. 迭代標簽

3. 引入標簽 可以把一個JSP頁面或者servlet引入一

個頁面中

4. 輸出標簽

5. 標簽賦予變量一個特定范圍內的值

6. 表單標簽

7. 文本域標簽

8. 下拉標簽

9. 聲明一個url的路徑

最常用的是：

判斷

循環

輸出

九、SSI整合

1、Action繼承于Actionsupport

2、引入struts-spring-plugin.jar包，從而完成struts和spring的整合

3、在struts2的action中注入service，保證service的名字和配置文件中的一致，并生成get,set方法

4、Dao層繼承于SqlMapClientDaoSupport

5、在dao層的配置文件中注入sqlMapClient

十、SSH整合

1.首先在web.xml中通過ContextLoaderListener來融入spring，并加載spring的相關配置文件

2.同樣配置sturts2的前端總控制器filterDispatcher來過濾相關的 請求并且加載struts.xml

２６

3.action繼承ActionSupport，然后通過引入struts-spring-plugin.jar 包并且根據配置文件中service的id生成get,set方法來注入service層。

4.dao層繼承于HibernateDaoSupport，并且在dao的配置文件中注入sessionFactory.5.通過spring中的配置文件加載hibernate.cfg.xml文件從而融入hibernate.在ssh框架中是怎么整合spring? 首先在web.xml中通過ContextLoaderListener來融入spring，并加載spring的相關配置文件

在ssh框架中是怎么整合hibernate? 通過spring中的配置文件加載hibernate.cfg.xml文件從而融入hibernate dao層繼承于HibernateDaoSupport，并且在dao的配置文件中注入sessionFactory

在ssh框架中是怎么整合struts2? 配置sturts2的前端總控制器filterDispatcher來過濾相關的 請求并且加載struts.xml

十、Spring MVC整合

1.首先,要在web.xml里面配置SpringMVC的核心控制器,DispatcherServlet,對指定的后綴請求進行攔截。

2.Controller層要加 @Controller注解,表明該類是MVC的控制層。

3.創建Service接口,給接口加上注解 @Component或者 @Service 表明這是Service業務處理層

4.在Controller層聲明Service變量(屬性),給變量（屬性）加上 @Autowired注解,通過自動綁定機制將Service注入到Controller。(注：@Autowired默認是ByType,如果想根據屬性名注入,那么就再加上注解 @Resource(name=“屬性名”))5.在Controller層的方法上加上注解 @RequestMapping(“requestAddress”)表明該方法的請求地址

6.Dao層要加上注解 @Repository 表明這是數據庫持久層 7.同樣將dao實例注入到service層中。

8.配置視圖解析器 “InternalResourceViewResolver”,對處理后的跳轉進行統一配置。

２７

十一、Hibernate 中get 和 load的區別

加載方式：

load為延遲加載(返回的是一個只有id屬性的代理,只有使用該對象屬性時,才

發出sql語句)；

get為立即加載(執行時,會立即向數據庫發出sql語句)返回結果：

load檢索不到記錄時,會拋ObjectNotFoundException異常

get檢索不到記錄時,會返回null

十二、Hibernate、Ibatis、Jdbc三者的區別

Hibernate屬于全自動，Ibatis屬于半自動，Jdbc屬于手動，從開發效率上講hibernate較高，ibatis居中，jdbc較低，從執行效率上講hibernate較低，ibatis居中，jdbc較高，因為jdbc是手工寫sql語句，程序員對sql的控制能力更大，可以根據業務需要進行優化，而ibatis雖然也可以對sql進行優化，但是他里面將resultset封裝為實體的過程中采用了反射機制所以一定程度上影響了性能，而hibernate因為高度封裝所以開發效率相對較高，但正因為這個原因，所以程序員在對sql語句的控制和優化方面相對比較弱，而且在將resultset封裝成實體的過程中也采用了反射機制，所以在性能方面較低

十三、Hibernate的運行原理

首先通過configuration去加載hibernate.cfg.xml這個配置文件，根據 配置文件的信息去創建sessionFactory,sessionFactory是線程安全的，是一個session工廠，用來創建session,session是線程不安全的，相當于

jdbc的connection，最后通過session去進行數據庫的各種操作，在進行操作 的時候通過transaction進行事務的控制。

十四、Hibernate五大核心（類/接口）簡述

1.Configuration接口的作用是對Hibernate進行配置，以及對它進行啟動。（加載 hibernate.cfg.xml）并創建一個SessionFactory對象。2.SessionFactory接口

SessionFactory接口負責初始化Hibernate。它充當數據存儲源的代理，并負責創建 Session對象。SessionFactory是線程安全的。3.Session接口

Session（會話）接口是Hibernate應用使用的主要接口。Session接口負責執行被持久化對象的CRUD操作(增刪改查)。Session對象是非線程安全的。Session 相當于jdbc的connection 4.Query與Criteria接口

總之Query和Criteria接口負責執行各種數據庫查詢。5.Transaction接口

２８

Transaction（事務）負責操作相關的事務。

十五、Hibernate與JDBC的區別

1、hibernate和jdbc主要區別就是，hibernate先檢索緩存中的映射對象(即hibernate操作的是對象)，而jdbc則是直接操作數據庫.2、Hibernate是JDBC的輕量級的對象封裝，它是一個獨立的對象持久層框架。Hibernate可以用在任何JDBC可以使用的場合

3、Hibernate是一個和JDBC密切關聯的框架，所以Hibernate的兼容性和JDBC驅動，和數據庫都有一定的關系，但是和使用它的Java程序，和App Server沒有任何關系，也不存在兼容性問題。

4、如果正確的使用JDBC技術,它的執行效率一定比hibernate要好,因為hibernate是基于jdbc的技術.5、JDBC使用的是SQL語句，Hibernate使用的是HQL語句，但是HQL語句最終還會隱式轉換成SQL語句執行。

十六、Hibernate中的兩大配置文件

*.hbm.xml：主鍵生成策略，映射關系，一對多，一對一的關系。

Hibernate.cfg.xml：方言(用哪個數據庫)，數據庫連接信息，包含*.hbm.xml內容，映射 文件，也可以配事務。

十七、Hibernate事務處理

開啟事務 session.beginTransaction();執行相關的操作，如果成功則session.getTransaction().commit();執行操作失敗則 session.getTransaction.rollback();

十八、Hibernate的三種狀態以及狀態的轉換

Transient(臨時)

new 一個初始化對象后，并沒有在數據庫里保存數據，處于臨時狀態； Persistent(持久化)

當執行save()方法，調用session.close()方法之前，內存中的對象與數據庫有

對應關系處于持久化狀態；

Detached(托管/游離)

當執行session.close()之后，處于托管狀態； 狀態的轉換

處于托管狀態下，調用update()方法后，轉換為持久化狀態；

在持久化狀態下，執行delete()方法后，轉換為臨時狀態；

在未初始化對象之前，調用get(),load(),find(),iterate()之后，直接進入持久化

狀態。

２９

十九、分頁步驟

①前臺封裝一個顯示分頁的組件 ②查詢總條數

③后臺封裝分頁工具類，計算開始位置、結束位置、總頁數 ④后臺寫支持分頁的sql語句

⑤前臺包含分頁組件，實現分頁效果

注意: 查詢總條數的where和查詢列表信息的where條件要保證一致。

二十、hibernate緩存概述

hibernate分為一級緩存即session緩存也叫事務級別的緩存以及

二級緩存sessionFactory即應用級別的緩存,還有查詢緩存即三級緩存.一級緩存的生命周期和session的生命周期保持一致，hibernate默認就啟用了一級緩存，不能將其關閉，可以通過session.clear()和session.evict(object)來管理一級緩存。其中get,load,iterate都會使用一級緩存，一級緩存緩存的是對象。

二級緩存的生命周期和sessionFactory的生命周期保持一致，可以跨session,被多個session共享，hibernate3默認開啟二級緩存,也可以手動開啟并指定緩存插件如ehcache,oscache 等。二級緩存也只能緩存對象。

三級緩存也叫查詢緩存，查詢緩存是針對普通屬性結果集的緩存, 對實體對象的結果集只緩存id。對query.list()起作用，query.iterate不起作用，也就是query.iterate不使用查詢緩存

二十一、Ssh的概述：

ssh是web開發中常見的一種框架 s-struts s-spring h-hibernate 其中struts在框架中充當控制器，實現MVC，主要用來處理用戶的請求，和跳轉頁面。使項目結構清晰，開發者只需要關注業務邏輯的實現即可。

spring在ssh充當粘合劑，粘合struts-sping-hibernate，主要用來進行事物的控制，hibernate-充當數據庫持久層，主要用它來與數據庫交互，提高開發效率，減輕程序員sql控制要求，而且hibernate通過反射機制，有靈活的映射性，還支持各種關系，一對一，一對多，多對多。

在進行ssh整合的時候，我們應該注意： 1.Action繼承于ActionSupport 引入struts-spring-plugin.jar包，從而完成struts和spring的整合

在struts2的action中注入service，保證service的名字和配置文件中的一致，并生成get,set方法

３０

Dao層繼承于hibernateDaoSupport 在dao層的配置文件中注入sessionFactory

二十二、防止表單重復提交

針對于重復提交的整體解決方案： 1.用redirect來解決重復提交的問題 2.點擊一次之后，按鈕失效 3.通過loading 4.自定義重復提交過濾器 5.解決struts2重復提交

可以結合s:token標簽來解決重復提交問題

利用token的原理：

1.在前端的jsp頁面中加入s:token標簽，在訪問該頁面時就會生成 隱藏域，該隱藏域中包含一個隨機生成的字符串，并把該字符串

存入session中

2.在struts2的配置文件中加入token攔截器后，當正常訪問action 的時候，會從session中取出該字符串，然后和頁面隱藏域中提交 字符串做對比，如果一致則正常執行并刪除session中存儲的字符串。

二十三、JSP標簽：

1.JSP include動作

jsp:include 動作

以“ ” 結束 比如：

2.JSP指令：<%@ include%><%@

%>

以“<%@ ” 開始，以“%> ” 結束。比如：

<%@ include file = “ Filename” %> 3.JSP輸出表達式：<%= %><%=Java表達式 %>

輸出變量的值，后邊不能加<%=;%> 4.JSP Scriptlet【腳本】:<%;%> <% Java 代碼 %>

例子：

<% Calendar now = Calendar.getInstance();%> 5.JSP聲明：<%!%> <%!函數或者方法 %>

例子：

<%!String getHello(String name){ return “Hi,” + name + “!”;}

%> 6.迭代標簽： ３１

Jstl中的核心標簽（core）7.JSP注釋：

<%--這也是注釋,但客戶端不能查看到--%> 8.el表達式：${} 9.jsp:include動作是在運行時動態包含。

@include指令是在編譯時包含。

它們兩個都只能包含本項目的相關文件，不能包含其他項目的。

如果要包含其他項目的文件可以使用c:import 二

十四、過濾器

filter的概述: filter是一個過濾器，用來在請求前和響應后進行數據的處理。

filter的生命周期是: 實例化--->初始化(init)-->進行過濾(doFilter)--->銷毀(destroy)-->釋放資源

一個Filter必須實現javax.servlet.Filter接口

在項目中我們通常通過filter進行編碼轉換，進行安全驗證，進行重復提交的判斷。

了解(不需要主動說)filter 相當于 攔截器 相當于Spring AOP servlet+jsp+javabean+jdbc+filter encodingFilter org.leopard.filter.EncodingFilter

encode

utf-8 encodingFilter *

二十五、攔截器的理解

什么是攔截器：

攔截器是AOP中的概念，它本身是一段代碼，可以通過定義“織入點”，來指定攔截器的代碼在“織入點”的前后執行，從而起到攔截的作用

正如上面 Struts2的Reference中講述的，Struts2的Interceptor，其攔截的對象是Action代碼，可以定義在Action代碼之前或者之后執行攔截器的代碼。在項目中，我們經常用來攔截通過非正常程序而進行的訪問

３２

Struts2的攔截器和Servlet過濾器類似。在執行Action的execute方法之前，Struts2會首先執行在struts.xml中引用的攔截器，在執行完所有引用的攔截器的intercept方法后，會執行Action的execute方法。

其中intercept方法是攔截器的核心方法，所有安裝的攔截器都會調用之個方法。在Struts2中已經在struts-default.xml中預定義了一些自帶的攔截器，如timer、params等。如果在

標簽中繼承struts-default，則當前package就會自動擁有struts-default.xml中的所有配置。代碼如下：

...

攔截器是Struts2框架的核心，它主要完成解析請求參數、將請求參數賦值給Action屬性、執行數據校驗、文件上傳等工作

在struts-default.xml中有一個默認的引用，在默認情況下（也就是中未引用攔截器時）會自動引用一些攔截器。struts2中默認的攔截器是defaultStack.自定義攔截器需要特別注意的是不要忘記引入struts2默認的攔截器。為了實現某些操作，我們可以自定義攔截器，自定義攔截器有三種方式定義。分別為實現Interceptor接口，繼承抽象類AbstractInterceptor，繼承MethodFilterInteceptor類。攔截器在項目中的運用：

同時可以減輕代碼冗余，提高重用率。

如果要求用戶密碼、權限等的驗證，就可以用自定義的攔截器進行密碼驗證和權限限制。對符合的登入者才跳轉到正確頁面。

二十六、Spring融入框架

我們通過在web.xml中配置ContextLoaderListener這個監聽器也加載 spring的配置文件，從而融入到項目框架中。

二十七、項目的部署方式

1、如果項目單獨部署到tomcat中的時候，應該看tomcat中的server.xml;

2、如果和eclipse結合使用進行項目部署的時候，應該看eclipse里面的server.xml.數據庫篇

一、JDBC連接數據庫步驟(以MYSQL為例)

1、加載JDBC驅動程序：

通過Class類的forName方法實現，并將驅動地址放進去

成功加載后，會將Driver類的實例注冊到DriverManager類中。

３３

2、提供JDBC連接的URL、創建數據庫的連接

?要連接數據庫，需要向java.sql.DriverManager請求并獲得Connection對象，該對象就代表一個數據庫的連接。

?使用DriverManager的getConnectin()方法傳入指定的欲連接的數據庫的路徑、數 據庫的用戶名和密碼。

Connection con=DriverManager.getConnection(url , username , password);&&&:“jdbc:mysql://localhost/test?user=root&password=123&useUnicode=true&characterEncoding=utf-8”;

3、創建一個Statement

?要執行SQL語句，必須獲得java.sql.Statement實例

?執行靜態SQL語句。通常通過Statement實例實現。

?執行動態SQL語句。通常通過PreparedStatement實例實現。

String sql = “”;

Statement st = con.createStatement();

PreparedStatement pst = con.prepareStatement(sql);

4、執行SQL語句

Statement接口提供了executeQuery、executeUpdate、execute三種方法

executeQuery：執行select語句，返回ResultSet結果集

ResultSet rst = pst.executeQuery();

? executeUpdate：執行insert、update、delete語句

pst.executeUpdate();

5、關閉JDBC對象

操作完成以后要把所有使用的JDBC對象全都關閉，以釋放JDBC資源。

二、數據庫連接池

數據庫連接池的優點運行原理: 在我們不使用數據庫連接池的時候，每次訪問數據庫都需要創建連接，使用完成之后需要釋放關閉連接，而這樣是很耗費資源的。當我們使用 數據庫連接池的時候，在tomcat啟動的時候就創建了指定數量的連接，之后當我們程序使用的時候就直接從連接池里面取，而不需要創建，同理，當我們使用完的時候也不需要關閉連接，而是將連接返回到連接池中，供 其他請求繼續使用。

DBCP：比較穩定。C3P0: 性能比較高。

３４

三、mysql的數據庫導入導出

配置：

首先找到mysql的安裝目錄，進入bin目錄下復制路徑 將mysql的bin目錄粘貼在計算機環境變量的path中 授權：

登錄mysql 將某張表的某個權限賦給某個用戶

grant [select,insert,update,delete,create,drop] on [databaseName].[tableName]

to [userName]@[userIP] identified by [?連接口令?]

grant select,insert,update,delete,create,drop on oa_ssh.user to root@[IP] identified by 'root';將所有庫的所有權限賦給某個用戶

grant all privileges on *.* to [userName]@[userIp] identified by [?連接口令?] grant all privileges on *.* to root@[IP] identified by ?root';將所有庫的所有權限賦給所有用戶

grant all privileges on *.* to root@'%' identified by ?root?;

導出本地數據庫：

mysqldump-u 用戶名-p 數據庫名 > 磁盤：導出的文件名(加后綴)

遠程導出數據庫：

mysqldump-h IP-u 用戶名-p 數據庫名稱 >導出的文件名(加后綴)

遠程導出數據表：

mysqldump-u root-p-d--add-drop-table 數據庫名稱 > 導出文件

名(加后綴)

導入數據：

mysql-u root-p登錄成功后 ==》 source 磁盤：導入的文件名(加后綴)

四、jdbc分段批量提交的時候出現異常怎么處理?

通過Map來解決性能問題。首先在分段批量提交的時候，我們不采用事務，這樣就保證了合法的數據就自動提交，不合法的數據就自己自動進行回滾，為了避免不合法數據影響后續合法數據的提交，采用定義業務規則字典表，實現對數據的驗證，將不合法的數據記錄下來，供用戶進行后續處理，而合法的數據就全部提交。

五、jdbc批量處理數據

批量處理數據:(代碼優化:提高程序執行性能)

３５

降低了java程序代碼(客戶端)和數據庫之間的 網絡通信的次數。

在jdbc中進行批量插入的核心API為 addBatch,executeBatch

大數據量的插入問題:（jdbc,hibernate,ibatis）

1.每次只插入一條和數據庫交互多次(很耗時間)

2.批量插入和數據庫只交互一次(內存溢出)

3.分段批量插入(推薦)

jdbc批量處理數據是通過PreparedStatement對象的 addbatch(), executebatch（）clearbatch()進行和數據庫的交互。通常我們使用分段批量處理的方式 這樣可以提高程序的性能，防止內存溢出。

1.每個sql語句都和數據庫交互一次(非批量操作)2.只和數據庫交互一次(批量操作)(內存溢出)當數據達到一定額度的時候就和數據庫進行交互，分多次進行(分段批量操作)

(500或者1000)pst.addBatch();if(i > 0 && i%1000 == 0){

pst.executeBatch();

pst.clearBatch();}

六、Oracle分頁

select * from(select * from(select s.*,rownum rn from student s)where rn<=5)where rn>0

七、Oracle的基本數據類型

Oracle的基本數據類型（常用）：

1、字符型

Char 固定長度字符串

占2000個字節 Varchar2 可變長度字符串 占4000個字節

Nvarchar2 占2000個字符（最多能存2000個字母/中文）

2、大對象型（lob）

Blob ：二進制數據 最大長度4G Blob 用于存一些圖片，視頻，文件。

３６

比如：當我們在進行文件上傳時，我們一般把上傳的文件存在硬盤上，可以不占用 數據庫，下載時，如果項目遷移時，文件也要跟著遷移。因此我們可以把用blob把它存在數據庫中。但這樣也增加了數據庫的負擔。

Clob ：字符數據 最大長度4G，可以存大字符串

varchar2和nvarchar2都具有一定的局限性，它們長度有限，但數據庫中無論用varchar2或nvarchar2類型，還是用clob，在java端都使用String接收。

3、數值型

Integer 整數類型，小的整數。Float 浮點數類型。Real 實數類型。

Number（p,s）包含小數位的數值類型。P表示精度，s表示小數后的位數。

Eg: number(10,2)表示小數點之前可有8位數字，小數點后有2位。

4、日期類型

Date 日期（日-月-年）DD-MM-YY(HH-MI-SS)Timestamp 跟date比 它可以精確到微秒。精確范圍0~9 默認為6.八、id、rowid、rownum的區別

rowid物理位置的唯一標識。

而id是邏輯上的唯一標識，所以rowid查找速度要快于id,是目前最快的定位一條記錄的方式

rowid和rownum都是”偽數列“ 所謂“偽數列”也就是默認隱藏的一個數列。rownum用于標記結果集中結果順序的一個字段，它的特點是按順序標記，而且是連續的，換句話說就是只有有rownum=1的記錄，才可能有rownum=2的記錄。rownum關鍵字只能和<或者<=直接關聯 如果是>或者=則需要給他起個別名

九、主鍵和唯一索引的區別？

在創建主鍵的同時會生成對應的唯一索引，主鍵在保證數據唯一性的同時不允許為

空，而唯一可以有一個為空數據項，一個表中只能有一個主鍵，但是一個主鍵可以

有多個字段，一個表中可以有多個唯一索引。

十、Preparedstatement和statement的區別

用Prepared statement進行開發。Prepared statement是預編譯的，而statement不是，在每次執行sql語句的增刪改時，如果是一條數據兩者沒差距，但如果數據量大于1，那么每次執行sql語句statement都要重新編譯一次，而Prepared statement不用，Prepared statement的運行效率大于statement；從代碼的可維護性和可讀性來說，雖然

３７

用Prepared statement來代替statement會使代碼多出幾行，但這樣的代碼無論從可讀性還是可維護性來說，都比直接使用statement的代碼高很多檔次；最重要的一點，從安全角度來說，使用Prepared statement可以大大提高程序的安全性，因為Prepared statement是用?？?傳參,可以防止sql注入，具有安全性，而statement用的是?+?字符串拼接，安全性較低。

十一、數據庫三范式

第一范式：數據庫表中的所有字段值都是不可分解的原子值。

第二范式：需要確保數據庫表中的每一列都和主鍵相關，而不能只與主鍵的某一部

分相關（主要針對聯合主鍵而言）

第三范式：需要確保數據表中的每一列數據都和主鍵直接相關，而不能間接相關

十二、視圖概述

視圖可以視為“虛擬表”或“存儲的查詢”

創建視圖所依據的表稱為“基表”

視圖的優點：

提供了另外一種級別的表安全性:隱藏了一些關鍵的字段

簡化的用戶的SQL命令

隔離基表結構的改變

十三、存儲過程概述

存儲過程（Stored Procedure）

可以包含邏輯判斷的sql語句集合。

是經過預編譯，存在于數據庫中。

通過調用指定存儲過程的名字（可有參，可無參）來執行。優點：

簡化了復雜的業務邏輯，根據需要可重復使用

屏蔽了底層細節，不暴露表信息即可完成操作

降低網絡的通信量，多條語句可以封裝成一個存儲過程來執行

設置訪問權限來提高安全性

提高執行效率，因為它是預編譯以及存儲在數據庫中 缺點：

可移植性差，相同的存儲過程并不能跨多個數據庫進行操作

大量使用存儲過程后，首先會使服務器壓力增大，而且維護難度逐漸增加

存儲過程的語法：

--下面是在oracle數據庫下最基本的語法

３８

--僅創建一個名為testProcedure 的無參的存儲過程--IS也可以是AS--如果已經存在名為 testProcedure 的存儲過程，下面的語法會出現 名稱已被使用的錯誤

--解決辦法：

--第一句可以寫成 create or replace procedure testProcedure--這樣會替換原有的存儲過程

--NULL表示任何可以正確執行的sql 語句，但至少一句

create procedure testProcedure IS BEGIN

NULL

END;

存儲過程的參數的分類: IN OUT INOUT

注意：

存儲過程之間可相互調用

存儲過程一般修改后，立即生效。

十四、索引概述

1、索引的概念

索引就是為了提高數據的檢索速度。

數據庫的索引類似于書籍的索引。

在書籍中，索引允許用戶不必翻閱完整個書就能迅速地找到所需要的信息。

在數據庫中，索引也允許數據庫程序迅速地找到表中的數據，2、索引的優點

３９ 而不必掃描整個數據庫.1.創建唯一性索引，保證數據庫表中每一行數據的唯一性

2.大大加快數據的檢索速度，這也是創建索引的最主要的原因

3.減少磁盤IO（向字典一樣可以直接定位）

3、索引的缺點

1.創建索引和維護索引要耗費時間，這種時間隨著數據量的增加而增加

2.索引需要占用額外的物理空間

3.當對表中的數據進行增加、刪除和修改的時候，索引也要動態的維護，降低了數據的維護速度

4、索引的分類

1.普通索引和唯一性索引

普通索引：CREATE INDEX mycolumn_index ON mytable(myclumn)

唯一性索引：保證在索引列中的全部數據是唯一的

CREATE unique INDEX mycolumn_index ON mytable(myclumn)

2.單個索引和復合索引

單個索引：對單個字段建立索引

復合索引：又叫組合索引，在索引建立語句中同時包含多個字段名，最多16個字段

CREATE INDEX name_index ON userInfo(firstname,lastname)

3.順序索引，散列索引,位圖索引

４０

十五、必背的sql語句

1：oracle 分頁

select * from(select t.*, rownum rn from(select * from menu order by id desc)t where

rownum < 10)where rn >=5

2: mysql 分頁

select * from music where id limit 5,5

3：oracle中如何快速將一張表的數據復制到另外一張表中(另外一張表不存在，另外一張

表存在，但數據為空)

1、.不存在另一張表時：

create table 新表

as select * from 將要復制的表

2、存在另一張表時：

insert into 新表名

select 字段

from 將要復制的表名

4：音樂專輯

查詢出special 表中的id 專輯名 并下面有多少首歌曲

Select s.id , min(s.sname),count(m.mid)from special s inner

join ms m on s.id=m.id group by s.id

5：快速刪除一張表（不可事物回滾，也就是沒有日志記錄）

TRUNCATE from 表名

6：inner join

select 查找信息 from 表名 1 inner join 表名2 on 表名1.列名 = 表名2.列名

7：left join

左外連接

select 查找信息 from 表名1 left join 表名2 on 表名1.列名 = 表名2.列名

8：right join

右外連接

select 查找信息 from 表名1 right join 表名2 on 表名1.列名 = 表名2.列名

４１

9：oracle中查詢遍歷樹形結構（start with）

select * from extmenu

start with pid=1 connect by prior id = pid

快速刪除父節點以及父節點下的所有節點： Delete from extmenu where id in(elect * from extmenu

start with pid=1 connect by prior id = pid)

10：查詢出來60-70,80-90,95-100學生的信息

select * from stu where chengji between 60 and 70 or between 80 and 90 or between 95 and 100 select * from stu where chengji > 60 and chengji < 70 or chengji > 80 and chengji < 90 or chengji > 95 and chengji < 100

11：用exists替換in------進行聯表查詢

select * from dept where exists(select * from emp where emp.deptno=dept.deptno);或

select * from dept d inner join emp e on d.deptno = e.deptno(只查詢出兩表共同擁有的字段數據)

12：刪除表中的重復數據：

delete from xin a where a.rowid!=（select max(b.rowid)from xin b

where a.name = b.name);13：row_number()，rank()over，dense_rank()over 按工資排序

select sal，row_number()over(order by sal desc)rank1，rank()over(order by sal desc)rank，dense_rank()over(order by sal desc)drank

from emp

14：select * from(select emp.* from(dense_rank()over(partition by departNo order by sal desc)rk from emp)Where rk=4

４２

十六、ibatis批量

this.getSqlMapClientTemplate().execute(new SqlMapClientCallback(){ public Object doInSqlMapClient（SqlMapExecutor executor)

throws SQLException {

executor.startBatch();

for(int i = 0, n = list.size();i < n;i++){

executor.insert（”productAttach.insertProductAttach“，list.get(i));

}

executor.executeBatch();

return null;} });

ibatis,jdbc,hibernate的分段的實現: 都應該在組裝list的時候進行拆分（如：action層加入）if(list.size()% 1000 == 0){ productAttachService.addBatch(list);list.clear();}

if(list.size()> 0)productAttachService.addBatch(list);

４３

業務場景篇

一、Spring的概述

Spring 是完全面向接口的設計，降低程序耦合性，主要是事務控制并創建bean實例對象。在ssh整合時，充當黏合劑的作用。

IOC(Inversion of Control)控制反轉/依賴注入，又稱DI(Dependency Injection)(依賴注入)

IOC的作用：產生對象實例，所以它是基于工廠設計模式的

Spring IOC的注入

通過屬性進行注入，通過構造函數進行注入，注入對象數組

注入List集合 注入Map集合注入Properties類型

Spring IOC 自動綁定模式：

可以設置autowire按以下方式進行綁定

按byType只要類型一致會自動尋找，按byName自動按屬性名稱進行自動查找匹配.AOP 面向方面（切面）編程

AOP是OOP的延續，是Aspect Oriented Programming的縮寫，意思是面向方面(切面)編程。

注：OOP(Object-Oriented Programming)面向對象編程

AOP 主要應用于日志記錄，性能統計，安全控制,事務處理（項目中使用的）等方面。

Spring中實現AOP技術：

在Spring中可以通過代理模式來實現AOP

代理模式分為

靜態代理：一個接口，分別有一個真實實現和一個代理實現。

動態代理：通過代理類的代理，接口和實現類之間可以不直接發生聯系，而

可以在運行期（Runtime）實現動態關聯。

動態代理有兩種實現方式，可以通過jdk的動態代理實現也可以通過cglib

來實現而AOP默認是通過jdk的動態代理來實現的。jdk的動態代理必須要有

接口的支持，而cglib不需要，它是基于類的。

Spring AOP事務的描述：

在spring-common.xml里通過里面先設定一個表達式，設定對service里那些方法

如：對add* ,delete*,update*等開頭的方法進行事務攔截。我們需 ４４

要配置事務的傳播（propagation=”REQUIRED“）特性,通常把增,刪,改以外的操作需要配置成只讀事務（read-only=”true“）.只讀事務可以提高性能。之后引入tx:advice,在tx:advice引用 transactionManager（事務管理）,在事務管理里再引入sessionFactory,sessionFactory注入 dataSource，最后通過 引入txAdvice。

Spring實現ioc控制反轉描述：

原來需要我們自己進行bean的創建以及注入，而現在交給 spring容器去完成bean的創建以及注入。

所謂的“控制反轉”就是 對象控制權的轉移，從程序代碼本身轉移到了外部容器。

官方解釋: 控制反轉即IoC(Inversion of Control)，它把傳統上由程序代碼直接操控的對象的調用權交給容器，通過容器來實現對象組件的裝配和管理。

所謂的“控制反轉”概念就是對組件對象控制權的轉移，從程序代碼本身轉移到了外部容器。

二、事務概述

在數據庫中,所謂事務是指一組邏輯操作單元即一組sql語句。當這個單元中的一部分操作失敗,整個事務回滾，只有全部正確才完成提交。

事務的ACID屬性

1.原子性（Atomicity）

原子性是指事務是一個不可分割的工作單位，事務中的操作要么都發生，要么都不發生。

2.一致性（Consistency）

事務必須使數據庫從一個一致性狀態變換到另外一個一致性狀態。(數據不被破壞)

3.隔離性（Isolation）

事務的隔離性是指一個事務的執行不能被其他事務干擾.4.持久性（Durability）

持久性是指一個事務一旦被提交，它對數據庫中數據的改變就是永久性的.在JDBC中，４５

事務默認是自動提交的，每次執行一個 SQL 語句時，如果執行成功，就會向數據庫自動提交，而不能回滾

為了讓多個 SQL 語句作為一個事務執行：

（1）執行語句前調用 Connection 對象的 setAutoCommit(false);

以取消自動提交事務

（2）在所有的 SQL 語句都成功執行后，調用 commit();方法提交事務（3）在出現異常時，調用 rollback();方法回滾事務。

三、權限概述

權限涉及到5張表：

用戶表，角色表，權限表(菜單表)，用戶角色關聯表，角色權限關聯表

當用戶登錄時，根據用戶名和密碼到用戶表驗證信息是否合法，如果合法 則獲取用戶信息，之后根據用戶id再到用戶角色關聯表中得到相關連的角色

id集合,之后根據角色id再到角色權限關聯表中獲取該角色所擁有的權限id集合，然后再根據權限id集合到權限表（菜單表）中獲取具體的菜單，展現給當前 登錄用戶，從而達到不同用用戶看到不同的菜單權限。

我們通過ZTree來給角色賦權并且通過ZTree來展示菜單，以及通過ZTree來管 理菜單即增加和編輯菜單。

我們做的權限控制到url級別,為了防止用戶不登錄直接輸入url訪問的這個弊端，通過攔截器進行攔截驗證。

四、OSCache業務場景

在我以前的項目中，我們考慮了系統性能問題，這個時候我們采用了Oscache緩存，剛開始把這個功能交給了項目組中的另外一個同事來做的，但是他做完的時候他發現緩存中明明已經緩存了數據，但是在取得時候發現沒有數據，我們項目經理讓我去幫忙看看這個問題，我閱讀完他的代碼之后，我發現了他每次緩存的時候都是調用一個新的緩存對象的方法，結果出現了明明已經走了緩存的方法而取不到數據的問題，通過我多年的工作經驗，我就想到了應該用單例模式去封裝一個單例工具類來調用oscache。但是，在后來的測試過程中，發現當并發訪問的時候也會出現上述的問題，這個時候我直接采取的DCL（雙重判定鎖）單例模式封裝了工具類，既解決了線程安全問題，相對的性能問題也考慮到了，這個問題才得到了完善的解決。

４６

五、線程概述

線程的狀態以及狀態之間的相互轉換：

1、新建狀態(New)：新創建了一個線程對象。

2、就緒狀態(Runnable)：線程對象創建后，其他線程調用了該對象的start()方法。該狀態的線程位于可運行線程池中，變得可運行，等待獲取CPU的使用權。

3、運行狀態(Running)：就緒狀態的線程獲取了CPU，執行程序代碼。

4、阻塞狀態(Blocked)：阻塞狀態是線程因為某種原因放棄CPU使用權，暫時停止運行。直到線程進入就緒狀態，才有機會轉到運行狀態。阻塞的情況分三種：

(一)、等待阻塞：運行的線程執行wait()方法，JVM會把該線程放入等待池中。

(二)、同步阻塞：運行的線程在獲取對象的同步鎖時，若該同步鎖被別的線程占用，則JVM會把該線程放入鎖池中。

(三)、其他阻塞：運行的線程執行sleep()或join()方法，或者發出了I/O請求時，JVM會把該線程置為阻塞狀態。當sleep()狀態超時、join()等待線程終止或者超時、或者I/O處理完畢時，線程重新轉入就緒狀態。

5、死亡狀態(Dead)：線程執行完了或者因異常退出了run()方法，該線程結束生命周期。

實現線程的兩種方式：

是繼承Thread類或實現Runnable接口，但不管怎樣，當new了這個對象后，線程就已經進入了初始狀態 wait和sleep的區別：

線程訪問：

鎖池狀態，之后等待鎖釋放，然后訪問代碼

wait

等待隊列(釋放資源)--->調用notify或者notifyall之后鎖池狀態--->(等待鎖釋放)--->可運行狀態--->運行狀態---->訪問代碼

sleep,join

不釋放資源-->結束后直接進入可運行狀態--->運行狀態---->訪問代碼

一個java控制臺程序，默認運行兩個線程，一個主線程，一個垃圾回收線程。線程與進程的區別：

1.線程(Thread)與進程(Process)進程定義的是應用程序與應用程序之間的邊界，通常來說一個進程就代表一個與之對應

的應用程序。不同的進程之間不能共享代碼和數據空間，而同一進程的不同線程可以共

享代碼和數據空間。

2.一個進程可以包括若干個線程，同時創建多個線程來完成某項任務，便是多線程。

六、Ajax請求Session超時問題

我在做項目時有時會遇到session超時問題，如果session超時，平常請求沒有什么問題，通過攔截器可以正確跳到登陸頁面，可是你如果用ajax請求的話這就出現問題了，因為ajax是異步的，局部刷新，所以登陸界面不會再全頁面中顯示，他只會顯示到頁面的一部分當中。所以根據我這幾年的經驗找到了我認為比較好的一種方法。因為那我用的框架是和struts2集成的，所以就在攔截器中進行設置：

４７

首先判斷session是否為空就是判斷session是否超時，如果超時就取出請求的head頭信息request.getHeader(”x-requested-with“)，如果不為空就和XMLHttpRequest(Ajax標識)進行比較(request.getHeader(”x-requested-with“).equalsIgnoreCase(”XMLHttpRequest“)))如果相等說明此請求是ajax請求。

如果是ajax請求就可以用response.setHeader(”鍵“,”值“)來設置一個標識來告訴用戶這是ajax請求并且session超時時發出的，這樣我就可以在回調函數中取出自己設置的那個唯一標識：XMLHttpRequest.getResponseHeader(”“);如果取出的值是和自己在后臺中設置的值一樣的話，就證明session已經超時，這樣就可以設置window.location.replace(”登陸界面")，來跳轉到登陸界面了。

這樣做雖然解決了問題，但是，會在每個回調函數中寫入那些代碼，這樣的話代碼就會顯得特別零散，所以就想能不能定義一個全局的設置所以就找到了jqery的ajaxSetUp方法，通過ajaxSetUp對jqery的ajax進行全局的判斷(ajaxSetUp就相當于ajax的攔截器)，通過設置ajaxSetUp里的complete，它就相當于回調函數，這樣那就彌補了上一方法的不足。我做項目時還用到$(document).ajaxStart()，這是ajax請求時的事件；$(document).ajaxSuccess()，這是AJAX請求成功后的事件。我一般用他們來顯示遮罩層和隱藏遮罩層用的加遮罩層是為了不讓用戶重復提交，更提高了用戶體驗度，讓用戶知道已經提交了。

七：java線程池概述

java線程池的工作原理和數據庫連接池的差不多，因為每次重新創建線程 都是很耗資源的操作，所以我們可以建立一個線程池，這樣當需要用到線程 進行某些操作時，就可以直接去線程池里面找到空閑的線程，這樣就可以直接 使用，而不用等到用到的時候再去創建，用完之后可以把該線程重新放入線程池 供其他請求使用從而提高應用程序的性能。

線程池的核心流程: 1.構建一個 ThreadPoolExecutor 并指定默認要創建的線程的數量 2.通過 threadPool.execute()去添加一個個要執行的線程即實現了Runable接口的java類

3.在實現了Runable接口的java類的run方法中寫入具體的業務代碼 線程池的業務場景：

我在工作的時候，當時一個同事給我提了一個需求，目前有大量的圖片 需要處理生產縮略圖并進行加水印，因為按照普通的處理方法一個個的 進行處理太慢了，問我有沒有好的解決方案，這個時候我就想到了java中 的線程池，我構建了一個線程數為5個線程池，然后采用分段批量提取的

方式每500條為一組數據進行圖片信息的提取，然后再把這些通過Threadpool的 execute方法交給線程池中的線程進行處理，即充分使用了CPU硬件資源又加快 了大數據情況下程序的處理效率。

４８

我當時在工作的過程中，認識一個做電商的朋友，他們當時公司才起步，很多 技術都不成熟，所以就常常和我探討一些技術問題，有次他向我請教一個問題，問我如何才能提高網站的性能，我根據自己在項目中的經驗以及自己以前閱讀的

關于優化方面的資料給他提出了很多建議，如用lucene進行全文檢索，用memcached 進行分布式緩存，以及通過spring定時器結合freeMarker模板引擎來生成靜態 頁面，由于要生成的頁面的數量比較多，考慮到程序的性能，我建議他結合 java的線程池進行工作，這樣就可以充分使用了CPU硬件資源又加快 了大數據情況下程序的處理效率。

八、OSCache概述

oscache是一個高性能的j2ee框架，可以和任何java代碼進行集成，并且還可以通過標簽對頁面內容進行緩存，還以緩存請求。

我們通常將那些頻繁訪問但是又不是經常改變的數據進行緩存。為了保證緩存數據的有效性，在數據發生改變的時候，我們要刷新緩存，避免臟數據的出現。刷新緩存的策略有兩種，一種是定時刷新，一種手動刷新。

緩存數據的時機通常也分為兩種，即在tomcat(web容器)啟動時候加載數據進行緩存，另外也可以在用戶第一次訪問數據的時候進行緩存，這個相當于緩存的立即加載和按需加載。

緩存的層次如下:jsp-->action-->service-->dao,緩存越靠前對性能的提升越大

一個action里面可以有多個service,一個service中可以有多個dao或者多個service

任何類之間都可以進行相互調用，可以通過構造函數傳參，set,get傳參或者是方法傳

參將相關的類連接起來。

九、OSCache+autocomplete+單例業務場景

在我以前做某項目的過程中，其中我們在做產品列表的查詢的時候為了提高用戶的體驗度，我們使用了autocomplete插件來代替select進行品牌的選擇，才開始的時候每次都要根據用戶輸入的信息去查詢數據庫進行模糊匹配返回結果，后來我們考慮到系統的性能，因此我們采用了oscache緩存，才開始這個功能是交給我們項目組中的另外一個同事來做的，但是他做完后，我們在使用這個工具類的時候，發現有時緩存中明明已經有時我們需要的數據，但是從緩存里面取的時候，發現沒有，之后項目經理讓我去幫這個同事看看這個問題，我經過閱讀他的代碼發現，它里面在使用緩存的時候，針對于每次方法的調用都產生一個新的實例，結果導致了上面的問題，這個時候我想起了可以使用設計模式中的單例模式來解決這個問題，才開始我直接采用了普通的單列模式，但是后來在測試的過程中，發現當用戶并發量大的時候還是會出現上面的問題，之后我再次考慮了代碼，最后發現是因為沒有給單列模式加鎖的原因，從而導致了大用戶并發的時候，線程安全的問題，之后我便在方法上加上了synchronized關鍵字，解決上述的問題，但是后來測試人員反饋，覺的這段的性能有問題，我考慮之后便采用在方法體內加鎖并結合雙重判定的方式解決了上面的問題。

４９

我們是將數據在tomcat啟動的時候加載到緩存中，之后用戶進行查詢的時候直接從緩存中獲取數據，根據前綴匹配進行查詢，將結果返回給用戶。這樣在提高用戶體驗度的同時也提高性能。

十、緩存概述

應用程序為了提高性能，可以通過使用緩存來達到目的，緩存的存儲介質可以 內存或者硬盤，通常將數據存儲在內存里，確切的說是jvm的內存中，緩存是 基于Map這種思想構建的，以鍵值對的方式進行存取，之所以還可以將

緩存的數據存儲在硬盤中，是因為內存資源相當有限和寶貴，所以當內存資源 不足的時候，就可以將其存儲到硬盤中，雖然硬盤的存取速度比內存要慢，但是 因為減少了網絡通信量，所以還是提高程序的性能。緩存可以分為客戶端緩存和 服務器端緩存，所謂的客戶端緩存通常指的是IE瀏覽器的緩存，服務器端緩存指 的web服務器的緩存，通常可以通過第三方組件實現，如oscache,memcache

我們通常將那些頻繁訪問但是又不是經常改變的數據進行緩存。為了保證緩存數據的 有效性，在數據發生改變的時候，我們要刷新緩存，避免臟數據的出現。刷新緩存的 策略有兩種，一種是定時刷新，一種手動刷新。

緩存的層次如下:jsp-->action-->service(通常放置在service)-->dao, 緩存越靠前對性能的提升越大

緩存的策略:(緩存空間不足需要進行清理的時候使用)LRU:最近最少使用原則.(理解:存儲書)FIFO:先進先出的緩存策略.(理解:排隊)

你來說說緩存？說說你對緩存的理解（如果遇到重復的，就可以省略）

我們在項目中使用緩存的目的是為了提高應用程序的性能，減少訪問數據庫 的次數，從而提高應用程序的吞吐量。我們通常將權限，菜單,組織機構

這些頻繁訪問但是不經常改變的基礎數據進行緩存，其中我在做()某某項目的時候 就通過oscache對ZTree的樹形菜單進行了緩存，并且在做的時候和單列設計 模式進行結合，考慮到多線程下的安全問題，還對單例模式加入了雙重判定鎖 的檢查方式。

十一、實現頁面靜態化業務場景

我們在做某項目時，涉及到程序訪問的性能問題，這時候我們想到可以通過靜態化來提高用戶訪問時候的性能，所以我們就采用了freemarker模板引擎，考慮到頁面也是要有動態的變化的，所以我們采用spring定時器在每天晚上2點鐘的時候定時再次生成html靜態

５０