快递管理训练（IO实现）

package com.javaEELesson.day06;
​
import java.io.Serializable;
import java.util.Objects;
​
public class Express implements Serializable {
    /**
     * 快递取件码。
     */
    private String pickUpCode;
    /**
     * 快递单号
     */
    private String expressNumber;
    /**
     * 快递公司
     */
    private String expressCompany;
    /**
     * 快递构造函数。
     * @param expressNumber 快递单号。
     * @param expressCompany 快递公司。
     */
    public Express(String expressNumber, String expressCompany) {
        setExpressNumber(expressNumber);
        setExpressCompany(expressCompany);
    }
​
    @Override
    public String toString() {
        return "Express{" +
                "pickUpCode='" + pickUpCode + '\'' +
                ", expressNumber='" + expressNumber + '\'' +
                ", expressCompany='" + expressCompany + '\'' +
                '}';
    }
​
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Express express = (Express) o;
        return Objects.equals(expressNumber, express.expressNumber);
    }
​
    @Override
    public int hashCode() {
        return Objects.hash(expressNumber);
    }
​
    public String getPickUpCode() {
        return pickUpCode;
    }
​
    public void setPickUpCode(String pickUpCode) {
        this.pickUpCode = pickUpCode;
    }
​
    public String getExpressNumber() {
        return expressNumber;
    }
​
    public void setExpressNumber(String expressNumber) {
        this.expressNumber = expressNumber;
    }
​
    public String getExpressCompany() {
        return expressCompany;
    }
​
    public void setExpressCompany(String expressCompany) {
        this.expressCompany = expressCompany;
    }
}

package com.javaEELesson.day06;
​
import java.io.Serializable;
import java.util.Objects;
​
public class ExpressAdministrator implements Serializable {
    private String name;
    private int age;
    private String gender;
    private String address;
    private HousingEstate housingEstate;
​
    /**
     * 快递管理员构造函数。
     * @param name 名称。
     * @param age 年龄。
     * @param gender 性别。
     * @param address 地址。
     */
    public ExpressAdministrator(String name, int age, String gender, String address) {
        setName(name);
        setAge(age);
        setGender(gender);
        setAddress(address);
    }
    /**
     * 快递管理员构造函数。
     * @param name 名称。
     * @param age 年龄。
     * @param gender 性别。
     * @param address 地址。
     * @param housingEstate 管理小区。
     */
    public ExpressAdministrator(String name, int age, String gender, String address, HousingEstate housingEstate) {
        setName(name);
        setAge(age);
        setGender(gender);
        setAddress(address);
        setHousingEstate(housingEstate);
    }
    /**
     * 将快递放入快递箱子。
     * @param express 要放入的快递。
     * @return 返回0表示成功放入快递，返回1表示所有快递箱子都已经存满，返回2表示快递单号重复，返回3表示异常情况需要修改程序。
     */
    public int putExpress(Express express) {return housingEstate.putExpress(express); }
    /**
     * 根据快递单号删除快递。
     * @param expressNumber 快递单号。
     * @return 返回0表示删除成功，返回1表示未找到该快递。
     */
    public int deleteExpress(String expressNumber) {return housingEstate.deleteExpress(expressNumber);}
    /**
     * 根据快递单号修改快递。
     * @param expressNumber 快递单号。
     * @param newExpress 新快递信息。
     * @return 返回0表示修改成功，返回1表示未找到该快递。
     */
    public int editExpress(String expressNumber, Express newExpress) {
        return housingEstate.editExpress(expressNumber, newExpress);
    }
    /**
     * 按快递在快递箱中的顺序位置（取件码的顺序）打印此小区中的所有快递。
     */
    public void printAllExpress() {housingEstate.printAllExpress();}
    /**
     * 根据快递单号寻找快递。
     * @param expressNumber 快递单号。
     * @return 寻找到了就返回要寻找的快递，否则返回null。
     */
    public Express findExpress(String expressNumber) {
        return housingEstate.findExpress(expressNumber);
    }
    @Override
    public String toString() {
        return "ExpressAdministrator{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", address='" + address + '\'' +
                ", housingEstate=" + housingEstate.getHousingEstateName() +
                '}';
    }
​
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ExpressAdministrator that = (ExpressAdministrator) o;
        return age == that.age && Objects.equals(name, that.name) && Objects.equals(gender, that.gender) && Objects.equals(address, that.address) && Objects.equals(housingEstate, that.housingEstate);
    }
​
    @Override
    public int hashCode() {
        return Objects.hash(name, age, gender, address);
    }
​
    public String getName() {
        return name;
    }
​
    private void setName(String name) {
        this.name = name;
    }
​
    private int getAge() {
        return age;
    }
​
    private void setAge(int age) {
        this.age = age;
    }
​
    private String getGender() {
        return gender;
    }
