目錄

• 1、引用數據類型
• 2、流程控制語句
  • 2.1 條件控制語句if
  • 2.2 if語句與三元運算符的互換
  • 2.3 循環語句
  • 2.4 循環嵌套
  • 2.5 跳轉語句
  • 2.6 選擇結構switch
• 3、猜數字案例

1、引用數據類型

Scanner類
Scanner類屬於引用數據類型；
格式： 數據類型 變量名 = new 數據類型();

/*
    引用數據類型，介紹一個類 Scanner，這是應存在的類
    定義引用數據類型變量，和基本類型變量有區別

    格式：
        數據類型 變量名 = new 數據類型();
    舉例：
        Scanner sc = new Scanner();
        創建出Scanner類的變量；

    每個引用類型都有自己的功能，使用功能方式：
        變量.功能名字()

    Scanner類，作用是在命令行中接收輸入
    使用Scanner類步驟：
        1.導入包，指明類所在的文件夾，關鍵字import；
        2.公式，創建出Scanner類型變量；
        3.變量，使用Scanner類中的功能，完成鍵盤輸入；
*/
 

import java.util.Scanner;
public class Scanner_Reference{
    public static void main(String[] args){

        // 創建出Scanner類變量
        Scanner sc = new Scanner(System.in);

        // 功能1：nextInt()接收鍵盤輸入，保證輸入的是整數；
        // 功能接收的數據就是整數，功能運行後的結果就是整數類型
        int i = sc.nextInt();
        System.out.println(i);

        // 功能2：next()接收鍵盤輸入的字符串
        String s = sc.next();
        System.out.println(s);
    }
}
 

Random類

/*
    java中的引用類型  Random類作用是產生隨機數
    步驟：
        1.導入包，Random類，也在java.util文件夾中
        2.公式：創建出Random類型的變量
        3.變量：調用Random類中的功能，產生隨機數；

    Random類中，nextInt()產生一個隨機數，結果是int類型；
        nextInt(寫一個整數)，產生的隨機數在0 —— 指定的整數之間的隨機數；
        例如，nextInt(100)，則範圍在0-99

    偽隨機數：這種隨機數是根據寫好的算法生成的一個偽隨機數；
*/
 

import java.util.Random;
public class Random_Reference{
    public static void main(String[] args){
        // 創建一個Random類型的變量
        Random rand = new Random();

        // 功能1：調用Random類中的功能，產生一個隨機整數；
        int i = rand.nextInt(100);
        System.out.println(i);

        // 功能2：調用Random類的功能，產生一個隨機浮點數；
        double d = rand.nextDouble();
        System.out.println(d);
    }
}

2、流程控制語句

2.1 條件控制語句if

if語句
if(條件語句){ 執行語句； ...}

/*
    if語句：
        編碼格式
        
    格式：
        if(條件語句){
            if語句的執行體，即執行語句；
        }
            條件語句：必須是布爾類型 1==1  true||false
            執行體：當if中的條件為true時，執行這個執行體；
                    當if中的條件為false時，什麽也不做；
*/

public class if_control{
    public static void main(String[] args){
        int i = 5;
        if(i >= 5){
            System.out.println("我是"+i+"號");
            i++;
        }
        System.out.println("我號碼增大: "+i);
       // System.out.println(i);
    }
}

if...else語句
格式：if(條件語句){執行語句1;}else{執行語句2;}

/*
    if...else 語句格式
        編寫格式
            if(條件){
                if的執行體
            }
            else{
                else的執行體
            }
        當if中的條件為true時，執行if的執行體；
        當if中的條件為false時，執行else的執行體；
*/

public class ifelse_control{
    public static void main(String[] args){
        int i = 25;
        
        if(i%2 == 0){
            System.out.println(i+"是偶數");
        }
        else{
            System.out.println(i+"是奇數");
        }
    }
}

if...(else if)...else語句

/*
    if...elseif...if 語句
    適合在程序中，實現多條件的判斷,條件的個數沒有限制；
    編寫格式：
        if(條件){
            執行體1;
        }
        else if(條件){
            執行體2;
        }
        else{
            執行體3;
        }
*/

