修改后的Package名字为com.javaoop1
    bean包

    1. package com.javaoop1.bean;
    3. import java.util.Objects;
    5. /**
    6.  * @Description: 一个快递包裹类的创建，包含快递单号，快递公司，包裹的取件码
    7.  * 包含比较快递单号是相同的方法（修改了equals方法）。
    8.  * @Author: XUEWEN TAN
    9.  * @Date：2020。08.30
    10.  * bean这个package中没有任何业务逻辑，所有属性全部私有，提供get,set方法，提供无参构造器的对象。
    11.  */
    12. public class Express {
    13.     //快递单号
    14.     private String number;
    15.     //快递公司
    16.     private String company;
    17.     //取件码
    18.     private int code;
    20.     public Express(String number, String company, int code) {
    21.         this.number = number;
    22.         this.company = company;
    23.         this.code = code;
    24.     }
    26.     @Override
    27.     public String toString() {
    28.         return "Express{" +
    29.                 "number='" + number + '\'' +
    30.                 ", company='" + company + '\'' +
    31.                 ", code=" + code +
    32.                 '}';
    33.     }
    35.     @Override
    36.     public boolean equals(Object o) {
    37.         if (this == o) return true;
    38.         if (o == null || getClass() != o.getClass()) return false;
    39.         Express express = (Express) o;
    40.         return Objects.equals(number, express.number);
    41.     }
    43.     @Override
    44.     public int hashCode() {
    45.         return Objects.hash(number);
    46.     }
    48.     public Express() {
    49.     }
    51.     public String getNumber() {
    52.         return number;
    53.     }
    55.     public void setNumber(String number) {
    56.         this.number = number;
    57.     }
    59.     public String getCompany() {
    60.         return company;
    61.     }
    63.     public void setCompany(String company) {
    64.         this.company = company;
    65.     }
    67.     public int getCode() {
    68.         return code;
    69.     }
    71.     public void setCode(int code) {
    72.         this.code = code;
    73.     }
    75. }

    DAO包

    1. package com.javaoop1.dao;
    3. import com.javaoop1.bean.Express;
    5. import java.util.Random;
    7. /**
    8.  *@Description:快递的数据的存储与取出(DAO= data access object),创建一个名为ExpressDao的类，
    9.  *包含添加快递包裹，生成取件码,查找单号（遍历法），查找取件码（遍历法）,update，删除快递包裹，查看所有包裹
    10.  *@Author: XUEWEN TAN
    11.  *@Date: 2020.08.30
    12.  */
    13. public class ExpressDao {
    14.     //创建一个10*10的快递柜
    15.     private  Express[][] data = new Express [10][];
    16.     private int size; //定义size作为当前已经存储的快递数量
    17.     private Random random = new Random();//定义随机数
    19.     public void init(){
    20.         for(int i=0;i<10;i++){
    21.             data[i] = new Express[10];
    22.         }
    23.     }
    25.     public ExpressDao(){
    26.         init();
    27.     }
    30.     /**
    31.      * 快递员添加快递包裹的方法add
    32.      * @param e
    33.      * @return 添加成功或者失败
    34.      */
    35.     public boolean add(Express e){//todo:需要判断e是否为空。
    36.         if(size == 100){
    37.             return false;//当存储快递数为100时即快递柜无空位
    38.         }
    39.         //随机生成二维数组下标
    40.         int x = -1;
    41.         int y = -1;
    42.         while(true){
    43.             x = random.nextInt(10);//生成x，y的随机坐标
    44.             y = random.nextInt(10);
    45.             if(data[x][y] == null){
    46.                 //此位置无快递
    47.                 break;
    48.             }
    49.         }
    50.         //存入坐标
    51.         int code =randomCode();
    52.         e.setCode(code);
    53.         data[x][y] = e;
    54.         return true;
    55.     }
    57.     /**
    58.      * 生成六位数取件码
    59.      * @return Int类型的6位数的取件码
    60.      */
    61.     private int randomCode(){
    62.         //100000-999999 = 0~899999+100000
    63.         while(true){
    64.             int code = random.nextInt(900000) + 100000;
    65.             //如果查到了快递则继续生成新的取件码
    66.             Express e = findCode(code);
    67.             //如果没有查到，则返回生成的取件码，即取件码生成成功
    68.             if (e == null) {
    69.                 return code;
    70.             }
    71.         }
    72.     }
    74.     /**
    75.      * 查找单号-遍历法
    76.      * @param number
    77.      * @return 快递包裹（对象）
    78.      */
    79.     public Express findNumber(String number){//todo:在一开始保证入参就是正确的，避免后置校验
    80.         Express e = new Express();
    81.         e.setNumber(number);
    82.         for(int i = 0 ;i<10;i++){
    83.             for(int j = 0;j<10;j++){
    84.                 if (data[i][j] != null)
    85.                     if (e.equals(data[i][j])){
    86.                         return data[i][j];
    87.                     }
    88.             }
    89.         }
    90.         return null;
    91.     }
    93.     /**
    94.      * 查找取件码-遍历法，小概率事件也需考虑（比如取件码重复）
    95.      * @param code
    96.      * @return 快递包裹（对象）
    97.      */
    98.     public Express findCode(int code){
    99.         for(int i = 0 ;i<10;i++){
    100.             for(int j = 0;j<10;j++){
    101.                 if (data[i][j] != null)
    102.                     if (data[i][j].getCode() == code){
    103.                         return data[i][j];
    104.                     }
    105.             }
    106.         }
    107.         return null;
    108.     }
    110.     /**
    111.      * 实际上这个update的操作是多余的操作，为了MVC更圆润（演示数据库的实际操作）
    112.      * @param oldExpress
    113.      * @param newExpress
    114.      */
    115.     public void update(Express oldExpress,Express newExpress){
    116.         delete(oldExpress);
    117.         add(newExpress);
    118.     }
    120.     /**
    121.      * 在快递柜中删除对应的快递包裹信息
    122.      * @param e
    123.      */
    124.     public void delete(Express e){
    125.         //命名循环为p
    126.         p:for(int i = 0 ;i<10;i++) {
    127.             for (int j = 0; j < 10; j++) {
    128.                 if (e.equals(data[i][j])) {
    129.                     data[i][j] = null;
    130.                     break p;
    131.                 }
    132.             }
    133.         }
    134.     }
    136.     /**
    137.      * 查看所有快递
    138.      * @return 快递柜里的所有东西
    139.      */
    140.     public Express[][] findAll(){
    141.         return data;
    142.     }
    144. }

    Main包

    1. package com.javaoop1.main;
    3. import com.javaoop1.bean.Express;
    4. import com.javaoop1.dao.ExpressDao;
    5. import com.javaoop1.view.Views;
    7. /**
    8.  * @Description：Main这个类是controller模块（MVC中的C模块），包含快递柜程序的控制逻辑，
    9.  * 初始化主要界面，分流快递员和取件人，即快递员界面和取件人界面
    10.  * @Author:Xuewen Tan
    11.  * @Date:2020.08.30
    12.  */
    13. public class Main {
    14.     //初始化视图对象
    15.     private static Views v = new Views();
    16.     //初始化dao对象
    17.     private static ExpressDao dao = new ExpressDao();
    19.     public static void main(String[] args){
    20.         init();
    21.     }
    23.     /**
    24.      * 初始化方法的定义
    25.      */
    26.     public static void init(){
    27.         //1.   欢迎
    28.         v.welcome();
    29.         m:while(true){
    30.             //2. 弹出身份选择菜单
    31.             int menu = v.menu();
    32.             switch (menu){
    33.                 case 0:
    34.                     break m;
    35.                 //主界面1选项：进入快递员界面
    36.                 case 1:
    37.                     cClient();
    38.                     break;
    39.                 //主界面2选项：进入用户界面
    40.                 case 2:
    41.                     uClient();
    42.                     break ;
    43.             }
    44.         }
    45.         v.bye();
    46.     }
    49.     /**
    50.      * 定义取件人界面的调用逻辑
    51.      */
    52.     public static  void uClient(){//todo：判断code合理性
    53.         //获得用户输入的取件码
    54.         int code = v.uMenu();
    55.         //取出快递
    56.         Express e = dao.findCode(code);
    57.         if (e == null){
    58.             v.printNull();
    59.         }else{
    60.             v.success();
    61.             v.printExpress(e);
    62.             dao.delete(e);//取件人取出快递后，在快递柜中删除该包裹
    63.         }
    64.     }
    66.     /**
    67.      * 定义快递员界面的调度逻辑
    68.      */
    69.     public static  void cClient(){
    70.         while(true){
    71.             int menu = v.cMenu();
    72.             switch(menu){
    73.                 case 0:
    74.                     return;
    75.                 case 1:{//提示输入快递信息
    76.                     Express e = v.insert();
    77.                     //查询快递单号是否已经存储
    78.                     Express e2 = dao.findNumber(e.getNumber());
    79.                     //存储快递
    80.                     if (e2 == null){
    81.                         dao.add(e);
    82.                         v.printExpress(e);
    83.                         break;
    84.                     }else{
    85.                         //单号重复
    86.                         v.expressExist();
    87.                     }
    88.                 }
    89.                     break;
    90.                 case 2:{//快递修改
    91.                     //1.提示输入快递信息
    92.                     String number = v.findByNumber();
    93.                     //2.查找数据
    94.                     Express e =dao.findNumber(number);//todo：findExpressByNumber，避免语义歧义
    95.                     Express e2 = e;
    96.                     //3. 打印快递信息
    97.                     if (e == null){
    98.                         v.printNull();
    100.                     }else{
    101.                         v.printExpress(e);
    102.                         //4. 提示修改
    103.                         v.update(e2);
    104.                         dao.update(e,e2);
    105.                         v.printExpress(e2);
    106.                     }
    107.                 }
    108.                     break;
    110.                 case 3:{//删除快递
    111.                     //1.输入快递单号并查找
    112.                     String number = v.findByNumber();
    113.                     //2.查找快递对象
    114.                     Express e = dao.findNumber(number);
    115.                     if (e == null){
    116.                         v.printNull();
    117.                     }else{
    118.                         v.printExpress(e);
    119.                         int type = v.delete();
    120.                         if(type == 1){
    121.                             dao.delete(e);
    122.                             v.success();
    123.                         }
    124.                     }
    125.                 }
    126.                     break;
    127.                 //查看所有
    128.                 case 4:{
    129.                     Express[][] date = dao.findAll();//todo：改为findAllExpress
    130.                     v.printAll(date);
    131.                 }
    132.                     break;
    134.             }
    135.         }
    136.     }
    138. }

    View包

    1. package com.javaoop1.view;
    3. import com.javaoop1.bean.Express;
    5. import java.util.Scanner;
    7. /**
    8.  * @Description:MVC中的V模块，V视图展示（欢迎，菜单，子菜单。。。）
    9.  * @Author: XUEWEN TAN
    10.  * @Date: 2020.08.30
    11.  */
    12. public class Views {
    13.     private Scanner input = new Scanner(System.in);
    15.     /**
    16.      * 欢迎
    17.      */
    18.     public void welcome(){
    19.         System.out.println("欢迎使用阿巴阿巴快递管理系统");
    20.     }
    22.     /**
    23.      * 再见
    24.      */
    25.     public void bye(){
    26.         System.out.println("欢迎下次使用");
    27.     }
    29.     /**
    30.      * 主菜单（分流快递员和取件的用户
    31.      * @return 使用者输入的功能选项-int
    32.      */
    33.     public int menu(){
    34.         System.out.println("请根据提示输入功能序号");
    35.         System.out.println("1. 快递管理"); //进入快递员管理界面
    36.         System.out.println("2. 普通用户"); //进入用户取件界面
    37.         System.out.println("0. 退出");
    38.         //所有方法均使用nextLine，不会因为输入产生冲突，
    39.         //还可以接收各种类型的数据。
    40.         String text = input.nextLine();
    41.         int num = -1;
    42.         try{
    43.             num = Integer.parseInt(text);
    44.         }catch (NumberFormatException e){//如果有字符串的错误数据输入，需要考虑；恶意输入
    46.         }
    47.         if(num<0 || num>2){
    48.             System.out.println("输入错误，请重新输入");
    49.             return menu(); //输入数字不在有效范围内，返回菜单
    50.         }
    51.         return num;
    52.     }
    54.     /**
    55.      * 快递员菜单cMenu
    56.      * @return 快递输入的功能选项-int
    57.      */
    58.     public int cMenu(){
    59.         System.out.println("请选择功能序号：");
    60.         System.out.println("1. 快递录入");
    61.         System.out.println("2. 快递修改");
    62.         System.out.println("3. 快递删除");
    63.         System.out.println("4. 查看所有快递");
    64.         System.out.println("0. 退出");//以上为快递员管理界面
    65.         String text = input.nextLine();
    66.         int num = -1;
    67.         try{
    68.             //将用户输入的取件码，转换为int数据类型
    69.             num = Integer.parseInt(text);
    70.         }catch(NumberFormatException e){
    72.         }
    73.         if(num<0 || num>4){
    74.             System.out.println("输入错误，请重新输入");
    75.             return cMenu();
    76.         }//同主界面
    77.         return num;
    78.     }
    80.     /**
    81.      * 快递员录入快递
    82.      * @return 包含了快递单号和快递公司的快递对象
    83.      */
    84.     public Express insert(){
    85.         System.out.println("请根据提示输入快递信息");
    86.         System.out.println("请输入快递单号");
    87.         String number = input.nextLine();
    88.         System.out.println("请输入快递公司");
    89.         String company = input.nextLine();
    90.         Express e = new Express();
    91.         e.setCompany(company);
    92.         e.setNumber(number);
    93.         return e;
    94.     }
    96.     /**
    97.      * 提示快递员输入快递单号
    98.      * @return 快递员输入的快递单号
    99.      */
    101.     public String findByNumber(){
    102.         System.out.println("请根据提示输入快递信息：");
    103.         System.out.println("请输入要操作的快递单号： ");
    104.         String number = input.nextLine();
    105.         return number;
    106.     }
    108.     /**
    109.      * 显示快递信息
    110.      * @param e
    111.      */
    112.     public void printExpress(Express e) {
    113.         System.out.println("快递信息如下：");
    114.         System.out.println("快递公司： " + e.getCompany() + ",快递单号： " + e.getNumber() + ",取件码：" + e.getCode());
    115.     }
    117.     /**
    118.      * 修改快递信息
    119.      * @param e
    120.      */
    121.     public void update(Express e){//todo：做个校验：e是否为空
    122.         System.out.println("请输入新的快递单号");
    123.         String number = input.nextLine();
    124.         System.out.println("请输入新的快递公司");
    125.         String company = input.nextLine();
    126.         e.setNumber(number);
    127.         e.setCompany(company);
    128.     }
    130.     /**
    131.      * 询问是否确认删除
    132.      * @return 1表示确认， 2表示取消操作
    133.      */
    134.     public int delete() {
    135.         System.out.println("是否确认删除");
    136.         System.out.println("1. 确认删除");
    137.         System.out.println("2. 取消删除");
    138.         System.out.println("0. 退出");
    139.         String text = input.nextLine();
    140.         int num = -1;
    141.         try {
    142.             num = Integer.parseInt(text);
    143.         } catch (NumberFormatException e) {
    145.         }
    146.         if (num < 1 || num > 2) {
    147.             System.out.println("输入错误，请重新输入");
    148.             return delete();
    149.         }
    150.         return num;
    151.     }
    153.     /**
    154.      * 给定数组的快递信息，遍历显示
    155.      */
    156.     public void printAll(Express[][] es){
    157.         int count = 0;
    158.         //通过循环，打印输出快递信息
    159.         for(int i=0;i<10;i++){
    160.             for(int j=0;j<10;j++){
    161.                 if(es[i][j] != null){
    162.                     count++;
    163.                     System.out.print("第"+(i+1)+"排"+(j+1)+"列快递");
    164.                     printExpress(es[i][j]);
    165.                 }
    166.             }
    167.         }
    168.         if (count == 0){
    169.             System.out.println("暂无快递信息");
    170.         }
    171.     }
    173.     /**
    174.      * 当查询快递无信息时的提示语
    175.      */
    176.     public void printNull(){
    177.         System.out.println("快递不存在，请确认输入是否正确");
    178.     }
    180.     /**
    181.      * 提示用户取件成功
    182.      * @param e
    183.      */
    184.     public void printCode(Express e){
    185.         System.out.println("快递取件码为："+e.getCode());
    186.     }
    188.     /**
    189.      * 快递员存储时存储重复的提示语
    190.      */
    191.     public void expressExist(){
    192.         System.out.println("快递单号已存在");
    193.     }
    195.     /**
    196.      * 操作成功提示语
    197.      */
    198.     public void success(){
    199.         System.out.println("操作成功");
    200.     }
    202.     /**
    203.      * 取件人的菜单uMenu
    204.      * @return
    205.      */
    206.     public int uMenu(){
    207.         System.out.println("请输入取件码");
    208.         String code = input.nextLine();
    209.         int num = -1;
    210.         try{
    211.             //将用户输入的取件码，转换为int数据类型
    212.             num = Integer.parseInt(code);
    213.         }catch(NumberFormatException e){
    214.             System.out.println("请输入正确的取件码");
    215.             return uMenu();
    216.         }
    217.         //判断取件码
    218.         if(num<100000 || num>999999){
    219.             System.out.println("输入错误，请重新输入");
    220.             return uMenu();
    221.         }
    222.         return num;
    223.     }
    225. }