流程控制语句

最新推荐文章于 2024-01-24 15:05:22 发布

_梧桐树。

最新推荐文章于 2024-01-24 15:05:22 发布

阅读量130

点赞数

分类专栏： Java Core 文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_45546075/article/details/128948328

版权

Java Core 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

【1】单分支：

public class T {
    public static void main(String[] args) {
        //功能：随机录入三个数（1-6），求和，根据和的大小选择奖品。
        //三个数
        int num1 = 3;
        int num2 = 1;
        int num3 = 1;

        //求和：
        int sum = 0;
        sum += num1;
        sum += num2;
        sum += num3;

        System.out.println("三个数的和是：" + sum);

        //根据和的大小选择奖品
        if (sum >= 12)
            System.out.println("恭喜你，获得了一等奖！");
        System.out.println("你很幸运啊。。。");

        if (sum >= 9 && sum < 12) {
            System.out.println("恭喜你，获得了二等奖！");
        }

        if (sum >= 6 && sum < 9) {
            System.out.println("恭喜你，获得了三等奖！");
        }

        if (sum < 6) {
            System.out.println("谢谢惠顾！");
        }              
                
                /*
                1.上面的代码中，我写了4个if的分支，每个都是一个单分支，四个单分支组成了四个选择。
                   上面的四个分支，是从上至下顺序执行的，是不可逆的过程。
                2.单分支原理：
                if(){}
                ()中是一个条件表达式，这个表达式返回的结果是要么是true要么是false
                假如返回的是true，就执行后面{}中的代码。假如返回的是false，就不执行后面{}的代码。
                
                3.if后面的{}可以省略不写，但是假如省略了，那么if只负责后面一句话，
                  所以我们一般在自己写代码的时候，建议：写着{} 
                  
                4.单分支缺点：
                我们这道题的代码，是想多个分支里面走一个，所以假如走了一个分支，后面的分支就不想走了，
                按照单分支的特点来说，是要每个都顺序执行的，效率相对较低
                
                5.优化：不用单分支，用多分支：
                */

    }

}

【2】多分支：

public class T {
    public static void main(String[] args) {
        //功能：随机录入三个数（1-6），求和，根据和的大小选择奖品。
        //三个数
        int num1 = 3;
        int num2 = 1;
        int num3 = 1;

        //求和：
        int sum = 0;
        sum += num1;
        sum += num2;
        sum += num3;

        System.out.println("三个数的和是：" + sum);

        //根据和的大小选择奖品
        if (sum >= 12) {
            System.out.println("1等奖");
        } else if (sum >= 9) {//else-->sum<12
            System.out.println("2等奖");
        } else if (sum >= 6) {//else--->sum<9
            System.out.println("3等奖");
        } else {//sum<6
            System.out.println("末等奖");
        }
                
                /*
                1.if(){}elseif(){}elseif(){}else  这是一条语句，一个多分支有多个选择。
                   并且这些分支里面只走一个，假如走了某个分支，后面的分支就不会再判断不会走了，效率比单分支高。
                2.if    else if   ---》else 隐藏条件:跟上面相反的可能性
                3.建议：建议你写的多分支中有最后的那个else
                  最后的else做一个“兜底”的功能。
                */


    }

}

【3】双分支：

public class T {
    public static void main(String[] args) {
        //功能：随机录入三个数（1-6），求和，根据和的大小选择奖品。
        //三个数
        int num1 = 3;
        int num2 = 1;
        int num3 = 1;

        //求和：
        int sum = 0;
        sum += num1;
        sum += num2;
        sum += num3;

        System.out.println("三个数的和是：" + sum);

        //根据和的大小选择奖品
        if (sum >= 12) {
            System.out.println("中奖了");
        } else {//sum<12
            System.out.println("没中奖");
        }
        System.out.println(sum >= 12 ? "中奖了" : "没中奖");
    }
}

【4】随机数：

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

        double num1 = Math.random();
        double num2 = Math.random();
        double num3 = Math.random();
        System.out.println("num1=" + num1);
        System.out.println("num2=" + num2);
        System.out.println("num3=" + num3);

        int num4 = (int) (Math.random() * 6);
        int num5 = (int) (Math.random() * 6);
        int num6 = (int) (Math.random() * 6);
        System.out.println("num4=" + num4);
        System.out.println("num5=" + num5);
        System.out.println("num6=" + num6);

        int num7 = (int) (Math.random() * 6) + 1;
        int num8 = (int) (Math.random() * 6) + 1;
        int num9 = (int) (Math.random() * 6) + 1;
        System.out.println("num7=" + num7);
        System.out.println("num8=" + num8);
        System.out.println("num9=" + num9);


    }
}