​
    private void setGender(String gender) {
        this.gender = gender;
    }
​
    private String getAddress() {
        return address;
    }
​
    private void setAddress(String address) {
        this.address = address;
    }
​
    public HousingEstate getHousingEstate() {
        return housingEstate;
    }
​
    public void setHousingEstate(HousingEstate housingEstate) {
        this.housingEstate = housingEstate;
    }
}

package com.javaEELesson.day06;
​
import java.io.Serializable;
import java.util.*;
​
public class ExpressCabinet implements Serializable {
    /**
     * 类的使用次数，也即ID。
     */
    private static int count;
    /**
     * 存储快递的快递箱子，HashMap取件码为键，存储的快递为值。
     */
    private HashMap<String, Express> expressCabinet;
    /**
     * 快递单号与取件码的对应关系。快递单号为键，取件码为值。
     */
    private HashMap<String, String> relationship;
    /**
     * 快递箱子的ID，自增，不可手动赋值。
     */
    private int ID;
    /**
     * 快递箱子最小行数，常量。
     */
    private static final int MIN_ROWS = 5;
    /**
     * 快递箱子实际行数。
     */
    private int rows;
    /**
     * 快递箱子最小列数，常量。
     */
    private static final int MIN_COLUMNS = 10;
    /**
     * 快递箱子实际列数。
     */
    private int columns;
    /**
     * 不指定快递箱子的行数与列数，快递箱子的规格为默认值。
     */
    public ExpressCabinet() {
        setID(++count);
        setRows(MIN_ROWS);
        setColumns(MIN_COLUMNS);
        setExpressCabinet(new HashMap<>());
        setRelationship(new HashMap<>());
    }
    /**
     * 指定快递箱子的行数与列数，快递箱子的规格为指定的行数与列数。
     * @param rows 行数。
     * @param columns 列数。
     */
    private ExpressCabinet(int rows, int columns) {
        setID(++count);
        setRows(rows);
        setColumns(columns);
        setExpressCabinet(new HashMap<>());
        setRelationship(new HashMap<>());
    }
    /**
     * 随机生成一个取件码，取件码的格式为“箱子序号-所在行数-所在列数”，
     * 若随机生成取件码在箱子中已经存在（已有快递），
     * 则以次寻找箱子中下一个格子处是否有快递，
     * 直到返回没有快递的箱子的取件码为止。
     * @return 快递取件码。
     */
    private String createPickUpCode() {
        int row = (int)(Math.random() * rows) + 1;
        int column = (int)(Math.random() * columns) + 1;
        String pickUpCode = ID + "-" + row + "-" + column;
        if (!expressCabinet.containsKey(pickUpCode))
            return pickUpCode;
        first:for (int i = 1; i <= rows; i++)
            for (int j = 1; j <= columns; j++) {
                pickUpCode = ID + "-" + i + "-" + j;
                if (!expressCabinet.containsKey(pickUpCode))
                    break first;
            }
        return pickUpCode;
    }
    /**
     * 将快递放入快递箱子。
     * @param express 要放入的快递。
     * @return 返回0表示成功放入快递，返回1表示快递箱子已满。
     */
    public int putExpress(Express express) {
        if (expressCabinet.size() >= rows * columns) return 1;
        //这行代码不需要了，但是不要删除，留个纪念。
        //if (relationship.containsKey(express.getExpressNumber())) return 2;
        String pickUpCode = createPickUpCode();
        express.setPickUpCode(pickUpCode);
        expressCabinet.put(pickUpCode, express);
        relationship.put(express.getExpressNumber(), pickUpCode);
        return 0;
    }
    /**
     * 根据快递单号寻找快递。
     * @param expressNumber 快递单号。
     * @return 寻找到了就返回要寻找的快递，否则返回null。
     */
    public Express findExpress(String expressNumber) {
        return expressCabinet.get(relationship.get(expressNumber));
    }
    /**
     * 根据快递单号删除快递。
     * @param expressNumber 快递单号。
     * @return 返回0表示删除成功，返回1表示未找到该快递。
     */
    public int deleteExpress(String expressNumber) {
        if (findExpress(expressNumber) == null) return 1;
        expressCabinet.remove(relationship.remove(expressNumber));
        return 0;
    }
    /**
     * 根据快递单号修改快递。
     * @param expressNumber 旧快递单号。
     * @param newExpress 新快递信息。
     * @return 返回0表示修改成功，返回1表示未找到该快递。
     */
    public int editExpress(String expressNumber, Express newExpress) {
        Express oldExpress = findExpress(expressNumber);
        if (oldExpress == null) return 1;
        newExpress.setPickUpCode(oldExpress.getPickUpCode());
        relationship.remove(expressNumber);
        relationship.put(newExpress.getExpressNumber(), oldExpress.getPickUpCode());
        expressCabinet.replace(oldExpress.getPickUpCode(), newExpress);
        return 0;
    }
    /**
     * 按快递在快递箱中的顺序位置（取件码的顺序）打印此快递箱中的所有快递。
     */
    public void printAllExpress() {
        TreeMap<String, Express> expresses = new TreeMap<>(new Comparator<String>() {
            @Override
            public int compare(String p1, String p2) {
                String[] location1 = p1.split("-");
                String[] location2 = p2.split("-");
                if (Integer.parseInt(location1[1]) == Integer.parseInt(location2[1])) {
                    if (Integer.parseInt(location1[2]) > Integer.parseInt(location2[2]))
                        return 1;
                    else if (Integer.parseInt(location1[2]) < Integer.parseInt(location2[2]))
                        return -1;
                    else
                        return 0;
                }
                else if (Integer.parseInt(location1[1]) > Integer.parseInt(location2[1]))
                    return 1;
                else
                    return -1;
            }
        });
        expresses.putAll(expressCabinet);
        Iterator<String> it = expresses.keySet().iterator();
        while (it.hasNext())
            System.out.println(expresses.get(it.next()));
    }
    /**
     * 根据取件码寻找快递。
     * @param pickUpCode 取件码。
     * @return 寻找到了就返回要寻找的快递，否则返回null。
     */
    public Express findExpressByPickUpCode(String pickUpCode) {
        return expressCabinet.get(pickUpCode);
    }
    /**
     * 根据取件码取快递。
     * @return 要取的快递，如果没有该快递则返回null。
     */
    public Express pickUpExpress(String pickUpCode) {
        Express express = expressCabinet.remove(pickUpCode);
        if (express == null)
            return null;
        relationship.remove(express.getExpressNumber());
        return express;
    }
​
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ExpressCabinet that = (ExpressCabinet) o;
        return ID == that.ID;
    }
