java基础语法——条件判断与循环语句

我会带着你远行 2024-03-27 09:23 245阅读 0赞

目录

一、流程控制语句

流程控制语句分类

二、顺序结构

顺序结构概述

顺序结构图

三、选择结构

选择结构概述

选择结构(if语句1)

选择执行图1

选择结构(if语句2)

选择执行图2

选择结构(if语句3)

选择执行图3

选择结构(switch语句)

switch语句执行流程图

四、 循环结构

for循环语句图

五、 循环结构(while循环语句)

while循环语句执行流程图

六、 循环结构(do…while循环语句)

do…while循环语句执行流程图

流程控制语句

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。

流程控制语句分类

——顺序结构

——选择结构

——循环结构

顺序结构

顺序结构概述

——是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

——总的来说：写在前面的先执行，写在后面的后执行

顺序结构图

c56b5363f612438dac4abdff2775ceaf.png

  1. package com.demo01;
  3. /*
  4.  * 顺序结构：从上往下依次进行
  5.  */
  6. public class OrderDemo {
  7.     public static void main(String[] args) {
  8.         System.out.println("开始");
  9.         System.out.println("语句A");
  10.         System.out.println("语句B");
  11.         System.out.println("语句C");
  12.         System.out.println("结束");
  13.     }
  14. }

#

选择结构

选择结构概述

–也被称为分支结构。

–选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。

–Java语言提供了两种选择结构语句

  • if语句
  • switch语句

选择结构(if语句1)

  • if语句有三种格式
  • if语句第一种格式：

–if(关系表达式) {

语句体

}

  • 执行流程

    ——首先判断关系表达式看其结果是true还是false

    ——如果是true就执行语句体

    ——如果是false就不执行语句体

    package com.demo02;

    /*

    • if语句有三种格式
    • if语句格式：
    • if(关系表达式) {
    • 语句体;
    • }
    • ִ执行流程
    • A:首先判断关系表达式是true还是false
    • B:如果是true,就执行语句体

    • C:如果是false,就不执行语句体
      */
      public class IfDemo {
      public static void main(String[] args) {
      System.out.println(“开始”);
      // 定义两个变量
      int a = 10;
      int b = 20;

      if (a == b) {
      System.out.println(“a等于b”);
      }

      int c = 10;
      if (a == c) {
      System.out.println(“a等于c”);
      }

      System.out.println(“结束”);
      }
      }

460739434c4c4e0badefad8be19fefec.png

选择执行图1

8c03ce67b1ea4af698df65de78a7a616.png

选择结构(if语句2)

  • if语句第二种格式：

–if(关系表达式){

语句体1;

}else{

语句体2;

}

  • 执行流程

–首先判断关系表达式看其结果是true还是false

–如果是true就执行语句体1

–如果是false就执行语句体2

选择执行图2

75e3920659044611a9673a449ffc7c57.png

  1. package com.demo02;
  3. import java.util.Scanner;
  5. /*
  6.  * if语句格式2
  7.  *         if(关系表达式) {
  8.  *             语句体1;
  9.  *         }else {
  10.  *             语句体2;
  11.  *         }
  12.  * 
  13.  * ִ执行流程
  14.  *         A:判断表达式是true还是false
  15.  *         B:如果是true,就执行语句体1
  16.  *         C:如果是false,就执行语句体2
  17.  */
  18. public class IfDemo2 {
  19.     public static void main(String[] args) {
  20.         System.out.println("开始");
  21.         // 判断给定的数据是奇数还是偶数
  22.         Scanner sc = new Scanner(System.in);
  24.         //接受数据
  25.         System.out.println("请录入一个整数：");
  26.         int a = sc.nextInt();
  29.         if (a % 2 == 0) {
  30.             System.out.println("a是偶数");
  31.         } else {
  32.             System.out.println("a是奇数");
  33.         }
  35.         System.out.println("结束");
  36.     }
  37. }

0a78d86320eb41a9bec7fd969a7b5279.png

选择结构(if语句3)

  • if语句第三种格式：

