流程控制_顺序结构_选择结构_if单选择结构_if双选择结构_if多选择结构_嵌套的if结构_switch多选择结构_循环结构_while循环_do...while循环_for循环_增强for循环

耀匙

已于 2022-08-17 15:21:03 修改

阅读量316

点赞数 2

文章标签： java

于 2022-08-13 15:30:48 首次发布

本文链接：https://blog.csdn.net/YAOSHI_XXZZ/article/details/126320219

版权

顺序结构

Java的基本结构就是顺序结构,排除特别指明,否则就按照顺序依据依据执行.

顺叙结构是最简单的算法结构

在这里插入图片描述

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

选择结构

if单选择结构

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

在这里插入图片描述

语法:

if(布尔表达式){
    //如果布尔表达式为true将执行的语句
}

布尔表达式为true则执行代码块**( {} 由正反大括号组成的结构也叫做代码块)**内的语句,布尔表达式为false则跳过代码块内容

实例:

public static void main(String[] args) {
    /*
        创建扫描器实例化对象用于接收键盘数据
        Scanner s = new Scanner(System.in);
        关闭IO流
        s.close();
        凡事属于IO流的类如果不关闭会一直占用资源,要养成良好的习惯用完就关掉
     */
    Scanner s = new Scanner(System.in);//实例化Scanner对象----将Scanner加载到内存中

    System.out.println("请输入正确内容我将返回该内容:");//向控制台输出提示语
    String a = s.nextLine();//定义字符串变量a来储存控制台输入的下一行内容

    if(a.equals("你好")){//判断输入的内容的值是否与括号内的值相同----.equals判断是操作符.之前的代码的值与括号内的代码的值是否相同; ==判断的是左右两边的内存地址是否相同
        System.out.println("你好");//布尔表达式为true的时候向控制台输出你好
    }
    System.out.println("End");

    s.close();//关闭Scanner占用的io流

}

效果演示图:

if单选择结构

if双选择结构

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

if双选择结构图

语法:

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

实例:

public static void main(String[] args) {
    /*
        创建扫描器实例化对象用于接收键盘数据
        Scanner s = new Scanner(System.in);
        关闭IO流
        s.close();
        凡事属于IO流的类如果不关闭会一直占用资源,要养成良好的习惯用完就关掉
     */
    Scanner s = new Scanner(System.in);//实例化Scanner对象----将Scanner加载到内存中

    System.out.println("您的回答将决定公司的选择:");//向控制台输出提示语
    String a = s.next();//定义字符串变量a来储存控制台输入的内容

    if(a.equals("100w太少了")){//判断输入的内容的值是否与括号内的值相同----.equals判断是操作符.之前的代码的值与括号内的代码的值是否相同; ==判断的是左右两边的内存地址是否相同
        System.out.println("找别人开发");//布尔表达式为true的时候向控制台输出
    }else{
        System.out.println("决定买下您的软件");//布尔表达式为false的时候向控制台输出
    }

    s.close();//关闭Scanner占用的io流

}

效果演示图:

if双选择结构

~~语言的艺术~~

代码的局限性 ✓

if多选择结构

代码不符合实际情况, 实际情况还可能存在ABCD, 存在区间多级判断. 比如我一百万都不愿意花,我就想10块开发一个软件,20块开发个稍微好一点的软件等等,在生活中很多时候的选择不仅仅只有两个,所以我们需要一个多选择结构来处理这类问题

if多选择结构

语法:

if(布尔表达式1){
    //如果布尔表达式1的值为true则执行
}else if(布尔表达式2){
    //如果布尔表达式2的值为true则执行
}else if(布尔表达式3){
    //如果布尔表达式3的值为true则执行
}else{
    //如果以上布尔表达式都不为true则执行
}

实例:

public static void main(String[] args) {
        /*
        创建扫描器实例化对象用于接收键盘数据
        Scanner s = new Scanner(System.in);
        关闭IO流
        s.close();
        凡事属于IO流的类如果不关闭会一直占用资源,要养成良好的习惯用完就关掉
     */
    Scanner s = new Scanner(System.in);//实例化Scanner对象----将Scanner加载到内存中

    System.out.println("公司决定最终找人开发,您是公司决策人,您决定投入资金(单位/元): ");//向控制台输出提示语
    int a = s.nextInt();//定义字符串变量a来储存控制台输入的内容

    if(a >= 1000000){//判断输入的数字是否大于等于1000000
        System.out.println("刚才100w怎么不买");//布尔表达式为true时向控制台输出
    }else if(a >= 20){//判断输入的数字是否大于等于20
        System.out.println("勉强试试");//布尔表达式为true时向控制台输出
    }else if(a >= 10){//判断输入的数字是否大于等于10
        System.out.println("洗洗睡吧梦里啥都有");//布尔表达式为true时向控制台输出
    }else{//上方的布尔表达式全为false时执行
        System.out.println("10块都不给的抠门xiugiu要不尝试下去b站大学免费自学习软件开发?");//发出灵魂拷问
    }

    s.close();//关闭Scanner占用的io流

}

