Java基礎學習 2 (選擇結構,循環結構)

程序的執行流程

在一個程序執行的過程當中，各條語句的執行順序對程序的結果是有直接影響的。
也就是說程序的流程對運行結果有直接的影響。因此，咱們必須清楚每條語句的執行流程。
並且，不少時候咱們要經過控制語句的執行順序來實現咱們要完成的功能。
程序的執行流程分爲三類：

1. 順序結構：代碼從上往下一行一行去執行。
2. 選擇結構：也被稱爲分支結構。選擇結構有特定的語法規則，代碼要執行具體的邏輯運算進行判斷，邏輯運算的結果有兩個，因此產生選擇，按照不一樣的選擇執行不一樣的代碼。
3. 循環結構：循環語句能夠在知足循環條件的狀況下，反覆執行某一段代碼，這段被重複執行的代碼被稱爲循環體語句，當反覆執行這個循環體時，須要在合適的時候把循環判斷條件修改成false，從而結束循環，不然循環將一直執行下去，造成死循環。

Scanner

Java提供的類，能夠同來獲取從鍵盤中輸入的數據。
使用步驟分爲如下三步：

1. 導入程序包：import java.util.Scanner;
2. 建立鍵盤錄入對象：Scanner a = new Scanner(System.in);
3. 錄入輸入的數據：int b = a.nextInt();

if(選擇結構)

if語句是條件選擇語句，具備如下三種格式。

格式一：if

1     if(比較表達式或者是boolean類型的值) {
2         語句體;
3     }
4     /*執行流程
5     先計算比較表達式的值，看其返回值是true仍是false。
6         若是是true，就執行語句體；
7         若是是false，就不執行語句體；*/

格式二：if-else

 1   if(比較表達式) {
 2             語句體1;
 3         }else {
 4             語句體2;
 5         }
 6 
 7     //注意事項：else後面是沒有比較表達式的，只有if後面有。
 8     /*執行流程
 9     首先計算比較表達式的值，看其返回值是true仍是false。
10     若是是true，就執行語句體1；
11     若是是false，就執行語句體2；*/

格式三：if-else if-else

 1  if(比較表達式1) {
 2             語句體1;
 3         }else if(比較表達式2) {
 4             語句體2;
 5         }else if(比較表達式3) {
 6             語句體3;
 7         }
 8         ...
 9         else {
10             語句體n+1;
11         }
12     //注意事項： 當只要有一個條件知足時，if語句結束。else是能夠省略，可是不建議省略。
13     /*執行流程
14     首先計算比較表達式1看其返回值是true仍是false，
15     若是是true，就執行語句體1，if語句結束。
16     若是是false，接着計算比較表達式2看其返回值是true仍是false，
17     
18     若是是true，就執行語句體2，if語句結束。
19     若是是false，接着計算比較表達式3看其返回值是true仍是false，
20     ...
21     
22     若是都是false，就執行語句體n+1。*/

if和三元表達式的區別：

1. 三元表達式寫出來的，if-else必定寫的出來。
2. if-else寫出來的，三元表達式不必定寫出來。

switch case（選擇結構）

switch case 語句判斷一個變量與一系列值中某個值是否相等，每一個值稱爲一個分支。
格式以下：

 1    switch語句的格式
 2         switch(表達式){
 3             case 值1:
 4                 語句體1;
 5                 break;
 6             case 值2:
 7                 語句體2;
 8                 break;
 9             case 值3:
10                 語句體3;
11                 break;
12             ....
13             default：    
14                 語句體n+1;
15                 break;
16         }
17     /*    switch語句的格式解釋
18     (1):switch表示這是switch語句
19         表達式的取值：byte,short,int,char
20         JDK5之後能夠是枚舉(什麼是枚舉，之後再講)
21         JDK7之後能夠是String
22     (2):case後面跟的是要和表達式進行比較的值
23     (3):語句體部分能夠是一條或多條語句
24     (4):break表示中斷，結束的意思，能夠結束switch語句
25     (5):default語句表示全部狀況都不匹配的時候，就執行該處的內容，和if語句的else類似*/
26     /*執行流程
27     先計算表達式的值
28     而後和case後面的匹配，若是匹配成功就執行對應的語句，遇到break就會結束,不然執行default控制的語句*/

