自从看了这篇Java的流程控制，再也不看别人的基础知识了

java的流程控制结构有三种：
顺序:

选择:

循环:

• 顺序结构，就是从头到尾依次执行每条语句的操作。
• 选择结构，也称条件控制，是指根据表达式的值有选择的执行。
  • if单选择结构
  • if双选择结构
  • if多选择结构
  • if嵌套结构
  • switch多选择结构

• 循环结构，也称回路控制，是根据循环初始条件和终结要求，执行循环体内的操作。
  • List item
  • while循环
  • do…while循环
  • for循环
  • 增强for循环
• 出循环的关键字
  • break
  • continue
  • return

顺序结构：

Java的基本结构就是顺序结构，除非特别指明，否则就是按照顺序一句一句执行。顺序结构是最简单的算法结构。语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。

选择结构：

我们很多时候需要去判断一个东西是否可行，然后我们才去执行，这样一个过程在程序中用选择语句来表达。
在java中，选择结构分为 if-else 语句和 switch 语句。
首先我们来看下if-else语句：
if单选择结构：
语法：

   if(布尔类型表达式){
    语句或语句块
    } 

注意：if括号里表达式的值返回的必须是布尔类型　　
例如：

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
​
        System.out.println("请输入内容：");
        String s = scanner.nextLine();
​
        if (s.equals("Hello"))
            System.out.println(s);
​
​
            scanner.close();
    } 　
 

在这里的s.equals的意思是判断s所表示的字符串是否和后面的Hello相同，当判断字符串时尽量别用 == 。
　if双选择结构：
　语法：

if(布尔类型表达式){
    语句或语句块
}else{
    语句或语句块
} 　

例如：

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
​
        System.out.println("请输入：");
        int score = scanner.nextInt();
        if(score>=60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
​
        scanner.close();
    }

if多选择结构：
很多选择不仅仅只有两个，所以要用多选择结构处理。
语法：

  if(布尔表达式1){
    //如果布尔表达式1为true将执行的语句
}else if(布尔表达式2){
    //如果布尔表达式2为true将执行的语句
}else if(布尔表达式3){
    //如果布尔表达式3为true将执行的语句
}else{
    //如果以上布尔表达式都不为true将执行的语句
}  

备注：
1.在多支语句中，这多种情形是一种互斥关系，非你即我，只有一种情形会成立，程序也只会执行条件里面的一种代码。　　 2.在多支语句中，如果最后一种情形它包含了它以上情形之外的所有情形，那么该种情形也可以这样表达，省略if（条件）。
例如：

int per = 76;
        if(per == 100){
            System.out.println("进1v1名师辅导班");
        }else if(per >= 90 && per < 100){
            System.out.println("进状元班");
        }else if (per >= 80 && per < 90){
            System.out.println("进尖子班");
        }else if (per >= 70 && per < 80){
            System.out.println("进珍珠班");
        }else if (per >= 60 && per < 70){
            System.out.println("进普通班");
        }else  if(per < 60){
            System.out.println("不录取");
        } 　　

if嵌套结构：
在一个if里再加一个if。
语法：

if(布尔类型表达式1){
　　 //如果布尔表达式1为true将执行的语句
   if(布尔类型表达式2){
    //如果布尔表达式2为true将执行的语句
    语句或语句块
}else{
　　 //如果布尔表达式2为false将执行的语句
    语句或语句块
}
}else{
　　//如果布尔表达式1为false将执行的语句
    if(布尔类型表达式2){
　　 //如果布尔表达式2为true将执行的语句
    语句或语句块
}else{
　　 //如果布尔表达式2为false将执行的语句
    语句或语句块
}
}   

例如：

 String sex = "男"；
double money = 18000；
if (sex.equals("男")) {
            if (money >= 20000) {
                System.out.println("女生眼中的高富帅");
            } else if(money < 8000){
                System.out.println("女生眼中的屌丝");
            }
        }else if (sex.equals("女")){
            if (money >= 12000){
                System.out.println("男生眼中的白富美");
            }else if (money <= 3000){
                System.out.println("男生眼中的女屌丝");
            }
        }  　　 

switch多选择结构：
switch原理：

switch流程图：

switch case语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

语法:switch(表达式){
case 常量值1:
    语句块;
    break;
case 常量值2:
    语句块;
    break;
case 常量值3:
    语句块;
    break;
        ..
default:
    语句块;
    break;
}  　　

