Java小练_面向对象-模拟迷你共享单车

1.开发计划

用例1：数据初始化[20分钟]

用例2：实现菜单切换[25分钟]

用例3：实现查看Bike信息[20分钟]

用例4：实现新增Bike信息[20分钟]

用例5：实现删除Bike信息[25分钟]

用例6：实现借出Bike业务处理[25分钟]

用例7：实现归还Bike业务处理[25分钟]

用例8：实现借出排行榜[20分钟]

2.用例编写

2.1用例1-数据初始化

2.1.1.需求说明

斜体样式初始化Bike信息

思路分析：
• 创建项目bike
• 创建类SharedBike/SharedBikeCompany，添加相应属性
• 创建类SharedBikeMgr，添加方法initial()，初始化3个公司以及每个公司单车基本信息

2.1.2.功能测试

• 创建类SharedBike/SharedBikeCompany 
• 创建类SharedBikeMgr，初始化单车信息

/**
 * 所有单车公司的父类
 * @title SharedBike.java
 * @author Administrator
 * @date 2020年4月29日
 * @version 0.1
 */
@AllArgsConstructor
@Setter
@Getter
public class SharedBike {
	private int bid;//单车编号 
	private String bname;//单车名称-->ofo 哈罗 摩拜 
	private int status;//单车状态--> 0 已借出 1 可借状态 
	private String borrowTime;//单车借出时间
	//重写toString()方法，输出单车元素不是地址
    public String toString(){
    	return bid+"\t"+"\t"+bname+"\t"+"\t"+status+"\t"+"\t"+borrowTime;
    }
}

@AllArgsConstructor
@Setter
@Getter
public class SharedBikeCompany {
	private int bikeCompanyId;//公司id 
	private String bikeCompanyName;//ofo 哈罗 摩拜 
	private SharedBike[] sharedBikes;//公司持有共享单车 
	private int sum;//公司单车总量
	private int count;//公司单车借出次数
}
package com.exercise.bike.entity;
//暂时没有什么成员，单纯继承单车公司父类
public class OfoBike extends SharedBike{
	public OfoBike(int bid, String bname, int status, String borrowTime) {
		super(bid, bname, status, borrowTime);
	}
}

public class HaloBike extends SharedBike {
	public HaloBike(int bid, String bname, int status, String borrowTime) {
		super(bid, bname, status, borrowTime);
	}
}

public class MoBaiBike extends SharedBike{
	public MoBaiBike(int bid, String bname, int status, String borrowTime) {
		super(bid, bname, status, borrowTime);
	}
}

public class SharedBikeMgr {
	//初始化三家公司，三家公司统一维护，适合放进一个数组里
	private SharedBikeCompany[] companies;//声明三家公司
	private void initial() {
		companies = new SharedBikeCompany[3];//初始化三家公司
		SharedBike[] sharedBikes = null;
		//初始化每家公司的数据，每家公司的情况不一样，不能用循环来写
		companies[0] = new SharedBikeCompany(1, "ofo", sharedBikes, 3, 100);
		companies[1] = new SharedBikeCompany(2, "哈罗", sharedBikes, 3, 210);
		companies[2] = new SharedBikeCompany(3, "摩拜", sharedBikes, 3, 50);
	
		//初始化三家单车公司各自持有单车的情况
		SharedBike[] bikes1 = new OfoBike[3];
		SharedBike[] bikes2 = new HaloBike[3];
		SharedBike[] bikes3 = new MoBaiBike[3];

		//遍历赋值单车元素
		for(int index = 0;index < 3;index ++) {
			bikes1[index] = new OfoBike(2, "ofo单车1", 0, "2019-8-12 12:00:00");
			bikes2[index] = new HaloBike(3, "halo单车2", 1, "");
			bikes3[index] = new MoBaiBike(1, "mobai单车0", 1, "");
		}
		System.out.println("单车编号bid\t单车名称bname\t单车状态status\t单车借出时间borrowTime");
		System.out.println(Array.get(bikes1, 0));
		System.out.println(Array.get(bikes2, 0));
		System.out.println(Array.get(bikes3, 0));
	}
	public static void main(String[] args) {
		SharedBikeMgr ceshi = new SharedBikeMgr();
		ceshi.initial();
	}
}

2.2.用例2-实现菜单切换

2.2.1.需求说明

编写程序入口，实现菜单显示和切换

