Java 總結

javaSE學習筆記

前言

一、 什麼是Android開發？  

Android是一個安裝在移動端設備上的操做系統，android應用程序開發（APP）。

二、 爲何要學習Android？

由於Android操做系統使用率最高

三、 如何學習？

Java語言，被公認爲是世界上最簡單的語言，Java是一種純面向對象的編程語言。

Android操做系統上運行的程序，都是由Java語言編寫的。

學習安排：

第一階段，JavaSE學習（Java基礎學習）40-50天，能夠開發簡單的桌面應用程序。

第二階段，android學習，50天左右，能夠開發簡單的手機應用。

第三階段，項目實戰，便利+ ……

 

第一部分 Java學習

1、 認識Java編程

1、Java簡介

Java的三個分支：

J2SE：Java語法基礎、面向對象概念、經常使用類庫、窗體設計、桌面軟件；

J2ME：嵌入式開發

J2EE：企業級開發，主要開發管理軟件和Web應用。

 

Java的開發環境

JDK：Java開發的工具包

JRE：Java的開發環境

JVM：Java虛擬機

 

 

 

2、Java開發環境搭建

（1）下載並安裝JDK，一路下一步，安裝到默認路徑；

（2）查看文件夾中是否有內容C:\Program Files\Java，查看

 

（3）測試是否安裝成功，開始鍵+R，調出運行框口，輸入cmd打開DOS命令窗口，在DOS命令窗口中輸入java，回車執行，若是有提示，則安裝成功

 

（4）配置環境變量步驟：

第一步：複製路徑C:\Program Files\Java\jdk1.8.0_92\bin

第二步：在計算機上點右鍵，打開「高級系統設置」，選擇「高級」選項卡，點擊右下角的「環境變量」；

 

第三步：在系統變量欄中找到「Path」變量，點擊編輯；

第四步：在變量值中，末尾處填寫：英文輸入法的分號 ;  ，而後把複製的bin目錄路徑粘貼，肯定保存。

測試環境變量配置成功：調出DOS窗口，運行javac

 

3、編寫第一個Java程序

（1） 在硬盤中新建一個文本文檔；

（2） 在文檔中編寫Java代碼，（全部的符號都是英文輸入法下編輯的）

public class Hello{    public static void main(String[] args){    System.out.println("智遞科技歡迎你！"); } }

（3） 把文檔名，重名爲Hello.java

（4） 在此處運行DOS命令

執行：javac  Hello.java ，自動建立Hello.class文件；

執行：java  Hello ，程序執行，打印輸出語句的內容；

注意事項：

（1） class後面的是類名，類名能夠自定義，可是要和文件保持一致，使用英文來命名，類名首字母要大寫；

（2） 大小寫要區分；

（3） 符號要使用英文；

（4） 若是源代碼更新，要從新編譯（執行javac）；

（5） 執行命令，javac編譯生成.class文件；java是執行程序，執行的是生成後的.class 文件，不帶擴展名；

（6） 在記事本中編輯；

4、Java的運行機制

 

（1） 經過javac命令，將.java的源代碼文件編譯爲.class的字節碼文件（.class字節碼文件與操做系統無關，與JVM有關）；

   

（2） 再使用java命令，經過Java虛擬機（JVM）將.class字節碼文件解釋爲特定平臺可以識別的機器碼；

       

 

五、 Java源碼書寫規範

（1） 在java源文件中，只能有一個使用public修飾的類，源文件名稱要和public修飾的類名保持一致；

若是源文件中沒有public修飾的類，文件名能夠自定義；

（2） 全部類名首字母應爲大寫（規範），而且類名不能以數字開頭；

（3） 類名中只能使用下劃線「_」 和美圓 「$」，這兩種符號；

（4） 在類的內部，還能夠繼續編寫類，稱其爲內部類；內部類的訪問權限與源文件名稱無關；

（5） 一個類中只能有一個main方法（即程序的入口），書寫的格式是固定；

（6） 在輸出語句中，字符串用雙引號修飾，若是要進行算術運算，能夠直接寫數字；

字符串與其餘內容拼接時，使用 + 號，若是字符串後面直接跟+號，後面的全部+號默認都是拼接；

拼接的+號後面若是要進行算術運算，可使用小括號；

（7） 在Java中能夠聲明變量，變量能夠賦值

 

int 表明整數型，double表明小數型；

（8）Java中的註釋：

在程序中對某行或某段代碼做解釋說明的文本內容，就稱爲註釋。在Java中有三種註釋方式：

a.使用 // 雙斜槓註釋，行內註釋

b./*

註釋的內容

*/  多行註釋

c.文檔註釋，使用文檔註釋的內容，能夠生成本地的API文檔。

源代碼解釋：

 

 

 

6、eclipse的使用

（1）選擇工做空間

 

（2）操做窗口

 

 

（3）修改文本字體大小

 

 

 

 

（4）包的命名規範

在項目的src下寫源碼，類要放在包內，包名的命名規範爲當前項目域名的倒置，例如：com.taobao.car

 

 

2、Java基礎語法

1、標識符

（1）使用在類名、方法名、變量名等須要自定義而且與其餘代碼或代碼塊做識別的一種符號標識；

（2）標識符由：數字、字母、下劃線「_」、美圓$組成；

（3）首字符不能使用數字；

（4）不能使用Java關鍵字和保留字；

（5）對大小寫敏感；

（6）類名的規範：首字母大寫，多個單詞組合的類名，每一個單詞的首字母都要大寫；

（7）方法名的規範：使用駝峯式寫法，多個單詞組合的方法名，第一個單詞所有小寫，從第二單詞開始首字母大寫；

2、變量的概念

局部變量的存儲機制

 

（1）語法

int a ; //聲明變量a a = 1; //爲變量a賦值，1 // int a = 1;  //簡寫方式

語法規則：

• 先聲明、再賦值；
• 沒有聲明的變量，不能直接賦值；聲明後沒有賦值的局部變量，不能直接使用；
• 局部變量

（2）變量類型

² 聲明在方法體、代碼塊中的變量稱爲局部變量；

² 生命週期：從方法執行到該變量聲明位置時建立，到方法結束時銷燬；

² 只能被final修飾，變爲常量；

² 局部變量沒有默認值，在使用以前必需要賦值；

• 成員變量（實例變量）

² 聲明在類中，在方法體和代碼塊以外；

² 成員變量有默認值，能夠直接使用；

² 成員變量是屬於每個具體實例的（對象的），在類的外部使用時，要用對象來調用；

² 成員變量可使用訪問修飾符修飾，也可使用非訪問修飾符修飾（static、final）；

² 一般把成員變量的訪問權限設爲私有的（private），經過公共的方法對其賦值和取值，這種形式稱爲封裝；

• 類變量

² 使用static關鍵字修飾的成員變量，被稱爲類的變量；

² 類變量是屬於類全部的，不屬於某一個對象，被該類的全部對象共同擁有；

² 類變量既可使用對象來調用，也可使用類名來調用；

² 在同類中，類變量能夠被靜態方法直接調用；

3、基本數據類型

 

（1）整數型：byte、short、int（默認）、long

public class Test {   public static void main(String[] args) {   System.out.println("字節類型byte的取值範圍："); System.out.println("長度="+Byte.SIZE); System.out.println("最大值="+Byte.MAX_VALUE); System.out.println("最小值="+Byte.MIN_VALUE); System.out.println("短整型short的取值範圍："); System.out.println("長度="+Short.SIZE); System.out.println("最大值="+Short.MAX_VALUE); System.out.println("最小值="+Short.MIN_VALUE); System.out.println("整數型int的取值範圍："); System.out.println("長度="+Integer.SIZE); System.out.println("最大值="+Integer.MAX_VALUE); System.out.println("最小值="+Integer.MIN_VALUE); System.out.println("長整型long的取值範圍："); System.out.println("長度="+Long.SIZE); System.out.println("最大值="+Long.MAX_VALUE); System.out.println("最小值="+Long.MIN_VALUE);   }   }

控制檯輸出：

字節類型byte的取值範圍： 長度=8 最大值=127 最小值=-128 短整型short的取值範圍： 長度=16 最大值=32767 最小值=-32768 整數型int的取值範圍： 長度=32 最大值=2147483647 最小值=-2147483648 長整型long的取值範圍： 長度=64 最大值=9223372036854775807 最小值=-9223372036854775808

整數型中的每種類型的取值範圍：

Byte型：最大值2⁷-1 ；最小值 -2⁷ 

