122.Java_控制語句

時間 2019-11-20

標籤 122.java java 控制語句欄目 Java 简体版

原文原文鏈接

控制語句

0.前定義

語句塊(有時叫作複合語句)，是用花括號擴起的任意數量的簡單Java語句。html

塊肯定了局部變量的做用域。塊中的程序代碼，做爲一個總體，是要被一塊兒執行的。java

塊能夠被嵌套在另外一個塊中，可是不能在兩個嵌套的塊內聲明同名的變量。dom

語句塊可使用外部的變量，而外部不能使用語句塊中定義的變量，由於語句塊中定義的變量做用域只限於語句塊。ide

 1 public class Test {
 2     public static void main(String[] args) {
 3         int n;
 4         int a;
 5         {
 6             int k;
 7             int n; //編譯錯誤：不能重複定義變量n
 8         } //變量k的做用域到此爲止
 9     }
10 }

Java裏的語句可分爲如下六類post

方法調用語句：如：System.out.println(" Hello");
表達式語句：表示式尾加上分號。好比賦值語句：x=23;
複合語句：能夠用{ }把一些語句括起來構成複合語句，如：{ z=123+x; System.out.println("How are you"); }
空語句：一個分號也是一條語句，稱作空語句。
控制語句：控制語句分爲條件分支語句、開關語句和循環語句。
package語句和 import語句：它們和類、對象有關，package是java放在哪，import指定導入包

1.綜述

流程控制語句是用來控制程序中各語句執行順序的語句，能夠把語句組合成能完成必定功能的小邏輯模塊。性能

控制語句分爲三類：順序、選擇和循環。
順序結構：表明「先執行a，再執行b」的邏輯。
選擇結構：表明「若是…，則…」的邏輯，
循環結構：表明「若是…，則再繼續…」的邏輯。 spa

遞歸結構：本身調用本身
迭代結構：不停調用另外一個設計

2.介紹

2.1 選擇結構

選擇結構用於判斷給定的條件，而後根據判斷的結果來控制程序的流程。調試

有以下結構：
if單選擇結構
if-else雙選擇結構
if-else if-else多選擇結構
switch結構 code

2.1.1 if單選擇結構

if語句是單條件分支語句，即根據一個條件來控制程序執行的流程

if(布爾表達式){
    語句塊
}

if語句對布爾表達式進行一次斷定，

若斷定爲真，則執行{}中的語句塊，不然跳過該語句塊

        if(count >= 10 && count <= 15) { //錯誤寫法：10<=count<=15
            System.out.println("1");
        }

注意：若是if語句不寫{}，則只能做用於後面的第一條語句。

　　　表達式的值必須是boolean型的；不能用0表明false；用1表明true；

//例子2將變量a，b，c內存中的數值按大小順序進行互換（從小到大排列）。 
public class Example3_2 {
   public static void main(String args[]) {
      int a = 9,b = 5,c = 7,t=0;
      if(b<a) {
        t = a;  a = b; b = t;
      }
      if(c<a) {
        t = a; a = c;c = t;
      }
      if(c<b) {
        t = b;  b = c; c = t;
      }        
    System.out.println("a="+a+",b="+b+",c="+c);
   }
}

2.1.2 if-else雙選擇結構

if-else 語句是雙條件分支語句，即根據一個條件來控制程序執行的流程

if(布爾表達式){
    語句塊1
}else{
       語句塊2
}

當布爾表達式爲真時，執行語句塊1，不然，執行語句塊2。也就是else部分。

if (a<b) {
            System.out.println(a);
} else {
            System.out.println(b);
}

注意：條件運算符有時候可用於代替if-else

 System.out.println((a<b)?a:b);

2.1.3 if-else if-else多選擇結構

if-else-if 語句是多條件分支語句，即根據多個條件來控制程序執行的流程

 if(布爾表達式1) {
     語句塊1;
 } else if(布爾表達式2) {
     語句塊2;
 }……else if(布爾表達式n){
     語句塊n;
} else {
     語句塊n+1;
}