–if(关系表达式1) {

语句体1;

}else if (关系表达式2){

语句体2;

}

…

else {

语句体n+1;

}

  • 执行流程

–首先判断关系表达式1看其结果是true还是false

–如果是true就执行语句体1

–如果是false就继续判断关系表达式2看其结果是true还是false

–如果是true就执行语句体2

–如果是false就继续判断关系表达式…看其结果是true还是false

–…

–如果没有任何关系表达式为true，就执行语句体n+1。

选择执行图3

703d143222ac4ad1b08e8d3c7c5fe26f.png

  1. * 
  2.  * if语句的3种格式
  3.  *         第一种适合做一种判断
  4.  *         第二种适合做两种判断
  5.  *         第三种适合做多种判断
  6.  */
  7. public class IfDemo3 {
  8.     public static void main(String[] args) {
  9.         while (true) {
  10.         // x和y的关系满足如下：
  11.         // x>=3     y = 2x + 1;
  12.         // -1<=x<3  y = 2x;
  13.         // x<-1     y = 2x-1;
  14.         //
  15.         // 根据给定的x的值,计算y并输出
  17.         // 
  18.         Scanner sc = new Scanner(System.in);
  19.         System.out.println("请录入一个数：");
  20.         int x = sc.nextInt();
  21.         int y = 0;
  22.         //根据x的值给y赋值ֵ
  23.         if (x >= 3) {
  24.             y = 2 * x + 1;
  25.         } else if (x >= -1 && x < 3) {
  26.             y = 2 * x;
  27.         } else if(x >= -10 && x < -1){
  28.             y = 2 * x - 1;
  29.         }
  31.         System.out.println("y的值是"+y);
  32.         }
  33.     }
  34. }

bf9baa69cda34d629dd64a877a4dcedc.png

练习：键盘录入学生考试成绩，请根据成绩判断该学生属于那个级别

  1. package com.demo02;
  3. import java.util.Scanner;
  5. /*
  6.  * 键盘录入学生考试成绩，请根据成绩判断属于哪个级别
  7.  * 90-100    优秀
  8.  * 80-90    好
  9.  * 70-80    良
  10.  * 60-70    及格
  11.  * 60以下    不及格
  12.  * 
  13.  * 分析：
  14.  *         A:键盘录入学生考试成绩
  15.  *             三步骤
  16.  *         B:ͨ通过简单分析，我们决定采用if语句格式来实现
  17.  * 
  18.  * 程序一定要考虑周全
  19.  *         安全数据
  20.  *         边界数据
  21.  *         错误数据
  22.  */
  23. public class IfTest2 {
  24.     public static void main(String[] args) {
  25.         while(true) {
  26.         // 创建对象
  27.         Scanner sc = new Scanner(System.in);
  29.         //接收数据 
  30.         System.out.println("输入考生成绩:");
  31.         int score = sc.nextInt();
  35.         if (score < 0 || score > 100) {
  36.             System.out.println("你的成绩是错误的");
  37.         } else if (score >= 90 && score <= 100) {
  38.             System.out.println("你的成绩属于优秀");
  39.         } else if (score >= 80 && score < 90) {
  40.             System.out.println("你的成绩属于好");
  41.         } else if (score >= 70 && score < 80) {
  42.             System.out.println("你的成绩属于良");
  43.         } else if (score >= 60 && score < 70) {
  44.             System.out.println("你的成绩属于及格");
  45.         } else {
  46.             System.out.println("你的成绩不及格");
  47.         }
  48.         }
  49.     }
  50. }

8e58c266a1014f048ef8d47994524fb8.png

选择结构(switch语句)

switch语句格式：

–switch(表达式) {

case 值1：

语句体1;

break;

case 值2：

语句体2;

break;

…

default：

语句体n+1;

break;

}

•格式解释

–switch表示这是switch语句

•表达式的取值：byte,short,int,char

•JDK5以后可以是枚举

•JDK7以后可以是String

–case后面跟的是要和表达式进行比较的值

–语句体部分可以是一条或多条语句

–break表示中断，结束的意思，可以结束switch语句

–default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

