JavaSE基础篇—流程控制语句

本章知识点分析：

流程控制语句

　　　　定义：流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。流程控

　　制方式采用结构化程序设计中规定的三种基本流程机构：顺序结构    分支结构    循环结构

　　　　　　　　　　　　　　

1.选择结构(重点)：if-else　　switch : case

　　　1.1.  if单分支选择结构

　　　　

　　　　if语句对布尔表达式进行一此测试，若测试为真，执行下面的语句，否则跳过该语句。

　　　1.2 if双分支选择结构

　　　if双分支语句当布尔表达式结果为真时，执行代码块1，否则执行代码块2。

　　　1.3 if—else  多分支选择结构

　　　　if(布尔表达式1) { 语句块1； } else if(布尔表达式2) { 语句块2； }……… else if(布尔表达式n){ 语句块n; } else { 语句块n+1; }

　　　1.4switch多值选择结构

　　　　switch(A)case:A的类型可以为：byte  int  short char String emun

　　　　原理：switch后面的内容是一个具体的数值，不是一个取件，得到这个值后会依次和case后面的数值进行比较，假如满足，那么执行case后面的代码，要是执行后面的代码那么在后面加上break。

　　　　default分支：起到"备胎"的作用。可以放在任意位置，如果不是在最后一行，那么必须加break。　　

　　　　switch能解决的问题，用if—else都可以解决，但是用if能解决的问题，switch不一定能解决。

　　

/*
实现一个功能：
给出一个学生的成绩，根据成绩判断学生的等级:
>=90  -----A
>=80  -----B
>=70  -----C
>=60  -----D
<60   -----E
*/
public class Test2{
    public static void main(String[] args) {
        //先给出一个学生的成绩
        int score = ;
        //定义一个变量记录学生成绩的等级
        String level = "";
        switch(score/){
            case :
            case :
                level = "A";break;
            case :
                level = "B";
                break;
            case :
                level = "C";
                break;
            case :
                level = "D";
                break;
            default:
                break;
        }
    }
}

2.顺序结构(重点)：while循环　　do-while循环　　for循环

　　2.1.while循环：

　　在循环开始的时候会有一个布尔表达式的值，若条件为真，则执行循环体，而后在后面的每一次循环都会先计算一次布尔表达式，真则循环，否则不循环，所以布尔表达式是while循环的最后执行的条件。

　　循环的条件：① 有初始化值(只执行一次)

　　　　　　　　② 有循环条件(循环最后执行的条件)

　　　　　　　　③循环体

　　　　　　　　④迭代器

　　　　　　　　

　　2.2.do-while循环　　

　　循环的条件： ① 有初始化值(只执行一次)

　　　　　　　　 ② 有循环条件(循环最后执行的条件)

　　　　　　　　 ③循环体

　　　　　　　　 ④迭代器

　　do-while循环和while循环的区别：while是先判断再循环。do-while循环是先循环一次，再进行判断

　　一般不能确定循环次数的时候使用while或者do-while循环

　　　　　　　　

　　2.3for循环(重点)

　　　　for循环语句是支持迭代(还有for-each，迭代器)的一种通用结构，是最有效、最灵活的循环结构。

　　　　循环的条件：(初始化条件;循环条件;迭代){循环体}

　　　　　　

　　　　注意事项：①初始化条件可以放到外面　　for(;循环条件;迭代){循环体}  作用于变大；

　　　　　　　　　②缺少迭代条件或者循环条件，或者所有条件，循环就会变成死循环；

　　　　　　　　　③在for循环循环的初始化条件中声明的变量作用于整个for循环体

例题1：用while和for循环计算 100以内的所有奇数的和和偶数的和，并输出　

　　用while循环处理　　　

public class Text1 {
    public static void main(String[] args) {
        int n =0;
        int sum = 0;    //和
        while(n <= 100){
            if(n % 2 != 0){
                sum = sum + n;
            }
            n++;
        }
        System.out.println(sum);
    }
}

　　使用for循环解决

public class Text1 {
    public static void main(String[] args) {
        int sum = 0;
        for(int i = 0;i<=100;i++){
            if(i % 2 == 0){
                sum = sum + i;
            }
        }
        System.out.println(sum);
    }
}

例题2：用while和for循环输出1-1000之间能被5整除的数，并且每行输出3个

　　使用while循环

