简单实现迷你共享单车管理系统 java 接口学习

实体类 SharedBike

@Setter
@Getter
@AllArgsConstructor
public class SharedBike {
    private Integer bid;// 单车编号
    private String bName;// 单车名称-->ofo 哈罗 摩拜 private
    private Integer status;// 单车状态--> 0 已借出 1 可借状态 private
    private String borrowTime;// 单车借出时间

}

实体类 SharedBikeCompany

@Setter
@Getter
@AllArgsConstructor
public class SharedBikeCompany {
    private Integer bikeCompanyId;// 公司id
    private String bikeCompanyName;// ofo 哈罗 摩拜
    private SharedBike[] sharedBikes;// 公司持有共享单车
    private Integer sum;//公司单车总量
    private Integer count;// 公司单车借出次数
}

接口 SharedBikeService

public interface SharedBikeService {
    /*查询当前单车品牌是否存在*/
    SharedBike selectSharedBike(String bikeName, SharedBike[] sharedBikes);

    /*展示当前公司品牌单车的所有信息*/
    void  showBrandBikeInfo(SharedBike[] sharedBikes);

    /*添加单车*/
    SharedBike[] addSharedBike(SharedBike[] sharedBikes,String bikeName,Integer bikeNameNumber);

    /*借出单车*/
    SharedBike[] lendShareBike(SharedBike[] sharedBikes, SharedBikeCompany sharedBikeCompany);

    SharedBike[] returnShareBike(SharedBike[] sharedBikes);
    
}

接口 实现类 SharedBikeServiceImpl

public class SharedBikeServiceImpl implements SharedBikeService {

    public static  SharedBikeServiceImpl sharedBikeService = new SharedBikeServiceImpl();

    /*查询当前单车品牌是否存在*/
    @Override
    public SharedBike selectSharedBike(String bikeName, SharedBike[] sharedBikes) {
        if (bikeName == null || sharedBikes == null){
            System.out.println("数据为空");
            return null;
        }
        for (SharedBike b: sharedBikes
             ) {
            if (bikeName.equals(b.getBName())){
                return b;
            }
        }
        return null;
    }
    /*展示当前公司品牌单车的所有信息*/
    @Override
    public void showBrandBikeInfo(SharedBike[] sharedBikes) {
        System.out.println(sharedBikes.length);
        if (sharedBikes == null || sharedBikes.length == 0){
            System.out.println("数据为空");
            return;
        }
        int i = 1 ;
        for (SharedBike s: sharedBikes
             ) {
            System.out.println("单车序号\t单车品牌\t单车状态\t借出时间");
            System.out.println(i+"\t\t"+s.getBName()+"\t\t"+(s.getStatus()==0?"已借出":"可借")+"\t\t"+s.getBorrowTime());
            i++;
        }
    }

    @Override
    public SharedBike[] addSharedBike(SharedBike[] sharedBikes, String bikeName, Integer bikeNameNumber) {
        int sum = 0;
        if (sharedBikes != null){
            sum = sharedBikes.length;
        }
        SharedBike[] sharedBikes1 = new SharedBike[sum+bikeNameNumber];
        for (int i = 0; i < sharedBikes1.length; i++) {
            if (i<sum){
                sharedBikes1[i] = sharedBikes[i];
            }else {
                sharedBikes1[i] = new SharedBike(i+1,bikeName,1,null);
            }
        }
        return sharedBikes1;
    }

    @Override
    public SharedBike[] lendShareBike(SharedBike[] sharedBikes , SharedBikeCompany sharedBikeCompany) {
        sharedBikeService.showBrandBikeInfo(sharedBikes);
        Scanner sc = new Scanner(System.in);
        int sum;
        while (true) {
            System.out.println("请输入您要借出的单车序号：");
            sum = sc.nextInt();
            if (sum > sharedBikes.length || sharedBikes[sum-1].getStatus()==0) {
                System.out.println("恁的输入有误！是否继续  yes/no");
                if (!sc.next().equals("yes")) {
                    return sharedBikes;
                }
                continue;
            }
            sharedBikeCompany.setCount(sharedBikeCompany.getCount()+1);
            System.out.println("成功借出");
            /*时间日期格式化*/
            LocalDateTime localDateTime = LocalDateTime.now();
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("YYYY-MM-dd HH:mm:ss");
            String time = dateTimeFormatter.format(localDateTime);
            sharedBikes[sum-1].setStatus(0);
            sharedBikes[sum -1].setBorrowTime(time);
            return sharedBikes;
        }
    }

