项目三_开发团队调度软件

目标

模拟实现一个基于文本界面的《开发团队调度软件》
熟悉Java面向对象的高级特性,进一步掌握编程技巧和调试技巧
主要涉及以下知识点

  • 类的继承性和多态性
  • 对象的值传递、接口
  • static和final修饰符
  • 特殊类的使用:包装类、抽象类、内部类
  • 异常处理

需求说明

该软件实现以下功能:

  • 软件启动时,根据给定的数据创建公司部分成员列表(数组)
  • 根据菜单提示,基于现有的公司成员,组建一个开发团队以开发一个新的项目
  • 组建过程包括将成员插入到团队中,或从团队中删除某成员,还可以列出团队中现有成员的列表开发团队成员包括架构师、设计师和程序员

本软件采用单级菜单方式工作。当软件运行时,主界面显示公司成员的列表,如下:

1
2
3
4
5
6
7
8
9
10
11
12

-------------------------------------开发团队调度软件--------------------------------------

ID 姓名 年龄 工资 职位 状态 奖金 股票 领用设备
1 马 云 22 3000.0
2 马化腾 32 18000.0 架构师 FREE 15000.0 2000 联想T4(6000.0)
3 李彦宏 23 7000.0 程序员 FREE 戴尔(NEC17寸)
4 刘强东 24 7300.0 程序员 FREE 戴尔(三星 17寸)
5 雷军 28 10000.0 设计师 FREE 5000.0 佳能 2900(激光)
……
----------------------------------------------------------------------------------------------
1-团队列表 2-添加团队成员 3-删除团队成员 4-退出 请选择(1-4): _

当选择“添加团队成员”菜单时,将执行从列表中添加指定(通过ID)成员到开发团队的功能:

1
2
3
4
5
6
1-团队列表  2-添加团队成员  3-删除团队成员  4-退出   请选择(1-4):2

---------------------添加成员---------------------
请输入要添加的员工ID:2
添加成功
按回车键继续...

添加成功后,按回车键将重新显示主界面。
开发团队人员组成要求

  • 最多一名架构师
  • 最多两名设计师
  • 最多三名程序员

如果添加操作因某种原因失败,将显示类似以下信息(失败原因视具体原因而不同):

1
2
3
4
5
6
1-团队列表  2-添加团队成员  3-删除团队成员 4-退出   请选择(1-4):2

---------------------添加成员---------------------
请输入要添加的员工ID:2
添加失败,原因:该员工已是某团队成员
按回车键继续...

失败信息包含以下几种

  • 成员已满,无法添加
  • 该成员不是开发人员,无法添加
  • 该员工已在本开发团队中
  • 该员工已是某团队成员
  • 该员正在休假,无法添加
  • 团队中至多只能有一名架构师
  • 团队中至多只能有两名设计师
  • 团队中至多只能有三名程序员

当选择“删除团队成员”菜单时,将执行从开发团队中删除指定(通过TeamID)成员的功能:

1
2
3
4
5
6
7
1-团队列表  2-添加团队成员  3-删除团队成员 4-退出   请选择(1-4):3

---------------------删除成员---------------------
请输入要删除员工的TID:1
确认是否删除(Y/N):y
删除成功
按回车键继续...

删除成功后,按回车键将重新显示主界面。

当选择“团队列表”菜单时,将列出开发团队中的现有成员,例如:

1
2
3
4
5
6
7
8
9
10
1-团队列表  2-添加团队成员  3-删除团队成员 4-退出   请选择(1-4):1

--------------------团队成员列表---------------------

TDI/ID 姓名 年龄 工资 职位 奖金 股票
2/4 刘强东 24 7300.0 程序员
3/2 马化腾 32 18000.0 架构师 15000.0 2000
4/6 任志强 22 6800.0 程序员
5/12 杨致远 27 600.0 设计师 4800.0
-----------------------------------------------------

