Java零基础(从0到1)---》控制语句

**❤️知识大纲 **

🏀1.分类

🥅怎么接收用户键盘输入

❤️java.util.Scanner s = new java.util.Scanner(System.in);
⭐️接收整数： int i = s.nextInt()
⭐️接收字符串：String str = s.next();

❤️或者把第一句话分为两个步骤：

⭐️import java.util.Scanner;

⭐️Scanner s = new Scanner(System.in)

🥅控制语句分类

❤️控制语句的可以让我们的程序具有逻辑性/条理性，可以使用控制语句来实现一个“业务”。

❤️控制语句包括3类：选择语句、循环语句、转向语句
⭐️选择语句(分支语句)： if语句、switch语句；
⭐️循环语句： for循环、while循环、do..while..循环；
⭐️转向语句： break、continue、return(后面讲)；

🏀2.语句详解

🥏选择语句if、switch

选择语句主要包括两种：if和switch!

🥅 if语句

if语句是分支语句，也可以叫做条件语句。if语句的语法格式：
❤️第一种写法：

  if(布尔表达式){
                    java语句;
                    java语句;
                }

  ⭐️这里的一个大括号{} 叫做一个分支。
   ⭐️该语法的执行原理是：如果布尔表达式的结果是true，则执行大括号中的程序，否则大括号中代码不执行。

** ❤️第二种写法：**

 if(布尔表达式){  // 分支1
                    java语句;     
                }else{  // 分支2
                    java语句;
                }

⭐️执行原理：如果布尔表达式的结果是true，则执行分支1，分支2不执行。如果布尔表达式的结果是false，分支1不执行，执行分支2。

** ❤️第三种写法：**

  if(布尔表达式1){ // 分支1
                    java语句;
                }else if(布尔表达式2){ // 分支2
                    java语句;
                }else if(布尔表达式3){ // 分支3
                    java语句;
                }else if(布尔表达式4){ // 分支4...
                    java语句;
                }....

 ⭐️执行原理：先判断“布尔表达式1”，如果“布尔表达式1”为true，则执行分支1，然后if语句结束了。
  ⭐️当“布尔表达式1”结果是false，那么会继续判断布尔表达式2的结果， 如果布尔表达式2的结果是true，则执行分支2，然后整个if就结束了。
  ⭐️ 从上往下依次判断，主要看第一个true发生在哪个分支上。第一个true对应的分支执行，只要一个分支执行，整个if结束。

❤️第四种写法：

  if(布尔表达式1){ // 分支1
                    java语句;
                }else if(布尔表达式2){ // 分支2
                    java语句;
                }else if(布尔表达式3){// 分支3
                    java语句;
                }else if(布尔表达式4){// 分支4
                    java语句;
                }else{
                    java语句; // 以上条件没有一个成立的。这个else就执行了。
                }

注意事项

⭐️对于if语句的额条件只能是布尔表达式，true和false！不能是具体的数字和变量买这一点是和C语言严格区分的；
⭐️对于if语句来说，在任何情况下只能有1个分支执行，不可能存在2个或者更多个分支执行。if语句中只要有1个分支执行了，整个if语句就结束了。（对于1个完整的if语句来说的）；
⭐️以上4种语法机制中，凡是带有else分支的，一定可以保证会有一个分支执行。以上4种当中，第一种和第三种没有else分支，这样的语句可能会导致最后一个分支都不执行。第二种和第四种肯定会有1个分支执行；
⭐️当分支当中“java语句;”只有1条，那么大括号{}可以省略，但为了可读性，最好不要省略。
⭐️控制语句和控制语句之间是可以嵌套的，但是嵌套的时候大家最好一个语句一个语句进行分析，不要冗杂在一起分析。

**实例分析 **

❤️例1

⭐️对于变量本身就是布尔类型，我们的方式有多中；因为本身类型就是布尔型，只要合乎语法和逻辑就可以！比如：sex、sex == true、或者写成三目运算符！

public class Test01{
    public static void main(String[] args){
//1.本身就是布尔类型
        boolean sex  = true;
        if(sex){//sex == true也可以
            System.out.println('男');
        }
        else{
            System.out.println('女');
        }
//2.也可以用三目运算符
        char str = sex?'男':'女';
        System.out.println(str);
//3.一种特殊情况
        if(sex = true){//赋值运算符，也可以编译通过，永远只执行if语句
            System.out.println('男');
        }
        else{
            System.out.println('女');
        }

    }
}

