java:使用Eclipse開發java程序

集成開發環境(IDE)是一類軟件將程序開發環境和程序調試環境集合在一起,提高開發效率
1.創建java項目
2.創建程序包(一般為域名的反向如hell.com則為com.hello)
3.編寫Java源程序
4.運行Java程序
第一步我們創建一個Java項目,第二步我們在Java項目的SRC下創建了一個包,第三步我們在包里面創建一個類并且編寫JAVA程序最后運行這個程序。
main():main()方法程序的入口比如拿鑰匙開門一樣不能從窗戶進去,這里的main()方法就是程序的入口.

Java中的關鍵字：
abstract boolean break byte case catch char class continue default do double else
extends false final finaly float for if implements import instanceof int interface long
native new null package private protected public return short static super switch synchronized
this throw throws transient true try void volatile while(區分大小寫如void是關鍵字但是Void就不是)

java標識符:
標識符就是用于給java程序中變量、類、方法等命名的符號。
使用標識符時,需要遵守幾條規則:
1.標識符可以由字母、數字、下劃線、美元符($)組成,但不能包含@、%、空格等其他字符,不能以數字開頭。譬如:123name就是不合法的
2.標識符不能是java關鍵字和保留字(java預留的關鍵字,以后的升級版本中可能作為關鍵字),但可以包含關鍵字和保留字。如:不可能使用void作為標識符,但是MYvoid是可以的
3.標識符時嚴格區分大小寫的.所以呢，一定要區分imooc和IMooc是兩個不同的標識符。
4.標識符的命名最好能反映出其作用,做到見名知意.

變量:
Java中通過變量類型、變量名、變量值這三個元素來描述變量

如何命名java變量
給變量取名字需要遵守一定規則

首字母 其余部分1.字母 任意多的:變量名=2.下劃線'_' + 1.數字3.'$'符號 2.字母3.下劃線'_'4.'$'符號

正確示范：
String myname=“tom”;
String _love=“imooc”;
String $hobby2=“lol”;
錯誤示范:
String 3hobby=“wow”;(不能以數字開頭)
String %sex=“男”;(不能以下劃線和美元符之外的其他特殊字符開頭)
String private=“www.imooc.com”;(不能使用java關鍵字)

java編程習慣:
1.變量名由多個單詞組成時，第一個單詞的首字母小寫，其后首字母大寫，俗稱駝峰式命名法，如myAge
2.變量命名時，盡量簡短且能清楚地表達變量的作用，做到見名知意。如:定義變量名stuName保存"學生姓名"信息
PS：java變量名的長度沒有限制，但是java語言是區分大小寫的，所以price和Price是兩個完全不同的變量

Java中的數據類型
java語言是一種強類型語言。java中存儲的數據都是有類型的，而且必須在編譯時就確定其類型。
java中有兩類數據類型;
1.整數類型（byte、short、int、long）
1.數值型2.浮點類型（float、double）
基本數據類型 2.字符型（char）
3.布爾型（boolean）

數據類型
1.類（class）
2.接口（interface）
引用數據類型 3.數組

在java中基本數據類型變量存的是數據本身，而引用數據類型變量存的是保存數據的空間地址
通俗而言基本數據類型存儲的是放在抽屜里的東西而引用數據類型則是存儲打開這個抽屜的鑰匙 抽屜鑰匙一一對應

常用的基本數據類型有:
int 整型 4byte 用于存儲整數，如年齡，個數 int age=21；
double 雙精度浮點型 8byte 用于存儲小數，如商品價格、成績平均分 double price=15.5；
float 單精度浮點型 4byte 用于存儲小數如身高 float height=175.2f；
char 字符型 2byte 用于存儲單個字符，如性別’男’、‘女’ char sex=‘男’；
boolean 布爾型 1byte 表示“真”或“假”，取值只能為 true或flase boolean flag=true；

String 是一種常見的引用數據類型，用來表示字符串。在程序開發中，很多操作都要使用字符串來完成，例如系統中的用戶名、密碼、電子郵箱等。

java中變量的使用規則
1.java中的變量需要先聲明后使用
2.變量使用時，可以聲明變量的同時進行初始化，也可以先聲明后賦值。
3.變量中每次只能賦一個值，但是可以修改多次。
4.main方法中定義的變量必須先賦值，然后才能輸出。

java中的自動類型轉換
不同的基本數據類型之間是需要進行相互轉換的
如:?int score1=82;
double score2=score1;
System.out.println(score2);
代碼中將int類型score1賦值給score2并且轉換為double類型。
1.目標類型與源類型兼容，如double 型兼容int型，但是char型不能兼容int型
2.目標型大于源類型，如double類型長度為8字節，int類型為4字節，因此double類型的變量里直接可以存放int類型的數據，但是反過來就不可以了。

java中的強制類型轉換
java強制類型轉換語法
double avg1=78.5；
int vag2=（int）avg1；
System.out.println（avg1）；
System.out.println（avg2）；
此時就強制把double類型轉換成int類型。PS（強制類型容易造成數據丟失所以需要謹慎使用,

java常量的應用
所謂常量可以理解為是一種特殊的變量在程序運行過程中不允許被改變。
語法：final 常量名 =值；
java中注釋的使用
java中有三種注釋類型：單行，多行，文檔三種注釋
/** /文檔注釋
/ */多行注釋
// 單行注釋

@author 標明開發該類模塊的作者 @version 標明該類模塊的版本 @see 參考轉向，也就是相關主題 @param 對方法中某參數的說明 @return 對方法返回值的說明

@exception 對方法可能拋出的異常進行說明

什么是運算符
運算符是一種“功能”符號，用以通知java進行相關的運算。如我們需要將變量age的值設置為20，這時則需要一個“=”號來將其連接告訴程序需要進行的輔助操作。
java語言中常用的運算符可以分為如下幾種；
1.算術運算符
2.賦值運算符
3.比較運算符
4.邏輯運算符
5.條件運算符

java中的算術運算符
算術運算符主要用于基本的算術運算，如加法、減法、乘法、除法、等。
java中常用的算術運算符：

• 加法 5+12=17

• 減法 25-10=15

• 乘法 3*8=24

/ 除法 24/6=4
% 求余 24%7=3
++ 自增1 int i=5；i++
– 自減1 int i=5；i–
3 其中++和–既可以出現在操作數的左邊，也可以出現在右邊，但結果是不同的

java中的賦值運算符

= 賦值 c=a+b將把a+b得到的值賦給c
+= 加等于 c+=a等價于c=c+a
-= 減等于 c-=a等價于c=c-a
= 乘等于 c=a等價于c=a*c
/= 除等于 c/=a等價于c=c/a
%= 模等于 c%=a等價于c=c%a

java中的比較運算符
比較運算符用于判斷兩個數據的大小，例如:大于、等于、不等于。比較的結果是一個布爾值（true或false）。

< >= <= == !=

1.>、<、>=、<=只支持左右兩邊操作數是數值類型
2.==、!=兩邊的操作數既可以是數值類型也可以是引用類型
java中的邏輯運算符
&& 與 a&&b 如果a與b都為true,則返回true；
|| 或 a!!b 如果a與b任一個為true，則返回true
! 非 !a 如果a為false,則返回true，即取反
^ 異或 a^b 如果a與b有僅有一個為true，則返回true

java中的條件運算符
條件運算符（？：）也稱為“三元運算符”。
語法形式:布爾表達式?表達式1:表達式2;
運算過程:如果布爾表達式的值為true,則返回表達式1的值,否則返回表達式2的值
例如:
String str=(8>5)?“8大于5”:“8不大于5”;
System.out.println(str);
因為表達式的值8>5所以返回的值為8大于5；

java中運算符的優先級 所謂優先級，就是在表達式的運算過程中的先后順序。java中常用的運算優先級如下所示：

1 （）
2 ！+（正） -（負）++ ——
3 */%
4 +（加）-（減）
5 < <= > >=
6 == !=
7 ^
8 &&
9 ||
10 ?:
11 = += -= *= /= %=
級別為1的優先級最高，11的優先級最低。

java條件語句之if
if（條件）{
條件成立時執行的代碼
}

java條件語句之if…else
語法
if（條件的布爾表達行）{
代碼塊1
}else{
代碼塊2
}
執行過程:當if中的條件滿足時則執行代碼塊1，否則執行代碼塊2；和if相比 if…else不管條件是否滿足都會執行一條語句；

java條件語句之多重if
語法：
if（條件1）{
代碼塊1
}else if（條件2）{
代碼塊2
}else{
代碼塊3
}
執行過程：先判斷條件1如果滿足則執行代碼1，否則繼續判斷條件2，如果條件2滿足則輸出代碼塊2，否則輸出代碼塊3，與前兩者相比較這個會多判斷一次。

java條件語句之嵌套if
嵌套if語句，只有當外層if的條件成立時，才會判斷內層if的條件。
if（條件1）{
if(條件2){
代碼塊1
}else{
代碼塊2
}
}else{
代碼塊3
}

equals()用于判斷字符串的內容是否相同，相同則返回true，反之則返回false；

java條件語句之switch
語法:
switch(表達式){
case 值1:
執行代碼塊1
break;
case 值2:
執行代碼塊2
break;
case 值n:
執行代碼塊n
break;
default:
默認執行的代碼
}
執行過程:當switch后表達式的值和case語句后的值相同時，從該位置開始向下執行，直到遇到break語句或者switch語句塊結束;如果沒有匹配的case語句則執行default塊的代碼。
PS:
1.switch后面的小括號中表達式的值必須是整型或字符型
2.case后面的值可以是常量數值，如1.2.;也可以是一個常量表達式，如2+2；但是不能是變量或帶有變量的表達式，如a*2
3.case匹配后，執行匹配快里的程序代碼，如果沒有遇到break會執行下一個的case塊的內容，直到遇到break語句或者switch語句塊結束。

java循環語句之while
java中常用的3中循環:while、do…while、for
while循環：
語法：
while(判斷條件){
循環操作
}
執行過程:
<1>:判斷while后面的條件是否成立(true/false)
<2>:當條件成立時，執行循環內的操作代碼，然后重復執行<1>,<2>，直到循環條件不成立為止
特點:先判斷，后執行
do…while
do…while循環與while循環語法有些類似，但是執行過程差別比較大。
語法:
do{
循環操作
}while(判斷條件);
執行過程：
<1>:先執行一遍程序，然后判斷條件是否成立
<2>:如果條件成立，繼續執行<1>,<2>直到循環條件不成立為止
特點:先執行，后判斷
由此可見，do…while語句保證循環至少被執行一次！

for循環
Java中的三種循環可以相互替換
語法:
for(循環變量初始化;循環條件;循環變量變化){
循環操作
}
執行過程:
<1>、執行循環變量初始化部分，設置循環的初始狀態，此部分在整個循環中只執行一次
<2>、進行循環條件的判斷，如果條件為true，則執行循環體內代碼，如果為false，則直接退出循環
<3>、執行循環變量變換部分，改變循環變量的值，以便進行下一次條件判斷
<4>、依次重新執行<2>、<3>、<4>，直到退出循環
特點:相比while和do…while語句結構更加簡潔易讀
PS:1.for關鍵字后面括號中的三個表達式必須用’；‘隔開，三個表達式可以省略但是’;‘不能省略。
省略’循環變化量初始化’，可以在for語句之前由賦值語句進行變量初始化。
省略’循環條件’，即可能會造成程序一直執行下去，也就是’死循環’現象
省略循環變量的變化部分，可以在循環體中進行循環變換的部分。
2.for循環變量初始化和循環變量變化部分，可以是使用’,'同時初始化或改變多個循環變量的值。如
for(int i=1,j=5;i<=5;i++,j–){
System.out.println(i+"+"+j+"="+(i+j));
}
java循環跳轉語句之break

