Java 学习笔记（四）流程控制

键盘输入与输出

输入

在 Java 中可以使用 java.util.Scanner 类实现从键盘获取数据

Scanner 类是 Java预先定义好的，放在 java.util 包中，我们直接使用即可，使用方法：

1. 在类定义前面先使用 import 导入该类
2. 创建 Scanner 对象，例如：
   • Scanner input = new Scanner(System.in);
3. 调用 Scanner 对象的方法从键盘上读取数据
   • input.next()获取键盘输入的字符串
   • input.nextInt()获取键盘输入的整数
   • input.nextDouble()获取键盘输入的小数
   • input.nextBoolean()获取键盘输入的布尔值
   • 不能从键盘获取 char 类型的字符

/**
    使用 java.util.Scanner 从键盘读取数据
*/

// 第一步导入 Scanner 类
import java.util.Scanner;

class Example01{
    public static void main(Sring[] args){
        // 第二步创建 Scanner 的对象
        // 使用 new 创建类的对象
        // Scanner input 表示 input 这个变量是 Scanner 类型的
        // System.in 表示系统的标准输入，System.out 表示系统的标准输出
        Scanner input = new Scanner(System.in);
        // 一般情况下，会给用户一个请输入的提示
        System.out.println("请输入一个整数");
        // 第三步获取用户输入
        // 获取用户输入的整数，并保存到 num 变量中
        int num = input.nextInt();
    }
}

输出

1. 打印并换行
   • System.out.println()
2. 打印不换行
   • System.out.print()

    class Example02{
        public static void main(String[] args){
            String name = "answer";
            int age = 18;
            boolean isMan = True;

            // 打印字面量
            System.out.println("Hello World");
            System.out.println(123);
            // 打印变量的值
            System.out.println(name);
            System.out.println(age);
            System.out.println(isMan);
            // 打印表达式的值
            System.out.println(1 + 1);
            System.out.println(age + 1);
            // 字符串拼接
            System.out.println("name" + name);
            System.out.println("性别男：" + isMan);
            System.out.println("年龄" + age)
            // 输出结果：年龄181
            System.out.println("年龄" + age + 1)
            // 输出结果：19年龄
            System.out.println(age + 1 + "年龄")
        }
}

流程控制

计算机的程序执行顺序有三种结构：

1. 顺序结构：从上向下逐条执行语句
2. 选择结构：根据条件是否成立，选择执行不同的分支
3. 循环结构：重复执行某段代码

选择结构

选择结构的语句有 if 和 switch 语句

if 语句

image

/**
if 语句
*/

import java.util.Scanner;

class Example01{
    // 判断输入的数字是不是正整数
    public static void main(String[] args){
        System.out.println("请输出一个整数");
        Scanner input = new Scanner(System.in);
        int num = input.nextInt();

        if(num > 0){
            System.out.println(num + "是正整数");
        }
    }
}

if ...else 语句

image

/**
    if...else 语句
*/

import java.util.Scanner;

class Example02{
    // 判断输入的整数是奇数还是偶数
    public static void main(String[] args){
        System.out.println("请输入一个整数");
        Scanner input = new Scanner(System.in);
        int num = input.nextInt();

        // 如果 num 可以被 2 整除，是偶数，否则，是奇数
        if(num % 2 == 0){
            System.out.println(num + "是偶数");
        }else{
            System.out.println(num + "是奇数");
        }
    }
}

多分支 if 语句

image

/**
    多分支 if 语句
*/

import java.util.Scanner;

class Example03{
    // 判断输入的是正整数，负数，还是 0
    public static void main(String[] args){
        System.out.println("请输入一个整数");
        Scanner input = new Scanner(System.in);
        int num = input.nextInt();

        if(num > 0){
            System.out.println(num + "是正数");
        }else if(num < 0){
            System.out.println(num + "是负数");
        }else{
            System.out.println(num + "是零");
        }
    }
}

switch 语句

switch 也是一种多分支语句，语法：

switch(条件表达式){
        case 常量1:
            代码块1;
            break;
        case 常量2:
            代码块2;
            break;
        default:
            代码块3;
    }

1. 条件表达式可以是int, short, byte, String 或者枚举类型，double,long 等类型不能做为 switch 的条件表达式
2. 常量值不能重复
3. 如果所有的常量值都不匹配条件表达式，则执行 default代码块
4. break 用于跳出 switch 语句
5. case 没有先后顺序

/**
switch语句
*/
import java.util.Scanner;

class Example04{
    public static void main(Sting[] args){
        // 根据输入的数字判断是星期几
        Scanner.out.println("请输入一个1～7范围内的正整数");
        Scanner input = new Scanner(System.in);
        int num = input.nextInt();

        switch(num){
            case 1:
                System.out.println("星期一");
                break;
            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;
            defaulf:
                System.out.println("你输入的数字不符合要求");
                break;
        }
        
    }
}

循环结构

循环就是重复的执行某一段代码，主要确定两点：

1. 重复执行的代码
2. 重复执行的条件

循环语句有 while 循环，do...while 循环，for 循环

while 语句

image

class Example01{
    public static void main(Sting[] args){
        // 打印10行"我是 while"
        int rows = 0;
        while(rows < 10){
            System.out.println("我是 while");
            rows++;
        }
    }
}

/*
    计算 1+2+3...100 的和
*/

class Example02{
    public static void main(String[] args){
        int sum = 0;
        int x = 1;
        while(x <= 100){
            sum += x;
            x++;
        }
        System.out.println("sum = " + sum);
    }
}

/*
    统计1～100范围内，有多少可以被7整除的数
*/

class Example03{
    public static void main(String[] args){
            int num = 1;
            int count = 0;
            while(num <= 100){
                if(num % 7 == 0){
                    count++;
                }
                num++;
            }
            System.out.print("1~100范围内可以被7整除的数有" + count + "个");
        }
}

