【后端学习】流程控制

流程控制大致包括分支语句、循环语句和顺序结构，接下来细说：

首先是传统的顺序结构：

如图所示：

就是一路到底，非常直接。

：然后是分支结构：包括if-else和switch结构

if else结构：

格式如下：

if（条件判断）

{执行语句}

else if（条件判断有时候可不写，可省略if）

{执行语句}

适用情况：多重选择分支，适用于多种情况，先条件判断再执行语句

例如：

6. 大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出

   一定的条件：高：180cm以上；富：财富1千万以上；帅：是。（注意:不用管单位）

        如果这三个条件同时满足，则：“我一定要嫁给他!!!”

        如果三个条件有为真的情况，则：“嫁吧，将就过日子。”

        如果三个条件都不满足，则：“不嫁！”

这个很明显的多重选择分支，三个判断条件分别用与或非就可以（最后一种判断可以用else ）。即&&、|即可。

代码如下：

import java.util.Scanner;
public class Jia {
    public static void main(String[] args) {
      Scanner sc =new Scanner(System.in);
      System.out.println("请输入身高（cm）： ");
      int h=sc.nextInt();
        System.out.println("请输入财富（万）： ");
      int q=sc.nextInt();
        System.out.println("请输入帅或不帅，帅为true，不帅为false： ");
      boolean n=sc.nextBoolean();
      if (h>180&&q>1000&&n==true){
          System.out.println("我一定嫁给他！");
      }else if(h>180|q>1000|n==true){
          System.out.println("嫁吧，将就过日子");
      }else {
          System.out.println("不嫁！");
      }

    }
}

switch则是相比if速度较快的一种结构但是只适用于等量判断。

格式：switch（条件判断）

{case 1：执行语句；break；

case 2: 执行语句2；break；

……}其中break表示结束当前语句，continue表示跳出当前循环执行下一个循环。

例如：

1. 使用键盘录入三个变量。

2. 使用switch判断语句对第三个变量进行判断，匹配要执行的操作。

3. 在每一个case中分别对第一个变量和第二个变量进行不同的操作。

import java.util.Scanner;
public class Demo2 {
    public static void main(String[] args) {
        // 2.创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        // 3.提示需要输入的数据，并调用方法获取输入的数据
        System.out.println("请输入第一个整数：");
        int num1 = sc.nextInt();
        System.out.println("请输入第二个整数：");
        int num2 = sc.nextInt();
        System.out.println("请输入您要进行的运算(1:表示加法,2:表示减法,3:表示乘法,4:表示除法)");
        int type = sc.nextInt();
        // 4.使用switch语句判断计算类型，并输出相应的结果
        switch (type) {
            case 1:
                System.out.println(num1 + " + " + num2 + " = " + (num1 + num2));
                break;
            case 2:
                System.out.println(num1 + " - " + num2 + " = " + (num1 - num2));
                break;
            case 3:
                System.out.println(num1 + " * " + num2 + " = " + (num1 * num2));
                break;
            case 4:
                System.out.println(num1 + " / " + num2 + " = " + (num1 * 1.0 / num2));
                break;
            default:
                System.out.println("您输入的运算类别有误");
                break;
        }
    }
}

注：witch语句原理是跳转到caseX位置执行剩下所有的语句（包括其他case里面的），直到最后或者遇见break为止。因此在每一条语句最后+break即可。
因此不加break的话将会执行跳转到的case本身以及以下所有的语句。

优缺点分析：代码流程简明扼要，一目了然且多数情况运算效率大于if。但是每次执行都会生成跳转表导致占用数据内存大，且只适用于等值判断，局限性大。

for循环：

格式：

for (初始化语句;条件判断语句;条件控制语句)

{     循环体语句;
}

执行流程：

执行流程：
执行初始化语句
执行条件判断语句，看其结果是true还是false
             如果是false，循环结束
             如果是true，继续执行
执行循环体语句
执行条件控制语句
回到条件判断语句继续执行

例如：2. 编写程序从1循环到150，并在每行打印一个值，另外在每个3的倍数行 上打印出“foo”,在每个5的倍数行上打印“biz”,在每个7的倍数行上打印 输出“baz” 。

public class Xun {
    public static void main(String[] args) {
        int i=1;
        for (i=1;i<=150;i++){
            if (i%3==0){
                System.out.println(i+"foo");
            }
            else if (i%5==0){
                System.out.println(i+"biz");
            }
            else if (i%7==0){
                System.out.println(i+"baz");
            }
            else {
                System.out.println(i);


        }}
    }
}

while和do while：

while：

使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环

格式：
初始化语句;
while (条件判断语句) {     循环体语句;
        条件控制语句;
}

例如：用while循环语句现，打印出20个3的倍数的和。

public class Wile {
    public static void main(String[] args) {

        int i=3;
        int sum=0;
        while (i<=60){
            sum+=i;
            i+=3;

        }
        System.out.println("20个3的倍数的和是:"+sum);
    }
}

do while：

do...while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）

格式：
初始化语句;
do {
    循环体语句;
    条件控制语句;
}while(条件判断语句);

执行流程：
执行初始化语句
执行循环体语句
执行条件控制语句
执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
回到②继续

例如：用do_while循环语句实现，打印出3的倍数，如果这个数是7的倍数则结束程序。

public class Wile {
    public static void main(String[] args) {
       int i=0;
       do {
           i+=3;
           System.out.println("3的倍数有："+i);

       }while (i<=60&&i%7!=0);


    }
}

循环嵌套：

循环嵌套是为了解决多层循环的问题；

外循环控制行数，内循环控制每一行的个数；

任何语句对外都可以看成是一句话，一句代码
分支语句中包含分支语句称为分支嵌套
循环语句中包含循环语句称为循环嵌套

例如：打印菱形：

import java.util.Scanner;

public class Tutu {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入菱形的对角线长度： ");
        int h = sc.nextInt();
        for (int i =0; i <h; i++) {

           for (int j = 1; j <h- i; j++) {
                System.out.print(" ");
            }
            for (int k = 0; k <= i; k++) {
                System.out.print("*");
            }for (int m=0;m<i;m++){
                System.out.print("*");
            }

            System.out.println();

        }
        for (int i =1; i <h; i++) {

            for (int f = 1; f <=i; f++) {
                System.out.print(" ");
            }//第一个for控制行数,第二个内循环for控制个数//
            for  (int b = 1; b <=h-i; b++) {
                System.out.print("*");
            }for (int c=2;c<=h-i;c++){
                System.out.print("*");
            }


            System.out.println();//换行，不然会接着编写//
        }
    }}

流程跳转（基于控制条件）：

break；结束本次循环，终止本次循环体内容的执行，也就是说结束当前的整个循环——witch语句原理是跳转到caseX位置执行剩下所有的语句（包括其他case里面的），直到最后或者遇见break为止。因此在每一条语句最后+break即可。
因此不加break的话将会执行跳转到的case本身以及以下所有的语句。

continue：跳过本次循环，进入下轮循环

return：表示返回一个方法返回的值或者一个方法退出并返回那个值。