❤️例2

⭐️对于变量是整型，我们的方式就很少了，因为if后面跟的必须是布尔表达式；所以要写成一个表达式，让它生成一个布尔类型，例如：i == 100；

⭐️如果if...else后面只跟着一条语句，大括号可以省略；如果省略写了两个java语句也是没问题的；但是就会和下面的else断开，造成else没有if语句，编译报错；

//1.本身不是布尔类型
        int i = 100;
        if(i == 100){
            System.out.println(true);
        }
        else{
            System.out.println(false);
        }
//2.else缺少if
        if(sex)
            System.out.println('男');
            System.out.println("Hello wprld");//合乎语法的
        else //这一行报错，因为else缺少if
            System.out.println('女');
    //上面等价于
        if(sex){
            System.out.println('男');
           }
            System.out.println("Hello wprld");
        else 
            System.out.println('女');

❤️例3

public class Test02{
    public static void main(String[] args){
        //从键盘接收数据
        System.out.print("请输入你的年龄:");
        java.util.Scanner s = new java.util.Scanner(System.in);
        int age = s.nextInt();
//1.方法1
        if(age<0 || age >150){
            System.out.println("年龄不合法");
        }else if(age <= 5){
            System.out.println("婴幼儿");
        }else if(age <= 10){
            System.out.println("少儿");
        }else if(age <= 18){
            System.out.println("少年");
        }else if(age <= 35){
            System.out.println("青年");
        }else if(age <= 55){
            System.out.println("中年");
        }else{
            System.out.println("老年");
        }

//2.方法2代码改良
        String str = "老年";
        if(age<0 || age >150){
            System.out.println("年龄不合法");
            return;
        }else if(age <= 5){
            str = "婴幼儿";
        }else if(age <= 10){
            str = "少儿";
        }else if(age <= 18){
            str = "少年";
        }else if(age <= 35){
            str = "青年";
        }else if(age <= 55){
            str = "中年";
        }
        System.out.println(str);
    }
}

❤️例4
⭐️系统接收一个学生的考试成绩，根据考试成绩输出成绩的等级。

⭐️等级：优：[90100]、良：[8090) 、中：[70-80)、及格：[60~70)、不及格：[0-60)

⭐️要求成绩是一个合法的数字，成绩必须在[0-100]之间，成绩可能带有小数。

public class Test03{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入你的成绩:");
        double grade = s.nextDouble();
        String str = "优";

        if(grade <0 || grade >100){
            System.out.println("分数不合法");
            return;
        }else if(grade<60){
            str = "不及格";
        }else if(grade < 70){
            str = "及格";
        }else if(grade < 80){
            str = "中";
        }else if(grade < 90){
            str = "良";
        }
        System.out.println(str);
    }
}

❤️例5

⭐️从键盘上接收天气的信息：1表示：雨天
0表示：晴天
⭐️同时从键盘上接收性别的信息：1表示：男
0表示：女
⭐️业务要求：
当天气是雨天的时候：男的：打一把大黑伞
女的：打一把小花伞
当天气是晴天的时候：男的：直接走起，出去玩耍
女的：擦点防晒霜，出去玩耍

public class Test04{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入天气，1表示雨天，0表示晴天:");
        int weather = s.nextInt();
        System.out.print("请输入性别，1表示男，0表示女:");
        int sex = s.nextInt();

        if(weather == 1){
            if(sex == 1){
                System.out.println("打一把大黑伞");
            }else{
                System.out.println("打一把小花伞");
            }
        
        }else{
            if(sex == 1){
                System.out.println("直接走起，出去玩耍");
            }else{
                System.out.println("擦点防晒霜，出去玩耍");
            }
        }
    }
}

🥅 switch语句

❤️switch语句也是选择语句，也可以叫做分支语句。
❤️switch语句的语法格式：

 switch(值){
            case 值1:
                java语句;
                java语句;...
                break;
            case 值2:
                java语句;
                java语句;...
                break;
            case 值3:
                java语句;
                java语句;...
                break;
            default:
                java语句;
            }

   ⭐️其中：break语句不是必须的；default分支也不是必须的。
    ⭐️**switch语句**支持的值有：**支持int类型以及String类型**。
    ⭐️一定要注意JDK的版本，JDK8之前不支持String类型，只支持int。在JDK8之后，switch语句开始支持字符串String类型。
    ⭐️**switch语句本质上是只支持int和String，但是byte,short,char也可以**
         使用在switch语句当中，因为byte short char可以进行自动类型转换。

