【Java实验2】开发一个商品租赁系统（封装，多态，继承）

实验内容

要求完成一个商品租赁系统，该系统允许用户租赁商店里的的各种商品。

创建一个Store类，Store类中保存了一个项目列表的引用。该列表（称为itemList）的类型是链表，它包含了商店里面所有项目。这些项目包括：书籍，杂志，DVD，Blurays，MusicCD。这些项目中的每一个物品都需要存储在列表中。

要求使用继承技术创建一个管理此系统的库类。允许除了添加或删除物品，查找一个物品。还要实现借用一件物品并能将其归还。如果借用的商品已经借出应该抛出ItemnotFound的异常。每个物品的信息应该可以写入磁盘中。
编写测试程序以确保商品租赁系统的能够正常运行。

程序源码

Store.java

@SuppressWarnings("serial")  //用于抑制编译器产生警告信息
public class Store extends ItemList   //构造函数
{
	Store() 
	{
		String[] names = { "BOOKS", "MAGAZINES", "DVD", "BLURAYS", "MUSICCD" };
		for (int i = 0; i < names.length; i++) 
		{
			Item item = new Item();
			item.setName(names[i]);    //给库中的物品设定名字
			super.add(item);           //添加物品
		}
	}

	public void addItem(String name) 
	{
		Item target = new Item(name); //父类中增加指定名称的物品，名称封装在物品
		super.addItem(target);  //super访问父类的成员
	}

	public boolean searchItem(String name)   //要查找的物品
	{
		Item target = new Item(name); //父类中查找指定名称的物品，名称封装在物品
		return super.searchItem(target);    //是否被找到
	}

	public void deleteItem(String name)   //要删除的物品的名称 
	{
		Item target = new Item(name);  //父类中删除指定名称的物品,名称封装在物品
		super.deleteItem(target);   //调用父类deleteItem函数
	}

	public boolean rentItem(String name)   //要租用的物品的名称
	{
		Item target = new Item(name);   //租用指定名称的物品，名称封装在物品中
		return super.rentItem(target);  //是否成功租用
	}

	public boolean returnItem(String name)  //要查找的物品的名称
	{
		Item target = new Item(name);   //归还定名称的物品，将该名称封装在物品中
		return super.returnItem(target);  //是否成功找到
	}

	public void write()
	{
		super.writeWords();  //调用父类writeWords函数，将所有商品信息写入文件
	}
}

Item.java

public class Item 
{
	private String name;  //物品名称
	private boolean rent;  //租用状态，boolean类型
	protected Item()   //无参的构造函数，生成一个名字为null 的空物品
	{
		this("", false);
	}
	protected Item(String name)  //生成一个有名字的物品，设定其租用状态为false
	{
		this(name, false);
	}
	protected Item(String name, boolean rent)  //生成任意名称和租用状态的物品
	{
		super();
		this.name = name;
		this.rent = rent;
	}
	protected String getName()
	{
		return name;  //需返回的物品名称
	}
	protected void setName(String name) 
	{
		this.name = name;  //要修改的物品名称
	}
	protected boolean isRent()   // 获取物品是否被租用
	{
		return rent;
	}
	protected void setRent(boolean rent)  //设置物品是否被租用
	{
		this.rent = rent;
	}
}

ItemTest.java

