3.8 控制流程

1 语句块

你可以把一段执行代码直接用花括号｛｝括起来，对程序没有影响。

public class MyString {
    public static void main(String[] args){
        //加的这个花括号就没有影响的和不加是一样的
        {
            System.out.println("比较字符串String");
            String a = "A";
            String b = a;//这里面a和b变量都指向同一个字符串
            String c = new String("A");//虽然c里面也是"A"，但是，new关键字却是新建了一个字符串
            if(a == b)
                System.out.println("a == b");//会输出
            if(a == c)
                System.out.println("a == c");//内存不一样，不会输出
        }


        System.out.println("比较整型类Integer");
        Integer x = 1;//自动装箱，把1变成Integer类了
        Integer y = x;
        Integer z = new Integer(1);
        if(x == y)
            System.out.println("x == y");//会输出
        if(x == z)
            System.out.println("x == z");//内存不一样，不会输出


    }
}

有一点的注意，就是不能定义重复的变量啊，语句块是不能够有块内局部变量的，方法块是可以定义局部变量的。

public static void main(String[] args)
{
    int x = 0;
    {
        int x = 9;//这是不可以的
    }
}

2 条件语句

1 if(条件语句)语句

这里，
条件语句执行结果是布尔类型，而且必须是为true才会执行后面的语句或语句块
语句部分，可以是一条语句（一个分号结束），也可以是一个语句块

int x = 0;
if(x > 0)
    System.out.println("x > 0");//不会执行，因为x > 0的结果是false

if(x == 0)
    System.out.println("x = 0");//会执行，因为x == 0的结果是true

if(x == 0)
{
    //只要结果是true，那么紧接的语句块都会被执行
    System.out.println("x = 0");//会执行，因为x == 0的结果是true
    System.out.println("x = 0");//会执行，因为x == 0的结果是true
}   

2 if(判断语句) 语句1 else 语句2

这里，
条件语句执行结果是布尔类型，
语句1部分，条件语句为true时执行，可以是一条语句（一个分号结束），也可以是一个语句块
语句2部分，条件语句为false时执行，可以是一条语句（一个分号结束），也可以是一个语句块
注意：当else 语句不要时，就是上一种条件语句了

int x = 5;
if(x > 0)
{
    System.out.println("x > 0");//会执行，是true嘛
}
else
{
    System.out.println("x <= 0");//不会执行，是true嘛，这里是else的块啊
}

注意：else关键字只会和最近的if配合

3 if(条件语句1) 语句1 else if(条件语句2) 语句2 else 语句3

这里，
条件语句1执行结果是布尔类型，
语句1部分，条件语句1为true时执行，可以是一条语句（一个分号结束），也可以是一个语句块
条件语句2执行结果是布尔类型，当条件语句1为false时就会执行这个部分
语句2部分，条件语句2为true时执行，可以是一条语句（一个分号结束），也可以是一个语句块
语句3部分，条件语句2为false时执行，可以是一条语句（一个分号结束），也可以是一个语句块
注意：else if(条件语句) 语句 部分可以重复，不要时就是上一种条件语句了，else 语句也可以不要

int x = -1;
if(x > 0)
{
    System.out.println("x > 0");
}
else if(x == 0)
{
    System.out.println("x == 0");
}
else
{
    System.out.println("x < 0");//最终这个会执行
}

//这样也可以的，然后就没有一个条件符合的
if(x > 0)
{
    System.out.println("x > 0");
}
else if(x == 0)
{
    System.out.println("x == 0");
}

//下面这个就有两个else if
if(x > 0)
{
    System.out.println("x > 0");
}
else if(x == 0)
{
    System.out.println("x == 0");
}
else if(-1 < x && x < 0)
{
    System.out.println("-1 < x < 0");
}
else
{
    System.out.println("x <= -1");//最终这个会执行
}

3 循环

1 while(条件语句) 语句

这里：
条件语句执行结果是布尔类型，仅当结果是true时，才会执行语句，并且，语句执行结束后，还会判断条件语句，如果还是true，那么还要执行语句，，就这么循环，直到条件结果是false时，就不执行语句了，就跳到后面的代码了