效果演示图:

if多选择结构

一个if最多只有一个else语句,else语句在所有的else if语句之后

if语句可以有若干个else if语句,他们必须在else语句之前

一旦其中一个else if语句检测为true 其他else if以及 else语句都不会被执行

嵌套的if结构

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

语法:

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

实例:

public static void main(String[] args) {
    /*
        创建扫描器实例化对象用于接收键盘数据
        Scanner s = new Scanner(System.in);
        关闭IO流
        s.close();
        凡事属于IO流的类如果不关闭会一直占用资源,要养成良好的习惯用完就关掉
     */
    Scanner s = new Scanner(System.in);//实例化Scanner对象----将Scanner加载到内存中

    System.out.println("输入一个1-100之间的数我将判断他是在哪个区间段: ");//向控制台输出提示语
    int a = s.nextInt();//定义字符串变量a来储存控制台输入的内容

    if (a <=100 && a >=1) {

        if (a >= 66) {

            if (a >= 88) {
                System.out.println("数字在88-100之间");
            } else if (a <= 77) {
                System.out.println("数字在66-77之间");
            } else {
                System.out.println("数字在77-88之间");
            }

        } else if (a <= 33) {

            if (a >= 22) {
                System.out.println("数字在22-33之间");
            } else if (a <= 11) {
                System.out.println("数字在1-11之间");
            } else {
                System.out.println("数字在11-22之间");
            }

        } else {

            if (a >= 55) {
                System.out.println("数字在55-66之间");
            } else if (a <= 44) {
                System.out.println("数字在33-44之间");
            } else {
                System.out.println("数字在44-55之间");
            }

        }

    }else{
        System.out.println("输入的数字不在1-100的范围内");
    }

    s.close();//关闭Scanner占用的io流

}

效果演示图:

if嵌套结构

所有的流程控制语句都可以相互嵌套互不影响

switch多选择结构

多选择结构还有一个实现方式就是switch case语句.

switch case语句判断一个变量与一系列值中某一个值是否相等,每个值称为一个分支.

switch语句中的变量类型可以是:

byte, short, int 或者 char.

从Java SE 7开始switch支持字符串String类型了

同时case标签必须为字符串常量或字面量

语法:

//switch匹配一个具体的值
switch(expression){
    case value :
        //语句
        break; //可选
    case value :
        //语句
        break; //可选
    //你可以有任意数量的case语句
    default : //可选
        //语句
}

实例:

public static void main(String[] args) {
    /*
        创建扫描器实例化对象用于接收键盘数据
        Scanner s = new Scanner(System.in);
        关闭IO流
        s.close();
        凡事属于IO流的类如果不关闭会一直占用资源,要养成良好的习惯用完就关掉
     */
    Scanner s = new Scanner(System.in);//实例化Scanner对象----将Scanner加载到内存中

    System.out.println("输入你的成绩: ");//向控制台输出提示语
    String a = s.next();//定义short类型变量a来储存输入的下一个short类型内容
    switch(a){//以表达式为标准
        case "A"://与表达式结果一致时执行
            System.out.println("优秀");//向控制台输出优秀
            break;//退出switch判断
        case "B"://与表达式结果一致时执行
            System.out.println("良好");//向控制台输出良好
            break;//退出switch判断
        case "C"://与表达式结果一致时执行
            System.out.println("一般");//向控制台输出一般
            break;//退出switch判断
        default://所有的case与表达式结果都不一致时执行
            System.out.println("不及格");//向控制台输出不及格
     }

    s.close();//关闭Scanner占用的io流

}

效果演示图:

switch选择结构

我们看到当case中没有break;时,有一个case条件达成就会输出后续所有的语句,这个现象叫做case穿透现象

由此可得知, 当有一个条件达成时, 且没有退出switch判断时后续的所有case内的代码都将执行, 直到退出switch判断或执行完所有case时停止; 当所有条件都未达成时default内的代码才会执行

循环结构

while循环

while是最基本的循环, 他的结构为:

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

只要布尔表达式为true, 循环就会一直执行下去.

我们大多数情况是会让循环停止下来的, 我们需要一个让表达式失效的方式来结束循环

少部分情况需要循环一直执行, 比如服务器的请求响应监听等.

循环条件一直为true就会造成无限循环[ 死循环 ], 我们正常的业务编程中应该尽量避免死循环. 死循环会影响程序性能或造成程序卡死崩溃!

实例:

