1_JAVA語言概述

1.1 JAVA的總體概述

第一部分：編程語言的核心結構
主要知識點：變數、基礎語法、分支、回圈、陣列、流程控制、…
第二部分：JAVA面向物件的核心邏輯
主要知識點：封裝、繼承、多型、抽象、…
第三部分：JAVA SE 高級部分
主要知識點：集合、泛型、例外、反射、網路編程、I/O、多執行緒、…

1.2 JAVA語言概述

1.2.1 基礎常識

軟體：即一系列按照特定順序組織的計算機資料和指令的集合，分為：系統軟體 和 應用軟體
系統軟體：windows , mac os , linux ,unix,android,ios,…
應用軟體：word ,ppt,畫圖板,…
人機互動方式： 圖形化界面 OR 命令列方式

常用的DOS命令：

1.2.2 計算機語言的發展迭代史

1、機器語言

最初的計算機所使用的是由“0”和“1”組成的二進制數，二進制是計算機的語言的基礎，計算機發明之初，計算機只能被少部分人使用，人們需要用0、1組成的指令序列交由計算機執行，對于機器語言的使用與普及都是很令人頭疼的問題，對于程式的移植能力幾乎沒有，從而時間成本，人力成本十分昂貴，但機器語言也不是沒有優勢，由于這種語言是直接對計算機硬體進行操作，所以在特定型號的計算機上面，運算效率也是很高的，機器語言的出現對于未來的計算機語言發展起到了很好的推動作用，所以機器語言也是第一代計算機語言，

2、匯編語言

匯編語言是在機器語言的基礎上誕生的一門語言，用一些簡潔的英文字母、符號串來替代一個特定的指令的二進制串，這也提高了語言的記憶性和識別性，對于程式的開發與維護起到了積極作用，匯編語言同樣也是直接對硬體進行操作，這樣依然局限了它的移植性，但是使用匯編語言針對計算機特定硬體而編制的匯編語言程式，對于計算機硬體的功能和特長的發揮已有了很大進步，它精煉而質量高，所以至今仍是一種常用的程式開發語言，
　　
3、高級語言

從最初與計算機交流的痛苦經歷中，人們意識到，應該設計一種這樣的語言，這種語言接近于數學語言或人的自然語言，同時又不依賴于計算機硬體，編出的程式能在所有機器上通用，經過努力，1954年，第一個完全脫離機器硬體的高級語言—FORTRAN問世了，40多年來，共有幾百種高級語言出現，有重要意義的有幾十種，影響較大、使用較普遍的有FORTRAN、ALGOL、COBOL、BASIC、LISP、SNOBOL、PL/1、Pascal、C、PROLOG、Ada、C++、VC、VB、Delphi、JAVA等，高級語言的發展也經歷了從早期語言到結構化程式設計語言，從面向程序到非程序化程式語言的程序，相應地，軟體的開發也由最初的個體手作業坊式的封閉式？生產，發展為產業化、流水線式的工業化生產，

面向物件：Java,JS,Python,Scala,…
面向程序：C,Pascal、Fortran

1.2.3 Java語言版本迭代概述

1991年 Green專案，開發語言最初命名為Oak (橡樹)
1994年，開發組意識到Oak 非常適合于互聯網
1996年，發布JDK 1.0，約8.3萬個網頁應用Java技術來制作
1997年，發布JDK 1.1，JavaOne會議召開，創當時全球同類會議規模之最
1998年，發布JDK 1.2，同年發布企業平臺J2EE
1999年，Java分成J2SE、J2EE和J2ME，JSP/Servlet技術誕生
2004年，發布里程碑式版本：JDK 1.5，為突出此版本的重要性，更名為JDK 5.0
2005年，J2SE -> JavaSE，J2EE -> JavaEE，J2ME -> JavaME
2009年，Oracle公司收購SUN，交易價格74億美元
2011年，發布JDK 7.0
2014年，發布JDK 8.0，是繼JDK 5.0以來變化最大的版本
2017年，發布JDK 9.0，最大限度實作模塊化
2018年3月，發布JDK 10.0，版本號也稱為18.3
2018年9月，發布JDK 11.0，版本號也稱為18.9

1.2.4 Java語言應用的領域

Java Web開發：后臺開發
大資料開發：
Android應用程式開發：客戶端開發

1.2.5 Java語言的特點

