选择结构与分支结构 | 我的日常分享

选择结构与分支结构

发表于2022-01-20更新于2022-01-20字数统计1.9k阅读时长23分

选择结构与分支结构

  • 选择结构概念：根据已知条件进行逻辑判断，满足条件后执行相应的操作。

一、基本if选择判断

  • 语法

    1
    2
    3
    4
    if(布尔表达式){
    	//代码块
    }
    //后续代码...

  • 执行流程

    1. 对布尔表达式进行判断。
    2. 结果为true，则先执行代码块，在执行后续代码。
    3. 结果为false，则跳过代码块，直接执行后续代码。

案例1：

1
2
3
4
5
6
7
8
public class TestBasicIf{
    public static void main(String[] args) {
        if(3 > 4){
            System.out.println("if代码块");
        }
        System.out.println("程序结束");
    }
}

运行结果：

image-20220119211529269

由于3>4表达式结果为false，if内语句则为执行，执行后续代码，因此输出结果为程序结束。

案例2：

1
2
3
4
5
6
7
8
9
public class TestBasisIf{
    public static void main(String[] args) {
        double score = 97.2;
        if(score >= 90.0){
            System.out.println("恭喜你，你的成绩优秀");
        }
        System.out.println("程序结束");
    }
}

运行结果：

image-20220119211835676

由于score=97.2大于90，所以表达式score>=90.0的结果为true，进入执行if内代码，执行完后再执行后续代码，所以输出结果为恭喜你，你的成绩优秀 程序结束。

二、if else选择结构

  • 语法

    1
    2
    3
    4
    5
    6
    if(布尔表达式){
        //代码块1
    }else{
        //代码块2
    }
    //后续代码

  • 执行流程

    1. 对布尔表达式进行判断。
    2. 结果为true，则先执行代码块1，再退出整个结构，执行后续代码。
    3. 结果为false，则先执行代码块2，再退出整个结构，执行后续代码。

    两个代码块互斥，总有一个会被执行到。

案例：

1
2
3
4
5
6
7
8
9
10
11
public class TestIfElse{
	public static void main(String[] args){
		double score = 99.0;
		if(score == 100.0){
			System.out.println("恭喜你，满分");
		}else{
			System.out.println("很遗憾，没有满分");
		}
		System.out.println("程序结束");
	}
}

运行结果：

image-20220119212944106

由于score=99.0不等于100，所以表达式score==100结果为false，则执行else中的代码块2，所以输出结果为很遗憾，没有满分 程序结束。

三、多重if选择结构

  • 语法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    if(布尔表达式1){
        //代码块1
    }else if(布尔表达式2){
        //代码块2
    }else if(布尔表达式3){
        //代码块3
    }else{
        //代码块4
    }

  • 执行流程

    1. 表达式1为true，则执行代码块1，再退出整个结构，执行后续代码。
    2. 表达式为2true，则执行代码块2，再退出整个结构，执行后续代码。
    3. 表达式为3true，则执行代码块3，再退出整个结构，执行后续代码。
    4. 以上均为false，则执行代码块4，再退出整个结构，执行后续代码。

    注意：相互排斥，有一个为ture,其他均不在执行，适用于区间判断。

案例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class TestMultipleIf{
	public static void main(String[] args){
		/*
			根据分数判断等级
			分数>=90 优秀
			分数>=80 良
			分数>=60 一般
			分数<60 不及格
		*/
		double score = 78;
		if(score>=90){
			System.out.println("优秀");
		}else if(score>=80){
			System.out.println("良");
		}else if(score>=60){
			System.out.println("一般");
		}else{
			System.out.println("不及格");
		}
		System.out.println("程序结束");
	}
}

运行结果：

image-20220119214347984

