java 控制流程 &枚举类型 enum 的用法 & 带标签的break语句 &continue语句

java 没有goto语句，但是可以用break+标签来跳到目的地
java有一种变形的for循环
java块：块确定了变量的作用域，不能在嵌套的两个块中声明同名的变量。
例如：

public static void main(String[] args)
{
    int n;
    {
    int n:     //不正确
    }
}

在C++中，可以在嵌套的块中冲定义一个变量，在内层定义的变量会覆盖外层的变量，但是可能会导致程序错误，java中不允许这样做。

条件语句

while循环语句首先检测循环条件，因此，while中的代码有可能不执行，如果希望代码中的程序至少执行一次，应使用do{ }while（）语句。
注意：在循环中，检测两个浮点数是否相等要格外小心，下面的for循环：

     for(double i=0;i！=1;i=i+0.1)
           System.out.println(i);
run:
run:
0.0
0.1
0.2
0.30000000000000004
0.4
0.5
0.6
0.7
0.7999999999999999
0.8999999999999999
0.9999999999999999
1.0999999999999999
1.2
1.3
1.4000000000000001
1.5000000000000002
1.6000000000000003
1.7000000000000004
1.8000000000000005
1.9000000000000006
……

可能永远也无法结束
当在for语句的第1部分中声明了一个变量以后，这个变量的作用于就是for循环的整个循环体。
特别指出：java中，如果在for语句内部定义了一个变量，这个变量就不能再循环体制外使用，因此，如果希望在for循环体之外使用这个变量，就必须确保这个变量在循环语句的前面而且在外部声明！

 for(int i=0;i<5;++i)
    System.out.println(i);
 if(i>1)
    System.out.println(i); //编译错误，找不到i变量，应该在for外面声明

正确的方式：

      int i;
      for(i=0;i<5;++i)
          System.out.println(i);
      if(i>2)
          System.out.println("i= "+i);
run:
0
1
2
3
4
i= 5

