java车辆租赁管理系统

迷南。 2023-09-24 21:03 39阅读 0赞

### 文章目录 ###

*   *  一、项目需求
     *  二、项目结构
     *   *  项目源代码：
         *  1、database层
         *   *  1.Database类（车辆）
             *  2.UserDatabase类
         *  2、model层
         *   *  1.Car类
             *  2.User类
         *  3、 operation层
         *   *  1. IOpreation接口
             *  2.AddCarInfoOperation类
             *  3.DeleteCarInfoOperation类
             *  4.UpdateCarInfoOperation类
             *  5.GetCarsInfoOperation类
             *  6.BorrowOperation类
             *  7.ReturnOperation类
             *  8.ExitOperation类
         *  4、service层
         *   *  1.MyCarManageService类
             *  2.UserDao类
         *  5、test层
         *   *  1.Main类
     *  三、运行截图

## 一、项目需求 ##

> 完成一个车辆租赁管理系统，实现：  
> 1、通过用户名、登录密码、验证码实现用户注册，并登录；  
> 2、用户能够查看所有车辆，展示车辆的生产类型 、车名、月租金、是否借出的情况；  
> 3、用户能够添加车辆信息（两种情况）：  
> 3.1 新添加的书籍类型在数据集合bookMap中已存在，那么就直接将新书添加到对应类型的书籍List集合中  
> 3.2 新添加的书籍类型在数据集合bookMap中不存在，那么需要新建键值对完成bookMap中的元素添加  
> 4、用户能够修改车辆信息，如车辆生产类型、名称、月租金；  
> 5、用户能够删除车辆信息，删除车辆后需要判断该车所在List集合长度是否为0，为0则该键值对一起移除；  
> 6、用户能够租赁车辆与归还车辆；  
> 7、退出系统

## 二、项目结构 ##

项目分五个包：

1、`database包`：**模拟数据层**；  
2、`model包`：**实体对象层**；  
3、`operation包`：**操作实现层**；  
4、`service包`：**业务逻辑层**；  
5、`test包`：**项目测试层**

![在这里插入图片描述][21c7fc6844d641a49202bc682578794d.png]

一个操作接口（ IOpreation接口）：  
对于每一个操作都有相近的一部分，刚好可以用接口，利用接口类型的数组来进行相关的操作。

七个操作实现类：  
用于实现租赁车辆的增删改查以及租赁归还等操作。

![在这里插入图片描述][6e13413c5dba42da8a269575004e253f.png]

用一个protected IOpreation\[\] iOpreations;即接口类型的数组，主要是在它的子类中，在构造 函数中需要根据它们各自的功能实例化各个操作。  
IOpreation\[\] iOpreations数组实例化：

public void doOperation(int choice, HashMap<String, ArrayList<Car>> CarMap) {
        
            this.iOpreations[choice].work(CarMap);
        }
        protected IOpreation[] iOpreations;
        /**
         * IOpreation[] iOpreations，在这里就实例化了
         */
        public MyCarManageService() {
        
            this.iOpreations = new IOpreation[]{
        
                    new GetCarsInfoOperation(),
                    new AddCarInfoOperation(),
                    new UpdateCarInfoOperation(),
                    new DeleteCarInfoOperation(),
                    new BorrowOperation(),
                    new ReturnOperation(),
                    new ExitOperation()
            };
        }

将type和用例car分别作为key和value关联，使用hashMap存储；

public static HashMap<String, ArrayList<Car>> initCarMap() {
        
            HashMap<String, ArrayList<Car>> CarMap = new HashMap<>();
            //创建车辆对象
            Car Car1 = new Car("红旗", "国产", 690,false);
            Car Car2 = new Car("吉利", "国产", 790,true);
            Car Car3 = new Car("比亚迪", "国产", 890,false);
    
            Car Car5 = new Car("奔驰", "德产", 770,true);
            Car Car6 = new Car("宝马", "德产", 870,false);
            Car Car7 = new Car("奥迪", "德产", 680,false);
    
            //创建车辆List集合
            ArrayList<Car> CarList1 = new ArrayList<>();
            ArrayList<Car> CarList2 = new ArrayList<>();
    
            // List集合添加车辆
            CarList1.add(Car1);
            CarList1.add(Car2);
            CarList1.add(Car3);
    
            CarList2.add(Car5);
            CarList2.add(Car6);
            CarList2.add(Car7);
    
            //HashMap添加键值对
            CarMap.put(Car1.getType(), CarList1);
            CarMap.put(Car6.getType(), CarList2);
            return CarMap;
        }

