关于java:Java-从入坑到放弃No-5-控制流程

前言

咱们在 上一篇文章 中讲了各种操作符的应用技巧，接上一篇文章中的内容，本次文章次要将流程管制，文章次要内容安顿如下：

• 输入输出
• 条件判断
• 管制循环

输入输出

输出

要实现从控制台输出并读取到咱们的程序中时，咱们先来看一个实例：

import java.util.Scanner;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Main
 * @date : 2021/4/15 13:53
 * @description : 输出
 */

public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);
        System.out.println("输出整型");
        int num = scanner.nextInt();
        System.out.println("输出的整型：" + num);

        System.out.println("输出字符型");
        String name = scanner.next();
        System.out.println("输出的字符型：" + name);

        System.out.println("输出浮点型");
        float floatNum = scanner.nextFloat();
        System.out.println("输出的字符型：" + floatNum);
        double doubleNum = scanner.nextDouble();
        System.out.println("输出的字符型：" + doubleNum);


    }
}

要实现从控制台输出，咱们须要借助 Scanner 类，它属于规范输出流，其步骤总结如下：

1. 首先，须要导入 Scanner 类。即 import java.util.Scanner，其中 import 示意导入某个类，并且只能放在程序的结尾；
2. 而后创立 Scanner 对象。这里须要留神，创立时须要传入 System.in，示意规范输出流，与之对应的 System.out 则代表规范输入流；
3. 最初就是读取用户输出即可。这里读取时，调用不同的办法 Scanner 会主动转换数据类型，不必咱们去进行手动转换；

从控制台获取不同类型的输出，其罕用办法如下：

输入

其实从一开始的 hello world 到目前的代码中，咱们曾经接触过输入了，也就是咱们的 System.out.println()。

其中 println 示意输入并换行，如果咱们不想换行，则应用 print 就能够了。

通过上述形式所输入的内容都是挤在一起的，非常不不便咱们浏览。为了更加清晰的打印出咱们所须要的后果，能够应用格式化输入。

要应用格式化输入，须要应用 System.out.printf() 或者 System.out.format() 搭配占位符，而后在前面的参数格式化成指定格局即可，两者达成的成果是等价的。常见的占位符如下：

此外，咱们还能够应用各种转义字符来使得咱们的输入更为简洁，常见的转义字符及意义如下表所示。

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Main
 * @date : 2021/4/15 14:48
 * @description : 输入
 */

public class Main {public static void main(String[] args) {
        int num1 = 10;
        double num2 = 34.9;
        float num3 = 3.34f;
        String name = "村雨遥";

        //        换行及不换行输入
        System.out.println("公众号：" + name);
        System.out.print("公众号：" + name);
        System.out.println(num1);

        //        格式化输入
        System.out.println("格式化输入：");
        System.out.printf("num1 = %d\n", num1);
        System.out.format("num2 = %f\t num3 = %f\n", num2, num3);
        System.out.printf("name = %s\n", name);
        System.out.format("name = %s\n", name);
    }
}

条件判断

if

1. 单次判断

当咱们只进行一次判断时，能够应用一个 if 语句蕴含一个条件表达式，其语法格局如下；

if(条件表达式){执行语句;}

其执行逻辑如下图所示，如果条件表达式的值为 true，则执行 if 语句块中的执行语句，否则就执行 if 语句块后边的代码；

1. 屡次判断

要进行屡次判断时，能够应用 if…else 的模式，其语法格局如下；

if(条件表达式 1){执行语句 1;} else if(条件表达式 2){执行语句 2;} else if(…){…}…

其执行逻辑如下图所示，如果条件表达式 1 为 true，则执行执行语句 1，否则接着判断条件表达式 2，若为 true，则执行执行语句 2，以此类推，直到实现最初一个条件表达式的判断。

import java.util.Scanner;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Main
 * @date : 2021/4/15 15:45
 * @description : 条件判断
 */

