目录
第二版
基本介绍
在第二版的房屋出租系统中，我们使用的数据库来存放，信息相比较第一版，第二版更加的简单，只需要完成一些对应的增删改查即可，第一版中我们要删除某个房屋对房屋的编号，我们还要进行判断，因为第一版中用的是数组。存放的信息因此很不方便，所以在我们后面学习到了数据库jdbc等知识之后使用，起来就更加的方便，并且程序的框架也比较明显，有完成相对应服务的service层有界面层，服务层也就是service层，用来完成界面层需要的，功能及实现在。domain层中一定要，给一个无参构造器，因为，底层是通过反射的机制去获取属性和对象，因此一定要给一个。，接下来就是对业务逻辑的升级增加判断，可以根据自己的需求选择对应的方式，这个房屋出租系统还是比较简单的，很多功能混合在一起，但是对我们练习增删改查了解jdbc的基本使用还是有点帮助的。使用数据库更加方便，我们直接的管理，
区别：
比如第一版的时候想查询一个房屋，我们只能用打编号去查询，但是使用数据库之后，我们可以根据访问的编号去查询，可以查询我们想要房屋的地址，比如你想在杭州找房子，那么就查询杭州根据地址来查，也可以根据租金的范围来查，比如说你的最大资金和最小资金两个范围之间可以帮你筛选出来，因此数据库还是帮助我们这很大的方便，相比较第一版有较大的升级在查询上也更加的方便，包括去修改房屋的信息，比如说想修改房屋的租客的姓名呀，电话，地址，租金等等，我们只需要一条SQL语句就可以完成，不像之前的需要修改数组中的内容，很麻烦，非常的麻烦
一个最简单的房屋出租系统，这里用到了一些mysql,jdbc等知识
BasicDAO类
package item.HousingRentalSystem.dao;
import item.HousingRentalSystem.utils.JDBCUtilsByDruid;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
public class BasicDAO<T> {
private QueryRunner qr = new QueryRunner();
//完成增删改查
public int update(String sql, Object... parameters) {
Connection connection = null;
try {
connection = JDBCUtilsByDruid.getConnection();
return qr.update(connection, sql, parameters);
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
JDBCUtilsByDruid.close(null, null, connection);
}
}
//返回多个对象(即查询的结果是多行), 针对任意表
public List<T> queryMulti(String sql, Class<T> clazz, Object... parameters) {
Connection connection = null;
try {
connection = JDBCUtilsByDruid.getConnection();
return qr.query(connection, sql, new BeanListHandler<T>(clazz), parameters);
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
JDBCUtilsByDruid.close(null, null, connection);
}
}
//返回单行对象
public T querySingle(String sql, Class<T> clazz, Object... parameters) {
Connection connection = null;
try {
connection = JDBCUtilsByDruid.getConnection();
return qr.query(connection, sql, new BeanHandler<T>(clazz), parameters);
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
JDBCUtilsByDruid.close(null, null, connection);
}
}
//返回单行单列的结果
public Object queryScalar(String sql, Class<T> clazz, Object... parameters) {
Connection connection = null;
try {
connection = JDBCUtilsByDruid.getConnection();
return qr.query(connection, sql, new ScalarHandler(), parameters);
} catch (SQLException e) {
throw new RuntimeException(e);
} finally {
JDBCUtilsByDruid.close(null, null, connection);
}
}
}HouseDAO类
package item.HousingRentalSystem.dao;
import item.HousingRentalSystem.domain.HouseDate;
public class HouseDateDAO extends BasicDAO<HouseDate> {
}
LoginDAO类
package item.HousingRentalSystem.dao;
import item.HousingRentalSystem.domain.Login;
public class LoginDAO extends BasicDAO<Login> {
}
HouseDate类
package item.HousingRentalSystem.domain;
public class HouseDate {
private int id;
private String name;
private String phone;
private String address;
private double rent;
private String state;
//一定需要无参构造器底层需要
public HouseDate() {
}
public HouseDate(int id, String name, String phone, String address, double rent, String state) {
this.id = id;
this.name = name;
this.phone = phone;
this.address = address;
this.rent = rent;
this.state = state;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public double getRent() {
return rent;
}
public void setRent(double rent) {
this.rent = rent;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
@Override
public String toString() {
return id + "\t\t\t" + name + "\t\t" + phone + "\t\t" + address + "\t\t\t" + rent + "\t\t" + state;
}
}
Login类
package item.HousingRentalSystem.domain;
public class Login {
private String name;
private String pwd;
public Login() {
}
public Login(String name, String pwd) {
this.name = name;
this.pwd = pwd;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
@Override
public String toString() {
return "Login{" +
"name='" + name + '\'' +
", pwd='" + pwd + '\'' +
'}';
}
}
HouseDateService类
该类用于完成对界面层的各种操作的相应，也就是完成一些简单的增删改查
package item.HousingRentalSystem.service;
import item.HousingRentalSystem.dao.HouseDateDAO;
import item.HousingRentalSystem.domain.HouseDate;
import java.util.List;
public class HouseDateService {
//定义一个HouseDatedDAO属性
private HouseDateDAO houseDateDAO = new HouseDateDAO();
//编写方法返回所有房屋信息
public List<HouseDate> list() {
return houseDateDAO.queryMulti("select * from houseDate", HouseDate.class);
}
/**
* 编写方法完成新增房源 ，因为房屋的编号，我们设计了自增长，所有只需要传入一个null即可
*
* @param name 名字
* @param phone 电话
* @param address 地址
* @param rent 租金
* @param state 状态
* @return 返回一个布尔值，如果添加成功，返回true，反之返回false
*/
public boolean addHouse(String name, String phone, String address, double rent, String state) {
int update = houseDateDAO.update("insert into houseDate values(null,?,?,?,?,?)", name, phone, address, rent, state);
return update > 0;
}
/**
* 编写方法 删除房屋
*
* @param id 房屋的编号
* @return 返回一个布尔值，如果返回的值小于0说明没有删除成功
*/
public boolean deleteHouse(int id) {
int update = houseDateDAO.update("delete from houseDate where id = ?", id);
return update > 0;
}
/**
* 编写方法根据用户输入的房屋编号查找房源
*
* @param id 房屋的编号
* @return 如果根据该编号，能查找到房屋，就返回一个HouseDate对象，反之返回null
*/
public HouseDate selHouseById(int id) {
return houseDateDAO.querySingle("select * from houseDate where id = ?", HouseDate.class, id);
}
/**
* 编写方法根据地址查找房源，因为在实际情况中，有可能根据地址来查找房子
*
* @param address 选择要查询房屋的地址
* @return 返回一个集合，因为查询到的可能不只有一个记录
*/
public List<HouseDate> selHouseByAddress(String address) {
return houseDateDAO.queryMulti("select * from houseDate where address = ? ", HouseDate.class, address);
}
/**
* 编写方法根据租金范围查找房源，因为在现实生活中，我们需要根据自己的预算去查找房屋
*
* @param minMoney 能接受房子的最小价格
* @param maxMoney 能接受房子的最大价格
* @return 返回一个集合，因为查询到的可能不只有一个记录
*/
public List<HouseDate> selHouseByRent(double minMoney, double maxMoney) {
return houseDateDAO.queryMulti("select * from houseDate where rent >= ? and rent <= ?", HouseDate.class, minMoney, maxMoney);
}
/**
* 编写方法根据便编号，修改房屋的地址
*
* @param address str表示，可以修改的是，房屋的地址
* @param id 表示房屋的编号
* @return 返回一个布尔值，如果修改成功，返回true，反之返回false
*/
public boolean updateHouseByAddress(String address, int id) {
int update = houseDateDAO.update("update houseDate set address = ? where id = ? ", address, id);
return update > 0;
}
/**
* 编写方法根据编号，修改房屋租金
*
* @param id 房屋的编号
* @param rent 房屋的租金
* @return 返回一个布尔值，如果修改成功，返回true，反之返回false
*/
public boolean updateHouseByRent(int id, double rent) {
int update = houseDateDAO.update("update houseDate set rent = ? where id = ? ", rent, id);
return update > 0;
}
/**
* 编写方法根据便编号修改房屋电话
*
* @param id 房屋的编号
* @param phone 电话
* @return 返回一个布尔值，如果修改成功，返回true，反之返回false
*/
public boolean updateHouseByPhone(int id, String phone) {
int update = houseDateDAO.update("update houseDate set phone = ? where id = ? ", phone, id);
return update > 0;
}
}
LoginService类
该类专门用来处理登录的情况，更具用户传入的信息，到数据库中去校验，是否存在
package item.HousingRentalSystem.service;
import item.HousingRentalSystem.dao.LoginDAO;
import item.HousingRentalSystem.domain.Login;
public class LoginService {
//定义一个LoginDAO属性
private LoginDAO loginDAO = new LoginDAO();
/**
* 编写方法，根据用户输入的信息到数据库中去判断，该用户是否存在
*
* @param id 用户名
* @param pwd 密码
* @return 返回一个Login对象，如果该用户不存在，返回的就是一个空值
*/
public Login checkIdByName(String id, String pwd) {
return loginDAO.querySingle("select * from login where name = ? and pwd = md5(?)", Login.class, id, pwd);
}
}
JDBCUtilsByDruid类
package item.HousingRentalSystem.utils;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
public class JDBCUtilsByDruid {
private static DataSource dataSource;
//在静态代码块中初始化
static {
Properties properties = new Properties();
try {
properties.load(new FileInputStream("src\\druid.properties"));
dataSource = DruidDataSourceFactory.createDataSource(properties);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
//编写方法等到连接
public static Connection getConnection() throws SQLException {
return dataSource.getConnection();
}
//编写方法关闭连接
public static void close(ResultSet resultSet, Statement statement, Connection connection) {
try {
if (resultSet != null) {
resultSet.close();
}
if (statement != null) {
statement.close();
}
if (connection != null) {
connection.close();
}
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
Utility类
这是一个用来帮助用户输入的工具类
package item.HousingRentalSystem.utils;
/**
* 工具类的作用:
* 处理各种情况的用户输入，并且能够按照程序员的需求，得到用户的控制台输入。
*/
import java.util.Scanner;
/**
*/
public class Utility {
//静态属性。。。
private static Scanner scanner = new Scanner(System.in);
/**
* 功能：读取键盘输入的一个菜单选项，值：1——5的范围
* @return 1——5
*/
public static char readMenuSelection() {
char c;
for (; ; ) {
String str = readKeyBoard(1, false);//包含一个字符的字符串
c = str.charAt(0);//将字符串转换成字符char类型
if (c != '1' && c != '2' &&
c != '3' && c != '4' && c != '5') {
System.out.print("选择错误，请重新输入：");
} else break;
}
return c;
}
/**
* 功能：读取键盘输入的一个字符
* @return 一个字符
*/
public static char readChar() {
String str = readKeyBoard(1, false);//就是一个字符
return str.charAt(0);
}
/**
* 功能：读取键盘输入的一个字符，如果直接按回车，则返回指定的默认值；否则返回输入的那个字符
* @param defaultValue 指定的默认值
* @return 默认值或输入的字符
*/
public static char readChar(char defaultValue) {
String str = readKeyBoard(1, true);//要么是空字符串，要么是一个字符
return (str.length() == 0) ? defaultValue : str.charAt(0);
}
/**
* 功能：读取键盘输入的整型，长度小于2位
* @return 整数
*/
public static int readInt() {
int n;
for (; ; ) {
String str = readKeyBoard(2, false);//一个整数，长度<=2位
try {
n = Integer.parseInt(str);//将字符串转换成整数
break;
} catch (NumberFormatException e) {
System.out.print("数字输入错误，请重新输入：");
}
}
return n;
}
/**
* 功能：读取键盘输入的 整数或默认值，如果直接回车，则返回默认值，否则返回输入的整数
* @param defaultValue 指定的默认值
* @return 整数或默认值
*/
public static int readInt(int defaultValue) {
int n;
for (; ; ) {
String str = readKeyBoard(10, true);
if (str.equals("")) {
return defaultValue;
}
//异常处理...
try {
n = Integer.parseInt(str);
break;
} catch (NumberFormatException e) {
System.out.print("数字输入错误，请重新输入：");
}
}
return n;
}
/**
* 功能：读取键盘输入的指定长度的字符串
* @param limit 限制的长度
* @return 指定长度的字符串
*/
public static String readString(int limit) {
return readKeyBoard(limit, false);
}
/**
* 功能：读取键盘输入的指定长度的字符串或默认值，如果直接回车，返回默认值，否则返回字符串
* @param limit 限制的长度
* @param defaultValue 指定的默认值
* @return 指定长度的字符串
*/
public static String readString(int limit, String defaultValue) {
String str = readKeyBoard(limit, true);
return str.equals("") ? defaultValue : str;
}
/**
* 功能：读取键盘输入的确认选项，Y或N
* 将小的功能，封装到一个方法中.
* @return Y或N
*/
public static char readConfirmSelection() {
System.out.print("确认是否预定(Y/N)：");
char c;
for (; ; ) {//无限循环
//在这里，将接受到字符，转成了大写字母
//y => Y n=>N
String str = readKeyBoard(1, false).toUpperCase();
c = str.charAt(0);
if (c == 'Y' || c == 'N') {
break;
} else {
System.out.print("选择错误，请重新输入：");
}
}
return c;
}
/**
* 功能： 读取一个字符串
* @param limit 读取的长度
* @param blankReturn 如果为true ,表示 可以读空字符串。
* 如果为false表示 不能读空字符串。
*
* 如果输入为空，或者输入大于limit的长度，就会提示重新输入。
* @return
*/
private static String readKeyBoard(int limit, boolean blankReturn) {
//定义了字符串
String line = "";
//scanner.hasNextLine() 判断有没有下一行
while (scanner.hasNextLine()) {
line = scanner.nextLine();//读取这一行
//如果line.length=0, 即用户没有输入任何内容，直接回车
if (line.length() == 0) {
if (blankReturn) return line;//如果blankReturn=true,可以返回空串
else continue; //如果blankReturn=false,不接受空串，必须输入内容
}
//如果用户输入的内容大于了 limit，就提示重写输入
//如果用户如的内容 >0 <= limit ,我就接受
if (line.length() < 1 || line.length() > limit) {
System.out.print("输入长度（不能大于" + limit + "）错误，请重新输入：");
continue;
}
break;
}
return line;
}
}
HouseSystrmView类
在界面层中的细节
另外有一个小细节，我在主菜单中做了一个三级菜单，我用的是一个单独的变量去控制三级菜单的显示，但是如果我们先进入修改房屋信息然后再去查找房屋信息的时候，因为想要退出就需要，将变量设置为false，才可以退出，所以，一但先进入了一个，三级菜单，那么我在进入另外一个三级菜单的时候，就进不去了，因为共用的是一个变量，所以当我们想进入另外一个菜单时候，就会发现进不去了，所以有种解决方案，第一种就是，在进入三级菜单之前，我们先将变量重新设置为true，这样子就不会到之后，先进入一个三级菜单，在想进入第二个三级菜单就进不去的情况了，第二种方式就是，定义两个单独的变量，用于控制对应菜单的显示。
package item.HousingRentalSystem.view;
import item.HousingRentalSystem.domain.HouseDate;
import item.HousingRentalSystem.domain.Login;
import item.HousingRentalSystem.service.HouseDateService;
import item.HousingRentalSystem.service.LoginService;
import item.HousingRentalSystem.utils.Utility;
import java.util.List;
import java.util.Scanner;
public class HouseSystemView {
//该变量用于控制菜单的显示
private boolean loop = true;
//该变量用于接受用户的一些输入
private String key = "";
//创建一个LoginService对象
private LoginService loginService = new LoginService();
//创建一个Scanner对象
private Scanner scanner = new Scanner(System.in);
//创建一个HouseDateService对象
private HouseDateService houseDateService = new HouseDateService();
private boolean b = true;//该变量用于控制查找房屋中的菜单
public static void main(String[] args) {
new HouseSystemView().MainView();
}
//编写方法修改房屋电话信息
public void updateHousePhone() {
System.out.print("请输入要修改的房屋电话：");
String phone = Utility.readString(50);
System.out.print("请输入房屋的编号:");
//这里也可以对id进行一个校验，如果查找不到房屋，那么就不能修改状态
int id = Utility.readInt();
if (!houseDateService.updateHouseByPhone(id, phone)) {
System.out.println("========修改成功========");
} else {
System.out.println("========修改失败，您输入的编号不存在========");
}
}
//编写方法修改房屋租金信息
public void updateHouseRent() {
System.out.print("请输入要修改的房屋租金：");
double rent = scanner.nextDouble();
System.out.print("请输入房屋的编号:");
//这里也可以对id进行一个校验，如果查找不到房屋，那么就不能修改状态
int id = Utility.readInt();
if (!houseDateService.updateHouseByRent(id, rent)) {
System.out.println("========修改成功========");
} else {
System.out.println("========修改失败，您输入的编号不存在========");
}
}
//编写方法修改房屋地址信息
public void updateHouseAddress() {
System.out.print("请输入要修改的房屋地址：");
String address = Utility.readString(50);
System.out.print("请输入房屋的编号:");
//这里也可以对id进行一个校验，如果查找不到房屋，那么就不能修改状态
int id = Utility.readInt();
if (!houseDateService.updateHouseByAddress(address, id)) {
System.out.println("========修改成功========");
} else {
System.out.println("========修改失败，您输入的编号不存在========");
}
}
//编写方法根据租金范围去查找房屋
public void selHouseRent() {
System.out.print("请输入最低价钱:");
double min = scanner.nextDouble();
System.out.print("请输入最高价钱:");
double max = scanner.nextDouble();
List<HouseDate> houseDates = houseDateService.selHouseByRent(min, max);
System.out.println("房屋\t\t\t编号\t\t\t姓名\t\t\t电话\t\t\t地址\t\t\t租金状态");
//如果返回的集合不为空，所有集合中有我们符合条件的房子，如果为空，说明没有符合我们要求的房子
if (houseDates != null) {
for (HouseDate houseDate : houseDates) {
System.out.println(houseDate);
}
System.out.println("========查询完毕========");
} else {
System.out.println("========没有查找到符合您条件的房子========");
}
}
//编写方法根据地址查找房屋
public void selHouseAddress() {
System.out.print("请输入要查找的房屋地址:");
String address = Utility.readString(50);
List<HouseDate> houseDates = houseDateService.selHouseByAddress(address);
System.out.println("房屋\t\t\t编号\t\t\t姓名\t\t\t电话\t\t\t地址\t\t\t租金状态");
if (houseDates != null) {
for (HouseDate houseDate : houseDates) {
System.out.println(houseDate);
}
System.out.println("========查询完毕========");
} else {
System.out.println("========没有查找到符合您条件的房子========");
}
}
//编写方法根据id查找房屋
public void selHouseId() {
System.out.print("请输入要查找的房屋编号:");
int id = Utility.readInt();
HouseDate houseDate = houseDateService.selHouseById(id);
System.out.println("房屋\t\t\t编号\t\t\t姓名\t\t\t电话\t\t\t地址\t\t\t租金状态");
if (houseDate != null) {
System.out.println(houseDate);
} else {
System.out.println("您要查找房屋的编号不存在");
}
}
//编写方法完成删除房屋
public void delHouse() {
System.out.print("请输入要删除房屋的编号:");
int id = Utility.readInt();
if (!houseDateService.deleteHouse(id)) {
System.out.println("删除失败");
}
System.out.println("========删除成功========");
}
//编写方法完成新增房源
public void addHouse() {
//提示用户输入一些信息
System.out.print("请输入名字:");
String name = Utility.readString(50);
System.out.print("请输入电话:");
String phone = Utility.readString(50);
System.out.print("请输入地址:");
String address = Utility.readString(50);
System.out.print("请输入租金:");
double rent = scanner.nextDouble();
System.out.print("请输入状态:");
String state = Utility.readString(50);
if (!houseDateService.addHouse(name, phone, address, rent, state)) {
System.out.println("新增失败");
}
}
//编写方法返回所有房屋的信息
public void list() {
List<HouseDate> list = houseDateService.list();
System.out.println("房屋\t\t\t编号\t\t\t姓名\t\t\t电话\t\t\t地址\t\t\t租金状态");
for (HouseDate houseDate : list) {
System.out.println(houseDate);
}
System.out.println("========输出完毕========");
}
//编写方法显示房屋出租系统的菜单
public void MainView() {
while (loop) {
System.out.println("==========欢迎来到房屋出租系统==========");
System.out.println("\t\t1.登录");
System.out.println("\t\t2.退出");
System.out.print("请输入你的选择:");
key = Utility.readString(10);
switch (key) {
case "1":
System.out.print("请输入用户名:");
String name = Utility.readString(50);
System.out.print("请输入密码:");
String pwd = Utility.readString(50);
//这里我们需要去数据验证该数据是否存在，现在我们先默认他为正确的
//该方法会返回一个login对象，如果用户不存在，那么login就是null,反之就是存在
Login login = loginService.checkIdByName(name, pwd);
if (login != null) {
System.out.println("==========登录成功==========");
while (loop) {
System.out.println("\n==========欢迎来到房屋出租系统二级菜单(" + login.getName() + ")==========");
System.out.println("\t\t\t1.新 增 房 源");
System.out.println("\t\t\t2.查 找 房 屋");
System.out.println("\t\t\t3.删 除 房 屋");
System.out.println("\t\t\t4.修 改 房 屋 信 息");
System.out.println("\t\t\t5.房 屋 列 表");
System.out.println("\t\t\t9.退 出");
System.out.print("请输入你的选择：");
key = Utility.readString(10);
switch (key) {
case "1":
addHouse();
break;
case "2":
//为什么要在这里把b在设置为true 因为我们的查找房屋三级菜单和修改房屋三级菜单，都是共用一个变量属性就是b
//如果是先使用查找房屋的三级菜单，那么想要退出只能将b设置成false，因此，当我们再去使用修改访问二级菜单的时候
//b的属性已经是false，就进不去了，所有在这里我们提前设置一下
b = true;
while (b) {
System.out.println("\n\t\t\t1.id");
System.out.println("\t\t\t2.地址");
System.out.println("\t\t\t3.租金范围");
System.out.println("\t\t\t4.退 出");
System.out.print("想选择通过什么方式去查找房屋:");
int n = Utility.readInt();
switch (n) {
case 1:
selHouseId();
break;
case 2:
selHouseAddress();
break;
case 3:
selHouseRent();
break;
case 4:
b = false;
break;
default:
System.out.println("你的输入有误");
break;
}
}
break;
case "3":
delHouse();
break;
case "4":
//为什么要在这里把b在设置为true 因为我们的查找房屋三级菜单和修改房屋三级菜单，都是共用一个变量属性就是b
//如果是先使用查找房屋的三级菜单，那么想要退出只能将b设置成false，因此，当我们再去使用修改访问二级菜单的时候
//b的属性已经是false，就进不去了，所有在这里我们提前设置一下
b = true;
while (b) {
System.out.println("\n\t\t\t1.电话");
System.out.println("\t\t\t2.租金");
System.out.println("\t\t\t3.地址");
System.out.println("\t\t\t4.退 出");
System.out.print("想选择通过什么方式去修改房屋信息:");
int n = Utility.readInt();
switch (n) {
case 1:
updateHousePhone();
break;
case 2:
updateHouseRent();
break;
case 3:
updateHouseAddress();
break;
case 4:
b = false;
break;
default:
System.out.println("你的输入有误");
break;
}
}
break;
case "5":
list();
break;
case "9":
System.out.println("退出房屋出租系统");
loop = false;
break;
}
}
} else {
System.out.println("用户名或者密码错误，请重新输入");
}
break;
case "2":
loop = false;
break;
default:
System.out.println("你的输入有误");
break;
}
}
}
}