用户使用ArrayList存储用户名和密码

//存储所有的用户信息
        List<User> user=new ArrayList<>();
        public List<User> getUser() {
        
            return user;
        }
    
        public void setUser(List<User> user) {
        
            this.user = user;
        }
    
        public UserDatabase(){
        
            //初始化用户信息
            User a=new User("小烟斗","111");
            User b=new User("小酒壶","222");
            User c=new User("小捣蛋","333");
    
            user.add(a);
            user.add(b);
            user.add(c);
        }

通过遍历集合和列表获取车辆月租金：

public static double getCarPrice(HashMap<String, ArrayList<Car>> CarMap, String CarName) {
        
    
            Set<Map.Entry<String, ArrayList<Car>>> entries = CarMap.entrySet();
            double price = 88;
            for (Map.Entry<String, ArrayList<CarManage.cn.edu.just.model.Car>> Car : entries) {
        
    
                ArrayList<CarManage.cn.edu.just.model.Car> CarList = Car.getValue();
                //对车辆List集合进行遍历
                for (CarManage.cn.edu.just.model.Car CarInfo : CarList) {
        
                    if (CarInfo.getName().equals(CarName)) {
        
                        price = CarInfo.getPrice();
                        break;
                    }
    
                }
    
            }
            return price;
    
        }

通过遍历集合和列表获取车辆生产类型：

public void isExitByType(HashMap<String, ArrayList<Car>> CarMap, String CarType) {
        
    
            ArrayList<Car> CarArrayList1 = CarMap.get(CarType);
            if (CarArrayList1 == null || CarArrayList1.size() == 0) {
        
                System.out.println("您要修改的车辆生产类型不存在");
                login(CarMap);
            }
    
        }

### 项目源代码： ###

### 1、database层 ###

#### 1.Database类（车辆） ####

package CarManage.cn.edu.just.dataBase;
    
    import CarManage.cn.edu.just.model.Car;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    
    public class Database {
        
    
    
        public static HashMap<String, ArrayList<Car>> initCarMap() {
        
            HashMap<String, ArrayList<Car>> CarMap = new HashMap<>();
            //创建车辆对象
            Car Car1 = new Car("红旗", "国产", 690,false);
            Car Car2 = new Car("吉利", "国产", 790,true);
            Car Car3 = new Car("比亚迪", "国产", 890,false);
    
            Car Car5 = new Car("奔驰", "德产", 770,true);
            Car Car6 = new Car("宝马", "德产", 870,false);
            Car Car7 = new Car("奥迪", "德产", 680,false);
    
            //创建车辆List集合
            ArrayList<Car> CarList1 = new ArrayList<>();
            ArrayList<Car> CarList2 = new ArrayList<>();
    
            // List集合添加车辆
            CarList1.add(Car1);
            CarList1.add(Car2);
            CarList1.add(Car3);
    
            CarList2.add(Car5);
            CarList2.add(Car6);
            CarList2.add(Car7);
    
            //HashMap添加键值对
            CarMap.put(Car1.getType(), CarList1);
            CarMap.put(Car6.getType(), CarList2);
            return CarMap;
        }
    
    }

#### 2.UserDatabase类 ####

package CarManage.cn.edu.just.dataBase;
    
    import CarManage.cn.edu.just.model.User;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class UserDatabase {
        
            //存储所有的用户信息
        List<User> user=new ArrayList<>();
        public List<User> getUser() {
        
            return user;
        }
    
        public void setUser(List<User> user) {
        
            this.user = user;
        }
    
        public UserDatabase(){
        
            //初始化用户信息
            User a=new User("小烟斗","111");
            User b=new User("小酒壶","222");
            User c=new User("小捣蛋","333");
    
            user.add(a);
            user.add(b);
            user.add(c);
        }
    
    }

### 2、model层 ###

#### 1.Car类 ####

