文章目录
- 登录
- 需求
- 分析
- 登录界面
- 注册功能：
- 登录功能：
- 忘记密码：
- 验证码规则：
- 图书管理系统
- 需求
- Book包
- Book类
- BookList类
- IOperation包
- IOperation接口
- 查找图书
- 新增图书
- 删除图书
- 显示图书
- 借阅图书
- 归还图书
- 退出系统
- User包
- user类
- Users类
- adminUser类
- normalUser类
- Main类
- 注册
- 登录
- 忘记密码
- Main类源码
- 总结
登录
需求
为学生管理系统书写一个登陆、注册、忘记密码的功能。
只有用户登录成功之后，才能进入到图书管理系统中进行增删改查操作。
分析
登录界面
System.out.println("欢迎来到学生管理系统");
System.out.println("请选择操作1登录 2注册 3忘记密码");
创建用户类
属性：用户名、密码、身份证号码、手机号码
注册功能：
(1)用户名需要满足以下要求：
验证要求：
- 用户名唯一
- 用户名长度必须在3~15位之间
- 只能是字母加数字的组合，但是不能是纯数字
(2)密码键盘输入两次，两次一致才可以进行注册。
(3)身份证号码需要验证。
验证要求：
- 长度为18位
- 不能以0为开头
- 前17位，必须都是数字
- 最为一位可以是数字，也可以是大写X或小写x
(4)手机号验证。
验证要求：
- 长度为11位
- 不能以0为开头
- 必须都是数字
登录功能：
- 键盘录入用户名
- 键盘录入密码
- 键盘录入验证码
验证要求：
用户名如果未注册，直接结束方法，并提示：用户名未注册，请先注册
判断验证码是否正确，如不正确，重新输入
再判断用户名和密码是否正确，有3次机会
忘记密码：
- 键盘录入用户名，判断当前用户名是否存在，如不存在，直接结束方法，并提示：未注册
- 键盘录入身份证号码和手机号码
- 判断当前用户的身份证号码和手机号码是否一致
- 如果一致，则提示输入密码，进行修改。
- 如果不一致，则提示：账号信息不匹配，修改失败。
验证码规则：
- 长度为5
- 由4位大写或者小写字母和1位数字组成，同一个字母可重复
- 数字可以出现在任意位置
- 比如：
aQa1K
图书管理系统
需求
实现以下操作，不同的用户对应不同的界面，以及对图书不同的操作
我们在设计图书管理系统的过程中会使用封装思想，向上转型，抽象类和接口的知识，也就是对之前所学的进行了融合，更好的理解面向对象的思想，对不同的对象，封装成不同的包
Book包
书包中包含了书和书架，书是放在书架上的，而书一本一本放在书架上，是有序的，我们可以理解为数组
Book类
属性：书名，作者，价格，类型，是否已借出
private String name;
private String athour;
private int price;
private String type;
private boolean isBorrowed;
//构造方法，这里不建议把isBorrowed进行引用
//在默认情况下是false也就是未借出
public Book(String name, String athour, int price, String type) {
this.name = name;
this.athour = athour;
this.price = price;
this.type = type;
}
我们使用了private修饰符，只能在本类中使用，若想被外界访问需要提供get和set方法
我们还可以重写ToString()方法,在是否借出中使用了三目运算符，需要注意优先级，记得加()
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", athour='" + athour + '\'' +
", price=" + price +
", type='" + type + '\'' +
(isBorrowed==true?"已借出":"未借出")+
// ", isBorrowed=" + isBorrowed +
'}';
}
BookList类
我们可以先在书架中放几本书，方便下面的操作，在书架上创建数组，用来放书，还需要定义一个属性usedSize,用来记录有效的数据个数
private int usesized;
private Book[] books=new Book[10];
通过书架的构造方法创建对象也就是实例化数组，我们在这放四本书，放四大名著
public BookList() {
this.books[0]=new Book("三国演义","罗贯中",10,"小说");
this.books[1]=new Book("西游记","吴承恩",12,"小说");
this.books[2]=new Book("红楼梦","曹雪芹",11,"小说");
this.books[3]=new Book("水浒传","施耐庵",13,"小说");
this.usesized=4;
}
并相应的提供获取数组和设置数组的get和set方法，我们需要获取的是某个位置下的某一本书，以及新增图书是把书放到书架上
public Book getBooks(int pos) {
return books[pos];
}
public void setBooks(int pos,Book book) {
this.books[pos] = book;
}
public Book[] getBooks() {
return books;
}
IOperation包
这里面包含了IOperation接口，以及增删改查的操作类
IOperation接口
定义work方法，实现IOperation接口就要重写work方法,而我们进行操作的对象是书架，所以需要传书架作为参数
public interface IOperation {
void work(BookList bookList);
}
查找图书
查找图书需要你输入的书名与书架中的书名一致，才可以找到，通过equal()方法
public class Findioperation implements IOperation{
@Override
public void work(BookList bookList) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你要查找的图书的名字：");
String name=scanner.nextLine();
int currentSize=bookList.getUsesized();
int i = 0;
for (; i < currentSize; i++) {
if(bookList.getBooks(i).getName().equals(name)){
System.out.println("找到了");
System.out.println(bookList.getBooks(i));
return;
}
}
System.out.println("没找到你要查找的书！");
}
}
新增图书
- 判满
- 匹配已有不放
- 最后放书
public class Addioperation implements IOperation{
@Override
public void work(BookList bookList) {
Scanner scanner = new Scanner(System.in);
int currentSize = bookList.getUsesized();
//判满
if(currentSize==bookList.getBooks().length){
System.out.println("书架满了，不能放了!");
}
//创建对象
System.out.println("请输入你要添加的图书的名字：");
String name=scanner.nextLine();
System.out.println("请输入你要添加的图书的作者：");
String author=scanner.nextLine();
System.out.println("请输入你要添加的图书的价格：");
int price=scanner.nextInt();
System.out.println("请输入你要添加的图书的类型：");
String type=scanner.nextLine();
//添加
Book book=new Book(name,author,price,type);
int i=0;
for (; i < currentSize; i++) {
if(bookList.getBooks(i).getName().equals(name)){
System.out.println("有这本书不能新增");
return;
}
}
bookList.setBooks(currentSize,book);
//size++
bookList.setUsesized(currentSize+1);
System.out.println("添加成功！");
}
}
删除图书
但是要注意，数组下标不能越界
public class Deleteioperation implements IOperation{
@Override
public void work(BookList bookList) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你要删除的图书的名字：");
String name=scanner.nextLine();
int currentSize=bookList.getUsesized();
int pos=-1;
int i=0;
for (; i < currentSize; i++) {
Book books = bookList.getBooks(i);
if(books.getName().equals(name)){
pos=i;
break;
}
}
if(i==currentSize){
System.out.println("没有你要删除的书！");
return;
}
//不能是currentSize，若把最后一本书删掉时，会越界
for (int j = pos; j < currentSize-1; j++) {
Book books = bookList.getBooks(j+1);
bookList.setBooks(j,books);
}
bookList.setBooks(currentSize-1,null);
bookList.setUsesized(currentSize-1);
System.out.println("删除成功！");
}
}
显示图书
public class Showioperation implements IOperation{
@Override
public void work(BookList bookList) {
int current = bookList.getUsesized();
for (int i = 0; i < current; i++) {
Book books = bookList.getBooks(i);
System.out.println(books);
}
}
}
借阅图书
借阅就需要改变isBorrowed的状态
public class Borrowioperation implements IOperation{
@Override
public void work(BookList bookList) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你要借阅的图书的名字：");
String name=scanner.nextLine();
int currentSize=bookList.getUsesized();
for (int i=0; i < currentSize; i++) {
Book books = bookList.getBooks(i);
if(books.getName().equals(name)){
if(books.isBorrowed()==true){
System.out.println("这本书已经被借出了");
}else {
books.setBorrowed(true);
System.out.println("借阅成功");
return;
}
}
}
System.out.println("没有你要借的书！");
}
}
归还图书
归还同样需要改变isBorrowed的状态
public class Returnioperation implements IOperation{
@Override
public void work(BookList bookList) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你要归还的图书的名字：");
String name=scanner.nextLine();
int currentSize=bookList.getUsesized();
for (int i=0; i < currentSize; i++) {
Book books = bookList.getBooks(i);
if(books.getName().equals(name)){
if(books.isBorrowed()==true) {
books.setBorrowed(false);
return;
}
}
System.out.println("没有你要归还的书！");
}
}
}
退出系统
public class Exitioperation implements IOperation
{
@Override
public void work(BookList bookList) {
System.out.println("退出系统");
System.exit(0);//程序正常退出
}
}
User包
User由于有不同的用户对象，所以需要放在包里，还需要创建user类，把共性的信息抽取出来，封装成抽象类，并让管理员和普通用户继承user类
由于我们在设置菜单的时候有不同的用户，而不同的用户都是继承于父类user,所以我们把menu()作为抽象方法，因为继承了抽象类，抽象类中抽象方法和构造方法是一定要被重写的
在由于我们进行增删改查的过程中需要是对象去操作书架而书架去调用方法，所以我们需要在user中创建接口数组，在user中的Ioperation是未进行初始化的
user类
protected String name;
public IOperation[] Ioperations;
public abstract int menu();
public User(String name) {
this.name = name;
}
Users类
这里是对登录界面Users的定义
属性：用户名、密码、身份证号码、手机号码
private String name;
private String password;
private String IdNumber;
private String phoneNumber;
//同样需要提供get和set方法
adminUser类
对于Ioperatoin进行初始化（实例化对象），把对应的操作作为数组的对象，对象具有对应的下标，通过对应的下标就可以访问具体的操作了
public class adiminUser extends User{
@Override
public int menu() {
System.out.println("欢迎"+this.name+"来到图书系统");
System.out.println("*******管理员菜单*******");
System.out.println("1. 查找图书");
System.out.println("2. 新增图书");
System.out.println("3. 删除图书");
System.out.println("4. 显示图书");
System.out.println("0. 退出系统");
System.out.println("************************");
Scanner scanner=new Scanner(System.in);
System.out.println("请输入你的操作：");
int choice=scanner.nextInt();
return choice;
}
public adiminUser(String name) {
super(name);
this.Ioperations=new IOperation[]{
new Exitioperation(),
new Findioperation(),
new Addioperation(),
new Deleteioperation(),
new Showioperation()
};
}
}
normalUser类
public class normalUser extends User{
public normalUser(String name) {
super(name);
this.Ioperations=new IOperation[]{
new Exitioperation(),
new Findioperation(),
new Borrowioperation(),
new Returnioperation()
};
}
@Override
public int menu() {
System.out.println("欢迎"+this.name+"来到图书系统");
System.out.println("*******普通用户菜单*******");
System.out.println("1. 查找图书");
System.out.println("2. 借阅图书");
System.out.println("3. 归还图书");
System.out.println("0. 退出系统");
System.out.println("************************");
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的操作：");
int choice=scanner.nextInt();
return choice;
}
}
Main类
程序的入口，写login方法，创建书架的对象，登录由于是不同的对象来调用，需要向上转型，再通过需要doIoperation调用work方法，doIoperation是由user调用的，所以在user类中写doIoperation方法
public class Main {
public static User login(){
System.out.println("请输入你的名字：");
Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
System.out.println("请输入你的身份：1.管理员 2：普通用户");
int choice = scanner.nextInt();
if (choice == 1) {
return new adiminUser(name);
} else {
return new normalUser(name);
}
}
public static void main(String[] args) {
BookList bookList=new BookList();
User user = login();
while (true) {
int choice = user.menu();
user.doIoperation(choice, bookList);
}
}
}
注册
public static void register(ArrayList<Users> users){
String username;
Scanner sc=new Scanner(System.in);
while (true) {
System.out.println("请输入用户名：");
username = sc.next();
boolean flag1=checkUsername(username);
if(!flag1){
System.out.println("当前格式满不足要求，请重新输入");
continue;
}
boolean flag=contains(users,username);
if(flag){
System.out.println("用户名"+username+"当前用户已存在，无法注册，请重新输入，");
}else {
System.out.println("用户名"+username+"可用");
break;
}
}
String password;
while (true) {
System.out.println("请输入密码：");
password= sc.next();
System.out.println("请再次输入密码：");
String password2 = sc.next();
if(!(password.equals(password2))){
System.out.println("两次密码输入不一致，请重新输入");
continue;
}else {
System.out.println("请继续录入数据");
break;
}
}
String idNumber;
while (true) {
System.out.println("请输入身份证号码");
idNumber=sc.next();
boolean flag3= checkIdnumber(idNumber);
if(flag3){
System.out.println("当前的身份证号码符合要求");
break;
}else {
System.out.println("当前的身份证号码不符合要求，请重新输入");
continue;
}
}
String phoneNumber;
while (true) {
System.out.println("请输入手机号码：");
phoneNumber=sc.next();
boolean flag4= checkPhonenumber(phoneNumber);
if(flag4){
System.out.println("当前输入的手机号码正确");
break;
}else {
System.out.println("当前输入的手机号码格式错误，请重新输入");
continue;
}
}
Users user=new Users(username,password,idNumber,phoneNumber);
users.add(user);
System.out.println("注册成功");
printList(users);
}
登录
我们在main方法里通过switch语句调用不同方法，我们是直接创建了集合，用于存储对象用户对象，由于我们实现图书管理系统用的是数组，这里是集合，不同的方法都可以实现存储对象的效果
private static void denglu(ArrayList<Users> users) {
Scanner sc=new Scanner(System.in);
for (int i = 0; i < 3; i++) {
System.out.println("请输入用户名：");
String username=sc.next();
boolean result = contains(users, username);
if(!result){
System.out.println("用户名未注册，请先注册");
return;
}
System.out.println("请输入密码：");
String password=sc.next();
while (true) {
String code = getCode();
System.out.println("正确的验证码为："+code);
System.out.println("请输入验证码：");
String input=sc.next();
if(input.equalsIgnoreCase(code)){
System.out.println("输入正确");
break;
}else {
System.out.println("验证码错误");
continue;
}
}
Users userinfo=new Users(username,password,null,null);
//封装的思想，把零散的数据放到一个整体的对象中
boolean res = checkUserInfo(users, username, password);
if(res){
System.out.println("登录成功,你可以使用图书管理系统了");
//创建对象调方法
BookList bookList=new BookList();
User user = login();
//不同的对象有不同的菜单
while(true){
int choice = user.menu();
user.doIoperation(choice,bookList);
}
}else {
System.out.println("登录失败");
if(i==2){
System.out.println("系统被锁定，请等待两分钟后在输入");
return;
}else {
System.out.println("用户名和密码错误，你还有"+(2-i)+"次机会");
}
}
}
}
忘记密码
private static void forgetNumber(ArrayList<Users> users) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入用户名：");
String username=sc.next();
boolean result = contains(users, username);
if(!result){
System.out.println("用户名未注册，请先注册");
return;
}
System.out.println("请输入身份证号码：");
String IdNumber=sc.next();
System.out.println("请输入手机号码：");
String phoneNumber=sc.next();
//需要把用户对象对应的索引身份证和手机号获取出来
int index = getIndex(users, username);
Users user = users.get(index);
//考虑到还要再输入密码，还有验证操作，我们需要取反
if(!(user.getIdNumber().equalsIgnoreCase(IdNumber)&&user.getPhoneNumber().equalsIgnoreCase(phoneNumber))) {
System.out.println("身份证号码和手机号码错误，修改失败");
return;
}
String newPassword1;
while (true) {
System.out.println("请输入新的密码：");
newPassword1=sc.next();
System.out.println("请再次输入新的密码：");
String newPassword2=sc.next();
if(newPassword1.equals(newPassword2)){
System.out.println("两次密码输入一致");
break;
}else{
System.out.println("两次密码输入不一致，请重新输入");
continue;
}
}
user.setPassword(newPassword1);
System.out.println("修改成功");
}
Main类源码
import Book.BookList;
import Book.Book;
import User.AdiminUser;
import User.NormalUser;
import User.User;
import User.Users;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
public class Main {
//登录入口
public static User login(){
Scanner scanner=new Scanner(System.in);
System.out.println("请输入你的名字：");
String name= scanner.nextLine();
System.out.println("请选择你的身份：1.管理员 2.普通用户");
int choice = scanner.nextInt();
//返回对象，使用到了向上转型
if(choice==1){
return new AdiminUser(name);
}else {
return new NormalUser(name);
}
}
public static void main(String[] args) {
ArrayList<Users> users=new ArrayList<>();
Scanner sc=new Scanner(System.in);
while(true){
System.out.println("欢迎来到图书管理系统");
System.out.println("请选择操作1登录 2注册 3忘记密码");
String input=sc.next();
switch (input){
case "1"->denglu(users);
case "2"->register(users);
case "3"->forgetNumber(users);
case "4"->{
System.out.println("拜拜");
System.exit(-1);
}
default -> System.out.println("没有这个选项");
}
}
}
private static void denglu(ArrayList<Users> users) {
Scanner sc=new Scanner(System.in);
for (int i = 0; i < 3; i++) {
System.out.println("请输入用户名：");
String username=sc.next();
boolean result = contains(users, username);
if(!result){
System.out.println("用户名未注册，请先注册");
return;
}
System.out.println("请输入密码：");
String password=sc.next();
while (true) {
String code = getCode();
System.out.println("正确的验证码为："+code);
System.out.println("请输入验证码：");
String input=sc.next();
if(input.equalsIgnoreCase(code)){
System.out.println("输入正确");
break;
}else {
System.out.println("验证码错误");
continue;
}
}
Users userinfo=new Users(username,password,null,null);
//封装的思想，把零散的数据放到一个整体的对象中
boolean res = checkUserInfo(users, username, password);
if(res){
System.out.println("登录成功,你可以使用图书管理系统了");
//创建对象调方法
BookList bookList=new BookList();
User user = login();
//不同的对象有不同的菜单
while(true){
int choice = user.menu();
user.doIoperation(choice,bookList);
}
}else {
System.out.println("登录失败");
if(i==2){
System.out.println("系统被锁定，请等待两分钟后在输入");
return;
}else {
System.out.println("用户名和密码错误，你还有"+(2-i)+"次机会");
}
}
}
}
private static String getCode(){
//先把a-z和A-Z的26个字母放到集合中泛型写字符
ArrayList<Character> list=new ArrayList<>();
for (int i = 0; i < 26; i++) {
list.add((char)('a'+i));
list.add((char)('A'+i));
}
StringBuilder sb=new StringBuilder();
Random r=new Random();
for (int i = 0; i < 4; i++) {
int Index = r.nextInt(list.size());
char c= list.get(Index);
sb.append(c);
}
int endIndex = r.nextInt(10);
sb.append(endIndex);
//改变字符串的内容，通过字符数组
char[] chars = sb.toString().toCharArray();
//获取随机索引
int randomIndex=r.nextInt(chars.length);
//最大跟随机索引进行交换
char tmp=chars[randomIndex];
chars[randomIndex]=chars[chars.length-1];
chars[chars.length-1]=tmp;
//返回新的字符串
return new String(chars);
}
private static boolean checkUserInfo(ArrayList<Users> users, String username, String password) {
for (int i = 0; i < users.size(); i++) {
if(users.get(i).getPassword().equals(password)&&users.get(i).getName().equals(username)){
return true;
}
}
return false;
}
public static boolean contains(ArrayList<Users> users, String username){
return getIndex(users,username)>=0;
}
public static int getIndex(ArrayList<Users> users, String username){
for (int i = 0; i < users.size(); i++) {
Users user=users.get(i);
if(user.getName().equals(username)){
return i;
}
}
return -1;
}
public static void register(ArrayList<Users> users){
String username;
Scanner sc=new Scanner(System.in);
while (true) {
System.out.println("请输入用户名：");
username = sc.next();
boolean flag1=checkUsername(username);
if(!flag1){
System.out.println("当前格式满不足要求，请重新输入");
continue;
}
boolean flag=contains(users,username);
if(flag){
System.out.println("用户名"+username+"当前用户已存在，无法注册，请重新输入，");
}else {
System.out.println("用户名"+username+"可用");
break;
}
}
String password;
while (true) {
System.out.println("请输入密码：");
password= sc.next();
System.out.println("请再次输入密码：");
String password2 = sc.next();
if(!(password.equals(password2))){
System.out.println("两次密码输入不一致，请重新输入");
continue;
}else {
System.out.println("请继续录入数据");
break;
}
}
String idNumber;
while (true) {
System.out.println("请输入身份证号码");
idNumber=sc.next();
boolean flag3= checkIdnumber(idNumber);
if(flag3){
System.out.println("当前的身份证号码符合要求");
break;
}else {
System.out.println("当前的身份证号码不符合要求，请重新输入");
continue;
}
}
String phoneNumber;
while (true) {
System.out.println("请输入手机号码：");
phoneNumber=sc.next();
boolean flag4= checkPhonenumber(phoneNumber);
if(flag4){
System.out.println("当前输入的手机号码正确");
break;
}else {
System.out.println("当前输入的手机号码格式错误，请重新输入");
continue;
}
}
Users user=new Users(username,password,idNumber,phoneNumber);
users.add(user);
System.out.println("注册成功");
printList(users);
}
private static boolean checkIdnumber(String idnumber){
int len=idnumber.length();
if(len!=18){
return false;
}
if(idnumber.charAt(0)=='0'){
return false;
}
for (int i = 0; i < len-1; i++) {
char c = idnumber.charAt(i);
if(!(c>='0'&&c<='9')){
return false;
}
}
char endchar = idnumber.charAt(len-1);
if((endchar>='0'&&endchar<='9')||(endchar=='X')||(endchar=='x')){
return true;
}else {
return false;
}
}
private static boolean checkUsername(String username) {
int len=username.length();
if(len<=3||len>=15){
return false;
}
int count=0;
for (int i = 0; i < username.length(); i++) {
char c = username.charAt(i);
if(!(c>='a'&&c<='z'||c>='A'&&c<='Z'||c>'0'&&c<='9')){
return false;
}
}
for (int i = 0; i < username.length(); i++) {
char c = username.charAt(i);
if(c>='a'&&c<='z'||c>='A'&&c<='Z'){
count++;
break;
}
}
return count>0;
}
private static boolean checkPhonenumber(String phoneNumber){
if(phoneNumber.length()!=11){
return false;
}
//startsWith如果第一个是0返回true
if( phoneNumber.startsWith("0")){
return false;
}
for (int i = 0; i < phoneNumber.length(); i++) {
char c = phoneNumber.charAt(i);
if(!(c>='0'&&c<='9')){
return false;
}
}
return true;
}
private static void printList(ArrayList<Users> users) {
for (int i = 0; i < users.size(); i++){
Users user = users.get(i);
System.out.println(user.getName()+","+user.getPassword()+","+user.getIdNumber()+","+user.getPhoneNumber());
}
}
private static void forgetNumber(ArrayList<Users> users) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入用户名：");
String username=sc.next();
boolean result = contains(users, username);
if(!result){
System.out.println("用户名未注册，请先注册");
return;
}
System.out.println("请输入身份证号码：");
String IdNumber=sc.next();
System.out.println("请输入手机号码：");
String phoneNumber=sc.next();
//需要把用户对象对应的索引身份证和手机号获取出来
int index = getIndex(users, username);
Users user = users.get(index);
//考虑到还要再输入密码，还有验证操作，我们需要取反
if(!(user.getIdNumber().equalsIgnoreCase(IdNumber)&&user.getPhoneNumber().equalsIgnoreCase(phoneNumber))) {
System.out.println("身份证号码和手机号码错误，修改失败");
return;
}
String newPassword1;
while (true) {
System.out.println("请输入新的密码：");
newPassword1=sc.next();
System.out.println("请再次输入新的密码：");
String newPassword2=sc.next();
if(newPassword1.equals(newPassword2)){
System.out.println("两次密码输入一致");
break;
}else{
System.out.println("两次密码输入不一致，请重新输入");
continue;
}
}
user.setPassword(newPassword1);
System.out.println("修改成功");
}
}
总结
欢迎小伙伴在评论区指导！
💕💕
💕💕
