目标

  • 模拟实现一个基于文本界面的《客户信息管理软件》
  • 进一步掌握编程技巧和调试技巧，熟悉面向对象编程
  • 主要涉及以下知识点：
    • 类结构的使用：属性、方法及构造器
    • 对象的创建与使用
    • 类的封装性
    • 声明和使用数组
    • 数组的插入、删除和替换
    • 关键字的使用：this


需求说明

模拟实现基于文本界面的《客户信息管理软件》。
该软件能够实现对客户对象的插入、修改和删除（用数组实现），并能够打印客户明细表。
项目采用分级菜单方式。

主菜单：

  1.          -----------------客户信息管理软件-----------------<br />                                     1添 加 客 户<br />                                     2修 改 客 户<br />                                     3删 除 客 户<br />                                     4客 户 列 表<br />                                     5 退           出<br />                                     请选择(1-5)：_
  • 每个客户的信息被保存在Customer对象中。
  • 以一个Customer类型的数组来记录当前所有的客户。
  • 每次“添加客户”（菜单1）后，客户（Customer）对象被添加到数组中。
  • 每次“修改客户”（菜单2）后，修改后的客户（Customer）对象替换数组中原对象。
  • 每次“删除客户”（菜单3）后，客户（Customer）对象被从数组中清除。
  • 执行“客户列表 ”（菜单4）时，将列出数组中所有客户的信息。


添加客户的界面：

……
请选择(1-5)：1
——————————-添加客户——————————-
姓名：佟刚
性别：男
年龄：35
电话：010-56253825
邮箱：tongtong@atguigu.com
——————————-添加完成——————————-

修改客户的界面：

……
请选择(1-5)：2
——————————-修改客户——————————-
请选择待修改客户编号(-1退出)：1
姓名(佟刚)：<__直接回车表示不修改__>
性别(男)：
年龄(35)：
电话(010-56253825)：
邮箱(tongtong@atguigu.com)：tongg@atguigu.com
——————————-修改完成——————————-

删除客户的界面：

……
请选择(1-5)：3
——————————-删除客户——————————-
请选择待删除客户编号(-1退出)：1
确认是否删除(Y/N)：y
——————————-删除完成——————————-

客户列表的界面：

……
请选择(1-5)：4
—————————————-客户列表—————————————-
编号 姓名 性别 年龄 电话 邮箱
1 佟刚 男 45 010-56253825 tong@abc.com
2 封捷 女 36 010-56253825 fengjie@ibm.com
3 雷丰阳 男 32 010-56253825 leify@163.com
————————————-客户列表完成————————————-

项目的搭建

Customer类的设计

Customer为实体类，用来封装客户信息
该类封装客户的以下信息：

  • String name ：客户姓名
  • char gender ：性别
  • int age ：年龄
  • String phone ：电话号码
  • String email ：电子邮箱

提供各属性的get/set方法
提供所需的构造器（可自行确定）

实现Customer类

  1. 按照设计要求编写Customer类，并编译。

  2. 在Customer 类中临时添加一个main方法中，作为单元测试方法。

    在方法中创建Customer对象，并调用对象的各个方法，以测试该类是否编写正确。

  1. package pers.zyx.CRM.bean;
  3. public class Customer {
  4.     private String name;
  5.     private char gender;
  6.     private int age;
  7.     private String phone;
  8.     private String email;
  10.     public Customer(){
  12.     }
  14.     public Customer(String name, char gender, int age, String phone, String email) {
  15.         this.name = name;
  16.         this.gender = gender;
  17.         this.age = age;
  18.         this.phone = phone;
  19.         this.email = email;
  20.     }
  22.     public String getName() {
  23.         return name;
  24.     }
  26.     public void setName(String name) {
  27.         this.name = name;
  28.     }
  30.     public char getGender() {
  31.         return gender;
  32.     }
  34.     public void setGender(char gender) {
  35.         this.gender = gender;
  36.     }
  38.     public int getAge() {
  39.         return age;
  40.     }
  42.     public void setAge(int age) {
  43.         this.age = age;
  44.     }
  46.     public String getPhone() {
  47.         return phone;
  48.     }
  50.     public void setPhone(String phone) {
  51.         this.phone = phone;
  52.     }
  54.     public String getEmail() {
  55.         return email;
  56.     }
  58.     public void setEmail(String email) {
  59.         this.email = email;
  60.     }
  61. }

