[Java]分支和循环

目录

顺序结构

分支结构

if语句：

Switch语句： 

switch其他知识点：

default的位置和省略：

case穿透： 

switch新特性：

switch和else if的使用场景：

循环结构

for循环：

while循环：

do...while循环：

三种循环的用法：

---

顺序结构

按照代码的先后顺序，依次执行，形如：

package day5;

public class test1 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = a>b?a:b;
        System.out.println(c);
    }
}

分支结构

if语句：

格式：
if (关系表达式) {
    语句体;    
}

执行流程：

1. 计算关系表达式的值，
2. 关系表达式的值为true就执行语句体
3. 关系表达式的值为false就不执行语句体，继续执行后面的语句内容

import java.util.Scanner;

public class ifdemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("enter the wine!");
        int wine = sc.nextInt();

        if (wine >= 20) {
            System.out.println("niubi");
        }else {
            System.out.println("bu xing a");
        }
    }
}

注：

1. 如果我们要对一个布尔类型的变量进行判断，不要写==，直接把变量写在小括号中即可。

2. 如果大括号中的语句体只有一条，那么大括号可以省略不写

   如果大括号省略了，那么if只能控制距离他最近的那一条语句。

if...else...

格式：
if (关系表达式) {
    语句体1;    
} else {
    语句体2;    
}

public class Elseif {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int money = sc.nextInt();
        if (money >= 100) {
            System.out.println("豪华大餐");
        }else{
            System.out.println("穷鬼套餐");
        }
    }
}

if...else if...

格式：
if (关系表达式1) {
    语句体1;    
} else if (关系表达式2) {
    语句体2;    
} 
…
else {
    语句体n+1;
}

import java.util.Scanner;

public class Test7 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入：");
        int score = sc.nextInt();
        if (score > 100){
            System.out.println("error");
        }else if (score == 100) {
            System.out.println("好孩子!");
        }else if (score >= 90 && score < 100) {
            System.out.println("中孩子!");
        }else {
            System.out.println("坏孩子!");
        }
    }
}

if：单条件判断

if...else...:双条件判断

if...else if...else: 多条件判断

Switch语句： 

switch (表达式) {
    case 1:
        语句体1;
        break;
    case 2:
        语句体2;
        break;
    ...
    default:
        语句体n+1;
        break;
}

表达式可取的值类型：byte、short、int、char

case：后跟与表达式匹配的值，值只能是常量，不能为变量，不能重复

default：没有case的值与之对应执行default

执行流程：

1. 首先计算出表达式的值

2. 和case依次比较，一旦有对应的值，执行相应的语句，遇到break结束。

3. 最后如果所有的case都和表达式的值不匹配执行default语句，程序结束。

import java.util.Scanner;

public class Test9 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();

        switch (a) {
            case 1:
                System.out.println("跑步");
                break;
            case 2:
                System.out.println("游泳");
                break;
            default:
                System.out.println("error");
                break;
        }
    }
}

switch其他知识点：

default的位置和省略：

1.位置：可以在任意位置不一定在最下面

2.省略：可以省略，语法不会有问题不建议省略

case穿透： 

语句中没写break时就会发生case穿透。

没有写break时：首先case的值还会和小括号中的值进行匹配，如果匹配上了就执行语句体，发现break就结束整个switch语句。如果没有发现break就继续执行下一个case语句体直到遇到break为止或者switch语句结束。

使用场景：多个case的语句体重复了，就考虑利用case穿透简化代码

import java.util.Scanner;

public class Test12 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        switch (a) {
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("工作日");
                break;
            case 6:
            case 7:
                System.out.println("休息日");
            default:
                System.out.println("ERROR");
                break;
        }
    }
}

jdk12中利用switch新特性的写法： 

import java.util.Scanner;

public class Test13 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        switch (a) {
            case 1,2,3,4,5 -> System.out.println("工作日");
            case 6,7 -> System.out.println("休息日");
            default -> System.out.println("ERROR");
        }
    }
}

switch新特性：

条件：jdk12+ 版本以上

不用之前繁琐的写法，也不会发生case穿透。简化switch的书写

package day5;

import java.util.Scanner;

public class Test10 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        switch (a) {
            case 1 -> System.out.println("1");
            case 2 -> System.out.println("2");
            case 3 -> System.out.println("3");
            case 4 -> {
                System.out.println("4");
            }
            default -> {
                System.out.println("没有此选项");
            }
        }
    }
}

switch和else if的使用场景：

else if：用于对范围的判断

switch：数据列举出来任选其一

循环结构

循环：反复执行一段代码逻辑知道循环条件判断语句为false值时循环结束，若一直为true就为死循环

for循环：

for (初始化语句;条件判断语句;条件控制语句) {
    循环体语句;
}

初始化语句：循环的开始只执行一次

条件判断语句：为true循环继续，为false循环结束

条件控制语句：控制循环中初始化语句的变化

循环体语句： 循环反复执行的内容

//短线重连
public class Test15 {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 5; i >= 0; i--) {
            System.out.println("正在重新链接,"+i+"秒后结束！");
            Thread.sleep(200);
        }
    }
}

while循环：

初始化语句;
while(条件判断语句){
    循环体;
    条件控制语句;
}

public class Test19 {
    public static void main(String[] args) {
        double height = 8844430.0;
        double paper = 0.1;
        int count = 0;
        while(paper<height){
            paper = paper*2;
            count++;
        }
        System.out.println(count);
    }
}

do...while循环：

特点： 至少执行一次

public class Test20 {
    public static void main(String[] args) {
        int a = 10;
        do{
            System.out.println("hello");
        }while (a>11);
    }
}

三种循环的用法：

for和while循环，是先判断，再执行。

do...while是先执行，再判断。

当知道循环次数或者循环范围的时候，用for循环。

当不知道循环次数，也不知道循环范围，但是知道循环的结束条件时，用while循环。