第一篇：JAVA培訓(xùn)總結(jié),重點都有1
學(xué)習(xí)使人進(jìn)步 第一課
一、java 語言簡介：
是由 sun 公司推出的新一代的純面向?qū)ο蟮木W(wǎng)絡(luò)編程語言，1995年問世的。
二、java語言的特性：
1、簡單的： { keep it simple and stupid(保持它的簡單性和可操作性)以人類正常的思維模式思考問題。java 是由c++語言 發(fā)展而來。
java 提供了非常豐富的內(nèi)置資源庫（API）}
2、安全的：健壯性 {
1、java 中沒有指針（指針，是一項能直接指向內(nèi)存地址的）
2、java 會內(nèi)存釋放--GC機制（垃圾回收器，自動釋放）
3、預(yù)檢索程序錯誤--在程序執(zhí)行前，會檢查程序是否有 語法 錯誤，有則不會允許執(zhí)行。
4、異常處理機制--}
3、可伸縮的： {
1、平臺：把軟件的語言，翻譯成硬件 所能識別的語言，即程序運行的硬件和軟件的環(huán)境。
2、java SE--java 標(biāo)準(zhǔn)版（實現(xiàn) 桌面應(yīng)用程序）
3、java EE--j2EE 企業(yè)級版本
4、java ME--java 微型版本（嵌入式 開發(fā)）}
4、跨平臺的： {
}
5、面向?qū)ο蟮模?{
1、現(xiàn)實世界是什么樣子的：（山川、河流、動物、植物。。分類組成的）
現(xiàn)實世界 就是對所有的事物進(jìn)行分類，分類就代表一個群體。
分類就是將具有相同特征和行為的事物進(jìn)行概括。
每個分類下面都有無數(shù)的個體，在java 語言中，和現(xiàn)實世界是一樣的，也是要先分類再去實現(xiàn)分類下的個體（java 中將 個體稱為：對象）
根據(jù)：特征（屬性）、行為 劃分的2、java 語言中，類和對象的關(guān)系：
java 語言中將現(xiàn)實世界中表示群體的分類稱之為類，而是將群體下面的每一個個體稱之為對象；
具有相同屬性和行為的 對象的集合 抽象為類或稱之為類型
對象是類的一個具體的實例，展示了類的不同屬性和行為
實例化：就是將抽象的類 轉(zhuǎn)化成具體的個體的過程
3、如何用java語言去描述類：
java 語言中類的描述分為兩部分：
1、要描述 他的屬性（特征、靜態(tài)屬性）
2、要描述的是行為（動態(tài)屬性、方法）語法格式：
class class_name{靜態(tài)屬性；動態(tài)屬性；}
類
類名
類體
靜態(tài)屬性：相當(dāng)于 字段 動態(tài)屬性：用方法描述 }
主控制類：
1、聲明對象
并對 對象 進(jìn)行 實例化對象
類型名 對象名=new 類型名()//聲明部分
2、使用對象，即向?qū)嶓w類發(fā)送消息。
對象名.屬性名=“屬性值”-----字符串用“" 數(shù)值 不用
對象名.方法名()
第二課
跨平臺性：
*
一、java如何實現(xiàn)跨平臺的？
1、平臺：把軟件的語言翻譯成硬件所能識別的語言，即程序運行的軟件或硬件環(huán)境。
java 之所以能夠?qū)崿F(xiàn)跨平臺性，是因為 java 有屬于自己的平臺，不直接與操作系統(tǒng)或硬件環(huán)境交流。
java平臺系統(tǒng)由兩部分組成：
1、java開發(fā)工具包；
2、java運行的軟環(huán)境（java虛擬機--JVM---java virtual machine）
API：是一些已編寫好的程序的集合，他提供java 面對程序員的接口。
接口：很多內(nèi)置資源中，有一個數(shù)據(jù)包存儲對市面上已經(jīng)存在的各種操作系統(tǒng)進(jìn)行解析。
java虛擬機：（JVM）就是一個小型的計算機，也可稱為 java的解釋器。作用：是翻譯、解釋java 的語言，只認(rèn)識字節(jié)碼文件（.class文件）。
java 實現(xiàn)跨平臺的原理：
.java 是程序員所能夠識別的代碼，通過 編譯器 轉(zhuǎn)換成 解釋器 所能夠識別的.class字節(jié)碼文件，解釋器 將.class字節(jié)碼文件 轉(zhuǎn)換成目標(biāo)機器 代碼文件，以
上就是java 實現(xiàn)跨平臺的原理。
*面向?qū)ο蠛?面向過程 兩者之間的區(qū)別：
1、面向過程：是分析出解決問題所需要的步驟，然后用方法 把這些步驟一步一步的實現(xiàn)，當(dāng)使用的時候，一個一個 依次調(diào)用。缺點，代碼的可重用性和可維護(hù)性 較差。
2、面向?qū)ο螅菏前褬?gòu)成問題的每一個對象 進(jìn)行分類，分類的目的不是為了解決某一個步驟，而是為了描述 某個事物在整個解決問題步驟中的行為。優(yōu)點：代碼的可重用性和可維護(hù)性較強。
分類--創(chuàng)建對象--發(fā)送消息
*作業(yè)1：用自己的語言 描述 類、對象、實例化，三者之間的關(guān)系。
類 就是擁有相同特征和行為 的 某一群體，而，對象就是 這一群體 中的某一個體，而實例化 是對群體聲明，使其從死的變成活的，使其從不占用系統(tǒng)內(nèi)存--到占用系統(tǒng)內(nèi)存。類--人 個體--王寧
實例化--王寧定義成人 的過程
作業(yè)2：使用 java 語言 描述 汽車類（品牌、顏色、車牌號、排氣量）行為：汽車運行。作業(yè)3：用java 語言，描述 門 類型（長、寬、材質(zhì)）行為：求面積、求周長
第二章
方法的設(shè)計
第一課
方法的語法規(guī)則：
[限定修飾詞] 返回值類型 方法名([形參列表])//方法頭 {
方法體;//方法所要執(zhí)行的一系列的語句（可以是一條或多條語句）}
只要是被稱之為 語句的都要 放在方法體中 執(zhí)行。
一、限定修飾詞 作用：對類的成員施以一定的 訪問權(quán)限限制，實現(xiàn)類中的成員一定范圍內(nèi)信息的隱藏。---限制方法被調(diào)用的范圍。
1、public 公共的，公有的，可以被 所有的類 進(jìn)行訪問。對所有用戶開放，所有的用戶都可以直接進(jìn)行調(diào)用。
可以被 當(dāng)前類下的程序訪問，同一包（同一文件夾）下的類訪問，子孫類訪問，其他包下的類訪問。
2、protected 受保護(hù)的，可以被 同一包下的類 訪問，父類 和 子類 的繼承關(guān)系中 也可以訪問。
3、friendly 友好的，默認(rèn)的限定修飾詞，可以被當(dāng)前類或 同一包下的類訪問。
4、private
私有的，只能有本類 來進(jìn)行訪問。
作用域
當(dāng)前類
同一包
子孫類
其他包 public
*
*
*
* protected *
*
*
x friendly *
*
x
x private
*
x
x
x
二、返回值 類型：
1、有返回值
⒈基本數(shù)據(jù)類型
整形的 byte（字節(jié)數(shù)據(jù)類型，1個字節(jié)）、short（短整型，2個字節(jié)）、int（4個字節(jié)，默認(rèn)的整形）、long（長整形，8個字節(jié)）
浮點數(shù) float（單精度浮點數(shù)，4個字節(jié)）
double（雙精度浮點數(shù)，8個字節(jié)，默認(rèn)的類型）
其他
char（字符數(shù)據(jù)類型，1個字節(jié)，用''號）
boolean（布爾數(shù)據(jù)類型，占1/8字節(jié)，只有
true/false）
⒉復(fù)合數(shù)據(jù)類型（引用數(shù)據(jù)類型）
類類型
數(shù)組
枚舉
接口
泛類型
標(biāo)注
（如果方法設(shè)定時，將其設(shè)定為有返回值類型的，那么，在方法體內(nèi) 必須有一條return 語句。return語句的作用:
1、返回給 調(diào)用者一個確切的值，而且該值的數(shù)據(jù)類型，必須與方法定義的返回值類型相一致。return語句 使用的注意事項：
1、一個方法體內(nèi)只能出現(xiàn)一條可執(zhí)行的return語句；
2、return語句后 可以是常量、變量或 表達(dá)式，但是 必須保證只能得到一個準(zhǔn)確值；
3、return語句 有結(jié)束方法體的作用，所以在return語句后 不允許出現(xiàn)任何的可執(zhí)行語句。）
2、無返回值 void
（如果是無返回值類型的，往往方法體內(nèi)描術(shù)的是一系列的動作，不需要給方法調(diào)用者 一個返回值。）
有返回值 與 無返回值 在執(zhí)行上的區(qū)別：
1、無返回值方法的調(diào)用步驟：傳遞參數(shù)、執(zhí)行方法體中的各條語句
2、有返回值方法的調(diào)用步驟：傳遞參數(shù)、執(zhí)行方法體中的語句、返回給調(diào)用者一個
確切的值
三、方法名
標(biāo)識符的命名規(guī)則和規(guī)范：
規(guī)則：
1、必須以字母、下劃線、或美元符號開頭，后面可以跟隨字母、下劃線、美元符號、或數(shù)字。
2、區(qū)分大小寫。
3、不可以單獨使用java中的關(guān)鍵字和保留字。
類名的規(guī)范：
1、簡單單詞做為類名，要求首字母大寫，其余字母小寫。
2、復(fù)合單詞作為類名，要求每一個單詞的首字母都要大寫，其余字母小寫。
變量名及方法名的規(guī)范：
1、簡單單詞作為變量名及方法名時，要求所有字符全部小寫。
2、復(fù)合單詞作為變量名及方法名時，要求第一個單詞所有字母小寫，從第二個單詞之后首字母大寫，其余字母小寫。
其他要注意的規(guī)范：
1、嚴(yán)格區(qū)分大小寫。
2、一個源文件中，只允許寫一個類。
3、源文件的名字要與類名字，相一致。
四、參數(shù)
參數(shù)：在調(diào)用方法的過程中，可以由參數(shù)對數(shù)據(jù)進(jìn)行傳遞。參數(shù)的分類：
1、形式參數(shù)：是在方法定義時，所定義的變量，就稱之為形式參數(shù)，或簡稱為形
參。可以一次定義多個，中間用，號分隔。
：是方法 接受參數(shù)的占位符。
2、實際參數(shù)：調(diào)用方法時，為形式參數(shù)所傳遞的具體值，就叫做實際參數(shù)。簡稱為 實參，實參可以有多個，中間用，號分隔。
形式參數(shù)在使用時的注意事項：
1、形式參數(shù)可以有一,個到多個，中間必須用，號分隔。
2、每一個形式參數(shù)就是聲明一個變量，但是不能為其賦值。
3、在我們的方法體內(nèi)，可以直接使用聲明的形式參數(shù)。
4、形式參數(shù) 只能在調(diào)用方法的時候，由方法的調(diào)用者為其賦值。實際參數(shù)在使用時的注意事項：
1、實際參數(shù)的數(shù)據(jù)類型 必須與形式參數(shù)的數(shù)據(jù)類型相一致 或相兼容。
2、實際參數(shù)的順序必須 與形式參數(shù)定義的順序相一致。
3、實際參數(shù)的個數(shù)必須與 形式參數(shù)的個數(shù)相一致。
參數(shù)傳遞的分類：
1、值傳遞：就是基本數(shù)據(jù)類型之間 數(shù)據(jù)的交互就稱之為 值傳遞
2、地址傳遞：就是對象 與 對象之間 數(shù)據(jù)的傳輸。
有三個類
男 女 中
男要向女
送一朵
玫瑰花
某男孩 喜歡 某女孩
送一朵 玫瑰花
第二課
一、事件委托機制
就是兩個類型不想做正面接觸，又想達(dá)到一定的目的，可以委托第三類完成。
方法體：就是程序功能的描述。通過運算符和表達(dá)式體現(xiàn)出來。
運算符 與 表達(dá)式：
運算：就是對數(shù)據(jù)進(jìn)行的操作。
運算符：就是運算時所使用的符號，稱為運算符。操作數(shù)：參與運算的數(shù)據(jù)。
表達(dá)式：由操作數(shù)和運算符，按一定語法形式 組成的有意義的符號序列。結(jié)合性：左，從左到右 開始運算
右，從右向左 開始運算
運算符：
1、賦值運算符：
變量名 = 值;（= 是將右邊的值 賦給 左邊的變量）
復(fù)合賦值運算符： +=、-=、*=、/=、%=
2、算術(shù)運算符：
1、一元
---元：指操作數(shù)的個數(shù)（+正號，-負(fù)號，++自增1 符號，--自減1 符號）例：int a=3
int b=++a 前綴
int b=a++ 后綴
如果 自增或自減 運算符，在變量之前，那么 我們就先自加1 或 自減1 后在使用，如果自增 或 自減 運算符 在變量之后，那么 我們就先使用，后自加1 或 自減1 的操作。
2、二元（+、-、*、/、%）
如果兩個操作數(shù) 都為整數(shù)的情況下，/ 表示整除，那么得到的結(jié)果就是 整數(shù)。
+、-、*、/ 中 只要操作數(shù)是整數(shù)，的到的結(jié)果 就是整數(shù)，操作數(shù) 是浮點數(shù)，得到的結(jié)果就是浮點數(shù)。
% 取模 操作數(shù)1 和 操作數(shù)2 如果 是負(fù)數(shù)的話，看% 符號，左邊的 操作數(shù)符號 賦給最終結(jié)果。
如果操作數(shù)有一個負(fù)數(shù)，先忽略操作數(shù)的符號，進(jìn)行運算，然后，將左邊操作數(shù)的符號 賦給 最終結(jié)果。
浮點數(shù)取模：a%b=a-((int a/b)*b)總結(jié)：
3、三元（表達(dá)式1？ 表達(dá)式2：表達(dá)式3；）
判斷表達(dá)式1 的結(jié)果（必須是 布爾類型）如果是 true 值 時，執(zhí)行--表達(dá)式2，如果是false 值，執(zhí)行--表達(dá)式3；
先算一元，再算二元，最后算三元。
3、其他運算符
編寫程序的三點原則：
1、就是保證程序運行速度快，每一條語句 盡量做到 優(yōu)化。
2、就是節(jié)省內(nèi)存資源。
3、保證程序運行的安全系數(shù)。
*** 如果一個類
是 public 來修飾的，類名 必須 與原文件名
相同。
第三課
一、關(guān)系運算符（>、<、>=、<=、==、!=）
任何一個 由關(guān)系運算符 鏈接的表達(dá)式，其返回值 一定是一個 布爾類型的值。
二、邏輯運算符（&& 與、|| 或、！非）
邏輯運算符 鏈接的表達(dá)式（前面或后面）
必須是一個布爾 數(shù)據(jù)類型的值，或能夠 獲得布爾值的表達(dá)式。
對“||”運算，如果左邊的表達(dá)式的值為true，則不必對運算符右邊的表達(dá)式再進(jìn)行運算，整個表達(dá)式的結(jié)果就為true。
對“&&”運算，如果左邊的表達(dá)式的值為false，則不必對運算符右邊的表達(dá)式再進(jìn)行運算，整個表達(dá)式的結(jié)果就為false。
（先算 非！，再算 與&&，最后算 或||）
位運算符：對二進(jìn)制 數(shù)進(jìn)行的運算。
~ 按位取反：對數(shù)據(jù)的每一個二進(jìn)制位 取反運算，1--0,0--1
& 按位 與運算 ： 要求有兩個操作數(shù)進(jìn)行運算，如果兩個相應(yīng)位均為一，則該位結(jié)果為1，否則結(jié)果為0。8&9--1000&1001
| 按位或 運算：
8|9 要求有兩個操作數(shù)進(jìn)行 運算，只要 兩個相應(yīng)位 中 有1 個 為1，則該位 結(jié)果為 1，否則 該位結(jié)果 為 0。
^ 按位 異或 運算：相同數(shù)值 為假，不同數(shù)值 為真。
相同的數(shù)字 進(jìn)行按位異或運算 得到的結(jié)果 及 為0，不同的數(shù)字 進(jìn)行按位異或運算 得到的結(jié)果 及為 1。
<< 左移 運算：x<<，箭頭 指向 則是要 移的 方向。
x 左移 移動n 位，就相當(dāng)于 x*2的n次冪。
>> 右移 運算（算術(shù)右移--相當(dāng)于除法運算）：8>>2 === 8/2
x右移 n位，就相當(dāng)于 x/2的 n次冪。
>>> 邏輯右移 ： 不管正數(shù) 還是 負(fù)數(shù)，空出來的左側(cè) 的高位，全部補 0。
邏輯右移 又被稱為 不帶符號位的右移，x邏輯右移n 位，就是將x 的各位 右移n 位，移到右端的低位 舍棄，左移后 左邊 留下的空位 一律 補0.負(fù)數(shù)的二進(jìn)制數(shù) 求法： 先忽略 符號，得到正數(shù) 的二進(jìn)制數(shù)，在進(jìn)行 按位取反，在在最后一位加一。
空出來的高位，正數(shù) 用 0 補，負(fù)數(shù) 用 1補。
邏輯與和或 與 按位與和或 的 區(qū)別：
1、&& 邏輯與 ||或運算符，& 按位與 |或 運算符。
2、邏輯與 ||或 的兩個操作數(shù) 都必須 是布爾數(shù)據(jù)類型，而 按位與 |或 的操作數(shù) 可以是任意的 基本數(shù)據(jù)類型。
3、邏輯與 ||或 有短路功能，而 按位與 無短路功能。
1、new 運算符
：就是對 對象 進(jìn)行實例化。
2、對象名 instance Of 類名
判斷你所給出來 的 對象 是否 屬于這個類 得到的結(jié)果 是布爾類型值，返回值 為true 說明 該對象 屬于該類，如果 返回false 說明該對象 不屬于 該類。
第四課
一、復(fù)合語句：
1、流程控制語句：
循環(huán)語句---使用的時機，當(dāng)程序中 有一條 到多條 需要 重復(fù)執(zhí)行時，我們就要用到 循環(huán)語句。
1、當(dāng)型 while 循環(huán)
while（條件表達(dá)式）--當(dāng) 條件表達(dá)式 滿足的時候 進(jìn)入 循環(huán)體
{
循環(huán)體；
}
工作流程：while 是當(dāng)?shù)囊馑?，?dāng)條件表達(dá)式的 內(nèi)容為真時，進(jìn)入循環(huán)體，循環(huán)體 執(zhí)行結(jié)束后，再一次判斷循環(huán)條件，如為 真，繼續(xù)回到 循環(huán)體 執(zhí)行，直到循環(huán)條件為假 時，終止 循環(huán)。
在使用 while循環(huán)時要考慮的內(nèi)容：
1、什么時候進(jìn)入循環(huán)體，什么時候退出循環(huán)體；
2、進(jìn)入循環(huán)體之后做什么；
2、直到型循環(huán)（do……while 循環(huán)）
do
{
循環(huán)體；
}while();
do。。while 循環(huán)的工作流程：在沒有 判斷循環(huán)條件的情況下 進(jìn)入循環(huán)體，循環(huán)體 執(zhí)行結(jié)束后，判斷 是否滿足 循環(huán)條件，如果 返回值 為 true，在一次 進(jìn)入到 循環(huán)體，直到 返回 false 為止。
while 與 do。while 的區(qū)別：
1、while 是先 判斷條件 在 決定 是否 進(jìn)入循環(huán)體。
do。while是先進(jìn)入 循環(huán)體，然后在判斷條件，在決定 是否繼續(xù)進(jìn)入循環(huán)。
2、使用 do while 循環(huán)時，循環(huán)體 至少被 執(zhí)行 一次。
3、for 循環(huán)
for(表達(dá)式1；表達(dá)式2；表達(dá)式3)
{
循環(huán)體；
} 表達(dá)式1：循環(huán)變量的初始值。
表達(dá)式2：循環(huán)條件，得到的 必須是一個 布爾 值。表達(dá)式3：循環(huán)步長，循環(huán)變量的增量值。
要注意的：
1、可同時為空，當(dāng)所有條件 都為空時，表示的是 死循環(huán)，2、表達(dá)式1，與表達(dá)式3 的位置 可以同時存放多個 表達(dá)式，中間用逗號，分隔。
3、表達(dá)式2 的位置，必須返回 一個布爾值。
4、循環(huán)體 可以為空。
工作流程：
1、執(zhí)行表達(dá)式1；
2、執(zhí)行表達(dá)式2，判斷條件是否成立；
3、執(zhí)行循環(huán)體；
4、執(zhí)行 表達(dá)式3；
5、回到 表達(dá)式2，判斷是否成立，成立3--4--5，不成立 退出循環(huán)；
第五課
Integer.parseInt(args[0])
// 轉(zhuǎn)換 成 int 類型
System.err.println(”請輸入一個值");//從標(biāo)準(zhǔn) 錯誤流
中 輸出 一句話。System.exit(-1);// 退出 java 虛擬機，exit 方法 需要 傳遞 一個int 類型的參數(shù)，此參數(shù)只能是 0 或-1。當(dāng)傳遞值為0 時，表示正常狀態(tài)退出 java虛擬機；當(dāng)參數(shù)為-1時，表示非正常狀態(tài) 退出java虛擬機。
}
1、命令行參數(shù)傳遞給誰？
傳遞給main方法中定義的String類型的args數(shù)組。
2、命令行出現(xiàn)多個參數(shù)由誰分隔？
多個參數(shù)通過空格分隔
3、命令行傳遞的值是什么數(shù)據(jù)類型？
String數(shù)據(jù)類型
4、令行參數(shù)如何進(jìn)行數(shù)據(jù)類型的轉(zhuǎn)換？
1）轉(zhuǎn)換為int類型
Integer.parseInt();
2）轉(zhuǎn)換為double類型： Double.valueOf(args[0]).doubleValue();
5、String args[]中args是否可由其他名字來代替？
可以
6、String[]args和String args[]兩種寫法是否都是正確的?
兩種寫法都是正確的。
方法
分三類：
1、構(gòu)造方法：又叫做 構(gòu)造函數(shù)、構(gòu)造器，構(gòu)造方法名 與類名 相同。沒有 返回值，但是 不用 void 修飾。
一個類中，可以有一個到多個 構(gòu)造方法。如果 有多個構(gòu)造方法，那么 要求 每個構(gòu)造方法的參數(shù)類型、個數(shù) 一定不同。由此，決定調(diào)用哪一個構(gòu)造方法。
構(gòu)造方法 只能通過 new 運算符調(diào)用。
作用：
1、在內(nèi)存中分配一塊空間，給 實例化的對象；
2、為成員變量 初始化；
默認(rèn)的構(gòu)造方法:參數(shù)體、方法體 為空，在一個類中，只要人為的 設(shè)置了 構(gòu)造方法，那么，默認(rèn)的構(gòu)造方法就會被 銷毀。
2、實例方法：必須由對象 調(diào)用的方法。
3、靜態(tài)方法：又叫做 類方法，是由static 來修飾的方法?？梢杂?對象名 或 類名直接調(diào)用。
main 方法 由java 虛擬機 自動調(diào)用 而不是由 用戶顯示調(diào)用。
作業(yè)：
1、為什么 main 方法 必須由 static 來修飾？ main 作用：1聲明對象
2、傳遞信息
在main方法加載之前是沒有對象的，但 main方法 可以加載，就說明是由類名調(diào)用，main方法 是靜態(tài)方法，所以 必須 由 static 來修飾。
2、設(shè)計一個 三角形的類，構(gòu)造方法
為三角形的 三邊 初始化；返回 三角形的周長；面積，高 通過形參 獲得；在main 方法 中 判斷，同過 命令 行 傳遞的 三個值 是否能夠成 三角形。
第六課
嵌套：包含的意思。在一個完整的結(jié)構(gòu)內(nèi)，包含 另一個結(jié)構(gòu)。
循環(huán)嵌套：在一個完整的循環(huán)內(nèi) 包含另一個 循環(huán)。
外層循環(huán)；
// 在循環(huán)體內(nèi)，包含 另一個 完整的循環(huán) 語句，就叫做 外層循環(huán)。{ 內(nèi)層循環(huán)；
// 放在 另一個 循環(huán)語句體內(nèi) 的 循環(huán)，就叫做 內(nèi)層循環(huán)。
}
循環(huán) 可以嵌套 若干層。
for（表達(dá)式1；表達(dá)式2；表達(dá)式3）{
for（表達(dá)式4；表達(dá)式5；表達(dá)式6）
{
內(nèi)層循環(huán)體；
} }
工作 流程：
1、表達(dá)式1；
2、表達(dá)式2；
3、表達(dá)式4；
4、表達(dá)式5；
5、內(nèi)層循環(huán)體；
6、表達(dá)式6；
7、表達(dá)式5； 為真：4、5、6 直到表達(dá)式5不成立；
8、表達(dá)式3；
9、表達(dá)式2；
為真：2、3、4、5、6、7
口訣：外層循環(huán) 執(zhí)行一步，內(nèi)層循環(huán) 要執(zhí)行 滿足條件的 一輪。
第七課
流程 控制語句：
二、條件分支語句：
1、if 不帶else ：if（條件表達(dá)式）
{
語句體；
}
帶 else ： if（條件表達(dá)式）
{
語句體1；
}
else
{
語句體2；
}
if的嵌套使用： if（條件表達(dá)式1）
{
語句體1；
}
else if（條件表達(dá)式2）
{
語句體2；
}
......else
{
語句體n；
}
2、switch case
switch（表達(dá)式）// 他的 返回值 必須是 byte、short、int、char、enum（枚舉）
不可以 出現(xiàn)其他數(shù)據(jù)類型的返回值，而且 返回的 必須是 一
個常量值 { case 常量1： 語句體1；[break；] case 常量2： 語句體2；[break；].......default：語句體n；[break；] }
常量 可以有多個，但不可以出現(xiàn) 相同的常量值。
為什么 switch比 if 嵌套 執(zhí)行效率高？
：所有流程控制語句，都是由 cpu 內(nèi)部提供的運算器中的高速緩存來處理，高速緩存 處理if 語句時，先找到條件1，如果 判斷為turn，在找條件2，判斷為turn 在找條件3，以此類推，直到所有 條件都判斷完畢，才會 確定要執(zhí)行的 語句體。而，在執(zhí)行switch 語句時，先去找 滿足條件的 找到，就執(zhí)行相應(yīng) 的語句，沒找到 就退出。由此看來，switch 語句 比 if 嵌套語句的執(zhí)行 效率高。
第八課
跳轉(zhuǎn)語句（轉(zhuǎn)向語句）：
一、cantinue：作用：退出本次 循環(huán)。
1、不帶標(biāo)號的：語法：
循環(huán)
{
[條件判斷]
{continue；}
} 執(zhí)行過程：進(jìn)入循環(huán)體內(nèi)，判斷 條件是否成立，成立執(zhí)行 continue；語句，從而 跳過continue；語句 后面的其他語句，完成 本次循環(huán)。繼續(xù) 進(jìn)行下一次 循環(huán)的 條件判斷，已決定 是否 繼續(xù) 循環(huán)。
t：相當(dāng)于 table 位，及 4個 空格。
2、帶有標(biāo)號的：（goto）標(biāo)號：就是 給循環(huán) 起個名字。
結(jié)束 標(biāo)號 所指名的循環(huán)
本次循環(huán)，繼續(xù)
標(biāo)號 所指名循環(huán)的 下一次循環(huán)條件 判斷，繼而 決定 是否 執(zhí)行 下一次循環(huán)。
語法：
標(biāo)號：
循環(huán)
{
循環(huán)
{
[條件判斷]
{continue 標(biāo)號；}
}
}
使用標(biāo)號要注意內(nèi)容：
1、標(biāo)號的后面 應(yīng)該 緊隨 一個循環(huán) 結(jié)構(gòu)，否則 編譯出錯；
2、標(biāo)號單獨使用 沒有任何意義，要與 break 或 continue 一起使用；
3、標(biāo)號 對于單層循環(huán)來說 意義不大。
二、break：終止循環(huán)的作用。
1、不帶標(biāo)號的：作用：結(jié)束 break 所在循環(huán)，轉(zhuǎn)去執(zhí)行 該循環(huán)體 后的其他語句。
語法：
循環(huán)
{
[循環(huán)條件；]
{break；}
}
其他語句；
2、帶有標(biāo)號的：作用：終止 標(biāo)號 所標(biāo)示 的循環(huán)體，轉(zhuǎn)去 執(zhí)行 該循環(huán) 外的 其他語句。
語法：
標(biāo)號：
循環(huán)
{
循環(huán)
{
[循環(huán)條件；]
{break 標(biāo)號；}
}
}
continue 與 break 的 區(qū)別：
1、continue 是用來 跳出 某一次 循環(huán)。而
break 是終止循環(huán)。
2、continue 只能出現(xiàn)在循環(huán) 結(jié)構(gòu)中，而 break 除了可以出現(xiàn) 在循環(huán)結(jié)構(gòu) 中之外，還可以出現(xiàn) switch 開關(guān) 語句中。
作業(yè)：
1、輸出1-1000 能 被 3整除的 前10個 較小的數(shù)，每行 輸出 5個值。
2、找出1-100 之間，第 3個 既能被 4整除，又能 被7整除的 數(shù)。
第九課
算法：
1、算術(shù)模型算法
2、非算術(shù)模型算法：解決三方面：
1、代碼的重用性；
2、代碼的可擴展性；
3、代碼
的可維護(hù)性。
1、窮舉（枚舉）算法：定義：遍歷一個域，窮盡 該域 范圍內(nèi)的所有可能。
性能最差的一個算法。
使用時機：只有一個 查詢條件，可是要查詢的數(shù)據(jù) 是海量的，此時就要用
到 窮舉算法。
使用窮舉算法需要確定的三個因素：
1、需要確定 循環(huán)的范圍，將可能的范圍一一列舉出來，不重復(fù)，不遺漏；
2、確定篩選條件，根據(jù)條件對結(jié)果，逐一判斷，挑選出符合條件的；
3、優(yōu)化，殼體條件是在保證，不遺漏掉 解 的情況下，盡量減少 循環(huán)的層數(shù)和 循環(huán)的范圍。
2、迭代算法：由一個已知的值，不斷地去推出新值的過程。
使用時的要素：
1、確定迭代變量的初始值；
2、迭代公式：就是能夠從變量的當(dāng)前值，推出下個值得公式；
3、迭代的范圍，迭代的終止條件。
3、遞歸算法：就是方法的自調(diào)用。（兩部分：
1、遞推；
2、回歸）
1、迭代的公式；
2、終止的條件；
3、初始值的確定（確定每一次調(diào)用方法時的參數(shù)，及返回值）
重復(fù)：
1、每一次方法的調(diào)用，都是在規(guī)模上有所縮?。?/p>
2、相鄰兩次的調(diào)用有緊密的聯(lián)系，前一次要為后一次做準(zhǔn)備；
3、在問題規(guī)模極小 的情況下，必須用直接給出解答的方式，而不能在遞推調(diào)用，因此，每一次遞歸 調(diào)用 都是有條件的。無條件的遞歸 調(diào)用，終將成為死循環(huán)。
在一個類中，相互調(diào)用 靜態(tài)方法時，類名 可以不寫。
第二章總結(jié)：
在設(shè)計方法時 應(yīng)秉承的原則：
1、在一個方法體里，盡量少的書寫 代碼；一個方法體中 只完成一個功能。
2、要有好的 運行效率：
1、盡可能少的占用資源（內(nèi)存資源、和 cpu（中央處理器）資源）
第三章
數(shù)據(jù)的設(shè)計
第一課
一、變量的聲明語法：數(shù)據(jù)類型
變量名
聲明變量中 數(shù)據(jù)類型的作用：
1、開辟多大的空間；
2、存放 哪種類型的數(shù)據(jù)
二、數(shù)據(jù)類型
1、基本數(shù)據(jù)類型-----所聲明的叫
變量
{ byte、short、int、long
float、double
char、boolean
int a=3 ；----叫做 值引用
基本數(shù)據(jù)類型 在java 虛擬機 的運行原理：
java 虛擬機 看到 int 類型的 a 變量，就會 開辟一個 4 個字節(jié)的 空間，名字 叫做 a，每個 基本數(shù)據(jù)類型的變量 只能對應(yīng) 一個 準(zhǔn)確的 值，所以我們 將其 稱之為 值引用。
基本數(shù)據(jù)類型的兩大特點：
1、值引用
2、基本數(shù)據(jù)類型 可以參與 各大數(shù)據(jù)類型的運算。
2、復(fù)合數(shù)據(jù)類型------所聲明的叫
對象
{ 類類型、數(shù)組、標(biāo)注、泛類型、枚舉、接口
兩大特點：
1、可以實現(xiàn) 地址 引用；
2、復(fù)合數(shù)據(jù)類型 不可以 參與各大數(shù)據(jù)類型的運算，但是 可以 比較地址是否相同（==）。
三、變量的 初始化
分為：
1、直接初始化 ；//a=3
2、間接初始化 ；//b=a*2
一個基本數(shù)據(jù)類型的變量 在使用之前，一定要對其 進(jìn)行 初始化，否則 該變量無法使用；成員變量的初始化 由構(gòu)造方法 實現(xiàn)；靜態(tài)方法的初始化 由 靜態(tài)初始化器實現(xiàn)；局部變量在使用之前 必須 賦值。
1、自動類型的轉(zhuǎn)換也成為 隱式轉(zhuǎn)換；
小空間 向 大空間 轉(zhuǎn)換時，可以自動（直接）進(jìn)行轉(zhuǎn)換的叫做：自動數(shù)據(jù)類型的轉(zhuǎn)換 特例：
1、long 數(shù)據(jù)類型 可以自動 轉(zhuǎn)換成 float、或 double 數(shù)據(jù)類型
2、byte 數(shù)據(jù)類型 不能 自動轉(zhuǎn)換成 char 數(shù)據(jù)類型
3、布爾數(shù)據(jù)類型 不參與自動數(shù)據(jù)類型的轉(zhuǎn)換。byte---short---int---long---float----double
char---
自動類型 轉(zhuǎn)換的時機：
1、賦值時；
2、方法調(diào)用時；
3、算術(shù)運算時（一元運算中：
1、操作數(shù)的數(shù)據(jù)類型是byte、short、char 時，結(jié)果將自動轉(zhuǎn)換成int數(shù)據(jù)類型；
2、++ 或--運算 等到的結(jié)果，任然是操作數(shù)本身的數(shù)據(jù)類型，及++ 或--符號不參與 自動數(shù)據(jù)類型的轉(zhuǎn)換
二元運算中：
1、在大多數(shù)情況下，兩個操作數(shù)進(jìn)行運算，會自動轉(zhuǎn)換成范圍 較大的數(shù)據(jù)類型；
2、假設(shè) 操作數(shù)類型為 byte、short、char 的情況下，運算結(jié)果會自動轉(zhuǎn)換成 int數(shù)據(jù)類型；
3、復(fù)合賦值運算符，不參與 自動數(shù)據(jù)類型的轉(zhuǎn)換）
2、強制類型的轉(zhuǎn)換也叫做 顯示轉(zhuǎn)換；
大空間 向 小空間 轉(zhuǎn)換，用到 強制數(shù)據(jù)類型的轉(zhuǎn)換；
語法格式：（目標(biāo)數(shù)據(jù)類型）常量、變量、表達(dá)式；
情況：
1、如果 被轉(zhuǎn)換的數(shù)據(jù)類型的值的大小 沒有超出 目標(biāo)數(shù)據(jù)類型的取值范圍，則值不發(fā)生任何改變；
2、如果要轉(zhuǎn)換的值，超出了目標(biāo)數(shù)據(jù)類型的取值范圍，那么，用該值 對目標(biāo)數(shù)據(jù)類型的值域變化范圍
進(jìn)行 取模 的操作。（該值 大于 目標(biāo)數(shù)據(jù)類型 的最大取值，并且超出了其值域變化范圍）；
3、如果該值 大于 目標(biāo)數(shù)據(jù)類型 的最大取值，但是沒有超出了目標(biāo)數(shù)據(jù)類型值域變化范圍，則用 該值-值域變化范圍。
4、浮點數(shù) 轉(zhuǎn)換成 整數(shù)時，直接 舍去 小數(shù)部分，保留 整數(shù)部分。
5、布爾數(shù)據(jù)類型 不參與 強制數(shù)據(jù)類型 轉(zhuǎn)換。
第二課
自動綁定的三部曲：
1、加載 靜態(tài)初始化器
2、加載主方法
3、通過 new 關(guān)鍵字 調(diào)用構(gòu)造方法
局部變量：
如果 局部變量 與成員變量 同名的情況下，那么在局部變量的作用范圍內(nèi) 隱藏 成員變量，想要在 局部變量 作用范圍內(nèi) 引用 成員變量，那么 要用到
this 關(guān)鍵字 引用成員變量。
相同作用域內(nèi) 不允許 出現(xiàn)同名 變量，而不相同 的作用域范圍內(nèi)，可以出現(xiàn) 同名變量。
成員變量 與 局部變量的 區(qū)別：
1、聲明的位置不同，成員變量 在一個類的方法體外 聲明；而 局部變量 可以放在方法體內(nèi)、也可以作為 方法的參數(shù)、或 放在 語句塊內(nèi)。
2、作用域不同，一對花括號 就是一個作用域。
3、成員變量的初始化，可以由 靜態(tài)初始化器、或 構(gòu)造方法來完成；而 局部變量的初始化 只能由 直接 或者 間接 來完成，而不能由 靜態(tài)初始化器 或 構(gòu)造方法來完成。
最終變量：
它是指 在程序 運行過程中，其值 不變的 變量。最終變量在使用前
必須 為其 初始化。
語法：
1、final 數(shù)據(jù)類型 變量名=賦值；// 聲明最終 變量時 直接 初始化。
2、final 數(shù)據(jù)類型 變量名； // 先聲明，在使用之前 在為其 初始化。
變量名=賦值；
目的：防止 值發(fā)生 改變。
數(shù)組：就是具有 相同類型 名稱的 數(shù)據(jù)的集合。
1、聲明的語法格式：
數(shù)據(jù)類型 [] 數(shù)組變量名；
數(shù)據(jù)類型 數(shù)組變量名 []；
2、實例化
聲明的同時 對其實例化；// 數(shù)據(jù)類型[] 數(shù)組變量名=new 數(shù)據(jù)類型[數(shù)組長度]；
先聲明，在實例化； // 數(shù)組變量名=new 數(shù)據(jù)類型[數(shù)組長度]；
數(shù)組長度 只能是：byte、short、int 三種 數(shù)據(jù)類型，不能是其他數(shù)據(jù)類型。new 數(shù)據(jù)類型這樣的語句有兩個作用：
1、在內(nèi)存中開辟一塊 連續(xù)的存儲空間，每塊空間的大小 由 數(shù)據(jù)類型來 進(jìn)行決定；
2、為每一個空間 進(jìn)行 初始化。
作業(yè)：
1、為什么使用數(shù)組？ ：
2、聲明，實例化數(shù)組的語法？
3、什么是數(shù)組元素？
4、如何得到 數(shù)組最大下標(biāo)值？
5、如何為 數(shù)組元素賦值？
6、如何遍歷數(shù)組？
7、數(shù)組與 數(shù)組 變量區(qū)別？
第三課
數(shù)組對象的方法：
一、冒泡法排序：
兩個循環(huán)，外層控制 輪數(shù)，內(nèi)層 控制 每輪比較的 次數(shù)。
import java.util.Arrays;// 引包（冒泡法）Arrays.sort(a);
二、在一個數(shù)組 當(dāng)中 查找 元素 所在的位置； int pos=Arrays.binarySearch(sum,15*15);//
采用2分 查找法，先找中間值，小于中間值得向前找，大于中間值得先后找，只能 對有序的數(shù)組 進(jìn)行查找。
三、數(shù)組復(fù)制
System.arraycopy(Object src,int src_pos,Object dst,int dsc_pos,int length)
Object src： 代表 元素組；
int src_pos：
代表
元素組的起始位置； Object dst： 目標(biāo)數(shù)組；
int dst_pos：
目標(biāo)數(shù)組的起始位置； int length： 要拷貝 數(shù)組元素的個數(shù)；
數(shù)組的特點：
1、數(shù)組的長度是固定的，必須在創(chuàng)建數(shù)組的時候指定數(shù)組長度，數(shù)組的長度一經(jīng)確定，就不能修改；
2、一個數(shù)組 只能用來保存 同一數(shù)據(jù)類型的數(shù)據(jù)；
第四課
多維數(shù)組：（二維數(shù)組）
聲明：數(shù)據(jù)類型[][] 數(shù)組變量名=new 數(shù)組類型[高維長度--必選][低維長度--可選]
高維--一維：行數(shù)
低維--二維：每行的個數(shù)
例：int[][] i1=new int[2][2];
靜態(tài)初始化：
int[][] i1={{0,1},{1,2,3},{2}};
第五課 向量：可以看做是 一個大小 可自由伸縮的數(shù)組。
三個構(gòu)造方法： public Vector()
---創(chuàng)建初始大小 為10，容量增加值為0（0代表 無限增加）的空Vector 對象。
public Vector(int initialCapacity)---創(chuàng)建初始容量 為initialCapacity，容量增加值為0 的空Vector 對象。
public Vector(int initialCapacity,int capacityIncrement)---創(chuàng)建初始容量為 initialCapacity，當(dāng)容量不足時 增加值為 capacityIncrement 的空 Vector 對象。
方法說明
public boolean add(Object o)將指定對象追加到當(dāng)前Vector對象的末尾。
public void add(int index, Object element)將指定對象element插入到當(dāng)Vector對象的指定位置處。
public int capacity()返回Vector對象的當(dāng)前容量。
public void clear()將所有的元素從當(dāng)前Vector對象中移去。
public boolean contains(Object elem)測試當(dāng)前Vector對象中是否包含指定的對象。
public void copyInto(Object[ ] anArray)將當(dāng)前Vector對象中的每一個元素復(fù)制到指定的數(shù)組中去。
public Object firstElement()返回當(dāng)前Vector對象中的第一個元素（其下標(biāo)值為0）。public Object lastElement()返回當(dāng)前Vector對象中的最后一個元素。public Object get(int index)返回當(dāng)前Vector對象中指定位置上的元素。
public int indexOf(Object elem)返回當(dāng)前Vector對象中指定對象elem首次出現(xiàn)的位置，找不到則返回-1。
public boolean isEmpty()測試當(dāng)前Vector對象是否為空。
public Object remove(int index)將指定位置的元素從當(dāng)前Vector對象中移去。public boolean remove(Object o)刪除當(dāng)前Vector對象中首次出現(xiàn)的指定對象，若當(dāng)前Vector對象包含該指定對象則返 回true。
protected void removeRange(int fromIndex, int toIndex)刪除當(dāng)前Vector對象中從fromIndex位置開始，到toIndex-1位置的所有元素。
public void removeAllElements()刪除Vector對象中的所有元素，并將其大小重置為0。public Object set(int index, Object element)將Vector對象中指定位置上的元素置換為指定對象element。
public int size()返回Vector對象中元素的數(shù)目。
public void trimToSize()將當(dāng)前Vector對象的容量調(diào)整為與其元素個數(shù)相同。相信能就一定能
第二篇：java 問題匯總(總結(jié),重點)
在用到spring框架中時，場景如下
post 請求過去，對象接收不到參數(shù)的值(解決辦法:考慮到在參數(shù)上加個@RequestBody 注解即可,有些沒加的是框架幫忙處理了后默認(rèn)接收的是json串)http://localhost:8080/xxxxxxxxxxx-xxxxxxx-api/xxxxxx/xxxxx/xxxxxxxxx/suggest/add.sgt
======================================== mapper.xml->@Repository{存儲數(shù)據(jù)層}->@Service{業(yè)務(wù)層}->@Controller{展示層}（spring注解可以理解為這樣的線性,任其項目結(jié)構(gòu)怎么變這樣的線性結(jié)構(gòu)是不會變的,萬變不離其宗）
@Repository @Service @Controller均是注冊在spring上下文中 @Autowired 在spring上下文中找bean
@Qualifier 配合 @Autowired使用 當(dāng)找到多個同一類型的bean，則會拋異常，此時可以使用 @Qualifier(“beanName”)，明確指定bean的名稱進(jìn)行注入 @RequestMapping 配置連接
@Required 注冊在sett方法上,檢查有沒有被調(diào)用 @RequestParam 綁定參數(shù)
@RequestBody讀取Request請求的body部分?jǐn)?shù)據(jù)，使用系統(tǒng)默認(rèn)配置的HttpMessageConverter進(jìn)行解析，然后把相應(yīng)的數(shù)據(jù)綁定到要返回的對象上
如果你也用過struts2.簡單介紹下springMVC和struts2的區(qū)別有哪些? springmvc的入口是一個servlet即前端控制器，而struts2入口是一個filter過慮器。
springmvc是基于方法開發(fā)(一個url對應(yīng)一個方法)，請求參數(shù)傳遞到方法的形參，可以設(shè)計為單例或多例(建議單例)，struts2是基于類開發(fā)，傳遞參數(shù)是通過類的屬性，只能設(shè)計為多例。
Struts采用值棧存儲請求和響應(yīng)的數(shù)據(jù)，通過OGNL存取數(shù)據(jù)，springmvc通過參數(shù)解析器是將request請求內(nèi)容解析，并給方法形參賦值，將數(shù)據(jù)和視圖封裝成ModelAndView對象，最后又將ModelAndView中的模型數(shù)據(jù)通過reques域傳輸?shù)巾撁?。Jsp視圖解析器默認(rèn)使用jstl。2.Spring的事務(wù)是如何配置的？
先配置事務(wù)管理器TransactionManager,不同的框架有不同屬性。再配置事務(wù)通知和屬性,通過tx:advice。配置,設(shè)置那些方法或者類需要加入事務(wù)。
3.spring事務(wù)控制放在service層，在service方法中一個方法調(diào)用service中的另一個方法，默認(rèn)開啟幾個事務(wù)？
spring的事務(wù)傳播方式默認(rèn)是PROPAGATION_REQUIRED，判斷當(dāng)前是否已開啟一個新事務(wù)，有則加入當(dāng)前事務(wù)，否則新開一個事務(wù)（如果沒有就開啟一個新事務(wù)），所以答案是開啟了一個事務(wù)。4.spring 什么情況下進(jìn)行事務(wù)回滾？
Spring、EJB的聲明式事務(wù)默認(rèn)情況下都是在拋出unchecked exception后才會觸發(fā)事務(wù)的回滾
unchecked異常,即運行時異常runntimeException 回滾事務(wù);checked異常,即Exception可try{}捕獲的不會回滾.當(dāng)然也可配置spring參數(shù)讓其回滾.spring的事務(wù)邊界是在調(diào)用業(yè)務(wù)方法之前開始的，業(yè)務(wù)方法執(zhí)行完畢之后來執(zhí)行commit or rollback(Spring默認(rèn)取決于是否拋出runtime異常).如果拋出runtime exception 并在你的業(yè)務(wù)方法中沒有catch到的話，事務(wù)會回滾。
一般不需要在業(yè)務(wù)方法中catch異常，如果非要catch，在做完你想做的工作后（比如關(guān)閉文件等）一定要拋出runtime exception，否則spring會將你的操作commit,這樣就會產(chǎn)生臟數(shù)據(jù).所以你的catch代碼是畫蛇添足。5.Spring支持的事務(wù)管理類型？ Spring支持兩種類型的事務(wù)管理：
編程式事務(wù)管理：這意味你通過編程的方式管理事務(wù)，給你帶來極大的靈活性，但是難維護(hù)。
聲明式事務(wù)管理：這意味著你可以將業(yè)務(wù)代碼和事務(wù)管理分離，你只需用注解和XML配置來管理事務(wù)。
6.Spring框架的事務(wù)管理有哪些優(yōu)點？
它為不同的事務(wù)API 如 JTA，JDBC，Hibernate，JPA 和JDO，提供一個不變的編程模式。
它為編程式事務(wù)管理提供了一套簡單的API而不是一些復(fù)雜的事務(wù)API如 它支持聲明式事務(wù)管理。
它和Spring各種數(shù)據(jù)訪問抽象層很好得集成。7.講下Spring的七大事務(wù)傳播？
Spring中通過Propagation來設(shè)置事務(wù)的傳播屬性的，在這個屬性中提供了我們其中關(guān)于事務(wù)傳播的特性：
PROPAGATION_REQUIRED：支持當(dāng)前事務(wù)，如果當(dāng)前沒有事務(wù)，就新建一個事務(wù)。這是最常見的選擇。
PROPAGATION_SUPPORTS：支持當(dāng)前事務(wù)，如果當(dāng)前沒有事務(wù)，就以非事務(wù)方式執(zhí)行。PROPAGATION_MANDATORY：支持當(dāng)前事務(wù)，如果當(dāng)前沒有事務(wù)，就拋出異常。PROPAGATION_REQUIRES_NEW：新建事務(wù)，如果當(dāng)前存在事務(wù)，把當(dāng)前事務(wù)掛起。PROPAGATION_NOT_SUPPORTED：以非事務(wù)方式執(zhí)行操作，如果當(dāng)前存在事務(wù)，就把當(dāng)前事務(wù)掛起。
PROPAGATION_NEVER：以非事務(wù)方式執(zhí)行，如果當(dāng)前存在事務(wù)，則拋出異常。PROPAGATION_NESTED：支持當(dāng)前事務(wù)，新增Savepoint點，與當(dāng)前事務(wù)同步提交或回滾。
8.事務(wù)并發(fā)會引起什么問題,怎么解決？
事務(wù)并發(fā)會引起臟讀,幻讀,不可重復(fù)讀等問題,設(shè)定事務(wù)的隔離級別就可以解決。
9.事務(wù)的安全問題：鎖機制的實現(xiàn)原理及在項目中的使用？
鎖有悲觀鎖和樂觀鎖,悲觀鎖一般假設(shè)每個人都會修改數(shù)據(jù),默認(rèn)情況下把數(shù)據(jù)都鎖住,影響性能,但安全性高.樂觀鎖是假設(shè)每個人都只讀下數(shù)據(jù),不會修改數(shù)據(jù),性能比較高,但是安全性較低,一般通過增加類似于版本控制里面版本號來解決問題。10.講下BeanFactory和ApplicationContext的區(qū)別？
BeanFactory是Spring容器頂級核心接口,比較早,但功能比較少,getBean就是BeanFactory定義的。
ApplicationContext是Spring里面的另外一個容器頂級接口,它繼承于BeanFactory,但是提供的功能譬如校驗,國際化,監(jiān)聽,對Bean的管理功能比較多,一般使用ApplicationContext。11.簡單介紹下你對mybatis的理解？ mybatis配置
SqlMapConfig.xml，此文件作為mybatis的全局配置文件，配置了mybatis的運行環(huán)境等信息。mapper.xml文件即sql映射文件，文件中配置了操作數(shù)據(jù)庫的sql語句。此文件需要在SqlMapConfig.xml中加載。
通過mybatis環(huán)境等配置信息構(gòu)造SqlSessionFactory即會話工廠
由會話工廠創(chuàng)建sqlSession即會話，操作數(shù)據(jù)庫需要通過sqlSession進(jìn)行。mybatis底層自定義了Executor執(zhí)行器接口操作數(shù)據(jù)庫，Executor接口有兩個實現(xiàn)，一個是基本執(zhí)行器、一個是緩存執(zhí)行器。
Mapped Statement也是mybatis一個底層封裝對象，它包裝了mybatis配置信息及sql映射信息等。mapper.xml文件中一個sql對應(yīng)一個Mapped Statement對象，sql的id即是Mapped statement的id。
Mapped Statement對sql執(zhí)行輸入?yún)?shù)進(jìn)行定義，包括HashMap、基本類型、pojo，Executor通過Mapped Statement在執(zhí)行sql前將輸入的java對象映射至sql中，輸入?yún)?shù)映射就是jdbc編程中對preparedStatement設(shè)置參數(shù)。
Mapped Statement對sql執(zhí)行輸出結(jié)果進(jìn)行定義，包括HashMap、基本類型、pojo，Executor通過Mapped Statement在執(zhí)行sql后將輸出結(jié)果映射至java對象中，輸出結(jié)果映射過程相當(dāng)于jdbc編程中對結(jié)果的解析處理過程。12.講下MyBatis和Hibernate的區(qū)別? MyBatis是JDBC的輕量級封裝,把Sql和java代碼獨立出來,性能相對比較高,寫SQL語句相對于比較靈活,并且容易調(diào)試,一般用在大型項目中.Hibernate是JDBC的重量級封裝,開發(fā)速度比較快,但是性能比較低,調(diào)試不方便,一般適合對進(jìn)度要求的比較高的中小型項目.13.mybatis中#{}和${}的區(qū)別是什么？
${}是Properties文件中的變量占位符，它可以用于標(biāo)簽屬性值和sql內(nèi)部，屬于靜態(tài)文本替換，比如${driver}會被靜態(tài)替換為com.mysql.jdbc.Driver。#{}是sql的參數(shù)占位符，Mybatis會將sql中的#{}替換為?號，在sql執(zhí)行前會使用PreparedStatement的參數(shù)設(shè)置方法，按序給sql的?號占位符設(shè)置參數(shù)值，比如ps.setInt(0, parameterValue)，#{item.name}的取值方式為使用反射從參數(shù)對象中獲取item對象的name屬性值，相當(dāng)于param.getItem().getName()。14.mybatis中XML映射文件中，除了常見的select|insert|updae|delete標(biāo)簽之外，還有哪些標(biāo)簽？、、、、，加上動態(tài)sql的9個標(biāo)簽，trim|where|set|foreach|if|choose|when|otherwise|bind等，其中為sql片段標(biāo)簽，通過標(biāo)簽引入sql片段，為不支持自增的主鍵生成策略標(biāo)簽。15.MyBatis編程步驟是什么樣的？ 創(chuàng)建SqlSessionFactory 通過SqlSessionFactory創(chuàng)建SqlSession 通過sqlsession執(zhí)行數(shù)據(jù)庫操作 調(diào)用session.commit()提交事務(wù) 調(diào)用session.close()關(guān)閉會話
16.JDBC編程有哪些不足之處，MyBatis是如何解決這些問題的？
① 數(shù)據(jù)庫鏈接創(chuàng)建、釋放頻繁造成系統(tǒng)資源浪費從而影響系統(tǒng)性能，如果使用數(shù)據(jù)庫鏈接池可解決此問題。
解決：在SqlMapConfig.xml中配置數(shù)據(jù)鏈接池，使用連接池管理數(shù)據(jù)庫鏈接。②Sql語句寫在代碼中造成代碼不易維護(hù)，實際應(yīng)用sql變化的可能較大，sql變動需要改變java代碼。
解決：將Sql語句配置在XXXXmapper.xml文件中與java代碼分離。
③向sql語句傳參數(shù)麻煩，因為sql語句的where條件不一定，可能多也可能少，占位符需要和參數(shù)一一對應(yīng)。
解決： Mybatis自動將java對象映射至sql語句。
④對結(jié)果集解析麻煩，sql變化導(dǎo)致解析代碼變化，且解析前需要遍歷，如果能將數(shù)據(jù)庫記錄封裝成pojo對象解析比較方便。解決：Mybatis自動將sql執(zhí)行結(jié)果映射至java對象。17.使用MyBatis的mapper接口調(diào)用時有哪些要求？ Mapper接口方法名和mapper.xml中定義的每個sql的id相同
Mapper接口方法的輸入?yún)?shù)類型和mapper.xml中定義的每個sql 的parameterType的類型相同
Mapper接口方法的輸出參數(shù)類型和mapper.xml中定義的每個sql的resultType的類型相同
Mapper.xml文件中的namespace即是mapper接口的類路徑。18.簡單的說一下MyBatis的一級緩存和二級緩存？
Mybatis首先去緩存中查詢結(jié)果集，如果沒有則查詢數(shù)據(jù)庫，如果有則從緩存取出返回結(jié)果集就不走數(shù)據(jù)庫。Mybatis內(nèi)部存儲緩存使用一個HashMap，key為hashCode+sqlId+Sql語句。value為從查詢出來映射生成的java對象 Mybatis的二級緩存即查詢緩存，它的作用域是一個mapper的namespace，即在同一個namespace中查詢sql可以從緩存中獲取數(shù)據(jù)。二級緩存是可以跨SqlSession的。
19.Mybatis是否支持延遲加載？如果支持，它的實現(xiàn)原理是什么？
Mybatis僅支持association關(guān)聯(lián)對象和collection關(guān)聯(lián)集合對象的延遲加載，association指的就是一對一，collection指的就是一對多查詢。在Mybatis配置文件中，可以配置是否啟用延遲加載lazyLoadingEnabled=true|false。它的原理是，使用CGLIB創(chuàng)建目標(biāo)對象的代理對象，當(dāng)調(diào)用目標(biāo)方法時，進(jìn)入攔截器方法，比如調(diào)用a.getB().getName()，攔截器invoke()方法發(fā)現(xiàn)a.getB()是null值，那么就會單獨發(fā)送事先保存好的查詢關(guān)聯(lián)B對象的sql，把B查詢上來，然后調(diào)用a.setB(b)，于是a的對象b屬性就有值了，接著完成a.getB().getName()方法的調(diào)用。這就是延遲加載的基本原理。
20.Mybatis的Xml映射文件中，不同的Xml映射文件，id是否可以重復(fù)？ 不同的Xml映射文件，如果配置了namespace，那么id可以重復(fù)；如果沒有配置namespace，那么id不能重復(fù)；畢竟namespace不是必須的，只是最佳實踐而已。
原因就是namespace+id是作為Map的key使用的，如果沒有namespace，就剩下id，那么，id重復(fù)會導(dǎo)致數(shù)據(jù)互相覆蓋。有了namespace，自然id就可以重復(fù)，namespace不同，namespace+id自然也就不同。21.為什么說Mybatis是半自動ORM映射工具？它與全自動的區(qū)別在哪里？ Hibernate屬于全自動ORM映射工具，使用Hibernate查詢關(guān)聯(lián)對象或者關(guān)聯(lián)集合對象時，可以根據(jù)對象關(guān)系模型直接獲取，所以它是全自動的。而Mybatis在查詢關(guān)聯(lián)對象或關(guān)聯(lián)集合對象時，需要手動編寫sql來完成，所以，稱之為半自動ORM映射工具。22.SSM優(yōu)缺點、使用場景？
1.Mybatis和hibernate不同，它不完全是一個ORM框架，因為MyBatis需要程序員自己編寫Sql語句，不過mybatis可以通過XML或注解方式靈活配置要運行的sql語句，并將java對象和sql語句映射生成最終執(zhí)行的sql，最后將sql執(zhí)行的結(jié)果再映射生成java對象。
2.Mybatis學(xué)習(xí)門檻低，簡單易學(xué)，程序員直接編寫原生態(tài)sql，可嚴(yán)格控制sql執(zhí)行性能，靈活度高，非常適合對關(guān)系數(shù)據(jù)模型要求不高的軟件開發(fā)，例如互聯(lián)網(wǎng)軟件、企業(yè)運營類軟件等，因為這類軟件需求變化頻繁，一但需求變化要求成果輸出迅速。但是靈活的前提是mybatis無法做到數(shù)據(jù)庫無關(guān)性，如果需要實現(xiàn)支持多種數(shù)據(jù)庫的軟件則需要自定義多套sql映射文件，工作量大。3.Hibernate對象/關(guān)系映射能力強，數(shù)據(jù)庫無關(guān)性好，對于關(guān)系模型要求高的軟件（例如需求固定的定制化軟件）如果用hibernate開發(fā)可以節(jié)省很多代碼，提高效率。但是Hibernate的學(xué)習(xí)門檻高，要精通門檻更高，而且怎么設(shè)計O/R映射，在性能和對象模型之間如何權(quán)衡，以及怎樣用好Hibernate需要具有很強的經(jīng)驗和能力才行。
4.總之，按照用戶的需求在有限的資源環(huán)境下只要能做出維護(hù)性、擴展性良好的軟件架構(gòu)都是好架構(gòu)，所以框架只有適合才是最好。23.SpringMvc里面攔截器是怎么實現(xiàn)的？
有兩種方式,一種是實現(xiàn)接口,另外一種是繼承適配器類,然后在SpringMvc的配置文件中配置攔截器即可:
24.Spring中AOP的應(yīng)用場景、Aop原理、好處？
AOP--Aspect Oriented Programming面向切面編程；用來封裝橫切關(guān)注點，具體可以在下面的場景中使用: Authentication 權(quán)限、Caching 緩存、Context passing 內(nèi)容傳遞、Error handling 錯誤處理Lazy loading懶加載、Debugging調(diào)試、logging, tracing, profiling and monitoring 記錄跟蹤優(yōu)化 校準(zhǔn)、Performance optimization 性能優(yōu)化、Persistence 持久化、Resource pooling 資源池、Synchronization 同步、Transactions 事務(wù)
原理：AOP是面向切面編程，是通過動態(tài)代理的方式為程序添加統(tǒng)一功能，集中解決一些公共問題。優(yōu)點：
1.各個步驟之間的良好隔離性耦合性大大降低
2.源代碼無關(guān)性，再擴展功能的同時不對源碼進(jìn)行修改操作。
第三篇：java培訓(xùn)總結(jié)
在現(xiàn)在這個科技飛速發(fā)展的時代，計算機已經(jīng)悄然走進(jìn)我們的生活，并且占據(jù)了不可動搖與替代的地位，無論是在工作還是生活，學(xué)習(xí)還是娛樂中，當(dāng)我們意識到的時候，卻突然發(fā)現(xiàn)我們已經(jīng)離不開這個叫做“電腦”的機器了，既然我們要時刻與電腦打交道，那就像人際交往一樣，交流是必不可少的，所以計算機語言應(yīng)運而生，而java作為一種簡單、安全、容易使用、面向兌現(xiàn)、可移植、高性能、多線程的計算機高級語言，受到人們的青睞也是理所當(dāng)然的了。
在很多人看來，計算機很復(fù)雜，有數(shù)不清的代碼和程序，可以完成各種各樣的任務(wù)，功能千變?nèi)f化，要掌握它是一件難比登天的任務(wù)，其實不然。計算機這種復(fù)雜性，完全是人賦予的，計算機只是單純的按照人的指令去完成我們想要完成的事情，從這方面看，計算機是簡單的，復(fù)雜的只是人們要對它說的話而已。其實計算機正像吳老師所說：“相比與人，我更喜歡和計算機打交道，因為它必須要完成人的指令，而不能有絲毫抗拒?！?/p>
在參加java培訓(xùn)的過程中，我感覺其實生活中很多時候與java編程是存在相似點。比如說我們想做一件什么事情，總是要先考慮下這件事的目的，做這件事需要先準(zhǔn)備些什么，中間需要哪些步驟，最后怎樣實現(xiàn)等等，這與計算機編程思想驚人的相似，所以說，任何事物發(fā)展到極致，必然還是在自然的這個圈子中，受自然規(guī)律的束縛，計算機就算功能再強大，也是人們賦予的，必然還是會局限再人們自身的思想當(dāng)中，用人們固有的解決問題的方法來解決問題，所以就這方面來說，其實計算機語言是簡單的，在這段時間的學(xué)習(xí)生活中，我也認(rèn)識了很多朋友，大家都對未來懷著美好的憧憬，所以學(xué)習(xí)時也加倍努力，每天十幾個小時的學(xué)習(xí)讓我們平時的生活過的無比充實，每個人對幸福的定義不同，就我個人來說，能每天學(xué)習(xí)一些新知識，認(rèn)識一些新朋友，吃得飽，睡的香，這就是幸福。在我們前行的道路上，或許有些許坎坷，但其實人生的快樂正是在起起落落間，只要堅信我們前進(jìn)的方向正確，總會觸摸到天堂。
路漫漫其修遠(yuǎn)兮，吾將上下而求索。
第四篇：java培訓(xùn)總結(jié)
java培訓(xùn)總結(jié)
篇一：JAVA培訓(xùn)心得體會
心得體會
此次只實訓(xùn)了短短的三周。雖說時間很短，但其中的每一天都使我收獲很大、受益匪淺，它不但極大地加深了我對一些理論知識的理解，不僅使我在理論上對java有了全新的認(rèn)識，在實踐能力上也得到了提高，真正地做到了學(xué)以致用，更學(xué)到了很多做人的道理，對我來說
受益非淺。除此以外，我知道了什么叫團(tuán)隊,怎樣和團(tuán)隊分工合作;同時我還學(xué)會了如何更好
地與別人溝通，如何更好地去陳述自己的觀點，如何說服別人認(rèn)同自己的觀點。這也是第一
次讓我親身感受到理論與實際的相結(jié)合，讓我大開眼界。也是對以前所學(xué)知識的一個初審吧！
這次實訓(xùn)對于我以后學(xué)習(xí)、找工作也是受益菲淺的，在短短的三周中相信這些寶貴的經(jīng)驗會
成為我今后成功的重要的基石；這對于我的學(xué)業(yè)，乃至我以后人生的影響無疑是極其深遠(yuǎn)的。這次實訓(xùn)雖然是我們的第一次，不過同學(xué)們表現(xiàn)不錯，由此看來，我們在進(jìn)入大學(xué)的這
幾個月里學(xué)到了不少的專業(yè)知識，只是自己感覺不到而已。對于所學(xué)專業(yè)，我們不能過于自
卑和擔(dān)憂，否則會妨礙自己學(xué)習(xí)。實訓(xùn)是學(xué)習(xí)java的重要環(huán)節(jié)，有利于我們鞏固專業(yè)知識、掌握工作技能，提高就業(yè)籌碼。我把本次為期三周的實訓(xùn)看作是 “理論與實踐相結(jié)合的橋梁”。通過這周的實訓(xùn)和學(xué)習(xí)，我知道了此次實訓(xùn)的目的，也清楚目前自己的不足，那就是缺乏相應(yīng)的知識與經(jīng)驗，對所學(xué)
的專業(yè)知識不能夠很好地運用于實踐操作。正所謂“百聞不如一見”，經(jīng)過這次自身的切身實
踐，我才深切地理會到了“走出課堂，投身實踐”的必要性。平時，我們只能在課堂上與老
師一起紙上談兵，思維的認(rèn)識基本上只是局限于課本的范圍之內(nèi)，也許就是這個原因就導(dǎo)致
我們對專業(yè)知識認(rèn)識的片面性，使得我們只知所以然，而不知其之所以然！限制了我們網(wǎng)絡(luò)
知識水平的提高。但是課本上所學(xué)到的理論知識是為我們的實際操作指明了方向、提供相應(yīng)
的方法，真正的職業(yè)技巧是要我們從以后的實際工作中慢慢汲取的。而針對實際操作中遇到
的一些特殊的問題，我們不能拘泥于課本，不可純粹地“以本為本”。在這次實訓(xùn)中我得到了許多收獲，我第一次體會到j(luò)ava工程師的工作是什么樣子的，也
發(fā)現(xiàn)了很多不曾注意到的細(xì)節(jié)，在實訓(xùn)的演示過程中，我對作為一名java工程師注意的事項
應(yīng)該從小事做起、從基本做起。把職業(yè)能力訓(xùn)練與職業(yè)素質(zhì)有機的結(jié)合起來。相信這對我接 下來學(xué)習(xí)專業(yè)知識會起到很有效的幫助，在接下來的幾個月里，我會以作為一名職業(yè)人的身
份在這幾個方面要求自己，嚴(yán)格自我，向java工程師靠近。而經(jīng)過這次實訓(xùn)，讓我明白如果是一個完整項目的開發(fā)，必須由團(tuán)隊來分工合作，否則，即費力又費時還做不好這個項目。因此不管在工作中還是在生活中要和老師、同學(xué)保持良好
的關(guān)系是很重要的。做事首先要學(xué)做人，要明白做人的道理，如何與人相處是現(xiàn)代社會的做
人的一個最基本的問題。對于自己這樣一個即將步入社會的人來說，需要學(xué)習(xí)的東西很多，他們就是最好的老師，正所謂“三人行，必有我?guī)煛?，我們可以向他們學(xué)習(xí)很多知識、道理。
實訓(xùn)結(jié)束了感覺雖然辛苦，但很充實。我想這就是java工程師的工作。我也體會到j(luò)ava工程師成功地完成一個任務(wù)的那種興奮，那種小有成就的感覺是只有置身其中的人才能
體會的。
總之，這次實訓(xùn)為我提供了與眾不同的學(xué)習(xí)方法和學(xué)習(xí)體會，從書本中面對現(xiàn)實，為我將來走上社會打下了扎實的基礎(chǔ)。作為在校計算機專業(yè)的學(xué)生，現(xiàn)在我能做的就是吸取知識，提高自身的綜合素質(zhì)，提高自己的職業(yè)技能，自己有了能力，到時候才會是 “車到山前必有
路”。我相信在不久的未來，會有屬于我自己的一片天空。
我希望計算機專業(yè)的同學(xué)在以后的學(xué)習(xí)或工作中以務(wù)實的態(tài)度給提供更多的機會鍛煉自
己,為大家的成才與就業(yè)奠定堅實的基礎(chǔ)；并希望同學(xué)們要做好角色定位，將自己所學(xué)的知識，學(xué)熟、學(xué)精。
多學(xué)習(xí)和收集與項目有關(guān)的資料，來提高自己的業(yè)務(wù)水平，同時多請教經(jīng)驗豐富的老師，使他們好的經(jīng)驗?zāi)軌驅(qū)ψ约浩鸬浇梃b作用，在他們的幫助下，能夠很快的培養(yǎng)自己的管理技
能及節(jié)省時間，避免做無用功，也可以讓自己了解很多項目管理上的捷徑，從而減少自己會
遇到的挫折和錯誤。篇二：java培訓(xùn)課心得總結(jié)
java培訓(xùn)課心得總結(jié)在參加java培訓(xùn)的過程中，我感覺其實生活中很多時候與java編程是存在相似點。比
如說我們想做一件什么事情，總是要先考慮下這件事的目的，做這件事需要先準(zhǔn)備些什么，中間需要哪些步驟，最后怎樣實現(xiàn)等等，這與計算機編程思想驚人的相似，所以說，在很多
人看來，計算機很復(fù)雜，有數(shù)不清的代碼和程序，可以完成各種各樣的任務(wù)，功能千變?nèi)f化，要掌握它是一件難比登天的任務(wù)，其實不然。計算機這種復(fù)雜性，完全是人賦予的，計算機
只是單純的按照人的指令去完成我們想要完成的事情，從這方面看，計算機是簡單的。經(jīng)過
這一次的java培訓(xùn)，其中在java的各種對象、方法、類等方面上有了一個比較清晰的想法。
當(dāng)自學(xué)時你就不會聽到有這樣那樣的想法與指導(dǎo)，學(xué)起來就會比較迷茫點，但是有一個比較
好的老師來指點下，那樣的效果上就不同了，可以讓自己的想法和思維開拓點來學(xué)習(xí)java，親身感受過后，確實跟自學(xué)不一樣，自學(xué)的話自己可能沒這么好去理解代碼，有個人帶著去 理解代碼的話學(xué)起來比較快點，用起來也會容易慣通點。
通過這次也可以學(xué)到一個團(tuán)隊的重要，一個小項目可以一個人完成，那已經(jīng)是很痛苦地
那種了，但是有一個大項目的話，那就不是一個人可以完成的事了，必須由一個團(tuán)體來共同
完成項目，一個的技術(shù)牛不算牛，一個團(tuán)體的技術(shù)都很牛了那才是真正的牛，這樣合作起來
就可以更快的把一個項目完成，而個人來說，也不會感到非常吃力，分功合作對于開發(fā)一個
項目來說是重要的一步，在分功的時候必須分功明確，不然在開發(fā)程中會出現(xiàn)錯亂，例如一
個人開發(fā)了登陸的功能了，由于分功不明確導(dǎo)至另一個在也在開發(fā)此功能，分功明確了會減
去諸如些類的一些錯誤和麻煩。學(xué)習(xí)java聽老師講起課來，自己聽得明白，但是要自己真的去動手起來做的話，那又是
另一回事了，聽得明白不一定就可以自己動手做出來，學(xué)習(xí)java只有聽懂了再自己動手去真
正的做出一些東西來運用這些代碼，讓代碼在你腦子里轉(zhuǎn)來轉(zhuǎn)去不會忘記，看到有類似的功
能你就會想起用這些代碼來實現(xiàn)功能，那樣才是真正的學(xué)會了，不然你就是沒學(xué)會。在學(xué)習(xí)
java的過程中，最需要的就是耐心，在學(xué)習(xí)過程中，你會感到很枯燥，煩惱，無聊，寂寞感，但這些都不是問題，問題就是你能不能有很好的耐心學(xué)習(xí)下去，一般的人都是因為沒耐心學(xué)
下去才覺得它難，其實java語言本身不難，難的是你自己有沒有這樣的心去學(xué)，耐心很重要。
耐心+靈活變通=學(xué)習(xí)成功篇三：java培訓(xùn)總結(jié) 學(xué)習(xí)總結(jié)
java語言是一種跨平臺的高級語言，無論是網(wǎng)絡(luò)世界和桌面應(yīng)用程序，還是分布式應(yīng)用
環(huán)境和嵌入式應(yīng)用都可以看到j(luò)ava的身影。顯然java語言依然保持著旺盛的生命力，這也
使得眾多的從業(yè)人員開始學(xué)習(xí)java語言。java技術(shù)入門 使讀者對java語言有個初步的了解，為后面的深入學(xué)習(xí)奠定基礎(chǔ)；面向
對象技術(shù)是需要讀者認(rèn)真學(xué)習(xí)和體會的，第三篇編程提高篇 詳細(xì)講述了java語言的高級主
題，即讀者進(jìn)階學(xué)習(xí)的必備內(nèi)容；java分布式計算技術(shù)的內(nèi)容，如果讀者對web編程感興
趣，相信本篇可以滿足您的需求。為了說明java語言的應(yīng)用，《java完全自學(xué)手冊》最后一
篇介紹了一個實例，通過該程序從無到有的過程使讀者知道如何使用java語言編寫應(yīng)用程
序。
剛開始頭緒有點亂，尤其是看了thinking in java第四版前面后，你知道那感覺，啃啃
不下去，實例每個都看的似懂非懂，一兩個還行，多了就慌了，更何況他的內(nèi)容也看不太懂，雖然硬著頭皮往后走，但走到第三章就覺得不能再這樣了。上網(wǎng)找，一個視頻教學(xué)，孫鑫老
師的那個視頻，老師講的細(xì)致，各種小細(xì)節(jié)都不放過，開始還認(rèn)真的一句一句聽，后來也覺
得有些東西用的時候查書google就好了到?jīng)]必要聽講的時候弄懂。但好在孫鑫老師講的大致
還是沿襲中國人能懂的語言，比起thinking in java來說，確實是聽懂了。所以到了lession4 以后，我就大量使用快進(jìn)了。講下自學(xué)心得，給準(zhǔn)備學(xué)習(xí)的朋友理個大概框架，尤其是有一
點asp一類語言基礎(chǔ)的，就更合適了： 基礎(chǔ)，java編寫的時候，用記事本或者編譯工具，把java語言寫出來，然后用javac 編
譯寫好的語言文件把它編譯成 class文件，class文件就是機器最終執(zhí)行的文件（至于class 里面是什么樣的，機器是怎么中轉(zhuǎn)又編譯的，我們就不用管它了）。前面涉及到要配置java 目錄、classpath目錄幾個工作，很多講座要在這里花上一兩堂課，我看用不著，你就記著
查google百度把path和classpath設(shè)好，就ok可以開始用了。
java以class為基本單位，一個class實現(xiàn)一個基本功能或者模塊或者接口，一個java 文件里面你可以編寫多個class，但一編譯就會變成多個class文件，跟你分開寫效果是一樣的。class里面如果包含main方法，就是機器最后執(zhí)行的class，（其他不含main方法的class為執(zhí)行的這個class提供各種方法）
java就是用class這
個概念把各種功能模塊化，當(dāng)你把一個一個功能都寫好或者系統(tǒng)本身就有這個功能的class 的時候，你就直接調(diào)用現(xiàn)成的class，就不用額外再去寫了，就省心。比如有個class他能
把這個三個數(shù)字按照我們設(shè)定好的方式組成一個矩形，當(dāng)我們下次要用這個矩形的時候，就
不用再重復(fù)寫三個數(shù)字到矩形的過程，只要把三個數(shù)字交給寫好的那個class讓他組合成矩
形，我們把矩形拿過來用就好了；比如有個class他能把每個學(xué)生各門成績都加總，我們要
做學(xué)生總分排名的時候，只需要調(diào)用這個現(xiàn)成class把成績給他加總，我們不再去寫成績?nèi)?/p>
和加總的過程，直接使用加總結(jié)果排名就可以了。也就是，很多功能、模塊，系統(tǒng)有的用系
統(tǒng)的，別人有公用的拿別人的用，自己以前有寫過的用自己以前寫過的，只有這三個都沒有
的，才需要自己動手去寫，這樣一排除下來，還真的就沒多少需要我們自己寫的了，所以才
說java比較省事。class有分屬性，公開的就是寫完誰都能用，還有默認(rèn)的，還有保護(hù)的，還有私有的，因為class可以模塊化，所以才有這個屬性，有些寫完誰都能用，有些寫完必須要放在一個
目錄下才能用，有些寫完就不能給外面用了。具體適用范圍用到的時候查google。
方法，class里面跟class同名的叫做構(gòu)造方法，如果沒有寫，意思系統(tǒng)會隱含了一個
構(gòu)造方法，寫了自然就沒有隱含的了。方法里面就可以進(jìn)行各種具體的操作，比如定義變量，比如輸出結(jié)果，比如判斷，比如實例化對象等等。main方法是系統(tǒng)找到會運行的方法，寫方
法就跟其他編程比如以前我用的asp差不多，形式有點不同意思差不多，特別點的就是所謂
的面向?qū)ο?，除了實例化對象這一點稍微理解一下，其他方法內(nèi)部的編寫跟asp差不太多，你比如說 dim x，這是asp，不用聲明類型，到了java就是 int x；其實asp里面也可以聲 明類型，dim x as int；還有比如 x=x+5;asp里面就是沒有那個最后的;而已，比如for循
環(huán)、while這些也都差不多，還有print跟response.write也感覺差不多，就是輸出字符嘛，大同小異。java里面你就理解下實例化對象（對象都來自class，class 里面方法怎么寫的，說明你這個對象實例化后可以干些什么，方法里面帶了什么參數(shù)，就說明你這個對象實例化后將有些什么參數(shù)）；再理解下怎么把現(xiàn)有的class弄進(jìn)來使用；其
他就跟其他編程差不多了，我以前只學(xué)過asp，不過做了十年asp算是理解比較深，原以為
java輸入真正編程軟件應(yīng)該比asp難很多，最后發(fā)現(xiàn)除了上面兩點外，其他技術(shù)范圍基本沒
有超出asp的技術(shù)范圍只是形式格式略有不同而已。i.o里面有輸入輸出需要的一些東西，他可以把外面進(jìn)來的東西轉(zhuǎn)換成合適的格式，也
可以把我們程序內(nèi)的內(nèi)容以合適的格式輸出，例如讀取文件、寫入文件，讀取數(shù)據(jù)、寫入數(shù)
據(jù)，讀取網(wǎng)絡(luò)、寫入網(wǎng)絡(luò)，都會用到io。
網(wǎng)絡(luò)依賴tcp/ip協(xié)議，和sockets接口，服務(wù)器端調(diào)用sockets的服務(wù)器端方法，打開
監(jiān)聽（設(shè)定一個唯一端口號調(diào)用一個現(xiàn)成監(jiān)聽方法），一旦有東西傳過來他就自動開始工作了，我們用io方法獲得傳來的內(nèi)容分析、判斷，然后產(chǎn)生相應(yīng)操作；sockets客戶端也類似，只
要指定了服務(wù)器ip地址和那個對應(yīng)的端口號，就能鏈接到服務(wù)器，然后用io方法發(fā)送返回
信息。
窗口部分，有相關(guān)的windows包，導(dǎo)入后，只需要定義窗口尺寸、位置等，按鈕、文本
等等也都有對應(yīng)的現(xiàn)成的給你引用，只要一一設(shè)定好就有了，還有一些窗口固有的組件比如
最小化、關(guān)閉，關(guān)聯(lián)上相應(yīng)的功能就可以了。大概就學(xué)了這么多，我估計基本概念都理解了，還差一個跟數(shù)據(jù)庫的交互的概念，估計
也不復(fù)雜，剩下的我預(yù)計就是用別人現(xiàn)成源碼過來修改試驗，進(jìn)一步體會代碼了?？磥韏ava 確實如外面介紹的那樣，并不算復(fù)雜，還沒有用jbuilder一類的軟件，用了后說不定更容易。學(xué)編程這段日子里，由無知，到心頭漸漸明朗，走過很多彎路，曾因jvm機制問題駐足
不前，也曾因數(shù)據(jù)結(jié)構(gòu)而苦惱不已，更因提前結(jié)束的大學(xué)生活而后悔良久。只是，靜下來，看代碼，體會其中的思想，慢慢地，一些東西，曾經(jīng)的不明白，如今也清晰起來。只要堅持，那片廣袤的天地已為你留出一片天地。學(xué)編程，基礎(chǔ)最重要，不要貪快，一步一步，把那些知識點弄的明明白白，然后看api文檔，另外
網(wǎng)上看一些源代碼，體會其中的一些編程思想，csdn論壇也是個很好的學(xué)習(xí)地方。等基礎(chǔ)好
了，就可以學(xué)一些框架了，也就是所謂的j2ee，主要用來開發(fā)web的技術(shù)。如此看來，學(xué)習(xí)
java并不難，只是要一點一點，走的實實在在。工作當(dāng)中，這是我對學(xué)習(xí)java的一些個人
體會！
李沛
2013.7.28篇四：java培訓(xùn)總結(jié),重點都有1 第一課
一、java 語言簡介： 是由 sun 公司推出的新一代的純面向?qū)ο蟮木W(wǎng)絡(luò)編程語言，1995年問世的。
二、java語言的特性：
1、簡單的：
{ keep it simple and stupid(保持它的簡單性和可操作性)以人類正常的思維模式思考問題。java 是由c++語言發(fā)展而來。java 提供了非常豐富的內(nèi)置資源庫（api）
}
2、安全的：健壯性
{
1、java 中沒有指針（指針，是一項能直接指向內(nèi)存地址的）
2、java 會內(nèi)存釋放--gc機制（垃圾回收器，自動釋放）
3、預(yù)檢索程序錯誤--在程序執(zhí)行前，會檢查程序是否有語法錯誤，有則不會允許執(zhí)行。
4、異常處理機制--} {
1、平臺：把軟件的語言，翻譯成硬件所能識別的語言，即程序運行的硬件和軟件的環(huán)境。
2、java se--java 標(biāo)準(zhǔn)版（實現(xiàn)桌面應(yīng)用程序）
3、java ee--j2ee 企業(yè)級版本
4、java me--java 微型版本（嵌入式開發(fā)）}
4、跨平臺的：
{}
5、面向?qū)ο蟮模?/p>
{
1、現(xiàn)實世界是什么樣子的：（山川、河流、動物、植物。。分類組成的）
現(xiàn)實世界就是對所有的事物進(jìn)行分類，分類就代表一個群體。分類就是將具有相同特征和行為的事物進(jìn)行概括。
每個分類下面都有無數(shù)的個體，在java 語言中，和現(xiàn)實世界是一樣的，也是要先分類
再去
實現(xiàn)分類下的個體（java 中將個體稱為：對象）根據(jù)：特征（屬性）、行為劃分的
2、java 語言中，類和對象的關(guān)系：
java 語言中將現(xiàn)實世界中表示群體的分類稱之為類，而是將群體下面的每一個個體稱之為對象；
具有相同屬性和行為的對象的集合抽象為類或稱之為類型
對象是類的一個具體的實例，展示了類的不同屬性和行為
實例化：就是將抽象的類轉(zhuǎn)化成具體的個體的過程
3、如何用java語言去描述類：java 語言中類的描述分為兩部分：
1、要描述他的屬性（特征、靜態(tài)屬性）
2、要描述的是行為（動態(tài)屬性、方法）
語法格式：
class class_name{靜態(tài)屬性；動態(tài)屬性；} 類類名類體靜態(tài)屬性：相當(dāng)于字段動態(tài)屬性：用方法描述
}主控制類：
1、聲明對象并對對象進(jìn)行實例化對象 類型名對象名=new 類型名()//聲明部分
2、使用對象，即向?qū)嶓w類發(fā)送消息。對象名.屬性名=屬性值-----字符串用
數(shù)值不用對象名.方法名()第二課 跨平臺性：*
一、java如何實現(xiàn)跨平臺的？
1、平臺：把軟件的語言翻譯成硬件所能識別的語言，即程序運行的軟件或硬件環(huán)境。java 之所以能夠?qū)崿F(xiàn)跨平臺性，是因為 java 有屬于自己的平臺，不直接與操作系統(tǒng)或
硬件 環(huán)境交流。java平臺系統(tǒng)由兩部分組成：
1、java開發(fā)工具包；
2、java運行的軟環(huán)境（java虛擬機--jvm---java virtual machine）api：是一些已編寫好的程序的集合，他提供java 面對程序員的接口。
接口：很多內(nèi)置資源中，有一個數(shù)據(jù)包存儲對市面上已經(jīng)存在的各種操作系統(tǒng)進(jìn)行解析。篇二：java培訓(xùn)課心得總結(jié)
Java培訓(xùn)課心得總結(jié)
在參加java培訓(xùn)的過程中，我感覺其實生活中很多時候與java編程是存在相似點。比如說我們想做一件什么事情，總是要先考慮下這件事的目的，做這件事需要先準(zhǔn)備些什么，中間需要哪些步驟，最后怎樣實現(xiàn)等等，這與計算機編程思想驚人的相似，所以說，在很多人看來，計算機很復(fù)雜，有數(shù)不清的代碼和程序，可以完成各種各樣的任務(wù)，功能千變?nèi)f化，要掌握它是一件難比登天的任務(wù)，其實不然。計算機這種復(fù)雜性，完全是人賦予的，計算機只是單純的按照人的指令去完成我們想要完成的事情，從這方面看，計算機是簡單的。經(jīng)過這一次的java培訓(xùn)，其中在java的各種對象、方法、類等方面上有了一個比較清晰的想法。當(dāng)自學(xué)時你就不會聽到有這樣那樣的想法與指導(dǎo)，學(xué)起來就會比較迷茫點，但是有一個比較好的老師來指點下，那樣的效果上就不同了，可以讓自己的想法和思維開拓點來學(xué)習(xí)java，親身感受過后，確實跟自學(xué)不一樣，自學(xué)的話自己可能沒這么好去理解代碼，有個人帶著去理解代碼的話學(xué)起來比較快點，用起來也會容易慣通點。
通過這次也可以學(xué)到一個團(tuán)隊的重要，一個小項目可以一個人完成，那已經(jīng)是很痛苦地那種了，但是有一個大項目的話，那就不是一個人可以完成的事了，必須由一個團(tuán)體來共同完成項目，一個的技術(shù)牛不算牛，一個團(tuán)體的技術(shù)都很牛了那才是真正的牛，這樣合作起來就可以更快的把一個項目完成，而個人來說，也不會感到非常吃力，分功合作對于開發(fā)一個項目來說是重要的一步，在分功的時候必須分功明確，不然在開發(fā)程中會出現(xiàn)錯亂，例如一個人開發(fā)了登陸的功能了，由于分功不明確導(dǎo)至另一個在也在開發(fā)此功能，分功明確了會減去諸如些類的一些錯誤和麻煩。
學(xué)習(xí)java聽老師講起課來，自己聽得明白，但是要自己真的去動手起來做的話，那又是另一回事了，聽得明白不一定就可以自己動手做出來，學(xué)習(xí)java只有聽懂了再自己動手去真正的做出一些東西來運用這些代碼，讓代碼在你腦子里轉(zhuǎn)來轉(zhuǎn)去不會忘記，看到有類似的功能你就會想起用這些代碼來實現(xiàn)功能，那樣才是真正的學(xué)會了，不然你就是沒學(xué)會。在學(xué)習(xí)java的過程中，最需要的就是耐心，在學(xué)習(xí)過程中，你會感到很枯燥，煩惱，無聊，寂寞感，但這些都不是問題，問題就是你能不能有很好的耐心學(xué)習(xí)下去，一般的人都是因為沒耐心學(xué)下去才覺得它難，其實java語言本身不難，難的是你自己有沒有這樣的心去學(xué)，耐心很重要。耐心+靈活變通=學(xué)習(xí)成功 篇三：java培訓(xùn)總結(jié)
學(xué)習(xí)總結(jié)
Java語言是一種跨平臺的高級語言，無論是網(wǎng)絡(luò)世界和桌面應(yīng)用程序，還是分布式應(yīng)用環(huán)境和嵌入式應(yīng)用都可以看到Java的身影。顯然Java語言依然保持著旺盛的生命力，這也使得眾多的從業(yè)人員開始學(xué)習(xí)Java語言。
Java技術(shù)入門 使讀者對Java語言有個初步的了解，為后面的深入學(xué)習(xí)奠定基礎(chǔ)；面向?qū)ο蠹夹g(shù)是需要讀者認(rèn)真學(xué)習(xí)和體會的，第三篇編程提高篇 詳細(xì)講述了Java語言的高級主題，即讀者進(jìn)階學(xué)習(xí)的必備內(nèi)容；Java分布式計算技術(shù)的內(nèi)容，如果讀者對Web編程感興趣，相信本篇可以滿足您的需求。為了說明Java語言的應(yīng)用，《Java完全自學(xué)手冊》最后一篇介紹了一個實例，通過該程序從無到有的過程使讀者知道如何使用Java語言編寫應(yīng)用程序。
剛開始頭緒有點亂，尤其是看了thinking in java第四版前面后，你知道那感覺，啃啃不下去，實例每個都看的似懂非懂，一兩個還行，多了就慌了，更何況他的內(nèi)容也看不太懂，雖然硬著頭皮往后走，但走到第三章就覺得不能再這樣了。上網(wǎng)找，一個視頻教學(xué)，孫鑫老師的那個視頻，老師講的細(xì)致，各種小細(xì)節(jié)都不放過，開始還認(rèn)真的一句一句聽，后來也覺得有些東西用的時候查書google就好了到?jīng)]必要聽講的時候弄懂。但好在孫鑫老師講的大致還是沿襲中國人能懂的語言，比起thinking in java來說，確實是聽懂了。所以到了lession4以后，我就大量使用快進(jìn)了。講下自學(xué)心得，給準(zhǔn)備學(xué)習(xí)的朋友理個大概框架，尤其是有一點asp一類語言基礎(chǔ)的，就更合適了：
基礎(chǔ)，java編寫的時候，用記事本或者編譯工具，把java語言寫出來，然后用javac 編譯寫好的語言文件把它編譯成 class文件，class文件就是機器最終執(zhí)行的文件（至于class里面是什么樣的，機器是怎么中轉(zhuǎn)又編譯的，我們就不用管它了）。前面涉及到要配置java目錄、classpath目錄幾個工作，很多講座要在這里花上一兩堂課，我看用不著，你就記著查google百度把path和classpath設(shè)好，就ok可以開始用了。
java以class為基本單位，一個class實現(xiàn)一個基本功能或者模塊或者接口，一個java文件里面你可以編寫多個class，但一編譯就會變成多個class文件，跟你分開寫效果是一樣的。class里面如果包含main方法，就是機器最后執(zhí)行的class，（其他不含main方法的class為執(zhí)行的這個class提供各種方法）
java就是用class這個概念把各種功能模塊化，當(dāng)你把一個一個功能都寫好或者系統(tǒng)本身就有這個功能的class的時候，你就直接調(diào)用現(xiàn)成的class，就不用額外再去寫了，就省心。比如有個class他能把這個三個數(shù)字按照我們設(shè)定好的方式組成一個矩形，當(dāng)我們下次要用這個矩形的時候，就不用再重復(fù)寫三個數(shù)字到矩形的過程，只要把三個數(shù)字交給寫好的那個class讓他組合成矩形，我們把矩形拿過來用就好了；比如有個class他能把每個學(xué)生各門成績都加總，我們要做學(xué)生總分排名的時候，只需要調(diào)用這個現(xiàn)成class把成績給他加總，我們不再去寫成績?nèi)绾图涌偟倪^程，直接使用加總結(jié)果排名就可以了。也就是，很多功能、模塊，系統(tǒng)有的用系統(tǒng)的，別人有公用的拿別人的用，自己以前有寫過的用自己以前寫過的，只有這三個都沒有的，才需要自己動手去寫，這樣一排除下來，還真的就沒多少需要我們自己寫的了，所以才說java比較省事。
class有分屬性，公開的就是寫完誰都能用，還有默認(rèn)的，還有保護(hù)的，還有私有的，因為class可以模塊化，所以才有這個屬性，有些寫完誰都能用，有些寫完必須要放在一個目錄下才能用，有些寫完就不能給外面用了。具體適用范圍用到的時候查google。
方法，class里面跟class同名的叫做構(gòu)造方法，如果沒有寫，意思系統(tǒng)會隱含了一個構(gòu)造方法，寫了自然就沒有隱含的了。方法里面就可以進(jìn)行各種具體的操作，比如定義變量，比如輸出結(jié)果，比如判斷，比如實例化對象等等。main方法是系統(tǒng)找到會運行的方法，寫方法就跟其他編程比如以前我用的asp差不多，形式有點不同意思差不多，特別點的就是所謂的面向?qū)ο螅藢嵗瘜ο筮@一點稍微理解一下，其他方法內(nèi)部的編寫跟asp差不太多，你比如說 dim x，這是asp，不用聲明類型，到了java就是 int x；其實asp里面也可以聲明類型，dim x as int；還有比如 x=x+5;asp里面就是沒有那個最后的;而已，比如for循環(huán)、while這些也都差不多，還有print跟response.write也感覺差不多，就是輸出字符嘛，大同小異。java里面你就理解下實例化對象（對象都來自class，class 里面方法怎么寫的，說明你這個對象實例化后可以干些什么，方法里面帶了什么參數(shù)，就說明你這個對象實例化后將有些什么參數(shù)）；再理解下怎么把現(xiàn)有的class弄進(jìn)來使用；其他就跟其他編程差不多了，我以前只學(xué)過asp，不過做了十年asp算是理解比較深，原以為java輸入真正編程軟件應(yīng)該比asp難很多，最后發(fā)現(xiàn)除了上面兩點外，其他技術(shù)范圍基本沒有超出asp的技術(shù)范圍只是形式格式略有不同而已。
i.o里面有輸入輸出需要的一些東西，他可以把外面進(jìn)來的東西轉(zhuǎn)換成合適的格式，也可以把我們程序內(nèi)的內(nèi)容以合適的格式輸出，例如讀取文件、寫入文件，讀取數(shù)據(jù)、寫入數(shù)據(jù)，讀取網(wǎng)絡(luò)、寫入網(wǎng)絡(luò)，都會用到io。
網(wǎng)絡(luò)依賴tcp/ip協(xié)議，和sockets接口，服務(wù)器端調(diào)用sockets的服務(wù)器端方法，打開監(jiān)聽（設(shè)定一個唯一端口號調(diào)用一個現(xiàn)成監(jiān)聽方法），一旦有東西傳過來他就自動開始工作了，我們用io方法獲得傳來的內(nèi)容分析、判斷，然后產(chǎn)生相應(yīng)操作；sockets客戶端也類似，只要指定了服務(wù)器ip地址和那個對應(yīng)的端口號，就能鏈接到服務(wù)器，然后用io方法發(fā)送返回信息。
窗口部分，有相關(guān)的windows包，導(dǎo)入后，只需要定義窗口尺寸、位置等，按鈕、文本等等也都有對應(yīng)的現(xiàn)成的給你引用，只要一一設(shè)定好就有了，還有一些窗口固有的組件比如最小化、關(guān)閉，關(guān)聯(lián)上相應(yīng)的功能就可以了。
大概就學(xué)了這么多，我估計基本概念都理解了，還差一個跟數(shù)據(jù)庫的交互的概念，估計也不復(fù)雜，剩下的我預(yù)計就是用別人現(xiàn)成源碼過來修改試驗，進(jìn)一步體會代碼了。看來java確實如外面介紹的那樣，并不算復(fù)雜，還沒有用jbuilder一類的軟件，用了后說不定更容易。
學(xué)編程這段日子里，由無知，到心頭漸漸明朗，走過很多彎路，曾因JVM機制問題駐足不前，也曾因數(shù)據(jù)結(jié)構(gòu)而苦惱不已，更因提前結(jié)束的大學(xué)生活而后悔良久。只是，靜下來，看代碼，體會其中的思想，慢慢地，一些東西，曾經(jīng)的不明白，如今也清晰起來。只要堅持，那片廣袤的天地已為你留出一片天地。學(xué)編程，基
礎(chǔ)最重要，不要貪快，一步一步，把那些知識點弄的明明白白，然后看API文檔，另外網(wǎng)上看一些源代碼，體會其中的一些編程思想，CSDN論壇也是個很好的學(xué)習(xí)地方。等基礎(chǔ)好了，就可以學(xué)一些框架了，也就是所謂的J2EE，主要用來開發(fā)WEB的技術(shù)。如此看來，學(xué)習(xí)java并不難，只是要一點一點，走的實實在在。工作當(dāng)中，這是我對學(xué)習(xí)java的一些個人體會！
李沛
2013.7.28
第五篇：Java培訓(xùn)后總結(jié)
————上接Crazy Code(09.11 星期六)
CrazyCode(09.12星期天)
0、struts2：
a、hello stuts2：
b、struts.xml、hello.jsp。地址欄傳參：。
c、傳參驗證：直接寫在User.java里面（extends ActionSupport）
public String show()
{ if(“admin”.equals(username)&& “admin”.equals(password)){ return SUCCESS;} else {
return ERROR;
} }
1、Spring ：Hello Spring3.0！(先打開至spring視圖方式.)Hello.Java(JavaBean)<——HelloTest.java中實例化Hello.java，applicationContext.xml中聲明
JavaBean的id、class，且對Hello.java中的變量賦值：
2、Hibernate：(先打開至spring視圖方式.)
1、連接數(shù)據(jù)庫MySQL jdbc:mysql://localhost:3306/helu而不是
jdbc:mysql://localhost:3306;helu；
2、HelloTest.java右鍵MyEclipse->add Hibernate Ca…..->….->….會自動導(dǎo)入Hibernate包、建3立好hiberenate.cfg.xml、HibernateSessionFactory.java文件；
3、新建個bean類User.java;
4、新建User.xml:
；
5、修改生成的hibernate.cfg.xml文件（ADDUser.xml）；
6、新建測試類Test.java；
注：The database returned no natively generated identity value 則是在數(shù)據(jù)庫中id沒設(shè)置為自動增長！
CrazyCode(09.13星期一)
1、看不懂SSH的整合過程，不懂它的原理和工作方式。
2、了解Hibernate中配置文件的含義。
CrazyCode(09.14星期二)
1、Spring的基本作用及其映射關(guān)聯(lián)屬性。
Crazy1、信息科技中心頁面修改。
2、Hibernate增刪改查。Code(09.15星期三)
CrazyCode(09.16、17星期四、五)
復(fù)習(xí)數(shù)據(jù)庫工程師
CrazyCode(09.18星期六)
1、考完數(shù)據(jù)庫四級。
2、Hibernate怎么建立關(guān)聯(lián)的？
3、初步了解JQuery。
CrazyCode(09.19星期天)
Struts、spring、Hibernate 在各層的作用
簡單的說：
struts 控制用的、hibernate 操作數(shù)據(jù)庫的、spring 用解耦的。
具體的：）struts 負(fù)責(zé) web 層.ActionFormBean 接收網(wǎng)頁中表單提交的數(shù)據(jù)，然后通過 Action 進(jìn)行處理，再 Forward 到對應(yīng)的網(wǎng)頁。
在 struts-config.xml 中定義
5.集成 Hiberante。）Hiberante，負(fù)責(zé)持久化層，完成數(shù)據(jù)庫的 crud 操作
hibernate 為持久層，提供 OR/Mapping。
它有一組.hbm.xml 文件和 POJO, 是跟數(shù)據(jù)庫中的表相對應(yīng)的。然后定義 DAO，這些是跟數(shù)據(jù)庫打交道的類，它們會使用 PO。
在 struts+spring+hibernate 的系統(tǒng)中，對象的調(diào)用流程是： jsp-> Action － > Service->DAO->Hibernate。
數(shù)據(jù)的流向是 ActionFormBean 接受用戶的數(shù)據(jù)，Action 將數(shù)據(jù)從 ActionFromBean 中取出，封裝成 VO 或 PO,再調(diào)用業(yè)務(wù)層的 Bean 類，完成各種業(yè)務(wù)處理后再 forward。而業(yè)務(wù)層 Bean 收到這個 PO 對象之后，會調(diào)用 DAO 接口方法，進(jìn)行持久化操作。
CrazyCode(09.20星期一)
1、tomcat6.0不需配環(huán)境變量，如果startup.bat一閃而過，則編輯startup.bat 文件。在其if “%OS%” == “Windows_NT” setlocal后加上：
java-jar-Duser.dir=“D:Study Progremapache_tomcat6.0apache-tomcat-6.0.29” “D:Study Progremapache_tomcat6.0apache-tomcat-6.0.29binbootstrap.jar” start。
3、hibernate連不上sqlserver2000數(shù)據(jù)庫。。
4、不需要在數(shù)據(jù)庫的表間建立關(guān)聯(lián)，只要建立映射即可。（但一般不采取此種方式，直接用SQL語句搞定?。?/p>
CrazyCode(09.21星期二)
1、GassFish：Hello Word!
點擊咨詢 