客户管理信息软件

参考视频(p248-p259)

{bilibili bvid=”1Kb411W75N” page=”248”/}

CustomerView 主模块,菜单显示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
package com.atguigu.p2.ui;

import com.atguigu.p2.bean.Customer;
import com.atguigu.p2.service.CustomerList;
import com.atguigu.p2.util.CMUtility;

/**
* @program: project12
* @description: 主模块,菜单显示,处理用户操作
* @author: kkx
* @create: 2021-12-28 17:12
**/
public class CustomerView {
private CustomerList customerList = new CustomerList(10);

public CustomerView(){
//默认有一个
Customer customer = new Customer("王涛", '男', 23, "13212341234", "wt@gmail.com");
customerList.addCustomer(customer);
}
/**
* @Description: 《显示客户信息管理软件》界面的方法
* @Author: kkx
* @Date: 2022/1/4
* @Param: []
* @return: void
*/
public void enterMainMenu(){
boolean isFlag = true;

while (isFlag){
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 退 出\n");
System.out.print(" 请选择(1-5):");

char menu = CMUtility.readMenuSelection();

switch (menu){
case '1':
addNewCustomer();
break;
case '2':
modifyCustomer();
break;
case '3':
deleteCustomer();
break;
case '4':
listAllCustomers();
break;
case '5':
System.out.print
("确认是否退出(Y/N):");
char isExit = CMUtility.readConfirmSelection();
if (isExit == 'Y') {
isFlag = false;
}
break;
}
}
}

/**
* @Description: 添加客户的操作
* @Author: kkx
* @Date: 2022/1/4
* @Param: []
* @return: void
*/
private void addNewCustomer(){
System.out.println("---------------------添加客户---------------------");
System.out.print("姓名:");
String name = CMUtility.readString(10);
System.out.print("性别:");
char gender = CMUtility.readChar();
System.out.print("年龄:");
int age = CMUtility.readInt();
System.out.print("电话:");
String phone = CMUtility.readString(13);
System.out.print("邮箱:");
String email = CMUtility.readString(30);

//包装
Customer customer = new Customer(name, gender, age, phone, email);
boolean isSuccess = customerList.addCustomer(customer);
if (isSuccess){
System.out.println("---------------------添加完成---------------------");
}else {
System.out.println("-------------------客户目录已满,添加失败---------------");
}
}

/**
* @Description: 修改客户的操作
* @Author: kkx
* @Date: 2022/1/5
* @Param: []
* @return: void
*/
private void modifyCustomer(){
System.out.println("---------------------修改客户---------------------");
//这两个放外面是因为后面在循环外要调用
int number;
Customer cust;

for (;;){
System.out.print("请选择待修改客户编号(-1退出):");
number = CMUtility.readInt();
if (number == -1){
return;
}
cust = customerList.getCustomer(number - 1);
if (cust == null){
System.out.println("无法找到指定客户!");
}else {
break;
}
}
//修改客户信息
System.out.print("姓名(" + cust.getName() + "):");
String name = CMUtility.readString(10, 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(13, cust.getPhone());
System.out.print("邮箱(" + cust.getEmail() + "):");
String email = CMUtility.readString(30, cust.getEmail());

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

boolean isReplaced = customerList.replaceCustomer(number - 1, newCust);
if (isReplaced){
System.out.println("---------------------修改完成---------------------");
}else {
//没有机会执行
System.out.println("---------------------修改失败---------------------");
}
}

/**
* @Description: 删除客户的操作
* @Author: kkx
* @Date: 2022/1/5
* @Param: []
* @return: void
*/
private void deleteCustomer(){
System.out.println("---------------------删除客户---------------------");
int number;

for (;;){
System.out.print("请选择待删除客户编号(-1退出):");
number = CMUtility.readInt();
if (number == -1){
return;
}
Customer customer = customerList.getCustomer(number -1);
if (customer == null){
System.out.println("无法找到指定客户!");
}else {
break;
}
}
//找到了指定的客户,开始修改
System.out.print("确认是否删除(Y/N):");
char isDelete = CMUtility.readConfirmSelection();
if (isDelete == 'Y'){
boolean deleteSuccess = customerList.deleteCustomer(number - 1);
if (deleteSuccess){
System.out.println("---------------------删除完成---------------------");
}else {
//没有机会执行
System.out.println("---------------------删除失败---------------------");
}
}else {
return;
}
}

/**
* @Description: 显示客户列表的操作
* @Author: kkx
* @Date: 2022/1/4
* @Param: []
* @return: void
*/
private void listAllCustomers(){
System.out.println("---------------------------客户列表---------------------------\n");
int total = customerList.getTotal();
if (total == 0){
System.out.println("没有客户记录!");
}else {
System.out.println("编号\t姓名\t性别\t年龄\t电话\t\t邮箱");
Customer[] custs = customerList.getAllCustomers();
for (int i = 0; i < custs.length; i++) {
Customer cust = custs[i];
System.out.println((i + 1) + "\t" + "\t" + cust.getName() +
"\t" + cust.getGender() + "\t" + "\t" + cust.getAge() +
"\t" + "\t" + cust.getPhone() + "\t" + cust.getEmail());
}
}
System.out.println("-------------------------客户列表完成-------------------------");
}

public static void main(String[] args){
CustomerView view = new CustomerView();
view.enterMainMenu();
}
}

Customer 管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
package com.atguigu.p2.service;

import com.atguigu.p2.bean.Customer;

/**
* @program: project12
* @description: Customer管理
* @author: kkx
* @create: 2021-12-28 17:11
**/
public class CustomerList {
private Customer[] customers;
private int total; //记录存储的客户的个数

/**
* @Description: 构造器,用来初始化customers数组
* @Author: kkx
* @Date: 2021/12/28
* @Param: [totalCustomer] 指定customers数组的最大空间
* @return:
*/
public CustomerList(int totalCustomer){
customers = new Customer[totalCustomer];
}

/**
* @Description: 添加指定的客户到数组中
* @Author: kkx
* @Date: 2021/12/28
* @Param: [customer]
* @return: boolean 是否添加成功
*/
public boolean addCustomer(Customer customer){
//小于最大则可以添加
if (total < customers.length){
customers[total] = customer;
total++;
return true;
}
return false;
}

/**
* @Description: 修改指定索引位置上的客户信息
* @Author: kkx
* @Date: 2021/12/28
* @Param: [index, cust]
* @return: boolean 是否修改成功
*/
public boolean replaceCustomer(int index, Customer cust){
if (index < 0 || index >= total){
return false;
}
customers[index] = cust;
return true;
}

/**
* @Description: 删除指定索引位置上的客户信息
* @Author: kkx
* @Date: 2022/1/4
* @Param: [index]
* @return: boolean 是否删除成功
*/
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];
}
//这里先把最后那个指向null,total再--
customers[--total] = null;
return true;
}