​
    @Override
    public int hashCode() {
        return Objects.hash(ID);
    }
​
    private int getID() {
        return ID;
    }
​
    private void setID(int ID) {
        this.ID = ID;
    }
​
    public HashMap<String, Express> getExpressCabinet() {
        return expressCabinet;
    }
​
    private void setExpressCabinet(HashMap<String, Express> expressCabinet) {
        this.expressCabinet = expressCabinet;
    }
​
    private int getRows() {
        return rows;
    }
​
    private void setRows(int rows) {
        if (rows < MIN_ROWS) {
            System.out.println("快递柜子行数必须大于5！设置为默认值5。");
            this.rows = MIN_ROWS;
        } else
            this.rows = rows;
    }
​
    private int getColumns() {
        return columns;
    }
​
    private void setColumns(int columns) {
        if (columns < MIN_COLUMNS) {
            System.out.println("快递柜子列数必须大于10！设置为默认值10。");
            this.columns = MIN_COLUMNS;
        } else
            this.columns = columns;
    }
​
    public HashMap<String, String> getRelationship() {
        return relationship;
    }
​
    private void setRelationship(HashMap<String, String> relationship) {
        this.relationship = relationship;
    }
​
}

package com.javaEELesson.day06;
​
import java.io.*;
import java.util.ArrayList;
import java.util.Scanner;
​
public class ExpressManagementSystem implements IMessage, Serializable {
    /**
     * 系统中所有小区。
     */
    private static ArrayList<HousingEstate> housingEstates = new ArrayList<>();
    /**
     * 获取键盘输入。
     */
    private static transient Scanner input = new Scanner(System.in);
​
    public static void main(String[] args) throws IOException, ClassNotFoundException {
//        //这些代码被注释了，它只在第一次序列化的时候会用到，请不要随意解除注释。
//        //创建小区。
//        HousingEstate housingEstate = new HousingEstate("测试地区");
//        //创建管理员。
//        ExpressAdministrator administrator =
//                new ExpressAdministrator("测试管理员", 26, "男", "测试地区");
//        //创建用户。
//        OrdinaryUser user = new OrdinaryUser("测试普通用户", 26, "男", "测试地区");
//        //将小区添加到系统中。
//        housingEstates.add(housingEstate);
//        //为小区设置管理员。
//        housingEstate.addAdministrator("admin-password", administrator);
//        //为小区添加普通用户。
//        housingEstate.addOrdinaryUser("user-password", user);
//        //为管理员设置管理的小区。
//        administrator.setHousingEstate(housingEstate);
//        //为普通用户设置小区。
//        user.setHousingEstate(housingEstate);
        //反序列化从文件中读取数据。
        dataDeSerializable();
        //进入主菜单。
        mainMenu.mainMenu();
    }
​
    static class mainMenu {
        public static void mainMenu() throws IOException {
            System.out.println(WELCOME_TO_MAIN_MENU_MESSAGE);
            System.out.println(MAIN_MENU_MESSAGE);
            System.out.println(SELECT_OPERATION_MESSAGE);
            int choice = Integer.parseInt(input.nextLine());
            if (choice <= 0 || choice >= 4) {
                System.out.println(INPUT_ERROR_MESSAGE);
                mainMenu.mainMenu();
            }
            switch (choice) {
                case 1:
                    administratorMenu.administratorMenu();
                    break;
                case 2:
                    ordinaryUserMenu.ordinaryUserMenu();
                    break;
                case 3:
                    input.close();
                    System.out.println(BY_BY);
                    System.exit(0);
            }
        }
    }
​
    static class administratorMenu {
        public static void administratorMenu() throws IOException {
            System.out.println(INPUT_ACCOUNT_NUMBER);
            String accountNumber = input.nextLine();
            System.out.println(INPUT_PASSWORD);
            String password = input.nextLine();
            String str = new StringBuffer(accountNumber + "-" + password).toString();
            //因为系统中目前只添加了一个小区测试，所以只需要获取第一个小区。
            HousingEstate housingEstate = housingEstates.get(0);
            ExpressAdministrator administrator = housingEstate.getAdministrator().get(str);
            if (administrator == null) {
                System.out.println(INPUT_ERROR_MESSAGE);
                mainMenu.mainMenu();
            }
//            //这些代码被注释了，它只在第一次序列化时会用到，它可能之后会用到，但是请不要谁便解除注释！
//            System.out.println("自动录入50个快递，防止快递过少。");
//            autoInput(administrator);
            while (true) {
                System.out.println(WELCOME_TO_ADMINISTRATOR_MENU_MESSAGE);
                System.out.println(ADMINISTRATOR_MENU_MESSAGE);
                System.out.println(SELECT_OPERATION_MESSAGE);
                int choice = Integer.parseInt(input.nextLine());
                if (choice <= 0 || choice >= 7) {
                    System.out.println(INPUT_ERROR_MESSAGE);
                    continue;
                }
                String expressNumber;
                String companyName;
                Express express;
                int information;
                switch (choice) {
                    case 1:
                        System.out.println(INPUT_EXPRESS_NUMBER_MESSAGE);
                        expressNumber = input.nextLine();
                        if (expressNumber.length() == 0) {
                            System.out.println(INPUT_EXPRESS_NUMBER_CAN_NOT_BE_NULL_MESSAGE);
                            break;
                        }
                        System.out.println(INPUT_EXPRESS_COMPANY_NAME_MESSAGE);
                        companyName  = input.nextLine();
                        if (companyName.length() == 0) {
                            System.out.println(INPUT_EXPRESS_COMPANY_CAN_NOT_BE_NULL_MESSAGE);
                            break;
                        }
                        express = new Express(expressNumber, companyName);
                        information = administrator.putExpress(express);
                        if (information == 0) {
                            System.out.println(SUCCESS_ADD_EXPRESS_MESSAGE);
                            dataSerializable();
                        }
                        else if (information == 1) {
                            System.out.println(FAIL_ADD_EXPRESS_MESSAGE);
                            System.out.println(ALL_THE_CABINETS_ARE_FULL_MESSAGE);
                        }
                        else if (information == 2) {
                            System.out.println(FAIL_ADD_EXPRESS_MESSAGE);
                            System.out.println(EXPRESS_HAS_BEEN_ENTERED_MESSAGE);
                        }
                        else if (information == 3) {
                            System.out.println(FAIL_ADD_EXPRESS_MESSAGE);
                            System.out.println(PROGRAM_ERROR);
                            System.exit(0);
                        }
                        break;
                    case 2:
                        System.out.println(INPUT_EXPRESS_NUMBER_MESSAGE);
                        expressNumber = input.nextLine();
                        if (expressNumber.length() == 0) {
                            System.out.println(INPUT_EXPRESS_NUMBER_CAN_NOT_BE_NULL_MESSAGE);
                            break;
                        }
                        information = administrator.deleteExpress(expressNumber);
                        if (information == 0) {
                            System.out.println(SUCCESS_DELETE_EXPRESS_MESSAGE);
                            dataSerializable();
                        }
                        else if (information == 1) {
                            System.out.println(FAIL_DELETE_EXPRESS_MESSAGE);
                            System.out.println(EXPRESS_DOES_NOT_EXIST_MESSAGE);
                        }
                        break;
                    case 3:
                        System.out.println(INPUT_EXPRESS_NUMBER_MESSAGE);
                        expressNumber = input.nextLine();
                        if (expressNumber.length() == 0) {
                            System.out.println(INPUT_EXPRESS_NUMBER_CAN_NOT_BE_NULL_MESSAGE);
                            break;
                        }
                        System.out.println(INPUT_NEW_EXPRESS_NUMBER_MESSAGE);
                        String newExpressNumber = input.nextLine();
                        if (newExpressNumber.length() == 0) {
                            System.out.println(INPUT_EXPRESS_NUMBER_CAN_NOT_BE_NULL_MESSAGE);
                            break;
                        }
                        System.out.println(INPUT_NEW_EXPRESS_COMPANY_NAME_MESSAGE);
                        String newExpressCompany = input.nextLine();
                        if (newExpressCompany.length() == 0) {
                            System.out.println(INPUT_EXPRESS_COMPANY_CAN_NOT_BE_NULL_MESSAGE);
                            break;
                        }
                        express = new Express(newExpressNumber, newExpressCompany);
                        information = administrator.editExpress(expressNumber, express);
                        if (information == 0) {
                            dataSerializable();
                            System.out.println(SUCCESS_UPDATE_EXPRESS_MESSAGE);
                        }
                        else if (information == 1) {
                            System.out.println(FAIL_UPDATE_EXPRESS_MESSAGE);
                            System.out.println(EXPRESS_DOES_NOT_EXIST_MESSAGE);
                        }
                        break;
                    case 4:
                        System.out.println(ALL_EXPRESS_MESSAGE);
                        administrator.printAllExpress();
                        break;
                    case 5:
                        mainMenu.mainMenu();
                    case 6:
                        input.close();
                        System.out.println(BY_BY);
                        System.exit(0);
                }
            }
        }
    }
​
    static class ordinaryUserMenu {
        public static void ordinaryUserMenu() throws IOException {
            System.out.println(INPUT_ACCOUNT_NUMBER);
            String accountNumber = input.nextLine();
            System.out.println(INPUT_PASSWORD);
            String password = input.nextLine();
            String str = new StringBuffer(accountNumber + "-" + password).toString();
            HousingEstate housingEstate = housingEstates.get(0);
            OrdinaryUser user = housingEstate.getOrdinaryUsers().get(str);
            if (user == null) {
                System.out.println(INPUT_ERROR_MESSAGE);
                mainMenu.mainMenu();
            }
            while (true) {
                System.out.println(WELCOME_TO_USER_MENU_MESSAGE);
                System.out.println(USER_MENU_MESSAGE);
                System.out.println(SELECT_OPERATION_MESSAGE);
                int choice = Integer.parseInt(input.nextLine());
                if (choice <= 0 || choice >= 4) {
                    System.out.println(INPUT_ERROR_MESSAGE);
                    continue;
                }
                switch (choice) {
                    case 1:
                        user.getHousingEstate().printAllExpress();
                        System.out.println(INPUT_PICK_UP_CODE_MESSAGE);
                        String pickUpCode = input.nextLine();
                        Express express = user.pickUpExpress(pickUpCode);
                        if (express == null) {
                            System.out.println(ERROR_GET_EXPRESS_MESSAGE);
                            System.out.println(EXPRESS_DOES_NOT_EXIST_MESSAGE);
                            break;
                        }
                        dataSerializable();
                        System.out.println(SUCCESS_GET_EXPRESS_MESSAGE);
                        System.out.println(express);
                        break;
                    case 2:
                        mainMenu.mainMenu();
                        break;
                    case 3:
                        input.close();
                        System.out.println(BY_BY);
                        System.exit(0);
                }
            }
        }
    }
    private static void dataSerializable() throws IOException {
        OutputStream os = new FileOutputStream("src\\com\\javaEELesson\\day06\\housingEstates.txt");
        ObjectOutputStream oos = new ObjectOutputStream(os);
        oos.writeObject(housingEstates);
        os.close();
        oos.close();
    }
    private static void dataDeSerializable() throws IOException, ClassNotFoundException {
        InputStream is = new FileInputStream("src\\com\\javaEELesson\\day06\\housingEstates.txt");
        ObjectInputStream ois = new ObjectInputStream(is);
        housingEstates = (ArrayList<HousingEstate>) ois.readObject();
        is.close();
        ois.close();
    }
    /**
     * 自动录入一些快递，防止数据过少。这个方法只在第一次序列化时调用过一次，
     * 非程序员之后请不要调用，否则会有一连串的快递单号重复消息被打印。
     * @param administrator 管理员。
     */
    private static void autoInput(ExpressAdministrator administrator) {
        for (int i = 0; i < 10; i++) {
            Express express = new Express(i + "", "京东公司");
            administrator.putExpress(express);
        }
        for (int j = 10; j < 20; j++) {
            Express express = new Express(j + "", "菜鸟公司");
            administrator.putExpress(express);
        }
        for (int k = 20; k < 30; k++) {
            Express express = new Express(k + "", "熊猫公司");
            administrator.putExpress(express);
        }
        for (int l = 30; l < 40; l++) {
            Express express = new Express(l + "", "顺丰公司");
            administrator.putExpress(express);
        }
        for (int m = 40; m < 50; m++) {
            Express express = new Express(m + "", "圆通公司");
            administrator.putExpress(express);
        }
    }
}