【5】总结：

if

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

        //录入会员积分，按照积分打折：
        //录入会员积分：
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入你的积分：");

        //判断：录入的是否是一个int类型的数：
        if (sc.hasNextInt()) {//hasNextInt()判断录入的是否是一个int类型的数，是返回true，不是返回的是false
            int credits = sc.nextInt();
            //判断：
            if (credits >= 5000) {
                System.out.println("6折");
            } else if (credits >= 3000) {
                System.out.println("7折");
            } else if (credits >= 1000) {
                System.out.println("8折");
            } else {
                System.out.println("9折");
            }

        } else {
            System.out.println("录入错误，必须要录入一个整数！");
        }

    }
}

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

        //键盘录入学生的成绩，按照成绩划分等级：
        //键盘录入成绩：
        int score = 44;
        //按照成绩划分等级
        switch (score / 10) {
            case 1:
                System.out.println("A级");
                break;
            case 2:
                System.out.println("B级");
                break;
            case 3:
                System.out.println("C级");
                break;
            case 4:
                System.out.println("D级");
                break;
            case 5:
                System.out.println("E级");
                break;
            default:
                System.out.println("error");
                break;
        }
                /*
                1.分支switch后面是一个(),()中返回的是一个等值
                 这个值可以是：byte,int,char,short,JDK1.5之后可以使用枚举，JDK1.7之后，可以使用String
                2.将这个等值依次跟{}中的case后面的数值进行比较：假如满足（匹配），就执行：后面的代码。
                   为了防止“穿透”，每个分支后面要加上一个关键字叫：break
                3.也有一个“兜底”功能的分支：default，如果default在最后一行，就不需要加break了，但是要是
                在中间某一行，那么为了防止“穿透”，必须后面加上break
                4.假如相连的某些分支中代码执行一样，那么可以删除只留最后一个即可。
                5.if和switch哪个好？
                switch能解决的问题，if都可以解决。但是if能解决的问题switch不一定能解决。
                if后面的()中可以加等值判断，也可以加区间判断，只要返回true和false即可
                但是switch只能利用等值判断。只能用固定的类型。
                switch：我们的等值判断基本用的switch偏多。
                */

    }
}

public class T {
    public static void main(String[] args) {
        //做一个简单的计算器功能：
        //1.录入第一个数
        Scanner sc = new Scanner(System.in);
        System.out.print("请录入第一个操作数：");
        int num1 = sc.nextInt();

        //2.录入第二个数
        System.out.print("请录入第二个操作数：");
        int num2 = sc.nextInt();


        //3.录入运算符
        System.out.print("请录入运算符---：+,-,*,/");
        String ope = sc.next();//键盘录入字符串

        //4.根据运算符进行计算：
        switch (ope) {
            case "+":
                System.out.print("结果为：" + (num1 + num2));
                break;
            case "-":
                System.out.print("结果为：" + (num1 - num2));
                break;
            case "*":
                System.out.print("结果为：" + (num1 * num2));
                break;
            case "/":
                if (num2 != 0) {
                    System.out.print("结果为：" + (num1 / num2));
                } else {
                    System.out.print("除数不能为0！");
                }
                break;
        }

    }
}

public class T {
    public static void main(String[] args) {
        //功能：求和：1+2+3+4+5
        int i = 1;//【1】条件初始化
        int sum = 0;//sum--》接收和的
        while (i <= 5) {//【2】条件判断
            sum = sum + i;//【3】循环体
            i++;//【4】迭代
        }
        System.out.println("和是：" + sum);//15
                /*
                1.什么情况下想到用循环解决问题的：
                   在代码多次有规律重复的情况下
                2.while后面是一个(),这个()中返回的是一个布尔值：true，false
                  在第一次循环的时候，判断()的内容，如果是true就执行{}中内容，
                  在第二次循环以后，每一次循环还是要走这个判断的。

                PS:()中要是直接写一个true，就是死循环了。

                3.循环执行过程：
                最开始：i=1   sum=0
                第1次循环：i<=5---》满足，执行：sum=1  , i=2
                第2次循环：i<=5---》满足，执行：sum=3   ,i=3
                第3次循环：i<=5---》满足，执行：sum=6  ,i=4
                第4次循环：i<=5---》满足，执行：sum=10 ,i=5
                第5次循环：i<=5---》满足，执行：sum=15 ,i=6
                第6次循环：i<=5---》不满足，循环停止。

                结论：循环只是减少了程序员的工作，而不是减少了计算机底层的工作。

                4.循环的组成：
                【1】条件初始化  【2】条件判断  【3】循环体   【4】迭代
                总结：初始化什么，就判断什么。判断什么就执行什么。执行什么就迭代什么。
                上面四步骤的执行过程：
                【1】【2】【3】【4】【2】【3】【4】【2】【3】【4】
                */
    }
}