软件设计结构

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

  • com.atguigu.team.view模块为主控模块,负责菜单的显示和处理用户操作
  • com.atguigu.team.service模块为实体对象(Employee及其子类如程序员等)的管理模块, NameListService和TeamService类分别用各自的数组来管理公司员工和开发团队成员对象
  • domain模块为Employee及其子类等JavaBean类所在的包
  • com.atguigu.team.domain模块中包含了所有实体类:
  • 其中程序员(Programmer)及其子类,均会领用某种电子设备(Equipment)。

第1步

创建项目基本组件

  1. 完成以下工作:
  • 创建TeamSchedule项目
  • 按照设计要求,创建所有包
  • 将项目提供的几个类复制到相应的包中(view包中:TSUtility.java; service包中:Data.java)
  1. 按照设计要求,在com.atguigu.team.domain包中,创建Equipment接口及其各实现子类代码
  2. 按照设计要求,在com.atguigu.team.domain包中,创建Employee类及其各子类代码
  3. 检验代码的正确性

键盘访问的实现

  • 项目view包中提供了TSUtility.java类,可用来方便地实现键盘访问。
  • 该类提供了以下静态方法:
    • public static char readMenuSelection()用途:该方法读取键盘,如果用户键入’1’-’4’中的任意字符,则方法返回。返回值为用户键入字符。
    • public static void readReturn()用途:该方法提示并等待,直到用户按回车键后返回。
    • public static int readInt() 用途:该方法从键盘读取一个长度不超过2位的整数,并将其作为方法的返回值。
    • public static char readConfirmSelection() :用途:从键盘读取‘Y’或’N’,并将其作为方法的返回值。

Equipment接口及其实现子类的设计


说明:

  • model 表示机器的型号
  • display 表示显示器名称
  • type 表示机器的类型
    根据需要提供各属性的get/set方法以及重载构造器,实现类实现接口的方法,返回各自属性的信息。

Equipment.java

1
2
3
4
5
package com.javami.team.domain;

public interface Equipment {
public String getDescription();
}

PC.java

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
package com.javami.team.domain;

public class PC implements Equipment{
private String model;// 机器型号
private String display;// 显示器名称

public PC() {
super();
}

public String getModel() {
return model;
}

public void setModel(String model) {
this.model = model;
}

public String getDisplay() {
return display;
}

public void setDisplay(String display) {
this.display = display;
}

public PC(String model, String display) {
super();
this.model = model;
this.display = display;
}

@Override
public String getDescription() {
return model + "(" + display + ")";
}

}

NoteBook.java

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
package com.javami.team.domain;

public class NoteBook implements Equipment{
private String model;//机器型号
private double price;//价格

public NoteBook() {
super();
}

public NoteBook(String model, double price) {
super();
this.model = model;
this.price = price;
}

@Override
public String getDescription() {
return model + "(" + price + ")";
}

public String getModel() {
return model;
}

public void setModel(String model) {
this.model = model;
}

public double getPrice() {
return price;
}

public void setPrice(double price) {
this.price = price;
}
}

Printer.java

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
package com.javami.team.domain;

public class Printer implements Equipment{
private String name;// 机器型号
private String type;// 机器类型

public String getName() {
return name;
}

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

public String getType() {
return type;
}

public void setType(String type) {
this.type = type;
}

public Printer() {
super();
}

public Printer(String name, String type) {
super();
this.name = name;
this.type = type;
}

@Override
public String getDescription() {
return name + "(" + type + ")";
}
}

Employee类及其子类的设计

说明:

  • memberId 用来记录成员加入开发团队后在团队中的ID
  • Status是项目service包下自定义的类,声明三个对象属性,分别表示成员的状态。
    • FREE-空闲
    • BUSY-已加入开发团队
    • VOCATION-正在休假
  • equipment 表示该成员领用的设备
  • 可根据需要为类提供各属性的get/set方法以及重载构造器
  • bonus 表示奖金
  • stock 表示公司奖励的股票数量
    可根据需要为类提供各属性的get/set方法以及重载构造器

Employee.java

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
package com.javami.team.domain;

