03-Java流程控制

一、用户交互Scanner

1.1 Scanner对象

Java给我们提供了一个工具类，java.util.Scanner，该工具类是Java5的新特征，可以通过Scanner类来获取用户的输入。

创建Scanner对象的基本语法：
- ```
Scanner scan = new Scanner(System.in);
```

1.2 next()&nextLine()

使用next方式接收输入的数据：

import java.util.Scanner

public class Demo01{
    public static void main(String[] args){
        //创建了一个扫描器对象，用于接收键盘数据
    	Scanner scan = new Scanner(System.in);
        
        //next方式接收字符串
        System.out.println("Next方式接收：");
            
        if (scan.hasNext()){
            String str = scan.next();
            System.out.println("输入的内容为：" + str);
        }
        //设计到io的类，在结束的时候一定要记得关闭，否则会占用很多资源
        scan.close();
	}
}

测试
- 输入：Hello world
- 输出：Hello
- 问题：为什么只输出了Hello？？
使用nextLine()

import java.util.Scanner

public class Demo02{
    public static void main(String[] args){
        //创建扫描器对象
        Scanner scan = new Scanner(System.in);
        
        // nextLine方式接收字符串
        System.out.println("nextLine方式接收");
        
        if (scan.hasNextLine()){
            String str2 = scan.nextLine();
            System.out.println("输入的内容为：" + str2);
        }
        
        scan.close();
    }
}

测试：
- 输入：Hello world
- 输出：Hello world

两者区别：

next():
- 一定要读取到有效字符后才可以结束输入
- 对输出有效字符之前遇到的空白，next()方法会自动将其去掉
- 只有输入有效字符后才将其后面输入的空白作为分隔符或结束符
- next()不能得到带有空格字符的字符串
nextLine():
- 以Enter为结束符，也就是说nextLine()方法返回的时输入回车之前的所有字符
- 可以获得空白

1.3 其他方法

如果要输入int或float类型的数据，在Scanner类中也有支持，但是在输入之前最好先使用hasNextXxx()方法进行验证，再使用nextXxx()来读取：

import java.util.Scanner

public class Demo03{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        
        //局部变量必须声明和设置初始值
        int i = 0;
        float f = 0.0f;
        
        System.out.print("输入整数：");
        //判断是否是整数
        if (scan.hasNextInt()){
            //获取整数并赋值给i
            i = scan.nextInt();
            System.out.println("整数数据：" + i);
        }else{
            System.out.println("输入的不是整数！");
        }
        
        System.out.print("输入小数：");
        //判断输入的是否是小数
        if (scan.hasNextFloat()){
            //获取小数并赋值给f
            f = scan.nextFloat();
            System.out.println("小数数据：" + f);
        }else{
            System.out.println("输入的不是小数！");
        }
        
        scan.close()
    }
}

输入多个数字求和和平均数

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
		
        // 计数器，记录有多少个数字
        int count = 0;
        
        // 设置和变量
        double sum = 0.0;

        while (scan.hasNextDouble()){
            count++;
            sum += scan.nextDouble();
        }

        System.out.println("输入的数字和为：" + sum);

        System.out.println("输入数字的平均数为：" + (sum / count));
    }
}

二、顺序结构

Java的基本结构是顺序结构，如果没有特别指明，会按照顺序一句一句的执行。

public class Demo03{
    public static void main(String[] args){
        System.out.println("Hello 1");
        System.out.println("Hello 2");
        System.out.println("Hello 3");
    }
}

三、选择结构

3.1 if单选择结构

if (布尔表达式){
    //如果布尔表达式为true将执行的语句
    System.out.println("当前布尔表达式的判断结为True");
}

举例

import java.util.Scanner

public class Demo04{
    public static void main(String[] args){
        //接收用户输入
        Scanner scan = new Scanner(System.in);
        
        System.out.println("请输入内容：");
        // 读取输出的内容，赋值给s
        String s = scan.nextLine();
        
        //如果输入的内容是Hello, 输出
        if (s.equals("Hello")){
            System.out.println("输入的内容是：" + s);
        }
        System.out.println("End");
        Scan.close();
    }
}