public class T {
    public static void main(String[] args) {
        //1+2+3+4+5
        int i = 16;//条件初始化
        int sum = 0;
        do {
            sum = sum + i;//循环体
            i++;//迭代
        } while (i <= 5);//条件判断---->后面必须加上;，否则编译报错

        System.out.println(i);//17
        System.out.println(sum);//16
                
                /*
                int i=16;
                int sum=0;
                while(i<=5){
                        sum=sum+i;
                        i++;
                }	
                System.out.println(i);//16
                System.out.println("和是："+sum);	//0
                */
                
                
                
                /*
                1.while和do-while的区别：
                        while :先判断，再执行。很可能一次都不执行。
                        do-while:先执行，再判断，无论如何都会被执行一次。
                
                2.在什么情况下只能用do-while呢?
                      考试  批卷   是否及格 
                          
                          while(是否及格 ){
                                  考试  批卷 
                          }
                          ----不合适
                          
                          
                          do{
                                  考试  批卷
                          }while(是否及格)
                      ----合适
                
                */
    }
}

public class T {
    public static void main(String[] args) {
        //1+2+3+4+5:
        int sum = 0;
        int i;
        for (i = 16; i <= 5; i++) {
            sum += i;
        }
        System.out.println(i);
        System.out.println(sum);
                /*
                1.for格式：
                for([1]条件初始化;[2]条件判断;[3]迭代){
                        [4]循环体;
                }
                
                2.执行顺序：
                [1][2][4][3][2][4][3][2][4][3]
                
                3.利用for循环代码简单，所以以后相对比较常用。特别是：循环数量固定的情况。
                
                4.for循环  格式特别灵活  ：但是你自己写代码 别太灵活了 怕你理解不了 
                
                5.for死循环：   
                for(;;){
                        //....
                }
                
                6.while,do-while,for谁的效率最高？一样的
                  谁的效率最高：高斯算法最高 。102*50=5050
                
                */
    }
}

public class T {
    public static void main(String[] args) {
        //输出1-100中被3整除的数，每行输出5个：
        int count = 0;//计数器：其实就是定义一个变量，自增操作
        for (int i = 1; i <= 100; i++) {
            if (i % 3 == 0) {//被3整除的数
                System.out.print(i + "\t");
                count++;
                if (count % 5 == 0) {
                    System.out.println();
                }
            }
        }
    }
}

public class T {
    public static void main(String[] args) {
        //1-100求和，当和第一次大于405的时候，停止程序。
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
            if (sum > 405) {
                break;//结束(最近的)循环。
            }
            System.out.println(sum);
        }
    }
}

public class T {
    public static void main(String[] args) {
                //break:结束最近的循环
                /*
                for(int i=1;i<=100;i++){
                        if(i==33){
                                break;
                        }
                        System.out.println(i);
                }
                */

        for (int i = 1; i <= 100; i++) {
            while (i == 33) {
                break;
            }
            System.out.println(i);
        }
    }
}

【1】continue:

public class T {
    public static void main(String[] args) {
        //输出1-100中被5整除的数：
        //方式1：
        /*for(int i=1;i<=100;i++){
                if(i%5==0){
                        System.out.println(i);
                }
        }*/
        //方式2：
        for (int i = 1; i <= 100; i++) {
            if (i % 5 != 0) {
                continue;//跳出当前循环，进行下一次循环。
            }
            System.out.println(i);
        }
    }
}

【2】continue深入：

public class T {
    public static void main(String[] args) {
        //continue:跳出当前循环，进行下一次循环：
        /*
        for(int i=1;i<=100;i++){
                if(i==33){
                        continue;
                }
                System.out.println(i);
        }
        */

        for (int i = 1; i <= 100; i++) {
            while (i == 33) {
                continue;
            }
            System.out.println(i);
        }

    }
}

【3】return：

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

        for (int i = 1; i <= 100; i++) {
            if (i == 33) {
                return;//结束当前的方法
            }
            System.out.println(i);
        }

        System.out.println("aaaaaq");
    }
}