Short型：最大值 2¹⁵-1；最小值 -2¹⁵

Int型：最大值 2³¹-1；最小值 -2³¹

Long型：最大值 2⁶³-1；最小值 -2⁶³  ，當值大於int型時，值的末尾要加L

 

（2）浮點型：

單精度32位 float，默認值是0.0f，當值爲整數型時，值的末尾不須要加 f ，當值爲小數時，末尾要加 f ；

雙精度64位 double（默認）

System.out.println("浮點型float的取值範圍："); System.out.println("長度="+Float.SIZE); System.out.println("最大值="+Float.MAX_VALUE); System.out.println("最小值="+Float.MIN_VALUE); System.out.println("浮點型double的取值範圍："); System.out.println("長度="+Double.SIZE); System.out.println("最大值="+Double.MAX_VALUE); System.out.println("最小值="+Double.MIN_VALUE);

控制檯輸出：

浮點型float的取值範圍： 長度=32 最大值=3.4028235E38 最小值=1.4E-45 浮點型double的取值範圍： 長度=64 最大值=1.7976931348623157E308 最小值=4.9E-324

 

（3）字符型

表示單個字符的一種類型 char，在Java的底層，char類型默認是以int類型進行換算

最大值： ‘\uffff’

最小值： ‘\u0000’

public static void main(String[] args) { char a = 'A'-2; int b = 1+'a'; System.out.println(b);   }

 

（4） 邏輯型（布爾型）

布爾型boolean只表示一種結果，值爲：true和false，默認值爲false

public static void main(String[] args) { boolean b = false;// 假 boolean c = true;// 真   System.out.println(b); System.out.println(c);   }

 

4、類型轉換

（1）強制類型轉換（顯式轉換）

當大類型轉小類型時，須要強制類型轉換

public static void main(String[] args) {   int a = 200; short b = 1;   //大類型轉小類型，會出現風險 b = (short)a; //賦值，把=號右邊變量的值 賦給 =號左邊的變量   System.out.println(b);   }

（2）自動類型轉換（隱式轉換）

當小類型轉大類型時，不須要強制類型轉換

byte b = 2; int a = 1; a = b;

 

（3）int和char類型轉換

int ==> char 須要強制類型轉換，結果爲char類型

int a = 70; char c = 'B'; c = (char) a;

char ==> int 自動類型轉換，由於char類型底層是以int進行換算的，結果爲int類型

int a = 70; char c = 'B'; a = c;

 

5、常量

在Java中聲明一個不可改變的量，就叫常量，使用final關鍵字修飾；爲了與變量區分，常量名一般要所有使用大寫字母；

應用場景：π= 3.14    

6、轉義字符

 

 

 

 

 

 

7、運算符

（1）算術運算

 

（2）賦值運算

 

 

 

（3）比較運算

 

（4）邏輯運算

 

• &&（短路與）和 &（按位與），均可以做爲邏輯運算符，表示「而且」，當兩邊的值都爲true時，結果true，反之爲false；
• ||（短路或）和 |（按位或），均可以做爲邏輯運算符，表示「或者」，當兩個的值有一個爲true時，結果爲true；
• !（非），結果爲值取反；
• &（按位與） 和 |（按位或），除了能夠做爲邏輯運算符以外，還能夠進行位運算；
• 在作位運算時，要先把進行運算的值轉爲二進制，而後再進行位運算；

&（按位與）運算時，兩個值轉爲二進制，逐位比較，比較的兩個值都爲1，結果爲1；

int a = 5; // 101 int b = 7; // 111 // 結果：101

|（按位或）運算時，兩個值轉爲二進制，逐位比較，比較的兩個值有一個爲1，結果爲1；

int a = 10; // 1010   int b = 3; //  0011 //結果：1011

當兩個字符作位運算時，把字符對應的ASCII碼錶的十進制數轉爲二進制，再逐位比較；

char a = 'A'; // ASCII-->65 -->  1000001 char b = 'a'; // ASCII-->97 -->  1100001       //             結果：1100001 System.out.println(a | b);

• ^（異或），是做位運算，兩邊的值先轉爲二進制，逐位比較，比較的兩個值不相等時，結果爲1，反之結果爲0；

char a = 'A'; // ASCII-->65 -->  1000001 char b = 'a'; // ASCII-->97 -->  1100001       //            結果：0100000 System.out.println(a ^ b);

 

&(按位與)和&&(短路與)的區別：

• 相同點是兩個均可以做爲邏輯運算符，兩邊都爲true，結果爲true；
• 不一樣點，按位與是兩邊都判斷才計算結果，而短路與在判斷第一個條件爲false時，就直接計算結果，再也不去判斷第二個；
• 因此在判斷字符串是否爲空時，應使用短路與。

示例：

String s = null; if(s!=null && !s.equals("") ){ System.out.println(s); }else{ System.out.println("空"); }

 

（5）三目運算

語法：

聲明類型  變量名 =  條件  ?   爲true的值  ： 爲false的值 ;

int week = 6; String s = (week>=1 && week <=5) ? "上班" : "打遊戲" ; System.out.println(s);

 

8、修飾符

Java提供的修飾符由兩類：訪問修飾符、非訪問修飾符。

（1）訪問修飾符

• 控制其餘類對該類中的屬性、方法調用的權限。
• 訪問權限有4種，分別是：public（公共的）、protected（受保護的）、default（默認的）、private（私有的）。
• 訪問修飾符有3個，分別是：public、protected、private，默認訪問權限什麼都不寫。
• 訪問修飾符能夠修飾類、實例成員和類的成員；不能修飾局部變量；
• 類只有兩種訪問權限，分別是public和default；
• 非訪問修飾符能夠修飾類、屬性、方法、代碼塊，與該類的訪問權限無關，是爲其修飾的元素增長附加的功能。
• 非訪問修飾符有：static、final、abstract、synchronized 和 volatile。
• static 能夠修飾成員方法、成員變量、代碼塊、內部類；當修飾成員方法和成員變量時，該方法和變量就變爲了類的方法和類的變量；修飾代碼塊時，該代碼塊叫靜態代碼塊，是優先於構造方法執行；
• final 能夠修飾類、成員變量、局部變量、成員方法；當修飾變量時，該變量成爲常量，必需要賦初始化值，值不能被修改，final修飾成員變量時一般和static配合使用；修飾類時，該類不能被繼承；修飾方法時，不能被子類重寫；
• abstract能夠修飾類和成員方法，用來建立抽象類和抽象方法。

（2）非訪問修飾符

3、流程控制

1、分支語句

（1）if-else 分支

語法：

if(判斷條件){

知足條件要執行的代碼語句；

}

String name = "小明"; int cont ;// 表明成績的變量 cont = 90;   if(cont >= 90 && cont <= 100){ System.out.println(name+"的成績爲：優"); }   if(cont >= 80 && cont <90){ System.out.println(name+"的成績爲：良"); }   if(cont >= 60 && cont <80){ System.out.println(name+"的成績爲：中"); }   if(cont >= 0 && cont <60){ System.out.println(name+"的成績爲：差"); }

升級版

String name = "小明"; int cont ;// 表明成績的變量 cont = 90;   if(cont >= 90 && cont <= 100){ System.out.println(name+"的成績爲：優"); }else if(cont >= 80 && cont <90){ System.out.println(name+"的成績爲：良"); }else if(cont >= 60 && cont <80){ System.out.println(name+"的成績爲：中"); }else if(cont >= 0 && cont <60){ System.out.println(name+"的成績爲：差"); }else{ System.out.println("輸入有誤"); }

（2）switch語句分支

把一個變量與一系列的值進行對比，找到匹配的那一個，而後執行下面的代碼，直到碰見break關鍵字才結束。

int week = 1; switch(week){ case 1: System.out.println("今天是週一"); break; case 2: System.out.println("今天是週二"); break; case 3: System.out.println("今天是週三"); break; case 4: System.out.println("今天是週四"); break; case 5: System.out.println("今天是週五"); break; case 6: System.out.println("今天是週六"); break; case 7: System.out.println("今天是週日"); break; default: System.out.println("輸入有誤"); }

Switch使用規則：

a) case後面跟的值的類型，應該與要判斷的變量類型保持一致；

b) case後面的值不能重複，而且必須爲字面常量或者是常量；

c) switch（x），x的類型能夠爲：byte、short、int、char，在jdk1.7後，又擴展了String。

2、循環語句

（1）while循環

語法：

