今日內容介紹
1、引用類型變量的創建及使用
2、流程控制語句之選擇語句
3、流程控制語句之循環語句
4、循環高級

01創建引用類型變量公式

* A: 創建引用類型變量公式
    * a: 我們要學的Scanner類是屬於引用數據類型，我們先了解下引用數據類型。
    * b: 引用數據類型的定義格式
        * 與定義基本數據類型變量不同，引用數據類型的變量定義及賦值有一個相對固定的步驟或格式。
        * 數據類型  變量名  =  new 數據類型();
    * c: 引用數據類型的使用
        * 每種引用數據類型都有其功能，我們可以調用該類型實例的功能。
        * 變量名.方法名();
    
 

02Scanner類的使用

* A: Scanner類的使用
    * a: 導包import java.util.Scanner;
    * b：創建鍵盤錄入對象 Scanner sc = new Scanner(System.in);
    * c: 讀取鍵盤錄入的一個整數
        * int enterNumber = sc.nextInt();
    * d: 讀取鍵盤錄入的字符串
        * String enterString = sc.next();
* B: 案例代碼
    import java.util.Scanner;
    public class Demo05Scanner{
        public static void main(String[] args) 
        {
            Scanner sc = new Scanner(System.in);

            int enterNumber = sc.nextInt();
            System.out.println("用戶輸入的整數為"+enterNumber);

            String enterString = sc.next();
            System.out.println("用戶輸入的字符串為"+enterString);
        }
    }
        
        
 

03Random隨機數類的使用_1

* A: Random隨機數類的使用_1
    * a: 功能
        * 生成隨機數需要使用到引用類型隨機數Random類
    * b: 使用方式
        * import導包：所屬包java.util. Random
        * 創建實例格式：Random  random = new Random ();
        * 調用方法
            * nextInt(int maxValue) 產生[0,maxValue)範圍的隨機數,包含0不包含maxValue
            * nextDouble()  產生[0,1)範圍的隨機數
            如：
                Random  random = new Random ();
                int  myNumber = random.nextInt(100);//結果為0-99的一個數
* B: 案例代碼
    import java.util.Random;
    public class RandomDemo{
        public static void main(String[] args){
           Random ran = new Random();
           // Random類中的,產生隨機數的功能
           int i = ran.nextInt(100);
           System.out.println(i);
           
           //問題? 產生隨機數,範圍 1-100之間
           // nextInt(100) 0-99 + 1
        }
    }
 

04Random隨機數類的使用_2

* A: Random隨機數類的使用_2
    * a: 調用方法
        * nextDouble()  產生[0,1)範圍的隨機數
        如：
            Random  random = new Random ();
            int  myNumber = random.nextDouble();//結果為0.0-1.0之間的數(包括0.0不包括1.0)

05if語句格式第一種

* A: if語句格式第一種
    * a: 書寫格式
        if(比較表達式) {
            語句體;
        }
    * b：執行流程：
        * 先計算比較表達式的值，看其返回值是true還是false。
        * 如果是true，就執行語句體；
        * 如果是false，就不執行語句體；
* B: 案例代碼
    public class IfDemo{
        public static void main(String[] args){
              int i = 5 ;
              //對變量i進行if判斷
              if(i > 5){
                  System.out.println("if中的條件是true");
                  i++;
              }
              
              System.out.println(i);
        }
    }
                

06if語句格式第二種

* A: if語句格式第二種
    * a: 書寫格式
        if(比較表達式) {
            語句體1;
        }else {
            語句體2;
        }
    * b：執行流程：
        * 首先計算比較表達式的值，看其返回值是true還是false。
        * 如果是true，就執行語句體1；
        * 如果是false，就執行語句體2；
* B: 案例代碼
    public class IfElseDemo{
        public static void main(String[] args){
             int i = 16 ;
             //判斷變量,是奇偶數, 除以2,看余數是0還是1
             if( i % 2 == 0 ){
                 System.out.println(i+" 是偶數");
             }else{
                 System.out.println(i+" 是奇數");
             }
        }
    }