注意：
1）switch中表达式的返回值只能是 int，byte，char，short，枚举，字符串；
2）case子句中的值必须是常量，且不能重复；
3）default可有可无
4）break作为某一个case代码段的结束句，使其跳出程序。
5）case 情形之间也是一种互斥关系，非你即我。

 public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    System.out.println("今天星期几了？");
    int week = scan.nextInt();
         
    switch(week){
    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:
        System.out.println("Sunday");
        break;
    default:
        System.out.println("Sorry,i don't know!");
    }
} 　　  

循环结构：

顺序结构的程序语句只能 被执行一次。如果你要同样的操作执行多次，就需要使用循环结构。
java中有三种主要的循环结构：while循环 do-while循环 for循环
1.while循环
while循环不知道循环次数。先判断，再循环。常用死循环。
while是最基本的循环，它的语法为：

　while(循环条件)
　　{
　　　　循环语句
　　}
　　只要循环条件的结果为真，就执行循环语句

注意：
一定要有退出循环的条件，否则会形成无限循环
例如：

public class Test {
    public static void main(String args[]) {
        int x = 10;
        while (x < 20) {
            System.out.print("value of x :" + x);
            x++;
            System.out.print("\n");
        }
    }
}

以上实例编译运行
结构如下：

value of x : 10
value of x : 11
...
value of x : 19

2.do…while循环
对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少 执行一次。
do…while循环和while循环相同，不同的是，
do…while循环至少会执行一次。
do…while循环的语法为：

 do {
         执行语句
} while(循环条件);

注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。如果布尔表达式值为true，则语句块一直执行，直到布尔表达式的值为false。
例如：

public class Test {
    public static void main(Staing args[]) {
        int x = 10;
        do {
            System.out.print("value of x :" + x);
            x++;
            System.out.print("\n");
        } while (x < 20);
    }
}

以上实例编译运行结果如下：
value of x : 10
…
value of x :193.for循环虽然所有循环结构都可以用while或者do…while表示，但java提供了另一种语句（for循环），使一些循环结构变得更简单。for循环的流程：for循环的语法为： for(初始化语句;判断条件语句;控制条件语句){
循环体语句;
} 注释：（1）初始化语句：一条或者多条语句，这些语句完成一些初始化操作
　　 （2）判断条件语句：这是一个boolean 表达式，这个表达式能决定是否执行循环体
　　 （3）循环体语句：这个部分是循环体语句，也就是我们要多次做的事情
　　 （4）控制条件语句：这个部分在一次循环体结束后，下一次循环判断条件执行前执行。通过用于控制循 环条件中的变量，使得循环在合适的时候结束例如：public class Test{
public static void main (Staing args[ ]){
for(int x=10;x<20;x=x+1){
System.out.print(“value of x :”+x);
System.out.print("\n");
}
}
}编译运行结果如下：

    value of x :10
...
value of x :19

4.增强for循环增强
for循环的语法：

  for(声明语句：表达式){
        //代码句子
    }
 

声明
语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
例如：

 public class test {
    public static void main(String args[]) {
        int[] numbers = { 10, 20, 30, 40, 50 };
        for (int x : numbers) {
            System.out.print(x);
            System.out.print(",");
        }
        System.out.print("\n");
        String[] names = { "James", "Larry", "Tom", "Lacy" };
        for (String name : names) {
            System.out.print(name);
            System.out.print(",");
        }
    }
}

编译运行如下：

10，20，30，40，50，
James,Larry,Tom,Lacy,

跳出循环的关键字：

break关键字：

break主要用在循环语句或者switch语句中，用来跳出整个语句块。
break跳出最里面的循环，并且继续执行该循环下面的语句。

break实例：

public class Test {
   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50};

      for(int x : numbers ) {
         // x 等于 30 时跳出循环
         if( x == 30 ) {
            break;
         }
         System.out.print( x );
         System.out.print("\n");
      }
   }
}

以上实例编译运行结果如下

10，20

continue 关键字：

continue 适用于任何循环控制结构中。作用是让程序立刻跳到下一次循环的迭代。
在for循环中，continue语句使程序立即跳转到更新语句。
在while或者do...while循环中，程序立即跳转到布尔表达式的判断语句。

continue 实例：

public class Test {
   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50};

      for(int x : numbers ) {
         if( x == 30 ) {
        continue;
         }
         System.out.print( x );
         System.out.print("\n");
      }
   }
}

以上实例编译运行结果如下：

10
20
40
5

0return 关键字：

直接结束当前main方法，遇到return后，方法中的所有代码将不再执行。

注意：程序中要减少return的使用频率。一旦使用return，整个main方法结束