一、学生管理系统
1、需求文档
（1）需求
- 采取控制台的方式去书写学生管理系统。
（2）分析
-
初始菜单：
-----------欢迎来到奥利给学生管理系统----------- 1: 添加学生 2: 删除学生 3: 修改学生 4: 查询学生 5: 退出系统 请输入您的选择: -
学生类：
- 属性：学号、姓名、年龄、家庭住址
-
添加功能：
- 键盘录入每一个学生信息并添加，需要满足以下要求：
- 学号唯一
- 键盘录入每一个学生信息并添加，需要满足以下要求：
-
删除功能：
- 键盘录入要删除的学生学号，需要满足以下要求：
- 学号存在删除
- 学号不存在，需要提示不存在，并回到初始菜单
- 键盘录入要删除的学生学号，需要满足以下要求：
-
修改功能：
- 键盘录入要修改的学生学号，需要满足以下要求：
- 学号存在，修改学生其他信息
- 学号不存在，需要提示不存在，并回到初始菜单
- 键盘录入要修改的学生学号，需要满足以下要求：
-
查询功能：
-
打印所有的学生信息，需要满足以下要求
-
如果没有学生信息，提示：当前无学生信息，请添加后再查询
-
如果有学生信息，需要按照以下格式输出。（不用过于纠结对齐的问题）
学号 姓名 年龄 家庭住址 alg001 张三 24 北京 alg002 李四 22 广州 alg003 王五 35 南宁 alg004 赵六 66 南京
-
-
2、实现
（1）初始化菜单
package com.gxcj.test;
import java.util.Scanner;
/*
学生管理系统
测试类
*/
public class Test {
public static void main(String[] args) {
// 1、定义一个学生对象类型的集合，用于存储学生对象
ArrayList<Student> students = new ArrayList<>();
// 2、创建键盘录入对象，用于从键盘录入数据
Scanner sc = new Scanner(System.in);
// 3、初始化菜单
systemHomePage(students, sc);
}
/**
* 学生管理系统首页
*
* @param students 学生对象集合
* @param sc 键盘录入对象
*/
public static void systemHomePage(ArrayList<Student> students, Scanner sc) {
// 1、打印初始菜单页面
System.out.println("----------欢迎来到奥利给学生管理系统----------");
while (true) {
System.out.println("1: 添加学生\n2: 删除学生\n3: 修改学生\n4: 查询学生\n5: 退出系统");
System.out.println("请输入您的选择: ");
// 2、接收输入的选择
String select = sc.next();
// 3、switch判断该选择是哪个功能
switch (select) {
case "1":
// 添加学生
System.out.println("-------添加学生-------");
break;
case "2":
// 删除学生
System.out.println("-------删除学生-------");
break;
case "3":
// 修改学生
System.out.println("-------修改学生-------");
break;
case "4":
// 查询学生
System.out.println("-------查询学生-------");
break;
case "5":
// 退出系统
System.out.println("好的！已退出系统！欢迎下次登录~");
return;
default:
// 其他选择
System.out.println("该功能未开发！请敬请等候~");
break;
}
}
}
}
----------欢迎来到奥利给学生管理系统----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
1
-------添加学生-------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
2
-------删除学生-------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
3
-------修改学生-------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
4
-------查询所有学生信息-------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
6
该功能未开发！请敬请等候~
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
rt
该功能未开发！请敬请等候~
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
5
好的！已退出系统！欢迎下次登录~
Process finished with exit code 0
（2）学生类
package com.gxcj.been;
/*
学生类
*/
public class Student {
/*
标准JavaBean：
1、私有化属性
2、提供无参数构造器
3、提供有参数构造器
4、提供全套的get和set方法，暴露其属性的取值和赋值
5、重写toString方法，格式化输出对象属性值
*/
// 1、私有化学生属性：学号、姓名、年龄、家庭住址
private String id;
private String name;
private int age;
private String address;
// 2、提供无参数构造器
public Student() {
}
// 3、提供有参数构造器
public Student(String id, String name, int age, String address) {
this.id = id;
this.name = name;
this.age = age;
this.address = address;
}
// 4、提供全套的get和set方法，暴露其属性的取值和赋值
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
// 5、重写toString方法，格式化输出对象属性值
@Override
public String toString() {
return "Student{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", age=" + age +
", address='" + address + '\'' +
'}';
}
}
（3）添加、查询功能实现
package com.gxcj.test;
import com.gxcj.been.Student;
import java.util.ArrayList;
import java.util.Scanner;
/*
学生管理系统
测试类
*/
public class Test {
public static void main(String[] args) {
// 1、定义一个学生对象类型的集合，用于存储学生对象
ArrayList<Student> students = new ArrayList<>();
// 2、创建键盘录入对象，用于从键盘录入数据
Scanner sc = new Scanner(System.in);
// 3、初始化菜单
systemHomePage(students, sc);
}
/**
* 学生管理系统首页
*
* @param students 学生对象集合
* @param sc 键盘录入对象
*/
public static void systemHomePage(ArrayList<Student> students, Scanner sc) {
// 1、打印初始菜单页面
System.out.println("----------欢迎来到奥利给学生管理系统----------");
while (true) {
System.out.println("1: 添加学生\n2: 删除学生\n3: 修改学生\n4: 查询学生\n5: 退出系统");
System.out.println("请输入您的选择: ");
// 2、接收输入的选择
String select = sc.next();
// 3、switch判断该选择是哪个功能
switch (select) {
case "1":
// 添加学生
System.out.println("-------添加学生-------");
addStudents(students, sc);
break; // 跳出switch，回到首页面
case "2":
// 删除学生
System.out.println("-------删除学生-------");
break;
case "3":
// 修改学生
System.out.println("-------修改学生-------");
break;
case "4":
// 查询所有学生信息
System.out.println("-------查询所有学生信息-------");
showStudents(students);
break;
case "5":
// 退出系统
System.out.println("好的！已退出系统！欢迎下次登录~");
return;
default:
// 其他选择
System.out.println("该功能未开发！请敬请等候~");
break;
}
}
}
/**
* 查询所有学生信息
*
* @param students 学生对象集合
*/
public static void showStudents(ArrayList<Student> students) {
// 1、判断接收的值是否为null
if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return;
}
// 2、判断学生对象集合中是否存在学生
if (students.size() == 0) {
System.out.println("当前无学生信息，请添加后再查询！");
return;
}
// 3、遍历students集合，依次获取集合中每个学生对象
System.out.println("学生信息如下：");
System.out.println("\t学号\t\t\t姓名\t\t\t年龄\t\t\t家庭住址");
for (Student student : students) {
System.out.println(student.getId() + "\t\t\t"
+ student.getName() + "\t\t\t"
+ student.getAge() + "\t\t\t"
+ student.getAddress());
}
System.out.println();
}
/**
* 添加学生功能实现
*
* @param students 学生对象集合
* @param sc 键盘录入对象
*/
public static void addStudents(ArrayList<Student> students, Scanner sc) {
// 1、判断接收的值是否为null
if (students == null && sc == null) {
System.out.println("您的学生对象集合与键盘录入对象都不能为null~");
return null;
} else if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return null;
} else if (sc == null) {
System.out.println("您的键盘录入对象不能为null~");
return null;
}
// 2、添加学生
// a.录入学生学号
String id;
while (true) {
System.out.println("请您录入学生的学号：");
id = sc.next();
// 根据学号判断该学生对象是否存在于集合中
boolean flag = exist(students, id);
if (flag) {
// 存在
System.out.println("学号为" + id + "的学生已存在！请重新录入~");
} else {
// 不存在，跳出循环，可以录入学生的其他信息
break;
}
}
// b.录入学生姓名
System.out.println("请您录入学生的姓名：");
String name = sc.next();
// c.录入学生年龄
int age;
while (true) {
System.out.println("请您录入学生的年龄：");
age = sc.nextInt();
// 判断年龄是否大于等于0
if (age >= 0) {
// 不为负数，跳出循环，可以录入学生的其他信息
break;
} else {
// 为负数
System.out.println("年龄不合理！请重新录入~");
}
}
// d.录入学生家庭住址
System.out.println("请您录入学生的家庭住址：");
String address = sc.next();
// e.所有信息录入完毕，将学生信息封装成学生对象，并添加进集合中
students.add(new Student(id, name, age, address));
System.out.println(name + "同学已成功录入奥利给学生管理系统~");
// f.添加完成一个学生对象，问一下是否要继续添加下一个学生对象？
ifContinueAdd(students, sc);
}
/**
* 是否继续添加学生信息
*
* @param students 学生对象集合
* @param sc 键盘录入对象
*/
public static void ifContinueAdd(ArrayList<Student> students, Scanner sc) {
// 1、判断接收的值是否为null
if (students == null && sc == null) {
System.out.println("您的学生对象集合与键盘录入对象都不能为null~");
return;
} else if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return;
} else if (sc == null) {
System.out.println("您的键盘录入对象不能为null~");
return;
}
// 2、是否继续添加
System.out.println("您是否要继续添加学生信息？(yes/no)：");
String command = sc.next();
switch (command) {
case "yes":
// 输入的是yes，回调addStudent方法，继续添加学生信息
addStudents(students, sc);
break;
default:
// 输入的是其他指令，结束录入，返回到系统首页
System.out.println("好的！添加结束！");
break;
}
}
/**
* 根据学号查询学生对象是否存在
*
* @param students 学生对象集合
* @param id 学生学号
* @return 存在返回true，否则返回false
*/
public static boolean exist(ArrayList<Student> students, String id) {
// 1、遍历students集合，依次获取集合中每个学生对象
for (Student student : students) {
// 判断要添加的学生学号 是否匹配 当前遍历到的学生学号
if (id.equals(student.getId())) {
// 匹配，说明存在，返回true
return true;
}
}
// 2、遍历结束，仍然匹配不到相同学号的学生对象，说明不存在，返回false
return false;
}
}
----------欢迎来到奥利给学生管理系统----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
4
-------查询所有学生信息-------
当前无学生信息，请添加后再查询！
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
1
-------添加学生-------
请您录入学生的学号：
java01
请您录入学生的姓名：
张翼德
请您录入学生的年龄：
-2
年龄不合理！请重新录入~
请您录入学生的年龄：
23
请您录入学生的家庭住址：
南京
张翼德同学已成功录入奥利给学生管理系统~
您是否要继续添加学生信息？(yes/no)：
yes
请您录入学生的学号：
java01
学号为java01的学生已存在！请重新录入~
请您录入学生的学号：
java02
请您录入学生的姓名：
关云长
请您录入学生的年龄：
24
请您录入学生的家庭住址：
兖州
关云长同学已成功录入奥利给学生管理系统~
您是否要继续添加学生信息？(yes/no)：
yes
请您录入学生的学号：
java01
学号为java01的学生已存在！请重新录入~
请您录入学生的学号：
java02
学号为java02的学生已存在！请重新录入~
请您录入学生的学号：
java03
请您录入学生的姓名：
刘备
请您录入学生的年龄：
45
请您录入学生的家庭住址：
广西
刘备同学已成功录入奥利给学生管理系统~
您是否要继续添加学生信息？(yes/no)：
no
好的！添加结束！
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
4
-------查询所有学生信息-------
学生信息如下：
学号 姓名 年龄 家庭住址
java01 张翼德 23 南京
java02 关云长 24 兖州
java03 刘备 45 广西
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
5
好的！已退出系统！欢迎下次登录~
Process finished with exit code 0
（4）删除、修改功能实现
package com.gxcj.test;
import com.gxcj.been.Student;
import java.util.ArrayList;
import java.util.Scanner;
/*
学生管理系统
测试类
*/
public class Test {
public static void main(String[] args) {
// 1、定义一个学生对象类型的集合，用于存储学生对象
ArrayList<Student> students = new ArrayList<>();
// 2、创建键盘录入对象，用于从键盘录入数据
Scanner sc = new Scanner(System.in);
// 3、初始化菜单
systemHomePage(students, sc);
}
/**
* 学生管理系统首页
*
* @param students 学生对象集合
* @param sc 键盘录入对象
*/
public static void systemHomePage(ArrayList<Student> students, Scanner sc) {
// 1、打印初始菜单页面
System.out.println("----------欢迎来到奥利给学生管理系统----------");
while (true) {
System.out.println("1: 添加学生\n2: 删除学生\n3: 修改学生\n4: 查询学生\n5: 退出系统");
System.out.println("请输入您的选择: ");
// 2、接收输入的选择
String select = sc.next();
// 3、switch判断该选择是哪个功能
switch (select) {
case "1":
// 添加学生
System.out.println("-------添加学生-------");
addStudents(students, sc);
break; // 跳出switch，回到首页面
case "2":
// 删除学生
System.out.println("-------删除学生-------");
deleteStudent(students, sc);
break; // 跳出switch，回到首页面
case "3":
// 修改学生
System.out.println("-------修改学生-------");
updateStudent(students, sc);
break; // 跳出switch，回到首页面
case "4":
// 查询所有学生信息
System.out.println("-------查询所有学生信息-------");
showStudents(students);
break; // 跳出switch，回到首页面
case "5":
// 退出系统
System.out.println("好的！已退出系统！欢迎下次登录~");
return; // 结束systemHomePage方法
// System.exit(0); // 停止虚拟机运行
default:
// 其他选择
System.out.println("该功能未开发！请敬请等候~");
break; // 跳出switch，回到首页面
}
}
}
/**
* 修改学生信息功能实现：根据学号修改
*
* @param students 学生对象集合
* @param sc 键盘录入对象
*/
public static void updateStudent(ArrayList<Student> students, Scanner sc) {
// 1、判断接收的值是否为null
if (students == null && sc == null) {
System.out.println("您的学生对象集合与键盘录入对象都不能为null~");
return;
} else if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return;
} else if (sc == null) {
System.out.println("您的键盘录入对象不能为null~");
return;
}
// 2、从键盘输入要修改的学生学号
String id;
System.out.println("请您输入要修改的学生学号：");
id = sc.next();
// 判断该学生对象是否存在于集合中
boolean flag = exist(students, id);
if (flag) {
// 存在
// 则根据输入的学生学号得到该学生对象
Student student = getStudentById(students, id);
// 修改该学生的其他信息
System.out.println("请您录入该学生修改后的姓名：");
String newName = sc.next();
// 修改学生姓名
student.setName(newName);
while (true) {
System.out.println("请您录入该学生修改后的年龄：");
int newAge = sc.nextInt();
if (newAge >= 0) {
// 年龄合理，修改学生年龄
student.setAge(newAge);
System.out.println("请您录入该学生修改后的家庭住址：");
String newAddress = sc.next();
// 修改学生家庭住址
student.setAddress(newAddress);
System.out.println("学号为" + id + "的学生修改成功！");
// 问一下是否要继续进行修改操作？
ifContinueUpdate(students, sc);
break; // 跳出循环
} else {
System.out.println("年龄不合理！请重新录入~");
}
}
} else {
System.out.println("学号为" + id + "的学生不存在！修改失败！");
// 问一下是否要继续进行修改操作？
ifContinueUpdate(students, sc);
}
}
/**
* 是否继续修改学生信息
*
* @param students 学生对象集合
* @param sc 键盘录入对象
*/
public static void ifContinueUpdate(ArrayList<Student> students, Scanner sc) {
// 1、判断接收的值是否为null
if (students == null && sc == null) {
System.out.println("您的学生对象集合与键盘录入对象都不能为null~");
return;
} else if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return;
} else if (sc == null) {
System.out.println("您的键盘录入对象不能为null~");
return;
}
// 2、是否继续修改
System.out.println("您是否要继续修改学生信息？(yes/no)：");
String command = sc.next();
switch (command) {
case "yes":
// 输入的是yes，回调updateStudent方法，继续修改学生信息
updateStudent(students, sc);
break;
default:
// 输入的是其他指令，结束修改，返回到系统首页
System.out.println("好的！修改结束！");
break;
}
}
/**
* 删除学生功能实现：根据学号删除
*
* @param students 学生对象集合
* @param sc 键盘录入对象
*/
public static void deleteStudent(ArrayList<Student> students, Scanner sc) {
// 1、判断接收的值是否为null
if (students == null && sc == null) {
System.out.println("您的学生对象集合与键盘录入对象都不能为null~");
return;
} else if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return;
} else if (sc == null) {
System.out.println("您的键盘录入对象不能为null~");
return;
}
// 2、从键盘输入要删除的学生学号
String id;
System.out.println("请您输入要删除的学生学号：");
id = sc.next();
// 判断该学生对象是否存在于集合中
boolean flag = exist(students, id);
if (flag) {
// 存在
// 则根据输入的学生学号得到该学生对象
Student student = getStudentById(students, id);
// 删除该学生
students.remove(student);
System.out.println("学号为" + id + "的学生删除成功！");
// 问一下是否要继续进行删除操作？
ifContinueDelete(students, sc);
} else {
System.out.println("学号为" + id + "的学生不存在！删除失败！");
// 问一下是否要继续进行删除操作？
ifContinueDelete(students, sc);
}
}
/**
* 是否继续删除学生信息
*
* @param students 学生对象集合
* @param sc 键盘录入对象
*/
public static void ifContinueDelete(ArrayList<Student> students, Scanner sc) {
// 1、判断接收的值是否为null
if (students == null && sc == null) {
System.out.println("您的学生对象集合与键盘录入对象都不能为null~");
return;
} else if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return;
} else if (sc == null) {
System.out.println("您的键盘录入对象不能为null~");
return;
}
// 2、是否继续删除
System.out.println("您是否要继续删除学生信息？(yes/no)：");
String command = sc.next();
switch (command) {
case "yes":
// 输入的是yes，回调deleteStudent方法，继续删除学生信息
deleteStudent(students, sc);
break;
default:
// 输入的是其他指令，结束删除，返回到系统首页
System.out.println("好的！删除结束！");
break;
}
}
/**
* 根据指定学生学号查询学生对象
*
* @param students 学生对象集合
* @param id 指定学生学号
* @return 返回查询到的学生对象
*/
public static Student getStudentById(ArrayList<Student> students, String id) {
// 1、判断接收的值是否为null
if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return null;
}
// 2、遍历students，依次获取集合中每个学生对象
for (Student student : students) {
// 判断指定的学生学号 是否匹配 当前遍历到的学生对象的学号
if (id.equals(student.getId())) {
// 匹配，返回当前遍历到的学生对象
return student;
}
}
// 3、循环结束，仍然没有查询到，返回null
return null;
}
/**
* 查询所有学生信息
*
* @param students 学生对象集合
*/
public static void showStudents(ArrayList<Student> students) {
// 1、判断接收的值是否为null
if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return;
}
// 2、判断学生对象集合中是否存在学生
if (students.size() == 0) {
System.out.println("当前无学生信息，请添加后再查询！");
return;
}
// 3、遍历students集合，依次获取集合中每个学生对象
System.out.println("学生信息如下：");
System.out.println("\t学号\t\t\t姓名\t\t\t年龄\t\t\t家庭住址");
for (Student student : students) {
System.out.println(student.getId() + "\t\t\t"
+ student.getName() + "\t\t\t"
+ student.getAge() + "\t\t\t"
+ student.getAddress());
}
System.out.println();
}
/**
* 添加学生功能实现
*
* @param students 学生对象集合
* @param sc 键盘录入对象
*/
public static void addStudents(ArrayList<Student> students, Scanner sc) {
// 1、判断接收的值是否为null
if (students == null && sc == null) {
System.out.println("您的学生对象集合与键盘录入对象都不能为null~");
return;
} else if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return;
} else if (sc == null) {
System.out.println("您的键盘录入对象不能为null~");
return;
}
// 2、添加学生
// a.录入学生学号
String id;
while (true) {
System.out.println("请您录入学生的学号：");
id = sc.next();
// 根据学号判断该学生对象是否存在于集合中
boolean flag = exist(students, id);
if (flag) {
// 存在
System.out.println("学号为" + id + "的学生已存在！请重新录入~");
} else {
// 不存在，跳出循环，可以录入学生的其他信息
break;
}
}
// b.录入学生姓名
System.out.println("请您录入学生的姓名：");
String name = sc.next();
// c.录入学生年龄
int age;
while (true) {
System.out.println("请您录入学生的年龄：");
age = sc.nextInt();
// 判断年龄是否大于等于0
if (age >= 0) {
// 不为负数，跳出循环，可以录入学生的其他信息
break;
} else {
// 为负数
System.out.println("年龄不合理！请重新录入~");
}
}
// d.录入学生家庭住址
System.out.println("请您录入学生的家庭住址：");
String address = sc.next();
// e.所有信息录入完毕，将学生信息封装成学生对象，并添加进集合中
students.add(new Student(id, name, age, address));
System.out.println(name + "同学已成功录入奥利给学生管理系统~");
// f.添加完成一个学生对象，问一下是否要继续添加下一个学生对象？
ifContinueAdd(students, sc);
}
/**
* 是否继续添加学生信息
*
* @param students 学生对象集合
* @param sc 键盘录入对象
*/
public static void ifContinueAdd(ArrayList<Student> students, Scanner sc) {
// 1、判断接收的值是否为null
if (students == null && sc == null) {
System.out.println("您的学生对象集合与键盘录入对象都不能为null~");
return;
} else if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return;
} else if (sc == null) {
System.out.println("您的键盘录入对象不能为null~");
return;
}
// 2、是否继续添加
System.out.println("您是否要继续添加学生信息？(yes/no)：");
String command = sc.next();
switch (command) {
case "yes":
// 输入的是yes，回调addStudent方法，继续添加学生信息
addStudents(students, sc);
break;
default:
// 输入的是其他指令，结束录入，返回到系统首页
System.out.println("好的！添加结束！");
break;
}
}
/**
* 根据学号查询学生对象是否存在
*
* @param students 学生对象集合
* @param id 学生学号
* @return 存在返回true，否则返回false
*/
public static boolean exist(ArrayList<Student> students, String id) {
// 1、遍历students集合，依次获取集合中每个学生对象
for (Student student : students) {
// 判断要添加的学生学号 是否匹配 当前遍历到的学生学号
if (id.equals(student.getId())) {
// 匹配，说明存在，返回true
return true;
}
}
// 2、遍历结束，仍然匹配不到相同学号的学生对象，说明不存在，返回false
return false;
}
}
----------欢迎来到奥利给学生管理系统----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
4
-------查询所有学生信息-------
当前无学生信息，请添加后再查询！
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
1
-------添加学生-------
请您录入学生的学号：
alg001
请您录入学生的姓名：
张翼德
请您录入学生的年龄：
34
请您录入学生的家庭住址：
南京
张翼德同学已成功录入奥利给学生管理系统~
您是否要继续添加学生信息？(yes/no)：
yes
请您录入学生的学号：
alg001
学号为alg001的学生已存在！请重新录入~
请您录入学生的学号：
alg002
请您录入学生的姓名：
关云长
请您录入学生的年龄：
-2
年龄不合理！请重新录入~
请您录入学生的年龄：
35
请您录入学生的家庭住址：
兖州
关云长同学已成功录入奥利给学生管理系统~
您是否要继续添加学生信息？(yes/no)：
yes
请您录入学生的学号：
alg001
学号为alg001的学生已存在！请重新录入~
请您录入学生的学号：
alg002
学号为alg002的学生已存在！请重新录入~
请您录入学生的学号：
alg003
请您录入学生的姓名：
刘玄德
请您录入学生的年龄：
45
请您录入学生的家庭住址：
广州
刘玄德同学已成功录入奥利给学生管理系统~
您是否要继续添加学生信息？(yes/no)：
no
好的！添加结束！
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
4
-------查询所有学生信息-------
学生信息如下：
学号 姓名 年龄 家庭住址
alg001 张翼德 34 南京
alg002 关云长 35 兖州
alg003 刘玄德 45 广州
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
3
-------修改学生-------
请您输入要修改的学生学号：
alg004
学号为alg004的学生不存在！修改失败！
您是否要继续修改学生信息？(yes/no)：
yes
请您输入要修改的学生学号：
alg002
请您录入该学生修改后的姓名：
赵子龙
请您录入该学生修改后的年龄：
33
请您录入该学生修改后的家庭住址：
南宁
学号为alg002的学生修改成功！
您是否要继续修改学生信息？(yes/no)：
yes
请您输入要修改的学生学号：
alg002
请您录入该学生修改后的姓名：
马超
请您录入该学生修改后的年龄：
-3
年龄不合理！请重新录入~
请您录入该学生修改后的年龄：
-2
年龄不合理！请重新录入~
请您录入该学生修改后的年龄：
33
请您录入该学生修改后的家庭住址：
柳州
学号为alg002的学生修改成功！
您是否要继续修改学生信息？(yes/no)：
no
好的！修改结束！
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
4
-------查询所有学生信息-------
学生信息如下：
学号 姓名 年龄 家庭住址
alg001 张翼德 34 南京
alg002 马超 33 柳州
alg003 刘玄德 45 广州
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
2
-------删除学生-------
请您输入要删除的学生学号：
alg005
学号为alg005的学生不存在！删除失败！
您是否要继续删除学生信息？(yes/no)：
yes
请您输入要删除的学生学号：
alg003
学号为alg003的学生删除成功！
您是否要继续删除学生信息？(yes/no)：
no
好的！删除结束！
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
4
-------查询所有学生信息-------
学生信息如下：
学号 姓名 年龄 家庭住址
alg001 张翼德 34 南京
alg002 马超 33 柳州
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
5
好的！已退出系统！欢迎下次登录~
Process finished with exit code 0
（5）最终测试
package com.gxcj.test;
import com.gxcj.been.Student;
import java.util.ArrayList;
import java.util.Scanner;
/*
学生管理系统
测试类
*/
public class Test {
public static void main(String[] args) {
// 1、定义一个学生对象类型的集合，用于存储学生对象
ArrayList<Student> students = new ArrayList<>();
// 2、创建键盘录入对象，用于从键盘录入数据
Scanner sc = new Scanner(System.in);
// 3、初始化菜单
systemHomePage(students, sc);
}
/**
* 学生管理系统首页
*
* @param students 学生对象集合
* @param sc 键盘录入对象
*/
public static void systemHomePage(ArrayList<Student> students, Scanner sc) {
// 1、打印初始菜单页面
System.out.println("----------欢迎来到奥利给学生管理系统----------");
while (true) {
System.out.println("1: 添加学生\n2: 删除学生\n3: 修改学生\n4: 查询学生\n5: 退出系统");
System.out.println("请输入您的选择: ");
// 2、接收输入的选择
String select = sc.next();
// 3、switch判断该选择是哪个功能
switch (select) {
case "1":
// 添加学生
System.out.println("-------添加学生-------");
addStudents(students, sc);
break; // 跳出switch，回到首页面
case "2":
// 删除学生
System.out.println("-------删除学生-------");
deleteStudent(students, sc);
break; // 跳出switch，回到首页面
case "3":
// 修改学生
System.out.println("-------修改学生-------");
updateStudent(students, sc);
break; // 跳出switch，回到首页面
case "4":
// 查询所有学生信息
System.out.println("-------查询所有学生信息-------");
showStudents(students);
break; // 跳出switch，回到首页面
case "5":
// 退出系统
System.out.println("好的！已退出系统！欢迎下次登录~");
return; // 结束systemHomePage方法
// System.exit(0); // 停止虚拟机运行
default:
// 其他选择
System.out.println("该功能未开发！请敬请等候~");
break; // 跳出switch，回到首页面
}
}
}
/**
* 修改学生信息功能实现：根据学号修改
*
* @param students 学生对象集合
* @param sc 键盘录入对象
*/
public static void updateStudent(ArrayList<Student> students, Scanner sc) {
// 1、判断接收的值是否为null
if (students == null && sc == null) {
System.out.println("您的学生对象集合与键盘录入对象都不能为null~");
return;
} else if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return;
} else if (sc == null) {
System.out.println("您的键盘录入对象不能为null~");
return;
}
// 2、从键盘输入要修改的学生学号
String id;
System.out.println("请您输入要修改的学生学号：");
id = sc.next();
// 判断该学生对象是否存在于集合中
boolean flag = exist(students, id);
if (flag) {
// 存在
// 则根据输入的学生学号得到该学生对象
Student student = getStudentById(students, id);
// 修改该学生的其他信息
System.out.println("请您录入该学生修改后的姓名：");
String newName = sc.next();
// 修改学生姓名
student.setName(newName);
while (true) {
System.out.println("请您录入该学生修改后的年龄：");
int newAge = sc.nextInt();
if (newAge >= 0) {
// 年龄合理，修改学生年龄
student.setAge(newAge);
System.out.println("请您录入该学生修改后的家庭住址：");
String newAddress = sc.next();
// 修改学生家庭住址
student.setAddress(newAddress);
System.out.println("学号为" + id + "的学生修改成功！");
// 问一下是否要继续进行修改操作？
ifContinueUpdate(students, sc);
break; // 跳出循环
} else {
System.out.println("年龄不合理！请重新录入~");
}
}
} else {
System.out.println("学号为" + id + "的学生不存在！修改失败！");
// 问一下是否要继续进行修改操作？
ifContinueUpdate(students, sc);
}
}
/**
* 是否继续修改学生信息
*
* @param students 学生对象集合
* @param sc 键盘录入对象
*/
public static void ifContinueUpdate(ArrayList<Student> students, Scanner sc) {
// 1、判断接收的值是否为null
if (students == null && sc == null) {
System.out.println("您的学生对象集合与键盘录入对象都不能为null~");
return;
} else if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return;
} else if (sc == null) {
System.out.println("您的键盘录入对象不能为null~");
return;
}
// 2、是否继续修改
System.out.println("您是否要继续修改学生信息？(yes/no)：");
String command = sc.next();
switch (command) {
case "yes":
// 输入的是yes，回调updateStudent方法，继续修改学生信息
updateStudent(students, sc);
break;
default:
// 输入的是其他指令，结束修改，返回到系统首页
System.out.println("好的！修改结束！");
break;
}
}
/**
* 删除学生功能实现：根据学号删除
*
* @param students 学生对象集合
* @param sc 键盘录入对象
*/
public static void deleteStudent(ArrayList<Student> students, Scanner sc) {
// 1、判断接收的值是否为null
if (students == null && sc == null) {
System.out.println("您的学生对象集合与键盘录入对象都不能为null~");
return;
} else if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return;
} else if (sc == null) {
System.out.println("您的键盘录入对象不能为null~");
return;
}
// 2、从键盘输入要删除的学生学号
String id;
System.out.println("请您输入要删除的学生学号：");
id = sc.next();
// 判断该学生对象是否存在于集合中
boolean flag = exist(students, id);
if (flag) {
// 存在
// 则根据输入的学生学号得到该学生对象
Student student = getStudentById(students, id);
// 删除该学生
students.remove(student);
System.out.println("学号为" + id + "的学生删除成功！");
// 问一下是否要继续进行删除操作？
ifContinueDelete(students, sc);
} else {
System.out.println("学号为" + id + "的学生不存在！删除失败！");
// 问一下是否要继续进行删除操作？
ifContinueDelete(students, sc);
}
}
/**
* 是否继续删除学生信息
*
* @param students 学生对象集合
* @param sc 键盘录入对象
*/
public static void ifContinueDelete(ArrayList<Student> students, Scanner sc) {
// 1、判断接收的值是否为null
if (students == null && sc == null) {
System.out.println("您的学生对象集合与键盘录入对象都不能为null~");
return;
} else if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return;
} else if (sc == null) {
System.out.println("您的键盘录入对象不能为null~");
return;
}
// 2、是否继续删除
System.out.println("您是否要继续删除学生信息？(yes/no)：");
String command = sc.next();
switch (command) {
case "yes":
// 输入的是yes，回调deleteStudent方法，继续删除学生信息
deleteStudent(students, sc);
break;
default:
// 输入的是其他指令，结束删除，返回到系统首页
System.out.println("好的！删除结束！");
break;
}
}
/**
* 根据指定学生学号查询学生对象
*
* @param students 学生对象集合
* @param id 指定学生学号
* @return 返回查询到的学生对象
*/
public static Student getStudentById(ArrayList<Student> students, String id) {
// 1、判断接收的值是否为null
if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return null;
}
// 2、遍历students，依次获取集合中每个学生对象
for (Student student : students) {
// 判断指定的学生学号 是否匹配 当前遍历到的学生对象的学号
if (id.equals(student.getId())) {
// 匹配，返回当前遍历到的学生对象
return student;
}
}
// 3、循环结束，仍然没有查询到，返回null
return null;
}
/**
* 查询所有学生信息
*
* @param students 学生对象集合
*/
public static void showStudents(ArrayList<Student> students) {
// 1、判断接收的值是否为null
if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return;
}
// 2、判断学生对象集合中是否存在学生
if (students.size() == 0) {
System.out.println("当前无学生信息，请添加后再查询！");
return;
}
// 3、遍历students集合，依次获取集合中每个学生对象
System.out.println("学生信息如下：");
System.out.println("\t学号\t\t\t姓名\t\t\t年龄\t\t\t家庭住址");
for (Student student : students) {
System.out.println(student.getId() + "\t\t\t"
+ student.getName() + "\t\t\t"
+ student.getAge() + "\t\t\t"
+ student.getAddress());
}
System.out.println();
}
/**
* 添加学生功能实现
*
* @param students 学生对象集合
* @param sc 键盘录入对象
*/
public static void addStudents(ArrayList<Student> students, Scanner sc) {
// 1、判断接收的值是否为null
if (students == null && sc == null) {
System.out.println("您的学生对象集合与键盘录入对象都不能为null~");
return;
} else if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return;
} else if (sc == null) {
System.out.println("您的键盘录入对象不能为null~");
return;
}
// 2、添加学生
// a.录入学生学号
String id;
while (true) {
System.out.println("请您录入学生的学号：");
id = sc.next();
// 根据学号判断该学生对象是否存在于集合中
boolean flag = exist(students, id);
if (flag) {
// 存在
System.out.println("学号为" + id + "的学生已存在！请重新录入~");
} else {
// 不存在，跳出循环，可以录入学生的其他信息
break;
}
}
// b.录入学生姓名
System.out.println("请您录入学生的姓名：");
String name = sc.next();
// c.录入学生年龄
int age;
while (true) {
System.out.println("请您录入学生的年龄：");
age = sc.nextInt();
// 判断年龄是否大于等于0
if (age >= 0) {
// 不为负数，跳出循环，可以录入学生的其他信息
break;
} else {
// 为负数
System.out.println("年龄不合理！请重新录入~");
}
}
// d.录入学生家庭住址
System.out.println("请您录入学生的家庭住址：");
String address = sc.next();
// e.所有信息录入完毕，将学生信息封装成学生对象，并添加进集合中
students.add(new Student(id, name, age, address));
System.out.println(name + "同学已成功录入奥利给学生管理系统~");
// f.添加完成一个学生对象，问一下是否要继续添加下一个学生对象？
ifContinueAdd(students, sc);
}
/**
* 是否继续添加学生信息
*
* @param students 学生对象集合
* @param sc 键盘录入对象
*/
public static void ifContinueAdd(ArrayList<Student> students, Scanner sc) {
// 1、判断接收的值是否为null
if (students == null && sc == null) {
System.out.println("您的学生对象集合与键盘录入对象都不能为null~");
return;
} else if (students == null) {
System.out.println("您的学生对象集合不能为null~");
return;
} else if (sc == null) {
System.out.println("您的键盘录入对象不能为null~");
return;
}
// 2、是否继续添加
System.out.println("您是否要继续添加学生信息？(yes/no)：");
String command = sc.next();
switch (command) {
case "yes":
// 输入的是yes，回调addStudent方法，继续添加学生信息
addStudents(students, sc);
break;
default:
// 输入的是其他指令，结束录入，返回到系统首页
System.out.println("好的！添加结束！");
break;
}
}
/**
* 根据学号查询学生对象是否存在
*
* @param students 学生对象集合
* @param id 学生学号
* @return 存在返回true，否则返回false
*/
public static boolean exist(ArrayList<Student> students, String id) {
// 1、遍历students集合，依次获取集合中每个学生对象
for (Student student : students) {
// 判断要添加的学生学号 是否匹配 当前遍历到的学生学号
if (id.equals(student.getId())) {
// 匹配，说明存在，返回true
return true;
}
}
// 2、遍历结束，仍然匹配不到相同学号的学生对象，说明不存在，返回false
return false;
}
}
----------欢迎来到奥利给学生管理系统----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
4
-------查询所有学生信息-------
当前无学生信息，请添加后再查询！
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
1
-------添加学生-------
请您录入学生的学号：
201901
请您录入学生的姓名：
孙悟空
请您录入学生的年龄：
688
请您录入学生的家庭住址：
水帘洞
孙悟空同学已成功录入奥利给学生管理系统~
您是否要继续添加学生信息？(yes/no)：
yes
请您录入学生的学号：
201902
请您录入学生的姓名：
猪八戒
请您录入学生的年龄：
455
请您录入学生的家庭住址：
高老庄
猪八戒同学已成功录入奥利给学生管理系统~
您是否要继续添加学生信息？(yes/no)：
yes
请您录入学生的学号：
2019002
请您录入学生的姓名：
沙和尚
请您录入学生的年龄：
300
请您录入学生的家庭住址：
黄泥河
沙和尚同学已成功录入奥利给学生管理系统~
您是否要继续添加学生信息？(yes/no)：
yes
请您录入学生的学号：
201901
学号为201901的学生已存在！请重新录入~
请您录入学生的学号：
201903
请您录入学生的姓名：
唐僧
请您录入学生的年龄：
34
请您录入学生的家庭住址：
东土大唐
唐僧同学已成功录入奥利给学生管理系统~
您是否要继续添加学生信息？(yes/no)：
no
好的！添加结束！
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
4
-------查询所有学生信息-------
学生信息如下：
学号 姓名 年龄 家庭住址
201901 孙悟空 688 水帘洞
201902 猪八戒 455 高老庄
2019002 沙和尚 300 黄泥河
201903 唐僧 34 东土大唐
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
3
-------修改学生-------
请您输入要修改的学生学号：
2019002
请您录入该学生修改后的姓名：
沙溢
请您录入该学生修改后的年龄：
35
请您录入该学生修改后的家庭住址：
广州
学号为2019002的学生修改成功！
您是否要继续修改学生信息？(yes/no)：
yes
请您输入要修改的学生学号：
2019005
学号为2019005的学生不存在！修改失败！
您是否要继续修改学生信息？(yes/no)：
no
好的！修改结束！
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
4
-------查询所有学生信息-------
学生信息如下：
学号 姓名 年龄 家庭住址
201901 孙悟空 688 水帘洞
201902 猪八戒 455 高老庄
2019002 沙溢 35 广州
201903 唐僧 34 东土大唐
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
2
-------删除学生-------
请您输入要删除的学生学号：
2019002
学号为2019002的学生删除成功！
您是否要继续删除学生信息？(yes/no)：
yes
请您输入要删除的学生学号：
2019
学号为2019的学生不存在！删除失败！
您是否要继续删除学生信息？(yes/no)：
no
好的！删除结束！
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
4
-------查询所有学生信息-------
学生信息如下：
学号 姓名 年龄 家庭住址
201901 孙悟空 688 水帘洞
201902 猪八戒 455 高老庄
201903 唐僧 34 东土大唐
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出系统
请输入您的选择:
5
好的！已退出系统！欢迎下次登录~
Process finished with exit code 0
二、学生管理系统升级版
1、需求文档
（1）需求
- 为学生管理系统书写一个登陆、注册、忘记密码的功能。
- 只有用户登陆成功之后，才能进入到学生管理系统中进行增删改查的操作。
（2）分析
-
登录页面：
------欢迎来到奥利给学生管理系统登录页面------ 1: 登录 2: 注册 3: 忘记密码 -
用户类
- 属性：用户名、密码、身份证号码、手机号码。
-
注册功能：
-
用户名需要满足以下要求：
验证要求：
- 用户名唯一
- 用户名长度必须在3~15位之间
- 只能是字母加数字的组合，但是不能是纯数字
-
密码键盘输入两次，两次一致才可以进行注册。
-
身份证号码需要验证：
验证要求：
- 长度为18位
- 不能以0开头
- 前17位，必须都是数字
- 最后一位可以是数字，也可以是大写的X或小写的x
-
手机号验证：
验证要求：
- 长度为11位。
- 必须都是数字。
- 不能以0位开头。
-
-
登录功能：
-
键盘录入用户名、密码、验证码（验证时不区分大小写）
验证要求：
- 用户如果未注册，直接结束方法，并提示：用户名未注册，请先注册！
- 判断验证码是否正确，如不正确，重新输入。
- 再判断用户名和密码是否正确，有3次机会。
-
-
忘记密码功能：
- 键盘录入用户名，判断当前用户名是否存在，如不存在，直接结束方法，并提示：未注册！
- 键盘录入身份证号码和手机号码
- 判断当前用户的身份证号码和手机号码是否一致：
- 如果一致，则提示输入密码，进行修改。
- 如果不一致，则提示：账号信息不匹配，修改失败。
-
验证码规则：
- 长度为5
- 由4位大写或小写字母和1位数字组成，同一个字母可重复。
- 最后1位数字可以出现在任意位置：
- 例如：Qaa3K、2HjhP
2、实现
（1）用户页面实现
-
用户类
package com.gxcj.been; /* 用户类 */ public class User { /* 定义用户属性： 用户名、密码、身份证号码、手机号码 */ private String username; private String password; private String IDCard; private String phoneNumber; /* 提供有参、无参构造器 */ public User() { } public User(String username, String password, String IDCard, String phoneNumber) { this.username = username; this.password = password; this.IDCard = IDCard; this.phoneNumber = phoneNumber; } /* 提供全套的get和set方法，暴露其属性的取值和赋值 */ public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public String getIDCard() { return IDCard; } public void setIDCard(String IDCard) { this.IDCard = IDCard; } public String getPhoneNumber() { return phoneNumber; } public void setPhoneNumber(String phoneNumber) { this.phoneNumber = phoneNumber; } /* 重写toString方法，格式化输出用户对象的信息 */ @Override public String toString() { return "User{" + "username='" + username + '\'' + ", password='" + password + '\'' + ", IDCard='" + IDCard + '\'' + ", phoneNumber='" + phoneNumber + '\'' + '}'; } } -
登录页面
package com.gxcj.test; import com.gxcj.been.Student; import com.gxcj.been.User; import java.util.ArrayList; import java.util.Scanner; /* 学生管理系统 测试类 */ public class Test { public static void main(String[] args) { // 2、创建键盘录入对象，用于从键盘录入数据 Scanner sc = new Scanner(System.in); // 3、定义一个用户对象类型的集合，用于存储用户对象 ArrayList<User> users = new ArrayList<>(); // 4、学生管理系统登录页面 systemLoginPage(users, sc); } /** * 学生管理系统登录页面 * * @param users 用户对象集合 * @param sc 键盘录入对象 */ public static void systemLoginPage(ArrayList<User> users, Scanner sc) { // 1、打印学生管理系统登录页面 System.out.println("----------欢迎来到奥利给学生管理系统登录页面----------"); while (true) { System.out.println("1: 登录\n2: 注册\n3: 忘记密码"); System.out.println("请输入您的选择: "); String chose = sc.next(); // 2、根据输入的选择进入相应的操作界面 switch (chose) { case "1": System.out.println("登录"); break; case "2": System.out.println("注册"); break; case "3": System.out.println("忘记密码"); break; default: System.out.println("该功能未开发！请敬请等候~"); } } } }----------欢迎来到奥利给学生管理系统登录页面---------- 1: 登录 2: 注册 3: 忘记密码 请输入您的选择: 1 登录 1: 登录 2: 注册 3: 忘记密码 请输入您的选择: 2 注册 1: 登录 2: 注册 3: 忘记密码 请输入您的选择: 3 忘记密码 1: 登录 2: 注册 3: 忘记密码 请输入您的选择: 4 该功能未开发！请敬请等候~ 1: 登录 2: 注册 3: 忘记密码 请输入您的选择: fdg 该功能未开发！请敬请等候~ 1: 登录 2: 注册 3: 忘记密码 请输入您的选择:
（2）注册功能实现
- 先有注册功能，才有登录功能和忘记密码功能。
package com.gxcj.test;
import com.gxcj.been.Student;
import com.gxcj.been.User;
import java.util.*;
/*
学生管理系统
测试类
*/
public class Test {
// 1、定义一个全局的键盘录入对象，用于从键盘录入数据
public static final Scanner SC = new Scanner(System.in);
public static void main(String[] args) {
// 2、定义一个学生对象类型的集合，用于存储学生对象
ArrayList<Student> students = new ArrayList<>();
// 3、定义一个用户对象类型的集合，用于存储用户对象
ArrayList<User> users = new ArrayList<>();
// 4、学生管理系统登录页面
systemLoginPage(users);
// 5、学生管理系统操作页面
systemHomePage(students);
}
/**
* 学生管理系统登录页面
*
* @param users 用户对象集合
*/
public static void systemLoginPage(ArrayList<User> users) {
// 1、打印学生管理系统登录页面
System.out.println("----------欢迎来到奥利给学生管理系统登录页面----------");
while (true) {
System.out.println("1: 登录\n2: 注册\n3: 忘记密码");
System.out.println("请输入您的选择: ");
String chose = SC.next();
// 2、根据输入的选择进入相应的操作界面
switch (chose) {
case "1":
System.out.println("登录");
break;
case "2":
userRegister(users);
break;
case "3":
System.out.println("忘记密码");
break;
default:
System.out.println("该功能未开发！请敬请等候~");
}
}
}
/**
* 用户注册功能
*
* @param users 用户对象集合
*/
public static void userRegister(ArrayList<User> users) {
System.out.println("-----------欢迎来到用户注册界面-----------");
// 1、定义空用户对象，用于封装录入的用户信息为一个用户对象。
User user = new User();
// 2、录入用户名
// 校验输入的用户名是否符合要求
String username = checkInputUsername(users);
// 符合要求，录入用户名
user.setUsername(username);
// 3、录入密码
while (true) {
System.out.println("请设置您的用户密码：");
String password = SC.next();
System.out.println("请再次确认您的用户密码：");
String okPassword = SC.next();
// 判断两次输入的密码是否是一致的
if (password.equals(okPassword)) {
// 是，则录入密码
user.setPassword(password);
// 密码录入完成，跳出循环
break;
} else {
// 不是，则重新输入密码
System.out.println("您两次输入的密码不一致！请重新输入~");
}
}
// 4、录入身份证号码
// 校验输入的身份证号码是否符合要求
String IDCard = checkInputIDCard();
// 符合要求，录入该身份证号码
user.setIDCard(IDCard);
// 5、录入手机号码
// 校验输入的手机号码是否符合要求
String phoneNumber = checkInputPhoneNumber();
// 符合要求，录入手机号码
user.setPhoneNumber(phoneNumber);
// 6、将封装了用户信息的用户对象添加进集合中
users.add(user);
System.out.println("恭喜用户：" + username + "注册成功！");
}
/**
* 校验输入的手机号码
* 要求：
* 1、长度为11位
* 2、必须都是数字
* 3、不能以0开头
*
* @return 返回通过校验的手机号码
*/
public static String checkInputPhoneNumber() {
// 1、定义变量用于接收输入的手机号码
String phoneNumber;
// 2、开始校验手机号码
while (true) {
System.out.println("请输入您的手机号码：");
phoneNumber = SC.next();
// 要求：长度为11位、不能以0开头、必须都是数字
int len = phoneNumber.length(); // 得到手机号码的长度
// a.判断手机号码是否为11位
if (len == 11) {
// 是，符合要求
int count = 0; // 定义计数器，用于统计不为数字的字符个数
// 遍历手机号码，依次获取到每个字符
for (int i = 0; i < len; i++) {
// 得到每个字符
char c = phoneNumber.charAt(i);
// b.判断手机号码是否不为数字
if (!(c >= '0' && c <= '9')) {
// 是，则统计不为数字的字符的个数
count++;
// 只要出现一个不是数字的字符，就跳出遍历了！
break;
}
}
// 遍历结束，判断不为数字的字符个数是否大于0
if (count > 0) {
// 是，则提示！
System.out.println("手机号码必须都是数字！");
}else {
// 否，符合要求
// 获取首字符
char c = phoneNumber.charAt(0);
// c.判断手机号码是否以0开头
if (c == '0') {
// 是，则提示！
System.out.println("手机号码不能以0开头！");
}else {
// 否，符合要求，校验通过，跳出while循环
break;
}
}
}else {
// 否，则提示！
System.out.println("手机号码长度必须为11位！");
}
}
// 循环结束，返回手机号码
return phoneNumber;
}
/**
* 校验输入的身份证号码
* 要求：
* 1、长度为18位
* 2、不能以0开头
* 3、前17位必须都是数字
* 4、最后一位可以是数字，也可以是大写的字母X 或 小写的字母x
*
* @return 返回通过校验的身份证号码
*/
public static String checkInputIDCard() {
// 1、定义变量接收输入的身份证号码
String IDCard;
// 2、校验
while (true) {
System.out.println("请输入您的身份证号码：");
IDCard = SC.next();
// 记录身份证号码的长度
int len = IDCard.length();
// a.判断身份证号码的长度是否为18位
if (len == 18) {
// 是，符合要求
// b.判断身份证号码是否以0开头
if (IDCard.charAt(0) == '0') {
// 是，则提示！
System.out.println("身份证号码不能以0开头！");
} else {
// 否，符合要求
// 取出身份证号码的前17位
String id17 = IDCard.substring(0, 17);
// 定义计数器，用于统计前17位有多少个字符不是数字的个数
int count = 0;
// 遍历身份证前17位，依次得到每个字符
for (int i = 0; i < id17.length(); i++) {
// 接收每个字符
char ch = IDCard.charAt(i);
// c.判断该字符是否都不为数字
if (!(ch >= '0' && ch <= '9')) {
// 是，则统计不为数字的字符个数
count++;
// 只要出现一个不是数字的字符，就跳出遍历了！
break;
}
}
// 遍历结束，判断不为数字的个数是否大于0
if (count > 0) {
// 是，则提示！
System.out.println("身份证号码的前17位必须都是数字！");
}else {
// 否，符合要求
// 取出身份证号码的最后一位字符
char c = IDCard.charAt(17);
// d.判断最后一位字符是否为数字或为'X'或为'x'
if ((c >= '0' && c <= '9') || c == 'X' || c == 'x') {
// 是，符合要求，校验通过，跳出while循环
break;
}else {
// 否，则提示！
System.out.println("身份证号码的最后一位必须为数字，也可以为X或x！");
}
}
}
} else {
// 否，则提示！
System.out.println("身份证号码必须是18位！");
}
}
// 3、循环结束，返回身份证号码
return IDCard;
}
/**
* 校验输入的用户名
* 要求：
* 1、用户名唯一
* 2、用户名长度必须在3~15位之间
* 3、只能是字符加数字的组合，但是不能是纯数字
*
* @param users 用户对象集合
* @return 返回符合以上要求的用户名
*/
public static String checkInputUsername(ArrayList<User> users) {
/*
开发细节：先验证格式是否正确，再验证是否唯一
因为在以后所有的数据，都是存在数据库中，如果我们要校验，需要使用到网络资源。
*/
// 1、输入用户名
String username; // 定义变量，接收输入的用户名
while (true) {
System.out.println("请输入您的用户名(3~15位)：");
username = SC.next();
// 开始校验该用户名的长度是否符合3~15位
int len = username.length(); // 存储用户名的长度
if (len >= 3 && len <= 15) {
// 标记：表示用户名的每个字符都符合内容要求
boolean flag = true;
// 用户名长度符合要求，遍历用户名，依次得到每个字符
for (int i = 0; i < len; i++) {
// 接收每个字符
char ch = username.charAt(i);
// 判断该用户名的每个字符是否不在大写字母或者小写字母或者数字之间
if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9'))) {
// 是，则说明该用户名不符合内容要求，flag的值改为false
flag = false;
}
}
// 遍历结束，判断flag的值是否为true
if (flag) {
// 为true，则说明用户名内容符合要求：是字母加数字的组合
// 用户名不能是纯数字
int count = 0; // 定义计数器，用于记录符合字母范围要求的字符个数
// 遍历用户名，依次得到每个字符
for (int i = 0; i < len; i++) {
// 接收每个字符
char ch = username.charAt(i);
// 判断该用户名的每个字符是否在大写字母范围 或 小写字母范围
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
// 是，则统计符合字母范围的字符个数
count++;
// 只要看到1个字母，就没有判断其他字符了
break;
}
}
// 遍历结束，判断字符个数是否大于0
if (count > 0) {
// 是，说明不是纯数字，符合要求
// 现在开始校验用户名的唯一性
if (containsUser(users, username)) {
// 为true，则说明该用户已存在！
System.out.println("用户：" + username + "已经注册了！");
} else {
// 为false，则说明该用户不存在！跳出循环
break;
}
} else {
// 不是，说明是纯数字，则提示！
System.out.println("用户名不能是纯数字！");
}
} else {
// 为false，则说明用户名内容不符合要求：不是字母加数字的组合
System.out.println("用户名必须是字母加数字的组合！");
}
} else {
// 用户名长度超出范围
System.out.println("用户名长度必须在3~15位之间！");
}
}
// 所有要求校验通过，返回用户名
return username;
}
/**
* 查询用户名是否已存在
*
* @param users 用户对象集合
* @param username 用户名
* @return 存在返回true，否则返回false
*/
public static boolean containsUser(ArrayList<User> users, String username) {
// 如果该用户的索引大于等于0，说明存在，返回true
// 否则该用户的索引小于0，说明不存在，返回false
return getUserIndex(users, username) >= 0;
}
/**
* 根据用户名查询该用户对象在集合中的索引
*
* @param users 用户对象集合
* @param username 用户名
* @return 返回该用户对象所在的索引
*/
public static int getUserIndex(ArrayList<User> users, String username) {
// 1、根据用户名获取该用户对象的索引
// 遍历集合，依次获取每个用户对象
for (int i = 0; i < users.size(); i++) {
// 判断查询的用户名 是否匹配 当前遍历到的用户对象的用户名
if (username.equals(users.get(i).getUsername())) {
// 存在，返回该用户对象的索引
return i;
}
}
// 遍历结束，仍然找不到该用户名的用户对象，说明不存在。返回-1
return -1;
}
/**
* 学生管理系统首页
*
* @param students 学生对象集合
*/
public static void systemHomePage(ArrayList<Student> students) {
// 1、打印学生管理系统操作页面
System.out.println("----------欢迎来到奥利给学生管理系统操作页面----------");
while (true) {
System.out.println("1: 添加学生\n2: 删除学生\n3: 修改学生\n4: 查询学生\n5: 退出登录");
System.out.println("请输入您的选择: ");
// 2、接收输入的选择
String select = SC.next();
// 3、switch判断该选择是哪个功能
switch (select) {
case "1":
// 添加学生
System.out.println("-------添加学生-------");
addStudents(students);
break; // 跳出switch，回到首页面
case "2":
// 删除学生
System.out.println("-------删除学生-------");
deleteStudent(students);
break; // 跳出switch，回到首页面
case "3":
// 修改学生
System.out.println("-------修改学生-------");
updateStudent(students);
break; // 跳出switch，回到首页面
case "4":
// 查询所有学生信息
System.out.println("-------查询所有学生信息-------");
showStudents(students);
break; // 跳出switch，回到首页面
case "5":
// 退出系统
System.out.println("好的！已退出系统！欢迎下次登录~");
break; // 结束systemHomePage方法
// System.exit(0); // 停止虚拟机运行
default:
// 其他选择
System.out.println("该功能未开发！请敬请等候~");
break; // 跳出switch，回到首页面
}
}
}
/**
* 修改学生信息功能实现：根据学号修改
*
* @param students 学生对象集合
*/
public static void updateStudent(ArrayList<Student> students) {
// 1、从键盘输入要修改的学生学号
String id;
System.out.println("请您输入要修改的学生学号：");
id = SC.next();
// 根据输入的学号获取该学生对象在集合中的索引
int studentIndex = getStudentIndex(students, id);
// 判断索引是否大于等于0
if (studentIndex >= 0) {
// 存在
// 则根据获取到的索引来获取该学生对象
Student student = students.get(studentIndex);
// 修改该学生的其他信息
System.out.println("请您录入该学生修改后的姓名：");
String newName = SC.next();
// 修改学生姓名
student.setName(newName);
while (true) {
System.out.println("请您录入该学生修改后的年龄：");
int newAge = SC.nextInt();
if (newAge >= 0) {
// 年龄合理，修改学生年龄
student.setAge(newAge);
System.out.println("请您录入该学生修改后的家庭住址：");
String newAddress = SC.next();
// 修改学生家庭住址
student.setAddress(newAddress);
System.out.println("学号为" + id + "的学生修改成功！");
// 问一下是否要继续进行修改操作？
ifContinueUpdate(students);
break; // 跳出循环
} else {
System.out.println("年龄不合理！请重新录入~");
}
}
} else {
System.out.println("学号为" + id + "的学生不存在！修改失败！");
// 问一下是否要继续进行修改操作？
ifContinueUpdate(students);
}
}
/**
* 是否继续修改学生信息
*
* @param students 学生对象集合
*/
public static void ifContinueUpdate(ArrayList<Student> students) {
// 1、是否继续修改
System.out.println("您是否要继续修改学生信息？(yes/no)：");
String command = SC.next();
switch (command) {
case "yes":
// 输入的是yes，回调updateStudent方法，继续修改学生信息
updateStudent(students);
break;
default:
// 输入的是其他指令，结束修改，返回到系统首页
System.out.println("好的！修改结束！");
break;
}
}
/**
* 删除学生功能实现：根据学号删除
*
* @param students 学生对象集合
*/
public static void deleteStudent(ArrayList<Student> students) {
// 1、从键盘输入要删除的学生学号
String id;
System.out.println("请您输入要删除的学生学号：");
id = SC.next();
// 根据输入的学号获取该学生对象在集合中的索引
int studentIndex = getStudentIndex(students, id);
// 判断索引是否大于等于0
if (studentIndex >= 0) {
// 是，说明存在
// 则根据获取到的索引来获取该学生对象
Student student = students.get(studentIndex);
// 删除该学生
students.remove(student);
System.out.println("学号为" + id + "的学生删除成功！");
// 问一下是否要继续进行删除操作？
ifContinueDelete(students);
} else {
// 不存在，则提示！
System.out.println("学号为" + id + "的学生不存在！删除失败！");
// 问一下是否要继续进行删除操作？
ifContinueDelete(students);
}
}
/**
* 是否继续删除学生信息
*
* @param students 学生对象集合
*/
public static void ifContinueDelete(ArrayList<Student> students) {
// 1、是否继续删除
System.out.println("您是否要继续删除学生信息？(yes/no)：");
String command = SC.next();
switch (command) {
case "yes":
// 输入的是yes，回调deleteStudent方法，继续删除学生信息
deleteStudent(students);
break;
default:
// 输入的是其他指令，结束删除，返回到系统首页
System.out.println("好的！删除结束！");
break;
}
}
/**
* 查询所有学生信息
*
* @param students 学生对象集合
*/
public static void showStudents(ArrayList<Student> students) {
// 1、判断学生对象集合中是否存在学生
if (students.size() == 0) {
System.out.println("当前无学生信息，请添加后再查询！");
return;
}
// 2、遍历students集合，依次获取集合中每个学生对象
System.out.println("学生信息如下：");
System.out.println("\t学号\t\t\t姓名\t\t\t年龄\t\t\t家庭住址");
for (Student student : students) {
System.out.println(student.getId() + "\t\t\t"
+ student.getName() + "\t\t\t"
+ student.getAge() + "\t\t\t"
+ student.getAddress());
}
System.out.println();
}
/**
* 添加学生功能实现
*
* @param students 学生对象集合
*/
public static void addStudents(ArrayList<Student> students) {
// 1、添加学生
// a.录入学生学号
String id;
while (true) {
System.out.println("请您录入学生的学号：");
id = SC.next();
// 根据学号判断该学生对象是否存在于集合中
boolean flag = containsStudent(students, id);
if (flag) {
// 存在
System.out.println("学号为" + id + "的学生已存在！请重新录入~");
} else {
// 不存在，跳出循环，可以录入学生的其他信息
break;
}
}
// b.录入学生姓名
System.out.println("请您录入学生的姓名：");
String name = SC.next();
// c.录入学生年龄
int age;
while (true) {
System.out.println("请您录入学生的年龄：");
age = SC.nextInt();
// 判断年龄是否大于等于0
if (age >= 0) {
// 不为负数，跳出循环，可以录入学生的其他信息
break;
} else {
// 为负数
System.out.println("年龄不合理！请重新录入~");
}
}
// d.录入学生家庭住址
System.out.println("请您录入学生的家庭住址：");
String address = SC.next();
// e.所有信息录入完毕，将学生信息封装成学生对象，并添加进集合中
students.add(new Student(id, name, age, address));
System.out.println(name + "同学已成功录入奥利给学生管理系统~");
// f.添加完成一个学生对象，问一下是否要继续添加下一个学生对象？
ifContinueAdd(students);
}
/**
* 是否继续添加学生信息
*
* @param students 学生对象集合
*/
public static void ifContinueAdd(ArrayList<Student> students) {
// 1、是否继续添加
System.out.println("您是否要继续添加学生信息？(yes/no)：");
String command = SC.next();
switch (command) {
case "yes":
// 输入的是yes，回调addStudent方法，继续添加学生信息
addStudents(students);
break;
default:
// 输入的是其他指令，结束录入，返回到系统首页
System.out.println("好的！添加结束！");
break;
}
}
/**
* 查询学生学号是否已存在
*
* @param students 学生对象集合
* @param id 学生学号
* @return 存在返回true，否则返回false
*/
public static boolean containsStudent(ArrayList<Student> students, String id) {
// 如果该学生对象的索引大于等于0，说明存在，返回true
// 否则该学生对象的索引小于0，说明不存在，返回false
return getStudentIndex(students, id) >= 0;
}
/**
* 根据学生学号查询该学生对象在集合中的索引
*
* @param students 学生对象集合
* @param id 学生学号
* @return 返回该学生对象所在的索引
*/
public static int getStudentIndex(ArrayList<Student> students, String id) {
// 1、根据学生学号获取该学生对象的索引
// 遍历集合，依次获取每个学生对象
for (int i = 0; i < students.size(); i++) {
// 判断查询的学号 是否匹配 当前遍历到的学生对象的学号
if (id.equals(students.get(i).getId())) {
// 存在，返回该学生对象的在集合中的索引
return i;
}
}
// 遍历结束，仍然找不到该学号的学生对象，说明不存在。返回-1
return -1;
}
}
----------欢迎来到奥利给学生管理系统登录页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
2
-----------欢迎来到用户注册界面-----------
请输入您的用户名(3~15位)：
as
用户名长度必须在3~15位之间！
请输入您的用户名(3~15位)：
1a
用户名长度必须在3~15位之间！
请输入您的用户名(3~15位)：
ji34jsdjjsdfjsj243
用户名长度必须在3~15位之间！
请输入您的用户名(3~15位)：
Hello123
请设置您的用户密码：
123123
请再次确认您的用户密码：
123
您两次输入的密码不一致！请重新输入~
请设置您的用户密码：
123abc
请再次确认您的用户密码：
123abc
请输入您的身份证号码：
54522197912061456x34
身份证号码必须是18位！
请输入您的身份证号码：
054522197912061456x
身份证号码必须是18位！
请输入您的身份证号码：
054522197912061456
身份证号码不能以0开头！
请输入您的身份证号码：
54522197912d6145fx
身份证号码的前17位必须都是数字！
请输入您的身份证号码：
54522197912061456x
请输入您的手机号码：
1919988787823
手机号码长度必须为11位！
请输入您的手机号码：
19199887878f
手机号码长度必须为11位！
请输入您的手机号码：
19123
手机号码长度必须为11位！
请输入您的手机号码：
1919988787t
手机号码必须都是数字！
请输入您的手机号码：
19199887878
恭喜用户：Hello123注册成功！
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
2
-----------欢迎来到用户注册界面-----------
请输入您的用户名(3~15位)：
Hello123
用户：Hello123已经注册了！
请输入您的用户名(3~15位)：
（3）登录功能实现
package com.gxcj.test;
import com.gxcj.been.Student;
import com.gxcj.been.User;
import java.awt.*;
import java.util.*;
/*
学生管理系统
测试类
*/
public class Test {
// 1、定义一个全局的键盘录入对象，用于从键盘录入数据
public static final Scanner SC = new Scanner(System.in);
public static void main(String[] args) {
// 2、定义一个学生对象类型的集合，用于存储学生对象
ArrayList<Student> students = new ArrayList<>();
// 3、定义一个用户对象类型的集合，用于存储用户对象
ArrayList<User> users = new ArrayList<>();
// 4、奥利给系统用户界面
systemLoginPage(users, students);
}
/**
* 奥利给系统用户界面
*
* @param users 用户对象集合
* @param students 学生对象集合
*/
public static void systemLoginPage(ArrayList<User> users, ArrayList<Student> students) {
// 1、打印学生管理系统登录页面
while (true) {
System.out.println("----------欢迎来到奥利给系统用户页面----------");
System.out.println("1: 登录\n2: 注册\n3: 忘记密码");
System.out.println("请输入您的选择: ");
String chose = SC.next();
// 2、根据输入的选择进入相应的操作界面
switch (chose) {
case "1":
userLogin(users, students); // 登录
break;
case "2":
userRegister(users); // 注册
break;
case "3":
System.out.println("忘记密码");
break;
default:
System.out.println("该功能未开发！请敬请等候~");
}
}
}
/**
* 用户登录功能
*
* @param users 用户对象集合
* @param students 学生对象集合
*/
public static void userLogin(ArrayList<User> users, ArrayList<Student> students) {
System.out.println("-----------欢迎来到用户登录界面-----------");
// 1、输入用户名
System.out.println("请输入您的用户名：");
String username = SC.next();
// 得到该用户在集合中的索引
int userIndex = getUserIndex(users, username);
// 判断该用户名是否未注册！
if (userIndex < 0) {
// 是，则提示！并结束方法
System.out.println("用户名未注册，请先注册！");
return;
}
// 已注册！
// 2、输入密码
Label: for (int i = 0; i < 3; i++) { // i: 0 1 2
System.out.println("请输入您的密码：");
String password = SC.next();
// 根据该用户在集合中的索引 获取到 该用户对象
User user = users.get(userIndex);
// 校验密码是否正确
if (password.equals(user.getPassword())) {
// 正确，校验通过
// 3、录入验证码
// 获取验证码
String authCode = createAuthCode();
// 输入验证码
while (true) {
System.out.println("请您输入验证码" + "(" + authCode + ")：");
String inputAuthCode = SC.next();
// 判断输入的验证码 是否匹配 生成的验证码: 不区分大小写
if (inputAuthCode.equalsIgnoreCase(authCode)) {
// 匹配，登录成功！
System.out.println("用户：" + username + "登录成功！");
systemHomePage(students);
// 操作完，跳出for循环！
break Label;
} else {
// 不匹配，说明输入的验证码有误！
System.out.println("验证码错误！");
// 重新获取验证码
authCode = createAuthCode();
}
}
} else {
// 判断i是否等于2
if (i == 2) {
// 是，说明没有机会了，提示！
System.out.println("密码已连续错误3次！登录失败！");
} else {
// 否，说明还有机会，重新输入
// 第一次：2 - 0 = 2
// 第二次：2 - 1 = 1
System.out.println("密码错误！您还有" + (2 - i) + "次机会！");
}
}
}
}
/**
* 生成验证码
* 要求：
* 1、长度为5
* 2、由4位大写或小写字母和1位数字组成，同一个字母可重复。
* 3、最后1位数字可以出现在验证码中的任意位置：
* 例如：Qaa3K、2HjhP
*
* @return 返回验证码
*/
public static String createAuthCode() {
// 1、定义一个用于存储52个英文字母的数组(大小写)
char[] letters = new char[52];
// 2、遍历letters数组，依次添加52个英文字母
for (int i = 0; i < letters.length; i++) {
// 判断i是否小于等于25
if (i <= 25) {
// 是，则往数组添加26个小写的英文字母
// 依次将 'a'~'z' 26个小写字母的ASCII码转换成字符后，添加进数组中
letters[i] = (char) (97 + i);
} else {
// 否，则i是大于25的，则往数组添加26个大写的英文字母
// 依次将 'A'~'Z' 26个大写字母的ASCII码转换成字符后，添加进数组中
/*
为什么要减26？因为此时i已经大于25了，也就是26了。
那么第一次就是：65 + 26 - 26 = 65
第二次就是：65 + 27 - 26 = 66
第三次就是：65 + 28 - 26 = 67
后面的就依次类推！
*/
letters[i] = (char) (65 + i - 26);
}
}
// for循环结束，52个英文字母已经添加完毕！
// 3、定义空字符串，用于拼接5位生成的验证码
String authCode = "";
// 4、随机生成4位英文字母验证码
// 创建随机数对象，用于生成一个随机索引
Random rd = new Random();
for (int i = 0; i < 4; i++) { // i: 0 1 2 3
// 生成一个随机索引，长度为52个英文字母数组的长度
int randomIndex = rd.nextInt(letters.length);
// 依次将随机生成的英文字母拼接起来
authCode += letters[randomIndex];
}
// 5、随机生成1位0~9之间的数字验证码
int randomNumber = rd.nextInt(10);
// 将随机生成的数字 与 4位英文字母验证码拼接起来
authCode += randomNumber;
// 6、将生成的5位验证码进行顺序打乱
// 将字符串转换成字符数组
char[] chars = authCode.toCharArray();
// 遍历chars数组，依次获取每个验证码字符
for (int i = 0; i < chars.length; i++) {
// 随机生成一个5之内的索引
int randomIndex = rd.nextInt(5);
// 用临时变量将当前获取到的验证码字符存储起来
char temp = chars[i];
// 开始交换位置：
// 将随机索引位置的验证码字符 放到 当前获取到的验证码的索引位置
chars[i] = chars[randomIndex];
// 将当前获取到的验证码字符 放到 随机索引的位置
chars[randomIndex] = temp;
}
// for循环结束，顺序已经全部打乱
// 7、将字符数组转换成字符串
authCode = new String(chars);
// 8、返回验证码
return authCode;
}
/**
* 用户注册功能
*
* @param users 用户对象集合
*/
public static void userRegister(ArrayList<User> users) {
System.out.println("-----------欢迎来到用户注册界面-----------");
// 1、定义空用户对象，用于封装录入的用户信息为一个用户对象。
User user = new User();
// 2、录入用户名
// 校验输入的用户名是否符合要求
String username = checkInputUsername(users);
// 符合要求，录入用户名
user.setUsername(username);
// 3、录入密码
while (true) {
System.out.println("请设置您的用户密码：");
String password = SC.next();
System.out.println("请再次确认您的用户密码：");
String okPassword = SC.next();
// 判断两次输入的密码是否是一致的
if (password.equals(okPassword)) {
// 是，则录入密码
user.setPassword(password);
// 密码录入完成，跳出循环
break;
} else {
// 不是，则重新输入密码
System.out.println("您两次输入的密码不一致！请重新输入~");
}
}
// 4、录入身份证号码
// 校验输入的身份证号码是否符合要求
String IDCard = checkInputIDCard();
// 符合要求，录入该身份证号码
user.setIDCard(IDCard);
// 5、录入手机号码
// 校验输入的手机号码是否符合要求
String phoneNumber = checkInputPhoneNumber();
// 符合要求，录入手机号码
user.setPhoneNumber(phoneNumber);
// 6、将封装了用户信息的用户对象添加进集合中
users.add(user);
System.out.println("恭喜用户：" + username + "注册成功！");
}
/**
* 校验输入的手机号码
* 要求：
* 1、长度为11位
* 2、必须都是数字
* 3、不能以0开头
*
* @return 返回通过校验的手机号码
*/
public static String checkInputPhoneNumber() {
// 1、定义变量用于接收输入的手机号码
String phoneNumber;
// 2、开始校验手机号码
while (true) {
System.out.println("请输入您的手机号码：");
phoneNumber = SC.next();
// 要求：长度为11位、不能以0开头、必须都是数字
int len = phoneNumber.length(); // 得到手机号码的长度
// a.判断手机号码是否为11位
if (len == 11) {
// 是，符合要求
int count = 0; // 定义计数器，用于统计不为数字的字符个数
// 遍历手机号码，依次获取到每个字符
for (int i = 0; i < len; i++) {
// 得到每个字符
char c = phoneNumber.charAt(i);
// b.判断手机号码是否不为数字
if (!(c >= '0' && c <= '9')) {
// 是，则统计不为数字的字符的个数
count++;
// 只要出现一个不是数字的字符，就跳出遍历了！
break;
}
}
// 遍历结束，判断不为数字的字符个数是否大于0
if (count > 0) {
// 是，则提示！
System.out.println("手机号码必须都是数字！");
} else {
// 否，符合要求
// 获取首字符
char c = phoneNumber.charAt(0);
// c.判断手机号码是否以0开头
if (c == '0') {
// 是，则提示！
System.out.println("手机号码不能以0开头！");
} else {
// 否，符合要求，校验通过，跳出while循环
break;
}
}
} else {
// 否，则提示！
System.out.println("手机号码长度必须为11位！");
}
}
// 循环结束，返回手机号码
return phoneNumber;
}
/**
* 校验输入的身份证号码
* 要求：
* 1、长度为18位
* 2、不能以0开头
* 3、前17位必须都是数字
* 4、最后一位可以是数字，也可以是大写的字母X 或 小写的字母x
*
* @return 返回通过校验的身份证号码
*/
public static String checkInputIDCard() {
// 1、定义变量接收输入的身份证号码
String IDCard;
// 2、校验
while (true) {
System.out.println("请输入您的身份证号码：");
IDCard = SC.next();
// 记录身份证号码的长度
int len = IDCard.length();
// a.判断身份证号码的长度是否为18位
if (len == 18) {
// 是，符合要求
// b.判断身份证号码是否以0开头
if (IDCard.charAt(0) == '0') {
// 是，则提示！
System.out.println("身份证号码不能以0开头！");
} else {
// 否，符合要求
// 取出身份证号码的前17位
String id17 = IDCard.substring(0, 17);
// 定义计数器，用于统计前17位有多少个字符不是数字的个数
int count = 0;
// 遍历身份证前17位，依次得到每个字符
for (int i = 0; i < id17.length(); i++) {
// 接收每个字符
char ch = IDCard.charAt(i);
// c.判断该字符是否都不为数字
if (!(ch >= '0' && ch <= '9')) {
// 是，则统计不为数字的字符个数
count++;
// 只要出现一个不是数字的字符，就跳出遍历了！
break;
}
}
// 遍历结束，判断不为数字的个数是否大于0
if (count > 0) {
// 是，则提示！
System.out.println("身份证号码的前17位必须都是数字！");
} else {
// 否，符合要求
// 取出身份证号码的最后一位字符
char c = IDCard.charAt(17);
// d.判断最后一位字符是否为数字或为'X'或为'x'
if ((c >= '0' && c <= '9') || c == 'X' || c == 'x') {
// 是，符合要求，校验通过，跳出while循环
break;
} else {
// 否，则提示！
System.out.println("身份证号码的最后一位必须为数字，也可以为X或x！");
}
}
}
} else {
// 否，则提示！
System.out.println("身份证号码必须是18位！");
}
}
// 3、循环结束，返回身份证号码
return IDCard;
}
/**
* 校验输入的用户名
* 要求：
* 1、用户名唯一
* 2、用户名长度必须在3~15位之间
* 3、只能是字符加数字的组合，但是不能是纯数字
*
* @param users 用户对象集合
* @return 返回符合以上要求的用户名
*/
public static String checkInputUsername(ArrayList<User> users) {
/*
开发细节：先验证格式是否正确，再验证是否唯一
因为在以后所有的数据，都是存在数据库中，如果我们要校验，需要使用到网络资源。
*/
// 1、输入用户名
String username; // 定义变量，接收输入的用户名
while (true) {
System.out.println("请输入您的用户名(3~15位)：");
username = SC.next();
// 开始校验该用户名的长度是否符合3~15位
int len = username.length(); // 存储用户名的长度
if (len >= 3 && len <= 15) {
// 标记：表示用户名的每个字符都符合内容要求
boolean flag = true;
// 用户名长度符合要求，遍历用户名，依次得到每个字符
for (int i = 0; i < len; i++) {
// 接收每个字符
char ch = username.charAt(i);
// 判断该用户名的每个字符是否不在大写字母或者小写字母或者数字之间
if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9'))) {
// 是，则说明该用户名不符合内容要求，flag的值改为false
flag = false;
}
}
// 遍历结束，判断flag的值是否为true
if (flag) {
// 为true，则说明用户名内容符合要求：是字母加数字的组合
// 用户名不能是纯数字
int count = 0; // 定义计数器，用于记录符合字母范围要求的字符个数
// 遍历用户名，依次得到每个字符
for (int i = 0; i < len; i++) {
// 接收每个字符
char ch = username.charAt(i);
// 判断该用户名的每个字符是否在大写字母范围 或 小写字母范围
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
// 是，则统计符合字母范围的字符个数
count++;
// 只要看到1个字母，就没有判断其他字符了
break;
}
}
// 遍历结束，判断字符个数是否大于0
if (count > 0) {
// 是，说明不是纯数字，符合要求
// 现在开始校验用户名的唯一性
if (containsUser(users, username)) {
// 为true，则说明该用户已存在！
System.out.println("用户：" + username + "已经注册了！");
} else {
// 为false，则说明该用户不存在！跳出循环
break;
}
} else {
// 不是，说明是纯数字，则提示！
System.out.println("用户名不能是纯数字！");
}
} else {
// 为false，则说明用户名内容不符合要求：不是字母加数字的组合
System.out.println("用户名必须是字母加数字的组合！");
}
} else {
// 用户名长度超出范围
System.out.println("用户名长度必须在3~15位之间！");
}
}
// 所有要求校验通过，返回用户名
return username;
}
/**
* 查询用户名是否已存在
*
* @param users 用户对象集合
* @param username 用户名
* @return 存在返回true，否则返回false
*/
public static boolean containsUser(ArrayList<User> users, String username) {
// 如果该用户的索引大于等于0，说明存在，返回true
// 否则该用户的索引小于0，说明不存在，返回false
return getUserIndex(users, username) >= 0;
}
/**
* 根据用户名查询该用户对象在集合中的索引
*
* @param users 用户对象集合
* @param username 用户名
* @return 返回该用户对象所在的索引
*/
public static int getUserIndex(ArrayList<User> users, String username) {
// 1、根据用户名获取该用户对象的索引
// 遍历集合，依次获取每个用户对象
for (int i = 0; i < users.size(); i++) {
// 判断查询的用户名 是否匹配 当前遍历到的用户对象的用户名
if (username.equals(users.get(i).getUsername())) {
// 存在，返回该用户对象的索引
return i;
}
}
// 遍历结束，仍然找不到该用户名的用户对象，说明不存在。返回-1
return -1;
}
/**
* 学生管理系统首页
*
* @param students 学生对象集合
*/
public static void systemHomePage(ArrayList<Student> students) {
// 1、打印学生管理系统操作页面
while (true) {
System.out.println("----------欢迎来到奥利给学生管理系统操作页面----------");
System.out.println("1: 添加学生\n2: 删除学生\n3: 修改学生\n4: 查询学生\n5: 退出登录");
System.out.println("请输入您的选择: ");
// 2、接收输入的选择
String select = SC.next();
// 3、switch判断该选择是哪个功能
switch (select) {
case "1":
// 添加学生
System.out.println("-------添加学生-------");
addStudents(students);
break; // 跳出switch，回到首页面
case "2":
// 删除学生
System.out.println("-------删除学生-------");
deleteStudent(students);
break; // 跳出switch，回到首页面
case "3":
// 修改学生
System.out.println("-------修改学生-------");
updateStudent(students);
break; // 跳出switch，回到首页面
case "4":
// 查询所有学生信息
System.out.println("-------查询所有学生信息-------");
showStudents(students);
break; // 跳出switch，回到首页面
case "5":
// 退出系统
System.out.println("好的！已退出登录！欢迎下次再来~ ^_^~");
return; // 结束systemHomePage方法
default:
// 其他选择
System.out.println("该功能未开发！请敬请等候~");
break; // 跳出switch，回到首页面
}
}
}
/**
* 修改学生信息功能实现：根据学号修改
*
* @param students 学生对象集合
*/
public static void updateStudent(ArrayList<Student> students) {
// 1、从键盘输入要修改的学生学号
String id;
System.out.println("请您输入要修改的学生学号：");
id = SC.next();
// 根据输入的学号获取该学生对象在集合中的索引
int studentIndex = getStudentIndex(students, id);
// 判断索引是否大于等于0
if (studentIndex >= 0) {
// 存在
// 则根据获取到的索引来获取该学生对象
Student student = students.get(studentIndex);
// 修改该学生的其他信息
System.out.println("请您录入该学生修改后的姓名：");
String newName = SC.next();
// 修改学生姓名
student.setName(newName);
while (true) {
System.out.println("请您录入该学生修改后的年龄：");
int newAge = SC.nextInt();
if (newAge >= 0) {
// 年龄合理，修改学生年龄
student.setAge(newAge);
System.out.println("请您录入该学生修改后的家庭住址：");
String newAddress = SC.next();
// 修改学生家庭住址
student.setAddress(newAddress);
System.out.println("学号为" + id + "的学生修改成功！");
// 问一下是否要继续进行修改操作？
ifContinueUpdate(students);
break; // 跳出循环
} else {
System.out.println("年龄不合理！请重新录入~");
}
}
} else {
System.out.println("学号为" + id + "的学生不存在！修改失败！");
// 问一下是否要继续进行修改操作？
ifContinueUpdate(students);
}
}
/**
* 是否继续修改学生信息
*
* @param students 学生对象集合
*/
public static void ifContinueUpdate(ArrayList<Student> students) {
// 1、是否继续修改
System.out.println("您是否要继续修改学生信息？(yes/no)：");
String command = SC.next();
switch (command) {
case "yes":
// 输入的是yes，回调updateStudent方法，继续修改学生信息
updateStudent(students);
break;
default:
// 输入的是其他指令，结束修改，返回到系统首页
System.out.println("好的！修改结束！");
break;
}
}
/**
* 删除学生功能实现：根据学号删除
*
* @param students 学生对象集合
*/
public static void deleteStudent(ArrayList<Student> students) {
// 1、从键盘输入要删除的学生学号
String id;
System.out.println("请您输入要删除的学生学号：");
id = SC.next();
// 根据输入的学号获取该学生对象在集合中的索引
int studentIndex = getStudentIndex(students, id);
// 判断索引是否大于等于0
if (studentIndex >= 0) {
// 是，说明存在
// 则根据获取到的索引来获取该学生对象
Student student = students.get(studentIndex);
// 删除该学生
students.remove(student);
System.out.println("学号为" + id + "的学生删除成功！");
// 问一下是否要继续进行删除操作？
ifContinueDelete(students);
} else {
// 不存在，则提示！
System.out.println("学号为" + id + "的学生不存在！删除失败！");
// 问一下是否要继续进行删除操作？
ifContinueDelete(students);
}
}
/**
* 是否继续删除学生信息
*
* @param students 学生对象集合
*/
public static void ifContinueDelete(ArrayList<Student> students) {
// 1、是否继续删除
System.out.println("您是否要继续删除学生信息？(yes/no)：");
String command = SC.next();
switch (command) {
case "yes":
// 输入的是yes，回调deleteStudent方法，继续删除学生信息
deleteStudent(students);
break;
default:
// 输入的是其他指令，结束删除，返回到系统首页
System.out.println("好的！删除结束！");
break;
}
}
/**
* 查询所有学生信息
*
* @param students 学生对象集合
*/
public static void showStudents(ArrayList<Student> students) {
// 1、判断学生对象集合中是否存在学生
if (students.size() == 0) {
System.out.println("当前无学生信息，请添加后再查询！");
return;
}
// 2、遍历students集合，依次获取集合中每个学生对象
System.out.println("学生信息如下：");
System.out.println("\t学号\t\t\t姓名\t\t\t年龄\t\t\t家庭住址");
for (Student student : students) {
System.out.println(student.getId() + "\t\t\t"
+ student.getName() + "\t\t\t"
+ student.getAge() + "\t\t\t"
+ student.getAddress());
}
System.out.println();
}
/**
* 添加学生功能实现
*
* @param students 学生对象集合
*/
public static void addStudents(ArrayList<Student> students) {
// 1、添加学生
// a.录入学生学号
String id;
while (true) {
System.out.println("请您录入学生的学号：");
id = SC.next();
// 根据学号判断该学生对象是否存在于集合中
boolean flag = containsStudent(students, id);
if (flag) {
// 存在
System.out.println("学号为" + id + "的学生已存在！请重新录入~");
} else {
// 不存在，跳出循环，可以录入学生的其他信息
break;
}
}
// b.录入学生姓名
System.out.println("请您录入学生的姓名：");
String name = SC.next();
// c.录入学生年龄
int age;
while (true) {
System.out.println("请您录入学生的年龄：");
age = SC.nextInt();
// 判断年龄是否大于等于0
if (age >= 0) {
// 不为负数，跳出循环，可以录入学生的其他信息
break;
} else {
// 为负数
System.out.println("年龄不合理！请重新录入~");
}
}
// d.录入学生家庭住址
System.out.println("请您录入学生的家庭住址：");
String address = SC.next();
// e.所有信息录入完毕，将学生信息封装成学生对象，并添加进集合中
students.add(new Student(id, name, age, address));
System.out.println(name + "同学已成功录入奥利给学生管理系统~");
// f.添加完成一个学生对象，问一下是否要继续添加下一个学生对象？
ifContinueAdd(students);
}
/**
* 是否继续添加学生信息
*
* @param students 学生对象集合
*/
public static void ifContinueAdd(ArrayList<Student> students) {
// 1、是否继续添加
System.out.println("您是否要继续添加学生信息？(yes/no)：");
String command = SC.next();
switch (command) {
case "yes":
// 输入的是yes，回调addStudent方法，继续添加学生信息
addStudents(students);
break;
default:
// 输入的是其他指令，结束录入，返回到系统首页
System.out.println("好的！添加结束！");
break;
}
}
/**
* 查询学生学号是否已存在
*
* @param students 学生对象集合
* @param id 学生学号
* @return 存在返回true，否则返回false
*/
public static boolean containsStudent(ArrayList<Student> students, String id) {
// 如果该学生对象的索引大于等于0，说明存在，返回true
// 否则该学生对象的索引小于0，说明不存在，返回false
return getStudentIndex(students, id) >= 0;
}
/**
* 根据学生学号查询该学生对象在集合中的索引
*
* @param students 学生对象集合
* @param id 学生学号
* @return 返回该学生对象所在的索引
*/
public static int getStudentIndex(ArrayList<Student> students, String id) {
// 1、根据学生学号获取该学生对象的索引
// 遍历集合，依次获取每个学生对象
for (int i = 0; i < students.size(); i++) {
// 判断查询的学号 是否匹配 当前遍历到的学生对象的学号
if (id.equals(students.get(i).getId())) {
// 存在，返回该学生对象的在集合中的索引
return i;
}
}
// 遍历结束，仍然找不到该学号的学生对象，说明不存在。返回-1
return -1;
}
}
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
1
-----------欢迎来到用户登录界面-----------
请输入您的用户名：
HelloJava
用户名未注册，请先注册！
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
2
-----------欢迎来到用户注册界面-----------
请输入您的用户名(3~15位)：
HelloJava
请设置您的用户密码：
123123
请再次确认您的用户密码：
123123
请输入您的身份证号码：
45899820091203666X
请输入您的手机号码：
13833884384
恭喜用户：HelloJava注册成功！
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
1
-----------欢迎来到用户登录界面-----------
请输入您的用户名：
HelloJava
请输入您的密码：
123123
请您输入验证码(ch3bz)：
chdf
验证码错误！
请您输入验证码(WkUC6)：
wkuc6
用户：HelloJava登录成功！
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
4
-------查询所有学生信息-------
当前无学生信息，请添加后再查询！
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
1
-------添加学生-------
请您录入学生的学号：
ko01
请您录入学生的姓名：
刘邦
请您录入学生的年龄：
66
请您录入学生的家庭住址：
江东
刘邦同学已成功录入奥利给学生管理系统~
您是否要继续添加学生信息？(yes/no)：
yes
请您录入学生的学号：
ko01
学号为ko01的学生已存在！请重新录入~
请您录入学生的学号：
ko02
请您录入学生的姓名：
蔡文姬
请您录入学生的年龄：
34
请您录入学生的家庭住址：
许昌
蔡文姬同学已成功录入奥利给学生管理系统~
您是否要继续添加学生信息？(yes/no)：
yes
请您录入学生的学号：
ko03
请您录入学生的姓名：
张飞
请您录入学生的年龄：
45
请您录入学生的家庭住址：
广州
张飞同学已成功录入奥利给学生管理系统~
您是否要继续添加学生信息？(yes/no)：
no
好的！添加结束！
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
4
-------查询所有学生信息-------
学生信息如下：
学号 姓名 年龄 家庭住址
ko01 刘邦 66 江东
ko02 蔡文姬 34 许昌
ko03 张飞 45 广州
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
2
-------删除学生-------
请您输入要删除的学生学号：
ko05
学号为ko05的学生不存在！删除失败！
您是否要继续删除学生信息？(yes/no)：
yes
请您输入要删除的学生学号：
ko01
学号为ko01的学生删除成功！
您是否要继续删除学生信息？(yes/no)：
no
好的！删除结束！
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
4
-------查询所有学生信息-------
学生信息如下：
学号 姓名 年龄 家庭住址
ko02 蔡文姬 34 许昌
ko03 张飞 45 广州
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
3
-------修改学生-------
请您输入要修改的学生学号：
ko04
学号为ko04的学生不存在！修改失败！
您是否要继续修改学生信息？(yes/no)：
yes
请您输入要修改的学生学号：
ko02
请您录入该学生修改后的姓名：
小乔
请您录入该学生修改后的年龄：
22
请您录入该学生修改后的家庭住址：
江东
学号为ko02的学生修改成功！
您是否要继续修改学生信息？(yes/no)：
no
好的！修改结束！
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
4
-------查询所有学生信息-------
学生信息如下：
学号 姓名 年龄 家庭住址
ko02 小乔 22 江东
ko03 张飞 45 广州
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
5
好的！已退出登录！欢迎下次再来~ ^_^~
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
2
-----------欢迎来到用户注册界面-----------
请输入您的用户名(3~15位)：
U12
请设置您的用户密码：
123
请再次确认您的用户密码：
123
请输入您的身份证号码：
598789200612064455
请输入您的手机号码：
19899885483
恭喜用户：U12注册成功！
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
1
-----------欢迎来到用户登录界面-----------
请输入您的用户名：
U12
请输入您的密码：
1233
密码错误！您还有2次机会！
请输入您的密码：
123f
密码错误！您还有1次机会！
请输入您的密码：
1234f
密码已连续错误3次！登录失败！
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
1
-----------欢迎来到用户登录界面-----------
请输入您的用户名：
U12
请输入您的密码：
1233
密码错误！您还有2次机会！
请输入您的密码：
12345
密码错误！您还有1次机会！
请输入您的密码：
123
请您输入验证码(3VYKr)：
3Vykr
用户：U12登录成功！
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
5
好的！已退出登录！欢迎下次再来~ ^_^~
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
（4）忘记密码功能实现
package com.gxcj.test;
import com.gxcj.been.Student;
import com.gxcj.been.User;
import java.util.*;
/*
学生管理系统
测试类
*/
public class Test {
// 1、定义一个全局的键盘录入对象，用于从键盘录入数据
public static final Scanner SC = new Scanner(System.in);
public static void main(String[] args) {
// 2、定义一个学生对象类型的集合，用于存储学生对象
ArrayList<Student> students = new ArrayList<>();
// 3、定义一个用户对象类型的集合，用于存储用户对象
ArrayList<User> users = new ArrayList<>();
// 4、奥利给系统用户界面
systemLoginPage(users, students);
}
/**
* 奥利给系统用户界面
*
* @param users 用户对象集合
* @param students 学生对象集合
*/
public static void systemLoginPage(ArrayList<User> users, ArrayList<Student> students) {
// 1、打印学生管理系统登录页面
while (true) {
System.out.println("----------欢迎来到奥利给系统用户页面----------");
System.out.println("1: 登录\n2: 注册\n3: 忘记密码");
System.out.println("请输入您的选择: ");
String chose = SC.next();
// 2、根据输入的选择进入相应的操作界面
switch (chose) {
case "1":
userLogin(users, students); // 登录
break;
case "2":
userRegister(users); // 注册
break;
case "3":
forgetPassword(users); // 忘记密码
break;
default:
System.out.println("该功能未开发！请敬请等候~");
}
}
}
/**
* 忘记密码功能
*
* @param users 用户对象集合
*/
public static void forgetPassword(ArrayList<User> users) {
System.out.println("------------欢迎来到忘记密码界面------------");
// 1、录入用户名
System.out.println("请输入您的用户名：");
String username = SC.next();
// 根据输入的用户名获取该用户在集合中的索引
int userIndex = getUserIndex(users, username);
// 2、判断当前用户是否未注册！
if (userIndex < 0) {
// 是，未注册！
System.out.println("用户：" + username + "未注册！请先注册~");
return;
}
// 已注册！
User user; // 定义空对象用于接收方法返回的用户对象
while (true) {
// 3、录入身份证号码
// 校验输入的身份证号码是否符合要求
String IDCard = checkInputIDCard();
// 4、录入手机号码
// 校验输入的手机号码是否符合要求
String phoneNumber = checkInputPhoneNumber();
// 身份证号码和手机号码都符合要求了
// 根据该用户在集合中的索引 获取到 该用户对象
user = users.get(userIndex);
// 5、判断输入的身份证号码与手机号码 是否匹配 该用户对象的身份证号码与手机号码
if (IDCard.equals(user.getIDCard()) && phoneNumber.equals(user.getPhoneNumber())) {
// 匹配，则账号信息匹配成功！跳出while循环
break;
}else {
// 不匹配，则账号信息匹配失败！不可以修改密码
System.out.println("您的账号信息不匹配！");
}
}
// 4、while循环结束，说明账号信息匹配成功！可以修改密码
while (true) {
System.out.println("请您输入新的密码：");
String newPassword = SC.next();
System.out.println("请您再次确认新密码：");
String okPassword = SC.next();
// 判断两次输入的密码是否一致
if (newPassword.equals(okPassword)) {
// 是一致的，开始修改密码！
user.setPassword(newPassword);
System.out.println("用户：" + username + "密码修改成功！请重新登录 ~^_^~");
// 修改成功！跳出while循环
break;
}else {
System.out.println("您两次输入的密码不一致！请重新确认~");
}
}
}
/**
* 用户登录功能
*
* @param users 用户对象集合
* @param students 学生对象集合
*/
public static void userLogin(ArrayList<User> users, ArrayList<Student> students) {
System.out.println("-----------欢迎来到用户登录界面-----------");
// 1、输入用户名
System.out.println("请输入您的用户名：");
String username = SC.next();
// 得到该用户在集合中的索引
int userIndex = getUserIndex(users, username);
// 判断该用户名是否未注册！
if (userIndex < 0) {
// 是，则提示！并结束方法
System.out.println("用户：" + username + "未注册，请先注册！");
return;
}
// 已注册！
// 2、输入密码
Label:
for (int i = 0; i < 3; i++) { // i: 0 1 2
System.out.println("请输入您的密码：");
String password = SC.next();
// 根据该用户在集合中的索引 获取到 该用户对象
User user = users.get(userIndex);
// 校验密码是否正确
if (password.equals(user.getPassword())) {
// 正确，校验通过
// 3、录入验证码
// 获取验证码
String authCode = createAuthCode();
// 输入验证码
while (true) {
System.out.println("请您输入验证码" + "(" + authCode + ")：");
String inputAuthCode = SC.next();
// 判断输入的验证码 是否匹配 生成的验证码: 不区分大小写
if (inputAuthCode.equalsIgnoreCase(authCode)) {
// 匹配，登录成功！
System.out.println("用户：" + username + "登录成功！");
systemHomePage(students);
// 操作完，跳出for循环！
break Label;
} else {
// 不匹配，说明输入的验证码有误！
System.out.println("验证码错误！");
// 重新获取验证码
authCode = createAuthCode();
}
}
} else {
// 判断i是否等于2
if (i == 2) {
// 是，说明没有机会了，提示！
System.out.println("密码已连续错误3次！登录失败！");
} else {
// 否，说明还有机会，重新输入
// 第一次：2 - 0 = 2
// 第二次：2 - 1 = 1
System.out.println("密码错误！您还有" + (2 - i) + "次机会！");
}
}
}
}
/**
* 生成验证码
* 要求：
* 1、长度为5
* 2、由4位大写或小写字母和1位数字组成，同一个字母可重复。
* 3、最后1位数字可以出现在验证码中的任意位置：
* 例如：Qaa3K、2HjhP
*
* @return 返回验证码
*/
public static String createAuthCode() {
// 1、定义一个用于存储52个英文字母的数组(大小写)
char[] letters = new char[52];
// 2、遍历letters数组，依次添加52个英文字母
for (int i = 0; i < letters.length; i++) {
// 判断i是否小于等于25
if (i <= 25) {
// 是，则往数组添加26个小写的英文字母
// 依次将 'a'~'z' 26个小写字母的ASCII码转换成字符后，添加进数组中
letters[i] = (char) (97 + i);
} else {
// 否，则i是大于25的，则往数组添加26个大写的英文字母
// 依次将 'A'~'Z' 26个大写字母的ASCII码转换成字符后，添加进数组中
/*
为什么要减26？因为此时i已经大于25了，也就是26了。
那么第一次就是：65 + 26 - 26 = 65
第二次就是：65 + 27 - 26 = 66
第三次就是：65 + 28 - 26 = 67
后面的就依次类推！
*/
letters[i] = (char) (65 + i - 26);
}
}
// for循环结束，52个英文字母已经添加完毕！
// 3、定义空字符串，用于拼接5位生成的验证码
String authCode = "";
// 4、随机生成4位英文字母验证码
// 创建随机数对象，用于生成一个随机索引
Random rd = new Random();
for (int i = 0; i < 4; i++) { // i: 0 1 2 3
// 生成一个随机索引，长度为52个英文字母数组的长度
int randomIndex = rd.nextInt(letters.length);
// 依次将随机生成的英文字母拼接起来
authCode += letters[randomIndex];
}
// 5、随机生成1位0~9之间的数字验证码
int randomNumber = rd.nextInt(10);
// 将随机生成的数字 与 4位英文字母验证码拼接起来
authCode += randomNumber;
// 6、将生成的5位验证码进行顺序打乱
// 将字符串转换成字符数组
char[] chars = authCode.toCharArray();
// 遍历chars数组，依次获取每个验证码字符
for (int i = 0; i < chars.length; i++) {
// 随机生成一个5之内的索引
int randomIndex = rd.nextInt(5);
// 用临时变量将当前获取到的验证码字符存储起来
char temp = chars[i];
// 开始交换位置：
// 将随机索引位置的验证码字符 放到 当前获取到的验证码的索引位置
chars[i] = chars[randomIndex];
// 将当前获取到的验证码字符 放到 随机索引的位置
chars[randomIndex] = temp;
}
// for循环结束，顺序已经全部打乱
// 7、将字符数组转换成字符串
authCode = new String(chars);
// 8、返回验证码
return authCode;
}
/**
* 用户注册功能
*
* @param users 用户对象集合
*/
public static void userRegister(ArrayList<User> users) {
System.out.println("-----------欢迎来到用户注册界面-----------");
// 1、定义空用户对象，用于封装录入的用户信息为一个用户对象。
User user = new User();
// 2、录入用户名
// 校验输入的用户名是否符合要求
String username = checkInputUsername(users);
// 符合要求，录入用户名
user.setUsername(username);
// 3、录入密码
while (true) {
System.out.println("请设置您的用户密码：");
String password = SC.next();
System.out.println("请再次确认您的用户密码：");
String okPassword = SC.next();
// 判断两次输入的密码是否是一致的
if (password.equals(okPassword)) {
// 是，则录入密码
user.setPassword(password);
// 密码录入完成，跳出循环
break;
} else {
// 不是，则重新输入密码
System.out.println("您两次输入的密码不一致！请重新输入~");
}
}
// 4、录入身份证号码
// 校验输入的身份证号码是否符合要求
String IDCard = checkInputIDCard();
// 符合要求，录入该身份证号码
user.setIDCard(IDCard);
// 5、录入手机号码
// 校验输入的手机号码是否符合要求
String phoneNumber = checkInputPhoneNumber();
// 符合要求，录入手机号码
user.setPhoneNumber(phoneNumber);
// 6、将封装了用户信息的用户对象添加进集合中
users.add(user);
System.out.println("恭喜用户：" + username + "注册成功！");
}
/**
* 校验输入的手机号码
* 要求：
* 1、长度为11位
* 2、必须都是数字
* 3、不能以0开头
*
* @return 返回通过校验的手机号码
*/
public static String checkInputPhoneNumber() {
// 1、定义变量用于接收输入的手机号码
String phoneNumber;
// 2、开始校验手机号码
while (true) {
System.out.println("请输入您的手机号码：");
phoneNumber = SC.next();
// 要求：长度为11位、不能以0开头、必须都是数字
int len = phoneNumber.length(); // 得到手机号码的长度
// a.判断手机号码是否为11位
if (len == 11) {
// 是，符合要求
int count = 0; // 定义计数器，用于统计不为数字的字符个数
// 遍历手机号码，依次获取到每个字符
for (int i = 0; i < len; i++) {
// 得到每个字符
char c = phoneNumber.charAt(i);
// b.判断手机号码是否不为数字
if (!(c >= '0' && c <= '9')) {
// 是，则统计不为数字的字符的个数
count++;
// 只要出现一个不是数字的字符，就跳出遍历了！
break;
}
}
// 遍历结束，判断不为数字的字符个数是否大于0
if (count > 0) {
// 是，则提示！
System.out.println("手机号码必须都是数字！");
} else {
// 否，符合要求
// 获取首字符
char c = phoneNumber.charAt(0);
// c.判断手机号码是否以0开头
if (c == '0') {
// 是，则提示！
System.out.println("手机号码不能以0开头！");
} else {
// 否，符合要求，校验通过，跳出while循环
break;
}
}
} else {
// 否，则提示！
System.out.println("手机号码长度必须为11位！");
}
}
// 循环结束，返回手机号码
return phoneNumber;
}
/**
* 校验输入的身份证号码
* 要求：
* 1、长度为18位
* 2、不能以0开头
* 3、前17位必须都是数字
* 4、最后一位可以是数字，也可以是大写的字母X 或 小写的字母x
*
* @return 返回通过校验的身份证号码
*/
public static String checkInputIDCard() {
// 1、定义变量接收输入的身份证号码
String IDCard;
// 2、校验
while (true) {
System.out.println("请输入您的身份证号码：");
IDCard = SC.next();
// 记录身份证号码的长度
int len = IDCard.length();
// a.判断身份证号码的长度是否为18位
if (len == 18) {
// 是，符合要求
// b.判断身份证号码是否以0开头
if (IDCard.charAt(0) == '0') {
// 是，则提示！
System.out.println("身份证号码不能以0开头！");
} else {
// 否，符合要求
// 取出身份证号码的前17位
String id17 = IDCard.substring(0, 17);
// 定义计数器，用于统计前17位有多少个字符不是数字的个数
int count = 0;
// 遍历身份证前17位，依次得到每个字符
for (int i = 0; i < id17.length(); i++) {
// 接收每个字符
char ch = IDCard.charAt(i);
// c.判断该字符是否都不为数字
if (!(ch >= '0' && ch <= '9')) {
// 是，则统计不为数字的字符个数
count++;
// 只要出现一个不是数字的字符，就跳出遍历了！
break;
}
}
// 遍历结束，判断不为数字的个数是否大于0
if (count > 0) {
// 是，则提示！
System.out.println("身份证号码的前17位必须都是数字！");
} else {
// 否，符合要求
// 取出身份证号码的最后一位字符
char c = IDCard.charAt(17);
// d.判断最后一位字符是否为数字或为'X'或为'x'
if ((c >= '0' && c <= '9') || c == 'X' || c == 'x') {
// 是，符合要求，校验通过，跳出while循环
break;
} else {
// 否，则提示！
System.out.println("身份证号码的最后一位必须为数字，也可以为X或x！");
}
}
}
} else {
// 否，则提示！
System.out.println("身份证号码必须是18位！");
}
}
// 3、循环结束，返回身份证号码
return IDCard;
}
/**
* 校验输入的用户名
* 要求：
* 1、用户名唯一
* 2、用户名长度必须在3~15位之间
* 3、只能是字符加数字的组合，但是不能是纯数字
*
* @param users 用户对象集合
* @return 返回符合以上要求的用户名
*/
public static String checkInputUsername(ArrayList<User> users) {
/*
开发细节：先验证格式是否正确，再验证是否唯一
因为在以后所有的数据，都是存在数据库中，如果我们要校验，需要使用到网络资源。
*/
// 1、输入用户名
String username; // 定义变量，接收输入的用户名
while (true) {
System.out.println("请输入您的用户名(3~15位)：");
username = SC.next();
// 开始校验该用户名的长度是否符合3~15位
int len = username.length(); // 存储用户名的长度
if (len >= 3 && len <= 15) {
// 标记：表示用户名的每个字符都符合内容要求
boolean flag = true;
// 用户名长度符合要求，遍历用户名，依次得到每个字符
for (int i = 0; i < len; i++) {
// 接收每个字符
char ch = username.charAt(i);
// 判断该用户名的每个字符是否不在大写字母或者小写字母或者数字之间
if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9'))) {
// 是，则说明该用户名不符合内容要求，flag的值改为false
flag = false;
}
}
// 遍历结束，判断flag的值是否为true
if (flag) {
// 为true，则说明用户名内容符合要求：是字母加数字的组合
// 用户名不能是纯数字
int count = 0; // 定义计数器，用于记录符合字母范围要求的字符个数
// 遍历用户名，依次得到每个字符
for (int i = 0; i < len; i++) {
// 接收每个字符
char ch = username.charAt(i);
// 判断该用户名的每个字符是否在大写字母范围 或 小写字母范围
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
// 是，则统计符合字母范围的字符个数
count++;
// 只要看到1个字母，就没有判断其他字符了
break;
}
}
// 遍历结束，判断字符个数是否大于0
if (count > 0) {
// 是，说明不是纯数字，符合要求
// 现在开始校验用户名的唯一性
if (containsUser(users, username)) {
// 为true，则说明该用户已存在！
System.out.println("用户：" + username + "已经注册了！");
} else {
// 为false，则说明该用户不存在！跳出循环
break;
}
} else {
// 不是，说明是纯数字，则提示！
System.out.println("用户名不能是纯数字！");
}
} else {
// 为false，则说明用户名内容不符合要求：不是字母加数字的组合
System.out.println("用户名必须是字母加数字的组合！");
}
} else {
// 用户名长度超出范围
System.out.println("用户名长度必须在3~15位之间！");
}
}
// 所有要求校验通过，返回用户名
return username;
}
/**
* 查询用户名是否已存在
*
* @param users 用户对象集合
* @param username 用户名
* @return 存在返回true，否则返回false
*/
public static boolean containsUser(ArrayList<User> users, String username) {
// 如果该用户的索引大于等于0，说明存在，返回true
// 否则该用户的索引小于0，说明不存在，返回false
return getUserIndex(users, username) >= 0;
}
/**
* 根据用户名查询该用户对象在集合中的索引
*
* @param users 用户对象集合
* @param username 用户名
* @return 返回该用户对象所在的索引
*/
public static int getUserIndex(ArrayList<User> users, String username) {
// 1、根据用户名获取该用户对象的索引
// 遍历集合，依次获取每个用户对象
for (int i = 0; i < users.size(); i++) {
// 判断查询的用户名 是否匹配 当前遍历到的用户对象的用户名
if (username.equals(users.get(i).getUsername())) {
// 存在，返回该用户对象的索引
return i;
}
}
// 遍历结束，仍然找不到该用户名的用户对象，说明不存在。返回-1
return -1;
}
/**
* 学生管理系统首页
*
* @param students 学生对象集合
*/
public static void systemHomePage(ArrayList<Student> students) {
// 1、打印学生管理系统操作页面
while (true) {
System.out.println("----------欢迎来到奥利给学生管理系统操作页面----------");
System.out.println("1: 添加学生\n2: 删除学生\n3: 修改学生\n4: 查询学生\n5: 退出登录");
System.out.println("请输入您的选择: ");
// 2、接收输入的选择
String select = SC.next();
// 3、switch判断该选择是哪个功能
switch (select) {
case "1":
// 添加学生
System.out.println("-------添加学生-------");
addStudents(students);
break; // 跳出switch，回到首页面
case "2":
// 删除学生
System.out.println("-------删除学生-------");
deleteStudent(students);
break; // 跳出switch，回到首页面
case "3":
// 修改学生
System.out.println("-------修改学生-------");
updateStudent(students);
break; // 跳出switch，回到首页面
case "4":
// 查询所有学生信息
System.out.println("-------查询所有学生信息-------");
showStudents(students);
break; // 跳出switch，回到首页面
case "5":
// 退出系统
System.out.println("好的！已退出登录！欢迎下次再来~ ^_^~");
return; // 结束systemHomePage方法
default:
// 其他选择
System.out.println("该功能未开发！请敬请等候~");
break; // 跳出switch，回到首页面
}
}
}
/**
* 修改学生信息功能实现：根据学号修改
*
* @param students 学生对象集合
*/
public static void updateStudent(ArrayList<Student> students) {
// 1、从键盘输入要修改的学生学号
String id;
System.out.println("请您输入要修改的学生学号：");
id = SC.next();
// 根据输入的学号获取该学生对象在集合中的索引
int studentIndex = getStudentIndex(students, id);
// 判断索引是否大于等于0
if (studentIndex >= 0) {
// 存在
// 则根据获取到的索引来获取该学生对象
Student student = students.get(studentIndex);
// 修改该学生的其他信息
System.out.println("请您录入该学生修改后的姓名：");
String newName = SC.next();
// 修改学生姓名
student.setName(newName);
while (true) {
System.out.println("请您录入该学生修改后的年龄：");
int newAge = SC.nextInt();
if (newAge >= 0) {
// 年龄合理，修改学生年龄
student.setAge(newAge);
System.out.println("请您录入该学生修改后的家庭住址：");
String newAddress = SC.next();
// 修改学生家庭住址
student.setAddress(newAddress);
System.out.println("学号为" + id + "的学生修改成功！");
// 问一下是否要继续进行修改操作？
ifContinueUpdate(students);
break; // 跳出循环
} else {
System.out.println("年龄不合理！请重新录入~");
}
}
} else {
System.out.println("学号为" + id + "的学生不存在！修改失败！");
// 问一下是否要继续进行修改操作？
ifContinueUpdate(students);
}
}
/**
* 是否继续修改学生信息
*
* @param students 学生对象集合
*/
public static void ifContinueUpdate(ArrayList<Student> students) {
// 1、是否继续修改
System.out.println("您是否要继续修改学生信息？(yes/no)：");
String command = SC.next();
switch (command) {
case "yes":
// 输入的是yes，回调updateStudent方法，继续修改学生信息
updateStudent(students);
break;
default:
// 输入的是其他指令，结束修改，返回到系统首页
System.out.println("好的！修改结束！");
break;
}
}
/**
* 删除学生功能实现：根据学号删除
*
* @param students 学生对象集合
*/
public static void deleteStudent(ArrayList<Student> students) {
// 1、从键盘输入要删除的学生学号
String id;
System.out.println("请您输入要删除的学生学号：");
id = SC.next();
// 根据输入的学号获取该学生对象在集合中的索引
int studentIndex = getStudentIndex(students, id);
// 判断索引是否大于等于0
if (studentIndex >= 0) {
// 是，说明存在
// 则根据获取到的索引来获取该学生对象
Student student = students.get(studentIndex);
// 删除该学生
students.remove(student);
System.out.println("学号为" + id + "的学生删除成功！");
// 问一下是否要继续进行删除操作？
ifContinueDelete(students);
} else {
// 不存在，则提示！
System.out.println("学号为" + id + "的学生不存在！删除失败！");
// 问一下是否要继续进行删除操作？
ifContinueDelete(students);
}
}
/**
* 是否继续删除学生信息
*
* @param students 学生对象集合
*/
public static void ifContinueDelete(ArrayList<Student> students) {
// 1、是否继续删除
System.out.println("您是否要继续删除学生信息？(yes/no)：");
String command = SC.next();
switch (command) {
case "yes":
// 输入的是yes，回调deleteStudent方法，继续删除学生信息
deleteStudent(students);
break;
default:
// 输入的是其他指令，结束删除，返回到系统首页
System.out.println("好的！删除结束！");
break;
}
}
/**
* 查询所有学生信息
*
* @param students 学生对象集合
*/
public static void showStudents(ArrayList<Student> students) {
// 1、判断学生对象集合中是否存在学生
if (students.size() == 0) {
System.out.println("当前无学生信息，请添加后再查询！");
return;
}
// 2、遍历students集合，依次获取集合中每个学生对象
System.out.println("学生信息如下：");
System.out.println("\t学号\t\t\t姓名\t\t\t年龄\t\t\t家庭住址");
for (Student student : students) {
System.out.println(student.getId() + "\t\t\t"
+ student.getName() + "\t\t\t"
+ student.getAge() + "\t\t\t"
+ student.getAddress());
}
System.out.println();
}
/**
* 添加学生功能实现
*
* @param students 学生对象集合
*/
public static void addStudents(ArrayList<Student> students) {
// 1、添加学生
// a.录入学生学号
String id;
while (true) {
System.out.println("请您录入学生的学号：");
id = SC.next();
// 根据学号判断该学生对象是否存在于集合中
boolean flag = containsStudent(students, id);
if (flag) {
// 存在
System.out.println("学号为" + id + "的学生已存在！请重新录入~");
} else {
// 不存在，跳出循环，可以录入学生的其他信息
break;
}
}
// b.录入学生姓名
System.out.println("请您录入学生的姓名：");
String name = SC.next();
// c.录入学生年龄
int age;
while (true) {
System.out.println("请您录入学生的年龄：");
age = SC.nextInt();
// 判断年龄是否大于等于0
if (age >= 0) {
// 不为负数，跳出循环，可以录入学生的其他信息
break;
} else {
// 为负数
System.out.println("年龄不合理！请重新录入~");
}
}
// d.录入学生家庭住址
System.out.println("请您录入学生的家庭住址：");
String address = SC.next();
// e.所有信息录入完毕，将学生信息封装成学生对象，并添加进集合中
students.add(new Student(id, name, age, address));
System.out.println(name + "同学已成功录入奥利给学生管理系统~");
// f.添加完成一个学生对象，问一下是否要继续添加下一个学生对象？
ifContinueAdd(students);
}
/**
* 是否继续添加学生信息
*
* @param students 学生对象集合
*/
public static void ifContinueAdd(ArrayList<Student> students) {
// 1、是否继续添加
System.out.println("您是否要继续添加学生信息？(yes/no)：");
String command = SC.next();
switch (command) {
case "yes":
// 输入的是yes，回调addStudent方法，继续添加学生信息
addStudents(students);
break;
default:
// 输入的是其他指令，结束录入，返回到系统首页
System.out.println("好的！添加结束！");
break;
}
}
/**
* 查询学生学号是否已存在
*
* @param students 学生对象集合
* @param id 学生学号
* @return 存在返回true，否则返回false
*/
public static boolean containsStudent(ArrayList<Student> students, String id) {
// 如果该学生对象的索引大于等于0，说明存在，返回true
// 否则该学生对象的索引小于0，说明不存在，返回false
return getStudentIndex(students, id) >= 0;
}
/**
* 根据学生学号查询该学生对象在集合中的索引
*
* @param students 学生对象集合
* @param id 学生学号
* @return 返回该学生对象所在的索引
*/
public static int getStudentIndex(ArrayList<Student> students, String id) {
// 1、根据学生学号获取该学生对象的索引
// 遍历集合，依次获取每个学生对象
for (int i = 0; i < students.size(); i++) {
// 判断查询的学号 是否匹配 当前遍历到的学生对象的学号
if (id.equals(students.get(i).getId())) {
// 存在，返回该学生对象的在集合中的索引
return i;
}
}
// 遍历结束，仍然找不到该学号的学生对象，说明不存在。返回-1
return -1;
}
}
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
3
------------欢迎来到忘记密码界面------------
请输入您的用户名：
Hello
用户：Hello未注册！请先注册~
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
2
-----------欢迎来到用户注册界面-----------
请输入您的用户名(3~15位)：
Hello
请设置您的用户密码：
123ad
请再次确认您的用户密码：
123ad
请输入您的身份证号码：
789998201903061166
请输入您的手机号码：
13833884834
恭喜用户：Hello注册成功！
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
3
------------欢迎来到忘记密码界面------------
请输入您的用户名：
Hello
请输入您的身份证号码：
78999820190306116
身份证号码必须是18位！
请输入您的身份证号码：
78999820190306116X
请输入您的手机号码：
13833884834
您的账号信息不匹配！
请输入您的身份证号码：
78999820190306116
身份证号码必须是18位！
请输入您的身份证号码：
789998201903061166
请输入您的手机号码：
13833884822
您的账号信息不匹配！
请输入您的身份证号码：
78999820190306116x
请输入您的手机号码：
13833884822
您的账号信息不匹配！
请输入您的身份证号码：
789998201903061166
请输入您的手机号码：
13833884834
请您输入新的密码：
tt1122
请您再次确认新密码：
tt1133
您两次输入的密码不一致！请重新确认~
请您输入新的密码：
gg33
请您再次确认新密码：
gg33
用户：Hello密码修改成功！请重新登录 ~^_^~
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
1
-----------欢迎来到用户登录界面-----------
请输入您的用户名：
Hello
请输入您的密码：
gg334
密码错误！您还有2次机会！
请输入您的密码：
gg33
请您输入验证码(V2MIq)：
v2miq
用户：Hello登录成功！
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
5
好的！已退出登录！欢迎下次再来~ ^_^~
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
3、测试
package com.gxcj.test;
import com.gxcj.been.Student;
import com.gxcj.been.User;
import java.util.*;
/*
学生管理系统
测试类
*/
public class Test {
// 1、定义一个全局的键盘录入对象，用于从键盘录入数据
public static final Scanner SC = new Scanner(System.in);
public static void main(String[] args) {
// 2、定义一个学生对象类型的集合，用于存储学生对象
ArrayList<Student> students = new ArrayList<>();
// 3、定义一个用户对象类型的集合，用于存储用户对象
ArrayList<User> users = new ArrayList<>();
// 4、奥利给系统用户界面
systemLoginPage(users, students);
}
/**
* 奥利给系统用户界面
*
* @param users 用户对象集合
* @param students 学生对象集合
*/
public static void systemLoginPage(ArrayList<User> users, ArrayList<Student> students) {
// 1、打印学生管理系统登录页面
while (true) {
System.out.println("----------欢迎来到奥利给系统用户页面----------");
System.out.println("1: 登录\n2: 注册\n3: 忘记密码");
System.out.println("请输入您的选择: ");
String chose = SC.next();
// 2、根据输入的选择进入相应的操作界面
switch (chose) {
case "1":
userLogin(users, students); // 登录
break;
case "2":
userRegister(users); // 注册
break;
case "3":
forgetPassword(users); // 忘记密码
break;
default:
System.out.println("该功能未开发！请敬请等候~");
}
}
}
/**
* 忘记密码功能
*
* @param users 用户对象集合
*/
public static void forgetPassword(ArrayList<User> users) {
System.out.println("------------欢迎来到忘记密码界面------------");
// 1、录入用户名
System.out.println("请输入您的用户名：");
String username = SC.next();
// 根据输入的用户名获取该用户在集合中的索引
int userIndex = getUserIndex(users, username);
// 2、判断当前用户是否未注册！
if (userIndex < 0) {
// 是，未注册！
System.out.println("用户：" + username + "未注册！请先注册~");
return;
}
// 已注册！
User user; // 定义空对象用于接收方法返回的用户对象
while (true) {
// 3、录入身份证号码
// 校验输入的身份证号码是否符合要求
String IDCard = checkInputIDCard();
// 4、录入手机号码
// 校验输入的手机号码是否符合要求
String phoneNumber = checkInputPhoneNumber();
// 身份证号码和手机号码都符合要求了
// 根据该用户在集合中的索引 获取到 该用户对象
user = users.get(userIndex);
// 5、判断输入的身份证号码与手机号码 是否匹配 该用户对象的身份证号码与手机号码
if (IDCard.equals(user.getIDCard()) && phoneNumber.equals(user.getPhoneNumber())) {
// 匹配，则账号信息匹配成功！跳出while循环
break;
}else {
// 不匹配，则账号信息匹配失败！不可以修改密码
System.out.println("您的账号信息不匹配！");
}
}
// 4、while循环结束，说明账号信息匹配成功！可以修改密码
while (true) {
System.out.println("请您输入新的密码：");
String newPassword = SC.next();
System.out.println("请您再次确认新密码：");
String okPassword = SC.next();
// 判断两次输入的密码是否一致
if (newPassword.equals(okPassword)) {
// 是一致的，开始修改密码！
user.setPassword(newPassword);
System.out.println("用户：" + username + "密码修改成功！请重新登录 ~^_^~");
// 修改成功！跳出while循环
break;
}else {
System.out.println("您两次输入的密码不一致！请重新确认~");
}
}
}
/**
* 用户登录功能
*
* @param users 用户对象集合
* @param students 学生对象集合
*/
public static void userLogin(ArrayList<User> users, ArrayList<Student> students) {
System.out.println("-----------欢迎来到用户登录界面-----------");
// 1、输入用户名
System.out.println("请输入您的用户名：");
String username = SC.next();
// 得到该用户在集合中的索引
int userIndex = getUserIndex(users, username);
// 判断该用户名是否未注册！
if (userIndex < 0) {
// 是，则提示！并结束方法
System.out.println("用户：" + username + "未注册，请先注册！");
return;
}
// 已注册！
// 2、输入密码
Label:
for (int i = 0; i < 3; i++) { // i: 0 1 2
System.out.println("请输入您的密码：");
String password = SC.next();
// 根据该用户在集合中的索引 获取到 该用户对象
User user = users.get(userIndex);
// 校验密码是否正确
if (password.equals(user.getPassword())) {
// 正确，校验通过
// 3、录入验证码
// 获取验证码
String authCode = createAuthCode();
// 输入验证码
while (true) {
System.out.println("请您输入验证码" + "(" + authCode + ")：");
String inputAuthCode = SC.next();
// 判断输入的验证码 是否匹配 生成的验证码: 不区分大小写
if (inputAuthCode.equalsIgnoreCase(authCode)) {
// 匹配，登录成功！
System.out.println("用户：" + username + "登录成功！");
systemHomePage(students);
// 操作完，跳出for循环！
break Label;
} else {
// 不匹配，说明输入的验证码有误！
System.out.println("验证码错误！");
// 重新获取验证码
authCode = createAuthCode();
}
}
} else {
// 判断i是否等于2
if (i == 2) {
// 是，说明没有机会了，提示！
System.out.println("密码已连续错误3次！登录失败！");
} else {
// 否，说明还有机会，重新输入
// 第一次：2 - 0 = 2
// 第二次：2 - 1 = 1
System.out.println("密码错误！您还有" + (2 - i) + "次机会！");
}
}
}
}
/**
* 生成验证码
* 要求：
* 1、长度为5
* 2、由4位大写或小写字母和1位数字组成，同一个字母可重复。
* 3、最后1位数字可以出现在验证码中的任意位置：
* 例如：Qaa3K、2HjhP
*
* @return 返回验证码
*/
public static String createAuthCode() {
// 1、定义一个用于存储52个英文字母的数组(大小写)
char[] letters = new char[52];
// 2、遍历letters数组，依次添加52个英文字母
for (int i = 0; i < letters.length; i++) {
// 判断i是否小于等于25
if (i <= 25) {
// 是，则往数组添加26个小写的英文字母
// 依次将 'a'~'z' 26个小写字母的ASCII码转换成字符后，添加进数组中
letters[i] = (char) (97 + i);
} else {
// 否，则i是大于25的，则往数组添加26个大写的英文字母
// 依次将 'A'~'Z' 26个大写字母的ASCII码转换成字符后，添加进数组中
/*
为什么要减26？因为此时i已经大于25了，也就是26了。
那么第一次就是：65 + 26 - 26 = 65
第二次就是：65 + 27 - 26 = 66
第三次就是：65 + 28 - 26 = 67
后面的就依次类推！
*/
letters[i] = (char) (65 + i - 26);
}
}
// for循环结束，52个英文字母已经添加完毕！
// 3、定义空字符串，用于拼接5位生成的验证码
String authCode = "";
// 4、随机生成4位英文字母验证码
// 创建随机数对象，用于生成一个随机索引
Random rd = new Random();
for (int i = 0; i < 4; i++) { // i: 0 1 2 3
// 生成一个随机索引，长度为52个英文字母数组的长度
int randomIndex = rd.nextInt(letters.length);
// 依次将随机生成的英文字母拼接起来
authCode += letters[randomIndex];
}
// 5、随机生成1位0~9之间的数字验证码
int randomNumber = rd.nextInt(10);
// 将随机生成的数字 与 4位英文字母验证码拼接起来
authCode += randomNumber;
// 6、将生成的5位验证码进行顺序打乱
// 将字符串转换成字符数组
char[] chars = authCode.toCharArray();
// 遍历chars数组，依次获取每个验证码字符
for (int i = 0; i < chars.length; i++) {
// 随机生成一个5之内的索引
int randomIndex = rd.nextInt(5);
// 用临时变量将当前获取到的验证码字符存储起来
char temp = chars[i];
// 开始交换位置：
// 将随机索引位置的验证码字符 放到 当前获取到的验证码的索引位置
chars[i] = chars[randomIndex];
// 将当前获取到的验证码字符 放到 随机索引的位置
chars[randomIndex] = temp;
}
// for循环结束，顺序已经全部打乱
// 7、将字符数组转换成字符串
authCode = new String(chars);
// 8、返回验证码
return authCode;
}
/**
* 用户注册功能
*
* @param users 用户对象集合
*/
public static void userRegister(ArrayList<User> users) {
System.out.println("-----------欢迎来到用户注册界面-----------");
// 1、定义空用户对象，用于封装录入的用户信息为一个用户对象。
User user = new User();
// 2、录入用户名
// 校验输入的用户名是否符合要求
String username = checkInputUsername(users);
// 符合要求，录入用户名
user.setUsername(username);
// 3、录入密码
while (true) {
System.out.println("请设置您的用户密码：");
String password = SC.next();
System.out.println("请再次确认您的用户密码：");
String okPassword = SC.next();
// 判断两次输入的密码是否是一致的
if (password.equals(okPassword)) {
// 是，则录入密码
user.setPassword(password);
// 密码录入完成，跳出循环
break;
} else {
// 不是，则重新输入密码
System.out.println("您两次输入的密码不一致！请重新输入~");
}
}
// 4、录入身份证号码
// 校验输入的身份证号码是否符合要求
String IDCard = checkInputIDCard();
// 符合要求，录入该身份证号码
user.setIDCard(IDCard);
// 5、录入手机号码
// 校验输入的手机号码是否符合要求
String phoneNumber = checkInputPhoneNumber();
// 符合要求，录入手机号码
user.setPhoneNumber(phoneNumber);
// 6、将封装了用户信息的用户对象添加进集合中
users.add(user);
System.out.println("恭喜用户：" + username + "注册成功！");
}
/**
* 校验输入的手机号码
* 要求：
* 1、长度为11位
* 2、必须都是数字
* 3、不能以0开头
*
* @return 返回通过校验的手机号码
*/
public static String checkInputPhoneNumber() {
// 1、定义变量用于接收输入的手机号码
String phoneNumber;
// 2、开始校验手机号码
while (true) {
System.out.println("请输入您的手机号码：");
phoneNumber = SC.next();
// 要求：长度为11位、不能以0开头、必须都是数字
int len = phoneNumber.length(); // 得到手机号码的长度
// a.判断手机号码是否为11位
if (len == 11) {
// 是，符合要求
int count = 0; // 定义计数器，用于统计不为数字的字符个数
// 遍历手机号码，依次获取到每个字符
for (int i = 0; i < len; i++) {
// 得到每个字符
char c = phoneNumber.charAt(i);
// b.判断手机号码是否不为数字
if (!(c >= '0' && c <= '9')) {
// 是，则统计不为数字的字符的个数
count++;
// 只要出现一个不是数字的字符，就跳出遍历了！
break;
}
}
// 遍历结束，判断不为数字的字符个数是否大于0
if (count > 0) {
// 是，则提示！
System.out.println("手机号码必须都是数字！");
} else {
// 否，符合要求
// 获取首字符
char c = phoneNumber.charAt(0);
// c.判断手机号码是否以0开头
if (c == '0') {
// 是，则提示！
System.out.println("手机号码不能以0开头！");
} else {
// 否，符合要求，校验通过，跳出while循环
break;
}
}
} else {
// 否，则提示！
System.out.println("手机号码长度必须为11位！");
}
}
// 循环结束，返回手机号码
return phoneNumber;
}
/**
* 校验输入的身份证号码
* 要求：
* 1、长度为18位
* 2、不能以0开头
* 3、前17位必须都是数字
* 4、最后一位可以是数字，也可以是大写的字母X 或 小写的字母x
*
* @return 返回通过校验的身份证号码
*/
public static String checkInputIDCard() {
// 1、定义变量接收输入的身份证号码
String IDCard;
// 2、校验
while (true) {
System.out.println("请输入您的身份证号码：");
IDCard = SC.next();
// 记录身份证号码的长度
int len = IDCard.length();
// a.判断身份证号码的长度是否为18位
if (len == 18) {
// 是，符合要求
// b.判断身份证号码是否以0开头
if (IDCard.charAt(0) == '0') {
// 是，则提示！
System.out.println("身份证号码不能以0开头！");
} else {
// 否，符合要求
// 取出身份证号码的前17位
String id17 = IDCard.substring(0, 17);
// 定义计数器，用于统计前17位有多少个字符不是数字的个数
int count = 0;
// 遍历身份证前17位，依次得到每个字符
for (int i = 0; i < id17.length(); i++) {
// 接收每个字符
char ch = IDCard.charAt(i);
// c.判断该字符是否都不为数字
if (!(ch >= '0' && ch <= '9')) {
// 是，则统计不为数字的字符个数
count++;
// 只要出现一个不是数字的字符，就跳出遍历了！
break;
}
}
// 遍历结束，判断不为数字的个数是否大于0
if (count > 0) {
// 是，则提示！
System.out.println("身份证号码的前17位必须都是数字！");
} else {
// 否，符合要求
// 取出身份证号码的最后一位字符
char c = IDCard.charAt(17);
// d.判断最后一位字符是否为数字或为'X'或为'x'
if ((c >= '0' && c <= '9') || c == 'X' || c == 'x') {
// 是，符合要求，校验通过，跳出while循环
break;
} else {
// 否，则提示！
System.out.println("身份证号码的最后一位必须为数字，也可以为X或x！");
}
}
}
} else {
// 否，则提示！
System.out.println("身份证号码必须是18位！");
}
}
// 3、循环结束，返回身份证号码
return IDCard;
}
/**
* 校验输入的用户名
* 要求：
* 1、用户名唯一
* 2、用户名长度必须在3~15位之间
* 3、只能是字符加数字的组合，但是不能是纯数字
*
* @param users 用户对象集合
* @return 返回符合以上要求的用户名
*/
public static String checkInputUsername(ArrayList<User> users) {
/*
开发细节：先验证格式是否正确，再验证是否唯一
因为在以后所有的数据，都是存在数据库中，如果我们要校验，需要使用到网络资源。
*/
// 1、输入用户名
String username; // 定义变量，接收输入的用户名
while (true) {
System.out.println("请输入您的用户名(3~15位)：");
username = SC.next();
// 开始校验该用户名的长度是否符合3~15位
int len = username.length(); // 存储用户名的长度
if (len >= 3 && len <= 15) {
// 标记：表示用户名的每个字符都符合内容要求
boolean flag = true;
// 用户名长度符合要求，遍历用户名，依次得到每个字符
for (int i = 0; i < len; i++) {
// 接收每个字符
char ch = username.charAt(i);
// 判断该用户名的每个字符是否不在大写字母或者小写字母或者数字之间
if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9'))) {
// 是，则说明该用户名不符合内容要求，flag的值改为false
flag = false;
}
}
// 遍历结束，判断flag的值是否为true
if (flag) {
// 为true，则说明用户名内容符合要求：是字母加数字的组合
// 用户名不能是纯数字
int count = 0; // 定义计数器，用于记录符合字母范围要求的字符个数
// 遍历用户名，依次得到每个字符
for (int i = 0; i < len; i++) {
// 接收每个字符
char ch = username.charAt(i);
// 判断该用户名的每个字符是否在大写字母范围 或 小写字母范围
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
// 是，则统计符合字母范围的字符个数
count++;
// 只要看到1个字母，就没有判断其他字符了
break;
}
}
// 遍历结束，判断字符个数是否大于0
if (count > 0) {
// 是，说明不是纯数字，符合要求
// 现在开始校验用户名的唯一性
if (containsUser(users, username)) {
// 为true，则说明该用户已存在！
System.out.println("用户：" + username + "已经注册了！");
} else {
// 为false，则说明该用户不存在！跳出循环
break;
}
} else {
// 不是，说明是纯数字，则提示！
System.out.println("用户名不能是纯数字！");
}
} else {
// 为false，则说明用户名内容不符合要求：不是字母加数字的组合
System.out.println("用户名必须是字母加数字的组合！");
}
} else {
// 用户名长度超出范围
System.out.println("用户名长度必须在3~15位之间！");
}
}
// 所有要求校验通过，返回用户名
return username;
}
/**
* 查询用户名是否已存在
*
* @param users 用户对象集合
* @param username 用户名
* @return 存在返回true，否则返回false
*/
public static boolean containsUser(ArrayList<User> users, String username) {
// 如果该用户的索引大于等于0，说明存在，返回true
// 否则该用户的索引小于0，说明不存在，返回false
return getUserIndex(users, username) >= 0;
}
/**
* 根据用户名查询该用户对象在集合中的索引
*
* @param users 用户对象集合
* @param username 用户名
* @return 返回该用户对象所在的索引
*/
public static int getUserIndex(ArrayList<User> users, String username) {
// 1、根据用户名获取该用户对象的索引
// 遍历集合，依次获取每个用户对象
for (int i = 0; i < users.size(); i++) {
// 判断查询的用户名 是否匹配 当前遍历到的用户对象的用户名
if (username.equals(users.get(i).getUsername())) {
// 存在，返回该用户对象的索引
return i;
}
}
// 遍历结束，仍然找不到该用户名的用户对象，说明不存在。返回-1
return -1;
}
/**
* 学生管理系统首页
*
* @param students 学生对象集合
*/
public static void systemHomePage(ArrayList<Student> students) {
// 1、打印学生管理系统操作页面
while (true) {
System.out.println("----------欢迎来到奥利给学生管理系统操作页面----------");
System.out.println("1: 添加学生\n2: 删除学生\n3: 修改学生\n4: 查询学生\n5: 退出登录");
System.out.println("请输入您的选择: ");
// 2、接收输入的选择
String select = SC.next();
// 3、switch判断该选择是哪个功能
switch (select) {
case "1":
// 添加学生
System.out.println("-------添加学生-------");
addStudents(students);
break; // 跳出switch，回到首页面
case "2":
// 删除学生
System.out.println("-------删除学生-------");
deleteStudent(students);
break; // 跳出switch，回到首页面
case "3":
// 修改学生
System.out.println("-------修改学生-------");
updateStudent(students);
break; // 跳出switch，回到首页面
case "4":
// 查询所有学生信息
System.out.println("-------查询所有学生信息-------");
showStudents(students);
break; // 跳出switch，回到首页面
case "5":
// 退出系统
System.out.println("好的！已退出登录！欢迎下次再来~ ^_^~");
return; // 结束systemHomePage方法
default:
// 其他选择
System.out.println("该功能未开发！请敬请等候~");
break; // 跳出switch，回到首页面
}
}
}
/**
* 修改学生信息功能实现：根据学号修改
*
* @param students 学生对象集合
*/
public static void updateStudent(ArrayList<Student> students) {
// 1、从键盘输入要修改的学生学号
String id;
System.out.println("请您输入要修改的学生学号：");
id = SC.next();
// 根据输入的学号获取该学生对象在集合中的索引
int studentIndex = getStudentIndex(students, id);
// 判断索引是否大于等于0
if (studentIndex >= 0) {
// 存在
// 则根据获取到的索引来获取该学生对象
Student student = students.get(studentIndex);
// 修改该学生的其他信息
System.out.println("请您录入该学生修改后的姓名：");
String newName = SC.next();
// 修改学生姓名
student.setName(newName);
while (true) {
System.out.println("请您录入该学生修改后的年龄：");
int newAge = SC.nextInt();
if (newAge >= 0) {
// 年龄合理，修改学生年龄
student.setAge(newAge);
System.out.println("请您录入该学生修改后的家庭住址：");
String newAddress = SC.next();
// 修改学生家庭住址
student.setAddress(newAddress);
System.out.println("学号为" + id + "的学生修改成功！");
// 问一下是否要继续进行修改操作？
ifContinueUpdate(students);
break; // 跳出循环
} else {
System.out.println("年龄不合理！请重新录入~");
}
}
} else {
System.out.println("学号为" + id + "的学生不存在！修改失败！");
// 问一下是否要继续进行修改操作？
ifContinueUpdate(students);
}
}
/**
* 是否继续修改学生信息
*
* @param students 学生对象集合
*/
public static void ifContinueUpdate(ArrayList<Student> students) {
// 1、是否继续修改
System.out.println("您是否要继续修改学生信息？(yes/no)：");
String command = SC.next();
switch (command) {
case "yes":
// 输入的是yes，回调updateStudent方法，继续修改学生信息
updateStudent(students);
break;
default:
// 输入的是其他指令，结束修改，返回到系统首页
System.out.println("好的！修改结束！");
break;
}
}
/**
* 删除学生功能实现：根据学号删除
*
* @param students 学生对象集合
*/
public static void deleteStudent(ArrayList<Student> students) {
// 1、从键盘输入要删除的学生学号
String id;
System.out.println("请您输入要删除的学生学号：");
id = SC.next();
// 根据输入的学号获取该学生对象在集合中的索引
int studentIndex = getStudentIndex(students, id);
// 判断索引是否大于等于0
if (studentIndex >= 0) {
// 是，说明存在
// 则根据获取到的索引来获取该学生对象
Student student = students.get(studentIndex);
// 删除该学生
students.remove(student);
System.out.println("学号为" + id + "的学生删除成功！");
// 问一下是否要继续进行删除操作？
ifContinueDelete(students);
} else {
// 不存在，则提示！
System.out.println("学号为" + id + "的学生不存在！删除失败！");
// 问一下是否要继续进行删除操作？
ifContinueDelete(students);
}
}
/**
* 是否继续删除学生信息
*
* @param students 学生对象集合
*/
public static void ifContinueDelete(ArrayList<Student> students) {
// 1、是否继续删除
System.out.println("您是否要继续删除学生信息？(yes/no)：");
String command = SC.next();
switch (command) {
case "yes":
// 输入的是yes，回调deleteStudent方法，继续删除学生信息
deleteStudent(students);
break;
default:
// 输入的是其他指令，结束删除，返回到系统首页
System.out.println("好的！删除结束！");
break;
}
}
/**
* 查询所有学生信息
*
* @param students 学生对象集合
*/
public static void showStudents(ArrayList<Student> students) {
// 1、判断学生对象集合中是否存在学生
if (students.size() == 0) {
System.out.println("当前无学生信息，请添加后再查询！");
return;
}
// 2、遍历students集合，依次获取集合中每个学生对象
System.out.println("学生信息如下：");
System.out.println("\t学号\t\t\t姓名\t\t\t年龄\t\t\t家庭住址");
for (Student student : students) {
System.out.println(student.getId() + "\t\t\t"
+ student.getName() + "\t\t\t"
+ student.getAge() + "\t\t\t"
+ student.getAddress());
}
System.out.println();
}
/**
* 添加学生功能实现
*
* @param students 学生对象集合
*/
public static void addStudents(ArrayList<Student> students) {
// 1、添加学生
// a.录入学生学号
String id;
while (true) {
System.out.println("请您录入学生的学号：");
id = SC.next();
// 根据学号判断该学生对象是否存在于集合中
boolean flag = containsStudent(students, id);
if (flag) {
// 存在
System.out.println("学号为" + id + "的学生已存在！请重新录入~");
} else {
// 不存在，跳出循环，可以录入学生的其他信息
break;
}
}
// b.录入学生姓名
System.out.println("请您录入学生的姓名：");
String name = SC.next();
// c.录入学生年龄
int age;
while (true) {
System.out.println("请您录入学生的年龄：");
age = SC.nextInt();
// 判断年龄是否大于等于0
if (age >= 0) {
// 不为负数，跳出循环，可以录入学生的其他信息
break;
} else {
// 为负数
System.out.println("年龄不合理！请重新录入~");
}
}
// d.录入学生家庭住址
System.out.println("请您录入学生的家庭住址：");
String address = SC.next();
// e.所有信息录入完毕，将学生信息封装成学生对象，并添加进集合中
students.add(new Student(id, name, age, address));
System.out.println(name + "同学已成功录入奥利给学生管理系统~");
// f.添加完成一个学生对象，问一下是否要继续添加下一个学生对象？
ifContinueAdd(students);
}
/**
* 是否继续添加学生信息
*
* @param students 学生对象集合
*/
public static void ifContinueAdd(ArrayList<Student> students) {
// 1、是否继续添加
System.out.println("您是否要继续添加学生信息？(yes/no)：");
String command = SC.next();
switch (command) {
case "yes":
// 输入的是yes，回调addStudent方法，继续添加学生信息
addStudents(students);
break;
default:
// 输入的是其他指令，结束录入，返回到系统首页
System.out.println("好的！添加结束！");
break;
}
}
/**
* 查询学生学号是否已存在
*
* @param students 学生对象集合
* @param id 学生学号
* @return 存在返回true，否则返回false
*/
public static boolean containsStudent(ArrayList<Student> students, String id) {
// 如果该学生对象的索引大于等于0，说明存在，返回true
// 否则该学生对象的索引小于0，说明不存在，返回false
return getStudentIndex(students, id) >= 0;
}
/**
* 根据学生学号查询该学生对象在集合中的索引
*
* @param students 学生对象集合
* @param id 学生学号
* @return 返回该学生对象所在的索引
*/
public static int getStudentIndex(ArrayList<Student> students, String id) {
// 1、根据学生学号获取该学生对象的索引
// 遍历集合，依次获取每个学生对象
for (int i = 0; i < students.size(); i++) {
// 判断查询的学号 是否匹配 当前遍历到的学生对象的学号
if (id.equals(students.get(i).getId())) {
// 存在，返回该学生对象的在集合中的索引
return i;
}
}
// 遍历结束，仍然找不到该学号的学生对象，说明不存在。返回-1
return -1;
}
}
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
1
-----------欢迎来到用户登录界面-----------
请输入您的用户名：
Hello
用户：Hello未注册，请先注册！
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
2
-----------欢迎来到用户注册界面-----------
请输入您的用户名(3~15位)：
12
用户名长度必须在3~15位之间！
请输入您的用户名(3~15位)：
a1
用户名长度必须在3~15位之间！
请输入您的用户名(3~15位)：
sdfdsfdsfdsfds2323232
用户名长度必须在3~15位之间！
请输入您的用户名(3~15位)：
我是你爸爸
用户名必须是字母加数字的组合！
请输入您的用户名(3~15位)：
Hello123
请设置您的用户密码：
abc123
请再次确认您的用户密码：
123
您两次输入的密码不一致！请重新输入~
请设置您的用户密码：
abc123
请再次确认您的用户密码：
abc123
请输入您的身份证号码：
sdfsdfsdfsdfs23423434
身份证号码必须是18位！
请输入您的身份证号码：
jdhdbghsne2234jf4
身份证号码必须是18位！
请输入您的身份证号码：
kodjfngjcnwi25hs24
身份证号码的前17位必须都是数字！
请输入您的身份证号码：
44566919891202x656
身份证号码的前17位必须都是数字！
请输入您的身份证号码：
445669198912024565X
身份证号码必须是18位！
请输入您的身份证号码：
44566919891202456x
请输入您的手机号码：
1232131232131232
手机号码长度必须为11位！
请输入您的手机号码：
我是牛爸爸
手机号码长度必须为11位！
请输入您的手机号码：
我是
手机号码长度必须为11位！
请输入您的手机号码：
sdfsdfds
手机号码长度必须为11位！
请输入您的手机号码：
dfdfd
手机号码长度必须为11位！
请输入您的手机号码：
我是你爸爸1
手机号码长度必须为11位！
请输入您的手机号码：
jjhhddffeeq
手机号码必须都是数字！
请输入您的手机号码：
13833884384
恭喜用户：Hello123注册成功！
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
2
-----------欢迎来到用户注册界面-----------
请输入您的用户名(3~15位)：
Hello123
用户：Hello123已经注册了！
请输入您的用户名(3~15位)：
Moyu
请设置您的用户密码：
123
请再次确认您的用户密码：
123
请输入您的身份证号码：
44599813958332222
身份证号码必须是18位！
请输入您的身份证号码：
455556121225451616
请输入您的手机号码：
19819198877
恭喜用户：Moyu注册成功！
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
1
-----------欢迎来到用户登录界面-----------
请输入您的用户名：
Moyu
请输入您的密码：
123d
密码错误！您还有2次机会！
请输入您的密码：
1234
密码错误！您还有1次机会！
请输入您的密码：
dfdfd
密码已连续错误3次！登录失败！
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
1
-----------欢迎来到用户登录界面-----------
请输入您的用户名：
Moyu
请输入您的密码：
123
请您输入验证码(iq9DA)：
idfd
验证码错误！
请您输入验证码(i3MZs)：
djfjue
验证码错误！
请您输入验证码(ZKqO0)：
Zkq0o
验证码错误！
请您输入验证码(xxoV0)：
XXov0
用户：Moyu登录成功！
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
4
-------查询所有学生信息-------
当前无学生信息，请添加后再查询！
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
1
-------添加学生-------
请您录入学生的学号：
gc001
请您录入学生的姓名：
猪八戒
请您录入学生的年龄：
-1
年龄不合理！请重新录入~
请您录入学生的年龄：
23
请您录入学生的家庭住址：
高老庄
猪八戒同学已成功录入奥利给学生管理系统~
您是否要继续添加学生信息？(yes/no)：
yes
请您录入学生的学号：
gc001
学号为gc001的学生已存在！请重新录入~
请您录入学生的学号：
gc002
请您录入学生的姓名：
熏悟空
请您录入学生的年龄：
34
请您录入学生的家庭住址：
水帘洞
熏悟空同学已成功录入奥利给学生管理系统~
您是否要继续添加学生信息？(yes/no)：
yes
请您录入学生的学号：
gc002
学号为gc002的学生已存在！请重新录入~
请您录入学生的学号：
gc003
请您录入学生的姓名：
刘玄德
请您录入学生的年龄：
44
请您录入学生的家庭住址：
南京
刘玄德同学已成功录入奥利给学生管理系统~
您是否要继续添加学生信息？(yes/no)：
no
好的！添加结束！
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
4
-------查询所有学生信息-------
学生信息如下：
学号 姓名 年龄 家庭住址
gc001 猪八戒 23 高老庄
gc002 熏悟空 34 水帘洞
gc003 刘玄德 44 南京
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
3
-------修改学生-------
请您输入要修改的学生学号：
gc004
学号为gc004的学生不存在！修改失败！
您是否要继续修改学生信息？(yes/no)：
yes
请您输入要修改的学生学号：
gc003
请您录入该学生修改后的姓名：
沙悟净
请您录入该学生修改后的年龄：
45
请您录入该学生修改后的家庭住址：
广州
学号为gc003的学生修改成功！
您是否要继续修改学生信息？(yes/no)：
no
好的！修改结束！
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
4
-------查询所有学生信息-------
学生信息如下：
学号 姓名 年龄 家庭住址
gc001 猪八戒 23 高老庄
gc002 熏悟空 34 水帘洞
gc003 沙悟净 45 广州
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
2
-------删除学生-------
请您输入要删除的学生学号：
gc006
学号为gc006的学生不存在！删除失败！
您是否要继续删除学生信息？(yes/no)：
yes
请您输入要删除的学生学号：
gc001
学号为gc001的学生删除成功！
您是否要继续删除学生信息？(yes/no)：
no
好的！删除结束！
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
4
-------查询所有学生信息-------
学生信息如下：
学号 姓名 年龄 家庭住址
gc002 熏悟空 34 水帘洞
gc003 沙悟净 45 广州
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
5
好的！已退出登录！欢迎下次再来~ ^_^~
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
3
------------欢迎来到忘记密码界面------------
请输入您的用户名：
Hello123
请输入您的身份证号码：
44566919891202456X
请输入您的手机号码：
13833884384
您的账号信息不匹配！
请输入您的身份证号码：
44566919891202456x
请输入您的手机号码：
13833884382
您的账号信息不匹配！
请输入您的身份证号码：
44566919891202456x
请输入您的手机号码：
13833884384
请您输入新的密码：
yuesha12
请您再次确认新密码：
jj
您两次输入的密码不一致！请重新确认~
请您输入新的密码：
yuesha12
请您再次确认新密码：
yuesha12
用户：Hello123密码修改成功！请重新登录 ~^_^~
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
1
-----------欢迎来到用户登录界面-----------
请输入您的用户名：
Hello123
请输入您的密码：
yuesha12
请您输入验证码(2bKrW)：
2bkrw
用户：Hello123登录成功！
----------欢迎来到奥利给学生管理系统操作页面----------
1: 添加学生
2: 删除学生
3: 修改学生
4: 查询学生
5: 退出登录
请输入您的选择:
5
好的！已退出登录！欢迎下次再来~ ^_^~
----------欢迎来到奥利给系统用户页面----------
1: 登录
2: 注册
3: 忘记密码
请输入您的选择:
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