❤️switch语句的执行原理
⭐️拿“值”与“值1”进行比较，如果相同，则执行该分支中的java语句，然后遇到"break;"语句，switch语句就结束了。
⭐️如果“值”与“值1”不相等，会继续拿“值”与“值2”进行比较，如果相同，则执行该分支中的java语句，然后遇到break;语句，switch结束。
⭐️注意：如果分支执行了，但是分支最后没有“break;”，此时会发生case 穿透现象。所有的case都没有匹配成功，那么最后default分支会执行。

**实例分析 **

❤️例1

⭐️写一个完整的switch语句；接收键盘输入，根据输入的数字来判断星期几。
⭐️0 星期日、1 星期一....、假设输入的数字就是正确的。0到6

public class Test05{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入[0-6]的天数:");
        int day = s.nextInt();
        switch(day){
        case 0:
            System.out.println("星期日");
            break;
        case 1:
            System.out.println("星期一");
            break;
        case 2:
            System.out.println("星期二");
            break;
        case 3:
            System.out.println("星期三");
            break;
        case 4:
            System.out.println("星期四");
            break;
        case 5:
            System.out.println("星期五");
            break;
        case 6:
            System.out.println("星期六");
            break;
        default:
            System.out.println("选择错误");
            break;
        }
        
    }
}

❤️例2
⭐️系统接收一个学生的考试成绩，根据考试成绩输出成绩的等级。必须用switch来写

⭐️等级：优：[90100]、良：[8090) 、中：[70-80)、及格：[60~70)、不及格：[0-60)

⭐️要求成绩是一个合法的数字，成绩必须在[0-100]之间，成绩可能带有小数。

public class SwitchTest02{
    public static void main(String[] args){
        //提示用户输入学生成绩
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入学生成绩：");
        double score = s.nextDouble();
        //System.out.println(score);
        if(score < 0 || score > 100){
            System.out.println("您输入的学生成绩不合法，再见！");
            return; 
        }

        // 程序能够执行到这里说明成绩一定是合法的。
        // grade的值可能是：0 1 2 3 4 5 6 7 8 9 10
        // 0 1 2 3 4 5 不及格
        // 6 及格
        // 7 中
        // 8 良
        // 9 10 优
        
        int grade = (int)(score / 10); // 95.5/10结果9.55，强转为int结果是9
        String str = "不及格";
        switch(grade){
        case 10: case 9:
            str = "优";
            break;
        case 8: 
            str = "良";
            break;
        case 7:
            str = "中";
            break;
        case 6:
            str = "及格";
        }
        System.out.println("该学生的成绩等级为：" + str);
    }
}

🥏循环语句while、do...while、for

🥅 for循环

❤️for循环的语法机制以及运行原理

⭐️语法机制：

 for(初始化表达式; 条件表达式; 更新表达式){
                循环体; // 循环体由java语句构成
                java语句;
                java语句;
                java语句;
                java语句;
                ....
            }

  ⭐️注意：
             第一：初始化表达式最先执行，并且在整个循环中只执行一次。
             第二：条件表达式结果必须是一个布尔类型，也就是：true或false
  ⭐️执行原理：
        （1）先执行初始化表达式，并且初始化表达式只执行1次。
        （2）然后判断条件表达式的结果，如果条件表达式结果为true，则执行循环体。
        （3）循环体结束之后，执行更新表达式。
        （4）更新完之后，再判断条件表达式的结果，如果还是true，继续执行循环体。
        （5）直到更新表达式执行结束之后，再次判断条件时，条件为false，for循环终止。       ⭐️更新表达式的作用是：控制循环的次数，换句话说，更新表达式会更新某个变量的值，这样条件表达式的结果才有可能从true变成false，从而 终止for循环的执行，如果缺失更新表达式，很有可能会导致死循环。

❤️例1