•执行流程

–首先计算出表达式的值

–其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。

–最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

switch语句执行流程图

e14dd4b4f4ea47c9a347f60da6854097.png

  1. package com.demo03;
  3. import java.util.Scanner;
  5. /*
  6.  * switch语句格式
  7.  * switch(表达式) {
  8.  *         case ֵ1:
  9.  *             语句体1;
  10.  *             break;
  11.  *         case ֵ2:
  12.  *             语句体22;
  13.  *             break;
  14.  *         ...
  15.  *         default:
  16.  *             语句体n+1;
  17.  *             break;
  18.  * }
  19.  * 格式解释
  20.  *         表达式:byte,short,int,char
  21.  *             JDK5以后可以是枚举
  22.  *             JDK7以后可以是字符串
  23.  *         case:就是要和表达式比较的值ֵ
  24.  *         break:表示中断结束
  25.  *         default:表示所有语句体的情况都不匹配的时候就执行语句体n+1.和if语句的else相似
  26.  * ִ�����̣�
  27.  *         A:计算出表达式的值ֵ
  28.  *         B:拿出计算出来的值和case后边的值依次比较，一旦有对应的值，就执该处的语句，在执行过程中，遇到break就结束
  29.  *         C:如果和所有的case都不匹配，就执行default控制语句，然后结束
  30.  * ����
  31.  *         根据键盘录入的值1,2,3---7，输出对应的星期一，星期二，星期三---，星期日
  32.  */
  33. public class SwitchDemo {
  34.     public static void main(String[] args) {
  35.         // 创建对象
  36.         while(true) {
  37.         Scanner sc = new Scanner(System.in);
  39.         // 接收数据
  40.         System.out.println("请输入数字（1-7）：");
  41.         int weekday = sc.nextInt();
  43.         // switch语句实现
  44.         switch (weekday) {
  45.         case 1:
  46.             System.out.println("星期一");
  47.             break;
  48.         case 2:
  49.             System.out.println("星期二");
  50.             break;
  51.         case 3:
  52.             System.out.println("星期三");
  53.             break;
  54.         case 4:
  55.             System.out.println("星期四");
  56.             break;
  57.         case 5:
  58.             System.out.println("星期五");
  59.             break;
  60.         case 6:
  61.             System.out.println("星期六");
  62.             break;
  63.         case 7:
  64.             System.out.println("星期日");
  65.             break;
  66.         default:
  67.             System.out.println("输入错误");
  68.             break;
  69.         }
  70.         }
  72.     }
  73. }

8989df8e5ded4569896730da6decb41e.png

循环结构

——循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

循环语句的组成

–初始化语句：

•一条或者多条语句，这些语句完成一些初始化操作。

–判断条件语句：

•这是一个boolean 表达式，这个表达式能决定是否执行循环体。

–循环体语句：

•这个部分是循环体语句，也就是我们要多次做的事情。

–控制条件语句：

•这个部分在一次循环体结束后，下一次循环判断条件执行前执行。通过用于控制循环条件中的变量，使得循环在合适的时候结束。

for循环语句格式：

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

循环体语句；

}

–执行流程

•A:执行初始化语句

•B:执行判断条件语句，看其结果是true还是false

–如果是false，循环结束。

–如果是true，继续执行。

•C:执行循环体语句

•D:执行控制条件语句

•E:回到B继续

for循环语句图

913713d8938c42e99c440e9ade2c968d.png

循环结构(for循环练习)

  1. 在控制台输出10次Hello Word
  2. 获取数据1-5和5-1
  3. 求出1-5之间数据之和
  4. 求出1-100之间偶数和
  5. 在控制台输出所有的”水仙花数”
  6. 统计”水仙花数”共有多少个