07if語句格式第三種

* A: if語句格式第三種
    * a: 書寫格式
            if(比較表達式1) {
                語句體1;
            }else if(比較表達式2) {
                語句體2;
            }else if(比較表達式3) {
                語句體3;
            }
            ...
            else {
                語句體n+1;
            }
    * b：執行流程：
        * 首先計算比較表達式1看其返回值是true還是false，
        * 如果是true，就執行語句體1，if語句結束。
        * 如果是false，接著計算比較表達式2看其返回值是true還是false，
        
        * 如果是true，就執行語句體2，if語句結束。
        * 如果是false，接著計算比較表達式3看其返回值是true還是false，
        
        * 如果都是false，就執行語句體n+1。
* B: 案例代碼
    public class IfElseIfDemo{
        public static void main(String[] args){
            //成績判斷要求 ,成績>80  成績>70  成績>60  不及格
            //定義變量,保存成績
            int grade = 75;
            //使用if else if 語句對成績判斷
            if( grade > 80 ){
                System.out.println(grade+" 成績是優");
            }else if ( grade > 70){
                System.out.println(grade+" 成績是良");
            }else if ( grade > 60){
                System.out.println(grade+" 成績是中");
            }else{
                System.out.println(grade+" 成績是差");
            }
            
        }
    }

08if語句和三元運算符的互換

* A: 三元運算符
    * a: 概念
        * 用來完成簡單的選擇邏輯，即根據條件判斷，從兩個選擇中選擇一種執行
    * b: 使用格式
        * (條件表達式)？表達式1：表達式2；
    * c: 運算規則
        * 1: 判斷條件表達式，結果為一個布爾值
        * 2: true，運算結果為表達式1
        * 3: false，運算結果為表達式2
* B: 案例代碼
    public class IfElseDemo_1{
        public static void main(String[] args){
            int j = 6;
            int i = 15;
            //使用if語句,判斷出最大值
            if(i>j){
            int j = 6;
                System.out.println(i+" 是最大值");
            }else{
                System.out.println(j+" 是最大值");
            }
            
            //使用三元運算實現
            int k = i>j ? i : j;
            System.out.println(k+" 是最大值");
        }
    }
* C: 使用if語句還是三元表達式
    * 判斷條件多,使用if
    * 三元,必須有結果的, if 可以沒有結果的

09while循環

* A: while循環結構
    * a: 使用格式
        初始化表達式；
        while(條件){
            循環體
        }
    * b: 執行順序
          當條件是true,就執行循環體,執行完循環體後
          程序再次執行while中的條件,如果條件還是true,繼續執行循環體
          直到條件是false的時候,循環就結束
* B: 案例代碼
    public class WhileDemo{
        public static void main(String[] args){
            //輸出 1-4之間的整數
            //定義變量,整數類型, 循環的條件
            int i = 1;
            while( i < 5 ){
                System.out.println(i);
                i++;
            }
        }
    }

10for循環_1

* A: for循環_1
    * a: 使用格式
         for(初始化變量 ; 條件 ; 增量){
             循環體;
         }
    * b: 各模塊解釋
        初始化變量: 定義變量,作用是用來控制循環的次數
        條件: 當條件是true,執行循環體,條件是false,結束循環
        增量: 變量自增情況 
* B: 案例代碼
    public class ForDemo{
        public static void main(String[] args){
            //for循環,輸出0-10
            for(int i = 0 ; i < 11 ; i++){
                System.out.println(i);
            }
        }
    }
    

11for循環_2

* A: for循環的執行流程
    for（① ; ② ; ③）{
        ④
    }
    第一步，執行①
    第二步，執行②，如果判斷結果為true，執行第三步，如果判斷結果為false，執行第五步
    第三步，執行④
    第四步，執行③，然後重復執行第二步
    第五步，退出循環
    

12for循環_3

* A: 案例
    * a: 利用for循環,計算1+4的結果