面試題：byte能夠做爲switch的表達式嗎?
long能夠做爲switch的表達式嗎?
String能夠做爲switch的表達式嗎?

switch 語句中的變量類型能夠是： byte、short、int 或者 char。從 Java SE 7 開始，switch 支持字符串 String 類型了，同時 case 標籤必須爲字符串常量或字面量。
因此，byte、String都可以做爲switch的表達式，而long不能夠做爲switch的表達式。

for（循環結構）

for循環執行的次數是在執行前就肯定的。
格式以下：

 1  for(初始化表達式語句;判斷條件語句;控制條件語句) {
 2         循環體語句;
 3     }
 4     //注意事項：初始化表達式語句只執行一次
 5     /*執行流程：
 6     a:執行初始化表達式語句
 7     b:執行判斷條件語句,看其返回值是true仍是false
 8         若是是true，就繼續執行
 9         若是是false，就結束循環
10     c:執行循環體語句;
11     d:執行控制條件語句
12     e:回到B繼續。*/
13     //循環嵌套以後，外層循環控制行數，裏層循環控制列數

for循環的經典算法（水仙花數，星星三角形，九九乘法表）

• 水仙花數

所謂的水仙花數是指一個三位數，其各位數字的立方和等於該數自己。
舉例：153就是一個水仙花數。
153 = 111 + 555 + 333 = 1 + 125 + 27 = 153

 1    public class FlowerNumber {
 2                 public static void main(String args[]){
 3                     int a;
 4                     int b;
 5                     int c;
 6                     for (int i = 100 ; i <= 999 ; i++){
 7                        /*for (a = 1 ; a <= 9 ; a ++){
 8                             for (b = 0 ; b <= 9 ; b++){
 9                                 for (c = 0 ; c <= 9 ; c++){
10                                     if ((a * a * a) + (b * b * b) + (c * c * c) == a * 100 + b * 10 + c && i == a * 100 + b * 10 + c){
11                                         System.out.println(a * 100 + b * 10 + c);
12                                     }
13                                 }
14                             }
15                         }*//* 方法一  循環嵌套法*/
16                        /*a = (i / 100);
17                        b = (i % 100) / 10;
18                        c = (i % 10);
19                        if ((a * a * a) + (b * b * b) + (c * c * c) == a * 100 + b * 10 + c){
20                            System.out.println(i);
21                        }*//*方法二 取位數法*/
22                     }
23                 }
24             }

• 星星三角形

用*繪製一個直角三角形（5x5）。
代碼以下：

1          public class PaintStar {
2         public static void main(String args[]){
3             for (int i = 0 ; i < 5 ; i++){
4                 for (int j = 0 ; j <= i ; j++){
5                     System.out.print("*");
6                 }
7                 System.out.println();
8             }
9         } }

• 九九乘法表

繪製一個九九乘法表。
代碼以下：

 public class chengfabiao {
            public static void main(String args[]){
                for (int i = 1 ; i < 10 ; i++){
                    for (int j = 1 ; j <= i ; j++){
                        System.out.print(j + "*" + i + "=" + (j * i) + "\t");
                    }
                    System.out.println();
                }
            }
        }

while（循環結構）

while是最基本的循環。
格式爲：

 1      初始化條件語句;
 2             while(判斷條件語句) {
 3                  循環體語句;
 4                  控制條件語句;
 5            }
 6     /*執行流程：
 7     a:執行初始化條件語句;
 8     b:執行判斷條件語句,看其返回值是true仍是false
 9         若是是true，就繼續執行
10         若是是false，就結束循環
11     c:執行循環體語句;
12     d:執行控制條件語句
13     e:回到b繼續。*/

do while（循環結構）