當布爾表達式1爲真時，執行語句塊1;不然，判斷布爾表達式2，當布爾表達式2爲真時，執行語句塊2;不然，繼續判斷布爾表達式3······;若是1~n個布爾表達式均斷定爲假時，則執行語句塊n+1，也就是else部分。

 1 if (age < 15) {
 2             System.out.println("兒童");
 3         } else if (age < 25) {
 4             System.out.println("青年");
 5         } else if (age < 45) {
 6             System.out.println("中年");
 7         } else if (age < 65) {
 8             System.out.println("中老年");
 9         } else if (age < 85) {
10             System.out.println("老年");
11         } else {
12             System.out.println("老年");
13         }

2.1.4 switch多選擇結構

switch 語句是單條件多分支的開關語句

它的通常格式定義以下(其中break語句是可選的）：

switch(表達式)
{
   case 常量值1:
               若干個語句
               break;
   case  常量值2:
               若干個語句
               break;
    ...
   case  常量值n:
              若干個語句
              break;
   default:
         若干語句
}

說明：

1)表達式的值必須是：byte，short， Int，char不能是String或者long型的；（與int兼容類型）

2)default語句放的位置是任意的。

3)檢查時case 常量必須與switch表達式可用的類型相同。

4)switch語句會根據表達式的值從相匹配的case標籤處開始執行，

一直執行到break語句處或者是switch語句的末尾。

若是表達式的值與任一case值不匹配，則進入default語句(若是存在default語句的狀況)。

 1 public class Test{
 2     public static void main(String[] args) {
 3         char c = 'a';
 4         int rand = (int) (26 * Math.random());
 5         char c2 = (char) (c + rand);
 6         System.out.print(c2 + ": ");
 7         switch (c2) {
 8         case 'a':
 9         case 'e':
10         case 'i':
11         case 'o':
12         case 'u':
13             System.out.println("元音");
14             break;
15         case 'y':
16         case 'w':
17             System.out.println("半元音");
18             break;
19         default:
20             System.out.println("輔音");
21         }
22     }
23 }

switch

注意：

1）根據表達式值的不一樣能夠執行許多不一樣的操做。

switch語句中case標籤在JDK1.5以前必須是整數(long類型除外)或者枚舉，不能是字符串，

在JDK1.7以後容許使用字符串(String)。

2）當布爾表達式是等值判斷的狀況，可使用if-else if-else多選擇結構或者switch結構，

若是布爾表達式區間判斷的狀況，則只能使用if-else if-else多選擇結構。

//例子4使用了switch語句判斷用戶從鍵盤輸入的正整數是否爲中獎號碼。 
import java.util.Scanner;
public class Example3_4{
      public static void main(String args[]) {
      int number = 0;
      System.out.println("輸入正整數(回車肯定)");
      Scanner reader = new Scanner(System.in);
      number = reader.nextInt();
      switch(number) {
            case 9 :
            case 131 :
            case 12 :       System.out.println(number+"是三等獎");
                                  break;
             case 209 :
             case 596 :
             case 27 :      System.out.println(number+"是二等獎");
                                  break;
             case 875 :
             case 316 :
             case 59 :       System.out.println(number+"是一等獎");
                                   break;
              default:       System.out.println(number+"未中獎");
      }
   }
}

View Code

2.2 循環結構

循環結構分兩大類，一類是當型，一類是直到型。
當型：當布爾表達式條件爲true時，反覆執行某語句，當布爾表達式的值爲false時才中止循環，好比：while與for循環。
直到型：先執行某語句，再判斷布爾表達式，若是爲true，再執行某語句，如此反覆，直到布爾表達式條件爲false時才中止循環，好比do-while循環。

2.2.1 while循環

while (布爾表達式) {
    循環體;
}