public class ForTest02{
    public static void main(String[] args){
//1. 最简练的for循环
      //初始化表达式、条件表达式、更新表达式 其实都不是必须的！！！
        for(;;){
            System.out.println("死循环");
        }

//2.最常见的for循环
        for(int i = 0;i < 10;i++){
            System.out.println("i = " + i); // 0 1 2 3....9
        } 
        System.out.println(i);//错误: 找不到符号,i的范围只在for循环内

//3.i变量的作用域就扩大了。
        int i = 0;
        for(;i < 10;i++){
            System.out.println("i --> " + i); // 0 1 2 3....9
        }
        System.out.println("i = " + i); //10，这里的i就可以访问了

//4.变形
        for(int k = 1; k <= 10; ){
            System.out.println("k --> " + k); 
            k++;// 1 2 3 4 5 6 7 8 9 10 
        }
//5.变形
        for(int k = 1; k <= 10; ){
            k++;
            System.out.println("value --> " + k); // 2 3 4 5 6 7 8 9 10 11
        }

    }
}

❤️例2

public class ForTest03{
    public static void main(String[] args){
//1. for的其它形式
        for(int i = 10; i > 0; i--){
            System.out.println("i = " + i); // 10 9 8 7 6 5 4 3 2 1
        }
//2. 变形
        for(int i = 0; i < 10; i += 2){
            System.out.println("value1 = " + i); // 0 2 4 6 8 
        }

//3. 死循环    
        for(int i = 100; i > 0; i %= 3){
            System.out.println("value2 = " + i); // 100 1 1... 1
        }

    }
}

❤️例3：求1-100所得奇数和

public class Test07{
    public static void main(String[] args){
        int i = 0;
        int sum = 0;
        for(i=1;i<=100;i+=2){
            sum+=i;
        }
        System.out.println("sum = "+sum);//2500
    }
}

❤️例4：嵌套循环

public class Test08{
    public static void main(String[] args){
//1.注意初始化放里面
    for(int i =0;i< 2;i++){
        for(int j=0;j<10;j++){
           System.out.print(j+" ");
       }
        System.out.println();
    }//打印两行0-9的数字
//2.初始化放外面
    int n = 0;
    for(int m = 0;m<2;m++){
        for(;n<10;n++){
            System.out.print(n+" ");
        }
        System.out.println();
    }//打印一行0-9的数字
 }
    
}

❤️例5：九九乘法表

public class Test09{
    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+"  ");
            }
            System.out.println();
        }
    }
}

🥅 while循环

❤️while循环的语法机制以及执行原理
⭐️语法机制：

 while(布尔表达式){
                    循环体;
                }

⭐️执行原理：
      判断布尔表达式的结果，如果为true就执行循环体，循环体结束之后，再次判断布尔表达式的结果，如果还是true，继续执行循环体，直到布尔表达式结果为false，while循环结束。

⭐️while循环有没有可能循环次数为0次？
       可能；while循环的循环次数是：0~n次。

❤️例1

public class WhileTest01{
    public static void main(String[] args){
//1.死循环
        while(true){
            System.out.println("死循环");
        }
//2.本质上while循环和for循环原理是相同的。
        for(初始化表达式; 布尔表达式; 更新表达式){
                循环体;
            }

        初始化表达式;
        while(布尔表达式){
                循环体;
                更新表达式;
            }
//3.例子对比
        //----for    
        for(int i = 0; i < 10; i++){
            System.out.println("i --->" + i);
         }
        //----while
        int i = 0;
        while(i < 10){
            System.out.println("i = " + i);
            i++;
        }

//4.for和while完全可以互换，只不过就是语法格式不一样。
        for(int i = 0; i < 10; ){
            i++;
            System.out.println("i --->" + i); // 1 2 3 .. 9 10
        }

        int i = 0;
        while(i < 10){
            i++;
            System.out.println("i = " + i); // 1 2 3 .. 9 10
        }

    }
}

🥅 do...while循环

❤️do..while循环语句的执行原理以及语法机制：
⭐️语法机制：

        do {
                循环体;
            }while(布尔表达式);

⭐️注意：do..while循环最后的时候别漏掉“分号”；

⭐️执行原理：
先执行循环体当中的代码，执行一次循环体之后，判断布尔表达式的结果，如果为true，则继续执行循环体，如果为false循环结束。
⭐️对于do..while循环来说，循环体至少执行1次。循环体的执行次数是：1n次。
对于while循环来说，循环体执行次数是：0n次。

❤️例1

