Java基础语法有哪些特点？

本文共计8052个文字，预计阅读时间需要33分钟。

目录- Java 基础语法- Java 概述- Java 跨平台原理- Java 环境 - JRE - JDK - 环境配置 - 下载 - 安装- 第一个 Java 程序 - 开发程序 - 执行原理- IDEA 集成开发 - 简介

目录

• Java 基础语法
  • 一、 Java 概述
    • 1、 Java 跨平台原理
    • 2、 Java 环境
      • 2.1 JRE
      • 2.2 JDK
      • 2.3 配置环境
        • 2.3.1 下载
        • 2.3.2 安装
    • 3、 第一个 Java 程序
      • 3.1 开发程序
      • 3.2 执行原理
    • 4、 IDEA 集成开发
      • 4.1 简介
      • 4.2 使用
      • 4.3 快速生成代码
  • 二、 Java 基础
    • 1、 注释
    • 2、 字面量
    • 3、 变量
    • 4、 数据类型
    • 5、 关键字
    • 6、 标识符
    • 7、 数据类型转换
      • 7.1 自动类型转换
      • 7.2 强制类型转换
  • 三、 运算符
    • 1、 算术运算符
    • 2、 赋值运算符
    • 3、 关系运算符
    • 4、 逻辑运算符
    • 5、 三元运算符
  • 四、 流程控制
    • 1、 顺序结构
    • 2、 分支结构
      • 2.1 if
      • 2.2 switch
    • 3、 循环结构
      • 3.1 for
      • 3.2 while
      • 3.3 do...while
      • 3.4 中断
        • 3.4.1 break
        • 3.4.2 continue
        • 3.4.3 return
    • 4、 随机数
    • 5、 输入数据
  • 五、 数组
    • 1、 概念
    • 2、 数组的定义
    • 3、 数组的遍历
    • 4、 数组排序
    • 5、 Java 内存分配
  • 六、 方法
    • 1、 简介
    • 2、 定义和调用
      • 2.1 定义
      • 2.2 调用
    • 3、 参数传递
      • 3.1 值传递
      • 3.2 引用传递
    • 4、 方法重载
  • 七、 案例
    • 1、 买飞机票
    • 2、 找素数
    • 3、 开发验证码
    • 4、 数组元素复制
    • 5、 评委打分
    • 6、 数据加密
    • 7、 模拟双色球
      • 7.1 业务分析
      • 7.2 用户输入一组蓝色号码
      • 7.3 判断中奖情况
      • 7.4 总代码

Java 基础语法 一、 Java 概述 1、 Java 跨平台原理

在需要运行 Java 应用程序的操作系统上，安装一个与操作系统对应的 Java 虚拟机（JVM）即可

2、 Java 环境 2.1 JRE

是 Java 程序运行时环境，包含 JVM 和运行时所需要的核心类库

我们想要运行一个已有的 Java 程序，那么只需安装 JRE 即可

2.2 JDK

是 Java 程序开发工具包，包含 JRE 和开发人员使用的工具

其中的开发工具：编译工具（javac）和运行工具（java）

我们想要开发一个全新的 Java 程序，那么必须先安装 JDK

2.3 配置环境 2.3.1 下载

通过官方网站获取 JDK：

针对不同操作系统，下载对应的 JDK

2.3.2 安装

一路点击下一步即可

安装路径下不要包含中文和空格，所有开发工具最好安装目录统一

JDK 各目录作用

目录名称 说明 bin 该路径下存放了 JDK 的各种工具命令。javac 和 java 就放在这个目录 conf 该路径下存放了 JDK 相关配置文件 include 该路径下存放了一些平台特定的头文件 jmods 该路径下存放了 JDK 的各种模块 legal 该路径下存放了 JDK 各模块的授权文档 lib 该路径下存放了 JDK 工具的一些补充 JAR 包

其余文件为说明文档

---

已知，我安装 JDK 的路径为 D:\Program Files\Java\jdk-17.0.2

在系统变量中添加以下值

• CLASSPATH

  • .;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar

    注意前面是有一个点的

• JAVA_HOME

  

  • D:\Program Files\Java\jdk-17.0.2

