运算符

算术运算符和表达式

运算符：对常量或者变量进行操作的符号
表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。不同运算符连接的表达式体现的是不同类型的表达式。

算术运算符

符号 作用 说明
+ 加 数学的加法
- 减 数学的减法
* 乘 数学的乘法
/ 除 数学的除法
% 取余 两个数据做除法的余数

ps：/和%的区别：两个数据做除法，/取结果的商，%取结果的余数
整数操作只能得到整数，要想得到小数，必须有浮点数参与运算

字符的“+”操作

char类型参与算术运算，使用的是计算机底层对应的十进制数值。需要我们记住三个字符对应的数值：
‘a’ — 97，a-z是连续的，所以’b’对应的数值是98，’c’是99，依次递加
‘A’ — 65，A-Z是连续的，所以’B’对应的数值是66，’C’是67，依次递加
‘0’ — 48，0-9是连续的，所以’1’对应的数值是49，’2’是50，依次递加

  1. // 可以通过使用字符与整数做算术运算，得出字符对应的数值是多少
  2. char ch1 = 'a';
  3. System.out.println(ch1 + 1); // 输出98，97 + 1 = 98
  4. char ch2 = 'A';
  5. System.out.println(ch2 + 1); // 输出66，65 + 1 = 66
  6. char ch3 = '0';
  7. System.out.println(ch3 + 1); // 输出49，48 + 1 = 49

算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。
提升规则：
byte类型，short类型和char类型将被提升到int类型，不管是否有其他类型参与运算。
整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型
等级顺序：byte,short,char —> int —> long —> float —> double

  1. byte b1 = 10;
  2. byte b2 = 20;
  3. // byte b3 = b1 + b2; // 该行报错，因为byte类型参与算术运算会自动提示为int，int赋值给byte可能损失
  4. 精度
  5. int i3 = b1 + b2; // 应该使用int接收
  6. byte b3 = (byte) (b1 + b2); // 或者将结果强制转换为byte类型
  7. -------------------------------
  8. int num1 = 10;
  9. double num2 = 20.0;
  10. double num3 = num1 + num2; // 使用double接收，因为num1会自动提升为double类型

ps：正是由于上述原因，所以在程序开发中我们很少使用byte或者short类型定义整数。也很少会使用char类型定
义字符，而使用字符串类型，更不会使用char类型做算术运算。

字符串的“+”操作

当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。
在”+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行。

  1. System.out.println("itheima"+ 666); // 输出：itheima666
  2. System.out.println(1 + 99 + "年黑马"); // 输出：100年黑马
  3. System.out.println(1 + 2 + "itheima" + 3 + 4); // 输出：3itheima34
  4. // 可以使用小括号改变运算的优先级
  5. System.out.println(1 + 2 + "itheima" + (3 + 4)); // 输出：3itheima7

赋值运算符

赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的，不能是常量。

符号 作用 说明
= 赋值 a=10，将10赋值给变量a
+= 加后赋值 a+=b，将a+b的值给a
-= 减后赋值 a-=b，将a-b的值给a
*= 乘后赋值 a*=b，将a×b的值给a
/= 除后赋值 a/=b，将a÷b的商给a
%= 取余后赋值 a%=b，将a÷b的余数给a

ps:扩展的赋值运算符隐含了强制类型转换。
例如：

  1. short s = 10;
  2. s = s + 10; // 此行代码报错，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度
  3. s += 10; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10);

自增自减运算符

符号 作用 说明
++ 自增 变量的值加1
— 自减 变量的值减1