package CarManage.cn.edu.just.model;
    
    
    
    /**车辆管理系统优化点
    
     1 在修改车辆功能中 如果要修改的车辆类型或车辆名不存在的情况下 直接进行提示操作
     2 在修改车辆功能中 增加修改已有车辆的类型的功能
     3 在删除车辆功能中 如果删除的车辆类型和或车辆名不存在的情况下 直接进行提示操作
    
    
     在优化完的基础上 新增两个功能
    
     1 借车辆功能
     2 还车辆功能
    
     */
    
    public class Car {
        
    
        //车辆名
        private String name;
        //类型
        private String type;
        //价格
        private double rentPrice;
        //是否借出
        private boolean isBorrowed;
    
        public Car() {
        
        }
    
        public Car(String name, String type, double rentPrice) {
        
            this.name = name;
            this.type = type;
            this.rentPrice = rentPrice;
        }
    
        public Car(String name, String type, double rentPrice, boolean isBorrowed) {
        
            this.name = name;
            this.type = type;
            this.rentPrice = rentPrice;
            this.isBorrowed = isBorrowed;
        }
    
        public boolean isBorrowed() {
        
            return isBorrowed ;
        }
    
        public void setBorrowed(boolean borrowed) {
        
            isBorrowed = borrowed;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public String getType() {
        
            return type;
        }
    
        public void setType(String type) {
        
            this.type = type;
        }
    
        public double getPrice() {
        
            return rentPrice;
        }
    
        public void setPrice(double rentPrice) {
        
            this.rentPrice = rentPrice;
        }
    
        @Override
        public String toString() {
        
            return "Car{" +
                    "name='" + name + '\'' +
                    ", type='" + type + '\'' +
                    ", rentPrice=" + rentPrice +
                    ", isBorrowed=" + (isBorrowed == true ? " 已借出 ":" 未借出 ") +
                    '}';
        }
    }

#### 2.User类 ####

package CarManage.cn.edu.just.model;
    
    /**
     * 用户类
     */
    public class User {
        
        //用户名
       private  String userName;
        //密码
       private String password;
    
        public User(String userName, String password) {
        
            this.userName = userName;
            this.password = password;
        }
    
        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;
        }
    }

### 3、 operation层 ###

#### 1. IOpreation接口 ####

package CarManage.cn.edu.just.operation;
    
    
    import CarManage.cn.edu.just.model.Car;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    
    /**
     * 操作接口
     * 对于每一个操作都有相近的一部分，刚好可以用接口，在User（使用者）中利用接口类型的数组来进行相关的操作。
     */
    public interface IOpreation {
        
    
         void work(HashMap<String, ArrayList<Car>> CarMap);
    }

#### 2.AddCarInfoOperation类 ####

#### 3.DeleteCarInfoOperation类 ####

#### 4.UpdateCarInfoOperation类 ####

package CarManage.cn.edu.just.operation;
    
    import CarManage.cn.edu.just.model.Car;
    import CarManage.cn.edu.just.service.MyCarManageService;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.Scanner;
    
    public class UpdateCarInfoOperation implements IOpreation {
        
        @Override
        public void work(HashMap<String, ArrayList<Car>> CarMap) {
        
            Scanner scan=new Scanner(System.in);
            MyCarManageService user = new MyCarManageService();
    
            System.out.println("");
            System.out.println("请选择：");
            System.out.println("1->修改车辆生产类型  2->修改车辆名称及价格  3->返回上一层");
    
            int choose=scan.nextInt();
            if(choose==1){
        
                System.out.println("请输入该车辆原生产类型");
                String originalCarType = scan.next();
                user.isExitByType(CarMap, originalCarType);
    
                System.out.println("请输入要修改的车辆名");
                String modifyCarName = scan.next();
                user.isExitByName(CarMap,originalCarType,  modifyCarName);
    
                System.out.println("请输入修改后的车辆生产类型");
                String newCarType = scan.next();
                double CarPrice=user.getCarPrice(CarMap,modifyCarName);
                boolean CarIsBorrowed=user.getCarIsBorrowed(CarMap,modifyCarName);
                Car addCar1 = new Car (modifyCarName, newCarType, CarPrice,CarIsBorrowed);
    
                ArrayList<Car> CarArrayList = CarMap.get(newCarType);
                if (CarArrayList != null){
        
                    CarArrayList.add(addCar1);
                    System.out.println("更改车辆生产类型"+modifyCarName+"成功!");
    
                    ArrayList<Car> CarArrayListRemove = CarMap.get(originalCarType);
    
                    for (int i = 0; i < CarArrayListRemove.size(); i++) {
        
                        Car Car = CarArrayListRemove.get(i);
                        String name = Car.getName();
                        if (name.equals(modifyCarName)) {
        
                            //要删除的车辆名存在进行删除
                            CarArrayListRemove.remove(i);
    
                            //删除车辆后需要判断该车辆所在ListJ集合长度是否为0
                            if (CarArrayListRemove.size() == 0) {
        
                                //移除该键值对
                                CarMap.remove(originalCarType);
                            }
                        }
                    }
    
                }else {
        
                    ArrayList<Car> CarList = new ArrayList<>();
                    CarList.add(addCar1);
                    // CarMap新添加键值对
                    CarMap.put(newCarType, CarList);
                    System.out.println("更改"+modifyCarName+"的车辆生产类型"+"成功!");
    
                    ArrayList<Car> CarArrayListRemove = CarMap.get(originalCarType);
    
                    for (int i = 0; i < CarArrayListRemove.size(); i++) {
        
                        Car Car = CarArrayListRemove.get(i);
                        String name = Car.getName();
                        if (name.equals(modifyCarName)) {
        
                            //要删除的车辆名存在进行删除
                            CarArrayListRemove.remove(i);
    //                    System.out.println("删除" + name + "成功!");
    
                            //删除车辆后需要判断该车辆所在ListJ集合长度是否为0
                            if (CarArrayListRemove.size() == 0) {
        
                                //移除该键值对
                                CarMap.remove(originalCarType);
                            }
                        }
                    }
    
                }
    
            }
    
            if (choose==2){
        
                System.out.println("请输入该车辆生产类型");
                String CarType = scan.next();
                user.isExitByType(CarMap, CarType);
    
                System.out.println("请输入要修改的车辆名");
                String oldCarName = scan.next();
                user.isExitByName(CarMap,CarType, oldCarName);
    
                System.out.println("请输入新的车辆名");
                String newCarName = scan.next();
    
                System.out.println("请输入新的月租金");
                double newCarPrice = scan.nextDouble();
    
                ArrayList<Car> CarArrayList = CarMap.get(CarType);
    
                for (Car Car : CarArrayList) {
        
                    String name = Car.getName();
                    if (name.equals(oldCarName)) {
        
                        Car.setName(newCarName);
                        Car.setPrice(newCarPrice);
                        System.out.println("车辆"+newCarName+"的名称及月租金修改完成!");
    
                    }
                }
            }
            if (choose==3){
        
    
                user.login(CarMap);
            }
    
    //        else{
        
    //            System.out.println("输入有误，重新输入");
    //            Scanner scanner3= new Scanner(System.in);
    //               user.updateCarInfo(CarMap,scan);
    //        }
            user.login( CarMap);
        }
    }