面向物件性：
兩個要素：類、物件
三個特征：封裝、繼承、多型
健壯性：① 去除了C語言中的指標 ②自動的垃圾回識訓制 -->仍然會出現記憶體溢位、記憶體泄漏
跨平臺型：write once,run anywhere:一次編譯，到處運行
功勞歸功于：JVM

1.3 開發環境的搭建（重點）

1.3.1 JDK、JRE、JVM的關系

JDK = JRE + 集成開發工具
JRE = JVM + JAVA SE基礎類別庫

1.3.2 JDK的下載、安裝

下載：http://www.oracle.com/technetwork/java/javase/downloads/index.html
安裝：傻瓜式安裝：JDK 、JRE
注意問題：安裝軟體的路徑中不能包含中文、空格，

1.3.3 path環境變數的配置

1.3.3.1 為什么配置path環境變數？

path環境變數：windows作業系統執行命令時所要搜尋的路徑
為什么要配置path:希望java的開發工具（javac.exe,java.exe)在任何的檔案路徑下都可以執行成功，

1.3.3.2 如何配置？

找到環境變數

右鍵我的電腦點屬性：

點擊高級系統設定

選擇環境變數

配置系統環境變數

新建JAVA_HOME變數，變數值是JDK安裝的根目錄

在Path變數中添加JAVA_HOME

Path是原有變數，只能編輯，不要新建，

添加：%JAVA_HOME%\bin.并上移到第一位

環境變數配置成功之后，需要在cmd下運行javac和java命令出現如下影像代表配置成功

1.3.4 第一個JAVA程式

新建java源檔案，編譯java源檔案，運行位元組碼檔案
創建一個java源檔案：
HelloWorld.java

class HelloChina{
	public static void main(String[] args){
		System.out.println("Hello,World!");
	}
}

編譯源檔案使用javac命令

javac HelloChina.java

編譯成功后形成class檔案
運行可執行檔案

java HelloChina

運行結果：

1.3.5 注釋與API檔案等…

1.3.5.1 注釋:Comment

分類：

單行注釋：//
多行注釋：/*     */
檔案注釋：/**     */

作用：

① 對所寫的程式進行解釋說明，增強可讀性，方便自己，方便別人
② 除錯所寫的代碼
特點：

①單行注釋和多行注釋，注釋了的內容不參與編譯，
②多行注釋不可以嵌套使用

1.3.5.2 Java API 檔案

API: application programming interface，習慣上：將語言提供的類別庫，都稱為api.
API檔案：針對于提供的類別庫如何使用，給的一個說明書，類似于《新華字典》

1.3.5.3 良好的編程風格

1.3.5.4 EditPlus

EditPlus是一款由韓國 Sangil Kim （ES-Computing）出品的小巧但是功能強大的可處理文本、HTML和程式語言的Windows編輯器，你甚至可以通過設定用戶工具將其作為C,Java,Php等等語言的一個簡單的IDE，
官網下載： https://www.editplus.com/

2_JAVA的基礎語法

2.1 關鍵字與識別符號

2.1.1 java關鍵字的使用

定義：被Java語言賦予了特殊含義，用做專門用途的字串（單詞）
特點：關鍵字中所字母都為小寫

2.1.2 保留字：

	現Java版本尚未使用，但以后版本可能會作為關鍵字使用，
	具體哪些保留字：goto 、const
	注意：自己命名識別符號時要避免使用這些保留字

2.1.3 識別符號的使用

定義：凡是自己可以起名字的地方都叫識別符號，
涉及到的結構：
包名、類名、介面名、變數名、方法名、常量名
規則：(必須要遵守，否則，編譯不通過)

規范：（可以不遵守，不影響編譯和運行，但是要求大家遵守）

注意點：
在起名字時，為了提高閱讀性，要盡量意義，“見名知意”，

2.2 變數的使用和資料型別

2.2.1 變數的分類

按資料型別分類

詳細說明：

整型：

byte(1位元組=8bit) \ short(2位元組) \ int(4位元組) \ long(8位元組)
① byte范圍：-128 ~ 127
② 宣告long型變數，必須以"l"或"L"結尾
③ 通常，定義整型變數時，使用int型，
④整型的常量，默認型別是：int型

浮點型 :

float(4位元組) \ double(8位元組)
① 浮點型，表示帶小數點的數值
② float表示數值的范圍比long還大
③ 定義float型別變數時，變數要以"f"或"F"結尾
④ 通常，定義浮點型變數時，使用double型，
⑤浮點型的常量，默認型別為：double

字符型

