java中流程控制和循环结构

java中的流程控制分为三种,任何的复杂业务逻辑都可以通过这三种结构来实现！
1.顺序结构：代码逐语句执行！也叫顺序执行，每句必走！
2.分支结构：有条件的执行某个语句，并非每句都走！
3.循环结构：有条件的重复执行某个语句，并非每句都走！

例如：
购物满 500 打8折 ------------条件是满足购物金额500 -------- 打8折 ------单路分支
if(条件){
}
购物满 500 打8折 不满则打9折 ------条件是满足购物金额500-- 打8折
不满足就打9折 -------双路分支
if(条件){
条件满足所执行的代码块
}else {
条件不满满足所执行的代码块
}

​单路分支：

package day05;
​
import java.util.Scanner;
​
/**
 * 单路分支的语法演示:
 * */
public class IFDemo {
    public static void main(String[] args) {
        /** 单路分支的语法结构：
         *   语法:
         *          if(条件){
         *              //满足条件所执行的代码块
         *          }
         *   执行过程：
         *          先去判断if小括号中的条件是否成立
         *          若成立  则执行当前对应的代码块
         *          若不成立 程序跳过当前的if的代码块 继续往下执行
         * */
        // 购物金额满 500 打8折  ------------条件是满足购物金额500 -------- 打8折
        Scanner s = new Scanner(System.in);//创建一个扫描器
        double price = s.nextDouble();//金额499
        if(price >= 500){//如果金额 大于等于500
            price *= 0.8;//price = price * 0.8;   金额打8折
            System.out.println("打完折后应付"+price);
        }
        System.out.println("用户已付款 付款金额"+price);
    }
}

双路分支：

package day05;
​
import java.util.Scanner;
​
/**
 *  双路分支的演示类
 * */
public class IFElseDemo {
​
    public static void main(String[] args) {
            /** 双路分支的语法演示：
             *       语法：
             *            if(条件){
             *                  满足则执行的代码块
             *            } else {
             *                  不满足则执行的代码块
             *            }
             *      执行过程：
             *          先去判断if小括号的条件
             *          若成立  则执行满足所执行的代码块
             *          若不成立 则执行不满足所执行的代码块！
             * */
//        购物满 500 打8折 不满则打9折 ------条件是满足购物金额500-- 打8折
//                不满足就打9折
        Scanner s = new Scanner(System.in);//创建一个扫描器
        System.out.println("请输入购物的金额");
        double price = s.nextDouble();//获取控制台输入的金额
        if(price >= 500){//如果金额 大于等于500
            price *= 0.8;//打8折    -------------------20：46 上课
            System.out.println("打完8折后应付"+price);
        }else {
            price *= 0.9;//打9折
            System.out.println("打完9折后应付"+price);
        }
​
        System.out.println("用户已付款 付款金额"+price);
    }
}

多路分支:

package day05;
​
import java.util.Scanner;
​
/**
 * 多路分支的演示类：
 * */
public class IFElseIFDemo {
    public static void main(String[] args) {
        /** 多路分支的语法结构：
         *  语法：
         *       if(条件1){
         *          若条件1成立则执行的代码块
         *       } else if(条件2){
         *          若条件2成立则执行的代码块
         *       }else if(条件3){
         *          若条件3成立则执行的代码块
         *       }else{ 否则
         *          该代码块是上述的条件全部不成立 则会走该代码块
         *       }
         *  执行过程：
         *          先判断条件1 若条件1满足 则走条件1的代码块 否则
         *          再判断条件2 若条件2满足 则走条件2的代码块 否则
         *          再判断条件3 若条件3满足 则走条件3的代码块 否则
         *          执行否则对应的代码块
         * */
        /*
        *   根据用户输入的成绩，来判断学生的学习等级
        *   分数  score
        *   1.分数大于等于 90 输出优秀！
        *   2.分数小于90 并且 大于等于 80 输出 良好！
        *   3.分数小于80 并且 大于等于 70 输出 一般！
        *   4.分数小于70 并且 大于等于 60 输出 及格！
        *   5.否则 不及格！
        * */
        Scanner s = new Scanner(System.in);//创建一个扫描器
        System.out.println("请输入分数！");
        double score = s.nextDouble();//获取用户输入的分数存入 score
        if(score >= 90){
            System.out.println("优秀！");
        }else if ( score >= 80 ){
            System.out.println("良好");
        }else if ( score >= 70 ){
            System.out.println("一般");
        }else if ( score >= 60 ){
            System.out.println("及格！");
        }else {
            System.out.println("不及格！");
        }
        System.out.println("程序继续执行....");
    }
}
​