public class Employee<getDescription> {
private int id;
private String name;
private int age;
private double salary;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

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

public int getAge() {
return age;
}

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

public double getSalary() {
return salary;
}

public void setSalary(double salary) {
this.salary = salary;
}

public Employee(int id, String name, int age, double salary) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}

public Employee() {
}

public String getDetails(){
return id + "\t" + name + "\t" + age + "\t" + salary;
}

@Override
public String toString() {
return getDetails();
}
}

Programmer.java

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
package com.javami.team.domain;

import com.javami.team.service.Status;

public class Programmer extends Employee{
private int memberId;
private Status status = Status.FREE;
private Equipment equipment;

public int getMemberId() {
return memberId;
}

public void setMemberId(int memberId) {
this.memberId = memberId;
}

public Status getStatus() {
return status;
}

public void setStatus(Status status) {
this.status = status;
}

public Equipment getEquipment() {
return equipment;
}

public void setEquipment(Equipment equipment) {
this.equipment = equipment;
}

public Programmer() {
super();
}

public Programmer(int id, String name, int age, double salary, Equipment equipment) {
super(id, name, age, salary);
this.equipment = equipment;
}

@Override
public String toString() {
return getDetails() + "\t程序员\t" + status + "\t\t\t" + equipment.getDescription();
}

public String getTeamBaseDetails(){
return memberId + "/" + getId() + "\t" + getName() + "\t" + getAge() + "\t" + getSalary();
}

public String getDetailsForTeam(){
return getTeamBaseDetails() + "\t程序员";
}



}

Designer.java

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
package com.javami.team.domain;

public class Designer extends Programmer {
private double bonus;// 奖金

public Designer() {
super();
}

public Designer(int id, String name, int age, double salary, Equipment equipment, double bonus) {
super(id, name, age, salary, equipment);
this.bonus = bonus;
}

public double getBonus() {
return bonus;
}

public void setBonus(double bonus) {
this.bonus = bonus;
}

@Override
public String toString() {
return getDetails() + "\t设计师\t" + getStatus() + "\t" + bonus + "\t\t" + getEquipment().getDescription();
}

// 3/5 雷军 28 10000.0 设计师 5000.0
public String getDetailsForTeam() {
return getTeamBaseDetails() + "\t设计师\t" + getBonus();
}
}

Architect.java

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
package com.javami.team.domain;

public class Architect extends Designer{
private int stock;//股票

public Architect() {
super();
}

public Architect(int id, String name, int age, double salary, Equipment equipment, double bonus, int stock) {
super(id, name, age, salary, equipment, bonus);
this.stock = stock;
}

public int getStock() {
return stock;
}

public void setStock(int stock) {
this.stock = stock;
}
@Override
public String toString() {
return getDetails() + "\t架构师\t" + getStatus() + "\t" + getBonus() + "\t" + stock + "\t" + getEquipment().getDescription();
}

public String getDetailsForTeam() {
return getTeamBaseDetails() + "\t架构师\t" + getBonus() + "\t" + getStock();
}
}

Status类

Status枚举类位于com.atguigu.team.service包中,封装员工的状态。其代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.atguigu.team.service;
public class Status {
private final String NAME;
private Status(String name) {
this.NAME = name;
}
public static final Status FREE = new Status("FREE");
public static final Status VOCATION = new Status("VOCATION");
public static final Status BUSY = new Status("BUSY");
public String getNAME() {
return NAME;
}
@Override
public String toString() {
return NAME;
}
}

第2步

实现service包中的类

  • 按照设计要求编写NameListService类
  • 在NameListService类中临时添加一个main方法中,作为单元测试方法。
  • 在方法中创建NameListService对象,然后分别用模拟数据调用该对象的各个方法,以测试是否正确。注:测试应细化到包含了所有非正常的情况,以确保方法完全正确。
  • 重复1-3步,完成TeamService类的开发

NameListService类的设计