练习1：在控制台输出10次Hello Word

  1. package com.demo04;
  3. /*
  4.  * for循环语句格式
  5.  *         for(初始化语句；判断条件语句；控制条件语句) {
  6.  *             循环体语句;
  7.  *         }
  8.  * 
  9.  *     
  10.  *             A:ִ执行初始化语句
  11.  *             B:ִ执行判断条件语句，看结果是true还是false
  12.  *                 如果是true，就继续执行
  13.  *                 如果是false,就结束循环
  14.  *             C:ִ执行循环体语句
  15.  *             D:ִ执行控制条件语句
  16.  *             E:回到B继续
  17.  * 
  18.  * 需求：
  19.  *         在控制台输出10次hello word
  20.  */
  21. public class ForDemo {
  22.     public static void main(String[] args) {
  25.         for (int x = 1; x <= 10; x++) {
  26.             System.out.println("HelloWorld:"+x);
  27.         }
  29.     }
  30. }

e596250073184a8aa69f56d2fcb578cc.png

练习2：获取数据1-5和5-1

  1. package com.demo04;
  3. /*
  4.  * for循环语句格式
  5.  *         for(初始化语句；判断条件语句；控制条件语句) {
  6.  *             循环体语句;
  7.  *         }
  8.  * 
  9.  *         ִ执行过程
  10.  *             A:ִ执行初始化语句
  11.  *             B:ִ执行判断条件语句，看结果是true还是false
  12.  *                 如果是true，就继续执行
  13.  *                 如果是false,就结束循环
  14.  *             C:ִ执行循环体语句
  15.  *             D:ִ执行控制条件语句
  16.  *             E:回到B继续
  17.  * 
  18.  * 需求：
  19.  *         获取数据1-5和5-1
  20.  */
  21. public class ForDemo {
  22.     public static void main(String[] args) {
  24.         System.out.println("*************");
  25.         for (int x = 1; x <= 5; x++) {
  26.             System.out.println(x);
  27.         }
  28.         System.out.println("*************");
  29.         for(int i=5;i>=1;i--) {
  30.             System.out.println(i);
  31.         }
  33.     }
  34. }

87243c196665474ea5d05f7879bcf29f.png

练习3：求出1-5之间数据之和

  1. package com.demo04;
  3. /*
  4.  * for循环语句格式
  5.  *         for(初始化语句；判断条件语句；控制条件语句) {
  6.  *             循环体语句;
  7.  *         }
  8.  * 
  9.  *         ִ执行过程
  10.  *             A:ִ执行初始化语句
  11.  *             B:ִ执行判断条件语句，看结果是true还是false
  12.  *                 如果是true，就继续执行
  13.  *                 如果是false,就结束循环
  14.  *             C:ִ执行循环体语句
  15.  *             D:ִ执行控制条件语句
  16.  *             E:回到B继续
  17.  * 
  18.  * 需求：
  19.  *         求出1-5之间数据之和
  20.  */
  21. public class ForDemo {
  22.     public static void main(String[] args) {
  23.         int sum = 0;
  24.         System.out.println("*************");
  25.         for (int x = 1; x <= 5; x++) {
  26.             sum = sum + x; 
  27.         }
  28.         System.out.println("1-5之和为："+ sum);
  30.         }
  32.     }

1c835cfe087d460ca1422d88887f3f76.png

练习4：求出1-100之间偶数和

  1. package com.demo04;
  3. /*
  4.  * for循环语句格式
  5.  *         for(初始化语句；判断条件语句；控制条件语句) {
  6.  *             循环体语句;
  7.  *         }
  8.  * 
  9.  *         ִ执行过程
  10.  *             A:ִ执行初始化语句
  11.  *             B:ִ执行判断条件语句，看结果是true还是false
  12.  *                 如果是true，就继续执行
  13.  *                 如果是false,就结束循环
  14.  *             C:ִ执行循环体语句
  15.  *             D:ִ执行控制条件语句
  16.  *             E:回到B继续
  17.  * 
  18.  * 需求：
  19.  *          求出1-100之间偶数和
  20.  */
  21. public class ForDemo {
  22.     public static void main(String[] args) {
  23.         int sum = 0;
  24.         System.out.println("*************");
  25.         for (int x = 1; x <= 100; x++) {
  26.             if (x%2==0) {
  27.             sum = sum + x; }
  28.         }
  29.         System.out.println("1-100 偶数之和为："+ sum);
  31.         }
  33.     }

