Java 基础语法——客户信息管理系统

目标

模拟实现一个基于文本界面的《客户信息管理软件》
进一步掌握编程技巧和调试技巧，熟悉面向对象编程
主要涉及以下知识点：
类和对象（属性、方法及构造器）
类的封装
引用数组
数组的插入、删除和替换
对象的聚集处理
多对象协同工作

需求说明

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

                        1 添 加 客 户
                        2 修 改 客 户
                        3 删 除 客 户
                        4 客 户 列 表
                        5 退           出

                        请选择(1-5)：_

每个客户的信息被保存在Customer对象中。
以一个Customer类型的数组来记录当前所有的客户
每次“添加客户”（菜单1）后，客户（Customer）对象被添加到数组中。
每次“修改客户”（菜单2）后，修改后的客户（Customer）对象替换数组中原对象。
每次“删除客户”（菜单3）后，客户（Customer）对象被从数组中清除。
执行“客户列表 ”（菜单4）时，将列出数组中所有客户的信息

“添加客户”的界面及操作过程如下所示：

				……
                   请选择(1-5)：1

---------------------添加客户---------------------
姓名：张三
性别：男
年龄：30
电话：010-56253825
邮箱：zhang@abc.com
---------------------添加完成---------------------

“修改客户”的界面及操作过程如下所示：

	“修改客户”的界面及操作过程如下所示：
				……
                   请选择(1-5)：2

---------------------修改客户---------------------
请选择待修改客户编号(-1退出)：1
姓名(张三)：<直接回车表示不修改>
性别(男)：
年龄(30)：
电话(010-56253825)：
邮箱(zhang@abc.com)：zsan@abc.com
---------------------修改完成---------------------

“删除客户”的界面及操作过程如下所示：

				……
                   请选择(1-5)：3

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

客户列表”的界面及操作过程如下所示：

				……
 				请选择(1-5)：4

---------------------------客户列表---------------------------
编号  姓名       性别    年龄   电话            邮箱
 1    张三       男      30     010-56253825   abc@email.com
 2    李四       女      23     010-56253825    lisi@ibm.com
 3    王芳       女      26     010-56253825   wang@163.com
-------------------------客户列表完成-------------------------

软件设计结构

该软件由以下三个模块组成：

CustomerView为主模块，负责菜单的显示和处理用户操作。
CustomerList为Customer对象的管理模块，内部用数组管理一组Customer对象，并提供相应的添加、修改、删除和获取方法，供CustomerView调用。
Customer为实体对象，用来封装客户信息。

Customer类的设计

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

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

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

CustomerList类的设计

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

Customer[] customers：用来保存客户对象的数组
int total = 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 CustomerList(int totalCustomer)
用途：构造器，用来初始化customers数组
参数：totalCustomer：指定customers数组的最大空间
public boolean addCustomer(Customer customer)
用途：将参数customer添加组中最后一个客户对象记录之后
参数：customer指定要添加的客户对象
返回：添加成功返回true；false表示数组已满，无法添加
public boolean replaceCustomer(int index, Customer cust)
用途：用参数customer替换数组中由index指定的对象
参数：customer指定替换的新客户对象
index指定所替换对象在数组中的位置
返回：替换成功返回true；false表示索引无效，无法替换

public CustomerList(int totalCustomer)
用途：构造器，用来初始化customers数组
参数：totalCustomer：指定customers数组的最大空间
public boolean addCustomer(Customer customer)
用途：将参数customer添加组中最后一个客户对象记录之后
参数：customer指定要添加的客户对象
返回：添加成功返回true；false表示数组已满，无法添加
public boolean replaceCustomer(int index, Customer cust)
用途：用参数customer替换数组中由index指定的对象
参数：customer指定替换的新客户对象
index指定所替换对象在数组中的位置
返回：替换成功返回true；false表示索引无效，无法替换

CustomerView类的设计

CustomerView为主模块，负责菜单的显示和处理用户操作
本类封装以下信息：
CustomerList customers = 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()方法以执行程序。

enterMainMenu()方法的活动图

键盘访问的实现