功能:负责将Data中的数据封装到Employee[]数组中,同时提供相关操作Employee[]的方法。
说明:

  • employees用来保存公司所有员工对象
  • NameListService()构造器:
    • 根据项目提供的Data类构建相应大小的employees数组
    • 再根据Data类中的数据构建不同的对象,包括Employee、Programmer、Designer和Architect对象,以及相关联的Equipment子类的对象
    • 将对象存于数组中
    • Data类位于com.atguigu.team.service包中
  • getAllEmployees ()方法:获取当前所有员工。
    • 返回:包含所有员工对象的数组
  • getEmployee(id : int)方法:获取指定ID的员工对象。
    • 参数:指定员工的ID
    • 返回:指定员工对象
    • 异常:找不到指定的员工
  • 在service子包下提供自定义异常类:TeamException
  • 另外,可根据需要自行添加其他方法或重载构造器

NameListService.java

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
package com.javami.team.service;

import com.javami.team.domain.*;

import static com.javami.team.service.Data.*;

public class NameListService {
private Employee[] employees;

public NameListService(){
// 1.根据项目提供的Data类构建相应大小的employees数组
// 2.再根据Data类中的数据构建不同的对象,包括Employee、Programmer、Designer和Architect对象,以及相关联的Equipment子类的对象
// 3.将对象存于数组中
employees = new Employee[EMPLOYEES.length];
for (int i = 0; i < employees.length; i++) {
//获取员工的类型
int type = Integer.parseInt(EMPLOYEES[i][0]);

//获取Employee的4个基本信息
int id = Integer.parseInt(EMPLOYEES[i][1]);
String name = EMPLOYEES[i][2];
int age = Integer.parseInt(EMPLOYEES[i][3]);
double salary = Double.parseDouble(EMPLOYEES[i][4]);

Equipment equipment;
double bonus;
int stock;
switch(type){
case EMPLOYEE:
employees[i] = new Employee(id, name, age, salary);
break;
case PROGRAMMER:
equipment = createEquipment(i);
employees[i] = new Programmer(id, name, age, salary, equipment);
break;
case DESIGNER:
equipment = createEquipment(i);
bonus = Double.parseDouble(EMPLOYEES[i][5]);
employees[i] = new Designer(id, name, age, salary, equipment, bonus);
break;
case ARCHITECT:
equipment = createEquipment(i);
bonus = Double.parseDouble(EMPLOYEES[i][5]);
stock = Integer.parseInt(EMPLOYEES[i][6]);
employees[i] = new Architect(id, name, age, salary, equipment, bonus, stock);
break;
}
}
}

//获取指定index上的员工的设备
private Equipment createEquipment(int index) {
int key = Integer.parseInt(EQUIPMENTS[index][0]);
String modelOrName = EQUIPMENTS[index][1];

switch(key){
case PC://21
String display = EQUIPMENTS[index][2];
return new PC(modelOrName, display);
case NOTEBOOK://22
double price = Double.parseDouble(EQUIPMENTS[index][2]);
return new NoteBook(modelOrName, price);
case PRINTER://23
String type = EQUIPMENTS[index][2];
return new Printer(modelOrName, type);
}
return null;
}
//获取当前所有员工
public Employee[] getAllEmployees(){
return employees;
}

//获取指定ID的员工对象。
public Employee getEmployee(int id) throws TeamException{
for(int i = 0;i < employees.length;i++){
if(employees[i].getId() == id){
return employees[i];
}
}
throw new TeamException("找不到指定的员工");
}


}

TeamService类的设计


功能:关于开发团队成员的管理:添加、删除等。
说明

  • counter为静态变量,用来为开发团队新增成员自动生成团队中的唯一ID,即memberId。(提示:应使用增1的方式)
  • MAX_MEMBER:表示开发团队最大成员数
  • team数组:用来保存当前团队中的各成员对象
  • total:记录团队成员的实际人数