package com.javaEELesson.day06;
​
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Objects;
​
public class HousingEstate implements Serializable {
    /**
     * 柜子最小值5。
     */
    private static final int MIN_EXPRESS_CABINET_NUMBERS = 5;
    /**
     * 快递柜子数量。
     */
    private int expressCabinetNumbers;
    /**
     * 小区总快递容纳数量。
     */
    private int expressCapacity;
    /**
     * 小区名称。
     */
    private String housingEstateName;
    /**
     * 所有快递柜子。
     */
    private ArrayList<ExpressCabinet> expressCabinets;
    /**
     * 小区普通用户。
     */
    private HashMap<String, OrdinaryUser> ordinaryUsers;
    /**
     * 小区快递管理员。
     */
    private HashMap<String, ExpressAdministrator> administrators;
    /**
     * 创建小区的构造函数，定义好柜子数量，小区名称。
     * @param expressCabinetNumbers 柜子数量。
     * @param housingEstateName 小区名称。
     */
    public HousingEstate(int expressCabinetNumbers, String housingEstateName) {
        setExpressCabinetNumbers(expressCabinetNumbers);
        setHousingEstateName(housingEstateName);
        setExpressCabinets(this.expressCabinetNumbers);
        setAdministrator(new HashMap<>());
        setOrdinaryUsers(new HashMap<>());
    }
    /**
     * 创建小区的构造函数，只定义小区名称，柜子数量为默认最小值5。
     * @param housingEstateName 小区名称。
     */
    public HousingEstate(String housingEstateName) {
        setHousingEstateName(housingEstateName);
        setExpressCabinetNumbers(MIN_EXPRESS_CABINET_NUMBERS);
        setExpressCabinets(this.expressCabinetNumbers);
        setAdministrator(new HashMap<>());
        setOrdinaryUsers(new HashMap<>());
    }
    /**
     * 将快递放入快递箱子。
     * @param express 要放入的快递。
     * @return 返回0表示成功放入快递，返回1表示所有快递箱子都已经存满，返回2表示快递单号重复，返回3表示异常情况需要修改程序。
     */
    public int putExpress(Express express) {
        if (expressCapacity >= expressCabinetNumbers * 50)
            return 1;
        for (ExpressCabinet expressCabinet : expressCabinets) {
            if (findExpress(express.getExpressNumber()) != null)
                return 2;
        }
        int index = (int) (Math.random() * expressCabinetNumbers);
        int information = expressCabinets.get(index).putExpress(express);
        if (information == 0) {
            expressCapacity++;
            return 0;
        }
        else {
            index = 0;
            while (information == 1) {
                information = expressCabinets.get(index++).putExpress(express);
            }
            return information;
        }
    }
    /**
     * 根据快递单号删除快递。
     * @param expressNumber 快递单号。
     * @return 返回0表示删除成功，返回1表示未找到该快递。
     */
    public int deleteExpress(String expressNumber) {
        for (ExpressCabinet expressCabinet : expressCabinets) {
            if (expressCabinet.deleteExpress(expressNumber) == 0) {
                expressCapacity--;
                return 0;
            }
        }
        return 1;
    }
    /**
     * 根据快递单号修改快递。
     * @param expressNumber 快递单号。
     * @param newExpress 新快递信息。
     * @return 返回0表示修改成功，返回1表示未找到该快递。
     */
    public int editExpress(String expressNumber, Express newExpress) {
        for (ExpressCabinet expressCabinet : expressCabinets) {
            if (expressCabinet.editExpress(expressNumber, newExpress) == 0)
                return 0;
        }
        return 1;
    }
    /**
     * 根据取件码寻找快递。
     * @param pickUpCode 取件码。
     * @return 寻找到了就返回要寻找的快递，否则返回null。
     */
    public Express findExpressByPickUpCode(String pickUpCode) {
        for (ExpressCabinet expressCabinet : expressCabinets) {
            Express express = expressCabinet.findExpressByPickUpCode(pickUpCode);
            if (express != null)
                return express;
        }
        return null;
    }
    /**
     * 根据取件码取快递。
     * @return 要取的快递，如果没有该快递则返回null。
     */
    public Express pickUpExpress(String pickUpCode) {
        for (ExpressCabinet expressCabinet : expressCabinets) {
            Express express = expressCabinet.pickUpExpress(pickUpCode);
            if (express != null) {
                expressCapacity--;
                return express;
            }
        }
        return null;
    }
    /**
     * 根据快递单号寻找快递。
     * @param expressNumber 快递单号。
     * @return 寻找到了就返回要寻找的快递，否则返回null。
     */
    public Express findExpress(String expressNumber) {
        for (ExpressCabinet expressCabinet : expressCabinets) {
            Express express = expressCabinet.findExpress(expressNumber);
            if (express != null)
                return express;
        }
        return null;
    }
    /**
     * 按快递在快递箱中的顺序位置（取件码的顺序）打印此小区中的所有快递。
     */
    public void printAllExpress() {
        for (ExpressCabinet expressCabinet : expressCabinets) {
            expressCabinet.printAllExpress();
        }
    }
    /**
     * 为小区添加普通用户。
     * @param ordinaryUser 普通用户。
     */
    public void addOrdinaryUser(String loginInformation, OrdinaryUser ordinaryUser) {
        ordinaryUsers.put(loginInformation, ordinaryUser);
    }
    /**
     * 为小区添加管理员。
     * @param administrator 管理员。
     */
    public void addAdministrator(String loginInformation, ExpressAdministrator administrator) {
        administrators.put(loginInformation, administrator);
    }
​
    @Override
    public String toString() {
        return "HousingEstate{" +
                "expressCabinetNumbers=" + expressCabinetNumbers +
                ", housingEstateName='" + housingEstateName + '\'' +
                ", expressCabinets=" + expressCabinets +
                '}';
    }
​
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        HousingEstate that = (HousingEstate) o;
        return expressCabinetNumbers == that.expressCabinetNumbers && Objects.equals(housingEstateName, that.housingEstateName) && Objects.equals(expressCabinets, that.expressCabinets);
    }