在循環剛開始時，會計算一次「布爾表達式」的值，若條件爲真，執行循環體。而對於後來每一次額外的循環，都會在開始前從新計算一次。

        int  i = 0;
        int  sum = 0;
        // 1+2+3+…+100=?
        while (i <= 100) {
            sum += i;//至關於sum = sum+i;
            i++;
        }

注意：語句中應有使循環趨向於結束的語句，不然會出現無限循環–––"死"循環。

2.2.2 do-while循環

do {
        循環體;
 } while(布爾表達式) ;

do-while循環結構會先執行循環體，而後再判斷布爾表達式的值，若條件爲真，執行循環體，當條件爲假時結束循環。

        int i = 0;
        int sum = 0;
        do {
            sum += i; // sum = sum + i
            i++;
        } while (i <= 100);//此處的；不能省略
        System.out.println("Sum= " + sum);

注意：while與do-while的區別

do-while循環的循環體至少執行一次

public class Test{
    public static void main(String[] args) {
        //while循環：先判斷再執行
        int a = 0;
        while (a < 0) {
            System.out.println(a);
            a++;
        }
        System.out.println("-----");
        //do-while循環：先執行再判斷
        a = 0;
        do {
            System.out.println(a);
            a++;
        } while (a < 0);
    }

2.2.3 for循環

for (初始表達式; 布爾表達式; 迭代因子) {
      循環體;
}

for循環語句是支持迭代的一種通用結構，是最有效、最靈活的循環結構。

for循環在第一次反覆以前要進行初始化，即執行初始表達式;

隨後，對布爾表達式進行斷定，若斷定結果爲true，則執行循環體，

不然，終止循環;

最後在每一次反覆的時候，進行某種形式的「步進」，即執行迭代因子。
A. 初始化部分設置循環變量的初值
B. 條件判斷部分爲任意布爾表達式
C. 迭代因子控制循環變量的增減

for循環在執行條件斷定後，先執行的循環體部分，再執行步進。

        //求1-100之間的累加和
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        System.out.println("Sum= " + sum);

注意：
1）在控制表達式的初始化和步進控制部分，可使用一系列由逗號分隔的表達式，並且那些表達式均會獨立執行。
        1. 不管在初始化仍是在步進部分，語句都是順序執行的。
        2. 儘管初始化部分可設置任意數量的定義，但都屬於同一類型。
        3. 約定:只在for語句的控制表達式中寫入與循環變量初始化，條件判斷和迭代因子相關的表達式。
    4.初始化部分、條件判斷部分和迭代因子能夠爲空語句，但必須以「;」分開

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

2）無限循環

for ( ; ; ) {    // 無限循環: 至關於 while(true)
            System.out.println("北京尚學堂");)
}

3）初始化變量的做用域

for ( int i=1; i<10; i++) {               
System.out.println("1");
}
System.out.println(i+「、」)
//編譯錯誤，沒法訪問在for循環中定義的變量i

2.2.4 嵌套循環

在一個循環語句內部再嵌套一個或多個循環，稱爲嵌套循環。

while、do-while與for循環能夠任意嵌套多層。

 for (int i=1; i <=5; i++) {
            for(int j=1; j<=5; j++){
                System.out.print(i+"  ");
            }
            System.out.println();
 }

2.2.5 break語句和continue語句

1）在任何循環語句的主體部分，都可用break控制循環的流程。

break用於強行退出循環，不執行循環中剩餘的語句。

 1 public class Test {
 2     public static void main(String[] args) {
 3         int total = 0;//定義計數器
 4         System.out.println("Begin");
 5         while (true) {
 6             total++;//每循環一次計數器加1
 7             int i = (int) Math.round(100 * Math.random());
 8             //當i等於88時，退出循環
 9             if (i == 88) {
10                 break;
11             }
12         }
13         //輸出循環的次數
14         System.out.println("Game over， used " + total + " times.");
15     }
16 }

2）continue 語句用在循環語句體中，用於終止某次循環過程，

即跳過循環體中還沒有執行的語句，