public class Test10{
    public static void main(String[] args){
        int i = 0;
//1.
        do{
            //第一种方法
            System.out.println(i);
            i++;
            //第二种方法
            System.out.println(i++);
        }while(i<10);//0...9
//2.
        i = 0;
        do{        
            System.out.println(++i);
        }while(i<10);//1...10
        
    }
}

🥏转向语句：break、continue

🥅 break语句

❤️break;语句比较特殊，特殊在：break语句是一个单词成为一个完整的java语句。
⭐️break的作用：终止当前循环，直接跳出循环；

❤️break主要用在两个地方，其它位置不行：
⭐️第一个位置：switch语句当中，用来终止switch语句的执行。用在switch语句当中，防止case穿透现象，用来终止switch。
⭐️第二个位置：break;语句用在循环语句当中，用在for当中、用在while当中、用在do....while当中；用来终止循环的执行。

❤️break;语句的执行并不会让整个方法结束，break;语句主要是用来终止离它最近的那个循环语句。

❤️怎么用break;语句终止指定的循环呢？
⭐️第一步：你需要给循环起一个名字，例如：

       a: for(){
                    b:for(){
                    
                    }
                }

⭐️第二步：终止：break a;

❤️例1

public class BreakTest01{
    public static void main(String[] args){
        for(int i = 0; i < 10; i++){
            if(i == 5){
//1.break;语句会让离它最近的循环终止结束掉。终止的不是if，不是针对if的，而是针对离它最近的循环。
                break; 
            }
            System.out.println("i = " + i); // 0 1 2 3 4
        }

//2.这里的代码照常执行。break;的执行并不会影响这里。
        System.out.println("Hello World!");

//3.常用的终止内存的for
        for(int k = 0; k < 2; k++){ // 外层for
            for(int i = 0; i < 10; i++){ // 内层for
                if(i == 5){
                    break; //这个break;语句只能终止离它最近的for，内层的for
                }
                System.out.println("i ===> " + i); 
            }
        }

        System.out.println("------------------------------------------");

//4.终止外层的for,起一个别名!
        a:for(int k = 0; k < 2; k++){ 
            b:for(int i = 0; i < 10; i++){
                if(i == 5){
                    break a; //终止指定的循环。
                }
                System.out.println("i ===> " + i); 
            }
        }

        System.out.println("呵呵");

    }
}

🥅 continue语句

❤️continue翻译为：继续；continue语句和break语句要对比着学习；
❤️continue语句的作用是：终止当前"本次"循环，直接进入下一次循环继续执行。
❤️continue语句后面也可以指定循环；

 a:for(;;更新表达式1){
                b:for(;;更新表达式2){
                    if(){
                        continue a;
                    }
                    code1;
                    code2;
                    code3;
                }
            }

❤️例1

public class ContinueTest01{
    public static void main(String[] args){
//1.对于break直接跳出当前循环
        for(int i = 0; i < 10; i++){
            if(i == 5){
                break;
            }
            System.out.println("i = " + i);//0、1、2、3、4
        }

        System.out.println("----------------------------");

//2.对于continue是跳出当前的一次循环，继续下一次循环
        for(int i = 0; i < 10; i++){
            if(i == 5){
                continue;
            }
            System.out.println("i = " + i); //输出结果是0-9没有5
        }

    }
}

🏀3.小试牛刀

❤️例1：计算1000以内所有不能被7整除的整数之和

public class Test01{
    public static void main(String[] args){
        int sum = 0;
        for(int i = 1;i<=1000;i++){
            if(i%7 != 0){
                sum +=i;
            }
        }
    System.out.println("sum="+sum);
    }
}

❤️例2：计算 1+2-3+4-5+6-7....+100的结果

⭐️注意除1以外，偶数是正，奇数是负；所以我们就从2开始循环，把sum初始化为1就可

//方法1：
public class Test02{
    public static void main(String[] args){
        int sum = 1;
        for(int i=2;i<=100;i++){
            if(i%2 ==0){
                sum+=i;
            }
            else{
                sum-=i;
            }
        }
    System.out.println(sum);
    }
}

//方法2:定义一个flag标记，用来控制正负，一个数一个数进行处理
public class Test02{
    public static void main(String[] args){
        int sum = 1;
        int flag = 1;
        for(int i=2;i<=100;i++){
            sum +=flag*i;
            flag = -flag;
        }
    System.out.println(sum);
    }
}