    @Override
    public SharedBike[] returnShareBike(SharedBike[] sharedBikes) {
        sharedBikeService.showBrandBikeInfo(sharedBikes);
        Scanner sc = new Scanner(System.in);
        int sum;
        while (true) {
            System.out.println("请输入您要归还的单车序号：");
            sum = sc.nextInt();
            if (sum > sharedBikes.length || sharedBikes[sum-1].getStatus() == 1) {
                System.out.println("恁的输入有误！是否继续  yes/no");
                if (!sc.next().equals("yes")) {
                    return sharedBikes;
                }
                continue;
            }
            System.out.println("归还成功");
            /*时间日期格式化*/
            LocalDateTime nowLocalDateTime = LocalDateTime.now();
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

            String str1 = dateTimeFormatter.format(nowLocalDateTime);
            String str2 = sharedBikes[sum-1].getBorrowTime();


            LocalDateTime startTime = LocalDateTime.parse(str1,dateTimeFormatter);
            LocalDateTime lendTime = LocalDateTime.parse(str2,dateTimeFormatter);

            Duration duration = Duration.between(lendTime,startTime);
            // 格式化Duration对象
            long hours = duration.toHours();
            long minutes = duration.toMinutesPart(); // 获取小时之后的分钟数
            long seconds = duration.getSeconds() % 60; // 获取剩余的秒数

            // 输出格式化后的时间差
            System.out.println("共借出 " + hours + " 小时 " + minutes + " 分钟 " + seconds + " 秒");
            System.out.println("您需要支付"+hours+"元");
            sharedBikes[sum-1].setStatus(1);
            sharedBikes[sum -1].setBorrowTime(null);
            return sharedBikes;
        }
    }
}

接口 SharedBikeCompanyService

public interface SharedBikeCompanyService {
    /*查询当前公司是否存在*/
    SharedBikeCompany selectBikeCompanyName(String bikeCompanyName, SharedBikeCompany[] sharedBikeCompanies);

    /*展示当前所有的单车公司信息*/
    void showBikeCompanyInfo(SharedBikeCompany[] sharedBikeCompanies);

    /*创建一个新的公司对象，存入到员公司对象数组中*/
    SharedBikeCompany[] addBikeCompany(SharedBikeCompany[] sharedBikeCompanies,String bikeCompanyName);

    /*删除 单车公司*/
    SharedBikeCompany[] deleteBike(SharedBikeCompany[] bikeCompanies );

    void rankingList(SharedBikeCompany[] sharedBikeCompanies);
}

接口实现类 SharedBikeCompanyServiceImpl

public class SharedBikeCompanyServiceImpl implements SharedBikeCompanyService {

    public static SharedBikeCompanyServiceImpl sharedBikeCompanyService = new SharedBikeCompanyServiceImpl();

    /*根据公司名称判断公司是否存在*/
    @Override
    public SharedBikeCompany selectBikeCompanyName(String bikeCompanyName, SharedBikeCompany[] sharedBikeCompanies) {
        if (bikeCompanyName == null || sharedBikeCompanies == null){
            System.out.println("数据为空");
            return null;
        }
        for (SharedBikeCompany s: sharedBikeCompanies
             ) {
            if (bikeCompanyName.equals(s.getBikeCompanyName())){
                return s;
            }
        }
        return null;
    }

    @Override
    public void showBikeCompanyInfo(SharedBikeCompany[] sharedBikeCompanies) {
        if (sharedBikeCompanies.length == 0 || sharedBikeCompanies == null){
            System.out.println("未查询到公司信息");
            return;
        }
        int i = 1;
        for (SharedBikeCompany s: sharedBikeCompanies
             ) {
            System.out.println("公司序号\t公司名称\t公司单车数量\t公司单车借出次数");
            System.out.println(i+"\t\t"+s.getBikeCompanyName()+"\t\t"+s.getSum()+"\t\t\t"+s.getCount());
            /*调用单车接口实现类查询单车信息*/
            sharedBikeService.showBrandBikeInfo(s.getSharedBikes());
            i++;
        }
    }

    @Override
    public SharedBikeCompany[] addBikeCompany(SharedBikeCompany[] sharedBikeCompanies,String bikeCompanyName) {
        if (sharedBikeCompanies == null){
            SharedBikeCompany s = new SharedBikeCompany(1,bikeCompanyName,null,0,0);
            sharedBikeCompanies = new SharedBikeCompany[]{s};
            return sharedBikeCompanies;
        }else {
            SharedBikeCompany[] sharedBikeCompanies1 = new SharedBikeCompany[sharedBikeCompanies.length+1];
            for (int i = 0; i < sharedBikeCompanies1.length; i++) {
                if (i<sharedBikeCompanies.length){
                    sharedBikeCompanies1[i] = sharedBikeCompanies[i];
                }else {
                    sharedBikeCompanies1[i] = new SharedBikeCompany(sharedBikeCompanies.length+1,bikeCompanyName,null,0,0);
                }
            }
            return sharedBikeCompanies1;
        }
    }