接着進行下一次是否執行循環的斷定。

注意事項
1. continue用在while，do-while中，continue 語句馬上跳到循環首部，越過了當前循環的其他部分。
2. continue用在for循環中，跳到for循環的迭代因子部分。

 1 public class Test{
 2     public static void main(String[] args) {
 3         int count = 0;//定義計數器
 4         for (int i = 100; i < 150; i++) {
 5             //若是是3的倍數，則跳過本次循環，繼續進行下一次循環
 6             if (i % 3 == 0){
 7                 continue;
 8             }
 9             //不然（不是3的倍數），輸出該數
10             System.out.print(i + "、");
11             count++;//沒輸出一個數，計數器加1
12             //根據計數器判斷每行是否已經輸出了5個數
13             if (count % 5 == 0) {
14                 System.out.println();
15             }
16         }
17     }
18 }

continue語句：把100~150之間不能被3整除的數輸出，而且每行輸出5個

3)「標籤」是指後面跟一個冒號的標識符，例如：「label:」。
對Java來講惟一用到標籤的地方是在循環語句以前。

而在循環以前設置標籤的理由是：在其中嵌套另外一個循環，

因爲break和continue關鍵字一般只中斷當前循環，

但若隨同標籤使用，它們就會中斷到存在標籤的地方。

 1 public class Test {
 2     public static void main(String args[]) {
 3         outer: for (int i = 101; i < 150; i++) {
 4             for (int j = 2; j < i / 2; j++) {
 5                 if (i % j == 0){
 6                     continue outer;
 7                 }
 8             }
 9             System.out.print(i + "  ");
10         }
11     }
12 }

帶標籤break和continue：控制嵌套循環跳轉(打印101-150之間全部的質數)

4）goto關鍵字很早就在程序設計語言中出現。儘管goto還是Java的一個保留字，但並未在Java語言中獲得正式使用;Java沒有goto語句。然而，在break和continue這兩個關鍵字的身上，仍然能看出一些goto的影子---帶標籤的break和continue。
在「goto有害」論中，最有問題的就是標籤，而非goto，隨着標籤在一個程序裏數量的增多，產生錯誤的機會也愈來愈多。但Java標籤不會形成這方面的問題，由於它們的活動場所已被限死，不可經過特別的方式處處傳遞程序的控制權。

2.3 遞歸結構

1）遞歸是一種常見的解決問題的方法，即把問題逐漸簡單化。

遞歸的基本思想就是「本身調用本身」，一個使用遞歸技術的方法將會直接或者間接的調用本身。
利用遞歸能夠用簡單的程序來解決一些複雜的問題。好比：斐波那契數列的計算、漢諾塔、快排等問題。

2）遞歸結構包括兩個部分：
1.定義遞歸頭。解答：何時不調用自身方法。若是沒有頭，將陷入死循環，也就是遞歸的結束條件。
2.遞歸體。解答：何時須要調用自身方法。

 1 public class Test {
 2     public static void main(String[] args) {
 3         long d1 = System.currentTimeMillis();  
 4         System.out.printf("%d階乘的結果:%s%n", 10, factorial(10));
 5         long d2 = System.currentTimeMillis();
 6         System.out.printf("遞歸費時：%s%n", d2-d1);  //耗時：32ms
 7     }
 8     /** 求階乘的方法*/
 9     static long  factorial(int n){
10         if(n==1){//遞歸頭
11             return 1;
12         }else{//遞歸體
13             return n*factorial(n-1);//n! = n * (n-1)!
14         }
15     }
16 }

遞歸計算n！

使用循環求n!
public class Test23 {
    public static void main(String[] args) {
        long d3 = System.currentTimeMillis();
        int a = 10;
        int result = 1;
        while (a > 1) {
            result *= a * (a - 1);
            a -= 2;
        }
        long d4 = System.currentTimeMillis();
        System.out.println(result);
        System.out.printf("普通循環費時：%s%n", d4 - d3);
    }
}