【JavaSE学习专栏】第02篇流程控制

文章目录

1 用户交互Scanner
2 顺序结构
3 选择结构
- 3.1 if单选择结构
- - 3.1.1 语法结构
  - 3.1.2 案例
- 3.2 if双选择结构
- - 3.2.1 语法结构
  - 3.2.2 案例
- 3.3 if多选择结构
- - 3.3.1 语法结构
  - 3.3.2 案例
- 3.4 嵌套的if结构
- - 3.4.1 语法结构
  - 3.4.2 案例
- 3.5 switch多选择结构
- - 3.5.1 语法结构
  - 3.5.2 案例
4 循环结构
- 4.1 while循环
- 4.2 do...while循环
- 4.3 for循环
5 调试程序
- 5.1 设置断点
- 5.2 使用debug模式
- 5.3 单步运行
6 增强for循环
7 break和continue
8 for循环的练习
- 练习1：计算0到100之间的奇数和，偶数和
- 练习2：用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个
- 练习3：打印九九乘法表
- 练习4：打印三角形

1 用户交互Scanner

1.java.util.Scanner是java5的新特征，我们可以通过Scanner类来获取用户的输入。

2.基本语法：Scanner scanner = new Scanner(System.in);

3.通过Scanner类的next()与nextLine()方法获取输入的字符串，使用hasNext()与hasNextLine()判断是否还有输入的数据。

4.next()：

一定要读取到有效字符后才可以结束输入。
对输入有效字符之前遇到的空白，next()方法会自动将其去掉。
只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
next()不能得到带有空格的字符串。

5.nextline():

以enter作为结束符，也就是说nextline()方法返回的是输入回车之前所有字符。
可以获得空白。

package scanner;

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()){
            //使用next方式接收
            String str=scanner.next();  //程序等待用户输入完毕
            System.out.println("输出的内容为："+str);
        }

        //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
        scanner.close();
    }
}

package scanner;

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);
        }

        scanner.close();
    }
}

package 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("输入的不是小数数据！");
        }

        scanner.close();
    }
}

2 顺序结构

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

3 选择结构

3.1 if单选择结构

3.1.1 语法结构

if(条件表达式) {

}

3.1.2 案例

package struct;

import java.util.Scanner;

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

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

        //equals:判断字符串是否相等
        if(s.equals("Hello")){
            System.out.println(s);
        }

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

3.2 if双选择结构

3.2.1 语法结构

// 当 if 条件表达式不成立的情况下就会进入else 代码块2 的执行
if(条件表达式) {
    //代码块1
} else {
    //代码块2
}

3.2.2 案例

package struct;

import java.util.Scanner;