练习：

     *          通过控制台的方式 获取用户的年龄
     *          对 int age 年龄进行判定
     *          1.如果 age 大于等于0 并且 小于 5    输出 幼年
     *          2.如果 age 大于等于5 并且 小于 18   输出 青年
     *          3.如果 age 大于等于18 并且 小于 35   输出 成年
     *          4.如果 age 大于等于35 并且 小于 50   输出 中年
     *          5.如果 age 大于等于50 并且 小于 65   输出 中老年
     *          6.如果 age 大于等于65 并且 小于等于 150   输出 老年
     *          如果上述条件不成立 输出年龄不合法。

​Switch case 多路分支结构

适用性：只能对整数进行判定是否相等(不包含long)若相等则走对应的代码块 JDK1.7以后支持String判断的内容。
不能匹配逻辑运算符的内容，只能匹配单值
主要作用就是判断是否相等的意思！
优点：判断单值整数类型的数据 效率优于 if elseif结构！
break : 代表的就是退出当前switch 的代码块
default：相当于else ，上面的case都没匹配上，则执行default的内容！

package day05;
​
import java.util.Scanner;
​
/**
 *  switch Case 使用演示类：
 * */
public class SwitchCaseDemo {
​
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("中文请按1,英文请按2,人工服务请按0");
        int type = s.nextInt();//接收用户的指令类型
         //long l = 100L;
        switch (type){ //小括号只能放 整数类型变量(long不可以)
            case 1: //case 后面只能放直接量
                System.out.println("中文服务开始！");
                break;//退出当前switch 的代码块
            case 2:
                System.out.println("英文服务开始了！");
                break;//退出当前switch 的代码块
            case 0:
                System.out.println("人工服务开始了！");
                break;//退出当前switch 的代码块
            default://默认的  若上述都没匹配上 则执行默认的！
                System.out.println("输入的指令不存在..");
        }
        System.out.println("程序继续执行");
    }
}

循环结构：

循环：字面意思代表就是重复执行某段代码。反反复复的过程 ，称之为循环。
Java循环结构有三种： 1.while 2.do…while 3.for(使用率最高)
循环的语法三要素： 1.循环变量的初始化 2.基于循环变量的一个条件 3.循环变量的改变(朝着目标去改变)

跑三圈
初始圈数 圈数为0
够三圈吗? 不够 跑一圈 圈数为1
够三圈吗? 不够 跑一圈 圈数为2
够三圈吗? 不够 跑一圈 圈数为3
够三圈吗? 够了 不跑了
三要素：
1. int count = 0; //循环变量的初始化
2. count < 3; //基于循环变量的一个条件
3. count++; //循环变量的改变

打印6份简历
初始份数 份数为0
够6份吗? 不够 打印一份 份数为1
够6份吗? 不够 打印一份 份数为2
够6份吗? 不够 打印一份 份数为3
够6份吗? 不够 打印一份 份数为4
够6份吗? 不够 打印一份 份数为5
够6份吗? 不够 打印一份 份数为6
够6份吗? 够了 不打印了…
三要素：
1.int number = 0;//循环变量的初始化
2. number < 6; // 基于循环变量的一个条件
3. number++;

​while：

package day06;
/**
 * while 循环的使用演示：
 * */
public class WhileDemo {
    public static void main(String[] args) {
        /** while 循环的语法结构
         *        三要素： 1.循环变量的初始化  2.基于循环变量的一个条件  3.循环变量的改变
         *        1.
         *        while(2.){
         *            要循环的代码块
         *            3.
         *        }
         *     执行过程：
         *              先判断 while小括号中的条件是否成立
         *              若成立   执行一次循环的代码块
         *              再去判断while小括号中的条件是否成立
         *              若成立   执行一次循环的代码块
         *              ....
         *              直至 小括号中条件不成立 则程序继续往下执行..
         * */
        // 行动是成功的阶梯！ 我是最棒的！  X3
//        int count = 0;//1.循环变量初始化
//        while(count < 3){//2.基于循环变量的一个条件W
//            System.out.println("行动是成功的阶梯！ 我是最棒的！");
//            count++;//3.
//        }
//        System.out.println("程序继续往下执行......");
        //  练习：使用while 循环 让 小明同学  跑10圈...
        int number = 0;
        while(number < 10){
            System.out.println("小明同学跑" + (number+1) + "圈");
            number++;
        }
        System.out.println("小明同学已经跑完10圈了..再也不杠了！");
​
    }
}
​

