JAVA基礎

-JAVA基礎

• 每篇一句 ：世界上本沒有完美，但是我們從未放棄追求完美
• 初學心得： 樂於揮霍的時間，都不能算作浪費
• (筆者：JEEP/711)[JAVA筆記 | 時間:2017-04-01| JAVA基礎 Ⅳ]

目錄導航

---

程序運行流程

(1) 順序結構 
(2) 分支結構 
(3) 循環結構 
(4) break 與 continue關鍵字 
(5) 數組 
(6) 方法

1.順序結構

如果代碼裏沒有流程控制，程序是至上而下一行一行執行的 
一條語句執行完之後繼續執行下一條語句，直到程序的最後

2.分支結構

順序結構只能順序執行，不能進行判斷和選擇，因此需要分支結構 
JAVA有兩種分支結構：● if 語句 ● switch 語句 
(1)：if 語句，一個 if 語句包含一個布爾表達式和一條或多條語句 
if語句三種格式：

語句格式一：if(條件表達式){
        執行語句；
    }
語句格式二：if(條件表達式){
        執行語句；
    }else{
        執行語句；
    }
語句格式三：if(條件表達式){
        執行語句；
    }else if (條件表達式){
        執行語句；
    }
    ……
    else
    {
        執行語句；
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19

if 語句的用語法如下： 如果布爾表達式的值爲 true，則執行 if 語句中的代碼塊，否則執行 if 語句塊後面的代碼

 if(布爾表達式) {
//如果布爾表達式爲true將執行的語句
 }

• 1
• 2
• 3

if語句代碼

 /**
 *if語句代碼
 **/
 //定義一個Demo類
public class Demo {
//定義主方法
   public static void main(String args[]){
      int a = 10; //定義一個變量
      if( a < 100 ){
         System.out.print("這是 if 語句"); //輸出語句
      }
   }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

if…else語句：if 語句後面可以跟 else 語句，當 if 語句的布爾表達式值爲 false 時，else 語句塊會被執行 
if…else 的用法：

 if(布爾表達式){
 //如果布爾表達式的值爲true
}else{
 //如果布爾表達式的值爲false
 }

• 1
• 2
• 3
• 4
• 5

if else語句代碼如下：

/**
*if else語句代碼
*//
//定義一個Demo2類
public class Demo2 {
//定義一個主方法
   public static void main(String args[]){
      int b = 30; //聲明一個變量並賦值
      if( b < 20 ){
         System.out.print("這是 if 語句");
      }else{
         System.out.print("這是 else 語句");
      }
   }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

(2)：switch 語句 
switch 語句判斷一個變量與一系列值中某個值是否相等，每個值稱爲一個分支 
case只是用來爲switch選擇一個執行代碼的入口，如果一旦進入一個入口之後，後面的case實際上已經失去了判斷的意義， 
JAVA在執行的時候就會把這個case之後的case相當於刪除了，所以就會一直往下執行，直到遇到break 
所以讀者可以發現， 每一個case後面沒有{}這個符號來表示一個代碼塊 
switch語句選擇的類型只有四種：byte、short、int 、char （java5版本之前）還支持 enum(jdk5), String(jdk7) 
case之間與default沒有順序，先執行第一個case，都沒有匹配的case值執行default。 
結束switch語句的兩種情況：遇到break，switch語句執行結束 
如果匹配的case或者default沒有對應的break，那麼程序會從第一次匹配的case語句開始繼續向下執行
運行可以執行的語句，直到遇到break或者switch結束爲止

switch語法格式：

switch(表達式){
    case 表達式可能的結果值1:
            執行語句；
    break；
    case 表達式可能的結果值2:
            執行語句；
    break；
        ...
    default:
            執行語句；
    break；
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

switch語句代碼如下：

/**
*switch代碼
**/
//定義一個Demo3類
public class Demo3 {
//定義一個主方法
   public static void main(String args[]){
      char grade = 'C';
      //switch語句
        switch(grades){
         case 'A' :
            System.out.println("優秀"); 
            break;
         case 'B' :
            System.out.println("良好");
            break;
         case 'C' :
            System.out.println("及格");
         case 'D' :
            System.out.println("你還需要努力學習");
            break;
         default :
            System.out.println("未知等級");
      }
      System.out.println("你的等級是 " + grade); //輸出語句
   }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27

3.循環結構

JAVA中有三種主要的循環結構：● while 循環 ● do…while 循環 ● for 循環 
用於處理需要重複執行的操作，根據判斷條件的成立與否，決定程序段落的執行次數，而這個程序段落稱爲循環體

(1)：while 循環，只要布爾表達式爲 true，循環體會一直執行下去，while是最基本的循環，它的結構爲：

while( 布爾表達式 ) {
  //循環內容
}

• 1
• 2
• 3

while循環代碼如下：

/**
*while循環
**/
//定義一個Demo4類
public class Demo4 {
//定義一個主方法
   public static void main(String args[]) {
      int c = 5; //定義一個變量
      // while循環體
      while( c < 10 ) {
         System.out.print("c的值爲:" + c ); //輸出c的值
         x++; //計數器
         System.out.print("\n"); // 輸出換行
      }
   }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

(2)：do…while 循環：do…while 循環和 while 循環相似，不同的是 do…while 循環至少會執行一次 
do…while 循環結構：布爾表達式在循環體的後面，所以語句塊在檢測布爾表達式之前已經執行了 
如果布爾表達式的值爲 true，則語句塊一直執行，直到布爾表達式的值爲 false

do {
  //代碼語句
}while(布爾表達式);

• 1
• 2
• 3

do…while 循環代碼

/**
*do…while 循環代碼
**/
//定義一個Demo5類
public class Demo5 {
//定義一個主方法
public static void main(String args[]){
   int d = 10; //定義一個變量
   //do…while 循環體
     do{
         System.out.print("d的值爲: " + d ); //輸出d的值
         d++; //計數器
         System.out.print("\n");
      }while( d < 20 );
   }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

(3).for循環：1, for循環裏面的3個表達式運行的順序，初始化表達式只讀一次，判斷循環條件，爲真就執行循環體 
然後再執行循環後的操作表達式，接着繼續判斷循環條件，重複找個過程，直到條件不滿足爲止。 
2, while與for可以互換，區別在於for爲了循環而定義的變量在for循環結束就在內存中釋放，而while循環使用的變量在循環結束後還可以繼續使用。 
3, 最簡單無限循環格式：while(true) , for(;;),無限循環存在的原因是並不知道循環多少次，而是根據某些條件，來控制循環

for循環執行的次數是在執行前就確定的，語法格式如下：

for(初始化表達式（1）；循環條件表達式（2）；循環後的操作表達式（3）){
        執行語句；（4）
}
for循環執行順序：(1) → (2) → (4) → (3) → (2) → (4) → (3)

• 1
• 2
• 3
• 4

for循環代碼

/**
*for循環代碼
*//
//定義一個Demo6類
public class Demo6 {
//定義一個主方法
   public static void main(String args[]) {
   //for循環體
  for(int e = 10; e < 20; e++) {
         System.out.print("e的值爲 : " + e);//輸出e的值
         System.out.print("\n"); //輸出換行
      }
   }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

4.break 與 continue關鍵字

break語句；break：終止該層循環 
continue語句；continue：跳過該層循環 
①：若這兩個語句離開應用範圍，存在是沒有意義的。 
②：這個兩個語句後面都能有語句，因爲執行不到。 
③：continue語句是跳過本次循環，繼續下次循環。 
④：標籤的出現，可以讓這兩個語句作用於指定的循環

break 關鍵字：break 主要用在循環語句或者 switch 語句中，用來跳出整個語句塊 
break 跳出最裏層的循環，並且繼續執行該循環下面的語句 
break 的用法很簡單，就是循環結構中的一條語句：break;

continue 關鍵字:continue 適用於任何循環控制結構中。作用是讓程序立刻跳轉到下一次循環的迭代 
在 for 循環中，continue 語句使程序立即跳轉到更新語句 
在 while 或者 do…while 循環中，程序立即跳轉到布爾表達式的判斷語句 
continue 就是循環體中一條簡單的語句：continue;

5.數組

筆者將講解JAVA數組的聲明、創建和初始化，並給出其對應的代碼 
數組概念：一組能夠儲存相同數據類型值得變量的集合 
數組的好處：數組裏的每個元素都有編號，編號從0開始；依次遞增，方便操作這些元素 
使用Java數組：必須先聲明數組，再給該數組分配內存， JAVA語言中提供數組是用來存儲固定大小的同類型元素

聲明一維數組 
一維數組：可以理解爲一列多行、類型相同的數據，其中每個數據被稱爲數組元素 
一維數組的聲明方式：

1.int x[];(不推薦使用)
2.int [] x = new int[3];
3.int x = new int[]{3,5.7}; 
4.int[] x; (推薦使用)
5.int[] x={3,5,7};
6.int a[5]; 非法數組，java語言聲明數組的時候不能指定其長度（元素的個數）

• 1
• 2
• 3
• 4
• 5
• 6

一維數組的初始化： 
JAVA中的數組必先初始化纔可以使用，所謂初始化就是爲數組的數組元素分配內存，併爲每個數組元素賦值 
數組初始化的兩種方式： 
1.靜態初始化：初始化時由我們自己指定每個數組元素的初始值，由系統決定需要的數組長度； 
格式：數組名 = new 數組類型[]{元素1,元素2,元素3…元素n}; 簡化語法：數組名 = {元素1,元素2,元素3…元素n}; 
2.動態初始化：初始化時由我們指定數組的長度，由系統爲數組元素分配初始值； 
格式：數組名 = new 數組類型[數組長度];

聲明二維數組： 
二維數組：(其實是一個一維數組，它的每一個元素又是一個一維數組),可以看做是一張表格 
在數組中再存放數組，外層數組看做是行，內層數組看做列；動態初始化，靜態初始化 
初始化二維數組聲明方式：

//動態初始化，定義了一個二維數組，其中有3個一維數組，每一個一維數組中有2個元素
int[][] a = new int[3][2];
//靜態初始化
int[][] a = new int[][]{{1,2},{3,4},{5,6}}; 
int[][] a = {{1,2},{3,4},{5,6}};

• 1
• 2
• 3
• 4
• 5

使用 二維數組：

int[] []  arr = {{3,1,5},{2,6},{8}};

• 1

元素值5的表示方式爲：arr[0][2] = 5; 
第二個一維數組的長度表示方式：int len = arr[1].length; 
對二維數組的遍歷使用for的嵌套循環。 
對於其他多維數組，幾維就用幾層for嵌套，但通常情況數組最多用到三維，因爲效率已經大大降低了

使用數組常見操作： 
JAVA語言的數組索引是從0開始的，也就是說數組裏的第一個元素的索引是0,第二個元素的索引是1 
1.給數組元素賦值 
2.數組名[索引] = 數組類型的值 ; 
3.訪問數組元素 
4.數組類型 變量 = 數組名[索引]; 
5.得到數組的長度 
6.int len = 數組名.length; //length是數組的屬性 
7.遍歷數組

數組操作常見問題

（ArrayIndexOutOfBoundsException）表示數組腳標越界異常
（NullPointerException）表示空引用異常

• 1
• 2

6.方法

筆者將講解：方法含義和定義格式，方法重載 
什麼是方法？一段可重複使用的代碼段；程序中完成獨立功能的一段代碼的集合 
方法的優點 ：● 1. 使程序變得更簡短而清晰 ● 2. 有利於程序維護 
● 3. 可以提高程序開發的效率 ● 4. 提高了代碼的重用性 
JAVA中定義方法的格式爲：

[修飾符] 返回值類型 方法名([參數類型 形式參數1，參數類型 形式參數2，……]){    
    執行語句;   [return 返回值;]
}
參數列表（參數的類型 ，參數的個數，參數的順序）

• 1
• 2
• 3
• 4

方法內容介紹： 
形式參數：在方法被調用時用於接收外界輸入的數據 
實參：調用方法時實際傳給方法的數據 
返回值：方法在執行完畢後返還給調用它的環境的數據 
返回值類型：事先約定的返回值的數據類型，如無返回值，必須給出返回類型 void 
方法簽名：方法名 和 方法的參數列表(能區別方法) 
java語言中調用方法：對象名.方法名（實參列表） 
實參的數目、數據類型和次序必須和所調用方法聲明的形參列表匹配 
return 語句終止方法的運行並指定要返回的數據

方法的重載（Overload） 
什麼是方法的重載？： 
在同一個類中，允許存在一個以上的同名方法，只要它們的參數個數或者參數類型或參數順序不同即可 
方法重載的特點：與返回值類型無關，只看參數列表 
記住方法重載方式的小技巧：兩同，一不同 
同一個類中方法名相同；參數列表不同：（參數個數，參數的類型，參數順序）

編程的命名規則： 
1.必須以字母、’_’或’＄’開頭 
2.可以包括數字，但不能以它開頭 
3.方法名不能使用關鍵字和保留字 
4.單詞的首字母大寫，採用駝峯式；由有實際意義的名詞或名詞短語構成 
5.方法名規範：第一個單詞的首字母小寫，採用駝峯式