++和— 既可以放在变量的后边，也可以放在变量的前边。
单独使用的时候， ++和— 无论是放在变量的前边还是后边，结果是一样的。
参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者—。
参与操作的时候，如果放在变量的前边，先拿变量做++或者—，后拿变量参与操作。
例如：

  1. int i = 10;
  2. i++; // 单独使用
  3. System.out.println("i:" + i); // i:11
  5. int j = 10;
  6. ++j; // 单独使用
  7. System.out.println("j:" + j); // j:11
  9. int x = 10;
  10. int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
  11. System.out.println("x:" + x + ", y:" + y); // x:11，y:10
  13. int m = 10;
  14. int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1
  15. System.out.println("m:" + m + ", m:" + m); // m:11，m:11
  17. int x = 10;
  18. int y = x++ + x++ + x++;
  19. System.out.println(y); // y的值是多少？
  20. /*
  21. 三个表达式都是++在后，所以每次使用的都是自增前的值，但程序自左至右执行，所以第一次自增时，使用的是
  22. 10进行计算，但第二次自增时，x的值已经自增到11了，所以第二次使用的是11，然后再次自增。所以整个式子应该是：int y = 10 + 11 + 12;
  23. 输出结果为33。
  24. */

关系运算符

符号 意义 说明
== 等于 a==b，判断a和b的值是否相等，成立为true，不成立为false
!= 不等于 a!=b，判断a和b的值是否不相等，成立为true，不成立为false
< 小于 a<b，判断a是否小于b，成立为true，不成立为false
<= 小于等于 a<=b，判断a是否小于等于b，成立为true，不成立为false
> 大于 a>b，判断a是否大于b，成立为true，不成立为false
>= 大于等于 a>=b，判断a是否大于等于b，成立为true，不成立为false

关系运算符的结果都是boolean类型，要么是true，要么是false。
千万不要把“==”误写成“=”，”==”是判断是否相等的关系，”=”是赋值。

  1. int a = 10;
  2. int b = 20;
  3. System.out.println(a == b); // false
  4. System.out.println(a != b); // true
  5. System.out.println(a > b); // false
  6. System.out.println(a >= b); // false
  7. System.out.println(a < b); // true
  8. System.out.println(a <= b); // true
  9. // 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量
  11. boolean flag = a > b;
  12. System.out.println(flag); // 输出false

逻辑运算符

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。

符号 作用 说明
& 逻辑与 a&b，a和b都是true，结果为true，否则为false
| 逻辑或 a|b，a和b都是false，结果为false，否则为true
^ 逻辑异或 a^b，a和b结果不同为true，相同为false
! 逻辑非 !a，结果和a的结果正好相反 
  1. //定义变量
  2. int i = 10;
  3. int j = 20;
  4. int k = 30;
  5. //& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
  6. System.out.println((i > j) & (i > k)); //false & false,输出false
  7. System.out.println((i < j) & (i > k)); //true & false,输出false
  8. System.out.println((i > j) & (i < k)); //false & true,输出false
  9. System.out.println((i < j) & (i < k)); //true & true,输出true
  10. System.out.println("--------");
  12. //| “或”，或者的关系，只要表达式中有一个值为true，结果即为true
  13. System.out.println((i > j) | (i > k)); //false | false,输出false
  14. System.out.println((i < j) | (i > k)); //true | false,输出true
  15. System.out.println((i > j) | (i < k)); //false | true,输出true
  16. System.out.println((i < j) | (i < k)); //true | true,输出true
  17. System.out.println("--------");
  19. //^ “异或”，相同为false，不同为true
  20. System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
  21. System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
  22. System.out.println((i > j) ^ (i < k)); //false ^ true,输出true
  23. System.out.println((i < j) ^ (i < k)); //true ^ true,输出false
  24. System.out.println("--------");
  26. //! “非”，取反
  27. System.out.println((i > j)); //false
  28. System.out.println(!(i > j)); //!false，,输出true

短路逻辑运算符

符号 作用 说明
&& 短路与 作用和&相同，但是有短路效果
|| 短路或 作用和|相同，但是有短路效果

