語法規(guī)則

一、變量與數(shù)據(jù)類型

變量就是系統(tǒng)為程序分配的一塊內(nèi)存單元，用來存儲各種類型的數(shù)據(jù)。由于該存儲單元中的數(shù)據(jù)可以發(fā)生改變，因此得名為"變量"。

1、變量分類：

基本數(shù)據(jù)類型變量

引用數(shù)據(jù)類型變量。

按照位置分類：

局部變量：方法或語句塊內(nèi)部定義的變量

成員變量：方法外部、類的內(nèi)部定義的變量

注意：類的外面不能有變量的聲明

2、數(shù)據(jù)類型：

Java中的數(shù)據(jù)類型有四類八種。

3、標(biāo)識符

Java 對包、類、方法、參數(shù)和變量等要素命名時使用的字符序列稱為標(biāo)識符。

規(guī)則：

1. 由字母、數(shù)字、下劃線（_）和美元符號（$）組成。
2. 不能以數(shù)字開頭
3. 區(qū)分大小
4. 長度無限制
5. 不能是 Java 中的保留關(guān)鍵字

需要見名知意，包名小駝峰，類名大駝峰，方法小駝峰，變量名全部小寫，遵循《阿里巴巴Java手冊規(guī)范》。

4、類型轉(zhuǎn)換

自動類型轉(zhuǎn)換：容量小的類型自動轉(zhuǎn)換成容量大的數(shù)據(jù)類型

byte,short,int -> float ->long ->double
byte,short,int 不會互相轉(zhuǎn)換，它們?nèi)咴谟嬎銜r會轉(zhuǎn)換成 int 類型

強(qiáng)制類型轉(zhuǎn)換：容量大的類型轉(zhuǎn)換成容量小的數(shù)據(jù)類型時，要加上強(qiáng)制轉(zhuǎn)換符

long l = 100L;
int i = (int)l;

有可能造成精度降低或數(shù)據(jù)溢出，使用時要小心。

二、方法

方法用于封裝一段特定的邏輯功能。方法的主要要素有：權(quán)限修飾符 方法名、參數(shù)列表和返回值。

1、格式：

權(quán)限修飾符 返回值類型聲明 方法名稱(參數(shù)列表){
    方法中封裝的邏輯功能;
    return 返回值;
}

2、權(quán)限修飾符

3、返回值

方法調(diào)用結(jié)束后可以返回一個數(shù)據(jù)，稱之為返回值。 方法在聲明時必須指定返回值的類型。 通過 return 語句返回，return 語句的作用在于結(jié)束方法且將數(shù)據(jù)返回。 如果方法沒有返回值（即方法不需要返回數(shù)據(jù)），需將返回值類型聲明為 void，此時直接return會結(jié)束此方法。

4、參數(shù)列表

方法的參數(shù)列表：在調(diào)用時傳遞給方法，需要被方法處理的數(shù)據(jù)。 在方法定義時，需要聲明該方法所需要的參數(shù)變量。 在方法調(diào)用時，會將實(shí)際參數(shù)值傳遞給方法的參數(shù)變量。必須保證傳遞參數(shù)的類型和個數(shù)符合方法的聲明。

public void say(int a,int b){
    System.out.println(“方法 say 正在執(zhí)行”);
}

三、運(yùn)算符

四、轉(zhuǎn)義字符

所有的ASCII碼都可以用“\”加數(shù)字（一般是8進(jìn)制數(shù)字）來表示。
而C中定義了一些字母前加"\"來表示常見的那些不能顯示的ASCII字符，如\0,\t,\n等，就稱為轉(zhuǎn)義字符，因?yàn)楹竺娴淖址疾皇撬緛淼腁SCII字符意思了

程序執(zhí)行結(jié)構(gòu)

任何簡單或復(fù)雜的算法都可以由順序結(jié)構(gòu)、分支結(jié)構(gòu)和循環(huán)結(jié)構(gòu)這三種基本 結(jié)構(gòu)組合而成。

順序結(jié)構(gòu)是一種基本的控制結(jié)構(gòu)，它按照語句出現(xiàn)的順序執(zhí)行操作。

分支結(jié)構(gòu)又被稱為選擇結(jié)構(gòu)，根據(jù)條件成立與否來執(zhí)行操作。

循環(huán)結(jié)構(gòu)是一種重復(fù)結(jié)構(gòu)，如果條件成立，它會重復(fù)執(zhí)行某一循環(huán)體，直到出現(xiàn)不滿足的條件為止。

一、分支結(jié)構(gòu)：

1、if-else、if-else if-else格式：

if(條件語句){…}
if (條件語句){…}else{…}
if (條件語句){…}else if(條件語句){…}
if (條件語句){…}else if(條件語句){…}else{…}