CustomerList类的设计

CustomerList为Customer对象的管理模块，内部使用数组管理一组Customer对象
本类封装以下信息：

  • Customer[] customers：用来保存客户对象的数组
  • inttotal = 0 ：记录已保存客户对象的数量

该类至少提供以下构造器和方法：

  • public CustomerList(int totalCustomer)
  • public boolean addCustomer(Customer customer)
  • public boolean replaceCustomer(int index, Customer cust)
  • public boolean deleteCustomer(int index)
  • public Customer[] getAllCustomers()
  • public Customer getCustomer(int index)
  • public int getTotal()

public CustomerList(int totalCustomer)

  • 用途：构造器，用来初始化customers数组
  • 参数：totalCustomer：指定customers数组的最大空间

public boolean addCustomer(Customercustomer)

  • 用途：将参数customer添加到数组中最后一个客户对象记录之后
  • 参数：customer指定要添加的客户对象
  • 返回：添加成功返回true；false表示数组已满，无法添加

public boolean replaceCustomer(int index, Customer cust)

  • 用途：用参数customer替换数组中由index指定的对象

  • 参数：customer指定替换的新客户对象

    1.        index指定所替换对象在数组中的位置，从0开始

  • 返回：替换成功返回true；false表示索引无效，无法替换

public boolean deleteCustomer(int index)

  • 用途：从数组中删除参数index指定索引位置的客户对象记录
  • 参数： index指定所删除对象在数组中的索引位置，从0开始
  • 返回：删除成功返回true；false表示索引无效，无法删除

public Customer[] getAllCustomers()

  • 用途：返回数组中记录的所有客户对象
  • 返回： Customer[] 数组中包含了当前所有客户对象，该数组长度与对象个数相同。

public Customer getCustomer(int index)

  • 用途：返回参数index指定索引位置的客户对象记录
  • 参数： index指定所要获取的客户在数组中的索引位置，从0开始
  • 返回：封装了客户信息的Customer对象


实现CustomerList类

  1. 按照设计要求编写CustomerList类，并编译
  2. 在CustomerList类中临时添加一个main方法中，作为单元测试方法。
  3. 在方法中创建CustomerList对象（最多存放5个客户对象），然后分别用模拟数据调用以下各个方法，以测试各方法是否编写正确：
  • addCustomer()
  • replaceCustomer()
  • deleteCustomer()
  • getAllCustomers()
  • getCustomer()
  • getTotal()


  1. package pers.zyx.CRM.service;
  3. import pers.zyx.CRM.bean.Customer;
  5. public class CustomerList {
  6.     private Customer[] customers;
  7.     private int total = 0;
  9.     public CustomerList(int totalCustomer){
  10.         customers = new Customer[totalCustomer];
  11.     }
  13.     public boolean addCustomer(Customer customer){
  14.         if(total >= customers.length){
  15.             return false;
  16.         }else{
  17.             customers[total++] = customer;
  18.             return true;
  19.         }
  20.     }
  21.     public boolean replaceCustomer(int index, Customer cust){
  22.         if(index >= total || index < 0){
  23.             return false;
  24.         }else{
  25.             customers[index] = cust;
  26.             return true;
  27.         }
  28.     }
  29.     public boolean deleteCustomer(int index){
  30.         if(index >= total || index < 0){
  31.             return false;
  32.         }else{
  33.             for(int i = index ; i < total - 1 ; i ++ ){
  34.                 customers[i] = customers[i + 1];
  35.             }
  36.             customers[total--] = null;
  37.             return true;
  38.         }
  39.     }
  40.     public Customer[] getAllCustomers(){
  41.         Customer[] custs = new Customer[total];
  42.         for(int i = 0 ; i < total ; i ++ ){
  43.             custs[i] = customers[i];
  44.         }
  45.         return custs;
  46.     }
  47.     public Customer getCustomer(int index){
  48.         if(index < 0 || index >= total){
  49.             return null;
  50.         }else{
  51.             return customers[index];
  52.         }
  53.     }
  55.     public int getTotal(){
  56.         return total;
  57.     }
  58. }