public class if_elseif_else{
    public static void main(String[] args){
        //典型案例，成績分類
        int i = 88;
        
        if(i>=90){
            System.out.println(i+"是優秀");
        }
        else if(i>+80){
            System.out.println(i+"是良好");
        }
        else if(i>=70){
            System.out.println(i+"是中等");
        }
        else if(i>=60){
            System.out.println(i+"是及格");
        }
        else{
            System.out.println(i+"不及格");
        }
    }
}

2.2 if語句與三元運算符的互換

/*
    if語句和三元運算符的替換
    要求：計算兩個數的最大值
    例如：兩個整數比較大小
    
    使用if和三元運算符的情況：
        （1）判斷條件多，則使用if；
        （2）三元，必須是有結果的，if可以沒有結果；
*/

public class if_Ternary_replace{
    public static void main(String[] args){
        int i = 5;
        int j = 5;
        
        // 使用if語句，判斷出最大值
        if(i>j){
            System.out.println(i+"是最大值");
        }
        else{
            System.out.println(j+"是最大值");
        }
        
        // 使用三元運算實現
        int k = i>j?i:j;
        System.out.println(k+"是最大值");
    }
}

2.3 循環語句

while循環

/*
    While循環：
        編碼格式：
            while(條件){
                循環體
            }
            
            條件：當條件是true，就執行循環體，執行完循環體後，程序再次判斷條件是否為true，如果是則繼續執行循環體，否則循環結束；
            循環體：循環體和if執行體一樣，都是語句；
*/

public class while_circle{
    public static void main(String[] args){
        
        int i = 1;
        while(i<7){
            System.out.println("互聯網思維"+i);
            i++;
        }
    }
}

for循環

/*
    for循環
        編碼格式
            for(初始化變量; 條件; 增量){
                循環體
            }
            
            初始化變量：定義變量，作用，控制循環的次數；
            條件：當條件是true，執行循環體，條件是false，結束循環
            增量：變量自增情況，例如：i++，i=i+2
*/

public class for_circle{
    public static void main(String[] agrs){
        // 定義變量，用於求階乘
        double factorial = 1;
        int i,j=0;
        
        // for循環
        for(i=10; i>0; i--){
            System.out.println(i);
            factorial = factorial*i;
            j++;
        }
        System.out.println(‘/n‘+j+"的階乘是"+factorial);
    }
}

do...while循環

/*
    do...while循環
        編寫格式：
            do{
                循環體；
            }while(條件);
            
        特點：無條件先執行一次；
*/

public class do_while_circle{
    public static void main(String[] args){
        int i = 1;
        do{
            System.out.println("x="+i);
            i++;
        }while(i<10);
    }
}

死循環

while死循環；while(true){}
for死循環；for(;true;){}

2.4 循環嵌套

/*
    循環嵌套：
    for(){
        for(){
            循環體
        }
        (循環體)——可以不存在
    }
    總循環次數=外循環次數*內循環次數；
    內循環是外循環的循環體；外循環控制行數，內循環控制每行個數；
*/

打印偏右三角形：

public class for_Nesting{
    public static void main(String[] args){
        // 打印由星星組成的三角形
        for(int i=0; i<9; i++){
            for(int j=0; j<5; j++){
                
                if(i<=4){
                    if(j<=i)
                        System.out.print("* ");
                }
                else{
                    if(j>=i-4)
                        System.out.print("* ");
                }
            }
            System.out.println();
        }
    }
}

輸出結果為：

*
* *
* * *
* * * *
* * * * *
* * * *
* * *
* *
*

打印出菱形

public class for_Nesting{
    public static void main(String[] args){
        // 打印由星星組成的菱形
        for(int i=0; i<9; i++){
            if(i<5){
                for(int k=4-i; k>0; k--)
                    System.out.print(" ");
            }
            else{
                for(int k=i-4; k>0; k--)
                    System.out.print(" ");
            }
            for(int j=0; j<5; j++){
                
                if(i<=4){
                    if(j<=i)
                        System.out.print("* ");
                }
                else{
                    if(j>=i-4)
                        System.out.print("* ");
                }
            }
            System.out.println();
        }
    }
}