2、switch

switch(表達(dá)式){
case 取值1: 語句塊 1;break;
case 取值n: 語句塊 n;break;
default: 語句塊 n+1;break;
}

注意：

1. 表達(dá)式的返回值必須是下述幾種類型之一：int, byte, char, short,String；
2. case 子句中的取值必須是常量，且所有 case 子句中的取值應(yīng)是不同的；
3. default 子句是可選的；
4. break 語句用來在執(zhí)行完一個 case 分支后使程序跳出 switch 語句塊；
5. 如果 case 后面沒有寫 break 則直接往下面執(zhí)行！
6. Case 后面的執(zhí)行體可寫{ }也可以不寫{ }

二、循環(huán)結(jié)構(gòu)

1、while循環(huán)

符合條件，循環(huán)繼續(xù)執(zhí)行；否則，循環(huán)退出 特點(diǎn)：先判斷，再執(zhí)行

while(條件表達(dá)式){
    //語句塊；
}

使用 while 循環(huán)的步驟

1. 分析循環(huán)條件和循環(huán)操作
2. 套用 while 語法寫出代碼
3. 檢查循環(huán)是否能夠退出

2、do-while循環(huán)

先執(zhí)行一遍循環(huán)操作，符合條件，循環(huán)繼續(xù)執(zhí)行；否則，循環(huán)退出

特點(diǎn)：先執(zhí)行，再判斷

do {
    循環(huán)操作
}while ( 條件表達(dá)式 );

while 循環(huán)和 do-while 循環(huán)的區(qū)別？

• while:先判斷條件，如果條件滿足，再執(zhí)行循環(huán)操作
• do while:先執(zhí)行一遍循環(huán)操作，然后再判讀條件，如果條件滿足，繼續(xù)執(zhí)行循環(huán)操作。

3、for循環(huán)

for(初始化參數(shù);判斷條件 ;更新循環(huán)變量){
    循環(huán)體;
}

逗號運(yùn)算符：

這里不可忽略的一個就是逗號操作符，Java里唯一用到逗號操作符的就是for循環(huán)控制語句。在表達(dá)式的初始化部分，可以使用一系列的逗號分隔的語句;通過逗號操作符，可以在 for語句內(nèi)定義多個變量，但它們必須具有相同的類型

for(int i = 1, j = i + 10;i < 5;i++, j = j * 2){}

4、for-each語句

在Java JDK 1.5中還引入了一種更加簡潔的、方便對數(shù)組和集合進(jìn)行遍歷的方法，即for-each 語句，例子如下：

int array[] = {7, 8, 9};
for (int arr : array) {
    System.out.println(arr);
}

三、跳出語句

Java語言中，有三種跳轉(zhuǎn)語句: break、continue 和return。

1、break語句：

break語句我們在 switch 中已經(jīng)見到了，它是用于終止循環(huán)的操作，實(shí)際上break 語句在for、while、do…while循環(huán)語句中，用于強(qiáng)行退出當(dāng)前循環(huán)，例如

for(int i = 0;i < 10;i++){
    if(i == 5){
        break;
    }
}

還可以通過添加標(biāo)簽跳出多層循環(huán)：

p:for(int j = 0; j < 10 ; j++){
    for(int i = 0;i < 10;i++){
        if(i == 5){
            break p;
        }
    }
}

2、continue語句：

continue也可以放在循環(huán)語句中，它與break 語句具有相反的效果，它的作用是用于直接執(zhí)行下一次循環(huán), 而不是退出當(dāng)前循環(huán)，還以上面的例子為主：

for(int i = 0;i < 10;i++){
    System.out.printl(" i = " + i );
    if(i == 5){
        System.out.printl("continue ... ");
        continue;
    }
}

3、return 語句

public void getName() {
    return name;
}

數(shù)組

數(shù)組是相同數(shù)據(jù)類型的多個數(shù)據(jù)的容器，這些元素按線性順序排列。所謂線性順序是指除第一個元素外，每一個元素都有唯一的前驅(qū)元素；除最后一個元素外，每一個元素都有唯一的后繼元素。（“簡單理解就是：一個跟一個順序排列”）。

1、創(chuàng)建格式：

//格式 1. 數(shù)據(jù)類型[] 數(shù)組名稱 = new 數(shù)據(jù)類型[數(shù)組長度];
//格式 2. 數(shù)據(jù)類型[] 數(shù)組名稱 = {數(shù)組內(nèi)容 1,數(shù)組內(nèi)容 2,數(shù)組內(nèi)容 3...數(shù)組內(nèi)容 n};
//格式 3. 數(shù)據(jù)類型[] 數(shù)組名;
//格式 3 屬于只創(chuàng)建了數(shù)組引用名， 并未在內(nèi)存創(chuàng)建數(shù)組空間。
//格式 4. 數(shù)據(jù)類型[] 數(shù)組名稱 = new 數(shù)據(jù)類型[]{內(nèi)容 1,內(nèi)容 2,內(nèi)容 3...內(nèi)容 n};

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

