bean包：

    1. package com.javaoop.bean;
    3. import java.util.Objects;
    5. /**
    6.  * todo:添加作者以及创建时间，添加类的描述
    7.  * bean这个package中没有任何业务逻辑，所有属性全部私有，提供get,set方法，提供无参构造器的对象。
    8.  */
    9. public class Express {
    10.     //快递单号
    11.     private String number;
    12.     //快递公司
    13.     private String company;
    14.     //取件码
    15.     private int code;
    17.     public Express(String number, String company, int code) {
    18.         this.number = number;
    19.         this.company = company;
    20.         this.code = code;
    21.     }
    23.     @Override
    24.     public String toString() {
    25.         return "Express{" +
    26.                 "number='" + number + '\'' +
    27.                 ", company='" + company + '\'' +
    28.                 ", code=" + code +
    29.                 '}';
    30.     }
    32.     @Override
    33.     public boolean equals(Object o) {
    34.         if (this == o) return true;
    35.         if (o == null || getClass() != o.getClass()) return false;
    36.         Express express = (Express) o;
    37.         return Objects.equals(number, express.number);
    38.     }
    40.     @Override
    41.     public int hashCode() {
    42.         return Objects.hash(number);
    43.     }
    45.     public Express() {
    46.     }
    48.     public String getNumber() {
    49.         return number;
    50.     }
    52.     public void setNumber(String number) {
    53.         this.number = number;
    54.     }
    56.     public String getCompany() {
    57.         return company;
    58.     }
    60.     public void setCompany(String company) {
    61.         this.company = company;
    62.     }
    64.     public int getCode() {
    65.         return code;
    66.     }
    68.     public void setCode(int code) {
    69.         this.code = code;
    70.     }
    75. }

    DAO包：数据操作（data access object)，也就是MVC中的M（model）模块，提供数据存取的功能。

    1. package com.javaoop.dao;
    3. import com.javaoop.bean.Express;
    5. import java.util.Random;
    7. /**
    8.  * todo:添加作者以及创建时间，以及类的描述
    9.  * DAO stands for Data Access Object
    10.  */
    11. public class ExpressDao {
    12.     //创建一个10*10的快递柜
    13.     private  Express[][] data = new Express [10][];
    14.     //定义size作为当前已经存储的快递数量
    15.     private int size; //todo:创建一个init方法，通过构造函数调用init方法
    16.     {
    17.         for(int i=0;i<10;i++){
    18.             data[i] = new Express[10];
    19.         }
    20.     }
    22.     private Random random = new Random();//定义随机数
    23.     //快递员添加快递的操作
    24.     public boolean add(Express e){//todo:需要判断e是否为空。
    25.         if(size == 100){
    26.             return false;//当存储快递数为100时即快递柜无空位
    27.         }
    28.         //随机生成二维数组下标
    29.         int x = -1;
    30.         int y = -1;
    31.         while(true){
    32.             x = random.nextInt(10);//生成x，y的随机坐标
    33.             y = random.nextInt(10);
    34.             if(data[x][y] == null){
    35.                 //此位置无快递
    36.                 break;
    37.             }
    38.         }
    39.         //存入坐标
    40.         int code =randomCode();
    41.         e.setCode(code);
    42.         data[x][y] = e;
    43.         return true;
    44.     }
    46.     //生成六位数取件码 todo:需要改为多行注释
    47.     private int randomCode(){
    48.         //100000-999999 = 0~899999+100000
    49.         while(true){
    50.             int code = random.nextInt(900000) + 100000;
    51.             //如果查到了快递则继续生成新的取件码
    52.             Express e = findCode(code);
    53.             //如果没有查到，则返回生成的取件码，即取件码生成成功
    54.             if (e == null) {
    55.                 return code;
    56.             }
    57.         }
    58.     }
    60.     //查找单号-遍历法
    61.     public Express findNumber(String number){//todo:在一开始保证入参就是正确的，避免后置校验
    62.         Express e = new Express();
    63.         e.setNumber(number);
    64.         for(int i = 0 ;i<10;i++){
    65.             for(int j = 0;j<10;j++){
    66.                 if (data[i][j] != null)
    67.                     if (e.equals(data[i][j])){
    68.                         return data[i][j];
    69.                     }
    70.             }
    71.         }
    72.         return null;
    73.     }
    75.     //查找取件码-遍历法，小概率事件也需考虑（比如取件码重复）
    76.     public Express findCode(int code){
    77.         for(int i = 0 ;i<10;i++){
    78.             for(int j = 0;j<10;j++){
    79.                 if (data[i][j] != null)
    80.                     if (data[i][j].getCode() == code){
    81.                         return data[i][j];
    82.                     }
    83.             }
    84.         }
    85.         return null;
    86.     }
    88.     /**
    89.      * 实际上这个update的操作是多余的操作，为了MVC更圆润（演示数据库的实际操作）
    90.      * @param oldExpress
    91.      * @param newExpress
    92.      */
    93.     public void update(Express oldExpress,Express newExpress){
    94.         delete(oldExpress);
    95.         add(newExpress);
    96.     }
    98.     //删除快递
    99.     public void delete(Express e){
    100.         //命名循环为p
    101.         p:for(int i = 0 ;i<10;i++) {
    102.             for (int j = 0; j < 10; j++) {
    103.                 if (e.equals(data[i][j])) {
    104.                     data[i][j] = null;
    105.                     break p;
    106.                 }
    107.             }
    108.         }
    109.     }
    111.     //查找所有快递
    112.     public Express[][] findAll(){
    113.         return data;
    114.     }
    116. }

    main包：MVC中的C模块（controller），调度逻辑（根据视图接受到的用户输入内容，调度数据存储）

    1. package com.javaoop.main;
    3. import com.javaoop.bean.Express;
    4. import com.javaoop.dao.ExpressDao;
    5. import com.javaoop.view.Views;
    7. public class Main {
    8.     //初始化视图对象
    9.     private static Views v = new Views();
    10.     //初始化dao对象
    11.     private static ExpressDao dao = new ExpressDao();
    13.     public static void main(String[] args){
    14.         init();
    15.     }
    16.     //定义初始化方法
    17.     public static void init(){
    18.         //1.   欢迎
    19.         v.welcome();
    20.         m:while(true){
    21.             //2. 弹出身份选择菜单
    22.             int menu = v.menu();
    23.             switch (menu){
    24.                 case 0:
    25.                     break m;
    26.                 //主界面1选项：进入快递员界面
    27.                 case 1:
    28.                     cClient();
    29.                     break;
    30.                 //主界面2选项：进入用户界面
    31.                 case 2:
    32.                     uClient();
    33.                     break ;
    34.             }
    35.         }
    36.         v.bye();
    37.     }
    40.     //定义用户界面的调用逻辑 todo:修改注释
    41.     public static  void uClient(){//todo：判断code合理性
    42.         //获得用户输入的取件码
    43.         int code = v.uMenu();
    44.         //取出快递
    45.         Express e = dao.findCode(code);
    46.         if (e == null){
    47.             v.printNull();
    48.         }else{
    49.             v.success();
    50.             v.printExpress(e);
    51.         }
    52.     }
    54.     //定义快递员界面的调度逻辑
    55.     public static  void cClient(){
    56.         while(true){
    57.             int menu = v.cMenu();
    58.             switch(menu){
    59.                 case 0:
    60.                     return;
    61.                 case 1:{//提示输入快递信息
    62.                     Express e = v.insert();
    63.                     //查询快递单号是否已经存储
    64.                     Express e2 = dao.findNumber(e.getNumber());
    65.                     //存储快递
    66.                     if (e2 == null){
    67.                         dao.add(e);
    68.                         v.printExpress(e);
    69.                         break;
    70.                     }else{
    71.                         //单号重复
    72.                         v.expressExist();
    73.                     }
    74.                 }
    75.                     break;
    76.                 case 2:{//快递修改
    77.                     //1.提示输入快递信息
    78.                     String number = v.findByNumber();
    79.                     //2.查找数据
    80.                     Express e =dao.findNumber(number);//todo：findExpressByNumber，避免语义歧义
    81.                     Express e2 = e;
    82.                     //3. 打印快递信息
    83.                     if (e == null){
    84.                         v.printNull();
    86.                     }else{
    87.                         v.printExpress(e);
    88.                         //4. 提示修改
    89.                         v.update(e2);
    90.                         dao.update(e,e2);
    91.                         v.printExpress(e2);
    92.                     }
    93.                 }
    94.                     break;
    96.                 case 3:{//删除快递
    97.                     //1.输入快递单号并查找
    98.                     String number = v.findByNumber();
    99.                     //2.查找快递对象
    100.                     Express e = dao.findNumber(number);
    101.                     if (e == null){
    102.                         v.printNull();
    103.                     }else{
    104.                         v.printExpress(e);
    105.                         int type = v.delete();
    106.                         if(type == 1){
    107.                             dao.delete(e);
    108.                             v.success();
    109.                         }
    110.                     }
    111.                 }
    112.                     break;
    113.                 //查看所有
    114.                 case 4:{
    115.                     Express[][] date = dao.findAll();//todo：改为findAllExpress
    116.                     v.printAll(date);
    117.                 }
    118.                     break;
    120.             }
    121.         }
    122.     }
    124. }

    view包：V视图展示（欢迎，菜单，子菜单。。。）

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