int x = 3;
while(x >0)
{
    System.out.println("I love you!");
    x--;
}
//上面这个循环语句，连续打印输出了3次I love you!

注意，除非你永远不想出了循环，否则，必须在循环体内部实现结束循环的方法，有3种方法

1. 改变判断条件，使之会在某次循环后达到false，就不会继续循环了，上面的实例就是这种方法
2. 用break语句，只要在循环体内有break语句，就会跳出一层循环，也就打破该层循环了嘛

int x = 3;
while(true)
{
    System.out.println("I love you!");
    x--;
    if(x <= 0)
        break;
}
//上面这个循环语句，连续打印输出了3次I love you!

1. 用renturn，每个方法都可以使用return 语句，一旦使用return ，连方法都要结束了，循环更会结束

public void print()
{
    int x = 3;
    while(true)
    {
        System.out.println("I love you!");
        x--;
        if(x <= 0)
            return ;//直接把方法都结束了，循环也就没有了
    }
}

2 do 语句 while (条件语句)；

这种循环的特点是，一定会进入循环体，显然，上面那种是不一定的。
先执行，再判断，如果是true，就再执行，再判断，，，直到判断是false，就执行后面的语句了

int x = 3;
do
{
    System.out.println("I love you!");
    x--;
}
while(x > 0);

注意：break语句和return语句仍然可以打破循环的

4 确定循环

for(初始语句; 判断语句；迭代语句)循环语句
执行顺序如下：

初始语句-->判断语句-->true -->循环语句-->迭代语句-->判断语句-->true-->...
                -->false-->出了循环                    -->false-->出了循环 

for(int x = 0; x < 88; x++)
{
    System.out.println("I love you!");
}
//上面这个循环语句，连续打印输出了88次I love you!

注意：初始语句、判断语句、迭代语句不能够是语句块；这个循环的好好处是，可以明确知道循环多少次
注意：break语句和return语句仍然可以打破循环的

5 多重选择语句

Scanner in = new Scanner(SYstem.in);
System.out.println("输入一个数：");
int choice = in.nextInt();
switch(choice)
{
    case 1:
        语句1;
        break;
    case 2:
        语句2;
        break;
    case 3:
        语句3;
        break;
    ...
    case n:
        语句n;
        break;
    default :
        语句n+1；
}

1. switch语句快的地方在于，它会直接跳到对应的地方执行，例如，输入的是3，那么就直接执行语句3了。
2. 如果没有任何一个case是正确的，那就执行语句n+1；这是默认情况嘛，这个默认语句段是可以省略的哦；
3. 关于break的问题，如果不写语句后的break，后果是当前语句执行完毕后，会直接执行下一个case的语句，而不会关系到底choice和case相不相等。后果很严重的哦，使用时请小心。。。至于default语句后面都没有case了，那么就不用写break了。

注意：除了整形可以用switch外还有，字符型、字符串和枚举型也可以进行switch语句。

6 break语句和continue语句；

前面已经介绍了break可以打破当层循环和跳出switch语句。实际上，break关键字后面也可以加标签的，意思是跳到标签位置开始执行，例如：

label:
int x = 3;
do
{
    System.out.println("I love you!");
    x--;
    if(x == 1)//当x=1时，break就会把程序跳道前面定的那个标签哪里了
        break label;
}
while(x > 0);

break的这种用法和其他程序语言的goto很像，Java保留了goto关键字，但是不能使用。

continue语句的意思是，结束本次循环体，进行下一次循环。
while(){}循环，一旦循环体内部被continue后，会直接进入判断语句，continue后面的就语句本次循环就不执行了。
do{}while();循环，一旦循环体内部被continue后，会直接进入判断语句，continue后面的就语句本次循环就不执行了。
for(;;){}循环，一旦循环体内部被continue后，会直接进入迭代语句，continue后面的就语句本次循环就不执行了。

for(int i = 0; i < 10; i++)
{
    if(i % 2 == 0) 
        continue;
    System.out.println(i + " I love you!");
}
//上面的循环只会执行奇数次的输出，偶数次的都被continue掉了，就不会输出的。

实际上，continue语句也可以像break语句一样贴标签，用法是一样的。这里就不赘述了。