Notes 20180308 : 語句

時間 2019-11-30

標籤 notes 語句简体版

原文原文鏈接

　　在講解流程控制語句以前，咱們先來講一下語句的問題。Java中的語句分爲聲明和賦值語句，條件和循環語句，調用和返回語句；咱們之因此每兩個放在一塊兒是有深意的，咱們大體將語句分爲這三塊，並以此爲綱來講一下，重點在流程控制語句（條件和循環語句）。html

　　程序就是由一系列的聲明、賦值、條件、循環、調用和返回語句組成的。通常來講代碼的結果都是嵌套的：一個條件或循環語句中也能夠嵌套條件語句或循環語句。而一個函數中能夠由若干各類語句組成，若干的函數組成類，正式這樣的組合才造成了功能豐富的軟件。下面咱們從聲明和賦值語句講起；java

1.1 聲明與賦值語句

　　聲明語句將一個變量名和一個類型在編譯時關聯起來。Java須要咱們在聲明語句的時候指定變量的名稱和類型。這樣咱們才能清楚的明白可以對其進行的操做。Java是一種強類型語言，由於Java編譯器會檢查類型的一致性（例如，它不會容許boolean類型和浮點類型的變量相乘）。變量能夠聲明在第一次使用以前的任何地方，通常咱們會在首次使用時聲明它，變量的做用域就是定義它的地方（成員或局部），通常由相同代碼段中聲明以後的全部語句組成。程序員

　　賦值語句（由一個表達式定義的）將某個數據類型的值（能夠是具體值，也能夠是一個引用）和一個變量關聯起來。在Java中，咱們進行賦值操做，咱們表達的不是數學中的等於「=」，而是將一個地址與該變量名綁定，讓該變量名指向這個內存地址。面試

package cn.assignment;

public class Test {
    //聲明語句由數據類型與變量名稱構成，--這裏的數據類型能夠是基本數據類型，也能夠是引用類型--對象
    static int i;
     /*int ii;
    ii = 89;*///不容許在賦值語句聲明完後再賦值，要在一塊兒操做,可是能夠成員聲明,函數中進行賦值的操做
    static int a1;
    public static void main(String[] args) {
        i = 23;
        System.out.println(i);//23
        System.out.println(a1 = 90);//90
    }
}

咱們在開發中每每建議將聲明和賦值放在一塊兒操做，即聲明的同時給語句賦值。算法

1.2 調用和返回語句

　　咱們對Java最大的印象只怕就在面向對象了，咱們寫的全部類的最大做用就是在於爲有須要的類提供可供解決的方法。這就是調用的的思想。例如咱們寫一個加法的運算，那麼之後凡是遇到加法的運算，那麼就均可以經過調用這個方法來解決了，這就是調用的思想，而有些方法是具備返回值的，返回值的語句是返回語句；舉例以下：數據庫

//簡單的加法運算
    public static int add(int a,int b){
        return a+b;//返回語句
    }

　　經過上面咱們發現語句並不固定於單類型語句的使用，而是花樣百出的嵌套，組合使用，這也是高級編程語言的靈活所在。在返回語句中咱們發現有一個關鍵字return，這裏咱們很少作介紹，咱們放在流程語句和continue和break一塊兒介紹。express

1.3 流程控制語句

　　瞭解完聲明和賦值語句、調用和返回語句，那麼咱們就進入今天的重頭戲--流程控制語句了，咱們在本節中會敘述流程控制語句的功能，同時還會附以案例增強，最後會深刻探討流程控制語句。編程

　　作任何事情都要遵循必定的原則。例如，到圖書館去借書，就必須有借書證，而且借書證不能過時，這兩個條件缺一不可。程序設計也是如此，須要有流程控制語言來實現與用戶的交流，並根據用戶的輸入決定程序要「作什麼」、「怎麼作」等。數組

　　流程控制語言對於任何一門編程語言來講都是相當重要的，它提供了控制程序步驟的基本手段。若是沒有流程控制語句，整個程序將按照線性的順序來執行，不能根據用戶的輸入來決定執行的序列。咱們大略的將流程控制語句分爲如下這麼幾類，複合語句、條件語句、循環語句。須要說明的一點是Java的控制流程結構與C、C++的控制流程結構同樣，只有不多的例外狀況。沒有goto語句，可是經過break+標籤，能夠實現從內層跳出的目的，另外，JDK1.5提供了一種變形的for循環，這是在C、C++中沒有出現過的。相似於C#中的foreach循環。多線程

1.3.1 複合語句

　　與C語言及其它語言相同，Java語言的複合語句是以整個區塊爲單位的語句，因此又稱塊（block）語句。塊是指由一堆大括號括起來的若干條簡單的Java語句。塊語句以整個塊爲單位，能夠用在任何一個單獨語句能夠用到的地方，塊肯定了變量的做用域。一個塊能夠嵌套在另外一個塊中。在前面的學習中已經解觸到了這種塊語句。例如在定義一個類或方法時，類體就是以「{}」做爲開始與結束的標記，方法體一樣也是以「{}」做爲標記。對於塊語句中的每一個語句都是從上到下的執行。

　　在使用複合語句時特別要注意，複合語句爲局部變量建立一個做用域，該做用域爲程序的一部分，在該做用域中某個變量被建立並可以被使用，若是某個變量的做用域外使用該變量，則會發生錯誤。同時，不能在嵌套的兩個塊中聲明同名的變量，這也是不被容許的。

【例5.1】建立CompoundStatementPractice類，進行復合語句的一些驗證；

class CompoundStatementPractice{
    public static void main(String[] args){
        int a = 23 ;
        System.out.println("a的值是:"+a);
        {
            int b = 24 , c = 25 ;
            System.out.println("b的值是:"+b);
            boolean boo ;        //咱們必定要注意變量的做用域,也就是它的生命週期
            {
                boo = b > c ;
                System.out.println("複合語句中的嵌套語句:"+boo);
            }
            // int a = 20 ; 若是在main方法中已經聲明成員變量,複合語句中再次聲明相同名字的成員變量會出現錯誤
            a = a++ + 1 ;
        }
        //System.out.println("在變量的做用域外使用變量會出現錯誤:"+b);  會提示找不到符號
        System.out.println("咱們必定要注意變量的做用域,和語句的線性順序:"+a);
    }
}

1.3.2 條件語句

　　條件語句可根據不一樣的條件執行不一樣的語句。條件語句包括if條件語句和switch多分支語句。

1.3.2.1 if條件語句

　　If條件語句是一個重要的編程語句，它用於告訴程序在某個條件成立的狀況下執行某段程序，而在另外一種狀況下執行另外的語句。

　　使用if條件語句，可選擇是否要執行緊跟在條件以後的那個語句。關鍵字if以後是做爲條件的「布爾表達式」，若是該表達式返回的結果是true，則執行其後的語句；若爲false，則不執行if條件以後的語句。If條件語句可分爲簡單的if條件語句、if...else語句和if...else if多分支語句。if語句在開發過程當中可能會出現Dead Code狀況,咱們平時可能較少遇到,可是要知道這種狀況,而且明白這是編譯器多作的優化.

1.3.2.1.1 簡單的if語句

　　語法格式以下：

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