對於 while 語句而言，若是不知足條件，則不能進入循環。但有時候咱們須要即便不知足條件，也至少執行一次。
do…while 循環和 while 循環類似，不一樣的是，do…while 循環至少會執行一次。

 1     初始化條件語句;
 2             do {
 3                 循環體語句;
 4                 控制條件語句;
 5             }while(判斷條件語句);
 6     /*執行流程：
 7     a:執行初始化條件語句;
 8     b:執行循環體語句;
 9     c:執行控制條件語句;
10     d:執行判斷條件語句,看其返回值是true仍是false
11         若是是true，就繼續執行
12         若是是false，就結束循環
13     e:回到b繼續。*/

三種循環結構的區別

1. do…while循環至少執行一次循環體。而for,while循環必須先判斷條件是否成立，而後決定是否執行循環體語句。
2. A： 若是你想在循環結束後，繼續使用控制條件的那個變量，用while循環，不然用for循環。不知道用for循環。由於變量及早的從內存中消失，能夠提升內存的使用效率。
3. B：建議優先考慮for循環，而後是while循環 ，最後是do…while循環。

break

中斷循環。能夠用在Switch語句，也能夠用在for，while循環中，用來結束循環。若離開了使用場景（switch，for，while）則沒有意義。若是有循環嵌套，break影響的是最近的循環.

例題：試判斷輸出結果

1     for (int i=0; i<3; i++) {
2     for (int j=0; j<3; j++) {
3     if (i == j) {
4     break;
5     }
6     System.out.println("i=" + i + ", j=" + j);
7     }
8     }

解：①結果：i=1, j=0
i=2, j=0
i=2, j=1
②（1）第一次外層for循環：i=0,由於0<3，因此執行內層的for循環。
第一次內層for循環：i=0,j=0，由於0 == 0，因此結束循環。
（2）第二次外層for循環：i=1,由於1<3，因此執行內層的for循環。
第一次內層for循環：i=1,j=0，由於1！=0，因此輸出i=1,j=0。
第二次內層for循環：i=1,j=1，由於1 == 0，因此結束循環。
（3）第三次外層for循環：i=2,由於2<3，因此執行內層的for循環。
第一次內層for循環：i=2,j=0，由於2！=0，因此輸出i=2,j=0。
第二次內層for循環：i=2,j=1，由於2！=1，因此輸出i=2,j=1。
第三次內層for循環：i=2,j=2，由於2==2，因此結束循環。
（4）第四次外層for循環：i=3,由於3=3，因此結束循環。

continue

用在循環場景當中，能夠跳過部分循環而不終端，離開循環場景後無心義。

例題：試判斷輸出結果

1 for (int i=0; i<3; i++) {
2     for (int j=0; j<3; j++) {
3     if (i == j) {
4     continue;
5     }
6     System.out.println("i=" + i + ", j=" + j);
7     }
8     }

解：①結果：i=0, j=1i=0, j=2i=1, j=0i=1, j=2i=2, j=0i=2, j=1②（1）第一次外層for循環：i=0,由於0<3，因此執行內層的for循環。第一次內層for循環：i=0,j=0，由於0 == 0，因此跳過這次循環。第二次內層for循環：i=0,j=1，由於0！=1，因此輸出i=0,j=1。第三次內層for循環：i=0,j=2，由於0！=2，因此輸出i=0,j=2。（2）第二次外層for循環：i=1,由於1<3，因此執行內層的for循環。第一次內層for循環：i=1,j=0，由於1！=0，因此輸出i=1,j=0。第二次內層for循環：i=1,j=1，由於1 == 1，因此跳過這次循環。第三次內層for循環：i=1,j=2，由於1！=2，因此輸出i=1,j=2。（3）第三次外層for循環：i=2,由於2<3，因此執行內層的for循環。第一次內層for循環：i=2,j=0，由於2！=0，因此輸出i=2,j=0。第二次內層for循環：i=2,j=1，由於2！=1，因此輸出i=2,j=1。第三次內層for循環：i=2,j=2，由於2==2，因此跳過這次循環。（4）第四次外層for循環：i=3,由於3=3，因此結束循環。