java车辆租赁管理系统

文章目录

- 一、项目需求
- 二、项目结构
- - 项目源代码：
  - 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包：项目测试层

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

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

用一个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类

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 AddCarInfoOperation implements IOpreation {
    @Override
    public void work(HashMap<String, ArrayList<Car>> CarMap) {
        MyCarManageService user = new MyCarManageService();
        Scanner scanner = new Scanner(System.in);
        System.out.println("");
        System.out.println("请输入您要添加的车辆生产类型:");
        String CarType = scanner.next();

        System.out.println("请输入您要添加的车辆名:");
        String CarName = scanner.next();
        System.out.println("请输入您要添加的车辆月出租价格:");
        double CarPrice = scanner.nextDouble();

        //创建车辆对象
        Car addCar = new Car(CarName, CarType, CarPrice);

        //添加车辆存在两种情况
        //1新添加的车辆生产类型在CarMap中已存在如果是这样那么就直接将新车辆添加到对应类型的车辆List集合中
        //2新添加的车辆生产类型在CarMap中不存在如果这样需要新建键值对完成CarMap中的元素添加
        //根据车辆生产类型查询是否有对应的车辆List集合

        ArrayList<Car>CarArrayList = CarMap.get(CarType) ;

        if (CarArrayList != null){
            // 情况1
            CarArrayList.add(addCar);
        }else {
            //情况2

            //新建List集合并添加车辆
            ArrayList<Car> CarList = new ArrayList<>();
            CarList.add(addCar);
            // CarMap新添加键值对
            CarMap.put (CarType,CarList);
        }
        System.out.println("添加"+CarName+"成功!");
        user.login( CarMap);
    }

}

3.DeleteCarInfoOperation类

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 DeleteCarInfoOperation implements IOpreation {
    @Override
    public void work(HashMap<String, ArrayList<Car>> CarMap) {
        MyCarManageService user = new MyCarManageService();
        Scanner scanner=new Scanner(System.in);
        System.out.println("");
        System.out.println("请输入要删除的车辆生产类型");
        String deleteCarType = scanner.next();
        user.isExitByType(CarMap,deleteCarType);

        System.out.println("请输入要删除的车辆名");
        String deleteCarName = scanner.next();
        user.isExitByName(CarMap,deleteCarType, deleteCarName);

        ArrayList<Car> CarArrayList = CarMap.get(deleteCarType);
        for (int i = 0; i < CarArrayList.size(); i++) {
            Car Car = CarArrayList.get(i);
            String name = Car.getName();
            if (name.equals(deleteCarName)) {
                //要删除的车辆名存在进行删除
                CarArrayList.remove(i);
                System.out.println("删除" + name + "成功!");

                //删除车辆后需要判断该车辆所在List集合长度是否为0
                if(CarArrayList.size() == 0) {
                    //移除该键值对
                    CarMap.remove(deleteCarType);
                }

                break;
            }

        }
        user.login( CarMap);
    }
}

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类

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.Map;
import java.util.Set;

public class GetCarsInfoOperation implements IOpreation {
    @Override
    public void work(HashMap<String, ArrayList<Car>> CarMap) {
        MyCarManageService user = new MyCarManageService();
        System.out.println("类型  \t车辆名\t\t月租金\t\t是否借出");
        //对CarMap进行遍历并打印
        Set<Map.Entry<String, ArrayList<Car>>> entries = CarMap.entrySet();

        for (Map.Entry<String, ArrayList<CarManage.cn.edu.just.model.Car>> Car : entries) {
            //获取CarMap中的key(车辆生产类型)
            String CarType = Car.getKey();
            System.out.println(CarType);
            //获取CarMap中的value（车辆List集合）
            ArrayList<CarManage.cn.edu.just.model.Car> CarList = Car.getValue();
            //对车辆List集合进行遍历
            for (CarManage.cn.edu.just.model.Car CarInfo : CarList) {
                System.out.println("\t\t"+CarInfo.getName()+"\t\t"+CarInfo.getPrice()+"\t\t"+(CarInfo.isBorrowed()==true ? "已借出" : "未借出"));
            }

        }
        user.login( CarMap);
    }
}

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();

        }
}