昨天的問題

1. Q：if/else和if/else if有甚麼差別?
   A：if/else只進行一個條件的判斷，當if的判斷為true時，執行if作用域內的程式碼，當if為flase時，執行else作用域內的程式碼。
2. Q：switch 應該如何使用?
   A：

switch(條件判斷) {
    case 判斷結果:
        執行程式碼;
        break; // 中斷程式碼
    default:
        條件判斷結果沒有相符的情況執行預設程式碼;
}

圈圈圓圓圈圈之循環再循環(單純想唱首歌)

Java中的循環方式有三種：

• for
• while
• do while

for：會由初始值、條件判斷(true、false)、迭代、執行的程式碼四個部分組成，當條件判斷為true時，會不斷地執行scope內的程式碼，在運行完後進行迭代，若迭代後條件判斷依然為true時，會不斷反覆的循環執行，一直到條件判斷為false時終止。

程式碼格式：

    for(初始值; 條件判斷; 迭代) {
        執行的程式碼
    }

• 生活舉例：我有100塊（初始值），當我的錢足夠買一瓶20塊的水時(條件判斷)，100塊-20塊(迭代)，買水(執行的程式碼)。

• 順序：我有100塊 -> 我的錢足夠買一瓶水 -> 買水 -> 100塊-20塊 -> 我的錢足夠買一瓶水 -> 買水 -> 80塊-20塊 -> .... 我的錢不夠買水 -> 覆蓋這張卡結束這回合回家喝水 ? 。

程式碼範例：

 
 for(int i = 1; i <= 10; i++) {
	  System.out.print(i+"\t");
  }
	// 1 2 3 4 5 6 7 8 9 10
    /*
	  int i = 1 : 初始值
	  i <= 10 : 條件判斷
	  System.out.print(i+"\t"); : 執行的程式碼
	  i++ : 迭代
	*/

while：與for一樣由初始值、條件判斷(true、false)、迭代、執行的程式碼四個部分組成，當條件判斷為true時，會不斷地執行scope內的程式碼，在運行完後進行迭代，若迭代後條件判斷依然為true時，會不斷反覆的循環執行，一直到條件判斷為false時終止。

💡while和for在於初始值、條件判斷(true、false)、迭代放置的位置不同，並且由於while的初始值是宣告在scope外，所以即使離開while循環時，依然能夠使用他的初始值，for則相反。

在寫while循環時，因為不像for循環一樣在最一開始時就先寫迭代，若不小心忘記加上迭代會造成無限循環~~~

程式碼範例：

int i = 1; //不一樣的地方是初始值的宣告在scope外

while(i <= 10) {
	System.out.print(i + "\t");
	i++; //不一樣的地方是迭代在scope內執行
}
  // 1 2 3 4 5 6 7 8 9 10
    /*
	  int i = 1 : 初始值
	  i <= 10 : 條件判斷
	  System.out.print(i+"\t"); : 執行的程式碼
	  i++ : 迭代
	*/

do while：與while和for一樣由初始值、條件判斷(true、false)、迭代、執行的程式碼四個部分組成，當條件判斷為true時，會不斷地執行scope內的程式碼，在運行完後進行迭代，若迭代後條件判斷依然為true時，會不斷反覆的循環執行，一直到條件判斷為false時終止。

💡do while循環相較於while和for比較不同的地方在於，即便今天條件判斷已經為false時，還是會執行一次scope內的程式碼。

程式碼範例：

1. 條件判斷一開始就已經為false：

• 生活舉例：我有100塊，去一間一道菜500元的餐廳點了一道菜來吃，沒有錢再點第二道。(這只是舉例你會被抓去關)

int i = 1;
do {
	System.out.println(i);
} while(i < 0);

  /*
	  int i = 1 : 初始值
		i <= 0 : 條件判斷
		System.out.println(i) : 執行的程式碼
		i++ : 迭代
	*/
	
	// 1
	

2. 條件判斷一開始為true：

• 生活舉例：我有1000塊，去一間一道菜500元的餐廳點了一道菜來吃，我的錢還足夠點一道菜，點了第二道菜來吃，錢不夠點第三道菜了，結束這回合。

