后端开发学习日志（流程控制篇）

Xiaoxian____

已于 2022-06-24 20:12:12 修改

阅读量785

点赞数

文章标签：学习 java 开发语言

于 2022-06-22 19:36:45 首次发布

本文链接：https://blog.csdn.net/Xiaoxian____/article/details/125407481

版权

一、用户交互Scanner

之前我们学的基本语法中我们并没有实现程序和人的交互，但是Java给我们提供了这样一个工具类，我们可以获取用户的输入。java.util.Scanner是Java5的新特征，我们可以通过Scanner类来获取用户的输入。

基本语法：

Scanner s = new Scanner（System.in);

通过Scanner类的next（）与nextLine（）方法获取输入的字符串，在读取前我们一般需要使用hasNext（）与hasNextLine（）判断是否还有输入的数据。

import java.util.Scanner;

public class Demo01 {

    public static void main(String[] args) {


        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方法接收：");


        if(scanner.hasNext()==true){

            String str = scanner.next();
            System.out.println("输入的内容为"+str);
        }

        scanner.close();


    }
}

凡是属于IO流的类如果不关闭会一直占用资源，我们使用scanner.close（）将其关闭，养成好习惯。

我们运行该程序，在控制台台得到以下结果：

使用next方法接收：

我们输入 hello world

得到结果为：

输出的内容为hello

显然输出结果并不完整，这时我们需要用到NextLine（）语句

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用nextLine接收：");

        if (scanner.hasNextLine());
        String str = scanner.nextLine();
        System.out.println("输出的结果为"+str);
    }
}

此时我们再次输入hello world，得到的结果为

输出的结果为hello world

next（）与nextLine（）的区别

next（）

1.一定要读到有效字符才可以结束输入
2.对输入有效字符之前遇到的空白，next（）会自动将其去掉
3.只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
4.next（）不能得到带有空格的字符串

nextLine（）

1.以Enter为结束符，也就是说nextLine（）方法返回的是输入回车之前的所有字符
2.可以获得空白

Scanner进阶使用

import java.util.Scanner;

public class Demo04 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);


        int i = 0;
        float f = 0.0f;
        System.out.println("请输入整数：");

        if(scanner.hasNextInt()){
            i = scanner.nextInt();
            System.out.println("整数数据："+ i);
        }else {
            System.out.println("输入的不是整数数据");
        }
        System.out.println("请输入小数：");


        if(scanner.hasNextFloat()){
            f = scanner.nextFloat();
            System.out.println("小数数据："+ f);
        }else {
            System.out.println("输入的不是小数数据");
        }
    }
}

当我们输入正确数字时，以13为例，得到的结果为：

整数数据：13

此时控制台提示我们继续输入一个小数，我们以1.3为例，得到结果为：

小数数据：1.3

如果我们第一次输入1.3时，结果为：

1.3
输入的不是整数数据
请输入小数：
小数数据：1.3

import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {
       
        Scanner scanner = new Scanner(System.in);

      
        double sum = 0;
       
        int m = 0;

       
        while (scanner.hasNextDouble()){
            double x = scanner.nextDouble();

            m = m+1;

            sum = sum + x;
        }
        System.out.println(m +"个数的和为"+sum);
        System.out.println(m +"个数的平均值是"+(sum/ m));




    }
}

我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果。其中sum为和，m为计入了多少个数字，通过循环结构判断是否还有输入，并在里面对每一次进行求和和统计。

二、顺序结构

Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。

public static void main(String[] args) {
        System.out.println("hello 1");
        System.out.println("hello 2");
        System.out.println("hello 3");
        System.out.println("hello 4");
        System.out.println("hello 5");
    }

顺序结构是最简单的算法结构。语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。

三、选择结构

1)if单选择结构

我们很多时候需要去判断一个东西是否可行，然后我们才去2执行，这样一个过程在程序中用if句来表示