    @Override
    public SharedBikeCompany[] deleteBike( SharedBikeCompany[] bikeCompanies) {
        System.out.println("1.删除单车公司\t2.删除单车");
        Scanner sc = new Scanner(System.in);
        switch (sc.nextInt()){
            case 1:
                System.out.println("请输入公司名称：");
                String bikeCompanyName = sc.next();
                SharedBikeCompany[] sharedBikeCompanies = new SharedBikeCompany[bikeCompanies.length];
                int sum = 0;
                for (int i = 0; i < bikeCompanies.length; i++) {
                    if (!bikeCompanies[i].getBikeCompanyName().equals(bikeCompanyName)){
                        sharedBikeCompanies[sum] = bikeCompanies[i];
                        sum++;
                    }
                }
                if (sum == bikeCompanies.length){
                    System.out.println(sharedBikeCompanies.length);
                    System.out.println("为查询到该公司信息");
                    return sharedBikeCompanies;
                }else {
                    System.out.println(sharedBikeCompanies.length);
                    SharedBikeCompany[] sharedBikeCompanies2 = new SharedBikeCompany[sharedBikeCompanies.length-1];
                    for (int i = 0; i < sharedBikeCompanies2.length; i++) {
                        sharedBikeCompanies2[i] = sharedBikeCompanies[i];
                        System.out.println("删除成功");
                    }
                    return sharedBikeCompanies2;
                }
            case 2:
                System.out.println("请输入公司名称：");
                String bikeCompanyName2 = sc.next();
                System.out.println("当前品牌下所有单车为：");
                for (SharedBikeCompany s: bikeCompanies
                     ) {
                    if (s.getBikeCompanyName().equals(bikeCompanyName2)){
                        while (true){
                            sharedBikeService.showBrandBikeInfo(s.getSharedBikes());
                            System.out.println("请输入你要删除的单车的序号：");
                            int id = sc.nextInt();
                            if (id>s.getSharedBikes().length+1){
                                System.out.println("恁的输入有误,请重新输入");
                                break;
                            }
                            int sum2 = 0;
                            SharedBike[] sharedBike = new SharedBike[s.getSharedBikes().length-1];
                            for (int i = 0; i < s.getSharedBikes().length-1; i++) {
                                if (i != id){
                                    sharedBike[sum2] = s.getSharedBikes()[i];
                                    sum2++;
                                }
                            }

                            s.setSum(s.getSum()-1);
                            System.out.println("删除成功");
                            s.setSharedBikes(sharedBike);
                            return bikeCompanies;
                        }

                    }
                }
                System.out.println("品牌输入有误");
                break;
            default:
                System.out.println("输入错误");
                return bikeCompanies;
        }
   return null;
    }

    @Override
    public void rankingList(SharedBikeCompany[] sharedBikeCompanies) {
        for (int i = 0; i < sharedBikeCompanies.length; i++) {
            for (int j = 0; j < sharedBikeCompanies.length-i-1; j++) {
                if (sharedBikeCompanies[j].getCount()>sharedBikeCompanies[j+1].getCount()){
                    SharedBikeCompany sharedBikeCompany = sharedBikeCompanies[j];
                    sharedBikeCompanies[j] = sharedBikeCompanies[j+1];
                    sharedBikeCompanies[j+1] = sharedBikeCompany;
                }
            }
        }
        int sum = 1;
        for (int i = sharedBikeCompanies.length-1; i >= 0 ; i--) {
            System.out.println(sum+"\t公司名称"+sharedBikeCompanies[i].getBikeCompanyName()+"\t借出次数："+sharedBikeCompanies[i].getCount());
            sum++;
        }
    }
}

测试类 test

public class Test {
    static Scanner scanner = new Scanner(System.in);
    static SharedBikeCompany[] sharedBikeCompanies = new SharedBikeCompany[0] ;