輸出結果為：

    *
   * *
  * * *
 * * * *
* * * * *
 * * * *
  * * *
   * *
    *

2.5 跳轉語句

Break語句

/*
    break 關鍵字
    作用於循環中，終止循環的作用;
    但是，break終止的是所在位置的循環，但是不能終止以外的循環；

    switch語句中的表達式的數據類型，是有要求的
    JDK1.0 - 1.4 數據類型接收 byte short int char
    JDK1.5       數據類型接收 byte short int char enum(枚舉)
    JDK1.7       數據類型接收 byte short int char enum(枚舉) string
*/

public class break_jump{
    public static void main(String[] args){
        for(int i=0; i<10; i++){
            for(int j=0; j<10; j++){
                System.out.print("j="+j);
                break;
            }
            System.out.println("i="+i);
        }      
    }
}

有一種break能夠終止指定循環位置：

public class break_jump{
    public static void main(String[] args){
        a:for(int i=0; i<10; i++){
            for(int j=0; j<10; j++){
                System.out.print("j="+j);
                break a;
            }
            System.out.println("i="+i);
        }      
    }
}

continue語句

/*
    continue關鍵字
    作用是終止本次循環，進入到下一個循環；
    
*/

public class continue_jump{
    public static void main(String[] args){
        for(int i=1; i<10; i++){
            if(i%5!=0){
                continue;
            }
            else{
                System.out.println("5的倍數有："+i);
            }
        }        
    }
}

2.6 選擇結構switch

/*
    選擇結構   switch語句
    編寫格式
        switch(表達式){
            case 常量1:
                要執行的語句；
            break 常量2；

            case 常量2:
                要執行的語句；
            break;

            case 常量3:
                要執行的語句；
            break;

            default:
                要執行的語句；
            break;
        }

        執行流程：表達式和case後面的常量進行比較
            匹配到哪個case常量，就執行對應語句；遇到break後，就結束；
*/

public class switch_opt{
    public static void main(String[] args){
        // 定義變量，保存星期位
        int week = 6;
        // switch語句
        switch(week){
            case 1:
                System.out.println("星期"+week);
            break;

            case 2:
                System.out.println("星期"+week);
            break;

            case 3:
                System.out.println("星期"+week);
            break;

            case 4:
                System.out.println("星期"+week);
            break;

            case 5:
                System.out.println("星期"+week);
            break;

            case 6:
                System.out.println("星期"+week);
            break;

            default:
                System.out.println("星期"+week);
            break;
        }
    }
}

case語句

switch特性：case穿透性；（不管前面的case，直接往後執行，即不匹配case，就往下走）
如果多個case語句的執行語句是一樣的，則該執行語句只需要書寫一次即可。
case 1 case 2 ... case 5輸出結果相同，則可以寫成：

switch(week){
        case 1:
        case 2:
        case 3:
        case 4:
        case 5:
                System.out.println("工作日");
        break;

        case 6:
        case 7:
                System.out.println("休息日");
        break;
}

3、猜數字案例

/*
    在一定範圍內猜數字
    （1）隨機數生成1-100的固定數，用Random；
            鍵盤輸入，用Scanner；
    （2）作比較，和固定數做比較，用if結構；
    （3）不斷猜數字，直到猜正確，用while結構；
*/

import java.util.Random;
import java.util.Scanner;
public class guess_number{
    public static void main(String[] args){
        System.out.println("猜數字遊戲開始了");
        System.out.println("輸入1-100的數字：");
        // 創建Random類
        Random rand = new Random();
        int randNumber = rand.nextInt(100)+1;  //使用功能nextInt()獲取數字輸入；
        
        // 創建Scanner類變量
        Scanner sc = new Scanner(System.in);
        
        while(true){
            int number = sc.nextInt();
            if(number>randNumber){
                System.out.println("猜大了");
            }
            else if(number<randNumber){
                System.out.println("猜小了");
            }
            else{
                System.out.println("恭喜你，猜中了");
                break;
            }
        }
    }
}

java控制流