1.關鍵字 & 標識符

關鍵字：被Java語言賦予了特殊含義，用做專門用途的字符串（單詞）

保留字：未來可能會被使用

標識符：凡是自己可以起名字的地方都叫標識符

命名的規則：（一定要遵守，不遵守就會報編譯的錯誤）
由26個英文字母大小寫，0-9 ，_或 $ 組成
數字不可以開頭。
不可以使用關鍵字和保留字，但能包含關鍵字和保留字。
Java中嚴格區分大小寫，長度無限制。
標識符不能包含空格。

Java中的名稱命名規範：（不遵守，也不會出現編譯的錯誤）
包名：多單詞組成時所有字母都小寫：xxxyyyzzz
類名、接口名：多單詞組成時，所有單詞的首字母大寫：XxxYyyZzz
變量名、方法名：多單詞組成時，第一個單詞首字母小寫，第二個單詞開始每個單詞首字母大寫：xxxYyyZzz
常量名：所有字母都大寫。多單詞時每個單詞用下劃線連接：XXX_YYY_ZZZ

2.變量

1.java中變量按照數據類型來分類：基本數據類型 vs 引用數據類型(數組 類 接口)
>基本數據類型：
整型：byte（8 bit） short int（默認類型） long
浮點型：float double (默認類型)
字符型：char（‘ ’）
布爾類型： boolean（只能取值為true 或false，不能取null）

補充：按照在類中存在的位置的不同：成員變量 vs 局部變量

2.進制（了解）
十進制 二進制 八進制 十六進制

二進制：計算機底層都是用二進制來存儲、運算。
>二進制 與十進制之間的轉換。
>二進制在底層存儲：正數、負數都是以補碼的形式存儲的。（原碼、反碼、補碼）
>四種進制間的轉換

3.變量的運算：
①自動類型轉換：容量小的數據類型自動轉換為容量大的數據類型。
short s = 12;
int i = s + 2;
註意：byte short char之間做運算，結果為int型！
②強制類型轉換：是①的逆過程。使用“（）”實現強轉。

3.運算符

運算符是一種特殊的符號，用以表示數據的運算、賦值和比較等。
算術運算符：
+ - + - * / % ++ -- +
註意：1） /: int i = 12; i = i / 5;
2） %：最後的符號只跟被模數相同
3）前++：先+1，後運算 後++：先運算，後+1
4）+：String字符串與其他數據類型只能做連接運算，且結果為String類型。sysout(‘*‘ + ‘\t‘ + ‘*‘); vs sysout("*" + ‘\t‘ + ‘*‘);

賦值運算符：
= += -= *= /= %=
int i= 12；
i = i * 5;
i *= 5;//與上一行代碼同樣的意思
【特別地】
short s = 10;
s = s + 5;//報編譯的異常
s = (short)(s + 5);
s += 5;//s = s + 5，但是結果不會改變s的數據類型。

比較運算符（關系運算符）
== > < >= <= instanceof

【註意】區分== 與 = 區別。
進行比較運算操作以後，返回一個boolean類型的值
4>=3 表達的是4 > 3或者 4 = 3.結果是true。

if(i > 1 && i < 10){ }
不能寫為：if(1 < i < 10){}

邏輯運算符（運算符的兩端是boolean值）
& && | || ^ !
【註意】區分 & 與 && 的區別，以及 | 與 || 的區別
我們使用的時候，選擇&& ， ||

位運算符(兩端是數值類型的數據)
<< >> >>> & | ^ ~
【例子】1.如何交換m = 12和n = 5的值
2.將60轉換為十六進制輸出。
三元運算符
(條件表達式)？ 表達式1 ： 表達式2；
1）既然是運算符，一定會返回一個結果，並且結果的數據類型與表達式1，2的類型一致
2）表達式1與表達式2 的數據類型一致。
3）使用三元運算符的，一定可以轉換為if-else。反之不一定成立。
例子：獲取兩個數的較大值；獲取三個數的最大值。

4.流程控制

1.順序結構
>程序從上往下的順序執行

2.分支結構：
if-else
switch-case

3.循環結構：
while(){}
do{}while()
for(;;){}

4.1 分支結構

1.條件判斷:
①if(條件表達式){ }

②if(條件表達式){
//執行的語句1；
}else{
//執行的語句2；
}

③if(條件表達式1){
//執行的語句1；
}else if(條件表達式2){
//執行的語句2；
}else if( 條件表達式3){
//執行的語句3；
}...
}else{
//執行的語句；
}

【註意】
1.一旦滿足某個條件表達式，則進入其執行語句塊執行，執行完畢，跳出當前的條件判斷結構，不會執行其以下的條件結構語句。
2.如果諸多個條件表達式之間為“互斥”關系，多個結構可以上下調換順序
如果諸多個條件表達式之間為“包含”關系，要求條件表達式範圍小的寫在範圍大的上面。

2.選擇結構
switch(變量){
case 值1:

//break;
case 值2:

//break;
...
default:

break;
}