布爾表達式：必要參數，表示它最後返回的結果必須是一個布爾值。它能夠是一個單純的布爾變量或常量，或者使用關係或布爾運算符的表達式。
語句序列：可選參數。能夠是一條或多條語句，當表達式爲true時執行這些語句。若是語句序列中僅含有一條語句，則能夠省略條件表達語句中的大括號。若是咱們本身編程時書寫了大括號，同時語句序列中只有一條語句，那麼編譯器在編譯時會自動幫咱們去除大括號。

【例5.2】建立IfPractice類，進行簡單if條件語句的練習

class IfPractice{
    public static void main(String[] args){
        int a = 23 , b = 24 ;
        boolean boo = true ,aoo = false ;
        if(! false == boo || (5 == 6)){
            System.out.println("表達式的形式能夠多樣但其結果必須爲boolean類型");
        }
        if(5 == 6);{
            System.out.println("若是if條件語句後即()後直接跟;則該條if簡單語句語句不管是否成立都繼續下面代碼");
        }
        if(a < b){
            if( a < b){
                System.out.println("If語句能夠像複合語句同樣嵌套語句!");
            }
            System.out.println("簡單if語句的標準形態;");
        }
        if(aoo) System.out.println("簡單if語句序列中若只有一條語句則能夠省略{}這時並沒有語法錯誤,而且if語句的做用範圍也可覆蓋,但不支持,爲了加強閱讀性");
            System.out.println("if語句若省略{},那麼其做用範圍只是緊隨其後的一條語句,其餘的語句會線性執行,不會受其表達式的影響!");
        if(boo){}//當簡單if語句序列中沒有內容時能夠省略{},末尾加;,固然也能夠保留,
        if(a < b && boo){
            System.out.println("簡單if語句中的條件必定要是布爾表達式,也就是結果必須是布爾型,格式不限制");
        }
        /*if(3 = 3){
            System.out.println("咱們必定要肯定if語句條件表達式的數據類型,如上3是int型,結果也是int型,會爆出錯誤之外的類型");
        }*/
    }
}

If語句注意點：

a,每一種格式都是單條語句。

b,第二種格式與三元運算符的區別：三元運算符運算完要有值出現。好處是：能夠寫在其餘表達式中。

c,條件表達式不管寫成什麼樣子，只看最終的結構是不是true 或者 false;

D.if語句同複合語句同樣能夠嵌套語句

If語句流程運行圖：

1.3.2.1.2 if...else語句

If....else語句和三元運算符的區別

If ....else語句的執行行程圖

對於if...else語句可使用三元運算符對語句進行簡化,以下面的代碼 if(a > 0) b = a ; else b = -a;

能夠簡化成: b = a>0?a:-a ；上面代碼爲求絕對值的語句，若是a > 0，就把a的值賦給b,不然將-a賦值給b。也就是「？」前面的表達式爲真，則將問號和冒號之間的表達式的計算結果賦值給變量b，不然將冒號後面的計算結果賦值給b，使用三元運算符的好處是可使代碼簡潔，而且有一個返回值。

圖3.4 if...else語句的執行過程圖

　　在第一種簡單if語句中條件不成立時if語句不能給出任何反饋,這是出現了第二種if語句當條件表達式的結果爲true則執行語句1,不然執行語句2.

注意事項:

A.else沒有條件表達式

B.else必須和if組合使用,else不能單獨使用會報錯

C.一個if語句只能有一個else

　　else是能夠省略的,當知道條件表達式成立時,能夠省略else,這時就至關於1.1if語句

　　if語句和else聯合使用時,if若是控制多行語句就必定要加{},不然出現B錯誤,這時狀況爲if語句+輸出語句+else,B狀況產生,若是if控制一行else控制一行時大括號能省,這時若是條件表達式爲true則進行緊挨if語句的輸出,反之輸出else,當if控制一行else控制多行時若是條件表達式爲true則進行緊挨if語句的輸出,else中輸出除去緊挨else的語句反之else中輸出,因此Java中無論什麼狀況不要省略{},避免錯誤

【例5.3】建立IfElsePractice類，並針對if....else的一些特性進行驗證

class IfElsePractice{
    public static void main(String[] args){
        /*else{
            System.out.println("else必須和if語句連用,不能單獨使用,不然會錯誤,有'if',可是沒有'else'");
        }*/
        if(5 > 6){
            System.out.println("咱們能夠看到簡單if語句條件不成立時,if語句不能出現任何反饋,那麼咱們怎麼知道是條件不成立仍是程序錯誤呢,這時就出現了if...else語句");
        }
        if(5 > 6){
            System.out.println("爲補充if語句而出現的if...else語句");
        }else/*(5 < 6)*/{
            System.out.println("if...else語句中else語句後不能有條件語句直接跟隨{},若是跟隨(),會發出錯誤,提示在()後加;");
        }/*else{
            System.out.println("一個if語句只能和一個else語句連用,不然會錯誤,有'if',可是沒有'else'");
        }*/
        if(5 < 6){
            System.out.println("當if後面只控制一條語句時,能夠省略{},它會直接輸出,不然不支持,由於它只會輸出緊跟他的一條");
        }else{
            System.out.println("當else後面只控制一條語句時,能夠省略{},它會直接輸出,不然不支持,由於它只會輸出緊跟他的一條");
        }
    /*if(5 > 6)
        System.out.println("{}省略");  當if...else...語句中，if後邊控制多條語句時，{}不可
        以省略，不然會報錯「有if沒有else」
        System.out.println("{}省略");
        else{
        System.out.println("{}省略時,");
        }*/
        //嵌套語句在if...else語句中的應用
        if(true){
            if(false){
                System.out.println("嵌套語句在if...else中的使用");
            }else{
                System.out.println("嵌套語句在if...else中的使用");
            }
        }else{
            System.out.println("嵌套語句在if...else中的使用");
        }
        /*三元運算符和if...else語句的區別,
        If--else語句與三元運算符的區別:三元運算符運算完要有值出現。好處是：能夠寫在其餘表達式中,而if----else語句則沒有這種限制,可是能夠寫在其餘方法中,不能寫在表達式中*/
        //求 a的絕對值和b的和
        int a = 7 , b = 3 , sum ;
        if(a > 0){
            System.out.println("您所求的兩個數的和爲:"+(a+b));
        }else
            System.out.println("您所求的數的絕對值爲:"+(-a+b));
        sum = (a > 0 ? a : (-a))+b;    
        System.out.println("您所求的兩個數的和爲:"+sum);
    }
}

面試題：問下面一段代碼是否會正常輸出?