• Path 中添加

  • %JAVA_HOME%\jre\bin
  • %JAVA_HOME%\bin

在 cmd 中输入 java -version 出现版本号即表示安装成功

---

3、 第一个 Java 程序 3.1 开发程序

开发 Java 程序，需要三个步骤：编写程序、编译程序、运行程序

• 编写程序

  public class first { public static void main (String[] args) { System.out.println("Hello World"); } }

• 编译程序

  在 cmd 中输入 javac 文件名.java javac first.java

• 运行程序

  在 cmd 中输入 java 文件名 java first

3.2 执行原理

不管是什么样的高级编程语言，最终都是翻译成计算机底层可以识别的机器语言

4、 IDEA 集成开发 4.1 简介

集成开发环境：

• 把代码编写、编译、执行等多种功能综合到一起的开发工具，可以进行代码智能提示、错误提醒、项目管理等等

IDEA 激活工具：

4.2 使用

IDEA 结构介绍

• project：项目、工程
  • module：模块
    • package：包
      • class：类

4.3 快速生成代码 效果 命令 生成主方法 psvm+回车 打出System.out.println(); sout+回车 复制当前一行 Ctrl + D 删除当前一行 Ctrl + X 格式化代码 Ctrl + Alt + L 快速遍历数组 数组名.fori + 回车 二、 Java 基础 1、 注释

注释是写在程序中对代码进行解释说明的文字，方便自己和其他人查看，以便理解程序