/*
   实现一个功能： 【1】请录入10个整数，当输入的数是666的时候，退出程序。
               【2】判断其中录入正数的个数并输出。
               【3】判断系统的退出状态：是正常退出还是被迫退出。
*/
public class T {
    public static void main(String[] args) {

        //请录入10个整数
        Scanner sc = new Scanner(System.in);
        //计数器：
        int count = 0;
        boolean flag = true;//把它理解成一个“开关”，暂定true就是开关开着的。
        for (int i = 1; i <= 10; i++) {
            System.out.print("请录入第" + i + "个数：");
            int num = sc.nextInt();
            //判断其中录入正数的个数
            if (num > 0) {
                count++;
            }
            //当输入的数是666的时候，退出程序。
            if (num == 666) {
                flag = false;
                break;
            }
        }

        System.out.println("正数的个数是：" + count);

        if (flag) {
            System.out.println("正常退出");
        } else {
            System.out.println("被迫退出");
        }

    }
}

【4】总结：
break:结束最近的循环
continue:跳出当前循环，进入下一次循环
return:结束当前方法

/*
乘法口诀：
1*1=1
1*2=2   2*2=4
1*3=3   2*3=6   3*3=9
1*4=4   2*4=8   3*4=12  4*4=16
1*5=5   2*5=10  3*5=15  4*5=20  5*5=25
1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36
1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49
1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64
1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81
*/
public class T {
    public static void main(String[] args) {

        //1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36
                /*
                System.out.print("1*6=6"+"\t");
                System.out.print("2*6=12"+"\t");
                System.out.print("3*6=18"+"\t");
                System.out.print("4*6=24"+"\t");
                System.out.print("5*6=30"+"\t");
                System.out.print("6*6=36"+"\t");
                */
                /*
                for(int i=1;i<=6;i++){
                        System.out.print(i+"*6="+i*6+"\t");
                }
                //换行：
                System.out.println();


                //1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49
                for(int i=1;i<=7;i++){
                        System.out.print(i+"*7="+i*7+"\t");
                }
                //换行：
                System.out.println();


                //1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64
                for(int i=1;i<=8;i++){
                        System.out.print(i+"*8="+i*8+"\t");
                }
                //换行：
                System.out.println();
                */

        for (int j = 1; j <= 9; j++) {
            for (int i = 1; i <= j; i++) {
                System.out.print(i + "*" + j + "=" + i * j + "\t");
            }
            //换行：
            System.out.println();
        }
    }
}

/*
1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81
1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64
1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49
1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36
1*5=5   2*5=10  3*5=15  4*5=20  5*5=25
1*4=4   2*4=8   3*4=12  4*4=16
1*3=3   2*3=6   3*3=9
1*2=2   2*2=4
1*1=1
*/
public class T {
    public static void main(String[] args) {
        for (int j = 9; j >= 1; j--) {
            for (int i = 1; i <= j; i++) {
                System.out.print(i + "*" + j + "=" + i * j + "\t");
            }
            //换行：
            System.out.println();
        }
    }
}

【1】矩形：

public class T {
    public static void main(String[] args) {
         /*
                打印各种形状：
                **********
                **********
                **********
                **********
                */

        for (int j = 1; j <= 4; j++) {//j:控制行数
            //**********
            for (int i = 1; i <= 10; i++) {//i:控制每行的*的个数
                System.out.print("*");
            }
            //换行：
            System.out.println();//换行
        }
    }
}

【2】平行四边形：

public class T {
    public static void main(String[] args) {
        /*
        打印各种形状：
             **********
            **********
           **********
          **********
        */
        for (int j = 1; j <= 4; j++) {//j:控制行数
            //加入空格：
            for (int i = 1; i <= (6 - j); i++) {
                System.out.print(" ");
            }


            //**********
            for (int i = 1; i <= 10; i++) {//i:控制每行的*的个数
                System.out.print("*");
            }
            //换行：
            System.out.println();//换行
        }
    }
}

【3】三角形：

public class T {
    public static void main(String[] args) {
        /*
          打印各种形状：
             *
            ***
           *****
          *******
        */

        for (int j = 1; j <= 4; j++) {//j:控制行数
            //加入空格：
            for (int i = 1; i <= (6 - j); i++) {//i:每行的空格数
                System.out.print(" ");
            }


            //**********
            for (int i = 1; i <= (2 * j - 1); i++) {//i:控制每行的*的个数
                System.out.print("*");
            }
            //换行：
            System.out.println();//换行
        }

    }
}

