类与对象（上）

最新推荐文章于 2024-01-27 10:46:35 发布

qq_42272067

最新推荐文章于 2024-01-27 10:46:35 发布

阅读量169

点赞数 2

分类专栏：基础练习文章标签： Java学习图书管理简单练习

本文链接：https://blog.csdn.net/qq_42272067/article/details/88019901

版权

基础练习专栏收录该内容

0 篇文章 0 订阅

订阅专栏

学生管理系统

package my;

import java.util.Date;

/**
 * 功能：图书类
 * 属性：编号，名称，分类，图书状态(可借，借出，损坏，采购中)
 * 作者，出版社，描述，封面图片，借出时间，单价，租价，国家
 * 作者：松哥
 * 日期：2019年2月27日-上午11:02:49
 * 地址：鼠窝
 * 版权：&copy;<a href="http://www.xuetang9.com">老九学堂</a>2015-2019
 */
public class Book {
	/**
	 * 编号
	 */
	private String id;
	/**
	 * 书名
	 */
	private String name;
	/**
	 * 分类
	 */
	private String type;
	/**
	 * 状态(1.可借，2.借出，3.损坏，4.采购中)
	 */
	private int status;
	/**
	 * 作者
	 */
	private String author;
	/**
	 * 出版社
	 */
	private String publishor;
	/**
	 * 描述
	 */
	private String desc;
	/**
	 * 借出时间
	 */
	private Date borrowTime;
	/**
	 * 售价
	 */
	private double price;
	/**
	 * 租价
	 */
	private double borrowPrice;
	/**
	 * 默认构造方法
	 */
	public Book() {}
	/**
	 * 带参构造方法
	 * @param id-编号
	 * @param name-书名
	 * @param type-类型
	 * @param author-作者
	 * @param publishor-出版社
	 * @param desc-描述
	 * @param price-售价
	 * @param borrowPrice-租价
	 */
	public Book(String id, String name, String type, String author, String publishor, String desc, double price,
			double borrowPrice) {
		super();
		this.id = id;
		this.name = name;
		this.type = type;
		this.author = author;
		this.publishor = publishor;
		this.desc = desc;
		this.price = price;
		this.borrowPrice = borrowPrice;
	}
	@Override
	public String toString() {
		
		//三目运算 借出时间-如果借出时间不为空，则将时间数据装欢成字符窜赋值给borrowTimeStr
		String borrowTimeStr=null==borrowTime?"":borrowTime.toString();
		return ""+id+"\t"+name+"\t"+type+"\t"+author+"\t"+publishor+"\t"+desc+"\t"+
		borrowTimeStr+"\t"+price+"\t"+borrowPrice+"";
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	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 int getStatus() {
		return status;
	}
	public void setStatus(int status) {
		this.status = status;
	}
	public String getAuthor() {
		return author;
	}
	public void setAuthor(String author) {
		this.author = author;
	}
	public String getPublishor() {
		return publishor;
	}
	public void setPublishor(String publishor) {
		this.publishor = publishor;
	}
	public String getDesc() {
		return desc;
	}
	public void setDesc(String desc) {
		this.desc = desc;
	}
	public Date getBorrowTime() {
		return borrowTime;
	}
	public void setBorrowTime(Date borrowTime) {
		this.borrowTime = borrowTime;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	public double getBorrowPrice() {
		return borrowPrice;
	}
	public void setBorrowPrice(double borrowPrice) {
		this.borrowPrice = borrowPrice;
	}
}

图书管理系统的界面显示类

package my;

import java.util.Date;
import java.util.Scanner;
/**
 * 功能：图书管理系统的界面显示
 * 把重用的功能代码封装成方法，灵活使用do-while，switch-case和数组嵌套
 * 作者：松
 * 日期：2019年2月27日-上午11:19:24
 * 地址：鼠窝
 * 版权：&copy;<a href="http://www.xuetang9.com">老九学堂</a>2015-2019
 */
public class BookView {
	/**
	 * 定义Scanner变量接收用户输入的数据
	 */
	static Scanner input=new Scanner(System.in);
	/**
	 * 将用户管理业务层定义为本类的私有属性
	 */
	private UserServise userServise=new UserServise();
	/**
	 * 将图书管理系统业务层定义为本类的私有属性
	 */
	private BookService bookService=new BookService();
	/**
	 * 登录菜单方法
	 */
	public void longinMenu() {
		String[]menuLines= {
				"-----------------------------------------",
				"\t登录图书管理系统\t",
				"1.登录",
				"2.注册",
				"3.退出系统",
		};
		menuPrint(menuLines);//调用菜单打印方法
		inputNotice();//调用提示操作方法
	}
	/**
	 * 打印菜单方法(遍历字符串数组打印)
	 * @param menuLines
	 */
	private void menuPrint(String[]menuLines) {
		for (int i = 0; i < menuLines.length; i++) {
			String menuLine=menuLines[i];
			System.out.println(menuLine);
		}
	}
	/**
	 * 通用提醒用户选择操作
	 */
	private void inputNotice() {
		System.out.print("请选择你的操作：");
	}
	/**
	 * 程序登录逻辑-运用do-while和switch-case循环操作
	 */
	public void login() {
		boolean hasOperation=true;//定义boolean类型变量控制循环添加
		userServise.inital();//初始化用户管理
		do {
			longinMenu();//调用菜单方法的-每次循环都要显示菜单
			int choice=input.nextInt();//定义一个整形变量代表对应的操作
			switch (choice) {
			case 1:
				viewLogin();//1.登录
				break;
			case 2:
				viewAddUser();//2.注册
				System.out.println("注册成功！请登录系统！");
				viewLogin();
				break;
			case 3:
				hasOperation=false;//3.退出系统
				break;
			default:
				System.out.println("操作选择有误，请重新选择！");
				break;
			}
		} while (hasOperation);
	}
	/**
	 * 注册新用户
	 */
	public void viewAddUser() {
		User user=new User();
		System.out.println("\t用户注册信息录入\t");
		System.out.print("请输入用户名：");
		user.setName(input.next());
		System.out.print("请输入密码：");
		user.setPass(input.next());
		userServise.add(user);//调用用户管理类-将新注册的用户添加到用户对象数组中	
	}
	/**
	 * 用户登录系统
	 */
	public void viewLogin() {
		String uname="";//存放用户名-参与运算验证
		boolean loginSucces=false;//验证身份信息是否通过
		for (int i = 0; i < 3; i++) {//身份验证最多可以验证三次
			System.out.print("请输入用户名：");
			uname=input.next();
			System.out.print("请输入密码：");
			String pass=input.next();
			if(yanzheng(uname,pass)) {
				loginSucces=true;
				break;
			}else {
				System.out.println("用户名或密码错误！你还有"+(2-i)+"次机会！");
			}
		}
		if(loginSucces) {
			System.out.println(uname+"登录成功，进入主程序！");
			start();
		}
	}
	/**
	 * 验证用户信息
	 * @param uname
	 * @param pass
	 * @return
	 */
	private boolean yanzheng(String uname,String pass) {
		//验证用户登录信息，需要一个用户管理类，从用户管理类中获取用户的验证信息
		User handlers[]=userServise.getUsers();
		boolean loginSucces=false;//验证身份信息是否通过
		for (int j = 0; j < handlers.length; j++) {
			if(uname.equals(handlers[j].getName())&&pass.equals(handlers[j].getPass())) {
				loginSucces=true;
				break;
			}		
		}
		return loginSucces;
	}
	/**
	 * 显示主菜单方法
	 */
	public void mainMenu() {
		String[]menuLines= {
				"-----------------------------------------",
				"\t图书管理系统\t",
				"1.录入图书",
				"2.排序",
				"3.精确查找",
				"4.价格区间查找",
				"5.删除",
				"6.借阅",
				"7.归还",
				"8。返回上层"
		};//定义字符串数组-显示菜单，用户输入对应的数字进行程序执行相应的操作
		menuPrint(menuLines);
		inputNotice();
	}
	/**
	 * 图书管理系统运行主逻辑-使用do-while,switch-case循环判断用户选择的操作·是否会有接下来的操作
	 */
	public void start() {
		boolean hasOperation=true;
		bookService.inital();//图书对象数组初始化数据
		do {//开始程序业务循环操作
			mainMenu();//每次循环都要显示菜单
			int choice=input.nextInt();//定义int型变量用来接收用户输入选择操作
			switch (choice) {
			case 1:
				viewAddBook();
				break;
			case 2:
				viewSort();
				break;
			case 3:
				viewQueryByName();
				break;
			case 4:
				viewQueryByPrice();
				break;
			case 5:
				viewRemoveBook();
				break;
			case 6:
				viewBorrowBook();
				break;
			case 7:
				viewRebackBook();
				break;
			case 8:
				hasOperation=false;
				break;
			default:
				System.out.println("操作选择有误，请重新选择!");
				break;
			}
			
		} while (hasOperation);	
	}
	/**
	 * 录入图书-创建一个图书对象并为图书对象属性赋值
	 */
	public void viewAddBook() {
		Book recored=new Book();//创建图书对象
		System.out.println("\t图书信息录入\t");
		System.out.print("书名：");
		recored.setName(input.next());
		System.out.print("类型：");
		recored.setType(input.next());
		System.out.print("作者：");
		recored.setAuthor(input.next());
		System.out.print("出版社：");
		recored.setPublishor(input.next());
		System.out.print("描述：");
		recored.setDesc(input.next());
		System.out.print("单价：");
		recored.setPrice(input.nextDouble());
		System.out.print("租价：");
		recored.setBorrowPrice(input.nextDouble());
		recored.setId(bookService.randId());//设置书的编号
		recored.setStatus(bookService.BOOK_STATUS_CAN_BORROW);//设置图书对象的状态默认是可借的
		//录入图书需要一个图书管理数组存放录入的图书，建立一个图书管理业务类来保存图书
		bookService.add(recored);//调用业务类的图书对象添加到图书管理数组的方法
		displayBooks(bookService.getBooks());
	}
	/**
	 * 打印图书对象数组中所有有效图书对象
	 * @param books
	 */
	public void displayBooks(Book[]books) {
		System.out.println("序号\t编号\t名称\t分类\t图书状态\t作者\t出版社\t描述\t借出时间\t单价\t租价");
		if(null==books||books.length==0) return;//对图书对象数组参数进行验证，防止传入空元素
		for (int i = 0; i < books.length; i++) {
			Book book = books[i];
			if(null!=book) {//输出对象数组非空元素
				System.out.println((i+1)+"\t"+book.toString());//i+1表示序号
			}
		}	
	}
	/**
	 * 排序菜单界面
	 */
	public void sortMenu() {
		String[]menuLines= {
				"1.按名称降序排序",
				"2.按名称升序排序",
				"3.按ID降序排序",
				"4.按ID升序排序"
		};
		menuPrint(menuLines);//调用菜单显示方式
		inputNotice();//提示用户选择操作
	}
	/**
	 * 根据用户选择对应排序方式-并打印
	 */
	public void viewSort() {
		sortMenu();//调用菜单界面显示
		int choice=input.nextInt();
		switch (choice) {
		case 1://1.按名称降序排序
			displayBooks(bookService.sort(BookService.SORT_BY_NAME, BookService.SORT_DESC));
			break;
		case 2://2.按名称降序排序
			displayBooks(bookService.sort(BookService.SORT_BY_NAME, BookService.SORT_ASC));
			break;
		case 3://3.按ID降序排序
			displayBooks(bookService.sort(BookService.SORT_BY_ID, BookService.SORT_DESC));
			break;
		case 4://4.按ID降序排序
			displayBooks(bookService.sort(BookService.SORT_BY_ID, BookService.SORT_ASC));
			break;
		default:
			System.out.println("没有找到你想要的排序方法");
			break;
		}
	}
	/**
	 * 根据书名进行查询
	 */
	public void viewQueryByName() {
		System.out.print("请输入要查找书籍的名称：");
		String name=input.next();
		Book[]resultBooks=bookService.querByName(name);//调用服务类中的根据书名查找图书对象方法
		displayBooks(resultBooks);
	}
	/**
	 * 按照价格区间查找
	 */
	public void viewQueryByPrice() {
		System.out.print("查找的起始价格：");
		double priceBegin=input.nextDouble();
		System.out.print("查找结束价格：");
		double priceEnd=input.nextDouble();
		Book[]result=bookService.queryByPrice(priceBegin, priceEnd);
		displayBooks(result);
	}
	/**
	 * 删除图书对象-调用业务类根据书名查找对象方法-调用业务类删除对象方法
	 */
	public void viewRemoveBook() {
		System.out.print("删除书籍的名称：");
		String name=input.next();//调用业务类根据名称查找与用户输入名称相同的所有书籍对象，并显示
		Book[]books=bookService.querByName(name);
		System.out.println("找到如下书籍:");
		displayBooks(books);//调用输出数组对象属性方法
		if(books.length>0) {
			Book removeBook=null;
			//如果查找到对象只有一本书，就直接让用户确认是否删除，如果是多本书，要求用户输入书的序号在确认是否删除
			if(books.length==1) {
				removeBook=books[0];
			}else {
				System.out.print("请输入需要删除书籍的序号：");
				int inputIndex=input.nextInt();//如果是多本书籍，要求用户输入书籍的序号进行删除
				if(inputIndex>0&&inputIndex-1<books.length) {//对用户输入的序号进行验证是否合法
					removeBook=books[inputIndex-1];//将对应序列的图书对象记录
				}
			}
			if(null!=removeBook) {//如果removeBook不为空
				System.out.print("是否确认删除(y/n)?:");
				String choice=input.next();
				if("y".equalsIgnoreCase(choice)) {
					books=bookService.remove(removeBook);//调用业务类的删除对象方法
					displayBooks(books);
				}
			}	
		}else {
			System.out.println("没有找到相关的书籍");
		}	
	}
	/**
	 * 借阅书籍-调用业务类根据书名查找方法-并修改借出书籍的状态，记录借出的时间
	 */
	public void viewBorrowBook() {
		System.out.print("要借阅的图书名称：");
		String name=input.next();
		Book[]books=bookService.querByName(name);//调用业务类根据书名查找对象方法
		if(books.length>0) {
			Book borrowBook=null;//定义一个存放借阅图书的Book变量
			if(books.length==1) {//如果查找到的对象只有一个，就将这个对象赋值给借阅对象变量
				borrowBook=books[0];//记录
			}else {
				System.out.print("请输入借阅图书的序号：");
				int inputIndex=input.nextInt();
				if(inputIndex>0&&inputIndex-1<books.length) {//
					borrowBook=books[inputIndex-1];//将对应的元素赋值给借阅对象变量
				}
			}
			if(borrowBook!=null) {
				bookService.borrowBook(borrowBook);
				System.out.println("成功借阅！");
			}
		}else {
			System.out.println("本馆还没有收藏这本书!");
		}	
	}
	/**
	 * 归还图书
	 */
	public void viewRebackBook() {
		//查询所有已经被借出的图书，并显示
		System.out.println("已经被借出的图书有：");
		Book[]books=bookService.querBeBorrowBook();
		displayBooks(books);//调用打印图书对象数组方法
		System.out.print("请选择要归还的图书序号：");//提示输入用户归还自己那一本书的
		int inputIndex=input.nextInt();
		if(inputIndex>0&&inputIndex-1<books.length) {
			Book backBook=books[inputIndex-1];//接收数组对应下标图书对象
			//计算借出的时间-方便计算租金
			long borrowDay=(new Date().getTime()-backBook.getBorrowTime().getTime())/1000;		
			double pay=borrowDay*backBook.getBorrowPrice();
			System.out.println("图书借了"+borrowDay+"天，租金是"+pay+"元");
			System.out.print("确认归还(y/n)?:");
			String choice=input.next();
			if("y".equalsIgnoreCase(choice)) {//如果确认归还-需要修改图书状态
				//修改图书的状态-可借出
				backBook.setStatus(bookService.BOOK_STATUS_CAN_BORROW);
				backBook.setBorrowTime(null);//没有借出时间
			}
		}	
	}	
}

图书管理系统业务层

package my;

import java.util.Arrays;
import java.util.Date;
import java.util.UUID;
/**
 * 功能：图书管理系统业务层
 * 作者：松哥
 * 日期：2019年2月27日-上午11:21:52
 * 地址：鼠窝
 * 版权：&copy;<a href="http://www.xuetang9.com">老九学堂</a>2015-2019
 */
public class BookService {
	/**
	 * 常量：图书状态，可借出
	 */
	public static final int BOOK_STATUS_CAN_BORROW=1;
	/**
	 * 常量：图书状态，已借出
	 */
	public static final int BOOK_STATUS_BE_BORROW=2;
	/**
	 * 常量：图书状态，已损坏
	 */
	public static final int BOOK_STATUS_BROKEN=3;
	/**
	 * 常量：图书状态，购买中
	 */
	public static final int BOOK_STATUS_CAN_IS_BUYING=4;
	/**
	 * 按名称类型排序
	 */
	public static final int SORT_BY_NAME=1;
	/**
	 * 按ID类型排序
	 */
	public static final int SORT_BY_ID=1;
	/**
	 * 升序
	 */
	public static final boolean SORT_ASC=true;
	/**
	 * 降序
	 */
	public static final boolean SORT_DESC=false;
	/**
	 * 常量-数组每次扩容默认增长的空间值
	 */
	private static final int DERAULT_CARACITY=10;
	/**
	 * 定义一个图书对象数组-存放图书对象-属性变量数组，初始元素值为null
	 */
	private Book[]books= {};
	/**
	 * 定义一个整形变量-记录图书对象数组中存放图书的实际数量
	 */
	private int size;
	/**
	 * 默认构造方法-创建一个初始空间容量为10个单位的图书对象数组
	 */
	public BookService() {
		books=new Book[DERAULT_CARACITY];
	}
	/**
	 * 初始化方法
	 */
	public void inital() {
		Book book1 = new Book(randId(), "深入理解Java虚拟机", "Java", "周志明", "机械工业出版社", 
				"本书第1版两年内印刷近10次，4家网上书店的评论近4?000条，98%以上的评论全部为5星级的好评，是整个Java图书领域公认的经典著作和超级畅销书，繁体版在台湾也十分受欢迎。",
				62.4, 3.0);
		book1.setStatus(BOOK_STATUS_CAN_BORROW);
		add(book1);
		Book book2 = new Book(randId(), "JAVA核心技术", "Java", "S.霍斯特曼", "机械工业出版社", 
				"Java领域*有影响力和价值的著作之一，与《Java编程思想》齐名，10余年全球畅销不衰，广受好评 根据Java SE 8全面更新，系统全面讲解Java语言的核心概念、语法、重要特性和开发方法，包含大量案例，实践性强",
				 94.0, 2.0);
		book2.setStatus(BOOK_STATUS_CAN_BORROW);
		add(book2);
		Book book3 = new Book(randId(), "深入理解Java虚拟机", "Java", "周志明", "机械工业出版社", 
				"本书第1版两年内印刷近10次，4家网上书店的评论近4?000条，98%以上的评论全部为5星级的好评，是整个Java图书领域公认的经典著作和超级畅销书，繁体版在台湾也十分受欢迎。",
				22.4, 3.0);
		book3.setStatus(BOOK_STATUS_CAN_BORROW);
		add(book3);
	}
	/**
	 * 将图书对象添加到图书管理对象数组中
	 * @param book-图书对象
	 * @return
	 */
	public boolean add(Book book) {
		//对参数合法性进行验证
		if(null==book) return false;
		//图书对象数组空间进行验证-是否充足
		ensureCapacity();//调用数组空间容量判断方法
		books[size++]=book;//将新创建的图书对象赋值给图书对象数组对应下标位置元素
		return true;
	}
	/**
	 * 对图书对象数组空间容量进行验证处理
	 */
	public void ensureCapacity() {
		//容量处理-如果容量不足，进行空间扩容操作
		if(size>=books.length-1) {
			int newArrayLength=books.length+DERAULT_CARACITY;//新数组的空间容量
			books=Arrays.copyOf(books, newArrayLength);
		}
	}
	/**
	 * 服务层提供的排序方法
	 * @param type-排序的类型 SORT_BY_NAME,SORT_BY_ID;
	 * @param isAsc-是否是升序 SORT_ASC,SORT_DESC;
	 * @return
	 */
	public Book[]sort(int type,boolean isAsc){
		Book[]result=Arrays.copyOf(books, size);
		for (int i = 0; i < result.length; i++) {
			for (int j = 0; j < result.length-i-1; j++) {
				int diff=0;//定义一个存放字符串比较的结果的整形变量
				if(type==SORT_BY_NAME) {//用名称类型排序
					//如果前一个对象书名比后一个对象书名大，compareTo比较结果大于1，否则小于0
					diff=result[j].getName().compareTo(result[j+1].getName());
				}else if(type==SORT_BY_ID){//类型排序
					//如果是前一个对象ID比后面一个对象ID大，compateTo比较结果大于1，否则小于0；
					diff=result[j].getId().compareTo(result[j+1].getId());
				}
				boolean swap=false;
				//当diff比较两个对象结果非零值，则需要进行交换，进行交换时需要根据排序规则进行交换
				//如果是升序，则需要diff的值大于零才可以进行交换，小于零情况不需要交换
				if(isAsc==SORT_ASC&&diff>0) {
					swap=true;
				}else if(isAsc==SORT_DESC&&diff<0) {
					//如果是降序，则需要diff的值小于零才可以进行交换，大于零不进行交换
				    swap=true;
				}
				if(diff!=0&&swap) {
					Book tempBook=result[j];
					result[j]=result[j+1];
					result[j+1]=tempBook;
				}
			}
		}
		return result;
	}
	/**
	 * 根据参数在对象数组中查找相应符号的对象，
	 * @param name-书名
	 * @return-返回查找到对象的数组
	 */
	public Book[]querByName(String name){
		if(null==name) return new Book[] {};//对参数进行验证是否合法，不合法返回一个空数组，解决调用length的空异常
		Book[]result=new Book[size];//定义存放查找到书籍的对象数组
		int findCOunt=0;//查找到对应书籍的数量
		for (int i = 0; i < size; i++) {
			Book book=books[i];//接收对应下标的book对象
			if(name.equals(book.getName())) {
				result[findCOunt++]=book;//将找到的book对象存放到对象数组中
			}
		}
		return Arrays.copyOf(result, findCOunt);//返回一个存放对象数组的副本，去掉空的元素
	}
	/**
	 * 根据价格区间查找对应的图书对象
	 * @param begin-上行价格
	 * @param end-下行价格
	 * @return-返回存储查找到的书籍对象数组
	 */
	public Book[]queryByPrice(double begin,double end){
		//对参数合法性验证,起始价格不能为负数，最高价格不能小于最低价格，如果不合法返回一个空对象数组
		if(begin<0||end<begin) return new Book[] {};
		Book[]result=new Book[size];
		int queryCount=0;//计数器，查找到的书籍个数
		for (int i = 0; i < books.length; i++) {
			Book book=books[i];//接收对应下标的book对象
			if(null!=book) {
				//如果价格大于起始价格，小于接收价格，那么就是我们要查找的图书对象
				if(book.getPrice()>=begin&&book.getPrice()<=end) {
					result[queryCount++]=book;//将查找符合的书籍对象放入对象数组对应下标元素中
				}
			}
		}
		return Arrays.copyOf(result, queryCount);
	}
	/**
	 * 删除传入的对象
	 * @param book
	 * @return
	 */
	public Book[] remove(Book book) {
		if(null==book) return new Book[] {};//对参数合法性进行验证
		int removeIndex=-1;//定义整形变量-存放要删除对象的下标位置
		//定义for循环遍历查找对象数组中与参数对象匹配的元素下标
		for (int i = 0; i < size; i++) {
			Book loopBook=books[i];//接收图书对象数组对应下标元素
			if(loopBook.equals(book)) {
				removeIndex=i;//如果找到对应元素，则记录其在对象数组的下标位置
				break;
			}
		}
		if(removeIndex!=-1) {
			System.arraycopy(books, removeIndex+1, books, removeIndex, size-removeIndex);
		    size--;
		}
		return books;
	}
	/**
	 * 回收多余的空间-回收空间是DERAULT_CARACITY的倍数
	 */
	public void freeSpace() {
		if(books.length-size>DERAULT_CARACITY) {
			int freeLen=books.length-size-((books.length-size)%DERAULT_CARACITY);
			books=Arrays.copyOf(books, books.length-freeLen);
		}
	}
	/**
	 * 借阅图书成功-需要改变当前借出图书的状态-已借出，并且需要记录借出的时间
	 * @param borrowBook
	 */
	public void borrowBook(Book borrowBook) {
		borrowBook.setStatus(BOOK_STATUS_BE_BORROW);
		borrowBook.setBorrowTime(new Date());
	}
	/**
	 * 查找所有已借出状态的图书对象
	 * @return-返回存放查找到的图书数组
	 */
	public Book[]querBeBorrowBook(){
		Book[]result=new Book[size];//定义一个图书对象数组存放查找已经被借阅的图书
		int borrowedCount=0;//定义整形变量-表示已经借出的图书数量
		for (int i = 0; i < size; i++) {
			Book book=books[i];//定义一个图书对象变量-存放取出数组中的元素进行查找操作
			if(book.getStatus()==BOOK_STATUS_BE_BORROW) {//如果图书对象状态是已借出的状态
				result[borrowedCount++]=book;//将查找到对应状态的图书存入数组指定的下标元素中
			}
		}
		return Arrays.copyOf(result, borrowedCount);//返回存放查找到的图书数组，对图书数组的空元素剔除		
	}	
	/**
	 * 图书编号生成方法
	 * @return
	 */
	public String randId() {
		return UUID.randomUUID().toString();
	}
	public Book[] getBooks() {
		return Arrays.copyOf(books, size);
	}
	public int getSize() {
		return size;
	}
}

用户类

package my;

/**
 * 功能：用户类
 * 作者：松
 * 日期：2019年2月27日-上午11:58:30
 * 地址：鼠窝
 * 版权：&copy;<a href="http://www.xuetang9.com">老九学堂</a>2015-2019
 */
public class User {
	private String name;
	private String pass;
	/**
	 * 无参默认构造
	 */
	public User() {}
	/**
	 * 带参默认构造方法
	 * @param name-用户名
	 * @param pass-用户密码
	 */
	public User(String name, String pass) {
		this.name = name;
		this.pass = pass;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPass() {
		return pass;
	}
	public void setPass(String pass) {
		this.pass = pass;
	}
}

用户管理类

/**
 * 
 */
package my;

import java.util.Arrays;

/**
 * 功能：用户管理类
 * 作者：松
 * 日期：2019年2月27日-下午12:02:42
 * 地址：鼠窝
 * 版权：&copy;<a href="http://www.xuetang9.com">老九学堂</a>2015-2019
 */
public class UserServise {
	/**
	 * 常量-用户数组每次默认增长的空间
	 */
	private static final int DILATATION=10;
	/**
	 * 定义一个用户对象数组-存放的是用户对象
	 * 属性变量数组-初始值为null
	 */
	private User[]users= {};
	/**
	 * 用户对象数组中存放用户的个数
	 */
	private int size;
	/**
	 * 默认构造方法
	 */
	public UserServise() {
		users=new User[DILATATION];
	}
	public boolean add(User user) {
		if(null==user) return false;
		ensureCapacity();
		users[size++]=user;
		return true;
	}
	/**
	 * 数组空间扩容-每次调用数组增长DERAULT_CAPACITY值
	 */
	public void ensureCapacity() {
		//容量的处理，如果容量不够，进行空间扩容,
		if(size>=users.length-1) {
			int newArrayLength=users.length+DILATATION;
			users=Arrays.copyOf(users, newArrayLength); 
		}
	}
	public void inital() {
		User user1=new User("徐松","asd");
		add(user1);
		User user2=new User("陈昕璇","123456");
		add(user2);
	}
	/**
	 * 这里外部获取的是用户对象数组的副本
	 * @return
	 */
	public User[] getUsers() {
		return Arrays.copyOf(users, size);
	}
	public int getSize() {
		return size;
	}	
}

qq_42272067

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
类与对象（上）

学生管理系统package my;import java.util.Date;/** * 功能：图书类 * 属性：编号，名称，分类，图书状态(可借，借出，损坏，采购中) * 作者，出版社，描述，封面图片，借出时间，单价，租价，国家 * 作者：松哥 * 日期：2019年2月27日-上午11:02:49 * 地址：鼠窝 * 版权：&amp;amp;copy;&amp;lt;a href=&quot;ht...
复制链接

扫一扫

专栏目录