Java基础--程序流程控制

1660013969836.jpg

1. 顺序结构

顺序结构中的代码会按照顺序一行一行向下执行所有的代码语句,可以用来进行输入 输出 计算等的操作

但顺序结构不可以完成先做判断,再做选择的流程

2. 分支结构

2.1 if 分支

2.1.1 单分支结构

适合只有一个判断条件时使用，符合条件，执行大括号里的代码，不符合条件，大括号里的代码跳过

<pre class="prettyprint hljs lua" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; word-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">if(判断条件){
如果判断条件的结果为true,就执行此处代码,不符合条件,此处跳过
}</pre>

2.1.2 多分支结构

适合有两种情况时使用，符合条件，执行代码1，其他情况执行代码2

<pre class="prettyprint hljs lua" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; word-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">if(判断条件){
如果判断条件的结果为true,就执行此处的代码
}else{
如果不符合条件,执行else处的代码
}</pre>

2.1.3 嵌套分支结构

适合有多个条件时使用，else-if的个数没有限制，else可加可不加

<pre class="prettyprint hljs xquery" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; word-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">if(判断条件1){
符合判断条件1,执行此处代码,不符合,继续向下判断
}else if(判断条件2){
符合判断条件2,执行此处代码,不符合,继续向下判断
}else if(判断条件3){
符合判断条件3,执行此处代码,不符合,继续向下判断
}else{
保底选项,以上条件均不符合的情况下,执行此处代码
}</pre>

练习:

<pre class="prettyprint hljs cs" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; word-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">package com.example.basic;

import java.util.Scanner;

/本类用于复习分支结构/
public class TestIf {
public static void main(String[] args) {
//1.提示并接收用户输入的月份
System.out.println("请输入您要测试的月份:");
int month = new Scanner(System.in).nextInt();

    //2.对用户输入的数据进行判断
    if(month<=0 || month >12){
        System.out.println("您输入的数据不正确!");
    }else{
        //3.如果用户输入的数据正确,我们就进行季节的判断
        if(month >=3 && month <=5){
            System.out.println(month+"月是春天");
        }else if(month >=6 && month <=8){
            System.out.println(month+"月是夏天");
        }else if(month >=9 && month<=11){
            System.out.println(month+"月是秋天");
        }else{
            System.out.println("冬天就要来啦,春天还会远吗?");
        }
    }
}

}</pre>

2.2 switch 分支

<pre class="prettyprint hljs groovy" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; word-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">switch (变量名){
case value1 : 操作1;break;//可选
case value2 : 操作2;break;//可选
case value3 : 操作3;break;//可选
case value4 : 操作4;break;//可选
default:保底选项;//可选
}</pre>

执行顺序: 先拿着变量a的值，依次与每个case后的值做比较，如果相等，就执行当前case后的操作，若case后没有break,就绪继续执行下一个case后的操作，如果一直没有遇到break,就会发生穿透的现象，包括default

注意事项：

1. 变量a支持的类型byte short char int String

2. 变量a的数据类型与case后value的数据类型必须一致

3. 如果没有添加break,并且又有case被匹配到，会发生穿透的现象，包括deafult

4. case的个数 是否加break 是否加default 完全根据自己的业务来决定

5. 如果添加了default保底选项，又没有任何一个case被匹配到，就会执行default后的语句

6. 一般我们习惯在每个case后加break【这个只是建议，具体还是根据业务来写】

3. 循环结构

当你想多次重复干某件事的时候，可以使用循环结构

3. 1 普通for循环

<pre class="hljs xquery" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 0.75em; font-size: 14px; line-height: 1.5em; word-break: break-all; word-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">for(开始条件 ; 循环条件 ; 更改条件){
循环体
}</pre>

注意1：写法小窍门：从哪开始 到哪结束 循环变量如何变化

注意2：for循环能够执行多少次，取决于循环变量可以取到几个值

[图片上传失败...(image-63d187-1660014197261)]

3.2 嵌套for 循环

外层循环控制的是轮数，内层循环控制的是每一轮中执行的次数

对于图形而言，外层循环控制的是行数，内层循环控制的是列数

<pre class="prettyprint hljs less" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; word-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">for(开始条件;循环条件;更改条件){//外层循环
for(开始条件;循环条件;更改条件){//内层循环
循环体
}
}</pre>

注意:外层循环控制的是行数,内层循环控制的是列数