if(5 > 6)

    System.out.println("{}省略」);

    System.out.println("{}省略");

else{

    System.out.println("{}省略時,");

  }

答:不會,代碼會出現錯誤,當代碼判斷條件語句不成立時,會自動跳過緊跟他的一條語句,這是它的做用範圍,而後編譯下一條代碼,這時由於沒有發現else,會將他認爲是簡單if語句,再往下執行時發現了else語句,這是編譯會將其做爲不合法代碼跳出」錯誤:有’if’沒有’else’」

1.3.2.1.3 if...else if語句

注意事項:

A.else if必須和if組合使用，else if語句末尾能夠（意味着非必須）是一條單獨的else語句
B.else不能有條件表達式
C.咱們if語句第三種格式,任何一個條件表達式成立,if語句直接結束.

【例5.4】建立IfElseIfPractice類，進行對IfElseIf語句的特性進行一些驗證

class IfElseIfPractice{
    public static void main(String[] args){
        if(false){
            System.out.println("1");
        }else if(false){
            System.out.println("2");
        }else if(true){//當發現if條件語句爲true時,只執行這條語句,其餘的就再也不執行,
            System.out.println("3");//跳出這個if..else..if語句,執行其餘程序
        }else if(true){
            System.out.println("4");
        }else{
            System.out.println("5");
        }
    }
}

1.3.2.1.4 if條件語句練習

【例5.5】學生考試成績出來了請對其進行劃分等級,要求90--100 A等 80--89 B等 70--79 C等 60--69 D等 60分如下叫家長,談人生

分析：咱們初看到這道題目時，要注意這麼幾點

考試成績大於等於0小於等於100,因此咱們要考慮輸入錯誤的狀況!
因爲成績是一個變量，因此這裏咱們須要一個變量來表明這個成績
等級對於成績來講是一個區間，而且這是一個條件語句，因此咱們須要應用到比較運算符，和邏輯運算符。
因爲咱們在這裏須要比較不少區間，因此咱們須要考慮用哪一種語句，在這裏很明顯選擇第三種if語句

class GradePractice{
    public static void main(String[] args){
        int score = 178 ;
        if(score <= 100 && score >= 90){
            System.out.println("您的成績是:"+score+",相對應的成績等級爲:A等");
        }else if(score < 90 && score >= 80){
            System.out.println("您的成績是:"+score+",相對應的成績等級爲:B等");
        }else if(score < 80 && score >= 70){
            System.out.println("您的成績是:"+score+",相對應的成績等級爲:C等");
        }else if(score < 70 && score >= 60){
            System.out.println("您的成績是:"+score+",相對應的成績等級爲:D等");
        }else if(score >=0 && score < 60){
            System.out.println("您的成績是:"+score+",叫家長,談人生!");
        }else{
            System.out.println("成績輸入錯誤請檢查後從新輸入!");
        }
    }
}

【例5.6】給出月份,判斷它所處的季節 3-5 春季 6-8 夏季 9-11 秋季 12-2 冬季

分析：咱們首先來看需求

首先咱們須要定義一個變量來表明月份，咱們用這個變量來在區間中比較；
第二這個變量要符合咱們的要求，即大於等於1，小於等於12，因此咱們要考慮輸入錯誤的狀況；
第三咱們要選擇合適的語句，在這裏咱們有不少種方法，下面一一介紹

方法一：一個個比較,使用簡單if語句。

class SeasonPractice1{
    public static void main(String[] args){
        int month = 9 ;        //聲明一個表明月份的變量
        if( month == 1){
            System.out.println("這個月份屬於冬季!");
        }
        ......
        if( month == 3){
            System.out.println("這個月份屬於春季!");
        }
        ......
        if( month == 6){
            System.out.println("這個月份屬於夏季!");
        }
        ......
        if( month == 9){
            System.out.println("這個月份屬於秋季!");
        }
        ......
         if( month == 12){
            System.out.println("這個月份屬於冬季!");
        }else{
            System.out.println("您輸入的數據儲存在問題,請檢查後從新輸入!");
        }
    }
}

方法2：使用邏輯運算符加上if語句。

class SeasonPractice2{
    public static void main(String[] args){
        int month = 2 ;
        if(month == 12 || month == 1 || month == 2){
            System.out.println("這個月份屬於冬季!");
            //咱們在這裏使用if...else.if語句,須要明白語句的一個特性當有else.if語句爲真時即跳出語句再也不進行if.else語句,進行其餘語句
        }else if(month == 3 || month == 4 || month == 5){
            System.out.println("這個月份屬於冬季!");
        }else if(month == 6 || month == 7 || month == 8){
            System.out.println("這個月份屬於冬季!");
        }else if(month == 9 || month == 10 || month == 11){
            System.out.println("這個月份屬於冬季!");
        }else {
            System.out.println("對不起,您輸入的數據存在問題,請檢查後從新輸入!");
        }
    }
}

方法三：使用比較運算符,邏輯運算符和if語句；

class SeasonPractice3{
    public static void main(String[] args){
        int month = 17 ;
        if(month == 1 || month == 2 || month == 12){
            System.out.println("這個月份屬於冬季!");
        }else if(month >= 3 && month <= 5){
            System.out.println("這個月份屬於春季!");
        }else if(month >= 6 && month <= 8){
            System.out.println("這個月份屬於夏季!");
        }else if(month >= 9 && month <= 11){
            System.out.println("這個月份屬於秋季!");
        }else{
            System.out.print("對不起,您輸入的數據錯誤,請檢查後從新輸入!");
        }
    }
}

方法四：精簡代碼，從上面的三種方法咱們能夠看出代碼的相同性有這麼幾點，（變量的判斷比較，結果的輸出，邏輯運算符的運用），咱們將這相同的幾點進行精簡以下！

class SeasonLastPractice{
    public static void main(String[] args){
        int month = 7 ;
        String str ;
        if(month == 1 || month == 2 || month == 12){
            str = "這個月份屬於冬季!";
        }else if(month >= 3 && month <= 5){
            str = "這個月份屬於春季!";
        }else if(month >= 6 && month <= 8){
            str = "這個月份屬於夏季!";
        }else if(month >= 9 && month <= 11){
            str = "這個月份屬於秋季!";
        }else{
            str = "對不起,您輸入的數據錯誤,請檢查後從新輸入!";
        }
        System.out.print(str);
    }
}

【例5.7】比較三個數的大小(if語句的嵌套使用)

package cn.if_else;

public class ComparePractice {
    public static void main(String[] args) {
        test(7, 7, 7);
        test(1, 2, 3);
        test(2, 1, 3);
        test(3, 2, 1);
        test(1, 3, 2);
    }
    
    public static void test(int a,int b,int c){
        if(a>=b){
            if(b>=c)
                System.out.println("這三個數的大小爲:"+"a>=b>=c");
            else if (a>=c) {
                System.out.println("這三個數的大小爲:"+"a>=c>b");
            }else {
                System.out.println("這三個數的大小爲:"+"c>a>=b");
            }
        }else {
            if(b<=c)
                System.out.println("這三個數的大小爲:"+"a<b<=c");
            else if(a<=c){
                System.out.println("這三個數的大小爲:"+"a<=c<b");
            }else {
                System.out.println("z這三個數的大小爲:"+"c<a<b");
            }
        }
    }
}

【例5.8】求三個數中的最值；（這裏本人作出了一種測試，實際能夠有多重方法，不一一贅述，詳細的能夠參見CSDN的一篇文章，代碼贅述在下面）

package cn.if_else;

public class MaxPractice {
    public static void main(String[] args){
        max(7, 6, 9);
        min(7, 6, 9);
    }
    public void test(){
        int a = 2 , b = 8 , c = 6 , max = 0;
        //若是隻是求最大值,那麼咱們只用拿出大的那個值同最後一個值比較
        if(a > b){
            if(a > c){
                max = a ;
            }else{
                max = c ;
            }
        }else{
            if(b > c){
                max = b ;
            }else{
                max = c ;
            }
        }
        System.out.print("三個數的最大值爲:"+max);
    }
    /**
     * 求最大值
     */
    public static void max(int a,int b,int c){
        if(a>=b&&a>=c)
            System.out.println("最大值爲:"+"a");
        else if (c>=b&&c>=a) {
            System.out.println("最大值爲:"+"c");
        }else if(b>=a&&b>=c) {
            System.out.println("最大值爲:"+"b");
        }
    }
    /**
     * 求最小值
     */
    public static void min(int a,int b,int c){
        if(a<=b&&a<=c){
            System.out.println("最小值爲:"+"a");
        }else if (b<=a&&b<=c) {
            System.out.println("最小值爲:"+"b");
        }else if (c<=a&&c<=b) {
            System.out.println("最小值爲:"+"c");
        }
    }
}

1、if語句嵌套

int a = 10;
int b = 30;
int c = 20;

int max;
if (a > b) {
if (a > c) {
max = a;
} else {
max = c;
}
} else {
if (b > c) {
max = b;
} else {
max = c;
}

}


2、if語句

int a = 10;
int b = 30;
int c = 20;

int max;
if (a > b) {
max = a;
} else {
max = b;
}

if (max < c) {
max = c;
}


3、if語句（假定a最大，b,c與a比較，若是比a大，則賦值給max）

int a = 10;
int b = 30;
int c = 20;

int max = a;
if (b > max) {
max = b;
}
if (c > max) {
max = c;
}


4、三元運算符

int a = 10;
int b = 30;
int c = 20;

int max = (a > b) ? a : b;
max = (max > c) ? max : c;

或者

int max = ((a > b ? a : b) > c) ? (a > b ? a : b) : c;（建議不用這種）


五、if語句 + 邏輯運算符 &&（a,b,c三個數，若是不是a最大，或者b最大，就是c最大）

int a = 10;
int b = 30;
int c = 20;

int max;
if (a > b && a > c) {
max = a;
} else if (c > a && c > b) {
max = c;
} else
max = b;

1.3.3 選擇語句

　　在JDK 1.6及之前的版本中，switch語句中表達式的值必須是整型或字符型，常量值1~n必須也是整型或字符型，可是在JDK 1.7中，switch語句的表達式的值除了整型和字符型，還能夠是字符串類型，這是JDK1.7 新添的特性。

switch語句:

A.當咱們看到switch的時候,這就是一個選擇語句
B.表達式:是一個常量或者變量,byte,short,int,char,因此case取值其實與表達式的類型一致
jdk1.5之後支持枚舉， jdk1.7之後支持String
C.case:表示的就是一個選項,取值就是選項的值
D.執行語句:功能代碼.
E.break:switch語句的結束符.
F.default:默認值,至關於if語句的else

【例5.9】根據指定的日期（1~7），輸出相應的星期；

class SwitchWeekPractice{
    public static void main(String[] args){
        int day = 9 ;
        switch(day){
            default:    //若沒有一個常量的值與表達式的值相同則默認執行default,
            System.out.println("請檢驗您的輸入數字是否正確!");
            //若是沒有發現break,則繼續執行下面的case語句直到發現break
            case 1:
            System.out.println("根據您輸入的數字能夠肯定是:星期一");
            break;
            /*default:    一個switch語句中只能有一個default,不然會提示標籤重複
            System.out.println("請檢驗您的輸入數字是否正確!");*/
            case 2:
            System.out.println("根據您輸入的數字能夠肯定是:星期二");
            break;
            case 3:
            System.out.println("根據您輸入的數字能夠肯定是:星期三");
            break;
            case 4:
            System.out.println("根據您輸入的數字能夠肯定是:星期四");
            break;
            case 5:
            System.out.println("根據您輸入的數字能夠肯定是:星期五");
            break;
            case 6:
            System.out.println("根據您輸入的數字能夠肯定是:星期六");
            break;
            case 7:
            System.out.println("根據您輸入的數字能夠肯定是:星期日");
            break;
        }
    }
}

Switch語句的執行過程：

【例5.10】根據輸入的城市名字，查詢出城市所在的省；

class ProvincePractice{
    public static void main(String[] args){
        String str = "洛陽";
        switch(str){
            case "石家莊":
            System.out.println("這是河北省會;");
            break;
            case "濟南":
            System.out.println("這是山東省會;");
            break;
            case "鄭州":
            System.out.println("這是河南省會;");
            break;
            case "洛陽":
            System.out.println("這是河南地級市;");
            break;
            default:
            System.out.println("對不起您所查找的城市在數據庫中沒有發現,請檢查後輸入!");
        }
    }
}

【例5.11】根據給定的月份，判斷所屬的季節；冬季（12,1,2）春季（3，4，5）夏季（6，7，8）秋季（9,10,11）

class SwitchMonthPractice{
    public static void main(String[] args){
        int month = 9 ;
        String str = "";
        switch(month){
        //運用Switch的省略,將break適當省略,將共性放在一處源代碼
            case 1:
            str = "冬季";
            case 2:
            str = "冬季";
            case 12:
            str = "冬季";
            break;
            case 3:
            str = "春季";
            case 4:
            str = "春季";
            case 5:
            str = "春季";
            break;
            case 6:
            str = "夏季";
            case 7:
            str = "夏季";
            case 8:
            str = "夏季";
            break;
            case 9:
            str = "秋季";
            case 10:
            str = "秋季";
            case 11:
            str = "秋季";
              break;
            default:
            System.out.println("請檢查您所輸入的數字是否在範圍中!");
        }
        System.out.print("根據您所輸入的月份判斷季節爲:"+str);
    }
}

　　總結：選擇語句的功能經過判斷語句也是能夠實現的，實際上這兩個語句在功能上類似，可是在進行選擇操做時，switch語句可以更加清楚明瞭，咱們在進行多項選擇操做的時候，且具備明確的選擇項，那麼switch是個很好的選擇，但每每咱們在程序中並無明瞭的選擇項，因此if語句是常見的操做。

1.3.4 循環語句

注意：循環語句是和if語句同樣常見的語句，須要重點關注一下；

1.3.4.1 while循環

【例5.12】將1到100的全部奇數都打印出來，並對他們進行求和運算；

分析：首先咱們要明白這是一個累加的運算，咱們在代碼中涉及到的是兩個變量，奇數和累加的和；對於奇數，咱們對他的判斷應該是除2取餘爲1,下面咱們經過代碼來分析；

class OddPractice{ public static void main(String[] args){ int i = 0 ,sum = 0;    //定義一個表明1到100的變量和奇數和的變量
        while(i <= 100){ if(i%2==1){ System.out.print(i+"、"); sum += i; } i++;//省略的話死循環,由於i值不變while後邊的條件表達式永遠爲真
 } System.out.println("咱們所求的奇數和爲:"+sum); } }

While語句的執行過程

下面再看一個例子，計算多長時間可以存儲必定數量的退休金，假定的是每一年存入相同數量的金額，並且利率是固定的。

package cn.while_statement;

import java.util.Scanner;

/**
 * 例子來源於   Java核心技術_卷1
 * @author Yorick
 * @date   2018年3月5日
 * @ver    1.0
 */
public class Retirement {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("讓你退休須要多少錢:");
        //目標錢
        double goal = in.nextDouble();
        System.out.println("每一年你準備存多少錢:");
        double payment = in.nextDouble();
        System.out.println("年利率%:");
        double interestRate = in.nextDouble();
        //帳戶餘額
        double balance = 0;
        //須要時間-年
        int years = 0;
        while (balance < goal) {
            balance += payment;
            double interest = balance * interestRate/100;
            balance += interest;
            years++;
        }
        System.out.println("你能夠在幾年後退休:"+years+"years.");
    }
}

