Java流程控制语句

接下来记录一下Java流程控制语句，包括条件语句（if-else）、选择语句（switch-case）和循环语句（while和for）。全文使用例子来记录，可以更好的理解上述流程控制语句。

流程控制语句

流程控制结构有顺序结构，分支结构和循环结构。

（1）顺序结构，代码从上到下从左到右执行

（2）分支结构，有if、if-else、if-else if，switch-case

（3）循环结构，有while，do-while和for

if

语法格式为：

if(逻辑判断){

代码块；

}

案例 判断一个数是奇数还是偶数，使用if可以完成。

import java.util.Scanner;
public class IfCase{
    public static void main(String[] args){
        //使用if判断一个数是奇数还是偶数
        Scanner scan=new Scanner(System.in);
        int inputNumber=scan.nextInt();
        if(inputNumber%2==0){
            System.out.println("这个数是偶数");
        }
        if(inputNumber%2==1){
            System.out.println("这个数是奇数");
        }
    }
}

测试结果

if是最简单的逻辑判断，如果有多个条件则需要写多个if判断。

if-else

语法格式为：

if(逻辑判断){

代码块1;

}else{

代码块2;

}

如果逻辑判断为true，则执行代码块1，否则执行代码块2。

案例：输入三个整数，得到三个数中的最大值。

import java.util.Scanner;
public class IfCase1{
    public static void main(String[] args){
        //使用if-else判断三个数中的最大数
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入三个整数");
        int a=scan.nextInt();
        int b=scan.nextInt();
        int c=scan.nextInt();

        //比较
        if(a>=b){
            if(a>=c){
                System.out.println("最大是为"+a);
            }else{
                System.out.println("最大是为"+c);
            }
        }else{
            if(b>=c){
                System.out.println("最大是为"+b);
            }else{
                System.out.println("最大是为"+c);
            }
        }
    }
}

测试结果

if-else整体上让代码看上去有两条分支。

if-else if 

语法格式为：

if(逻辑判断1){

代码块1;

}else if(逻辑判断2){

代码块2;

}

... 

else{

最后代码块;

}

案例：根据分数大小定等级，如90→A，80→B，70→C等，这个如果用if-else来实现，会显得代码可阅读性很差，使用if-else if效果更好。

 1 import java.util.Scanner;
public class IfCase2{
    public static void main(String[] args){
        //使用if-else if来输出分数的等级
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入分数");
        int score=scan.nextInt();

        //给分数分级
        if(score>100||score<0){
            System.out.println("非法的分数");
        }else if(score>=90){
            System.out.println("A");
        }else if(score>=80){
            System.out.println("B");
        }else if(score>=70){
            System.out.println("C");
        }else if(score>=60){
            System.out.println("D");
        }else{
            System.out.println("E");
        }
    }
}

测试结果

if-else if代码看起来更加的有层次感，可读性较好，另外如果if或者else中代码块只有一句话，大括号可以省略。

switch-case

语法格式为：

switch(选项){

　　case 选项1: 代码块1;break;

　　case 选项2: 代码块2;break;

　　case 选项3: 代码块3;break;

　　...

　　default: 代码块;break;

}

案例1：根据输入的数字1~7，输出对应的星期英文名。

import java.util.Scanner;
public class SwitchCase{
    public static void main(String[] args){
        //使用switch-case语句输出星期
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入数字1~7");
        int num=scan.nextInt();
        
        //先限定
        if(num<1||num>7){
            System.out.println("不是范围内数字");
            return;
        }

        switch(num){
            case 1:
            System.out.println("Monday");
            break;

            case 2:
            System.out.println("Tuesday");
            break;

            case 3:
            System.out.println("Wednesday");
            break;

            case 4:
            System.out.println("Thursday");
            break;

            case 5:
            System.out.println("Friday");
            break;

            case 6:
            System.out.println("Saturday");
            break;
            //case 7 最后一个写成default也可以，前面加个限定就行
            default:
            System.out.println("Sunday");
            break;
        }
    }
}