#### 5.GetCarsInfoOperation类 ####

#### 6.BorrowOperation类 ####

package CarManage.cn.edu.just.operation;
    
    /**
     * 租赁车辆
     * 对于租赁车辆只需要将车辆信息中的布尔型变量isBorrowed变量变为true即可，首先还是要遍历Carlist找到该车辆。
     */
    
    import CarManage.cn.edu.just.model.Car;
    import CarManage.cn.edu.just.service.MyCarManageService;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.Scanner;
    
    public class BorrowOperation implements IOpreation {
        
        public void work( HashMap<String, ArrayList<Car>> CarMap){
        
            MyCarManageService user = new MyCarManageService();
            Scanner scan=new Scanner(System.in);
            System.out.println("--------租赁车辆-----------");
            System.out.println("请输入要租赁的车辆生产类型：");
            String borrowType=scan.next();
            user.isExitByType(CarMap,borrowType);
    
            System.out.println("请输入要租赁的车辆名称：");
            String borrowCarName=scan.next();
            user.isExitByName(CarMap,borrowType,borrowCarName);
    
            ArrayList<Car> CarArrayList = CarMap.get(borrowType);
            //判断是否借出
            for (Car Car : CarArrayList) {
        
                String name = Car.getName();
                if (name.equals(borrowCarName)&&Car.isBorrowed()==false) {
        
                    System.out.println("租赁车辆多少个月：");
                    double carRentPrice=user.getCarPrice(CarMap,borrowCarName);
                    int month=scan.nextInt();
                    double yourPrice=month*carRentPrice;
                    Car.setBorrowed(true);
                    System.out.println("租赁成功");
                    System.out.println("该车辆的最新信息为：");
                    System.out.println(Car.toString());
                    System.out.println("本次租金金额为："+yourPrice);
                    break;
                }
                if (name.equals(borrowCarName) && Car.isBorrowed()==true){
        
                    System.out.println("该车辆已被借出");
                    break;
                }
            }
            user.login( CarMap);
          }
        }

#### 7.ReturnOperation类 ####