* B: 案例代碼
    public class ForDemo_1{
        public static void main(String[] args){
            // 定義變量,記錄求和後的數據
            int sum = 0;
            // 利用循環,將變量從1變化到4
            for(int i = 1 ; i <= 4 ; i++){
                //對變量進行求和
                sum = sum + i;
            }
            System.out.println(sum);
        }
    }

13do_while循環

* A: do_while循環
    * a: 使用格式
        do{
           循環體;
        }while(條件);
    * b: 執行順序
        先執行一次循環體，然後再判斷條件，如果條件為true，繼續執行循環體，
        如果條件為false，循環結束。
    * c: 特點
        * 無條件先執行一次
* B: 案例代碼
    public class DoWhileDemo{
        public static void main(String[] args){
            int i = 0; 
            do{
                System.out.println(i);
                i++;
            }while( i <  5);
        }
    }

14死循環

* A: 死循環概述
    * 無限循環存在的原因是並不知道循環多少次，而是根據某些條件，來控制循環
* B: 死循環格式
    * while(true){}
    * for(;;){}
         

15嵌套for循環_1

* A: 嵌套循環的概述
    * 嵌套循環是指在一個循環語句的循環體中再定義一個循環語句的語法結構。
    * while、do…while、for循環語句都可以進行嵌套，並且它們之間也可以互相嵌套，
    * 如最常見的在for循環中嵌套for循環。
* B: 嵌套循環的格式
    for(初始化表達式; 循環條件; 操作表達式) {
        ………
        for(初始化表達式; 循環條件; 操作表達式) {
            執行語句
            ………
        }
        ………
    }
* C: 各模塊解釋
    * 總的循環次數 =  內循環次數 * 外循環的次數
    * 內循環,是外循環的循環體
       
    * 外循環,控制的是行數
    * 內循環,控制的是每行的個數

16嵌套for循環_2

* A: 案例
    * a: 打印正三角形
* B: 案例代碼
    public class ForForDemo{
        public static void main(String[] args){
            for(int i = 0 ; i < 9 ; i++){
                for(int j = 0; j < i+1 ;j++){
                    System.out.print("* ");
                }
                System.out.println();
            }
        }
    }

17break語句

* A: break語句
    * a: 作用
        * 跳出所在的循環體
    * b: 書寫位置
        * 必須出現在循環或選擇結構內
    * c: 舉例
        for(int i=0; i<10; i++) {
            if(i>5) {
            break;
        }
            System.out.println(“我愛Java”+i);
        }
        //會從0-5輸出6次“我愛Java”
* B: break詳細解釋
    * a: 作用
        * 在loop/switch選擇或者循環過程中，我們總是滿足布爾表達條件才能執
        * 行對應的代碼，然而在這些邏輯過程中，
            可以使用一些關鍵字直接跳出正在執行的代碼，去執行後邊或者指定位置的代碼，
            這些關鍵字一旦出現就可以跳轉語句執行順序。
    * b: 使用方式
        * 無法單獨使用，必須將break關鍵字置於switch或循環語句中
    * c: 運行規律
        * 不需要判斷任何條件，只要遇到break變直接跳出執行後續代碼。會完全跳
        * 出選擇或者循環結構
        * 只能跳出最近的代碼塊，不能跨越多級代碼塊

* C：循環標號
    * a: 為什麽使用循環標號
        * 當在雙層循環或者循環內有switch選擇語句時，我們發現，使用break或者continue
        * 所作用的對象均是內層語句，無法直接跳出外層循環，這時就需要使用標號語句跳轉了.
    * b: 使用方式
        * 在外層循環外的某行前邊，使用後邊跟有冒號”:”的標識符，即定義完畢。
          使用時當在內層循環使用break或continue時後邊緊跟之前定義的標號即可
    * c: 運行規律
        * 當外層循環外定義了標號
        * 內層使用break，終止內外雙層循環。
        * 內層使用continue，終止內層循環，繼續外層循環。

18continue語句

