1、編譯型和解釋型

編譯型：compile:將中文翻譯成英文。

解釋型：如js，邊解釋邊執行。

Java是先編譯，再在作業系統進行解釋，編譯型和解釋型相結合的。

2、java語法

2.1 註釋：單行註釋，多行註釋，文件註釋。

2.2 識別符號：識別符號都是以字母、數字、美元符、下劃線組合，且不能以數字開頭，不能以關鍵字命名。

3、資料型別

java是一種強型別語言，要求變數的使用嚴格符合規定，所有的變數必須先定義後才能使用。

Java的資料型別分為兩大類：基本型別，引用型別。

//Long型別要在數字後面加個L，用於區分它是長整型。浮點型同理。

long num2 = 30L;

float num3 = 20.2F;

double num4 = 3.14159;

int型別的包裝類Integer。

什麼是位元組：

4、資料型別擴充套件

        //===========================
        //浮點數擴充套件   銀行業務怎麼表示?錢
        //BigDecimal  數學工具類
        //===========================
        //總結：float  有限，離散，舍入誤差，大約，接近但不等於
        //double
        //最好完全避免使用浮點數進行比較
        float f = 0.1f; //0.1
        double d = 1.0/10; //0.1
        System.out.println(f==d);//false
        float f1 = 12312321312123f;
        float f2 = f1 + 1;
        System.out.println(f1==f2);//true
 

總結：對小數進行比較或者加減，最好使用BigDecimal工具類對小數進行定義。

		//===========================
        //字元擴充套件
        //===========================
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);//a
        System.out.println((int)c1);//97
        System.out.println(c2);//中
        System.out.println((int)c2);//20013
        //所有的字元本質還是數字
        //轉移字元
        // \t  製表符
        // \n  換行
 

5、型別轉換

低 -------------------->高

byte,short,char-> int -> long -> float -> double

//強制轉換 （型別）變數名 高--低

//自動轉換 低--高

注意點：

1.不能對布林值進行轉換

2.不能把物件型別轉換為不相干的型別

3.在把高容量轉換到低容量的時候，強制轉換

4.轉換的時候可能存在記憶體溢位，或者精度問題（如byte最大值為127，若定義為128，則會存在記憶體溢位。小數強轉為整數則會出現精度問題）

6、變數與常量

變數作用域：

類變數（寫在類裡面的，static關鍵詞修飾的）、例項變數（也是寫在類裡面的，但是沒有static關鍵詞修飾）、區域性變數（寫在方法裡面的）

區域性變數：必須宣告和初始化值，不然不能使用。

例項變數：從屬於物件；如果不自行初始化，

基本型別的預設值為0或0.0。布林值預設是false，除了基本型別，其餘的預設值是null。

Variable variable = new Variable ();

System.out.println(variable.str);// 能夠輸出hello world，這就是例項變數定義的作用。

常量：

//修飾符，不存在先後順序,final static也可以。

static final double pi = 3.14;

常量命名一般都是大寫字母和下劃線組合。如MAX_VALUE;

7、運算子

關係運算符：instanceof 判斷一個物件是否是一個類的例項。

a++ ，++a

邏輯運算子：

與：&& //邏輯與運算，兩個變數都為真，結果才為真

或：|| //邏輯或運算，兩個變數有一個為真，則結果為真

非！ //邏輯非運算，如果為真，則結果為假，如果是假則結果為真

位運算：

/*
        A = 0011 1100
        B = 0000 1101
        ---------------
        A&B = 0000 1100 A或B
        A|B = 0011 1101 A與B
        A^B = 0011 0001 A異或B
        ~B = 1111 0010 非B

        思考題：2*8 = 16   用什麼辦法可以運算最快？
        可以用移位運算子，因為移位運算子是跟底層二進位制打交道的，效率極高。
        例如，2<<3  翻譯出來就是 2 * 2^3 = 2*8,
        3<<2 翻譯出來就是 3*2^2 = 3*4;
        << 左移是乘
        >> 右移是除
*/

字串拼接符：

int a = 10;
int b = 20;
//字串連線符 + ，String
System.out.println(""+a+b);//結果為1020
System.out.println(a+b+"");//結果為30
//總結：如果拼接的字串在後面，則前面的變數會進行運算

8、包機制

一般利用公司域名倒置作為包名

com.公司名.專案名.模組名.*

9、JavaDoc生成文件

引數資訊：

@author 作者名

@version 版本號

@since 指明需要最早使用的jdk版本

@param 引數名

@return 返回值情況