import java.io.BufferedWriter; 
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.LinkedList;
@SuppressWarnings( "serial" )  //用于抑制编译器产生警告信息
public class ItemList extends LinkedList<Item> 
 //该类可对货物进行增删改查并将其状态写入文件
{
	public void addItem(Item target)  //在列表中添加物品
	{
		super.add(target);
	}

	public boolean searchItem(Item target)   //要寻找的物品
	{
		if (this.contains(target))  //找到该物品
		{
			return true;
		} 
		else  
		{
			try 
			{
				throw new ItemNotFound("没有找到物品");   //语句抛出一个异常
			} 
			catch (ItemNotFound e) {	}
		}
		return false;
	}

	public void deleteItem(Item target) 
	{
		if (this.searchItem(target))  //判断列表中是否有此物品
		{
			super.remove(position(target));  //有该物品
		}
	}

	public boolean rentItem(Item target)
	{
		if (this.searchItem(target))  //在列表中找到该物品的位置
		{
			if (super.get(position(target)).isRent())   //找不到物品则返回假
			{
				return false;
			}
			else
			{
				target.setRent(true);
				super.set((position(target)), target);
			}
		}
		return target.isRent();  //将物品状态设为已租用，返回真
	}

	public boolean returnItem(Item target) 
	{
		if (this.searchItem(target))  //列表中找到该物品的位置
		{
			if (super.get(position(target)).isRent())
			{
				target.setRent(false);  //若能找到，在列表中将物品状态设为未租用
				super.set((position(target)), target);  
				return true;
			}
			else
			{
				return false;  //若找不到物品则返回假
			}
		}
		return target.isRent();
	}

	private boolean contains(Item target) 
	{
		for (int i = 0; i < super.size(); i++)   //遍历父类链表
		{
			Item current = super.get(i);
			if (current.getName().equals(target.getName())) 
//若找到该物品，返回真
			{
				return true;
			}
		}
		return false;
	}

	private int position(Item target)   //遍历父类链表，标记某物品所在的位置
	{
		for (int position = 0; position < super.size(); position++) 
		{
			Item current = super.get(position);
			if (current.getName().equals(target.getName()))
			{
				return position;
			}
		}
		return -1;
	}

	public void writeWords()  //将物品信息写入文件
	{
		try 
		{
			File file = new File("Item.txt");
			FileWriter newFile = new FileWriter(file, true);
			BufferedWriter writer = new BufferedWriter(newFile);
			for (int i = 0; i < super.size(); i++)  //遍历链表
			{
				Item temp = super.get(i);
				writer.write(temp.getName());
				writer.newLine();
				writer.flush();  //flush()方法起到强制写出的效果
				if (temp.isRent()) 
				{
					writer.write("rent");
				} 
				else 
				{
					writer.write("unrent");
				}
				writer.newLine();
				writer.flush();
			}
			writer.close();
		} 
		catch (IOException e)   //抛出异常
		{
			System.out.println(e);
		}
	}
}

ItemNotFound.java

@SuppressWarnings("serial")  //用于抑制编译器产生警告信息
public class ItemNotFound extends Exception
{
	public ItemNotFound(String message)
	{
		super(message);
		System.out.println("发生异常，未找到物品");  //出现异常
	}
}

StoreTest.java

public class StoreTest 
{
	public static void main(String[] args)
	{
		Store myStore = new Store();
		myStore.write();
		String[] names = { "BOOKS", "MAGAZINES", "DVD", "BLURAYS", "MUSICCDS" };
		for (int i = 0; i < names.length; i++)   //遍历链表
		{
			if (myStore.searchItem(names[i]))  //查找物品
			{
				if (myStore.rentItem(names[i]))
				{
					System.out.println("借用物品成功");
				}
				else 
				{
					System.out.println("该商品已被借用");
				}
			}
		}
		for (int i = 0; i < names.length; i++)
		{
			if (myStore.searchItem(names[i]))
			{
				if (myStore.rentItem(names[i]))
				{
					System.out.println("借用物品成功");
				}
				else
				{
					System.out.println("该商品已被借用");
				}
			}
		}
		for (int i = 0; i < names.length; i++)
		{
			if (myStore.searchItem(names[i]))
			{
				if (myStore.returnItem(names[i]))
				{
					System.out.println("成功归还物品");
				}
				else 
				{
					System.out.println("未成功归还物品");
				}
			}
		}
		for (int i = 0; i < names.length; i++)
		{
			if (myStore.searchItem(names[i]))
			{
				System.out.println("找到物品");
				myStore.deleteItem(names[i]);
			}
		}
		for (int i = 0; i < names.length; i++)
		{
			if (myStore.searchItem(names[i])) 
			{
				System.out.println("找到物品！");
				myStore.deleteItem(names[i]);
			} 
			else 
			{
				myStore.addItem(names[i]);
			}
		}
	}
}

程序运行结果

存储物品信息的txt文件如下：

总结

---

  实验二是完成一个商品租赁系统，使用列表来存储商店里的各种商品，用继承的技术创建一个可以实现添加、查找和删除功能的类库，并自定义一个异常类。
  Item是物品类，ItemList将Item作为自己的类成员封装起来，Store 继承自ItemList，对外提供可直接通过 String操作其中物品的方法。自定义的异常类可以规定哪些方法产生什么样的异常，该程序中如果未找到商品就会发生异常，还有就是记得必须在try-catch语句中调用抛出异常的方法。
  面向对象编程主要体现的特性就是封装、继承和多态。封装可以使得代码模块化，继承可以扩展已存在的代码，他们的目的都是为了代码重用。而多态的目的则是为了接口重用。