Java 基础语法

Java 基础语法

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：【https://www.oracle.com/java/technologies/downloads/】

针对不同操作系统，下载对应的 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 激活工具：【https://files.cnblogs.com/files/blogs/722174/IDEA.zip?t=1646960426】

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随机数技术

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

使用步骤：

导包
```
 import java.util.Random;
```
实例化对象
```
 Random rd = new Random();
```
调用随机数
```
 int num = rd.nextInt(10);  // 获取 0 ~ 9 的整型随机数
```
Random 生成随机数的技巧，使用减加法获取指定范围的随机数

也可以直接输入区间

5、输入数据

Scanner键盘键入技术

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

使用步骤：

导包
```
 import java.util.Scanner;
```
实例化对象
```
 Scanner sc = new Scanner(System.in);
```

调用随机数

 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 内存分配

栈区

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

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

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

六、方法

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);
    }
}

posted @ 2022-03-21 12:24 Kenny_LZK 阅读(69) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Java 核心语法

· JS基础语法（一）

· Java基础语法（1）

· java语法基础

· Java基础语法

阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 单线程的Redis速度为什么快？

公告

昵称： Kenny_LZK
园龄： 3年3个月
粉丝： 68
关注： 5

+加关注

2025年3月

日

一

二

三

四

五

六

随笔分类 (297)

随笔档案 (185)

文章分类 (5)

国学(5)

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

	package demo001;

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

	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);
	}
	}

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

	// 判断最大值
	int k = 10, j = 30, i = 50;
	int max = (k > j ? k : j) > i ? (k > j ? k : j) : i;

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

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

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

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

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

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

	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 循环遍历数组
	}
	}
	}

	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;
	}
	}

	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;
	}
	}

	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);
	}

Kenny

Java 基础语法

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 总代码

公告

搜索

常用链接

最新随笔

3、第一个 Java 程序

1、注释

2、字面量

3、变量

4、数据类型

5、关键字

6、标识符

7、数据类型转换

三、运算符

1、算术运算符

2、赋值运算符

3、关系运算符

4、逻辑运算符

5、三元运算符

四、流程控制

1、顺序结构

2、分支结构

3、循环结构

4、随机数

5、输入数据

五、数组

1、概念

2、数组的定义

3、数组的遍历

4、数组排序

六、方法

1、简介

2、定义和调用

3、参数传递

4、方法重载

七、案例

1、买飞机票

2、找素数

3、开发验证码

4、数组元素复制

5、评委打分

6、数据加密

7、模拟双色球