@throws 異常丟擲資訊

如何使用Idea生成JavaDoc文件？

10、Scanner互動

    public static void main(String[] args) {

        //建立一個掃描物件，用於接收鍵盤資料
        Scanner scanner = new Scanner(System.in);

        //判斷使用者有沒有輸入字串
        /*if(scanner.hasNext()){
            //使用next方式接收
            String str = scanner.next();
            System.out.println("我輸入了：" + str);
        }
        //凡是屬於IO流的類，如果不關閉會一直佔用資源，要養成好習慣用完就關掉
        scanner.close();*/

        /*System.out.println("使用nextLine方式接收：");
        //判斷是否還有輸入
        if(scanner.hasNextLine()){
        String str = scanner.nextLine();
            System.out.println("我輸入了：" + str);
        }
        scanner.close();*/

        System.out.println("請輸入資料：");
        String str = scanner.nextLine();
        System.out.println("輸出的內容為："+str);
        scanner.close();
        
    }

11、流程控制結構

順序結構、選擇結構、迴圈結構

if多選擇結構：只會進入滿足條件的表示式，然後就跳出了

一旦其中一個else if 語句檢測為true，其他的else if 以及 else 語句都將跳過執行。

switch多選擇結構：

迴圈結構：

while 迴圈、do....while迴圈、增強for迴圈

for迴圈結構：

	//初始化//條件判斷//迭代
for(int i = 1;i < 100;i++){

}

迴圈結構小練習：

 		//練習1：計算0到100之間的奇數和偶數的和
        int oddSum = 0;//儲存奇數的和
        int evenSum = 0;//儲存偶數的和

        for (int i = 0; i < 100; i++) {
            if(i%2!=0){
                oddSum+=i;
            }else{
                evenSum+=i;
            }
        }
        System.out.println("奇數的和："+oddSum);
        System.out.println("偶數的和："+evenSum);

        //練習2：用while或for迴圈輸出1-1000之間能被5整除的數，並且每行輸出3個
        int m=0;//用於計數
        for (int i = 0; i < 1000; i++) {
            if(i%5==0){
                System.out.print(i + "\t");
                m++;
                if (m%3==0){
                    System.out.println();//換行符
                }
            }
        }

        //練習3：列印九九乘法表
        for (int i = 1; i < 10; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j+"*"+i+"="+i*j);
                System.out.print("\t");
            }
            System.out.println();
        }

普通for迴圈和增強for迴圈結構的區別：

		int[] numbers = {10,20,30,40,50};
        //普通for迴圈
        for (int i=0; i < numbers.length; i++){
            System.out.println(numbers[i]);
        }
        System.out.println("===============");
        //增強for迴圈 遍歷陣列元素
        for (int number:numbers){
            System.out.println(number);
        }

總結：可以簡化程式碼

break和continue的區別：

break用於強行退出迴圈，不執行迴圈中剩餘的語句。

continue用於終止某次迴圈過程，即跳過迴圈體中尚未執行的語句，接著進行下一次是否執行迴圈的判定。

12、Java的方法

一個方法只完成一個功能，保證方法的原子性，有利於日後的擴充套件。

Java都是值傳遞，不是引用傳遞。

方法的過載：

過載就是在一個類中，有相同的方法名稱，但形參不同的方法。

方法的重寫：子類繼承父類，並重寫父類的方法。

可變長引數：

在方法宣告中，在指定引數型別後加一個省略號（...）。

一個方法中只能指定一個可變引數，它必須是方法的最後一個引數。任何普通的引數必須在它之前宣告。

public class Demo05 {
    public static void main(String[] args) {
         Demo05 demo05 = new Demo05();
         demo05.test(1,2,3,4,5);
    }

    public void test(int a,int... i ){
        System.out.println(i[0]);//會輸出2,也就是定義的i的引數可以隨便變化的
    }
}

13、遞迴講解

遞迴就是自身呼叫自身方法，遞迴結構包括兩個部分：

遞迴頭：什麼時候不呼叫自身方法。如果沒有頭，將陷入死迴圈。

遞迴體：什麼時候需要呼叫自身方法。

遞迴要有邊界條件：邊界

返回階段：如n*(n-1)

Java的執行就像一個棧，main方法在最底層，每遞迴一個方法都會網上加一層，所以遞迴次數多了，程式就很容易崩潰。所以儘量少用遞迴。

14、陣列

陣列是相同型別資料的有序集合。

陣列的宣告：int[] nums; int nums[];

陣列的四個基本特點：

