3.分支循环，数组

不知道为什么换名字

已于 2022-11-12 17:49:12 修改

阅读量190

点赞数

文章标签： java

于 2022-11-10 20:46:52 首次发布

本文链接：https://blog.csdn.net/qq_51748637/article/details/127795497

版权

JAVA学习专栏专栏收录该内容

12 篇文章 0 订阅

订阅专栏

1.5 break,continue 关键字

1.分支循环

分支结构有 if 和 switch
循环条件有 for 和 while

1.1 if

全条件分支：
        if(  /* condition 1*/){
            //order1 ;
        } 
        else if (   /* condition 2*/) {
            //order2 ;
        }
        //...else if (   /* condition N*/){}
        else {
            //order N+1 ;
        }
if ( 逻辑表达式1 /* == true */) {

指令1

}

else if ( 逻辑表达式2 /* == true */) {

指令2

}

//....表示中间可能有很多其他的 else if

else {

指令n

}

1.1.1 单分支 if

if ( 逻辑表达式1 /* == true */) {

指令1

}

如果输入的条件满足，那么就执行方法体的指令，否则不执行

public class test {
    public static void main(String[] args) {
                 
        if( 1 + 1 == 2){
            System.out.println("条件为真");
        }
    }
    
}

1.1.2 多分支 if-else if

if ( 逻辑表达式1 /* == true */) {

指令1

}

else if ( 逻辑表达式2 /* == true */) {

指令2

}

如果输入的条件满足，那么就执行方法体的指令（下面的条件就不会判断）
不满足则一直向下陆续判断条件，直到出现为止
如果都不满足，则不执行

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

        if( 1 + 1 == 3){
            System.out.println("条件1为真");
        }
        else if( 1 + 1 == 2 ){
            System.out.println("条件2为真");
        }
    }

}

1.1.3 else

用于单分支或多分支之后的补充，相当于一种条件的补集（所有条件不满足必然执行）

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

        if( 1 + 1 == 3){
            System.out.println("条件1为真");
        }
        else if( 1 + 1 == 1 ){
            System.out.println("条件2为真");
        }
        else {
            System.out.println("以上都不对");
        }
    }

}

1.2 switch

对于 if 循环，如果分支过多或者所有逻辑条件的被判断语句（变量1 == 变量2(或整型常量)）变量1相同且变量2为整型（case 的接收端不能为小数），即可使用switch结构
        switch ( /*(int)Calculate*/ ){
            case /*(int)result 1*/ :
                //order 1;
                break;
            case /*(int)result 2*/:
                //order 2;
                break;
            //...
            case /*(int)result N*/:
                //order N;
                break;
            default:
                // order N+1;
        }

1.2.1 switch中表达或情况

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

        //键盘输入一个字符，判断输出字符还是数字
        java.util.Scanner scanf = new java.util.Scanner(System.in);
        char ch = scanf.next().charAt(0);

        switch (ch){
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                System.out.println("输入的是数字");break;
            case 'a':
            case 'b':
            case 'c':
            case 'd':
            case 'e':
            case 'f':
            case 'g':
            case 'h':
                System.out.println("输入的是字符");break;
            default:
                System.out.println("其他");break;
        }
    }

}

1.2.2 switch的一些性质

        switch ( 16/7){
            case 2:
                System.out.println("switch 的表达式 输入端的计算类型被转换成int"); //会输出这个
                break;
            case 1:
            case 0:
                break;
            default:System.out.println("switch 的表达式 输入端的计算类型被转换成float");
        }

从上面的例子可以看出，switch和case会把后面跟随的变量或常量转换到int类型进行比较

1.3 for

带初始化的一种循环机制

1.3.1 普通for循环

可以提供下角标，支持数组索引遍历

        for(/* Init */ ; /*condition*/ ;/*order 2*/){
            //order 1 
        }
//Init 循环开始前初始化赋值(如果在这里创建变量，该变量为局部变量，生命周期为循环体内)，只会执行一次
//condition 循环开始和继续 的逻辑条件
//order 1 循环中满足一次条件就执行一次的指令1
//order 2 每执行完一次就会执行一次条件2
//for内如果有多个语句用逗号间隔，order2可以为空

循环如下：

//1. 初始化(for区域1)
//2. 判断条件condition(for区域2)

/*第1次进入循环*//*

3. 执行order 1(若满足)
4. 执行order 2
5. 判断条件condition(for区域2)

*//*第2次进入循环*//*

6. 执行order 1(若满足)
7. 执行order 2
8. 判断条件condition(for区域2)

*/...

..../*第N次进入循环*//*

3N. 执行order 1(若满足)
3N+1. 执行order 2
3N+2. 判断条件condition(for区域2) // 不满足则跳出

*/

1.3.2 增强for循环

全遍历for循环，底层是迭代器，可以用于实现set接口类对象实例的遍历
        for(/*ClassName*/ /*element*/:/*Collection*/){
            //Order 1；
        }

1.4 while

1.3.1 普通while

先判断再执行

        while ( /*condition*/){
            //Order ;
        }

循环机制

//1. 判断条件condition

/*第1次进入循环*//*

2. 执行order 1(若满足)

3.判断条件condition

*//*第2次进入循环*//*

4. 执行order 1

5.判断条件condition

*/...

..../*第N次进入循环*//*

2N-1. 执行order 1
2N. 判断条件condition // 不满足则跳出

*/

1.3.2 do-while

先执行再判断

        do{
            //Order ;
        
        }while ( /*condition*/)