While(條件){

知足條件後執行的代碼；

}

int a = 0; while(a<10){ a++;// a = a+1 System.out.println("hello："+a); }

 

int a = 0; boolean b = true; while(b){ a++;// a = a+1 System.out.println("hello："+a); if(a == 5){ b = false; } }

 

 

（2）do-while循環

語法：

do{

要執行的代碼；

}while(條件);

與while循環的區別：

do-while當條件不知足時，至少也會被執行一次；

int a = 0; do{ a++;//變量的迭代 System.out.println("a="+a); }while(a<=0);

（3）for循環

語法：

for(變量聲明；條件子句；迭代){

知足條後執行的代碼；

}

//變量聲明、條件、迭代 for (int i = 1; i < 3;i++ ) { System.out.println("i="+i); }

 

（4）跳出循環

• break：跳出當前的循環，繼續執行循環下面的代碼，可使用在任何循環和switch語句中；
• continue：結束當前的本次循環，continue後面的代碼不會被執行，繼續下一次迭代循環；可使用在任何的循環語句中；
• 跳出多重循環體，可使用Java的標籤，

標籤名：（標籤名是自定義的）

out: for (int i = 0; i <5;i++ ) {   System.out.println("***i="+i+"*****");   for(int j=0; j< 5;j++){ if(j==3){ // break out;//跳出out標籤後面的循環 continue out; } System.out.println("j="+j); } }

4、數組

1、數組的概念

是一組相同類型的數的集合，數組也能夠理解爲是一個容器；

2、數組的聲明

• 方法一

數據類型[] 數組名 = new  數據類型[長度];

// int[] arry = new int[11]; // arry[0] = 1; // arry[1] = 2; // arry[2] = 3;

賦值和取值都是經過下標來完成

• 方法二

數據類型[] 數組名 = { 值1，值2，值3…… } ;

int[] arry = {1,2,3,4,5,6,7,8,9,10,20,30,40,50,55,60,90};   for(int i = 0 ; i < arry.length ; i++){ System.out.println(arry[i]); }

取值，能夠經過循環來取值

• 方法三

數據類型[] 數組名 = new 數據類型[]{值1，值2，……};

int[] arry = new int[]{1,2,3,4,5,6};

3、數組的賦值

a) 經過下標賦值

b) 經過聲明方法二的形式，直接賦值

4、數組的遍歷

經過循環的方式取得數組中的值，參考聲明方法二

5、多維數組

int[] a = {1,2,3,4};//數組中的值的聲明語句是int   int[] b = {5,6,7,8,9,10};   int[] c = {9,10,11,12,13};   int[][] arry = {a,b,c};//int[]   for(int i = 0 ; i < arry.length ; i++){ for(int j = 0 ; j < arry[i].length ; j++){ System.out.print(arry[i][j]+","); } System.out.println(); }

 

6、加強for循環

語法：

for(數據類型 標識符 :  數組名){

}

int[] a = {3,1,7,5,4,9,2};   for(int i : a){ System.out.println(i); }

7、數組排序

（1）冒泡排序

相鄰的兩個元素對比，交換數據，從後往前依次肯定最大或最小值。

 

int[] a = {3,1,7,5,4,9,2};   for (int i = 1; i < a.length; i++) { for(int j = 0 ; j < a.length - i ; j++){ if(a[j] < a[j+1]){ int temp = a[j]; a[j] = a[j+1]; a[j+1] = temp; } } }   System.out.println("排序後："); for (int i : a) { System.out.print(i+" "); }

 

（2）選擇排序

第一元素和後面的元素依次對比，交換數據，從前日後依次肯定最大或最小值。

 

int[] a = {3,1,7,5,4,9,2};   for (int i = 0; i < a.length-1; i++) { for(int j = i+1 ; j < a.length; j++){ if(a[i] < a[j]){ int temp = a[i]; a[i] = a[j]; a[j] = temp; } } }   System.out.println("排序後："); for (int i : a) { System.out.print(i+" "); }

 

5、面向對象

1、面向對象的概念

對象是指一切客觀存在的可見事物和一切不可見事物；

面向對象就是把客觀事物在計算機中去建立模型的思想；

對象是由屬性和行爲組成的；

類就是對象在計算機中的模型；

使用成員變量來表示數據模型（成員屬性）；

語法：訪問修飾  數據類型  屬性名

//成員屬性-->數據模型 public String name; public String gender; public int age ;

 

使用成員方法來表示行爲模型；

語法：

訪問修飾符  返回值類型(void)   方法名（參數列表）{

要執行的代碼；

}

//成員方法-->行爲模型    // 無參無返回值方法 public void eat(){ System.out.println("吃飯……"); }

 

2、類的使用

（1）建立對象(實例化對象)

語法：

類名  對象名 = new  構造器();

//建立對象 Person xw = new Person();//構造器

（2）對象賦值

語法：

對象名.屬性名;

//建立對象 Person xw = new Person();//構造器 xw.age = 20; xw.name = "小王"; xw.gender = "男";

（3）方法調用

語法：

對象名.方法名();

Person p1 = new Person(); p1.name = "張三"; p1.age = 22; p1.gender = "女"; p1.eat();

 

（4）方法參數和返回值

Person類：

public class Person {   public String name; public String gender; public double weight;   public String jianfei(int i){   return name+"是個"+gender+"胖子體重"+weight+"kg。某天他開始減肥，" + "通過不懈努力，減了"+i+"kg。減肥後的體重是"+(weight-i)+"kg。"; }   }

Test類：

Person p1 = new Person(); p1.name = "小王"; p1.gender = "男"; p1.weight = 200;        String s = p1.jianfei(40); System.out.println(s);

3、成員變量和局部變量

區別：

• 成員變量聲明在類中，局部變量聲明在方法體或代碼塊內；
• 成員變量做用域在整個類中，局部變量做用在當前的方法體或代碼塊內；
• 成員變量有初識化值，局部變量沒有初始化值，不賦值不能直接使用；
• 當成員變量和局部變量重名的時候，若是直接使用變量名，默認使用的是局部變量，要想使用成員變量，能夠加上this關鍵字；

4、方法重載

原則：

（1） 在同一個類中，聲明多個同名的方法；

（2） 方法名相同，參數列表不一樣，與返回值無關；

（3） 參數列表的個數，類型，類型的順序不相同；

 

public class Test {   //方法重載   public void a(int j,double i){   }   public void a(){   }   public void a(double j,int i){   }   public void a(int i){   }   public static void main(String[] args) { Test t = new Test(); t.a(1); } }

 

5、構造方法

構造方法是一個特殊的方法，只有在實例化對象時纔會被調用。

語法：

訪問修飾符  類名(參數列表){

}

當一個類中沒有顯式的構造方法，程序在執行的時候會自動建立一個公開的無參的構造方法；

若是類中有一個顯式的構造方法，程序在執行時，就不會自動建立公開的無參構造方法；

做用：通常是用於對類中成員變量的賦初始化值；

public class Person {   public String name; public int age;      //經過構造方法的形式爲成員變量賦初始化值 public Person(String name,int age){ this.name = name; this.age = age; }   public Person(){   } }

 

public static void main(String[] args) {   Person p1 = new Person("小明",20);   Person p2 = new Person("小王",10);   Person p3 = new Person("小李",22);   System.out.println(p1.name); System.out.println(p2.name); System.out.println(p3.name);   }

 

6、this關鍵字

用法：

（1）是指當前對象；

（2）當局部變量與成員變量名稱衝突時，使用this關鍵字來表示成員變量；

（3）在構造方法中能夠調用另外一個構造方法，使用this(參數列表)來表示調用構造方法；

public class Person {   public String name; public int age;   public Person(){ this(1); }   public Person(int a){ // this(); this.age = a; }   }

 

7、static關鍵字

用法：

（1）static能夠直接修飾，成員變量、成員方法、代碼塊；

（2）使用static關鍵字修飾的成員變量、成員方法被稱爲類的變量和類的方法；沒有使用static關鍵字修飾的成員變量、成員方法被稱爲實例變量和實例方法；

（3）靜態成員能夠直接調用靜態成員，若是調用實例成員，必需要先實例化對象，用具體的對象調用實例成員；

實例成員能夠直接調用靜態成員和實例成員；

Person類

public class Person {   public static String name;//類的 public int age;//實例的，具體對象的   }

 

Test類

public void print(){ Person.name = ""; Person p = new Person(); p.age = 1; }

（4）靜態成員是屬於類的，全部該類的對象共享靜態成員的數據；

Account類

public class Account {   public String name; public static double balance;   public void qu(double b){ balance -= b; System.out.println(name+"取了"+b+"元，當前餘額"+balance+"元"); }   public void cun(double b){ balance += b; System.out.println(name+"存了"+b+"元，當前餘額"+balance+"元"); }   public void print(){ System.out.println(name+"查看，當前餘額爲"+balance+"元"); }   }

 

Test類

public static void main(String[] args) { Account wy = new Account(); wy.name = "網銀"; Account zfb = new Account(); zfb.name = "支付寶"; Account wx = new Account(); wx.name = "微信";   wy.cun(100); zfb.cun(200); wx.cun(100); wx.qu(300);   wy.print(); zfb.print(); wx.print(); }

（5）static修飾代碼塊時，該代碼塊爲靜態代碼塊，在類加載的時候先執行，若是有多個靜態代碼塊，按照前後順序依次執行；通常用於初始化成員變量；

8、訪問修飾符

訪問修飾符	同類	同包	同包子類	不一樣包	不一樣包子類
public	√	√	√	√	√
protected	√	√	√	×	×
默認的	√	√	√	×	×
private	√	×	×	×	×

 

9、封裝

對屬性的封裝，私有（private）的屬性，公開（public）的方法（getter & setter）

Account類

public class Account {   private String id; private String name; private String pwd; private double balance;   public void setBalance(double balance){ this.balance = balance; }   public double getBalance(){ return balance; }   }

Test類

public static void main(String[] args) { Account a = new Account(); a.setBalance(-20); double d= a.getBalance(); System.out.println(d); }

 

10、繼承

（1）概念

當多個類中具備相同的屬性和行爲時，能夠把這些相同的元素抽取到一個類中，多個類繼承這一個類，就具備了這些元素；

（2）子類的語法

[訪問修飾符]  class  子類的類名  extends  父類的類名{

}

子類能夠繼承父類全部非私有的屬性和方法；

當父類的方法沒法知足子類的需求時，子類能夠重寫父類的方法；

（3）重寫的規則

• 子類重寫方法的訪問修飾符必須大於等於父類方法的訪問權限；
• 聲明名部分必須和父類的方法保持一致（返回值，方法名，參數列表）；
• 子類繼承父類的方法，子類對象調用該方法時，執行的是父類的方法；
• 子類重寫父類的方法，子類對象調用該方法時，執行的是子類重寫後的方法；
• 子類重寫方法拋出的異常範圍不能大於父類；
• 在執行子類的構造方法以前，先執行父類的構造方法；
• super()指父類的構造方法，super(參數列表)是指父類的有參構造方法；在子類中若是沒有顯式的super()，程序執行時會默認建立；
• super()必須在子類的構造方法中第一行執行；
• 在父類中的this關鍵字，指的是子類的對象；父類中this()指的是當前類的無參構造方法；
• 子類不能繼承父類的構造方法；
• 當存在多重繼承關係時，先執行最高級別的父類，而後在依次向下執行；
• 在Java中的繼承關係是單繼承，一個子類只能有一個父類，可是父類能夠有多個子類；
• 當父類的屬性爲子類和父類共同享有時，不管在哪一個類中super.屬性，this.屬性，都是指父類中的那個屬性；

（4）子類建立的流程

若是父類和子類具備相同名稱的屬性，this.屬性是指當前類的屬性，super.屬性是指父類的屬性；

 

11、多態

實現多態的前提：

（1） 具備繼承關係；

（2） 子類重寫父類方法；

（3） 父類的引用指向子類的對象

語法：

父類類名  引用名 = new  子類構造器();

情景一：

Animal cat = new Cat(); Cat c = (Cat) cat;//cat對象是 Cat類的實例，程序不會出現異常 c.eat();

情景二：

Animal cat = new Cat(); Dog d = (Dog) cat;//cat對象不是Dog類的實例，會出現類型轉換異常 d.eat();

異常信息：

Exception in thread "main" java.lang.ClassCastException: com.zhidi.zoo.Dog cannot be cast to com.zhidi.zoo.Cat

 

在對象之間作強制類型轉換時，咱們要先判斷要強轉的對象是否爲某一類的實例，可使用instanceof關鍵字作驗證。

示例：

//父類的引用cat,指向子類的對象 cat --> 貓對象 Animal cat = new Cat();   //cat對象若是是Dog類的實例，則返回true，反之返回false  if(cat instanceof Dog){  Cat c = (Cat) cat; c.eat(); }else{ System.out.println("類型不匹配"); }

 

12、抽象類

（1）概念

• 沒有具體的功能，沒有方法體的方法就是抽象方法；
• 包含抽象方法的類，必定是抽象類，使用abstract關鍵字修飾；
• 抽象類和普通類相似，只是多了抽象方法而已；
• 抽象類不能被實例化對象，只能被繼承；
• 繼承抽象類的子類必須重寫抽象類中的全部抽象方法；
• 抽象類能夠用於聲明；
• 抽象類也能夠繼承於其餘類，成爲子類；

（2）語法

 

抽象方法：

[訪問修飾符]  abstract  返回值類型  方法名([參數列表]) ;

抽象類：

[訪問修飾符] abstract  class  類名 [extends 父類]{

}

 

13、接口

（1）概念

• 接口是定義程序開發中的規範，是更加抽象的抽象類；
• 聲明接口是使用interface關鍵字；
• 接口中只能聲明常量和抽象方法，能夠省略abstract關鍵字；
• 接口不能被實例化，只能被類實現，使用implements來實現接口；一個類能夠同時實現多個接口；
• 一個接口能夠繼承另外一個或多個接口，成爲子接口；
• 接口也是能夠被聲明爲變量的；

（2）語法

[訪問修飾符]  interface  接口名 [extends 父接口1,父接口2，……] {

[常量];

[抽象方法];

}

 

14、內部類

（1）成員內部類

聲明在類的內部，和外部類的成員屬性、成員方法屬於同一級別；

public class Outer {   //成員屬性 public int i = 1;   //成員方法 public void print(){   }   //成員內部類 public class Inner{ public int i = 2; public void abc(){ System.out.println(Outer.this.i);//指外部類的成員屬性i System.out.println(this.i);//指內部類的成員屬性i } }   }

實例化內部類：

public static void main(String[] args) { Outer o = new Outer(); Outer.Inner in = o.new Inner();//實例化內部類的對象 in.abc();   }

 

（2）靜態內部類

聲明在類的內部，使用static關鍵字修飾的類，叫靜態內部類。

public class Outer {   //靜態屬性屬於類的 public static int i = 0; public int j = 2;   //靜態方法，是屬於類的 public static void print(){   }   //靜態員內部類 public static class Inner{ public int i = 1; public void abc(){ System.out.println(i);//調用靜態內部中的屬性 System.out.println(Outer.i);//調用外部類的靜態屬性   Outer o = new Outer();//調用外部類的非靜態屬性 System.out.println(o.j); } }   }

實例化靜態內部類：

public static void main(String[] args) { Outer.Inner in = new Outer.Inner(); in.abc(); }

 

（3）局部內部類

聲明在外部類的成員方法或代碼塊中的類，稱爲局部內部類，其做用域範圍只存在於所處的方法內部，因此只能在其所處的方法中實例化對象。

public class Outer {   //成員屬性 public int i = 1;   //成員方法 public void print(){   int j = 2;//局部變量   //局部內部類 class Inner{ public int i = 3; public void abc(){ System.out.println(i);//指局部內部類Inner的成員屬性 System.out.println(Outer.this.i);//指外部類Outer的成員屬性 System.out.println(j);//指外部類Outer的print()中的局部變量 } }   Inner in = new Inner();//實例化局部內部類對象 in.abc(); }   }

執行局部內部類的方法：

public static void main(String[] args) { Outer o = new Outer(); o.print(); }

 

（4）匿名內部類

匿名內部類的聲明方式和局部內部類相同，匿名內部類沒有類名，實現匿名內部類的前提：必需要繼承一個類或實現一個接口，兩者選一。

語法：

 new  父類構造器(){

重寫父類後的方法；

};

示例：

抽象類Person:

public abstract class Person {   public abstract void eat();   }

匿名內部類：

Person p = new Person(){ @Override public void eat() { System.out.println("吃飯"); }   }; p.eat();

以上代碼，等同於如下代碼：

抽象類Person:

public abstract class Person {   public abstract void eat();   }

Man類繼承Person：

public class Man extends Person { @Override public void eat() { System.out.println("吃飯"); } }

測試類：

Person p = new Man(); p.eat();

 

匿名內部類的用途：

通常是用於實例化抽象類和接口的對象。

 

6、Java經常使用類庫

1、Object類

（1）toString()方法

Student類：

public class Student { public String name; public int age; public char gender; public Student(String name, int age, char gender) { super(); this.name = name; this.age = age; this.gender = gender; } public Student() { } }

測試類：

Student s1 = new Student(); s1.name = "張三";   //直接輸出對象名，是默認調用的Object類的toString()方法 System.out.println(s1);  System.out.println(s1.toString());   //toString()方法返回值的得到詳解 String name = s1.getClass().getName();//得到類的全路徑； String haxi = Integer.toHexString(s1.hashCode());//獲得對象的16進製表示的哈希值 String toString = name+"@"+haxi;//對象的內存地址：對象的全路徑 + @ + 16進制哈希值 System.out.println(toString);

 

（2）equals()方法

重寫Object類的equals()方法，能夠對比兩個對象內部的屬性，經過對比屬性來判斷兩個對象是否表示同一個事物。

2、字符串操做

（1）String類

• 構造方法：

² String(char[]  value) 把char[]數組轉爲字符串類型

² String(String  str)

• 經常使用方法：

² charAt(int  index) 根據下標（index）返回對應的字符

² contains(CharSequence  c) 判斷字符串中是否包含指定內容

² endsWith(String  s) 判斷是否以指定內容結束

² startsWith(String  s) 判斷是否以指定內容開始

² length() 返回字符串的長度（以字符爲單位）

² toString() 返回此字符串

² equals(Object  obj) 對比兩個字符串內容是否相等

² getBytes()  把字符串轉爲字節數組

² indexOf()  返回指定字符或字符串第一次出現的位置

² lastIndexOf() 返回指定字符或字符串最後一次出現的位置

² replace()  替換指定字符，返回新的字符串

² split()  按照指定的內容截取字符串，返回字符串數組

² subString() 按照下標截取字符串，返回子字符串

² toCharArray() 把字符串轉爲字符數組

² toLowerCase() 把字符串中的大寫轉爲小寫

² toUpperCase() 把字符串中的小寫轉爲大寫

² trim()  清除字符串先後的空格

² valueOf() 把指定內容轉爲字符串

（2）StringBuffer/StringBuilder類

以StringBuffer爲例：

• 經常使用方法：

² append() 追加

² delete(int start,int end) 刪除，包含開始下標，不包含結束下標

² insert(int index,Object obj) 插入，插入到第index的下標位置，obj是插入內容

（3）String、StringBuffer和StringBuilder的區別

 

 

• String對象能夠指向字面常量，字面常量是存儲在常量池中，一旦建立內容不可修改；
• StringBuffer和StringBuilder是以對象的形式建立，建立的字符串是能夠修改的；
• StringBuffer是線程安全的，StringBuilder是線程不安全的，StringBuilder的存儲速度比StringBuffer要快；

 

3、基本數據類型的包裝類

Character：

char c = 'A';   Character ch = new Character(c);//封箱 Character ch1 = Character.valueOf(c);//封箱   System.out.println("是否爲數字："+Character.isDigit(c)); System.out.println("是否爲非數字和標點："+Character.isLetter(c)); System.out.println("是否爲空格："+Character.isWhitespace(c)); System.out.println("是否爲大寫字母："+Character.isUpperCase(c)); System.out.println("是否爲小寫字母："+Character.isLowerCase(c)); System.out.println("轉爲大寫："+Character.toUpperCase(c)); System.out.println("轉爲小寫："+Character.toLowerCase(c));

 

4、Date類

// long time = System.currentTimeMillis();   long time = 1488935537022L; long time2 = 1488935537023L;   Date d = new Date(time); Date d2 = new Date(time2);   System.out.println(d.before(d2));

 

補充：

//得到時區對象 TimeZone tz = TimeZone.getDefault();   //得到全部時區ID String[] str = TimeZone.getAvailableIDs();   for (String id : str) {             //根據時區id來得到此TimeZone對象 TimeZone zone = TimeZone.getTimeZone(id); System.out.println(id+"--->"+zone.getDisplayName()); }   //設置時區 TimeZone timzone = TimeZone.getTimeZone("Africa/Abidjan");//得到格林威治時區對象 TimeZone.setDefault(timzone);   long time = 0; Date date = new Date(time); System.out.println(date);

5、日期格式化

long time = 0L; Date d = new Date(time);   //按照給定的模式，格式化時間對象 SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); String date = sdf.format(d); System.out.println(date);   //得到當前時間 System.out.println(sdf.format(new Date()));

6、Calendar類

//得到日曆對象 Calendar c = Calendar.getInstance(); // c.set(2017, 3, 8,12,20,30);//設置時間，若是沒有設置時間，默認爲當前時間   //添加時間 // c.add(Calendar.MONTH, 100);//若是日後推算，用正數，往前推算用負數 // c.add(Calendar.HOUR_OF_DAY, 20);   System.out.println("年："+c.get(Calendar.YEAR));//年 System.out.println("月："+(c.get(Calendar.MONTH)+1));//月，從0開始計算 System.out.println("日："+c.get(Calendar.DAY_OF_MONTH));//日 System.out.println("時："+c.get(Calendar.HOUR_OF_DAY));//時 System.out.println("分："+c.get(Calendar.MINUTE));//分 System.out.println("秒："+c.get(Calendar.SECOND));//秒 System.out.println("星期："+(c.get(Calendar.DAY_OF_WEEK)-1));//星期(這周的第幾天，從週日開始算爲第1天)   //把日曆對象轉爲Date對象 Date date = c.getTime(); //格式化Date對象 SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日E  HH:mm:ss"); System.out.println(sdf.format(date));

得到字段的最大/最小值：

//返回指定字段的最大值 int i = c.getActualMaximum(Calendar.DAY_OF_YEAR); //返回指定字段的最小值 int j = c.getActualMinimum(Calendar.DAY_OF_YEAR);

格里高利日曆對象：

//得到日曆對象 Calendar cal = Calendar.getInstance(); //設置指定日曆字段的具體值 cal.set(Calendar.YEAR, 2020); //Calendar類中表示年份的字段 int yearField = Calendar.YEAR; //得到當前日曆對象中的年份數據 int year = cal.get(yearField);   //實例化格里高利日曆對象 GregorianCalendar gc = new GregorianCalendar(); //判斷Calendar日曆對象中的年份是否爲閏年 boolean b = gc.isLeapYear(year);   if(b){ System.out.println(year+"年是閏年"); }else{ System.out.println(year+"年是平年"); }

 

7 、日期解析

//得到一個具體時間 Scanner sc = new Scanner(System.in); System.out.println("請輸入一個日期："); String str = sc.nextLine();   //按照獲取的時間格式來設定解析模式 SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy"); //解析時間字符串 Date d = sdf.parse(str);   System.out.println(d);

8、正則表達式

正則符號：

含義	符號
數字	[0-9]   \\d
字母	[a-zA-Z]
空白字符	[ \n\t\r\f\x0B]
表示非	[^規則]
任意字符（換行除外）	. (點)
正則開始	^
正則結束	$

正則數量：

符號	含義
+	n≥1   1到多個
*	n≥0   0到多個
?	0≤ n ≤1   0或1個
{n}	n個
{n,}	n ≤    n到多個
{n,m}	n≤ num ≤m   n到m個

正則邏輯：

含義	符號
分組	()
或	|
且	什麼都不寫

示例1：

//要驗證的字符串 String str = "abc123ABC"; //[]內放的是匹配的規則 boolean b = str.matches("^[a-zA-Z0-9]{6,8}$"); if(b){ System.out.println("匹配"); }else{ System.out.println("不匹配"); }

示例2：

String str = "abc12bA"; //必須是包含大寫、小寫、數字，必須以大寫字母開頭，6-8位 //boolean b = str.matches("^([A-Z])(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])[a-zA-Z0-9]{5,7}$");   //必須是包含大寫、小寫、數字，6-8位 boolean b = str.matches("^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])[a-zA-Z0-9]{6,8}$");   if(b){ System.out.println("匹配"); }else{ System.out.println("不匹配"); }

 

7、異常處理

1、異常的層級關係

 

2、常見異常類

（1）ArithmeticException 算術異常

int i,j; i = 1; j = 0; System.out.println(i/j);

（2）NullPointerException 空指針異常

String s = null; System.out.println(s.toString());

（3）ArrayIndexOutOfBoundsException 數組下標越界異常

int[] arr = new int[5]; System.out.println(arr[-5]);

（4）StringIndexOutOfBoundsException 字符串下標越界異常

String s = "hello"; char c = s.charAt(6); System.out.println(c);

（5）InputMismatchException 輸入不匹配異常

Scanner sc = new Scanner(System.in); int i = sc.nextInt(); System.out.println(i);

（6）ParseException 解析時異常

Scanner sc = new Scanner(System.in); System.out.println("請輸入一個日期："); String date = sc.nextLine(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); Date date2 = sdf.parse(date); System.out.println(date2);

（7）ClassCastException 類型轉換異常

//父類的引用指向子類的對象，o執行的是Integer對象 Object o = new Integer(1); //能夠強轉爲int類型 // int i = (int) o; //不能再強轉爲String類型 String s = (String) o; System.out.println(s);

3、異常處理的方式

（1）使用try-catch-fiannly 語句捕獲異常

int i,j; i = 1; j = 0; try{//可能會出現問題的代碼 System.out.println(i/j);   String s = null; System.out.println(s.toString());   Object o = new Integer(1); String str = (String) o; System.out.println(str); }catch(ArithmeticException e){//捕獲相關問題 //解決異常的代碼 e.printStackTrace();//打印追蹤異常信息 }catch(NullPointerException e){ //解決異常的代碼 }catch(Exception e){ //解決異常的代碼 }finally{ //不管是否出現異常，finally語句塊始終會被執行 }   System.out.println("程序結束");

注意：當有多個catch語句塊時，捕獲異常的順序應該爲由小到大，子類異常在前，父類異常在後

（2）使用throws拋出異常

語法：

[訪問修飾符]  返回值類型  方法名(參數列表)  throws  異常類{

//執行的代碼

//存在異常狀況的代碼語句

}

public static void main(String[] args) {   Test t = new Test(); int i = t.abc(1, 0); System.out.println(i);   System.out.println("main方法結束"); }   //除法運算 public int abc(int cs,int bcs) throws ArithmeticException{ if(bcs == 0){ throw new ArithmeticException("b除數不能爲0"); } int rel = cs / bcs; System.out.println("abc方法結束"); return rel; }

 

4、自定義異常類

語法：

[訪問修飾符]  class  類名  extends  異常父類(Exception){

}

public class SuanShuException extends Exception {   public SuanShuException(String mess) { super(mess); }   }

使用：

public static void main(String[] args) throws SuanShuException {   Test t = new Test(); int i = t.abc(1, 0); System.out.println(i);   System.out.println("main方法結束"); }   //除法運算 public int abc(int cs,int bcs) throws SuanShuException{ if(bcs == 0){ throw new SuanShuException("b除數不能爲0"); } int rel = cs / bcs; System.out.println("abc方法結束"); return rel; }

 

8、集合

1、序列ArrayList類

規則：聲明時無需定義長度，使用get()方法經過下標取值，是有順序的。

經常使用方法：

（1） add(Object  obj) 添加，能夠添加任意對象類型

（2） addAll(Collection<E>  c) 添加集合

（3） get(int  index) 根據下標獲取對應的值

（4） size() 得到序列的長度

（5） set(int index,Object obj) 修改序列中指定下標的內容，返回被修改的對象

（6） clear() 清除序列中全部的數據

（7） remove(int index) 根據下標刪除對應數據

（8） remove(Object obj) 根據對象刪除對應數據，返回boolean類型，刪除成功返回true，反之爲false

（9） iterator()  迭代器，遍歷集合，返回Iterator<E>類型

（10） contains(Object obj) 判斷集合中是否包含某對象，判斷的是地址

添加方法：

ArrayList list = new ArrayList();//序列 //增 list.add(1); list.add(2); list.add(3); list.add(0,4); //把4添加到下標爲0的位置

 

Student s1 = new Student("張三",20); Student s2 = new Student("李四",22); Student s3 = new Student("王五",23); //泛型，規定集合中只能存放哪一種類型的元素 List<Student> list = new ArrayList<Student>();//使用多態   //增 list.add(s1); list.add(s2); list.add(s3);   Student s4 = new Student("Tom",20); Student s5 = new Student("Jack",22); Student s6 = new Student("Lily",23); Student[] arry = {s4,s5,s6};   // List<Student> list2 = new ArrayList<Student>(); // list2.add(s4); // list2.add(s5); // list2.add(s6);   //把數組轉爲集合，添加到list中 list.addAll(Arrays.asList(arry));

 

修改方法：

Student s4 = new Student("小明",22); Object obj = list.set(3, s4); //修改爲功，返回被修改的對象

刪除方法：

// list.clear(); // list.remove(3); //根據下標刪除 boolean b = list.remove(s2); //根據對象刪除，刪除成功返回true

查詢方法：

for (Object obj : list) { System.out.println(obj); }

 

for (int i = 0; i < list.size(); i++) { Integer index = (Integer) list.get(i); System.out.println(index); }

使用迭代器遍歷：

Student s1 = new Student("張三",20); Student s2 = new Student("李四",22); Student s3 = new Student("王五",23);   //泛型，規定集合中只能存放哪一種類型的元素 List<Student> list = new ArrayList<Student>();//使用多態   //增 list.add(s1); list.add(s2); list.add(s3);   //使用迭代器查詢 Iterator<Student> it = list.iterator(); while(it.hasNext()){ Student stu = it.next(); System.out.println(stu.getName()); }

 

 

集合與數組的轉換：

//數組轉爲集合 List<Student> stuList = Arrays.asList(arry);   //把集合轉爲數組 Object[] stuArry =  list.toArray(); for (Object obj : stuArry) { if(obj instanceof Student){ Student s = (Student) obj; System.out.println(s.getName()); } }

 

2、set集中HashSet類

概念：set集是無序的，不可重複的。

經常使用方法：

（1） add(Object obj) 添加對象

（2） addAll(Collection<E> c) 添加集合

（3） contains(Object obj) 判斷集合中是否存在某對象

（4） isEmpty()  判斷集合中是否有元素

（5） iterator() 使用迭代器遍歷集合

（6） remove(Object obj) 刪除指定對象

（7） size()  返回集合的長度

添加方法：

Student s1 = new Student("張三",20); Student s2 = new Student("李四",22); Student s3 = new Student("王五",23);   Set<Student> set = new HashSet<Student>();   //添加方法 set.add(s1); set.add(s2); set.add(s3);

 

Student s4 = new Student("Tom",20); Student s5 = new Student("Jack",22); Student s6 = new Student("Lily",23);   // List<Student> list = new ArrayList<Student>(); // list.add(s4); // list.add(s5); // list.add(s6);   // Student[] arry = {s4,s5,s6}; // List<Student> list = Arrays.asList(arry);   Set<Student> stuSet = new HashSet<Student>(); stuSet.add(s4); stuSet.add(s5); stuSet.add(s6);   set.addAll(stuSet);

修改方法：

//間接修改集合元素 //先遍歷集合中全部元素 for (Student stu : stuSet) { //判斷查詢的對象中是否包含名字爲「Tom」的學生 if(stu.getName().equals("Tom")){ //若是存在該學生，將其刪除 boolean b = set.remove(stu); if(b){ //刪除成功，添加新對象 set.add(new Student("HanMeimei",20)); } } }

刪除方法：

//根據對象的屬性刪除指定元素  Iterator<Student> it = set.iterator(); while(it.hasNext()){//遍歷全部元素 Student stu = it.next(); if(stu.getName().equals("張三")){//判斷指定的學生對象 it.remove();//調用Iterator對象的remove()方法刪除 } }   //清除集合中全部元素 set.clear();   //刪除集合中指定元素 set.remove(obj);

查詢方法：

//使用foreach查詢 for (Student stu : set) { System.out.println(stu.getName()); }   //使用迭代器查詢 Iterator<Student> it = set.iterator(); while(it.hasNext()){ Student stu = it.next(); System.out.println(stu.getName()); }

3、Collection接口思惟導圖

 

4、集合排序

Collections.sort(list);//升序 Collections.reverse(list);//倒置 Collections.shuffle(list);//隨機排

 

 

 

5、Map映射

Map是以鍵值對的形式存在的，語法：Map<Key,Value>，鍵是不可重複，值能夠重複，即一個鍵對應一個值，每一個值能夠有多個鍵。

經常使用方法：

（1） put(Object  key,Object  value) 添加方法

（2） putAll(Map<K,V>  m)  添加map集合

（3） get(Object  key) 經過鍵查詢對應值

（4） size()  返回map集合中元素的個數

（5） remove(Object key) 經過鍵刪除元素，返回被刪除元素的值

（6） clear()  清空全部元素

（7） keySet() 返回全部鍵的集合

（8） entrySet() 返回全部鍵值對映射項的集合，使用Entry對象中的getKey()和getValue()方法分別得到鍵和值

（9） containsKey(Object  key) 判斷map集合中是否包含某個鍵

（10） containsValue(Object  value) 判斷map集合中是否包含某個值

（11） values()  返回map集合中值的Collection集合

（12） isEmpty() 判斷map集合中是否存在映射項，沒有返回true

添加方法：

Map<Integer,String> map = new HashMap<Integer,String>();   //添加 map.put(1, "張三"); map.put(2, "李四"); map.put(3, "王五"); map.put(4, "趙六");   //經過鍵查詢對應的值  String s = map.get(1); System.out.println(s);

修改方法：

String s1 = map.put(1, "張三"); System.out.println(s1); //s1 = null，由於這是第一次添加 String str = map.put(1,"Tom"); System.out.println(str); //str = 「張三」，返回本次修改前的值 String str2 = map.put(1,"Jack"); System.out.println(str2); //str2 = 「Tom」

刪除方法：

//清空全部元素 map.clear(); //根據鍵刪除元素 String s = map.remove(1);//返回的是被刪除元素的值

經過值刪除元素：

Map<String,String> map2 = new HashMap<String,String>(); map2.put("校長", "Tom"); map2.put("主任", "Tom"); map2.put("老師", "Lily"); map2.put("副校長", "Tom");   System.out.println("刪除前map的長度："+map2.size());   Set<String> set = map2.keySet(); Set<String> temp = new HashSet<String>();//存要刪除的鍵  for (String s : set) { String name = map2.get(s);//根據鍵得到值 if(name.equals("Tom")){//判斷值是否知足條件 temp.add(s);//把該值映射的鍵存到臨時的集合中 } } System.out.println("要刪除元素的個數："+temp.size());   //經過鍵刪除map集合中的元素 for (String key : temp) { String v = map2.remove(key); System.out.println(v+"被刪除了"); }   System.out.println("刪除後map的長度："+map2.size());

查詢方法：

//查詢全部元素 Set<Integer> set = map.keySet();//把全部的鍵以set集合形式返回 for (Integer i : set) { String str = map.get(i); System.out.println(i+":"+str); }   //把map集合中的鍵值對項做爲對象，以set集合來存儲這些鍵值對項 Set<Entry<Integer,String>> set = map.entrySet(); for (Entry<Integer, String> entry : set) { System.out.println(entry.getKey()+":"+entry.getValue()); }

6、集合中對象的排序

步驟：

（1） 實體類要實現Comparable<T>接口，並重寫compareTo()方法

（2） 實例化對象存到List集合，調用Collections.sort(list)方法進行排序

示例：

Student類

public class Student implements Comparable<Student> { private String name; private String className; private Double cj; //基本數據類型要用封裝類的對象纔可使用compareTo()方法排序 @Override public int compareTo(Student o) { return cj.compareTo(o.cj); } }

Test類

List<Student> list = new ArrayList<Student>(); list.add(new Student("Tom","java",90)); list.add(new Student("Jack","php",91)); list.add(new Student("Lilei","css",92)); list.add(new Student("Luch","html",80));   Collections.sort(list);

 

9、IO流

1、File類

經常使用方法：

（1） createNewFile() 建立文件

（2） mkdir() 建立目錄

（3） mkdirs() 建立多級目錄

示例：

File f = new File("F:\\abc\\a");   boolean b = f.createNewFile();//建立文件   boolean b = f.mkdir();//建立目錄   boolean b = f.mkdirs();//建立多級目錄   System.out.println(b);

 

File f = new File("F:\\demo.txt"); if(!f.exists()){ boolean b = f.createNewFile(); if(b){ System.out.println("文件建立成功"); } }else{ System.out.println("文件已存在"); boolean b = f.delete(); if(b){ System.out.println("文件被刪除"); } }

 

2、RandomAccessFile類

輸入流：數據從硬盤流向內存，read

輸出流：數據從內存流向硬盤，write

示例：

File f1 = new File("E:\\11.mp4"); File f2 = new File("F:\\22.mp4");   RandomAccessFile r1 = new RandomAccessFile(f1, "rw"); RandomAccessFile r2 = new RandomAccessFile(f2, "rw");   int i;//用來存儲讀取的每個字節 while((i=r1.read()) != -1){//從f1文件對象讀取1個字節，把該字節賦值給變量i r2.write(i);//把f1對象讀到1個字節寫到f2文件對象 }   //關閉資源 r1.close(); r2.close();

 

 

3、IO流

（1）字節流

• 字節輸入流：InputStream，全部字節輸入流的父類

² 子類：FileInputStream

// File f = new File("F:\\abc.txt"); FileInputStream fis = new FileInputStream("F:\\abc.txt"); byte[] b = new byte[1024];//每次讀取1024個字節 int len; while((len = fis.read(b)) != -1){ //解碼byte數組從下標0開始，到讀取字節數減1的位置 String s = new String(b,0,len); System.out.println(s); }   //關閉資源 fis.close();

• 字節輸出流：OutputStream，全部字節輸出流的父類

² 子類：FileOutputStream

FileOutputStream fos = new FileOutputStream("F:\\demo.txt");   String s = "abcdefg"; fos.write(s.getBytes());   fos.close();

 

示例：

FileInputStream fis = new FileInputStream("E:\\11.mp4"); FileOutputStream fos = new FileOutputStream("F:\\11.mp4");   byte[] b = new byte[1024];//每次讀的字節數 int i; while( (i=fis.read(b)) != -1){ fos.write(b); }   //關閉資源 fis.close(); fos.close();

（2）序列化和反序列化（對象流）

在作序列化以前，實體類要先實現Serializable接口。

先序列化（保存對象文件），再作反序列化（讀取對象文件）。

Student類：

public class Student implements Serializable{ public String name; public int age; public String gender;   public Student() { }   public Student(String name, int age, String gender) { super(); this.name = name; this.age = age; this.gender = gender; }   @Override public String toString() { return "Student [name=" + name + ", age=" + age + ", gender=" + gender + "]"; }   }

序列化：

//要序列化的對象，能夠是數組、集合、實體對象 Student[] stu = {new Student("張三",20,"男"),new Student("李四",22,"男"),new Student("王五",26,"男"),new Student("趙六",20,"男")}; List<Student> list = Arrays.asList(stu);   FileOutputStream fos = new FileOutputStream("F:\\stu.cctv"); ObjectOutputStream oos = new ObjectOutputStream(fos);   oos.writeObject(list);   //關閉資源 oos.close(); fos.close();

反序列化：

FileInputStream fis = new FileInputStream("F:\\stu.cctv"); ObjectInputStream ois = new ObjectInputStream(fis);   // Student stu = (Student) ois.readObject();   // Student[] stu = (Student[]) ois.readObject(); // for (Student student : stu) { // System.out.println(student); // }   List<Student> list = (List<Student>) ois.readObject(); for (Student student : list) { System.out.println(student); }   //關閉資源 ois.close(); fis.close();

 

（3）字符流

字符輸入流：Reader，InputStreamReader子類

InputStreamReader isr = new InputStreamReader(new FileInputStream("F:\\abc.txt"));   StringBuffer sb = new StringBuffer(); char[] c = new char[1024]; int i; while((i=isr.read(c)) != -1){ sb.append(c); }   System.out.println(sb.toString());   isr.close();

 

字符輸出流：Writer，OutputStreamWriter

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("F:\\demo.txt")); osw.write("智遞科技"); osw.close();

文件複製示例：

InputStreamReader isr = new InputStreamReader(new FileInputStream("E:\\2.doc"),"ISO-8859-1"); OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("F:\\2.doc"),"ISO-8859-1");   //讀取到內存 char[] c = new char[1024]; int i; while((i=isr.read(c)) != -1){ osw.write(c); }   isr.close(); osw.close();

 

（4）緩衝流

緩衝輸入流：BufferedReader

//緩衝流-->字符輸入流-->字節流 // BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("F:\\練習.txt")));   //緩衝流-->字符流，FileReader是InputStreamReader的子類 BufferedReader br = new BufferedReader(new FileReader("F:\\練習.txt")); String str; while((str=br.readLine()) != null){ System.out.println(str); }   br.close();

緩衝輸出流：BufferedWriter

//緩衝流-->字符流-->字節流 // BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("F:\\abc.txt")));   BufferedWriter bw = new BufferedWriter(new FileWriter("F:\\abc.txt")); bw.write("智遞\r\n智遞");//  \r\n表示換行   bw.close();

 

10、多線程

1、語法

（1）繼承Thread類

步驟：

• 自定義線程類，繼承Thread類；
• 重寫run方法，線程中要執行的內容，寫到run方法中；
• 實例化自定義線程；
• 使用線程對象調用start方法；

示例：

public class A extends Thread{   @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println("i="+i); } }   }

Test類：

A a = new A(); a.start();//啓動線程

 

（2）實現Runnable接口

步驟：

• 自定義線程類，實現Runnable接口；
• 重寫run方法；
• 實例化自定義線程對象；
• 實例化Thread對象，把線程對象做爲參數；
• 使用Thread對象調用start方法；

示例：

public class A implements Runnable{ @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println("i="+i); } } }

Test:

// Runnable a = new A();//多態，父類的引用指向子類對象 A a = new A(); Thread t1 = new Thread(a); t1.start();//啓動線程

 

2、線程生命週期

（1）新建狀態，線程對象建立；

（2）就緒狀態，執行start方法後；

（3）執行狀態，得到CPU資源後，開始執行run方法；

（4）阻塞狀態，CPU資源過時後，從新回到就緒狀態，等待CPU下次分配資源；

（5）終止狀態，run方法執行結束後；

3、經常使用方法

（1）Sleep(long ms) 睡眠方法，靜態方法能夠直接用類名調用

示例：

public void run() { for (int i = 0; i < 1000; i++) { System.out.println("i="+i); if(i==500){ try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } } }

 

（2）currentThread() 返回當前線程對象

@Override public void run() { Thread t = Thread.currentThread(); for (int j = 0; j < 1000; j++) { System.out.println(t.getName()+"="+j); } }

（3）getName 得到當前線程名稱

（4）setName 設置線程名稱

Thread t1 = new Thread(a); t1.setName("線程A"); t1.start();//啓動線程

（5）getID 得到當前線程的惟一標識

（6）getPriority() 得到當前線程的優先級

（7）setPriority(int  i) 設置當前線程的優先級

4、線程同步

概念：

被多線程併發訪問時若是一個對象有可能出現數據不一致的問題,那麼這個對象稱爲線程不安全的對象。

解決：

在須要同步的方法聲明部分添加synchronized修飾符；

或者是

Synchronized（對象）{

同步的代碼；

}

示例：

Bank類：

public class Bank {   public double balance;//餘額   public Bank(double money){ this.balance = money; }   //取錢 // public synchronized void getMoney(double money){ // System.out.println(Thread.currentThread().getName()+"查詢當前餘額爲"+balance+"元"); // balance -= money;//取錢 // System.out.println(Thread.currentThread().getName()+"取了"+money+"元，取款後餘額爲"+balance+"元"); // }   public void getMoney(double money){ synchronized (this) {//this指當前對象 System.out.println(Thread.currentThread().getName()+"查詢當前餘額爲"+balance+"元"); balance -= money;//取錢 System.out.println(Thread.currentThread().getName()+"取了"+money+"元，取款後餘額爲"+balance+"元"); }   }   }

取錢的線程類：

public class Qu extends Thread{   public Bank bank; public double money;   /**  * 構造方法  * @param bank 要操做的帳戶  * @param money 取款金額  */ public Qu(Bank bank,double money){ this.bank = bank; this.money = money; }   @Override public void run() { bank.getMoney(money); }   }

測試類：

Bank b = new Bank(1000);   //你用網銀取款 Qu wy = new Qu(b,100); wy.setName("網銀");   //你媽在家用支付寶取款 Qu zfb = new Qu(b,100); zfb.setName("支付寶");   //你媳婦在單位用微信取款 Qu wx = new Qu(b,100); wx.setName("微信");   wy.start(); zfb.start(); wx.start();

 

11、配置文件操做

1、XML文件

（1）使用pull方式解析

//1.建立解析工廠對象 XmlPullParserFactory xmlFactory = XmlPullParserFactory.newInstance();   //2.得到解析器對象 XmlPullParser xmlParser = xmlFactory.newPullParser();   //3.指定資源路徑 FileReader fr = new FileReader("F:\\book.xml"); xmlParser.setInput(fr);   int event = xmlParser.getEventType(); while(event != END_DOCUMENT){ switch(event){ case START_DOCUMENT://文檔開始 System.out.println("=====開始解析文檔======"); break; case START_TAG://標籤開始 String tagname = xmlParser.getName();//得到標籤名稱 switch(tagname){ case "name": String name = xmlParser.nextText(); System.out.println(name); break; case "jiage": String jiage = xmlParser.nextText(); System.out.println(jiage); break; case "zz": String zz = xmlParser.nextText(); System.out.println(zz); break; case "cb": String cb = xmlParser.nextText(); System.out.println(cb); break; } break; case END_TAG://標籤結束 tagname = xmlParser.getName(); System.out.println("======文檔解析結束======="); break; }   event = xmlParser.next();//獲取下一個事件   }

 

（2）使用pull方式寫入

 

//1.建立解析工廠 XmlPullParserFactory xmlFactory = XmlPullParserFactory.newInstance();   //2.建立序列化對象 XmlSerializer xmls = xmlFactory.newSerializer();   //3.指定文件資源 FileWriter fw = new FileWriter("F:\\stu.xml"); xmls.setOutput(fw);   xmls.startDocument("utf-8", false);//生成xml文檔頭信息 xmls.startTag(null, "student");//student標籤開始 xmls.startTag(null, "id");//id標籤開始 xmls.text("1234");//文本內容 xmls.endTag(null, "id");//id標籤結束 xmls.endTag(null, "student");//student標籤結束 xmls.endDocument();//文檔結束

 

2、json文件

（1）使用gson方式解析

//1.實例化解析對象 JsonParser jp = new JsonParser();   //2.讀取要解析的json文件 FileReader fr = new FileReader("F:\\stu.json");   //3.解析json文件 JsonObject jo = (JsonObject) jp.parse(fr);   System.out.println("姓名："+jo.get("name").getAsString()); System.out.println("年齡："+jo.get("age").getAsDouble()); System.out.println("是否有車："+jo.get("car").getAsBoolean());   //獲取數組 JsonArray jarr = jo.get("hobby").getAsJsonArray(); for (int i = 0; i < jarr.size(); i++) { JsonObject j = (JsonObject)jarr.get(i); System.out.println("id:"+j.get("id").getAsString()); }

 

（2）寫入json文件

//1.建立json對象 JsonObject jo = new JsonObject();   //2.添加鍵值對 jo.addProperty("name", "張三"); jo.addProperty("age", 20); jo.addProperty("car", true);   JsonObject hobby1 = new JsonObject();//數組中的第1個元素 hobby1.addProperty("id", "java");   JsonObject hobby2 = new JsonObject();//數組中的第2個元素 hobby2.addProperty("id", "php");   JsonArray ja = new JsonArray();//數組對象 ja.add(hobby1); ja.add(hobby2);   jo.add("hobby", ja);//把數組對象添加到json的hobby屬性中   //3.保存到json文件 FileOutputStream fos = new FileOutputStream("F:\\abc.json"); fos.write(jo.toString().getBytes()); fos.close();

 

3、properties文件

（1）解析properties

//1.實例化properties對象 Properties prop = new Properties();   //2.得到屬性文件 FileInputStream fis = new FileInputStream("F:\\stu.properties");   //3.使用屬性對象的load()方法獲取內容 prop.load(fis);   //4.根據鍵得到值 String name = prop.getProperty("userName"); System.out.println(name); String pwd = prop.getProperty("pwd"); System.out.println(pwd);   //5.關閉資源 fis.close();

（2）寫入properties

//1.建立properties對象 Properties prop = new Properties();   //2.指定輸出文件 FileOutputStream fos = new FileOutputStream("F:\\stu.properties");   //3.設置要輸出的屬性 prop.setProperty("userName", "java456"); prop.setProperty("pwd", "abc123");   //4.保存文件 prop.store(fos, "abc");   //5.關閉資源 fos.close();