一、Java語言概述

1、開發環境的搭建

1.1、官網下載并安裝JDK

JDK、JRE、JVM的關系

1、JRE(Java Runtime Environment Java運行環境)： 包括Java虛擬機和Java程式所需的核心類別庫
2、JDK(Java Development Kit Java開發工具包)： JDK提供給Java開發人員使用，包含Java的開發工具和JRE
（其中的開發工具：編譯工具javac.exe 打包工具jar.exe， 簡言之：使用JDK開發完成的java程式，交給jre去運行 ）

1.2 、配置環境變數

為什么配置path環境變數？

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

PATH： 目的是可以在任意目錄下找到java和javac命令
CLASSPATH: 讓指定的class檔案可以在任意目錄下找到

2、程式的撰寫

二、基本語法

1、關鍵字與識別符號

關鍵字： 被Java語言賦予特定含義的單詞 一共50+2(保留字goto和const)
識別符號： 給類，介面，方法，變數起名字時使用的字符序列（凡是自己可以起名字的地方都叫識別符號）
識別符號命名規則： ① 由字母，數字，_或$組成 ② 不能以數字開頭

2、變數

2.1 、按資料型別分類：基本資料型別和參考資料型別

• 基本資料型別容量從小到大（數的范圍大和小）： byte (1位元組 )、 char (2位元組)、short (2位元組) ->int (4位元組) ->long ( 8位元組) ->float (4位元組) -> double (8位元組)
  boolean (只能取true或false)

自動型別轉換： 在參與運算時，會自動提升到int型別和double型別(只涉及7種基本資料型別)
強制型別轉換： 高精度轉低精度 (大盒子裝小盒子)

• 參考資料型別： 類class，介面interface，陣列[ ]

2.2、 按宣告的位置分類

3、運算子

1、算術運算子： ±*/%(前)++ (后) ++(前) (后)--?連接符+ （只能使用在String與其他資料型別變數之間）
2、賦值運算子： = += -= *= /= %=
3、比較運算子（關系運算子）: == != > < >= <= instanceof
4、邏輯運算子： & | ||（短路或，左真右不運算）&&(短路與，左假右不運算) ! ^
5、位運算子： << >> >>> & | ^ ~
6、三元運算子： (條件運算式)? 運算式1 : 運算式2

4、流程控制

1、順序結構： 程式從上到下執行，
2、分支結構： if-else if - else?switch-case
? 說明: ① 針對于條件運算式：如果多個條件運算式之間有包含的關系，通常情況下，需要將范圍小的宣告在范圍大的上面，否則，范圍小的就沒機會執行了，② switch結構中的運算式， 只能是如下的6種資料型別之一： byte 、short、char、int、列舉型別(JDK5.0新增)、String型別(JDK7.0新增)
3、回圈結構： for?while?do-while
回圈結構的四要素： ① 初始化條件 ② 回圈條件 —>是boolean型別 ③ 回圈體 ④ 迭代條件

?鍵盤錄入

a：導包 import java.util.Scanner;
b：創建鍵盤錄入物件 Scanner sc = new Scanner(System.in);
c：呼叫方法接收鍵盤錄入的資料
? sc.nextInt() 接收一個int型別的資料
? sc.next() 接收一個字串
說明： Scanner是一個掃描器，我們錄取到鍵盤的資料，先存到快取區等待讀取，它判斷讀取結束的標示是 空白符；比如：空格，回車，tab 等等，其中nextLine（）方法的結束符只是Enter鍵，即nextLine（）方法回傳的是Enter鍵之前的所有字符，它是可以得到帶空格的字串的，所以一定要注意next（）方法和nextLine（）方法的連用，

三、陣列

1、陣列的概述