package CarManage.cn.edu.just.operation;
    
    import CarManage.cn.edu.just.model.Car;
    import CarManage.cn.edu.just.service.MyCarManageService;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.Scanner;
    
    
    /**
     * 归还车辆
     * 和借阅车辆进行对比可只，借阅车辆是将isBorrowed变量由false变为true，那么归还车辆就是将isBorrowed变量由true变为false.
     */
    public class ReturnOperation implements IOpreation {
        
    
        @Override
        public void work( HashMap<String, ArrayList<Car>> CarMap) {
        
            Scanner scan=new Scanner(System.in);
            MyCarManageService user = new MyCarManageService();
            System.out.println("-----------归还车辆--------------");
    
            System.out.println("请输入要归还的车辆生产类型：");
            String returnCarType=scan.next();
            user.isExitByType(CarMap,returnCarType);
    
            System.out.println("请输入要归还的车辆名称：");
            String returnCarName=scan.next();
            user.isExitByName(CarMap,returnCarType,returnCarName);
    
            ArrayList<Car> CarArrayList = CarMap.get(returnCarType);
            for (CarManage.cn.edu.just.model.Car Car : CarArrayList) {
        
                String name = Car.getName();
                if (name.equals(returnCarName)&&Car.isBorrowed()==true ) {
        
                    Car.setBorrowed(false);
                    System.out.println("归还成功");
                    System.out.println("该车辆的最新信息为：");
                    System.out.println(Car.toString());
                    break;
                }
    
                if (name.equals(returnCarName)&&Car.isBorrowed()==false){
        
                    System.out.println("该车辆已被归还");
                }
            }
            user.login( CarMap);
        }
    
    }

#### 8.ExitOperation类 ####

package CarManage.cn.edu.just.operation;
    
    import CarManage.cn.edu.just.model.Car;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    
    public class ExitOperation implements IOpreation {
        
        @Override
        public void work(HashMap<String, ArrayList<Car>> CarMap) {
        
            //正在退出系统
            System.out.println("正在退出系统");
            System.exit(0);
        }
    }

### 4、service层 ###

#### 1.MyCarManageService类 ####