说明

  • getTeam()方法:返回当前团队的所有对象
    • 返回:包含所有成员对象的数组,数组大小与成员人数一致
  • addMember(e: Employee)方法:向团队中添加成员
    • 参数:待添加成员的对象
    • 异常:添加失败, TeamException中包含了失败原因
  • removeMember(memberId: int)方法:从团队中删除成员
    • 参数:待删除成员的memberId
    • 异常:找不到指定memberId的员工,删除失败
  • 另外,可根据需要自行添加其他方法或重载构造器

TeamService.java

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
package com.javami.team.service;

import com.javami.team.domain.Architect;
import com.javami.team.domain.Designer;
import com.javami.team.domain.Employee;
import com.javami.team.domain.Programmer;

//关于开发团队成员的管理:添加、删除等。
public class TeamService {

private static int counter = 1;//给memberId赋值使用
private final int MAX_MEMBER = 5;//限制开发团队的人数
private Programmer[] team = new Programmer[MAX_MEMBER];//保存开发团队成员
private int total;//记录开发团队中实际的人数

public TeamService() {
super();
}

//获取开发团队中的所有成员
public Programmer[] getTeam(){
Programmer[] team = new Programmer[total];
for(int i = 0;i < team.length;i++){
team[i] = this.team[i];
}
return team;
}

//将指定的员工添加到开发团队中
public void addMember(Employee e) throws TeamException{
//成员已满,无法添加
if(total >= MAX_MEMBER){
throw new TeamException("成员已满,无法添加");
}
//该成员不是开发人员,无法添加
if(!(e instanceof Programmer)){
throw new TeamException("该成员不是开发人员,无法添加");
}
//该员工已在本开发团队中
if(isExist(e)){
throw new TeamException("该员工已在本开发团队中");
}
//该员工已是某团队成员
//该员正在休假,无法添加
Programmer p = (Programmer)e;//一定不会出现ClassCastException
if("BUSY".equalsIgnoreCase(p.getStatus().getNAME())){//if(p.getStatus().getNAME().equals("BUSY")){
throw new TeamException("该员工已是某团队成员");
}else if("VOCATION".equalsIgnoreCase(p.getStatus().getNAME())){
throw new TeamException("该员正在休假,无法添加");
}

// 团队中至多只能有一名架构师
// 团队中至多只能有两名设计师
// 团队中至多只能有三名程序员
//获取team已有成员中架构师,设计师,程序员的人数
int numOfArch = 0,numOfDes = 0,numOfPro = 0;
for(int i = 0;i < total;i++){
if(team[i] instanceof Architect){
numOfArch++;
}else if(team[i] instanceof Designer){
numOfDes++;
}else if(team[i] instanceof Programmer){
numOfPro++;
}
}
//正确的
if(p instanceof Architect){
if(numOfArch >= 1){
throw new TeamException("团队中至多只能有一名架构师");
}
}else if(p instanceof Designer){
if(numOfDes >= 2){
throw new TeamException("团队中至多只能有两名设计师");
}
}else if(p instanceof Programmer){
if(numOfPro >= 3){
throw new TeamException("团队中至多只能有三名程序员");
}
}

//将p(或e)添加到现有的team中
team[total++] = p;
//p的属性赋值
p.setStatus(Status.BUSY);
p.setMemberId(counter++);

}


//判断指定的员工是否已经存在于现有的开发团队中
private boolean isExist(Employee e) {

for(int i = 0;i < total;i++){
return team[i].getId() == e.getId();
}
return false;
}

//从团队中删除成员
public void removeMember(int memberId) throws TeamException{
int i = 0;
for(;i < total;i++){
if(team[i].getMemberId() == memberId){
team[i].setStatus(Status.FREE);
break;
}
}

//未找到指定memberId的情况
if(i == total){
throw new TeamException("找不到指定memberId的员工,删除失败");
}


//后一个元素覆盖前一个元素,实现删除操作
for(int j = i + 1;j < total;j++){
team[j - 1] = team[j];
}

//写法一:
// team[total-1] = null;
// total--;
//写法二:
team[--total] = null;


}


}

TeamException.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.javami.team.service;

//自定义异常类
public class TeamException extends Exception{
static final long serialVersionUID = -3387514229948L;

public TeamException(){
super();
}

public TeamException(String msg){
super(msg);
}
}