public static void main(String[] args) {
    //计算从1加到100等于多少
    int a = 1;//定义一个int类型变量a储存初始数字1
    int b = 0;//定义一个int类型变量b储存初始结果0
    while(a <= 100){//a小于等于100时执行{}内代码
        b += a;//将b和a相加的新值赋值给b
        a++;//a自增一次
    }
    System.out.println(b);//输出最终结果
}

效果演示图:

while循环

do…while循环

对于while语句而言, 如果不满足条件, 则不能进入循环. 但有时候我们需要即使不满足条件, 也至少执行一次.

do…while循环和while循环相似, 不同的是, do…while循环至少会执行一次.

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

while和do…while的区别:

while先判断后执行, do…while先执行后判断

do…while宗师保证循环体至少会被执行一次, 这是他们的主要差别.

实例:

public static void main(String[] args) {
    //测试{}内的代码是否会被执行
    int a = 1;//定义一个int类型变量a储存初始数字1
    int b = 0;//定义一个int类型变量b储存初始结果0
    do{//{}内代码至少执行一次
        b += a;//将b和a相加的新值赋值给b
        a++;//a自增一次
    }while(a <= 0);
    System.out.println(b);//输出最终结果
}

效果演示图:

do...while循环

for循环

虽然所有循环结构都可以用while或者do…while表示, 但Java提供了另外一种语句------for循环, 使一些循环结构变得更加简单.

for循环语句是支持迭代的一种通用结构, 是最有效, 最灵活的循环结构.

for循环执行的次数是在执行前就确定的.

语法:

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

for循环有以下几点说明

执行初始化步骤, 可以声明一种类型, 但可初始化一个或多个循环控制变量. 也可以是空语句.
检测布尔表达式的值, 如果为true, 循环体被执行, 如果没false, 循环终止. 开始执行循环体后面的语句.
执行一次循环后, 更新循环控制变量(迭代因子控制循环变量的增减).
再次检测布尔表达式, 循环执行 2 以后的过程(包括 2 )

实例:

计算0-100之间的奇数和偶数的和

public static void main(String[] args) {
    
    //计算0-100之间的奇数和偶数他们各自的和
    int b = 0;//定义一个int类型变量b来储存奇数的和
    int c = 0;//定义一个int类型变量c来储存偶数的和
    
    for(int a = 1;a <=100;a++){//初始化a等于1(从1开始加);a小于等于100时循环继续;每次循环后a自增一次
        if(a % 2 == 1){//判断a模2余数是否为1
            b += a;//将当次循环a的值与当次循环b的值相加并将结果赋值给b
        }else{//余数不为1的时候执行
            c += a;//将当次循环a的值与单词循环b的值相加并将结果赋值给c
        }
    }
    
    System.out.println("奇数之和为: " + b + "\n偶数只之和为: " + c);//分别输出奇数和偶数之和------\n表示换行

}

效果演示图:

for循环计算奇数与偶数的和

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

public static void main(String[] args) {
    //用while或for循环输出1-1000之间能被5整除的数, 并且每行输出3个

    String b = "";//定义字符串类型变量b并初始化为空串------用来储存能除5的数字, 同时只有字符串能通过 + 拼接
    int c = 0;//定义int类型变量c并初始化赋值0------用来记录输出了几个能被5整除的数字
    for(int a = 1;a <= 1000;a++){//定义int类型变量a初始化数字为1(从1开始找能被5整除的数字);a 小于等于1000时循环继续;每次循环后a自增一次

        if(a % 5 == 0){//判断当次循环内a是否能被5整除

            b += (a + "\t");//当a能被5整除时将a的值加上\t(表示制表符,可以使文本看起来更美观)负值给b------a加"\t"的时候类型已经变成了字符串类型,如果b不是字符串类型会报错
            c++;//当a能被5整除时c自增一次
            if(c % 3 == 0){//判断当次循环内c是否没被3整除

                System.out.println(b);//当c能被3整除时输出b------完成了每行输出3个数字
                b ="";//当c能被3整除时将b重新变成空串方便记录下一行三个数字------黑心老板重复利用小b,傻白甜小b持续被利用中

            }

        }

    }
    System.out.println(b);//最后输出一次傻白甜小b------最后两个数字是990和1000没有第三个数字所以c的值是2代码块内不执行.

}

效果演示图:

for循环输出能被5整除的数

打印九九乘法表

public static void main(String[] args) {
    //打印九九乘法表
    for(int a = 1;a <= 9;a++){//定义int类型变量a初始化赋值1;a小于等于9是循环继续;当次循环后a自增一次
        for(int b = 1;b <= a;b++){//定义int类型变量b初始化赋值1;b小于等于a是循环继续;当次循环后b自增一次
            System.out.print(b + "×" + a + "＝" + (a*b) + "\t");//输出惩罚等式 a×b＝a*b------print是输出到控制台,\t是制表符,都能让结构看起来更美观
        }
        System.out.println();//输出到控制台并换行------加上ln输出内容就会自动换行
    }

}