​
    @Override
    public int hashCode() {
        return Objects.hash(expressCabinetNumbers, housingEstateName, expressCabinets);
    }
​
    private int getExpressCabinetNumbers() {
        return expressCabinetNumbers;
    }
​
    private void setExpressCabinetNumbers(int expressCabinetNumbers) {
        if (expressCabinetNumbers < MIN_EXPRESS_CABINET_NUMBERS) {
            System.out.println("快递柜子数量必须大于5！设置为默认值5。");
            this.expressCabinetNumbers = MIN_EXPRESS_CABINET_NUMBERS;
        } else
            this.expressCabinetNumbers = expressCabinetNumbers;
    }
​
    public String getHousingEstateName() {
        return housingEstateName;
    }
​
    private void setHousingEstateName(String housingEstateName) {
        this.housingEstateName = housingEstateName;
    }
​
    private ArrayList<ExpressCabinet> getExpressCabinets() {
        return expressCabinets;
    }
​
    private void setExpressCabinets(int expressCabinetNumbers) {
        this.expressCabinets = new ArrayList<>(expressCabinetNumbers);
        for (int i = 0; i < expressCabinetNumbers; i++) {
            ExpressCabinet expressCabinet = new ExpressCabinet();
            expressCabinets.add(expressCabinet);
        }
    }