3.2 if双选择结构

if (布尔表达式){
    //如果布尔表达式为true将执行的语句
    System.out.println("当前布尔表达式的判断结为True");
}else{
    //如果表达式判断的结构是false
    System.out.println("当前布尔表达式判断的False");
}

如果学生的成绩大于60输出“及格”，如果低于60输出“不及格”

import java.util.Scanner
    
public class Demo05{
    public static void main(String[] agrs){
        //录入用户输入的成绩数据
        Scanner scan = new Scanner(System.in);
        
        System.out.println("输入的成绩是：");
        int score = scan.nextInt();
        
        //对输入成绩进行判断
        if (score > 60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        
        scan.close();
    }
}

3.3 if多选择结构

if (布尔表达式1){
    //如果布尔表达式1的结果是true
    System.out.println("布尔表达式1的比对结果是true");
}else if (布尔表达式2){
    //如果布尔表达式2的结果是true
    System.out.println("布尔表达式2的比对结果是true");
}else{
    //布尔表达式1和布尔表达式2的条件都不满足
    System.out.println("布尔表达式1和布尔表达式2的条件都不满足");
}

判断学生的成绩是优秀还是良好还是不及格

import java.util.Scanner

public class Demo06{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        
        System.out.println("请输入成绩：");
        int score = scan.nextInt();
        
        if (score == 100){
            System.out.println("恭喜满分");
        }else if (score < 100 && score >= 90){
            System.out.println("A级");
        }else if (score < 90 && score >= 80){
            System.out.println("B级");
        }else if (score < 80 && score >= 70){
            System.out.println("C级");
        }else if (score < 70 && score >= 60){
            System.out.println("D级");
        }else{
            System.out.println("不及格");
        }
    }
}

3.4 嵌套的if结构

可以在一个if...else结构中使用if...else结构

if (布尔表达式1){
    // 如果布尔表达式1为true的时候，执行如下语句
    if (布尔表达式2){
        //布尔表达式1和布尔表达式2都为true
        System.out.println("布尔表达式1和布尔表达式2都为true");
    }
}

所有流程控制语句都可以进行嵌套

3.5 switch多选择结构

多选择结构可以通过switch...case语句进行实现

switch(expression){
    case value1:
        // 语句
        break;
    case value2:
        //语句
        break;
    default:
        //语句
}

switch case语句有如下规则
- switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
- switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
- case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
- 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
- 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现break 语句。
- switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

public class Demo07{
    public static void main(String[] args){
        char grade = 'C';
        switch (grade){
            case 'A':
                System.out.println("优秀");
                break;
            case 'B':
                System.out.println("良好");
                break;
            case 'C':
                System.out.println("及格");
                break;
            default:
                System.out.println("未知等级");
        }
        System.out.println("您的成绩是：" + grade);
    }
}

JDK7增加了字符串表达式

public class Demo08{
    public static void main(String[] args){
        String Language = "Java";
        switch (Language){
            case 'Java':
                System.out.println("you favourite language is java!");
                break;
            case 'Python':
                System.out.println("you favourite language is Python!");
                break;
            case 'Go':
                System.out.println("you favourite language is Go!");
                break;
            default:
                System.out.println("i don't know you favourite language!");
        }
    }
}

四、循环结构

顺序结构的程序语句只能被执行一次，如果想要同样的操作执行多次，就需要用循环结构

Java中有三种主要的循环结构
- while循环
- do...while循环
- for循环
在Java5中引入了一种主要用与数组的增强型for循环

4.1 while循环

while (布尔表达式){
    //循环体
}

在大多数情况下，不会让循环一直执行下去，都要设置跳出循环的条件，或者通过让一个表达式失效的方式来结束循环。循环结束的方式有：循环内部控制，外部设立标志位等。

