Express:快递属性类

    1. import java.util.Objects;
    2. public class Express {
    3.     private String num; //快递单号    
    4.     private String company;//快递公司    
    5.     private  int code;//快递取件码
    6.     public Express() {
    7.     }
    8.     public Express(String num, String company, int code) {
    9.         this.num = num;        this.company = company;        this.code = code;    }
    10.     public void setNum(String num) {
    11.         this.num = num;    }
    12.     public void setCompany(String company) {
    13.         this.company = company;    }
    14.     public void setCode(int code) {
    15.         this.code = code;    }
    16.     public String getNum() {
    17.         return num;    }
    18.     public String getCompany() {
    19.         return company;    }
    20.     public int getCode() {
    21.         return code;    }
    22.     /*    在管理系统中，有两个值需要比较：
    23.     1.对于快递员来说，需要根据快递码是否相同来执行删除或修改快递。
    24.     2.对于用户来说，需要根据取件码是否相同来执行取件操作。
    25.     3.equals方法不能同时解决两个问题，但是可以先解决一个码的问题。
    26.      */
    27.     @Override    
    28.     public boolean equals(Object o) {
    29.         if (this == o) return true;        
    30.         if (o == null || getClass() != o.getClass()) 
    31.             return false;        
    32.         Express express = (Express) o;        
    33.         return Objects.equals(num, express.num);    
    34.     }
    35.     @Override    
    36.     public int hashCode() {
    37.         return Objects.hash(num);    
    38.     }
    39.     @Override    
    40.     public String toString() {
    41.         return "Experss{" +
    42.                 "num='" + num + '\'' +
    43.                 ", company='" + company + '\'' +
    44.                 ", code=" + code +
    45.                 '}';    }
    46. }

    Main:

    1. import java.util.List;
    3. public class Main {
    4.     private static Views views = new Views(); //初始化视图对象
    5.     private static ExpressDao dao = new ExpressDao(); //初始化dao对象
    6.     public static void main(String[] args) {
    7.         //1.欢迎
    8.         views.welcome();
    11.     m:    while (true) {
    12.             //2.弹出身份选择菜单
    13.             int menu = views.menu();
    14.             switch (menu) {
    15.                 case 0:
    16.                     break m;  //跳出m循环
    17.                 case 1:
    18.                     cClient(); //调用快递员的客户端
    19.                     break ;
    20.                 case 2:
    21.                     uClient();//调用用户的客户端 Client:客户端
    22.                     break ;
    25.             }
    27.         }
    29.         views.bye();
    30.     }
    32.     private static void uClient() {
    33.         //1.取件码获取
    34.        int code = views.uMenu();
    35.        //2.根据取件码取出快递
    36.         Express e = dao.findByCode(code);
    37.         if(e==null){
    38.             views.printNull();
    39.         }
    40.         else{
    41.             views.succeed();
    42.             views.printExpress(e);
    43.             dao.delete(e);
    44.         }
    45.     }
    47.     private static void cClient() {
    48.         while (true) {
    49.             int menu = views.cMenu();//快递员菜单
    50.             switch (menu) {
    51.                 case 0:
    52.                     return ;
    53.                 case 1: { //加入大括号，使得e成为局部对象，以便我们每个case都用一个对象名但不受到干扰
    54.                     /**
    55.                      * 快递录入
    56.                      */
    57.                     //1.提示输入快递信息
    58.                     Express e = views.insert(); //e是快递信息对象
    59.                     //2.此快递是否储存过
    60.                     Express e2 = dao.findByNumber(e.getNum());
    61.                     //3.存储快递
    62.                     if(e2==null){
    63.                         //单号未储存过，存入快递
    64.                         dao.Add(e);
    65.                         views.printExpress(e);//打印快递信息
    66.                     }
    67.                     else{
    68.                         //单号在快递柜中已存在
    69.                         views.expressExist();
    70.                     }
    73.                 }
    74.                     break;
    75.                 case 3:{
    76.                     /**
    77.                      * 快递修改
    78.                      */
    79.                     //1.提示输入快递信息
    80.                     String number = views.findByNumber();
    81.                     //2.查找数据
    82.                     Express e = dao.findByNumber(number);
    83.                     //3.打印快递信息
    84.                     if(e ==null){
    85.                         views.printNull();
    86.                     }
    87.                     else {
    88.                         views.printExpress(e); //打印快递信息
    89.                     }
    90.                     //4.提示修改
    91.                     views.update(e);
    92.                     dao.update(e,e); //这个update没什么意义
    93.                     views.printExpress(e); //打印修改后的快递信息
    94.                 }
    95.                     break;
    96.                 case 2:{
    97.                     /**
    98.                      * 删除
    99.                      */
    100.                     //1.输入快递单号
    101.                     String number = views.findByNumber();
    102.                     //2.查找快递对象
    103.                     Express e = dao.findByNumber(number);
    104.                     if(e==null ){
    105.                         views.printNull();
    106.                     }
    107.                     else {
    108.                         views.printExpress(e);
    109.                         int type = views.delete();
    110.                         if(type == 1){
    111.                             dao.delete(e);
    112.                             views.succeed();
    113.                         }
    115.                     }
    116.                 }
    117.                     break;
    118.                 case 4:{
    119.                     /**
    120.                      * 查看所有
    121.                      */
    122.                     List<Express> data = dao.findAll();
    123.                     views.printAll(data);
    125.                 }
    126.                     break;
    127.             }
    128.         }
    129.     }
    130. }

    ExpressDao:

    1. import java.util.ArrayList;
    2. import java.util.List;
    3. import java.util.Random;
    5. public class ExpressDao {
    6.     private ArrayList<Express> data = new ArrayList<>();//模拟一维快递柜
    7.     private int size; //当前储存快递数
    10.     private Random random = new Random(); //随机取件码对象
    12.     /**
    13.      * 用于存储快递
    14.      *
    15.      * @param e :快递信息对象(快递单号，快递公司)
    16.      * @return ：返回是否成功存储信息。
    17.      */
    18.     public boolean Add(Express e) {
    19.         if (size == 100) {  //如果快递柜满了，直接返回false给add函数，表示存储失败
    20.             return false;
    21.         }
    22.     A:    for (int i=0;i<data.size();i++){
    23.             if (data.get(i)==null){
    24.                 //此位置无快递
    25.                 break A;
    26.             }
    27.         }
    28.         // 2. 取件码
    29.         int code = randomCode();
    30.         e.setCode(code);
    31.         return data.add(e); //储存快递信息
    33.     }
    35.     /**
    36.      * 生成随机取件码
    37.      *
    38.      * @param
    39.      */
    41.     private int randomCode() {
    42.         while (true) { //如果取件码取不到快递，就会返回code,如果取件码取到了快递，继续循环
    43.             //六位数的随机码的正确范围应该是：100000-999999
    44.             int code = random.nextInt((900000) + 100000);
    45.             //范围应该是10000-(899999+100000)
    46.             Express e = findByCode(code);
    47.             if (e == null) {  //生成的取件码在已生成的取件码中不存在的
    48.                 return code;//生成取件码成功，返回取件码
    49.             }
    51.         }
    52.     }
    54.     /**
    55.      * 通过快递单号进行查询
    56.      */
    57.     public Express findByNumber(String number) {
    58.         //Express e = new Express();
    59.         //e.setNum(number);
    60.         for (Express express:data){
    61.             if (number.equals(express.getNum())){
    62.                 return express;
    63.             }
    64.         }
    65.         return null;
    66.     }
    68.     /**
    69.      * 根据取件码查询快递
    70.      *
    71.      * @param code 要查询的取件码
    72.      * @return 查询失败时返回null
    73.      */
    74.     //通过取件码领取快递
    75.     public Express findByCode(int code) {
    76.         for (Express express:data){
    77.             if (express!=null){
    78.                 if (express.getCode()==code){
    79.                     return express;
    80.                 }
    81.             }
    82.         }
    83.         return null;
    84.     }
    86.     /**
    87.      * 多余的操作，为了MVC更圆满
    88.      * @param oldexpress
    89.      * @param newexpress
    90.      */
    91.     //修改
    92.     //得到的数据：1.原单号2.查到的原对象3.用户修改的信息
    93.     //步骤：1.先查找到原单号。2.修改。3.把原单号的对象delete。4.重新存储(重新存储(即调用add(),并生成新的取件码)
    94.     public void update(Express oldexpress, Express newexpress) {
    95.         delete(oldexpress); //删除旧单号
    96.         Add(newexpress);//添加新单号
    97.     }
    99.     //删除
    100.     public boolean delete(Express e) {
    101.         return data.remove(e);
    102.     }
    104.     //返回所有快递
    105.     public List<Express> findAll() {
    106.         return data;
    107.     }
    108. }

    Views:

    1. import java.util.List;
    2. import java.util.Scanner;
    4. public class Views {
    5.     private Scanner input = new Scanner(System.in);
    7.     /**
    8.      * 欢迎
    9.      */
    10.     public void welcome(){
    11.         System.out.println("欢迎使用xxx快递管理系统");
    12.     }
    14.     /**
    15.      * 再见
    16.      */
    17.     public void bye(){
    18.         System.out.println("欢迎下次使用！");
    19.     }
    21.     /**
    22.      * 选择身份菜单
    23.      * @return
    24.      */
    25.     public int menu(){
    26.         System.out.println("请根据提示,输入功能序号:");
    27.         System.out.println("1:快递员");
    28.         System.out.println("2:普通用户");
    29.         System.out.println("0:退出");
    30.     /*
    31.         这里的代码逻辑，相较于nextInt优点在哪？
    32.         单思考这个方法内的逻辑，没有什么优点。
    33.         但是思考全局代码，是有优点：所有方法均使用nextLine，不会因为输入产生冲突，还可以更好的接受各种类型的数据。
    34.         1.nextLine()与其他next方法会有冲突，只能使用一个。
    35.         2.在其他视图的用户输入，其内容不仅仅是整型数字，还有可能是其他基本类型。
    36.         3.因此，我们统一使用nextLine()来接受用户的输入
    37.      */
    38.         String text = input.nextLine(); //接收一行数据
    39.         int num = -1;
    40.         try {
    41.             num = Integer.parseInt(text);
    42.         }
    43.         catch (NumberFormatException e){
    45.         }
    46.         if(num<0||num>2){
    47.             System.out.println("输入有误，请重新输入！");
    48.             return menu(); //重新调用menu，让他重新输入
    49.         }
    50.         return num;
    51.     }
    53.     /**
    54.      * 快递员菜单
    55.      */
    56.     public  int cMenu(){
    57.         System.out.println("请根据提示,输入功能序号:");
    58.         System.out.println("1:快递录入");
    59.         System.out.println("2:快递删除");
    60.         System.out.println("3:快递修改");
    61.         System.out.println("4:查看所有快递");
    62.         System.out.println("0:返回上级目录");
    64.         String text = input.nextLine(); //接收一行数据
    65.         int num = -1;
    66.         try {
    67.             num = Integer.parseInt(text);
    68.         }
    69.         catch (NumberFormatException e){
    71.         }
    72.         if(num<0||num>4){
    73.             System.out.println("输入有误，请重新输入！");
    74.             return cMenu(); //重新调用cmenu，让他重新输入
    75.         }
    76.         return num;
    77.     }
    79.     /**
    80.      * 快递员录入快递
    81.      * @return :包含了快递单号和快递公司的快递对象。
    82.      */
    83.     public Express insert() {  //这里的Experss表示函数返回值是Experss对象类型
    84.         System.out.println("请根据提示，输入快递信息:");
    85.         System.out.println("请输入快递单号:");
    86.         String number = input.nextLine();
    87.         System.out.println("请输入快递公司:");
    88.         String company = input.nextLine();
    89.         Express e = new Express();
    90.         e.setCompany(company);
    91.         e.setNum(number);
    92.         return e;
    93.     }
    95.     /**
    96.      * 提示用户输入快递单号
    97.      * @return
    98.      */
    99.     //编写查询单号的方法，以便重复利用
    100.     public String findByNumber(){
    101.         System.out.println("请根据提示，输入快递信息:");
    102.         System.out.println("请输入要操作的快递单号:");
    103.         String number = input.nextLine();
    104.         return  number;
    106.     }
    108.     /**
    109.      * 显示快递信息
    110.      * @param e
    111.      */
    112.     //编写打印快递信息的方法,以便重复利用,给予用户确认输入信息是否有误。
    113.     public void printExpress(Express e){
    114.         System.out.println("快递信息如下：");
    115.         System.out.println("快递公司:"+e.getCompany()+",快递单号:"+e.getNum()+",取件码:"+e.getCode());
    116.     }
    118.     /**
    119.      * 修改快递信息
    120.      * @param e
    121.      */
    122.     public  void update(Express e){
    123.         System.out.println("请根据提示，输入新的快递单号:");
    124.          String number2 = input.nextLine();
    125.         System.out.println("请输入新的快递公司:");
    126.         String company = input.nextLine();
    127.         e.setNum(number2); //修改快递单号
    128.         e.setCompany(company); //修改快递公司
    130.     }
    132.     /**
    133.      * 询问是否删除快递信息
    134.      * @return  1表示确认，2表示取消操作
    135.      */
    136.     public int delete(){
    137.         System.out.println("是否确认删除 y/n?");
    138.         System.out.println("1:确认删除");
    139.         System.out.println("2:取消操作");
    140.         String text = input.nextLine();
    141.         int num = -1;
    142.         try {
    143.             num = Integer.parseInt(text);
    144.         }
    145.         catch (NumberFormatException e){
    147.         }
    148.         if(num<1||num>2){
    149.             System.out.println("输入有误，请重新输入！");
    150.             return delete(); //重新调用delete，让他重新输入
    151.         }
    152.         return num;
    153.     }
    155.     /**
    156.      * 给定数组快递信息，遍历显示
    157.      * @return
    158.      */
    159.     public void printAll(List<Express> data){
    160.         int count = 0;
    161.         for (Express express:data){
    162.             printExpress(express);
    163.         }
    164.         if(count==0){
    165.             System.out.println("暂无快递信息");
    166.         }
    167.     }
    169.     /**
    170.      * 用户菜单
    171.      */
    172.     public int uMenu(){
    173.         System.out.println("请根据提示，进行取件：");
    174.         System.out.println("请输入您的取件码:");
    175.         String code = input.nextLine(); //这个取件码要return的，但是return接收的类型是Int,所以要转一下星。
    176.         int num = -1;
    177.         try {
    178.             num = Integer.parseInt(code);
    179.         }
    180.         catch (NumberFormatException e){
    182.         }
    183.         if(num<100000||num>999999){  //此判断条件是确保输入的是6位数
    184.             System.out.println("输入有误，请重新输入！");
    185.             return uMenu(); //重新调用umenu，让他重新输入
    186.         }
    187.         return num;
    188.     }
    190.     public void expressExist(){
    191.         System.out.println("此单号在快递柜中已存在，请勿重复存储");
    192.     }
    194.     public void printNull(){
    195.         System.out.println("快递不存在，请检查您的输入");
    196.     }
    198.     public void printcode(Express e){
    199.         System.out.println("快递的取件码为:"+e.getCode());
    201.     }
    203.     public void succeed(){
    204.         System.out.println("操作成功");
    205.     }
    206. }