java学习---小项目---租房系统

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;
    }
}

效果展示：

原文地址：https://blog.csdn.net/qq_56798493/article/details/140595942

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！