    public static void main(String[] args) {
       while (true){
           start();
       }
}
public static void start(){
    System.out.println("欢迎使用迷你共享单车管理系统");
    System.out.println("*******************************************");
    System.out.println("                  1.投放Bike");
    System.out.println("                  2.查看Bike");
    System.out.println("                  3.删除Bike");
    System.out.println("                  4.借出Bike");
    System.out.println("                  5.归还Bike");
    System.out.println("                  6.Bike排行榜");
    System.out.println("                  7.退      出");
    System.out.println("*******************************************");
    System.out.print("请选择：");
    Scanner sc = new Scanner(System.in);
    switch (sc.nextInt()){
        case 1:
            System.out.println("投放Bike");
            putBikes();
            break;
        case 2:
            System.out.println("查看所有的Bike信息");
            lookBikesInfo();
            break;
        case 3:
            System.out.println("删除Bike");
          sharedBikeCompanies =  sharedBikeCompanyService.deleteBike(sharedBikeCompanies);
            break;
        case 4:
            System.out.println("借出Bike");
            lendBike();
            break;
        case 5:
            System.out.println("归还Bike");
            returnShareBike();
            break;
        case 6:
            System.out.println("查看Bike排行榜");
            rankingList();
            break;
        case 7:
            System.out.println("退出");
            System.exit(0);
            break;
        default:
            System.out.println("输入错误");
            break;
    }
}

    private static void rankingList() {
        sharedBikeCompanyService.rankingList(sharedBikeCompanies);
    }

    private static void returnShareBike() {
        while (true){
            System.out.println("当前车辆信息如下：");
            sharedBikeCompanyService.showBikeCompanyInfo(sharedBikeCompanies);
            System.out.println("请输入您要归还单车公司名称：");
            SharedBikeCompany sharedBike = sharedBikeCompanyService.selectBikeCompanyName(scanner.next(),sharedBikeCompanies);
            if (sharedBike == null){
                System.out.println("输入有误是否继续  yes/no");
                if (!scanner.next().equals("yes")){
                    return;
                }else {
                    continue;
                }
            }
            sharedBike.setSharedBikes(sharedBikeService.returnShareBike(sharedBike.getSharedBikes()));
            sharedBikeCompanyService.showBikeCompanyInfo(sharedBikeCompanies);
            break;
        }
    }

    private static void lendBike() {
     while (true){
         System.out.println("当前车辆信息如下：");
         sharedBikeCompanyService.showBikeCompanyInfo(sharedBikeCompanies);
         System.out.println("请输入您要借出单车公司名称：");
         SharedBikeCompany sharedBike = sharedBikeCompanyService.selectBikeCompanyName(scanner.next(),sharedBikeCompanies);
         if (sharedBike == null){
             System.out.println("输入有误是否继续  yes/no");
             if (!scanner.next().equals("yes")){
                 return;
             }else {
                 continue;
             }
         }
         sharedBike.setSharedBikes(sharedBikeService.lendShareBike(sharedBike.getSharedBikes(),sharedBike));

         sharedBikeCompanyService.showBikeCompanyInfo(sharedBikeCompanies);
         break;
     }

    }


    private static void lookBikesInfo() {
        if (sharedBikeCompanies.length == 0 || sharedBikeCompanies == null){
            System.out.println("当前数据为空。");
            return;
        }
        for (int i = 0; i < sharedBikeCompanies.length; i++) {
            sharedBikeCompanyService.showBikeCompanyInfo(sharedBikeCompanies);
        }
    }

    private static void putBikes() {
        System.out.println("请输入您的公司名称");
        String bikeCompanyName = scanner.next();
        System.out.println("请输入您要投放的单车品牌");
        String bikeName = scanner.next();
        System.out.println("请输入您要投放的单车数量");
        Integer bikeNameNumber = scanner.nextInt();
        /*查询当前公司是否存在*/
        SharedBikeCompany result = sharedBikeCompanyService.selectBikeCompanyName(bikeCompanyName,sharedBikeCompanies);
        if (result != null){
            /*当前公司已存在*/
            /*添加单车*/
            System.out.println("当前公司已存在,正在进行添加");
            result.setSharedBikes(sharedBikeService.addSharedBike(result.getSharedBikes(),bikeName,bikeNameNumber));
            result.setSum(result.getSum()+bikeNameNumber);
            System.out.println("添加完成");
        }else {
            /*当前公司不存在*/
            System.out.println("当前公司不存在,已进行公司创建");
            sharedBikeCompanies =  sharedBikeCompanyService.addBikeCompany(sharedBikeCompanies,bikeCompanyName);
            sharedBikeCompanies[sharedBikeCompanies.length-1].setSum(bikeNameNumber);
            /* 公司创建完成 开始投放单车 */
            sharedBikeCompanies[sharedBikeCompanies.length-1].setSharedBikes(sharedBikeService.addSharedBike(null,bikeName,bikeNameNumber));
        }
    }
}