在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都
计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。
逻辑与&，**无论左边真假，右边都要执行。
短路与&&，**如果左边为真，右边执行；如果左边为假，右边不执行。
逻辑或|，**无论左边真假，右边都要执行。
短路或||，**如果左边为假，右边执行；如果左边为真，右边不执行。
例如：

  1. int x = 3;
  2. int y = 4;
  3. System.out.println((x++ > 4) & (y++ > 5)); // 两个表达都会运算
  4. System.out.println(x); // 4
  5. System.out.println(y); // 5
  6. System.out.println((x++ > 4) && (y++ > 5)); // 左边已经可以确定结果为false，右边不参与运算
  7. System.out.println(x); // 4
  8. System.out.println(y); // 4

三元运算符

三元运算符语法格式：
关系表达式 ? 表达式1 : 表达式2;
解释：问号前面的位置是判断的条件，判断结果为boolean型，为true时调用表达式1，为false时调用表达式2。其
逻辑为：如果条件表达式成立或者满足则执行表达式1，否则执行第二个。

  1. int a = 10;
  2. int b = 20;
  3. int c = a > b ? a : b; // 判断 a>b 是否为真，如果为真取a的值，如果为假，取b的值

数据输入

我们可以通过 Scanner 类来获取用户的输入。使用步骤如下：
1、导包。Scanner 类在java.util包下，所以需要将该类导入。导包的语句需要定义在类的上面。
2、创建Scanner对象。
3、接收数据

  1. import java.util.Scanner;//导包的语句需要定义在类的上面。
  2. Scanner sc = new Scanner(System.in);// 创建Scanner对象，sc表示变量名，其他均不可变
  3. int i = sc.nextInt(); // 表示将键盘录入的值作为int数返回。

实际使用

  1. //导包
  2. import java.util.Scanner;
  3. public class ScannerDemo {
  4. public static void main(String[] args) {
  5. //创建对象
  6. Scanner sc = new Scanner(System.in);
  7. //接收数据
  8. int x = sc.nextInt();
  9. //输出数据
  10. System.out.println("x:" + x);
  11.     }
  12. }

流程控制语句

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

流程控制语句分类

顺序结构
分支结构(if, switch)
循环结构(for, while, do…while)

顺序结构

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

分支结构之if语句

if语句格式1

  1. if (关系表达式) {
  2. 语句体;
  3. }

执行流程：
1、首先判定关系表达式的值
2、如果关系表达式的值为true就执行语句体
3、如果关系表达式的值为false就不执行语句体
4、继续执行后面的语句内容
流程图如下。

  1. public class IfDemo {
  2. public static void main(String[] args) {
  3. System.out.println("开始");
  4. //定义两个变量
  5. int a = 10;
  6. int b = 20;
  7. //需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
  8. if(a == b) {
  9. System.out.println("a等于b");
  10. }
  11. //需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
  12. int c = 10;
  13. if(a == c) {
  14. System.out.println("a等于c");
  15. }
  16. System.out.println("结束");
  17. }
  18. }

if语句格式2

  1. if (关系表达式) {
  2. 语句体1;
  3. } else {
  4. 语句体2;
  5. }

执行流程：
1、首先计算关系表达式的值
2、如果关系表达式的值为true就执行语句体1
3、如果关系表达式的值为false就执行语句体2
4、继续执行后面的语句内容
流程图如下。
例如：

  1. public class IfDemo02 {
  2. public static void main(String[] args) {
  3. System.out.println("开始");
  4. //定义两个变量
  5. int a = 10;
  6. int b = 20;
  7. b = 5;
  8. //需求：判断a是否大于b，如果是，在控制台输出：a的值大于b，否则，在控制台输出：a的值不大于b
  9. if(a > b) {
  10. System.out.println("a的值大于b");
  11. } else {
  12. System.out.println("a的值不大于b");
  13. }
  14. System.out.println("结束");
  15. }
  16. }

if语句格式3

  1. if (关系表达式1) {
  2. 语句体1;
  3. } else if (关系表达式2) {
  4. 语句体2;
  5. }
  6. …
  7. else {
  8. 语句体n+1;
  9. }