package CarManage.cn.edu.just.service;
    
    import CarManage.cn.edu.just.dataBase.Database;
    import CarManage.cn.edu.just.dataBase.UserDatabase;
    import CarManage.cn.edu.just.model.Car;
    import CarManage.cn.edu.just.model.User;
    import CarManage.cn.edu.just.operation.*;
    
    import java.util.*;
    
    /**车辆管理系统优化点
    
     1 在修改车辆功能中 如果要修改的车辆生产类型或车辆名不存在的情况下 直接进行提示操作
     2 在修改车辆功能中 增加修改已有车辆的类型的功能
     3 在删除车辆功能中 如果删除的车辆生产类型和或车辆名不存在的情况下 直接进行提示操作
    
     在优化完的基础上 新增两个功能
     1 借车辆功能
     2 还车辆功能
     */
    
    public class MyCarManageService {
        
        private Database database1=new Database();
        HashMap<String, ArrayList<Car>> CarMap = database1.initCarMap();
    
        private UserDatabase database2=new UserDatabase();
        private UserDao userDao1=new UserDao(database2);
    
        Scanner scanner = new Scanner(System.in);
        public MyCarManageService(UserDatabase database2) {
        
            this.userDao1 = new UserDao(database2);
        }
        public void doOperation(int choice, HashMap<String, ArrayList<Car>> CarMap) {
        
            this.iOpreations[choice].work(CarMap);
        }
        protected IOpreation[] iOpreations;
        /**
         * IOpreation[] iOpreations，在这里就实例化了
         */
        public MyCarManageService() {
        
            this.iOpreations = new IOpreation[]{
        
                    new GetCarsInfoOperation(),
                    new AddCarInfoOperation(),
                    new UpdateCarInfoOperation(),
                    new DeleteCarInfoOperation(),
                    new BorrowOperation(),
                    new ReturnOperation(),
                    new ExitOperation()
            };
        }
    
    
        
    
        /**
         * 起始菜单
         */
        public void start() {
        
            System.out.println("1. 登录");
            System.out.println("2. 注册");
            System.out.println("3. 退出系统");
            Scanner enter = new Scanner(System.in);
            int choices = enter.nextInt();
            if(choices>3||choices<1){
        
                System.out.println("你的输入不合要求！");
                start();
            }
            switch (choices) {
        
                case 1:
                    firstLogin();
                    login(CarMap);
    //                GoBack1();
                    break;
                case 2:
                    enroll();
                    start();
                    break;
                case 3:
                    System.exit(0);
            }
        }
    
        public void login(HashMap<String, ArrayList<Car>> CarMap){
        
    
            //创建键盘录入对象
            Scanner scanner = new Scanner(System.in);
    
            int choice = menu(scanner,CarMap)-1;
            doOperation(choice, CarMap);//对车辆进行相关的操作
        }
    
        public int menu( Scanner scanner,HashMap<String, ArrayList<Car>> CarMap) {
        
    
            System.out.println();
            System.out.println("-------欢迎使用车辆租借管理系统-------");
            System.out.println("1.查看所有车辆");
            System.out.println("2.添加车辆信息");
            System.out.println("3.修改车辆信息");
            System.out.println("4.删除车辆信息");
            System.out.println("5.租赁车辆");
            System.out.println("6.归还车辆");
            System.out.println("7.退出系统");
            System.out.println("请您选择:");
    
            //获取键盘录入的数字
            int chooseNum = scanner.nextInt();
            if(chooseNum >7 ||chooseNum <1){
        
                System.out.println("您的输入不合要求！");
                login(CarMap);
            }
            return chooseNum;
    
        }
    
    
        public void GoBack1() {
        
            String opt1 = scanner.next();
            if (opt1.equals("0")) {
        
                start();
            }
            else {
        
                return;
            }
        }
    
        /**
         * 登陆
         */
        public void  firstLogin() {
        
            System.out.println("请输入用户名：");
            String userName = scanner.next();
    
            User user = userDao1.findByName(userName);
            if (user == null) {
        
                //在数据库中找不到的账户，给出提示
                System.out.println("该用户不存在！\n请重新输入：");
                firstLogin();
            }
    
            System.out.println("请输入密码：");
            String password = scanner.next();
    
    //        else {
        
                //在数据库中找到的账户，再根据其密码和输入的密码比较
                if ((user.getPassword()).equals(password)) {
        
                    System.out.println("用户"+userName+"登录成功！");
    //                mainMenu();
    //                GoBack1();
                } else {
        
                    System.out.println("您输入的密码有误！");
                    firstLogin();
                }
            }
    //    }
    
        /**
         * 注册
         */
        //产生验证码
        public String createValidateCode(){
        
            String code = "";
            Random random = new Random();
            for(int i = 1; i <= 4; i++){
        
                //产生一位0-9的随机数
                int num = random.nextInt(10);
                code +=num;
            }
            //返回验证码
            return code;
        }
    
        public void enroll() {
        
            System.out.println("请输入注册的用户名：");
            String userName = scanner.next();
            //判断用户名是否被注册
            User user = userDao1.findByName(userName);
            if(user != null){
        
                System.out.println("该用户已被注册");
                enroll();
            }
            System.out.println("请输入注册的密码：");
            String password1 = scanner.next();
            System.out.println("请确认密码:");
            String password2 = scanner.next();
            if(!password1.equals(password2))
            {
        
                System.out.println("两次密码不一样");
                password1 = passWord() ;
    //            enroll();
    //            start();
    
            }
            System.out.println("验证码:");
            String code=createValidateCode();
            System.out.println(code);
            System.out.println("请输入验证码:");
            String ValidateCode = scanner.next();
            if (!ValidateCode.equals(code)) {
        
                System.out.println("验证码错误");
                     ValidateCode();
    //            enroll();
    //                 start();
            }
    
                    User enrollUser = new User(userName, password1);
                    enrollUser.setUserName(userName);
                    enrollUser.setPassword(password1);
                    //将注册的信息写入数据库
                    userDao1.insert(enrollUser);
                    System.out.println("用户"+userName+"创建成功！");
                    //返回起始菜单
                    start();
                }
    
    
    
        public String passWord() {
        
            System.out.println("请输入要注册的密码：");
            String password1 = scanner.next();
            System.out.println("请确认密码:");
            String password2 = scanner.next();
            if (!password1.equals(password2)) {
        
                System.out.println("两次密码不一样");
                passWord();
            }
    
                return password1;
    
    //        GoBack1();
        }
    
    
        public void ValidateCode() {
        
            System.out.println("验证码:");
            String code=createValidateCode();
            System.out.println(code);
            System.out.println("请输入验证码:");
            String ValidateCode = scanner.next();
    
            if (!ValidateCode.equals(code)) {
        
                System.out.println("验证码错误");
                ValidateCode();
            }
            else {
        
                return;
            }
    //        GoBack1();
        }
    
    
    
    
        //
    
    
    
    
        /**
         * 获取车辆原出租价格
         * @param CarMap
         * @param CarName
         * @return
         */
        public static double getCarPrice(HashMap<String, ArrayList<Car>> CarMap, String CarName) {
        
    
            Set<Map.Entry<String, ArrayList<Car>>> entries = CarMap.entrySet();
            double price = 88;
            for (Map.Entry<String, ArrayList<CarManage.cn.edu.just.model.Car>> Car : entries) {
        
    
                ArrayList<CarManage.cn.edu.just.model.Car> CarList = Car.getValue();
                //对车辆List集合进行遍历
                for (CarManage.cn.edu.just.model.Car CarInfo : CarList) {
        
                    if (CarInfo.getName().equals(CarName)) {
        
                        price = CarInfo.getPrice();
                        break;
                    }
    
                }
    
            }
            return price;
    
        }
    
        /**
         * 判断车辆是否借出
         * @param CarMap
         * @param CarName
         * @return
         */
    
        public static boolean getCarIsBorrowed(HashMap<String, ArrayList<Car>> CarMap, String CarName) {
        
    
            Set<Map.Entry<String, ArrayList<Car>>> entries = CarMap.entrySet();
            boolean isBorrowed=false;
            for (Map.Entry<String, ArrayList<CarManage.cn.edu.just.model.Car>> Car : entries) {
        
    
                ArrayList<CarManage.cn.edu.just.model.Car> CarList = Car.getValue();
                //对车辆List集合进行遍历
                for (CarManage.cn.edu.just.model.Car CarInfo : CarList) {
        
                    if (CarInfo.getName().equals(CarName)) {
        
    
                        isBorrowed = CarInfo.isBorrowed();
                        break;
                    }
    
                }
    
            }
            return isBorrowed;
    
        }
    
        /**
         * 判断车辆生产类型是否存在
         *
         * @param CarMap
         * @param CarType
         */
        public void isExitByType(HashMap<String, ArrayList<Car>> CarMap, String CarType) {
        
    
            ArrayList<Car> CarArrayList1 = CarMap.get(CarType);
            if (CarArrayList1 == null || CarArrayList1.size() == 0) {
        
                System.out.println("您要修改的车辆生产类型不存在");
                login(CarMap);
            }
    
        }
    
        /**
         * 判断车辆名称是否存在
         *
         * @param CarMap
         * @param CarType
         * @param CarName
         */
        public void isExitByName(HashMap<String, ArrayList<Car>> CarMap, String CarType, String CarName) {
        
    
            //根据车辆生产类型获取车辆List集合
            ArrayList<Car> CarArrayList = CarMap.get(CarType);
            //判断要修改的车辆是否存在
            boolean isExist = false;
    
            for (CarManage.cn.edu.just.model.Car Car : CarArrayList) {
        
                String name = Car.getName();
                if (name.equals(CarName)) {
        
                    isExist = true;
                    break;
                }
            }
    
            if (!isExist) {
        
                System.out.println("您要修改的车辆名:" + CarName + "在系统里不存在");
                Scanner scanner = new Scanner(System.in);
    
                login(CarMap);
                 }
            }
        }