public class IfDemo02 {
    public static void main(String[] args) {
        //考试分数大于60就是及格，小于60分就不及格
        Scanner scanner = new Scanner(System.in);

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

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

3.3 if多选择结构

3.3.1 语法结构

if(条件表达式) {
    //代码块1
} else if (条件表达式) {
    //代码块2
} else {
    代码块3
}

3.3.2 案例

public static void main(String[] args) {
    /*我想买车，买什么车决定于我在银行有多少存款
        如果我的存款超过500万，我就买凯迪拉克
        否则，如果我的存款超过100万，我就买帕萨特
        否则， 如果我的存款超过50万，我就买依兰特
        否则， 如果我的存款超过10万，我就买奥托
        否则， 如果我的存款10万以下 ，我买捷安特*/

    int bankMoney = 1000000;
    //如果我的存款超过500万，我就买凯迪拉克
    if(bankMoney > 5000000) {
        System.out.println("我就买凯迪拉克");
    } else if(bankMoney > 1000000) {    //否则，如果我的存款超过100万，我就买帕萨特
        System.out.println("我就买帕萨特");
    } else if(bankMoney > 500000) { //否则， 如果我的存款超过50万，我就买依兰特
        System.out.println("我就买依兰特");
    } else if(bankMoney > 100000) { //否则， 如果我的存款超过10万，我就买奥托
        System.out.println("我就买奥托");
    } else {    //否则， 如果我的存款10万以下 ，我买捷安特
        System.out.println("我买捷安特");
    }

}

3.4 嵌套的if结构

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

3.4.1 语法结构

if(条件表达式1) {
    if(条件表达式2) {
        //代码块1
    } else {
        //代码块2
    }
} else {
    //代码块3
}

3.4.2 案例

/* 
学校举行运动会，百米赛跑跑入10秒内的学生有资格进决赛，根据性别分别进入男子组和女子组
*/
public static void main(String[] args) {
    int runTime = 11;    //百米赛跑时间，单位为秒
    String sex = "男";
    // 小于10s才有资格进入决赛
    if(runTime < 10) {
        //进入决赛后根据性别判断进入男子或者女子组
        if(sex.equals("男")) {
            System.out.println("进入决赛男子组");
        } else {
            System.out.println("进入决赛女子组");
        }
    } else {
        System.out.println("抱歉，你没有进入决赛");
    }

}

3.5 switch多选择结构

在很多等值判断的情况下，使用if多重选择结构语法较复杂、啰嗦，这个时候可以使用switch 来作为选择结构，它的优点是：条件为等值判断、语法清晰！

3.5.1 语法结构

switch(表达式) {	//表达式 可以是int、byte、short、枚举、cha、String 类型 
    case 常量 1:
         语句1;
         break;
    case 常量 2:
         语句2;	 //如果表达式的值 为2 则进入 常量2，执行语句2
         break;
    case 常量 3:
         语句3;
         break;
    case ...
    default:	 // 如果以上都没有匹配到，则进入到default!
         语句;
         break;
}

3.5.2 案例

package struct;

public class SwitchDemo01 {
    public static void main(String[] args) {
        //switch 匹配一个具体的值
        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("未知等级");
        }
    }
}

4 循环结构

4.1 while循环

1、 while是最基本的循环，它的结构为：
while(布尔表达式){
//循环内容
}
2、只要布尔表达式为true，循环就会一直执行下去。
3、我们大多数情况会让循环停止下来的，我们需要用一个让表达式实效的方式来结束循环。
4、少部分情况需要循环一直执行，比如服务器的请求响应监听等。
5、循环条件一直为true就会造成无限循环（死循环），我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死崩溃!

package struct;

public class WhileDemo01 {
    public static void main(String[] args) {
        //输出1-100
        int i=0;
        while(i<100){
            i++;
            System.out.println(i);
        }
    }
}

4.2 do…while循环

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

do{
//代码语句
}while(布尔表达式)；

while和do-while的区别：
while先判断后执行。do-while先执行后判断！
do…while总是保证循环体会被至少执行一次！这是他们的主要差别。

package struct;

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

4.3 for循环

for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。
for循环执行的次数是在执行前就确定的。语法格式如下：

for(变量初始化;条件判断;更新循环变量) {
    //循环操作
}

//示例
for(int i = 0;i < 100;i++) {
    //循环操作
}

// 在变量初始化可以定义多个变量，变量之间以逗号分开
for(int i = 0,count = 100;i < count;i++) {
    //循环操作
}

package struct;

public class ForDemo01 {
    public static void main(String[] args) {
        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("for循环结束！");

        /*
        关于for有以下几点说明：
        最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
        然后，检测布尔表达式的值。如果为true,循环体执行。如果为false,循环终止，开始执行循环体后面的语句。
        执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）。
        再次检测布尔表达式。循环执行上面的过程
         */
       
    }
    
}

5 调试程序

在开发的过程中经常会碰到各种各样的程序错误，很多时候自己去看代码很难找出其中的问题，这时候就需要debug程序断点调试；

例如：在输出 1~5 这个5个数字时，发现只输出了 1 ~ 4 这4个数字，程序代码如下：

//输入1 ~ 5 这5个数字
int i = 1;
while (i < 5) {
    System.out.println(i);
    i++;
}

5.1 设置断点

在可能出现问题的代码处打上断点
在这里插入图片描述

5.2 使用debug模式

在这里插入图片描述

5.3 单步运行

可以使用快捷键F6(单步运行)，一步一步查看程序的运行结果和变量的值；

单步运行（F6）
结束调试，运行完成（F8）
单步跳入，当调试时调用了方法，那么会进入到方法体内（F5）

6 增强for循环

Java5引入了一种主要用于数组或集合的增强for循环。
Java增强for循环语法格式如下：

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

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

package struct;

public class ForDemo05 {
    public static void main(String[] args) {
        int[] numbers={10,20,30,40,50}; //定义了一个数组

        for(int i=0;i<5;i++){
            System.out.println(numbers[i]);
        }
        System.out.println("==============================");
        //遍历数组的元素
        for(int x:numbers){
            System.out.println(x);
        }
    }
}

7 break和continue

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

package struct;

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

package struct;

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

8 for循环的练习

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

package struct;

public class ForDemo02 {
    public static void main(String[] args) {
        //练习1：计算0到100之间的奇数和 偶数和
        int oddSum=0;
        int evenSum=0;

        for (int i = 0; i < 100; i++) {
            if(i%2!=0){  //奇数
                oddSum+=i;
            }else{
                evenSum+=i;
            }
        }
        System.out.println("奇数的和："+oddSum);
        System.out.println("偶数的和："+evenSum);
    }
}

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

package struct;

public class ForDemo03 {
    public static void main(String[] args) {
       // 练习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();
                System.out.println("\n");
            }
        }
        
        //println 输出完会换行
        //print 输出完不会换行
    }
}

练习3：打印九九乘法表

package struct;

public class ForDmo04 {
    public static void main(String[] args) {

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

练习4：打印三角形

package struct;

public class TextDemo01 {
    public static void main(String[] args) {
        //打印5行的三角形
        for(int i=1;i<=5;i++){
            for(int j=5;j>=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();
        }
    }
}