606bb5af3a36460bb967de99cc41071d.png

练习5：在控制台输出所有的”水仙花数”

  1. package com.demo04;
  2. /*
  3.  * 需求：在控制台输出所有的水仙花数
  4.  * 
  5.  * 分析：
  6.  *         什么是水仙花数?
  7.  *             所谓的水仙花数是指一个三位数，是指各位数字的立方和等于该数本身
  8.  *            举例子：153就是一个水仙花数
  9.  *            153 = 1*1*1 + 5*5*5 + 3*3*3
  10.  *
  11.  *        A:三位数实际告诉我们水仙花数字的范围：
  12.  *            100-999
  13.  *        B:如何获取一个数据的每一位上的数字呢？
  14.  *            举例：我有一个数据153，如何获取个位、十位、百位？
  15.  *            个位153%10 = 3;
  16.  *            十位153/10%10 = 5;
  17.  *            百位153/10/10%10 = 1;
  19.  *        C:让每个位上的立方和相加，并和该数字比较，如果相等，就是水仙花数，在控制台输出
  20.  */
  21. public class ForTest4 {
  22.     public static void main(String[] args) {
  23.         //ͨ通过循环获取到每一个三位数
  24.         for(int x=100; x<=999; x++) {
  25.             //获取十位、个位、百位
  26.             int ge = x%10;
  27.             int shi = x/10%10;
  28.             int bai = x/10/10%10;
  30.             //让每个位上的立方和相加，并和该数字比较，如果相等，就是水仙花数，在控制台输出
  31.             if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
  32.                 System.out.println(x);
  33.             }
  34.         }
  35.     }
  36. }

cec9c9ad4a9748b2944b8c25749ea14d.png

练习6：统计”水仙花数”共有多少个

  1. package com.demo04;
  2. /*
  3.  * 需求：在控制台输出所有的水仙花数
  4.  * 
  5.  * 分析：
  6.  *         什么是水仙花数?
  7.  *             所谓的水仙花数是指一个三位数，是指各位数字的立方和等于该数本身
  8.  *            举例子：153就是一个水仙花数
  9.  *            153 = 1*1*1 + 5*5*5 + 3*3*3
  10.  *
  11.  *        A:三位数实际告诉我们水仙花数字的范围：
  12.  *            100-999
  13.  *        B:如何获取一个数据的每一位上的数字呢？
  14.  *            举例：我有一个数据153，如何获取个位、十位、百位？
  15.  *            个位153%10 = 3;
  16.  *            十位153/10%10 = 5;
  17.  *            百位153/10/10%10 = 1;
  19.  *        C:让每个位上的立方和相加，并和该数字比较，如果相等，就是水仙花数，在控制台输出
  20.  */
  21. public class ForTest4 {
  22.     public static void main(String[] args) {
  23.         //ͨ通过循环获取到每一个三位数
  24.         int count = 0;
  25.         for(int x=100; x<=999; x++) {
  26.             //获取十位、个位、百位
  27.             int ge = x%10;
  28.             int shi = x/10%10;
  29.             int bai = x/10/10%10;
  31.             //让每个位上的立方和相加，并和该数字比较，如果相等，就是水仙花数，在控制台输出
  32.             if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
  33.                 count++;
  35.             }
  37.         }
  38.         System.out.println(count);
  39.     }
  40. }

651d607d82244158bd03695515e97ac6.png

循环结构(while循环语句)

while循环语句格式：

–基本格式

while(判断条件语句) {

循环体语句;

}

–改版格式

初始化语句;

while(判断条件语句) {

循环体语句;

控制条件语句; }

while循环语句执行流程图