思路分析：
• 创建方法startMenu()，实现菜单切换
• 创建方法returnMain()，返回主菜单
• 编写类Start，实现程序入口
难点提示：
使用switch语句实现菜单切换

2.2.2.功能测试

• 实现菜单切换
• 输入非数字时程序报错

public class SharedBikeMgr {
	private Scanner input;//声明一个可以供该类里所有方法共享的Scanner变量
	//编写管理系统的入口方法startMenu()
	public void startMenu() {
		while(true) {//使得主界面可以循环显示
			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("请选择：");
			input = new Scanner(System.in);
			//输入非数字时程序报错
			if(!input.hasNextInt()) {
				System.err.println("抱歉，您输入的不是数字。");
				input = new Scanner(System.in);
				returnMain();
			}else {
				int option = input.nextInt();
				switch(option) {
				case 1:
					System.out.println("---->1.投放Bike");
					break;
				case 2:
					System.out.println("---->2.查看Bike");
					break;
				case 3:
					System.out.println("---->3.删除Bike");
					break;
				case 4:
					System.out.println("---->4.借出Bike");
					break;
				case 5:
					System.out.println("---->5.归还Bike");
					break;
				case 6:
					System.out.println("---->6.Bike排行榜");
					break;
				case 7:
					System.out.println("程序退出");
					return;
				default:
					System.out.println("您的输入有误，请重新输入：");
					return;
				}
				returnMain();
			}			
		}
	}
	private int returnMain() {
		System.out.println("---------------");
		System.out.print("输入0返回:");
		int num = input.nextInt();
		return num;
	}
	public static void main(String[] args) {
		SharedBikeMgr ceshi = new SharedBikeMgr();
		ceshi.startMenu();
	}
}

2.3.用例3-实现查看Bike信息

2.3.1.需求说明

遍历所有公司下的Bike，获取数组元素信息，并进行显示

思路分析：
• 在类SharedBikeDao中创建方法selectAllBike()，完成功能要求
• 根据状态值输出“已借出”或“可借”
难点提示：
• 循环结束条件：bikeCompanies[i].getSharedBikes()[i] == null
• 避免变量为null

2.3.2.功能测试

• 正确输出所有Bike信息
• 正确输出Bike状态信息
• 输出格式正确

public class SharedBikeMgr {
	//初始化三家公司，三家公司统一维护，适合放进一个数组里
	private SharedBikeCompany[] companies;//声明三家公司
	private Scanner input;//声明一个可以供该类里所有方法共享的Scanner变量
	private SharedBikeDao sharedBikeDao;//声明接口类SharedBikeDao
	private void initial() {
		//初始化input
		input = new Scanner(System.in);
		//初始化sharedBikeDao
		sharedBikeDao = new SharedBikeDaoImpl();
		
		//初始化三家单车公司各自持有单车的情况
		SharedBike[] bikes1 = new OfoBike[3];
		SharedBike[] bikes2 = new HaloBike[3];
		SharedBike[] bikes3 = new MoBaiBike[3];

		//遍历赋值单车元素
		for(int index = 0;index < 3;index ++) {
			int bid = index + 1;
			bikes1[index] = new OfoBike(bid, "ofo单车"+(bid-1), 1, "");
			bikes2[index] = new HaloBike(bid, "halo单车"+(bid-1), 1, "");
			bikes3[index] = new MoBaiBike(bid, "摩拜单车"+(bid-1), 1, "");
		}
		companies = new SharedBikeCompany[3];//初始化三家公司
		//初始化每家公司的数据，每家公司的情况不一样，不能用循环来写
		companies[0] = new SharedBikeCompany(1, "ofo单车", bikes1, 3, 100);
		companies[1] = new SharedBikeCompany(2, "哈罗单车", bikes2, 3, 210);
		companies[2] = new SharedBikeCompany(3, "摩拜单车", bikes3, 3, 50);
	}
    
	//将查看单车封装进viewBike()方法里
	private void viewBike() {
		System.out.println("---->2.查看Bike");
		sharedBikeDao.selectAllBike(companies);		
	}
	
	public SharedBikeMgr() {
		//有且只走一次初始化操作，将初始化写在构造里
		initial();
	}
	public static void main(String[] args) {
		SharedBikeMgr ceshi = new SharedBikeMgr();
		ceshi.startMenu();
	}
}