【4】菱形：

public class T {
    public static void main(String[] args) {
         /*
                打印各种形状：
                     *
                    ***
                   *****
                  *******
                   *****
                    ***
                     *
          */
        //上面的三角形
        for (int j = 1; j <= 4; j++) {//j:控制行数
            //加入空格：
            for (int i = 1; i <= (6 - j); i++) {//i:每行的空格数
                System.out.print(" ");
            }


            //**********
            for (int i = 1; i <= (2 * j - 1); i++) {//i:控制每行的*的个数
                System.out.print("*");
            }
            //换行：
            System.out.println();//换行
        }
        //下面的三角形
        for (int j = 1; j <= 3; j++) {//j:控制行数
            //加入空格：
            for (int i = 1; i <= (j + 2); i++) {//i:每行的空格数
                System.out.print(" ");
            }


            //**********
            for (int i = 1; i <= (7 - 2 * j); i++) {//i:控制每行的*的个数
                System.out.print("*");
            }
            //换行：
            System.out.println();//换行
        }

    }
}

【5】空心菱形：

public class T {
    public static void main(String[] args) {
          /*
                打印各种形状：
                     *
                    * *
                   *   *
                  *     *
                   *   *
                    * *
                     *
         */
        //上面的三角形
        for (int j = 1; j <= 4; j++) {//j:控制行数
            //加入空格：
            for (int i = 1; i <= (6 - j); i++) {//i:每行的空格数
                System.out.print(" ");
            }


            //**********
            for (int i = 1; i <= (2 * j - 1); i++) {//i:控制每行的*的个数
                if (i == 1 || i == (2 * j - 1)) {
                    System.out.print("*");
                } else {
                    System.out.print(" ");
                }
            }
            //换行：
            System.out.println();//换行
        }
        //下面的三角形
        for (int j = 1; j <= 3; j++) {//j:控制行数
            //加入空格：
            for (int i = 1; i <= (j + 2); i++) {//i:每行的空格数
                System.out.print(" ");
            }


            //**********
            for (int i = 1; i <= (7 - 2 * j); i++) {//i:控制每行的*的个数
                if (i == 1 || i == (7 - 2 * j)) {
                    System.out.print("*");
                } else {
                    System.out.print(" ");
                }
            }
            //换行：
            System.out.println();//换行
        }

    }
}

public class T {
    public static void main(String[] args) {
        //正方形的宽
        int size = 19;//必须是奇数
        //中轴线所在的列：
        int centerNum = size / 2 + 1;
        int startNum = centerNum;
        int endNum = centerNum;

        //定义一个开关：
        boolean flag = true;
        for (int j = 1; j <= size; j++) {
            for (int i = 1; i <= size; i++) {
                //if(i>=startNum&&i<=endNum){
                if (i == startNum || i == endNum) {
                    System.out.print("*");
                } else {
                    System.out.print(" ");
                }
            }

            if (endNum == size) {
                flag = false;
            }

            //边界要变化：
            if (flag) {
                startNum--;
                endNum++;
            } else {
                startNum++;
                endNum--;
            }
            System.out.println();
        }

    }
}

百钱买百鸡

/*
    百钱买百鸡：
    公鸡5文钱一只，母鸡3文钱一只，小鸡3只一文钱，
    用100文钱买一百只鸡,其中公鸡，母鸡，小鸡都必须要有，问公鸡，母鸡，小鸡要买多少只刚好凑足100文钱。
    三元一次方程组：
    公鸡：x只
    母鸡：y只
    小鸡：z只
    x+y+z=100
    5x+3y+z/3=100
*/
public class T {
    public static void main(String[] args) {

        //第一种方式
        for (int x = 1; x <= 19; x++) {
            for (int y = 1; y <= 31; y++) {
                for (int z = 1; z <= 100; z++) {
                    if ((x + y + z == 100) && (5 * x + 3 * y + z / 3 == 100) && (z % 3 == 0)) {
                        System.out.println(x + "\t" + y + "\t" + z);
                    }
                }
            }
        }
          //第二种方式
//        for (int x = 1; x <= 19; x++) {
//            for (int y = 1; y <= 31; y++) {
//                int z = 100 - x - y;
//                if ((x + y + z == 100) && (5 * x + 3 * y + z / 3 == 100) && (z % 3 == 0)) {
//                    System.out.println(x + "\t" + y + "\t" + z);
//                }
//            }
//        }
    }
}