java基础之分支与循环语句

一、语句概述

程序是由一条条语句组成，按照语句格式来划分语句的话可以分为三种结构：顺序结构，分支结构，循环结构。
顺序结构就是代码自上而下逐句执行，中间没有任何的判断和跳转，此处不再赘述。

二、分支结构

java提供了两种常见的的分支结构，if结构和switch结构

1. if语句

if语句是使用运算结果为布尔型的表达式或者布尔型的值（即true或false）来进行分支控制。

if有三种不同的表达形式分别为：

①

if(logic expression){   
    statement..
}

②

if(logic expression){
    statement..
}else{
    statements..
}

③

if(logic expression){
    statement..
}else if(logic expression){
    statement..
...//此处可以有若干个else if
else{
    statement..
}

具体的执行过程为：如果if后面括号中的表达式的结果或值为true则执行if后花括号中的语句代码if 后的else if 和else 不再执行；如果为false则对else if 的逻辑表达式进行判断true或false，若为true则执行else if 后花括号里的语句代码，若为false则对下一个else if进行判断，若所有的else if 都未false 则执行else 花括号里的代码语句。
示例代码：

int i = 5;
if(i>3){
    System.out.println(i+"大于3");
}else if(i>4){
    System.out.println(i+"大于4");
}else if(i==5){
    System.out.println(i+"等于5");
}else{
    System.out.println(i+"为i的值");
}

运行结果为：5大于3

2. switch 语句

switch语句是对多个值进行匹配进而实现分支控制，但是这个进行匹配比较的值得类型只能是byte、short、char、int、String（java7开始支持）和枚举类型不能是其他类型。

语法格式：

switch(expression){
    case 值1：{
        statement;
        break;
    }
    case 值2：{
        statement;
        break;
    }
    ...
    case 值N：{
        statement;
        break;
    }
    default:{
        statement;
    }
}

具体执行过程为先求出expression的值，然后与各个值1，值2 ~ 值N进行匹配，遇到匹配的值则执行该值后面对应的代码块，如果所有的值都未能匹配的话则执行default后的代码块。case和default后的花括号可以省略。切记case语句后的break绝对不能省略，在switch中一旦完成匹配之后，后面的case不再进行匹配比较而是直接执行case后的代码块，直到switch结束。

示例代码：

    public class SwitchDemo{
        public static void main(String [] args){
            int i = 3;
            switch(i){
                case 1: System.out.println("i的值为1");break;
                case 2: System.out.println("i的值为2");break;
                default: System.out.println("i的值为3");
            }
        }
    }

运行结果为：i的值为3

三、循环结构

循环是在满足循环条件的情况下反复执行某段代码，循环条件需要在适当的时候改为假，否则将会变成死循环。
在循环中可能包含四个部分：初始化语句，循环条件（布尔型表达式）、循环体、迭代语句（控制循环结束）。
在Java中循环大体可以分为四种结构：while、do while、for、for each（通常用于遍历集合和数组此处不介绍）。

1.while循环

语法格式：

    [init_statement]//初始化循环条件
    while(test_expression){
        statement;
        [iteration_statement]
    }

while循环在每次执行循环体之前，先对test_expression循环条件求值，如果值为真则执行循环体语句。

示例代码：

public class WhileDemo{
    public static void main(String [] args){
        int count = 0;
        while(count <= 3){
            System.out.println(count);
            count++;
        }
        System.out.println("while循环结束");
    }
}

运行结果：0 1 2 3 while循环结束

2. do while 循环

语法格式：

[init_statement]
do{
    Statement;
    [interation_statement]
}while(test_expression);

do while循环的循环条件后面必须有一个分号表明循环语句结束。与while循环不同的是：while循环是先判断循环条件，若为真则执行循环体里的语句，而do while循环则是先执行一次循环体语句然后进行循环条件的判断，若为真则执行下一次循环，否则循环结束。

示例代码：

public class DoWhileDemo{
    public static void main(String [] args){
        int count = 5;
        do{
            count--;
            System.out.println(count);
        }while(count>=0);
        System.out.println("循环结束!");
    }
}

运行结果：4 3 2 1 0 循环结束！

3. for循环

for循环是更加简洁的循环语句，在大部分情况下for循环可以替代while循环和 do while循环。

语法格式：

for(init_statement ;test_expression; interation_statement){
    statement;
}   

程序在执行for循环之前先执行循环初始语句init_statement，该语句只在循环开始前执行一次。在执行循环体之前先判断test_expression的值，若为true则执行循环体，循环体结束后执行循环迭代语句interation_statement。在for循环中可以一次性定义多个初始化变量，但这些变量的数据类型必须相同。在循环体内不建议修改循环变量的值，以避免陷入死循环。
在for循环中只有两个分号是必须的其余条件可以全部省略或部分省略如：

for(; ;){
    statement;
}

这样的话循环条件将会默认为true，产生死循环。

示例代码：

public class ForDemo{
    public static void main(String [] args){
    //初始化语句;循环条件;循环迭代语句
        for(int a=0,b=1; a<=3 && b<=2 ; a++,b++){
            System.out.println(a+" "+b);
        }
        System.out.println("循环结束");
    }
}

运行结果：0 1 ， 1 2 循环结束

四、循环嵌套

把一个循环放到另一个循环的的循环体内则形成循环嵌套。当程序遇到循环嵌套是，如果外层循环的循环条件为真则开始执行外层循环的循环体，内层循环则会被当做外层循环的循环体执行。只有当内层循环的循环条件为false时才会跳出内层循环，并结束外层循环的本次循环，开始外层循环的下一次循环。
假设内层循环的循环次数为m次，外层循环的循环次数为n次，则内层循环的循环体实际需要执行m*n次。
流程示意图如图所示。

代码示例：

     public class LoopDemo{
        public static void main(String [] args){
            for(int i=1; i<=4; i++){
                for(int k=1; k<=4; k++){
                    System.out.print("  ");
                }
                for(int j=1; j<=2*i-1; j++){
                    System.out.print("* ");
                }
                System.out.println();
            }
        }
    }

运行结果：
      *  
    * * * 
  * * * * *
* * * * * * *

五、循环控制结构

java中没有提供goto语句来控制程序的跳转，这样就降低了程序流程控制的灵活性，但这样也提高了可读性。为了弥补灵活性不高这一缺点，java提供了continue和break来控制循环结构。当然也可以使用return 来结束整个方法这样也就结束了循环。

1.使用break来结束循环

在某些特定的时候我们需要强行终止循环而不是让循环条件为false时才停止循环，此时便可用break来实现该功能。break用于结束一个循环，跳出所在循环的循环体。在循环中一旦遇到break系统将会完全结束其所在的循环，开始执行循环之后的代码。

代码示例：

public class BreakDemo{
    public static void main (String [] args){
        for(int k=10; k>=2; k--){
            System.out.println(k);
            if(k==8)
                break;
        }
        System.out.println("循环结束");
    }
}

运行结果：10，9，8 循环结束

当break出现在循环嵌套的内层循环中时，我们想让该break结束整个循环该怎么办呢？此时我们就需要用到java中的标签了。java中的标签就是一个str后紧跟着一个冒号‘：’其作用为标识一个循环。在break后面紧跟一个标签则可以结束标签所标识的循环。

示例代码：

public class BreakDemo{
    public static void main(String [] args){
        zz:
        for(int j=0; j<=10; j++){
            for(int k=0; k<=3; k++){
                System.out.println(j+" "+k);
                if(k==3)
                    break zz;
            }
        }
    }
}

运行结果：0 0 ，0 1 ，0 2 ，0 3

2.使用continue忽略本次循环之后的语句

continue作用与break有异曲同工之妙，区别在于continue只是忽略本次循环中continue之后的语句，接着开始下一次循环而不是结束循环。

代码示例：

public class ContinueDemo{
    public static void main(String [] args){
        for(int k=10; k>=7; k--){
            if(k==8)
                continue;
            System.out.println("k的值为"+k);
        }
    }
}

运行结果：k的值为10，k的值为9，k的值为7

与break相同，continue也可以使用标签来忽略标签所标识的循环的本次循环所剩下的语句

代码示例

public class ContinueDemo{
    public static void main(String [] args){
        GG:
        for(int k=0; k<=2; k++){
            for(int j=2; j<=4; j++){
                System.out.println("k的值为"+k+" "+"j的值为"+j);
                if(j==2)
                    continue GG;
            }
        }
    }
}

运行结果：k的值为0 j的值为2，k的值为1 j的值为2，k的值为2 j的值为2