CustomerView类的设计

CustomerView为主模块，负责菜单的显示和处理用户操作
本类封装以下信息：

  • CustomerList customerList = new CustomerList(10);
  • 创建最大包含10个客户对象的CustomerList 对象，供以下各成员方法使用。

该类至少提供以下方法：

  • public void enterMainMenu()
  • private void addNewCustomer()
  • private void modifyCustomer()
  • private void deleteCustomer()
  • private void listAllCustomers()
  • public static void main(String[] args)

public void enterMainMenu()

  • 用途：显示主菜单，响应用户输入，根据用户操作分别调用其他相应的成员方法（如addNewCustomer），以完成客户信息处理。

private void addNewCustomer()
private void modifyCustomer()
private void deleteCustomer()
private void listAllCustomers()

  • 用途：这四个方法分别完成“添加客户”、“修改客户”、“删除客户”和“客户列表”等各菜单功能。
  • 这四个方法仅供enterMainMenu()方法调用。

public static void main(String[] args)

  • 用途：创建CustomerView实例，并调用enterMainMenu()方法以执行程序。

实现CustomerView类

  1. 按照设计要求编写CustomerView类，逐一实现各个方法，并编译
  2. 执行main方法中，测试以下功能：
    1. 主菜单显示及操作是否正确
    2. 添加客户 操作是否正确，给用户的提示是否明确合理；测试当添加的客户总数超过10时，运行是否正确
    3. 修改客户 操作是否正确，给用户的提示是否明确合理；
    4. 删除客户 操作是否正确，给用户的提示是否明确合理；
    5. 客户列表 操作是否正确，表格是否规整；


  1. package pers.zyx.CRM.view;
  3. import pers.zyx.CRM.bean.Customer;
  4. import pers.zyx.CRM.service.CustomerList;
  5. import pers.zyx.CRM.util.CMUtility;
  8. public class CustomerView {
  10.     private CustomerList customerList = new CustomerList(10);
  12.     public CustomerView(){
  13.         Customer cust = new Customer("马云",'男',25,"66776677","mayun@gmail.com");
  14.         customerList.addCustomer(cust);
  15.     }
  17.     public void enterMainMenu(){
  19.         boolean isFlag = true;
  20.         while(isFlag){
  21.             System.out.println("\n-----------------客户信息管理软件-----------------\n");
  22.             System.out.println("                   1 添 加 客 户");
  23.             System.out.println("                   2 修 改 客 户");
  24.             System.out.println("                   3 删 除 客 户");
  25.             System.out.println("                   4 客 户 列 表");
  26.             System.out.println("                   5 退       出\n");
  27.             System.out.print("                   请选择(1-5)：");
  29.             char menu = CMUtility.readMenuSelection();
  30.             switch (menu){
  31.                 case '1':
  32.                     addNewCustomer();
  33.                     break;
  34.                 case '2':
  35.                     modifyCustomer();
  36.                     break;
  37.                 case '3':
  38.                     deleteCustomer();
  39.                     break;
  40.                 case '4':
  41.                     listAllCustomers();
  42.                     break;
  43.                 case '5':
  44.                     System.out.println("确认是否退出(Y|N)");
  45.                     char isExit = CMUtility.readConfirmSelection();
  46.                     if(isExit == 'Y'){
  47.                         isFlag = false;
  48.                     }
  49.             }
  51.         }
  53.     }
  54.     private void addNewCustomer(){
  55.         System.out.println("---------------------添加客户---------------------");
  56.         System.out.print("姓名：");
  57.         String name = CMUtility.readString(4);
  58.         System.out.print("性别：");
  59.         char gender = CMUtility.readChar();
  60.         System.out.print("年龄：");
  61.         int age = CMUtility.readInt();
  62.         System.out.print("电话：");
  63.         String phone = CMUtility.readString(15);
  64.         System.out.print("邮箱：");
  65.         String email = CMUtility.readString(15);
  67.         Customer customer = new Customer(name,gender,age,phone,email);
  68.         boolean flag = customerList.addCustomer(customer);
  69.         if(flag == true){
  70.             System.out.println("---------------------添加完成---------------------");
  71.         }else{
  72.             System.out.println("---------------------添加失败---------------------");
  73.         }
  74.     }
  76.     private void modifyCustomer(){
  77.         System.out.println("---------------------修改客户---------------------");
  78.         Customer cust;
  79.         int index;
  80.         for( ; ; ){
  81.             System.out.print("请选择待修改客户编号(-1退出)：");
  82.             index = CMUtility.readInt();
  83.             if(index == -1) {
  84.                 return;
  85.             }
  87.             cust = customerList.getCustomer(index - 1);
  88.             if(cust == null){
  89.                 System.out.println("无法找到指定客户！");
  90.             }else {
  91.                 break;
  92.             }
  93.         }
  94.         System.out.print("姓名(" + cust.getName() + ")：");
  95.         String name = CMUtility.readString(4, cust.getName());
  97.         System.out.print("性别(" + cust.getGender() + ")：");
  98.         char gender = CMUtility.readChar(cust.getGender());
  100.         System.out.print("年龄(" + cust.getAge() + ")：");
  101.         int age = CMUtility.readInt(cust.getAge());
  103.         System.out.print("电话(" + cust.getPhone() + ")：");
  104.         String phone = CMUtility.readString(15, cust.getPhone());
  106.         System.out.print("邮箱(" + cust.getEmail() + ")：");
  107.         String email = CMUtility.readString(15, cust.getEmail());
  109.         cust = new Customer(name, gender, age, phone, email);
  110.         boolean isReplace = customerList.replaceCustomer(index - 1, cust);
  112.         if (isReplace) {
  113.             System.out
  114.                     .println("---------------------修改完成---------------------");
  115.         } else {
  116.             System.out.println("----------无法找到指定客户,修改失败--------------");
  117.         }
  118.     }
  120.     private void deleteCustomer(){
  121.         System.out.println("---------------------删除客户---------------------");
  122.         int index;
  123.         Customer cust;
  124.         for (;;) {
  125.             System.out.print("请选择待删除客户编号(-1退出)：");
  126.             index = CMUtility.readInt();
  127.             if (index == -1) {
  128.                 return;
  129.             }
  131.             cust = customerList.getCustomer(index - 1);
  132.             if (cust == null) {
  133.                 System.out.println("无法找到指定客户！");
  134.             } else
  135.                 break;
  136.         }
  138.         System.out.print("确认是否删除(Y|N)：");
  139.         char yn = CMUtility.readConfirmSelection();
  140.         if (yn == 'N')
  141.             return;
  143.         boolean isDelete = customerList.deleteCustomer(index - 1);
  144.         if (isDelete) {
  145.             System.out.println("---------------------删除完成---------------------");
  146.         } else {
  147.             System.out.println("----------无法找到指定客户,删除失败--------------");
  148.         }
  150.     }
  151.     private void listAllCustomers(){
  152.         System.out.println("---------------------添加客户---------------------");
  153.         int total = customerList.getTotal();
  154.         if(total == 0){
  155.             System.out.println("没有客户记录");
  156.         }else {
  157.             System.out.println("编号\t姓名\t性别\t年龄\t\t电话\t\t邮箱");
  158.             Customer[] custs = customerList.getAllCustomers();
  159.             for(int i = 0 ; i < custs.length ; i ++ ){
  160.                 Customer cust = custs[i];
  161.                 System.out.println((i + 1) + "\t" + cust.getName() + "\t" + cust.getAge()+ "\t" + cust.getGender() + "\t" + cust.getPhone() + "\t" +
  162.                         cust.getEmail());
  163.             }
  164.         }
  165.         System.out.println("------------------客户列表加载完毕------------------");
  168.     }
  169.     public static void main(String[] args){
  170.         CustomerView cView = new CustomerView();
  171.         cView.enterMainMenu();
  172.     }
  173. }


思考

当软件退出时，所有客户信息便丢失了！运用什么手段可以将这些信息长久保存，以便在下一次运行软件时继续使用？

参考