项目中提供了CMUtility.java类，可用来方便地实现键盘访问。
该类提供了以下静态方法：
public static char readMenuSelection()
用途：该方法读取键盘，如果用户键入’1’-’5’中的任意字符，则方法返回。返回值为用户键入字符。
public static char readChar() 和
public static char readChar(char defaultValue)
用途：这两个方法功能相同，均从键盘读取一个字符，并将其作为方法的返回值。
参数： defaultValue — 如果用户不输入字符而直接回车，方法将以defaultValue 作为返回值。（提示：此方法可在修改客户时调用）
public static int readInt() 和
public static int readInt(int defaultValue)
用途：这两个方法功能相同，均从键盘读取一个长度不超过2位的 整数，并将其作为方法的返回值。
参数： defaultValue — 如果用户不输入字符而直接回车，方法将以defaultValue 作为返回值。
public static String readString(int limit) 和
public static String readString(int limit, String defaultValue)
用途：这两个方法功能相同，均从键盘读取一个长度不超过limit的字符串，并将其作为方法的返回值。
参数：limit — 指定字符串的最大长度
defaultValue — 如果用户不输入字符而直接回车，方法将以defaultValue 作为返回值。
public static char readConfirmSelection() ：
用途：从键盘读取‘Y’或’N’，并将其作为方法的返回值。

设计思路

第1步 — 实现Customer类

1.按照设计要求编写Customer类，并编译
2.在Customer 类中临时添加一个main方法中，作为单元测试方法。
在方法中创建Customer对象，并调用对象的各个方法，以测试该类是否编写正确。

第2步 — 实现CustomerList类

1.按照设计要求编写CustomerList类，并编译
2.在CustomerList类中临时添加一个main方法中，作为单元测试方法。
3.在方法中创建CustomerList对象（最多存放5个客户对象），然后分别用模拟数据调用以下各个方法，以测试各方法是否编写正确：
addCustomer
replaceCustomer
deleteCustomer
getAllCustomers
getCustomer
4.进一步测试以下情况，以验证该类是否编写正确：
调用addCustomer方法，添加至5个以上客户对象时
当数组中客户对象数量为0时，仍然调用replaceCustomer方法替换对象
当数组中客户对象数量为0时，仍然调用deleteCustomer方法删除对象
对于replaceCustomer、 deleteCustomer和getCustomer的调用，当参数index的值无效时（例如-1或6）
getAllCustomers方法返回的数组长度是否与实际的客户对象数量一致

第3步 — 实现CustomerView类

1.按照设计要求编写CustomerView类，逐一实现各个方法，并编译
2.执行main方法中，测试以下功能：
主菜单显示及操作是否正确
“添加客户”操作是否正确，给用户的提示是否明确合理；测试当添加的客户总数超过10时，运行是否正确
“修改客户”操作是否正确，给用户的提示是否明确合理；
“删除客户”操作是否正确，给用户的提示是否明确合理；
“客户列表”操作是否正确，表格是否规整；
3.思考以下问题：
当软件退出时，所有客户信息便丢失了！运用什么手段可以将这些信息长久保存，以便在下一次运行软件时继续使用？

代码区

CMUtility.java

package com.heiyeqiutu.java;
import java.util.*;

public class CMUtility {
    private static Scanner scanner = new Scanner(System.in);
    