三、嵌套if选择结构

  • 语法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    if(外层表达式){
        if(内层表达式){
            //内层代码块1
        }else{
            //内层代码块2
        }
    }else{
        //外层代码块
    }

  • 执行流程

    1. 当外层条件满足时，再执行内层判断。

    注意：

    • 一个选择结构中，可嵌套另一个选择结构
    • 嵌套格式正确的情况下，支持任意组合

案例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class TestNestedIf{
	public static void main(String[] args){
		/*
			数学、英语、语文成绩均大于90，为优秀。
		*/
		double math = 94.8;
		double english = 92.3;
		double chinese = 89.4;
		if(math >=90){
			if(english >= 90){
				if(chinese >= 90){
					System.out.println("您成绩都非常优秀");
				}else{
					System.out.println("英语不优秀");
				}
			}else{
				System.out.println("英语不优秀");
			}
		}else{
			System.out.println("数学不优秀");
		}
		System.out.println("程序结束");
	}
}

运行结果：

image-20220120144737846

四、switch分支结构

  • 语法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    switch(变量|表达式){
        case 值1:
            逻辑代码1;
        case 值2:
            逻辑代码2;
        case 值n:
            逻辑代码n;
        default:
            未满足以上条件时的逻辑代码;
    }

  • 可判断的类型

    byte、short、int、char、String(JDK7+)

  • 执行流程

    1. 如果变量中的值等于值1，则执行逻辑代码。
    2. 如果变量中的值等于值2，则执行逻辑代码2。
    3. 如果变量中的值等于值n，则执行逻辑代码n。
    4. 如果变量中的值没有匹配的case值时，执行default中的逻辑代码。

  • 注意：当匹配的case执行后，不会自动退出整个结构，而是继续往下执行。如需退出需要添加break关键字。

案例1：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class TestSwitch{
	public static void main(String[] args){
		/*
			根据数字输出星期几
		*/
		int weekDay =5;
		switch(weekDay){
			case 1:
				System.out.println("星期一");
			case 2:
				System.out.println("星期二");
			case 3:
				System.out.println("星期三");
			case 4:
				System.out.println("星期四");
			case 5:
				System.out.println("星期五");
			case 6:
				System.out.println("星期六");
			case 7:
				System.out.println("星期天");
			default:
				System.out.println("输入错误");
		}
	}
}

运行结果：

image-20220120150352343

会发现weekDay与5匹配后，不仅将case为5的代码执行了，后续代码都相应执行了，这是没有添加break退出结构。

案例2：解决案例1问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class TestSwitch{
	public static void main(String[] args){
		/*
			根据数字输出星期几
		*/
		int weekDay =5;
		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;
		}
	}
}

运行结果：

image-20220120150724931

五、局部变量的特点与注意事项

  • 概念：声明在方法内部的变量，必须先赋值再使用。未赋值使用将会报错错误: 可能尚未初始化变量num

以上代码均在main主方法中写的，所以声明都是局部变量。

  • 作用范围：定义行开始到所在的代码块结束。

  • 注意：多个变量，在重合的作用范围内，不能出现重名（命名冲突）。

    案例1：

1
2
3
4
5
6
public class TestLocalVariable{
    public static void main(String[] args){
        int a;
        System.out.println(a);
    }
}

运行结果：

image-20220120152202697

局部变量未赋值直接使用报错。

案例2：

1
2
3
4
5
6
7
8
public class TestLocalVariable{
    public static void main(String[] args){
        {
            int b=10;
        }
        System.out.println(b);
    }
}

运行结果：

image-20220120152354223

局部变量作用范围，定义行开始到所在的代码块结束。案例中int b=10的作用范围在{}中，因此System.out.println(b);无法访问到b。

案例3：命名冲突

1
2
3
4
5
6
7
8
9
public class TestLocalVariable{
	public static void main(String[] args){
		int c = 12;
		if(3>4){
			int c = 5;
			System.out.println(c);
		}
	}
}

运行结果：

image-20220120152656750

这是因为在第三行定义的变量c的作用范围在if语句中，与if语句中第五行定义的变量名一致冲突报错。