多重选择 switch语句

       Scanner in=new Scanner(System.in);
       int number=in.nextInt();
       switch(number)
       {
           case 1:
               System.out.println(number);
               break;
           case 2:
               System.out.println(number);
               break;
           case 3:
               System.out.println(number);
               break;
           default:
               System.out.println(number);
               break;

switch语句将从预选相知相匹配的case标签处开始执行直到遇到break; 或者switch语句的结束为止。如果没有相匹配的case标签，而又default语句，就执行这个句子。
警告：使用switch可能会触发多个case分支。如果在case分支语句的末尾没有break语句，那么就会接着执行下一个case分支语句。这种情况很危险，常常会引发错误，为此，我们在程序中从不使用switch语句。
如果你比我们更喜欢switch语句，编译代码时可以考虑加上-Xlint:fallthrough 选项，这样一来，如果某个分支最后缺少一个break语句，编译器就会给出一个警告信息
如果你确实正是想使用这种直通式（fallthrough）行为，可以为其外围方法加一个标注：@supressWarnnings(“fallthrough”).这样就不会对这个方法生成警告了
@标注是为编译器或处理java源文件或者类文件的工具提供的一种机制。
switch中的case可以是：
1,类型为char、byte、short、或者int的常量表达式
2,枚举常量：

    package 第3章;
// enum Size {A,B,C,D};  enum放在这里也可以
public class 第3章a
{
    public static void main(String[] args)
    {
        Size number=Size.A;  //  注意
        switch(number)
        {
            case A:
                System.out.println(number);
                break;
            case B:
                System.out.println(number);
                break;
            default:
                System.out.println("hello");
                break;
        }
    }
}
enum Size {A,B,C,D};  //  枚举类型的地位和class是并列的，不能放在class内部，可以放于class后，也可以放于package后，class前

package 第3章;

public class 第3章a
{
    public static void main(String[] args)
    {
       size name=size.boy;
       size name2=null;
        System.out.println(name);
        System.out.println(name2);
    }
}
enum size {hello,good,boy};

3,case标签还可以是字符串字面量
package 第3章;

public class 第3章a
{
public static void main(String[] args)
{
String number=”hello”;
switch(number)
{
case “good”:
System.out.println(“a”);
break;
case “hello”:
System.out.println(“b”);
}
}
}
java.lang.String;
toLowerCase():将字符串转换为小写，返回this
toUpperCase（）：将字符串转换为大写，返回this

package 第3章;
import java.util.*;
public class 第3章a
{
    public static void main(String[] args)
    {
        Scanner in=new Scanner(System.in);
        String str=in.nextLine();
        switch(str.toLowerCase())
        {
            case "hello":
                System.out.println("a");
                break;
            case "good":
                System.out.println("b");
                break;
        }
    }
}

不带标签的break语句，可以用于跳出switch，也可以用于退出循环语句（只退出当前循环语句）
java还提供了一种带标签的break语句，用于跳出多重嵌套的循环语句
标签必须放在希望跳出的最外层循环之前，并且紧跟一个冒号
注意：不是标签在哪就跳到那，必须放在循环体的前面，而不能放在循环体的后面。
跳到循环体块的尾部，而不是调到haha：处！
a

package 第3章;
import java.util.*;
public class 第3章a
{
    public static void main(String[] args)
    {
 Scanner in=new Scanner(System.in);

    int number=in.nextInt();
    haha:   
  //  System.out.println("what?");   这里不可以有语句
    while(number>0) 
    {
        System.out.println(number--);
        if(number<3)
            break haha;
    }
    if(number==2)
        System.out.println("well");
    else
        System.out.println("what?");
    System.out.println("hello"+number);
    }
}
//对于任何使用break语句的代码，都需要检测循环是正常结束，还是由break退出。

package 第3章;
import java.util.*;
public class 第3章a
{
    public static void main(String[] args)
    {
 Scanner in=new Scanner(System.in);
  int number =in.nextLine();
  //  System.out.println("what?");
    while(number>0)
    {
        System.out.println(number--);
        if(number<3)
            break haha;
    }
    if(number==2)
        System.out.println("well");
    else
        System.out.println("what?");
    System.out.println("hello"+number);
    }
}

break
使用场景有两个，第一，switch中，第二，循环语句中。 
switch场景就不多说了，现在说说循环语句的场景。 
在循环语句中，表示跳出循环语句继续向下执行。

        for(int a=0;a<6;a++)
        {
            if(a>3)
            {
                break;
            }
            System.out.println("a="+a);
        }

上面的代码表示当a循环到a=4的时候跳出循环。 

还有一种场景是双循环中break跳出哪一个循环的问题。

     for(int i=1;i<=4;i++)
     {
            for(int j=1;j<=4;j++)
            {
                System.out.println("i="+i+",j="+j);
                break;
            }       
     }

在上面的双循环中，break跳出的循环是内层循环，而外层循环继续。 
运行结果是： 
 
这时候有个问题，如果我想跳出外层循环怎么办呢？ 
那就给循环起个名字。

    w:for(int i=1;i<=4;i++){
            n:for(int j=1;j<=4;j++){                    
                System.out.println("i="+i+",j="+j);
                break w;
            }   
        }

这时候，跳出的循环就是名字为w的外循环了，且不会在执行一遍w。
continue
continue的使用场景是在循环中，想要跳出当次循环，继续下次循环。

      w:for(int i=1;i<=4;i++){
            n:for(int j=1;j<=4;j++){                    
                System.out.println("i="+i+",j="+j);
                continue w;
            }   
        } 


重点：1.break和continue语句的作用范围就是当前的循环。
continue
与break语句一样，，他将中断正常的控制流程。continue将控制转移到最内层循环的首部。

package 第3章;
import java.util.*;
public class 第3章a
{
    public static void main(String[] args)
    {
        Scanner in=new Scanner(System.in);
        double sum=0;
        double goal=100;
        while(sum<goal)
        {
            System.out.println("please input a sum");
            double n=in.nextDouble();
            if(n<0)
            {
                System.out.println("what?");
                continue;
            }
            sum+=n;
        }

    }
}

如果将continue语句用于for循环中，就可以跳到for循环的更新部分
带标签的continue将跳到与标签匹配的循环首部