效果演示图:

for循环嵌套打印九九乘法表

在Java5中引入了一种主要用于数组的增强型for循环

数组重点使用

java增强for循环语法格式如下:

语法:

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

声明语句: 声明新的局部变量, 该变量的类型必须和数组元素的类型匹配. 其作用域限定在循环语句块, 其值与此时数组元素的值相等.

表达式: 表达式是要访问的数组名, 或者是返回值为数组的方法

实例:

public static void main(String[] args) {

    int[] arr = {10,20,30,40,50};//定义了一个数组

    for(int i = 0;i < 5;i++){//定义int类型变量; i小于5时循环继续; 循环一次后i自增一次
        System.out.println(arr[i]);//当次循环向控制台输出数组arr索引位置[i]所储存的值
    }
    System.out.println("===========分割线==========");//输出分割线

    //遍历数组的元素
    for(int x : arr){//定义int类型变量储存名为arr的数组所有索引的值
        System.out.println(x);//输出变量x------也就是整个数组的值
    }

}

效果演示图:

增强for循环

break & continue

break在任何循环语句的主体部分, 均可用break控制循环的流程. break用于强行退出循环, 不执行循环中剩余的语句. (break语句也在switch语句中使用)

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

实例:

public static void main(String[] args) {

    int i = 0;//定义int类型变量i初始化赋值0
    while(i < 100){//i小于100时循环继续

        i++;//i自增一次
        if(i % 10 == 0){//i模10没有余数的时候执行
            System.out.println("此处跳过并换行, 此处未输出的值为: " + i);//输出提示语
            continue;//跳过此次循环,直接进行循环的布尔表达式判断
        }
        System.out.print(i + "\t");//输出i的值-----加上\t制表符使输出更整洁

    }

}

效果图演示:

continue使用

可以看到if判断的代码块执行后continue之前的输出执行了,continue之后的所有代码包括代码块外的语句也没有执行

关于goto关键字

goto关键字很早就在程序设计语言中出现, 尽管goto仍是Java的一个保留关键字, 但并未在语言中的到正式使用; Java没有goto. 然而, 在break和continue这两个关键字的身上, 我们仍然能看出一些goto的影子—代标签的break和continue.

"标签"是指后面跟一个冒号的标识符, 例如: label:

对Java来说唯一用到的标签的地方是在循环语句之前, 而在循环之前设置标签的唯一理由是: 我们希望在其中嵌套另一个循环,犹豫break和continue关键字通常只中断当前循环, 但若随同标签使用, 它们就会中断到存在标签的地方.

输出两个数之间的所有质数

实例:

public static void main(String[] args) {

    //输出101到150之间的所有质数
    //一个数如果只能被1或者它自己整除,那么它就是质数
    z:for (int i = 101; i < 150; i++) {//在开头做一个z:标签,配合之后的continue z;

        for (int j = 2; j < i/2; j++) {//定义被除的数字循环, i除二分之一是因为一个数的最大商除了他自己以外就是他自己的平方根,而平方根是不可能超过一个数的二分之一的,最多只能相等

            if(i % j == 0){//开始检测i模j是否有余数,如果没有余数则执行
                continue z;//跳回到z:标签处开始执行代码
            }

        }
        System.out.print(i + " ");//第二层for循环执行后没有跳过的数字就是计算出的数字,也就是需要输出的质数

    }

}

效果演示图:

continue标签的用法

输出三角形

实例:

public static void main(String[] args) {

    //打印三角形
    for (int i = 1; i <= 5; i++) {//用于输出换行,五次换行

        for (int j = 5; j >= i; j--) {//占据三角形左边的空白的空格,第一层输出五个空格
            System.out.print(" ");//输出空白部分空格
        }
        for(int j = 1; j < i * 2; j++) {//输出三角形的本体,j < i * 2是关键
            // 是精髓,
            System.out.print("*");//输出三角形主体
        }
        System.out.println();//输出换行

    }

}

效果演示图:

在这里插入图片描述

耀匙

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
流程控制_顺序结构_选择结构_if单选择结构_if双选择结构_if多选择结构_嵌套的if结构_switch多选择结构_循环结构_while循环_do...while循环_for循环_增强for循环

由此可得知, 当有一个条件达成时, 且没有退出switch判断时后续的所有case内的代码都将执行, 直到退出switch判断或执行完所有case时停止;布尔表达式为true则执行代码块**( {} 由正反大括号组成的结构也叫做代码块)**内的语句,布尔表达式为false则跳过代码块内容。可以看到if判断的代码块执行后continue之前的输出执行了,continue之后的所有代码包括代码块外的语句也没有执行。0-100之间的奇偶数的和__1-1000之间能被5整除的数_九九乘法表_打印三角形.....
复制链接

扫一扫