	public static char readMenuSelection() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1, false);
            c = str.charAt(0);
            if (c != '1' && c != '2' && 
                c != '3' && c != '4' && c != '5') {
                System.out.print("选择错误，请重新输入：");
            } else break;
        }
        return c;
    }

    public static char readChar() {
        String str = readKeyBoard(1, false);
        return str.charAt(0);
    }

    public static char readChar(char defaultValue) {
        String str = readKeyBoard(1, true);
        return (str.length() == 0) ? defaultValue : str.charAt(0);
    }

    public static int readInt() {
        int n;
        for (; ; ) {
            String str = readKeyBoard(2, false);
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }

    public static int readInt(int defaultValue) {
        int n;
        for (; ; ) {
            String str = readKeyBoard(2, true);
            if (str.equals("")) {
                return defaultValue;
            }

            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }

    public static String readString(int limit) {
        return readKeyBoard(limit, false);
    }

    public static String readString(int limit, String defaultValue) {
        String str = readKeyBoard(limit, true);
        return str.equals("")? defaultValue : str;
    }

    public static char readConfirmSelection() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1, false).toUpperCase();
            c = str.charAt(0);
            if (c == 'Y' || c == 'N') {
                break;
            } else {
                System.out.print("选择错误，请重新输入：");
            }
        }
        return c;
    }

    private static String readKeyBoard(int limit, boolean blankReturn) {
        String line = "";

        while (scanner.hasNextLine()) {
            line = scanner.nextLine();
            if (line.length() == 0) {
                if (blankReturn) return line;
                else continue;
            }

            if (line.length() < 1 || line.length() > limit) {
                System.out.print("输入长度（不大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
        }

        return line;
    }
}

Customer.java

package com.heiyeqiutu.java;

/**
 * Customer 实体类，用于封装客户信息
 * @author heiyeqiutu
 *
 */
public class Customer {

	private String name;
	private char gender;
	private int age;
	private String phone;
	private String email;

	public Customer() {
	}

	public Customer(String name, char gender, int age, String phone, String email) {
		this.name = name;
		this.gender = gender;
		this.age = age;
		this.phone = phone;
		this.email = email;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public char getGender() {
		return gender;
	}

	public void setGender(char gender) {
		this.gender = gender;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getPhone() {
		return phone;
	}

	public void setPhone(String phone) {
		this.phone = phone;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public String getDetails(){
		return name + "\t" + gender + "\t" + age + "\t" + phone + "\t" + email; 
	}
}

CustomerList.java

package heiyeqiutu.java;

/**
 * CustomerList 用于 Customer 对象的管理模块
 * @author heiyeqiutu
 *
 */
public class CustomerList {
	
	private Customer[] customers; //用于批量保存 Customer 对象  {new Customer(), null, null, null, null}
	private int total = 0; //用于记录数组中有效元素的个数
	
	/**
	 * 利用构造器初始化数组
	 * @param totalCustomer
	 */
	public CustomerList(int totalCustomer){
		customers = new Customer[totalCustomer];
	}

	/**
	 * 添加 Customer 对象到数组中
	 * @param customer
	 * @return
	 */
	public boolean addCustomer(Customer customer){
		if(total >= customers.length){//说明数组已满，无法添加
			return false;
		}
		
		customers[total++] = customer;
		return true;
	}
	
	/**
	 * 将数组中 index 位置的元素替换为 cust
	 * @param index : 索引值
	 * @param cust
	 * @return
	 */
	public boolean replaceCustomer(int index, Customer cust){
		if(index < 0 || index >= total){
			return false;
		}
		
		customers[index] = cust;
		return true;
	}
	
	/**
	 * 删除指定索引位置的 Customer 对象
	 * @param index ：索引值
	 * @return
	 */
	public boolean deleteCustomer(int index){
		if(index < 0 || index >= total){
			return false;
		}
		
		for(int i = index; i < total - 1; i++){//覆盖元素，若删除数组中最后一个元素，则不需要覆盖的方式
			customers[i] = customers[i+1];
		}
		
		customers[--total] = null;//最后一个有效元素赋值为null
		return true;
	}

	/**
	 * 获取所有有效元素的数组
	 * @return
	 */
	public Customer[] getAllCustomers(){
		Customer[] custs = new Customer[total];
		
		for(int i = 0; i < total; i++){
			custs[i] = customers[i];
		}
		
		return custs;
	}
	
	/**
	 * 获取 index 索引位置的 Customer 对象
	 * @param index ：索引值
	 * @return
	 */
	public Customer getCustomer(int index){
		if(index < 0 || index >= total){
			return null;
		}
		
		return customers[index];
	}

	/**
	 * 单元测试
	 * @param args
	 */
	public static void main(String[] args) {
		CustomerList cl = new CustomerList(10);
		
		//添加客户信息
		Customer customer = new Customer("张三", '男', 18, "010-123467", "zhangs@abc.com");
		boolean flag = cl.addCustomer(customer);
		if(flag){
			System.out.println("添加成功");
		}else{
			System.out.println("数组已满，无法添加");
		}
		
		Customer[] customers = cl.getAllCustomers();
		
		for (Customer cust : customers) {
			System.out.println(cust.getName() + "," + cust.getAge());
		}
	}
}
``
## CustomerView.java

```java
package com.heiyeqiutu.java;

/**
 * 程序的主模块，用于与用户进行交互
 * 
 * @author heiyeqiutu
 *
 */
public class CustomerView {

	private CustomerList cl = new CustomerList(10);

	/**
	 * 显示主菜单
	 */
	public void enterMainMenu() {
		boolean loopFlag = true;

		do {

			System.out.println("\n-----------------客户信息管理软件-----------------\n");
			System.out.println("                   1 添 加 客 户");
			System.out.println("                   2 修 改 客 户");
			System.out.println("                   3 删 除 客 户");
			System.out.println("                   4 客 户 列 表");
			System.out.println("                   5 退       出");
			System.out.println("");
			System.out.print("                   请选择(1-5)：");

			char key = CMUtility.readMenuSelection();

			switch (key) {
			case '1':
				// 添加客户
				addNewCustomer();
				break;
			case '2':
				// 修改客户
				modifyCustomer();
				break;
			case '3':
				// 删除客户
				deleteCustomer();
				break;
			case '4':
				// 客户列表
				listAllCustomers();
				break;
			case '5':
				// 退出
				System.out.print("确认是否退出(Y/N):");
				char yn = CMUtility.readConfirmSelection();
				if (yn == 'Y') {
					loopFlag = false;
				}
				break;
			}

		} while (loopFlag);
	}

	/**
	 * 添加客户
	 */
	private void addNewCustomer() {
		System.out.println("\n---------------------添加客户---------------------\n");

		System.out.print("姓名:");
		String name = CMUtility.readString(25);

		System.out.print("性别:");
		char gender = CMUtility.readChar();

		System.out.print("年龄:");
		int age = CMUtility.readInt();

		System.out.print("电话:");
		String phone = CMUtility.readString(30);

		System.out.print("邮箱:");
		String email = CMUtility.readString(30);

		// 将散列数据封装进 Customer 对象
		Customer cust = new Customer(name, gender, age, phone, email);

		// 调用 CustomerList 中的 addCustomer 添加客户信息
		boolean flag = cl.addCustomer(cust);

		if (flag) {
			System.out.println("---------------------添加完成---------------------");
		} else {
			System.out.println("---------------------数组已满，无法添加---------------------");
		}
	}

	/**
	 * 修改客户
	 */
	private void modifyCustomer() {
		System.out.println("\n---------------------修改客户---------------------\n");
		Customer cust = null;
		int num = 0;
		for (;;) {
			System.out.print("请选择待修改客户编号(-1退出)：");
			num = CMUtility.readInt();// num：客户编号

			if (num == -1) {
				return; // 用于结束当前方法
			}

			// 根据编号查询客户是否存在
			cust = cl.getCustomer(num - 1);

			if (cust == null) {
				System.out.println("无法找到指定客户！");
			} else {
				break;
			}
		}

		// 修改操作
		System.out.print("姓名(" + cust.getName() + "):");
		String name = CMUtility.readString(25, cust.getName());

		System.out.print("性别(" + cust.getGender() + "):");
		char gender = CMUtility.readChar(cust.getGender());

		System.out.print("年龄(" + cust.getAge() + "):");
		int age = CMUtility.readInt(cust.getAge());

		System.out.print("电话(" + cust.getPhone() + "):");
		String phone = CMUtility.readString(30, cust.getPhone());

		System.out.print("邮箱(" + cust.getEmail() + "):");
		String email = CMUtility.readString(30, cust.getEmail());

		Customer customer = new Customer(name, gender, age, phone, email);

		// 调用 CustomerList 中的修改方法
		boolean flag = cl.replaceCustomer(num - 1, customer);

		if (flag) {
			System.out.println("---------------------修改完成---------------------");
		} else {
			System.out.println("---------------------修改失败---------------------");
		}
	}

	/**
	 * 删除客户
	 */
	private void deleteCustomer() {
		System.out.println("---------------------删除客户---------------------");

		int num = 0;
		for (;;) {
			System.out.print("请选择待删除客户编号(-1退出)：");
			num = CMUtility.readInt();

			if (num == -1) {
				return;
			}

			Customer cust = cl.getCustomer(num - 1);

			if (cust == null) {
				System.out.println("无法找到指定客户！");
			} else {
				break;
			}
		}

		// 进行删除操作
		System.out.print("确认是否删除(Y/N)：");
		char yn = CMUtility.readConfirmSelection();

		if (yn == 'N') {
			return;
		}

		// 通过 CustomerList 中提供的 deleteCustomer 方法进行删除
		boolean flag = cl.deleteCustomer(num - 1);

		if (flag) {
			System.out.println("---------------------删除完成---------------------");
		} else {
			System.out.println("---------------------删除失败---------------------");
		}
	}

	/**
	 * 客户列表
	 */
	private void listAllCustomers() {
		System.out.println("---------------------------客户列表---------------------------");

		Customer[] customers = cl.getAllCustomers();

		if (customers.length == 0) {
			System.out.println("没有客户记录！");
		} else {
			System.out.println("编号\t姓名\t性别\t年龄\t电话\t\t邮箱");
		}

		for (int i = 0; i < customers.length; i++) {
			// System.out.println((i+1) + "\t" + customers[i].getName() + "\t" +
			// customers[i].getGender() );
			System.out.println((i + 1) + "\t" + customers[i].getDetails());
		}

		System.out.println("-------------------------客户列表完成-------------------------");
	}

	/**
	 * 程序的入口
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		CustomerView cv = new CustomerView();
		cv.enterMainMenu();
	}
}