尚硅谷_宋红康_Project2.pptx

    1. package com.atguigu.project;
    3. /*
    4. 该类封装客户的以下信息：
    5. String name ：客户姓名
    6. char gender  ：性别
    7. int age          ：年龄
    8. String phone：电话号码
    9. String email ：电子邮箱
    11.  */
    12. public class Customer {
    13.     private String name;
    14.     private char gender;
    15.     private int age;
    16.     private String phone;
    17.     private String email;
    19.     public Customer() {
    20.     }
    22.     public Customer(String name, char gender, int age, String phone, String email) {
    23.         this.name = name;
    24.         this.gender = gender;
    25.         this.age = age;
    26.         this.phone = phone;
    27.         this.email = email;
    28.     }
    30.     public String getName() {
    31.         return name;
    32.     }
    34.     public void setName(String name) {
    35.         this.name = name;
    36.     }
    38.     public char getGender() {
    39.         return gender;
    40.     }
    42.     public void setGender(char gender) {
    43.         this.gender = gender;
    44.     }
    46.     public int getAge() {
    47.         return age;
    48.     }
    50.     public void setAge(int age) {
    51.         this.age = age;
    52.     }
    54.     public String getPhone() {
    55.         return phone;
    56.     }
    58.     public void setPhone(String phone) {
    59.         this.phone = phone;
    60.     }
    62.     public String getEmail() {
    63.         return email;
    64.     }
    66.     public void setEmail(String email) {
    67.         this.email = email;
    68.     }
    69. }
    1. package com.atguigu.project;
    3. public class CustomerList {
    4.     private Customer[] customers;
    5.     private int total = 0;
    7.     public CustomerList() {
    9.     }
    11.     /**
    12.      * 用途：构造器，用来初始化customers数组
    13.      * 参数：totalCustomer：指定customers数组的最大空间
    14.      *
    15.      * @param totalCustomer 指定customers数组的最大空间
    16.      */
    17.     public CustomerList(int totalCustomer) {
    18.         customers = new Customer[totalCustomer];
    19.     }
    21.     /**
    22.      * 用途：将参数customer添加到数组中最后一个客户对象记录之后
    23.      * 参数：customer指定要添加的客户对象
    24.      * 返回：添加成功返回true；false表示数组已满，无法添加
    25.      *
    26.      * @param customer 指定要添加的客户对象
    27.      * @return 添加成功返回true；false表示数组已满，无法添加
    28.      */
    29.     public boolean addCustomer(Customer customer) {
    30.         if (total < customers.length) {
    31.             customers[total++] = customer;
    32.             return true;
    33.         } else {
    34.             return false;
    35.         }
    36.     }
    38.     /**
    39.      * 用途：用参数customer替换数组中由index指定的对象
    40.      * 参数：customer指定替换的新客户对象
    41.      * index指定所替换对象在数组中的位置，从0开始
    42.      * 返回：替换成功返回true；false表示索引无效，无法替换
    43.      *
    44.      * @param index 指定所替换对象在数组中的位置，从0开始
    45.      * @param cust  customer指定替换的新客户对象
    46.      * @return 替换成功返回true；false表示索引无效，无法替换
    47.      */
    48.     public boolean replaceCustomer(int index, Customer cust) {
    49.         if (index >= 0 && index < customers.length) {
    50.             customers[index] = cust;
    51.             return true;
    52.         } else {
    53.             return false;
    54.         }
    55.     }
    57.     /**
    58.      * 用途：从数组中删除参数index指定索引位置的客户对象记录
    59.      * 参数： index指定所删除对象在数组中的索引位置，从0开始
    60.      * 返回：删除成功返回true；false表示索引无效，无法删除
    61.      *
    62.      * @param index index指定所删除对象在数组中的索引位置，从0开始
    63.      * @return 删除成功返回true；false表示索引无效，无法删除
    64.      */
    65.     public boolean deleteCustomer(int index) {
    66.         if (index >= 0 && index < customers.length) {
    67.             customers[index] = null;
    68.             return true;
    69.         } else {
    70.             return false;
    71.         }
    72.     }
    74.     /**
    75.      * 用途：返回数组中记录的所有客户对象
    76.      * 返回： Customer[] 数组中包含了当前所有客户对象，该数组长度与对象个数相同。
    77.      *
    78.      * @return Customer[] 数组中包含了当前所有客户对象，该数组长度与对象个数相同。
    79.      */
    80.     public Customer[] getAllCustomers() {
    81.         return customers;
    82.     }
    84.     /**
    85.      * 用途：返回参数index指定索引位置的客户对象记录
    86.      * 参数： index指定所要获取的客户在数组中的索引位置，从0开始
    87.      * 返回：封装了客户信息的Customer对象
    88.      *
    89.      * @param index 指定所要获取的客户在数组中的索引位置，从0开始
    90.      * @return 封装了客户信息的Customer对象
    91.      */
    92.     public Customer getCustomer(int index) {
    93.         if (index >= 0 && index < customers.length) {
    95.             return customers[index];
    96.         } else {
    97.             System.out.println("索引有问题，反回第一个客户信息");
    98.             return customers[0];
    99.         }
    100.     }
    102.     public int getTotal() {
    103.         return this.total;
    104.     }
    107. }
    1. package com.atguigu.project;
    3. import java.util.Scanner;
    5. public class CustomerView {
    6.     CustomerList customerList = new CustomerList(10);
    7.     Scanner sc = new Scanner(System.in);
    9.     /**
    10.      * 用途：显示主菜单，响应用户输入，根据用户操作分别调用其他相应的成员方法（如addNewCustomer），以完成客户信息处理。
    11.      */
    12.     public void enterMainMenu() {
    13.         System.out.println("-----------------客户信息管理软件-----------------");
    14.         System.out.println("                  1 添 加 客 户");
    15.         System.out.println("                  2 修 改 客 户");
    16.         System.out.println("                  3 删 除 客 户");
    17.         System.out.println("                  4 客 户 列 表");
    18.         System.out.println("                  5 退       出");
    19.         System.out.print("                  请选择(1-5)：");
    20.     }
    22.     /**
    23.      *
    24.      */
    25.     private void addNewCustomer() {
    26.         System.out.println("---------------------添加客户---------------------");
    27.         Customer customer = new Customer();
    28.         System.out.print("姓名：");
    29.         customer.setName(sc.next());
    30.         System.out.print("性别：");
    31.         customer.setGender(sc.next().charAt(0));
    32.         System.out.print("年龄：");
    33.         customer.setAge(sc.nextInt());
    34.         System.out.print("电话：");
    35.         customer.setPhone(sc.next());
    36.         System.out.print("邮箱：");
    37.         customer.setEmail(sc.next());
    38.         customerList.addCustomer(customer);
    39.         System.out.println("---------------------添加完成---------------------");
    40.     }
    42.     private void modifyCustomer() {
    43.         System.out.println("---------------------修改客户---------------------");
    44.         System.out.print("请选择待修改客户编号(-1退出)：");
    45.         int choice = sc.nextInt()-1;
    46.         //返回目标类customerList.getCustomer(choice);
    47.         Customer customer = new Customer();
    48.         System.out.print("姓名（" + customerList.getCustomer(choice).getName() + "）：");
    49.         customer.setName(sc.next());
    50.         System.out.print("性别（" + customerList.getCustomer(choice).getGender() + "）：");
    51.         customer.setGender(sc.next().charAt(0));
    52.         System.out.print("年龄（" + customerList.getCustomer(choice).getAge() + "）：");
    53.         customer.setAge(sc.nextInt());
    54.         System.out.print("电话（" + customerList.getCustomer(choice).getPhone() + "）：");
    55.         customer.setPhone(sc.next());
    56.         System.out.print("邮箱（" + customerList.getCustomer(choice).getEmail() + "）：");
    57.         customer.setEmail(sc.next());
    58.         customerList.replaceCustomer(choice, customer);
    59.         System.out.println("---------------------添加完成---------------------");
    60.     }
    62.     private void deleteCustomer() {
    63.         System.out.println("---------------------删除客户---------------------");
    64.         System.out.print("请选择待删除客户编号(-1退出)：");
    65.         int choice = sc.nextInt();
    66.         System.out.println("确认是否删除(Y/N)：");
    67.         String flag = sc.next();
    68.         if (flag.toLowerCase().equals("y")) {
    69.             customerList.deleteCustomer(choice);
    70.         } else {
    71.             System.out.println("删除失败！！！");
    72.         }
    73.         System.out.println("---------------------删除完成---------------------");
    74.     }
    76.     private void listAllCustomers() {
    77.         System.out.println("---------------------------客户列表---------------------------");
    78.         System.out.println("编号    姓名        性别    年龄    电话                    邮箱");
    79.         //得到客户数组customerList.getAllCustomers();
    80.         for (int i = 0; i < customerList.getTotal(); i++) {
    81.             if (customerList.getCustomer(i) != null) {
    82.                 System.out.println(i + 1 + "\t\t" + customerList.getCustomer(i).getName() + "\t\t" + customerList.getCustomer(i).getGender()
    83.                         +"\t\t"+customerList.getCustomer(i).getAge()
    84.                         + "\t\t" + customerList.getCustomer(i).getPhone() + "\t\t\t\t" + customerList.getCustomer(i).getEmail());
    85.             } else {
    86.                 System.out.println(i + 1 + "\t" + "什么都没有");
    87.             }
    88.         }
    89.         System.out.println("-------------------------客户列表完成-------------------------\n");
    90.     }
    92.     public static void main(String[] args) {
    93.         Scanner sc = new Scanner(System.in);
    94.         CustomerView cv = new CustomerView();
    95.         label:
    96.         while (true){
    97.             cv.enterMainMenu();
    98.             int yourChoice=sc.nextInt();
    99.             switch (yourChoice){
    100.                 case 1:
    101.                     cv.addNewCustomer();
    102.                     break;
    103.                 case 2:
    104.                     cv.modifyCustomer();
    105.                     break;
    106.                 case 3:
    107.                     cv.deleteCustomer();
    108.                     break;
    109.                 case 4:
    110.                     cv.listAllCustomers();
    111.                     break;
    112.                 case 5:
    113.                     break label;
    114.                 default:
    115.                     System.out.println("输入有问题，请重新输入");
    116.                     break;
    117.             }
    118.         }
    119.     }
    120. }