注意:外层循环控制的是轮数,内层循环控制的是在这一轮中执行的次数

3.3 高效for 循环

<pre class="prettyprint hljs xquery" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; word-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">for(遍历到的元素的类型 遍历到的元素的名字 ：要遍历的数组/集合名){
循环体
}</pre>

优点：写法简单，效率高

缺点：只能从头到尾的遍历数据，不能进行步长的选择

3.4 while循环

<pre class="hljs xquery" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 0.75em; font-size: 14px; line-height: 1.5em; word-break: break-all; word-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">while(判断条件){
如果符合判断条件,继续循环
}</pre>

注意:常用来完成死循环,但死循环必须设置出口!

练习:

<pre class="prettyprint hljs cs" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; word-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">package com.example.basic;
/本类用于复习while循环/
public class TestWhile {
public static void main(String[] args) {
//需求:通过while循环打印10次"小可爱们中午好~"
//f1();
//需求:通过while循环打印1 2 3 ... 10
//f2();
//需求:通过while循环打印1 3 5 7... 99
f3();
//需求:通过while计算1+2+3+4...+10
f4();
//需求:通过while计算2+4+6+8...+100
f5();
}

private static void f5() {
    //需求:通过while计算2+4+6+8...+100
    int i = 2;//定义循环变量i用来控制循环
    int sum = 0;//定义变量用来保存累加的结果
    while (i<=100){
        //sum += i;
        sum = sum + i;//累加
        //i += 2;
        i = i + 2;//循环变量i每次+2
    }
    System.out.println("2到100所有偶数的和为:"+sum);
}

private static void f4() {
    //需求:通过while计算1+2+3+4...+10
    int i = 1;//用于控制循环,相当于循环变量
    int sum = 0;//用于保存求和累加的结果
    while(i<=10){
        sum = sum + i;
        i++;
    }
    System.out.println("1到10累加的结果为:"+sum);
}

private static void f3() {
    //需求:通过while循环打印1 3 5 7... 99
    int sum = 1;
    while(sum <100){
        System.out.println(sum);
        //sum = sum +2;
        sum += 2;
    }
}

private static void f2() {
    //需求:通过while循环打印1 2 3 ... 10
    //1.定义一个变量来控制执行的次数
    int i = 1;
    while(i<=10){
        System.out.println(i);
        i++;
    }
}

private static void f1() {
    //需求:通过while循环打印10次"小可爱们中午好~"
    //1.定义一个变量用来控制执行的次数
    int count = 1;
    while(count <= 10){
        System.out.println("小可爱们中午好~");
        count++;//注意count的值需要自增,否则还是一个死循环
    }
}

}</pre>

3.5 do-while循环

do-while循环一定会执行一次，然后再判断，如果符合条件，再执行后面的循环

<pre class="hljs sql" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 0.75em; font-size: 14px; line-height: 1.5em; word-break: break-all; word-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">do{
循环体
}while(判断条件);</pre>

几种循环的区别:

1. 如果明确知道循环的次数/需要设置循环变量的变化情况时–使用for循环
2. 如果想写死循环–while(true){}
3. 如果需要先执行一次，再做判断–do-while循环
4. 循环之间是可以互相替换的，但是最好使用比较合适的循环结构

4. 跳转关键字

4.1 break

跳出并结束当前循环的执行

注意: 只能用于结束所在循环, 或者结束所在switch 分支的执行

4.2 continue

用于跳出当前循环的档当次执行, 进入下一次循环

注意: 只能在循环中使用

5. 案例技术

5.1 随机数Random类

作用: 用于在程序中获取随机数的技术

使用步骤:

1. 导包：告诉程序去JDK的哪个包中找随机数技术

2. 写一行代码代表得到随机数对象

3. 调用随机数的功能获取0-9的随机数

<pre class="prettyprint hljs java" style="padding: 0.5em; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68, 68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size: 14px; line-height: 1.5em; word-break: break-all; word-wrap: break-word; white-space: pre; background-color: rgb(246, 246, 246); border: none; overflow-x: auto; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">package com.example.random;

import java.util.Random; //1.导包

public class Test {

public static void main(String[] args) {
    Random r = new Random(); //2.

    int number = r.nextInt(10); //3.
    System.out.println("随机生成了:"+ number);

}

}</pre>

注意: nextInt(n)功能只能生成: 0至n-1之间的随机数,不包含n