java学习笔记
前言
Debug工具的使用
IDEA自带的断点调试工具，可以控制代码从断点开始一行一行的执行，然后详细观看程序执行的情况。
Random的使用
作用
生成随机数
代码展示
// 给定一个0~9的伪随机数
package randomDemo;
import java.util.Random;
public class randomDemo {
public static void main(String[] args) {
Random r = new Random();
for (int i = 0; i < 3; i++) {
int number = r.nextInt(10);
System.out.println(number);
}
}
}
//random r 的作用是把 r 作为 random 的一个代替名词使用，来减少 random 的复杂书写程度
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z6PSQZT1-1692209509618)(%E7%AC%94%E8%AE%B0.assets/image-20230714223905834.png)]
//再1~100内随机一个数，提示用户猜测，猜大则提示过大，猜小则提示过小，知道猜中结束游戏
package randomDemo;
import java.util.Random;
import java.util.Scanner;
public class game_random_big_or_small {
public static void main(String[] args) {
Random r = new Random();
int answer = r.nextInt(100)+1;
Scanner s = new Scanner(System.in);
while (true){
System.out.println("请在1~100内猜一个数");
int my_answer = s.nextInt();
if(my_answer<answer){
System.out.println("猜小了，再猜猜");
}
else if(my_answer == answer) {
System.out.println("恭喜你，猜对了");
break;
}
else{
System.out.println("猜大了，再猜猜");
}
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TmMivhur-1692209509619)(%E7%AC%94%E8%AE%B0.assets/image-20230714224042210.png)]
技巧
减加法
由于random中默认的区间是从零开始的，所以当我们取比如020之间的随机数是直接可以拿来使用的，但是如果我们想要取317之内的随机数的话我们就可以使用减加法来帮助实现这段代码。
//0~19的随机数
package randomDemo;
import java.util.Random;
public class randomDemo {
public static void main(String[] args) {
Random r = new Random();
int number = r.nextInt(20);
System.out.println("随机生成的数是："number);
}
}
------------------------------------------
//3~17的随机数
package randomDemo;
import java.util.Random;
public class randomDemo {
public static void main(String[] args) {
Random r = new Random();
int number = r.nextInt(15);//产生一个0~14的随机数
number += 3;//让产生的随机数加3就可以得出3~17的随机数了
System.out.println("随机生成的数是："number);
}
}
java中的API接口和scanf
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kxkJD5tp-1692209509619)(%E7%AC%94%E8%AE%B0.assets/image-20230713011240331.png)]
ASCII编码表
美国信息交换标准编码，规定了现代英语，数字字符，和其他西欧字符对应的数字编号
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C21XLECk-1692209509620)(%E7%AC%94%E8%AE%B0.assets/image-20230712000705474.png)]
常用快捷键
1：第一次Java的HelloWorld
一：在安装了JDK17之后，在视频的帮助下成功的编写了一个在Java环境下的第一个代码HelloWorld
2>代码全况：
public class HelloWorld{
public static void main(String[] args){
System.out.println("HelloWorld");
}
}
3>只是潦草的抄了一遍，不认识任何语法，感觉Java的语法有亿点点复杂:)QAQ
二：开发一个java程序要经历哪些步骤？
编写，编译，运行
三：Java代码编写有什么基本要求？
1>文件名称的后缀必须是Java结尾
2>文件名称必需与代码的类名称一致
3>必须使用英文模式下的符号
2：java程序的执行原理
一：Java程序的执行原理？
不管是什么样的高级编程语言，最终都是翻译成计算机底层可以识别的机器语言
二：机器语言是有什么组成的？
0和1
三：BUG的来源
BUG的英文意思是虫子，最早时是指虫子飞到计算机里，造成了计算机硬件的短路，所以计算机程序的故障就被称为BUG .
3：JDK的组成和跨平台原理
JDk的组成（JVM虚拟机，核心类库，开发工具（javac,java…））
一：JVM虚拟机
Java虚拟机，真正运行Java程序的地方。
二：核心类库
Java自己写好的程序，给程序员自己的程序调用的
三：JRE
Java的运行环境
四：JDK
Java开发工具包（包括上面所有）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vnFm3LTg-1692209509620)(%E7%AC%94%E8%AE%B0.assets/image-20230709174720729.png)]
跨平台原理
含义
一次编译，处处可用
程序只需要开发一次，就可以在各种安装了JVM的系统平台上使用
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U13ou9eB-1692209509620)(%E7%AC%94%E8%AE%B0.assets/image-20230709174752079.png)]
4：path和java_home环境变量
path环境变量
Path环境变量用于记住程序路径，方便再命令行窗口的任意目录启动程序
目前较新的JDk在安装时会自动配置javac,java程序的路径到path环境变量中去，因此，Javac,java可以直接使用
注意
以前老版本的JDK在安装时不会自动配置环境变量，此时需要自己配置环境变量
Java_home环境变量
Java_Home
告诉操作系统JDK安装在了那个位置，需要手动配置
5：IDEA管理Java程序的结构
结构：
project（项目、工程）
module（模块）
package（包）
class（类文件）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UZcuxEsb-1692209509620)(%E7%AC%94%E8%AE%B0.assets/image-20230709223630533.png)]
创建一个新工程的步骤
project->module->package->calss
1：创建一个新的空工程
2：创建一个新模块
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fczHWlgB-1692209509620)(%E7%AC%94%E8%AE%B0.assets/image-20230709232738543.png)]
3：创建一个新包
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OzkChwcZ-1692209509621)(%E7%AC%94%E8%AE%B0.assets/image-20230709232925489.png)]
4：创建一个新类
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wGl6qwfr-1692209509621)(%E7%AC%94%E8%AE%B0.assets/image-20230709232955823.png)]
5：编写代码并启动
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mCvAzmZp-1692209509621)(%E7%AC%94%E8%AE%B0.assets/image-20230709233016213.png)]
java基础语法
注释（不影响程序的执行）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qPLVifW4-1692209509621)(%E7%AC%94%E8%AE%B0.assets/image-20230710180505790.png)]
单行注释
//
多行注释
/*
*/
文档注释
/**
*/
字面量
计算机是用来处理数据的，字面量就是告诉程序员：数据在程序中的书写格式
常用数据
| 常用数据 | 生活中的写法 | 程序中的写法 | 说明 |
|---|---|---|---|
| 整数 | 666，-88 | 666，-88 | 写法一致 |
| 小数 | 1.3，1.5，3.11 | 1.3,1.5,3.11 | 写法一致 |
| 字符 | A，0，我 | ‘A’,‘0’,‘我’ | 只能使用单引号，有且只能有一个字符 |
| 字符串 | HelloWorld | “HelloWorld” | 程序中必须使用双引号，内容可有可无 |
| 布尔值 | 真，假 | ture,false | ture:真 false:假 |
| 空值 | 值是：null | 一个特殊的值：空值 | |
变量
变量的定义格式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-05Ww1gG5-1692209509622)(%E7%AC%94%E8%AE%B0.assets/image-20230710182115862.png)]
变量在计算机中的执行原理
变量就是内存中的一块区域，可以理解成是一个盒子，用来装一个数据
变量的特点
可替换性
变量中装的数据是可以被替换的
变量的应用场景
编写代码更灵活，管理代码更方便
使用变量的几个注意事项
1>变量要先声明在使用
2>变量是什么类型，就应该用来装什么类型的数据，否则会报错
3>变量从定义开始到"}"截至的范围内有效；且同一个范围内，定义的多个变量，他们的名称不能一样
4>变量定义的时候可以不赋初始值；但在使用时变量里必须有值，否则会报错
数据类型
基本数据类型
！！4大类8种
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qO1LmjkS-1692209509622)(%E7%AC%94%E8%AE%B0.assets/image-20230712002241047.png)]
引用数据类型
string
类型转换
自动类型转换（类型范围小的变量，可以直接赋值给类型范围大的变量）
1>存在某种类型的变量赋值给另一种类型的变量
2>存在不同类型的数据一起运算
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LgHb94ts-1692209509622)(%E7%AC%94%E8%AE%B0.assets/image-20230712003457154.png)]
表达式的自动类型转换
在表达式中，小范围类型的变量，会自动转换成表达式中较大范围的类型，再参与运算
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lLDKX6xs-1692209509622)(%E7%AC%94%E8%AE%B0.assets/image-20230712003916908.png)]
注意!!!
表达式的最终结果类型由表达式中的最高类型决定。
在表达式中，byte，short，char是直接转换成int类型参与运算的
强制类型转换（大范围类型的变量编程小范围类型的变量）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TnzeFxEU-1692209509622)(%E7%AC%94%E8%AE%B0.assets/image-20230712004644003.png)]
int a = 20;
byte b = (byte) a;
//20
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9RUZpHat-1692209509623)(%E7%AC%94%E8%AE%B0.assets/image-20230712005023623.png)]
注意！！！
强制类型转换可能会造成数据溢出
浮点型强制转换成整型，直接丢掉小数部分，保留整数部分返回
关键字，标识符
关键字
Java语言自己用到的一些词，有特殊作用的，我们称之为关键词，如：public，class，int，double…
关键字是Java本身使用的，我们不能用来做为：类名，变量名否则会报错
标识符
标识符就是名字，如类名，变量名等等都是标识符。
标识符的要求
基本组成
由数字、字母、下划线（_）和美元符号（$）组成
强制要求
标识符不能以数字开头、不能用关键字作为名字、且区分大小写
建议规范
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l0E5w7S5-1692209509623)(%E7%AC%94%E8%AE%B0.assets/image-20230710230421686.png)]
运算符（同c）
对变量，字面量进行运算的符号
基本的算术运算符
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IxnixowX-1692209509623)(%E7%AC%94%E8%AE%B0.assets/image-20230712234611522.png)]
自增自减运算符
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZozxI66J-1692209509623)(%E7%AC%94%E8%AE%B0.assets/image-20230712235151125.png)]
赋值运算符和扩展赋值运算符
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sFTx46hg-1692209509623)(%E7%AC%94%E8%AE%B0.assets/image-20230712235856458.png)]
注意，扩展赋值运算符自带强制类型转换
关系运算符
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qcMCXBUo-1692209509624)(%E7%AC%94%E8%AE%B0.assets/image-20230713000318652.png)]
逻辑运算符
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1oYaMrcA-1692209509624)(%E7%AC%94%E8%AE%B0.assets/image-20230713000406286.png)]
注意！！！！
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KNmoYbgO-1692209509624)(%E7%AC%94%E8%AE%B0.assets/image-20230713000754046.png)]
三元运算符
格式
条件表达式？值1:值2
注意：值1后面跟的是冒号:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uMw8tcP3-1692209509624)(%E7%AC%94%E8%AE%B0.assets/image-20230713001018731.png)]
运算符的优先级
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SyH4I4Fd-1692209509624)(%E7%AC%94%E8%AE%B0.assets/image-20230713001146957.png)]
程序的流程控制
概述
| 顺序结构 | 自上而下地执行代码 |
|---|---|
| 分支结构 | 根据条件，选择对应代码执行 |
| 循环结构 | 控制某段代码重复执行 |
分支结构
if
定义
根据条件的真或假来决定执行某段代码
if的三种形式
//第一种
if(条件表达式){
代码；
}
//第二种
if(条件表达式){
代码1；
}
else(条件表达式){
代码2；
}
//第三种
if(条件表达式){
代码1；
}
else if(条件表达式){
代码3；
}
.
.
.
else(条件表达式){
代码n；
}
switch
定义
通过比较值来决定执行哪条分支
switch(表达式){
case值1:
执行代码；
break；
case值2:
执行代码；
break；
......
case值n-1:
执行代码；
break；
default:
执行代码n;
}
执行流程
1>先执行表达式的值，在拿这个值与case后的值进行匹配。
2>与哪个case后的值匹配结果为ture就执行哪个case块的代码，遇到break就跳出switch分支。
3>如果全部case的值与之匹配都是false，则执行default块的代码。
switch的案例
package switchDemo1;
public class switchDemo {
public static void main(String[] args) {
String day = "周日";
switch (day){
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("不想上班");
default:
System.out.println("你这个星期不对劲");
}
}
}
注意事项
1>表达式的值类型不能是double,float,long
2>当多个case分支的代码相同时，可以把相同的代码放到一个case块中，其他的case块都通过穿透性穿透到该case块执行代码即可，这样可以简化代码。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9jJB3eqt-1692209509625)(%E7%AC%94%E8%AE%B0.assets/image-20230713235948721.png)]
if 和 switch的比较
if可以做区间匹配即if可以判断信息是否大于小于某个值，而switch只能判断一个独立的值。
1>若当前条件是区间，应直接使用if分支结构
2>若当前条件是与一个一个的值作比较的时候，switch分支更合适：格式良好，性能较好，代码优雅。
循环结构（同c）
控制一段代码重复执行多次
for循环
减少代码的重复编写，灵活的控制程序的执行
//输出三次HelloWorld
for(int i = 0;i<3;i++){
System.out.println("HelloWorld")
}
/*
1>首先执行初始化语句i = 0
2>判断循环条件，ture就执行循环体语句，然后执行迭代语句i++；false就会结束循环语句
*/
/*
for(初始化语句;循环条件;迭代语句){
循环体语句；
}
*/
while循环
int i = 0;
while(i < 5){
System.out.println("HelloWorld");
i++;
}
/*
初始化语句；
while(循环条件){
循环体语句；
迭代语句；
}
*/
while案例分析
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EIkdhQzq-1692209509625)(%E7%AC%94%E8%AE%B0.assets/image-20230714204221464.png)]
// 代码自己写写才能真正掌握0.o!!
package whileDemo;
public class whileDemo1 {
public static void main(String[] args) {
double mountain_height = 8848860;
double paper_height = 0.1;
int count = 0;
while(paper_height < mountain_height){
paper_height = paper_height * 2;
count += 1;
}
System.out.println("需要"+count+"次才能把纸张的厚度编程珠穆朗玛峰那么大");
System.out.println("最后折叠完纸张的厚度是："+paper_height);
}
}
//下图纸张的厚度使用的是科学计数法即1.34237728 * 10^7(E就是10的n次方)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vfGR4D5l-1692209509625)(%E7%AC%94%E8%AE%B0.assets/image-20230714204655703.png)]
while和for的区别
1>二者的功能完全一样，for和while都能解决问题。
2>使用规范：知道循环几次就用for；不知道就建议使用：while。
do-while循环
初始化语句;
do {
循环体语句;
迭代语句;
}
while(循环条件);
int i = 0;
do {
System.out.println("HelloWorld");
i++;
}
while(i<3);
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mYwDK2Rd-1692209509625)(%E7%AC%94%E8%AE%B0.assets/image-20230714205443483.png)]
特点
先执行后判断
死循环
可以一直执行下去的一种循环，如果没有干预就会一直执行下去
写法
//
for( ; ; ){
System.out.println("HelloWorld");
}
//
while(ture){
System.out.println("HelloWorld");
}
//
do{
System.out.println("HelloWorld");
}
while(ture);
循环嵌套
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MqfhBeOv-1692209509626)(%E7%AC%94%E8%AE%B0.assets/image-20230714215116829.png)]
跳转关键字：break；continue；OUT
break
跳出并结束当前所在循环的执行
注意
break只能用于结束所在循环，或者结束所在switch分支的执行。
continue
用于跳出档次循环的当次执行，直接进入循环的下一次执行。
注意
continue只能在循环中进行使用
OUT
OUT可以直接跳过外部循环的当前执行阶段
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qjsZQkuZ-1692209509626)(%E7%AC%94%E8%AE%B0.assets/image-20230721175947407.png)]
数组
定义
一个容器，用来存储一批同种类型的数据。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sCl1c0WP-1692209509626)(%E7%AC%94%E8%AE%B0.assets/image-20230715184630341.png)]
数组的定义和访问
基本原理
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J8QSt1AT-1692209509626)(%E7%AC%94%E8%AE%B0.assets/image-20230715190020175.png)]
注意
数组变量名中存储的是数组在内存中的地址信息，数组是一种引用数据类型。
静态初始化数组
特点
定义数组的时候直接给数组赋值
格式
//完整格式
数据类型[] 数组名 = new 数据类型[]{元素1，元素2..};
int[] age = new int[]{12,24,36};
double[] scores = new doubble[]{88.3,99.5...};
//简化格式
数据类型[] 数组名 = {元素1，元素2...};
int[] ages = {12,24,36};
注意
1>“数据类型[] 数组名"也可以写成"数据类型 数组名[]”
2>什么类型的数组只能存放什么类型的数据
数组的访问
语法格式
数组名[索引]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mtIpzzEb-1692209509626)(%E7%AC%94%E8%AE%B0.assets/image-20230715190357515.png)]
//取值
System.out.println(arr[0]);//12
//赋值
arr[2] = 100;
System.out.println(arr[2]);//100
//获取数组中元素的个数
System.out.println(arr.length);//3
//获取数组的最大索引（前提：元素个数大于0）
System.out.println(arr.length-1);//2
注意
如果访问数组是，使用的索引超过了数组最大索引会出现bug,提示索引越界。
数组的遍历
就是一个一个数据的访问
//代码展示
int ages[] = {12,24,36}
for (int i = 0;i < arr.length; i++){
System.out.println(ages[i]);
}
案例
//某部门5名员工的销售额分别为：16，26，36，6，100，岂能计算出他们部门的总销售量。
package star.arrayDemo;
public class plus_arrayDemo1 {
public static void main(String[] args) {
int arr[] = {16,26,36,6,100};
int sum = 0;
for (int j : arr) {
sum += j;
}
System.out.println(sum);
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1z7pDBvU-1692209509627)(%E7%AC%94%E8%AE%B0.assets/image-20230716155251000.png)]
动态初始化数组
定义
定义数组时先不存入具体的元素值，只确定数组存储的数据类型和数组的长度
格式
//先定义
数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[3];
//后赋值
arr[0] = 10;
System.out.println(arr[0]);//10
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n4BNFJKd-1692209509628)(%E7%AC%94%E8%AE%B0.assets/image-20230716161233135.png)]
注意
静态初始化和动态初始化数组的写法是相互独立的，不可以混用。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B3g0dr2L-1692209509628)(%E7%AC%94%E8%AE%B0.assets/image-20230716162406199.png)]
动态初始化数组后的元素默认值规则：
| 数据类型 | 明细 | 默认值 |
|---|---|---|
| byte，short,char,int,long | 0 | |
| 基本类型 | float,double | 0.0 |
| boolean | false | |
| 引用类型 | 类、接口、数组、string | null |
案例
需求
某歌唱比赛，需要开发一个系统：可以录入六名评委的打分，录入完毕后立即输出平均分作为选手得分。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vUXjeqeb-1692209509628)(%E7%AC%94%E8%AE%B0.assets/image-20230716164509058.png)]
package star.arrayDemo;
import java.util.Scanner;
public class array_game_plusScore {
public static void main(String[] args) {
int arr[] = new int[6];
int sum = 0;
Scanner s = new Scanner(System.in);
for (int i = 0; i < 6; i++) {
arr[i] = s.nextInt();
}
for (int i = 0; i < 6; i++) {
sum += arr[i];
}
sum /= arr.length;
System.out.println("这个选手的我平均得分是："+sum);
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9Zw3i5Oi-1692209509629)(%E7%AC%94%E8%AE%B0.assets/image-20230716164322576.png)]
两种数组定义方法的对比
动态初始化
适合开始不确定具体元素值，只知道元素个数的业务场景。
静态初始化
适合一开始就知道要存入哪些元素值的业务场景
专项训练-数组常见案例
1>数组求最值
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nT5ukBLi-1692209509629)(%E7%AC%94%E8%AE%B0.assets/image-20230716200531857.png)]
package star.arrayDemo;
public class arraytext1_max_facescore {
public static void main(String[] args) {
int facescore[] = {15,9000,10000,20000,30,-5};
int max = facescore[0];
for (int i = 1; i < facescore.length; i++) {
if (facescore[i]>max) {
max = facescore[i];
}
}
System.out.println("颜值最高的分数是"+max);
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-H2y50una-1692209509629)(%E7%AC%94%E8%AE%B0.assets/image-20230716200705362.png)]
2>数组反转
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fs8QO70S-1692209509629)(%E7%AC%94%E8%AE%B0.assets/image-20230716200744419.png)]
//船舰一个新变量，把原来的变量反转装入新变量中
package star.arrayDemo;
public class arraytext2_array_yarra {
public static void main(String[] args) {
int arr[] = {10,20,30,40,50};
int arr1[] = new int[5];
for (int i = 0; i < arr.length; i++) {
arr1[arr.length-1-i] = arr[i];
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr1[i]);
if (i == arr.length-1){
break;
}
System.out.print(",");
}
}
}
//船舰一个新变量作为中间变量，把老变量的元素反转
package star.arrayDemo;
public class arraytext2_array_yarra {
public static void main(String[] args) {
int arr[] = {10,20,30,40,50};
int arr1[] = new int[5];
for (int i = 0,j = arr.length-1; i <= j; i++,j--) {
arr1[i] = arr[i];
arr[i] = arr[j];
arr[j] = arr1[i];
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]);
if (i == arr.length-1){
break;
}
System.out.print(",");
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WXeIZMkN-1692209509629)(%E7%AC%94%E8%AE%B0.assets/image-20230716201827946.png)]
3>随机排名
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-heD166pB-1692209509630)(%E7%AC%94%E8%AE%B0.assets/image-20230716203311833.png)]
package star.arrayDemo;
import java.util.Random;
import java.util.Scanner;
public class arraytxet3_radom_you_and_me {
public static void main(String[] args) {
int arr[] = new int[5];
Scanner sc = new Scanner(System.in);
Random r = new Random();
int arr1[] = new int[5];
for (int i = 0; i < arr.length; i++) {
System.out.printf("请输入第"+(i+1)+"位的工号");
arr[i] = sc.nextInt();
}
for (int i = 0; i < arr.length; i++) {
arr1[i] = arr[i];
int address = r.nextInt(5);
arr[i] = arr[address];
arr[address] = arr1[i];
}
System.out.print("随机后的工号排序是：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]);
if (i == arr.length-1){
break;
}
System.out.print(",");
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5u1fBQVO-1692209509630)(%E7%AC%94%E8%AE%B0.assets/image-20230716204502978.png)]
方法（等同于函数）
定义
方法是一种语法结构，它可以把一段代码封装成一个功能，以便重复调用。
好处
1>使用方法可以提高代码的复用性，提高了开发效率。
2>让程序的逻辑更加清晰。
格式
修饰符 返回值类型 方法名（形参列表）{
方法体代码(需要执行的功能代码);
return 返回值;
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UzOg7gyA-1692209509630)(%E7%AC%94%E8%AE%B0.assets/image-20230717174459799.png)]
注意
方法的修饰符
暂时使用public static 来修饰。
2>方法中申明了具体的返回值类型，内部必须使用return返回对应类型的数据。
3>形参列表可以有多个，甚至可以没有；如果有多个形参，多个形参必须使用“ ，”隔开，且不能给初始化值。
4>如果方法不需要返回数据，返回值类型必须申明成void(无返回值申明)，此时方法内不可以使用return来返回数据
4>没有参数，且没有返回值类型申明的方法，称为无参数，无返回值的方法，以此类推。
方法重载
定义
一个类中，出现多个方法的名称相同 ，但是他们的形参列表是不同的，那么这些方法被称为方法重载了
注意
1>一个类中，只要一些方法的名称相同、形参列表不同，那么他们就是方法重载了，其他的都不管（如：修饰符，返回值类型是否一样都不管）。
2>形参列表不同指的是：形参的个数、类型、顺序不同，不关心形参的名称。
案例
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UFQfQFaD-1692209509630)(%E7%AC%94%E8%AE%B0.assets/image-20230717220755525.png)]
package methodDemo;
import java.util.Scanner;
public class methodDemo4_weaponFIre {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请问要向哪里发射？");
String stress = sc.next();
System.out.println("请问要向发射几枚？");
int number = sc.nextInt();
weaponFire();
weaponFire(stress);
weaponFire(stress,number);
}
public static void weaponFire(){
System.out.println("武器发射成功");
}
public static void weaponFire(String stress){
System.out.println("已经往"+stress+"发射了武器");
}
public static void weaponFire(String stress,int number){
System.out.println("已经往"+stress+"发射了"+ number +"枚武器");
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pgx6bbrn-1692209509630)(%E7%AC%94%E8%AE%B0.assets/image-20230717221923889.png)]
return关键字在方法中单独使用
return;可以用在无返回值的方法中，作用是：立即跳出并结束当前方法的执行。
常见问题
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qsYSQI2T-1692209509631)(%E7%AC%94%E8%AE%B0.assets/image-20230717180003667.png)]
案例
1>求1~n的累加结果
package methodDemo;
import java.util.Scanner;
public class methodDemo1_plus_1_to_n {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入你想累加到的数字");
int n = sc.nextInt();
System.out.println(n + "的累加结果为：" + plus_1_to_n(n));
}
public static int plus_1_to_n(int n){
int sum = 0;
for (int i = 1; i <= n ; i++) {
sum += i;
}
return sum;
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1hwMqCiQ-1692209509631)(%E7%AC%94%E8%AE%B0.assets/image-20230717180831405.png)]
2>判断输入的数字是奇数还是偶数，并输出结果
package methodDemo;
import java.util.Scanner;
public class methodDemo2_odd_or_even {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个数字");
int number = sc.nextInt();
System.out.println(odd_or_even(number));
}
public static String odd_or_even(int n){
if(n % 2 == 1){
return "这个数是奇数";
}
else {
return "这个数是偶数";
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jmGkncbN-1692209509631)(%E7%AC%94%E8%AE%B0.assets/image-20230717181512650.png)]
java的参数传递机制（值传递）
定义
在传输实参给方法的形参的时候，传输的是实参变量中储存的值的副本。
实参
在方法内部定义的变量
形参
在定义方法是声明的参数
基本类型的参数传递
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kRkAyxP0-1692209509631)(%E7%AC%94%E8%AE%B0.assets/image-20230717183234868.png)]
引用类型的参数传递机制
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uE1QXGFD-1692209509632)(%E7%AC%94%E8%AE%B0.assets/image-20230717183742856.png)]
由于在进行参数的引用时，形参被传递的数值是数组的值（地址），所以在方法中改变数组的值时，会连带的把实参改变，即在引用类型的参数传递时，实参和形参一同改变。
案例
1>输出数组内容
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pYJ3vonu-1692209509632)(%E7%AC%94%E8%AE%B0.assets/image-20230717184048531.png)]
package methodDemo;
public class mehtodDemo3_putArrayOUT {
public static void main(String[] args) {
int arr[] = {10,20,70,90};
putArrayOUT(arr);
}
public static void putArrayOUT(int arr[]){
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length-1){
System.out.print(arr[i]);
break;
}
System.out.print(arr[i]+", ");
}
System.out.println("]");
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dfyQSvBr-1692209509632)(%E7%AC%94%E8%AE%B0.assets/image-20230717184856415.png)]
2>判断两个数组的内容是否一致
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HurYpPVg-1692209509632)(%E7%AC%94%E8%AE%B0.assets/image-20230717194340766.png)]
package methodDemo;
public class methodDemo4_same_or_different {
public static void main(String[] args) {
int arr1[] = {10,20,30};
int arr2[] = {10,20,30};
same_or_different(arr1,arr2);
}
public static void same_or_different(int arr1[],int arr2[]){
if(arr1.length != arr2.length){
System.out.println("这两个数组不一样");
}
else{
for (int i = 0; i < arr1.length; i++){
if(arr1[i] != arr2[i]){
System.out.println("这两个数组不一样");
return;
};
}
System.out.println("这两个数组看起来好像一样");
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Tr7RXGCh-1692209509632)(%E7%AC%94%E8%AE%B0.assets/image-20230717195025362.png)]
java案例
1>买飞机票
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R65rLlQd-1692209509633)(%E7%AC%94%E8%AE%B0.assets/image-20230718220635628.png)]
package javaText;
import java.util.Scanner;
public class javaText_planeTickets {
public static void main(String[] args) {
Scanner sc =new Scanner(System.in);
System.out.println("系统默认返回当前月份");
int days = sc.nextInt();
System.out.println("请问您要购买的是什么类型的票(系统默认给出经济舱或者头等舱)");
String place = sc.next();
season(days,place);
}
public static void season(int days, String place) {
if (days >= 5 && days <= 10) {
if (place.equals("头等舱")) {
System.out.println("当前头等舱的优惠是9折");
}else if (place.equals("经济舱")) {
System.out.println("当前经济舱的优惠是8.5折");
} else {
System.out.println("系统出错，请稍后再试");
}
}
else if (days <= 4 || days >= 11){
if (place.equals("头等舱")) {
System.out.println("当前头等舱的优惠是7折");
}else if (place.equals("经济舱")) {
System.out.println("当前经济舱的优惠是6.5折");
}else {
System.out.println("系统出错，请稍后再试");
}
}
else {
System.out.println("系统出错，请稍后再试");
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PKAzAyDD-1692209509633)(%E7%AC%94%E8%AE%B0.assets/image-20230718223040134.png)]
2>开发验证码
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KzOTHSTX-1692209509633)(%E7%AC%94%E8%AE%B0.assets/image-20230718232423208.png)]
package javaText;
import java.util.Random;
import java.util.Scanner;
public class javaText_createCode {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请问需要一个几位的验证码");
int n = sc.nextInt();
System.out.println("生成的验证码是：" + code(4));
}
public static String code(int n){
String ch = "";
Random r =new Random();
for (int i = 1; i <=n; i++) {
int number = r.nextInt(3);
switch (number){
case 0://数字
ch += r.nextInt(10);
break;
case 1://大写字母
ch += (char) (r.nextInt(26) + 65);
break;
case 2://小写字母
ch += (char) (r.nextInt(26) + 97);
break;
}
}
return ch;
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vxs03up2-1692209509633)(%E7%AC%94%E8%AE%B0.assets/image-20230718234208379.png)]
3>评委打分
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MytUqnMA-1692209509633)(%E7%AC%94%E8%AE%B0.assets/image-20230718234318056.png)]
package javaText;
import java.util.Scanner;
public class javaText_score {
public static void main(String[] args) {
int arr[] = new int[6];
Scanner sc = new Scanner(System.in);
for (int i = 0; i < arr.length; i++) {
System.out.println("请输入第"+(i+1)+"位评委的成绩");
arr[i] = sc.nextInt();
}
System.out.println("该名选手的平均得分是："+score(arr));
}
public static double score(int arr[]){
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return (sum-max(arr)-min(arr))/(arr.length-2);
}
public static int max(int arr[]){
int arr1 = arr[0];
for (int i = 1; i < arr.length; i++) {
if(arr[i]> arr1){
arr1 = arr[i];
}
}
return arr1;
}
public static int min(int arr[]){
int arr1 = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] < arr1) {
arr1 = arr[i];
}
}
return arr1;
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nWIO8ajN-1692209509634)(%E7%AC%94%E8%AE%B0.assets/image-20230719223742623.png)]
4>数字加密
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GjtFOMle-1692209509634)(%E7%AC%94%E8%AE%B0.assets/image-20230719223845051.png)]
package javaText;
import java.util.Scanner;
public class javaText_secretCode {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("密码");
int number = sc.nextInt();
System.out.println(secret(number));
}
public static String secret(int number){
int arr[] = change(number);
for (int i = 0; i < 4; i++) {
arr[i] = (arr[i]+5)%10;
}
String change_number = "";
for (int i = 3; i >=0 ; i--) {
change_number += arr[i];
}
return change_number;
}
public static int[] change(int number){
int[] arr = new int[4];
arr[0] = number/1000;
arr[1] = (number%1000)/100;
arr[2] = (number%100)/10;
arr[3] = number%1000;
return arr;
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ESVdSH5O-1692209509634)(%E7%AC%94%E8%AE%B0.assets/image-20230720155537917.png)]
5>数据拷贝
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WCa6mj9L-1692209509634)(%E7%AC%94%E8%AE%B0.assets/image-20230720224114926.png)]
package javaText;
public class javaText_copyarray {
public static void main(String[] args) {
int arr[] = {11,22,33};
int[] arr1 = copy(arr);
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if(i == arr.length-1){
System.out.print(arr1[i]);
break;
}
System.out.print(arr1[i]);
System.out.print(",");
}
System.out.print("]");
}
public static int[] copy(int arr[]){
int arr1[] = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
arr1[i] = arr[i];
}
return arr1;
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oEjyGXcH-1692209509635)(%E7%AC%94%E8%AE%B0.assets/image-20230720225013871.png)]
6>抢红包
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fpPEC88a-1692209509635)(%E7%AC%94%E8%AE%B0.assets/image-20230720225503872.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ewGyKM9a-1692209509635)(%E7%AC%94%E8%AE%B0.assets/image-20230720225511488.png)]
package javaText;
import java.util.Random;
import java.util.Scanner;
public class javaTxte_getMoney {
public static void main(String[] args) {
int money[] = {9,666,188,520,99999};
System.out.println(GetMoney(GetMoney(GetMoney(GetMoney(GetMoney(money))))));
}
public static int[] GetMoney(int money[]){
if(money.length-1 == 0){
System.out.println("请抽取属于您个人得分红包");
Scanner sc = new Scanner(System.in);
String call = sc.next();
System.out.println(call + "，您的抽奖结果是：" + money[0]);
System.out.println("抽红包阶段结束");
return money;
}
else {
System.out.println("请抽取属于您个人得分红包");
Scanner sc = new Scanner(System.in);
String call = sc.next();
Random r = new Random();
int number = r.nextInt(money.length);
int arr[] = new int[money.length - 1];
for (int i = 0, j = 0; j < arr.length; i++, j++) {
if (i == number) {
j--;
continue;
}
arr[j] = money[i];
}
System.out.println(call + "，您的抽奖结果是："+ money[number]);
return arr;
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PgBl2lPu-1692209509635)(%E7%AC%94%E8%AE%B0.assets/image-20230720232543387.png)]
7>找素数
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6WvjedNc-1692209509635)(%E7%AC%94%E8%AE%B0.assets/image-20230721172211894.png)]
//方法一
package javaText;
public class javaText_find_sushu {
public static void main(String[] args) {
find_sushu(100,200);
}
public static void find_sushu(int origin,int bound){
int count = 0;
int arr[] = new int[bound-origin+1];
if(origin < 3){
System.out.println("没有素数");
}
else {
for (int i = origin; i <= bound ; 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 += 1;
}
}
System.out.println("一共有" + count +"个素数");
}
}
}
//方法二（调用方法判断素数）
package javaText;
public class javaText_find_sushu_1 {
public static void main(String[] args) {
int count = 0;
for (int i = 101; i <= 200; i++) {
if (check(i)){
System.out.println(i);
count++;
}
}
System.out.println(count);
}
public static boolean check(int date){
for (int i = 2; i <= date/2; i++) {
if (date % i == 0) {
return false;
}
}
return true;
}
}
8>九九乘法表
package javaText;
public class javaText_99multiplication {
public static void main(String[] args) {
multiplication(9);
}
public static void multiplication(int n){
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j+"*"+i+"="+j*i+" ");
}
System.out.println();
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DtnyODGE-1692209509636)(%E7%AC%94%E8%AE%B0.assets/image-20230721182140812.png)]
9>画三角形
//中间没空
package javaText;
public class javaText_triangle {
public static void main(String[] args) {
int number = 5;
for (int i = 1; i <= number; i++) {
for (int j = 0; j < (2*number - 1)/2-i+1; j++) {
System.out.print(" ");
}
for (int j = 0; j < 2*i - 1; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
//中间有空
package javaText;
public class javaText_triangle {
public static void main(String[] args) {
int number = 5;
for (int i = 1; i <= number; i++) {
for (int j = 0; j < (2*number - 1)/2-i+1; j++) {
System.out.print(" ");
}
for (int j = 0; j < 2*i - 1; j++) {
System.out.print(j % 2 == 1? " ":"*");
}
System.out.println();
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SYFulSRk-1692209509636)(%E7%AC%94%E8%AE%B0.assets/image-20230721183138275.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iDtvVBqx-1692209509636)(%E7%AC%94%E8%AE%B0.assets/image-20230721183442741.png)]
10>终极考验！！！模拟双色球
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dJCONTfN-1692209509636)(%E7%AC%94%E8%AE%B0.assets/image-20230723175326830.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YbBm6TE9-1692209509636)(%E7%AC%94%E8%AE%B0.assets/image-20230723181126610.png)]
package javaText;
import java.util.Random;
import java.util.Scanner;
public class javaText_beg {
public static void main(String[] args) {
int betnumber[] = betFirst();
System.out.println("您投注的号码是：");
printArray(betnumber);
System.out.println();
int luckNumber[] = createLuckNumber();
System.out.println("幸运号码是：");
printArray(luckNumber);
areYouLucky(betnumber,luckNumber);
}
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.print("]");
}
public static int[] betFirst() { // 投注程序
int beg[] = new int[7]; // 设置一个整形数组，容纳投注的七个数据
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 6; i++) {
while (true) { // 创造死循环，结合判断是否可以投注，最后用break步出
if (i == 0) { // 第一个数据不需要判断重复，只需要在区间内就可以加入数组
System.out.println("请您投注第1个红球号码");
int number = sc.nextInt();
// 为了先判断是否可以加入，创建一个中间变量，先做判断
if (number < 1 || number > 33) {
System.out.println("您当前输入的数字不在区间内，请重试");
}else {
beg[i] = number;
break;
}
}else { // 判断第二个以后的数据
System.out.println("请您投注第" + (i + 1) + "个红球号码");
int number = sc.nextInt();
if (number < 1 || number > 33) {
System.out.println("您当前输入的数字不在区间内，请重试");
} else {
if (exist(beg, i,number)) {
System.out.println("该号码重复使用，请重试");
}else {
beg[i] = number;
break;
}
}
}
}
}
while (true) { // 投注蓝球
System.out.println("请您投注最后一个蓝球号码");
int number = sc.nextInt();
if(number < 1 || number > 16){
System.out.println("您当前输入的数字不在区间内，请重试");
}else {
beg[6] = number;
break;
}
}
return beg;
}
private static boolean exist(int[] beg, int i,int number) { // 判断输入的数据在数组中是否存在（数据不能重复），若存在，就重复询问
for (int k = 0; k < i; k++) {
if (number == beg[k]) {
return true;
}
}
return false;
}
public static int[] createLuckNumber(){ // 产生幸运中奖号码
Random r = new Random();
int luckNumber[] = new int[7];
for (int i = 0; i < 6; i++) { // 产生六个红球号码
while(true){
int number = r.nextInt(33)+1;
if(i == 0){
luckNumber[0] = number;
break;
}else {
if (exist(luckNumber,i,number)) {
// 重复执行循环
}else {
luckNumber[i] = number;
break;
}
}
}
}
int number = r.nextInt(16)+1; // 产生蓝球号码
luckNumber[6] = number;
return luckNumber;
}
public static void areYouLucky(int beg[],int luckNumber[]){ // 判断是否得奖
int redCount = 0;
int blueCount = 0;
for (int i = 0; i < beg.length-1; i++) { // 红球猜中几个
for (int j = 0; j < beg.length-1; j++) {
if(beg[i] == luckNumber[j]){
redCount++;
break;
}
}
}
if(beg[6] == luckNumber[6]){ // 蓝球有没有猜中
blueCount = 1;
}
// 情况分析
if(redCount == 0 && blueCount == 1){
System.out.println("恭喜您中了六等奖，获得5元");
}else if (redCount == 1 && blueCount == 1) {
System.out.println("恭喜您中了六等奖，获得5元");
}else if (redCount == 2 && blueCount == 1) {
System.out.println("恭喜您中了六等奖，获得5元");
}else if (redCount == 3 && blueCount == 1) {
System.out.println("恭喜您中了五等奖，获得10元");
}else if (redCount == 4 && blueCount == 0) {
System.out.println("恭喜您中了五等奖，获得10元");
}else if (redCount == 4 && blueCount == 1) {
System.out.println("恭喜您中了四等奖，获得200元");
}else if (redCount == 5 && blueCount == 0) {
System.out.println("恭喜您中了四等奖，获得200元");
}else if (redCount == 5 && blueCount == 1) {
System.out.println("恭喜您中了三等奖，获得3000元");
}else if (redCount == 6 && blueCount == 0){
System.out.println("恭喜您中了二等奖，获得最高500万元");
}else if (redCount == 6 && blueCount == 1){
System.out.println("恭喜您中了一等奖，获得最高1000万元");
}else {
System.out.println("抱歉，您没有得奖");
}
// 不知道为啥嵌套switch不能用
// switch (redCount) {
// case 0:
// switch (blueCount) {
// case 0:
// System.out.println("抱歉，您没有中奖");
// break;
// case 1:
// System.out.println("恭喜您中了六等奖，获得5元");
// break;
// }
// case 1:
// switch (blueCount) {
// case 0:
// System.out.println("抱歉，您没有中奖");
// break;
// case 1:
// System.out.println("恭喜您中了六等奖，获得5元");
// break;
// }
// case 2:
// switch (blueCount) {
// case 0:
// System.out.println("抱歉，您没有中奖");
// break;
// case 1:
// System.out.println("恭喜您中了六等奖，获得5元");
// break;
// }
// case 3:
// switch (blueCount) {
// case 0:
// System.out.println("抱歉，您没有中奖");
// break;
// case 1:
// System.out.println("恭喜您中了五等奖，获得10元");
// break;
// }
// case 4:
// switch (blueCount) {
// case 0:
// System.out.println("恭喜您中了五等奖，获得10元");
// break;
// case 1:
// System.out.println("恭喜您中了四等奖，获得200元");
// break;
// }
// case 5:
// switch (blueCount) {
// case 0:
// System.out.println("恭喜您中了四等奖，获得200元");
// break;
// case 1:
// System.out.println("恭喜您中了三等奖，获得3000元");
// break;
// }
// case 6:
// switch (blueCount) {
// case 0:
// System.out.println("恭喜您中了二等奖，获得最高500万元");
// break;
// case 1:
// System.out.println("恭喜您中了一等奖，获得最高1000万元");
// break;
// }
// }
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N1kI5VMA-1692209509637)(%E7%AC%94%E8%AE%B0.assets/image-20230723225634969.png)]
面向对象编程（Object Oriented Programming 简称oop）
三大特征！！！！
封装，继承，多态
入门
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nBRaH40a-1692209509637)(%E7%AC%94%E8%AE%B0.assets/image-20230723231038638.png)]
//创建一个学生类
package oopDemo;
public class student {
String name;
Double chinese;
Double math;
public void studentTotalScore(){
System.out.println(name + "的总成绩是" + (chinese + math));
}
public void studentAverageScore(){
System.out.println(name + "的平均成绩是" + (chinese + math)/2.0);
}
}
//使用student类
package oopDemo;
public class studentText {
public static void main(String[] args) {
student s1 = new student();
s1.name = "波妞";
s1.chinese = 100.0;
s1.math = 100.0;
s1.studentTotalScore();
s1.studentAverageScore();
student s2 = new student();
s2.name = "波仔";
s2.chinese = 58.0;
s2.math = 100.0;
s2.studentTotalScore();
s2.studentAverageScore();
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vXjdT82i-1692209509637)(%E7%AC%94%E8%AE%B0.assets/image-20230723231811939.png)]
定义
开发一个一个的对象，把数据交给对象，在调用对象的方法来完成对数据的处理
面向对象编程的好处
符合人类的思维习惯，编程更简单，更直观
程序中的对象到底指的是什么
对象本质上是一种特殊的数据结构
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u2Iu10Xd-1692209509637)(%E7%AC%94%E8%AE%B0.assets/image-20230723232539888.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UYV2yS7D-1692209509638)(%E7%AC%94%E8%AE%B0.assets/image-20230723232546124.png)]
对象是怎么出来的？
class也就是类，也称为对象的设计图（或者对象的模板）。
对象是用类new出来的，有了类就可以创建出对象。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5H2ieUOd-1692209509638)(%E7%AC%94%E8%AE%B0.assets/image-20230723233057739.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vbUpmSwc-1692209509638)(%E7%AC%94%E8%AE%B0.assets/image-20230726001935728.png)]
类和对象的注意事项
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rh6b5aOA-1692209509638)(%E7%AC%94%E8%AE%B0.assets/image-20230724215209046.png)]
基础语法
this关键字
定义
this就是一个变量，可以用在方法中，来拿到当前对象。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HzsgwZUb-1692209509638)(%E7%AC%94%E8%AE%B0.assets/image-20230724220706014.png)]
this只是拿到当前变量的信息，即当前变量的地址。
应用场景
this主要是用来解决变量名称冲突问题的。
package oopDemo;
public class thisDemo {
int score;
public void printThis(){ // 打印地址
System.out.println(this);
}
public void printScore(Double score){
if(score < this.score){ // 这里的this。score指的就是最上面的score变量
System.out.println("您考上了TYUT");
}else {
System.out.println("落选了~~");
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RrsID9kZ-1692209509639)(%E7%AC%94%E8%AE%B0.assets/image-20230724221749475.png)]
！！！
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QxiyXhFn-1692209509639)(%E7%AC%94%E8%AE%B0.assets/image-20230724221953678.png)]
构造器
认识（基本格式）
public class Student{
// 无参数构造器
public Student(){
...
}
// 有参数构造器
public Student(String name, Doouble score){
...
}
}
特点
创建对象时，对象会去调用构造器
Student s1 = new student();
常见应用场景
创建对象时，同时完成对对象成员变量（属性）的初始化赋值。
构造器的注意事项
1>类在设计时，如果不写构造器，Java会自动生成一个无参构造器。
2>一旦定义了有参数构造器，Java就不会帮我们的类自动生成午餐构造器了，此时就建议自己手写一个无参数构造器出来了。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eijCllfz-1692209509639)(%E7%AC%94%E8%AE%B0.assets/image-20230724223956797.png)]
封装！！！！（三大特征之一）
定义
再用类设计对象处理某一个事物的数据时，应该要把要处理的数据，以及处理这些数据的方法，涉及到一个对象中去。
设计规范
合理隐藏（private），合理暴露（public）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6JdqUUB7-1692209509639)(%E7%AC%94%E8%AE%B0.assets/image-20230724225239279.png)]
实体类JavaBean
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cXf7CCD0-1692209509639)(%E7%AC%94%E8%AE%B0.assets/image-20230724230939467.png)]
局部变量和成员变量的区别
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r3wy0rDe-1692209509640)(%E7%AC%94%E8%AE%B0.assets/image-20230726003124990.png)]
案例（电影简单管理系统）
我目前认为面向对象编程分为三大模块（信息端，后端，用户端）
class（信息端）是一个设计的模板，表示我们填入的信息需要些什么，只需要什么
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xZe1Mku6-1692209509640)(%E7%AC%94%E8%AE%B0.assets/image-20230726001402532.png)]、
// 创建一个信息储存平台
package oopDemo;
public class movieDemo {
private int id;
private String name;
private Double price;
private Double score;
private String director;
private String actor;
private String info;
public movieDemo() {
}
public movieDemo(int id, String name, Double price, Double score, String director, String actor, String info) {
this.id = id;
this.name = name;
this.price = price;
this.score = score;
this.director = director;
this.actor = actor;
this.info = info;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Double getPrice() {
return price;
}
public void setPrice(Double price) {
this.price = price;
}
public Double getScore() {
return score;
}
public void setScore(Double score) {
this.score = score;
}
public String getDirector() {
return director;
}
public void setDirector(String director) {
this.director = director;
}
public String getActor() {
return actor;
}
public void setActor(String actor) {
this.actor = actor;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
// 创建一个后端控制平台
package oopDemo;
public class movieOperator {
private movieDemo[] movies;
public movieOperator(movieDemo[] movies){
this.movies = movies;
}
public void printAllMovie(){
System.out.println("----------电影信息如下----------");
for (int i = 0; i < movies.length; i++) {
movieDemo m = movies[i];
System.out.println("编号:" + m.getId());
System.out.println("电影名称:" + m.getName());
System.out.println("价格:" + m.getPrice());
System.out.println("得分:" + m.getScore());
System.out.println("导演:" + m.getDirector());
System.out.println("演员列表:" + m.getActor());
System.out.println(m.getInfo());
System.out.println("-----------------------------");
}
}
public void printMovieId(int id){
for (int i = 0; i < movies.length; i++) {
movieDemo m = movies[i];
if(id == m.getId()){
System.out.println("-------电影详情如下-------");
System.out.println("电影名称:" + m.getName());
System.out.println("价格:" + m.getPrice());
System.out.println("得分:" + m.getScore());
System.out.println("导演:" + m.getDirector());
System.out.println("演员列表:" + m.getActor());
System.out.println(m.getInfo());
System.out.println("---------------------");
return;
}
}
System.out.println("没有该电影信息");
}
}
// 创建一个服务端用户平台
package oopDemo;
import java.util.Scanner;
public class movieText {
public static void main(String[] args) {
movieDemo[] movies = new movieDemo[2];
movies[0] = new movieDemo(1,"满江红",38.8,6.6,"徐峥","大佐","3.3万人想看");
movies[1] = new movieDemo(2,"流浪地球",38.8,9.9,"吴京","吴京","13.3万人想看");
movieOperator operator = new movieOperator(movies);
// operator.printAllMovie();
// operator.printMovieId(2);
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("--------电影信息系统--------");
System.out.println("如果您想查询所有电影信息请按1");
System.out.println("如果想查找电影请按2");
int number = sc.nextInt();
switch (number){
case 1:
operator.printAllMovie();
break;
case 2:
System.out.println("请输入您想查找的电影编号");
int id = sc.nextInt();
operator.printMovieId(id);
default:
System.out.println("您输入的命令有问题，请重试");
}
}
}
}
包
定义
包是用来分门别类的管理各种不同程序的，类似于文件夹，建包有利于程序的管理和维护。
语法格式
package JavaDemo;
public class Student {
}
在自己程序中调用其他包下的程序的注意事项
1>如果当前程序中，要调用自己所在包下的其他程序，可以直接调用。（同一个包下的类，互相可以直接调用）
2>如果当前程序中，要调用其他包下的程序，则必须在当前程序中导包，才可以访问！
导包格式：
import 包名.类名；
3>如果当前程序中，要调用Java提供的程序，也需要先导包才可以正常使用；但是Java. Lang包下的程序时不需要我们导包的，可以直接使用。
4>如果当前程序中，要调用多个不同包下的程序，而这些程序名正好一样，此时默认只能导入一个程序，另一个程序必须带包名访问。
常用API
String（字符串）
java.Lang.String
String创建对象封装字符串数据的方式
方式一
Java程序中的所有字符串文字（例如"ABC"）都为此类的对象
String name = "波妞"
String schoolName = "TYUT"
方式二
调用String类型的构造器初始化字符串对象。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2VAUiSPl-1692209509640)(%E7%AC%94%E8%AE%B0.assets/image-20230726173605160.png)]
常用的处理字符串的方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hguQicdw-1692209509640)(%E7%AC%94%E8%AE%B0.assets/image-20230726174153748.png)]
注意
substring中填写的数据是包前不包后的。
String的注意事项
1>String对象的内容不可改变，被称为不可改变字符串对象
2>只要是以下方式写出的字符串对象，会储存到字符串常量池，且相同内容的字符串只储存一份。(我认为直接赋值的，字符串储存的地址相同，同改共改)
String name = "TYUT";
String name1 = "TYUT";
System.out.println(name == name1);
// ture
3>通过new方式创建字符串对象，每new一次都会产生一个新的对象放在堆内存中。(我认为间接赋值的，字符串内容相同，但存放地址不同)
char[] chars = {"a","b","c"};
String a1 = new String(chars);
String a2 = new String(chars);
System.out.peintln(a1 == a2);
// false
案例
完成用户登陆
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LIxi09Ml-1692209509641)(%E7%AC%94%E8%AE%B0.assets/image-20230726214325784.png)]
//类似数据库，信息储存端
package StringDemo;
public class LoginSystem {
// 直接把登录信息保存在数据库，保证用户的直接交互
private String name = "itheima";
private String password = "123456";
public LoginSystem() {
}
public LoginSystem(String name, String password) {
this.name = name;
this.password = password;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
// 控制端
package StringDemo;
import java.util.Scanner;
public class LoginSystemOperator {
private LoginSystem Login;
public LoginSystemOperator(){
this.Login = Login;
}
//直接使用方法把方法投射在控制台中
public void LoginSystem(){
LoginSystem l = new LoginSystem();
System.out.println("------登陆系统------");
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 3; i++) {
System.out.println("请输入账号：");
String name = sc.next();
System.out.println("请输入密码：");
String passwprd = sc.next();
if(name.equals(l.getName())){
if (passwprd.equals(l.getPassword())){
System.out.println("欢迎进入系统");
return;
}else {
System.out.println("您的账户或者密码错误");
System.out.println("您还有"+(2-i)+"次登录机会");
}
}else{
System.out.println("您的账户或者密码错误");
System.out.println("您还有"+(2-i)+"次登录机会");
}
if (i == 2){
System.out.println("请30秒后再试");
return;
}
}
}
}
//
package StringDemo;
public class LoginSystemText {
public static void main(String[] args) {
LoginSystemOperator m = new LoginSystemOperator();
m.LoginSystem();
}
}
验证码的反馈
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J9fkde2x-1692209509641)(%E7%AC%94%E8%AE%B0.assets/image-20230727232059804.png)]
package StringDemo;
import java.util.Random;
import java.util.Scanner;
public class createCode_get_set {
public static void main(String[] args) {
while(true) {
String number1 = code(4);
System.out.println("生成的验证码是：" + number1);
System.out.println("请输入验证码");
Scanner sc = new Scanner(System.in);
String number = sc.next();
if (number.equalsIgnoreCase(number1)) {
System.out.println("---成功进入系统---");
break;
} else {
System.out.println("输入错误，请重试");
}
}
}
public static String code(int n){
String ch = "";
Random r =new Random();
for (int i = 1; i <=n; i++) {
int number = r.nextInt(3);
switch (number){
case 0://数字
ch += r.nextInt(10);
break;
case 1://大写字母
ch += (char) (r.nextInt(26) + 65);
break;
case 2://小写字母
ch += (char) (r.nextInt(26) + 97);
break;
}
}
return ch;
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n7e2seU8-1692209509641)(%E7%AC%94%E8%AE%B0.assets/image-20230727232048443.png)]
Array List（集合）
java.Util.ArrayList
集合是一种容器，用来装数据的，类似于数组。
为什么需要集合
1>数组定义完并启动后，长度就会固定。
2>集合大小可变，开发中用的更多。
常用方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LTIIgpB5-1692209509641)(%E7%AC%94%E8%AE%B0.assets/image-20230730002407787.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z6i2M7YG-1692209509641)(%E7%AC%94%E8%AE%B0.assets/image-20230730233403923.png)]
案例
从容器中找出某些特定的数据并删除
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u0JpL9YN-1692209509642)(%E7%AC%94%E8%AE%B0.assets/image-20230731234057486.png)]
package arrayLIstDemo;
import java.util.ArrayList;
public class delete_gouqi {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Java入门");
list.add("宁夏枸杞");
list.add("黑枸杞");
list.add("人字拖");
list.add("特级枸杞");
list.add("枸杞子");
// 看看数据有没有存进去
System.out.println(list);
// 倒着遍历可以很好的解决数据自动填充的问题
for (int i = list.size()-1; i >= 0; i--) {
String lis = list.get(i);
if(lis.contains("枸杞")){
list.remove(lis);
}
}
System.out.println(list);
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UE3JXCvW-1692209509642)(%E7%AC%94%E8%AE%B0.assets/image-20230731234852251.png)]
菜品的上架和浏览
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b46rL8zm-1692209509642)(%E7%AC%94%E8%AE%B0.assets/image-20230801001707101.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eTmt9g69-1692209509642)(%E7%AC%94%E8%AE%B0.assets/image-20230801001723137.png)]
帮助
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4jRUAm7h-1692209509642)(%E7%AC%94%E8%AE%B0.assets/image-20230731235019220.png)]
前期总结案例！！！！
ATM
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-znt5fyiy-1692209509643)(%E7%AC%94%E8%AE%B0.assets/image-20230802172152929.png)]
// 测试类 text
package TotalDemo_ATM;
public class text {
public static void main(String[] args) {
AccountOperator Operator = new AccountOperator();
Operator.Start();
}
}
// 账户类
package TotalDemo_ATM;
public class Account {
private String name;
private String passWord;
private String gender;
private Double balance = 0.0;
private Double limit_balance;
private String AccountNumber;
public Account() {
}
public Account(String name, String passWord, String gender, Double balance, Double limit_balance, String accountNumber) {
this.name = name;
this.passWord = passWord;
this.gender = gender;
this.balance = balance;
this.limit_balance = limit_balance;
AccountNumber = accountNumber;
}
public String getAccountNumber() {
return AccountNumber;
}
public void setAccountNumber(String accountNumber) {
AccountNumber = accountNumber;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassWord() {
return passWord;
}
public void setPassWord(String passWord) {
this.passWord = passWord;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public Double getBalance() {
return balance;
}
public void setBalance(Double balance) {
this.balance = balance;
}
public Double getLimit_balance() {
return limit_balance;
}
public void setLimit_balance(Double limit_balance) {
this.limit_balance = limit_balance;
}
}
// ATM类
package TotalDemo_ATM;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
public class AccountOperator {
private ArrayList<Account> AccountList = new ArrayList<>();
// 开户程序
public void openAccount(){
Account a1 = new Account();
System.out.println("------欢迎进入开户系统------");
Scanner sc = new Scanner(System.in);
// 账户
System.out.println("------请输入您的账户名------");
String name = sc.next();
// 密码
while (true) {
System.out.println("------请输入您的密码(六位纯数字)------");
String passWord = sc.next();
int length = passWord.length();
if(length != 6){
System.out.println("------您输入的号码位数不是六位，请重新输入------");
}else {
System.out.println("------请重新确认您的密码------");
String passWord1 = sc.next();
int length1 = passWord1.length();
if(length1 != 6){
System.out.println("------您输入的号码位数不是六位，请重新输入------");
}else {
if(passWord.equals(passWord1)) {
a1.setPassWord(passWord);
break;
}else {
System.out.println("------密码前后不一致，请重新输入------");
}
}
}
}
// 性别
Boolean key = true;
while (key) {
System.out.println("------请输入您的性别(男或女)------");
String gender = sc.next();
switch (gender) {
case "男":
a1.setName(name + "先生");
a1.setGender(gender);
key = false;
break;
case "女":
a1.setName(name + "女士");
a1.setGender(gender);
key = false;
break;
default:
System.out.println("------您的性别输入错误，请重试------");
}
}
// 额度
while (true) {
System.out.println("------请输入该账户单次取出额度------");
Double limitBalance = sc.nextDouble();
if(limitBalance <= 1000){
System.out.println("------该额度过低，请重新输入------");
}else {
a1.setLimit_balance(limitBalance);
break;
}
}
System.out.println("------该账户开户成功------");
// 随机创建一个卡号，给到用户
String AccountNumber = "";
Random r = new Random();
Boolean out = true;
// 判断集合中的元素有没有相同的卡号，如果有就重新随机一个新卡号
while (out) {
for (int i = 0; i < 6; i++) {
int RandomNumber = r.nextInt(10);
AccountNumber += RandomNumber;
}
int numb = AccountList.size();
if(AccountList.size() == 0){
out = false;
continue;
}
for (int i = 0; i < numb; i++) {
Account a2 = AccountList.get(i);
String num = a2.getAccountNumber();
if(AccountNumber.equals(num)){
break;
}
if(i == AccountList.size()-1){
out = false;
}
}
}
a1.setAccountNumber(AccountNumber);
System.out.println("账户卡号为：" + a1.getAccountNumber());
AccountList.add(a1);
}
public void loginAccount(){
int number = AccountList.size();
if(number == 0){
System.out.println("------当前系统中没有任何账户，请重试------");
return;
}else {
while (true) {
System.out.println("------请输入您的卡号------");
Scanner sc = new Scanner(System.in);
String Number = sc.next();
for (int i = 0; i < number; i++) {
Account a = AccountList.get(i);
String AccountNumber = a.getAccountNumber();
if (AccountNumber.equals(Number)){
System.out.println("------登陆成功------");
Operator(Number);
}
if(i == number-1){
System.out.println("------您输入的卡号有误，请重试------");
}
}
}
}
}
private void Operator(String Number) {
while (true) {
System.out.println("------欢迎使用ATM机，请选择您要办理的业务------");
System.out.println("1、查询账户信息");
System.out.println("2、存款");
System.out.println("3、取款");
System.out.println("4、转账");
System.out.println("5、修改密码");
System.out.println("6、退出");
System.out.println("7、注销账户");
Scanner sc = new Scanner(System.in);
int method = sc.nextInt();
switch (method){
case 1:
basicInformation(Number);
break;
case 2:
deposit(Number);
break;
case 3:
getBalance(Number);
break;
case 4:
transAccount(Number);
break;
case 5:
changePasswprd(Number);
break;
case 6:
Start();
case 7:
quitAccount(Number);
Start();
break;
default:
System.out.println("------命令有误，请重新输入------");
}
}
}
private void transAccount(String Number) {
int number = AccountList.size();
if(number < 2){
System.out.println("------当前暂不支持转账，请联系工作人员处理------");
return;
}
for (int i = 0; i < number; i++) {
Account a = AccountList.get(i);
String AccountNumber = a.getAccountNumber();
if (AccountNumber.equals(Number)) {
Double mon = a.getBalance();
while (true) {
System.out.println("您当前的存款为：" + mon);
Scanner sc = new Scanner(System.in);
System.out.println("请输入您要转账的卡号");
String number3 = sc.next();
for (int j = 0; j < number; j++) {
Account b = AccountList.get(j);
String number4 = b.getAccountNumber();
if (number3.equals(number4)) {
System.out.println("请问您要转账多少元");
int getmon = sc.nextInt();
if(getmon > mon){
System.out.println("您现在存款没有这么多可以转账");
continue;
}
System.out.println("转账成功");
a.setBalance(mon - getmon);
System.out.println("您当前存款为：" + a.getBalance());
}
}
}
}
}
}
private void quitAccount(String Number) {
int number = AccountList.size();
for (int i = 0; i < number; i++) {
Account a = AccountList.get(i);
String AccountNumber = a.getAccountNumber();
if (AccountNumber.equals(Number)){
System.out.println("------请问您真的要注销账户吗(y/n)------");
Scanner sc = new Scanner(System.in);
String ch = sc.next();
switch (ch){
case "y":
AccountList.remove(i);
System.out.println("您的账户注销成功");
case "n":
return;
}
}
}
}
private void changePasswprd(String Number) {
int number = AccountList.size();
for (int i = 0; i < number; i++) {
Account a = AccountList.get(i);
String AccountNumber = a.getAccountNumber();
if (AccountNumber.equals(Number)){
System.out.println("请输入您的初始密码");
Scanner sc = new Scanner(System.in);
String passW = sc.next();
if(passW.equals(a.getPassWord())){
while (true) {
System.out.println("------请输入您的更改后密码(六位纯数字)------");
String newPassWord = sc.next();
int length = newPassWord.length();
if(length != 6){
System.out.println("------您输入的号码位数不是六位，请重新输入------");
}else {
System.out.println("------请重新确认您的密码------");
String passWord2 = sc.next();
int length1 = passWord2.length();
if(length1 != 6){
System.out.println("------您输入的密码不一致，请重新输入------");
}else {
if(passWord2.equals(newPassWord)) {
a.setPassWord(newPassWord);
System.out.println("修改成功");
break;
}else {
System.out.println("------密码前后不一致，请重新输入------");
}
}
}
}
}
}
}
}
private void getBalance(String Number) {
int number = AccountList.size();
for (int i = 0; i < number; i++) {
Account a = AccountList.get(i);
String AccountNumber = a.getAccountNumber();
if (AccountNumber.equals(Number)){
Double mon = a.getBalance();
while (true) {
System.out.println("您当前的存款为：" + mon);
if(mon == 0){
System.out.println("您当前没有存款，请进行其他服务");
return;
}
System.out.println("请问您要取出多少");
Scanner sc = new Scanner(System.in);
int getmon = sc.nextInt();
Double limitmon = a.getLimit_balance();
if(limitmon < getmon){
System.out.println("您超过了单次取出限制");
continue;
}
if(getmon > mon){
System.out.println("您现在存款没有这么多可以取用");
continue;
}
System.out.println("取款成功");
a.setBalance(mon - getmon);
System.out.println("您当前存款为：" + a.getBalance());
break;
}
}
}
}
private void deposit(String Number) {
int number = AccountList.size();
for (int i = 0; i < number; i++) {
Account a1 = AccountList.get(i);
String AccountNumber = a1.getAccountNumber();
if (AccountNumber.equals(Number)){
// 现实生活中， 点钞机会提供数据
System.out.println("------请输入您要存多少------");
// 模拟点钞机返回金额
Scanner sc = new Scanner(System.in);
Double money = sc.nextDouble();
Double nowBalance = a1.getBalance();
a1.setBalance(money+nowBalance);
System.out.println("您当前的存款数为：" + a1.getBalance());
}
}
}
public void basicInformation(String Number){
int number = AccountList.size();
for (int i = 0; i < number; i++) {
Account a = AccountList.get(i);
String AccountNumber = a.getAccountNumber();
if (AccountNumber.equals(Number)){
System.out.println("------账户信息------");
System.out.println("卡号:" + a.getAccountNumber());
System.out.println("用户名:" + a.getName());
System.out.println("性别:" + a.getGender());
System.out.println("余额:" + a.getBalance());
System.out.println("单次取出额度:" + a.getLimit_balance());
System.out.println("-------------------");
return;
}
}
}
public void Start(){
while (true) {
System.out.println("------欢迎使用ATM机，请选择您要办理的业务------");
System.out.println("1、登录账户");
System.out.println("2、开户");
System.out.println("3、检查所有账户");
System.out.println("4、退出");
Scanner sc = new Scanner(System.in);
int key = sc.nextInt();
switch (key){
case 1:
loginAccount();
break;
case 2:
openAccount();
break;
case 3:
printAllAccount();
break;
case 4:
quitnow();
break;
default:
System.out.println("指令错误，请重试");
}
}
}
private void printAllAccount() {
int number = AccountList.size();
for (int i = 0; i < number; i++) {
Account a = AccountList.get(i);
System.out.println("------账户信息------");
System.out.println("卡号:" + a.getAccountNumber());
System.out.println("用户名:" + a.getName());
System.out.println("性别:" + a.getGender());
System.out.println("余额:" + a.getBalance());
System.out.println("单次取出额度:" + a.getLimit_balance());
System.out.println("-------------------");
}
return;
}
public void quitnow(){
return;
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BnmnKqlc-1692209509643)(%E7%AC%94%E8%AE%B0.assets/image-20230802172417987.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w4S1yDhX-1692209509643)(%E7%AC%94%E8%AE%B0.assets/image-20230802172433265.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DoqqQJiI-1692209509643)(%E7%AC%94%E8%AE%B0.assets/image-20230802172521426.png)]
高级面向对象编程
static(静态)
可以修饰成员变量，成员方法
成员变量按照有无static修饰，分为两种：
1>类变量
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EUhlv48t-1692209509644)(%E7%AC%94%E8%AE%B0.assets/image-20230802231409524.png)]
2>实例变量（对象的变量）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yRzuQylR-1692209509644)(%E7%AC%94%E8%AE%B0.assets/image-20230802231419805.png)]
public class Student {
static String name;// 类变量
// 有static修饰，属于类，在计算机内存中只会存储一份，会被类的全部对象共享。只能存一份数据.
int age; // 实例变量
// 实例变量，属于每个对象，可以有多个对象同时存在，比如说s1.name,s2.name.
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2cCw9Q0v-1692209509644)(%E7%AC%94%E8%AE%B0.assets/image-20230802230015901.png)]
类变量的应用场景
应用场景
在开发中，如果莫格数据只需要一份，且希望能被共享、访问、修改，则该数据就可以定义成类变量来记住。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MVCEOxAE-1692209509644)(%E7%AC%94%E8%AE%B0.assets/image-20230802232557428.png)]
// 创建成员类，记录保存static方法的变量
package static_or_not;
public class number_plusPlus {
public static int number;
public number_plusPlus() {
number++;
}
}
package static_or_not;
// 使用成员类方法调用，验证static特性
public class text {
public static void main(String[] args) {
number_plusPlus n1 = new number_plusPlus();
number_plusPlus n2 = new number_plusPlus();
number_plusPlus n3 = new number_plusPlus();
number_plusPlus n4 = new number_plusPlus();
System.out.println("当前一共有" + number_plusPlus.number + "个对象");
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oRzetJqv-1692209509644)(%E7%AC%94%E8%AE%B0.assets/image-20230802232542339.png)]
注意
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-maWFbQLk-1692209509645)(%E7%AC%94%E8%AE%B0.assets/image-20230802232704454.png)]
成员方法的分类
类方法
有static修饰的方法，属于类。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S1f0mma4-1692209509645)(%E7%AC%94%E8%AE%B0.assets/image-20230802232925920.png)]
成员方法
无static修饰的成员方法，属于对象。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xEyrQOzO-1692209509645)(%E7%AC%94%E8%AE%B0.assets/image-20230802232954688.png)]
类方法的常见应用场景
应用场景
类方法最常见的应用场景是做工具类
工具类
工具类中的方法都是一些类方法，每个方法都是用来完成一个功能的，工具类是给开发人员共同使用的。
提高了代码的复用性，调用方便，提高了开发效率
// static一个类方法来 调用随机生成验证码。
package javaText;
import java.util.Random;
import java.util.Scanner;
public class javaText_createCode {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请问需要一个几位的验证码");
int n = sc.nextInt();
System.out.println("生成的验证码是：" + code(4));
}
public static String code(int n){
String ch = "";
Random r =new Random();
for (int i = 1; i <=n; i++) {
int number = r.nextInt(3);
switch (number){
case 0://数字
ch += r.nextInt(10);
break;
case 1://大写字母
ch += (char) (r.nextInt(26) + 65);
break;
case 2://小写字母
ch += (char) (r.nextInt(26) + 97);
break;
}
}
return ch;
}
}
// 在另外一个类中,只需要调用该方法就可以随机生成一个六位数验证码
createCode.code(6);
// 生成验证码
注意
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8jn355wM-1692209509645)(%E7%AC%94%E8%AE%B0.assets/image-20230802234907187.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8xJ1eCTX-1692209509646)(%E7%AC%94%E8%AE%B0.assets/image-20230802234946217.png)]
static的注意事项
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mZGHSlcA-1692209509646)(%E7%AC%94%E8%AE%B0.assets/image-20230802235712948.png)]
代码块
简述
代码块是类的五大成分之一（成员变量、构造器、方法、代码块、内部类）。
代码块分为两种
静态代码块
格式
static{};
特点
类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次。
作用
完成类的初始化，例如：对类变量的初始化赋值
实例代码块
格式
{};
特点
每次创建对象时，执行实例代码块，并在构造器前执行。
作用
完成对象的初始化。例如： 完成对实例对象的初始化赋值。
单例设计模式
什么是设计模式
定义
一个问题通常有n中解法，其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。
设计模式有20中，对应20多种软件开发中会遇到的问题
单例设计模式
确保一个类只有一个对象
写法
1>把类的构造器私有
2>定义一个类变量记住类的一个对象
3>定义一个类方法，返回对象。
饿汉式单例模式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OpKCTGgo-1692209509646)(%E7%AC%94%E8%AE%B0.assets/image-20230803003135778.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XOVBkgE4-1692209509646)(%E7%AC%94%E8%AE%B0.assets/image-20230803003144510.png)]
private static A a = new A();
private A(){
}
public static A getObiect{
return a;
}
懒汉式单例模式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g557RAvR-1692209509646)(%E7%AC%94%E8%AE%B0.assets/image-20230803003054372.png)]
private static A a;
private A(){
}
public static A getObiect{
if(a == null){
a = new A();
}
return a;
}
继承（三大特征之二）
定义
java中提供了一个关键字extends，用这个关键字，可以让一个类和另一个类建立起父子关系。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KFpvKjps-1692209509647)(%E7%AC%94%E8%AE%B0.assets/image-20230803230246879.png)]
特点
子类能继承父类的非私有成员（成员变量、成员方法）
继承后对象的创建
子类的对象由子类和父类共同完成的。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SJI3Gvwy-1692209509647)(%E7%AC%94%E8%AE%B0.assets/image-20230804225220801.png)]
使用继承的好处
减少重复代码的编写
继承的注意事项
权限修饰符
就是用来限制类中的成员，（成员变量，成员方法，构造器，代码块…）能够访问的权限
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QafY6KQX-1692209509647)(%E7%AC%94%E8%AE%B0.assets/image-20230804231000685.png)]
单继承
java中只支持单继承，即一个孩子只能有一个爸爸，但是支持多层继承，即，儿子有爸爸，爸爸有爷爷，子子孙孙无穷匮也。
Object类
Object类是所有类的祖宗类，我们写的任何一个类，其实都是Object的子类或者子孙类。
方法重写
当子类觉得父类的某个方法不好用时，或者无法满足自己的需求是，子类可以重写一个方法名称，参数列表一样的方法，去覆盖掉父类的这个方法，这就是方法重写
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-27d2xICP-1692209509647)(%E7%AC%94%E8%AE%B0.assets/image-20230804234226812.png)]
注意
方法的访问，遵循就近原则。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-drt4lhUy-1692209509647)(%E7%AC%94%E8%AE%B0.assets/image-20230804234347789.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-23fMw3o7-1692209509648)(%E7%AC%94%E8%AE%B0.assets/image-20230804235712128.png)]
子类中访问其他成员的特点
牢记就近原则
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V3PIFJBR-1692209509648)(%E7%AC%94%E8%AE%B0.assets/image-20230804235903204.png)]
super（访问超类）
super.name直接访问父类的name变量
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kK9H70ZY-1692209509648)(%E7%AC%94%E8%AE%B0.assets/image-20230805000050338.png)]
子类构造器的特点
子类的全部构造器，都会优先调用父类的构造器，在执行自己的构造器
package static_or_not;
class A {
public A() {
System.out.println("父类执行了");
}
}
class B extends A {
public B() {
System.out.println("子类执行了");
}
}
public class text1 {
public static void main(String[] args) {
B b = new B();
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xEVjCmxJ-1692209509648)(%E7%AC%94%E8%AE%B0.assets/image-20230805000654180.png)]
this调用兄弟构造器
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-30HEYWZc-1692209509649)(%E7%AC%94%E8%AE%B0.assets/image-20230805001821667.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QkrLVqi8-1692209509649)(%E7%AC%94%E8%AE%B0.assets/image-20230805001810450.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BB1zv8gb-1692209509649)(%E7%AC%94%E8%AE%B0.assets/image-20230805001911108.png)]
多态（三大特征之三）
定义
多态是在继承\实现情况下的一种现象，称为：对象多态，行为多态
多态的具体代码体现
（编译看左边，运行看右边）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GsTAkSts-1692209509649)(%E7%AC%94%E8%AE%B0.assets/image-20230805232106173.png)]
多态的前提
1>有继承/实现关系
2>存在父类引用子类对象
3>存在方法重写
注意
多态是对象、行为的多态，Java中的属性（成员变量）不谈多态。
使用多态的好处
1>在多态形式下，右边对象是解耦合的，更便于拓展和维护。
2>定义方法时，使用父类类型的形参，可以接受一切子类对象，扩展性更强，更便利
使用多态的坏处（可以使用类型转换避免）
多态情况下不能调用子类的独有功能
多态的类型转换
自动类型转换
父类 变量名 = new 子类();// people p = new Student();
强制类型转换
子类 变量名 = new 子类();// Student t = (Student) p;
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WYybnEKx-1692209509649)(%E7%AC%94%E8%AE%B0.assets/image-20230805233703082.png)]
final关键字
final是最终的意思，可以修饰（类，方法，变量）。
修饰类
该类会被称为最终类，特点是不能被继承了。
修饰方法
该方法会被称为最终方法，特点是不能被重写了。
修饰变量
该变量只能被赋值一次。
注意[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Umd19WSg-1692209509650)(%E7%AC%94%E8%AE%B0.assets/image-20230805235142378.png)]
常量
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WnsZgwQ3-1692209509650)(%E7%AC%94%E8%AE%B0.assets/image-20230806000213742.png)]
抽象类（abstract关键字（抽象））
抽象类好比是一个模板，一切的一切都要来让子类实现，父类只提供一个期望，比如，父类希望孩子学习，孩子就会有学习这种方法，孩子学习，不论学的好与坏，都是学习，这就是抽象类的意义。
抽象类&&抽象方法（）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3walB0ME-1692209509650)(%E7%AC%94%E8%AE%B0.assets/image-20230806000348046.png)]
注意
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PPBKXigC-1692209509650)(%E7%AC%94%E8%AE%B0.assets/image-20230806000932123.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qVVAu6aV-1692209509650)(%E7%AC%94%E8%AE%B0.assets/image-20230806001521973.png)]
模板方法设计模式
解决方法中存在重复代码的问题
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PDOl6fvh-1692209509651)(%E7%AC%94%E8%AE%B0.assets/image-20230806002620258.png)]
写法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-itca3omo-1692209509651)(%E7%AC%94%E8%AE%B0.assets/image-20230806002649649.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vYUSqPRl-1692209509651)(%E7%AC%94%E8%AE%B0.assets/image-20230806002716648.png)]
接口
认识接口
java提供了一个关键字interface，用这个关键字我们可以定义一个特殊的结构：接口。
代码展示
public interface 接口名{
// 成员变量(常量)
// 成员方法(抽象方法)
}
实现类（名词）
接口不能创建对象；接口是用来被类实现(implements)的，实现接口的类被称为实现类。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9qMkkYgi-1692209509651)(%E7%AC%94%E8%AE%B0.assets/image-20230807000726800.png)]
注意
一个类可以实现多个接口（接口可以被理解成是干爹），实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则实现类需要定义成抽象类
使用接口的好处
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K8PEHd0f-1692209509651)(%E7%AC%94%E8%AE%B0.assets/image-20230807001005738.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nin2CLG6-1692209509652)(%E7%AC%94%E8%AE%B0.assets/image-20230807001709734.png)]
JDK 8 之后新增的接口方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7iPXooka-1692209509652)(%E7%AC%94%E8%AE%B0.assets/image-20230807003659808.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UIpSkuBw-1692209509652)(%E7%AC%94%E8%AE%B0.assets/image-20230807003739751.png)]
注意
接口是可以多继承的
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OWQTeIR3-1692209509652)(%E7%AC%94%E8%AE%B0.assets/image-20230807004546549.png)]
内部类
概述
内部类是类中的五大成分之一（成员变量，方法，构造器，内部类，代码块），如果一个类定义在另一个类的内部，那么这个类就是内部类。
应用场景
如果一个类的内部，包含了一个完整的事物，且这个事物没有必要单独设计时，就可以把这个事物设计成内部类。
内部类的四种形式
成员内部类
定义
成员内部类就是类中的一个普通成员，类似于前面学过的成员方法和成员类
创建对象的格式
外部类名.内部类名 对象名 = new 外部类().new 内部类()；
outer.inner in = new outer().new inner();
代码
// text
package inner_class;
public class text {
public static void main(String[] args) {
outer.inner in = new outer().new inner();
in.text();
}
}
// outer&&inner
package inner_class;
public class outer {
private int age = 99;
public class inner{
private int age = 88;
private String name;
public static String go; // JDK 16 开始支持
public void text(){
int age = 66;
System.out.println(age);
System.out.println(this.age);
System.out.println(outer.this.age);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
}
成员内部类中访问其他成员的特点
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z7CqbnBP-1692209509653)(%E7%AC%94%E8%AE%B0.assets/image-20230809000535409.png)]
System.out.println(age);
System.out.println(this.age);
System.out.println(outer.this.age);
JDK 16 之后才可以在成员内部类中定义静态变量。
静态内部类
定义
有static修饰的内部类，属于外部类自己持有。
创建对象的格式
外部类名.内部类名 对象名 = new 外部类.内部类()；
outer.inner in = new outer.inner();
代码
// text
package inner_class.d2;
public class text {
public static void main(String[] args) {
outer.inner in = new outer.inner();
in.text();
}
}
// outer&&inner
package inner_class.d2;
public class outer {
private int age;
static String school;
public static class inner{
private String name;
private static int a;
public void text(){
System.out.println(school);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
}
静态内部类访问其他成员的特点
可以直接访问外部类的静态成员，不可以直接访问外部类的实例成员（实例成员属于对象，访问格式为：对象.实例成员）
局部内部类
定义
局部内部类时定义在方法中、代码块中、构造器等执行体中。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qiWmyxgz-1692209509653)(%E7%AC%94%E8%AE%B0.assets/image-20230809002648647.png)]
匿名内部类！！！
定义
就是一种特殊的局部内部类；所谓匿名，就是程序员不需要为这个类生命名字。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MmifoDxb-1692209509653)(%E7%AC%94%E8%AE%B0.assets/image-20230809002844149.png)]
代码
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bqys3s87-1692209509653)(%E7%AC%94%E8%AE%B0.assets/image-20230809003505946.png)]
简化
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kf28916U-1692209509653)(%E7%AC%94%E8%AE%B0.assets/image-20230809004702668.png)]
特点
匿名内部类本质上就是一个子类，并会立即创建出一个子类对象。
作用
用于更方便的创建一个子类对象。
常见使用场景
通常作为一个参数传输给方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gTfVf6Cq-1692209509654)(%E7%AC%94%E8%AE%B0.assets/image-20230809004011326.png)]
枚举
定义
枚举是一种特殊的类
枚举类的格式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-77UnEgb4-1692209509654)(%E7%AC%94%E8%AE%B0.assets/image-20230809004849570.png)]
特点
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t2IomRNp-1692209509654)(%E7%AC%94%E8%AE%B0.assets/image-20230809232801625.png)]
抽象枚举
当前枚举类中的抽象方法需要在枚举对象中直接重写
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KRCOocmb-1692209509654)(%E7%AC%94%E8%AE%B0.assets/image-20230809233543025.png)]
应用场景（信息的分类和标志）
用来表示一组信息，然后作为参数进行传输。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TmlQ73z3-1692209509654)(%E7%AC%94%E8%AE%B0.assets/image-20230810000111082.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Cfk1eCRf-1692209509655)(%E7%AC%94%E8%AE%B0.assets/image-20230810000042843.png)]
泛型
定义类、接口、方法时，同时声明了一个或多个类型变量（如：），被称为泛型类，泛型接口，泛型方法他们被称为泛型。例如：Array List
泛型不支持基本数据类型，只支持引用数据类型
作用
提供了在编译阶段约束所能操作的数据类型，并自动进行检查的能力！这样可以避免强制类型转换，及可能出现的异常。
本质
把具体的数据类型作为参数传给类型变量
泛型类
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tlxCR7M7-1692209509655)(%E7%AC%94%E8%AE%B0.assets/image-20230810001448010.png)]
泛型接口
定义
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ELky8FFy-1692209509655)(%E7%AC%94%E8%AE%B0.assets/image-20230810002939078.png)]
基本使用
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UdOPs1TQ-1692209509655)(%E7%AC%94%E8%AE%B0.assets/image-20230810002832397.png)]
泛型方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CwpOf4fO-1692209509656)(%E7%AC%94%E8%AE%B0.assets/image-20230810003036706.png)]
？通配符
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SSEf0j2D-1692209509656)(%E7%AC%94%E8%AE%B0.assets/image-20230810003657309.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JplYuOlP-1692209509656)(%E7%AC%94%E8%AE%B0.assets/image-20230810003830565.png)]
泛型的上下限
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-afBnqUrF-1692209509656)(%E7%AC%94%E8%AE%B0.assets/image-20230810003843786.png)]
泛型擦除
泛型只在编译阶段使用，编译过后代码中泛型就不会存在了，这就是泛型擦除
API
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AP54yGTr-1692209509656)(%E7%AC%94%E8%AE%B0.assets/image-20230812001339505.png)]
Object
Object类是所有类的祖宗类，我们写的任何一个类，其实都是Object的子类或者子孙类。因此，Java中所有类的对象都可以直接使用Object类中提供的一些方法。
常见方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sotwXJG1-1692209509657)(%E7%AC%94%E8%AE%B0.assets/image-20230812001829099.png)]
toString
作用
返回对象的字符串形式
意义
方便子类重写，以便返回子类对象的内容
equals
作用
比较两个对象的地址是否相等
意义
方便子类重写，以便用于比较对象的内容是否相同
clone
作用
克隆当前对象，一创建一个一摸一样的新对象
意义
方便重写，实现浅克隆和深克隆
浅克隆
定义
拷贝出的新对象，与原本对象的数据一摸一样（引用类型拷贝的是地址）
深克隆
定义
对象中基本类型的数据直接拷贝，对象中的字符串数据拷贝的还是地址，对象中还包含的其他对象，不会拷贝地址，会创建新的对象。
Objects
Objects是一个工具类，提供了很多操作对象的静态方法来让我们使用。
常见方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-969bR8qn-1692209509657)(%E7%AC%94%E8%AE%B0.assets/image-20230812013217854.png)]
包装类
定义
把基本类型的数据包装成对象
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2ZXNHtzd-1692209509657)(%E7%AC%94%E8%AE%B0.assets/image-20230812013744064.png)]
代码&&自动装箱&&自动拆箱
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xlBXpL30-1692209509657)(%E7%AC%94%E8%AE%B0.assets/image-20230812014015414.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yLeFkHv2-1692209509657)(%E7%AC%94%E8%AE%B0.assets/image-20230812014525072.png)]
注意
在把字符串类型的变量转换为基本类型是，就可以直接使用valueof来转换类型
String intstr = "39";
int age int.valueof(intstr);
// 直接把字符串转换为整型
String scorestr = "16.6";
Double score = Double.valueof(scorestr);
//直接把字符串类型转换为浮点数
StringBulider
定义
StringBulider代表可变字符串对象，相当于是一个容器，它里面装的字符串对象是可以改变的，就是用来操作字符串的。
好处
StringBulider 比 String 更适合做字符串的修改操作，效率会更高，代码也会更简洁
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lECnhS5B-1692209509658)(%E7%AC%94%E8%AE%B0.assets/image-20230812020614711.png)]
常用代码
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dDFlYRS4-1692209509658)(%E7%AC%94%E8%AE%B0.assets/image-20230812020135582.png)]
String Buffer
注意
String Buffer 和StringBulider 的用法一摸一样。
但是StringBulider是线程不安全的，String Buffer 是线程安全的
案例
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g5f74Lbw-1692209509658)(%E7%AC%94%E8%AE%B0.assets/image-20230812222955433.png)]
package StringBuliderDemo;
public class intArray_text {
public static void main(String[] args) {
intArray text = new intArray();
int arr[] ={11,22,33};
text.setArr(arr);
System.out.println(text.getIntArray());
}
}
package StringBuliderDemo;
public class intArray {
private int[] arr;
public String getIntArray(){
StringBuilder sb = new StringBuilder();
int num = this.arr.length;
sb.append("[");
for (int i = 0; i < num; i++) {
sb.append(arr[i]);
if(i != num -1){
sb.append(", ");
}else {
sb.append("]");
}
}
String answer = sb.toString();
return answer;
}
public intArray() {
}
public intArray(int[] arr) {
this.arr = arr;
}
public int[] getArr() {
return arr;
}
public void setArr(int[] arr) {
this.arr = arr;
}
}
String Joiner
拼接数据更高效，更简洁
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OTLktqNh-1692209509658)(%E7%AC%94%E8%AE%B0.assets/image-20230812223018200.png)]
Math
定义
一个工具类，里面提供的都是对数据进行操作的一些静态方法
常见方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ixGW9iEB-1692209509658)(%E7%AC%94%E8%AE%B0.assets/image-20230812223353777.png)]
random 包前不包后
System
System代表程序所在的系统，也是一个工具类。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9nV7ewJ9-1692209509659)(%E7%AC%94%E8%AE%B0.assets/image-20230812224849902.png)]
exit
该方法中参数用作状态代码，按照惯例，非零状态代码表示异常终止。
currentTimeMillis
该方法可以返回long类型的时间毫秒值，指从1970-1-1 0：0：0 开始走到现在的总的毫秒值，1s = 1000ms
Runtime
定义
代表程序所在的运行环境
Runtime是一个单例类
常用方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ycugnukc-1692209509659)(%E7%AC%94%E8%AE%B0.assets/image-20230813004240838.png)]
destroy
关闭当前对象使用的软件搭配exec来使用
BigDecimal
意义
为了解决浮点数运算时，出现结果失真的问题。
常见方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BIR5WNwh-1692209509659)(%E7%AC%94%E8%AE%B0.assets/image-20230813005749126.png)]
代码
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4yIDAejW-1692209509659)(%E7%AC%94%E8%AE%B0.assets/image-20230813005938661.png)]
JDK8之前的传统的日期和时间
Date
代表日期和时间
常用方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8tdxkn3Y-1692209509660)(%E7%AC%94%E8%AE%B0.assets/image-20230813011358711.png)]
代码
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M1nuRNfC-1692209509660)(%E7%AC%94%E8%AE%B0.assets/image-20230813011816313.png)]
SimpleDateFormat
意义
代表简单日期格式化，可以用来吧日期对象、时间毫秒值格式化成我们想要的形式
操作格式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4BzCVkQv-1692209509660)(%E7%AC%94%E8%AE%B0.assets/image-20230813195535646.png)]
常见方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SwaX0lNE-1692209509660)(%E7%AC%94%E8%AE%B0.assets/image-20230813195517538.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yYGXLtRV-1692209509660)(%E7%AC%94%E8%AE%B0.assets/image-20230814000104668.png)]
代码
package time;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDate {
public static void main(String[] args) throws ParseException {
Date d = new Date();
System.out.println(d);
long nowtime = d.getTime();
System.out.println(nowtime/1000/1000);
SimpleDateFormat sdf = new SimpleDateFormat("yy-MM-dd");
System.out.println(sdf.format(d));
System.out.println(sdf.format(nowtime));
String sdf2 = "2023-10-20 11:22:56";
SimpleDateFormat sdf1 = new SimpleDateFormat("yy-MM-dd HH:mm:ss");
System.out.println(sdf1.parse(sdf2));
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-riT1JBqs-1692209509661)(%E7%AC%94%E8%AE%B0.assets/image-20230814001252973.png)]
一元秒杀案例
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9hC8Y5fJ-1692209509661)(%E7%AC%94%E8%AE%B0.assets/image-20230814003820200.png)]
package time;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class buy_a_ticket_to_eat_KFC {
public static void main(String[] args) throws ParseException {
String start = "2023-11-12 0:00:00";
String end = "2023-11-12 0:10:00";
String xw = "2023-11-12 0:2:13";
String xl = "2023-11-12 0:11:10";
SimpleDateFormat sdf1 = new SimpleDateFormat("yy-MM-dd HH:mm:ss");
Date dat = sdf1.parse(start);
Date dat2 = sdf1.parse(end);
Date dat3 = sdf1.parse(xw);
Date dat4 = sdf1.parse(xl);
//xw
long start1 = dat.getTime();
long end1 = dat2.getTime();
long xw1 = dat3.getTime();
long xl1 = dat4.getTime();
if(xw1 >= start1 && xw1 <= end1){
System.out.println("小王秒杀成功");
}else {
System.out.println("小王秒杀失败");
}
//xl
if(xl1 >= start1 && xl1 <= end1){
System.out.println("小李秒杀成功");
}else {
System.out.println("小李秒杀失败");
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fcSJ5skE-1692209509661)(%E7%AC%94%E8%AE%B0.assets/image-20230814003835846.png)]
Calendar
定义
代表的是系统此时时间对应的日历，通过它可以单独获取、修改时间中的年、月、日、时、分、秒等
意义
不用Calendar
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dwVIT3xB-1692209509661)(%E7%AC%94%E8%AE%B0.assets/image-20230814004107241.png)]
使用Calendar
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UQupGpSB-1692209509662)(%E7%AC%94%E8%AE%B0.assets/image-20230814004146499.png)]
常用方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mEuHsGbP-1692209509662)(%E7%AC%94%E8%AE%B0.assets/image-20230814005233174.png)]
代码
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6UDjH3cc-1692209509662)(%E7%AC%94%E8%AE%B0.assets/image-20230814010811197.png)]
注意
Calendar是一个可变对象，一旦对其修改，其本身表示的时间将产生变化
JDK8之后的新的日期和时间
新增的优点
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bA2wFsjI-1692209509662)(%E7%AC%94%E8%AE%B0.assets/image-20230814010710257.png)]
LocalDate&&LocalTime&&LocalDateTime(三者的方法基本一样)
他们三个获取对象的方式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u2VkTIHe-1692209509662)(%E7%AC%94%E8%AE%B0.assets/image-20230815171116213.png)]
LocalDate
代表本地日期（年、月、日、星期）
代码以及常用方法
package time;
import java.time.LocalDate;
public class LocalDateDemo {
public static void main(String[] args) {
// 使用now方法创建LocalDate对象
LocalDate ld = LocalDate.now();
// 得到当前对象中储存的年份
int year = ld.getYear();
//得到当前对象中储存的月份（1~12）
int month = ld.getMonthValue();
//得到当前是一个月中的第几天
int day = ld.getDayOfMonth();
//得到当前是一年中的第几天
int dayOfYear = ld.getDayOfYear();
//得到当前是星期几
int week = ld.getDayOfWeek().getValue();
System.out.println(year);
System.out.println(month);
System.out.println(day);
System.out.println(dayOfYear);
System.out.println("当前记录的是星期" + week);
// 直接修改时间 withYear withDayOfYear withDayOfMonth withMonth
LocalDate ld2 = ld.withYear(2077).withDayOfYear(277);
System.out.println(ld2);
//在某个时间点加多少 plusDays plusWeeks plusMonths plusYears
LocalDate ld3 = ld.plusDays(15).plusWeeks(1).plusMonths(2).plusYears(3);
System.out.println(ld3);
//在某个时间点减多少 minusYears minusDays minusMonths minusWeeks
LocalDate ld4 = ld.minusYears(1).minusDays(1).minusMonths(1).minusWeeks(1);
System.out.println(ld4);
//获取指定日期的LocalDate对象 public static LocalDate of(int year, Month month, int dayOfMonth)
LocalDate ld5 = LocalDate.of(2077,5,20);
System.out.println(ld5);
//判断两个日期是否相等、在前还是在后 equals isAfter isBefore
System.out.println(ld5.equals(ld3));
System.out.println(ld.isAfter(ld4));
System.out.println(ld.isBefore(ld3));
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gSqhUBJV-1692209509663)(%E7%AC%94%E8%AE%B0.assets/image-20230815184845048.png)]
LocalTime
代表本地时间（时、分、秒、纳秒）
代码以及常用方法
package time;
import java.time.LocalTime;
public class LocalTimeDemo {
public static void main(String[] args) {
// 使用now方法创建LocalDate对象
LocalTime ld = LocalTime.now(); //时、分、秒、纳秒
// 得到当前小时
int Hour = ld.getHour();
//得到第几分钟
int Minute = ld.getMinute();
//得到当前是第几分秒
int Second = ld.getSecond();
//得到当前对象表示的纳秒
int Nano = ld.getNano();
System.out.println(Hour);
System.out.println(Minute);
System.out.println(Second);
System.out.println(Nano);
// 直接修改时间 withHour withSecond withMinute withNano
LocalTime ld2 = ld.withHour(1).withSecond(1).withMinute(1).withNano(1);
System.out.println(ld2);
//在某个时间点加多少 plusHours plusMinutes plusSeconds plusNanos
LocalTime ld3 = ld.plusHours(1).plusMinutes(1).plusSeconds(1).plusNanos(1);
System.out.println(ld3);
//在某个时间点减多少 minusHours minusMinutes minusSeconds minusNanos
LocalTime ld4 = ld.minusHours(1).minusMinutes(1).minusSeconds(1).minusNanos(1);
System.out.println(ld4);
//获取指定日期的LocalDate对象 public static LocalDate of(int year, Month month, int dayOfMonth)
LocalTime ld5 = LocalTime.of(2077,5,20);
System.out.println(ld5);
//判断两个日期是否相等、在前还是在后 equals isAfter isBefore
System.out.println(ld5.equals(ld3));
System.out.println(ld.isAfter(ld4));
System.out.println(ld.isBefore(ld3));
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QeFiz457-1692209509663)(%E7%AC%94%E8%AE%B0.assets/image-20230815184826869.png)]
LocalDateTime(综合了上面两个的方法)
代表本地日期、时间（年、月、日、星期、时、分、秒、纳秒）
代码以及常用方法
package time;
import java.time.LocalDateTime;
public class LocalDateTimeDemo {
public static void main(String[] args) {
// 使用now方法创建LocalDate对象
LocalDateTime ld = LocalDateTime.now(); //时、分、秒、纳秒
// 得到当前小时
int Hour = ld.getHour();
//得到第几分钟
int Minute = ld.getMinute();
//得到当前是第几分秒
int Second = ld.getSecond();
//得到当前对象表示的纳秒
int Nano = ld.getNano();
// 得到当前对象中储存的年份
int year = ld.getYear();
//得到当前对象中储存的月份（1~12）
int month = ld.getMonthValue();
//得到当前是一个月中的第几天
int day = ld.getDayOfMonth();
//得到当前是一年中的第几天
int dayOfYear = ld.getDayOfYear();
//得到当前是星期几
int week = ld.getDayOfWeek().getValue();
System.out.println(year);
System.out.println(month);
System.out.println(day);
System.out.println(dayOfYear);
System.out.println("当前记录的是星期" + week);
System.out.println(Hour);
System.out.println(Minute);
System.out.println(Second);
System.out.println(Nano);
// 直接修改时间 withYear withDayOfYLocalDate withDayOfMonth withMonth withHour withSecond withMinute withNano
LocalDateTime ld2 = ld.withHour(1).withSecond(1).withMinute(1).withNano(1);
System.out.println(ld2);
//在某个时间点加多少 plusDays plusWeeks plusMonths plusYears plusHours plusMinutes plusSeconds plusNanos
LocalDateTime ld3 = ld.plusHours(1).plusMinutes(1).plusSeconds(1).plusNanos(1);
System.out.println(ld3);
//在某个时间点减多少 minusYears minusDays minusMonths minusWeeks minusHours minusMinutes minusSeconds minusNanos
LocalDateTime ld4 = ld.minusHours(1).minusMinutes(1).minusSeconds(1).minusNanos(1);
System.out.println(ld4);
//获取指定日期的LocalDateTime对象 public static LocalDateTime of(int year, Month month, int dayOfMonth, int hour, int minute)
LocalDateTime ld5 = LocalDateTime.of(2077,5,20,5,20);
System.out.println(ld5);
//判断两个日期是否相等、在前还是在后 equals isAfter isBefore
System.out.println(ld5.equals(ld3));
System.out.println(ld.isAfter(ld4));
System.out.println(ld.isBefore(ld3));
//LocalDateTime直接转换成LocalDte 和 LocalTime 对象 toLocalDate toLocalTime
LocalDate ld6 = ld.toLocalDate();
LocalTime ld7 = ld.toLocalTime();
System.out.println(ld6);
System.out.println(ld7);
//将LocalDte 和 LocalTime 对象转换成LocalDateTime对象
LocalDateTime ld8 = LocalDateTime.of(ld6,ld7);
System.out.println(ld8);
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-77LWDdzx-1692209509663)(%E7%AC%94%E8%AE%B0.assets/image-20230815184807412.png)]
ZoneId&&zonedDateTime
ZoneId
ZonedDateTime
常用方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EF7GMjcv-1692209509663)(%E7%AC%94%E8%AE%B0.assets/image-20230815185923521.png)]
Instant（瞬间）
时间线上的某个时刻/时间戳
意义
通过获取instant的对象可以拿到此刻的时间，该时间由两部分组成：从1970-01-01 00：00：00开始走到此刻的总秒数 + 不够1秒的纳秒数
常用方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SKLpGAJV-1692209509664)(%E7%AC%94%E8%AE%B0.assets/image-20230815190835210.png)]
代码
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2bZuOIuU-1692209509664)(%E7%AC%94%E8%AE%B0.assets/image-20230815192711125.png)]
作用
可以用来记录代码的执行时间，或用于记录用户操作的某个时间的时间点
DateTimeFormatter(格式化器)
用于时间的格式化和解析
常见方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U1KNLtuW-1692209509664)(%E7%AC%94%E8%AE%B0.assets/image-20230815220623457.png)]
代码
package time;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
class DateTimeFormatterDemo {
public static void main(String[] args) {
DateTimeFormatter daf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// 时间格式化
LocalDateTime ldt = LocalDateTime.now();
System.out.println(ldt);
String str = daf.format(ldt);// 正向格式化
System.out.println(str);
String str1 = ldt.format(daf); // 反向格式化
System.out.println(str1);
// 解析时间 一般使用LocalDateTime 的解析方法来解析时间
String sdf2 = "2023-10-20 11:22:56";
LocalDateTime ldt2 = LocalDateTime.parse(sdf2, daf);
System.out.println(ldt2);
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lMA7GZts-1692209509664)(%E7%AC%94%E8%AE%B0.assets/image-20230815223106776.png)]
LocalDateTime格式化方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UTPeBVTT-1692209509664)(%E7%AC%94%E8%AE%B0.assets/image-20230815221132916.png)]
period（一段时期）
可以用于计算两个LocalDate对象相差的年数、月数、天数
常用方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DmhafHLR-1692209509665)(%E7%AC%94%E8%AE%B0.assets/image-20230815223308666.png)]
代码
package time;
import java.time.LocalDate;
import java.time.Period;
public class periodDemo {
public static void main(String[] args) {
LocalDate ld = LocalDate.of(2077,5,20);
LocalDate ld2 = LocalDate.of(2077,5,21);
// 创建period 对象
Period period = Period.between(ld,ld2);
// 得到间隔数
System.out.println(period.getYears());
System.out.println(period.getMonths());
System.out.println(period.getDays());
}
}
Duration
用于计算两个时间对象相差的天数、小时数、分数、秒数、纳秒数；支持LocalTime , LocalDateTime, instant等时间。
常见方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T9Kxi58P-1692209509665)(%E7%AC%94%E8%AE%B0.assets/image-20230815223716695.png)]
代码
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yiqCe4YM-1692209509665)(%E7%AC%94%E8%AE%B0.assets/image-20230815223827609.png)]
Arrays(操作数组的工具类)
常见方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ov3QkQwn-1692209509665)(%E7%AC%94%E8%AE%B0.assets/image-20230815224643606.png)]
代码
package ArraysDemo;
import java.util.Arrays;
import java.util.function.IntUnaryOperator;
public class Demo1 {
public static void main(String[] args) {
int arr[] = {10,20,30,40};
System.out.println(Arrays.toString(arr));
// 截取数组内容
int[] arr2 = Arrays.copyOfRange(arr, 1, 3);
System.out.println(Arrays.toString(arr2));
// 复制并扩容数组
int[] arr3 = Arrays.copyOf(arr, 10);
System.out.println(Arrays.toString(arr3));
// 将数组的每一个元素按照特定规则更改后返回给这个数组 使用的时候需要重写IntUnaryOperator
Arrays.setAll(arr, new IntUnaryOperator() {
@Override
public int applyAsInt(int operand) {
return arr[operand] * 2;
}
});
System.out.println(Arrays.toString(arr));
// 将数组进行排序 sort(某类型 arr[]) (默认是升序)
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8x02RWl9-1692209509666)(%E7%AC%94%E8%AE%B0.assets/image-20230815230757005.png)]
遵循的官方约定
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ulgVWoSP-1692209509666)(%E7%AC%94%E8%AE%B0.assets/image-20230815232405140.png)]
sort的对象操作
当需要排序的是一个个的对象时，我们需要使用以下的方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xSEBd7oA-1692209509666)(%E7%AC%94%E8%AE%B0.assets/image-20230815231514349.png)]
方法一
1> 实现comparable接口, 重写compareTo方法
// 测试类
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-09ogSmAk-1692209509666)(%E7%AC%94%E8%AE%B0.assets/image-20230815231701199.png)]
// 代码实现
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p18WMOPx-1692209509666)(%E7%AC%94%E8%AE%B0.assets/image-20230815231442804.png)]
改进写法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9Zgose0B-1692209509667)(%E7%AC%94%E8%AE%B0.assets/image-20230815231617331.png)]
方式二
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s6ubIskm-1692209509667)(%E7%AC%94%E8%AE%B0.assets/image-20230815231852988.png)]
参数一
arr： 需要排序的数组
参数二
comparator：比较器对象（用来制定比较规则）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7BZmxeBW-1692209509667)(%E7%AC%94%E8%AE%B0.assets/image-20230815232218131.png)]
改进写法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RzEEUDT1-1692209509667)(%E7%AC%94%E8%AE%B0.assets/image-20230815232241271.png)]
lambda表达式
描述
Lambda表达式是JDK8开始新增的语法形式
作用
用于简化匿名内部类的代码写法
格式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lj77EtWM-1692209509667)(%E7%AC%94%E8%AE%B0.assets/image-20230816234428497.png)]
注意
Lambda表达式只能简化函数式接口的匿名内部类写法
函数式接口
有且仅有一个抽象方法的接口
注意
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BGguTRnD-1692209509668)(%E7%AC%94%E8%AE%B0.assets/image-20230816235014086.png)]
Lambda表达式的省略规则
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wqqXX2Mc-1692209509668)(%E7%AC%94%E8%AE%B0.assets/image-20230816235316539.png)]
方法引用
标志性符号(:
方法引用的标志性符号 ::
静态方法的引用
格式
类名::静态方法
使用场景
如果某个Lambda表达式里只是调用一个静态方法，并且前后参数的形式一致，就可以使用静态方法引用
代码
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6IulvLBQ-1692209509668)(%E7%AC%94%E8%AE%B0.assets/image-20230817000446949.png)]
实例方法的引用
格式
类名::实例方法
使用场景
如果某个Lambda表达式里只是调用一个实例方法，并且前后参数的形式一致，就可以使用实例方法引用
代码
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E1pNdmCM-1692209509668)(%E7%AC%94%E8%AE%B0.assets/image-20230817000747978.png)]
特定类型方法的引用
格式
类名::方法
使用场景
如果某个Lambda表达式里只是调用一个实例方法，并且前面参数列表中的第一个参数是作为方法的主调，后面的所有参数都是作为该实例方法的入参的，则此时就可以使用特定类型的方法引用
代码
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3wt4Nbn7-1692209509668)(%E7%AC%94%E8%AE%B0.assets/image-20230817003613318.png)]
构造器引用
格式
类名::new
使用场景
如果某个Lambda表达式只是在创建对象，并且前后参数情况一致，就可以使用构造器引用
代码
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9XIKia45-1692209509669)(%E7%AC%94%E8%AE%B0.assets/image-20230817004629110.png)]
中期总结案例（医院挂号系统）
// 1、科室管理:新增科室,删除科室(如果有医生在,则不能删除该科室),修改科室。
// 2、医生管理:录入医生信息,以及科室信息。修改医生信息(主要是修改个人信息和科室)
// 3、坐诊信息设置:可以设置医生当天和未来6天的坐诊情况,包括上午和下午的坐诊时间段和可预约数量,系统将自动保存到该医生的坐诊信息列表中。
// 4、全部信息展示:按照科室,展示每个医生七天的坐诊情况,需要按照科室归类展示
// 5、预约功能:用户可以选择要预约的科室,医生、日期和时间段,并输入患者的个人信息,系统将自动判断该时间段是否还有预约名额,并保存预约信息。
// 6、搜索功能:用户可以输入搜索日期和时间段,系统将自动搜索未来七天内在该时间段坐诊的医生信息,并按照科室分类展示。
// 7、可以查询某个医生未来七天,病人对它的预约情况。
w();
System.out.println(ldt);
String str = daf.format(ldt);// 正向格式化
System.out.println(str);
String str1 = ldt.format(daf); // 反向格式化
System.out.println(str1);
// 解析时间 一般使用LocalDateTime 的解析方法来解析时间
String sdf2 = "2023-10-20 11:22:56";
LocalDateTime ldt2 = LocalDateTime.parse(sdf2, daf);
System.out.println(ldt2);
}
}
[外链图片转存中...(img-lMA7GZts-1692209509664)]
#### LocalDateTime格式化方法
[外链图片转存中...(img-UTPeBVTT-1692209509664)]
### period（一段时期）
可以用于计算两个LocalDate对象相差的年数、月数、天数
#### 常用方法
[外链图片转存中...(img-DmhafHLR-1692209509665)]
#### 代码
```java
package time;
import java.time.LocalDate;
import java.time.Period;
public class periodDemo {
public static void main(String[] args) {
LocalDate ld = LocalDate.of(2077,5,20);
LocalDate ld2 = LocalDate.of(2077,5,21);
// 创建period 对象
Period period = Period.between(ld,ld2);
// 得到间隔数
System.out.println(period.getYears());
System.out.println(period.getMonths());
System.out.println(period.getDays());
}
}
Duration
用于计算两个时间对象相差的天数、小时数、分数、秒数、纳秒数；支持LocalTime , LocalDateTime, instant等时间。
常见方法
[外链图片转存中…(img-T9Kxi58P-1692209509665)]
代码
[外链图片转存中…(img-yiqCe4YM-1692209509665)]
Arrays(操作数组的工具类)
常见方法
[外链图片转存中…(img-Ov3QkQwn-1692209509665)]
代码
package ArraysDemo;
import java.util.Arrays;
import java.util.function.IntUnaryOperator;
public class Demo1 {
public static void main(String[] args) {
int arr[] = {10,20,30,40};
System.out.println(Arrays.toString(arr));
// 截取数组内容
int[] arr2 = Arrays.copyOfRange(arr, 1, 3);
System.out.println(Arrays.toString(arr2));
// 复制并扩容数组
int[] arr3 = Arrays.copyOf(arr, 10);
System.out.println(Arrays.toString(arr3));
// 将数组的每一个元素按照特定规则更改后返回给这个数组 使用的时候需要重写IntUnaryOperator
Arrays.setAll(arr, new IntUnaryOperator() {
@Override
public int applyAsInt(int operand) {
return arr[operand] * 2;
}
});
System.out.println(Arrays.toString(arr));
// 将数组进行排序 sort(某类型 arr[]) (默认是升序)
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}
}
[外链图片转存中…(img-8x02RWl9-1692209509666)]
遵循的官方约定
[外链图片转存中…(img-ulgVWoSP-1692209509666)]
sort的对象操作
当需要排序的是一个个的对象时，我们需要使用以下的方法
[外链图片转存中…(img-xSEBd7oA-1692209509666)]
方法一
1> 实现comparable接口, 重写compareTo方法
// 测试类
[外链图片转存中…(img-09ogSmAk-1692209509666)]
// 代码实现
[外链图片转存中…(img-p18WMOPx-1692209509666)]
改进写法
[外链图片转存中…(img-9Zgose0B-1692209509667)]
方式二
[外链图片转存中…(img-s6ubIskm-1692209509667)]
参数一
arr： 需要排序的数组
参数二
comparator：比较器对象（用来制定比较规则）
[外链图片转存中…(img-7BZmxeBW-1692209509667)]
改进写法
[外链图片转存中…(img-RzEEUDT1-1692209509667)]
lambda表达式
描述
Lambda表达式是JDK8开始新增的语法形式
作用
用于简化匿名内部类的代码写法
格式
[外链图片转存中…(img-Lj77EtWM-1692209509667)]
注意
Lambda表达式只能简化函数式接口的匿名内部类写法
函数式接口
有且仅有一个抽象方法的接口
注意
[外链图片转存中…(img-BGguTRnD-1692209509668)]
Lambda表达式的省略规则
[外链图片转存中…(img-wqqXX2Mc-1692209509668)]
方法引用
标志性符号(:
方法引用的标志性符号 ::
静态方法的引用
格式
类名::静态方法
使用场景
如果某个Lambda表达式里只是调用一个静态方法，并且前后参数的形式一致，就可以使用静态方法引用
代码
[外链图片转存中…(img-6IulvLBQ-1692209509668)]
实例方法的引用
格式
类名::实例方法
使用场景
如果某个Lambda表达式里只是调用一个实例方法，并且前后参数的形式一致，就可以使用实例方法引用
代码
[外链图片转存中…(img-E1pNdmCM-1692209509668)]
特定类型方法的引用
格式
类名::方法
使用场景
如果某个Lambda表达式里只是调用一个实例方法，并且前面参数列表中的第一个参数是作为方法的主调，后面的所有参数都是作为该实例方法的入参的，则此时就可以使用特定类型的方法引用
代码
[外链图片转存中…(img-3wt4Nbn7-1692209509668)]
构造器引用
格式
类名::new
使用场景
如果某个Lambda表达式只是在创建对象，并且前后参数情况一致，就可以使用构造器引用
代码
[外链图片转存中…(img-9XIKia45-1692209509669)]
中期总结案例（医院挂号系统）
// 1、科室管理:新增科室,删除科室(如果有医生在,则不能删除该科室),修改科室。
// 2、医生管理:录入医生信息,以及科室信息。修改医生信息(主要是修改个人信息和科室)
// 3、坐诊信息设置:可以设置医生当天和未来6天的坐诊情况,包括上午和下午的坐诊时间段和可预约数量,系统将自动保存到该医生的坐诊信息列表中。
// 4、全部信息展示:按照科室,展示每个医生七天的坐诊情况,需要按照科室归类展示
// 5、预约功能:用户可以选择要预约的科室,医生、日期和时间段,并输入患者的个人信息,系统将自动判断该时间段是否还有预约名额,并保存预约信息。
// 6、搜索功能:用户可以输入搜索日期和时间段,系统将自动搜索未来七天内在该时间段坐诊的医生信息,并按照科室分类展示。
// 7、可以查询某个医生未来七天,病人对它的预约情况。
``
// 测试类
package TotalDemo_hospital;
public class text {
public static void main(String[] args) {
hospitalOperator hospitalOperator = new hospitalOperator();
hospitalOperator.allStart();
}
}
// 管理类，究极难上加难
package TotalDemo_hospital;
// 1、科室管理:新增科室,删除科室(如果有医生在,则不能删除该科室),修改科室。
// 2、医生管理:录入医生信息,以及科室信息。修改医生信息(主要是修改个人信息和科室)
// 3、坐诊信息设置:可以设置医生当天和未来6天的坐诊情况,包括上午和下午的坐诊时间段和可预约数量,系统将自动保存到该医生的坐诊信息列表中。
// 4、全部坐诊信息展示:按照科室,展示每个医生七天的坐诊情况,需要按照科室归类展示
// 5、预约功能:用户可以选择要预约的科室,医生、日期和时间段,并输入患者的个人信息,系统将自动判断该时间段是否还有预约名额,并保存预约信息。
// 6、搜索功能:用户可以输入搜索日期和时间段,系统将自动搜索未来七天内在该时间段坐诊的医生信息,并按照科室分类展示。
// 7、可以查询某个医生未来七天,病人对它的预约情况。
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.UUID;
public class hospitalOperator {
ArrayList<Department> department = new ArrayList<>(); // 创建一个科室类，保存所有的科室
ArrayList<Doctor> doctors = new ArrayList<>(); // 创建一个医生数组对象
Scanner sc = new Scanner(System.in); // 输入信息
public void allStart(){
while (true) {
System.out.println("欢迎进入仁爱医院，请选择您的身份");
System.out.println("1、用户");
System.out.println("2、管理");
int cmd = sc.nextInt();
switch (cmd){
case 1:
peopleStart();
break;
case 2:
start();
break;
}
}
}
// 用户操作系统
private void peopleStart() {
while (true) {
System.out.println("请选择您要进行的操作");
System.out.println("1、预约");
System.out.println("2、搜索");
System.out.println("3、查看预约情况");
System.out.println("4、退出");
int cmd = sc.nextInt();
switch (cmd){
case 1:
appointmentOperator(department);
break;
case 2:
searchOperator(department);
break;
case 3:
dorSearch(department);
break;
case 4:
return;
default:
System.out.println("系统繁忙，请重试");
break;
}
}
}
public void start(){
while (true) {
System.out.println("欢迎进入医院管理系统");
System.out.println("请选择您要使用的功能");
System.out.println("1、科室管理");
System.out.println("2、医生管理");
System.out.println("3、坐诊信息设置");
System.out.println("4、全部坐诊信息展示");
System.out.println("5、退出");
int com = sc.nextInt();
switch (com){
case 1:
deportmentOperator();
break;
case 2:
doctorOperator();
break;
case 3:
scheduleOperator();
break;
case 4:
printAllInformation(department);
break;
case 5:
return;
default:
System.out.println("指令错误，请重试");
break;
}
}
}
// 查询功能
public void dorSearch(ArrayList<Department> department){
System.out.println("请输入您要查询的科室");
Department department1 = getDepartByUser();
System.out.println("请输入您要查询的医生");
Doctor doctor = getDoctorByUser(department1);
System.out.println( doctor.getName() + "的坐诊信息如下");
getTime(doctor);
}
private void getTime(Doctor doctor) {
ArrayList<Schedule> schedules = doctor.getSchedule();
for (int i = 0; i < schedules.size(); i++) {
Schedule schedule = schedules.get(i);
LocalDate lod = schedule.getDay();
System.out.println(lod);
if(!schedule.getUpdate()){
System.out.println("未排班");
}else {
System.out.println("早上排班情况如下：");
if(!schedule.getMorning()){
System.out.println("早上的看诊时间为" + schedule.getMorDoctorBeginTime() + "-" + schedule.getMorDoctorEndTime());
System.out.println("当前预约人数/看诊人数为：" + schedule.getMorTotalAppointmentNumber() + "/" + schedule.getMorTotalVisitorNumber());
}else {
System.out.println("休息");
}
System.out.println("晚上排班情况如下：");
if(!schedule.getAfternoon()){
System.out.println("晚上的看诊时间为" + schedule.getAftDoctorBeginTime() + "-" + schedule.getAftDoctorEndTime());
System.out.println("当前预约人数/看诊人数为：" + schedule.getAftTotalAppointmentNumber() + "/" + schedule.getAftTotalVisitorNumber());
}else {
System.out.println("休息");
}
}
}
}
// 搜索功能
public void searchOperator(ArrayList<Department> department){
// 6、搜索功能:用户可以输入搜索日期和时间段,系统将自动搜索未来七天内在该时间段坐诊的医生信息,并按照科室分类展示。
// 获取当前时间，遍历之后七天
LocalDate lod = LocalDate.now();
for (int i = 0; i < 7; i++) {
System.out.println( (i+1) + "、" + lod.plusDays(i));
}
System.out.println("请选择您要搜索的日期");
// 得到用户选择的日期
int cmd = sc.nextInt()-1;
System.out.println("请选择上午还是下午");
System.out.println("1、上午");
System.out.println("2、下午");
int cmdd = sc.nextInt();
for (int i = 0; i < department.size(); i++) {
// 得到每一个科室对象
Department department1 = department.get(i);
ArrayList<Doctor> doctors = department1.getDoctor();
System.out.println(department1.getDepartmentName());
for (int i1 = 0; i1 < doctors.size(); i1++) {
// 得到每一个医生对象
Doctor doctor = doctors.get(i);
ArrayList<Schedule> schedules = doctor.getSchedule();
// 得到用户选择的那一天的时刻表
Schedule schedule = schedules.get(cmd);
if (!schedule.getUpdate()){
continue;
}
switch (cmdd){
case 1:
if(!schedule.getMorning()){
System.out.println(doctor.getName());
}
break;
case 2:
if(!schedule.getAfternoon()){
System.out.println(doctor.getName());
}
break;
}
}
System.out.println(" --------------------- ");
}
}
// 用户预约功能
public void appointmentOperator(ArrayList<Department> department){
System.out.println("请选择您要预约的科室");
Department department1 = getDepartByUser();
System.out.println("请选择您要预约的医生");
Doctor doctor = getDoctorByUser(department1);
System.out.println("请选择您要预约的日期和时间");
getTimeByUser(doctor);
}
private void getTimeByUser(Doctor doctor) {
ArrayList<Schedule> schedules = doctor.getSchedule();
for (int i = 0; i < schedules.size(); i++) {
Schedule schedule = schedules.get(i);
LocalDate lod = schedule.getDay();
System.out.println((i+1) + "、" + lod);
if(!schedule.getUpdate()){
System.out.println("未排班");
}else {
System.out.println("早上排班情况如下：");
if(!schedule.getMorning()){
System.out.println("早上的看诊时间为" + schedule.getMorDoctorBeginTime() + "-" + schedule.getMorDoctorEndTime());
System.out.println("当前预约人数/看诊人数为：" + schedule.getMorTotalAppointmentNumber() + "/" + schedule.getMorTotalVisitorNumber());
}else {
System.out.println("休息");
}
System.out.println("晚上排班情况如下：");
if(!schedule.getAfternoon()){
System.out.println("晚上的看诊时间为" + schedule.getAftDoctorBeginTime() + "-" + schedule.getAftDoctorEndTime());
System.out.println("当前预约人数/看诊人数为：" + schedule.getAftTotalAppointmentNumber() + "/" + schedule.getAftTotalVisitorNumber());
}else {
System.out.println("休息");
}
}
}
System.out.println("请输入您要选择的时间");
int cmd = sc.nextInt()-1;
Schedule schedule = schedules.get(cmd);
if(!schedule.getUpdate()){
System.out.println("该时刻医生未排班，请更换时间");
return;
}
if(!schedule.getMorning() & !schedule.getAfternoon()){
System.out.println("请选择早上还是下午");
System.out.println("1、早上 2、下午");
int cmd1 = sc.nextInt();
switch (cmd1){
case 1:
int number = schedule.getMorTotalAppointmentNumber();
number++;
schedule.setMorTotalAppointmentNumber(number);
System.out.println("请输入您的名字");
String name = sc.next();
doctor.getAppointPeople().add(name);
System.out.println("预约成功");
return;
case 2:
int number1 = schedule.getAftTotalAppointmentNumber();
number1++;
schedule.setAftTotalAppointmentNumber(number1);
System.out.println("请输入您的名字");
String name1 = sc.next();
doctor.getAppointPeople().add(name1);
System.out.println("预约成功");
}
}else if (!schedule.getAfternoon()){
int number1 = schedule.getAftTotalAppointmentNumber();
number1++;
schedule.setAftTotalAppointmentNumber(number1);
System.out.println("请输入您的名字");
String name = sc.next();
doctor.getAppointPeople().add(name);
System.out.println("预约成功");
}else if (!schedule.getMorning()) {
int number = schedule.getMorTotalAppointmentNumber();
number++;
schedule.setMorTotalAppointmentNumber(number);
System.out.println("请输入您的名字");
String name = sc.next();
doctor.getAppointPeople().add(name);
System.out.println("预约成功");
}else {
System.out.println("当前时间医生休息，请更换医生");
}
}
// 全部坐诊信息展示
public void printAllInformation(ArrayList<Department> department){
for (int i = 0; i < department.size(); i++) {
// 打印科室名
System.out.println( (i + 1) + "、" + department.get(i).getDepartmentName());
// 拿到医生数组信息
ArrayList<Doctor> doctors = department.get(i).getDoctor();
// 打印医生坐诊情况
for (int i1 = 0; i1 < doctors.size(); i1++) {
// 拿到医生信息
Doctor doctor = doctors.get(i1);
// 输出医生名字
System.out.println( (i1+1) + "、" + doctor.getName());
// 更新一下医生的排班时刻表
updateSchedule(doctor.getSchedule());
// 得到医生时刻表数组对象
ArrayList<Schedule> schedules = doctor.getSchedule();
for (int i2 = 0; i2 < schedules.size(); i2++) {
// 得到医生时刻表
Schedule schedule1 = schedules.get(i2);
LocalDate lod = schedule1.getDay();
System.out.println(lod + "的排班情况如下");
if(!schedule1.getUpdate()){
System.out.println("未排班");
}else {
System.out.println("早上排班情况如下：");
if(!schedule1.getMorning()){
System.out.println("早上的看诊时间为" + schedule1.getMorDoctorBeginTime() + "-" + schedule1.getMorDoctorEndTime());
System.out.println("当前预约人数/看诊人数为：" + schedule1.getMorTotalAppointmentNumber() + "/" + schedule1.getMorTotalVisitorNumber());
}else {
System.out.println("休息");
}
System.out.println("晚上排班情况如下：");
if(!schedule1.getAfternoon()){
System.out.println("晚上的看诊时间为" + schedule1.getAftDoctorBeginTime() + "-" + schedule1.getAftDoctorEndTime());
System.out.println("当前预约人数/看诊人数为：" + schedule1.getAftTotalAppointmentNumber() + "/" + schedule1.getAftTotalVisitorNumber());
}else {
System.out.println("休息");
}
}
}
}
}
}
// 坐诊信息管理
public void scheduleOperator(){
if(department.size() == 0){
System.out.println("系统暂无科室信息，请录入科室信息后重试");
return;
}
// 选择科室
Department department1 = getDepartByUser();
// 选择医生
ArrayList<Doctor> doctors = department1.getDoctor();
if(doctors.size() == 0) {
System.out.println("当前科室下无医生");
return;
}
Doctor doctor1 = getDoctorByUser(department1);
// 更改时刻表
// 得到医生对象的时间表
ArrayList<Schedule> schedule1 = doctor1.getSchedule();
// 更新医生的坐诊时间
updateSchedule(schedule1);
// 修改医生的坐诊情况
for (int i = 0; i < schedule1.size(); i++) {
Schedule schedule = schedule1.get(i);
updateDoctorSchedule(schedule);
}
}
private void updateDoctorSchedule(Schedule schedule) {
LocalDate lod = schedule.getDay();
System.out.println(lod + "的排班情况如下");
if(!schedule.getUpdate()){
System.out.println("未排班");
}else {
System.out.println("早上排班情况如下：");
if(!schedule.getMorning()){
System.out.println("早上的看诊时间为" + schedule.getMorDoctorBeginTime() + "-" + schedule.getMorDoctorEndTime());
System.out.println("当前预约人数/看诊人数为：" + schedule.getMorTotalAppointmentNumber() + "/" + schedule.getMorTotalVisitorNumber());
}else {
System.out.println("休息");
}
System.out.println("晚上排班情况如下：");
if(!schedule.getAfternoon()){
System.out.println("晚上的看诊时间为" + schedule.getAftDoctorBeginTime() + "-" + schedule.getAftDoctorEndTime());
System.out.println("当前预约人数/看诊人数为：" + schedule.getAftTotalAppointmentNumber() + "/" + schedule.getAftTotalVisitorNumber());
}else {
System.out.println("休息");
}
}
System.out.println("是否修改信息（y/n）");
String cmd = sc.next();
switch (cmd){
case "y":
schedule.setUpdate(true);
System.out.println("请问是否在早上排班(y/n)");
String cmdd= sc.next();
switch (cmdd){
case "y":
schedule.setMorning(false);
// 早上开始看诊的时间
System.out.println("请设置开始看诊的时间");
String MorBeaginTime = sc.next();
schedule.setMorDoctorBeginTime(LocalTime.parse(MorBeaginTime));
// 结束看诊的时间
System.out.println("请设置结束的时间");
String MorEndTime = sc.next();
schedule.setMorDoctorEndTime(LocalTime.parse(MorEndTime));
// 总的可预约人数
System.out.println("请设置总预约人数");
int visitor = sc.nextInt();
schedule.setMorTotalVisitorNumber(visitor);
break;
case "n":
schedule.setMorning(true);
break;
}
System.out.println("请问下午是否排班(y/n)");
String cmddd = sc.next();
switch (cmddd){
case "y":
schedule.setAfternoon(false);
// 早上开始看诊的时间
System.out.println("请设置开始看诊的时间");
String AftBeaginTime = sc.next();
schedule.setAftDoctorBeginTime(LocalTime.parse(AftBeaginTime));
// 结束看诊的时间
System.out.println("请设置结束的时间");
String AftEndTime = sc.next();
schedule.setAftDoctorEndTime(LocalTime.parse(AftEndTime));
// 总的可预约人数
System.out.println("请设置总预约人数");
int visitor = sc.nextInt();
schedule.setAftTotalVisitorNumber(visitor);
break;
case "n":
schedule.setAfternoon(true);
break;
}
}
}
// 更新坐诊时间表（更新到自今天起后六天）
private void updateSchedule(ArrayList<Schedule> schedule1) {
// 当前医生没有坐诊信息，对坐诊信息初始化
if(schedule1.size() == 0){
for (int i = 0; i < 7; i++) {
Schedule schedule = new Schedule();
LocalDate lod = LocalDate.now();
schedule.setDay(lod.plusDays(i));
schedule1.add(schedule);
}
return;
}
// 更新当前医生的坐诊时间
//1、去除过期的时间
// ！！注意：去除过去时间之后数组内部的元素个数会同步减少
for (int i = 0; i < schedule1.size(); i++) {
Schedule schedule = schedule1.get(i);
LocalDate lod = LocalDate.now();
LocalDate current = schedule.getDay();
if(current.equals(lod)){
break;
}
if(current.isBefore(lod)){
// ！！注意：remove会删除数组内元素，并且使之后的元素序号全部向前移动一位
schedule1.remove(i);
i--;
}
}
// 更新之后七天的时间，只需要更新新的时间就可以了
// 得到最后一天的时间
LocalDate endTime = schedule1.get(schedule1.size()-1).getDay();
int number = schedule1.size();
for (int i = 0; i < 7 - number; i++) {
Schedule schedule = new Schedule();
schedule.setDay(endTime.plusDays(i + 1));
schedule1.add(schedule);
}
}
// 医生管理
public void doctorOperator(){
// 判断当前有没有科室，没有科室需要先创建科室
if (department.size() == 0){
System.out.println("系统无科室信息，请录入科室后再尝试操作");
return;
}
while (true) {
System.out.println("欢迎进入医生管理系统");
System.out.println("请选择您要进行的功能");
System.out.println("1：录入医生信息");
System.out.println("2：删除医生信息");
System.out.println("3：修改医生信息");
System.out.println("4：退出");
int com = sc.nextInt();
switch (com){
case 1:
addDoctor();
break;
case 2:
deleteDoctor();
break;
case 3:
changeDoctor();
break;
case 4:
return;
default:
System.out.println("您输入的指令有误，请重试");
break;
}
}
}
private void changeDoctor() {
if(doctors.size() == 0){
System.out.println("请您录入医生信息后重试");
return;
}
System.out.println("请输入医生所属的科室名");
String nowDepartName = sc.next();
for (int i = 0; i < department.size(); i++) {
String departName = department.get(i).getDepartmentName();
if(nowDepartName.equals(departName)){
ArrayList<Doctor> doctors = department.get(i).getDoctor();
System.out.println("请选择需要修改信息的医生");
// 遍历科室所属医生
for (int i1 = 0; i1 < doctors.size(); i1++) {
System.out.println("1、" + doctors.get(i).getName());
}
// 得到需要修改的医生对象
int docCom = sc.nextInt() -1;
if(docCom < 1|| docCom > doctors.size()){
System.out.println("指令输入错误，请重新输入");
return;
}
Doctor doctor = doctors.get(docCom);
while (true) {
System.out.println("请选择您要修改的信息 ");
System.out.println("1、医生名字");
System.out.println("2、医生性别");
System.out.println("3、医生所属科室");
System.out.println("4、医生年龄");
System.out.println("5、医生擅长治疗方向");
System.out.println("6、退出");
int com = sc.nextInt();
switch (com){
case 1:
System.out.println("请输入修改后的名字");
doctor.setName(sc.next());
System.out.println("修改成功");
break;
case 2:
System.out.println("请输入修改后的性别");
doctor.setGender(sc.next());
System.out.println("修改成功");
break;
case 3:
// 遍历所有科室名
for (int i1 = 0; i1 < department.size(); i1++) {
System.out.println((i + 1) + "、" + department.get(i).getDepartmentName());
}
System.out.println("请选择要更改的科室");
ArrayList<Doctor> doctors1 = department.get(sc.nextInt() - 1).getDoctor();
doctors1.add(doctor);
doctors.remove(doctor);
System.out.println("科室更改完成");
break;
case 4:
System.out.println("请输入修改后年龄");
doctor.setAge(sc.nextInt());
System.out.println("修改成功");
break;
case 5:
System.out.println("请输入修改后治疗方向");
doctor.setSkill(sc.next());
System.out.println("修改成功");
break;
case 6:
return;
default:
System.out.println("指令输入错误，请重试");
break;
}
}
}
}
}
private void deleteDoctor() {
if(doctors.size() == 0){
System.out.println("请您先录入医生后重试");
return;
}
System.out.println("请输入您要删除的医生编号");
String ID = sc.next();
for (int i = 0; i < doctors.size(); i++) {
String Id = doctors.get(i).getDoctorId();
if(ID.equals(Id)){
// 把医生从科室里面删除
Doctor doc = doctors.get(i);
for (int i1 = 0; i1 < department.size(); i1++) {
if(department.get(i1).getDepartmentName().equals(doc.getDepartmentName())){
for (int i2 = 0; i2 < department.get(i1).getDoctor().size(); i2++) {
Doctor doctor = department.get(i1).getDoctor().get(i2);
if (doctor.getDoctorId().equals(ID)){
department.get(i1).getDoctor().remove(i2);
}
}
}
}
// 在医生数组中把医生删除
doctors.remove(i);
System.out.println("医生信息删除成功");
return;
}
}
System.out.println("ID错误，请重试");
}
// 添加医生
private void addDoctor() {
// 1、找见科室
System.out.println("新增医生");
Doctor doctor = new Doctor();
OUT:
while (true) {
System.out.println("请选择该医生要加入的科室");
for (int i = 0; i < department.size(); i++) {
Department de = department.get(i);
System.out.println((i + 1) + "、" + de.getDepartmentName());
}
int com = sc.nextInt();
if(com < 1 || com > department.size()){
System.out.println("您输入的指令错误，请重试");
continue OUT;
}
Department de1 = department.get(com-1);
// 将该医生所在的科室名加入
doctor.setDepartmentName(de1.getDepartmentName());
// 使用UUID工具类随机一个ID
doctor.setDoctorId(UUID.randomUUID().toString());
System.out.println("请输入医生的名字");
doctor.setName(sc.next());
System.out.println("请输入医生的性别");
doctor.setGender(sc.next());
System.out.println("请输入医生的年龄");
doctor.setAge(sc.nextInt());
System.out.println("请输入医生的擅长方向");
doctor.setSkill(sc.next());
// 入职时间
System.out.println("请输入医生的入职时间（格式： yyyy-MM-dd）");
LocalDate jointimeee = LocalDate.parse(sc.next());
doctor.setJoinTime(jointimeee);
// 把医生信息加入全部医生中
doctors.add(doctor);
// 把医生对象加入到所属的科室类中
de1.getDoctor().add(doctor);
break ;
}
}
// 科室管理
public void deportmentOperator(){
while (true) {
System.out.println("欢迎进入科室管理系统");
System.out.println("请选择您要进行的功能");
System.out.println("1：新增科室");
System.out.println("2：删除科室");
System.out.println("3：修改科室信息");
System.out.println("4：退出");
int command = sc.nextInt();
switch (command){
case 1:
newDeportment(); // 新增科室
break;
case 2:
deleteDeportment(); // 删除科室
break;
case 3:
changeDeportment(); // 修改科室信息
break;
case 4:
return;
default:
System.out.println("您输入的指令有误，请重新输入");
}
}
}
// 修改科室信息
private void changeDeportment() {
int number = department.size();
System.out.println("欢迎进入科室修改系统");
if (number == 0){
System.out.println("系统无科室信息，请录入科室后再尝试操作");
return;
}
while (true){
System.out.println("请输入您要修改的科室名");
String departName = sc.next();
for (int i = 0; i < number; i++) {
Department de = department.get(i);
String departName1 = de.getDepartmentName();
if(departName.equals(departName1)){
ArrayList<Doctor> doctors = de.getDoctor(); // 获取Doctor对象，便于之后直接更改
// 修改科室信息
Boolean flag = true;
while (true) {
System.out.println("修改科室名请按1,退出请按2");
int com = sc.nextInt();
switch (com){
case 1:
System.out.println("请输入修改后的科室名");
String newDepartName = sc.next();
de.setDepartmentName(newDepartName);
System.out.println("修改成功");
break;
case 2:
return;
default:
System.out.println("输入指令错误，请重试");
break;
}
}
}else { // 匹配不成功
if(i == number -1 ){
System.out.println("您输入的科室名错误，请重试");
}
}
}
}
}
// 删除科室
private void deleteDeportment() {
int number = department.size();
if(number == 0){
System.out.println("系统无科室信息，请录入科室后再尝试操作");
return;
}
while (true) {
System.out.println("请输入需要删除的科室名");
String departName = sc.next();
for (int i = 0; i < number; i++) {
Department de = new Department();
de = department.get(i);
String departName1 = de.getDepartmentName();
if(departName.equals(departName1)){
// 删除科室，如果没有医生了就删除，有就提示并保留
ArrayList<Doctor> doctors = new ArrayList<>();
doctors = de.getDoctor();
if(doctors.size() == 0){
department.remove(i);
System.out.println("科室删除成功");
return;
}else {
System.out.println("当前科室内仍然有医生在岗，请修改后重试");
return;
}
}else{
if(i == number -1){
System.out.println("科室信息不存在,请重试");
}
}
}
}
}
// 新增科室
private void newDeportment() {
Department de = new Department();
OUT:
while (true) {
System.out.println("---新建科室---");
System.out.println("请输入科室名");
String departName = sc.next();
// 做判断，保证科室名不重复
for (int i = 0; i < department.size(); i++) {
String departName1 = department.get(i).getDepartmentName();
if(departName.equals(departName1)){
System.out.println("您输入的科室名重复，请重试");
continue OUT;
}
}
de.setDepartmentName(departName);
department.add(de); // 把新创建的科室对象加入数组中
break;
}
}
public Department getDepartByUser() {
Department department1;
while (true) {
for (int i = 0; i < department.size(); i++) {
System.out.println(i+1 + "、" + department.get(i).getDepartmentName());
}
int com = sc.nextInt()-1;
if(com < 0 || com > department.size()){
System.out.println("指令输入错误，请重新输入");
continue;
}
department1 = department.get(com);
return department1;
}
}
public Doctor getDoctorByUser(Department department) {
Doctor doctor;
while (true) {
for (int i = 0; i < department.getDoctor().size(); i++) {
System.out.println(i+1 + "、" + department.getDoctor().get(i).getName());
}
int com = sc.nextInt()-1;
if(com < 0 || com > department.getDoctor().size()){
System.out.println("指令输入错误，请重新输入");
continue;
}
doctor = department.getDoctor().get(com);
return doctor;
}
}
}
// 时刻表类
package TotalDemo_hospital;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.ArrayList;
// 时刻类
// 时刻表是基于每一个医生独有的
public class Schedule extends Doctor{
// 记录当前时间
private LocalDate day;
// 记录是否排班
private Boolean update = false;
// 今日预约信息
//早上预约情况
private Boolean morning = false; // 判断是否在早上排班
private LocalTime morDoctorBeginTime; // 早上开始看诊的时间
private LocalTime morDoctorEndTime; // 早上结束看诊的时间
private int morTotalVisitorNumber; // 早上医生总共可以接受看诊的人数 int类型在医生可以多看几个的时候可以随意增添
private int morTotalAppointmentNumber; // 早上已经预约的人数
//下午预约情况
private Boolean afternoon = false; // 判断是否在晚上排班
private LocalTime aftDoctorBeginTime; // 晚上开始看诊的时间
private LocalTime aftDoctorEndTime; // 晚上结束看诊的时间
private int aftTotalVisitorNumber; // 晚上医生总共可以接受看诊的人数 int类型在医生可以多看几个的时候可以随意增添
private int aftTotalAppointmentNumber; // 晚上已经预约的人数
public Schedule() {
}
public Schedule(LocalDate day, Boolean update, Boolean morning, LocalTime morDoctorBeginTime, LocalTime morDoctorEndTime, int morTotalVisitorNumber, int morTotalAppointmentNumber, Boolean afternoon, LocalTime aftDoctorBeginTime, LocalTime aftDoctorEndTime, int aftTotalVisitorNumber, int aftTotalAppointmentNumber) {
this.day = day;
this.update = update;
this.morning = morning;
this.morDoctorBeginTime = morDoctorBeginTime;
this.morDoctorEndTime = morDoctorEndTime;
this.morTotalVisitorNumber = morTotalVisitorNumber;
this.morTotalAppointmentNumber = morTotalAppointmentNumber;
this.afternoon = afternoon;
this.aftDoctorBeginTime = aftDoctorBeginTime;
this.aftDoctorEndTime = aftDoctorEndTime;
this.aftTotalVisitorNumber = aftTotalVisitorNumber;
this.aftTotalAppointmentNumber = aftTotalAppointmentNumber;
}
public Boolean getUpdate() {
return update;
}
public void setUpdate(Boolean update) {
this.update = update;
}
public LocalDate getDay() {
return day;
}
public void setDay(LocalDate day) {
this.day = day;
}
public Boolean getMorning() {
return morning;
}
public void setMorning(Boolean morning) {
this.morning = morning;
}
public LocalTime getMorDoctorBeginTime() {
return morDoctorBeginTime;
}
public void setMorDoctorBeginTime(LocalTime morDoctorBeginTime) {
this.morDoctorBeginTime = morDoctorBeginTime;
}
public LocalTime getMorDoctorEndTime() {
return morDoctorEndTime;
}
public void setMorDoctorEndTime(LocalTime morDoctorEndTime) {
this.morDoctorEndTime = morDoctorEndTime;
}
public int getMorTotalVisitorNumber() {
return morTotalVisitorNumber;
}
public void setMorTotalVisitorNumber(int morTotalVisitorNumber) {
this.morTotalVisitorNumber = morTotalVisitorNumber;
}
public int getMorTotalAppointmentNumber() {
return morTotalAppointmentNumber;
}
public void setMorTotalAppointmentNumber(int morTotalAppointmentNumber) {
this.morTotalAppointmentNumber = morTotalAppointmentNumber;
}
public Boolean getAfternoon() {
return afternoon;
}
public void setAfternoon(Boolean afternoon) {
this.afternoon = afternoon;
}
public LocalTime getAftDoctorBeginTime() {
return aftDoctorBeginTime;
}
public void setAftDoctorBeginTime(LocalTime aftDoctorBeginTime) {
this.aftDoctorBeginTime = aftDoctorBeginTime;
}
public LocalTime getAftDoctorEndTime() {
return aftDoctorEndTime;
}
public void setAftDoctorEndTime(LocalTime aftDoctorEndTime) {
this.aftDoctorEndTime = aftDoctorEndTime;
}
public int getAftTotalVisitorNumber() {
return aftTotalVisitorNumber;
}
public void setAftTotalVisitorNumber(int aftTotalVisitorNumber) {
this.aftTotalVisitorNumber = aftTotalVisitorNumber;
}
public int getAftTotalAppointmentNumber() {
return aftTotalAppointmentNumber;
}
public void setAftTotalAppointmentNumber(int aftTotalAppointmentNumber) {
this.aftTotalAppointmentNumber = aftTotalAppointmentNumber;
}
}
// 科室类
package TotalDemo_hospital;
import java.util.ArrayList;
// 科室类
public class Department {
private String departmentName; // 科室名
private ArrayList<Doctor> doctor = new ArrayList<>();
public Department() {
}
public Department(String departmentName, ArrayList<Doctor> doctor) {
this.departmentName = departmentName;
this.doctor = doctor;
}
public ArrayList<Doctor> getDoctor() {
return doctor;
}
public void setDoctor(ArrayList<Doctor> doctor) {
this.doctor = doctor;
}
public String getDepartmentName() {
return departmentName;
}
public void setDepartmentName(String departmentName) {
this.departmentName = departmentName;
}
}
// 预约类
package TotalDemo_hospital;
import java.time.LocalDateTime;
// 患者预约类
public class Appointment {
private String name; // 患者的名字
private String gender; // 患者的性别
private int age; // 患者的年龄
private String diseaseDesc; // 患者的病情描述
private String appointDeportmentName; // 预约的科室名
private String doctorId; // 预约的医生编号
private LocalDateTime appointTime; // 预约的时间
public Appointment() {
}
public Appointment(String name, String gender, int age, String diseaseDesc, String appointDeportmentName, String doctorId, LocalDateTime appointTime) {
this.name = name;
this.gender = gender;
this.age = age;
this.diseaseDesc = diseaseDesc;
this.appointDeportmentName = appointDeportmentName;
this.doctorId = doctorId;
this.appointTime = appointTime;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getDiseaseDesc() {
return diseaseDesc;
}
public void setDiseaseDesc(String diseaseDesc) {
this.diseaseDesc = diseaseDesc;
}
public String getAppointDeportmentName() {
return appointDeportmentName;
}
public void setAppointDeportmentName(String appointDeportmentName) {
this.appointDeportmentName = appointDeportmentName;
}
public String getDoctorId() {
return doctorId;
}
public void setDoctorId(String doctorId) {
this.doctorId = doctorId;
}
public LocalDateTime getAppointTime() {
return appointTime;
}
public void setAppointTime(LocalDateTime appointTime) {
this.appointTime = appointTime;
}
}
// 医生类
package TotalDemo_hospital;
import java.time.LocalDate;
import java.util.ArrayList;
// 医生类
public class Doctor extends Department{ // 医生属于每个科室
private String doctorId; // 医生编号
private String name; // 医生名字
private String gender; // 性别
private String DepartmentName; // 医生所属科室名
private int age; // 年龄
private String skill; // 擅长治疗方向
private LocalDate joinTime; // 入职时间
private ArrayList<Schedule> schedule = new ArrayList<>(); // 创造时刻表，表示未来七天的日程
private ArrayList<String> appointPeople = new ArrayList<>(); // 创建预约表，以便叫号
public Doctor() {
}
public ArrayList<String> getAppointPeople() {
return appointPeople;
}
public void setAppointPeople(ArrayList<String> appointPeople) {
this.appointPeople = appointPeople;
}
public ArrayList<String> getStrings() {
return appointPeople;
}
public void setStrings(ArrayList<String> strings) {
this.appointPeople = strings;
}
public ArrayList<Schedule> getSchedule() {
return schedule;
}
public void setSchedule(ArrayList<Schedule> schedule) {
this.schedule = schedule;
}
public String getDoctorId() {
return doctorId;
}
public void setDoctorId(String doctorId) {
this.doctorId = doctorId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getDepartmentName() {
return DepartmentName;
}
public void setDepartmentName(String departmentName) {
DepartmentName = departmentName;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSkill() {
return skill;
}
public void setSkill(String skill) {
this.skill = skill;
}
public LocalDate getJoinTime() {
return joinTime;
}
public void setJoinTime(LocalDate joinTime) {
this.joinTime = joinTime;
}
}