测试结果

switch-case中，switch中的选项只能是byte，short，char和int，在JDK1.7之后可以使用String。另外break的位置对执行结果也有影响，case后的条件满足，就寻找到了程序入口，代码块什么时候停由后面的break决定，或者执行到最后停止，具体参考如下案例。

案例2：输入月份，判断这个月有多少天。

import java.util.Scanner;
public class MonthDay{
    public static void main(String[] args){
        //灵活使用break的位置
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入月份");
        int month=scan.nextInt();
        //只考虑break的用法暂时不考虑是否严谨
        switch(month){
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
            System.out.println("这个月有31天");
            break;

            case 4:
            case 6:
            case 9:
            case 11:
            System.out.println("这个月有30天");
            break;

            //暂时按照28天来处理
            case 2:
            System.out.println("这个月有28天");

            default:
            System.out.println("输入月份不合法");
        }
    }
}

测试结果

案例3：根据输入的年月日，计算这天在这一年中是第多少天。

import java.util.Scanner;
public class DayCalculate{
    public static void main(String[] args){
        //计算这天是第多少天
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入年");
        int year=scan.nextInt();
        System.out.println("请输入月");
        int month=scan.nextInt();
        System.out.println("请输入日");
        int day=scan.nextInt();

        //临时变量
        int sum=0;

        //年的作用是为了判断2月有多少天，日的作用是判断当月的天数，月的作用是判断前几个月一共有多少天
        switch(month){
            //进入多少月份，先计算这个月前面月份的总天数
            case 12:sum+=30;
            case 11:sum+=31;
            case 10:sum+=30;
            case 9:sum+=31;
            case 8:sum+=31;
            case 7:sum+=30;
            case 6:sum+=31;
            case 5:sum+=30;
            case 4:sum+=31;
            //3月进入，需要看2月的天数，需要判断闰年和平年
            case 3:
            if(year%400==0||(year%4==0&&year%100!=0)){
                sum+=29;
            }else{
                sum+=28;
            }
            case 2:sum+=31;
            case 1:sum+=0;
            //break可以不用加
            break;
        }
        //输出
        System.out.println("这是"+year+"年的第"+(sum+day)+"天");
    }
}

测试结果

while 

语法格式为：

while(逻辑值){

　　代码块;

　　新的逻辑值;
}

逻辑值为true，才能执行代码块，然后更新逻辑值再次判断是否为true，如此反复循环，适用于不知道次数的循环案例。

案例1：输入5个数，得到其中最大的值。

import java.util.Scanner;
public class GetMaxNumber{
    public static void main(String[] args){
        //使用while循环
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入5个数");
        int max=scan.nextInt();
        int count=0;
        while(count<4){
            int num=scan.nextInt();
            if(max<num){
                max=num;
            }
            count++;
        }
        //输出
        System.out.println("最大的值是"+max);
    }
}

测试结果

案例2：输入一个整数，判断它是一个几位数，如输入98999，得到5位数的结果。

import java.util.Scanner;
public class GetBitNumber{
    public static void main(String[] args){
        //判断一个数有多少位
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入一个整数");
        int num=scan.nextInt();
        int bitNum=0;//位数
        //int 
        while(true){
            num=num/10;
            if(num>0){
                bitNum++;
            }
            if(num==0){
                bitNum++;
                break;
            }
        }
        System.out.println("这个数位数为"+bitNum);
    }
}

测试结果

案例3：输入一个整数，打印这个数的所有因数，如输入8，需打印出1，2，4，8。

import java.util.Scanner;
public class GetFactor{
    public static void main(String[] args){
        //判断一个数的所有公约数
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入一个整数");
        int num=scan.nextInt();
        int index=1;
        while(index<=num){
            if(num%index==0){
                System.out.print(index+" ");
            }
            index++;
        }
        System.out.println();
    }
}