执行流程：
1、首先计算关系表达式1的值
2、如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
3、如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
4、…
5、如果没有任何关系表达式为true，就执行语句体n+1。
流程图如下

switch语句

  1. switch (表达式) {
  2.     case 1:
  3.         语句体1;
  4.         break;
  5.     case 2:
  6.         语句体2;
  7.         break;
  8.     ...
  9.     default:
  10.         语句体n+1;
  11.         break;
  12. }

执行流程：
1、首先计算出表达式的值
2、其次和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
3、最后如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
ps：如果switch中得case，没有对应break的话，则会出现case穿透的现象。

循环结构之for循环

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

  1. for (初始化语句;条件判断语句;条件控制语句) {
  2.     循环体语句;
  3. }

初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情
条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去

执行流程：
1、执行初始化语句
2、执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
3、执行循环体语句
4、执行条件控制语句
5、回到2继续

示例1

在控制台输出1-5和5-1的数据

  1. public class ForTest01 {
  2.     public static void main(String[] args) {
  3.         //需求：输出数据1-5
  4.         for(int i=1; i<=5; i++) {
  5.             System.out.println(i);
  6.         }
  7.             System.out.println("--------");
  8.             //需求：输出数据5-1
  9.         for(int i=5; i>=1; i--) {
  10.             System.out.println(i);
  11.         }
  12.     }
  13. }

示例2

求1-5之间的数据和，并把求和结果在控制台输出

  1. public class ForTest02 {
  2.     public static void main(String[] args) {
  3.         //求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
  4.         int sum = 0;
  5.             //从1开始到5结束的数据，使用循环结构完成
  6.             for(int i=1; i<=5; i++) {
  7.             //将反复进行的事情写入循环结构内部
  8.             // 此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中
  9.             sum += i;
  10.             /*
  11.             sum += i; sum = sum + i;
  12.             第一次：sum = sum + i = 0 + 1 = 1;
  13.             第二次：sum = sum + i = 1 + 2 = 3;
  14.             第三次：sum = sum + i = 3 + 3 = 6;
  15.             第四次：sum = sum + i = 6 + 4 = 10;
  16.             第五次：sum = sum + i = 10 + 5 = 15;
  17.             */
  18.             }
  19.                 //当循环执行完毕时，将最终数据打印出来
  20.                 System.out.println("1-5之间的数据和是：" + sum);
  21.         }
  22.     }

ps：遇到的需求中，如果带有求和二字，立即联想到求和变量
求和变量的定义位置，必须在循环外部，如果在循环内部则计算出的数据将是错误的

示例3

在控制台输出所有的“水仙花数”

  1. public class ForTest04 {
  2.     public static void main(String[] args) {
  3.         //输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
  4.         for(int i=100; i<1000; i++) {
  5.             //在计算之前获取三位数中每个位上的值
  6.             int ge = i%10;
  7.                 int shi = i/10%10;
  8.             int bai = i/10/10%10;
  9.                 //判定条件是将三位数中的每个数值取出来，计算立方和后与原始数字比较是否相等
  10.                 if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
  11.                     //输出满足条件的数字就是水仙花数
  12.                     System.out.println(i);
  13.                 }
  14.             }
  15.         }
  16.     }

示例4

统计“水仙花数”一共有多少个，并在控制台输出个数

  1. public class ForTest05 {
  2.     public static void main(String[] args) {
  3.         //定义变量count，用于保存“水仙花数”的数量，初始值为0
  4.         int count = 0;
  5.         //输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
  6.             for(int i=100; i<1000; i++) {
  7.                 //在计算之前获取三位数中每个位上的值
  8.                 int ge = i%10;
  9.                 int shi = i/10%10;
  10.                 int bai = i/10/10%10;
  11.                     //在判定水仙花数的过程中，满足条件不再输出，更改为修改count的值，使count+1
  12.                     if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
  13.                         count++;
  14.                         }
  15.                 }
  16.                 //打印输出最终结果
  17.                 System.out.println("水仙花共有：" + count + "个");
  18.     }
  19. }

