分支语句解读

最新推荐文章于 2024-10-01 09:29:45 发布

帝泊荒

最新推荐文章于 2024-10-01 09:29:45 发布

阅读量152

点赞数

分类专栏：自学文章标签： java 开发语言 eclipse

本文链接：https://blog.csdn.net/qq_43813308/article/details/121568189

版权

自学专栏收录该内容

8 篇文章 0 订阅

订阅专栏

分支结构

一、分支结构

1、if-esle语句

格式1：

//    if(条件表达式){
//       执行代码块;
//    }

**执行流程：**首先判断关系表达式看其结果是true还是false，如果是true就执行语句体，如果是false就不执行语句体。

格式2：

//if(条件表达式){
//        执行代码块;
//    }else{
//        执行代码块;
//    }

**执行流程：**首先判断关系表达式看其结果是true还是false，如果是true就执行语句体1，如果是false就执行语句体2。

格式3：

//if(条件表达式){
//        执行代码块；
//    }
//else if (条件表达式){
//        执行代码块；
//    }
//……
//        else{
//        执行代码块；
//    }

**执行流程：**首先判断关系表达式1看其结果是true还是false，如果是true就执行语句体1，如果是false就继续判断关系表达式2，看其结果是true还是false，如果是true就执行语句体2，如果是false就继续判断关系表达式…看其结果是true还是false…如果没有任何关系表达式为true，就执行语句体n+1。

if语句例题：
从命令行参数接收小明的期末成绩。当成绩为100分时，奖励一辆BMW；当成绩为（80，99]时，奖励一个台iphone7Plus；当成绩为[60,80]时，奖励一本参考书；其它时，什么奖励也没有。

//        1.if语句例题
//        从命令行参数接收小明的期末成绩当成绩为100分时，奖励一辆BMW；
//        当成绩为（80，99]时，奖励一台iphone7Plus；
//        当成绩为[60,80]时，奖励一本参考书；其它时，什么奖励也没有。
//        Scanner scanner=new Scanner(System.in);
//        System.out.println("请输入你的成绩：");
//        int score=scanner.nextInt();
        int score=Integer.parseInt(args[0]);
        if(score==100){
            System.out.println("奖励一辆BMW");
        }
        if(score>80&&score<=99){
            System.out.println("奖励一台iphone7Plus");
        }
        if(score>=60&&score<=80){
            System.out.println("奖励一本参考书");
        }
        if(score<60){
            System.out.println("什么奖励也没有");
        }

int col = Integer.parseInt(args[0]);

1. int是java的基本数据类型，"int n"表示定义了一个int 型的变量n;
2. int n = Integer.parseInt(args[0]) 表示给定义的变量n 赋予一个初值为"Integer.parseInt(args[0])";
3. Integer.parseInt(args[0])中，Integer是java中的一个内置类，parseInt()是这个类的一个静态方法，
这个方法的作用是把括号里面的参数（args[0])转为int型的值，比如定义一个String a="123",这时"a"是一个字符串，不能进行数值计算，如果你要让"a"能进行数值计算，
你就可以用Integer.parseInt(a)这个函数把"a"转为int型再来进行数值计算。

if语句和三元运算符的互换

//if语句和三元运算符的互换
int a1=10;
int b1=20;
//定义变量，保存a和b的较大值
int c1;
if(a1>b1){c1=a1;}
else{c1=b1;}
//可以上述功能改写为三元运算符形式
c1=a1>b1?a1:b1;
System.out.println(c1);

2、switch语句

语法：

//switch(变量){
//        case 常量1:
//        语句1;
//        break;
//        case 常量2:
//        语句2;
//        break;
//        … …
//        case 常量N:
//        语句N;
//        break;
//default:
//        语句;
//        break;
//        }

**执行流程：**首先计算出表达式的值其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

switch 使用规则：

switch(表达式)中表达式的返回值必须是下述几种类型之一：byte，short，char，int，String, 枚举；
case子句中的值必须是常量，且所有case子句中的值应是不同的；
default子句是可任选的，当没有匹配的case时，执行default
break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾
switch 和 if的区别：

如果判断的具体数值不多，而且符合byte、 short 、int、 char这四种类型。虽然两个语句都可以使用，建议使用switch语句。因为效率稍高。
其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。
switch练习：

//定义变量，判断是星期几
int weekday=6;
//switch语句实现选择
switch(weekday){
    case 1:
        System.out.println("星期一");
        break;
    case 2:
        System.out.println("星期二");
        break;
    case 3:
        System.out.println("星期三");
        break;
    case 4:
        System.out.println("星期四");
        break;
    case 5:
        System.out.println("星期五");
        break;
    case 6:
        System.out.println("星期六");
        break;
    case 7:
        System.out.println("星期日");
        break;
    default:
        System.out.println("你输入的数字有误");
        break;}