/*
    猜数
    1 生成一个1～100范围内的随机整数
    2 提示用户输入一个猜测的数字
         如果输入的数字比随机数字大，提示大了
         如果输入的数字比随机数字小，提示小了
         如果相等，提示猜中了
    3 统计用户猜测的次数
*/

import java.util.Scanner;

class Example04{
    public static void main(String[] args){
        // 1. 生成一个1～100范围内的随机整数
        // Math.random() 方法返回一个0～1范围内的随机小数
        int dest = (int)(Math.random * 100);
        Scanner input = new Scanner(System.in);
        // 统计用户猜测的次数
        int count = 0;
        System.out.println("请输入你猜测的数字");
        int num = input nextInt();
        // 每次输入，计数器就加1
        count++;
        
        while(num != dest){
            if(num > dest){
                System.out.println("大了，请重新输入");
            }else if(num < dest){
                System.out.println("小了，请重新输入");
            }
            // 重新输入的数字赋值给 num
            num = input.nextInt();
            // 每次重新输入，计数器就加1
            count++;
        }
        // 循环结束，说明 dest == num 即猜中了
        System.out.println("恭喜你，猜中了，共猜了" + count + "次");
    }
}

do...while 语句

image

class Example05{
    public static void main(String[] args){
        // 1. 打印10行字符串
        int count = 0;
        do{
            System.out.println("Hello world");
            count++;
        }while(count < 10);
        
        // 2. 累加 1+2+3...100
        int num = 1;
        int sum = 0;
        do{
            sum += num;
            num++;
        }while(num <= 100);
        System.out.println("sum = " + sum);
    }
}

/*
    与 while 的区别：
    如果循环条件不成立
    do...while 至少执行一次循环
    while 一次循环都不会执行
*/

class Example05{
    public static void main(String[] args){
        int num = 10;
        // 循环条件不成立， while 一次也不执行
        while(num < 0){
            System.out.println(num);
            num++;
        }

        // 循环条件不成立，do...while 执行一次
        do{
            System.out.println(num);
            num++;
        }while(num < 0);
    }
}

for 语句

image

for(初始化表达式；循环条件表达式；循环体后表达式){
    循环体
}

执行过程：

1. 执行初始化表达式
2. 判断循环条件
3. 如果条件成立，执行循环体，执行循环体后表达式
4. 重复2，3步，当循环条件不成立时结束循环

一般情况下，当循环次数确定时使用 for 循环，循环次数不确定时使用 while 循环

public class Example06 {
    public static void main(String[] args){
        // 1.打印10次hello world
        for(int i = 1; i <= 10; i++){
            System.out.println("Hello World" + i);
        }

        // 2.计算 1+2+3...100 的和
        int sum = 0;
        for(int i = 1; i <= 100; i++){
            sum += i;
        }
        System.out.println("sum=" + sum);

        // 3.输出1～100之间能被7整除的数
        for(int i = 1; i <= 100; i++){
            if(i % 7 == 0){
                System.out.print(i + " ");
            }
        }
    }
}

/**
    循环嵌套
    根据输入的行数和个数打印星号
 */

 import java.util.Scanner;

public class Example07 {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.println("请输入行数");
        int rows = input.nextInt();
        System.out.println("请输入个数");
        int num = input.nextInt();

        // 外层循环控制行数
        for(int x = 1; x <= rows; x++){
            // 内层循环控制个数
            for(int i = 1; i <= num; i++){
                System.out.print("*");
            }
            System.out.println();
        }
        input.close();
    }
}

/**
    打印以下图形
    *
    **
    ***
    ****
    *****
    ******
 */

import java.util.Scanner;

public class Example08 {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.println("请输入行数");
        int num = input.nextInt();

        for(int i = 1; i <= num; i++){
            for(int x = 1; x <= i; x++){
                System.out.print("*");
            }
        System.out.println();
        }
        input.close();
    }
}

结束循环

• continue 结束本次循环，继续下次循环

• break 跳出循环结构

/*
 continue 结束本次循环，继续下一次循环
*/

public class Example09{
    public static void main(String[] args){
        // 打印1～100范围内可以被7整除的数
        num = 0;
        while(num <= 100){
            num ++;
            if(num % 7 != 0){
                // 如果不能被7整除就结束本次循环，再去判断循环条件
                continue;
            }
            System.out.print(num + " ")
        }
    }
}

/*
    break 结束循环
*/
import java.util.Scanner;

class Example10{
    public static void main(String[] args){
        int dest = (int)(Math.random() * 100);
        Scanner input = new Scanner(System.in);
        int count = 0;
        int num = -1;
        // 循环条件一致成立
        while(true){
            System.out.println("请输入你猜测的数字");
            num = input.nextInt();
            count++
            if(num > dest){
                System.out.println("大了");
            }else{
                System.out.println("小了");
            }else{
                System.out.println("恭喜你，猜中了，共猜了" + count + "次");
                // 结束循环
                break;
            }
        }
    }
}

/*
    for 循环中的 break , continue
 */
public class Example11{
    public static void main(String[] args){
        // 1.计算两个整数的最大公约数
        int m = 20;
        int n = 30;
        for(int i = m > n ? n : m; i >= 1; i--){
            if(m % i == 0 && n % i == 0){
                System.out.println(m + "与" + n + "的最大公约数是" + i);
                // 跳出整个循环
                break;
            }
        }

        // 2. 打印1～100之间能被7整除的数
        for(int i = 1; i <= 100; i++){
            if(i % 7 != 0){
                // 结束本次循环体，去执行表达式3
                continue;
            }
            System.out.print(i + " ");
        }
    }
}