1.3.4.2 do...while循環

【例5.13】比較while和do...while;

class CompareWhilePractice{ public static void main(String[] args){ int a = 100 , b = 100 ; //鮮明的比較while和do...while的區別
        while(a == 60){ System.out.println("Ok"+a); a--; } do{ System.out.println("Ok"+b); b--; }while(b == 60); } }

咱們對while循環中的退休金問題進行改編，首先計算帳戶餘額，而後詢問是否要退休；

package cn.while_statement;

import java.util.Scanner;

public class Retirement2 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("你每一年要存多少錢:");
        double payment = in.nextDouble();
        System.out.println("年利率%:");
        double interestRate = in.nextDouble();
        double balance = 0;
        int year = 0;
        String input;
        do {
            balance += payment;
            double interest = balance*interestRate/100;
            balance += interest;
            year++;
            System.out.printf("After year %d,your balance is %,.2f%n",year,balance);
            System.out.println("Ready to retire?(Y/N)");
            input = in.next();
        } while (input.equals("N"));//不退休就繼續循環
    }
}

1.3.4.3 for循環

1.3.4.3.1 for語句

小結：

關鍵字:for
固定格式:for(初始化表達式(3);循環條件表達式(1);循環後的操做表達式(4))(2){執行語句(5)}
運行順序: 循環條件爲true時 3--1--5--4--1--5