public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);
        System.out.println("请输出分数：");
        double score = scanner.nextDouble();

        if (score < 0 || score > 100) {System.out.println("输出的分数不在 0 -100 之间，不符合要求");
        } else if (score >= 90) {System.out.println("A");

        } else if (score >= 80) {System.out.println("B");

        } else if (score >= 60) {System.out.println("C");
        } else {System.out.println("D");

        }
    }
}

switch

当咱们须要应用 if 进行判断时，不免显得有些繁琐。此时，咱们就能够应用 switch 来进行代替，通过判断一个变量所属范畴，从而划分出不同的分支。

switch 分支的语法格局如下：

switch(表达式){
    case value1:
        执行语句 1;
        break;
    case value2:
        执行语句 2;
        break;
    ……
    default:
        执行语句;
        break;
}    

通过判断表达式的值，而后执行对应值下的执行语句，而 default 下的执行语句示意如果 switch 表达式未匹配到对应的值时所执行的语句；

一个 switch 的实例如下：

import java.util.Scanner;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Main
 * @date : 2021/4/15 15:49
 * @description : switch
 */

public class Main {public static void main(String[] args) {Scanner input = new Scanner(System.in);
        System.out.print("请输出该学生问题：");
        int grade = input.nextInt();// 定义 grade 且获取键盘输入的整数
        if (grade < 0 || grade > 100) {// 输出的整数范畴应为 0 -100
            System.out.println("输出的问题有误");
            return;
        }
        switch (grade / 10) {
            case 10:
            case 9:
                System.out.println("该学生成绩优秀");
                break;
            case 8:
                System.out.println("该学生问题良好");
                break;
            case 7:
                System.out.println("该学生问题中等");
                break;
            case 6:
                System.out.println("该学生问题根本合格");
                break;
            default:
                System.out.println("该学生问题不合格");
                break;
        }
    }
}

而在应用 switch 分支语法时，须要遵循肯定的规定：

1. switch 中的变量类型能够是：byte、short、int、char、String（自 JDK 1.7 开始）；
2. switch 语句依据表达式的后果跳转到对应的 case 后果，而后执行其后跟着的语句，晓得遇到 break 才完结执行；
3. 默认状况下，个别都会跟着一个 default 的分支，用于未匹配到对应状况时的执行状况；

管制循环

while

假如咱们当初有一个题目，须要你计算 1 + 2 + 3 + …… + 50 的后果，你会怎么办呢？

这么写么：

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Main
 * @date : 2021/4/16 9:35
 * @description : while
 */

public class Main {public static void main(String[] args) {
        int sum = 1 + 2;
        sum += 3;
        sum += 4;
        ……
        sum += 50;
        System.out.println("1 + 2 + 3 + …… + 50 =" + sum);
    }
}

这么写就太麻烦了，计算到 50 的值就曾经很多了，如果有 1000,10000 甚至更大，那咱们岂不是写个良久能力写完。这个时候咱们就得找找有没有简略的办法，可能只写几句就实现雷同的成果呢？答案是：Yes，这就是咱们这一大节将要讲到的循环。

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Main
 * @date : 2021/4/16 9:35
 * @description : while
 */

public class Main {public static void main(String[] args) {
        int sum = 0;
        int num = 1;
        while (num <= 50) {
            sum += num;
            num++;
        }
        System.out.println("1 + 2 + 3 + …… + 50 =" + sum);
    }
}

从下面的实例，利用 while 循环，咱们就能轻易达成循环的成果。其语法格局如下：

while(表达式){执行语句;}

只有表达式为 true，就会一直循环执行其中的执行语句，直到表达式为 false，此时便跳出循环，不再执行其中的执行语句。

除开下面的模式之外，还有另一种 while 模式：

do{执行语句;}while(表达式);

两者的最大区别在于：do……while 无论 表达式 是否为 true，都至多会执行一次。

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Main
 * @date : 2021/4/16 9:35
 * @description : while
 */

public class Main {public static void main(String[] args) {
        int sum = 0;
        int num = 10;
        while (num <= 9) {
            sum += num;
            num++;
        }
        System.out.println("sum =" + sum);
    }
}

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Main
 * @date : 2021/4/16 9:35
 * @description : while
 */

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