ps：如果需求带有统计xxx，先想到计数器变量
计数器变量定义的位置，必须在循环外部
**

while循环

  1. 初始化语句;
  2.     while (条件判断语句) {
  3.     循环体语句;
  4.     条件控制语句;
  5. }

执行流程：
1、执行初始化语句
2、执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
3、执行循环体语句
4、执行条件控制语句
5、回到2继续

示例

  1. public class WhileDemo {
  2.     public static void main(String[] args) {
  3.         //需求：在控制台输出5次"HelloWorld"
  4.         //for循环实现
  5.             for(int i=1; i<=5; i++) {
  6.                 System.out.println("HelloWorld");
  7.             }
  8.                 System.out.println("--------");
  9.                 //while循环实现
  10.                 int j = 1;
  11.                 while(j<=5) {
  12.                     System.out.println("HelloWorld");
  13.                     j++;
  14.                 }
  15.         }
  16. }

do…while循环

  1. 初始化语句;
  2.     do {
  3.         循环体语句;
  4.         条件控制语句;
  5.     }while(条件判断语句);

执行流程：
1、执行初始化语句
2、执行循环体语句
3、执行条件控制语句
4、执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
5、回到2继续

示例

  1. public class DoWhileDemo {
  2.     public static void main(String[] args) {
  3.         //需求：在控制台输出5次"HelloWorld"
  4.         //for循环实现
  5.         for(int i=1; i<=5; i++) {
  6.             System.out.println("HelloWorld");
  7.         }
  8.             System.out.println("--------");
  9.             //do...while循环实现
  10.                 int j = 1;
  11.                 do {
  12.                         System.out.println("HelloWorld");
  13.                         j++;
  14.             }while(j<=5);
  15.     }
  16. }

三种循环的区别

三种循环的区别
for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）
for循环和while的区别
条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量可 以继续使用
死循环（无限循环）的三种格式
1. for(;;){}
2. while(true){}
3. do {} while(true);

跳转控制语句

  1. /*
  2.     continue:用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行
  3.     break:用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环
  4. */
  5. public class ControlDemo {
  6.     public static void main(String[] args) {
  7.         for(int i = 1; i<=5; i++) {
  8.             if(i%2 == 0) {
  9.                 //continue;
  10.                 break;
  11.             }
  13.             System.out.println(i);
  14.         }
  15.     }
  16. }

跳转控制语句（break）
跳出循环，结束循环
跳转控制语句（continue）
跳过本次循环，继续下次循环
注意： continue只能在循环中进行使用！
**

循环嵌套

  1. /*
  2.     循环嵌套：
  3.         循环语句中包含循环语句
  5.     需求：
  6.         在控制台输出一天的小时和分钟
  8.         分钟和小时的范围：
  9.             分钟：0 <= minute < 60
  10.             小时：0 <= hour < 24
  11. */
  12. public class ForForDemo {
  13.     public static void main(String[] args) {
  14.         /*
  15.         System.out.println("0时0分");
  16.         System.out.println("0时1分");
  17.         System.out.println("0时2分");
  18.         System.out.println("0时3分");
  19.         System.out.println("--------");
  20.         System.out.println("1时0分");
  21.         System.out.println("1时1分");
  22.         System.out.println("1时2分");
  23.         System.out.println("1时3分");
  24.         System.out.println("--------");
  25.         System.out.println("2时0分");
  26.         System.out.println("2时1分");
  27.         System.out.println("2时2分");
  28.         System.out.println("2时3分");
  29.         */
  31.         //循环改进
  32.         /*
  33.         for(int minute=0; minute<4; minute++) {
  34.             System.out.println("0时" + minute + "分");
  35.         }
  36.         System.out.println("--------");
  38.         for(int minute=0; minute<4; minute++) {
  39.             System.out.println("1时" + minute + "分");
  40.         }
  41.         System.out.println("--------");
  43.         for(int minute=0; minute<4; minute++) {
  44.             System.out.println("2时" + minute + "分");
  45.         }
  46.         System.out.println("--------");
  47.         */
  49.         //外循环控制小时的范围，内循环控制分钟的范围
  50.         /*
  51.         for(int hour=0; hour<3; hour++) {
  52.             for(int minute=0; minute<4; minute++) {
  53.                 System.out.println(hour + "时" + minute + "分");
  54.             }
  55.             System.out.println("--------");
  56.         }
  57.         */
  59.         for(int hour=0; hour<24; hour++) {
  60.             for(int minute=0; minute<60; minute++) {
  61.                 System.out.println(hour + "时" + minute + "分");
  62.             }
  63.             System.out.println("--------");
  64.         }
  65.     }
  66. }