* A: continue語句
    * a: 作用
        * 提前結束本次循環，繼續進行下次循環
    * b: 使用方式
        * 無法單獨使用，必須將continue關鍵字置於循環語句中
    * c：運行規律
        * 不需要判斷任何條件，只要遇到continue變直接跳出本輪循環進行下次循環
    * d：案例代碼
        public class ContinueDemo{
            public static void main(String[] args){
                for(int i = 0 ; i < 10 ; i++){
                    if(i%2==0){
                        continue;
                    }
                    System.out.println(i);
                }
            }
        }
        //會把0-9之間所有的奇數打印到控制臺上

19猜數字小遊戲

* A: 猜數字小遊戲     
    * a: 分析
        * 用戶給的數可能大於、小於、或等於被猜的數，這樣就會出現三種情況，
        * 用前面講的三元運算符可以實現，
            但是得用三元運算符的嵌套，比較麻煩！可以用更簡單的方式if條件判斷，
        可以有三個以上的條件
    * b: 需求分析
        * 後臺預先生成一個隨機數1-100，用戶鍵盤錄入猜數字
        * 如果猜對了，打印“恭喜您，答對了”
        * 如果猜錯了
        * 猜大了：打印“sorry，您猜大了!”
        * 猜小了：打印“sorry，您猜小了!”
                直到數字猜到為止
                最多只能猜5次，否則提示“sorry，您沒有機會了!”
* B: 案例代碼
    /*
        猜數字小遊戲
        
        完成猜數字小遊戲：
        1、產生隨機數
        後臺預先生成一個隨機數1-100，用戶鍵盤錄入猜數字
        2、通過if語句對用戶猜的數與隨機數進行比較
        如果猜對了，打印“恭喜您，答對了”
        如果猜錯了
        猜大了：打印“sorry，您猜大了!”
        猜小了：打印“sorry，您猜小了!”
        3、通過for循環完成用戶猜數的循環
        直到數字猜到為止
        最多只能猜5次，否則提示“sorry，您沒有機會了!”

    */
    import java.util.Random;
    import java.util.Scanner;
    //通過*的方式可以一次導入該包下所有的類，但是不建議使用。建議使用哪個導哪個。
    //import java.util.*;
    public class GuessNumber{
        public static void main(String[] args) {
            //1、產生隨機數
            //後臺預先生成一個隨機數1-100，用戶鍵盤錄入猜數字
            //創建隨機數對象
            Random random = new Random();
            //產生一個1-100的隨機數
            int randomNumber = random.nextInt(100)+1;
            //System.out.println("我產生的隨機數是："+randomNumber+"你猜猜是多少？");  
            作弊專用

            //產生控制臺錄入的Scanner對象
            Scanner sc = new Scanner(System.in);
            //3、通過for循環完成用戶猜數的循環
            //通過for循環完成猜數字邏輯
            for(int i=1; i<=5; i++){
                //提示用戶輸入要猜的數，用變量接收
                System.out.println();
                System.out.println("請您輸入一個1-100的數：");
                int guessNumber = sc.nextInt();
                
                //2、通過if語句對用戶猜的數與隨機數進行比較
                //如果猜對了
                if(guessNumber==randomNumber) {
                    //打印猜對後的提示
                    System.out.println("恭喜您，猜對了！");
                    //跳出循環，不用再猜了
                    break;
                }else {//如果猜錯了
                    //如果猜大了
                    if(guessNumber>randomNumber) {
                        System.out.println("sorry，您猜大了!");
                    }else {//如果猜小了
                        System.out.println("sorry，您猜小了!");
                    }
                }
                //如果猜到了最後的第5次仍然沒有猜對就跳出循環
                if(i==5) {
                    System.out.println("對不起，點太背，下次再來吧！");
                    break;
                }
                //每次猜錯後，都提示還有多少次機會
                System.out.println("請註意，您還有"+(5-i)+"次機會，請慎重作答！");
            }
        }
    }

03_Java基礎語法_第3天（Scanner、Random、流程控制語句）