循環條件爲false時 3--1 當循環條件爲false時,循環終止

注意事項:

一、變量做用域問題：

- 若是後邊要使用這個變量，須要定義在for循環前
- 　若是後邊不使用這個變量，須要定義在for循環中
- 變量做用域在一對大括號之間，兩個嵌套的for循環中不能聲明同名的變量，兩個獨立的for循環中能夠聲明同名的變量，可是注意仍然遵循塊嵌套。

第一個表達式能夠放置在循環體前，能夠爲空
第三個表達式能夠放置在循環體中，能夠爲空
第二個表達式能夠爲空，不報錯，可是爲死循環。除非特殊業務或算法需求，不然不會出現該種狀況
儘管Java容許在for循環的各個部分放置任何表達式，可是有一條不成文的規矩：for循環的三個部分應該對同一個計數器變量進行初始化、檢查和更新。若不遵循這一規則，編寫的循環可能晦澀難懂。
循環中對兩個浮點數進行判斷要格外當心，浮點數的操做，存在舍入的偏差，可能得不到精確值，如：for(double x = 0; x != 10;x += 0.1)[x將從9.99999999999998跳到10.09999999999998]

【例5.14】計算1到100相加的和；

class SumPractice{
    public static void main(String[] args){
        int sum = 0;
        for(int i = 1;i<101;i++){
            sum += i;
        }
        System.out.println("1到100的累計相加的和爲:"+sum);
    }
}

注意：在編程時，有時會使用for循環的特殊語法格式來實現無限循環，語法格式爲：

For（；；）{

......

}

對於這種無限循環能夠經過break語句跳出循環，例如：

For（；；）{
If(i<20){
System.out.println(「無限循環」);
}
Break；
}

package cn.for_test;

public class Test {
    public static void main(String[] args) {
        int i = 20;
        for (; ; i++) {
            if(i > 25){
                System.out.println("經過break關鍵字跳出死循環!" + "--i = " + i);
                break;
            }
        }
    }
}

　　咱們在這裏,看一個抽獎的問題,這是for循環的典型示例.這個程序用來計算抽獎中獎的機率。例如，若是從1~50之間的數字中取6個數字來抽獎，那麼會有（50*49*48*47*46*45）/（1*2*3*4*5*6）種可能的結果，因此中獎的概率是1/15890700。通常狀況下，若是從n個數字中抽取k個數字,可使用下列公式獲得結果:

　　　　　　　　　　　　　　　　　　　　　　　　　　　　n*(n-1)*(n-2)*...*(n-k+1)/{1*2*3*...*k}

下面咱們經過for循環來實現一下：

package cn.for_test;

import java.util.Scanner;

public class LotteryOdds {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("有多少個數字須要抽取:");
        int k = in.nextInt();
        System.out.println("你能抽到的最大的數字:");
        int n = in.nextInt();
        int lotteryOdds = 1;
        //注意循環不能從0開始,應該從1開始,這是由於除數不能爲0,因此這裏i = 1
        /*for (int i = 0; i < k; i++) {*/
        for (int i = 1; i <= k; i++) {
            lotteryOdds = lotteryOdds*(n - i + 1)/i;
        }
        System.out.println("Your odds are 1 in" + lotteryOdds + ". Good luck");
    }
}

1.3.4.3.2 foreach語句

　　foreach語句是for語句的特殊簡化版本，foreach語句並不能徹底取代for語句，然而任何foreach語句均可以改成for語句版本。foreach並非一個關鍵字，習慣上將這種特殊的for語句格式稱之爲foreach語句。foreach語句在遍歷數組等方面爲程序員提供了很大方便（在數組中咱們將會講到）。foreach語句也叫加強for循環，加強for循環是for的一種新用法！用來循環遍歷數組和集合。編譯器在編譯時會將增強for轉換爲底層迭代操做，外觀上看起來加強了for的語法,其實是經過迭代器來實現的。關於foreach循環咱們在這裏很少作介紹，我會在一篇文章「扒掉foreach的外衣中詳細探討foreach的底層運做」！

語法格式以下

for（元素變量x:遍歷對象 obj）{ 　　引用了x的Java語句； }

x的值從數組的第一個元素一直到最後一個元素！

foreach語句中的元素變量x，沒必要對其進行初始化。下面經過一個小例子來講明；

【例5.15】建立一個一維數組，對其進行遍歷，經過兩種for循環；

public class Repetition{
    public static void main(String args[]){
        int arr[] = {1,2,3,4,5};
        System.out.print("數組中的元素爲：");
        /*標準for循環
        for(int i = 0;i<5;i++){
            System.out.print(arr[i]+",");
        }*/
        for(int x:arr){
            System.out.print(x+",");
        //foreach語句，元素變量x爲遍歷數組的元素值    
        }
    }
}

加強for的冒號左邊是定義變量，右邊必須是數組或集合類型。例如上例中循環遍歷的arr這個int數組，加強for內部會依次把arr中的元素賦給變量i。

加強for

* 1. 只是語法簡單了一點點！

* 2. 它沒有老for增大！

特色：

* 1. 只能遍歷數組、集合...

* 2. 在遍歷時不能使用下標

* 3. 遍歷只能從頭至尾

* 4. 對數組和集合只能作讀操做，不能作寫操做！

語法：

* 1. for(元素類型變量名 : 集合或數組對象)

* 2. 每次循環，獲取一個數組中的元素給左邊的變量了。

加強for到底能夠遍歷什麼：

* 1. 能夠遍歷任何的實現了Iterable接口的實例

* 2. 加強for底層是Iterator

1.3.4.4 循環語句小結

爲了完成重複的事情，咱們一般要使用循環來完成需求

3.1 while循環 3.2 do while 3.3 for循環

While語句格式 do{執行語句} for(初始化表達式;循環

條件表達式;循

While(條件表達式){ while(條件表達式); 環後的操做表達式){

執行語句 } 執行語句 }

for條件相對複雜，可是最經常使用,while/do while 簡單易懂--具備明確的判斷條件時使用

Do while循環較少使用