package demo001; /** 文档注释 文档注释的内容是可以提取到一个程序说明文档中去的 */ public class demo1 { public static void main(String[] args) { // 以下是打印程序，单行注释 System.out.println("hello"); /* 这是多行注释 */ } }

注释的特点

• 注释不影响程序的执行

2、 字面量

计算机是用来处理数据的，字面量就是告诉程序员：数据在程序中的书写格式

package demo001; /** 字面量 */ public class demo1 { public static void main(String[] args) { // 整数 System.out.println(666); // 小数 System.out.println(2.3); // 字符，\n 换行字符，\t 水平制表位 System.out.println('A'); // 其自带了换行功能 System.out.println('\n'); // 换两行 // 字符串 System.out.println("ABC"); // bool 值 System.out.println(true); } }

和 C++ 的字面量相同

3、 变量

变量就是用来存储一个数据的内存区域（可以理解成盒子），且里面存储的数据可以变化

语法：

数据类型 变量名称 = 初始值;

注意：

• 变量要先声明再使用
• 变量声明后，不能存储其他类型的数据
• 变量的有效范围是从定义开始到 ";" 截止，且在同一个作用域内不能定义多个同名变量
• 变量定义的时候可以没有初始值，但是使用的时候必须给初始值

4、 数据类型

有两类：

• 引用数据类型：String

• 基本数据类型：4 大类 8种

  类型名称 关键字 占用内存 取值范围 字节型 byte 1 字节 -128~127 短整型 short 2 字节 -32768~32767 整型 int（默认） 4 字节 -2147483648~2147483647 长整型 long 8 字节 -9223372036854775808L~9223372036854775807L 单精度浮点型 float 4 字节 +/-3.4E+38F（6~7 个有效位） 双精度浮点型 double（默认） 8 字节 +/-1.8E+308 (15 个有效位） 字符型 char 2 字节 ISO 单一字符集 布尔型 boolean 1 字节 true 或 false

5、 关键字

Java 自己保留的一些单词，作为特殊功能

我们不能使用关键字作为类名或者变量名称，否则报错

6、 标识符

标识符就是由一些字符。符号组成起来的名称，用于给类、方法、变量等取名字的规矩

要求：

• 由数字、字母、下划线和美元符等组成
• 不能以数字开头，不能是关键字，区分大小写

命名规范：

• 变量名称： 满足标识符规则，建议全英文、有意义、首字母小写，满足驼峰命名法
• 类名称：满足标识符命名规则，建议全英文、有意义、首字母大写，满足驼峰命名法

7、 数据类型转换 7.1 自动类型转换

类型范围小的变量，可以直接赋值给类型范围大的变量

byte a = 20; int b = a; System.out.println(b);

表达式类型自动转换：

byte a = 1; double b = 1.2; System.out.println(a + b);

小范围的类型会自动转换成大范围的类型运算

7.2 强制类型转换

类型范围大的数据或者变量，不能直接赋值给类型范围小的变量，会报错；要通通过强制类型转换类实现

语法：

数据类型2 变量2 = (数据类型2)变量1

int a = 30; byte b = (byte)a; // 强制转换 System.out.println(b);

注意：

• 其可能会造成数据损失或溢出

三、 运算符 1、 算术运算符

运算符：对字面量或者变量进行操作的符号

"+" 加, "-" 减, "/" 除, "*" 乘, "%" 取余, "++" 递增, "--"递减

两个整数相除结果是整数

加法与字符串运算的时候是用作 连接符的，其结果依然是一个字符串

++ 既可以放在变量后面，也可以放在变量前面

• 前面，先对变量进行算术运算，再进行其他运算
• 后面，先对变量进行其他运算，再进行算术运算

2、 赋值运算符

"=" 等于, "+=" 加等于 , "-=" 减等于 , "/=" 除等于 , "%=" 余等于 , "*=" 乘等于

其中，隐含了强制类型转换

byte i = 10, j = 20; // i = (byte) (i + j); i += j; 3、 关系运算符

"=="等于 , "<=" 小于等于, ">=" 大于等于 , "!=" 不等于 , "<" 小于 , ">" 大于

4、 逻辑运算符 操作符 描述 && 短路与运算符，当且仅当两个操作数都为真，条件才为真。 | | 短路或操作符，如果任何两个操作数任何一个为真，条件为真。 ！ 逻辑非运算符，用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false & 逻辑与，当两个操作数为真，即为真 | 逻辑或，当两个操作数为假，即为假 ^ 逻辑异或，两个运算结果不同才为 true

逻辑与、逻辑或：无论左边是 false 还是 true，右边都要执行

短路与、。短路或：当左边可以判断结果时，不会执行右边的代码

5、 三元运算符

语法：

条件吧表达式 ? 值1 : 值2；

执行流程：首先要计算关系表达式的值，如果值为 true，返回值1；如果值为 false ，返回值2

// 判断最大值 int k = 10, j = 30, i = 50; int max = (k > j ? k : j) > i ? (k > j ? k : j) : i; 四、 流程控制 1、 顺序结构

程序默认流程

2、 分支结构

根据判定的结果（真或假）决定执行某个分支的代码

2.1 if

语法：

if (条件表达式1) { 语句体1; } else if (条件表达式2) { 语句体2; } esle { 语句体3; } 2.2 switch

语法：

switch (表达式) { case 值1: 执行代码1; break; case 值2: 执行代码2; brreak; default: 执行代码n; }

注意：

• 表达式类型只能是 byte、short、int、char，JDK5开始支持枚举，JDK7 支持 String、不支持 double、float、long
• case 给出的值不允许重复，且只能是字面量，不能是变量
• 不要忘记写 break，否则会出现穿透现象

3、 循环结构

控制一段代码反复执行很多次

3.1 for

语法：

for (初始化语句; 循环条件; 迭代语句) { 循环语句; } 3.2 while

语法：

while (循环条件) { 循环语句; 迭代语句; }

当不确定循环次数时，优先使用 while 循环；反之使用 for 循环

3.3 do...while

语法：

do { 循环语句; 迭代语句; } while (循环条件) 3.4 中断 3.4.1 break

终止循环

3.4.2 continue

中断本次循环，进行下次循环

3.4.3 return

跳出并立即结束所在方法的执行

4、 随机数

Random随机数技术

作用：用于在程序中获取随机数

使用步骤：

1. 导包

   import java.util.Random;

2. 实例化对象

   Random rd = new Random();

3. 调用随机数

   int num = rd.nextInt(10); // 获取 0 ~ 9 的整型随机数

   Random 生成随机数的技巧，使用减加法获取指定范围的随机数

   也可以直接输入区间

5、 输入数据

Scanner键盘键入技术

作用：用于在程序中获取键盘输入的内容

使用步骤：

1. 导包

   import java.util.Scanner;

2. 实例化对象

   Scanner sc = new Scanner(System.in);

3. 调用随机数

   int num = sc.nextInt(); // 获取数字 String ch = sc.next(); // 获取字符串

五、 数组 1、 概念

数组就是用来存储一批同种类型数据的内存区域（可以理解成容器）

• 数组适合做一些同种类型数据的存储

2、 数组的定义

• 静态初始化数组

  • 定义数组的时候直接给数组赋值

  语法：

  • 数据类型[] 数组名 = new 数据类型[]{ 元素1, 元素2 }; // 简化版本 数据类型[] 数组名 = { 元素1, 元素2 };

    注意事项：

    • 数据类型[] 数组名也可以写成数据类型 数组名[]
    • 什么类型的数组就存放什么类型的数据，否则报错
    • 数组一旦定义出来，程序执行的过程中，长度、类型就固定了

  数组的访问

  • 索引访问

    语法：

    • 数组名[索引];

      其也可以给数组赋值

  • 数组长度属性

    语法：

    • 数组名.length; // 获取数组的长度

      最大索引是：arr.length - 1

• 动态初始化数组

  • 定义数组的时候只确定元素的类型和数组长度，之后再存入具体数据

  语法：

  • 数据类型[] 数组名 = new 数据类型[长度];

    数组里面的元素默认值为 boolean 值为 false 所对应的数据类型

  后赋值

  • 数组名[索引] = 值;

• 区别

  • 当前已经知道存入的元素值，用静态初始化
  • 当前还不清楚要存入哪些数据，用动态初始化
  • 两种格式的写法是独立的，不能混合使用

3、 数组的遍历

遍历：就是一个一个数据的访问

public class demo1 { public static void main(String[] args) { int[] arr = {0, 1, 2, 3, 4}; for (int i = 0; i < (arr.length); i++){ System.out.println(arr[i]); // for 循环遍历数组 } } } 4、 数组排序

冒泡排序思想：

• 每次从数组中找出最大值放在数组的后面去

实现冒泡排序的关键步骤：

• 确定总共需要做几轮：数组长度 - 1
• 每轮比几次：数组长度 - 1 - 已比较多少轮

package demo001; public class demo1 { public static void main(String[] args) { int[] arr = {0, 1, 2, 5, 4}; for (int i = 0; i < arr.length - 1; i++) { for (int j = 0; j < arr.length - i - 1; j++) { if (arr[j] > arr[j+1]) { int temp = arr[j + 1]; arr[j + 1] = arr[j]; arr[j] = temp; // 降序排序 } } } for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } } 5、 Java 内存分配

1. 栈区

   方法运行时所进入的内存，变量也是存储在这里

2. 堆区

   new 出来的东西会在这块内存中开辟空间并生产地址

3. 方法区

   里面存储了定义的方法和类

六、 方法 1、 简介

方法是什么：

• 方法是一种语法结构，它可以把一段代码封装成一个功能，以方便重复调用

作用：

• 提高了代码的复用性
• 让程序逻辑更清晰

package demo001; public class demo1 { public static void main(String[] args) { System.out.println(sum(2, 3)); } public static int sum(int a, int b) { return a + b; } } 2、 定义和调用 2.1 定义

语法：

修饰符 返回值类型 方法名(形参列表) { 方法体代码; }

注意：

• 方法的修饰符：暂时使用 public static 修饰
• 方法申明了具体返回值类型，内部必须使用 return 返回对应类型的数据
• 形参列表可以有多个，甚至可以没有；如果有多个形参，多个形参必须用 "," 隔开，且不能给初始化值
• 方法定义时：返回值类型、形参按照需求来填写

2.2 调用

语法：

方法名(参数); 3、 参数传递 3.1 值传递

在传输实参给方法的时候，并不是传输实参变量本身，而是传输实参变量中存储的值，这就是值传递

注意：

• 实参：在方法内部定义的变量
• 形参：在方法定义时，声明的参数

3.2 引用传递

在传输实参给方法的时候，传递实参变量的地址给函数，函数内部修该变量，外部也会同步修改

4、 方法重载

同一个类中，出现多个方法名称相同，但是形参列表是不同的，那么这些方法就是重载方法

调用方法的时候，会通过参数的不同来区分调用的是哪个方法

作用：

• 可读性好
• 通过形参不同实现功能差异化的选择，是一种专业化的代码设计

七、 案例 1、 买飞机票

需求分析：

• 机票价格按照淡季旺季、头等舱和经济舱收费、输入飞机票原价、月份和头等舱或经济舱
• 机票最终优惠价格的计算方案如下：
  • 旺季（5~10月）：头等舱9折、经济舱8.5折
  • 淡季（11月~4月）：头等舱7折、经济舱6.5折

实现思路：

• 键盘录入机票的原价，仓位类型、月份信息，调用方法返回机票最终的优惠价格
• 方法内部应该先使用 if 分支判断月份是在淡季还是旺季，然后使用 switch 分支判断是头等舱还是经济舱

package demo001; import java.util.Scanner; public class demo1 { public static void main(String[] args) { // 用户输入信息 Scanner sc = new Scanner(System.in); System.out.println("请输入机票的原价："); double price = sc.nextDouble(); System.out.println("请输入机票的月份："); int month = sc.nextInt(); System.out.println("请输入舱位类型：\n1. 头等舱\n2. 经济舱"); int type = sc.nextInt(); System.out.println(calc(price, month, type)); } public static double calc(double price, int month, int type) { if (!(month > 0 && month < 13 && type > 0 && type < 3 && price > 0)) { System.out.println("您输入有误，请重新输入！！！"); return 0; } if (month > 4 && month < 11) { // 4 < month < 11 switch (type) { case 1: price *= 0.9; break; case 2: price *= 0.85; break; } } else { // 11 ~ 4 switch (type) { case 1: price *= 0.7; break; case 2: price *= 0.65; break; } } return price; } } 2、 找素数

判断 101 ~ 200 之间有多少个素数，并输出所有素数

分析：

• 101 ~ 200 之间的数据可以采用循环依次拿到；每拿到一个数，判断该数是否是素数
• 判断规则是：从2开始遍历到该数的一半数据，看是否有数据可以整除它，有则不是素数，没有则是素数

package demo001; public class demo1 { public static void main(String[] args) { for (int i = 101; i < 201; i++) { boolean flag = true; // 信号位，默认为素数 for (int j = 2; j < (i / 2); j++) { if ((i % j) == 0) { flag = false; break; } } if (flag) { System.out.println(i + "该数为素数"); } else { System.out.println(i + "该数不是素数"); } } } } 3、 开发验证码

需求：

• 定义一个方法实现随机产生一个 5 位的验证码，每位可能是数字、大写字母、小写字母

分析：

• 定义一个方法，生成验证码返回：方法参数是位数、方法返回值类型是 String
• 在方法内部使用 for 循环生成指定位数的随机字符，并连接起来
• 把连接好的随机字符作为一组验证码进行返回

package demo001; import java.util.Random; public class demo1 { public static void main(String[] args) { System.out.println(verify(5)); } public static String verify(int n) { String verify = ""; // 接收生成的验证码 Random r = new Random(); for (int i = 0; i < n; i++) { // 生成随机字符 int type = r.nextInt(3); // 0 1 2 分别对应英文大小写，数字 switch (type) { case 0: // 英文大写 A~Z 65~65+25 char ch = (char) (r.nextInt(26) + 65); verify += ch; break; case 1: // 英文小写 a~z 97~97+25 char cr = (char) (r.nextInt(26) + 97); verify += cr; break; case 2: // 数字 0~9 int ci = r.nextInt(10); verify += ci; } } return verify; } } 4、 数组元素复制

需求：

• 把一个数组中的元素复制到另一个新数组中去

分析：

• 需要动态初始化一个数组，长度与原数组一样
• 遍历原数组的每个元素，依次赋值给新数组
• 输出两个数组的内容

package demo001; public class demo1 { public static void main(String[] args) { int[] arr1 = {11, 22, 33, 44}; int[] arr2 = new int[arr1.length]; copy_arr(arr1, arr2); printArr(arr1); printArr(arr2); } public static void printArr(int[] arr) { System.out.print("["); for (int i = 0; i < arr.length; i++) { // 输出数组 System.out.print( i != arr.length - 1 ? arr[i] + ", " : arr[i]); } System.out.println("]"); } public static void copy_arr(int[] arr, int[] arr2) { for (int i = 0; i < arr.length; i++) { arr2[i] = arr[i]; } } } 5、 评委打分

需求：

• 在唱歌比赛中，有 6 名评委给选手打分，分数范围是 [0, 100] 之间的整数。选手的最后得分为：去掉最高分和最低分后的四名评委的平均分

分析：

• 把 6 个评委的打分录入到一个数组中去
• 遍历数组中每个数据，进行累加求和，并找出最高分、最低分
• 按照分数的计算规则算出平均分

package demo001; import java.util.Random; public class demo1 { public static void main(String[] args) { int[] score = new int[6]; playScore(score); printArr(score); sum(score); } public static void playScore(int[] arr) { Random r = new Random(); for (int i = 0; i < arr.length; i++) { // 使用随机数表示 arr[i] = r.nextInt(101); } } public static void printArr(int[] arr) { System.out.print("["); for (int i = 0; i < arr.length; i++) { // 输出数组 System.out.print( i != arr.length - 1 ? arr[i] + ", " : arr[i]); } System.out.println("]"); } public static void sum(int[] arr) { int max = arr[0], min = arr[0], sum = 0; for (int i = 0; i < arr.length; i++) { if (max < arr[i]) { max = arr[i]; } if (min > arr[i]) { min = arr[i]; } sum += arr[i]; } int sum1 = sum - min - max; System.out.println(sum + " - " + min + " - " + max + " = " + sum1); // 输出最值 System.out.println("平均分为：" + sum1 * 1.0 / (arr.length - 2)); // 平均分 } } 6、 数据加密

需求：

• 某系统的数字密码：比如1983 --> 8346，采用加密方式进行传输，规则如下：

  • 先得到每位数，然后每位数都加上 5，再对 10 取余，最后将所有数字反转，得到一串新数

分析：

• 将每位数据存入到数组中去，遍历数组每位数据，按照规则进行修改，把更改后的数据重新存入数组中

package demo001; import java.util.Scanner; public class demo1 { public static void main(String[] args) { System.out.println("请您输入要加密的数字"); Scanner sc = new Scanner(System.in); int num = sc.nextInt(); int[] arr = new int[getBit(num)], arr_encrypt = new int[getBit(num)]; getIntArr(arr, num); // 得到整型数组 printArr(arr); // 输出数组 encrypt(arr, arr_encrypt); // 加密数组 printArr(arr_encrypt); // 输出加密后的数组 } private static int getBit(int num) { // 获取数字的位数 if (num == 0) { return 1; } int length = 0; for (int i = num; i != 0; i /= 10) { length++; } return length; } private static void getIntArr(int[] arr, int num) { for (int i = 0; i < arr.length; i++) { arr[arr.length - i - 1] = num / ((int) Math.pow(10, i)) % 10; // 得到数字的每一位 } } private static void printArr(int[] arr) { System.out.print("["); for (int i = 0; i < arr.length; i++) { System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", "); } System.out.println("]"); } private static void encrypt(int[] arr, int[] encrypt_arr) { for (int i = 0; i < arr.length; i++) { // 加密 encrypt_arr[arr.length - i - 1] = (arr[i] + 5) % 10; } } }

同时其也是解密程序

7、 模拟双色球 7.1 业务分析

投注号码由 6 个红色球号码 1 个蓝色球号码组成。红色球号从 1 - 33 中选择；蓝色球号从 1 - 16 中选择

随机生成一组中奖号码：

• 中奖号码由 6 个红球和 1 个蓝色组成（注意：6个红球不能重复）
• 可以定义方法用于返回一组中奖号码（7个数据），返回的形式是一个整型数组

package demo001; import java.util.Random; public class demo1 { public static void main(String[] args) { int[] arr = createLuckNum(); printArr(arr); } private static int[] createLuckNum() { // 定义一个动态初始化的数组，有 7 个数字 int[] num = new int[7]; Random r = new Random(); // 红球赋值 for (int i = 0; i < 6; i++) { // 注意要判断数字是否出现过 while (true) { int data = r.nextInt(33) + 1; boolean flag = true; // 默认没有重复 for (int j = 0; j < i; j++) { if (num[j] == data) { flag = false; break; } } if (flag) { // 没有重复 num[i] = data; break; } } } // 生成蓝色号码 num[num.length - 1] = r.nextInt(16) + 1; return num; } private static void printArr(int[] arr) { System.out.print("["); for (int i = 0; i < arr.length; i++) { System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", "); } System.out.println("]"); } } 7.2 用户输入一组蓝色号码

分析：

• 定义一个方法，该方法可以录入用户输入的 6 个红球和 1 个蓝色号码
• 该方法最终返回一个数组，数组中就是用户录入的号码（7位）

private static int[] userInputNum() { // 定义一个数组存储 7 个号码 int[] num = new int[7]; // 用户输入 7 个号码 Scanner sc = new Scanner(System.in); for (int i = 0; i < 6; i++) { System.out.printf("请您输入第%d个红球号码：\n", i + 1); int data = sc.nextInt(); // 把数据存入数组中 num[i] = data; } // 存入蓝球号码 System.out.println("请您输入蓝球号码："); num[num.length - 1] = sc.nextInt(); return num; } 7.3 判断中奖情况

private static void judge(int[] arr, int[] arrUser) { // 判断是否中奖 int red = 0, blue = arr[arr.length - 1] == arrUser[arrUser.length - 1] ? 1 : 0; // 统计红球的个数 for (int i = 0; i < arr.length - 1; i++) { for (int j = 0; j < arrUser.length - 1; j++) { if (arr[i] == arrUser[j]) { red++; break; } } } System.out.println("红球中奖个数：" + red + "\t蓝球中奖个数：" + blue); } 7.4 总代码

package demo001; import java.util.Random; import java.util.Scanner; public class demo1 { public static void main(String[] args) { int[] arr = createLuckNum(), userArr = userInputNum(); System.out.println("中奖号码："); printArr(arr); System.out.println("投注号码："); printArr(userArr); judge(arr, userArr); } private static int[] createLuckNum() { // 定义一个动态初始化的数组，有 7 个数字 int[] num = new int[7]; Random r = new Random(); // 红球赋值 for (int i = 0; i < 6; i++) { // 注意要判断数字是否出现过 while (true) { int data = r.nextInt(33) + 1; boolean flag = true; // 默认没有重复 for (int j = 0; j < i; j++) { if (num[j] == data) { flag = false; break; } } if (flag) { // 没有重复 num[i] = data; break; } } } // 生成蓝色号码 num[num.length - 1] = r.nextInt(16) + 1; return num; } private static void printArr(int[] arr) { System.out.print("["); for (int i = 0; i < arr.length; i++) { System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", "); } System.out.println("]"); } private static int[] userInputNum() { // 定义一个数组存储 7 个号码 int[] num = new int[7]; // 用户输入 7 个号码 Scanner sc = new Scanner(System.in); for (int i = 0; i < 6; i++) { System.out.printf("请您输入第%d个红球号码：\n", i + 1); int data = sc.nextInt(); // 把数据存入数组中 num[i] = data; } // 存入蓝球号码 System.out.println("请您输入蓝球号码："); num[num.length - 1] = sc.nextInt(); return num; } private static void judge(int[] arr, int[] arrUser) { // 判断是否中奖 int red = 0, blue = arr[arr.length - 1] == arrUser[arrUser.length - 1] ? 1 : 0; // 统计红球的个数 for (int i = 0; i < arr.length - 1; i++) { for (int j = 0; j < arrUser.length - 1; j++) { if (arr[i] == arrUser[j]) { red++; break; } } } System.out.println("红球中奖个数：" + red + "\t蓝球中奖个数：" + blue); } }