char (1字符=2位元組)
① 定義char型變數，通常使用一對’’,內部只能寫一個字符
② 表示方式：1.宣告一個字符 2.轉義字符 3.直接使用 Unicode 值來表示字符型常量

布爾型

boolean
① 只能取兩個值之一：true 、 false
② 常常在條件判斷、回圈結構中使用

按宣告的位置分類(了解)

2.2.2 定義變數的格式

資料型別 變數名 = 變數值;

 int one = 100;

資料型別 變數名;
變數名 = 變數值;

  int one;
  one = 100;

2.2.3 變數使用的注意點：

① 變數必須先宣告，后使用
② 變數都定義在其作用域內，在作用域內，它是有效的，換句話說，出了作用域，就失效了
③ 同一個作用域內，不可以宣告兩個同名的變數

2.2.4 基本資料型別變數間運算規則

涉及到的基本資料型別：除了boolean之外的其他7種
自動型別轉換(只涉及7種基本資料型別）
結論：當容量小的資料型別的變數與容量大的資料型別的變數做運算時，結果自動提升為容量大的資料型別，
byte 、char 、short --> int --> long --> float --> double
特別的：當byte、char、short三種型別的變數做運算時，結果為int型
說明：此時的容量大小指的是，表示數的范圍的大和小，比如：float容量要大于long的容量

強制型別轉換(只涉及7種基本資料型別）：自動型別提升運算的逆運算，
1.需要使用強轉符：()
2.注意點：強制型別轉換，可能導致精度損失，

2.2.5 String與8種基本資料型別間的運算

1. String屬于參考資料型別,翻譯為：字串
2. 宣告String型別變數時，使用一對""
3. String可以和8種基本資料型別變數做運算，且運算只能是連接運算：+
4. 運算的結果仍然是String型別
   避免：

String s = 123;//編譯錯誤
String s1 = "123";
int i = (int)s1;//編譯錯誤

2.3 進制（只做了解）

編程中涉及的進制及表示方式：

二進制的使用說明：

計算機底層的存盤方式：所有數字在計算機底層都以二進制形式存在，
二進制資料的存盤方式：所有的數值，不管正負，底層都以補碼的方式存盤，
原碼、反碼、補碼的說明：
正數：三碼合一
負數：

2.4 運算子

算術運算子：
+ - * / % ++ –

%運算只能在整數型時使用，浮點數不適用，

++前 是變數先自加再運算，后++ 是變數先運算在自加，

賦值運算子：
= += -= *= /= %=

=運算子右側會出現四種情況

int i = 100;// 常量值賦值，什么型別的常量值賦值給什么型別的變數，
int i = 100 + 50;// 運算式運算結果賦值，
int j = i;// 變數給變數賦值，值傳遞，
double d = Math.random();// 方法的回傳值賦值，
one += 10 等同于 one = one + 10;

關系運算子：
< > <= >= == !=

關系運算子連接的關系運算式，關系運算式的結果是boolean，

邏輯運算子：
邏輯運算子的作用是連接多個關系運算式，& | ^ ! && ||

&符號：左右兩端的關系運算式同時回傳true的時候整個運算式回傳true，有一端回傳false則整個運算式是false，

|符號：左右兩端有一端是回傳true則整個運算式回傳true，只有兩端同時回傳false整個運算式才回傳false，

^符號：異或就是找不同，左右兩端的運算式回傳的結果不一樣，則回傳true，左右兩端回傳的結果一樣則回傳false，

！：反轉一個boolean運算式的結果，true變false，false變true，

&&：短路與，短路與左側關系運算式為false則右側關系運算式將不再運算，

||：短路或，短路或左側運算式回傳為true則右側運算式不再運算，

三目運算子：
？：，問號左側是一個boolean運算式，當boolean運算式的結果是true 則執行：號左側的運算式，回傳false則執行：右側的運算式，

位運算子（了解）：
& | ^ ~ << >> >>> 對于數學運算，位運算的效率更高，位運算只能操作整數，

<< 左移 ： 任何一個數左移N位，相當于這個數乘以2的N次方， >>右移：任何一個數右移N為，相當于這個數除以2的N次方法，

2.5 流程控制（回圈陳述句）

順序結構：程式從上到下執行，

判斷結構：if，if-else

if(條件運算式){// 條件運算式回傳true，則執行if塊，if塊執行結束程式會向下繼續，如果回傳false則跳過if塊執行后面的代碼，
    
}
if(條件運算式){// if后面的運算式回傳true則執行if塊，回傳false則執行else塊，
    
}else{
}
    

分支結構：多重的if-else

if(條件1){
}else if(條件2){// 多重的else if可以寫任何多個，沒有個數限制
}else if(條件3){
}
.......
else{// 可選結構
}

分支結構：switch-case

switch(運算式){
case 常量1:
	執行陳述句1;
	//break;
case 常量2:
	執行陳述句2;
	//break;
default:
	//可選
     break;

回圈結構 ：while，do-while，for

while(回圈條件){// 回圈條件為true則進入回圈體，回圈體執行完畢，則回傳起點重新判斷回圈條件
    // 回圈操作
}
// while回圈，先判斷后執行，如果回圈條件的初始值不滿足則一次回圈都不執行

do{
    // 回圈操作
}while(回圈條件);
// do-while回圈，先執行后判斷，回圈體會首先執行一次，然后判斷回圈條件，回圈條件true則繼續回圈，false則退出回圈，

for(回圈變數的定義;回圈條件;回圈變數的改變){// 用于執行回圈次數確定，先判斷后執行，三個運算式都可以根據需求進行省略，但是兩個分號不能省略，
    // 回圈操作
}

二重回圈：嵌套的回圈

// 一個回圈完整的包含在另一個回圈的回圈體里，可以是任何一個回圈結構去包含另一個回圈系結構
for(){// 外層回圈
    for(){// 內層回圈
        // 外層回圈執行一次，內層回圈要完整的執行完所有的操作，所以內層回圈的回圈體執行的次數是外層回圈次數*記憶體回圈次數，
    }
}

3_陣列

陣列的概念：陣列是一個裝載多個資料的容器，

陣列的四個要素：陣列的型別，陣列名，陣列元素，訪問下標，

陣列的宣告：三種方式

int[] one = new int[5];// 陣列必須在宣告的時候給出長度，且這個長度不再改變，第一種宣告方式，給出陣列長度，但是沒有給陣列元素賦值，陣列元素上是默認值，

int[] two = {30,50};// 陣列在宣告的同時給每一個元素賦值，陣列的長度根據大括號中的值得數量決定，這種方式必須在一行之內完成，

int[] three
three = new int[]{30,40,50};// 陣列在宣告的同時給每一個元素賦值，陣列的長度根據大括號中的值得數量決定，這種方式允許在兩行之內完成，

陣列的遍歷：

// 普通for回圈遍歷陣列
for(int i = 0;i < nums.length; i++){
    System.out.println(nums[i]);// 訪問陣列元素的方式是陣列名[下標]，下標的合法訪問區間，是0到陣列長度-1.訪問陣列元素時，如果下標在合法區間，則訪問可以正常進行，如果訪問下標超過了合法區間則會拋出陣列越界例外，
}

二維的陣列：一維的元素是另一個陣列

int[][] nums = new int[5][3];// 同時給出一維和二維的陣列長度，

int[][] nums = new int[5][];// 只給出一維的長度，不給二維的長度，此時一維元素為null，
nums[0] = new int[3];// 創建新陣列給一維元素賦值，

int[][] nums = {{35,87,90},{35,77,20,17},{90,87,65,100,40}};// 靜態宣告二維陣列，必須在宣告陣列的同時完成賦值

int[][] nums;
nums = new int[][]{{1,2,3},{1,2,3},{1,2,3}};// 靜態初始化二維陣列，允許在陣列宣告之后賦值，

二維陣列的遍歷

for(int i = 0;i < nums.length; i++){// 回圈遍歷一維陣列
    for(int j = 0;j < nums[i].length; j++){
        System.out.println(nums[i][j]);
    }
}

4_面向物件

4.1 面向物件學習的三條主線：

• 1.Java類及類的成員：屬性、方法、構造器；代碼塊、內部類

• 2.面向物件的大特征：封裝性、繼承性、多型性、(抽象性)

• 3.其它關鍵字：this、super、static、final、abstract、interface、package、import等

4.2 面向物件中兩個重要的概念：

類：對一類事物的描述，是抽象的、概念上的定義
物件：是實際存在的該類事物的每個個體，因而也稱為實體

面向物件程式設計的重點是類的設計
設計類，就是設計類的成員，

4.3 面向程序和面向物件的區別

• 面向程序：考慮問題主要是分步，步驟不可逆，順序執行，

• 面向物件：考慮問題主要是找到解決問題的類，用類創建物件，用物件呼叫屬性或者方法，

• 類：是一個規范，是一個模板，規定了一類事物必須有的屬性和方法，

• 物件：使用類創建出來的具體的客觀存在的物體，使用物件呼叫屬性，使用物件呼叫方法，

在java程式中定義類：

public class Student{// 定義類的時候給出若干屬性和方法，類體中主要是定義屬性和方法，
    public String stuName;
    public int stuAge;
    
    public void sayHello(){// 定義方法，方法有五個常規部分，訪問修飾符，回傳型別，方法名，引陣列，方法體，訪問修飾符暫時記public，回傳型別如果沒有回傳值則寫void，引陣列如果沒有引數則小括號空著，大括號中是方法體， 
    }
    
    public int methodOne(){// 當一個方法規定了回傳型別，必須在方法結束前，回傳一個該型別的變數，
        int one = 0;
        one = 100;
        return one;// java語言規定回傳值只能回傳一個值，
    }
    
    public void methodTwo(int i,double d){// 方法有引數，引數是基礎型別，一個方法定義引數，那么呼叫這個方法的時候必須按照要求傳參，引數型別要求，引數個數要求，順序要求，
        System.out.println(i+d);
    }
    
    public void methodThree(String s){// 引數是參考型別，引數是物件，物件有屬性，物件有方法，
        System.out.println(s.equals("Tom"));
    }
}

4.4 靜態

static關鍵字：static關鍵字能修飾類的成員，被static關鍵字修飾的屬性叫靜態屬性，被static關鍵字修飾的方法叫靜態方法，

靜態成員的特征：

• 1、靜態成員可以不用創建物件，直接由類名呼叫，也可以由物件名呼叫，但不推薦這樣做，

• 2、靜態的成員只能訪問靜態的成員，不能訪問普通成員，靜態的成員初始化時間比較早，在類的加載同時初始化，普通的成員在創建物件時初始化，

• 3、靜態屬性是類所有物件共有屬性，也被稱作類變數，靜態屬性出現在記憶體的方法區中，

4.5 封裝

面向物件語言的三大特性：封裝，繼承，多型，

封裝：將類的細節隱藏起來，通過private修飾符，阻止外界訪問，通過給private修飾的成員提供public的訪問方法類實作訪問，

JavaBean：所有的屬性都是private修飾的，所有的private修飾的屬性都有public修飾的get/set方法，必須擁有一個無參的構造方法，有參的構造方法可選，

public class Student {
    private String stuName;
    private Integer stuAge;
    private String stuGender;

    public Student() {
    }

    public Student(String stuName, Integer stuAge, String stuGender) {
        this.stuName = stuName;
        this.stuAge = stuAge;
        this.stuGender = stuGender;
    }

    public String getStuName() {
        return stuName;
    }

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public Integer getStuAge() {
        return stuAge;
    }

    public void setStuAge(Integer stuAge) {
        this.stuAge = stuAge;
    }

    public String getStuGender() {
        return stuGender;
    }

    public void setStuGender(String stuGender) {
        this.stuGender = stuGender;
    }

    @Override
    public String toString() {
        return "Student{" +
                "stuName='" + stuName + '\'' +
                ", stuAge=" + stuAge +
                ", stuGender='" + stuGender + '\'' +
                '}';
    }
}

4.6 繼承

4.6.1 繼承的語法

public class Father{
    
    private int one;
    
    public int getOne(){
        return one;
    }
    public void setOne(int one){
        this.one = one;
    }
    
    public void show(){
        System.out.println("one="+one);
    }
}

public class Son extends Father{// Son類繼承自Father類，Son類是子類，Father類是父類，
    // 子類可以繼承到父類所有的屬性和方法，但是不能繼承構造方法，private的屬性和方法可以被子類繼承，但是不能被子類直接訪問，需要通過public修飾的方法方法，
    private int two;// 子類可以擁有自己的屬性和方法
    public int getTwo(){
        return two;
    }
    public void setTwo(int two){
        this.two = two;
    }
    
    public void getInfo(){
        System.out.println("one="+this.getOne()+",two="+this.two;
    }
}

4.6.2 java繼承的特點：

java語言使用單繼承，單繼承就是一個java類只能有一個父類，一個父類可以有多個子類，

一個java類如果顯示的繼承自類一個類，那么它的父類就是顯示繼承的類，如果一個java類沒有顯示的繼承，那么它隱示的繼承自Object，所以所有的java類的父類都是Object，Object就是java繼承樹的根節點，

4.6.3、方法的多載和方法的重寫：

方法的多載：發生在一個類中，方法名相同，引陣列不同(引數型別不同，引數個數不同，引數順序不同)，

方法的重寫：發生在父子類中，子類撰寫一個方法名，引陣列，訪問修飾符，回傳型別和父類方法完全一樣的方法，子類重寫的父類方法的修飾符只允許比父類方法更寬不能比父類方法更窄，子類重寫父類 的方法時，子類重寫的方法的回傳型別允許是父類方法回傳型別的子型別，方法重寫是一個方法，一旦子類重寫了父類的方法，再呼叫的一定是子類重寫的方法，

4.7 多型

多型的概念：任何一個需要父類參考的位置，都可以傳遞一個子類物件，

多型的實作步驟：

1、有繼承，有父子類，
2、父類定義方法，子類重寫方法，
3、父類的參考，子類的物件，

class Father{
    public void methodOne(){
        System.out.println("父類的methodOne");
    }
}

class Son extends Father{
    public void methodOne(){
        System.out.println("子類重寫的methodOne");
    }
}

class Test{
    public static void main(String[] args){
        Father f = new Son();// 創建物件多型
        f.methodOne();// 子類一旦重寫父類方法，再次呼叫的一定是子類重寫的方法，
        
        // Son son = new Son();
        methodTwo(new Son());// 引數定義是父型別別，傳遞引數時傳遞子類物件，
        
        Father[] nums = new Father[5];// 宣告一個父型別別的物件陣列
        nums[0] = new Son();// 為陣列元素賦值時傳遞子類物件，
        nums[1] = new Son();
        nums[2] = new Son();
        nums[3] = new Son();
        nums[4] = new Son();
    }
    
    public static void methodTwo(Father f){// 方法定義的引數是父型別別引數，
        f.methodOne();
    }
}

4.8 抽象

abstract關鍵字：可以修飾類，被修飾的類稱作抽象類，抽象類不能被實體化，可以修飾方法，被修飾的方法稱作抽象方法，抽象方法沒有方法體，抽象的方法必須在抽象的類中，抽象的類中可以有抽象的方法也可以有普通的方法

abstract class Father{
    public abstract void methodOne();// 抽象的方法沒有方法體,抽象的方法必須在抽象的類里
    public void methodTwo(){
        // 抽象的類中還可以有普通的方法，
    }
}

class Son extends Father{
    public void methodOne(){
        // 子類繼承自抽象父類，必須重寫父類中所有的抽象方法，
    }
}

class Test{
    public static void main(String[] args){
       // Father f = new Father();// 抽象類不能創建物件
        Father f = new Son();// 抽象類需要物件，只能創建抽象了的子類物件，
    }
}

注意點：

• 1.abstract不能用來修飾：屬性、構造器等結構
• 2.abstract不能用來修飾私方法、靜態方法、final的方法、final的類

4.9 static:靜態的

可以用來修飾的結構：主要用來修飾類的內部結構
屬性、方法、代碼塊、內部類

靜態成員的特征：

• 1、靜態成員可以不用創建物件，直接由類名呼叫，也可以由物件名呼叫，但不推薦這樣做，

• 2、靜態的成員只能訪問靜態的成員，不能訪問普通成員，靜態的成員初始化時間比較早，在類的加載同時初始化，普通的成員在創建物件時初始化，

• 3、靜態屬性是類所有物件共有屬性，也被稱作類變數，靜態屬性出現在記憶體的方法區中，

//示例代碼
class Circle{
	
	private double radius;
	private int id;//自動賦值
	
	public Circle(){
		id = init++;
		total++;
	}
	
	public Circle(double radius){
		this();
//		id = init++;
//		total++;
		this.radius = radius;
		
	}
	
	private static int total;//記錄創建的圓的個數
	private static int init = 1001;//static宣告的屬性被所物件所共享
	
	public double findArea(){
		return 3.14 * radius * radius;
	}

	public double getRadius() {
		return radius;
	}

	public void setRadius(double radius) {
		this.radius = radius;
	}

	public int getId() {
		return id;
	}

	public static int getTotal() {
		return total;
	}

}

4.10 介面

介面的語法：

public interface A{
    // 介面中所有的屬性默認是公開靜態常量
    public static final String NAME = "Tom";
    // 介面中所有的方法默認是公開抽象
    public abstract void methodOne();
}

*介面的特點：

• 1、介面不允許實體化，

• 2、介面必須配備實作類，

*介面的實作類：

// 使用implements關鍵字，類B是介面A的實作類
// 一個介面的實作類必須實作介面中所有的抽象方法
public class B implements A{
    public void methodOne(){
        System.out.println("hello world!");
    }
}
// 一個介面可以有多個實作類
public class C implements A{
    public void methodOne(){
        System.out.println("bye bye!");
    }
}

// 一個類可以實作多個介面，一個類實作多個介面必須，實作這些介面中的所有的抽象方法，
public class D implements A,Comparable{
    
}

介面可以繼承，并且是多繼承

interface A{
    public void methodOne();
}

// 介面可以繼承介面
interface B extends A{
    // 子介面繼承父介面，子介面將繼承到父介面中的方法
    
    public void methodTwo();
}

class C implements B{
    public void methodOne(){};
    
    public void methodTwo(){};
}

interface D{
}
// 介面可以多繼承
interface E extends A,D{
}

4.11 封裝類

概念：java語言為每一種基礎資料型別都對應的準備了一個參考型別，這個參考型別叫做封裝類，

封裝類的基本操作：

// 1、創建封裝類物件
Integer one = new Integer(10);
Integer two = new Integer("50");

// 2、物件轉基礎型別
int i = one.intValue();

// 3、基礎型別轉封裝型別
Integer one = new Integer(i);
Integer two = Integer.valueOf(i);

// 4、String型別轉封裝型別
Integer one = new Integer("50");

// 5、封裝型別轉String
String s = one.toString();

// 6、基礎型別轉String
String s = Integer.toString(i);

自動裝箱和自動拆箱：從jdk1.5開始，基礎型別和對應參考型別可以自動轉換，如果是參考型別需要進行運算，參考型別必須轉成基礎型別，

4.12 列舉

概念：列舉用于適應只有固定的幾個值的情況，比如一年有四季，一個年有十二個月，一個星期有七天，

實作列舉：jdk1.5之前的列舉

public class Gender{
    // 提供公開靜態常量的該類屬性
    public static final Gender MAN = new Gender();
    public static final Gender WEMON = new Gender();
    
    // 構造方法私有
    private Gender(){
        
    }
}

jdk 1.5之后的列舉

public enum Gender{
    // 必須在類體的第一部分宣告該類屬性的公開靜態常量
    // 除屬性名外的其他修飾部分全部省略
    MAN,WEMON;
    
    // enum宣告的類體中，所有的構造方法默認是private修飾
}

4.13 內部類

概念：一個類定義在另一個類的類體中，這個里面的類叫內部類，外面的類叫外部類，

分類：

• 1、靜態成員內部類：宣告在外部類的類體中，由static關鍵字修飾，

特點：可以在內部類中宣告靜態的成員，可以不需要創建外部類物件，直接創建內部類物件，可以訪問外部類靜態的成員，不能訪問外部類普通的成員，

• 2、普通成員內部類：宣告在外部類的類體中，沒有static關鍵字修飾，

特點：只能在內部類類體中宣告普通成員，需要先創建外部類物件，在由外部類物件創建內部類物件，可以訪問外部類所有的成員，

• 3、區域內部類：宣告在方法體中的內部類，不能脫離宣告內部類的方法使用，

• 4、匿名內部類：匿名內部類是區域內部類的特殊形式，匿名內部類通常作為類的子類或者介面的實作類，

4.14 注解

注解從jdk1.5開始的時候出現，@注解名,注解可以出現在類的任何一個位置，注解可以實作一些功能，做出一些標注，檢測一些語法，但是注解不能影響程式的運行結果，

系統注解：

@SuppressWarnings("unused") // 抑制警告注解

@Deprecated // 標注方法過時注解

@Override // 檢測方法重寫注解

元注解：修飾注解的注解

@Target //標注注解可以修飾那些內容
@Retention // 標注注解的生命周期
@Documented // 標注注解可以隨生成檔案進入API中
@Inherited // 標注注解可以在繼承時被子類繼承到

5_例外處理

概念：程式運行時的錯誤，
例外的流程：在一行代碼運行時出現例外，程式會在例外產生行終止，創建并拋出一個該類例外物件，例外物件在沒有被捕獲的情況下會一直向上拋出，一旦例外物件拋給虛擬機，則虛擬機立即終止當前行程，

例外處理的目的：例外處理的目的是防止例外物件拋給虛擬機，防止因為例外導致程式終止，

5.1 例外

5.1.1 例外的體系結構

 * java.lang.Throwable
 * 		|-----java.lang.Error:一般不撰寫針對性的代碼進行處理，
 * 		|-----java.lang.Exception:可以進行例外的處理
 * 			|------編譯時例外(checked)
 * 					|-----IOException
 * 						|-----FileNotFoundException
 * 					|-----ClassNotFoundException
 * 			|------運行時例外(unchecked,RuntimeException)
 * 					|-----NullPointerException
 * 					|-----ArrayIndexOutOfBoundsException
 * 					|-----ClassCastException
 * 					|-----NumberFormatException
 * 					|-----InputMismatchException
 * 					|-----ArithmeticException

5.1.2 從程式的執行角度來看分為運行時例外和編譯時例外

編譯時例外：執行javac.exe命名時，可能出現的例外
運行時例外：執行java.exe命名時，出現的例外

5.1.3 常見的例外型別，請舉例說明：

//******************以下是運行時例外***************************
	//ArithmeticException
	@Test
	public void test6(){
		int a = 10;
		int b = 0;
		System.out.println(a / b);
	}
	
	//InputMismatchException
	@Test
	public void test5(){
		Scanner scanner = new Scanner(System.in);
		int score = scanner.nextInt();
		System.out.println(score);
		
		scanner.close();
	}
	
	//NumberFormatException
	@Test
	public void test4(){
		
		String str = "123";
		str = "abc";
		int num = Integer.parseInt(str);
		
		
		
	}
	
	//ClassCastException
	@Test
	public void test3(){
		Object obj = new Date();
		String str = (String)obj;
	}
	
	//IndexOutOfBoundsException
	@Test
	public void test2(){
		//ArrayIndexOutOfBoundsException
//		int[] arr = new int[10];
//		System.out.println(arr[10]);
		//StringIndexOutOfBoundsException
		String str = "abc";
		System.out.println(str.charAt(3));
	}
	
	//NullPointerException
	@Test
	public void test1(){
		
//		int[] arr = null;
//		System.out.println(arr[3]);
		
		String str = "abc";
		str = null;
		System.out.println(str.charAt(0));
		
	}

	//******************以下是編譯時例外***************************
	@Test
	public void test7(){
//		File file = new File("hello.txt");
//		FileInputStream fis = new FileInputStream(file);
//		
//		int data = fis.read();
//		while(data != -1){
//			System.out.print((char)data);
//			data = fis.read();
//		}
//		
//		fis.close();
		
	}

5.2 例外的處理

java例外處理的抓拋模型：

程序一：
“拋”：程式在正常執行的程序中，一旦出現例外，就會在例外代碼處生成一個對應例外類的物件，
并將此物件拋出，
一旦拋出物件以后，其后的代碼就不再執行，
關于例外物件的產生：
① 系統自動生成的例外物件
② 手動的生成一個例外物件，并拋出（throw）
程序二：
“抓”：可以理解為例外的處理方式：① try-catch-finally ② throws

5.2.1 例外處理方式一：try-catch-finally

try{
    // try塊監控可能出現例外的代碼
}catch(Exception ex){
    // catch塊捕獲例外物件，進行例外處理
}fianlly{
    // 無論出現不出現例外，finally塊一定執行，用于釋放自愿
}

5.2.2 例外處理方式二：throws,throw

public void methodOne()throws Exception{// throws關鍵字用于宣告方法不處理的例外，將該類例外拋給呼叫點處理
    throw new Excetpion();// throw關鍵字用于拋出手動創建的例外物件
}

throw 和 throws區別：
throw 表示拋出一個例外類的物件，生成例外物件的程序，宣告在方法體內，
throws 屬于例外處理的一種方式，宣告在方法的宣告處，

例外的分類：
Exception是所有例外類的總父類，只要是例外類必須是Exception的子類

除RuntimeException及其子類以外的所有例外類：這類例外被稱作已檢查例外，這類例外強制處理，

RuntimeException及其子類：這類例外被稱作未檢查例外，這類例外不強制處理，但是一旦爆發例外還是走例外流程，

5.2.3 自定義例外：

自定義已檢查例外則繼承Exception，自定義未檢查例外則繼承RuntimeException，

自定義例外重寫getMessage()方法，或者構造方法傳參呼叫super()將例外資訊傳遞給父類的構造方法，

示例代碼：

public class MyException extends Exception{
	
	static final long serialVersionUID = -7034897193246939L;
	
	public MyException(){
		
	}
	
	public MyException(String msg){
		super(msg);
	}
}