#### 2.UserDao类 ####

package CarManage.cn.edu.just.service;
    
    import CarManage.cn.edu.just.dataBase.UserDatabase;
    import CarManage.cn.edu.just.model.User;
    
    public class UserDao {
        
        UserDatabase database1;
    
        public UserDao(UserDatabase database1) {
        
            this.database1 = database1;
        }
    
        /**
         * 根据用户名查找用户
         */
        public User findByName(String userName){
        
            User user =null;
    
            for (User username:database1.getUser()) {
        
                if((username.getUserName()).equals(userName))
                {
        
                    user=username;
                    break;
                }
            }
            return user;
        }
        /**
         * 新增用户
         */
        public void insert(User user){
        
            database1.getUser().add(user);
        }
    }
    
    /**
     * 为了使每一个DAO对象访问到的数据库都是同一个数据库
     * 需要将数据库对象通过参数进行传递，以确保每个DAO访问到的是相同的数据库
     */

### 5、test层 ###

#### 1.Main类 ####

package CarManage.cn.edu.just.test;
    
    
    import CarManage.cn.edu.just.dataBase.Database;
    import CarManage.cn.edu.just.service.MyCarManageService;
    
    public class Main {
        
        public static void main(String[] args) {
        
            Database database = new Database();
            MyCarManageService user = new MyCarManageService();
                 user.start();
    
            }
    }

## 三、运行截图 ##

![在这里插入图片描述][eedd242cc0d6481c92439d16ea09457d.png]  
![在这里插入图片描述][ef60d736942f4928b17c1119a89c1278.png]