​
    public HashMap<String, OrdinaryUser> getOrdinaryUsers() {
        return ordinaryUsers;
    }
​
    private void setOrdinaryUsers(HashMap<String, OrdinaryUser> ordinaryUsers) {
        this.ordinaryUsers = ordinaryUsers;
    }
​
    public HashMap<String, ExpressAdministrator> getAdministrator() {
        return administrators;
    }
​
    private void setAdministrator(HashMap<String, ExpressAdministrator> administrator) {
        this.administrators = administrator;
    }
​
    public int getExpressCapacity() {
        return expressCapacity;
    }
​
    private void setExpressCapacity(int expressCapacity) {
        this.expressCapacity = expressCapacity;
    }
}

package com.javaEELesson.day06;
​
interface IMessage {
    String PROGRAM_ERROR = "程序出现异常，请处理！";
    String INPUT_ACCOUNT_NUMBER = "请输入账号：";
    String INPUT_PASSWORD = "请输入密码：";
    String SUCCESS_GET_EXPRESS_MESSAGE = "取出快递成功！";
    String ERROR_GET_EXPRESS_MESSAGE = "取出快递失败！";
    String INPUT_NEW_EXPRESS_NUMBER_MESSAGE = "请输入新的快递单号：";
    String INPUT_NEW_EXPRESS_COMPANY_NAME_MESSAGE = "请输入新的快递公司名称：";
    String ALL_THE_CABINETS_ARE_FULL_MESSAGE = "所有柜子都已放满";
    String INPUT_PICK_UP_CODE_MESSAGE = "请输入快递取件码：";
    String EXPRESS_FORMAT_MESSAGE = "快递单号\t\t快递公司\t\t柜子位置\t取件码";
    String INPUT_EXPRESS_NUMBER_MESSAGE = "请输入快递单号：";
    String INPUT_EXPRESS_NUMBER_CAN_NOT_BE_NULL_MESSAGE = "快递单号不能为空！";
    String INPUT_EXPRESS_COMPANY_NAME_MESSAGE = "请输入快递公司名称：";
    String INPUT_EXPRESS_COMPANY_CAN_NOT_BE_NULL_MESSAGE = "快递公司不能为空！";
    String SUCCESS_ADD_EXPRESS_MESSAGE = "录入快递信息成功！";
    String FAIL_ADD_EXPRESS_MESSAGE = "录入快递信息失败！";
    String SUCCESS_DELETE_EXPRESS_MESSAGE = "删除快递信息成功！";
    String FAIL_DELETE_EXPRESS_MESSAGE = "删除快递信息失败！";
    String SUCCESS_UPDATE_EXPRESS_MESSAGE = "修改快递信息成功！";
    String FAIL_UPDATE_EXPRESS_MESSAGE = "修改快递信息失败！";
    String EXPRESS_HAS_BEEN_ENTERED_MESSAGE = "该快递已经被录入！";
    String EXPRESS_DOES_NOT_EXIST_MESSAGE = "系统中不存在该快递！";
    String INPUT_ERROR_MESSAGE = "您的输入有误，请重新输入！";
    String ALL_EXPRESS_MESSAGE = "所有快递信息如下：";
    String WELCOME_TO_MAIN_MENU_MESSAGE = "============欢迎来到控制台快递管理系统============";
    String WELCOME_TO_USER_MENU_MESSAGE = "================欢迎您！普通用户================";
    String WELCOME_TO_ADMINISTRATOR_MENU_MESSAGE = "================欢迎您！快递管理员================";
    String SELECT_OPERATION_MESSAGE = "请选择你的操作：";
    String MAIN_MENU_MESSAGE = "1.快递管理员登陆\t\t2.普通用户登陆" + "\n" + "3.退出系统";
    String ADMINISTRATOR_MENU_MESSAGE = "1.快递录入\t\t2.删除快递" + "\n" + "3.修改快递\t\t4.查看所有快递" + "\n" + "5.返回主菜单\t\t6.退出系统";
    String USER_MENU_MESSAGE = "1.快递取出\t\t2.返回主菜单" + "\n" + "3.退出系统";
    String BY_BY = "====================再见，期待您再次使用本系统！====================";
}