二、循环结构

循环语句分类：

while 循环
do/while 循环
for 循环 foreach

1、while 循环语句

1、语法格式

//[初始化语句]
//        while( 布尔值测试表达式)｛
//        语句或语句块;
//        [更改语句;]
//        }

2、应用案例：

public class WhileLoop {

public static void main(String[] args) {
	//1、初始化语句，进行循环前的准备
	int result = 0;
    int i=1;
    
    //2、循环条件,决定循环生死
	while(i<=5) {  // 循环的次数 = 条件后面的值 - 初始化值
		//3、循环体：被多次执行的语句块
        result += i;
        //4、迭代语句：使循环趋于结束
        i++;
	}
	System.out.println("result=" + result);
	System.out.println("i:"+i);
}

2、do—while循环

语法：

//[初始化语句]
//         do｛
//         语句或语句块;
//         [更改语句;]
//         ｝while(布尔值测试表达式);

先执行do中内容，然后在判断while()中条件是否满足，若满足则继续执行do中的语句块

应用案例：

public class DoWhileLoop1 {
    public static void main(String[] args) {
        int result = 0;
        // 初始语句
        int i = 1;
        do {
            // 循环体
            result += i;
            // 迭代语句
            i++;
        } while (i <= 5);// 条件判断

        System.out.println("result:" + result);
        System.out.println("i:" + i);
    }
}

3、for循环

语法：

//for(int i = 0; i< n; i++){
//        语句块
//        }

当i = 0 时候满足 i< n 条件，执行语句块，然后i +1;此时判断i+1 和 n的关系，若i+1<n，继续执行语句块，反反复复，直到i++不在满足条件，退出循环。

应用案例：求10以内的所有偶数的和*

int sum=0;
for (int i1= 0; i1 < 10; i1++) {
    if(i1%2==0){
        sum=sum+i1;
    }
}
System.out.println("10以内的偶数和为："+sum);

for和while的小区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while。

4、特殊流程控制语句

1、continue语句

continue语句用于跳过某个循环语句块的一次执行
continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
案例：

//public class ContinueTest1 {
//    public static void main(String args[]) {
//        for (int i = 0; i < 100; i++) {
//            if (i % 2 == 0){
//                continue;//结束当次循环，直接进行下一次循环（迭代语句i++）
//                //System.out.println("after continue"); 永远无法到达的语句
//            }
//            // 本来的目的就是义无反顾地执行下面的语句, 但是前面发生了点意外, 中止了.
//            System.out.println(i);
//        }
//    }
//}

2、break语句

break放在循环最后表示终止循环

5、补充

死循环：也就是循环中的条件永远为true，死循环的是永不结束的循环。例如：while(true){}。

嵌套循环：是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总共的循环次数=外循环次数*内循环次数

//for(初始化表达式①;循环条件②;步进表达式⑦){
//        for(初始化表达式③;循环条件④;步进表达式⑥){
//        执行语句⑤;
//        }
//        }

执行顺序：①②③④⑤⑥>④⑤⑥>⑦②③④⑤⑥>④⑤⑥外循环一次，内循环多次。比如跳绳：一共跳5组，每组跳10个。5组就是外循环，10个就是内循环。

增强for循环：

增强型for循环语法：for(ElementType element:arrayName){};

//举个例子:(1)
//        int[] numArray = { 1, 2, 3, 4, 5, 6 };
//        for (int i : numArray) {
//        System.out.print(i);
//        }
结果会是123456

System.out.println("===============5.增强for循环=================");
int [] array = {1,2,3};
for(int i2 : array){
    System.out.println(i2);
}
//for(int var17 = 0; var17 < var16; ++var17) {
//            int i2 = var15[var17];
//           System.out.println(i2);
//        }
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
for(Object obj : list){
    System.out.println(obj);
}
//Iterator var22 = list.iterator();
//        while(var22.hasNext()) {
//            Object obj = var22.next();
//            System.out.println(obj);
//        }
Map<String, String> map = new HashMap<>();
map.put("1", "1");
map.put("2", "2");
map.put("3", "3");
for (Map.Entry<String, String> stringStringEntry : map.entrySet()) {
    System.out.println(stringStringEntry.getKey() + stringStringEntry.getValue());
}

增强for循环删除问题：

迭代器内部的每次遍历都会记录List内部的modcount当做预期值，然后在每次循环中用预期值与List的成员变量modCount作比较，但是普通list.remove调用的是List的remove，这时modcount++，但是iterator内记录的预期值=并没有变化，所以会报错。

    System.out.println("===============5.增强for循环删除问题=================");
    List list1 = new ArrayList();
    list.add(1);
    list.add(2);
    list.add(3);
    for(Object obj : list1){
        System.out.println(obj);
        list.remove(obj);
    }
}