语法： if(布尔表达式）{

//如果布尔表达式为true将执行语句

}

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入内容");
        String s = scanner.nextLine();


        if(s.equals("Hello")) {
            System.out.println(s);

        }
        System.out.println("End");
        scanner.close();

当我们随意输入除Hello以外的字符，输出结果都为：

End

当我们输入Hello时，输出结果为：

Hello
End

2）if双选择结构

现在有个需求，公司要收购一个软件，成功了，给入支付100万元，失败了，自己找人开发。这样的需求用一个if就搞不定了，我们需要有两个判断，需要一个双选择结构，所以就有了if-else结构。

语法：if(布尔表达式){
//如果布尔表达式的值为true}

else{
//如果布尔表达式的值为false

}

例：

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩");
        int score = scanner.nextInt();

        if(score>=60){
            System.out.println("及格");
        }else {
            System.out.println("不及格");
        }

3）if多选择结构

我们发现刚才的代码不符合实际情况，真实的情况还可能存在ABCD，存在区间多级判断。比如90-100就是A，80-90就是B等等，在生活中我们很多时候的选择也不仅仅只有两个，所以我们需要一个多选择结构来处理这类问题。

语法：if(布尔表达式1){
//如果布尔表达式1的值为true执行代码

}else if(布尔表达式2){
//如果布尔表达式2的值为true执行代码

}else if(布尔表达式3){
//如果布尔表达式3的值为true执行代码

}else {
//如果以上布尔表达式都不为true执行代码}

例：

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩");
        int score = scanner.nextInt();

        if(score == 100){
            System.out.println("恭喜获得满分");
        }else if(score<100 && score>=90){
            System.out.println("恭喜获得A");
        }else if(score<90 && score>=70){
            System.out.println("恭喜获得B");
        }else if(score<70 && score>=60){
            System.out.println("恭喜获得C");
        }else if(score<60 && score>0){
            System.out.println("很遗憾，不及格");
        }else {
            System.out.println("请输入正确成绩");
        }

4）嵌套的if结构

使用嵌套的if...else语句是合法的。也就是说你可以在另一个if或者else if 语句中使用if或者else if 语句。你可以像if语句一样嵌套else if...else。

语法：

if(布尔表达式1){
//ll如果布尔表达式1的值为true执行代码

if(布尔表达式2){
///如果布尔表达式2的值为true执行代码

}
}

四、switch多选择结构

switch语句在Java中是用来做决策的。与if-then和if-then-else语句不同，switch语句可以有许多可能的执行路径。多选择结构还有一个实现方式就是switch case语句。switch case语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。switch case语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
switch语句中的变量类型可以是:byte、short、int或者char。从Java SE 7开始switch支持字符串String类型了。同时case标签必须为字符串常量或字面量。

语法：

switch(expression){
case value :
//语句
break;

//可选

case value :
//语句
break;//可选
//你可以有任意数量的case语句

default : //可选
//语句
}

        char grade = 'C';

        switch (grade){
            case 'A':
                System.out.println("优秀" );
                break;
            case 'B':
                System.out.println("良好" );
                break;
            case 'C':
                System.out.println("及格" );
                break;
            case 'D':
                System.out.println("再接再厉" );
                break;
            case 'E':
                System.out.println("挂科" );
                break;
            default:
                System.out.println("未知等级");

当我们测试C的时候输出结果为

及格

测试其他等级同理。

需要注意的是，我们每写完一个case后要在后面写上break进行中止。如果没有break编程运行会继续往下穿透，例如：

 char grade = 'C';

        switch (grade){
            case 'A':
                System.out.println("优秀" );
                break;
            case 'B':
                System.out.println("良好" );
           
            case 'C':
                System.out.println("及格" );
             
            case 'D':
                System.out.println("再接再厉" );
               
            case 'E':
                System.out.println("挂科" );
             
            default:
                System.out.println("未知等级");

得到结果为：

及格
再接再厉
挂科
未知等级

我们再看何为支持字符串String类型

        String name = "小贤";

        switch(name){
            case"芸":
                System.out.println("芸");
                break;
            case "小贤":
                System.out.println("芸");
                break;
            default:
                System.out.println("弄啥呢");

输出结果为

芸

五、循环结构

当我们需要重复去打一段字符串的时候，我们当然能重复输入一串代码去实现，但是我们可以用循环结构去更高效的完成任务。

1）while循环

while是最基本的循环,只要布尔表达式为true，循环就会一直执行下去。我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环。少部分情况需要循环一直执行，比如服务器的请求响应监听等。循环条件一直为true就会造成无限循环【死循环】，我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死奔溃!语法如下：

while(布尔表达式) {

//循环内容
}

思考：如何输出1~100

int i = 0;
while (i<100){
i++;
system.out.println(i);
}

将它们相加起来可使用以下代码：

        int i = 0;
        int sum = 0;
        while (i<=100) {
            sum = i + sum;
            i++;

        }
        System.out.println( sum);

2）do...while循环

对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件,也至少执行一次。do...while循环和while循环相似，不同的是，do...while循环至少会执行一次。语法如下：

do{

//代码语句

}while(布尔表达式)；

        int i = 0;
        int sum = 0;

        do {
            sum = i + sum;
            i++;
        }while(i<=100);
        System.out.println(sum);

输出结果与while循环相同。

While和do-While的区别:

while先判断后执行。dowhile是先执行后判断!

Do...while总是保证循环体会被至少执行一次!这是他们的主要差别。

3）for循环

虽然所有循环结构都可以用while或者do...while表示，但Java 提供了另一种语句——for循环，使一些循环结构变得更加简单。for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环执行的次数是在执行前就确定的。语法格式如下:

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

        int a = 1;

        while(a<=100){
             System.out.println(a);
             a+=2;
        }

        System.out.println("while循环结束");

        for(int i = 1; i<=100 ; i++){
            System.out.println(i);


            }

        System.out.println("fot循环结束");

我们可以发现使用for循环比while循环更加简洁高效。

下面我们看三个题

练习1:计算0到100之间的奇数和偶数的和

        int oodSum = 0;
        int evenSum = 0;

        for (int i = 0; i <= 100; i++) {
            if(i%2!=0) {
                oodSum += i;
            }else {
                evenSum += i;

            }
        }

        System.out.println("奇数的和："+oodSum);
        System.out.println("偶数的和："+evenSum);

利用i%2判断数字的奇偶性，再相加即可获得答案

练习2:用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个

        for (int i = 0; i <= 1000; i++) {
            if(i%5 == 0){
                System.out.print(i+"\t");
            }
            if(i%(5*3) == 0){
                System.out.println();

println是指输出完会换行，print是指输出完不换行。由于每三个进行一次换行，即15的倍数换行一次，可用 i%(5*3) == 0进行判断

练习3:打印九九乘法表

       for (int j = 1; j < 10; j++) {
            for (int i = 1; i <=j; i++) {
                System.out.print(j + "*" + i +"=" + (i*j)+"\t");
        }
            System.out.println();

4）增强for循环

此次对增强for循环进行一个初步了解，在后面数组会重点学习。在Java5中引入了一种主要用于数组或集合的增强型for循环。语法如下：

for(声明语句︰表达式)

{
//代码句子

}

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

        int [] number = {10,20,30,40,50};
        for(int i = 0;i<5;i++){
            System.out.println(number[i]);
                }
        for(int x:number){
            System.out.println(x);

输出结果为：

10
20
30
40
50
10
20
30
40
50

5）break与continue

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

        int i = 0;
        while (i<100){
            i++;
            System.out.println(i);
            if(i==30){
                break;
            }
        }
        System.out.println("123");

break只是中止而不是停止程序，在下方再次输入 System.out.println("123");我们可以发现程序依旧可以输出123。

        int i =0;
        while (i<100){
            i++;
            if(i%10==0){
                System.out.println();
                continue;
            }
            System.out.println(i);

continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

6）关于goto关键字
goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字，但并未在语言中得到正式使用;Java没有goto。然而，在break和continue这两个关键字的身上，我们仍然能看出一些goto的影子---带标签的break和continue。“标签”是指后面跟一个冒号的标识符，例如:label:
对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是:我们希望在其中嵌套另-个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。

        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+"  ");

此编程是打印出101~150之间的所有指数，该方法不建议使用，了解即可。

六、一些练习题

1.打印三角形

for (int i = 1; i <= 5; i++) {
            for (int j = 0; j < 5 - i; j++) {
                System.out.print("* ");
}
 System.out.println();
}

图形为

* * * *
* * *
* *
*

       for (int i = 1; i <= 5; i++) {
            for (int j = 0; j < 5 - i; j++) {
                System.out.print("");
            }
            for(int j = 1; j<=i;j++){
               System.out.print("*");
            }
 System.out.println();
}

图形为

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

 for (int i = 1; i <= 5; i++) {
            for (int j = 0; j < 5 - i; j++) {
                System.out.print(" ");
            }
            for(int j = 1; j<=i;j++){
                System.out.print("*");
            }
            for (int j = 1; j < i; j++) {
                System.out.print("*");
            }
            System.out.println();
}

图形为：