第3步

实现view包中类

  • 按照设计要求编写TeamView类,逐一实现各个方法,并编译
  • 执行main方法中,测试软件全部功能

TeamView类的设计

说明

  • listSvcteamSvc属性:供类中的方法使用
  • enterMainMenu ()方法:主界面显示及控制方法。
  • 以下方法仅供enterMainMenu()方法调用:
    • listAllEmployees ()方法:以表格形式列出公司所有成员
    • getTeam()方法:显示团队成员列表操作
    • addMember ()方法:实现添加成员操作
    • deleteMember ()方法:实现删除成员操作

TeamView.java

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
package com.javami.team.view;

import com.javami.team.domain.Employee;
import com.javami.team.domain.Programmer;
import com.javami.team.service.NameListService;
import com.javami.team.service.TeamException;
import com.javami.team.service.TeamService;

public class TeamView {

private NameListService listSvc = new NameListService();
private TeamService teamSvc = new TeamService();

public void enterMainMenu(){

boolean loopFlag = true;
char menu = 0;
while(loopFlag){

if(menu != '1'){
listAllEmployees();
}

System.out.print("1-团队列表 2-添加团队成员 3-删除团队成员 4-退出 请选择(1-4):");

menu = TSUtility.readMenuSelection();
switch(menu){
case '1':
getTeam();
break;
case '2':
addMember();
break;
case '3':
deleteMember();
break;
case '4':
System.out.print("确认是否退出(Y/N):");
char isExit = TSUtility.readConfirmSelection();
if(isExit == 'Y'){
loopFlag = false;
}
break;
}
}
}

//显示所有的员工信息
private void listAllEmployees(){
// System.out.println("显示公司所有的员工信息");
System.out.println("-------------------------------开发团队调度软件--------------------------------\n");

Employee[] employees = listSvc.getAllEmployees();
if(employees == null || employees.length == 0){
System.out.println("公司中没有任何员工信息!");
}else{
System.out.println("ID\t姓名\t年龄\t工资\t职位\t状态\t奖金\t股票\t领用设备");

for(int i = 0;i < employees.length;i++){
System.out.println(employees[i]);
}
}

System.out.println("-------------------------------------------------------------------------------");
}
private void getTeam(){
// System.out.println("查看开发团队情况");

System.out.println("--------------------团队成员列表---------------------\n");

Programmer[] team = teamSvc.getTeam();
if(team == null || team.length == 0){
System.out.println("开发团队目前没有成员!");
}else{
System.out.println("TID/ID\t姓名\t年龄\t工资\t职位\t奖金\t股票\n");
for(int i = 0;i < team.length;i++){
System.out.println(team[i].getDetailsForTeam());

}
}

System.out.println("-----------------------------------------------------");
}
private void addMember(){
// System.out.println("添加团队成员");
System.out.println("---------------------添加成员---------------------");
System.out.print("请输入要添加的员工ID:");
int id = TSUtility.readInt();

try {
Employee emp = listSvc.getEmployee(id);
teamSvc.addMember(emp);
System.out.println("添加成功");
} catch (TeamException e) {
System.out.println("添加失败,原因:" + e.getMessage());
}
//按回车键继续...
TSUtility.readReturn();
}
private void deleteMember(){
// System.out.println("删除团队成员");
System.out.println("---------------------删除成员---------------------");
System.out.print("请输入要删除员工的TID:");
int memberId = TSUtility.readInt();

System.out.print("确认是否删除(Y/N):");
char isDelete = TSUtility.readConfirmSelection();
if(isDelete == 'N'){
return;
}

try {
teamSvc.removeMember(memberId);
System.out.println("删除成功");
} catch (TeamException e) {
System.out.println("删除失败,原因:" + e.getMessage());
}
//按回车键继续...
TSUtility.readReturn();
}

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


}

本博客所有文章除特别声明外,均采用 CC BY-SA 3.0协议 。转载请注明出处!