![在这里插入图片描述][5e6913c775da412aba7d3fb266e96223.png]

查看车辆

![在这里插入图片描述][644ff86ddaa24c479ffd324814d347e0.png]

添加车辆

![在这里插入图片描述][d63c0e3096b5419a9846c0c6cbb9fb70.png]  
![在这里插入图片描述][264535305b324551896a497158118879.png]

修改车辆

![在这里插入图片描述][8a688b4b11ac47f1bd0eccefb402509e.png]  
![在这里插入图片描述][99ca23e36cef44cbb819c652cf8b1682.png]  
![在这里插入图片描述][098aea1d768f46c6a46a87f81844be61.png]

![在这里插入图片描述][93eaa55995c044fcada522303a6c6579.png]

删除车辆：

![在这里插入图片描述][9fe702cd8057488e836ce04e8c8870ee.png]  
![在这里插入图片描述][ce5a5537b5064d53bb49dbc6252a382f.png]

租赁车辆

![在这里插入图片描述][764b56d3c6d6478e8028e5fc782fd4f2.png]  
![在这里插入图片描述][2f0626905bd64e78ad3ed0ef8296c066.png]

归还车辆

![在这里插入图片描述][9ac7c0e204da4ca7aced156833ed626a.png]  
![在这里插入图片描述][24ce9b10df514319b5803e42ca3ed161.png]

结束退出

![在这里插入图片描述][94188664ef6c400987f634719e7471b0.png]

[21c7fc6844d641a49202bc682578794d.png]: https://img-blog.csdnimg.cn/21c7fc6844d641a49202bc682578794d.png
[6e13413c5dba42da8a269575004e253f.png]: https://img-blog.csdnimg.cn/6e13413c5dba42da8a269575004e253f.png
[eedd242cc0d6481c92439d16ea09457d.png]: https://img-blog.csdnimg.cn/eedd242cc0d6481c92439d16ea09457d.png
[ef60d736942f4928b17c1119a89c1278.png]: https://img-blog.csdnimg.cn/ef60d736942f4928b17c1119a89c1278.png
[5e6913c775da412aba7d3fb266e96223.png]: https://img-blog.csdnimg.cn/5e6913c775da412aba7d3fb266e96223.png
[644ff86ddaa24c479ffd324814d347e0.png]: https://img-blog.csdnimg.cn/644ff86ddaa24c479ffd324814d347e0.png
[d63c0e3096b5419a9846c0c6cbb9fb70.png]: https://img-blog.csdnimg.cn/d63c0e3096b5419a9846c0c6cbb9fb70.png
[264535305b324551896a497158118879.png]: https://img-blog.csdnimg.cn/264535305b324551896a497158118879.png
[8a688b4b11ac47f1bd0eccefb402509e.png]: https://img-blog.csdnimg.cn/8a688b4b11ac47f1bd0eccefb402509e.png
[99ca23e36cef44cbb819c652cf8b1682.png]: https://img-blog.csdnimg.cn/99ca23e36cef44cbb819c652cf8b1682.png
[098aea1d768f46c6a46a87f81844be61.png]: https://img-blog.csdnimg.cn/098aea1d768f46c6a46a87f81844be61.png
[93eaa55995c044fcada522303a6c6579.png]: https://img-blog.csdnimg.cn/93eaa55995c044fcada522303a6c6579.png
[9fe702cd8057488e836ce04e8c8870ee.png]: https://img-blog.csdnimg.cn/9fe702cd8057488e836ce04e8c8870ee.png
[ce5a5537b5064d53bb49dbc6252a382f.png]: https://img-blog.csdnimg.cn/ce5a5537b5064d53bb49dbc6252a382f.png
[764b56d3c6d6478e8028e5fc782fd4f2.png]: https://img-blog.csdnimg.cn/764b56d3c6d6478e8028e5fc782fd4f2.png
[2f0626905bd64e78ad3ed0ef8296c066.png]: https://img-blog.csdnimg.cn/2f0626905bd64e78ad3ed0ef8296c066.png
[9ac7c0e204da4ca7aced156833ed626a.png]: https://img-blog.csdnimg.cn/9ac7c0e204da4ca7aced156833ed626a.png
[24ce9b10df514319b5803e42ca3ed161.png]: https://img-blog.csdnimg.cn/24ce9b10df514319b5803e42ca3ed161.png
[94188664ef6c400987f634719e7471b0.png]: https://img-blog.csdnimg.cn/94188664ef6c400987f634719e7471b0.png