public class Test2 {
    public static void main(String[] args) {
        int n = 1;
        int sum = 0;
        int count = 0;         //计算数字个数
        while(n <=1000){
            if(n % 5 == 0){
                //sum = sum + n;
                System.out.print(n+"\t");
                count++;
                if(count % 3 == 0){
                    System.out.println();
                }
            }
            n++;
        }
    }
}

　　使用for循环

public class Text1 {
    public static void main(String[] args) {
        int count = 0;
        //for循环条件限定循环范围 1~1000
        for(int i = 1;i <= 1000;i++){
            if(i % 5 ==0){
                count++;
                System.out.print(i+"\t");
                if(count % 3 == 0){
                    System.out.println();
                }
            }
        }
    }
}

 3.跳转语句　　break　　continue　　return

　　break：在任何循环语句的控制的主体部分，均可使用break控制循环的流程，break用于强制退出循环，不执行循环中剩余的部分。break也可以用于swicth多分支语句中。

　　continue:在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否进行循环的判定。

//实现一个功能：1-100求和，在和第一次大于300的时候，停止程序。
public class Test2 {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        for (i = 0;i<=100;i++){
            if(sum <= 300){
                sum = sum + i;
            }else {
                System.out.println(i);
                System.out.println(sum);
                break;
            }
        }
    }
}

break的作用:1.switch配合使用，停止case后面代码块的执行

　　　　　   2.强行退出循环，不执行循环剩余的代码块，多用于switch中

/ /实现一个功能：输出1-100中被5整除的数：

public class Test2{
    public static void main(String[] args) {
        for(int i = 1;i<=100;i++){
            if(i % 5 != 0){
                continue;
            }
            System.out.println(i);
        }
    }
}

/**
 * 实现一个功能： 请输入10个整数，当输入的数是666的时候，退出程序。
              判断其中录入正数的个数并输出。
              判断系统的退出状态：是正常退出还是被迫退出。
 */
import java.util.Scanner;
public class Test2{
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int count = 0;    //用来计数
        boolean flag = true;    //判断是否是正常退出
        for(int i = 1;i<=10;i++){
            System.out.println("请输入第"+(count+1)+"位整数：");
            int num = input.nextInt();
            if(num > 0){
                count++;
            }
            if(num == 666){
                flag = false;
                break;
            }
        }
        System.out.println("输入正确整数共"+count+"个");
        if(flag){
            System.out.println("正常退出");
        }else {
            System.out.println("遇到666被迫退出");
        }
    }
}

continue的作用:语句用在循环语句中，用于终止某次循环循环过程，即跳过循环体中尚未执行的语句，接着执行下一次是否执行循环的判定。

/**
 * 请输入1~100内的前30位整数
 */
public class Test2{
    public static void main(String[] args) {
        for(int i = 0; i<=100;i++){
            if(i == 30){
                break;
            }
            System.out.println(i);    //打印0~29
        }
        System.out.println("打印结束");    //会打印
    }
}

/**
 * 请输入1~100内的前30位整数
 */
public class Test2{
    public static void main(String[] args) {
        for(int i = 0; i<=100;i++){
            if(i == 30){
                return;
            }
            System.out.println(i);    //打印1~29
        }
        System.out.println("打印结束");    //不会打印
    }
}

return的作用：return结束的是整个方法。从当前方法退出，返回到调用该方法的语句处，并从该条语句的下条语句处继续执行程序。

4.多重循环(循环嵌套)　　　　

　　　　多重循环:一个循环体内又包含另一个完整的循环体结构。

　　　任意两个循环体都可以相互嵌套使用，其中外层循环控制行的个数，内层循环控制列的个数；可以任意层次的嵌套，但是一般不超过三层。

练习1：打印矩形

 public class Test2{
     public static void main(String[] args) {
         for(int i = 0;i<=5;i++){
             for(int j = 0;j<=10;j++){
                 System.out.print(" "+"*"+" ");
             }
             System.out.println();
         }
     }
 }

练习2：打印九九乘法表

public class Test2{
    public static void main(String[] args) {
        for(int i = 1;i<=9;i++){    //外层循环控制行数
            for(int j = 1;j<=i;j++){    //内层循环控制列数
                System.out.print(j+"*"+i+"="+i*j+"\t");
            }
            System.out.println();
        }
    }
}