java循環語句之continue continue的作用是跳過循環體中剩余的語句執行下一次循環。java循環語句之多重循環 循環體中包含循環語句的結構稱為多重循環。三種循環語句可以自身嵌套，也可以相互嵌套，最常見的就是二重循環，在二重循環中，外層循環每執行一次，內層循環要執行一圈。例子1: package com.vb;**** import java.util.Scanner;public class LX27 { public static void main(String[] args) { ***** Scanner input=new Scanner(System.in);//創建Scanner對象System.out.print("請輸入考試成績信息:"); ***** int score=input.nextInt();//獲取用戶輸入的成績并保存在變量中int count=0;System.out.println("加分前成績:"+score);for(;score<60;score++) {count++; }System.out.println("加分后成績:"+score);System.out.println("加分次數:"+count); }

}

這個例子展示了Scanner類的導入例子2 實現了三個班級的各4個學生的成績，并且求出了他們的平均分package com.vb;import java.util.Scanner;public class LX28 { public static void main(String[] args) {Scanner input=new Scanner(System.in);//創建Scanner對象int classNum=3;//班級數量int stuNum=4;//學生數量double sum=0;//成績總和double avg=0;//成績平均分for(int i=1;i<=classNum;i++) {//外層循環控制班級的數量System.out.println("請輸入第"+i+"個班級的成績");for(int j=1;j<=stuNum;j++) {//內層循環控制學生的數量System.out.print("第"+j+"個學生成績為");int score=input.nextInt();sum=sum+score;//成績累加總和}avg=sum/stuNum;//計算平均分System.out.println("第"+i+"個班級學生的平均分為:"+avg);sum=0;//成績清0}}

}
java之數組
數組可以理解為是一個巨大的“盒子”，里面可以按順序存放多個類型相同的數據，比如可以定義int型的數組scores存儲45名學生的成績
int[] scores={76,83,92,87};
數組里面每個值都有一個索引，索引從0開始；
例如可以通過scores[0]獲取數組中的第一個元素，scores[2]就可以獲取第三個元素。
如何使用java中的數組
java中操作數組只需要4步；
1.聲明數組
語法：數據類型[] 數組名；
或者 數據類型 數組名[];
其中，數組名可以是任意合法的變量名，如：
int[] scores；
double height[]；
String[] names;
2.分配空間
簡單來說就是指定數組中最多可存儲多少個元素
語法：數組名=new 數據類型[數組長度]；（其中數組長度就是數組中能存放元素的個數）如：
scores=new int[5];
height=new double[5];
names=new String[5];
上面聲明數組和分配空間可以合并如：
int[] scores=new int[5];
3.賦值
語法:
scores[0]=89;
scores[1]=79;
4.處理數組中數據
java中還提供了另外一種直接創建數組的方式，它將聲明數組，分配空間和賦值合并完成，如
int[] scores={78,91,84,68};他等價于:
int[] scores=new int[此括號中不能指定長度不然報錯]{78,91,84,68};

使用循環來操作java中的數組 如:

int[] scores={78,91,84,68};
for(int i=1;i<scores.length;i++){
System.ou.println(“數組中的第”+(i+1)“個元素的值是：”+scores[i])
}
其中，數組名.length 用于獲取數組的長度
PS：
1.數組下標從0開始。因此 scores[3]，代表數組中第4個元素，而非第三個元素
2.數組下標是0到數組長度-1，如果越界訪問，就會報錯。
循環遍歷數組
package com.vb;
public class LX31 {
public static void main(String[] args) {
String[] hobbys= {“sports”,“game”,“movie” };
System.out.println(“循環輸出數組中元素的值:”);
for(int i=0;i<hobbys.length;i++) {
System.out.println(hobbys[i]);
}
}

}
例子: package com.vb;

public class LX32 { public static void main(String[] args) {int[] nums=new int[]{61,23,4,74,13,148,20};//定義一個整型數組int max=nums[0];//假定最大值為數組中的第一個數int min=nums[0];//假定最小值為數組中的第一個數double sum=0;//累加值double avg=0;//平均值for(int i=0;i<nums.length;i++) {if(nums[i]>max){max=nums[i];}//如果當前值大于max，則替換max值if(nums[i]<min){min=nums[i];}sum=sum+nums[i];avg=sum/nums.length; }System.out.println("數組中的最大值為:"+max);System.out.println("數組中的最小值為:"+min);System.out.println("數組中的平均值為:"+avg);}}使用Arrays類操作java中的數組Arrays類是java中提供的一個工具類，在java.util包中。該類中包含了一些方法用來直接操作數組，比如可以直接實現數組的排序、搜索等。1.排序語法:Arrays.sort(數組名);可以使用sort()方法實現對數組的排序，只要將數組名放在sort()方法的括號中，就可以完成對該數組的排序(按升序排序)2.將數組轉換為字符串語法:Arrays.toString(數組名);可以使用toString()方法將一個數組轉換成字符串，該方法按順序把多個數組元素連接在一起，多個元素之間使用逗號和空格隔開使用foreach操作數組語法:for(元素類型 元素變量:遍歷數組){執行的代碼 }java中的二維數組1.聲明數組并分配空間數據類型[][] 數組名=new 數據類型[行的個數][列的個數]；或者 數據類型[][] 數組名；數組名=new 數據類型[行的個數][列的個數]；如：定義一個兩行三列的二維數組int[][] num=new int[2][3];2.賦值二維數組的賦值，和一維數組類似，可以通過下標來逐個賦值，注意索引從0開始數組名[行的索引][列的索引]=值；也可以在聲明數組的同時為其賦值數據類型[][] 數組名={{值1，值2...},{值11，值22...}};如：//給第1行第1列的元素賦值num[0][0]=12;3.處理數組如何定義java中的方法所謂方法，就是用來解決一類問題的代碼的有序組合，是一個功能模塊。一般情況下，定義一個方法的語法是:訪問休止符 返回值類型 方法名(參數列表){方法體}其中1.訪問休止符:方法允許被訪問的權限范圍，可以是pubulic、protected、private 甚至可以省略，其中public表示該方法可以被其他任何代碼調用。2.返回值類型:方法返回值的類型，如果方法不返回任何值，則返回值類型指定為void；如果方法具有返回值，則需要返回指定返回值類型，并且在方法中使用return語句返回返回值3.方法名：定義的方法的名字，必須使用合格的標識符4.參數列表：傳遞給方法的參數列表，參數可以有多個，多個參數間用逗號隔開，每個參數由參數類型和參數名組成，以空格隔開根據方法是否帶參、是否帶返回值，可以將方法分四類：*無參無返回值方法*無參帶返回值方法*帶參無返回值方法*帶參帶返回值方法Java中無參無返回值方法的使用如果方法不包含參數，且沒有返回值，我們稱之為無參無返回值方法。方法的使用分兩步：第一步，定義方法如：public void show（）{System.out.println（“welcome to imooc.”）； }其中void是返回值類型 show方法名System.out.println（“welcome to imooc.”）方法體PS：1.方法體放在一對大括號中，實現特定的操作2.方法名主要在調用這個方法時使用，需要注意命名的規范，一般采用第一個單詞首字母小寫，其他單詞首字母大寫的形式第二步，調用方法當需要調用方法執行某個操作時，可以先創建類的對象，然后通過對象名.方法名（）來實現；java中無參帶返回值方法的使用如果方法不包含參數，但是有返回值，我們稱為無參帶返回值的方法。如果返回值類型為int 則需要return來返回結果PS：如果返回值為void，則方法中不能使用return返回值！public void showInfo（）{return “java”；//這個時候會報錯}2.方法返回值最多只能有一個，不能返回多個public int getInfo（）{int score1=94;int score2=87;return score1,score2;//返回值只能返回一個值；}3.方法返回值的類型必須兼容，例如，如果返回值類型為int，則不能返回String型的值public int getInfo(){String name="imooc";return name;//name為String類型但是返回值類型為int所以會報錯}例：package com.vb;public class LX40 { public static void main(String[] args) {LX40 hello=new LX40();int maxScore=hello.getMaxAge();System.out.println(maxScore);}public int getMaxAge() {int[] ages= {18,23,21,19,25,29,17};int maxScore=ages[0];for(int i=0;i<ages.length;i++) {if(ages[i]>maxScore) {maxScore=ages[i];}}return maxScore;}}java中帶參無返回值方法的使用例：public void show（String name）{System.out.println（“歡迎您，”+name+“！”）；HelloWorld hello=new HelloWorld（）；hello.show（“愛慕課”）；}上面的代碼定義了一個show方法，帶有一個參數name，實現輸出歡迎消息。調用帶參方法與調用無參方法的語法類似，但是調用時必須傳入實際的參數值對象名.方法名（實參1，實參2，....，實參n）很多時候我們把定義方法時的參數稱為形參，目的是用來定義方法需要傳入的參數的個數和類型；把調用方法時的參數稱為實參，是傳遞給方法真正被處理的值。上例中String name 就是形參“愛慕課”就是實參 一定不可以被忽視的問題：1.調用帶參方法時，必須保證實參的數量、類型、順序與形參一一對應2.調用方法時，實參不需要指定數據類型3.方法的參數可以是基本數據類型，如int、double等，也可以是引用數據類型，如String、數組等’4.當方法參數有多個時，多個參數間以逗號隔開java中帶參帶返回值方法的使用java中方法的重載什么是方法的重載：如果同一個類中包含了兩個或兩個以上方法名相同、方法參數的個數、順序或類型不同的方法，則稱為方法的重載，也可以稱該方法被重載了。如何區分調用的是哪個重載方法呢當調用被重載的方法時，java會根據參數的個數和類型來判斷應該調用哪個重載方法，參數完全匹配的方法將被執行。判斷方法重載的依據：1.必須是在同一類中2.方法名相同3.方法參數的個數、順序或類型不同4.與方法的修飾符或返回值沒有關系

重點復習:package com.vb;
import java.util.Arrays;
public class LX44 {
public static void main(String[] args) {
LX44 hello=new LX44();
int[] nums=hello.getArray(8);
System.out.println(Arrays.toString(nums));
}
public int[] getArray(int length) {
int[] nums=new int[length];
for(int i=0;i<nums.length;i++) {
nums[i]=(int)(Math.random()*100);
}
return nums;

}

}

定義類：
1.類的重要性：所有java程序都以類calss為組織單元
2.什么是類：
類是模子，確定對象將會擁有的特征（屬性）和行為（方法）{屬性：這個類這個東西所具有的東西比如手機所具有CPU 為多少 屏幕多大；方法是指這個東西能做什么比如手機可以打電話，發短信}
類的特點
類是對象的類型
具有相同屬性和方法的一組對象的集合·
3.類的組成：屬性和方法。
4.定義一個類的步驟：
a.定義類名 public class 類名(){}
java對象
使用對象的步驟:
1.創建對象:
類名 對象名=new 類名();
LX1 phone=new LX1();
2.使用對象：
引用對象的屬性:對象名.屬性
phone.screen=5;//給scree屬性賦值5
引用對象的方法：對象名.方法名()
phone.sendMessage();//調用sendMessage()方法

成員變量和局部變量區別1.作用域不同局部變量的作用域僅限于定義它的方法成員變量的作用域在整個類內部都是可見的2.初始值不同java會給成員變量一個初始值java不會給局部變量賦予初始值3.在同一個方法中，不允許有同名局部變量；在不同的方法中，可以有同名局部變量；4.兩類變量同名時，局部變量具有更高的優先級； 構造方法1.使用new+構造方法 創建一個新的對象//意思是:比如創建了一個構造方法 public print(){} 當創建此構造方法的對象時則時 print i=new print();這時的print不是類名print而是構造方法print();2.構造方法是定義在java類中的一個初始化對象的方法，構造方法與類名相同且沒有返回值 構造方法的語句格式沒有返回值public 構造方法名(){ //沒有返回值類型 方法名與類名相同 可以指定參數//初始化代碼 } 帶參構造方法的使用 5.當沒有指定構造方法時，系統會自動添加無參的構造方法6.當有指定構造方法時，無論是有參、無參的構造方法，都不會自動添加無參的構造方法7.構造方法的重載：方法名相同，但是參數不同的多個方法調用時會自動根據不同的參數選擇相應的方法java中的static使用之靜態變量java中被static修飾的成員稱為靜態成員或類成員。它屬于整個類所有，而不是某個對象所有，即被類的所有對象所共享。靜態成員可以使用類名直接訪問，也可以使用對象名進行訪問。當然，鑒于他作用的特殊性更推薦用類名訪問。PS：靜態成員屬于整個類，當系統第一次使用該類時，就會為其分配內存空間直到該類被卸載才會進行資源回收java中的static使用之靜態方法與靜態變量一樣，我們可以使用static修飾方法，稱為靜態方法或類方法。其實之前我們一直寫的main方法就是靜態方法。PS:靜態方法中可以直接調用同類中的靜態成員，但不鞥直接調用非靜態成員。面向對象的三大特性:封裝、繼承、多態封裝1.概念:將類的某些信息隱藏在類內部，不允許外部程序直接訪問，而是通過該類提供的方法來實現對隱藏信息的操作和訪問2.好處:a.只能通過規定的方法訪問數據 b.隱藏類的實例細節，方便修改和實現3.封裝的實現步驟1.修改屬性的可見性設為private 2.創建getter/setter方法用于屬性的讀寫3.在getter/setter方法中加入屬性語句對屬性值得合法性進行判斷java中的包:1.包的作用：管理java文件解決同名文件沖突2.定義包：package包名注：必須放在java源程序的第一行包名間可以使用“.”隔開eg：com.imooc.MyClass4.包的使用（1）可以通過import關鍵字，在某個文件使用其他文件的類。import com.imooc.music.MyClass（2）java中，包的命名規范是全小寫字母拼寫java中的訪問修飾符訪問修飾符--可以修飾屬性和方法的訪問范圍訪問修飾符 本類 同包 子類 其他private √默認 √ √protected √ √ √public √ √ √ √java中的this關鍵字1.this關鍵字代表當前對象this.屬性 操作當前的對象this.方法 調用當前對象的方法2.封裝對象的屬性的時候，經常會使用this關鍵字什么是java中的內部類內部類就是定義在另外一個類里面的類。與之對應，包含內部類的類被稱為外部類。內部類的功能是什么？ 1.內部類提供了更好的封裝，可以把內部類隱藏在外部類之內，不允許同一個包中的其他類訪問該類2.內部類的方法可以直接訪問外部類的所有數據，包括私有的數據3.內部類所實現的功能使用外部類同樣可以實現，只是有時使用內部類更方便內部類有幾種呢1.成員內部類2.靜態內部類3.方法內部類4.匿名內部類java中的成員內部類內部類中最常見的就是成員內部表，也稱為普通內部類。PS:外部類不能直接使用內部類的成員和方法package com.vb2;public class Outer {//外部類Outer private int a=99;//外部類的私有屬性 public class Inner{//內部類Innerint b=2;//內部類的成員屬性public void test() {System.out.println("訪問外部類中的a:"+a);System.out.println("訪問內部類中的b:"+b);} } public static void main(String[] args) {//測試成員內部類Outer o=new Outer();//創建外部類對象，對象名為oInner i=o.new Inner();//使用外部類對象創建內部類對象，對象名為ii.test();}}從上面的代碼中我們可以看到，成員內部類的使用方法:1.Inner類定義在Outer類的內部，相當于Outer類的一個成員變量的位置，Inner類可以使用任意訪問控制符，如public、protected、private等2.Inner類中定義的test()方法可以直接訪問Outer類中的數據，而不受訪問控制符的影響，如直接訪問Outer類中的私有屬性a3.定義了成員內部類后，必須使用外部類對象來創建內部類對象，而不能直接去new一個內部類對象，即:內部類 對象名=外部類對象名.new 內部類();PS1.外部類是不能直接使用內部類的成員和方法的2.如果外部類和內部類具有相同的成員變量或方法，內部類默認訪問自己的成員變量或方法，如果要訪問外部類的成員變量，可以使用this 關鍵字。如package com.vb2;public class imooc {//外部類imooc int b=1;//外部類的成員屬性b public class inner{//內部類innerint b=2;//內部類的成員屬性bpublic void test() {//內部類的test方法System.out.println("訪問外部類中的b:"+imooc.this.b);System.out.println("訪問內部類中的b:"+b);}}public static void main(String[] args) {imooc o=new imooc();inner i=o.new inner();i.test();}

}

java中的靜態內部類靜態內部類是static修飾的內部類，這種內部類的特點是:1.靜態內部類不能直接訪問外部類的非靜態成員，但可以通過new 外部類().成員的方式訪問2.如果外部類的靜態成員與內部類的成員相同，可以通過“類名.靜態成員”訪問外部類的靜態成員；如果外部類的靜態成員與內部類的成員名稱不相同，則可以通過“成員名”直接調用外部類的靜態成員3.創建靜態內部類的對象，不需要為外部類的對象，可以直接創建 內部類 對象名=new 內部類（）；java中的方法內部類方法內部類就是內部類定義在外部類的方法中，方法內部類只在該方法的內部可見，即只在該方法內可以使用。PS:由于方法內部類不能在外部類的方法以外的地方使用，因此方法內部類不能使用訪問修飾符和static修飾符。 java中的繼承繼承是類與類的一種關系，是一種“is a”的關系PS:java中的繼承類是單向的繼承的好處：子類擁有父類的所有屬性和方法實現代碼復用3.語法規則：class 子類 extends 父類例：class Dog extends Animal{....}方法的重寫1.什么是方法的重寫：如果子類對繼承父類的方法不滿意，是可以重寫父類繼承的方法的，當調用方法時會優先調用子類的方法。2.語法規則：a.返回值類型b.方法名c.參數類型及個數都要與父類繼承的方法相同，才叫方法的重寫。 繼承的初始化順序1.初始化父類再初始化子類2.先執行初始化對象中屬性，在執行構造方法中的初始化 final關鍵字使用final關鍵字做標識有“最終的”含義final可以修飾類、方法、屬性和變量final修飾類，則該類不允許被繼承final修飾方法，則該方法不允許被覆蓋（重寫）final修飾屬性則該類的屬性不會進行隱式的初始化（類的初始化屬性必須有值）或在構造方法中賦值（但只能選其一）final修飾變量，則該變量的值只能賦一次值，即變為常量super關鍵字:在對象的內部使用，可以代表父類對象1.訪問父類的屬性super.age2.訪問父類的方法super.eat()super的應用子類的構造的過程當中必須調用其父類的構造方法。如果子類的構造方法中沒有顯示調用父類的構造方法，則系統默認調用父類無參的構造方法如果顯示的調用構造方法，必須在子類的構造方法的第一行。如果子類構造方法中既沒有顯示調用父類的構造方法，而父類中有沒有無參的構造方法則編譯會報錯。Object類Object類是所有類的父類，如果一個類沒有使用extends關鍵字明確標識繼承另外一個類，那么這個類默認繼承Object類。Object類中的方法，適合所有子類。1.toString（）方法在Object類里面定義toString（）方法的時候返回對象的哈希code碼（對象地址字符串）可以通過重寫toString（）方法表示對象的屬性2.equals（）方法比較的是對象的引用是否指向同一塊內存地址。DOG dog=new DOG();一般情況下比較兩個對象時比較他的值是否一致，所以要進行重寫多態對象的多種形態1.引用多態父類的引用指向本類的對象父類的引用指向子類的對象2.方法多態創建本類對象時，調用的方法為本類方法創建子類對象時，調用的方法為子類重寫的方法或者繼承的方法引用類型轉換1.向上類型轉換(隱式/自動類型轉換)，最小類型到大類型的轉換2.向下類型轉換(強制類型轉換)，是大類型到小類型3.instanceof運算符，來解決引用對象的類型，避免類型轉換的安全性問題抽象類1.語法定義抽象類前使用abstract關鍵字修飾，則該類為抽象類。2.應用場景:a.在某些情況下，某個父類只是知道其子類應該包含怎樣的方法，但是無法準確知道這些子類如何實現這些方法。b.從多個具有相同特征的類中抽象出一個抽象類，以這個抽象類作為子類的模板，從而避免了子類設計的隨意性。3.作用:不關注子類的實現但是限制子類必須具有某些特征4.使用規則:a.abstract定義抽象類b.abstract定義抽象方法，只有聲明，不需要實現c.包含抽象方法的類是抽象類d.抽象類中可以包含普通的方法，也可以沒有抽象方法接口概念類是一種具體實現體，而接口定義了某一批類所需要遵守的規范，接口不關心這些類的內部數據，也不關心這些類里方法的實現細節，它只規定這些類里必須提供某些方法。2.接口定義和類定義不同，定義接口不再使用class關鍵字，而是使用interface關鍵字。接口定義的基本語法:[修飾符] interface 接口名 [extends 父接口1,父接口2...]{零個到多個常量定義...零個到多個抽象方法的定義...}接口就是用來被繼承、被實現的、修飾符一般建議用publicPS:不能使用private和protected修飾接口3.接口定義常量:接口中的屬性是常量，即使定義時不添加public static final 修飾符，系統也會自動加上。方法:接口中的方法只能是抽象方法，總是使用，即使定義時不添加public abstract修飾符，系統也會自動加上。4.使用接口一個類可以實現一個或多個接口，實現接口使用implements關鍵字。java中一個類只能繼承一個父類，是不夠靈活的，通過實現多個接口可以做補充。繼承父類實現接口的語法為:[修飾符]class 類名 extends 父類 implements 接口1，接口2...{類體部分//如果繼承了抽象類，需要實現繼承的抽象方法；要實現接口中的抽象方法。} 如果要繼承父類，繼承父類必須在實現接口之前 使用接口:接口在使用過程當中，還經常與匿名內部類配合使用匿名內部類就是沒有名字的內部類，多用于關注實現而不關注實現類的名稱語法格式:Interface i=new Interface(){public void method(){System.out.println("匿名內部類實現接口的方式")

}
};

UML 1.UML概念Unied Modeling Language(UML)又統稱一建模語言或標準建模語言是一個支持模型化和軟件系統開發的圖形化語言為軟件開發的所有階段提供模型化和可視圖支持 2.UML圖示UML2.2中一共定義了12種視圖 3.常用UML圖 用例圖(The Use Case Diagram)用例圖能夠以可視化的方式，表達系統如何滿足所收集的業務規則，以及特定的用戶需求等信息UML 3.常用UML圖序列圖（The Sequence Diagram）序列圖用于按照交互發生的一系列順序，顯示獨享之間的這些交互。類圖(The Class Diagram)UML類圖、業務邏輯和所有支持結構一同被用于定義全部的代碼結構。 4.UML建模工具Visio.Rational Rose\ PowerDesign三種建模工具應用最廣綜合練習

一.項目背景介紹
根據所學知識，編寫一個控制臺版的“答答租車系統”
功能：
1.展示所有可租車輛
2.選擇車型、租車量
3.展示租車清單，包含：總金額、總載貨量及其車型、總載人量及車型
二.項目分析
1.數據模型分析
2.業務模型分析
3.顯示和流程分析
數據模型分析
1.通過對現實世界的事與物主要特征的分析、抽象，為信息系統的實施提供數據存取的數據結構以及相應的約束。
2.數據結構的組成:操作(方法)、屬性
業務模型分析
1.在設計應用程序之前，應該明確該應用程序必須執行那些任務。分析業務需求是應用程序開發中最重要的步驟之一。
確定業務需求的目的在于創建一個能同時滿足零售商和消費者需要的解決方案。
2.答答租車系統中，只需要考慮消費者需求就可以了。
顯示和流程分析
1.顯示：用戶可以看到的信息提示界面。
2.流程：顯示信息的執行過程、步驟。
3.答答租車系統中，要以命令行的方式顯示提示信息和輸出結果信息，要考慮其樣式，用戶輸入的數據不同，信息該如何提示、如何處理并顯示出結果，這部分知道囊括了顯示與流程的內容。
例：請選擇車輛->請輸入序號->輸出總金額…

this.x(成員變量)=x(局部變量)private static//修飾為靜態私有屬性，修飾后次屬性只能被此類中的方法中使用（方法可以是靜態方法也可以是非靜態方法）異常簡介異常處理的作用java異常體系結構簡介 →Error(如果Error出現則表明程序崩潰了) Throwbale →空指針異常(NullPointerException)處理異常 →Exception→非檢查異常(RuntimeException)→數組下標越界異常(ArrayIndexOutOf)try-catch以及try-catch-finally →類型轉換異常(ClassCastException)拋出異常 →算術異常(ArithmetiException)自定義異常異常鏈 →檢查異常→文件異常(IOException)→SQL異常(SQLException)try-catch語法 try{ //一些會拋出異常的方法}catch (Exception e){//處理該異常的代碼塊}catch (Exception2 e){//處理Exception2的代碼塊}...(n個catch塊)...{ }java中的異常拋出throwthrows--聲明將要拋出幾何類型的異常(聲明)public void 方法名(參數列表)throws 異常列表{//調用會拋出異常的方法或者:throw new Exception();}自定義異常java中的異常鏈實際應用中的經驗與總結1.處理運行異常時，采用邏輯去合理規避同時輔助try-catch處理2.在多重catch塊后面，可以加一個catch(Exception)來處理可能會被遺漏的異常3.對于不確定的代碼，可以加上Try-catch,處理潛在的異常4.盡量去處理異常，切忌只是簡單的調用printStackTrace()去打印輸出5.具體如何處理異常，要根據不同的業務需求和異常類型去決定6.盡量添加finally語句塊去釋放占用的資源String類的常用方法:方法int length() 返回當前字符串的長度int indexOf(int ch) 查找ch字符在該字符串中第一次出現的位置int indexOf(String str) 查找str子字符串在該字符串中第一次出現的位置int lastIndexOf(int ch) 查找ch字符在該字符串中最后一次出現的位置int lastIndexOf(String str) 查找str子字符串在該字符串中最后一次出現的位置String substring(int beginIndex) 獲取從beginIndex位置開始到結束的子字符串String substring(int beginIndex,int endIndex) 獲取從beginIndex位置開始到endIndex位置的子字符串String trim() 返回去除了前后空格的字符串boolean equals(Object obj) 將該字符串與指定對象比較，返回true或falseString toLowerCase() 將字符串轉換為小寫String toUpperCase() 將字符串轉換為大寫char charAt(int index) 獲取字符串中指定位置的字符String[] split(String regex,int limit) 將字符串分割為子字符串，返回字符串數組byte[] getBytes() 將該字符串轉換為byte數組String i="piano";String i2=new String("piano");他們區別是內存區將會出現兩個piano對象并且由i和i2分別控制。“==”和equals（）有什么區別呢？==：判斷兩個字符串在內存中首地址是否相同，即判斷是否是同一個字符串對象equals（）：比較存儲在兩個字符串對象中的內容是否一致PS：字節是計算機存儲信息的基本單位，1和字節等于8位，gbk編碼中1個漢字字符存儲需要2個字節，1個英文字符存儲需要1個字節。所以我們看到上面的程序運行結果中，每個漢字對應兩個字節值，如“學”對應“-47 -89”，而英文字母“j”對應“74”。同時，我們還發現漢字對應的字節值為負數，原因在于每個字是8位，最大值不能超過127，而漢字轉換為字節后超過127，如果超過就會溢出，以負數的形式顯示。認識java中的StringBuilder類在java中，除了可以使用String類來存儲字符串，還可以使用StringBuilder類或StringBuffer類存儲字符串，那么他們之間有什么區別呢？String類具有是不可變性。如String str="hello";System.out.println(str+"world");System.out.println(str);java中StringBuilder類的常用方法StringBuilder類提供了很多方法來操作字符串方法 說明 StringBuilder append(參數) 追加內容到當前StringBuilder對象的末尾StringBuilder insert(位置，參數) 將內容插入到StringBuilder對象的指定位置String toString() 將StringBuilder對象轉換為String對象int length() 獲取字符串的長度

java中基本類型和包裝類之間的轉換
Integer a=new Integer(3);
int b=a+5;

裝箱:把基本類型轉換成包裝類，使其具有對象的性質，又可分為手動裝箱和自動裝箱
int i=10;
Integer x=new Integer(i);
Integer y=i;
拆箱:和裝箱相反，把包裝類對象轉換成基本類型的值，又可分為手動拆箱和自動拆箱
Integer j=new Integer(8);
int m=j.intValue();
int n=j;

java中基本類型和字符串之間的轉換
在程序開發中，我們經常需要在基本數據類型和字符串之間進行轉換。
其中，基本類型轉換為字符串有三種方法:
1.使用包裝類的toString()方法
2.使用sTRING類的valueOf()方法
3.用一個空字符串加上基本數據類型,得到的就是基本類型數據對應的字符串
將字符串轉換成基本類型有兩種方法;
1.調用包裝類的parseXxx靜態方法
2.調用包裝類valueOf()方法轉換為基本類型的包裝類，會自動拆箱

使用Date和SimpleDateFormat類表示時間
在程序開發中，經常需要處理日期和時間的相關數據，此時我們可以使用java.util包中的Date類。這個類最主要的作用就是獲取當前的時間，我們來看下Date類的使用:
Calendar類的應用
Date類最主要的作用就是獲得當前時間，同時這個類里面也具有設置時間以及一些其他的功能，但是由于本身設計的問題，這些方法卻遭到眾多批評，不建議使用，更推薦使用Calendar類進行時間和日期的處理。

java.util.Calendar類是一個抽象類，可以通過調用getInstance（）靜態方法獲取一個Calendar對象，此對象已由當前日期時間初始化，即魔人代表當前時間，如Calendar c=Calendar.getInstance（）;
使用Math類操作數據
Math類位于java.lang包中，包含用于執行基本數學運算的方法，Math類的所有方法都是靜態方法，所以使用該類中的方法時，可以直接使用類名.方法名，如:Math.round();
常用的方法:
返回值 方法名 解釋
long round() 返回四舍五入的整數
double floor() 返回小于參數的最大整數
double cell() 返回大于參數的最小整數
double random() 返回[0,1]之間的隨機數浮點數

集合框架 集合概念java中的集合類:是一種工具類里面是具有相同屬性的內容 集合的作用在類的內部，對數據進行組織；簡單而快速的搜索大數量的條目；有的集合接口，提供了一系列排列有序的元素，并且可以在序列中間快速的插入或者刪除有關元素有的集合接口，提供了映射關系，可以通過關鍵字（key）去快捷查找對應的唯一對象，而這個關鍵字可以是任意類型。 與數組的對比數組的長度固定，集合長度可變數組只能通過下標訪問元素，類型固定，而有的集合可以通過任意類型查找所映射的具體對象 java集合框架的框架Collection map list Queue Ste HashMap <Key,Value>Entry(鍵值對)

LinkedList
ArrayList LinkedList HashSet

Collection接口，子接口以及實現類
Collection接口
List接口及其實現類—ArrayList
List是元素有序并且可以重復的集合，被稱為序列
List可以精確的控制每個元素的插入位置，或刪除某個位置元素
ArrayList–數組序列，是List的一個重要實現類
ArrayList底層是由數組來實現的
方法的重寫:有繼承關系的子類中
方法名相同,參數列表相同,{參數順序,個數,類型,方法返回值相同}
與重寫方法的參數名無關
訪問修飾符的限定范圍大于等于父類方法。
方法的重載:在同一個類中
方法名相同
參數個數,順序,類型不同
返回值類型,訪問修飾符任意

List接口排序用
Collections.sort();方法進行排序

數組排序 Arrays.sort()
集合排序 Collections.sort();
Comparator接口中包含一個 int compare(T o1,T o2)方法的 用來比較排序的兩個參數
如果o1<o2 返回負整數
如果o1==o2;返回0;
如果o1>o2,返回正整數
還包含一個 boolean equals(Obkect obj)方法 指示某個其他對象是否 “等于” 此 Comparator
此方法可以被Object類中的equals方法覆蓋,不必重寫

public class NameComparator implements Comparator<Cat> { @Override public int compare(Cat o1, Cat o2) {int n=o1.getName().compareTo(o2.getName());return n; }for(Cat n:list) {System.out.println(n); } System.out.println("*********************"); Collections.sort(list, new NameComparator()); for(Cat n:list) {System.out.println(n); }}對集合中的某一個屬性進行排序首先定義一個類實現(implements)接口 Comparator然后進行重寫 compare方法進行比較 public int compare(Cat o1, Cat o2) {return o2.getMonth()-o1.getMonth(); }compare默認返回是int類型的值,當類型不一致時直接進行加減運算就可以了

Comparable java.lang包中的
此接口強行對實現它的每個類的對象進行整體排序
這種排序被稱為類的自然排序,類的 compareTo方法 被稱為它的自然比較方法
對于集合,通過調用Collections.sort方法進行排序
對于數組,通過調用Arrays.sort方法進行排序.
int compareTo(T o)方法
該對象小于,等于或大于指定對象,則分別返回負整數,零或正整數.

Comparable和Comparator的區別
排序所用的的方法 collections 前者 一個參數 后者兩個參數
重寫compareTo方法前者直接在定義的類中重寫并與之當前的屬性進行比較
后者 則單獨創建一個類并重寫該方法在排序的參數中實例化該類對象

package com.demo25.sort;

public class Goods implements Comparable{
private String id;//商品編號
private String name;//商品名稱
private double price;//商品價格

//構造方法public Goods(String id, String name, double price) {super();this.id = id;this.name = name;this.price = price;}//getter/setter方法public String getId() {return id;}public void setId(String id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getPrice() {return price;}public void setPrice(double price) {this.price = price;}@Override public String toString() {return "商品編號:"+id+",商品名稱:"+name+",商品價格:"+price;} @Override public int compareTo(Goods o) {int n=(int)(o.getPrice()-this.getPrice());return n; }}File類什么是文件?文件可認為是相關記錄或放在一起的數據的集合在java中,使用java.io.File類對文件進行操作.字節流字節輸入流 InputStream字節輸出流 OutputStreamFileInputStream從文件系統中的某個文件中獲得輸入字節try {FileInputStream fis=new FileInputStream("imooc.txt");int n=0;while((n=fis.read())!=-1) {System.out.println((char)n);}fis.close();讀取指定文件的數據

public class FileInputStreamDemo {

public static void main(String[] args) {FileInputStream fis;try {fis = new FileInputStream("imooc.txt");byte[] b=new byte[100];fis.read(b,0,5 );System.out.println(new String(b));} catch (FileNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IOException e) {e.printStackTrace();}}

通過數組形式進行輸出文件內容

緩沖輸入流 BufferedInputStream
緩沖輸出流 BufferedOutputStream

字符輸入流 Reader
字符數出流 Writer

字節字符轉換流 InputStreamReader
OutputStreamWrite

對象序列化
步驟:
創建一個類,繼承Serializable接口
創建對象
將對象寫入文件
從文件讀取對象信息

對象輸入流 ObjectInputStream;
對象輸出流 ObjectOutputStream;

Library

Lorem Ipsum is simply dummy text of the printing and typesetting industy

Lorem Ipsum has been the industry’s tsandard dummy text ever since the 1500s,When an unknown printer took a galley of type and scrambled it to make a tyle specimen book.

element.getAttribute//獲取屬性
element.setAttribute//添加或者修改屬性
element.src//修改圖片名稱
element.href//修改網址

DOM事件不同寫法
1)

請點擊該文本

2)Element.οnclick=function(){displayDate()};
3)Element.addEventListener(“click”,function(){ })

DOM節點
document.createElement("");新增一個元素標簽
document.createTextNode("")新增的內容
parent.appendChild(child);//把子類的元素插入到父類中
parent.removeChild(child);//移除子類中的元素

window的方法
window.open()//打開新窗口 //四個參數第一個打開的頁面 第二個窗口的名字 第三個寬 第四個高
window.close()//關閉當前窗口
window.moveTo()//移動當前窗口
window.resizeTo()//調整當前窗口的尺寸

window.screen
screen.availWidth//可用的屏幕寬度
screen.availHeight//可用的屏幕高度

window.inner
window.innerWidth//當前文檔可顯示的寬度
window.innerHeight//當前文檔可顯示的高度

window.Location
location.hostname 返回web主機的域名
location.pathname返回當前頁面的路徑和文件名
location.protocol返回所使用的web協議(http://或https//)
location.href 返回(當前頁面的)整個URL

window.aler(’’)在網頁中輸出警告框
document.write(’’)輸出內容到網頁中
document.getElementById(’’).innerHTML輸出內容到html元素中
console.log(’’)輸出元素到控制臺

prompt() 方法用于顯示可提示用戶進行輸入的對話框。有確定和取消選項 確定返回true 反之false
confirm(“文本”)用于提示用戶需要輸入的值并且創建一個接受用戶輸入的文本框

xml
1.標簽名要有意義
2.建議使用，小寫字母，單詞之間使用"-"分割
3.建議多級標簽之間不要存在重名的情況

適當的注釋與縮進
適當的注釋與縮進可以讓XML文檔更容易閱讀

合理使用屬性
1.標簽屬性用于描述標簽不可或缺的信息
2.對標簽分組或者標簽設置id時常用屬性表示

xml支持五中實體引用
CDATA標簽

<![CDATA[ 開始]]}> 有序的子元素 1.在xml多層嵌套的子元素中，標簽前后順序應保持一致 xml標簽書寫規則 xml語義約束 1.xml文檔結構正確，但可能不是有效的。 例如，員工檔案XML中絕對不允許出現“植物品種”標簽。XML語義約束就是用于規定XML文檔中允許出現哪些元素 XML語義約束有兩種定義方式：DTD與XML Schemma. DTD(Document Type Definition,文檔類型定義)是一種簡單易用的語義約束方式 DTD文件的擴展名為.dtd. hr.dtd 最少出現一個employee子節點 <!ELEMENT hr (employee+)> 可能出現0..n個employee子節點 <!ELEMENT hr (employee*)> 最多出現1個employee子節點 <!ELEMENT hr (employee?)> <!ELEMENT employee (name,age,salary,department)> <!ATTLIST employee no CDATA""> <!ELEMENT name (#PCDATA)> DTD定義節點 1.利用DTD中的<!ELEMENT>標簽，我們可以定義XML文檔中允許出現的節點及數量 XML引用DTD文件 1.在XML中使用標簽來引用DTD文件. XML Schema DOM文檔對象模型 1.DOM(Document Object Model)定義了訪問和操作XML文檔的標準方法，DOM把XML 文檔作為樹結構來查看，能夠通過DOM樹來讀寫所有元素。 Dom4j 1.Dom4j是一個易用的、開源的庫，用于解析XML。它應用于Java平臺，具有性能優異 功能強大和極其易使用的特點 2.Dom4j將XML視為Document對象。 3.XML標簽被Dom4j定義為Element對象 XPath基本表達式 1.最常用的基本表達式 nodename 選取此節點的所有子節點 / 從根節點選取 // 從匹配選擇的當前節點選擇文檔中的節點,而不去考慮他們的位置。 . 選取當前節點 .. 選取當前節點的父節點 @ 選取屬性 XPath基本表達式案例 bookstore 選取bookstore元素的所有子節點 /bookstore 選取根元素 bookstore PS:注釋:假如路徑起始與正斜杠(/)，則此路徑始終代表到某元素的絕對路徑! bookstore/book 選取屬于bookstore 的子元素的所有book元素。 //book 選取所有book子元素,而不管他們在文檔中的位置. bookstore//book 選擇屬于bookstore元素的后代的所有book元素,而不管他們位于 bookstore之下的什么位置 //@lang選取名為lang的所有屬性 /bookstore/book[1] 選取屬于bookstore子元素的第一個book元素 /bookstore/book[last()] 選取屬于bookstore子元素的最后一個book元素 /bookstore/book[last()-1] 選取屬于bookstore子元素的倒數第二個元素 /bookstore/book[position()<3] 選取最前面的兩個屬于bookstore元素的book元素 //title[@lang] 選取所有擁有名為lang的屬性的title元素 //title[@lang='eng'] 選取所有title元素,且這些元素擁有值為eng的lang屬性 /bookstore/book[price>35.00] 選取bookstore元素的所有book元素，其中的price元素的值須大于35.00. /bookstore/book[price>35.00]/title 選取bookstore元素中的book元素的所有title元素,其中的price元素的值須大于35.00 Jaxen 1.Jaxen是一個Java編寫的開源的XPath庫。這是適應多種不同對象的類型，包括DOM，XOM，dom4j和JDOM 2.Dom4j底層依賴Jaxen實現XPath查詢 3.Jaxen下載地址:jaxen.codehaus.org BS 請求與響應成對出現 從瀏覽器發出送給服務器的數據包稱為請求 (Request) 與 (Response) 從服務器返回瀏覽器的結果稱為響應 J2EE 1.J2EE(Java 2 Platform Enterprise Edition)是指"Java 2企業版" 2.開發BS(Web)應用程序就是j2EE最核心的功能 3.J2EE由13個功能模塊組成 J2EE中13個功能模塊 Servlet JSP JDBC XML web服務器小程序 服務器頁面 數據庫交互模塊 XML交互模塊 EJB RMI JNDI JMS 企業級Java Bean 遠程調用 目錄服務 消息服務 JTA JavaMail JAF CORBA 事務管理 發送/接收Email 安全框架 CORBA集成 JTS CORBA事務監控 Apache Tomcat 1.Tomcat是Apache軟件基金會旗下一款免費的開放源代碼的Web應用服務器程序 J2EE與Tomcat的關系 1.J2EE是一組技術規范與指南，具體實現由軟件廠商決定 2.Tomcat是J2EE Web(Servlet與JSP)標準的實現著 3.J2SE是J2EE運行的基石,運行Tomcat離不開J2SE Servlet 1.Servlet(Server Applet)服務器小程序,主要功能用于生成動態Web內容 2.Servlet是J2EE最重要的組成部分 安裝Tomcat 1.安裝JDK 8 2.安裝Tomcat 8.x 標準Java Web工程結構 tomcat安裝目錄/webapps/ Tomcat應用根目錄 /web應用目錄/ Java Web應用目錄 /web應用目錄/index.html|.jsp 默認首頁 /WEB-INF WEB應用的安全目錄,用于存放配置文件 /WEB-INF/web.xml web.xml是"部署描述文件",是該Web項目核心配置文件 /WEB-INF/classes 存放編譯后的classes文件 /WEB-INF/lib 用于存放web應用依賴的jar文件 /META-INF/MANIFEST.MF 包含Web應用的版本等信息 Servlet開發步驟 1.創建Servlet類,繼承HttpServlet 2.重寫servlet方法,編寫程序代碼 3.配置web.xml,綁定URL Servlet訪問方法 1.http://IP地址:端口/context-path/url-mapping 2.遠程訪問使用IP地址,本地訪問localhost(127.0.0.1) context-path成為"上下文路徑",默認為工程名 請求參數 1.請求參數是指瀏覽器通過請求向Tomcat提交的數據 2.請求參數通過是指用戶輸入的數據,待Servlet進行處理 3.參數名1=值&參數名2=值2&參數名n=... Servlet接收請求參數 1.request.getParameter() 接收單個參數 2.request.getParameterValues() 接收多個同名參數 Servlet生命周期 1.裝載 - web.xml 2.創建 - 構造函數 3.初始化 - init() 4.提供服務 - service() 5.銷毀 - destory() 使用注釋簡化配置 啟動時加載Servlet 1.web.xml使用設置啟動加載 2.0-9999 0最先被加載 使用注解時需要在loadOnStartup中來設置加載順序 還需要設置urlPatterns 才能生效 3.啟動時加載在工作中常用于系統的預處理 JSP介紹 1.JSP全稱是(Java Server Pages)，Java服務器頁面 2.JSP是J2EE功能模塊,由Web服務器執行 3.JSP的作用就是降低動態網頁開發難度 JSP的特點 1.JSP使用簡單,短時間學習便可以上手 2.JSP可將Java代碼與HTML分離,降低開發難度 3.JSP的本質就是Servlet JSP基本語法 JSP語法十分簡單,按功能可分為以下四種 1.JSP代碼塊 2.JSP聲明構造快 3.JSP輸出指定 4.JSP處理指令 JSP代碼塊 1.JSP代碼塊用于在JSP中嵌入Java代碼 2.JSP代碼塊語法:<% java代碼 %> JSP聲明代碼塊 1.JSP聲明構造塊用于聲明變量或方法 2.JSP聲明構造塊語法:<%!聲明語句%> 3.例如:<%! public int add(int a,int b){return a+b;}%> JSP輸出指定 1.JSP輸出指令用于在JSP頁面中顯示Java代碼執行結果 2.JSP輸出指令語法:<%=java代碼%> 例如:<%=" " + name + "" %> JSP處理指定 1.JSP處理指定用于提供JSP執行過程中的輔助信息 2.JSP處理指令語法:<%@ jsp指令 %> 例如: <%@ page import="java.util.*" %> JSP常用處理指令 1.<%@ page %>定義當前JSP頁面全局設置 2.<%@ include %>將其他JSP頁面與當前JSP頁面合并 3. <%@ taglib %>引入JSP標簽庫 JSP注釋的區別 1. <%--注釋--%> JSP注釋,被注釋語句不做任何處理 2.// , /*..*/ 用于注釋<% %>java代碼,被注釋代碼不執行 3, HTML注釋，被注釋的語句不會被瀏覽器解釋 JSP頁面重用 HTTP請求結構 1.HTTP請求包含三部分:請求行、請求頭、請求體 巧用請求頭開發多端應用 ContentType的作用 1.ContentType決定瀏覽器采用何種方式對響應體進行處理 MIME 類型 描述 text/plain 純文本 text/html HTML文檔 text/xml XML文檔 application/x-msdownload 需要下載的資源 image/jpeg 圖片資源 image/gif image/... 請求轉發 1.請求轉發是服務器跳轉,只會產生一次請求 響應重定向 1.重定向則是瀏覽器端跳轉,會產生兩次請求 2.響應重點向語句是:response.sendRedirct(); 設置請求自定義屬性 1.請求允許創建自定義屬性 2.設置請求屬性:request.setAttribute(屬性名,屬性值) 3.獲取請求睡醒:Object attr = request.getAttribute(屬性名) 瀏覽器Cookie 1.Cookie 是瀏覽器保存在本地的文本內容 2.Cookie常用于保存登錄狀態,用戶資料等小文本 3.Cookie具有時效性,Cookie內容會伴隨請求發送給Tomcat Session-用戶對話 1.Session(用戶對話) 用于保存與"瀏覽器窗口" 對應的數據 2.Session的數據存儲在Tomcat服務器的內存中,具有時效性 3.Session通過瀏覽器Cookie的SessionId值提取用戶數據 ServletContext 1.ServletContext（Servlet上下文對象）,是Web應用全局對象 1.HttpServletRequest-請求對象 2.HttpSession-用戶會話對象 3.ServletContext-web應用全局對象 Web應用的中文亂碼問題 1.Tomcat默認使用字符集ISO-8859-1,屬于西歐字符集 2.解決問題的核心思路是將ISO-8859-1轉換成UTF-8 3.Servlet中請求與響應都需要設置UTF-8字符集 web.xml常用配置 1.修改web應用默認首頁 2.Servlet通配符映射及初始化參數 3.設置404,500等狀態碼默認 JSP九大內置對象 內置對象 描述 request 請求對象-HttpServletRequest response 響應對象-HttpServletResponse session 用戶會話-HttpSession application 應用全局對象-ServletContext out 輸出對象-PrintWriter page 當前頁面對象-this pageContext 頁面上下文對象-PageContext config 應用配置對象-ServletContext exception 應用異常對象-Throwable Java Web打包與發布 1.Java Web應用采用war包進行發布 2.發布路徑為:{TOCAT_HOME}/webapps 3.Edipse支持war包導入 JSTL與EL表達式 EL表達式 1.EL(Expression Language)表達式語言,用于簡化JSP的輸出 2.EL表達式的基本語法:$(表達式) 3.示例:

學生姓名:$(student.name)

作用域對象 EL表達式內置四種作用域對象 忽略書寫作用域對象時,el則按作用域從小到大一次嘗試獲取 作用域對象 描述 pageScope 從當前頁面取值 requestScope 從當前請求中獲取屬性值 sessionScope 從當前會話中獲取屬性值 applicationScope 從當前應用獲取全局屬性值 EL表達式輸出 1.語法 ${[作用域.]屬性名[.子屬性]} 2.EL表達式支持將運算結果進行輸出 3.EL支持絕大多數對象輸出,本質是執行toString()方法 EL輸出參數值 1.EL表達式內置param對象來簡化參數的輸出 2.語法:${param.參數名} JSTL標簽庫 1.JSTL(JSP Standard Tag Libray)JSP標準標簽庫 2.JSTL用于簡化JSP開發,提高代碼的可讀性與可維護性 3.JSTL由SUN(Oracle)定義規范,由Apache Tomcat團隊實現 JSTL的標簽庫種類 1.JSTL按功能劃分可分為五類標簽庫 類別 核心標簽庫-core 格式化輸出標簽庫-fmt SQL操作標簽庫-sql XML操作標簽庫-xml 函數標簽庫-functions 引用JSTL核心庫 1.核心標簽庫(Core)是JSTL最重要的標簽庫,提供了JSTL的基礎功能 2.<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 3.JSTL核心標簽庫在taglibs-standard-impl.jar由META-INF/c.tld定義 判斷標簽 1.JSTL核心庫提供了兩組判斷標簽 2.-單分支判斷 3.、、-多分支判斷 遍歷集合 1.標簽用于遍歷集合{Collection}中的每一個對象 第${idx.index+1}位
姓名:${p.name} 性別:${p.sex} 年齡:${p.age} fmt格式化標簽庫 1.fmt格式化標簽庫 URI:http://java.sun.com/jsp/jstl/fmt 2.格式化日期標簽 3.格式化數字標簽 web注冊登錄案例 MVC設計模式 Web案例開發 MVC的概述 SUN公司推出JSP技術后,同時也推薦了兩個web應用程序的開發模式,一種是JSP+JavaBean模式——簡單程序開發,一種是Servlet+JSP+JavaBean模式 Servlet + JSP +JavaBean(MVC)——>復雜web程序 丨 丨 丨 處理用戶 數據顯示 數據封裝 請求 web開發模式 Servlet Servlet缺陷: 丨 1.需要配置 丨 2.顯示HTML元素的時候很復雜 丨 丨 JSP JSP缺陷: 丨 1.封裝和處理數據麻煩 丨 丨 JSP+JavaBean JSP+JavaBean模式優點 1.JSP顯示數據 2.JavaBean封裝和處理數據 Model1:使用JSP+JavaBean模式開發 Servlet 丨 丨 丨 丨 JSP Servlet+JSP+JavaBean模式優點: 丨 1.使用Servlet處理用戶的請求 丨 2.JSP顯示數據 丨 3.JavaBean封裝和處理數據 JSP+JavaBean 丨 丨 丨 Servlet+JSP+JavaBean Model2:使用 Servlet+JSP+JavaBean模式開發稱為MVC模式 M:Model模型層——JavaBean V:View視圖層——JSP C:Controller控制層——Servlet 用戶的請求都提交到Servlet(C)，由C統一調度JavaBean(M)封裝和處理數據, 由JSP(V)進行數據顯示 模式一 應用了Java Web開發中的兩種技術 1.JSP完成邏輯上的處理很顯示 2.JavaBean封裝數據,處理數據 瀏覽器 request(請求) JSP 瀏覽器 response(響應) 丨 JavaBeans （Web服務器） 模式二 1.Model2分為三部分 1.Servlet控制顯示那個JSP頁面給用戶、調用那個JavaBean 2.JSP響應用戶請求,把結果數據展現給用戶 3.JavaBean對數據庫的數據的存取,復雜的業務功能和邏輯處理 瀏覽器 request(請求) Servlet———— 丨 丨 JSP<———>JavaBeans MVC開發流程 瀏覽器 ————>Servlet調用JavaBean(封裝數據) 調用另外一個JavaBean(處理數據) 最后將處理的結果通過JSP響應給瀏覽器 Get與Post請求方法 1.Get方式是將數據通過在URL附加數據顯性向服務器發送數據 http://localhost:8080/FirstServer/sam-ple?name=zhangsan 2.Post方式會將數據存放在"請求體" 中隱性向服務器發送數據 請求體:name=zhangsan Get與Post處理方式 1.所有請求-servlet()方法 2.Get請求-doGet()方法 3.Post請求-doPost（）方法 Get與Post應用場景 1.Get常用于不包含敏感信息的查詢功能 2.Post用于安全性要求較高的功能或者服務器的"寫"操作 1.用戶登錄 2.用戶注冊 3.更新公司賬目 xml是可擴展標記語言 編寫xml就是編寫標簽,與html很相似 良好的人機可讀性 xml與html比較 xml和html非常相似,都是編寫標簽 xml沒有預定義標簽,html存在大量預定義標簽 xml重在保存與傳輸數據,html用于顯示信息 html xml 首頁 三年級 1班 三年級 2班 xml用途 配置描述文件 用于保存程序產生的數據 網絡間的數據傳輸 xml文檔結構 第一行必須是xml聲明 有且只有一個根節點 xml聲明 xml聲明說明xml文檔的基本信息,包括版本號與字符集,寫在xml第一行 <?xml version="1.0" encoding="UTF-8"?> version代表版本號1.0/1.1 encoding UTF-8設置字符集,用于支持中文 xml標簽書寫規則 1.合法的標簽名 2.適當的縮進與注釋 3.合理使用屬性 4.特殊字符與CDATA標簽 5.有序的子元素 xml支持五種實體引用 實體引用 對應符號 說明 < < 小于 > > 大于 & & 和號 ' ' 單引號 " " 雙引號 CDATA標簽 1.CDATA指的是不應由XML解析器進行解析的文本數據 2.從 <![CDATA[ 不需要解析的代碼 ]]> 結束

有序的子元素
在xml多層嵌套的子元素中,標簽前后順序應保持一致.

xml語義約束
1.xml文檔結構正確,但可能不是有效的
2.例如,員工檔案xml中絕不允許出現其他類型的標簽

xml語義約束有兩種定義方式:DTD與xml Schema

Document Type Definition
1.DTD(Document Type Definition,文檔類型定義)是一種簡單易用的語義約束方式
2.DTD文件的擴展名為.dtd.

<!ELEMENT hr (employee)> 定義hr節點下只允許出現1個employee子節點 <!ELEMENT employee(name,age,salary,department)> employee節點下必須包含以下四個節點,且按順序出現 <!ELEMENT name(#PCDATA) 定義name標簽體只能是文本,#PCDATA代表文本元素. DTD定義節點數量 1.如某個節點需要多次重復出現,則需要在子節點后增加相應的描述符 <!ELEMENT hr (employee+)> hr節點下最少出現1個employee子節點 <!ELEMENT hr (employee*)> hr節點下可能出現0~n個employee子節點 <!ELEMENT hr (employee?)> hr節點下最多出現1個employee子節點

xml引用dtd文件
在xml中使用<!DOCTYPE>標簽來引用DTD文件
書寫格式

示例

XML Schema
1.xml schema比dtd更為復雜,提供了更多功能
2.xml schema提供了數據類型,格式限定,數據范圍等特性
3.xml schema是w3c標準

DOM文檔對象模型
1.DOM（Document Object Model）定義了訪問和操作XML文檔的標準方法,DOM把XML文檔
當做樹結構來查看,能夠通過DOM樹來讀寫所有元素.

DOM文檔對象模型

Dom4j
1.Dom4j是一個易用的,開源的庫，用于解析XML。它應用于Java平臺,具有性能優異，功能強大和極其易使用的特點.
2.Dom4j將XML視為Document對象.
3.XML標簽被Dom4j定義為Element對象

XPath路徑表達式
1.Xpath路徑表達式是XML文檔中查找數據的語言
2.掌握XPath樂意極大的提高在提取數據時的開發效率。
3.學習Xpath本質就是掌握各種形式表達式的使用技巧.

XPath基本表達式
1.最常用的基本表達式
表達式 描述
nodename 選取此節點的所有子節點
/ 從根節點選取
// 從匹配選擇的當前節點選擇文檔中的節點,而不考慮他們的位置
. 選取當前節點
… 選取當前節點的父節點
@ 選取屬性

XPath基本表達式案例
路徑表達式 結果
bookstore 選取bookstore元素的所有子節點
/bookstore 選取根元素bookstore。
bookstore/book 選取屬于bookstore的子元素的所有book元素
//book 選取所有book子元素，而不是他們在文檔的位置
//bookstore//book 選取屬于bookstore元素的后代的所有book元素，而不管他們位于bookstore之下的什么位置
//@lang 選取名為lang的所有屬性

XPath謂語表達式案例
路徑表達式 結果
/bookstore/book[1] 選取屬于bookstore子元素的第一個book元素
/bookstore/book[last()] 選取屬于bookstore子元素的最后一個book元素
/bookstore/book[last()-1] 選取屬于bookstore子元素的倒數第二個book元素
/bookstore/book[position()??] 選取最前面的兩個屬于bookstore元素的子元素的book元素
//title[@lang] 選取所擁有名為lang的屬性的title元素
//title[@lang=‘eng’] 選取所有title元素，且這些元素擁有值為eng的lang屬性
/bookstore/book[price>35.00] 選取bookstore元素的所有book元素,且其中的price元素的值須大于35.00
/bookstore/book[price>35.00]/title 選取bookstore元素的book元素的所有title元素,且其中的price元素的值須大于35.00

jaxen
1.jaxen是一個java編寫的開源的XPath庫，這是適應多種不同的對象模型,包括DOM，XOM，dom4j和
JDOM.
2.Dom4j底層依賴jaxen實現XPath查詢

標準Java Web工程結構
組織結構 描述
tomcat Tomcat應用根目錄
/web應用目錄 Java Web應用目錄
/web應用目錄/index.html |.jsp 默認首頁
/WEB-INF WEB應用的安全目錄,用于存放配置文件
/WEB-INF/web.xml web.xml是"部署描述文件",是該Web項目核心配置文件
/WEB-INF/classes 存放編譯后的classes文件
/WEB-INF/lib 用于存放web應用依賴的jar文件
/META-INF/MANIFEST.MF 包含Web應用的版本等信息

Servlet開發步驟

1.創建Servlet類,繼承HttpServlet
2.重寫service方法,編寫程序代碼
3.配置web.xml,綁定URL

Servlet訪問方法
1.http://IP地址:端口/context-path/url-mapping
2.遠程訪問使用,本地訪問localhost (127.0.0.1)
3.context-path稱為’上下文路徑’，默認工程名

請求參數
1.請求參數是指瀏覽器通過請求向Tomcat提交的數據
2.請求參數通常是用戶輸入的數據,待Sevlet進行處理

Servlet接收請求參數
request.getParameter()–接收單個參數
request.getParameterValues()—接收多個同名參數

Get與Post請求方法
1.Get方式是將數據通過在URL附加數據顯性向服務器發送數據
1.http://localhost:8080/FirstServlet/sample?name=zhangsan

2.Post方式會將數據存放在"請求體"中隱性向服務器發送數據
2.請求體:name=zhangsan

request.getMethod();獲取當前請求方法

Servlet生命周期
1.裝載-web.xml
2.創建-構造函數
3.初始化-init()
4.提供服務-service()
5.銷毀-destory()

啟動時加載Servlet

1.web.xml使用設置啟動加載
2.0~9999
3.啟動時加載在工作中常用于系統的預處理

JSP執行過程
Tomcat 將jsp—轉譯為Servlet源代碼-----在進行編譯成Servlet字節碼

JSP基本語法
1.JSP語法按功能可分為以下四種
1.JSP代碼塊 2.JSP聲明構造塊
3.JSP輸出指令 4.JSP處理指令

JSP聲明構造快
1.JSP聲明構造快用于聲明變量或方法
2.JSP聲明構造快語法:<%!聲明語句 %>
例如 <%! public int add(int a,int b){return a+b;} %>

JSP常用處理指令
1.<%@ page %>定于當前jsp頁面全局設置
2.<%@ include %>將其他JSP頁面與當前JSP頁面合并
3. <%@ taglib %>引入JSP標簽庫

JSO九大內置對象
HTTP請求的結構
1.HTTP請求包含三部分:請求行,請求頭,請求體

String userAgent = request.getHeader("User-Agent"); 獲取顯示形式

響應的結構
1.HTTP響應包含三部分:響應行,響應頭,響應體

狀態碼 錯誤描述
200 服務器處理成功
404 無法找到文件
500 內部服務器錯誤
403 服務器拒絕訪問
301.302 請求重定向
400 無效的請求
401 未經過授權
503 服務器超負載或正停機維護,無法處理請求

ContentType的作用
1.ContentType決定瀏覽器采用何種方式對響應體進行處理

MIME類型 描述
text/plain 純文本
text/html HTML文檔
text/xml XML文檔
application/x-msdownload 需要下載的資源
image/jpeg 圖片資源
image/gif
image/…

請求轉發與重定向

1.多個Servlet(JSP)之間跳轉有兩種方式
2.request.getRequestDispatcher().forward() -請求轉發
3.response.sendRedirect() --響應重定向

請求轉發
1.請求轉發是服務器跳轉,只會產生一次請求
2.重定向會產生兩次請求

瀏覽器Cookie
1.Cookie(小甜餅) 是瀏覽器保存在本地的文本內容
2.Cookie常用于保存登錄狀態,用戶資料等小文本
3.Cookie具有時效性,Cookie內容會伴隨請求發送給Tomcat

Session–用戶會話
1.Session(用戶會話) 用于保存與"瀏覽器窗口"對應的數據
2.Session的數據存儲在Tomcat服務器的內存中,具有時效性
3.Session通過瀏覽器Cookie的SessionId值提取用戶數據

Session原理

ServletContext
1.ServletContext(Servlet上下文對象),是Web應用全局對象
2.一個Web應用只會創建一個ServletContext對象
3.ServletContext隨著Web應用啟動而自動創建

Java Web三大作用域對象
1.HttpServletRequest–請求對象 作用域范圍一次遞增
2.HttpSession–用戶會話對象
3.ServletCotext-web應用全局對象

web.xml常用配置
1.錯誤頁面
2.映射配置

JSP九大內置對象
內置對象 描述
request 請求對象-HttpServletRequest
response 響應對象-HttpServletResponse
session 用戶會話-HttpSession
application 應用全局對象-ServletContext
out 輸處對象-PrintWriter
page 當前頁面對象-this
pageContext 頁面上下文對象-PageContext
config 應用配置對象-ServletConfig
exception 應用異常對象-Throwable

EL表達式
1.EL(Expression Language)表達式語言,用于簡化JSP的輸出
2.EL表達式的基本語法:${表達式}

EL的作用域對象
1.EL表達式內置四種作用域對象

作用域對象 描述
pageScope 從當前頁面取值
requestScope 從當前會話中獲取屬性值
sessionScope 從當前會話中獲取屬性值
applicationScope 從當前應用獲取全局屬性值

El表達式的輸出
1.語法:${[作用域.]屬性名[.子屬性]}
2.EL表達式支持將運算結果進行輸出
3.EL支持絕大多數對象輸出,本質是執行toString()方法

EL輸出參數值
1.EL表達式內置param對象來簡化參數的輸出
2.語法:${param.參數名}//可以代替request.getParameter

JSTL標簽庫
1.JSTL(JSP Standard Tag Library),JSP標準標簽庫
2.JSTL用于簡化JSP代碼開發,提高代碼的可讀性與可維護性
3.JSTL由SUN(Oracle)定義規范,由Apache Tomcat實現

JSTL的標簽庫種類
1.JSTL按功能規劃可分為五類標簽庫
類別
核心標簽庫–core
格式化輸出標簽庫–fmt
SQL操作標簽庫–sql
XML操作標簽庫–xml
函數標簽庫–functions

判斷標簽
1.JSTL核心庫提供了兩組判斷的標簽
2.<c:if>-單分支判斷
3.<c:choose>、<c:when>、<c:otherwise> -多分支判斷

fmt格式化標簽庫
1.fmt格式化標簽庫 URI:http://java.sun.com/jsp/jstl/fmt
2.<fmt:formatDate value="" pattern ="" >格式化日期標簽
3.<fmt:formatNumber value = “” pattern ="">格式化數字標簽

MVC模式

Servlet + JSP + JavaBena(MVC)---->復雜的web程序
控制層 視圖層 模型層
處理用戶請求 數據顯示 數據封裝

*****************接收表單中存在文件類型數據時的接收方式,request.getparameter不可以接收文件
//1.創建一個磁盤文件項工廠對象
DiskFileItemFactory diskFileItemFactory = new DiskFileItemFactory();
//2.創建一個核心解析類
ServletFileUpload servletFileUpload = new ServletFileUpload(diskFileItemFactory);
//3.解析request請求,返回的是List集合，List中存放的是Fileitem對象
List list= servletFileUpload.parseRequest(request);
//4.遍歷集合,獲得每個Fileitem對象,判斷是表單項還是文件上傳項
for (FileItem fileItem:list) {
//判斷是否為表單項還是普通項
if (fileItem.isFormField()) {
//普通表單項
//接收表單項參數的值
fileItem.getFieldName();//獲取表單項的name
fileItem.getString(“UTF-8”);//獲取表單項Value的值
} else {
//文件上傳項
//文件上傳功能
}

}

文件讀取固定代碼
int len = 0;
byte[] b = new byte[1024];
while ((len = is.read(b)) != -1) {
os.write(b,0,len);
}

JSON
1.JavaScript Object Notation(JavaScript對象表示法)
2.JSON是輕量級的文本數據交換格式
3.JSON獨立于語言,具有自我描述性,更易于理解

JSON語法規則
1.數據由鍵(key)值(value)描述,由逗號分隔
2.大括號代表一個完整的對象,擁有多個鍵/值對
3.中括號保存數組,多個對象之間使用逗號分隔

JSON與字符串互相轉換
1.JSON.parse()方法將字符串裝換為JSON對象
2.JSON.stringify()方法將JSON對象轉換為字符串

@JSONField(format = “yyyy-MM-dd”)//對時間進行注釋格式化

Calendar c = Calendar.getInstance();
c.set(2019, 0, 30, 0, 0, 0); 設置時間方式
employee.setHdate(c.getTime());

JSON和JAVA的交互

JSON.toJSONString將json進行序列化返回的是一個字符串
JSON.parseObject將JSON轉換為JSON對象

JSON和JavaScript的交互

JSON.stringify()將json進行序列化返回的是一個字符串
JSON.parse()將JSON轉換為JSON對象

document.getElementById //選中表單Id

$("#id") ID選擇器,指定id元素的對象
$(“標簽”) 元素選擇器,選擇指定標簽名的選擇器
$(".class") 類選擇器,選中擁有指定css類的元素
$(“S1,S2,SN”) 組合選擇器,對元素進行組合

層疊選擇器
1.層疊選擇器是根據元素的位置關系來獲取元素的選擇器表達式

語法 說明
$(“ancestor descendant”) 后代選擇器
$(“ancestor>descendant”) 子選擇器
$(“prev~siblings”) 兄弟選擇器

屬性選擇器
1.屬性選擇器是根據元素的屬性值來選擇元素的選擇器表達式

語法 說明
$(“selector[attribute=value]”) 選中屬性值等于具體值得組件
$(“selector[attribute^=value]”) 選中屬性值以某值開頭的組件
$("selector[attribute$=value]") 選中屬性值以某值結尾的組件
$(“selector[attribute*=value]”) 選中屬性值包含某值得組件

$(“selector:first”) 獲取第一個元素
$(“selector:last”) 獲取最后一個元素
$(“selector:even”) 獲取偶數位置的元素
$(“selector:odd”) 獲取奇數位置的元素
$(“selector:eq(n)”) 獲取指定位置的元素

attr() 獲取或者設置元素屬性
removeAttr(name) 移除元素屬性

操作元素的CSS樣式
1.css() 獲取或設置匹配元素的樣式屬性
2.addClass() 為每個匹配的元素添加指定的類名
3.removeClass() 從所有匹配的元素中刪除全部或者指定的類

設置元素內容
1.val() 獲取或設置輸入項的值
2.text() 獲取或設置元素的純文本
3.html() 獲取或設置元素內部的HTML

jQuery事件處理方法
1.on(“click”,function) 為選中的頁面元素綁定單機事件
2.click(function) 是綁定事件的簡寫形式
3.處理方法中提供了event參數包含了事件的相關信息

Ajax的使用流程
1.創建XmlHttpRequest對象
2.發送Ajax請求
3.處理服務器響應

1.XMLHttpRequest用于在后臺與服務器交換數據,是AJAX的核心
2.XMLHttpRequest并不是W3C的標準,不同瀏覽器的創建方式不一樣

處理服務器響應
1.xmlHttp.onreadystatechange() 事件用于監聽AJAX的執行過程
2.xmlhtto.readyState屬性說明XMLHttpRequest當前狀態

readyState = 0 請求未初始化
readyState = 1 服務器連接已建立
readyState = 2 請求已被接收
readyState = 3 請求正在處理
readyState = 4 響應文本已被接收

獲取響應體的文本
var responseText = xmlhttp.responseText;

jQuery對Ajax的支持
常用設置項 說明
url 發送請求地址
type 請求類型(get|post)
data 向服務器傳遞的參數
dataType 服務器響應的數據類型
text|json|xml|html|jsonp|script
success 接收響應時的處理函數
error 請求失敗時的處理函數

-----------------------當id為lv1的屬性發生改變時自動觸發后面的function()函數
$(function () {
$("#lv1").on(“change” , function () {
var parent = $(this).val(); //可以接收當前id為lv1的表單選項發生改變時對應選項的value值
})
})

正則表達式語法規則
1.[abc] a,b或c（簡單類）
2.[a-zA-Z]a到z或者A到Z，兩頭的字母包括在內（范圍）
3.\d 數字 : [0-9]
4.X{n} X,恰好n次
5.X{n,} X,至少n次
6.X{n，m} X，至少n次，但是不超過m次

1.\D:非數字
2.\s:空白字符(如空格，\t,\n換行等)
3.\S:非空白字符（除了空白字符以外的其他都可以）
4.\w：單詞字符:[a-zA-Z_0-9]
5.\W:非單詞字符

matches方法的含義是將獲取過來的值與想匹配的正則表達式相比較,滿足返回true反之false

Java過濾器概述
過濾器的作用
1.實現對web資源請求的攔截，完成特殊的操作，尤其是對請求的預處理

JSPServlet 大部分過濾器會對請求做預處理的操作

Web 圖片 常常會忽略過濾器也會對請求處理完成后的一個響應做出后處理的操作
文件

過濾器的應用場景
1.Web資源權限訪問控制
2.請求字符集的編碼處理
3.內容敏感字符詞匯過濾
4.響應信息壓縮 //響應后處理的應用

過濾器的工作流程圖解

過濾器請求預處理客戶端 響應后處理 servlet.service()

過濾器的生命周期
1.web應用程序啟動時，web服務器創建Filter的實例對象，以及對象的初始化
2.當請求訪問與過濾器關聯的Web資源時，過濾器攔截請求，完成指定功能
3.Filter對象創建后會駐留在內存，在web應用移除或服務器停止時才銷毀
4.過濾器的創建和銷毀由WEB服務器實現

過濾器的實現步驟
1.編寫java類實現Filter接口，并實現其doFilter方法
2.在web.xml文件中對filter類進行注冊，并設置所攔截的資源

過濾器鏈
1.在一個web應用中，多個過濾器組合起來稱之為一個過濾器鏈
2.過濾器的調用順序取決于過濾器在web.xml文件中的注冊順序

引入表單樣式css文件格式

1.注冊過濾器
2.攔截映射配置CharacterEncodingFiter

config.getInitParameter(“charset”)//獲取初始化參數

Servlet中使用load-on-startup配合 init能夠在啟動的時候就初始化init

response.sendError(404)//可以使當前頁面變成404頁面

ServletContextWeb Web

應用服務器 監聽器 HttpSession

ServletRequest

Java監聽器簡介

java監聽器定義
1.Servlet規范定義的一種特殊類
2.用于監聽ServletContext，HttpSession，ServletRequest等的創建
，銷毀及其屬性修改發生變化的事件
3.監聽器可以在事件發生前后進行一些必要的處理操作

常見應用場景1.統計在線人數（監聽Session會話的創建來統計有多少用戶人數）2.頁面訪問量的統計（監聽Request的請求）3.應用啟動時完成信息初始化工作（）4.與Spring結合監聽器的實現步驟1.編寫java類實現監聽器接口，并實現其接口方法2.在web.xml文件中對實現的監聽器類進行注冊多個監聽器啟動順序 1.監聽器的啟動順序好在web.xml中配置的順序一致當銷毀是則是逆序Java監聽器分類按監聽對象1.ServletContext對象監聽器 主要監聽上下文對象2.HttpSession對象監聽器主要監聽會話對象3.ServletRequest對象監聽器主要監聽請求對象按監聽事件1.域對象自身的創建和銷毀事件監聽器2.域對象中屬性的創建，替換和消除事件監聽器3.綁定到session中的某個對象的狀態事件監聽器getAttributeHttpSession 對屬性的變化做監聽setAttribute

單例模式:
1. 構造器的私有化 private LoginCache() {

} 2. 實例化一個本身的私有靜態對象 private static LoginCache instance = new LoginCache(); 3. 定義一個靜態的方法返回實例化的對象 public static LoginCache getInstance() {return instance;}session.invalidate();//將session會話中的信息進行清除,使其失效;charAt方法可以返回指定索引位置的字符Linux命令格式

關機/重啟命令
關機:shutdown -h now
重啟:shutdown -r now 或者 reboot

Linux目錄結構 使用ls命令查看目錄結構Linux目錄結構

/bin 命令存放目錄 /opt 第三方軟件放置目錄
/boot 啟動目錄 /root 超級用戶家目錄
/dev 設備文件存放目錄 /tmp 臨時目錄
/etc 配置文件存放目錄 /sbin 命令存放目錄
/lib 函數庫存放目錄 /proc 放置數據到內存
/home 普通用戶家目錄 /srv 服務存放數據目錄
/mnt 系統掛載目錄 /usr 系統軟件資源目錄
/media 媒體設備掛載目錄 /var 系統相關文檔內容目錄

目錄查看，切換，顯示當前目錄

目錄查看:ls [-al] [文件或目錄名稱]
目錄切換:cd [目錄名稱]
顯示當前目錄:pwd

路徑格式
絕對路徑:
從根目錄/開始寫起

相對路徑:
當前目錄 .
上級目錄 …
家目錄 ~

目錄創建，刪除
目錄創建:mkdir [-p] 目錄名稱
目錄刪除:rmdir [-p] 目錄名稱

文件的創建
文件創建:touch 文件名稱
文件編輯模式 vi 文件名

a在光標后插入 A在當前行之后插入
i在光標前插入 I在當前行之前插入
o在當前行之下插入 O在上一行插入

文件內容查看
cat 文件名稱

文件的復制，移動，刪除
復制：cp [-r] 來源文件 目標文件
移動：mv 來源文件 目標文件
刪除：rm [-rf] 文件或目錄

用戶管理
查看：who
創建用戶：useradd [-g 群組] 用戶名
設置密碼：passwd 用戶名

刪除用戶:userdel [-r] 用戶名

群組管理
查看群組:groups[用戶名]
創建群組:groupadd群組名
刪除群組:groupdel群組名

用戶群組修改:usermod [-g 群組名] 用戶名

權限，角色的作用
符號 權限 對文件的含義 對目錄的含義
r 讀權限 查看文件 查看目錄
w 寫權限 修改文件 修改目錄內容
x 執行權限 執行文件 進入目錄

權限，角色的設置
修改所有者：chown[-R] 用戶名 文件或目錄
修改所有者和組:chown[-R]用戶名:組名 文件或目錄
修改所屬組:chgrp[-R] 組名 文件或目錄

權限修改:chmod[-R] xyz 文件或目錄
x所有者權限 y所屬組權限 z其他用戶權限
r:4 w:2 x:1 rwx數字總和即權限

JDBC連接數據庫開發步驟 1.加載驅動 Class.forName("com.mysql.cj.jdbc.Driver");2.獲得連接Connection conn=DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/jdbctest?useSSL=false&serverTimezone=Hongkong&useUnicode=true&characterEncoding=utf-8","root", "password123123");3.創建執行SQL語句的對象，并且執行SQL//3.1創建執行sql對象String sql = "select * from user";Statement stmt=conn.createStatement();//3.2執行sql語句ResultSet resultSet=stmt.executeQuery(sql);while(resultSet.next()) {int uid=resultSet.getInt("uid");String username=resultSet.getString("username");String password=resultSet.getString("password");String name=resultSet.getString("name");System.out.println(uid+" "+username+" "+password+" "+name);} 4.釋放資源resultSet.close();stmt.close();conn.close();java的反射機制--JAVA反射機制是在運行期間，對于任意一個類，都能夠知道這個類的所有屬性和方法，對于任意一個對象，都能夠調用它的任意方法和屬性；這種動態獲取信息以及動態調用對象方法的功能稱為java語言的反射機制java會被編譯成.class后綴的文件然后會被ClassLoader進行記載進JVM中運行(運行期間)可以動態獲得這個類中的屬性和方法以及可以通過.class動態獲取實例對象這就是反射Java的反射機制的作用-是用來編寫一些通用性較高的代碼或者框架的時候使用Classclass類的實例表示正在運行的java應用程序中的類和接口Constructor關于類的單個構造方法的信息以及對它的訪問權限FieldField提供有關類或接口的單個字段信息，以及對它的動態訪問權限MethodMethod提供關于類或接口上單獨某個方法信息 Java中java.lang.Class類用于表示一個類的字節碼（.class）文件如何得到某個class文件對應的Class對象--已知類和對象的情況下類名.class對象.getClass()--Object類提供--未知類和對象的情況下Class.forName（“包名.類名”）返回的都是Class對象 例：Class class1=Class.forName("com.imooc.demo.Person");獲得無參/帶參構造直接用獲得的字節碼文件.getConstructor 返回的對象為Constructor然后調用Constructor的對象.newInstance進行實例化 例： Constructor c = class1.getConstructor();Person person = (Person) c.newInstance();有參 Constructor c = class1.getConstructor(String.class,String.class);Person person = (Person) c.newInstance();Spring的IOC的底層原地實現ocp原則:open-close原則，對程序擴展是open的，對修改程序代碼是close盡量做到不修改程序的源碼，實現對程序的擴展工廠模式 + 反射+ 配置文件配置文件<bean id="us" class="com.imooc.UserServiceImpl"/>進行發射找到配置文件然后進行類的實例化

總結

以上是生活随笔為你收集整理的JAVA整理的笔记的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。