/**
* @Description: 获取所有客户的客户信息
* @Author: kkx
* @Date: 2022/1/4
* @Param: []
* @return: com.atguigu.p2.bean.Customer[]
*/
public Customer[] getAllCustomers(){
Customer[] custs = new Customer[total];
for (int i = 0; i < total; i++) {
custs[i] = customers[i];
}
return custs;
}

/**
* @Description: 返回指定索引位置上的Customer
* @Author: kkx
* @Date: 2022/1/4
* @Param: [index]
* @return: 如果找到元素,则返回,如果没有找到,返回null
*/
public Customer getCustomer(int index){
if (index < 0 || index >= total){
return null;
}
return customers[index];
}

/**
* @Description: 获取存储的客户的数量
* @Author: kkx
* @Date: 2022/1/4
* @Param: []
* @return: int
*/
public int getTotal(){
return total;
}
}

Customer 类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
package com.atguigu.p2.bean;

/**
* @program: project12
* @description: Customer类
* @author: kkx
* @create: 2021-12-28 17:08
**/
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;
}
}

CMUtility 工具类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
package com.atguigu.p2.util;

/**
* @program: project12
* @description: CMUtility工具类
* @author: kkx
* @create: 2021-12-28 17:14
**/

import java.util.*;
/**
CMUtility工具类:
将不同的功能封装为方法,就是可以直接通过调用方法使用它的功能,而无需考虑具体的功能实现细节。
*/
public class CMUtility {
private static Scanner scanner = new Scanner(System.in);
/**
用于界面菜单的选择。该方法读取键盘,如果用户键入’1’-’5’中的任意字符,则方法返回。返回值为用户键入字符。
*/
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);
}
/**
从键盘读取一个字符,并将其作为方法的返回值。
如果用户不输入字符而直接回车,方法将以defaultValue 作为返回值。
*/
public static char readChar(char defaultValue) {
String str = readKeyBoard(1, true);
return (str.length() == 0) ? defaultValue : str.charAt(0);
}
/**
从键盘读取一个长度不超过2位的整数,并将其作为方法的返回值。
*/
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;
}
/**
从键盘读取一个长度不超过2位的整数,并将其作为方法的返回值。
如果用户不输入字符而直接回车,方法将以defaultValue 作为返回值。
*/
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;
}
/**
从键盘读取一个长度不超过limit的字符串,并将其作为方法的返回值。
*/
public static String readString(int limit) {
return readKeyBoard(limit, false);
}
/**
从键盘读取一个长度不超过limit的字符串,并将其作为方法的返回值。
如果用户不输入字符而直接回车,方法将以defaultValue 作为返回值。
*/
public static String readString(int limit, String defaultValue) {
String str = readKeyBoard(limit, true);
return str.equals("")? defaultValue : str;
}
/**
用于确认选择的输入。该方法从键盘读取‘Y’或’N’,并将其作为方法的返回值。
*/
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;
}
}