int i = 1;
do {
	System.out.println(i);
	i++
} while(i < 10);

  /*
	  int i = 1 : 初始值
		i <= 10 : 條件判斷
		System.out.println(i) : 執行的程式碼
		i++ : 迭代
	*/
	
	// 1
	// 2
	// ...
	// 9
	// 10

break 和 continue

• break：可以使用在switch case或循環(for、while、do while)中，用於將循環中斷，有時候無法確定到底需要循環幾次才中斷時，可以使用break;將循環中斷。

• 生活舉例：我去操場跑步，但是我不知道我的體力可以跑幾圈(條件判斷為未知)，當我沒有體力時就回家洗洗睡(break)。

範例：

for(int i = 1; i <= 10; i++) {
	if(i % 3 == 0) {
		break;
		}
	System.out.println(i);
}

// 1
// 2

// 當 i 為 3 時，餘數為0，執行break結束整個循環，只印出了1、2

第二種方式：
使用for(初始值;;迭代)，代表不確定條件判斷或使用for(;;)，連初始值和迭代都不寫，並且在scope內加入break;進行循環中段。

範例：

// 有初始化和迭代
for(int i = 0;;i++){
    if(i == 10) {
        System.out.println(i);
        break;
    }
}
// 10

// 沒有初始化和迭代
int num = 5;
for(;;) {
    num++;
    if(num > 100) {
        System.out.println(num);
        break;
    }
}
// 100

💡當break用在兩層循環時，只會將離他最近的循環結束掉，第一層的循環仍會繼續執行，除非有在第一層的循環加上標籤。

沒有標籤範例：

for(int i = 1; i <= 4; i++) {
	 for(int j = 1; i <= 10; j++) {
		if(j % 3 == 0) {
			break;
			}
		System.out.println(i);
	}
}
// 1
// 2
// 1
// 2
// 1
// 2
// 1
// 2

//執行了4次外層的for循環

有標籤範例：

label:for(int i = 1; i <= 4; i++) {
	 for(int j = 1; i <= 10; j++) {
		if(j % 3 == 0) {
			break label;
			}
			
		System.out.println(i);
	}
}
// 1
// 2

//執行了1次外層的for循環

continue：只可以使用循環(for、while、do while)中，與break不同的地方是，continue只會結束當次的循環，整個循環一樣會繼續執行

for(int i = 1; i <= 10; i++) {
	if(i % 3 == 0) {
			continue;
		}
	System.out.print(i);
}

// 12457810

💡當continue用在兩層循環時，只會將離他最近的循環結束掉，第一層的循環仍會繼續執行，除非有在第一層的循環加上標籤。

沒有標籤的範例：

for(int i = 1; i <= 4; i++) {
	for(int j = 1; j <= 10; i++) {
		if(j % 3 == 0) {
				continue;
			}
		System.out.print(i);
	}
	System.outt.println();
}

// 12457810
// 12457810
// 12457810
// 12457810

有標籤的範例：

label:for(int i = 1; i <= 4; i++) {
	for(int j = 1; j <= 10; i++) {
		if(j % 3 == 0) {
				continue label;
			}
		System.out.print(i);
	}
	System.outt.println();
}

// 12
// 12
// 12
// 12

99乘法表之我循環你的循環

循環裡面也可以有第二、第三.....循環到你不要不要，但一般兩層就差不多了，不然時間複雜度會大大大大的提升，對於程式執行的效率會很差。

上面是99乘法表的表格，透過兩層for循環，可以將99乘法表印出來

for(int i = 2; i <= 9; i++) {
    for(int j = 1; j <= 9; j++) {
        System.out.print((i * j) + "\t");
    }
    System.out.println(); // 換行
}

可以將行數看成是j，列數看成是i
i = 2： -> j = 1 -> 印出2 * 1 -> j = 2 -> 印出2 * 2 .... -> 印出2 * 9 -> 跳出j的循環 -> System.out.println(); // 換行 -> i++
i = 3： -> j = 1 -> 印出3 * 1 -> j = 2 -> 印出3 * 2 .... -> 印出3 * 9 -> 跳出j的循環 -> System.out.println(); // 換行 -> i++
...
i = 9： -> j = 1 -> 印出9 * 1 -> j = 2 -> 印出9 * 2 .... -> 印出9 * 9 -> 跳出j的循環 -> System.out.println(); // 換行 -> 跳出循環