1、陣列的長度是確定的，陣列一旦被建立，它的大小就是不可以改變的。

2、其元素必須是相同型別，不允許出現混合型別。

3、陣列中的元素可以是任何資料型別，包括基本型別和引用型別。

4、陣列變數屬引用型別，陣列本身就是物件，每個元素相當於該物件的成員變數，Java中物件是在堆中的，所以陣列無論儲存宣告型別，陣列物件本身是在堆中的。

陣列的三種初始化：

1、靜態初始化：

int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)}//引用初始化

2、動態初始化：

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

3、陣列的預設初始化：

陣列是引用型別，它的元素相當於雷打例項變數，因此陣列一經分配空間，其中的每個元素也被按照例項變數同樣的方式被隱式初始化。

陣列特點小結：

• 陣列是相同物件資料型別的有序集合
• 陣列也是物件。陣列元素相當於物件的成員變數。
• 陣列長度是確定的，不可變的。如果越界，則報ArrayIndexOutoBounds錯誤。

小作業，將陣列逆序輸出：

package main.java;

public class Demo07 {
    public static void main(String[] args) {

        int[] nums = {1,2,3,4,5};
        int[] reverse = reverse(nums);//將陣列逆序
        printArray(reverse);//列印逆序後的陣列

    }

    //將陣列元素逆序
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        for (int i = 0,j = arrays.length -1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }

    //輸出列印陣列
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }

    }
}

15、記憶體分析

16、多維陣列

多維陣列就是陣列巢狀陣列。

package main.java;

public class Demo08 {
    public static void main(String[] args) {
        //可以看成一個4行2列的陣列。
        int[][] array = {{1,2},{3,4},{5,6},{7,8}};
        printArray(array[0]);//{1,2}
        System.out.println();
        System.out.println(array[2][0]);//5
        System.out.println(array[3][1]);//8
        System.out.println(array.length);//4
        System.out.println(array[0].length);//2
    }

    //輸出列印陣列
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }

}

17、Arrays類

Java工具類的一種，常用方法：

給陣列賦值：通過fill方法。

對陣列排序：通過sort方法，按升序。

比較陣列：通過equals方法比較陣列中元素值是否相等。

將陣列轉轉換成字串：通過toString方法。

查詢陣列元素：通過binarySearch方法能對排序好的陣列進行二分查詢法操作。

18、氣泡排序

兩兩比較，最大的一個數比較到最後一個去，然後最後一個不動，比較剩餘的數。依次迴圈比較。

package main.java;

import java.util.Random;

//氣泡排序
public class Demo09 {
    public static void main(String[] args) {

        int[] arr = new int[5];//宣告一個數組
        Random r = new Random();//生成隨機數

        for (int i = 0; i < arr.length; i++) {
            arr[i] = r.nextInt(20);//生成10以內的隨機數放入陣列中
        }
        boolean flag = false;//通過flag標識位減少沒有意義的比較
        for (int j = arr.length -1; j > 0; j--) {
            for (int i = 0; i < j; i++){
                if (arr[i] > arr[i+1]){
                    swap(arr,i,i+1);
                    flag = true;//陣列沒有處在最好的情況（正序），則繼續迴圈
                }
            }
            if(!flag){//如果陣列是排好的，則可以跳出迴圈
                break;
            }
        }
        printArrays(arr);

    }

    //列印陣列元素
    static void printArrays(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }

    //將陣列元素進行交換
    static void swap(int[] arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

}

19、稀疏陣列

概念：記錄有效的座標，記錄出原始數值的座標及有效值，記錄每個值的有效座標。

待更新程式碼。

20、面向物件

1、Java的核心思想就是OOP（面向物件程式設計）

2、面向過程思想：步驟清晰簡單，第一步做什麼，第二步做什麼...

面向物件思想：物以類聚，分類的思維模式。

面向過程適合處理一些較為簡單的問題，面向物件適合處理複雜的問題。

3、面向物件程式設計的本質就是：以類的方式組織程式碼，以物件的組織（封裝）資料。

物件，是具體的事物。類，是抽象的，是對物件的抽象。

從程式碼執行角度考慮是先有類後有物件。類是物件的模板。

21、構造器詳解

1、一個類即使什麼都不寫，它也會存在一個方法，這個方法就是構造方法。

2、構造器核心概念：

2.1、有參構造：一旦定義了有參構造，無參構造就必須顯示定義。

//一個類即使什麼都不寫，也會存在一個隱式的無參的構造方法。
public class Person{

	String name;
    