测试结果

while循环使用比较多，还有一个do-while循环，这个用的比较少，就先不说明了，反正是不管while中逻辑判断是否满足，都至少需要执行完一次do中的代码块。 

for

语法格式为：

for(循环变量定义:控制条件:循环变量变化){

　　代码块;

}

接下来使用打印星星来理解for循环。

案例1：打印一个星星图案，要是直角三角形的，再倒过来打印。

案例2：打印一个星星图案，要是菱形。

public class DrawTriangle{
    public static void main(String[] args){
        //1 打印一个直角三角形，左边直角
        for(int i=1;i<=8;i++){
            for(int j=1;j<=i;j++){
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println();

        //2 将上面三角形倒过来
        for(int i=8;i>=1;i--){
            for(int j=i;j>=1;j--){
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println();

        //3 打印一个直角三角形，右边直角
        for(int i=1;i<=8;i++){
            //打印空格的次数
            for(int j=1;j<=8-i;j++){
                System.out.print(" ");
            }
            //打印星星的次数
            for(int j=1;j<=i;j++){
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println();

        //4 将上面三角形倒过来
        for(int i=8;i>=1;i--){
            //打印空格的次数
            for(int j=1;j<=8-i;j++){
                System.out.print(" ");
            }
            //打印星星的次数
            for(int j=1;j<=i;j++){
                System.out.print("*");
            }
            System.out.println();
        }

        //打印一个等腰三角
        for(int i=1;i<=8;i++){
            //打印空格的次数
            for(int j=1;j<=8-i;j++){
                System.out.print(" ");
            }
            //打印星星的次数
            for(int j=1;j<=i;j++){
                System.out.print("*"+" ");
            }
            System.out.println();
        }

        //5 打印一个等腰三角形，但是这个星星数是按照1 3 5 7 9增加，如下图所示
        /*
                *
            *    *    *
        *    *    *    *    *
            *    *    *
                *        
        */
        //上面四个例子其实已经给了提示，可以组合起来就是一个菱形
        for(int i=1;i<=8;i++){
            //打印左边
            //打印空格的次数
            for(int j=1;j<=8-i;j++){
                System.out.print(" ");
            }
            //打印星星的次数
            for(int j=1;j<=i;j++){
                System.out.print("*");
            }
            //打印右边，只打印出星星，空格可以不用管
            for(int j=1;j<=i-1;j++){
                //i-1:最左边的星星不需要打印
                System.out.print("*");
            }

            System.out.println();
        }
        //将上面三角形倒过来
        for(int i=8;i>=1;i--){
            //打印左边
            //打印空格的次数
            for(int j=1;j<=8-i;j++){
                System.out.print(" ");
            }
            //打印星星的次数
            for(int j=1;j<=i;j++){
                System.out.print("*");
            }
            //打印右边，空格的数目不需要管
            for(int j=1;j<=i-1;j++){
                //i-1:最左边的星星不打印
                System.out.print("*");
            }
            System.out.println();
        }
    }
}  

测试结果

break&continue关键字

break关键字用于switch-case和循环语句，用于终止当前层的循环，外层循环不受影响。

continue关键字也用于switch-case和循环语句，用于终止当前的循环逻辑，当前循环后面的代码不再执行，继续进行下一次循环。

案例1：break关键字使用

public class BreakDemo{
    public static void main(String[] args){
        //测试break
        for(int i=0;i<9;i++){
            System.out.println(i);
            if(i%2==1){
                break;
            }
        }
        //两层循环测试，只结束内存循环
        for(int i=0;i<9;i++){
            for(int j=0;j<9;j++){
                if(j%2==1){
                    break;
                }
                System.out.println(i+"|"+j);
            }
        }
    }
}

测试结果

可以看出break后，break所属层的代码都不再继续执行。

案例2：continue关键字使用

public class ContinueDemo{
    public static void main(String[] args){
        //测试continue
        for(int i=0;i<9;i++){
            if(i%2==1){
                continue;
            }
            System.out.println(i);
        }        
        //两层循环测试，只影响continue所在的循环
        for(int i=0;i<9;i++){
            for(int j=0;j<9;j++){
                if(j%2==1){
                    continue;
                }
                //如果是奇数，后面不再打印
                System.out.println(i+"|"+j);
            }
        }
    }
}

测试结果

可以看出，continue关键字使用后，当前循环逻辑终止，但是不影响下一个循环逻辑的继续执行，因此继续输出后面的偶数。

经典练习

（1）百钱百鸡，即用100文钱买100只鸡，具体参考代码解释

public class MoneyAndChick{
    public static void main(String[] args){
        //百钱白鸡 
        /**
        3文钱-1只公鸡
        2文钱-1只母鸡
        1文钱-3只小鸡
        */
        int numberCock;//公鸡数目
        int numberBiddy;//母鸡数目
        for(numberCock=0;numberCock<=33;numberCock++){
            for(numberBiddy=0;numberBiddy<=50;numberBiddy++){
                //小鸡一定是3的倍数
                if((100-numberCock-numberBiddy)%3==0){
                int price=numberCock*3+numberBiddy*2+(100-numberCock-numberBiddy)/3;
                //System.out.println("开始判断");
                if(price==100){
                    System.out.println("公鸡数"+numberCock);
                    System.out.println("母鸡数"+numberBiddy);
                    System.out.println("小鸡数"+(100-numberCock-numberBiddy));
                    System.out.println("---------------------分割线---------------------");
                }
                }
            }
        }                    
    }
}

（2）判断一个数是否为质数，这个代码有优化，以前是没考虑到一个数一半以后的数不需要考虑。

import java.util.Scanner;
public class PrimeNumber{
    public static void main(String[] args){
        //判断是否为质数
        System.out.println("请输入数字");
        Scanner scan=new Scanner(System.in);
        int number=scan.nextInt();
        //质数只能被1和本身整除，并且只需要比较2~number/2的即可，后面的数除了肯定是一点几的数，无需考虑
        boolean flag=true;
        for(int i=2;i<=number/2;i++){
            if(number%i==0){
                flag=false;
                break;
            }
        }
        if(flag){
            System.out.println(number+"是质数");
        }else{
            System.out.println(number+"不是质数");
        }
    }
}

（3）求一个数所有的质因数

import java.util.Scanner;
public class PrimeFactor{
    public static void main(String[] args){
        //求出一个数所有的质因数
        /**
        质因数：因数全为质数
        */
        System.out.println("请输入一个数");
        Scanner scan=new Scanner(System.in);
        int number=scan.nextInt();
        for(int factor=2; number!=1; ){
            if(number%factor==0){
                System.out.println(factor);
                number/=factor;
            }else{
                factor++;
            }
        }
    }
}

（4）使用一个for循环完成九九乘法表

public class NinePlusNine{
    public static void main(String[] args){
        //两个for循环打印9*9循环表
        System.out.println("两个for循环打印9*9循环表");
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+i*j+" ");
            }
            System.out.println();
        }
        //一个for循环打印9*9循环表
        System.out.println("一个for循环打印9*9循环表");
        for(int i=1,j=1;i<=9;j++){
            System.out.print(j+"*"+i+"="+i*j+" ");    
            if(i==j){
                i++;
                j=0;
                //换行
                System.out.println();
            }
        }    
        //一个for循环打印9*9循环表，换一种写法
        System.out.println("一个for循环打印9*9循环表");
        for(int i=1,j=1;i<=9; ){
            System.out.print(j+"*"+i+"="+i*j+" ");    
            if(i==j){
                i++;
                j=0;
                //换行
                System.out.println();
            }
            //j自增
            j++;
        }        
    }
}

结论

流程控制语句是程序基本语句，复习用。

参考博客：

（1）https://www.cnblogs.com/adamjwh/p/8329496.html