package com.project.House_rental.HouseApp;
import com.project.House_rental.HouseView.HouseView;
//主界面
public class HouseApp {
public static void main(String[] args) {
new HouseView().List_();
System.out.println("------已退出----------");
}
}
package com.project.House_rental.House;
//定义·一个类，存放需要的属性
public class House {
int id;//房屋编号
String name;//房东姓名
String tele;//电话
String add;//地址
double monthly_rent;//租金
String stale;//状态
//构造器
public House(int id, String name, String tele, String add, double monthly_rent, String stale) {
this.id = id;
this.name = name;
this.tele = tele;
this.add = add;
this.monthly_rent = monthly_rent;
this.stale = stale;
}
//封装
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 getTele() {
return tele;
}
public void setTele(String tele) {
this.tele = tele;
}
public String getAdd() {
return add;
}
public void setAdd(String add) {
this.add = add;
}
public double getMonthly_rent() {
return monthly_rent;
}
public void setMonthly_rent(double monthly_rent) {
this.monthly_rent = monthly_rent;
}
public String getStale() {
return stale;
}
public void setStale(String stale) {
this.stale = stale;
}
//重写toString方法
@Override
public String toString() {
return
"编号" + "\t\t 姓名" + "\t\t电话"+"\t\t地址" +"\t\t月租" +"\t\t状态\n"+ id+"\t\t"
+ name + "\t\t" +
tele + "\t\t" +
add + "\t\t"+
monthly_rent +"\t\t"+
stale + "\t" ;
}
}
package com.project.House_rental.HouseServe;
import com.project.House_rental.House.House;
//实现效果所需的方法放入该类
public class HoseServe {
House house[] = null;//定义一个House类的数组，暂时置空，用来接收房屋数据的
private int size;//数组大小
private int HosueNum = 1;//当前有的房屋信息数量，因为，在构造器我们初始化了一组房屋数据所以数量为1
int idCount = 1;//房屋编号，有一组所以目前编号为1
//构造器，用于初始化属性
public HoseServe(int size) {
this.size = size;
house = new House[size];//初始化新建的数组，使其容量为size
house[0] = new House(1, "小美", "12345", "北海", 1234, "未出租");//初始化一组数据
}
//类似一般属性封装的get
public House[] List_() {
return house;
}
//数据的增加
public Boolean HouseAdd_(House newhouse) {
if (HosueNum == size) {//判断house数组当前数据是否已满
System.out.println("数组已满无法添加");
return false;
} else {
house[HosueNum++] = newhouse;//没满就将传进来的newhouse数据赋为house数组
//下标从0开始，HouseNum计数从1开始，所以，HouseNum当前的值就正好为下个数值的下标，
// 与此同时，HouseNum也需要自加，完成计数的任务
System.out.println("添加成功！");
newhouse.setId(++idCount);//id不能人为自己选择是多少，
// 所以在此需要给新加入的数据自加编号
return true;
}
}
//数据的删除
public Boolean House_Delet(int idIndext) {
//方法一
// int i=0;
// for( i=0;i<house.length;i++)
// {
// if (house[i].getId()==idIndext)//判断当前id是否是要删的id
// {
// break;//是的直接跳出循环不再接着循环
// }
// }
// if (i<house.length) {//判断i的值，如果i的值还是小于数组长度，代表进入过循环中的if判断，
// //且当前的i就是对应id的数据的下标
// for (; i < house.length; i++) {
// if (i + 1 < house.length)
// house[i] = house[i + 1];//将当前的数据用后面的数据覆盖，实现删除
// }
// HosueNum--;//因为删除了数据，所以相应的数据数量也要减少
// return true;
// }
// else
// return false;
// }
//方法二
int indext_ = -1;//一个索引用来判断是否进入过判断
for (int i = 0; i < HosueNum; i++) {
if (house[i].getId() == idIndext) {//判断当前id是否是要删的id
indext_ = i;
break;
}
}
//如果还为代表遍历完循环了并未进入过判断
if (indext_ == -1) {
return false;
} else {
for (int i = idIndext; i < HosueNum - 1; i++) {//下标从0开始，而HouseNum计数从1开始
house[i] = house[i + 1];//将当前的数据用后面的数据覆盖，实现删除
}
house[--HosueNum] = null;//因为当前数据删了一个，删除数据后的所有数据都向前挪了一个，
// 最后一个就会没有数值，所以需要将最后一个手动置空
//并且计数的HouseNum也需要减少
return true;
}
}
//查找
public House House_Find(int Index1)
{
if (Index1>0&&Index1<=HosueNum) {//先判断是否存在
for (int i=0;i<HosueNum;i++)
if (Index1==house[i].getId())//寻找是否有对应编号的数据
return house[i];//找到了返回其数据
}
else
{
return null;//未找到，返回null
}
return null;
}
}
package com.project.House_rental.HouseView;
import com.project.House_rental.House.House;
import com.project.House_rental.HouseApp.HouseApp;
import com.project.House_rental.HouseServe.HoseServe;
import com.project.House_rental.Utility.Utility;
import java.util.Scanner;
public class HouseView {
private boolean o=true;//相当于索引，结束循环的工具
private char key=' ';//执行操作的索引
private HoseServe hoseServe=new HoseServe(10);//新建了个HoseServe类的属性这样可以实现调用该类的方法
public void List_(){//用于展示的方法
do{
menu();//菜单目录
key= Utility.readChar();//Utility包中的一个方法，功能：读取键盘输入的一个字符
switch (key)//通过判断key中的为哪个字符从而去到相应的case实现效果
{
case '1':
HouseAdd();
break;
case '2':
HouseCheck();
break;
case '3':
ViewDelet();
break;
case '4':
House_modify();
break;
case '5':
HouseList_();
break;
case '6':
Quit();
break;
default:
System.out.println("请重新输入");
}
}while(o);
}
//菜单
private void menu(){
System.out.println("--------房屋出租列表--------\n"+
"1.新增房源\n"+"2.查找房源\n"+"3.删除房源\n"+"4.更改房源\n"+"5.查看房源\n"+"6.退出\n"+"1-6请输入一个数字"
);
}
//查看房源列表
private void HouseList_()
{
House house[]=hoseServe.List_();//调用了hoseServe中List_()，该方法返回了创建的House类型数组
System.out.println("--------房屋列表-------");
for(int i=0;i<house.length;i++)
{
//挨个遍历，但数组不一定都是满的，没有数据的数组会自动赋null，
// 所以如果遍历到null值直接退出循环不执行之后的代码
if (house[i]==null)
break;
System.out.println(house[i]);
}
}
//添加
private void HouseAdd()
{
System.out.println("姓名：");
//手动输入要添加的数据的属性
//* readString( );功能：读取键盘输入的指定长度的字符串
// * @param limit 限制的长度
// @return 指定长度的字符串
String name=Utility.readString(9);
System.out.println("电话：");
String tele=Utility.readString(11);
System.out.println("地址：");
String add=Utility.readString(20);
System.out.println("租金");
Scanner scanner=new Scanner(System.in);
double monthly_rent=scanner.nextDouble();
System.out.println("状态(未出租/已出租)：");
String stale=Utility.readString(10);
//新建一个House类型的对象将刚刚输入的信息传入其中
House newhouse = new House(0, name, tele, add, monthly_rent, stale);
//HouseAdd_(newhouse)方法的返回值为布尔类型，如果成功会返回true失败为false
if (hoseServe.HouseAdd_(newhouse))
{
System.out.println("-------添加成功--------");
}
else
{
System.out.println("添加失败");
}
}
//删除
private void ViewDelet()
{
System.out.println("-------删除房屋--------\n");
System.out.println("输入-1为退出");
/** Utility中的readInt()方法
* 功能：读取键盘输入的整型，长度小于2位
* @return 整数
*/
int index=Utility.readInt();
if (index==-1)
return;//输入-1表示退出
else {
/**Utility中的readConfirmSelection()方法
* 功能：读取键盘输入的确认选项，Y或N
* 将小的功能，封装到一个方法中.
* @return Y或N
*/
Utility.readConfirmSelection();
System.out.println("请选择要删除的编号：\n");
if (hoseServe.House_Delet(index)) {//House_Delet(index)方法的返回值为布尔类型，如果成功会返回true失败为false
System.out.println("--------删除成功--------");
} else {
System.out.println("-------删除失败-------");
}
}
}
private void Quit(){
/**Utility中的readConfirmSelection()方法
* 功能：读取键盘输入的确认选项，Y或N
* 将小的功能，封装到一个方法中.
* @return Y或N
*/
char c=Utility.readConfirmSelection();
if (c=='Y')
{
o=false;//代表确定退出将o置为false即可退出循环
}
}
//查找
private void HouseCheck()
{
System.out.println("------查询房源--------");
System.out.println("输入编号：");
System.out.println("输入-1为退出");
/** Utility中的readInt()方法
* 功能：读取键盘输入的整型，长度小于2位
* @return 整数
*/
int Index1=Utility.readInt();
//创建一个House类数据接收
House house=hoseServe.House_Find(Index1);//House_Find(Index1)方法的返回类型为House，查到返回数据失败返回null
if (house==null)
System.out.println("查找失败！无此编号");
else
System.out.println(house);
}
//修改
private void House_modify()
{
System.out.println("------修改房源--------");
System.out.println("输入编号：");
/** Utility中的readInt()方法
* 功能：读取键盘输入的整型，长度小于2位
* @return 整数
*/
int Index1=Utility.readInt();
House house=hoseServe.House_Find(Index1);//调用House_Find(Index1)方法查找该编号数据是否存在
if (house==null)
System.out.println("查找失败！无此编号");
else {
System.out.print("姓名(" + house.getName() + ")：");
//手动输入要修改的数据的属性
//* readString( );功能：读取键盘输入的指定长度的字符串
// * @param limit 限制的长度
// @return 指定长度的字符串
String name=Utility.readString(9);
//判断name是否做修改，如果跟“ ”一样代表并未修改，那么就不用进入if更改house的name的值
//如果修改了，则直接调用setName(name)方法，将修改的name的值传人其中
if (!"".equals(name))
{
house.setName(name);
}
System.out.print("电话(" + house.getTele() + ")：");
String tele=Utility.readString(11);
if (!"".equals(tele))
{
house.setTele(tele);
}
System.out.print("地址(" + house.getAdd() + ")：");
String add=Utility.readString(20);
if (!"".equals(add))
{
house.setAdd(add);
}
System.out.print("月租(" + house.getMonthly_rent() + ")：");
Scanner scanner=new Scanner(System.in);
double monthly_rent=scanner.nextDouble();
if (!" ".equals(monthly_rent))
{
house.setMonthly_rent(monthly_rent);
}
System.out.print("状态(" + house.getStale() + ")：");
String state=Utility.readString(20);
if (!"".equals(state))
{
house.setStale(state);
}
}
}
}
package com.project.House_rental.Utility;
/**
工具类的作用:
处理各种情况的用户输入，并且能够按照程序员的需求，得到用户的控制台输入。
*/
import java.util.*;
/**
*/
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(10, false);//一个整数，长度<=10位
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.println("请输入你的选择(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;
}
}
效果展示：