循環須要的內容：

一、循環條件----循環條件表達式若是沒有循環條件就會一直循環下去----存在死循環現象

二、循環體：執行語句----循環執行的代碼語句

三、循環變量定義並初始化-----初始化表達式

四、循環變量的變化狀況----循環後的操做表達式

　　若是已經能夠判斷出循環次數的話，使用for循環比較方便，若是不知道循環次數使用while循環比較合適。for循環只不過是while循環的一個簡化形式。注意的一點是多線程中咱們使用while，而不建議使用if，這個稍後在多線程中介紹。

1.3.4.5 循環語句的練習

【例5.15】將1到100中的偶數打印出來，而且對他們進行求和；

class EvenPractice{
    public static void main(String[] args){
        int sum = 0;
        for(int i=1;i<101;i++){
            if(i%2==0){
                System.out.print(i+"、");
                sum += i;
            }
        }
        System.out.println("1到100的全部偶數的和爲:"+sum);
    }
}

對比【例5.12】while語法計算奇數和

【例5.16】珠峯高度8848m , 一張紙厚度爲0.1mm ,判斷將一張紙對摺多少次能夠達到珠峯高度，但不超過珠峯高度,並輸出打印對摺次數,以及對摺後的紙的厚度!分別使用For循環和While循環

class PaperPractice{
    public static void main(String[] args){
        int x = 88480000 , y = 1 ;//定義珠峯高度和紙的厚度
        int n = 0 ;//用n來表示摺疊的次數
        /*for(;y<=x;n++){    //for循環的運行順序: 沒有摺疊時n=0,紙的厚度小於珠峯高度,紙的厚度乘2加倍,摺疊次數加1,此時表明摺疊了一次
            y = y*2;    //摺疊到倒數第2次時,紙的厚度小於珠峯高度,此時繼續循環,紙的厚度超出珠峯高度,次數也會比實際需求大1
        }*/
        /*while(y<=x){
            n++;        //在原有摺疊次數上再摺疊一次
            y = y * 2 ;    //摺疊一次後紙的厚度翻倍
        }*/
        do{
            y=y*2;
            n++;
        }while(y<=x);
        System.out.println("摺疊"+n+"次後紙的厚度爲:"+y);
        System.out.println("摺疊的倒數第二次紙的厚度是:"+y/2);
    }
}

分析：當咱們摺疊第一次時，n爲1，厚度翻倍，當摺疊到倒數第二次時，摺疊後，此時紙的厚度仍小於珠峯高度，仍然知足循環條件，此時會再循環一次，但循環後紙的厚度超過珠峯高度，循環中止，因此若是咱們求紙摺疊多少次才能達到珠峯高度時，並不超過期，應該爲最後獲得的摺疊次數減去1。另外觀察咱們也能夠發現對於不知道循環次數的循環咱們使用while循環比較容易理解！

【例5.17】給出一個整數，計算出它的階乘；使用for和while循環

分析：階乘：正整數階乘指從 1 乘以 2 乘以 3 乘以 4 一直乘到所要求的數

class FactorialPractice{
    public static void main(String[] args){
        int x = 12 ;//定義一個咱們要階乘的數
        int p = 1;//定義一個階乘後的結果,因爲是從1開始,因此咱們將它定義爲1
        int y=1;//定義一個乘法的開始數字
        /*for(;y<=x;y++){
            p = p*y;
        }*/
        while(y<=x){
            p = p*y;
            y++;
        }
        System.out.println("咱們所求的階乘是:"+p);
    }
}

【例5.18】規則圖形的打印，打印一個給定行數和給定列數的規則圖形；

class FigurePractice{
    public static void main(String[] args){
        //打印一個給定行數給定列數的規則圖形(行高9,列數12)
        int line = 9 , list = 12;
        for(int x=1;x<=line;x++){
        //行的循環裏嵌套了列的循環換
            for(int y=1;y<=list;y++){
                System.out.print("* ");
            }
            //列尾咱們要注意換行
            System.out.println("");
        }
        //打印一個直角三角形
        for(int x=0;x<5;x++){
            for(int q=0;q<=x;q++){
                System.out.print("* ");
            }
            System.out.println("");
        }
        //打印一個倒立的正三角,實際上就是打印一個空格三角形和另外一個三角形
        for(int y=5;y>0;y--){//定義正三角形的邊長,正三角形的邊長和它的行數相同
            for(int s=5;s>y;s--){//打印空格的循環和打印*的循環要注意前後,打印空格實際上就是打印一個直角三角形
                System.out.print(" ");
            }
            for(int z=y;z>0;z--){
                System.out.print("* ");
            }    
            System.out.println("");
        }
        //另外一種方法
        int last = 5;
        for(int y=0;y<last;y++){
            for(int q=0;q<y;q++){
                System.out.print(" ");
            }
            for(int z=y;z<last;z++){
                System.out.print("* ");
            }
            System.out.println("");
        }
    //打印一個由數字構成的正三角形
    for(int i=1;i<10;i++){
        for(int j=1;j<10-i;j++){//最多的前面有八個空格
            System.out.print(" ");
        }
        for(int j=i;j>0;j--){//數字的打印咱們分兩部分,第一部分從i倒序到1
            System.out.print(j);
        }
        for(int j=1;j<i;j++){//第二部分從2打印當i
            System.out.print(j+1);
        }
        System.out.println("");
    }
    }
}

【例5.19】打印一個正九九乘法表和一個倒立的九九乘法表

class TablePractice{
    public static void main(String[] args){
        for(int x=1;x<10;x++){    //咱們要注意這和大三角形的思想是一致的,可是咱們要打出來的是一些字符串的連接,
            for(int y=1;y<=x;y++){//而且這些連接中包含兩個變量
                System.out.print(y+"*"+x+"="+x*y+" ");
            }
            System.out.println("");
        }
        for(int x=9;x>0;x--){
            for(int y=1;y<=x;y++){
                System.out.print(y+"*"+x+"="+x*y+" ");
            }
            System.out.println("");
        }
    }
}

【例5.20】有一對兔子,從第三個月開始產小兔子,每月產一對,小兔子在第三個月也開始生小兔子,假設無心外狀況,20個月後有多少隻小兔子

分析:發現規律,作以下計算:
第一個月有兔子1對,第二個月有兔子1對,第三個月有兔子2對,第四個月有兔子3對,第五個月有兔子5對,第六個月有兔子8對......從上面咱們能夠看到有這麼個規律「從第三個月開始腿子的對數是前兩個月的兔子對數之和」，
由此咱們能夠對所求兔子對數進行一個規律運算；
變量分析：
經過上面的規律咱們能夠得出對於兔子對數咱們須要3個變量，即第一個月兔子對數M1，第二個月兔子對數M2，第三個月兔子對數M3，M3=M1+M2；除此以外咱們須要一個月份的變量，者用於循環；
class RabbitPractice{
    public static void main(String[] args){
        int M1 = 1 ,M2 = 1 ,M3 = 2 ;
        //經過規律咱們從第三個月開始按照規律差計算
        for(int month=3;month<=20;month++){
            M3 = M1 + M2;//經過前兩個月兔子對數計算出第三個與兔子對數
            M1 = M2;    //此時向下循環的話,最先的第二個月變成了如今的第一個月,
            M2 = M3;    //第三個月變成了第二個月,再下次循環中的第三個月就是前兩個月之和
        }
        System.out.print("20個月後咱們共有兔子"+M3+"對;");
    }
}