2、下標(biāo)

數(shù)組中內(nèi)容的數(shù)字序號，從 0 開始 ，對于長度為 n 的數(shù)組，下標(biāo)的范圍是 0~n-1。我們可以通過下標(biāo)的方式訪問數(shù)組中的每一個元素。

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

3、獲取數(shù)組長度

int len = a.length;

注意：使用數(shù)組不當(dāng)會出現(xiàn)數(shù)組未賦值、空指針異常的問題。超出長度的下標(biāo)操作會導(dǎo)致數(shù)組越界異常。數(shù)組的長度在創(chuàng)建時就固定了，如果數(shù)組已經(jīng)滿了想增加元素只能動態(tài)擴(kuò)容（申請新數(shù)組，舊數(shù)組拷貝，釋放舊數(shù)組）。

4、數(shù)組常用算法：

冒泡排序：

原理：
- 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
- 對每一對相鄰元素做同樣的工作，從開始第一對到結(jié)尾的最后一對。在這一點(diǎn)，最后的元素應(yīng)該會是最大的數(shù)。
- 針對所有的元素重復(fù)以上的步驟，除了最后一個。
- 持續(xù)每次對越來越少的元素重復(fù)上面的步驟，直到?jīng)]有任何一對數(shù)字需要比較。

升序排列:
    最后一個位置放最大值
    外層 循環(huán)length-1
    內(nèi)層循環(huán)length-i-1
降序排序:
    最后一個位置放最小值
    外層 循環(huán)length-1
    內(nèi)層循環(huán)length-i-1

int[] nums = new int[]{1,3,9,5,6,7,15,4,8};
int target = 6;

//冒泡排序
for(int i = 0; i < nums.length; i++){
    for(int j = 0; j < nums.length - i - 1; j++){
        if(nums[j] > nums[j+1]){
            //可以使用亦或運(yùn)算避免引入額外變量來交換
            int temp = nums[j+1];
            nums[j+1] = nums[j];
            nums[j] = temp;
        }
    }
}
System.out.println("排序后的數(shù)組為");
for(int i = 0; i < nums.length; i++){
    System.out.print(nums[i]+" ");
}
System.out.println("");

二分查找：

二分查找也稱折半查找（Binary Search），它是一種效率較高的查找方法。但是，二分查找要求數(shù)組數(shù)據(jù)必須采用順 序存儲結(jié)構(gòu)有序排列。

首先，假設(shè)數(shù)組中元素是按升序排列，將數(shù)組中間位置的數(shù)據(jù)與查找數(shù)據(jù)比較，如果兩者相等，則查找成功；否則利用 中間位置記錄將數(shù)組分成前、后兩個子數(shù)組，如果中間位置數(shù)據(jù)大于查找數(shù)據(jù)，則進(jìn)一步查找前子數(shù)組，否則進(jìn)一步查 找后子數(shù)組。 重復(fù)以上過程，直到找到滿足條件的數(shù)據(jù)，則表示查找成功， 直到子數(shù)組不存在為止，表示查找不成功。

//二分查找
int minIndex = 0;
int maxIndex = nums.length - 1;
int midInex = (minIndex + maxIndex)/2;

while (minIndex <= maxIndex){
    if(nums[midInex] == target) return midInex;
    else if(nums[midInex] < target){
        minIndex = midInex + 1;
    }
    else if(nums[midInex] > target){
        maxIndex = midInex - 1;
    }
    midInex = (minIndex + maxIndex)/2;
}
System.out.println("不存在該目標(biāo)數(shù)字");
return -1;

動態(tài)擴(kuò)容：選取模擬實(shí)現(xiàn)數(shù)組的myList類中的add方法

public void add(Object...elements){
        if(this.length == 0){
            this.element = elements;
            this.length = elements.length; // 一共有多少位置
            this.size = this.length; //當(dāng)前使用了多少位置
            return;
        }
        if(this.size <= this.size + elements.length){//原本已經(jīng)有內(nèi)容了，但是要擴(kuò)容添加
            this.length = this.size + elements.length;
            Object[] newElement = new Object[this.length];
            int i = 0;
            for( ; i < this.size; i++){
                newElement[i] = element[i];
            }
            System.out.println("i = " + i);
            for(int j = 0; j < elements.length;j++){
                newElement[i] = elements[j];
                i++;
            }
            this.element = newElement;
            this.size = this.length;
        }
    }