daa1d45c118d424e9fc28956164ee939.png

  1. package com.demo05;
  2. /*
  3.  * while循环语句的基本格式
  4.  *         while(判断条件语句) {
  5.  *             循环体语句;
  6.  *         }
  7.  * 扩展格式
  8.  *         初始化语句;
  9.  *         while(判断条件语句) {
  10.  *             循环体语句;
  11.  *             控制条件语句
  12.  *         }
  13.  * 
  14.  * 回顾for循环语句格式
  15.  *         for(初始化语句；判断条件语句；控制条件语句) {
  16.  *             循环体语句;
  17.  *         }
  18.  */
  19. public class WhileDemo {
  20.     public static void main(String[] args) {
  21.         //输出10次hello World
  22.         /*
  23.          * for(int x=1; x<=10; x++) { System.out.println("HellloWorld"); }
  24.          */
  27.         //while循环实现
  28.         int x=1;
  29.         while(x<=10) {
  30.             System.out.println("HellloWorld");
  31.             x++;
  32.         }
  33.         System.out.println(x);
  34.     }
  35. }

" class="reference-link">0eff2e242d6b405aad5b9832cfb729d6.png

循环结构(do…while循环语句)

do…while循环语句格式：

–基本格式

do {

循环体语句;

}while((判断条件语句);

–改版格式

初始化语句;

do {

循环体语句;

控制条件语句;}

while((判断条件语句);

do…while循环语句执行流程图

d8ff0557d13a40348c31708fca3a9c5d.png

  1. package com.demo06;
  2. /*
  3.  * do...while循环基本格式
  4.  *         do {
  5.  *             循环体语句;
  6.  *         }while(判断条件语句);
  7.  * 扩展格式
  8.  *         初始化语句;
  9.  *         do {
  10.  *             循环体语句;
  11.  *             控制条件语句;
  12.  *         }while(判断条件语句);
  13.  * ִ执行流程
  14.  *         A:ִ执行初始化语句
  15.  *         B:ִ执行循环体语句
  16.  *         C:ִ执行控制条件语句;
  17.  *         D:ִ执行判断条件语句
  18.  *             如果是true，回到B继续
  19.  *             如果是false,就结束
  20.  * 
  21.  * 
  22.  */
  23. public class DoWhileDemo {
  24.     public static void main(String[] args) {
  26.         int x=1;
  27.         System.out.println("************************");
  28.         do {
  30.             System.out.println("HelloWorld");
  31.             x++;
  32.         }while(x<=10);
  33.     }
  34. }

64bbffa8da3d48a79b4a0c7004d8d7d2.png 循环结构(三种循环的区别)

虽然可以完成同样的功能，但是还是有小区别：

–do…while**循环至少会执行一次循环体**。

–for循环和while循环只有在条件成立的时候才会去执行循环体

for循环语句和while循环语句的小区别：

–使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for**循环结束，该变量就从内存中消失，能够提高内存的使用效率**。（for 变量定义在括号里边，while 变量定义在括号外边）

跳转控制语句

  • 我想让循环在某一步的时候结束或者跳过某些数据不要，现在就做不了这件事情。为了弥补这个缺陷，Java就提供了break，continue来实现控制语句的中断和跳转。
  • break 中断
  • continue 继续
  • break的使用场景：

–在选择结构switch语句中

–在循环语句中

–离开使用场景的存在是没有意义的

  • break的作用：

–跳出单层循环

  1. package com.demo07;
  3. public class BreakDemo {
  4.     public static void main(String[] args) {
  5.         //break;
  7.         for(int x=1; x<=10; x++) {
  8.             if(x == 3) {
  9.                 break;
  10.             }
  11.             System.out.println("HelloWorld");
  12.         }
  13.     }
  14. }
  • continue的使用场景：

–在循环语句中

–离开使用场景的存在是没有意义的

  • continue的作用：

–单层循环对比break，然后总结两个的区别

•break 退出当前循环

•continue 退出本次循环

  1. package com.demo07;
  3. public class ContinueDemo {
  4.     public static void main(String[] args) {
  5.         //continue;
  7.         for(int x=1; x<=10; x++) {
  8.             if(x == 3) {
  9.                 //break;
  10.                 continue;
  11.             }
  12.             System.out.println("HelloWorld");
  13.         }
  14.     }
  15. }

" class="reference-link">e898c69950404c78a1ee3f2b07270233.png

退出当前循环，往后走

随机数

  • 作用：———– 用于产生一个随机数
  • 使用步骤(和Scanner类似)

–导包

•import java.util.Random;

–创建对象

•Random r = new Random()

–获取随机数

•int number = r.nextInt(10);

•产生的数据在0到10之间，包括0，不包括10。

•如何获取一个1-100之间的随机数呢?

  1. import java.util.Random;
  3. /**
  4.  * 
  5.  * @author 无限嚣张(菜菜) 
  6.  * 使用步骤(和Scanner类似)     
  7.  *                 –导包
  8.  * 
  9.  *                 •import java.util.Random;
  10.  * 
  11.  *             –创建对象
  12.  * 
  13.  *                 •Random r = new Random()
  14.  * 
  15.  *             –获取随机数
  16.  * 
  17.  *                 •int number = r.nextInt(10);
  18.  */
  19. public class SuiJiShu {
  21.     public static void main(String[] args) {
  22.         for(int x=1;x<=10;x++) {
  23.         // TODO Auto-generated method stub
  24.         // 创建对象
  25.         Random Sc = new Random();
  26.         //接收数据
  27.         int i = Sc.nextInt(10);
  28.         System.out.println(i);}
  30.         //如何获取1-100
  31.         //int i = Sc.nextInt(100)+1;
  33.     }
  35. }

a804d5ed359e46728168267adbdd7991.png

随机数练习：猜数字小游戏 (拒绝赌博，热爱家庭)

  1. import java.util.Random;
  2. import java.util.Scanner;
  4. /**
  5.  * 
  6.  * @author 无限嚣张(菜菜) 
  7.  * 使用步骤(和Scanner类似)     
  8.  *                 –导包
  9.  * 
  10.  *                 •import java.util.Random;
  11.  * 
  12.  *             –创建对象
  13.  * 
  14.  *                 •Random r = new Random()
  15.  * 
  16.  *             –获取随机数
  17.  * 
  18.  *                 •int number = r.nextInt(10);
  19.  *        猜数字小游戏案例
  20.  *            系统产生一个1-100之间的随机数
  21.  *        分析：
  22.  *        A：系统产生一个1-100之间的随机数
  23.  *            random r = new Random();
  24.  *          int number = r.nextInt(100)+1;
  25.  *        B:键盘录入我们要猜的数据
  26.  *        C：比较这两个数据，用if语句实现
  27.  *            大了：提示大了
  28.  *            笑了：提示小了
  29.  *            猜中：提示恭喜你猜中了
  30.  *        D：多次猜数据，而我们不知道猜多少次怎么办呢？
  31.  *            while(true) 循环体语句
  32.  */
  33. public class SuiJiShu {
  35.     public static void main(String[] args) {
  36.         // TODO Auto-generated method stub
  37.         // 创建对象
  38.         while(true) {
  39.         Random Sc = new Random();
  40.         //接收数据
  41.         int i = Sc.nextInt(10);
  42.         System.out.println("随机数为：");
  43.         System.out.println(i);
  45.         //创建键盘录入数据
  46.         Scanner sc = new Scanner(System.in);
  48.         //接受数据
  49.         System.out.println("请输入您要猜的数字：");
  50.         int j = sc.nextInt();
  52.         if(i>j) {
  53.             System.out.println("猜小了");
  54.         }
  55.         else if(i<j) {
  56.             System.out.println("猜大了");
  57.         }
  58.         else {
  59.             System.out.println("恭喜您猜中了");
  60.             break;
  61.         }
  62.         }
  65.         //如何获取1-100
  66.         //int i = Sc.nextInt(100)+1;
  68.     }
  70. }

7c478523a51b4f9b862f00255bea288a.png

发表评论

表情：
评论列表 （有 0 条评论，245人围观）

还没有评论，来说两句吧...

相关阅读

    相关 判断语句与循环语句

    java程序流程控制语句 程序的流程控制分为以下几种方式： 1. 顺序结构 2. 判断结构 3. 选择结构 4. 循环结构 一般情况下，程序是从上往下依次顺序

    悠悠悠悠/ 0 赞/ 479 阅读