第一篇：Java開發(fā)筆記 — HttpServletRequest方法總結
Java開發(fā)筆記 — HttpServletRequest方法總結
HttpServletRequest方法總結
getScheme()方法返回請求的計劃，比如http,https或者ftp.getServerName()方法返回被發(fā)送請求的服務器的主機名 getServerPort()方法返回被發(fā)送請求的端口號。
getContextPath()返回請求地址的根目錄，以“/”開關，但不是以“/”結尾。
一個常用的獲得服務器地址的連接字符串是： String path = request.getContextPath();String basePath = request.getScheme()+“://”+request.getServerName()+“:”+request.getServerPort()+path+“/”;getCookies()取得cookie
getMethod()取得請求方法，如get,post或put getRequestURL()取得請求URL(統(tǒng)一資源定位符)getRequestURI()取得請求URI(統(tǒng)一資源標識符)getSession()取得對應session getHeaderNames()返回請求包含的所有頭名稱的一個enumeration(遍歷器)使用方法如下：
Enumeration en = request.getHeaderNames();while(en.hasMoreElements()){
out.print(en.nextElement());
} 輸出如下結果：
accept accept-language accept-encoding user-agent host connection cookie 具體含義是：
Accept：瀏覽器可接受的MIME類型。
Accept-Language：瀏覽器所希望的語言種類，當服務器能夠提供一種以上的語言版本時要用到。
Accept-Encoding：瀏覽器能夠進行解碼的數(shù)據(jù)編碼方式，比如gzip。Servlet能夠向支持gzip的瀏覽器返回經gzip編碼的HTML頁面。許多情形下這可以減少5到10倍的下載時間。
User-Agent：瀏覽器類型，如果Servlet返回的內容與瀏覽器類型有關則該值非常有用。Host：初始URL中的主機和端口。
Connection：表示是否需要持久連接。如果Servlet看到這里的值為“Keep-Alive”，或者看到請求使用的是HTTP 1.1（HTTP 1.1默認進行持久連接），它就可以利用持久連接的優(yōu)點，當頁面包含多個元素時（例如Applet，圖片），顯著地減少下載所需要的時間。要實現(xiàn)這一點，Servlet需要在應答中發(fā)送一個Content-Length頭，最簡單的實現(xiàn)方法是：先把內容寫入 ByteArrayOutputStream，然后在正式寫出內容之前計算它的大小。
Cookie：這是最重要的請求頭信息之一
getHeader(name)返回指定名稱的特定請求的值。使用方法如下：
out.print(“cookie:===”+request.getHeader(“cookie”)+“
”);完整舉例： accept:===*/* accept-language:===zh-cn accept-encoding:===gzip, deflate user-agent:===Mozilla/4.0(compatible;MSIE 6.0;Windows NT 5.1;SV1;TheWorld)host:===localhost:8080 connection:===Keep-Alive cookie:===JSESSIONID=BF00F7FD72F5DF83DF8F62E3D5EFF960
第二篇：Java筆記總結
1、Java是一種可以編譯 跨平臺、面向對象的高級計算機語言。
2、Java語言的特點：簡單、安全、跨平臺、面向對象、支持多線程。
3、Java的三個技術平臺分別是 JavaSE、JavaEE、JavaME。
4、Java程序的運行環(huán)境簡稱為 JDK。
5、編譯Java程序需要使用 javac 命令。
6、javac.exe和java.exe這兩個可執(zhí)行程序存放在JDK安裝目錄的bin目錄下。
7、PATH環(huán)境變量用來存儲Java的編譯和運行工具所在的路徑；CLASSPATH環(huán)境變量 則用來保存Java虛擬機要運行的“.calss”文件。
8、.class文件在 java.exe 文件啟動的JVM中運行。
9、JRE與JDK之間的區(qū)別：
a)JRE（Java Runtime Environment）提供java程序運行所需要的基本條件（如JVM）和許多基礎類。
b)JDK（Java Development Kit）是Java程序開發(fā)工具包——包含編譯工具、解釋工具、打包工具等開發(fā)工具。
10、JVM——Java虛擬機，相當于一個虛擬的操作系統(tǒng)，負責運行javac.exe生成的 字節(jié)碼（二進制）文件。java.exe執(zhí)行”.class”，就是java.exe啟動JVM運行”.class”文件。
11、標識符命名規(guī)則：
a)包名所有字母一律小寫。
b)類名和接口名每個單詞首字母大寫。
c)常量名所有字母都大寫，單詞之間用下劃線分開。
d)變量名和方法名的第一個單詞小寫，之后的每個單詞首字母大寫。
12、強制類型轉換：
a)格式：目標類型 變量名 =（目標類型）值
b)int類型轉換成byte類型 很容易造成 精度丟失。因為int類型變量是32位，byte類型只有8位，所以在轉換過程中會丟失int類型的高3位字節(jié)。
c)在用”雙字符“型運算符（+=、-=之類的）運算時，強制類型會自動完成，不用程序顯示的聲明。
13、三元運算符：判斷條件？表達式1：表達式2；——若條件成立，執(zhí)行表達式1，否則執(zhí)行表達式2。
14、跳轉語句：
a)break：
i.用于switch語句，終止某case并跳出switch結構。ii.用于循環(huán)語句，跳出循環(huán)語句，執(zhí)行后面的程序。
b)continue——只用于循環(huán)語句中：終止本次循環(huán)，執(zhí)行下一次循環(huán)。
15、方法重載：
a)2個條件：方法名相同、參數(shù)個數(shù)或參數(shù)類型不同。b)與返回值類型無關。
16、數(shù)組：
a)定義數(shù)組：
i.類型[ ] 數(shù)組名 = new 類型[ 數(shù)組長度 ] //這種定義方式只指定了長度，元素的初值由系統(tǒng)自動賦0。（動態(tài)初始化）
ii.類型[ ] 數(shù)組名 = new 類型[ ]{元素，元素，......} iii.類型[ ] 數(shù)組名 = {元素，元素，......} //這2種稱為 靜態(tài)初始化。
17、冒泡排序：
a)若有n個元素，則進行n-1輪排序（n-1次外循環(huán)）
b)第1輪排序，元素之間進行n-1次比較；第2輪排序進行n-2次排序......最后1輪只進行1次比較。c)外循環(huán)條件：i < arr.length d)內循環(huán)條件：j < arr.length1
18、二維數(shù)組：
a)定義方式1：類型[ ][ ] 變量名 = new 類型[ 幾行 ][ 幾列 ];b)可理解為數(shù)組的 數(shù)組——例arr[0][1]-->數(shù)組名arr[0]，第二個元素[1];c)二維數(shù)組的 長度 由”[ 幾行 ]“確定！
d)定義方式2：類型[ ][ ] 變量名 = new 類型[ 幾行 ][ ];//行數(shù)確定，列數(shù)不確定——每行可以隨便 賦值。
e)定義方式3：類型[ ][ ] 變量名 = { { ,...,...,...}，{ }，{ }，......} //這種行數(shù)、列數(shù)都不確定。大括號 內的每個 大括號 代表 一行 的元素，每行有多少個元素 取決于 內大括號 中元素的個數(shù)。
19、面向對象的特點：封裝性、繼承性、多態(tài)性。
20、在創(chuàng)建變量后，JVM運行程序時，會自動初始化變量。引用型變量 為 null。
21、垃圾對象——沒有變量引用的對象。
22、類的封裝：將類中的屬性 私有化。外界訪問私有屬性時 只能通過該屬性的 getxxx（）方法。
a)//擇Generate getter and setter--> 自動生成
set和get方法。
23、構造方法：實例化對象。
a)可以用 帶參數(shù)的構造方法 在實例化對象時就 給私有屬性 賦值。b)好的程序員 應該為每個類 寫一個 無參構造方法。c)定義構造方法的條件：
i.方法名與類名相同。ii.沒有返回值的 聲明。
iii.方法中 不能有return 返回值。
24、this關鍵字
a)this指代 該類實例化的 對象。所以可以用 this.xx的方式調用 成員。b)在成員方法中使用this關鍵字，避免參數(shù)名與屬性名相同。c)用this關鍵字調用 構造方法
i.只能在構造方法中 用this調用其他構造方法； ii.此時this語句必須位于第1行，并且只能出現(xiàn)一次 iii.不能在一個類的兩個構造方法中互相調用。
25、static關鍵字
a)靜態(tài)變量：
i.用static修飾的變量 ii.靜態(tài)變量被所有實例共享
iii.可以使用“類名.變量名”的形式來訪問。iv.只能修飾 成員變量 b)靜態(tài)方法
i.希望在不創(chuàng)建對象的情況下也能條用 類中的 某個方法，那就用static關鍵字休息這個方法 ii.靜態(tài)方法 只能訪問 靜態(tài)成員！
//因為非靜態(tài)成員 必須先創(chuàng)建對象才能訪問，而靜態(tài)方法在被調用的時候可以 不創(chuàng)建對象——那么就沒有非靜態(tài)成員可供訪用。
c)靜態(tài)代碼塊
i.當類被加載時，靜態(tài)代碼會執(zhí)行一次。而類只會被加載一次，所以靜態(tài)代碼塊只會被執(zhí)行一次。
ii.通常會用靜態(tài)代碼塊對類的成員變量進行初始化。d)單例模式
i.private static 類名 INSTANCE = new 類名();量——自己創(chuàng)建一個對象。private 類名(){};
//私有的 構造方法，只能內部訪問
}
//私有成員變public static 類名 getInstance(){ return INSTANCE;//定義靜態(tài)方法，返回自己的實例對象。ii.第二種單例模式創(chuàng)建方法。
1.Private 類名(){} 調用。
2.public static fianl 類名 INSTANCE = new 類名();的不能被修改的 靜態(tài)成員對象。
26、內部類——定義在類里面的 類
a)成員內部類
i.相當于成員方法，可以訪問外部類的所有成員；
ii.因為成員內部類相當于 成員方法，所以想要創(chuàng)建內部類對象時，必須得用外部類的對象 去創(chuàng)建內部類對象：
1.外部類名.內部類名 變量名 = new 外部類名().new 內部類名();b)靜態(tài)內部類
i.用static修飾的成員內部類，也相當于靜態(tài)方法。只能訪問外部類的靜態(tài)成員。
ii.因為靜態(tài)，所以在創(chuàng)建內部類對象時，可以不用先創(chuàng)建外部類對象：
1.外部類名.內部類名 變量名 = new 外部類名.內部類名();iii.靜態(tài)內部類中 可以定義靜態(tài)成員，非靜態(tài)內部類則不可。c)方法內部類
i.在方法中定義的類，只能在當前方法中被使用。
27、當一個對象被當成垃圾從內存中釋放時，它的 finalize（）方法會被自動調用。
//公有
//私有的 構造方法，只能在類的內部被
28、繼承
a)繼承關鍵字：extends。b)格式：Class A extends B{} c)單繼承——一個類只能有一個直接父類。
29、重寫父類方法
a)條件：方法名、參數(shù)、返回值類型 3個都相同。
b)重寫之后，子類調用被重寫的方法時，就是調用自己寫的方法。c)重寫應用：
i.應用對象 是父類的 公有方法。重載 應用的對象是 類本身的 方法。ii.重寫父類 不適合子類的 方法 iii.實現(xiàn)接口。
30、super關鍵字
a)調用父類成員變量和成員方法：
i.super.成員變量;ii.super.成員方法（參數(shù)1,參數(shù)2,...）;b)調用父類的構造方法
i.super（參數(shù)1,參數(shù)2,...）;ii.必須位于子類的構造方法的第一行，且只能出現(xiàn)一次。
iii.在實例化子類時，系統(tǒng)會在 子類的構造方法中 調用
父類的構造方法——如果子類的構造方法中 沒有調用 父類的構造方法，系統(tǒng)會自動調用父類的無參構造方法。所以 每個類的 無參構造方法 一定不要漏了！子類也可以顯示的調用 父類的有參或無參構造法方法。c)解決 重寫了父類方法之后，不能調用父類方法的問題。
31、final關鍵字
a)final修飾的類 不能被繼承 b)final修飾的方法 不能被子類重寫
c)final修飾的變量 是常量，不能被修改，且必須在定義時 為變量賦值。
32、抽象類
a)關鍵字 abstract b)抽象方法：abstract void shout（）{}；——沒有方法體。
c)包含抽象方法的類必須聲明為 abstract類：abstract class Animal{} d)抽象類可以 不包含任何抽象方法，只需用abstract修飾。e)抽象方法不能直接實例化，只能讓 子類實例化。
33、接口
a)定義關鍵字：interface——interface Animal{} b)接口中的方法 被默認修飾為：public abstract——抽象方法。c)接口中的變量 被默認修飾為 :public static final —— 全局常量
i.所以變量最好用
全大寫
表示。
d)因為方法都是抽象的，所以必須定義一個類 來實現(xiàn)（implements）接口——Class A implements B{} e)接口之間可以繼承——interface C extends B{} f)一個類可以實現(xiàn)多個接口，接口直接間用逗號隔開。g)一個類可以在繼承一個類的同時，實現(xiàn)其它的接口。
h)如果一個類去實現(xiàn)接口的話，那么這個類必須實現(xiàn)接口中所有的方法。
34、多態(tài)
a)方法上的多態(tài)
i.類內部方法的重載 ii.子類對父類方法的重寫 b)對象上的多態(tài)性
i.假設父類：A；子類B B b = new B();ii.對象的自動向上轉型：A a = b;//子類對象，變成了父類對象。
1.雖然a指向A的對象，但是如果B重寫了A的方法，那a調用的還是B中的方法。
iii.對象的強制向下轉型
1.若 A a = new A();2.B b =(B)a;
//父類對象變成了 子類對象。3.這時對象b調用的是 子類的重寫的方法。
4.注意：對象發(fā)生強制向下轉型之前，必須保證已經發(fā)生了向上轉型，否則會出異常。
35、異常
a)異常類分為：編譯時異常、運行時異常 b)異常處理機制： i.try...catch...finally 1.try代碼包含可能發(fā)生異常的Java語句，catch塊中包含針對一場進行處理的代碼。
2.當發(fā)生異常時，系統(tǒng)將異常信息封裝成一個異常對象傳遞給catch代碼塊。所以catch需要定義1個對應的異常類 變量。3.finally代碼塊包含，無論發(fā)生什么異常都要執(zhí)行的代碼。常用于關閉系統(tǒng)資源。
ii.throws關鍵字聲明拋出異常，調用者對其處理。這種方法能通過編譯，但是發(fā)生異常后就會終止運行。
c)自定義異常
i.首先定義 一個繼承Exception異常的 異常類；異常類中 編寫一個無參構造方法（調用父類無參構造方法），再編寫一個 帶String參數(shù)的構造方法（也調用父類的帶Stirng參數(shù)的構造方法）。ii.再定義一個 測試類，定義要調用的方法，并在此方法后面用 throws關鍵字 聲明拋出自定義異常；再在 方法體 內判斷什么時候 用throw new 自定義異常（“要打印的信息”）。//聲明自定義異常對象。
iii.最后在 測試類的main 方法中，iv.try{...}
catch(...){ System.out.printlan(e.getMessage)}
finally{...}
36、線程的創(chuàng)建： a)繼承Thread類，并重寫run（）方法。然后new Thread（）.start;開啟線程。
b)實現(xiàn)Runnable接口，重寫run（）方法。然后new Thread（new myRunnable）.start開啟線程。
37、兩種實現(xiàn)多線程的比較——實現(xiàn)Runnable接口的方法更好
a)可以讓多個線程共享資源。——售票系統(tǒng)需要。b)避免單繼承。38、36、
第三篇：java學習筆記總結
java 學習筆記總結
1.Java是什么呢？
Java不僅是一門語言，而且是一個完整的平臺，有一個龐大的庫，其中包含了很多可重用的代碼和一個提供安全性、跨操作系統(tǒng)的可移植性以及自動垃圾收集等服務的執(zhí)行環(huán)境。
2.JDK 和 JRE 是什么？
JDK：全稱是 Java Development Kit，這是我們編寫java程序的開發(fā)人員需要的。我們首先要下載和安裝JDK，然后設置環(huán)境變量，具體操作可以加我扣：七零五叁零六久久久
JRE：全稱是 Java Runtime Environment，它包含虛擬機但不包含編譯器，這是運行java程序的用戶需要的環(huán)境
3.來個Hello World看看吧？
照例先創(chuàng)建一個類HelloWorld.java，源代碼如下： /** * @author 老孫
*/ public class HelloWorld {
public static void main(String[] args){
System.out.println(“Hello World”);
} } Java類名一般是以大寫字母開頭的名詞，多個單詞的話每個單詞首字母都應該大寫。Java源代碼以.java作為擴展名，而且文件名必須和文件里的公共類同名。
4.怎么用命令行運行java程序？
比如上面我們編寫了一個類叫做HelloWorld.java，首先打開一個終端；
? 然后進入到HelloWorld.java類所在的目錄； ? 輸入命令 javac HelloWorld.java。javac是一個java編譯器，注意該命令需要的是文件名，也就是要帶著.java后綴。? 輸入命令 java HelloWorld。java啟動Java虛擬機，該命令只需要類名，不需要帶著.java或者.class等后綴。?
5.Java代碼怎么加注釋？
// 單行注釋 和 /*{……}*/ 長篇注釋，這兩種方式很多語言都一樣，沒什么特別強調的。
另外還有一種注釋可以方便的生成java doc文檔，以/** 開頭，以*/結束。
6.Java的幾種基本數(shù)據(jù)類型是？
4種整型：byte(1字節(jié)),short(2字節(jié))，int(4字節(jié)),long(4字節(jié))。(PS：Java沒有無符號整型)? 2種浮點型：float(4字節(jié)),double(8字節(jié))? 字符類型：char ? 布爾類型：boolean
在Java種每個類型占用幾個字節(jié)是固定的，與運行java的機器無關，這點與C#不同，這也是Java具有可移植性的關鍵點。
浮點類型一般double比float常用,而且浮點型存在四舍五入的情況，如果用在對精確度要求高的商業(yè)場景，就得使用java.math.BigDecimal類型了。我們寫個demo看看： ?
/** * @author 老孫
*/ public class DemoDouble { public static void main(String[] args){
double d1=0.05;
double d2=0.01;
double result=d1+d2;
System.out.println(result);//結果：0.***005
BigDecimal bd1=new BigDecimal(“0.05”);
BigDecimal bd2=new BigDecimal(Double.valueOf(“0.01”));
double result2=bd1.add(bd2).doubleValue();
System.out.println(result2);//結果：0.06
} }
7.Java怎么定義常量？
使用關鍵字final定義常量，之前C#用的是const關鍵字，這一點不同要注意一下。命名規(guī)則上，常量一般使用大寫字母，中間用下劃線分隔。例如： private static final Integer MAX_SIZE=100;
8.String字符串怎么截取子串？
Substring(beginIndex,endIndex)：返回子字符串，從beginIndex到endIndex-1。String s=“你好，今天是2018年1月5日，圣誕快樂！” String date = s.substring(6,17);System.out.println(date);// 輸出：2018年1月5日
注意：該方法的返回結果不包含最后一個位置的字符。如果有問題就問我：七零五叁零六久久久 9.Java字符串怎么拼接？
①最簡單的拼接方式就是使用+符號。
②String.join(char,str1,str2….strN)：靜態(tài)方法拼接字符串，用字符char分隔，將字符串進行拼接。//拼接
String s2=String.join(“、”,“JAVA核心技術”,“JAVA編程思想”,“SpringBoot”);System.out.println(s2);//輸出：JAVA核心技術、JAVA編程思想、SpringBoot
③當有大量字符串拼接操作的時候使用StringBuilder，這跟C#基本相同。
10.怎么判斷兩個Java字符串是否相等？
equals方法判斷兩個字符串內容是否相等。而==判斷兩個字符串是否指向內存中同一位置。//比較
String s3=“abc”;String s4=“abc”;String s5=new String(“abc”);String s6=new String(“abc”);System.out.println(s3==s4);//true System.out.println(s3.equals(s4));//true System.out.println(s5==s6);//false System.out.println(s5.equals(s6));//true 這個demo中s3==s4返回true，因為在Java中字符串是不可修改的，編譯器有一些優(yōu)化機制讓字符串共享，所以s3和s4實際上指向了內存中同一位置 11.Java數(shù)組有哪些常用操作？
①foreach循環(huán)數(shù)組
//foreach循環(huán)數(shù)組 int[] arr={1,3,5,7,9};for(int item:arr){ System.out.println(item);} ②打印數(shù)組元素
Arrays.toString(a)：返回字符串，數(shù)組元素包含在方括號中，以逗號分隔。Arrays.deepToString(arr)：用來打印多維數(shù)組。//打印數(shù)組
System.out.println(Arrays.toString(arr));//輸出 [1, 3, 5, 7, 9] int[][] arrM={{1,2,3},{11,12,13},{21,22,23}};System.out.println(Arrays.deepToString(arrM));//[[1, 2, 3], [11, 12, 13], [21, 22, 23]] ③拷貝數(shù)組元素
靜態(tài)方法Arrays.copyOf(originalArray,length):第一個參數(shù)是要拷貝的源數(shù)組，第二個元素是新數(shù)組的長度，如果第二個大于原數(shù)組長度，則自動填充默認值。//拷貝數(shù)組元素
int[] arr2=Arrays.copyOf(arr,arr.length);System.out.println(Arrays.toString(arr2));//輸出 [1, 3, 5, 7, 9] int[] arr3=Arrays.copyOf(arr,arr.length/2);System.out.println(Arrays.toString(arr3));//輸出 [1, 3] int[] arr4=Arrays.copyOf(arr,arr.length*2);System.out.println(Arrays.toString(arr4));//輸出 [1, 3, 5, 7, 9, 0, 0, 0, 0, 0] ④排序
靜態(tài)方法Arrays.sort()方法采用優(yōu)化后的快速排序算法對數(shù)組元素進行排序。//排序
int[] arr6={12,4,53,78,21,943,3};Arrays.sort(arr6);System.out.println(Arrays.toString(arr6));//輸出 [3, 4, 12, 21, 53, 78, 943]
⑤查找
靜態(tài)方法Arrays.binarySearch(arr, valueToFind)：二分查找，第一個參數(shù)是要查找的數(shù)組，第二個參數(shù)是要查找的目標元素。該方法有個前提是數(shù)組必須是有序的。//查找
int index=Arrays.binarySearch(arr6,12);//輸出 2 System.out.println(index);
⑥填充數(shù)組元素
靜態(tài)方法Arrays.fill(arr,item)：將數(shù)組arr每個元素都填充為item.//填充數(shù)組元素
String[] arr7=new String[5];Arrays.fill(arr7,“*”);System.out.println(Arrays.toString(arr7));//[*, *, *, *, *]
⑦比較數(shù)組
注意要使用Arrays.equals(arr1,arr2)比較數(shù)組，如果兩個數(shù)組元素全部相同，則返回true。//比較數(shù)組元素
String[] arr8={“*”,“*”,“*”,“*”,“*”,};System.out.println(arr7.equals(arr8));//false System.out.println(Arrays.equals(arr7,arr8));//true
12.日期對象LocalDate ①獲取當前日期時間 //當前日期
LocalDate today=LocalDate.now();
System.out.println(today);//2017-12-26
//當前時間
LocalTime currentTime=LocalTime.now();
System.out.println(currentTime);//12:23:09.054
//當前日期時間
LocalDateTime dateTime=LocalDateTime.now();
System.out.println(dateTime);//2017-12-26T12:23:09.054
②構造某個指定日期
//構造指定日期
LocalDate newYear=LocalDate.of(2018,1,1);System.out.println(newYear);//2018-01-01
③解析日期字符串，如果不合法會拋出異常。
//解析日期字符串
LocalDate date1=LocalDate.parse(“2018-12-31”);System.out.println(date1);//2018-12-31//LocalDate.parse(“2018-11-31”);//拋出異常
④獲取若干天后的某個日期 //15天后
LocalDate date15=today.plusDays(15);System.out.println(date15);//2018-01-10
⑤獲取年份、月份、日期
//獲取年、月、日
System.out.println(date15.getYear());//2018 System.out.println(date15.getMonth());//JANUARY System.out.println(date15.getMonthValue());//1 System.out.println(date15.getDayOfMonth());//10 System.out.println(date15.getDayOfWeek());//WEDNESDAY System.out.println(date15.getDayOfYear());//10 注意：使用Date對象的getYear()方法，不能獲取當前的年份
System.out.println(new Date().getYear());//117,不是我們想要的結果2018 我們看一下該方法的源碼，計算的是當前年份和1900年的差值
public int getYear(){ return normalize().getYear()-1900;}
大家在學習的過程中遇到任何的問題都可以咨詢我（QQ：705306999，奔跑de蝸牛）
也可以加入到我們的免費學習交流群： 579016988（職坐標java編程交流群2）玩微信的朋友也可以加老孫的個人微信公眾號：微信右上角點擊加號--添加朋友--公眾號--搜索：我是老孫（如下圖），也會不定期發(fā)送技術文章，娛樂八卦，吃喝玩樂，房產頭條，心靈雞湯等信息！
加圖片說明文字
注意：添加時請注明微博
移除點擊此處添如果大家想看老孫的直播學習，可以加入咱們的免費公開課進行學習！騰訊課程地址：https://ke.qq.com/course/92963#tuin=2a0a2177
有的人會這樣說：“我只是在業(yè)余時間打盹而已，業(yè)余時間干嗎把自己弄得那么緊張？”
愛因斯坦就曾提出：“人的差異在于業(yè)余時間。”
一位在哈佛任教的朋友說，只要知道一個青年怎樣度過他的業(yè)余時間，就能預言出這個青年的前程怎樣。記得點贊和轉發(fā)哦！
片說明文字
移除點擊此處添加圖
第四篇：java學習方法筆記總結.
本人親自總結了多年學習JAVA的筆記總結，多年心血都在此了，速來下載！下面簡單列舉一下大家學習java的一個系統(tǒng)知識點的一些介紹(按照TTS6上面的順序來的)：
一：java基礎部分：java基礎的時候，有些知識點是非常重要的，比如循環(huán)系列。For,while,do-while.這方面只要大家用心點基本沒什么難點。
二：面向對象：oop面向對象的時候，偏重理論，相信這方面的文章也很多，大家可以多看看，在這就不說了。重點掌握面向對象的三大特征和基本原理。
三：java核心一：這方面主要偏重API,所以在學習了這章的時候，一定要對照API去學習，多看API，主要就是方法多，string和集合的方法最為重要。后面將為大家提供本人整理的部分筆記。
四：java核心二：主要講解了異常，線程和IO流，其實個人認為重點掌握線程就行，對于流和異常多寫就行，線程偏重理論也最為重要。
五：oracle數(shù)據(jù)庫方面：建議學習數(shù)據(jù)庫的時候大家一定要端正態(tài)度，數(shù)據(jù)庫極為重要，本人當時在學習這個的時候，一直以為數(shù)據(jù)庫只是為了增刪改查，故沒有認真學習，后期面試的時候吃了不少虧，因為現(xiàn)在軟件公司對數(shù)據(jù)庫的要求跟java一樣重要，基本都會單獨一張筆試題筆試數(shù)據(jù)庫。
六：JDBC/XML系列：JDBC主要是3個核心接口(Connection)(Statement)(ResultSet)的使用，大家在學習的時候，熟練運用3接口，jdbc的原理也相當重要，雖然后期學習了HIbernate之后，JDBC不需要再用，但其底層原理還是JDBC，而且現(xiàn)在很多軟件公司不一定會用到Hibernate框架，所以建議大家還是把“本”學好，XML：重點掌握解析互換的2個核心接口方法。
七：HTML/CSS/JS:對于這個，本人相當糾結，因為這個有點偏向于美工的意思，所以后期想從事后臺開發(fā)的同學一般不會太重視，但是現(xiàn)在都是web項目，而且很多軟件公司并不是把許多這方面的事情交給美工(除非是那種有很高要求的靜態(tài)頁面),而且現(xiàn)在html代碼都是在jsp里面寫，所以建議還是好好學學，因為公司不會讓一個美工去專門為你寫一些簡單的html代碼，包括js!這章其實不難，就是屬性方法知識點比較多，大家多記記，多寫寫，重在多練！
八：Servlet/Jsp:如果想從事web和b/s開發(fā)(現(xiàn)在基本都是web和b/s開發(fā)),這章極為重要，服務器的訪問以及配置。tomcat的使用都在這一章，雖然后期struts框架的學習簡化了servlet代碼的繁瑣性，但是你可知道現(xiàn)在有些公司只用servlet不用struts!即使用了框架技術也不一定是struts!servlet跟JDBC一樣都是“本”，而struts和Hibernate一樣都是封裝了它們而后簡化代碼而已。所以只有把“本”學會了，就不怕框架的變化！jsp就不多說了，如果你學習java這個就不會缺少！后期b/s項目頁面的布局以及功能就全靠它了。
九：Ajax/Jquery：當初學習這個的時候，本人沒有用心去學，然后結果就是本人在進公司之后花了一個星期的時間練習jQuery!這個對于強化web服務器頁面的功能技術實在是強大.這個封裝了js對象的技術，可以對jsp頁面元素進行樣式的更改以及操作，想要玩好web項目，這個技術必須玩好！
十：SSH：傳說中的三大框架；
Struts：前面已經提到，這個框架技術主要是為了彌補servlet和jsp頁面之間交互的復雜性，可以有效的提高客戶端與服務器之間的交互。而且采用了MVC思想進行改善減弱代碼之間的復雜性。Hibernate:主要封裝了jdbc的核心功能，可以采用映射方式訪問并操作數(shù)據(jù)庫，一定程度上講是簡化了程序代碼，但前面已經提到，由于是框架，而框架是隨著時代而改變的，并且很多公司不一定用到這個框架，所以，只有掌握好JDBC的根本原理，才會更加理解這個框架。
Spring框架：其實后期學框架知識大家都會覺得很無趣和乏味，因為框架的知識都是理論很深的知識點，spring主要是要完善代碼之間的耦合度，包括類似工廠模式的對象自動控制，AOP的事物日志管理等，都其實是為了減少程序員的工作量，但不得不說是有很大的作用的，而且這個框架可以整合JDBC以及Hibernate，struts技術，可以把所有的框架技術都整合在一起。相當于一塊主板把內存，風扇，cpu，顯卡都集中在一起。
前面所有的都是個人學習之中的一點感受，希望大家也能有所感觸，主要想說明的是前面的基礎一定要打好，對于學習方法的問題也可以和大家聊一聊，本人在學習之初，由于面向對象和集合一些理論較深的知識點出現(xiàn)，導致后期比較注重理論，最終在寫實際項目的時候吃了苦頭，因為代碼量沒有跟上，即使理論都懂，但很多功能還是無法自己寫出，所以要強調的是在注重理論的情況下一定要多寫代碼，我的建議是在理論比較深刻的知識點面前，比如面向對象，集合，線程這些知識，多看點理論，而對于html,css以及API方法比較多的知識點的情況下，多寫代碼。總之，各50%最好！當然，這就需要大家付出更多的時間和精力辛苦勤勞下了！其實java的學習還是要多練代碼，多思考，舉一反三，任何的知識點只要你認真的去做，沒有拿不下的頑石，勤能補拙，相信自己，然后用功，你就勝利了。
下面說一下面試技巧。
其實4個月是相當?shù)目欤凰查g而已，所以希望大家在還沒有學完的時候，就要有面試的準備，關于面試，一般企業(yè)也就那幾個步驟，筆試-面試，面試又包括技術面試和人事面試，人事面試基本不會有什么問題，關鍵就是技術面試，當然，如果大家有認真的學學習，筆試一般不會有什么問題，技術面試的話，一般都是項目經理之類的，會問到幾個技術問題，范圍也很廣，不知道他會問到什么，所以必須大家對于知識點的話都要有基本的掌握，當然會有幾個比較重點的知識 點，像集合，servlet，線程，其實重點也很多，這個大家后期可以參考面試的文檔，到時候老師會發(fā)給大家一些相關的文檔，當然自己也可以去下載一些相關的文檔，要強調一點的是數(shù)據(jù)庫必問！這個相當重要！前面也已經說了，所以希望一定要把數(shù)據(jù)庫學好！
下面為大家提供部分本人整理的筆記： String的核心方法：
字符串轉換整數(shù)：Integer.parseInt(字符串變量);整數(shù)轉換字符串：String.valueOf(整型變量)
日期轉字符串：new SimpleDateFormat().format(date類型)返回字符串元素的字符長度：length()方法
Int IndexOf(String a),在字符串元素中檢索a字符，返回第一個出現(xiàn)的下標位置。Int indexOf(String a,int fromIndex),從formIndex位置開始檢索字符串，找到之后的a字符。
Char charAt(int index):用于返回字符串index位置的字符.Substring(begin,end):返回子字符串
valueOf(Object):返回Object參數(shù)的字符串表示形式。toUpperCase():返回字符串的大寫形式。toLowerCase():返回小寫形式。
StringBuilder核心方法：
StringBuilder:性能好,非線程安全.Append(String s):追加字符串。
Insert(3,”String”)插入字符串
Delete(int start,int end):刪除字符串。
Replace(int start,int end, String s):替換字符串 Reverse():字符串反轉.集合核心方法：
Boolean isEmpty():判斷集合是否為空 Size():判斷集合里面元素的個數(shù)
Boolean Contains(Object):判斷集合元素中是否包含Object元素.Clear():清空集合。
Boolean Add(Object):向集合中添加元素，返回是否添加成功.Boolean remove(Object):從集合中刪除元素。Iterator iterator():迭代元素。
增強for循環(huán)：for(Point p:list):遍歷list，每次循環(huán)從list中取出一個元素賦值給p.List單獨的方法：
get(index):得到index下標的集合元素.Set(index,元素o):設置index處的元素為元素o，前面的元素將被覆蓋，并且方法返回的值是前面的元素。
Add(index,元素):在指定下標index添加元素 Remove(index):刪除指定下標的元素值
List:定義線性表數(shù)據(jù)結構.ArrayList:動態(tài)數(shù)組方式，適合隨機訪問對象.LinkedList:鏈表方式,適合于插入和刪除.subList():用于獲取子List,獲取的List與原List占有相同的存貯空間,操作會影響原List.List
以上方法都是本人從API里面選取的面試筆試必考的方法，這些方法大家完全可以去背熟，當然理解的去記更好了。這個還是需要大家自己親身去總結的！別人給不了你知識！知識還是自己去學去掌握！別人只能給你方法！別人可以寫出來給你，但是要完全理解并掌握還是要自己！授人與魚不如授人與漁！好了，本人要說的就是這些了。更多的精彩需要大家自己去發(fā)現(xiàn)！曾在網上看過幾個不錯的學習視頻，感興趣的可以進群了解下，群號是五一四，一六七，后面是六七八，連在一起就好了，真心可以學到東西！
第五篇：java開發(fā)技術總結
數(shù)據(jù)庫
oracle-->數(shù)據(jù)庫管理系統(tǒng)-->SQL、PL/SQL-->Java(JDBC+SQL)DBA,數(shù)據(jù)庫編程程序員 1.概念導論
1）什么是數(shù)據(jù)庫
有組織和結構存儲數(shù)據(jù)。可以存儲 字符、字節(jié)、圖形、圖像等類型數(shù)據(jù)
DB(數(shù)據(jù)庫):數(shù)據(jù)集合
DBMS(數(shù)據(jù)庫管理系統(tǒng))：對數(shù)據(jù)集合進行管理和操作的軟件
--Oracle
--DB2
--MySQL
--SQLSERVER
JDBC 1.什么是JDBC 全稱Java DataBase Connection,Java數(shù)據(jù)庫訪問。
JDBC是Java訪問數(shù)據(jù)庫的一項技術
JDBC是SUN推出的Java訪問數(shù)據(jù)庫的一套標準。由一系列接口構成。
各個數(shù)據(jù)庫廠商負責提供JDBC接口API的實現(xiàn)包。
開發(fā)者只需要掌握JDBC接口的使用,就可以實現(xiàn)對各種數(shù)據(jù)庫的操作，不需要了解開發(fā)商的實現(xiàn)類。
XML
1、什么是xml(xtendsible markup language可擴 展的標記語言)? 1)定義
基于文本的通用的數(shù)據(jù)保存格式。
(1)通用的點的坐標
Point類
point對象(x=10,y=20)
a,序列化
b,數(shù)據(jù)庫表
c,文件
...(2)數(shù)據(jù)格式
HTML 知識準備
1、分層：表現(xiàn)層：UI界面（DOS界面、桌面類型、web類型）
業(yè)務層：
數(shù)據(jù)層：文件、Oracle數(shù)據(jù)庫
2、Web類型的應用程序----B/S 類型
打開 Browser，輸入 URL，瀏覽器將請求發(fā)送到服務器
服務器得到請求，分析，返回響應
瀏覽器得到響應，解析（翻譯），顯示為頁面
3、web 學習階段
客戶端技術：HTML+CSS+Javascript---Web 基礎
服務器端技術：JSP、PHP、ASP.NET
4、web基礎的課程
HTML：頁面的創(chuàng)建
CSS：頁面的外觀
JavaScript：頁面的動態(tài)效果和交互行為--3 一：HTML 概述
1、超文本標記語言：一種編寫頁面的純文本的標記語言，文件以.html或者.htm 為后綴，依靠瀏覽器運行顯示----解釋性的語言
2、標記：一些用 <> 括起來的內容，特殊的顯示
3、主流瀏覽器：IE/Firefox/Chrome/
4、瀏覽器兼容性：符合標準規(guī)范，具體問題
CSS 一：CSS 概述
1、CSS：級聯(lián)樣式表（層疊樣式表）
2、特征：為頁面定義外觀的語言，實現(xiàn)內容和表現(xiàn)的分離，多個樣式可以合為一個，如果沖突，以優(yōu)先級為準
二：基礎語法
1、語法：
屬性名稱:值;屬性名稱:值;比如--color:red;
2、如何應用
方式一（內聯(lián)方式）：<元素 style=“" />---將樣式直接定義在元素的 style 屬性里
方式二（內部樣式表）：在頁面的 head 里的 style 里定義樣式
方式三（外部樣式表）：定義一個單獨的.css的文件（定義樣式）；然后，在頁面的 head 里用 link 引入---推薦方式
3、外部樣式表的優(yōu)點：實現(xiàn)內容和表現(xiàn)的分離，提高代碼的可重用性和可維護性
---可以準備多套樣式---換皮膚/主題
4、樣式表，如果重復定義
a、樣式不同，取并集
b、相同，按照優(yōu)先級
內聯(lián) > 內部或者外部
c、相同優(yōu)先級下，以最后定義的為準
javascript 一：javascript 概述
1、什么是 javascript：一種基于對象和事件驅動的解釋性腳本語言，嵌入到網頁上
2、歷史：js代碼---W3C定義了標準規(guī)范的 js 代碼
3、瀏覽器兼容問題：標準代碼，個別情況個別對待
4、怎么寫
方式一：直接寫在事件里，僅限于代碼很少
方式二：寫在 head 的 script 里，僅限于當前頁面重用
方式三：寫在 js 文件里，html 頁面的head 里用 script 引入
5、js的特征53………………………………………………..一種解釋性的腳本語言，適用于為網頁添加動態(tài)效果和交互行為
6、錯誤：
二：基礎語法
1、寫法：以 ；結束，大小寫敏感
名
2、標識符：以字母、數(shù)字和下劃線還有 $組成，不以數(shù)字開頭---不能和系統(tǒng)關鍵字重
3、變量 ***----聲明變量，以 var 開始
var i = 1;var s = ”mary“;var b = true;js是一種弱類型的語言---變量聲明時不需要確定類型，數(shù)據(jù)類型以賦值為準
4、數(shù)據(jù)類型
簡單類型：string、number、bool 特殊類型：null、undefined
var i;
alert(i);---undefined 復雜類型：對象
5、（string）字符串類型
var s = ”mary“;var s = 'mary';
特殊字符：使用轉義---轉換為普通字符，解決漢字的問題
”hello'w“ornld” alert(“一”);alert(“u4e00”);[u4e00-u9fa5]
6、number：并不區(qū)分整數(shù)和小數(shù)
var n = 12;var n1 = 12.34;
7、bool：true（1）和 false（0）
8、數(shù)據(jù)類型之間的轉換
var n = 18;var name = “mary”;隱式轉換（直接）
string + number--
number + bool--
bool + bool--
string + bool--
顯式轉換（調用方法）*** xxx.toString()parseInt(xxx);parseFloat(xxx);--確實能轉，如果不能轉，將返回 NaN
NaN---not a number 判斷
isNaN(“aaa”)--is not a number--返回 bool
9、運算符
算術運算符、比較、邏輯、位。。
特殊一：***
=== 嚴格相等：值和類型
if(a == b)
if(a === b)servlet １、web開發(fā)的背景知識(了解)b/s架構:
特點:
客戶端使用瀏覽器，服務器端使用web服務器，客戶端與服務器端使用標準化的http協(xié)議來進行通信。
優(yōu)點：
與c/s架構相比，有兩個優(yōu)點：
a,客戶端不需要單獨安裝
b,開發(fā)相對簡單(因為c/s架構需要自定義協(xié)議，開發(fā)相應的 通信模塊，而b/s使用標準化的http協(xié)議，瀏覽器與 web服務器都提供了相應的通信模塊)。
2、什么是servlet? sun公司制訂的一種用來擴展web服務器功能的組件規(guī)范。
(1)擴展web服務器功能
早期的web服務器(iis,apache ws等等)，只能夠處理靜態(tài)
資源的請求(即需要事先將html文件寫好并保存到web服務器
相應的文件夾下面)，不能夠處理動態(tài)資源的請求(即需要進行
計算，然后生成相應的html)。
a,可以使用cgi程序來擴展。
cgi程序可以使用c/c++,perl等語言來開發(fā)，但是，程序比較復雜，而且可移值性不好，性能也比較差，現(xiàn)在用得不多。
b,servlet可以擴展這些web服務器的功能。
瀏覽器發(fā)送請求給web服務器(apache ws)，web服務器
檢查請求是否需要計算，如果需要，web服務器會訪問
servlet容器，servlet容器會調用servlet來進行計算。
(2)組件規(guī)范
1)什么是組件?
符合一定規(guī)范，實現(xiàn)部分功能，并且需要部署到
相應的容器里面才能運行的軟件模塊。
2)什么是容器?
符合一定規(guī)范，為組件提供運行環(huán)境及相應服務的 程序。
3、如何開發(fā)一個servlet? step1,先寫一個java類，實現(xiàn)Servlet接口或者繼承
HttpServlet類(一般會使用繼承的方式)。
step2,編譯
step3,打包(創(chuàng)建一個具有如下結構的文件夾)
appname(應用名稱)
WEB-INF
classes(放.class文件)
lib(可選,放.jar文件)
web.xml(部署描述文件)step4,部署
將step3創(chuàng)建好的文件夾拷貝到servlet容器指定的 某個文件夾下面(比如，如果容器是tomcat,可以拷貝到
webapps文件夾下面)。
注意：也可以使用jar命令將step3創(chuàng)建好的文件夾
壓縮成一個以“.war”為后綴的文件，然后拷貝。
step5,啟動servlet容器，訪問servlet
http://ip:port/appname/servlet-url
6、servlet是如何運行的? 比如，在瀏覽器地址欄輸入
http://ip:port/web01/hello
step1,瀏覽器依據(jù)ip,port建立與servlet容器(容器同時 也是一個簡單的web服務器)之間的連接。
step2,瀏覽器將請求數(shù)據(jù)打包(按照http協(xié)議,該數(shù)據(jù)包 也稱為請求數(shù)據(jù)包)。
step3,瀏覽器發(fā)送請求數(shù)據(jù)包給容器。
step4,容器收到請求數(shù)據(jù)包之后，解析該數(shù)據(jù)包，并將
解析之后得到的數(shù)據(jù)封裝到request(請求數(shù)據(jù)包)對象上，同時，容器 還要創(chuàng)建response對象。
step5,容器要依據(jù)請求資源路徑(“/web01/hello”)找到 servlet的配置，然后創(chuàng)建servlet對象。
step6,容器調用servlet對象的service方法。容器會將事先 創(chuàng)建好的request,response作為參數(shù)傳遞給service方法。step7,在service方法里面，可以通過request對象獲得
請求參數(shù)，并進行相應的處理，處理結果會放到response對象 里面。
step8,容器從response對象中取出處理結果，然后打包(按照http協(xié)議，該數(shù)據(jù)包稱之為響應數(shù)據(jù)包)。然后將 響應數(shù)據(jù)包發(fā)送給瀏覽器。
step9,瀏覽器收到響應數(shù)據(jù)包之后，解析處理結果，然后生成 相應的頁面。
http://localhost:8080/web01/hello?uname=jetty ?后是請求參數(shù)，其中uname是參數(shù)名,jetty是參數(shù)值。
JSP
1、什么是jsp(java server page java服務器端頁面技術)? 1)定義
sun公司制訂的一種服務器端動態(tài)頁面生成技術規(guī)范。
2)理解
a,因為直接使用servlet,雖然也可以生成動態(tài)頁面，但是比較繁瑣(需要使用out.println語句),并且維護困難
(如果頁面發(fā)生改變，必須修改java代碼),所以，sun 在servlet規(guī)范制訂之后，又添加了jsp規(guī)范。
b,jsp其實就是一個以“.jsp”為后綴的文本文件，該文件會被容器(比如tomcat)轉換成一個servlet。
2、如何寫一個jsp文件? step1,寫一個以“.jsp”為后綴的文件。step2,在該文件里面，可以添加如下的內容:
1)html(css,javascript)
直接寫即可(不用out.println)
2)java代碼
a, java代碼片斷
<% java代碼;
%>
b, jsp表達式
<%= java表達式 %>
3)指令
a,什么是指令?
告訴容器，在容器將.jsp文件轉換成.java文件時
做一些額外的處理，比如導包。
b,基本語法
<%@指令名稱 屬性名稱=屬性值 %>
c,page指令
import屬性：導包，比如
<%@page import=“java.util.*”%>
<%@page import=“java.util.*,java.text.*”%>
contentType屬性：設置
response.setContentType的內容，比如
<%@page contentType=“text/html;charset=utf-8”%>
pageEncoding屬性：告訴容器jsp文件的編碼。
因為容器需要讀jsp文件的內容(也就是
說，需要解碼,某些容器，如果沒有該
屬性，默認情況下會按照iso-8859-1
去解碼，會產生亂碼問題)。
4)隱含對象
a,什么是隱含對象?
在jsp文件里面可以直接使用的對象，比如
out,request,response。
b,為什么可以直接使用這些隱含對象?
因為容器會自動添加創(chuàng)建這些對象的語句。
3、jsp是如何運行的? step1,容器要將.jsp文件轉換成.java文件(其實就是
一個servlet類)。
a, html(css,javascript)--->
在service方法里，使用out.write輸出。
(out.write方法會將null轉換成“"輸出)
b,<%
%>
----->
在service方法里，照搬。
c, <%=
%>
----->
在service方法里，使用out.print輸出。
step2,容器調用servlet來處理請求。
4、轉發(fā)
(1)什么是轉發(fā)?
一個web組件(servlet/jsp)將未完成的處理通過
容器交給另外一個web組件繼續(xù)完成。
最常見的情況:
一個servlet獲得數(shù)據(jù)，然后轉發(fā)給一個jsp來展現(xiàn)
這些數(shù)據(jù)。
(2)如何轉發(fā)?
step1,綁訂數(shù)據(jù)到request對象上。
request.setAttribute(String name,Object value);
說明:
name:綁訂名稱
value:綁訂值 step2,獲得轉發(fā)器
RequestDispatcher rd =
request.getRequestDispatcher(String uri);
說明:
url : 轉發(fā)的目的地 step3,轉發(fā)
rd.forward(request,response);request對象的其它和綁訂相關的方法: 依據(jù)綁訂名稱找到綁訂值，如果找不到對應的值，返回null。
Object request.getAttribute(String name);
解除綁訂
request.removeAttribute(String name)(3)轉發(fā)的特點
a,轉發(fā)之后，瀏覽器地址欄的地址不變。
b,轉發(fā)的目的地必須是同一個應用內部某個
web組件的地址。
Ajax
1、ajax是什么?(asynchronous javascript and xml 異步的javascript 和xml)
ajax是一種用來改善用戶體驗的技術，其實質是
利用瀏覽器提供的一個特殊的對象(XMLHttpRequest 對象，一般稱之為ajax對象)異步地(當ajax對象向
服務器發(fā)請求時，瀏覽器不會銷毀當前頁面，用戶
仍然可以對當前頁面做其它的操作)向服務器發(fā)送請求。服務器返回的數(shù)據(jù)不再是一個完整的新的頁面，而是部分數(shù)據(jù)，利用這些數(shù)據(jù)，更新當前頁面。整個
過程，頁面無刷新，不打斷用戶的操作。
2、如何獲得ajax對象?
XMLHttpRequest沒有標準化，要區(qū)分瀏覽器。
function getXhr(){
var xhr = null;
if(window.XMLHttpRequest){
} //非ie瀏覽器
xhr = new XMLHttpRequest();}else{ //ie瀏覽器
xhr = new ActiveXObject('MicroSoft.XMLHttp');} return xhr;
4、編程步驟
step1,獲得ajax對象。
比如:
var xhr = getXhr();
step2,使用ajax對象發(fā)請求。
1)發(fā)送get請求
xhr.open('get', 'check_username.do?username=tom',true);xhr.onreadystatechange=f1;xhr.send(null);注意:
true:發(fā)送異步請求(ajax對象發(fā)請求時，瀏覽器不會銷毀當前頁面，用戶仍然可以
做其它操作)。
false:發(fā)送同步請求(ajax對象發(fā)請求時，瀏覽器不會銷毀當前頁面,瀏覽器會鎖定
當前頁面，用戶不能操作當前頁面)。step3,編寫服務器端的處理代碼，一般不再需要返回
一個完整的頁面，只需要返回部分數(shù)據(jù)。step4,編寫事件處理函數(shù)
function f1(){
if(xhr.readyState == 4){
var txt = xhr.responseText;
更新當前頁面
}
} jQuery
1、jQuery介紹 www.tmdps.cn
(1)特點
利用選擇器查找要操作的節(jié)點，并且會將這些節(jié)點
封裝成一個jQuery對象。通過調用jQuery對象的屬性
或者方法來實現(xiàn)對底層節(jié)點的操作，這樣做的好處有
兩個：一是兼容性更好了，另外，代碼得到簡化。
(2)編程步驟
step1,使用jQuery選擇器查找要操作的節(jié)點。
step2,調用jQuery對象的方法或者屬性。
(3)一個簡單例子 first.html(4)jQuery對象與dom對象如何相互轉換?
1)dom對象---> jQuery對象
$(dom對象)
2)jQuery對象---> dom對象
2、選擇器
(1)選擇器是什么?
jQuery借鑒了css選擇器的語法，用來查找要操作的節(jié)點。
(2)基本選擇器
selector / s1.html
#id
.class
element
select1,select2..selectn
*(3)層次選擇器
selector / s2.html
select1 select2:查找所有的后代
select1>select2:只查找子節(jié)點
select1+select2:下一個兄弟
select1~select2:下面所有兄弟
(4)過濾選擇器
1)基本過濾選擇器
selector / s3.html
:first
:last
:not(select)排除滿足select要求的節(jié)點 :even :odd :eq(index):gt(index):lt(index)2)內容過濾選擇器
selector / s4.html :contains(text)匹配包含給定文本的元素
:empty 匹配所有不包含子元素或者文本的空元素
:has(select)匹配含有選擇器所匹配的元素的元素
:parent 匹配含有子元素或者文本的元素 3)可見性過濾選擇器 selector / s5.html :hidden 匹配所有不可見元素，或者type為hidden的元素
:visible 匹配所有的可見元素 4)屬性過濾選擇器 selector / s6.html [attribute] [attribute=value] [attribute!=value] 5)子元素過濾選擇器
selector / s7.html :nth-child(index/even/odd)
注意： 下標從1開始。
6)表單對象屬性過濾選擇器 selector / s8.html
:enabled
:disabled
:checked
:selected(5)表單選擇器
:input :text
:pasword :radio :checkbox :submit :image :reset :button :file :hidden
3、dom 1)查詢
dom / d1.html
找到節(jié)點之后，可以讀取或者修改節(jié)點的html內容,文本,值,屬性。
a, html()讀取或者修改節(jié)點的html內容
b, text()讀取或者修改節(jié)點的文本內容
c, val()
讀取或者修改節(jié)點的值
d, attr()讀取或者修改節(jié)點的屬性
2)創(chuàng)建
dom / d2.html
$(html);3)插入節(jié)點
append():作為最后一個孩子添加進來。
prepend():作為第一個孩子添加進來。
after():作為下一個兄弟
before():作為上一個兄弟 4)刪除節(jié)點
dom / d3.html remove()remove(selector)empty():清空節(jié)點
5)數(shù)據(jù)與行為分離 dom / d4.html d5.html 即不用修改html文件，通過引入外部的js文件來 為頁面提供動態(tài)效果。
$(fn);fn是一個函數(shù)的名稱
或者
$(function(){
//當整個頁面加載完畢，會執(zhí)行這兒的代碼。
});6)復制節(jié)點 dom / d6.html clone()clone(true):使復制的節(jié)點也具有行為(將事件
處理代碼一塊復制)7)屬性操作
讀取：attr('id');設置： attr('id','d1')或者一次
設置多個 attr({”id“:”d1“,”class“:”s1“});刪除：removeAttr('id')8)樣式操作 dom / d7.html 獲取和設置: attr(”class“,”“)attr(”style“,”“)追加:addClass('')移除:removeClass('')
或者removeClass('s1 s2')
或者removeClass()//會刪除所有樣式
切換樣式：toggleClass,有該樣式，就刪除，沒有，就添加。
是否有某個樣式 hasClass('')讀取css('')設置css('','')或者
css({'':'','':''})//設置多個樣式 9)遍歷節(jié)點 dom / d8.html children()/children(select):只考慮子元素，不考慮其它后代元素。
next()/next(select):下一個兄弟
prev()/prev(select):上一個兄弟
siblings()/siblings(select):其它兄弟
find(select):從當前節(jié)點向下查找所有的后代
(滿足select要求的)parent():父節(jié)點
struts
1、什么是Struts? Struts是基于MVC的輕量級框架，主要處理請求分發(fā)的問題，重心在控制層和表現(xiàn)層。
--基于MVC：實現(xiàn)了MVC，滿足MVC的設計思想。
--輕量：侵入性低，是我們業(yè)務代碼對框架的依賴程度很小，既很少需要import Struts包。
--框架：基礎的代碼，引入之后可以減少我們的開發(fā)工作量，提高開發(fā)效率。
2、為什么用Struts? 1）對比Servlet
--Servlet優(yōu)缺點
優(yōu)點：直接、效率高
缺點：業(yè)務代碼耦合度高，不便于維護
--Struts優(yōu)缺點
優(yōu)點：將業(yè)務代碼解藕，便于維護
缺點：效率低
--Servlet中的MVC與Struts中的MVC，參考圖理解
2）對比其他框架
--健壯性(4*)：穩(wěn)定程度
--易用性(4*)：好學、好用
--擴展性(5*)：就軟件未來而言，將來有更復雜的需求時，是否有處理方式。
--侵入性(4*)：與依賴性/耦合度成正比
3、Struts發(fā)展史
1）Struts1，結構簡單、易用，由Apache推出。
與Servlet/JSP耦合緊密，導致發(fā)展受限。
2）WebWork，技術先進，核心是XWork。
3）Struts2，基于XWork，在此基礎上發(fā)展形成。
面試題：Struts1和Struts2的區(qū)別和聯(lián)系？
--Struts2與Struts1差別很大，不能理解為Struts1
的升級版本。
--Struts2以XWork為核心，可以理解為WebWork
的升級版本。
*
4、Struts2使用步驟,HelloWorld--使用版本Struts2.1.8 1）創(chuàng)建web項目
2）導包
3）配置前端控制器(filter)
--在web.xml中配置filter
--控制請求分發(fā)的控制器
4）創(chuàng)建struts.xml--放在src根路徑
--名稱必須是struts.xml 5）*創(chuàng)建Action--控制業(yè)務流程的控制器 6）*創(chuàng)建JSP 7）*配置struts.xml--體現(xiàn)請求和Action的關系
--體現(xiàn)Action和JSP的關系
*
5、擴展HelloWorld 目標：掌握Action與JSP頁面數(shù)據(jù)交換的方式。
1）Action如何向頁面發(fā)送數(shù)據(jù)？
--通過EL表達式
2）*Action如何從頁面接收數(shù)據(jù)？
--注入：調用JavaBean的set方法，為其屬性賦值的行為稱之為注入。
*a、基礎屬性注入
--Action中定義基本類型的屬性，給它set方法
--表單中，文本框的name=”屬性名“
--表單提交時，Struts2會自動將表單的內容，傳遞給Action里的屬性。
--Struts2會自動初始化屬性
--注意：Action跳轉的頁面，EL表達式${屬性名}
*b、域模型注入
--Action中定義JavaBean類型的屬性，給他set方法
--表單中，文本框的name=”對象名.屬性名“
--表單提交時，Struts2會自動將表單的內容，傳遞給Action里定義的對象
--Struts2會自動的初始化對象
--注意：Action跳轉的頁面，EL表達式${對象名.屬性名}
c、模型驅動注入(了解即可)
--需要Action實現(xiàn)接口ModelDriven
*
6、使用Struts2實現(xiàn)NetCTOSS中的資費列表
--準備：分析需求、了解表結構、建表
1）創(chuàng)建web項目
2）導包
3）前端控制器(filter)4）創(chuàng)建struts.xml 5）創(chuàng)建Action
-->filter->struts.xml->Action
-->DAO-->DBUtil,Entity a、Entity b、DBUtil c、DAO d、Action 6）JSP 7）配置struts.xml Hibernate
1、什么是Hibernate 1）Hibernate是數(shù)據(jù)訪問層的框架，對JDBC進行了
封裝，是針對數(shù)據(jù)訪問層的面向對象的解決方案。
2）Hibernate允許我們直接訪問對象，然后將訪問
自動轉化為SQL去執(zhí)行，從而達到間接訪問數(shù)據(jù)庫
的目的，簡化代碼開發(fā)，提升開發(fā)效率。
2、為什么使用Hibernate 1）使用JDBC開發(fā)出現(xiàn)的問題
--需要在代碼中寫大量的SQL
--需要給大量的？賦值
--需要將結果集轉換為實體對象
--在SQL中可能會寫數(shù)據(jù)庫特定的函數(shù)，移植性差。
2）使用Hibernate可以解決上面的問題
--基本上不需要寫SQL，因為Hibernate可以
自動生成SQL并執(zhí)行
--可以自動給？賦值
--可以自動將結果集轉換為實體對象
--Hibernate提供通用的API來訪問不同的數(shù)據(jù)庫，移植性好。
3）補充JDBC與Hibernate的優(yōu)缺點
a、JDBC優(yōu)點：
效率高
b、Hibernate缺點：
效率相對于JDBC要低
*
3、Hibernate的設計原理
1）Hibernate是采用了ORM的思想，對JDBC進行的 封裝。
2）ORM：Object Relation Mapping，即對象關系
映射，指的是Java對象和關系數(shù)據(jù)庫的映射。
--之前使用JDBC開發(fā)時，需要知道數(shù)據(jù)庫表和實體
對象的關系，以及字段和對象屬性的關系，比如
需要知道COST表和Cost對象的關系。那么這種 關系我們之前是手動維護的，比如： cost.setName(rs.getString(”name“));ps.setString(2,cost.getName());--ORM思想是希望將這種關系的維護提煉出來，用一個公共的組件描述，那么在我們訪問數(shù)據(jù)庫
時，需要使用這種關系時，可以復用基于ORM 思想提煉出來的關系
--正是由于存在這樣通用關系的描述，Hibernate 才可以讓我們直接訪問Java對象，從而通過
關系轉換成SQL自動執(zhí)行。
--Hibernate中將這種關系定義在XML配置文件中。
4、Hibernate體系結構
1）hibernate.cfg.xml
是Hibernate的主配置文件，用于配置數(shù)據(jù)庫連接
參數(shù)，以及Hibernate框架參數(shù)。
2）實體類
是Java類型，用于封裝表中的數(shù)據(jù)
3）xxx.hbm.xml
是關系映射文件，用于配置表與實體類的關系，以及表中字段與類中屬性的關系。
4）Hibernate底層API
主要是用于解析主配置文件，以及關系映射文件，然后根據(jù)關系自動生成SQL并執(zhí)行。
5、Hibernate常用API 1）Configuration
用于解析主配置文件的2）SessionFactory
用于創(chuàng)建Session的3）Session
是數(shù)據(jù)庫連接會話，相當于是數(shù)據(jù)庫連接。
注意：此Session和HttpSession沒有任何關系。
4）Transaction
用于控制事務
5）Query
用于做特殊查詢
*
6、Hibernate使用步驟
1）導包
2）引入主配置文件hibernate.cfg.xml 3）創(chuàng)建實體類Emp 4）*創(chuàng)建關系映射文件Emp.hbm.xml
--該配置文件必須和實體類同名
--該配置文件必須和實體類位于同一個包下
--在主配置文件中引入該關系映射文件
5）使用Hibernate的API，來進行增、刪、改、查
Spring 1.什么是Spring，有什么作用
Spring框架屬于一個解決方案框架 可以對其他技術和框架進行整合 應用。
*好處是：將程序中的各個組件和 框架技術進行解耦，便于日后系統(tǒng) 維護，升級和擴展操作。
在SSH中，會將Action,DAO組件都 交給Spring框架管理，由Spring 框架創(chuàng)建這些對象，建立這些對象 關聯(lián)。
*2.Spring都含有哪些功能
--可以創(chuàng)建和管理程序組件對象
(相當于工廠的作用)--提供了IoC機制實現(xiàn)組件對象關系的解耦
--提供了AoP機制實現(xiàn)共通組件低耦合的調用。
(例如事務處理)--提供了對其他技術,例如JDBC，Hibernate,Struts等框架整合API--提供了一個Spring MVC框架實現(xiàn)
*3.Spring基本使用
1)創(chuàng)建和管理程序組件對象
--引入Spring IOC開發(fā)包
--在src下添加Spring配置文件
--將Bean組件定義到Spring配置
文件中
--(編碼)實例化Spring容器對象
利用getBean獲取Bean對象實例
*a.控制Bean對象創(chuàng)建模式
在使用時，可以在
scope=”singleton“表示單例模式(默認值)scope=”prototype“表示原型模式，每次調用getBean都返回一個新的 Bean對象。
b.控制Bean對象創(chuàng)建時機
scope=”singleton“時，Bean對象 是在容器實例化時創(chuàng)建。
在
scope=”prototype“時，Bean對象 是在getBean方法時創(chuàng)建。
c.追加初始化和銷毀方法
在
同理destroy-method=”mydestroy“ 在容器銷毀時，也釋放單例的Bean 對象,此時會自動調用mydesctory 方法。(該屬性僅適用于singleton 模式的Bean對象)
2)Spring的核心IoC容器
a.IoC概念
Inversion of Control 控制反轉 或反向控制（控制轉移）
2004 Martin fowler提出的IoC思想.IoC思想：兩個組件之間調用(例如A調用B)原有方式是A負責創(chuàng)建B對象；現(xiàn)在變成了 B對象由第三方框架或容器負責實例化，然后給A對象注入。即A對象獲取B對象的 方式發(fā)生了反轉。
IoC技術方案有兩種：依賴注入和依賴查找 Spring采用依賴注入技術實現(xiàn)IoC控制。依賴技術主要以下兩種方式：--set方式注入(推薦)在A中定義setB(B b),接收傳進來的B對象--構造方式注入 在A中定義構造方法 public A(B b){}
DI:Dependency Injection依賴注入
b.IoC使用方法
--編寫Action,定義到Spring配置中
--編寫DAO,定義到Spring配置中
--在Action中定義DAO接口類型變量和
setter方法
--在Action的
配置
ref=”要注入的Bean對象id值">
點擊咨詢 