//接口类SharedBikeDao
public interface SharedBikeDao {
	/**
	 * 遍历所有公司的单车信息
	 * @param companies  所有的单车公司
	 */
	void selectAllBike(SharedBikeCompany[] companies);
}

/**SharedBikeDao接口的实现类 可以看作父接口
 * @title SharedBikeDaoImpl.java
 * @author Administrator
 * @date 2020年4月30日
 * @version 0.1
 */
public class SharedBikeDaoImpl implements SharedBikeDao{
	@Override
	public void selectAllBike(SharedBikeCompany[] companies) {
		//接收传过来的公司信息并遍历公司信息以及每个公司下的单车信息
		for(SharedBikeCompany company : companies) {
			System.out.println("-----------------------------------------------------------------");
			System.out.println("公司序号\t|\t公司名称\t|\t单车数量\t|\t借出次数");
			System.out.println("-----------------------------------------------------------------");
			System.out.println(company.getBikeCompanyId()+"\t|\t"+company.getBikeCompanyName()+"\t|\t"+company.getSum()+"\t|\t"+company.getCount());
			System.out.println("-----------------------------------------------------------------");
			System.out.println("单车序号\t|\t单车品牌\t|\t单车状态\t|\t借出时间");
			System.out.println("-----------------------------------------------------------------");
             //获取单车信息
			SharedBike[] sharedBikes = company.getSharedBikes();
             //每家公司的情况不一样，不适合用增强for循环遍历
			for(int index = 0;index < 3;index ++) {
				SharedBike bike = sharedBikes[index];
				//将借出状态以字符串形式输出
				String status = (bike.getStatus() == 1) ? "可借" : "已借出";
				//借出时间为null输出空白
				String borrowTime = (bike.getBorrowTime() == null) ? "" : bike.getBorrowTime();
				System.out.println(bike.getBid()+"\t|\t"+bike.getBname()+"\t|\t"+status+"\t|\t"+borrowTime);
			}
		}
	}
}

2.4.用例4-实现投放Bike信息

2.4.1.需求说明

向bike数组新增n辆某品牌的单车信息，实现新增Bike信息

思路分析：
• 在类SharedBikeDao中创建方法putBike()，完成功能要求 
• 定位新增位置 
• 插入Bike信息，状态值为1(可借) 
难点提示：
• 定位新增位置：第一个bike为null的位置

2.4.2.功能测试

正确新增Bike

	//代码优化
	//单车公司和单车名字都是固定的，可以通过常量去统一维护单车的信息
	package com.exercise.bike.consts;
	public class BikeConstants {
		private BikeConstants() {}
		public static final String OFO_NAME = "ofo单车";
		public static final String HALO_NAME = "halo单车";
		public static final String MOBAI_NAME = "摩拜单车";
		public static final String OFO_COMPANY_NAME = "ofo单车公司";
		public static final String HALO_COMPANY_NAME = "halo单车公司";
		public static final String MOBAI_COMPANY_NAME = "摩拜单车公司";
	}
	//初始化单车公司和单车信息的遍历语句就可以修改为
	//遍历赋值单车元素
	for(int index = 0;index < 3;index ++) {
		int bid = index + 1;
//		bikes1[index] = new OfoBike(bid, "ofo单车"+(bid-1), 1, "");
		bikes1[index] = new OfoBike(bid, BikeConstants.OFO_NAME+(bid-1), 1, null);
		bikes2[index] = new HaloBike(bid, BikeConstants.HALO_NAME+(bid-1), 1, "");
		bikes3[index] = new MoBaiBike(bid, BikeConstants.MOBAI_NAME+(bid-1), 1, "");
	}
	companies = new SharedBikeCompany[3];//初始化三家公司