package com.javaEELesson.day06;
​
import java.io.Serializable;
import java.util.Objects;
​
public class OrdinaryUser implements Serializable {
    private String name;
    private int age;
    private String gender;
    private String address;
    private HousingEstate housingEstate;
    /**
     * 普通用户基本信息构造函数。
     * @param name 名称。
     * @param age 年龄。
     * @param gender 性别。
     * @param address 地址。
     */
    public OrdinaryUser(String name, int age, String gender, String address) {
        setName(name);
        setAge(age);
        setGender(gender);
        setAddress(address);
    }
    /**
     * 普通用户全部信息构造函数。
     * @param name 名称。
     * @param age 年龄。
     * @param gender 性别。
     * @param address 地址。
     * @param housingEstate 小区。
     */
    public OrdinaryUser(String name, int age, String gender, String address, HousingEstate housingEstate) {
        setName(name);
        setAge(age);
        setGender(gender);
        setAddress(address);
        setHousingEstate(housingEstate);
    }
    /**
     * 非null返回值表示取出成功，null表示失败。
     * @param pickUpCode 取件码。
     * @return 非null返回值表示取出成功，null表示失败。
     */
    public Express pickUpExpress(String pickUpCode) {
        return housingEstate.pickUpExpress(pickUpCode);
    }
​
    @Override
    public String toString() {
        return "OrdinaryUser{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", address='" + address + '\'' +
                ", housingEstate=" + housingEstate +
                '}';
    }
​
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        OrdinaryUser that = (OrdinaryUser) o;
        return age == that.age && Objects.equals(name, that.name) && Objects.equals(gender, that.gender) && Objects.equals(address, that.address) && Objects.equals(housingEstate, that.housingEstate);
    }
​
    @Override
    public int hashCode() {
        return Objects.hash(name, age, gender, address, housingEstate);
    }
​
    private String getName() {
        return name;
    }
​
    private void setName(String name) {
        this.name = name;
    }
​
    private int getAge() {
        return age;
    }
​
    private void setAge(int age) {
        this.age = age;
    }
​
    private String getGender() {
        return gender;
    }
​
    private void setGender(String gender) {
        this.gender = gender;
    }
​
    private String getAddress() {
        return address;
    }
​
    private void setAddress(String address) {
        this.address = address;
    }
​
    public HousingEstate getHousingEstate() {
        return housingEstate;
    }
​
    public void setHousingEstate(HousingEstate housingEstate) {
        this.housingEstate = housingEstate;
    }
}