❤️例3：从控制台输入一个正整数，计算该数的阶乘。

public class Test03{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入一个整数:");
        int num = s.nextInt();
        int ret = 1;
        //方法1
        for(int i=1;i<=num;i++){
            ret*=i;
        }
        //方法2
        for(int i = num;i>0;i--){
            ret*=i;
        }
    System.out.println(ret);
    }
}

❤️例4：判断一个数是不是质数

//方法1：
public class Test04{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        int num = s.nextInt();
        int i = 0;
        for(i = 2;i<num;i++){
            if(num%i == 0){
             System.out.println(num+"不是质数");
             break;
            }
        }
        if(i == num){
            System.out.println(num+"是质数");
    }
}

//方法2：
public class Test04{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        int num = s.nextInt();
        int i = 0;
        boolean str = true;//也相当于一个标记
        for(i = 2;i<num;i++){
            if(num%i == 0){
             str = false;//不是更改标记
             break;
            }
        }
        System.out.println(num+(str ? "是":"不是")+"质数");//根据标记输出值
    }
}

❤️例5：打印金字塔

    *
   ***
  *****
 *******
*********

public class Test05{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        int n = s.nextInt();
        for(int i=0;i<n;i++){
            for(int j=0;j<n-i-1;j++){
                    System.out.print(" ");
            }
            for(int j=0;j<2*i+1;j++){
                System.out.print("*");
            }
        System.out.println();
        }
        
    }
}

❤️例6：

小芳的妈妈每天给她2.5元钱，她都会存起来，但是，每当这一天是存钱的第5天
或者5的倍数的话，她都会花去6元钱，请问，经过多少天，小芳才可以存到100元钱！

public class Test06{
    public static void main(String[] args){
        double money = 0;
        int day = 0;
        while(true){//这也可以写成while(money<100)，这样就不需要break了
            money += 2.5;
            day++;
            if(day%5 == 0){
                money -= 6;
            }
            if(money >= 100){
                break;
            }
        }
    System.out.println("需要"+day+"天存到"+money+"元钱");
    }
}

❤️例7：

一个数如果恰好等于它的因子之和，这个数就是完数，例如 6 = 1 + 2 + 3，编程
找出1000内所有的完数。

public class Test07{
    public static void main(String[] args){
        for(int i=2;i<=1000;i++){//1不算完数，从2开始
//注意sum的位置，写在内循环，因为每次都要重置sum为0
            int sum = 0;
//i取一半，最好的是取根号i，目前还没学习库函数，先取i/2
            for(int j=1;j<= i/2;j++){
                if(i%j == 0){
                    sum += j;
                }
            }
            if(sum == i){
                System.out.println(i);
            }
        }
        
    }
}

❤️例8：求一个数是几位数，并逆序打印每一位

public class Test08{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        int num = s.nextInt();
        int count = 0;
        int tmp = num;
        //求位数
        while(tmp != 0){
                count++;
                tmp /= 10;
        }
        System.out.println("位数是"+count+"位");
        //逆序打印
        tmp = num;
        while(tmp != 0){
            System.out.println(tmp%10);
            tmp /= 10;
        }
    }
}

❤️例9

1 10 100 1000 
2 20 200 2000 
3 30 300 3000 
4 40 400 4000 

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

❤️例10

    *
   ***
  *****
 *******
*********
 *******
  *****
   ***
    *

public class Test10{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        int num = s.nextInt();
        x(num);
    }
    public static void x(int n){
//1.打印上半部分
        for(int i=0;i<n;i++){
            for(int j=0;j<n-i-1;j++){
                System.out.print(" ");
            }
            for(int j=0;j<2*i+1;j++){
                System.out.print("*");
            }
            System.out.println();
        }
//2.打印下半部分
        for(int i=0;i<n-1;i++){
            for(int j=0;j<=i;j++){
                System.out.print(" ");
            }
            for(int j=0;j<2*(n-i-1)-1;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

❤️例11

篮球从 5 米高的地方掉下来，每次弹起的高度是原来的 30%，经过几次弹起，篮球的高度是 0.1 米。

public class Test11{
    public static void main(String[] args){
        int count = 0;
        double h = 5;
        while(h >= 0.1){
            h *= 0.3;
            count++;
        }    
     System.out.println(count);
    }
}