//	companies[0] = new SharedBikeCompany(1, "ofo单车", bikes1, 3, 100);
	companies[0] = new SharedBikeCompany(1, BikeConstants.OFO_COMPANY_NAME, bikes1, 3, 100);
	companies[1] = new SharedBikeCompany(2, BikeConstants.HALO_COMPANY_NAME, bikes2, 3, 210);
	companies[2] = new SharedBikeCompany(3, BikeConstants.MOBAI_COMPANY_NAME, bikes3, 3, 50);

	private void putBike() {
		System.out.println("---->1.投放Bike");
//		System.out.println("1:"+companies[0].getBikeCompanyName());
		System.out.println("1:"+BikeConstants.OFO_COMPANY_NAME);
		System.out.println("2:"+BikeConstants.HALO_COMPANY_NAME);
		System.out.println("3:"+BikeConstants.MOBAI_COMPANY_NAME);
		System.out.println("请选择投放的单车品牌:");
		int companyIndex = input.nextInt();//把companyIndex当作索引值来用
		System.out.println("请录入投放的数量:");
		int addBikeNum = input.nextInt();
		sharedBikeDao.putBike(companies[companyIndex-1],addBikeNum);
	}

	//接口类SharedBikeDao
	/**
	 * 向bike数组新增addBikeNum辆某品牌的单车信息
	 * @param sharedBikeCompany 投放的单车公司
	 * @param addBikeNum 新投放的数量
	 */
	void putBike(SharedBikeCompany sharedBikeCompany, int addBikeNum);

	//实现类里的投放操作
	@Override
	public void putBike(SharedBikeCompany sharedBikeCompany, int addBikeNum) {
		//投放到当前company下面的一个数组里面SharedBike[] sharedBikes
		SharedBike[] sharedBikes = sharedBikeCompany.getSharedBikes();
		int len = sharedBikes.length;//现有的单车数组长度
		int sum = sharedBikeCompany.getSum();//现有的单车量
		//现有的单车数组长度减去现有的公司单车量，比新增的单车量比较
		if((len - sum) < addBikeNum) {
			//不够新增量存放
			try {
				//Thread.sleep();使当前线程休眠，暂停执行2秒种， 制造正在扩容空间的假象。
				Thread.sleep(2000);
			}catch(InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("空间不足，已经参照配置进行扩容");
			sharedBikes = Arrays.copyOf(sharedBikes, len+5*addBikeNum);//新增5辆
			//需注意：copyOf()是产生了一个新的数组。在内存里开辟了一块新内存，跟原数组地址不一样。
		}
		//将addBikeNum个单车信息存储到 sharedBikes
		//新的元素紧跟着之前的元素（比如之前5个元素，现在要从第6个元素起，也就是从索引值为5的元素起） 
		for(int i = 1;i <= addBikeNum;i ++) {
			//sharedBikes[sum] = new ???//new的对象OfoBike/HaloBike/Mobai 不固定，需要自己制定逻辑
			SharedBike bike = null;
			switch(sharedBikeCompany.getBikeCompanyId()) {
			case 1:
				bike = new OfoBike(sum+1,BikeConstants.OFO_NAME+sum,1,null);
				break;
			case 2:
				bike = new HaloBike(sum+1,BikeConstants.HALO_NAME+sum,1,null);
				break;
			default:
				bike = new MoBaiBike(sum+1,BikeConstants.MOBAI_NAME+sum,1,null);
				//SharedBike[] getSharedBikes()
				break;
			}
			sharedBikes[sum] = bike;
			sum++;
		}
		System.out.println("投放"+addBikeNum+"辆"+sharedBikeCompany.getBikeCompanyName()+"成功");
		//公司的单车总量要累加（sum值已经改变了，重新获取赋值）
		sharedBikeCompany.setSum(sharedBikeCompany.getSum()+addBikeNum);
		//修改过的sharedBikes一定要告诉公司 不然新投放的单车信息遍历不到
		sharedBikeCompany.setSharedBikes(sharedBikes);
	}

2.5.用例5-实现删除Bike信息

2.5.1.需求说明

按照输入的名称/编号，删除指定Bike

思路分析：
• 查找要删除元素 
• 通过把后面的元素依次前移一位，实现删除
• 最后一个不为空元素置空
难点提示：
• 不允许删除借出状态的Bike 
• 不存在指定Bike，给出提示

2.5.2.功能测试

• 正确删除未借出Bike 
• 删除借出状态的Bike，给出相应提示 
• 指定删除不存在的Bike，给出相应提示

//删除单车也需要先选择要操作的单车品牌，代码与投放单车的有重叠，可以将重叠部分单独封装起来，减小代码的冗余
	private int getBikeCompanyIndex() {
		System.out.println("1:"+BikeConstants.OFO_COMPANY_NAME);
		System.out.println("2:"+BikeConstants.HALO_COMPANY_NAME);
		System.out.println("3:"+BikeConstants.MOBAI_COMPANY_NAME);	
		System.out.println("请选择要操作的单车品牌:");
		return input.nextInt();
	}

	private void deleteBike() {
		System.out.println("---->3.删除Bike");
		int companyIndex = getBikeCompanyIndex();
		//操作选中公司下的单车
		sharedBikeDao.deleteBike(companies[companyIndex-1],input);
	}

	//接口类SharedBikeDao
	/**
	 * 删除单车
	 * @param sharedBikeCompany 单车公司
	 */
	void deleteBike(SharedBikeCompany sharedBikeCompany,Scanner scanner);

	//实现类里的删除操作	
		/*
		 * 遍历要删除的单车公司下的所有单车信息
		 * 与查询单车selectAllBike()的代码有重复，可以单独封装起来，减少代码的冗余
		 */
	private void getAllBikes(SharedBikeCompany company) {
		//获取单车信息
		SharedBike[] sharedBikes = company.getSharedBikes();
		//每家公司的情况不一样，不适合用增强for循环遍历
		for(int index = 0;index < company.getSum();index ++) {
			SharedBike bike = sharedBikes[index];
			//将借出状态以字符串形式输出
			String status = (bike.getStatus() == 1) ? "可借" : "已借出";
			//借出时间为null输出空白
			String borrowTime = (bike.getBorrowTime() == null) ? "" : bike.getBorrowTime();
			System.out.println(bike.getBid()+"\t|\t"+bike.getBname()+"\t|\t"+status+"\t|\t"+borrowTime);
		}		
	}

	@Override
	public void deleteBike(SharedBikeCompany sharedBikeCompany,Scanner scanner) {

		System.out.println("此"+sharedBikeCompany.getBikeCompanyName()+"有共享单车如下：");
		getAllBikes(sharedBikeCompany);
		System.out.println("请录入要删除单车的编号：");
		//不进行new Scanner实例操作了，将之前写过的传过来
		int bid = scanner.nextInt();
		//1.需要判断要删除的id代表的单车是否存在
		//2.判断单车是否是可删除即可借状态
		SharedBike[] sharedBikes = sharedBikeCompany.getSharedBikes();
		boolean flag = false;//设置一个flag变量维护单车id不存在以及删除成功的提示操作
		int sum = sharedBikeCompany.getSum();
		for(int index = 0;index < sum;index ++) {
			SharedBike bike = sharedBikes[index];
			if(bid == bike.getBid()) {
				//确定单车存在之后，还需要判断单车是否是可借状态
				if(bike.getStatus() == 0) {//已借出状态
					System.out.println(bid+"此单车已被借出，不能删除");
					return;//结束程序
				}
				//判断为可借状态即可以删除后的操作：
				flag = true;
//				sharedBikes[index] = null;//删除的索引位置的元素设置为null
				/*
				 * 后续还要遍历输出单车信息，而getAllBikes()是根据getSum()遍历，没有判断是否为空，
				 * 所以为防止后续遍历输出单车情况 会出现空指针异常，此处需要补空位，即让后面元素向前移位。
				 * 后面元素向前移位，最后一个肯定是null值，
				 * 这个操作会覆盖掉之前的操作，所以不需要让删除的索引位置设置为null也可以。
				 * 
				 * 考虑到空位后可能有多个元素，比如1,2,null,4,5,所以需要循环遍历数组去移动位置，
				 * 循环位置j从当前单车开始，因为减少了一个元素，为了防止索引越界，循环条件设置为j<sum-1。
				 */
				for(int j = index;j < sum-1;j++) {
					sharedBikes[j] = sharedBikes[j + 1];
				}
				sharedBikes[sum-1] = null;//元素都向前补位，最后一个为空
				break;//删除完需要结束程序，否则最后一个值为null的情况下一直遍历 不结束循环，会出现空指针异常。
			}
		}
		//单车不存在的提示，执行一次即可，放在for循环外面
		//不能直接执行，需要加条件。定义一个flag变量控制该流程
		if(!flag) {
			System.out.println(bid+"单车不存在，无法删除");
		}else {
			System.out.println(bid+"单车删除成功");
			//删除成功意味着当前公司的单车总量-1
			sharedBikeCompany.setSum(sum-1);
		}
	}

2.6.用例6-实现借出Bike业务处理

2.6.1.需求说明

按照输入的编号，借出指定Bike

思路分析： 
• 查找要借出的Bike 
• 判断是否存在 
• 判断是否已借出 
• 如果可借，修改状态值
难点提示：
• 各种情况的判断条件

2.6.2.功能测试

• 正确借出匹配的未借出Bike 
• 借出匹配的已借出Bike，给出相应提示 
• 借出无匹配的Bike，给出相应提示

	private void borrowBike() {
		System.out.println("---->4.借出Bike");
		int companyIndex = getBikeCompanyIndex();
		//操作选中公司下的单车
		sharedBikeDao.borrowBike(companies[companyIndex-1],input);
	}
	
	/**
	 * 借出单车
	 * @param sharedBikeCompany
	 * @param input
	 */
	void borrowBike(SharedBikeCompany sharedBikeCompany, Scanner input);

	//整理与删除重复的代码，优化封装部分。注意封装进了输入id的操作，要修改返回值类型。
	private int getAllBikes(SharedBikeCompany company,Scanner scanner) {
		//展示所需要操作的单车信息
		System.out.println("此"+company.getBikeCompanyName()+"有共享单车如下：");
		//获取单车信息
		SharedBike[] sharedBikes = company.getSharedBikes();
		System.out.println("---------------------------------------------------------------------");
		System.out.println("单车序号\t|\t单车品牌\t|\t单车状态\t|\t借出时间");
		System.out.println("---------------------------------------------------------------------");
		//每家公司的情况不一样，不适合用增强for循环遍历
		for(int index = 0;index < company.getSum();index ++) {
			SharedBike bike = sharedBikes[index];
			//将借出状态以字符串形式输出
			String status = (bike.getStatus() == 1) ? "可借" : "已借出";
			//借出时间为null输出空白
			String borrowTime = (bike.getBorrowTime() == null) ? "" : bike.getBorrowTime();
			System.out.println(bike.getBid()+"\t|\t"+bike.getBname()+"\t|\t"+status+"\t|\t"+borrowTime);
			System.out.println("---------------------------------------------------------------------");
		}		
		if(scanner == null) 
			return 0;
			System.out.println("请录入要操作的单车的编号：");
			int bid = scanner.nextInt();
			return bid;
	}

	@Override
	public void borrowBike(SharedBikeCompany sharedBikeCompany, Scanner input) {
		int bid = getAllBikes(sharedBikeCompany,input);
		//1.需要判断要借出的id代表的单车是否存在
		//2.判断单车是否是可借状态
		SharedBike[] sharedBikes = sharedBikeCompany.getSharedBikes();
		boolean flag = false;//设置一个flag变量维护单车id不存在以及删除成功的提示操作
		int sum = sharedBikeCompany.getSum();
		for(int index = 0;index < sum;index ++) {
			SharedBike bike = sharedBikes[index];
			if(bid == bike.getBid()) {
				//单车id存在，判断单车状态
				if(bike.getStatus() == 0) {
					System.out.println(bid + "此单车已被借出，不能被借");
					return;
				}
				flag = true;
				System.out.println("请录入借出日期(2020-01-01 12:00:00):");
				input.nextLine();
				String borrowTime = input.nextLine();
				//将借出数据给单车对象
				bike.setBorrowTime(borrowTime);
				bike.setStatus(0);
				break;
			}
		}
		if(!flag) {
			System.out.println(bid+"单车不存在，无法借出");
		}else {
			System.out.println("借出"+sharedBikeCompany.getBikeCompanyName()+"下的"+bid+"序号单车成功");
			//借出成功意味着当前公司的单车总量+1
			sharedBikeCompany.setCount(sharedBikeCompany.getCount()+1);
		}			
	}

2.7.用例7-实现归还Bike业务处理

2.7.1.需求说明

编写方法 returnBike()，实现归还Bike，并计算租金

思路分析：
• 查找要归还的Bike 
• 判断是否存在 
• 判断是否未借出 
• 如果已借出，修改status值，并计算和输出租金 
难点提示：
• 字符串-日期转换

2.7.2.功能测试

• 正确归还借出状态的Bike 
• 归还未借出的Bike，给出相应提示 
• 归还不存在的Bike，给出相应提示 

	private void revertBike() {
		System.out.println("---->5.归还Bike");
		int companyIndex = getBikeCompanyIndex();
		//操作选中公司下的单车
		sharedBikeDao.revertBike(companies[companyIndex-1],input);
	}

	/**
	 * 归还单车
	 * @param sharedBikeCompany
	 * @param input
	 */
	void revertBike(SharedBikeCompany sharedBikeCompany, Scanner input);

	@Override
	public void revertBike(SharedBikeCompany sharedBikeCompany, Scanner input) {
		int bid = getAllBikes(sharedBikeCompany,input);
		//1.需要判断要借出的id代表的单车是否存在
		//2.判断单车是否是可借状态
		SharedBike[] sharedBikes = sharedBikeCompany.getSharedBikes();
		boolean flag = false;//设置一个flag变量维护单车id不存在以及删除成功的提示操作
		int sum = sharedBikeCompany.getSum();
		for(int index = 0;index < sum;index ++) {
			SharedBike bike = sharedBikes[index];
			if(bid == bike.getBid()) {
				if(bike.getStatus() == 1) {
					System.out.println(bid + "此单车未被借出，不能执行归还操作");
					return;
				}
				flag = true;
				//归还操作
				System.out.println("请录入归还日期(yyyy-MM-dd HH:mm:ss):");
				input.nextLine();
				String revertTime = input.nextLine();
				String borrowTime = bike.getBorrowTime();
				int hour = getDuration(borrowTime,revertTime);
				System.out.println("您的借车时间："+borrowTime);
				System.out.println("您的用车时间为<<"+hour+">>小时，需要支付"+hour+"元。");
				//归还成功之后需要修改单车状态以及借出时间
				bike.setStatus(1);
				bike.setBorrowTime(null);
				break;
			}
		}
		if(!flag) {
			System.out.println(bid+"单车不存在，无法归还");
		}else {
			System.out.println("借出"+sharedBikeCompany.getBikeCompanyName()+"下的"+bid+"序号单车归还成功");
		}
	}

2.8.用例8-实现借车排行榜

2.8.1.需求说明

增加菜单项“借出排行榜”，实现借车次数从大到小的顺序显示借出排行榜

思路分析：
• 利用冒泡排序实现排行榜 
• 每次借出成功后，count++
难点提示：
• 冒泡算法

2.8.2.功能测试

	private void topBike() {
		System.out.println("---->6.Bike排行榜");
		sharedBikeDao.topBike(companies);
	}
	/**
	 * 单车排行榜
	 * @param companies
	 */
	void topBike(SharedBikeCompany[] companies);

	@Override
	public void topBike(SharedBikeCompany[] companies) {
		System.out.println("");
		System.out.println("公司名称\t借出次数");
		//方式一：Arrays.sort();
		Arrays.sort(companies);
		//支持对字面量类型的排序
		//自定义类型，默认只对实现Comparable接口的类进行排序（手动告诉程序排序规则）
		for(SharedBikeCompany company:companies) {
			System.out.println(company.getBikeCompanyName()+"\t"+company.getCount());
		}
	}

@AllArgsConstructor
@Setter
@Getter
//public class SharedBikeCompany {
public class SharedBikeCompany implements Comparable<SharedBikeCompany> {
	private int bikeCompanyId;//公司id 
	private String bikeCompanyName;//ofo 哈罗 摩拜 
	private SharedBike[] sharedBikes;//公司持有共享单车 
	private int sum;//公司单车总量
	private int count;//公司单车借出次数
	@Override
	public int compareTo(SharedBikeCompany company) {
//		return this.count - company.count;//升序排列
		return company.count - this.count;//降序排列
	}
}

		// 方式二：冒泡排序
		// 尽量避免对原数组直接操作
		int len = companies.length;
		SharedBikeCompany[] newCompanyArray = Arrays.copyOf(companies, len);
		for (int i = 1; i < len; i++) {
			for (int j = 0; j < len - i; j++) {
				if (newCompanyArray[j].getCount() < newCompanyArray[j + 1].getCount()) {
					// 交换位置
					SharedBikeCompany temp = companies[j];
					newCompanyArray[j] = newCompanyArray[j + 1];
					newCompanyArray[j + 1] = temp;
				}
			}
		}
		for (SharedBikeCompany company : newCompanyArray) {
			System.out.println(company.getBikeCompanyName() + "\t" + company.getCount());
		}

3.其他

刚开始是自己写的，到后面只是思考了一下，几乎就全然跟着网课老师的解答敲了。之后会再找点系统的练习自己做做。

<学习内容借鉴于runoob.com，CSDN，https://space.bilibili.com/422389870/等网络资源>