【註意】
1.變量可以為如下的數據類型：byte short int char 枚舉 String
2.case後只能填寫變量的值，不能寫範圍。
3.default是可以省略的。並且其位置也是靈活的，但是通常將其放在case語句之後。
4.一旦滿足某個case語句，則進入執行其操作。直至遇到break或者程序終止。
5.若要判斷的語句的條件滿足switch變量的數據類型，且值不多的情況下，建議選擇switch-case .
除此之外，選擇if-else.

4.2 循環結構

1.格式：
①初始化條件
②循環條件
③叠代部分
④循環體

for(①;②;③){
④
}

①
while(②){
④
③
}

①
do{
④
③
}while(②);

註：1.不同的循環結構之間可以相互轉換
2.while和do-while的區別：do-while程序至少會執行一次

2.嵌套循環：循環結構還可以聲明循環。讓內層循環結構整體充當外層循環的循環體。
若外層循環執行m次，內層循環執行n次，整個程序執行m*n次。

【題目】
******
******
******
for(int i = 0;i < 3;i++){
for(int j = 0;j < 6;j++){
System.out.print("*");
}
System.out.println();
}
說明：外層循環控制行數，內層循環控制列數
【例題】1.九九乘法表 2.輸出100內的質數。（兩種）

3.無限循環結構
for(;;){
...
if( ){
break;
}
...
}
或者
while(true){
...
if( ){
break;
}
...
}
往往我們在無限循環結構內部提供循環的終止條件，使用break關鍵字。否則，此循環將無限制的執行下去，形成死循環！
死循環是我們要避免的。

4.3 break & continue

break:
>使用switch-case結構或者循環結構中
>在循環結構中，一旦執行到break，就跳出當前循環。

continue:使用在循環結構中
>一旦執行到continue，就跳出當次循環。

for(int i = 1;i <= 10;i++){
if(i % 4 == 0){
//break; //123
continue; //123567910
}

System.out.print(i);
}

在嵌套循環中，使用帶標簽的break和continue。
label:for(int i = 1;i < 5;i++){
for(int j = 1;j <= 10;j++){
if(j % 4 == 0){
//break;
//continue;
//break label;
continue label;
}
System.out.print(j);
}
System.out.println();
}

5.數組

數組：相同數據類型的數據的組合。

如： int score1 = 72;
int score2 = 90;
int score3 = 59;

使用數組：
1.數組的初始化
int[] scores1 = new int[]{72,90,59};//靜態初始化：在聲明並初始化數組與給數組相應的元素賦值操作同時進行。
int scores2[] = new int[3];//動態初始化：在聲明並初始化數組與給數組相應的元素賦值操作分開進行。
scores2[0] = 72;
scores2[1] = 90;
scores2[2] = 59;
//聲明數組的錯誤寫法：
1）String[] names = new String[5]{"AA","BB","CC"};
2）int i[10];
3）int i = new int[];
註：不管是動態還是靜態初始化數組，一定在創建的時候，就指明了數組的長度！
2.如何引用數組元素：通過數組的下角標的方式。下角標從0開始，到n-1結束。其中n為數組的長度。
3.數組的長度：通過數組的屬性length來調用。
System.out.println(scores2.length);//3
4.如何遍歷數組
for(int i = 0;i < scores1.length;i++){
System.out.println(scores1[i]);
}
5.關於數組元素的默認初始化值
1)byte short int long 而言：0
2)float double 而言：0.0
3)char而言：空格
4)boolean而言：false
5)引用類型變量而言:null

5.1 二維數組

1.聲明並初始化
//一維：
int[] i = new int[12];
i[0] = 12;

int[] j = new int[]{12,3};

//二維：
1)String[][] str = new String[4][3]; //4行3列

2)String[][] str1 = new String[4][];
str1[0] = new String[3];
...
str1[3] = new String[5];
3)
int[][] arr = new int[][]{{1,2,3},{4,5},{6}};

2.如何引用二維數組的元素：arr[1][0] = 12;

3.二維數組的長度：arr.length;//3
arr[1].length;//2

4.遍歷二維數組

for(int i = 0;i < arr.length;i++){
for(int j = 0;j < arr[i].length;j++){
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}

5.2 數組的常見異常

//1.數組下標越界的異常:java.lang.ArrayIndexOutOfBoundsException
int[] i = new int[10];
// i[0] = 90;
// i[10] = 99;

// for(int m = 0;m <= i.length;m++){
// System.out.println(i[m]);
// }
//2.空指針的異常：NullPointerException
//第一種：
// boolean[] b = new boolean[3];
// b = null;
// System.out.println(b[0]);

//第二種：
// String[] str = new String[4];
// //str[3] = new String("AA");//str[3] = "AA";
// System.out.println(str[3].toString());

//第三種：
int[][] j = new int[3][];
j[2][0] = 12;

5.3 數組的常用算法

1.求數組元素的最大值、最小值、和、平均數

2.數組的復制和反轉

數組的反轉：
// 數組元素的反轉
// for(int i = 0;i < arr.length/2;i++){
// int temp = arr[i];
// arr[i] = arr[arr.length-1 - i];
// arr[arr.length - 1 - i] = temp;
// }
for (int x = 0, y = arr.length - 1; x < y; x++, y--) {
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}

2.基本語法