do…while:

//打印输出     冲冲冲！！！ X3
        int count = 0;//1.
        do {
            System.out.println(" 冲冲冲！！！");
            count++;//3.
        }while(count < 3);//2.
        System.out.println("程序继续往下执行....");

while 和 do…whlie 区别：

相同点：当不明确循环次数，但是已知循环条件时，可以选择while 和 do…whlie
不同点：
while循环一定是先判断条件再决定是否执行循环体！ 如果可能一次都不做 用while
do…while循环一定先做一次循环体的代码块，再去判断条件！至少做一次 用do…while

for循环：最常用的循环

package day06;
​
/**
 * for 循环的演示类：
 */
public class ForDemo {
    public static void main(String[] args) {
        /** for 循环语法演示：
         *  三要素： 1.循环变量的初始化  2.基于循环变量的一个条件  3.循环变量的改变
         *      for(①int i = 0;②i < 3;③i++){
         *           //④循环体
         *      }
         *  执行过程：
         *        先执行  ① --------②---------④
         *        再执行  ③ --------②---------④-------③ --------②---------④
         *        直至当前 ② 不满足条件  循环体不再继续做了 代码继续往后执行
         * */
//        for (int i = 0; i < 3; i++) {
//            System.out.println("同学们继续加油！！！");
//        }
//        System.out.println("程序继续往后执行....");
        //循环10次，输出1~10之间的偶数 如果是奇数输出奇数
        //continue关键字：遇到continue关键字 代表中止当次循环，直接执行下次循环
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) {
                System.out.println(i + "是偶数");
                continue;//代表中止当次循环，直接执行下次循环
            }
            System.out.println(i + "是奇数");
        }
        //-----------break 在循环中表示的是终止循环 或者说叫退出循环！
        for (int i = 1; i <= 10; i++) {
            if (i > 5) {
                System.out.println("腾飞同学肚子疼....剩下圈数不能再跑了");
                break;//退出了循环
            }
            System.out.println("腾飞同学跑了第" + i + "圈");
        }
        Stem.out.println("让孩子歇歇吧...");
    }
}

for循环小括号里面声明的变量，作用域只在当前这个for内部，其它地方视为看不见。

 for (int i = 1; i <= 10; i++) {
     
 }
 for (int i = 1; i <= 10; i++) { //再次使用int i 这个变量并不与上面的冲突！
     
 }

练习题：

随机10道加法试题：

(1) 10 + 23 = ?
    请回答！
    33
    恭喜你答对了！
(2) 67 + 99 = ？
    请回答！
    1000
    很遗憾答错了！
........
(10) 1 + 1 =?
    请回答！
    2
    恭喜你答对了！
总共答对了多少道题！分数为多少，程序判定此成绩为 例如 优秀！
    ---------------------------------------------------------
     //随机10道加法的练习题
        Scanner s = new Scanner(System.in);//创建一个扫描器
        //1.出题   2.答题   3.判题
        /*          随机0~100
                (1) 10 + 23 = ?
              请回答！
        * */
        int score = 0;//分数
        for(int i = 0;i < 10;i++ ) {
            int number1 = (int) (Math.random() * 100);//随机一个0~100的数据
            int number2 = (int) (Math.random() * 100);//随机一个0~100的数据
            System.out.println("("+ (i+1)+")" + number1 + "+" + number2 + "= ?");
            System.out.println("请回答！");
            int user = s.nextInt();//接收用户输入的数据
            if (user == (number1 + number2)) {//判断用户输入的数据与系统产生的两个数据和是否相等
                score += 10;
                System.out.println("恭喜你 答对了！");
            } else {
                System.out.println("很遗憾 答错了！");
            }
        }
        System.out.println("成绩为："+score);

双重for循环
外层for循环控制行数，内层for循环控制列数。
外层for循环控制轮数，内层for循环控制次数。

//外层循环 执行一次
        for(int num = 1;num <= 9; num++) {
            //内层循环 执行多次 但是内层循环做几次取决于内层循环的条件！
            for (int i = 1; i <= num; i++) {
                System.out.print(i + "*" + num + "=" + (i * num) + "\t");
            }
            System.out.println();//换行
        }

 //5行6列的*
        //外层for循环控制行数，内层for循环控制列数。
        for (int i = 1; i <= 5; i++) {//行数
​
            for (int j = 1; j <= 6; j++) {//列数
                System.out.print("*");
            }
            System.out.println();
        }