public class Demo08 {
    public static void main(String[] args){
        int i = 0;
        while (i < 100){
            i++;
            System.out.println(i);
        }
    }
}

有少数的情况需要循环一直执行，比如服务器的请求响应监听。

public class Demo09 {
    public static void main(String[] args){
        while (true){
            //等待客户端连接
            //定时检查
            //........
        }
    }
}

【案例：计算1 + 2 +3 ...+ 100 = ?】

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

4.2 do...while循环

对于while而言，如果条件不满足的情况下，无法进去循环，但是有的时候即使不满足条件，也至少要执行一次循环

do{
    //循环体
}while(布尔表达式);

布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。如果布尔表达式的值为True，则语句块一直执行，只到布尔表达式的值为false.

使用do...while编写1-100的求和

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

while和do...while的区别
- while是先判断再执行
- do...while是先执行再判断

public class Demo11 {
    public static void main(String[] args){
        int a = 0;
        while (a < 0){
            System.out.println(a);
        }
        System.out.println("----------------------");
        
        do {
            System.out.println(a);
            a++;
        } while (a < 0);
    }
}

4.3 For循环

for循环一般用在，在执行前就明确了需要执行循环的次数。

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

for循环执行步骤：

最先执行初始化步骤，可以声明一种类型，但可以初始化一个或多个循环控制变量，也可以是空语句
检查布尔表达式的值，如果是true，循环体被执行，如果是false，循环终止。
执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）
再次检测布尔表达式。循环执行如上的步骤

public class Demo12 {
    public static void main(String args[]){
        int a = 1;
        while (a <= 100){
            System.out.println(a);
            a+=2;
        }
        System.out.print("while 循环结束");
        
        for (int i = 1; i <= 100; i++){
            System.out.println(i);
        }
        System.out.println("for 循环结束!");
    }
}

4.4 增强for循环

Java5引入的一种用于数组或集合的增强型for循环。

for(声明语句:表达式){
    //代码句子
}

声明语句：
- 该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：
- 表达式是要访问的数组名，或者返回值为数组的方法

public class Demo13{
    public static void main(String[] args){
        int [] numbers = {10, 20, 30, 40, 50};
        for (int x : numbers){
            System.out.print(x);
            System.out.print(",");
        }
        
        System.out.print("\n");
        String [] names = {"James", "Larry", "Tom", "Lacy"};
        for (String name : names){
            System.out.print(name);
            System.out.print(",");
        }
    }
}

五、break&continue

5.1 break

break 用于跳出最里面的循环，然后执行跳出循环下面的语句

public class Demo12 {
    public static void main(String[] args){
        int i = 0;
        while (i<100){
            i++;
            System.out.println(i);
            if (i==30){
                break;
            }
        }
    }
}

5.2 continue

在 for 循环中，continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

public class Demo13 {
    public static void main(String[] args){
        i = 0;
        while (i<100){
            i++;
            if (i % 10 == 0){
                System.out.println();
                continue;
        	}
        }  
    }
}

5.3 两者的区别

break
- break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循
  环中剩余的语句。(break语句也在switch语句中使用)
continue
- continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行
  下一次是否执行循环的判定。

5.4 带标签的continue&break

“标签”是指后面跟一个冒号的标识符，例如：label:
对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希
望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使
用，它们就会中断到存在标签的地方。

public class Demo15 {
    public static void main(String[] args){
        int count = 0;
        outer:for (int i = 101; i < 150; i++){
            for (int j = 2; j < i /2; j++){
                if (i % j == 0){
                    continue outer;
                }
            }
            System.out.print(i + " ");
        }
    }
}

相当于给循环起了个名字，可以通过continue和break来指定是跳过哪次循环，或者结束哪次循环

posted @ 2023-01-10 20:36 Coilin 阅读(12) 评论(0) 编辑收藏举报

刷新页面返回顶部

Coilin's Blog