文章最后有pdf版！！！
1. Java入门
1.1 Java技术体系
| 技术体系 | 说明 |
|---|---|
| Java SE(Java Standard Edition)：标准版 | Java技术的核心和基础 |
| Java EE(Java Enterprise Edition)：企业版 | 企业级应用开发的一套解决方案 |
| Java ME(Java Micro Edition)：小型版（市场不大认可） | 针对移动设备应用的解决方案 |
1.2 Java环境搭建
JDK：Java开发者工具包
1.2.1 下载jdk
进入Oracle官网：[Oracle 甲骨文中国 | 云应用和云平台](https://www.oracle.com/cn/)
往下滚动：
需要登录Oracle官网，再下载；还有更简单的方法：直接问AI
1.2.2 安装jdk
双击文件直接安装：
一定要修改文件安装路径，路径没有空格和中文。
安装成功！
1.2.3 java和javac
1.3 Java入门程序开发
1.3.1 编写源代码文件
1.3.2 编译文件
打开命令符窗口，使用javac命令：
成功后会生成class文件：
1.3.3 运行代码命令
jdk11开始可以直接运行Java源代码文件：
这样原理相同，但是不会生成class文件。
1.4 单元测试
2. 开发工具
2.1 JDK的组成
- JDK：Java开发工具包
- JRE：Java的运行环境
- JVM：Java虚拟机，真正运行Java程序的地方
- 核心类库：Java自己写好的程序，给程序员自己的程序调用的
2.2 Java的跨平台原理
一次编译，处处可用
2.3 配置Path环境变量
Path环境变量用于记住程序路径，方便在命令行窗口的任意目录启动程序
jdk17自动配置了Path环境变量，java命令默认放在c盘下：
但是较老版本的jdk需要手动配置Path环境变量。
2.4 配置JAVA_HOME环境变量
JAVA_HOME:告诉操作系统JDK安装在了哪个位置（将来其他技术或组件要通过这个环境变量找到JDK）
jdk17只自动配置了Path环境变量，需要手动配置JAVA_HOME。
配置完JAVA_HOME后，推荐在Path中直接调用JAVA_HOME变量；这样在后来更换jdk版本时，只需要修改JAVA_HOME就行，不需要修改Path变量：
2.5 IDEA的下载和安装
IDEA的官网：[IntelliJ IDEA – 专业 Java 和 Kotlin 开发 IDE](https://www.jetbrains.com/zh-cn/idea/)
下载后双击安装包：
修改安装路径，不要带空格和中文。
2.6 使用IDEA
IDEA管理Java程序的结构：
- project（项目、工程）
- module（模块）
- package（包）
- class（类）
2.7 IDEA的背景色和快捷键
将背景设置成豆沙绿：
常用快捷键：
| 快捷键 | 功能 |
|---|---|
| ctrl+z | 撤销上一步操作（win系统自带） |
| ctrl+d | 复制当前行代码至下一行 |
| ctrl+x | 剪切当前行，相当于删除当前行 |
| ctrl+alt+l | 格式化代码 |
| shift+alt+⬆️/⬇️ | 将当前行上移/下移 |
| ctrl+/ | 单行注释 |
| shift+ctrl+/ | 多行注释 |
2.8 单元测试
3. 基础语法
3.1 注释
文档注释的内容可以提取到程序说明文档中。
3.2 字面量
字面量（Literal） 是指直接在代码中表示固定值的符号或文本。
package com.itheima.literal;
/**
* @ClassName LiteralDemo
* @Description 字面量
* @Author 孙克旭
* @Date 2025/2/22 21:46
*/
public class LiteralDemo {
public static void main(String[] args) {
//1. 整数
System.out.println(101);
//2. 小数
System.out.println(10.2);
//3. 字符：必须用单引号，里面有且只有一个字符
System.out.println('1');
System.out.println('a');
System.out.println('孙');
System.out.println(' '); // 一个空格
// System.out.println(''); 错误，不能为空
// System.out.println(' '); 错误，不能有多个空格
//3.1 特殊字符：\n:换行，\t:制表符
System.out.println('\n');
System.out.println('\t');
//4. 字符串：双引号引用，里面内容随意
System.out.println(""); // 空字符串
System.out.println("a");
System.out.println("我");
System.out.println("孙克旭");
System.out.println(" "); // 空格字符串
//5. 布尔值：true false
System.out.println(true);
System.out.println(false);
}
}
3.3 变量
变量是内存中的一块区域，用来存储计算机将要计算的数据。
变量格式：变量类型 变量名称 = 数据；
package com.itheima.variable;
/**
* @ClassName VariableDemo1
* @Description 变量
* @Author 孙克旭
* @Date 2025/2/23 15:33
*/
public class VariableDemo1 {
public static void main(String[] args) {
// 模拟微信钱数变化，原来有100.67元，发出38.4元，收到20.5元。
double money = 100.67;
money = money - 38.4;
System.out.println(money);
money = money + 20.5;
System.out.println(money);
System.out.println("-------------------------------");
// 车站收费规则：大人2元，小孩1元
// 第一站：2个大人，3个小孩
// 第二站：3个大人，5个小孩
int count = 0;
int money2 = 0;
count = count + 2 + 3 + 3 + 4;
money2 = money2 + 2 * 2 + 3 * 1 + 3 * 2 + 5 * 1;
System.out.println(count);
System.out.println(money2);
}
}
3.4 关键字、标识符
变量名、类名等都是标识符
- 标识符由数字、字母、下划线（_）和美元符号（$）组成
- 标识符不能以数字开头，不能与关键字重名，区分大小写
标识符建议规范：
3.5 单元测试
3.6 课后练习
请编写程序，将某位学员的个人信息输出到屏幕上。信息包括姓名（字符串常量）、性别（字符常量）、年龄（整型常量）、身高（单位米，小数常量）、婚否（布尔常量）。输出格式如下：
张三
男
18
1.78
false
package com.itheima.variable;
/**
* @ClassName VariableDemo2
* @Description 课后练习
* @Author 孙克旭
* @Date 2025/2/23 16:11
*/
public class VariableDemo2 {
public static void main(String[] args) {
String name = "张三";
char gender = '男';
int age = 18;
double tall = 1.78;
boolean marry = false;
System.out.println(name);
System.out.println(gender);
System.out.println(age);
System.out.println(tall);
System.out.println(marry);
}
}
3.7 单元练习1
3.7.1 聊一聊你对变量的理解, 说明在什么情况下, 该定义变量
变量:
[官方定义]:内存中的一块存储空间, 空间中存储着经常发生改变改变的数据
[方便理解]:程序运行期间,其值可以发生改变的数据,叫做变量
场景:
如果发现程序中, 自己要使用的数据, 是经常发生改变的, 那就可以使用变量进行保存
例如:
姓名, 年龄, 用户名, 密码...
格式:
数据类型 变量名 = 数据值;
3.7.2 简述下什么是标识符, 在定义标识符的时候, 应该满足哪些规则和规范呢 ?
标识符:
简单来说就是自己给类, 变量...起名字的符号
规则:
字母 az A-Z
数字 09
特殊符号 _ $
数字不能开头, 不能是Java中的关键字
规范:
小驼峰命名法(变量): 如果是一个单词, 所有字母小写, 如果是多个单词, 从第二个单词开始, 首字母大写
例如:
age maxAge
大驼峰命名法(类):
如果是一个单词, 首字母大写, 如果是多个单词, 每个单词首字母大写
例如:
Student GoodStudent
3.7.3 编码题1
定义一个类，并在main方法中完成如下任务：
① 在控制台分别输出数字100，小数520.1314，字符‘X’，字符串“博学谷真棒！”
② 假设学生A年龄24岁，定义变量保存学生年龄，并在控制台输出年龄数字
③使用单行注释，注释任务②的输出语句，运行并查看控制台输的结果。
④ 使用多行注释，注释任务①的输出语句，运行并查看控制台输的结果。
⑤ 定义变量，变量名中分别包含： “_” “123” “$” 运行并在控制台分别输出并查看结果
package com.itheima.variable;
/**
* @ClassName VariableDemo2
* @Description 编码题1
* @Author 孙克旭
* @Date 2025/2/23 16:11
*/
public class VariableDemo3 {
public static void main(String[] args) {
/*System.out.println(100);
System.out.println(520.1314);
System.out.println('X');
System.out.println("博学谷真棒!");*/
int age = 24;
// System.out.println(age);
String $123_ = "孙克旭";
System.out.println($123_);
}
}
3.7.4 编码题2
学生张三，个人信息如下：
姓名：张三
年龄：22（岁）
身高：1.85（米）
① 在控制台分别输出学生的姓名、年龄、身高。
② 该学生语文、数学、英语成绩分别为：88、92、85，定义三个变量分别保存成绩，在控制台分别输出三个成绩
package com.itheima.variable;
/**
* @ClassName VariableDemo2
* @Description 编码题2
* @Author 孙克旭
* @Date 2025/2/23 16:11
*/
public class VariableDemo4 {
public static void main(String[] args) {
System.out.println("张三");
System.out.println(22);
System.out.println(1.85);
int Chinese = 88;
int Math = 92;
int English = 85;
System.out.println(Chinese);
System.out.println(Math);
System.out.println(English);
}
}
3.7.5 编码题3
请选用符合条件的变量，接收以下专辑信息，并打印在控制台：
①名字：范特西
②发行日期：2001年9月14日
③曲目数量：10
④演唱：周杰伦
package com.itheima.variable;
/**
* @ClassName VariableDemo2
* @Description 编码题3
* @Author 孙克旭
* @Date 2025/2/23 16:11
*/
public class VariableDemo5 {
public static void main(String[] args) {
String name = "范特西";
String date = "2001年9月14日";
int count = 10;
String singer = "周杰伦";
System.out.println(name);
System.out.println(date);
System.out.println(count);
System.out.println(singer);
}
}
4. 类型转换
4.1 ASCⅡ 编码表
计算字底层存储的数字是二进制，数据的最小单位是字节，即8bit；
字符与二进制的转换关系是ASCⅡ编码表，每个字符底层都占一个字节；
A：65
a：97
4.2 2、8、16进制
package com.itheima.literal;
/**
* @ClassName Demo2
* @Description 进制
* @Author 孙克旭
* @Date 2025/2/23 17:37
*/
public class Demo2 {
public static void main(String[] args) {
// 2进制,必须以0b或0B开头
int i1 = 0B01100001;
System.out.println(i1);
// 8进制，必须以0开头
int i2 = 0141;
System.out.println(i2);
// 16进制，必须以0x或0X开头
int i3 = 0X61;
System.out.println(i3);
}
}
4.3 数据类型
数据类型分为基本数据类型和引用数据类型
基本数据类型：
引用数据类型：
String，字符串
package com.itheima.variable;
/**
* @ClassName TypeDemo1
* @Description 基本数据类型
* @Author 孙克旭
* @Date 2025/2/23 19:19
*/
public class TypeDemo1 {
public static void main(String[] args) {
//1.整型
byte n1 = 21;
short n2 = 124;
int n3 = 12345; //默认
//直接写的一串数字默认是int类型，需要在后面加上l/L,表示long类型
long n4 = 43645765756857L;
//2.浮点型
//直接写的一串小数字面量默认是double类型，需要在后面加上f/F,表示double类型
float score1 = 90.55F;
double score2 = 56.34;
//3.字符型
char ch1 = 'a';
char ch2 = '孙';
//4.布尔型
boolean flag1 = true;
boolean flag2 = false;
//5.字符串
String name = "孙克旭";
}
}
4.4 自动类型转换
数据类型范围小的变量可以直接赋值给数据类型范围大的变量；
如byte类型的变量可以直接赋值给int类型的变量
package com.itheima.typeConversion;
/**
* @ClassName TypeConversionDemo1
* @Description 自动类型转换
* @Author 孙克旭
* @Date 2025/2/23 19:55
*/
public class TypeConversionDemo1 {
public static void main(String[] args) {
byte b = 78;
int i = b; //自动类型转换
System.out.println(i);
long l = i; //自动类型转换
System.out.println(l);
float f = b; //自动类型转换
System.out.println(f);
char c = 'A';
double d = c; //自动类型转换
System.out.println(d);
//隐式类型转换；当前数值没有超过int范围，不用加L，编译器会自动将int类型转换成long
long a = 1242535435;
System.out.println(a);
}
}
4.5 表达式的自动类型转换
表达式中，小范围的变量类型会自动转变成最大的变量类型
byte、short、char->int->long ->float->double(long类型到float类型的转换是隐式转换)
- 表达式的最终结果类型是由最高数据类型决定的
- byte、short、char是直接转换成int类型参与运算的
package com.itheima.typeConversion;
/**
* @ClassName TypeConversionDemo1
* @Description 表达式的自动类型转换
* @Author 孙克旭
* @Date 2025/2/23 19:55
*/
public class TypeConversionDemo2 {
public static void main(String[] args) {
byte a = 10;
short b = 20;
int c = 30;
long d = 40;
float e = 50.5F;
float result = a + b + c + d + e;
System.out.println(result);
//short result2 = a + b; 错误
int result2 = a + b;
System.out.println(result2);
byte a2 = 100;
// byte result3 = a + a2;错误
int result3 = a + a2;
System.out.println(result3);
}
}
4.6 强制类型转换
范围大的变量赋值给范围小的变量
数据类型 变量1 = （数据类型）变量2；
package com.itheima.typeConversion;
/**
* @ClassName TypeConversionDemo1
* @Description 强制类型转换
* @Author 孙克旭
* @Date 2025/2/23 19:55
*/
public class TypeConversionDemo3 {
public static void main(String[] args) {
int a = 100;
byte b = (byte) a;
System.out.println(b);//100
int a2 = 100000;
byte b2 = (byte) a2;
System.out.println(b2);//-96,数据溢出
double d = 100.69;
byte b3 = (byte) d;
System.out.println(b3);//100,精度丢失
}
}
4.7 单元练习2
4.7.1 十进制、二进制、八进制、十六进制的书写格式是什么？任意进制到十进制的转换公式？十进制到任意进制的转换公式？
书写格式：
十进制：Java中，数值默认都是10进制，不需要加任何修饰。
二进制：数值前面以0b开头，b大小写都可以。
八进制：数值前面以0开头。
十六进制：数值前面以0x开头，x大小写都可以。
任意进制转换到十进制公式：
公式：系数 * 基数的权次幂 相加
系数：每一【位】上的数
基数：几进制，就是几
权：从数值的右侧，以0开始，逐个+1增加
十进制转换到任意进制公式：
公式：除基取余
使用源数据，不断的除以基数（几进制，基数就是几）得到余数，直到商为0，再将余数倒着拼起来即可。
4.7.2 请回答Java中各数据类型占用的内存空间和取值范围
4.7.3 如下代码是否可以编译通过，请说明原因：
public class Test {
public static void main(String[] args) {
byte b = 100 + 30;
}
}
编译不通过
原因：
因为100和30，是两个常量，Java中存在【常量优化机制】
常量优化机制：在编译时(javac)，就会将100和30计算出一个130的结果，并且会自动判断该结果是否在byte取值范围内
在：编译通过
不在：编译失败
4.7.4 编码题1
定义一个类，并在main方法中完成如下任务：
① 分别定义int、long、double、boolean类型变量且初始化，并在控制台分别输出变量值
② 将double类型变量赋值给int类型变量，并在控制台输出int类型变量值
③ 将int类型变量赋值给double类型的变量，并在控制台输出double类型变量
package com.itheima.typeConversion;
/**
* @ClassName Demo1
* @Description 编码题1
* @Author 孙克旭
* @Date 2025/2/23 21:48
*/
public class Demo1 {
public static void main(String[] args) {
int a = 100;
long b = 2000;
double c = 20.5;
boolean d = true;
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
a = (int) c;
System.out.println(a);
c = a;
System.out.println(c);
}
}
4.7.5 编码题2
定义一个类，并在main方法中完成如下任务：
① 定义两个int类型变量并分别初始化值为65和97，分别将变量强制转换为char类型并输出到控制台
② 改变变量值，分别让变量值 加 10，再次分别将变量强制转换为char类型并输出到控制台
③ 定义char类型变量，初始化值为 110 ，在控制台输出char类型变量值
package com.itheima.typeConversion;
/**
* @ClassName Demo2
* @Description 编码题2
* @Author 孙克旭
* @Date 2025/2/23 21:53
*/
public class Demo2 {
public static void main(String[] args) {
int a = 65, b = 97;
char a2 = (char) a, b2 = (char) b;
System.out.println(a2);
System.out.println(b2);
a = a + 10;
b = b + 10;
a2 = (char) a;
b2 = (char) b;
System.out.println(a2);
System.out.println(b2);
char c = 100;
System.out.println(c);
}
}
4.7.6 编码题3
数字分解游戏，要求如下：
① 定义char类型变量，初始化值为 ‘z’ ，定义int型变量初始化值为char类型的变量，在控制台输出整型变量的值。
② 分别定义二进制的变量1110，八进制变量107，十六进制变量5b3，分别输出这几个变量的十进制结果
package com.itheima.typeConversion;
/**
* @ClassName Demo3
* @Description 编码题3
* @Author 孙克旭
* @Date 2025/2/23 21:58
*/
public class Demo3 {
public static void main(String[] args) {
char ch = 'z';
int i = ch;
System.out.println(i);
int a = 0B1110;
int b = 0107;
int c = 0X5b3;
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
}
5. 运算符
5.1 基本算术运算符
package com.itheima.operator;
/**
* @ClassName OperatorDemo1
* @Description 运算符
* @Author 孙克旭
* @Date 2025/2/25 10:05
*/
public class OperatorDemo1 {
public static void main(String[] args) {
int a = 10, b = 4;
System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(a / b); //2
//得到小数：1.0必须放在前面相乘
System.out.println(1.0 * a / b);//2.5 正确
System.out.println(a / b * 1.0);//2.0 错误
//取余
System.out.println(a % b);//10 / 4 =2 ……2
}
}
"+"可以做连接符，用于拼接字符串
int c = 10;
System.out.println(c);//10
System.out.println(c + 2);//12
//字符底层是数字，所以可以与数字运算
System.out.println(c + 'a');//107
System.out.println(c + '?');//73
System.out.println(c + '孙');//23395
//数字与字符串是拼接
System.out.println(c + "a");//10a
System.out.println(c + "孙" + "克旭");//10孙克旭
5.2 自增自减运算符
| 运算符 | 功能 |
|---|---|
| ++ | 变量值加1 |
| – | 变量值减1 |
package com.itheima.operator;
/**
* @ClassName OperatorDemo1
* @Description 自增自减运算符
* @Author 孙克旭
* @Date 2025/2/25 10:05
*/
public class OperatorDemo2 {
public static void main(String[] args) {
//单独使用自增自减运算符
int a = 10;
a++;
System.out.println(a);//11
++a;
System.out.println(a);//12
a--;
System.out.println(a);//11
--a;
System.out.println(a);//10
}
}
在表达式中使用自增自减运算符时，结果与运算符的位置有关。
//在表达式中使用运算符
int b = 10;
int rs = b++;//先赋值，再运算
System.out.println(rs);//10
System.out.println(b);//11
rs = ++b;//先运算，再赋值
System.out.println(rs);//12
System.out.println(b);//12
rs = b--;//先赋值，再运算
System.out.println(rs);//12
System.out.println(b);//11
rs = --b;//先运算，再赋值
System.out.println(rs);//10
System.out.println(b);//10
5.3 扩展赋值运算符
package com.itheima.operator;
/**
* @ClassName OperatorDemo1
* @Description 扩展赋值运算符
* @Author 孙克旭
* @Date 2025/2/25 10:05
*/
public class OperatorDemo3 {
public static void main(String[] args) {
int a = 10, b = 2;
a += b;//a=(int)(a+b)
System.out.println(a);//12
a -= b;//a=(int)(a-b)
System.out.println(a);//10
a *= b;//a=(int)(a*b)
System.out.println(a);//20
a /= b;//a=(int)(a/b)
System.out.println(a);//10
a %= b;//a=(int)(a%b)
System.out.println(a);//0
}
}
面试题：
byte c = 10, d = 20;
// c = c + d;报错：c+d会转换成int类型计算，赋值给byte类型需要强制转换
c = (byte) (c + d);//等价于 c+=d
// c+=d;
System.out.println(c);//30
5.4 关系运算符
=表示赋值，==表示判断是否相等
package com.itheima.operator;
/**
* @ClassName OperatorDemo1
* @Description 关系运算符
* @Author 孙克旭
* @Date 2025/2/25 10:05
*/
public class OperatorDemo4 {
public static void main(String[] args) {
int a = 10, b = 2;
System.out.println(a > b);//true
System.out.println(a >= b);//true
System.out.println(a < b);//false
System.out.println(a <= b);//false
System.out.println(a == b);//false
System.out.println(a != b);//true
System.out.println(a == 10);//true
System.out.println(b == 2);//true
}
}
5.5 逻辑运算符
&&和||效率更高，在开发中使用更多
| 符号 | 叫法 | 运算逻辑 |
|---|---|---|
| & | 逻辑与 | 所有条件都为true，结果才为true |
| Ι | 逻辑或 | 所有条件都为false，结果才为false |
| ! | 逻辑非 | 取反：!truefalse,!falsetrue |
| ^ | 逻辑异或 | 前后条件结果不同，才为true |
| && | 短路与（双与） | 结果与’&'相同；左边为false，右边则不执行 |
| ΙΙ | 短路或（双或） | 结果与’Ι’相同；左边为true，右边则不执行 |
package com.itheima.operator;
/**
* @ClassName OperatorDemo1
* @Description 逻辑运算符
* @Author 孙克旭
* @Date 2025/2/25 10:05
*/
public class OperatorDemo5 {
public static void main(String[] args) {
int size = 5, cpu = 8;
//需求一：尺寸大于4.5，cpu核数大于6
System.out.println(size > 4.5 & cpu > 6);//true
//需求二：要么尺寸大于4.5，要么cpu核数大于6
System.out.println(size > 4.5 | cpu > 6);//true
// 需求三：cpu不是8核
System.out.println(!(cpu == 8));//false
//异或：^
System.out.println(size > 5 ^ cpu < 9);//true
System.out.println(size == 5 ^ cpu == 8);//false
System.out.println("---------------------------------------------");
int m = 10, n = 20;
System.out.println(m < 10 && ++n > 10);//false
System.out.println(n);//20,右边没有执行
System.out.println(m <= 10 || ++n > 10);//true
System.out.println(n);//20,右边没有执行
}
}
5.6 三元运算符
条件表达式 ？值1 ： 值2；
先计算条件表达式的值，如果值为true，返回值1，否则返回值2。
package com.itheima.operator;
/**
* @ClassName OperatorDemo6
* @Description 三元运算符
* @Author 孙克旭
* @Date 2025/2/25 10:05
*/
public class OperatorDemo6 {
public static void main(String[] args) {
//1.计算学科成绩是否及格
double Chinese = 75.5;
double English = 56;
System.out.println(Chinese > 60 ? "语文及格" : "语文不及格");
System.out.println(English > 60 ? "英语及格" : "英语不及格");
//2.计算两者最大值
int a = 50, b = 20;
System.out.println(a > b ? a : b);
//3.计算三个数中最大值
int c = 30;
int temp = a > b ? a : b;
System.out.println(temp > c ? temp : c);
}
}
5.7 运算符优先级
注意：&&的优先级比||高
5.8 扫描器API
5.8.1 jdk手册
API是应用程序接口，是jdk自带的；可以从官方（[Oracle 甲骨文中国 | 云应用和云平台](https://www.oracle.com/cn/)）下载API文档：
解压并打开：
双击html文件，打开后搜索API
也有中文版jdk手册：[Overview (Java SE 11 & JDK 11 )](https://www.runoob.com/manual/jdk11api/index.html)
5.8.2 使用Scanner-键盘录入
package com.itheima.scanner;
import java.util.Scanner;
/**
* @ClassName ScannerDemo1
* @Description 扫描器
* @Author 孙克旭
* @Date 2025/2/25 18:37
*/
public class ScannerDemo1 {
public static void main(String[] args) {
//1.导包：导入Scanner包。IDEA会自动导入
//2.创建扫描器(Scanner)对象
Scanner scanner = new Scanner(System.in);
//3.使用扫描器的功能
System.out.println("请输入您的年龄：");
int age = scanner.nextInt();//程序会等待用户输入整型数字，直到用户按下回车键
System.out.println("您的年龄是：" + age);
System.out.println("请输入您的名字：");
String name = scanner.next();//程序会等待用户输入字符串，直到用户按下回车键
System.out.println("欢迎" + name + "进入系统~~~");
}
}
5.9 课后练习
5.9.1 编码题1
请根据下列描述，选用合适的数据类型定义变量，并输出变量的值。
1、班级里有100个学员。
2、某商品价格55.55元。
3、地球已经诞生超过46亿年。
4、“5是偶数”这句话的描述是假的。
输出结果如下：
100
55.55
4600000000
false
package com.itheima.scanner;
/**
* @ClassName Demo1
* @Description 编码题
* @Author 孙克旭
* @Date 2025/2/25 21:40
*/
public class Demo1 {
public static void main(String[] args) {
// 1、班级里有100个学员。
int studentNum = 100;
System.out.println(studentNum);
// 2、某商品价格55.55元。
double price = 55.55;
System.out.println(price);
// 3、地球已经诞生超过46亿年。
long years = 4600000000L;
System.out.println(years);
// 4、“5是偶数”这句话的描述是假的。
boolean word = false;
System.out.println(word);
}
}
5.9.2 编码题2
某小伙想定一份外卖，商家的优惠方式如下：鱼香肉丝单点24元，油炸花生米单点8元，米饭单点3元。订单满30元8折优惠。鱼香肉丝优惠价16元，但是优惠价和折扣不能同时使用。那么这个小伙要点这三样东西，最少要花多少钱？请编写程序计算。
【思路分析】：
有两种购买方式，一种是不使用优惠价，另一种是使用优惠价。分别计算花费后，对两种方式的花费作对比。
【参考方案】：
使用算术运算符、赋值运算符和三元运算符联合完成本题
【参考步骤】：
- 使用算术运算符求出不使用优惠时的总价
- 使用三元运算符判断总价是否满足打折条件，并求出折后总价
- 使用算术运算符求出使用优惠价时的总价
- 使用三元运算符判断最终更合算的购买方式和花费
package com.itheima.scanner;
/**
* @ClassName Demo2
* @Description 编码题
* @Author 孙克旭
* @Date 2025/2/25 21:47
*/
public class Demo2 {
public static void main(String[] args) {
int fish = 24, peanut = 8, rice = 3;
int sum = fish + peanut + rice;
//方案一：折扣
double price1 = sum >= 30 ? 1.0 * sum * 0.8 : sum;
//方案二：优惠价
int price2 = sum - fish + 16;
//比较最小值
System.out.println(price1 > price2 ? price2 : price1);
}
}
5.9.3 编码题3
在java中，算术运算符加号“+”，也可以作为字符串的连接符。它可以将多个字符串连接在一起，组成一个新的字符串，也可以将其他数据类型与字符串连接在一起，组成一个新的字符串。请阅读如下解释：
我们输出HelloWorld时，输出语句为：
System.out.println(“HelloWorld”);
其实，这个输出语句就是输出了一个字符串，这个字符串也可以由两个或者多个字符串组成。例如：
System.out.println(“Hello” + “World”);
这里，两个字符串会先拼接为一个，再输出，结果与上面一致。再比如：
int age = 20;
System.out.println(“我的年龄是” + age);
上面输出语句中，将int类型的变量与字符串连接在一起，组成一个新的字符串，程序的输出结果是：
我的年龄是20
而且，还可以多个数据与字符串连接，例如：
int height = 180;
System.out.println(“我的年龄是” + age + “，我的身高是” + height);
这个语句中，两个字符串与两个变量会拼成一个字符串输出，输出结果为：
我的年龄是20，我的身高是180
根据以上描述，请编写程序，定义两个整数（int类型）变量，并求这两个整数的和，将结果输出到屏幕上。输出格式如下：
10 + 20 = 30
package com.itheima.scanner;
/**
* @ClassName Demo3
* @Description 编码题
* @Author 孙克旭
* @Date 2025/2/25 21:56
*/
public class Demo3 {
public static void main(String[] args) {
int a = 10, b = 20;
System.out.println(a + "+" + b + "=" + (a + b));
}
}
5.10 单元练习3
5.10.1 描述下算数运算符中 , / 和 % 的特点
/ 的特点：
Java当中整数相除, 结果只能得到整数, 想要带有小数的结果, 需要有小数参与运算
% 的特点:
取模, 得到的是除法之后剩下的余数
5.10.2 现有代码如下, 请回答打印的结果, 并描述中间的运算过程 (务必说明原因)
int a = 10;
double b = 12.3;
a += b;
System.out.println(a);
打印的结果:
22
原因:
a += b, 就是 10 + 12.3 结果为22.3
+= : 将累加的结果给符号左边赋值
22.3需要给符号左边的a变量赋值, 注意+=自带强转效果, a又是int类型, 所以22.3给int类型的a赋值, 有一个强转
类似于: int a = (int)22.3;
小数强转为整数, 砍掉小数点后面的内容, 因此结果是22
5.10.3 编码题
定义一个类，并在main方法中完成如下任务：
① 定义两个int类型变量，分别输出两个变量加、减、乘、除 的结果，并输出到控制台。
② 将步骤①中 两变量相加 将运算结果在控制台输出，格式为：“两数之和是:xx”。
③ 将步骤①中 变量1进行前++输出到控制台上、变量2进行后++输出到控制台上。
④ 判断步骤①的两个变量和是否大于10作为条件1、积是否大于20作为条件2，如果两个条件都满足，则在控制台上输出true，如果两个条件任意一个不满足，则在控制台上输出false。
⑤ 使用int类型变量接收3.14，解释输出结果为整数的原因。
⑥ 键盘录入两个整数，比较这两个数的大小如果哪个数大就在控制台上输出哪个数字。
package com.itheima.scanner;
import java.util.Scanner;
/**
* @ClassName Demo4
* @Description 编码题
* @Author 孙克旭
* @Date 2025/2/25 22:03
*/
public class Demo4 {
public static void main(String[] args) {
// 定义一个类，并在main方法中完成如下任务：
//① 定义两个int类型变量，分别输出两个变量加、减、乘、除 的结果，并输出到控制台。
int a = 10, b = 20;
System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(1.0 * a / b);
//② 将步骤①中 两变量相加 将运算结果在控制台输出，格式为："两数之和是:xx"。
System.out.println("两数之和是：" + (a + b));
//③ 将步骤①中 变量1进行前++输出到控制台上、变量2进行后++输出到控制台上。
System.out.println(++a);//11
System.out.println(b++);//20
//④ 判断步骤①的两个变量和是否大于10作为条件1、积是否大于20作为条件2，
// 如果两个条件都满足，则在控制台上输出true，如果两个条件任意一个不满足，则在控制台上输出false。
System.out.println((a + b) > 10 && (a * b) > 20);//true
//⑤ 使用int类型变量接收3.14，解释输出结果为整数的原因。
int c = (int) 3.14;//3.14为浮点数
System.out.println(c);
//⑥ 键盘录入两个整数，比较这两个数的大小如果哪个数大就在控制台上输出哪个数字。
Scanner scanner = new Scanner(System.in);
int i = scanner.nextInt();
int n = scanner.nextInt();
System.out.println(i > n ? i : n);
}
}
5.10.4 技术面试题
请阅读下面代码（先不要直接运行代码），给出程序输出结果
public class demo {
public static void main(String[] args) {
int a = 1;
a = a++;
int b = a++;
int c = a+ ++a * a++;
System.out.println("a = " + a); // 输出的结果是？
System.out.println("b = " + b); // 输出的结果是？
System.out.println("c = " + c); // 输出的结果是？
}
}
a = 4
b = 1
c = 11
解析
单独使用：a++；或者 ++a；直接加1
和其他运算符复合使用：++在前 先加1 再使用、++在后 先使用 再加1
6. 程序流程控制
| 程序结构 | 描述 | 实现 |
|---|---|---|
| 顺序结构 | 自上而下执行代码 | 默认写的代码就是顺序结构 |
| 分支结构 | 根据条件，执行代码 | if、switch |
| 循环结构 | 重复执行某一段代码 | for、while、do-while |
6.1 分支结构
6.1.1 if
if的代码快中只有一行代码时，{}可以省略；但是不推荐
package com.itheima.branch;
/**
* @ClassName IfDemo1
* @Description if分支
* @Author 孙克旭
* @Date 2025/2/26 11:32
*/
public class IfDemo1 {
public static void main(String[] args) {
//1.发红包：余额有90元，发100元红包
int balance = 90, redEnvelope = 100;
if (balance >= redEnvelope) {
//可以发红包
System.out.println("红包发送成功");
} else {
//余额不足
System.out.println("余额不足，发送失败");
}
/* 2.学生成绩等级：
[90,100] A
[85,90) B
[60,85) C
[0,60) D*/
double score = 68.5;
if (score >= 90 && score <= 100) {
System.out.println('A');
} else if (score >= 85 && score < 90) {
System.out.println('B');
} else if (score >= 60 && score < 85) {
System.out.println('C');
} else if (score >= 0 && score < 60) {
System.out.println('D');
} else {
System.out.println("分数错误");
}
}
}
6.1.2 switch
package com.itheima.branch;
/**
* @ClassName SwitchDemo2
* @Description switch
* @Author 孙克旭
* @Date 2025/2/26 16:05
*/
public class SwitchDemo2 {
public static void main(String[] args) {
// 周一：埋头苦干，解决bug 周五：今晚吃鸡
// 周二： 请求大牛程序员帮忙 周六：与王婆介绍的小芳相亲
// 周三：今晚啤酒、龙虾、小烧烤 周日：郁郁寡欢、准备上班。
// 周四：主动帮助新来的女程序解决bug
String week = "周三";
switch (week) {
case "周一":
System.out.println("埋头苦干，解决bug");
break;
case "周二":
System.out.println("请求大牛程序员帮忙");
break;
case "周三":
System.out.println("今晚啤酒、龙虾、小烧烤");
break;
case "周四":
System.out.println("主动帮助新来的女程序解决bug");
break;
case "周五":
System.out.println("今晚吃鸡");
break;
case "周六":
System.out.println("与王婆介绍的小芳相亲");
break;
case "周日":
System.out.println("郁郁寡欢、准备上班");
break;
default:
System.out.println("您输入的星期信息不存在~~~");
}
}
}
6.1.3 if和switch的比较
- if在功能上远远大于switch
- 当前条件是区间时，应该用if分支
- 当前条件是一个一个的值比较的时候，switch分支更合适：格式良好，性能较好，代码优雅。
6.1.4 switch的注意事项
- switch的表达式的数据类型可以是byte、short、int、char，jdk5开始支持枚举，jdk7开始支持String；不支持long、float、double
- case的值不能重复且不能是变量，只能是字面量
- switch的break一定要写，否则会有break穿透问题
6.1.5 break穿透
当一个分支没有break时，程序会向下执行
package com.itheima.branch;
/**
* @ClassName SwitchDemo2
* @Description break穿透
* @Author 孙克旭
* @Date 2025/2/26 16:05
*/
public class SwitchDemo3 {
public static void main(String[] args) {
String week = "周三";
switch (week) {
case "周一":
System.out.println("埋头苦干，解决bug");
break;
case "周二":
case "周三":
case "周四":
System.out.println("请求大牛程序员帮忙");
break;
case "周五":
System.out.println("与王婆介绍的小芳相亲");
break;
case "周六":
case "周日":
System.out.println("打游戏");
break;
default:
System.out.println("您输入的星期信息不存在~~~");
}
}
}
6.2 循环结构
6.2.1 for
for(初始化语句；条件判断语句；迭代语句){
代码块；
}
package com.itheima.loop;
/**
* @ClassName ForDemo1
* @Description for
* @Author 孙克旭
* @Date 2025/2/28 13:26
*/
public class ForDemo1 {
public static void main(String[] args) {
//输出多行hello world
for (int i = 0; i < 5; i++) {
System.out.println("Hello World");
}
for (int i = 0; i < 9; i += 2) {
//i=0 2 4 6 8
System.out.println("Hello World2");
}
}
}
6.2.1.1 for循环案例
package com.itheima.loop;
/**
* @ClassName ForDemo1
* @Description for
* @Author 孙克旭
* @Date 2025/2/28 13:26
*/
public class ForDemo2 {
public static void main(String[] args) {
//求1-100的和
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
System.out.println(sum);
//求1-100的奇数和
int sum2 = 0;
for (int i = 1; i <= 100; i += 2) {
sum2 += i;
}
System.out.println(sum2);
int sum3 = 0;
for (int i = 1; i <= 100; i++) {
if (i % 2 == 1) {//i为奇数
sum3 += i;
}
}
System.out.println(sum3);
}
}
6.2.2 单元练习4
1. 请回答switch语句, (表达式) 中可以接收的类型有哪些 ?
1). 基本数据类型:
byte short char int
2). 引用数据类型:
jdk5版本开始可以接收枚举, jdk7版本开始可以是String字符串
2. 现有如下代码 , 请说出执行流程和最终结果
public class Demo {
public static void main(String[] args){
for(int i = 1; i <= 5; i++){
System.out.println(i);
}
System.out.println(i);
}
}
结果:
代码编译出错
原因:
在for循环执行完毕后, i的变量会从内存中释放掉, 再想使用就找不到了
3. 编码题1
定义一个类，并在main方法中完成如下任务：
① 键盘录入一个学生的成绩,如果成绩大于90分(包含90分)，则在控制台上打印优秀，如果成绩在60分(包含60分)到90分之间，则在控制台上打印一般，如果成绩在0(包含0分)到60分之间，则在控制台上打印不及格。
② 键盘录入一个1~7之间的数字，输入值为1，则在控制台上打印"星期一"。输入值为2，则在控制台上打印"星期二"。以此类推。
③ 使用for循环输出1-100之内的所有偶数数字
package com.itheima.loop;
import java.util.Scanner;
/**
* @ClassName ForDemo1
* @Description 编码题
* @Author 孙克旭
* @Date 2025/2/28 13:26
*/
public class ForDemo3 {
public static void main(String[] args) {
// 定义一个类，并在main方法中完成如下任务：
//① 键盘录入一个学生的成绩,如果成绩大于90分(包含90分)，则在控制台上打印优秀，如果成绩在60分(包含60分)到90分之间，
// 则在控制台上打印一般，如果成绩在0(包含0分)到60分之间，则在控制台上打印不及格。
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个成绩：");
double score = scanner.nextDouble();
if (score >= 90) {
System.out.println("优秀");
} else if (score >= 60) {
System.out.println("一般");
} else if (score >= 0) {
System.out.println("不及格");
} else {
System.out.println("分数错误");
}
//② 键盘录入一个1~7之间的数字，输入值为1，则在控制台上打印"星期一"。输入值为2，则在控制台上打印"星期二"。以此类推。
System.out.println("请输入1-7之间的数字：");
int num = scanner.nextInt();
switch (num) {
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;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("输入错误");
}
//③ 使用for循环输出1-100之内的所有偶数数字
for (int i = 0; i <= 100; i += 2) {
System.out.println(i);
}
}
}
4. 编码题2
NBA扣篮大赛上一共有4位选手参赛，他们的成绩分别是 2 、4 、6 、8，统计出分数低于5分的球员一共有几位？
package com.itheima.loop;
import java.util.Scanner;
/**
* @ClassName ForDemo1
* @Description 编码题
* @Author 孙克旭
* @Date 2025/2/28 13:26
*/
public class ForDemo4 {
public static void main(String[] args) {
// NBA扣篮大赛上一共有4位选手参赛，他们的成绩分别是 2 、4 、6 、8，统计出分数低于5分的球员一共有几位？
int count = 0;
Scanner scanner = new Scanner(System.in);
for (int i = 0; i < 4; i++) {
System.out.println("请输入第" + (i + 1) + "位球员的成绩：");
int score = scanner.nextInt();
if (score < 5) {
count++;
}
}
System.out.println(count);
}
}
6.2.3 while
初始化语句；
while(条件判断语句){
循环体语句；迭代语句；
}
package com.itheima.loop;
/**
* @ClassName WhileDemo1
* @Description while
* @Author 孙克旭
* @Date 2025/2/28 14:38
*/
public class WhileDemo1 {
public static void main(String[] args) {
int i = 0;
while (i < 5) {
System.out.println("Hello World");
i++;
}
}
}
6.2.3.1 for和while的区别？
- for和while在功能上是一样的
- 明确知道用几次循环，用for
- 不知道需要几次循环，用while
6.2.3.2 while循环案例
世界最高山峰珠穆朗玛峰高度是:8848.86米=8848860毫米，假如我有一张足够大
的纸，它的厚度是0.1毫米。请问:该纸张折叠多少次，可以折成珠穆朗玛峰的高度?
package com.itheima.loop;
/**
* @ClassName WhileDemo1
* @Description while案例
* @Author 孙克旭
* @Date 2025/2/28 14:38
*/
public class WhileDemo2 {
public static void main(String[] args) {
// 世界最高山峰珠穆朗玛峰高度是:8848.86米=8848860毫米，假如我有一张足够大
// 的纸，它的厚度是0.1毫米。请问:该纸张折叠多少次，可以折成珠穆朗玛峰的高度?
int count = 0;
double paper = 0.1, peak = 8848860;
while (paper < peak) {
count++;
paper *= 2;
}
System.out.println(count);//27
}
}
6.2.4 do-while
初始化语句；
do{
循环体语句；
迭代语句；
}while(条件判断语句)；
package com.itheima.loop;
/**
* @ClassName DoWhileDemo1
* @Description do while
* @Author 孙克旭
* @Date 2025/3/1 10:29
*/
public class DoWhileDemo1 {
public static void main(String[] args) {
int i = 0;
do {
System.out.println("Hello World");
i++;
} while (i < 5);
do {
System.out.println("Hello World2");
} while (false);
}
}
- do-while是先循环，再判断
- 应用场景：抢票。用户执行抢票软件后，程序直接抢票，再判断用户是否有票，再循环执行。
6.2.5 死循环
一直执行下去的循环，如果没有干预不会停下来。
package com.itheima.loop;
/**
* @ClassName EndLessLoopDemo1
* @Description 死循环
* @Author 孙克旭
* @Date 2025/3/2 13:25
*/
public class EndLessLoopDemo1 {
public static void main(String[] args) {
/* for (; ; ) {
System.out.println("hello world");
}*/
//经典写法
/* while (true) {
System.out.println("hello world");
}*/
do {
System.out.println("hello world");
} while (true);
}
}
6.2.6 循环嵌套
package com.itheima.loop;
/**
* @ClassName LoopNestDemo1
* @Description 循环嵌套
* @Author 孙克旭
* @Date 2025/3/2 13:38
*/
public class LoopNestDemo1 {
public static void main(String[] args) {
//假如你有老婆，你犯了错误后，老婆惩罚你3天，每天说5句：我爱你
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 5; j++) {
System.out.println("第" + i + "天，第" + j + "句：我爱你");
}
System.out.println("--------------------------");
}
/*打印：4行，5列
🌟🌟🌟🌟🌟
🌟🌟🌟🌟🌟
🌟🌟🌟🌟🌟
🌟🌟🌟🌟🌟*/
for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= 5; j++) {
System.out.print("🌟"); //不换行
}
System.out.println(); //换行
}
}
}
6.2.7 跳转关键字
break：跳出并结束当前循环（只能跳出一层循环）；
continue：跳出当次循环，并进入下一次循环；
package com.itheima.loop;
/**
* @ClassName BreakAndContinueDemo1
* @Description 跳转关键字
* @Author 孙克旭
* @Date 2025/3/2 14:05
*/
public class BreakAndContinueDemo1 {
public static void main(String[] args) {
/* 假如你有老婆，你犯错误后，老婆惩罚你说5遍我爱你，
当你说到第3遍时，心软了，不用再说了。*/
for (int i = 1; i <= 5; i++) {
System.out.println("我爱你");
if (i == 3) {
break;
}
}
/* 假如你有老婆，你犯错误后，老婆惩罚你说洗碗5天，
当你洗到第3天时，老婆看你表现良好，心软了，不用洗了，但是明天还要继续。*/
for (int i = 1; i <= 5; i++) {
if (i == 3) {
continue;
}
System.out.println(i+"洗碗");
}
}
}
6.3 生成随机数：Random
package com.itheima.random;
import java.util.Random;
/**
* @ClassName RandomDemo1
* @Description 生成随机数
* @Author 孙克旭
* @Date 2025/3/2 14:29
*/
public class RandomDemo1 {
public static void main(String[] args) {
//1.导包(程序自动导包)
//2.创建Random对象
Random random = new Random();
//3.使用Random功能，生成0-9之间的随机数
for (int i = 0; i < 10; i++) {
int n = random.nextInt(10); //[0,10)
System.out.println(n);
}
}
}
6.3.1 生成指定区间的随机数
package com.itheima.random;
import java.util.Random;
/**
* @ClassName RandomDemo1
* @Description 生成指定区间的随机数
* @Author 孙克旭
* @Date 2025/3/2 14:29
*/
public class RandomDemo2 {
public static void main(String[] args) {
//1.导包(程序自动导包)
//2.创建Random对象
Random random = new Random();
//3.使用Random功能，生成7-28之间的随机数
//3.1 将左侧数字变为0：0-21
//3.2 生成的随机数加上相差的数值：7
int i = random.nextInt(22) + 7;
System.out.println(i);
}
}
6.3.2 案例：猜数字
随机生成一个1-108之间的数据，提示用户猜测，猜大提示过大，猜小提示过小，直到猜中结束游戏。
package com.itheima.random;
import java.util.Random;
import java.util.Scanner;
/**
* @ClassName RandomDemo3
* @Description 猜数字游戏
* @Author 孙克旭
* @Date 2025/3/2 14:49
*/
public class RandomDemo3 {
public static void main(String[] args) {
// 随机生成一个1-100之间的数据，提示用户猜测，猜大提示过大，猜小提示过小，直到猜中结束游戏
Scanner scanner = new Scanner(System.in);
Random random = new Random();
int n = random.nextInt(100) + 1;
while (true) {
System.out.println("请输入您猜测的数字：");
int i = scanner.nextInt();
if (i > n) {
System.out.println("猜大了");
} else if (i < n) {
System.out.println("猜小了");
} else {
System.out.println("猜对了");
break;
}
}
}
}
6.4 单元练习5
1. 现有如下代码 , 请说出执行流程和最终结果
public class Demo {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 5; i++) {
sum += i;
System.out.print(sum + " ");
}
}
}
最终结果：
1 3 6 10 15
执行流程:
定义求和变量
执行for循环, 满足循环条件的话, 则进入循环开始累加
在循环内部打印了每一次累加的过程
2. 现有如下代码 , 打印所有的水仙花数, 但是代码存在错误, 请说明错误原因, 并更正代码
提示：水仙花数就是 个位的立方 + 十位的立方 + 百位的立方 = 它本身 例如：153 = 111 + 555 + 333
public class Demo {
public static void main(String[] args) {
int i = 100;
while(i <= 999){
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 10 / 10 % 10;
if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i){
System.out.println(i);
}
}
}
}
错误原因：
while循环中, 忘记了 i++ 所以操作的数据, 一直都是100
更正代码如下：
public class Demo {
public static void main(String[] args) {
int i = 100;
while(i <= 999){
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 10 / 10 % 10;
if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i){
System.out.println(i);
}
i++;
}
}
}
3. 观察以下的代码 , 下划线位置加入什么语句,可以在控制台打印
控制台输出 7次： “ I Love Java ”
控制台输出 2次： “ I Love Java ”
控制台输出 13次： “ I Love Java ”
public class Demo {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i % 3 == 0) {
//___________
}
System.out.println("I Love Java");
}
}
}
加入语句如下：
7次: continue
2次: break
13次: System.out.println("I Love Java");
4. 编码题1
定义一个类，并在main方法中完成如下任务：
① 编写一个while死循环在控制台输出 1-30 之间的数字（提示：循环变量值为30时，使用break终止循环）
② 改进程序，在循环执行过程中遇到偶数则生成一个（10-100）随机数，只输出随机数，不再输出原本应该输出的数字
package com.itheima.random;
import java.util.Random;
/**
* @ClassName Demo1
* @Description 编码题1
* @Author 孙克旭
* @Date 2025/3/2 15:10
*/
public class Demo1 {
public static void main(String[] args) {
int count = 1;
Random r = new Random();
while (true) {
//判断是否是偶数
if (count % 2 == 0) {
System.out.println("----->" + (r.nextInt(91) + 10));
} else {
System.out.println(count);
}
//循环累计变量+1
count++;
//判断循环次数
if (count == 30) {
break;
}
}
}
}
5. 编码题2
设计一个程序，随机生成一组双色球（总共7个数字，一组双色球由6个红球+1个篮球组成，其中红球为1-33之间的数字，且不能重复【本题允许重复出现红球】，篮球为1-16之间的数字），要求如下：
随机生成一组双色球，每个红球数字用“-”（中划线）分割连成字符串显示，蓝球最后一个显示，且和红球之间用空格分隔。如：“23-12-3-8-14-17 8”
package com.itheima.random;
import java.util.Random;
/**
* @ClassName Demo2
* @Description 编码题2
* @Author 孙克旭
* @Date 2025/3/2 15:10
*/
public class Demo2 {
public static void main(String[] args) {
/* 设计一个程序，随机生成一组双色球（总共7个数字，一组双色球由6个红球+1个篮球组成，其中红球为1-33之间的数字，
且不能重复【本题允许重复出现红球】，篮球为1-16之间的数字），要求如下：
随机生成一组双色球，每个红球数字用“-”（中划线）分割连成字符串显示，蓝球最后一个显示，
且和红球之间用空格分隔。如：“23-12-3-8-14-17 8”*/
Random random = new Random();
String unionLotto = ""; //双色球
for (int i = 1; i <= 6; i++) {
int red = random.nextInt(33) + 1;
if (i == 6) {
unionLotto += red;
} else {
unionLotto += red + "-";
}
}
int blue = random.nextInt(16) + 1;
unionLotto += " " + blue;
System.out.println(unionLotto);
}
}
6.5 章节测评-分支和循环
1. 简述下 ++ 运算符在参与运算使用的时候, 在前在后的区别
单独使用
++, -- 在前在后没有区别的
例如：
int a = 10;
++a;
a++;
参与运算使用
++在前 : 先自增, 再操作
++在后 : 先操作, 再自增。将该变量原本记录的值, 提取出来做操作, 然后再完成自增
2. 如果switch语句省略了break, 会出现什么现象? 请简单描述下这个现象？
现象：
case穿透现象
描述：
当执行完某一个case中的语句体后, 如果没有遇到break, 将会开启case穿透，这种穿透指的是, 会进行到下一个case中, 继续执行语句体，直到遇见了break, 或者执行到了switch的末尾, 才会停止
3. 简述下注释的作用, 以及注释的分类和格式？
在程序的指定位置添加的说明性信息, 简单来说就是对代码的一种解释说明, 代码中加入注释后, 可以提高程序的阅读性
分类:
单行注释: // 注释信息
多行注释: /* 注释信息 */
文档注释: /** 注释信息 */
4. 编码题1
小明搬家想添置一套家用电器，某电商平台优惠如下：
① 拼单价: 电压力锅1199(满1199减650)，空气炸锅399(满399减50)，烧水壶199(满199减30）。
② 总价打6折（拼单价和折扣不能同时使用）。
那么小明要买这三样东西，最少要花多少钱？
package com.itheima.test;
/**
* @ClassName Demo1
* @Description 章节测试
* @Author 孙克旭
* @Date 2025/3/2 15:37
*/
public class Demo1 {
public static void main(String[] args) {
int count1 = 1199 - 650 + 399 - 50 + 199 - 30;
double count2 = (1199 + 399 + 199) * 0.6;
System.out.println((count1 > count2) ? count2 : count1);
}
}
5. 编码题2
有五双鞋子，鞋码分别是41、42、43、44、45，小明的脚穿42和43的鞋子都合适，请用程序判断出不符合小明脚码数的鞋子有几双。
package com.itheima.test;
/**
* @ClassName Demo1
* @Description 章节测试
* @Author 孙克旭
* @Date 2025/3/2 15:37
*/
public class Demo2 {
public static void main(String[] args) {
//有五双鞋子，鞋码分别是41、42、43、44、45，小明的脚穿42和43的鞋子都合适，请用程序判断出不符合小明脚码数的鞋子有几双。
//① 定义一个计数器初始化为0
int count = 0;
//② 定义五双鞋子，鞋码数分别是41~45
for (int i = 41; i < 46; i++) {
//③ 如果鞋子的码数不是42、43，则计数器加1
if (i != 42 && i != 43) {
count++;
}
}
//④ 输出不符合小明脚的鞋子一共有几双
System.out.println(count);
}
}
6. 编码题3
设计一个程序，帮助小学生练习10以内的加法，要求如下：
① 每次随机生成1道加法算式题目，显示在控制台上，学生在控制台查看题目并输入答案，当输入的答案正确时提示“回答正确”，否则提示“回答错误”
② 统计学生答对次数，答对5题时，提示“练习的很棒,程序结束！” 程序结束。
package com.itheima.test;
import java.util.Random;
import java.util.Scanner;
/**
* @ClassName Demo1
* @Description 章节测试
* @Author 孙克旭
* @Date 2025/3/2 15:37
*/
public class Demo3 {
public static void main(String[] args) {
/* 设计一个程序，帮助小学生练习10以内的加法，要求如下：
① 每次随机生成1道加法算式题目，显示在控制台上，学生在控制台查看题目并输入答案，当输入的答案正确时提示“回答正确”，
否则提示“回答错误”
② 统计学生答对次数，答对5题时，提示“练习的很棒,程序结束！” 程序结束。*/
Scanner scanner = new Scanner(System.in);
Random random = new Random();
int count = 0; //答对的数量
while (true) {
if (count == 5) {
System.out.println("练习的很棒,程序结束！");
break;
}
int i = random.nextInt(11);
int j = random.nextInt(11);
int realAnswer = i + j;
System.out.println(i + "+" + j + "=");
System.out.println("请输入您的答案：");
int answer = scanner.nextInt();
if (answer == realAnswer) {
System.out.println("回答正确！");
count++;
} else {
System.out.println("回答错误！答案是" + realAnswer);
}
}
}
}
7. 数组
数组本质上是一个容器，用来存储同种类型的数据。
数组名称中存储的是数值在内存中的地址，数组可以看作是一种引用数据类型
7.1 静态初始化数组
在定义数组时为数组赋值。
package com.itheima.define;
/**
* @ClassName ArrayDemo1
* @Description 静态初始化数组
* @Author 孙克旭
* @Date 2025/3/2 18:36
*/
public class ArrayDemo1 {
public static void main(String[] args) {
//数据类型[] 数组名称=new 数据类型[]{元素1,元素2,元素3……}
int[] ages = new int[]{10, 20, 22, 50, 60};
//简化写法：
//据类型[] 数组名称={元素1,元素2,元素3……}
int[] ages2 = {10, 20, 22, 50, 60};
System.out.println(ages2);//[I@14ae5a5
}
}
[I@14ae5a5：
- [：表示这个是一个数组的地址
- I：表示数组的元素是int类型
- @：分隔符，后面是16进制的地址
数组的底层原理：
7.2 数组的访问
package com.itheima.define;
/**
* @ClassName ArrayDemo1
* @Description 数组的访问
* @Author 孙克旭
* @Date 2025/3/2 18:36
*/
public class ArrayDemo2 {
public static void main(String[] args) {
int[] ages = {10, 20, 22, 50, 60};
//1.获取数组的长度(元素个数)
System.out.println(ages.length);
//2.获取数组的最大索引 数组长度-1
System.out.println(ages.length - 1);
//3.获取数组每个元素的值
System.out.println(ages[0]);
System.out.println(ages[1]);
System.out.println(ages[2]);
System.out.println(ages[3]);
System.out.println(ages[4]);
//4.为第3个元素赋值 下标为2的元素
ages[2] = 100;
System.out.println(ages[2]); //100
}
}
- 数组的下标（索引）是从0开始的
7.3 数组的遍历
package com.itheima.define;
/**
* @ClassName ArrayDemo1
* @Description 数组的遍历
* @Author 孙克旭
* @Date 2025/3/2 18:36
*/
public class ArrayDemo3 {
public static void main(String[] args) {
int[] ages = {10, 20, 22, 50, 60};
for (int i = 0; i < ages.length; i++) {
System.out.println(ages[i]);
}
}
}
7.4 案例1
某部门5名员工的销售额分别是:16、26、36、6、100，请计算出他们部门的总销售额。
package com.itheima.define;
/**
* @ClassName ArrayDemo4
* @Description 案例
* @Author 孙克旭
* @Date 2025/3/3 17:19
*/
public class ArrayDemo4 {
public static void main(String[] args) {
// 某部门5名员工的销售额分别是:16、26、36、6、100，请计算出他们部门的总销售额。
int[] money = {16, 26, 36, 6, 100};
int sum = 0;
for (int i = 0; i < money.length; i++) {
sum += money[i];
}
System.out.println(sum);
}
}
7.5 动态初始化数组
定义数组时，先不为数组赋值，而是确定数组的数据类型和数组长度。
格式：数据类型[] 数组名称=new 数据类型[数组长度]
底层原理：
- 程序在内存开辟3个连续的长度为int类型的空间
- 每个空间的值为0
- 将首个元素的地址赋值给数组名
package com.itheima.define;
/**
* @ClassName ArrayDemo4
* @Description 动态初始化数组
* @Author 孙克旭
* @Date 2025/3/3 17:19
*/
public class ArrayDemo5 {
public static void main(String[] args) {
int[] ages = new int[3];
System.out.println(ages[0]); //0
System.out.println(ages[1]); //0
System.out.println(ages[2]); //0
ages[0] = 10;
ages[1] = 20;
ages[2] = 30;
for (int i = 0; i < ages.length; i++) {
System.out.println(ages[i]);
}
}
}
动态初始化数组后元素的默认值：
- byte、short、int、long、char的默认是0
- float、double的默认值是0.0
- boolean类型的默认值是flase
- String类型的默认值是null
两者数组定义方式的适用场景：
- 动态初始化数组：适合不明确元素值，但知道数组长度
- 静态初始化数组：适合明确元素值的情况
7.6 案例2
某歌唱比赛，需要开发一个系统:可以录入6名评委的打分，录入完毕后立即输出平均分做为选手得分。
package com.itheima.define;
import java.util.Scanner;
/**
* @ClassName ArrayDemo4
* @Description 案例
* @Author 孙克旭
* @Date 2025/3/3 17:19
*/
public class ArrayDemo6 {
public static void main(String[] args) {
//某歌唱比赛，需要开发一个系统:可以录入6名评委的打分，录入完毕后立即输出平均分做为选手得分。
Scanner scanner = new Scanner(System.in);
//1.定义长度为6的数组，用于记录评委的分数
double[] scores = new double[6];
//2.记录分数
for (int i = 0; i < scores.length; i++) {
System.out.println("请输入第" + (i + 1) + "位评委的打分：");
scores[i] = scanner.nextDouble(); //将分数赋值到数组中
}
//3.遍历数组，计算平均分
double sum = 0; //保存总分
for (int i = 0; i < scores.length; i++) {
sum += scores[i];
}
System.out.println(sum / scores.length);
}
}
7.7 单元练习6
1. 请回答数组元素访问是什么意思 , 以及访问格式是什么 ?
数组元素访问 :
访问到数组中存储的元素进行使用.
格式:
数组名[索引];
索引 (角标, 下标) :
数组中, 每一个空间所对应的编号, 编号从0开始逐个 + 1增长
2. 聊聊你对数组遍历的理解, 什么时候需要对数组做遍历, 以及如何书写遍历代码 ?
数组遍历 :
将数组中每一个元素取出来的过程
需求：
如果要实现的需求, 是对数组中的每一个元素进行操作, 就可以对数组进行遍历
遍历代码:
for(int i = 0; i < 数组名.length; i++){
// 操作
}
快捷键: 数组名.fori + 回车
数组名.length : 动态获取到数组的长度(元素的个数)
3. 编码题1
定义一个类，在main方法中完成如下任务：
① 使用静态初始化的方式创建一个数组，将10，20，30，40，50存入这个数组中；
② 将数组中的第三个元素打印到控制台上；
③ 使用动态初始化的方式再创建一个数组，将60，70，80，90，100存入这个数组中；
④ 遍历该数组并将结果打印到控制台上。
package com.itheima.define;
import java.util.Scanner;
/**
* @ClassName ArrayDemo4
* @Description 编码题
* @Author 孙克旭
* @Date 2025/3/3 17:19
*/
public class ArrayDemo7 {
public static void main(String[] args) {
// 定义一个类，在main方法中完成如下任务：
//① 使用静态初始化的方式创建一个数组，将10，20，30，40，50存入这个数组中；
int[] arr1 = {10, 20, 30, 40, 50};
//② 将数组中的第三个元素打印到控制台上；
System.out.println(arr1[2]);
//③ 使用动态初始化的方式再创建一个数组，将60，70，80，90，100存入这个数组中；
int[] arr2 = new int[5];
arr2[0] = 60;
arr2[1] = 70;
arr2[2] = 80;
arr2[3] = 90;
arr2[4] = 100;
//④ 遍历该数组并将结果打印到控制台上。
for (int i = 0; i < arr2.length; i++) {
System.out.println(arr2[i]);
}
}
}
4. 编码题2
有一名老师在统计学生成绩，目前需要在系统中录入5名学生的成绩，他们的成绩分别是；100，99，95，90，85分，成绩录入后，系统会自动展示学生的平均成绩。请使用代码完成该系统的功能。
package com.itheima.define;
import java.util.Scanner;
/**
* @ClassName ArrayDemo4
* @Description 编码题
* @Author 孙克旭
* @Date 2025/3/3 17:19
*/
public class ArrayDemo8 {
public static void main(String[] args) {
// 有一名老师在统计学生成绩，目前需要在系统中录入5名学生的成绩，他们的成绩分别是；100，99，95，90，85分，
// 成绩录入后，系统会自动展示学生的平均成绩。请使用代码完成该系统的功能。
int[] scores = new int[5];
Scanner scanner = new Scanner(System.in);
for (int i = 0; i < scores.length; i++) {
System.out.println("请录入学生的分数：");
scores[i] = scanner.nextInt();
}
int sum = 0;
for (int i = 0; i < scores.length; i++) {
sum += scores[i];
}
System.out.println(sum / scores.length); //93
}
}
7.8 数组的应用
7.8.1 java内存分配
7.8.2 多个变量指向同一个数组
package com.itheima.define;
/**
* @ClassName ArrayDemo1
* @Description 多个变量指向同一个数组
* @Author 孙克旭
*/
public class ArrayDemo9 {
public static void main(String[] args) {
int[] arr1 = new int[]{10, 20, 22, 50, 60};
int[] arr2 = arr1;
System.out.println(arr1); //[I@14ae5a5
System.out.println(arr2); //[I@14ae5a5
arr2[0] = 100;
System.out.println(arr1[0]); //100
arr2 = null;
System.out.println(arr2); //null
System.out.println(arr2[0]); //报错：空指针异常 Exception in thread "main" java.lang.NullPointerException
}
}
- arr1和arr2都指向同一个地址，即同一个数组，当从arr2修改元素时，arr1的元素也会被修改。
7.8.3 数组案例：求最值
package com.itheima.test;
/**
* @ClassName Demo1
* @Description 求最值
* @Author 孙克旭
* @Date 2025/3/4 16:48
*/
public class Demo1 {
public static void main(String[] args) {
//求数组的最大值
int[] arr = {10, -5, 30, 16, 6, 20};
int max = arr[0]; //存储最大值，先以第一个元素作为参照
for (int i = 1; i < arr.length; i++) { //从第二个元素开始便利
if (arr[i] > max) { //如果当前值比max的值大，就将max替换
max = arr[i];
}
}
System.out.println(max);
}
}
7.8.4 数组案例：数组反转
package com.itheima.test;
/**
* @ClassName Demo1
* @Description 数值反转
* @Author 孙克旭
* @Date 2025/3/4 16:48
*/
public class Demo2 {
public static void main(String[] args) {
int[] arr = {10, -5, 30, 16, 6, 20};
// i j
//i记录左边的值，j记录右边的值；将i与j的值相互调换即可；循环条件是i必须在j的左边
for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//打印反转后的值
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
//20 6 16 30 -5 10
}
}
7.8.5 数组案例：随机排名
每遍历到一个数组的元素时，随机生成一个数组索引值，将该元素值与索引处的值交换，达到随机排名的效果。
package com.itheima.test;
import java.util.Random;
import java.util.Scanner;
/**
* @ClassName Demo1
* @Description 随机排名
* @Author 孙克旭
* @Date 2025/3/4 16:48
*/
public class Demo3 {
public static void main(String[] args) {
//需求：将5位学生的名字随机排序
Scanner scanner = new Scanner(System.in);
Random random = new Random();
String[] names = new String[5];
//录入学生名字
for (int i = 0; i < names.length; i++) {
System.out.println("请输入第" + (i + 1) + "位学生的名字：");
names[i] = scanner.next();
}
//将名字随机排序:将当前元素与随机位置的元素交换
for (int i = 0; i < names.length; i++) {
int index = random.nextInt(names.length); //随机一个数组下标
String temp = names[i];
names[i] = names[index];
names[index] = temp;
}
//查看随机后的名字
for (int i = 0; i < names.length; i++) {
System.out.print(names[i] + " ");
}
}
}
7.9 Debug工具
IDEA自带的断点调试工具，可以控制代码从断点开始一行一行的执行，然后详细观看程序执行的情况。
7.9.1 Step Over和 Step Into的区别？
- 点击
Step Over按钮时，调试器会执行当前行的代码， 但不会进入任何方法调用 。也就是说，如果当前行调用了某个方法，调试器会直接跳过该方法，继续执行下一行代码。这个方法适用于不想深入查看某个方法内部逻辑的场景。 - 当点击
Step Into按钮时，调试器会进入当前行调用的方法内部， 并暂停在该方法的第一行代码 。这个方法适用于想要深入查看某个方法内部执行逻辑的场景。
7.10 单元测试
7.11 课后练习
1. 练习一
现有一个小数数组{12.9,53.54,75.0,99.1,3.14}。请编写代码，找出数组中的最小值并打印。
训练提示
- 数组的元素是小数，需要定义小数类型数组。
- 找最小值和找最大值的思路是一样的。
解题方案
使用求最大值的思路完成
操作步骤
- 定义小数类型数组并存入元素。
- 定义小数变量min代表最小值。
- 遍历数组，用每个元素依次和变量min对比。
- 如果元素小于min,则把元素赋值给min。
- 遍历结束之后打印最小值。
package com.itheima.test;
/**
* @ClassName Demo4
* @Description 练习
* @Author 孙克旭
* @Date 2025/3/4 19:51
*/
public class Demo4 {
public static void main(String[] args) {
// 现有一个小数数组{12.9,53.54,75.0,99.1,3.14}。请编写代码，找出数组中的最小值并打印。
double[] nums = {12.9, 53.54, 75.0, 99.1, 3.14};
double min = nums[0];
for (int i = 1; i < nums.length; i++) {
if (nums[i] < min) {
min = nums[i];
}
}
System.out.println(min);
}
}
2. 练习二
小李用自己的钱买了十只股票，年末他看了各只股票的收益分别是10.4%,-3%,-6.2%,1.2%,-6.1%,-19%,-3.8%,0.9%,-4.5%,5.5%。请使用数组相关知识编程，帮他统计赚钱的股票和赔钱的股票分别有多少只？打印效果如下：
赚钱的股票一共有：4只
赔钱的股票一共有：6只
训练提示
- 有多只股票，可以使用数组来存储。
- 股票收益为小数，所以数组类型应该是小数。
- 需要定义两个变量来分别存储统计的个数。
解题方案
- 使用数组的遍历，判断每个股票是正值还是负值，分别统计。
操作步骤
- 定义小数数组存储十只股票的收益值。
- 定义变量count1用于存储赚钱股票的个数，初始值是0。
- 定义变量count2用于存储赔钱股票的个数，初始值是0。
- 遍历数组判断，如果收益大于0则count1加一，如果收益小于0则count2加一。
- 遍历结束后打印两个变量值。
package com.itheima.test;
/**
* @ClassName Demo4
* @Description 练习
* @Author 孙克旭
* @Date 2025/3/4 19:51
*/
public class Demo5 {
public static void main(String[] args) {
/* 小李用自己的钱买了十只股票，年末他看了各只股票的收益分别是
10.4,-3,-6.2,1.2,-6.1,-19,-3.8,0.9,-4.5,5.5。
请使用数组相关知识编程，帮他统计赚钱的股票和赔钱的股票分别有多少只？*/
double[] stocks = {10.4, -3, -6.2, 1.2, -6.1, -19, -3.8, 0.9, -4.5, 5.5};
int makeMoneyCount = 0, loseMoneyCount = 0;
for (int i = 0; i < stocks.length; i++) {
if (stocks[i] > 0) {
makeMoneyCount++;
} else if (stocks[i] < 0) {
loseMoneyCount++;
}
}
System.out.println("赚钱的股票:" + makeMoneyCount + "只");
System.out.println("赔钱的股票:" + loseMoneyCount + "只");
}
}
7.12 单元练习7
1. Java 中的内存分配常用的主要分为3块, 分别是哪些 ? 这些内存维护了什么样的数据 ?
栈内存：
方法运行时，进入的内存，局部变量都存放于这块内存当中
堆内存：
new出来的内容都会进入堆内存，并且会存在地址值
方法区：
字节码文件(.class文件)加载时进入的内存
2. 现有如下代码, 请分析代码是否存在问题, 如果有, 请说明问题所在并改正, 没有的话, 分析代码执行流程, 说出最终打印结果
public class Demo {
public static void main(String[] args){
int[] arr1 = {11,22,33,44,55};
System.out.println(arr1[0]);
int[] arr2 = arr1;
arr2 = null;
System.out.println(arr1[arr1.length]);
}
}
执行流程：
// 静态初始化数组, 没有问题
int[] arr1 = {11,22,33,44,55};
// 取出数组中0号索引位置元素 11 并打印, 没有问题
System.out.println(arr1[0]);
// 将arr1的地址值, 复制了一份给arr2, 两个数组指向同一个地址了, 没有问题
int[] arr2 = arr1;
// arr2赋值为null, 代表跟堆内存的连接被切断, 但是不影响arr1, 没有问题
arr2 = null;
// 索引越界异常,数组的最大索引是长度-1
System.out.println(arr1[arr1.length-1]);
3. 数组动态初始化中, 不同类型数组, 默认初始化值都不一样, 分别是什么 ?
默认初始值：
整数 : 0
小数 : 0.0
布尔 : false
字符 : '\u0000' --> Unicode字符 --> 空白字符
引用数据类型 : null
引用数据类型 :
数组, 类, 接口
4. 编码题1
定义一个类，并在main方法中完成如下任务：
① 定义两个数组变量arr1、arr2指向同一个长度为10的整型数组，使用键盘分别录入10个数字，使用数组arr1保存键盘输入的数字到数组中，遍历数组找出数组的最大值并输出到控制台显示。
② 使用数组变量 arr2修改数组的第一个元素为 100，遍历输出arr2数组保存的数据到控制台显示。
package com.itheima.test;
import java.util.Scanner;
/**
* @ClassName Demo4
* @Description 编码题
* @Author 孙克旭
* @Date 2025/3/4 19:51
*/
public class Demo6 {
public static void main(String[] args) {
//① 定义两个数组变量arr1、arr2指向同一个长度为10的整型数组，使用键盘分别录入10个数字，使用数组arr1保存键盘输入的数字到数组中，
// 遍历数组找出数组的最大值并输出到控制台显示。
int[] arr1 = new int[10];
int[] arr2 = arr1;
Scanner scanner = new Scanner(System.in);
for (int i = 0; i < arr1.length; i++) {
arr1[i] = scanner.nextInt();
}
int max = arr1[0];
for (int i = 0; i < arr1.length; i++) {
if (arr1[i] > max) {
max = arr1[i];
}
}
System.out.println(max);
//② 使用数组变量 arr2修改数组的第一个元素为 100，遍历输出arr2数组保存的数据到控制台显示
arr2[0] = 100;
for (int i = 0; i < arr2.length; i++) {
System.out.print(arr2[i] + " ");
}
}
}
5. 编码题2
定义一个类，并在main方法中实现数组拷贝功能：
定义两个长度为5的数组，其中arr1元素为：{10,34,56,12,100}、arr2为空数组，将arr1数组中的内容拷贝到arr2中，并在控制台分别输出arr1、arr2数组的内容
package com.itheima.test;
/**
* @ClassName Demo4
* @Description 编码题
* @Author 孙克旭
* @Date 2025/3/4 19:51
*/
public class Demo7 {
public static void main(String[] args) {
//定义两个长度为5的数组，其中arr1元素为：{10,34,56,12,100}、arr2为空数组，将arr1数组中的内容拷贝到arr2中，
// 并在控制台分别输出arr1、arr2数组的内容
int[] arr1 = {10, 34, 56, 12, 100};
int[] arr2 = new int[5];
for (int i = 0; i < arr1.length; i++) {
arr2[i] = arr1[i];
}
for (int i = 0; i < arr2.length; i++) {
System.out.print(arr2[i] + " ");
}
}
}
6. 编码题3
设计一个程序，实现在跳水比赛中评委打分，有5名评委为1名运动员打分，运动员得分方式为去掉一个最高分，去掉一个最低分，然后剩下的3个分数求平均值，即为选手得分。请在键盘录入5名评委打的分数（0分到10分），将选手得分输出到控制台
package com.itheima.test;
import java.util.Scanner;
/**
* @ClassName Demo4
* @Description 编码题
* @Author 孙克旭
* @Date 2025/3/4 19:51
*/
public class Demo8 {
public static void main(String[] args) {
/* 设计一个程序，实现在跳水比赛中评委打分，有5名评委为1名运动员打分，
运动员得分方式为去掉一个最高分，去掉一个最低分，然后剩下的3个分数求平均值，即为选手得分。
请在键盘录入5名评委打的分数（0分到10分），将选手得分输出到控制台*/
Scanner scanner = new Scanner(System.in);
double[] scores = new double[5];
double max = 0, min = 0, sum = 0;
for (int i = 0; i < 5; i++) {
System.out.println("请输入第" + (i + 1) + "位评委的打分：");
scores[i] = scanner.nextDouble();
}
for (int i = 0; i < scores.length; i++) {
sum += scores[i];
if (scores[i] > max) {
max = scores[i];
} else if (scores[i] < min) {
min = scores[i];
}
}
System.out.println("平局分：" + (sum - max - max) / (scores.length - 2));
}
}
8. 方法
方法是一种语法结构，将一段代码封装起来作为一个功能，便于重复调用。
格式：
修饰符 返回值类型 方法名（形参列表）{
方法体代码；return 返回值；
}
方法的优点：
- 使代码逻辑更清晰
- 提高代码的复用型，提高了开发效率
package com.itheima.define;
/**
* @ClassName MethodDemo1
* @Description 方法的定义
* @Author 孙克旭
* @Date 2025/3/6 8:59
*/
public class MethodDemo1 {
public static void main(String[] args) {
//需求：两数求和
System.out.println(sum(1, 2));
System.out.println(sum(10, 20));
}
/**
* 求和方法
*
* @param a
* @param b
* @return
*/
public static int sum(int a, int b) {
return a + b;
}
}
8.1 方法的其他形式
开发中，应该根据实际的业务需求，设计合理的方法来解决问题。
package com.itheima.define;
/**
* @ClassName MethodDemo1
* @Description 方法的其他形式
* @Author 孙克旭
* @Date 2025/3/6 8:59
*/
public class MethodDemo2 {
public static void main(String[] args) {
//打印三行Hello World
printHelloWorld();
System.out.println("------------------------------");
//打印n行Hello World
printHelloWorld2(5);
}
/**
* 无参无返回值方法
*/
public static void printHelloWorld() {
for (int i = 0; i < 3; i++) {
System.out.println("Hello World");
}
}
/**
* 有参无返回值方法
*
* @param n
*/
public static void printHelloWorld2(int n) {
for (int i = 0; i < n; i++) {
System.out.println("Hello World");
}
}
}
- 方法必须定义在类下，不能定义在其他方法（main方法）中
8.2 案例
8.2.1 求1-n的和
package com.itheima.define;
/**
* @ClassName MethodDemo1
* @Description 案例
* @Author 孙克旭
* @Date 2025/3/6 8:59
*/
public class MethodDemo3 {
public static void main(String[] args) {
//需求：求1-n的和
/*分析：1.方法的返回值类型？
1-n都是整数相加，可以是int类型
2.方法的形参列表？
方法应该接受n的值，所以形参只有一个，类型是int*/
System.out.println(add(100)); //5050
}
/**
* 求1-n的和
*
* @param n
* @return
*/
public static int add(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i;
}
return sum;
}
}
8.2.2 判断一个数是偶数还是奇数
package com.itheima.define;
/**
* @ClassName MethodDemo1
* @Description 案例
* @Author 孙克旭
* @Date 2025/3/6 8:59
*/
public class MethodDemo4 {
public static void main(String[] args) {
//需求：判断一个数是偶数还是奇数
/* 1.方法的返回值类型？
可以是String类型
2.方法的形参列表？
方法只接受一个数值，所以是int类型*/
System.out.println(judge(97)); //奇数
System.out.println(judge(50)); //偶数
}
/**
* 判断n是偶数还是奇数
*
* @param n
* @return
*/
public static String judge(int n) {
if (n % 2 == 0) {
return "偶数";
} else {
return "奇数";
}
}
}
8.3 方法的底层原理
- 方法是在栈内存中运行的（栈是一种先进后出的数据结构）
方法在计算机中的执行原理
视频解释：方法在计算机中的执行原理.mp4 链接: https://pan.baidu.com/s/1lDxW2Us8z_EtTe6XR1XTwA?pwd=dvs4 提取码: dvs4
8.4 单元练习8
1. 聊聊你对方法的理解, 以及方法可以为代码带来怎样的好处 ?
方法的理解：
方法是一段具有独立功能的代码块, 不调用就不执行
带来的好处：
1. 提高了代码的可阅读性
- 可以将原本挤在一起的臃肿代码, 按照功能进行分类管理.
2. 提高了代码的复用性
- 只需要编写好一个方法, 就可以对方法进行多次调用了
2. 方法是否可以提高程序的执行效率 ?
不可以, 提高效率是代码逻辑能够少执行一些, 而方法只不过是将代码逻辑的存放换了个地方而已.
3. 编码题1
① 定义一个方法，这个方法的作用是在控制台上打印1~100的数字。
② 定义一个方法，在这个方法参数里面传递一个随机数字，这个随机数的取值范围是1~100，随机数生成的是几，程序就计算1到几的数字之和。
package com.itheima.define;
import java.util.Random;
/**
* @ClassName Test1
* @Description 编码题1
* @Author 孙克旭
* @Date 2025/3/6 17:18
*/
public class Test1 {
public static void main(String[] args) {
// ① 定义一个方法，这个方法的作用是在控制台上打印1~100的数字。
printNums();
//② 定义一个方法，在这个方法参数里面传递一个随机数字，这个随机数的取值范围是1~100，随机数生成的是几，程序就计算1到几的数字之和。
Random random = new Random();
int i = random.nextInt(100) + 1;
System.out.println(sum(i));
}
/**
* 输出1-100
*/
public static void printNums() {
for (int i = 1; i <= 100; i++) {
System.out.println(i);
}
}
/**
* 计算1-n的和
*
* @param n
* @return
*/
public static int sum(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i;
}
return sum;
}
}
4. 编码题2
某地电费收费标准如下
① 第一档电量为240度及以下（包含240度）的电量：0.4元/度;
② 第二档电量为241-400度（包含400度）之间的电量：0.5元/度;
③ 第三档电量为超过400度的电量：0.7元/度;
请设计一个方法用来根据用电量计算并返回应付电费
package com.itheima.define;
/**
* @ClassName Test1
* @Description 编码题2
* @Author 孙克旭
* @Date 2025/3/6 17:18
*/
public class Test2 {
public static void main(String[] args) {
/* 某地电费收费标准如下
① 第一档电量为240度及以下（包含240度）的电量：0.4元/度;
② 第二档电量为241-400度（包含400度）之间的电量：0.5元/度;
③ 第三档电量为超过400度的电量：0.7元/度;
请设计一个方法用来根据用电量计算并返回应付电费*/
System.out.println(electricityBill(50));
System.out.println(electricityBill(500));
}
/**
* 计算电费
*
* @param electricityQuantity
* @return
*/
public static double electricityBill(int electricityQuantity) {
double bill = 0;
if (electricityQuantity <= 240) {
bill = 0.4 * electricityQuantity;
} else if (electricityQuantity <= 400) {
bill = 0.4 * 240 + 0.5 * (electricityQuantity - 240);
} else {
bill = 0.4 * 240 + 0.5 * (400 - 240) + 0.7 * (electricityQuantity - 400);
}
return bill;
}
}
8.5 方法参数都是值传递
8.5.1 基本类型的参数传递
基本类型的参数传递是数据值
package com.itheima.parameter;
/**
* @ClassName Demo1
* @Description 基本类型的参数传递
* @Author 孙克旭
* @Date 2025/3/6 17:53
*/
public class Demo1 {
public static void main(String[] args) {
int a = 10;
change(a);
System.out.println(a);
/* 输出：
10
11
10*/
}
public static void change(int a) {
System.out.println(a);
a++;
System.out.println(a);
}
}
- 方法传递的具体的值，不会修改原来变量的值
8.5.2 引用类型的参数传递
引用类型的参数传递是地址值
package com.itheima.parameter;
/**
* @ClassName Demo2
* @Description 引用类型的参数传递
* @Author 孙克旭
* @Date 2025/3/6 17:53
*/
public class Demo2 {
public static void main(String[] args) {
int[] arr = {10, 20};
change(arr);
System.out.println(arr[0]);
/* 输出：
10
11
11*/
}
public static void change(int[] arr) {
System.out.println(arr[0]);
arr[0]++;
System.out.println(arr[0]);
}
}
8.5.3 案例一
输出一个int类型的数组内容，要求输出格式为：[11, 22, 33,44, 55]。
package com.itheima.parameter;
/**
* @ClassName Demo3
* @Description 案例
* @Author 孙克旭
* @Date 2025/3/6 19:13
*/
public class Demo3 {
public static void main(String[] args) {
// 输出一个int类型的数组内容，要求输出格式为：[11, 22, 33,44, 55]。
int[] arr = {10, 20, 30, 40, 50};
printArray(arr); //[10,20,30,40,50]
int[] arr2 = {};
printArray(arr2); //[]
int[] arr3 = null;
printArray(arr3); //null
}
/**
* 打印数组
*
* @param arr
*/
public static void printArray(int[] arr) {
if (arr == null) {
System.out.println(arr);
return; //跳出方法
}
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
/* if (i == arr.length - 1) {
System.out.println(arr[i]);
} else {
System.out.print(arr[i] + ",");
}*/
System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ",");
}
System.out.println("]");
}
}
8.5.4 案例二
判断两个int类型的数组是否一样。
package com.itheima.parameter;
/**
* @ClassName Demo4
* @Description 案例
* @Author 孙克旭
* @Date 2025/3/6 19:13
*/
public class Demo4 {
public static void main(String[] args) {
// 需求：判断两个int类型的数组是否一样
int[] arr1 = null;
int[] arr2 = null;
int[] arr3 = {10, 20, 30};
int[] arr4 = {10, 20, 30, 40};
int[] arr5 = {10, 20, 30, 40};
System.out.println(equals(arr1, arr2)); //true
System.out.println(equals(arr1, arr3)); //false
System.out.println(equals(arr3, arr4)); //false
System.out.println(equals(arr4, arr5)); //true
}
public static boolean equals(int[] arr1, int[] arr2) {
//1.判断是否都为null
if (arr1 == null && arr2 == null) {
return true;
}
//2.判断其中是否有一个为null
if (arr1 == null || arr2 == null) {
return false;
}
//3.判断数组长度是否相同
if (arr1.length != arr2.length) {
return false;
}
//4.判断数组元素是否相同
for (int i = 0; i < arr1.length; i++) {
if (arr1[i] != arr2[i]) {
return false;
}
}
return true;
}
}
8.6 方法重载
在一个类中，有多个方法名相同，但形参列表不同的方法，它们称为方法重载。
开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
package com.itheima.overLoad;
/**
* @ClassName MethodOverLoadDemo1
* @Description 方法重载的应用
* @Author 孙克旭
* @Date 2025/3/6 20:09
*/
public class MethodOverLoadDemo1 {
public static void main(String[] args) {
//开发一套武器系统
fire();
fire("太平洋");
fire("太平洋", 10);
}
public static void fire() {
fire("岛国");
}
public static void fire(String country) {
fire(country, 1);
}
public static void fire(String country, int num) {
System.out.println("发射了" + num + "枚导弹给" + country);
}
}
8.7 单元测试
8.8 单元练习9
1. 正确的方法重载, 需要满足哪些条件呢 ?
方法重载：
在同一个类中, 方法名相同, 参数不同, 与返回值无关
条件：
参数不同: 个数不同, 类型不同, 顺序不同.
2. 请回答带返回值方法有几种调用格式, 分别是哪几种, 还有不带返回值方法的调用格式？
带返回值:
- 单独调用(不推荐)
getMax(10,20);
- 赋值调用(推荐)
int max = getMax(10,20);
好处: 拿到了真实的数据, 可以干很多后续的操作
System.out.println(max);
if(max % 2 == 0){
}
for(int i = 1; i <= max; i++){
}
- 输出调用(偶尔用)
System.out.println(getMax(10,20));
不带返回值:
- 只能单独调用!
3. 基本类型的参数传递和引用类型的参数传递的区别是什么？（拓展题）
Java中有两种类型的参数传递机制，分别是基本类型的参数传递和引用类型的参数传递。
1、基本类型的参数传递：在方法调用时，实参的值被复制给形参。在方法内部，形参是实参的一个副本。因此，如果在方法内部修改形参的值，不会影响到实参的值。
2、引用类型的参数传递：在方法调用时，实参的引用被复制给形参。在方法内部，形参和实参指向同一个对象。因此，如果在方法内部修改形参所指向的对象的状态，实参也会受到影响。
4. 编码题1
定义一个类，并在类中完成如下任务：
① 定义一个有参有返回值的方法，返回数组元素的最大值，在main方法中调用该方法并在控制台输出最大值
② 定义一个有参有返回值的方法，实现随机数组功能（数组元素随机打乱），返回打乱后的随机数组，
③ 定义一个有参无返回值的方法，实现数组各元素在控制台输出打印功能，格式:“[1,2,3]”
④ 在main方法中将任务①定义的数组，作为参数调用任务②返回的随机数组 使用任务③ 的数组打印方法，将随机后的数组打印输出在控制台上
⑤ 定义两个名为sum的方法，方法1参数为两个int类型，该方法返回两个int类型变量相加的和，方法2为一个int类型，一个double类型，该方法返回两个参数的乘积，在main中分别调用两个方法sum(1,2)、sum(1,2.0) 并输出调用结果到控制台上。
package com.itheima.overLoad;
import java.util.Random;
/**
* @ClassName Test1
* @Description 编码题
* @Author 孙克旭
* @Date 2025/3/7 13:54
*/
public class Test1 {
public static void main(String[] args) {
//① 定义一个有参有返回值的方法，返回数组元素的最大值，在main方法中调用该方法并在控制台输出最大值
int[] arr = {10, 20, 12, 43, 33, 56, 65, 46, 10};
System.out.println(getMaxInArray(arr));
//② 定义一个有参有返回值的方法，实现随机数组功能（数组元素随机打乱），返回打乱后的随机数组，
int[] ints = randomArray(arr);
for (int i = 0; i < ints.length; i++) {
System.out.print(ints[i] + " ");
}
System.out.println();
//③ 定义一个有参无返回值的方法，实现数组各元素在控制台输出打印功能，格式:"[1,2,3]"
printArray(arr);
//④ 在main方法中将任务①定义的数组，作为参数调用任务②返回的随机数组 使用任务③ 的数组打印方法，将随机后的数组打印输出在控制台上
//⑤ 定义两个名为sum的方法，方法1参数为两个int类型，该方法返回两个int类型变量相加的和，方法2为一个int类型，一个double类型，
// 该方法返回两个参数的乘积，在main中分别调用两个方法sum(1,2)、sum(1,2.0) 并输出调用结果到控制台上。
System.out.println(sum(1, 2));
System.out.println(sum(1, 2.0));
}
/**
* 获取数组的最大值
*
* @param array
* @return
*/
public static Integer getMaxInArray(int[] array) {
if (array == null || array.length == 0) {
return null;
}
int max = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] > max) {
max = array[i];
}
}
return max;
}
/**
* 将数组元素打乱
*
* @param array
* @return
*/
public static int[] randomArray(int[] array) {
if (array == null || array.length == 0) {
return array;
}
Random random = new Random();
for (int i = 0; i < array.length; i++) {
int index = random.nextInt(array.length);
int temp = array[i];
array[i] = array[index];
array[index] = temp;
}
return array;
}
/**
* 打印数组
*
* @param array
*/
public static void printArray(int[] array) {
if (array == null) {
System.out.println(array);
}
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if (i == array.length - 1) {
System.out.print(array[i]);
} else {
System.out.print(array[i] + ",");
}
}
System.out.println("]");
}
public static int sum(int a, int b) {
return a + b;
}
public static double sum(int a, double b) {
return a * b;
}
}
5. 编码题2
定义一个类，并在类中完成如下任务：
① 定义一个求2个数最大公约数的方法，返回值为最大公约数。在main方法中从键盘接收两个整数，调用该方法并输出最大公约数到控制台上显示。
② 改进任务① 中方法的代码，如果接收的任何一个数字为0，方法返回0，并提示：“输入的数字不能为0”
package com.itheima.overLoad;
import java.util.Random;
/**
* @ClassName Test2
* @Description 编码题
* @Author 孙克旭
* @Date 2025/3/7 13:54
*/
public class Test2 {
public static void main(String[] args) {
//① 定义一个求2个数最大公约数的方法，返回值为最大公约数。在main方法中从键盘接收两个整数，调用该方法并输出最大公约数到控制台上显示。
//② 改进任务① 中方法的代码，如果接收的任何一个数字为0，方法返回0，并提示：“输入的数字不能为0”
System.out.println(greatestCommonFactor(98, 63)); //7
}
/**
* 求最大公约数
* 1.用较大的数除以较小的数，得到余数。
* 2.将较小的数与余数进行比较，继续用较大的数除以较小的数，直到余数为0。
* 3.最后一个非零余数就是最大公约数。
*
* @param a
* @param b
* @return
*/
public static int greatestCommonFactor(int a, int b) {
if (a == 0 || b == 0) {
System.out.println("输入的数字不能为0");
return 0;
}
int greater = getGreaterNum(a, b);
int smaller = getSmallerNum(a, b);
int r = greater % smaller;
if (r == 0) {
return smaller;
} else {
return greatestCommonFactor(smaller, r);
}
}
/**
* 获取两个数中更小值
*
* @param a
* @param b
* @return
*/
private static int getSmallerNum(int a, int b) {
return a < b ? a : b;
}
/**
* 获取两个数中的最大值
*
* @param a
* @param b
* @return
*/
private static int getGreaterNum(int a, int b) {
return a > b ? a : b;
}
}
6. 编码题3
定义一个类，并在类中实现个人所得税各种计算、查询功能，要求如下：
① 定义一个方法查询个人所得税税率，方法接收一个参数个人税前薪资，返回税率（小数）。
② 定义一个方法查询个人所得税速算扣除金额，方法接收一个参数个人税前薪资，返回速算扣除金额。
③ 定义一个方法计算个人所得税税额，方法接收一个参数返回个人所得税税额（个人所得税计算公式：个人所得税税额 = 税前薪资 * 适用税率 - 速算扣除数）
税率表：
1.年度不超过36000元的税率为： 3% 速算扣除数：0、
2.超过36000-144000元的部分税率为： 10% 速算扣除数：2520
3.超过144000-300000元的部分税率为：20% 速算扣除数：16920
4.超过300000-420000元的部分税率为：25% 速算扣除数：31920
5.超过420000-660000元的部分税率为：30% 速算扣除数：52920
6.超过660000-960000元的部分税率为：35% 速算扣除数：85920
7.超过960000元的税率为： 45% 速算扣除数：181920
package com.itheima.overLoad;
/**
* @ClassName Test3
* @Description 编码题
* @Author 孙克旭
* @Date 2025/3/7 13:54
*/
public class Test3 {
public static void main(String[] args) {
/*① 定义一个方法查询个人所得税税率，方法接收一个参数个人税前薪资，返回税率（小数）。
② 定义一个方法查询个人所得税速算扣除金额，方法接收一个参数个人税前薪资，返回速算扣除金额。
③ 定义一个方法计算个人所得税税额，方法接收一个参数返回个人所得税税额
（个人所得税计算公式：个人所得税税额 = 税前薪资 * 适用税率 - 速算扣除数）
税率表：
1.年度不超过36000元的税率为： 3% 速算扣除数：0、
2.超过36000-144000元的部分税率为： 10% 速算扣除数：2520
3.超过144000-300000元的部分税率为：20% 速算扣除数：16920
4.超过300000-420000元的部分税率为：25% 速算扣除数：31920
5.超过420000-660000元的部分税率为：30% 速算扣除数：52920
6.超过660000-960000元的部分税率为：35% 速算扣除数：85920
7.超过960000元的税率为： 45% 速算扣除数：181920*/
double salary = 20000;
System.out.println(getTaxRate(salary));
System.out.println(getDeductionAmount(salary));
System.out.println(getTaxAmount(salary));
}
/**
* 查询个人所得税税率
*
* @param salary
* @return
*/
public static double getTaxRate(double salary) {
if (salary <= 36000) {
return 0.03;
} else if (salary <= 144000) {
return 0.1;
} else if (salary <= 300000) {
return 0.2;
} else if (salary <= 420000) {
return 0.25;
} else if (salary <= 660000) {
return 0.3;
} else if (salary <= 960000) {
return 0.35;
} else {
return 0.45;
}
}
/**
* 查询个人所得税速算扣除金额
*
* @param salary
* @return
*/
public static int getDeductionAmount(double salary) {
if (salary <= 36000) {
return 0;
} else if (salary <= 144000) {
return 2520;
} else if (salary <= 300000) {
return 16920;
} else if (salary <= 420000) {
return 31920;
} else if (salary <= 660000) {
return 52920;
} else if (salary <= 960000) {
return 85920;
} else {
return 181920;
}
}
/**
* 查询个人所得税税额
*
* @param salary
* @return
*/
public static double getTaxAmount(double salary) {
return salary * getTaxRate(salary) - getDeductionAmount(salary);
}
}
8.9 案例一
8.9.1 买飞机票
用户购买机票时，机票原价会按照淡季、旺季，头等舱还是经济舱的情况进行相应的优惠，优惠方案如
下：5-10月为旺季，头等舱9折，经济舱8.5折；11月到来年4月为淡季，头等舱7折，经济舱6.5折，
请开发程序计算出用户当前机票的优惠价。
package com.itheima.test;
/**
* @ClassName Demo1
* @Description 买飞机票
* @Author 孙克旭
* @Date 2025/3/7 16:00
*/
public class Demo1 {
public static void main(String[] args) {
/* 用户购买机票时，机票原价会按照淡季、旺季，头等舱还是经济舱的情况进行相应的优惠，优惠方案如
下：5-10月为旺季，头等舱9折，经济舱8.5折；11月到来年4月为淡季，头等舱7折，经济舱6.5折，
请开发程序计算出用户当前机票的优惠价。*/
System.out.println(getTicketPrices(1500, 3, "头等舱"));
}
/**
* 获取机票的优惠价
*
* @param price
* @param month
* @param cabinType
* @return
*/
public static double getTicketPrices(double price, int month, String cabinType) {
if (month >= 5 && month <= 10) {
switch (cabinType) {
case "头等舱":
price *= 0.9;
break;
case "经济舱":
price *= 0.85;
break;
default:
break;
}
} else {
switch (cabinType) {
case "头等舱":
price *= 0.7;
break;
case "经济舱":
price *= 0.65;
break;
default:
break;
}
}
return price;
}
}
8.9.2 开发验证码
开发一个程序，可以生成指定位数的验证码，每位可以是数字、大小写字母。
package com.itheima.test;
import java.util.Random;
/**
* @ClassName Demo2
* @Description 开发验证码
* @Author 孙克旭
* @Date 2025/3/7 16:00
*/
public class Demo2 {
public static void main(String[] args) {
// 开发一个程序，可以生成指定位数的验证码，每位可以是数字、大小写字母。
System.out.println(verificationCode(6));
}
public static String verificationCode(int n) {
Random random = new Random();
String code = "";
for (int i = 0; i < n; i++) {
int type = random.nextInt(3); //0:数字 1：小写字母 2：大写字母
switch (type) {
case 0:
code += random.nextInt(10);
break;
case 1:
char ch = (char) (random.nextInt(26) + 'a');
code += ch;
break;
case 2:
char ch1 = (char) (random.nextInt(26) + 'A');
code += ch1;
break;
default:
break;
}
}
return code;
}
}
8.9.3 评委打分
在唱歌比赛中，可能有多名评委要给选手打分，分数是[0-100]之间的整数。选手最后得分为：去掉
最高分、最低分后剩余分数的平均分，请编写程序能够录入多名评委的分数，并算出选手的最终得分。
package com.itheima.test;
import java.util.Scanner;
/**
* @ClassName Demo3
* @Description 评委打分
* @Author 孙克旭
* @Date 2025/3/8 16:00
*/
public class Demo3 {
public static void main(String[] args) {
/* 在唱歌比赛中，可能有多名评委要给选手打分，分数是[0-100]之间的整数。选手最后得分为：去掉
最高分、最低分后剩余分数的平均分，请编写程序能够录入多名评委的分数，并算出选手的最终得分。*/
System.out.println(getAvgScore(5));
}
/**
* 计算平均分
*
* @param judgesNumber
* @return
*/
public static double getAvgScore(int judgesNumber) {
Scanner scanner = new Scanner(System.in);
//1.创建动态数组，记录评委分数
int[] scores = new int[judgesNumber];
//2.记录评委打分
for (int i = 0; i < scores.length; i++) {
System.out.println("请输入第" + (i + 1) + "位评委的打分：");
scores[i] = scanner.nextInt();
}
//3.找出分数中的最大值、最小值，计算总分
int sum = scores[0], max = scores[0], min = scores[0];
for (int i = 1; i < scores.length; i++) {
sum += scores[i];
if (scores[i] > max) {
max = scores[i];
}
if (scores[i] < min) {
min = scores[i];
}
}
//4.计算平均分
return 1.0 * (sum - max - min) / (judgesNumber - 2);
}
}
8.9.4 数字加密
某系统的数字密码是一个四位数，如1983，为了安全，需要加密后再传输，加密规则是：对密码中的每位数
都加5，再对10求余，最后将所有数字顺序反转，得到一串加密后的新数，请设计出满足本需求的加密程序！
package com.itheima.test;
/**
* @ClassName Demo4
* @Description 数字加密
* @Author 孙克旭
* @Date 2025/3/8 20:33
*/
public class Demo4 {
public static void main(String[] args) {
/* 某系统的数字密码是一个四位数，如1983，为了安全，需要加密后再传输，加密规则是：对密码中的每位数
都加5，再对10求余，最后将所有数字顺序反转，得到一串加密后的新数，请设计出满足本需求的加密程序！*/
System.out.println(encrypt(1983)); //8346
}
/**
* 对数字加密
*
* @param number
* @return
*/
public static String encrypt(int number) {
//对数字拆解
int[] arr = split(number);
//计算过程
for (int i = 0; i < arr.length; i++) {
arr[i] = (arr[i] + 5) % 10;
}
//将数字反转
reverse(arr);
//转换成字符串
String data = "";
for (int i = 0; i < arr.length; i++) {
data += arr[i];
}
return data;
}
/**
* 将数组反转
*
* @param arr
*/
private static void reverse(int[] arr) {
for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
/**
* 将数字拆解成数组
*
* @param number
* @return
*/
private static int[] split(int number) {
int[] arr = new int[4];
arr[0] = number / 1000;
arr[1] = number / 100 % 10;
arr[2] = number / 10 % 10;
arr[3] = number % 10;
return arr;
}
}
8.9.5 数组拷贝
package com.itheima.test;
/**
* @ClassName Demo5
* @Description 数组拷贝
* @Author 孙克旭
* @Date 2025/3/8 20:59
*/
public class Demo5 {
public static void main(String[] args) {
int[] arr = arrayCopy(new int[]{10, 20, 30});
printArray(arr);
}
/**
* 数组拷贝
*
* @param arr
* @return
*/
public static int[] arrayCopy(int[] arr) {
if (arr == null) {
return null;
}
int[] array = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
array[i] = arr[i];
}
return array;
}
/**
* 打印数组
*
* @param arr
*/
public static void printArray(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("]");
}
}
8.10 案例二
8.10.1 抢红包
一个大V直播时发起了抢红包活动，分别有：9、666、188、520、99999五个红包。请模拟粉丝来抽奖，按照先来先得，
随机抽取，抽完即止，注意：一个红包只能被抽一次，先抽或后抽哪一个红包是随机的，示例如下（不一定是下面的顺序）：
package com.itheima.test;
import java.util.Random;
import java.util.Scanner;
/**
* @ClassName Demo6
* @Description 抢红包
* @Author 孙克旭
* @Date 2025/3/9 13:36
*/
public class Demo6 {
public static void main(String[] args) {
int[] redEnvelope = {9, 666, 188, 520, 9999};
start(redEnvelope);
}
public static void start(int[] array) {
Scanner scanner = new Scanner(System.in);
Random random = new Random();
for (int i = 0; i < array.length; i++) {
System.out.print("请按任意键完成抽奖：");
scanner.next();
while (true) {
int index = random.nextInt(array.length);
int money = array[index];
if (money != 0) {
System.out.println("恭喜您，您抽中了：" + money);
array[index] = 0;
break;
}
}
}
System.out.println("活动结束！");
}
}
8.10.2 找素数
判断101-200之间有多少个素数，并输出所有素数。
package com.itheima.test;
/**
* @ClassName Demo7
* @Description 找素数
* @Author 孙克旭
* @Date 2025/3/9 14:12
*/
public class Demo7 {
public static void main(String[] args) {
System.out.println(primeNumber(101, 200)); //21
}
public static int primeNumber(int start, int end) {
int count = 0; //记录素数个数
for (int i = start; i <= end; 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);
count++;
}
}
return count;
}
}
8.10.3 模拟双色球
1. 用户投注双色球
package com.itheima.test;
import java.util.Scanner;
/**
* @ClassName Demo8
* @Description 双色球
* @Author 孙克旭
* @Date 2025/3/9 15:13
*/
public class Demo8 {
public static void main(String[] args) {
int[] ints = userSelectNumber();
printArr(ints);
}
/**
* 用户投注双色球
*
* @return
*/
public static int[] userSelectNumber() {
Scanner scanner = new Scanner(System.in);
//有6个红球（1-33,不能重复），1个蓝球（1-16）
int[] arr = new int[7];
//投注红球
int red = 0;
while (true) {
if (red == 6) {
break;
}
System.out.println("请投注第" + (red + 1) + "个红球：");
int number = scanner.nextInt(); //用户投注的数字
//判断是否在数字范围内
if (number < 1 || number > 33) {
System.out.println("投注失败，红球数字的范围是1-33，请重新投注：");
continue;
}
//判断新数字是否与之前的数字重复
boolean flag = true;
for (int i = 0; i < red; i++) {
if (arr[i] == number) {
System.out.println("投注失败，您输入的数字与之前的重复，请重新投注：");
flag = false;
break;
}
}
if (flag) {
arr[red] = number;
System.out.println("投注成功！");
red++;
}
}
//投注蓝球
while (true) {
System.out.println("请投注蓝球：");
int blue = scanner.nextInt();
if (blue < 1 || blue > 16) {
System.out.println("投注失败，蓝球数字范围是1-16，请重新投注：");
continue;
}
arr[arr.length - 1] = blue;
System.out.println("投注成功！");
break;
}
return arr;
}
/**
* 打印数组
*
* @param arr
*/
public static void printArr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print((i == arr.length - 1) ? arr[i] : arr[i] + ",");
}
}
}
2. 模拟一组中奖号码
/**
* 产生一组中奖号码
*
* @return
*/
public static int[] createNumbers() {
Random random = new Random();
int[] array = new int[7];
//模拟红球号码 1-33，不重复
int red = 0;
while (true) {
if (red == 6) {
break;
}
int num = random.nextInt(33) + 1;
boolean flag = true;
for (int j = 0; j < red; j++) {
if (array[j] == num) { //重复了，重新生成
flag = false;
break;
}
}
if (flag) {
array[red] = num;
red++;
}
}
//模拟蓝球号码 1-16
array[6] = random.nextInt(16) + 1;
return array;
}
3. 判断用户中奖情况
/**
* 判断中奖情况
*
* @param userNumbers
* @param luckNumbers
*/
public static void judge(int[] userNumbers, int[] luckNumbers) {
int red = 0, blue;
//判断红球相同的个数
for (int i = 0; i < luckNumbers.length - 1; i++) {
for (int i1 = 0; i1 < userNumbers.length - 1; i1++) {
if (luckNumbers[i] == userNumbers[i1]) {
red++;
break;
}
}
}
//判断蓝球相同的个数
blue = (userNumbers[6] == luckNumbers[6]) ? 1 : 0;
System.out.println("您红球中奖的个数是：" + red);
System.out.println("您蓝球中奖的个数是：" + blue);
//判断中奖情况
if (red == 6 && blue == 1) {
System.out.println("恭喜您，中奖金额为1000万!");
} else if (red == 6) {
System.out.println("恭喜您，中奖金额为500万!");
} else if (red == 5 && blue == 1) {
System.out.println("恭喜您，中奖金额为3000元!");
} else if (red == 5 || (red == 4 && blue == 1)) {
System.out.println("恭喜您，中奖金额为200元!");
} else if (red == 4 || (red == 3 && blue == 1)) {
System.out.println("恭喜您，中奖金额为10元!");
} else if (red <= 2 && blue == 1) {
System.out.println("恭喜您，中奖金额为5元!");
} else {
System.out.println("很遗憾，您未中奖~~~");
}
}
4. 整体代码
package com.itheima.test;
import java.util.Random;
import java.util.Scanner;
/**
* @ClassName Demo8
* @Description 双色球
* @Author 孙克旭
* @Date 2025/3/9 15:13
*/
public class Demo8 {
public static void main(String[] args) {
int[] user = userSelectNumber();
printArr(user);
int[] luck = createNumbers();
printArr(luck);
judge(user, luck);
}
/**
* 用户投注双色球
*
* @return
*/
public static int[] userSelectNumber() {
Scanner scanner = new Scanner(System.in);
//有6个红球（1-33,不能重复），1个蓝球（1-16）
int[] arr = new int[7];
//投注红球
int red = 0;
while (true) {
if (red == 6) {
break;
}
System.out.println("请投注第" + (red + 1) + "个红球：");
int number = scanner.nextInt(); //用户投注的数字
//判断是否在数字范围内
if (number < 1 || number > 33) {
System.out.println("投注失败，红球数字的范围是1-33，请重新投注：");
continue;
}
//判断新数字是否与之前的数字重复
boolean flag = true;
for (int i = 0; i < red; i++) {
if (arr[i] == number) {
System.out.println("投注失败，您输入的数字与之前的重复，请重新投注：");
flag = false;
break;
}
}
if (flag) {
arr[red] = number;
System.out.println("投注成功！");
red++;
}
}
//投注蓝球
while (true) {
System.out.println("请投注蓝球：");
int blue = scanner.nextInt();
if (blue < 1 || blue > 16) {
System.out.println("投注失败，蓝球数字范围是1-16，请重新投注：");
continue;
}
arr[arr.length - 1] = blue;
System.out.println("投注成功！");
break;
}
return arr;
}
/**
* 产生一组中奖号码
*
* @return
*/
public static int[] createNumbers() {
Random random = new Random();
int[] array = new int[7];
//模拟红球号码 1-33，不重复
int red = 0;
while (true) {
if (red == 6) {
break;
}
int num = random.nextInt(33) + 1;
boolean flag = true;
for (int j = 0; j < red; j++) {
if (array[j] == num) { //重复了，重新生成
flag = false;
break;
}
}
if (flag) {
array[red] = num;
red++;
}
}
//模拟蓝球号码 1-16
array[6] = random.nextInt(16) + 1;
return array;
}
/**
* 判断中奖情况
*
* @param userNumbers
* @param luckNumbers
*/
public static void judge(int[] userNumbers, int[] luckNumbers) {
int red = 0, blue;
//判断红球相同的个数
for (int i = 0; i < luckNumbers.length - 1; i++) {
for (int i1 = 0; i1 < userNumbers.length - 1; i1++) {
if (luckNumbers[i] == userNumbers[i1]) {
red++;
break;
}
}
}
//判断蓝球相同的个数
blue = (userNumbers[6] == luckNumbers[6]) ? 1 : 0;
System.out.println("您红球中奖的个数是：" + red);
System.out.println("您蓝球中奖的个数是：" + blue);
//判断中奖情况
if (red == 6 && blue == 1) {
System.out.println("恭喜您，中奖金额为1000万!");
} else if (red == 6) {
System.out.println("恭喜您，中奖金额为500万!");
} else if (red == 5 && blue == 1) {
System.out.println("恭喜您，中奖金额为3000元!");
} else if (red == 5 || (red == 4 && blue == 1)) {
System.out.println("恭喜您，中奖金额为200元!");
} else if (red == 4 || (red == 3 && blue == 1)) {
System.out.println("恭喜您，中奖金额为10元!");
} else if (red <= 2 && blue == 1) {
System.out.println("恭喜您，中奖金额为5元!");
} else {
System.out.println("很遗憾，您未中奖~~~");
}
}
/**
* 打印数组
*
* @param arr
*/
public static void printArr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print((i == arr.length - 1) ? arr[i] : arr[i] + ",");
}
System.out.println();
}
}
9.【阶段一】JavaSE基础-自我介绍
请完成如下四个需求：
一.请写一篇400字左右的自我介绍。
自我介绍基本提纲
1、姓名
2、爱好、籍贯、学历或业务经历 (应注意与公司有关)
3、专业知识、学术背景 (应注意与岗、职有关)
4、优点、技能 (应突出能对公司所作的贡献）
5、用幽默或警句概括自己的特点可加深他人的印象
参考实例：
① 如果你是非应届生
面试官好,我是xx，今年xx岁，毕业于xx大学,主修xx专业。
曾先后任职于xx、xx这几家公司,在最后的xx中担任xx的岗位。
曾负责/参与过xx、xx等xx级别的项目,并取得了xxx的成绩。
在公司中曾获得xx等荣誉/奖项。我个人比较喜欢钻研技术，喜欢与人沟通，生活中也是一个乐观开朗的人，现在应聘贵公司xx岗位，希望能得到这个宝贵的机会,非常感谢!
② 如果你是应届生
面试官好,我是xx,今年xx岁，XX大学xx届的学生,专业是xx。
之前在xx公司的xx岗位上实习过,负责xx方面的工作内容。
我还在校级/市级/省级(哪个最牛说哪个）xx比赛中凭借xx课题夺得过xx的奖项。
在校期间我也比较喜欢参加社会实践，社团活动，平时我是一个比较客观积极，喜欢与人沟通热爱学习的人。以上就是我的自我介绍，谢谢！
二.总结到目前为止你都获得了哪些技术能力。
注意：技术能力提纲 （使用 了解、熟悉、掌握 等词汇）*
参考实例：
① 掌握Java开发环境的搭建
② 熟悉面向对象基本思想
③ 了解ArrayList的基本原理
三.场景模拟
假设技术老师是面试官。
请和面试官沟通完成自我介绍。（通过腾讯会议的方式）
请和面试官沟通目前都获得了哪些技术能力。（通过腾讯会议的方式）
四.场景模拟
假设技术老师是面试官。
选取一个综合案例给面试官介绍程序 执行流程。（通过腾讯会议的方式）
或者课后面试题给面试官讲解程序的 底层原理（通过腾讯会议的方式）
面试官你好,我是孙克旭,今年24岁，山东中医药大学24届的学生,专业是数据科学与大数据技术。
之前在浪潮通信公司的软件实施岗位上实习过,负责网络通信方面的工作内容。
在校期间我也比较喜欢参加社会实践，社团活动，平时我是一个比较客观积极，喜欢与人沟通热爱学习的人。以上就是我的自我介绍，谢谢！
见笑见笑~~~😄
10. 章节测评
10.1 数组的两种初始化分别是什么 ? 格式如何编写 ?
动态初始化:
数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[3];
// 创建了一个int类型的数组, 数组名叫做arr, 这个数组可以存储3个整数
静态初始化:
完整格式:
数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3...};
int[] arr = new int[]{11,22,33};
简化格式:
数据类型[] 数组名 = {元素1, 元素2, 元素3...};
int[] arr = {11,22,33};
10.2 我们调用方法传递实际参数的时候, 参数是基本数据类型, 和引用数据类型, 有什么不同 ?
不同点：
基本数据类型: 传递的是数据值
引用数据类型: 传递的是地址值
10.3 方法最完整的定义格式是什么 ? 再请详细描述下
定义的格式：
public static 返回值类型 方法名 (参数列表) {
方法体;
return 结果数据;
}
详细描述：
public static : 目前来说, 暂时记住即可
返回值类型: 跟return返回的结果有关
方法名: 自己定义的名字(见名知意, 小驼峰命名法)
参数列表: 方法逻辑运行之前, 需要的一些材料
方法体: 方法中真正执行的代码逻辑
return :
1. 用于结束方法
2. 用于将结果返还给调用者
10.4 编码题1
小明去超市购买 牙膏(12元)、牙刷(2元)、洗头膏(32元)、毛巾(5元)、香皂(8元)这几款日用品，收银员需要手动在收银系统中录入这几款商品的价格，并在订单列表中求出它们的总价。请使用代码，完成收银系统的功能。
package com.itheima.work;
import java.util.Scanner;
/**
* @ClassName Demo1
* @Description 编码题1
* @Author 孙克旭
* @Date 2025/3/10 11:27
*/
public class Demo1 {
public static void main(String[] args) {
/*小明去超市购买 牙膏(12元)、牙刷(2元)、洗头膏(32元)、毛巾(5元)、香皂(8元)这几款日用品，
收银员需要手动在收银系统中录入这几款商品的价格，并在订单列表中求出它们的总价。请使用代码，完成收银系统的功能。*/
System.out.println("一共需收款：" + sum() + "元"); //59
}
public static int sum() {
Scanner scanner = new Scanner(System.in);
int sum = 0;
System.out.print("请输入牙膏的价格：");
sum += scanner.nextInt();
System.out.print("请输入牙刷的价格：");
sum += scanner.nextInt();
System.out.print("请输入香皂的价格：");
sum += scanner.nextInt();
System.out.print("请输入洗头膏的价格：");
sum += scanner.nextInt();
System.out.print("请输入毛巾的价格：");
sum += scanner.nextInt();
return sum;
}
}
10.5 编码题2
设计一个程序，实现数组元素出现次数统计功能，具体如下：
① 定义一个长度为10的数组，里面存放0-5之间的随机数，并输出显示数组内容到控制台
② 统计任务①的数组每个元素出现的次数，并输出到控制台显示，格式为：“x出现了:x次”
package com.itheima.work;
import java.util.Random;
/**
* @ClassName Demo2
* @Descriptio 编码题2
* @Author 孙克旭
* @Date 2025/3/10 11:34
*/
public class Demo2 {
public static void main(String[] args) {
//① 定义一个长度为10的数组，里面存放0-5之间的随机数，并输出显示数组内容到控制台
//② 统计任务①的数组每个元素出现的次数，并输出到控制台显示，格式为：“x出现了:x次”
randomArray();
}
public static void randomArray() {
Random random = new Random();
int[] array = new int[10];
int n0 = 0, n1 = 0, n2 = 0, n3 = 0, n4 = 0, n5 = 0;
for (int i = 0; i < array.length; i++) {
int ele = random.nextInt(6);
array[i] = ele;
System.out.println(ele);
switch (ele) {
case 0:
n0++;
break;
case 1:
n1++;
break;
case 2:
n2++;
break;
case 3:
n3++;
break;
case 4:
n4++;
break;
case 5:
n5++;
break;
default:
break;
}
}
System.out.println("***************************");
System.out.println(0 + "出现了:" + n0 + "次");
System.out.println(1 + "出现了:" + n1 + "次");
System.out.println(2 + "出现了:" + n2 + "次");
System.out.println(3 + "出现了:" + n3 + "次");
System.out.println(4 + "出现了:" + n4 + "次");
System.out.println(5 + "出现了:" + n5 + "次");
}
}
10.6 编码题3
某地出租车收费标准如下
① 起步价：10元，起步里程：3公里
② 车公里单价：1.8元/公里。
③ 加收燃油附加费1元
假如乘客行驶的里程是4公里。
请设计一个方法用来计算乘客乘坐出租车应付的费用。
package com.itheima.work;
/**
* @ClassName Demo3
* @Description 编码题3
* @Author 孙克旭
* @Date 2025/3/10 11:47
*/
public class Demo3 {
public static void main(String[] args) {
/*① 起步价：10元，起步里程：3公里
② 车公里单价：1.8元/公里。
③ 加收燃油附加费1元
假如乘客行驶的里程是4公里。
请设计一个方法用来计算乘客乘坐出租车应付的费用。*/
System.out.println(cost(4)); //12.8
}
public static double cost(int n) {
if (n <= 0) {
return 0;
} else if (n <= 3) {
return 10 + 1;
} else {
return (n - 3) * 1.8 + 10 + 1;
}
}
}
第一章 Java基础语法.pdf 链接: https://pan.baidu.com/s/17lP4WxViaS1eJ_EBopaZew?pwd=z8xf 提取码: z8xf
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