察看以上两个实例，在 while 程序中，咱们定义 num = 10，而后假如 num <= 9 时就进入循环体，而 $10 > 9$，所以不进入循环体，间接打印 sum 的值为 0。而在 do…while 程序中，咱们同样定义 num = 10，而后假如 num < 10 时持续循环，很显著不满足该状况，理当跳出循环，打印出 sum 的值为 10，阐明此时还是进行了一次循环。

因而，当咱们须要在 while 和 do……while 之间做出抉择时，如果咱们起码须要进行一次循环，则抉择 do……while，其余状况下选用两者都能够。

for

• 一般 for 循环

除开 while 和 do……while 之外，咱们还有 for 循环来达成同样的后果，只是表达方法不一样。同样以下面计算 1 + 2 + …… + 50 为例，能够写成如下的模式：

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Main
 * @date : 2021/4/16 10:20
 * @description : for 循环
 */

public class Main {public static void main(String[] args) {
        int sum = 0;
        for (int num = 1; num <= 50; num++) {sum += num;}

        System.out.println("1 + 2 + …… + 50 =" + sum);
    }
}

for 循环的语法模式如下：

for(初始条件; 终止条件; 更新语句){循环语句;}

for 循环的执行步骤如下：

1. 首先执行初始条件，能够申明一种类型，但能够初始化一个或多个循环控制变量，甚至能够放空；
2. 接着判断终止条件，如果为 true，则进入循环体执行循环语句；如果为 false，则终止循环，执行循环体前面的语句；
3. 一次循环实现后，执行更新语句来更新循环控制变量；
4. 最初再次判断终止条件，循环以上三个步骤；

for 和 while 最大的区别就在于 for 循环个别都是当时晓得须要循环的次数的，而 while 循环则不须要。

• 加强 for 循环

自 Java 5 后，引入了一种增强型 for 循环，次要用于数字遍历，其语法格局如下：

for(申明语句: 表达式){// 循环语句}

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Main
 * @date : 2021/4/16 10:39
 * @description : 加强 for 循环
 */

public class Main {public static void main(String[] args) {int[] numbers = {1, 4, 5, 6, 9, 10};
        for (int number : numbers) {System.out.print(number + "\t");
        }
    }
}

其中，申明语句个别是申明一个同数组数据类型雷同的局部变量，而表达式则是要拜访的数组名或者返回值是数组的办法。

continue & break

break

次要用在循环语句或者 switch 语句中，示意跳出最里层的循环，而后继续执行该循环下的语句。

break 在 switch 语句中的用法曾经见识过了，咱们就来看看它在循环中的利用。

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Main
 * @date : 2021/4/16 10:51
 * @description : break & continue
 */

public class Main {public static void main(String[] args) {for (int i = 1; i < 10; i++) {System.out.println("i =" + i);
            if (i == 5) {break;}
        }
    }
}

察看后果可知，当 i == 5 时，咱们执行了 break 语句，此时就间接跳出了 for 循环，而不再进行下一次的循环。

continue

continue 也同样是利用在循环控制结构中，次要是让程序跳出当次循环，进而进入下一次循环的迭代。

在 for 循环中，执行 continue 语句后，间接跳转到更新语句，而不再执行 continue 后的语句。而在 while 或 do……while 循环中，执行 continue 语句后，间接跳转到表达式的判断。

/**
 * @author : cunyu
 * @version : 1.0
 * @className : Main
 * @date : 2021/4/16 10:51
 * @description : break & continue
 */

public class Main {public static void main(String[] args) {for (int i = 1; i < 10; i++) {if (i == 5) {continue;}
            System.out.println("i =" + i);
        }
    }
}

察看上述后果可知，当 i == 5 时，咱们执行了 continue 语句，此时便跳出了当次循环，不再进行后边的打印语句，而后持续下一次的循环，所以最终打印的后果没有 5.

总结

明天的内容到此就完结了，老规矩，如果大家感觉有用的话，就给个点赞关注吧！

其次就是对于文中脱漏或者存在欠缺的知识点，还请大家不吝赐教，在评论区给我指出来！