    //無參構造，定義了有參構造，無參構造就必須要給定義出來
    //作用：1.使用new關鍵字，本質是在呼叫構造器 2.用來初始化值
    public Person(){     
    }
    
    //有參構造，可以根據傳遞的引數來建立物件包含的屬性
    public Person(String name){
        this.name = name;//this.  代表當前類
    }
    
}

3、總結：

構造器：

1、構造器和類名相同

2、沒有返回值

作用：

1、new本質是在呼叫構造方法。

2、初始化物件的值。

注意點：定義有參構造之後，如果想使用無參構造，就需要顯式的定義一個無參的構造器。

22、物件記憶體分析

解析：Java的主方法和定義的物件的變數名都是存放在棧中的，每執行一個方法也在在棧中疊加。還有一個堆都是存放例項化出來的物件的，方法區放置一些靜態方法和常量，也屬於堆。

23、封裝、繼承、多型

1、封裝：

追求高內聚，低耦合。

從程式碼層面解釋：高內聚就是類的內部資料操作細節自己完成，不允許外部干涉；低耦合：僅暴露少量的方法給外部使用。

高內聚就是說相關度比較高的部分儘可能的集中，不要分散。

低耦合就是說兩個相關的模組儘可以能把依賴的部分降低到最小，不要讓兩個系統產生強依賴。模組與模組之間關聯小，相互獨立。

封裝的意義：

//屬性私有，get/set
1.提高程式的安全性，保護資料
2.隱藏程式碼的實現細節
3.統一介面
4.增加系統的可維護性

2、繼承：

子類繼承父類，實際就是子類（派生類）對父類（基類）的擴充套件。

Java只能單繼承，沒有多繼承。一個兒子只能有一個爸爸。

1.子類繼承了父類，就會擁有父類的全部方法。
2.Java中所有類都直接或間接繼承Object類。

如果類被final修飾了，則不能被繼承了。

3、多型：

多型即同一方法可以根據傳送物件的不同而採用多種不同的行為方式。

多型注意事項：
1、多型是方法的多型，屬性沒有多型
2、父類和子類，有聯絡 型別轉換異常：ClassCastException
3、多型存在的條件：有繼承關係，子類重寫父類方法，父類引用指向子類物件。Father f1 = new Son();

注意：多型是方法的多型，屬性沒有多型性。

注意點：

1、private，static，final修飾的方法不能被重寫。

24、Super詳解

super注意點：
 1.super呼叫父類的構造方法，必須在構造方法的第一個
 2.super必須只能出現在子類的方法或構造方法中。
 3.super和this不能同時呼叫構造方法。
 
 super 和 this的不同：
 代表的物件不同：
   this:本身呼叫者的這個物件。
   super:代表父類物件的應用。
 前提：
   this:沒有繼承也能使用
   super:只能在繼承條件才可以使用
 構造方法：
   this()本類的構造
   super()父類的構造
 

25、方法重寫

重寫：需要有繼承關係，子類重寫父類的方法。
1、方法名必須相同
2、引數列表必須相同
3、修飾符：範圍可以擴大但不能縮小； public>protected>default>private
4、丟擲的異常：範圍可以被縮小，但不能被擴大。

重寫，子類的方法和父類的方法必須要一致，方法體不同。

為什麼需要重寫？

1、父類的功能，子類不一定需要，或者不一定滿足。

26、instanceof和型別轉換

X instanceof Y 如果X和Y有繼承關係，則返回true。

27、static關鍵字詳解

static可以修飾變數，方法，還有程式碼塊。

跟隨類一起載入。

只執行一次。

28、抽象類與介面

抽象類：

1、抽象類只能單繼承，介面可以多繼承。

2、不能new一個抽象類，只能靠子類去實現它。

3、抽象類 中可以寫普通的方法。抽象方法必須寫在抽象類中。

介面：

作用：

1.約束 2.定義一些方法，讓不同的人實現。

3.public abstract 4.public static final定義常量

5.介面不能被例項化，介面中沒有構造方法。

6.implements可以實現多個介面。

7.必須要重寫介面中的方法。

29、內部類

30、異常

異常處理處理五個關鍵字：try,catch,finally,throw（在方法中丟擲異常）,throws（在方法上丟擲異常）；···

try{//try監控區域

}catch(Exception e){//catch 捕獲異常

}finally{//處理善後操作

}

finally 可以不要，但是如果是IO流，資源必須關閉。

catch(想要捕獲的異常型別，如 Throwable,Exception)

假設要捕獲多個異常，要從小到大去捕獲。