1、 陣列的理解： 陣列(Array)，是多個相同型別資料一定順序排列的集合，并使用一個名字命名， 并通過編號的方式對這些資料進行統一管理，
2、 陣列相關的概念： 陣列名，元素角標，下標、索引，陣列的長度：元素的個數，
3、 陣列的特點： ① 陣列是序排列的 ② 陣列屬于參考資料型別的變數，陣列的元素，既可以是基本資料型別，也可以是參考資料型別 ③ 創建陣列物件會在記憶體中開辟一整塊連續的空間 ④ 陣列的長度一旦確定，就不能修改，
4、 陣列的分類： ① 按照維數：一維陣列、二維陣列、，，， ② 按照陣列元素的型別：基本資料型別元素的陣列、參考資料型別元素的陣列，

2、一維陣列和二維陣列

2.1、一維陣列的宣告與初始化：

//靜態初始化
int[] num ;//宣告
num = new int[] {1,3,5,7,9};//陣列的初始化和陣列元素的賦值操作

//動態初始化
int[] num = new int[5];

一維陣列元素的默認初始化值
? 陣列元素是整型： 0
? 陣列元素是浮點型： 0.0
? 陣列元素是char型： 0 或’\u0000’，而非’0’
? 陣列元素是boolean型： false
? 陣列元素是參考資料型別： null

一維陣列記憶體決議：

2.2、二維陣列的宣告與初始化：

//靜態初始化
int[][] num = new int[][]={{1,3,5},{2,3},{2,3,4,5}};
//動態初始化
int[][] num = new int[3][2];

二維陣列記憶體決議：

3、陣列的常見演算法

3.1、冒泡排序
原理：

• 比較相鄰的元素，如果第一個比第二個大，就交換他們兩個，
• 對每一對相鄰元素做同樣的作業，從開始第一對到結尾的最后一對，在這一點，最后的元素應該會是最大的數，
• 針對所有的元素重復以上的步驟，除了最后一個，
• 持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較，

public class BubbleSort {
    public static void main(String[] args) {
        int[] nums = {121,54,38,21,56,32};
        //外層回圈控制的是，比較的輪數
        //外層回圈次數 length-1
        int temp;
        for (int i = 0; i < nums.length-1; i++) {
            //內層回圈控制的是每輪比較的次數
            //第i輪（i從0開始計算），比較次數為：length-i-1
            for (int j = 0; j < nums.length - i - 1; j++) {
                if (nums[j]>nums[j+1]){
                    //兩兩相比，滿足移動條件
                    temp = nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;
                }
            }

        }
        //排序已完成，下面是遍歷列印查看的程序
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i]+" ");

        }
    }
}

3.2、選擇排序
原理：

• 將整個陣列遍歷一遍，將最小的數和首個元素互換
• 然后將第二個到最后的陣列遍歷，其中最小的和第二個互換，以此類推，