【例5.21】要求一個五位數個位=萬位十位=千位個位+十位+萬位+千位=百位

分析：咱們從上面題目中分析出來當給定咱們一個五位數時咱們應該求出這個五位數的個十百千萬位，而後進行運算，以一段代碼爲例：

int a = 98765;
System.out.println("這個數的個位是"+a%10);//整數%10,獲得個位數
System.out.println("這個數的十位數是"+a/10%10);//除以10獲得的結果,十位數變成了個位數,按照上面求出所需結果
System.out.println("這個數的百位數是"+a/10/10%10);
System.out.println("這個數的千位數是"+a/10/10/10%10);
System.out.println("這個數的萬位數是"+a/10/10/10/10%10);

從上面咱們得出了個十百千位的算法，那麼咱們就能夠在循環中進行判斷，而後輸出結果；咱們在循環中最早開始比較的是最小的五位數直到最大的五位數；

class NumberPractice{
    public static void main(String[] args){
        int ud,td,hd,thd,md;//聲明五個變量表明個十百千位
        //System.out.print();
        for(int num=10000;num<100000;num++){
            ud = num%10;
            td = num/10%10;
            hd = num/10/10%10;
            thd = num/10/10/10%10;
            md = num/10/10/10/10%10;
            //判斷知足條件的數字
            if(ud==md&&td==thd&&ud+md+td+thd==hd){
                System.out.print(num+" ");
            }
        }
    }
}

【例5.22】水仙花問題；

1.什麼是水仙花問題-----水仙花數是指一個 n 位數 ( n≥3 )，它的每一個位上的數字的n次冪之和等於它自己。
2.假定是一個三位數num,那麼num%10得出的結果就是個位值g,num/10%10得出的結果就是十位值s,num/10/10%10得出的結果就是百位值b,根據需求,g*g*g+s*s*s+b*b*b==num
3.要了解什麼是水仙花數，這樣才能快速選擇是用什麼方式、方法，甚至算法來解決問題，在這裏咱們來計算一下4位數的水仙花問題；
class DaffodilPractice{
    public static void main(String[] args){
        int ud,td,hd,thd;//聲明個十百千位
        for(int num=1000;num<10000;num++){
            ud=num%10;
            td=num/10%10;
            hd=num/10/10%10;
            thd=num/10/10/10%10;
            if(ud*ud*ud*ud+td*td*td*td+hd*hd*hd*hd+thd*thd*thd*thd==num){
                System.out.print(num+" ");
            }
        }
    }
}

【例5.23】打印一個空心菱形和一個實心菱形

分析:打印菱形咱們知道,無非就是打印三角,那麼打印空心菱形呢?咱們是否是能夠按照一樣的思路來分析呢?咱們能夠將菱形分爲打印直三角空格,打印星號,打印正三角空格,打印星號;

下面經過代碼來實現;

package cn.practice; public class Diamond { public static void main(String[] args) { fun1(9); } public static void fun1(int hangshu){ //根據行數判斷循環次數,若是行數是奇數那麼循環此數就是column/2+1,若是是偶數,那麼空心菱形只能打印奇數,要作出提示
         int yiban = hangshu / 2 + 1; int yibanduo = hangshu / 2; if(hangshu%2==1){ System.out.println("空心菱形："); for(int k = 1;k <= yiban;k++){ for(int i = 1;i <= (yiban - k);i++){ System.out.print(" "); } System.out.print("*"); for(int i = 1;i <= ( (k - 2) * 2 + 1);i++){ System.out.print(" "); } if(k != 1){ System.out.print("*"); } System.out.println(); } for(int k = yibanduo;k >=1;k--){ for(int i = 1;i <= (yiban - k);i++){ System.out.print(" "); } System.out.print("*"); for(int i = 1;i <= ( (k - 2) * 2 + 1);i++){ System.out.print(" "); } if(k != 1){ System.out.print("*"); } System.out.println(); } System.out.println("實心菱形："); for(int i = 1;i <= hangshu;i++){ if(i <= hangshu/2 + 1){ for(int k = 1;k <= hangshu/2 + 1- i;k++){ System.out.print(" "); } for(int k = 1;k <= i;k++){ System.out.print("* "); } System.out.println(); }else{ for(int k =1;k <= (i -(hangshu/2 + 1));k++){ System.out.print(" "); } for(int k = 1;k <= (2 *(hangshu/2 + 1) - i);k++){ System.out.print("* "); } System.out.println(); } } }else { System.out.println("對不起,空心菱形行數應該爲大於0的奇數,請確認輸出!"); } } }

【例5.24】打印楊輝三角；

分析:在代碼實現以前咱們先來看一下什麼是楊輝三角,

楊輝三角，是二項式係數在三角形中的一種幾何排列。在歐洲，這個表叫作帕斯卡三角形。它把二項式係數圖形化，把組合數內在的一些代數性質直觀地從圖形中體現出來，是一種離散型的數與形的優美結合。實現結果以下圖所示:

　　分析:楊輝三角的規則是:每一行的第一個值爲1,每一行的最後一個值爲1,當前數=上一行的數+上一行的數的前一個數;明白了規則咱們就來分析一下,咱們看楊慧三角是否是很像一個二維數組呢?數組的長度爲列數,二維數組中角標0對應的是一個長度爲1的數組,二維數組角標1對應的是一個長度爲2的數組;根據這個咱們下面來經過代碼實現;

package cn.practice; public class YangHui { public static void main(String[] args) { fun1(8); } /** * 楊慧三角: * 1.每行的頭一個數是1; * 2.每行的最後一個數是1; * 3.當前數是上一行的數+其前一個數 */
     public static void fun1(int column){ /*建立二維數組,來做爲楊慧三角中的元素的容器,二維數組的長度是楊慧三角的列數, * 二維數組中的一維數組的長度是當前行的元素個數+空格數*/
         int[][] intArr = new int[column][column]; for (int i = 0; i < intArr.length; i++) { //動態開闢空間,每一行的空間大小和行號是相同的
              intArr[i] = new int[i+1]; } //爲數組填充元素
         for (int i = 0; i < intArr.length; i++) { //每一行第一個是1,最後一個也是1
              intArr[i][0] = 1; intArr[i][i] = 1; //注意楊慧三角的運算是從第二行開始的
              for (int j = 1; j < i; j++) { //當前數是上一行的數+其前一個數,實際上只有到了第三行纔會運算
                   intArr[i][j] = intArr[i-1][j]+intArr[i-1][j-1]; } } //循環過濾
         for (int j = 0; j < intArr.length; j++) { for (int j2 = 0; j2 < intArr[j].length; j2++) { System.out.print(intArr[j][j2]+"\t"); } //打印完一行換行
 System.out.println(); } } }

1.3.5 條件語句在計算機中的操做

　　咱們知道馮諾依曼提出的存儲程序概念要求順序執行程序,可若是全部的程序都按步照班的一條條的順序執行,那麼就缺乏了用戶交互,程序缺乏了靈活性,因此出現了流程控制語句,那麼程序在計算機中的執行又有什麼不一樣了呢?這其實就牽涉到了程序計數器,下面咱們經過了解程序計數器來了解一下"順序執行";