整个内循环，就是外循环的一个循环体，内部循环体没有执行完毕，外循环是不会继续向下执行的
结论：外循环执行一次，内循环执行一圈
**

Random

Random产生随机数

概述：
Random类似Scanner，也是Java提供好的API，内部提供了产生随机数的功能
使用步骤：

  1. 导入包
    import java.util.Random;
  2. 创建对象
    Random r = new Random();
  3. 产生随机数
    int num = r.nextInt(10);
    解释： 10代表的是一个范围，如果括号写10，产生的随机数就是0-9，括号写20，参数的随机数则是0-
    19

示例1

  1. /*
  2.     Random
  4.     作用：
  5.         用于产生一个随机数
  7.     使用步骤：
  8.         1:导包
  9.             import java.util.Random;
  10.         2:创建对象
  11.             Random r = new Random();
  12.         3:获取随机数
  13.             int number = r.nextInt(10);
  14.             获取数据的范围：[0,10) 包括0,不包括10
  15. */
  17. import java.util.Random;
  19. public class RandomDemo {
  20.     public static void main(String[] args) {
  21.         //创建对象
  22.         Random r = new Random();
  24.         //用循环获取10个随机数
  25.         for(int i=0; i<10; i++) {
  26.             //获取随机数
  27.             int number = r.nextInt(10);
  28.             System.out.println("number:" + number);
  29.         }
  31.         //需求：获取一个1-100之间的随机数
  32.         int x = r.nextInt(100) + 1;
  33.         System.out.println(x);
  34.     }
  35. }

示例2

  1. /*
  2.     猜数字
  4.     需求：
  5.         程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
  6.         当猜错的时候根据不同情况给出相应的提示
  8.         如果猜的数字比真实数字大，提示你猜的数据大了
  9.         如果猜的数字比真实数字小，提示你猜的数据小了
  10.         如果猜的数字与真实数字相等，提示恭喜你猜中了
  11. */
  13. import java.util.Random;
  14. import java.util.Scanner;
  16. public class RandomTest {
  17.     public static void main(String[] args) {
  18.         //要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
  19.         Random r = new Random();
  20.         int number = r.nextInt(100) + 1;
  22.         while(true) {
  23.             //使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
  24.             Scanner sc = new Scanner(System.in);
  26.             System.out.println("请输入你要猜的数字：");
  27.             int guessNumber = sc.nextInt();
  29.             //比较输入的数字和系统产生的数据，需要使用分支语句。这里使用if..else..if..格式，根据不同情况进行猜测结果显示
  30.             if(guessNumber > number) {
  31.                 System.out.println("你猜的数字" + guessNumber + "大了");
  32.             } else if(guessNumber < number) {
  33.                 System.out.println("你猜的数字" + guessNumber + "小了");
  34.             } else {
  35.                 System.out.println("恭喜你猜中了");
  36.                 break;
  37.             }
  38.         }
  40.     }
  41. }