public class SelectSort {
    public static void selectSort(int[] nums) {
        int length = nums.length;
        if (length == 0) {
            return;
        }
        int min = 0;
        int minIndex = 0;
        for (int i = 0; i < length; i++) {
            min = nums[i];
            minIndex = i;
            for (int j = i + 1; j < length; j++) {
                if (nums[j] < min) {
                    min = nums[j];
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                swap(nums, i, minIndex);
            }
        }
    }

    public static void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

3.3、二分查找（折半查找）

二分查找也稱折半查找（Binary Search），它是一種效率較高的查找方法，但是，二分查找要求陣列資料必須采用順序存盤結構有序排列，

原理：

• 假設陣列中的值按照某個順序排序后，我們在陣列中查找某個元素的位置，
• 我們將要查找的值和陣列中間的值進行比較
• 如果中間的值比我們要查找的值大，那么說明我們要查找的值在中間值的左邊，反之，就在右邊，

public class BinarySearch{
    /**
     * 二分查找（折半查找）
     */
    public static void main(String[] args) {
        int[] nums = {10,20,30,40,50,60,70,80,90};

        //要查找的資料
        int num = 80;

        //關鍵的三個變數：
        //1. 最小范圍下標
        int minIndex = 0;
        //2. 最大范圍下標
        int maxIndex = nums.length-1;
        //3. 中間資料下標
        int centerIndex = (minIndex+maxIndex)/2;
        while(true) {
            System.out.println("回圈了一次");
            if(nums[centerIndex]>num) {
                //中間資料較大
                maxIndex = centerIndex-1;
            }else if(nums[centerIndex]<num) {
                //中間資料較小
                minIndex = centerIndex+1;
            }else {
                //找到了資料  資料位置：centerIndex
                break;
            }

            if(minIndex > maxIndex) {
                centerIndex = -1;
                break;
            }
            //當邊界發生變化， 需要更新中間下標
            centerIndex = (minIndex+maxIndex)/2;
        }

        System.out.println("位置："+centerIndex);

    }
}

4、Arrays工具類的使用

• ① 定義在java.util包下 ② Arrays:提供了很多操作陣列的方法，
• 使用：

    //1.boolean equals(int[] a,int[] b):判斷兩個陣列是否相等，
    int[] arr1 = new int[]{1, 2, 3, 4};
    int[] arr2 = new int[]{1, 3, 2, 4};
    boolean isEquals = Arrays.equals(arr1, arr2);
    System.out.println(isEquals);

    //2.String toString(int[] a):輸出陣列信息，
    System.out.println(Arrays.toString(arr1));
    
    //3.void fill(int[] a,int val):將指定值填充到陣列之中，
    Arrays.fill(arr1,10);
    System.out.println(Arrays.toString(arr1));
    
    //4.void sort(int[] a):對陣列進行排序，
    Arrays.sort(arr2);
    System.out.println(Arrays.toString(arr2));

    //5.int binarySearch(int[] a,int key)
    int[] arr3 = new int[]{-98, -34, 2, 34, 54, 66, 79, 105, 210, 333};
    int index = Arrays.binarySearch(arr3, 210);
    if(index>=0) {
        System.out.println(index);
    }else {
        System.out.println("未找到");
    } 

四、面向物件（上）

1、類與物件

面向物件學習的三條主線：
1、Java類及類的成員： 屬性、方法、構造器；代碼塊、內部類
2、面向物件的大特征： 封裝性、繼承性、多型性、(抽象性)
3、其它關鍵字： this、super、static、final、abstract、interface、package、import等

1.1、物件的創建與物件的記憶體決議：

1.2、匿名物件:

我們創建的物件，沒顯式的賦給一個變數名，即為匿名物件
特點： 匿名物件只能呼叫一次，

• 應用場景：

PhoneMall mall = new PhoneMall();

//匿名物件的使用
mall.show(new Phone());
其中，
class PhoneMall{
	public void show(Phone phone){
		phone.sendEmail();
		phone.playGame();
	}
	
}

1.3、JVM記憶體結構：

• 編譯完源程式以后，生成一個或多個位元組碼檔案，
• 我們使用JVM中的類的加載器和解釋器對生成的位元組碼檔案進行解釋運行，意味著，需要將位元組碼檔案對應的類加載到記憶體中，涉及到記憶體決議，

• 虛擬機堆疊，即為平時提到的堆疊結構，我們將區域變數存盤在堆疊結構中，將new出來的結構（比如：陣列、物件）加載在對空間中，
• 補充：物件的屬性（非static的）加載在堆空間中，
• 方法區：類的加載資訊、常量池、靜態域

2、封裝性

程式設計追求 “高內聚，低耦合”
內聚： 每個模塊盡可能獨立完成自己的功能，不依賴于模塊外部的代碼，
耦合： 模塊與模塊之間介面的復雜程度，模塊之間聯系越復雜耦合度越高，牽一發而動全身，

封裝性思想的體現：

1、將類的屬性私有化，同時對外提供get，set方法來獲取屬性的值
2、單例模式（將構造器私有化）
3、如果不希望類在包外被呼叫，可以將類設定為預設

Java權限修飾符:

說明： 4種權限都可修飾類的內部結構：屬性、方法、構造器、內部類，而修飾類只能使用：預設，public

3、成員變數（屬性）和區域變數區別

① 宣告位置不同： 成員變數直接定義在類的{ }中；區域變數宣告在方法內，方法形參，代碼塊內，構造器形參，構造器內，
② 權限修飾符不同： 成員變數有private，預設，protected，public；而區域變數不可以使用權限修飾符，
③ 默認初始值不同： 類的屬性，根據其型別，都默認初始化值，
? 整型（byte、short、int、long：0）
? 浮點型（float、double：0.0）
? 字符型（char：0 （或’\u0000’））
? 布爾型（boolean：false）
? 而區域變數沒有默認初始值，所以在呼叫區域變數之前，要顯式賦值，

4、構造器

作用： 創建物件,初始化物件資訊
說明： ① 如果沒有顯式的定義類的構造器，則系統默認提供一個空參的構造器 ② 一個類中定義的多個構造器，彼此構成多載

屬性的賦值先后順序:
?① 默認初始化
?② 顯式初始化
?③ 構造器中初始化
?④ 通過"物件.方法"或"物件.屬性"的方式賦值

JavaBean的概念： 是指符合如下標準的Java類

• 類是公共的
• 是一個無參的公共的構造器
• 屬性，且對應的get，set方法

5、關鍵字：this

理解為當前物件或當前正在創建的物件
說明： ① 如果方法或構造器的形參和類的屬性同名時，我們必須顯式的使用"this.變數"的方式，表明此變數是屬性，而非形參 ② 構造器不能通過’'this(形參串列)“方式呼叫自己 ③ 如果一個類中有n個構造器，，則最多有n-1個構造器使用了"this(形參串列)” ④ 規定："this(形參串列)“必須宣告在當前構造器的首行 ⑤ 構造器內部，最多只能宣告一個"this(形參串列)”，用來呼叫其他的構造器

6、關鍵字：package，import

package：

1、為了更好的實作專案中類的管理，提供包的概念
2、使用package宣告類或介面所屬的包，宣告在源檔案的首行
3、包，屬于識別符號，遵循識別符號的命名規則、規范
4、每"."一次，就代表一層檔案目錄

例如：MVC設計模式

import：

• JDK中主要包的介紹

1、java.lang ——包含一些Java語言的核心類，如String、Math、Integer、System和Thread，提供常用功能，
2、java.net ——包含執行與網路相關的操作的類和介面，
3、java.io ——包含能提供多種輸入/輸出功能的類，
4、java.util ——包含一些實用工具類，如定義系統特性、介面的集合框架類、使用與日期日歷相關的函式，
5、java.text ——包含了一些java格式化相關的類
6、java.sql ——包含了java進行JDBC資料庫編程的相關類/介面
7、java.awt ——包含了構成抽象視窗工具集（abstract window toolkits）的多個類，這些類被用來構建和管理應用程式的圖形用戶界面(GUI)，

• 匯入說明

1、 在源檔案中顯式的使用import結構匯入指定包下的類、介面
2、 宣告在包的宣告和類的宣告之間
3、如果需要匯入多個結構，則并列寫出即可
4、可以使用"xxx."的方式，表示可以匯入xxx包下的所結構
5、如果使用的類或介面是java.lang包下定義的，則可以省略import結構
6、如果使用的類或介面是本包下定義的，則可以省略import結構
7、如果在源檔案中，使用了不同包下的同名的類，則必須至少一個類需要以全類名的方式顯示，
8、使用"xxx."方式表明可以呼叫xxx包下的所結構，但是如果使用的是xxx子包下的結構，則仍需要顯式匯入
9、import static:匯入指定類或介面中的靜態結構:屬性或方法，

五、面向物件（中）

1、繼承性

1.1、為什么要有類的繼承性？

• 減少了代碼的冗余，提高了代碼的復用性
• 便于功能的擴展
• 為之后多型性的使用，提供了前提

1.2、繼承的格式
class A extends B{ }

• 說明：
  ?A:子類、派生類、subclass
  ?B:父類、超類、基類、superclass

1.3、Java中繼承性的說明

• 1、一個類可以被多個子類繼承，
• 2、Java中類的單繼承性：一個類只能有一個父類
• 3、子父類是相對的概念，
• 4、子類直接繼承的父類，稱為：直接父類，間接繼承的父類稱為：間接父類
• 5、子類繼承父類以后，就獲取了直接父類以及所間接父類中宣告的屬性和方法

2、方法的重寫

2.1、什么是方法的重寫(override 或 overwrite)？

子類繼承父類以后，可以對父類中同名同引數的方法，進行覆寫操作.

2.2、重寫的規則
? 方法的宣告: 權限修飾符 回傳值型別 方法名(形參串列) throws 例外的型別{//方法體}

1、子類重寫的方法的方法名和形參串列與父類被重寫的方法的方法名和形參串列相同
2、子類重寫的方法的權限修飾符不小于父類被重寫的方法的權限修飾符
特殊情況：子類不能重寫父類中宣告為private權限的方法
3、回傳值型別：
?父類被重寫的方法的回傳值型別是void，則子類重寫的方法的回傳值型別只能是void
?父類被重寫的方法的回傳值型別是A型別，則子類重寫的方法的回傳值型別可以是A類或A類的子類
?父類被重寫的方法的回傳值型別是基本資料型別(比如：double)，則子類重寫的方法的回傳值型別必須是相同的基本資料型別(必須也是double)
4、子類重寫的方法拋出的例外型別不大于父類被重寫的方法拋出的例外型別

子類和父類中的同名同引數的方法要么都宣告為非static的（考慮重寫，要么都宣告為static的（不是重寫)，

2.3、重寫(Override)和多載(Overload)的區分

（1） 概念上： ① 多載： 在一個類中，同名的方法如果有不同的引數串列（引數型別不同、引數個數不同甚至是引數順序不同）則視為多載，同時，多載對回傳型別沒有要求，可以相同也可以不同， ② 重寫： 就是在子類中把父類本身有的方法重新寫一遍，在方法名，引數串列，回傳型別都相同的情況下， 對方法體進行修改或重寫，
（2）多載和重寫的具體規則
（3）多載： 不表現為多型性 ?? 重寫： 表現為多型性
（4）多載，是指允許存在多個同名方法，而這些方法的引數不同，編譯器根據方法不同的引數表，對同名方法的名稱做修飾，對于編譯器而言，這些同名方法就成了不同的方法，它們的呼叫地址在編譯期就系結了，Java的多載是可以包括父類和子類的，即子類可以多載父類的同名不同引數的方法，所以，對于多載而言，在方法呼叫之前，編譯器就已經確定了所要呼叫的方法，這稱為 “早系結”或“靜態系結” ；而對于多型，只等到方法呼叫的那一刻，解釋運行器才會確定所要呼叫的具體方法，這稱為 “晚系結”或“動態系結” ，

3、關鍵字：super

理解為：父類的

3.1、super呼叫屬性、方法：

• 我們可以在子類的方法或構造器中，通過使用"super.屬性"或"super.方法"的方式，顯式的呼叫父類中宣告的屬性或方法，但是，通常情況下，我們習慣省略"super."
• 當子類和父類中定義了同名的屬性時，我們要想在子類中呼叫父類中宣告的屬性，則必須顯式的使用"super.屬性"的方式，表明呼叫的是父類中宣告的屬性，
• 當子類重寫了父類中的方法以后，我們想在子類的方法中呼叫父類中被重寫的方法時，則必須顯式的使用"super.方法"的方式，表明呼叫的是父類中被重寫的方法，

3.2、super呼叫構造器：

• 我們可以在子類的構造器中顯式的使用"super(形參串列)"的方式，呼叫父類中宣告的指定的構造器，
• "super(形參串列)"的使用，必須宣告在子類構造器的首行！
• 我們在類的構造器中，針對于"this(形參串列)"或"super(形參串列)"只能二選一，不能同時出現，
• 在構造器的首行，沒顯式的宣告"this(形參串列)“或"super(形參串列)”，則默認呼叫的是父類中空參的構造器：super()
• 在類的多個構造器中，至少一個類的構造器中使用了"super(形參串列)"，呼叫父類中的構造器，

4、子類物件實體化全程序

子類中所有的建構式默認都會訪問父類中的空引數的建構式，當然，如果子類中指定了訪問父類帶引數的建構式，就不會訪問父類默認的建構式，所以，如果父類中沒有默認的建構式，子類嘗試呼叫父類的默認建構式，程式就會報錯：

public class ExtendsDemo {
    public static void main(String[] args) {
        new Zi(10);
    }
}

class Fu {
    Fu(int x) {      //指定了新的建構式，默認的建構式就沒有了
        System.out.println("父類有參構造器");
    }
}

class Zi extends Fu {
    Zi() {
        super(3);  //父類有帶引數的建構式
        System.out.println("子類無參構造器");
    }

    Zi(int x) {
        this();
        //super(x);  //默認會訪問父類的建構式
        System.out.println("子類有參構造器");
    }
}

運行結果：

圖示：

5、多型性

5.1、什么是多型性？

父類的參考指向子類的物件（或子類的物件賦給父類的參考）

5.2、多型性的使用：虛擬方法呼叫

有了物件的多型性以后，我們在編譯期，只能呼叫父類中宣告的方法，但在運行期，我們實際執行的是子類重寫父類的方法，
總結：編譯，看左邊；運行，看右邊，
注意點：物件的多型性，只適用于方法，不適用于屬性（編譯和運行都看左邊）

5.3、多型性的使用前提：① 類的繼承關系 ② 方法的重寫

5.4、關于向上轉型（多型）與向下轉型：

• 為什么使用向下轉型：
  有了物件的多型性以后，記憶體中實際上是加載了子類特有的屬性和方法的，但是由于變數宣告為父型別別，導致編譯時，只能呼叫父類中宣告的屬性和方法，子類特有的屬性和方法不能呼叫，如何才能呼叫子類特的屬性和方法？使用向下轉型，
• 如何實作向下轉型：
  使用強制型別轉換符：()
• 使用時的注意點：
  ① 使用強轉時，可能出現ClassCastException的例外，
  ② 為了避免在向下轉型時出現ClassCastException的例外，我們在向下轉型之前，先進行instanceof的判斷，一旦回傳true，就進行向下轉型，如果回傳false，不進行向下轉型，
• instanceof的使用：
  ① a instanceof A:判斷物件a是否是類A的實體，如果是，回傳true；如果不是，回傳false，
  ② 如果 a instanceof A回傳true,則 a instanceof B也回傳true.其中，類B是類A的父類，
  ③ 要求a所屬的類與類A必須是子類和父類的關系，否則編譯錯誤，

圖示：

5.5、多型性的理解：

1、實作代碼的通用性
2、Object類中定義的public boolean equals(Object obj){ }
JDBC:使用java程式操作(獲取資料庫連接、CRUD)資料庫(MySQL、Oracle、DB2、SQL Server)
3、 抽象類、介面的使用肯定體現了多型性，（抽象類、介面不能實體化）

6、Object類的使用

6.1、java.lang.Object類的說明：

• Object類是所Java類的根父類
• 如果在類的宣告中未使用extends關鍵字指明其父類，則默認父類為java.lang.Object類
• Object類中的功能(屬性、方法)就具通用性，
  屬性：無
  方法：equals() / toString() / getClass() /hashCode() / clone() / finalize() / wait() / notify() / notifyAll()
• Object類只宣告了一個空參的構造器

6.2、equals（）方法的使用：

① 是一個方法，而非運算子 ② 只能適用于參考資料型別 ③ 比較兩個物件的"物體內容"是否相同，

7、包裝類的使用

7.1、為什么要有包裝類(或封裝類）

為了使基本資料型別的變數具有類的特征，引入包裝類，

7.2、基本資料型別與對應的包裝類：

7.3、需要掌握的型別間的轉換：（基本資料型別、包裝類、String）

簡易版：

• 基本資料型別<—>包裝類： JDK 5.0 新特性：自動裝箱 與自動拆箱
• 基本資料型別、包裝類—>String: 呼叫String多載的valueOf(Xxx xxx)
• String—>基本資料型別、包裝類: 呼叫包裝類的parseXxx(String s)
  注意： 轉換時，可能會報NumberFormatException

應用場景舉例：

• Vector類中關于添加元素，只定義了形參為Object型別的方法：
  v.addElement(Object obj); //基本資料型別 —>包裝類 —>使用多型