　　程序計數器是用於存放下一條指令所在單元的地址的地方。當執行一條指令時，首先須要根據PC中存放的指令地址，將指令由內存取到指令寄存器中，此過程稱爲「取指令」。與此同時，PC中的地址或自動加1或由轉移指針給出下一條指令的地址。此後通過分析指令，執行指令。完成第一條指令的執行，然後根據PC取出第二條指令的地址，如此循環，執行每一條指令。

　　在程序開始執行前，將程序指令序列的起始地址，即程序的第一條指令所在的內存單元地址送入PC，CPU按照 PC的指示從內存讀取第一條指令（取指）。當執行指令時，CPU自動地修改PC的內容，即每執行一條指令PC增長一個量，這個量等於指令所含的字節數（指令字節數），使 PC老是指向下一條將要取指的指令地址。因爲大多數指令都是按順序來執行的，因此修改PC 的過程一般只是簡單的對PC 加「指令字節數」。
　　當程序轉移時(即流程控制語句)，轉移指令執行的最終結果就是要改變PC的值，此PC值就是轉去的目標地址。處理器老是按照PC 指向取指、譯碼、執行，以此實現了程序轉移。

　　流程控制語句提升了程序的可操做性,使得程序更加靈活。對於咱們的開發頗有幫助，可是對於其中的陷阱，咱們也不能忽視！

1.4 break、continue和循環標號&&return

　　Java語句除了流程控制語句用於跳轉外,還提供了3中跳轉語句，分別是break語句、continue語句和return語句。下面對這三種跳轉語句進行詳細介紹。

1.4.1 break

　　break語句咱們應該都不會陌生,在介紹switch語句時已經應用過了。在switch語句中，break語句用於終止下面case語句的比較。實際上，break語句還能夠應用在for、while和do...while循環語句,用於強行退出循環塊，也就是忽略循環塊體中任何其餘語句和循環條件的限制。

　　break關鍵字它的常見做用在於跳出當前循環(即break所在的循環,若是存在for(){for(){break;}},那麼break只是跳出內存循環,外層循環繼續;)，應用範圍爲循環語句，選擇語句。

【例5.25】計算1到100的全部偶數的和，要求當和大於250時跳出，並輸出這個和；

class SumDemoPractice{
public static void main(String[] args){ int sum = 0 , i=1; for(;i<101;i++){ if(i%2==0){ sum+=i; } //當和大於250時，break語句跳出循環, if(sum>250){ break; } } //最後一次的相加和已經大於了250,在下面的輸出中會體現出來 System.out.print("從1到"+i+"的偶數相加的和爲:"+sum); } }

1.4.2 continue

　　Continue語句只能應用在for、while和do...while循環語句中，用於讓程序直接跳過其後面的語句進行下一次循環。Continue關鍵字做用是跳出當前循環進行下次循環，整個循環不結束,那麼break和continue有什麼不一樣呢?下面咱們來對比一下:

這兩個語句離開應用範圍，存在是沒有意義的。
這兩個語句單獨存在下面都不能夠有語句，由於執行不到。
Continue語句是結束本次循環執行下次循環，break是結束循環體進行循環後面的語句。
標號的出現，可讓這兩個語句做用於指定的範圍。
Break只能用於循環和switch語句，continue使用於循環，普通函數這兩個關鍵字不適用。

【例5.25】打印出1到20中的全部奇數，可是13被認爲是一個不吉祥的數，不打印

class SumDemo1Practice{ public static void main(String[] args){ int sum = 0 , i = 0; while(i<=20){ i++; if(i%2==1){ if(i==13) continue; System.out.print(i+" "); } } } }

1.4.3 循環標號

　　Break和continue跳轉語句它的做用範圍僅在當前循環，那麼若是多層循環中咱們想break跳出指定循環該怎麼操做呢？這時就引出了標號的概念；標號是爲循環起一個名字，或者叫作爲循環作一個標記，能夠經過break 標記達到直接跳出該標記循環的目的,注意標號是須要":"和循環在一塊兒使用的。下面咱們舉例說明；

【例5.26】打印一個矩形*；

class RectanglePractice{ public static void main(String[] args){ int a = 4 , b = 5 ; for(int i=1;i<=a;i++){ for(int j=1;j<=b;j++){ System.out.print("*"); } System.out.println(""); } } }

打印一個矩形*，當出現一行裏超過第三個*時，打印結束；

class RectanglePractice{ public static void main(String[] args){ int a = 4 , b = 5 ; out:for(int i=1;i<=a;i++){ inner:for(int j=1;j<=b;j++){ System.out.print("*"); if(j==3){ //當j==3時,它打印的是第三顆*,此時跳出循環,但他跳出的只是內循環, //咱們如何跳出外循環呢,這時就用到了標號,爲循環標號,跳出標號循環 break out; } } System.out.println(""); } } }

1.4.4 return

　　return關鍵字有兩個功能：1是結束函數，2是返回（值會對象）。有返回值的return和返回內容構成返回語句，若是沒有返回值，那麼就僅僅是中止該函數。return 語句可使其從當前方法中退出，返回到調用該方法的語句處，繼續程序的執行。返回語句有兩種格式。　　

　　 * return expression: 返回一個值給調用該方法的語句，返回值的數據類型必須與方法聲明中的返回值類型一致。可使用強制類型轉換來使類型一致。 = 　　

　　 * return: 當方法說明中用 void 聲明返回類型爲空時，應使用這種格式不返回任何值。此時return是能夠省略的。

return語句一般用在一個方法體的最後，以退出該方法並返回一個值。在Java語言中，單獨的return語句用在一個方法體的中間時，會產生編譯錯誤【return語句後面不能有代碼】，由於這樣會有一些語句執行不到。但能夠經過把return語句嵌入某些語句（如 if…else）來使程序在未執行完方法中的全部語句時退出，例如：

 void method(int iVar){ if( iVar>0 ){ return; 怪蜀黍 }else{ System.out.println(iVar); } }

Java中的return語句使用總結
一、return語句的做用：a、返回一個值，這個值能夠是任意類型。b、使程序返回到操做系統（即終止程序）
二、java中對於一個函數，不論有沒有返回值類型，均可以帶有return 語句。可是區別在於，return語句是否能夠返回一個值（這取決於該函數的返回值類型）。
　　a、若是函數有返回值類型（即返回值類型不爲void ），則必須帶有返回相應類型值的return 語句。
　　b、若是函數沒有返回值（即返回值類型爲void ），則函數中return 語句（若是存在return語句！）的後面不能加任何的變量。（該狀況下的函數中也能夠沒有return 語句，可是若是有的話，return 只能做爲返回操做系統的做用使用。）
例如：

一、有返回值

public int getAge(){ return age; //返回int 類型的變量age的值 }

二、無返回值 //函數不帶return 語句

public void putAge(){ System.out.println(age); }

三、返回到操做系統

//函數無返回值，可是帶有return語句public void put(int a) {
        if (a > 0)
            return;      //return語句後不帶返回值，做用是退出該程序的運行         
        else
            System.out.println("fasfsa");
}

1.5 總結

　　咱們本節內容進行到了這裏,也就進行到了尾聲,關於語句總結了不少,其中大部分是例子,對於一些例子.初始寫的時候須要思考,再次看的時候,仍不能很快又思路,因此都貼了出來,能夠之後隨時看看,本節內容也較爲淺顯,可是用於學習使用已是能夠了,望各位閱讀者,不吝指教,共同進步!

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。