Java学习配套项目实操

目录

项目一：家庭收支记账软件

需求说明

工具类 Utility.java

工具类介绍

工具类的使用

代码实现

项目二  客户信息管理软件 

目 标

需求说明

软件设计结构 

项目三 开发团队调度软件

目标

需求说明

 软件设计结构

实现

---

项目一：家庭收支记账软件

模拟实现一个基于文本界面的《家庭记账软件》 
掌握初步的编程技巧和调试技巧

主要涉及以下知识点：
   局部变量和基本数据类型 
   循环语句 
   分支语句 
   方法调用和返回值的接收 
   简单的屏幕输出格式控制

需求说明

模拟实现基于文本界面得家庭记账软件

该软件能够记录家庭的收入支出，并能够打印收支明细表

项目采用分级菜单方式。主菜单如下：

假设家庭起始的生活基本金为 10000 元。
• 每次登记收入（菜单 2）后，收入的金额应累加到基本上并记 录本次收入明细，以便后续的查询。
• 每次登记支出（菜单 3）后，支出的金额应从基本中扣除并记 录本次支出明细，以便后续的查询。
• 查询收支明细（ 菜单 1）时，将显示所有的收入、支出名细列表
 

“登记收入”的界面及操作过程如下所示：

 “登记支出”的界面及操作过程如下所示：
 

“收支明细”的界面及操作过程如下所示：
 

 提示：明细表格的对齐，可以简单使用制表符‘ \t’来实现

“退 出”的界面及操作过程如下所示：
 

工具类 Utility.java

工具类介绍

将不同的功能封装为方法，就是可以直接通过调用方法使用它的功能，而无需考虑具体的功能实现细节，在 Utility.java工具类中提供了以下静态方法： 
   public static char readMenuSelection() ：用于界面菜单的选择。该方法读取键盘，如果用户键入’ 1’-’4’中的任意字符，则方法返回。返回值为用户键入

   public static int readNumber() ：用于收入和支出金额的输入。该方法从键盘读取一个不超过4位长度的整数，并将其作为方法的返回值。

   public static String readString() ：用于收入和支出说明的提示：明细表格的对齐，可以简单使用制符‘ \t’输入。该方法从键盘读取一个不超过8位长度的字符串，并将其作为方法的返回值。

   public static char readConfirmSelection() ：用于确认选择的输入。该方法从键盘读取‘ Y’ 或’ N’，并将其作为方法的返回值。

工具类的使用

这些方法都是 public static修饰的，因此使用这些方法可以通过“类名 .方法”直接使用。例如：
char key = Utility.readMenuSelection();
int amount = Utility.readNumber();
String desc = Utility.readString();
char confirm = Utility.readConfirmSelection();

Utility.java

import java.util.Scanner;
/**
Utility工具类：
将不同的功能封装为方法，就是可以直接通过调用方法使用它的功能，而无需考虑具体的功能实现细节。
*/
public class Utility {
    private static Scanner scanner = new Scanner(System.in);
    /**
	用于界面菜单的选择。该方法读取键盘，如果用户键入’1’-’4’中的任意字符，则方法返回。返回值为用户键入字符。
	*/
	public static char readMenuSelection() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1);
            c = str.charAt(0);
            if (c != '1' && c != '2' && c != '3' && c != '4') {
                System.out.print("选择错误，请重新输入：");
            } else break;
        }
        return c;
    }
	/**
	用于收入和支出金额的输入。该方法从键盘读取一个不超过4位长度的整数，并将其作为方法的返回值。
	*/
    public static int readNumber() {
        int n;
        for (; ; ) {
            String str = readKeyBoard(4);
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }
	/**
	用于收入和支出说明的输入。该方法从键盘读取一个不超过8位长度的字符串，并将其作为方法的返回值。
	*/
    public static String readString() {
        String str = readKeyBoard(8);
        return str;
    }
	
	/**
	用于确认选择的输入。该方法从键盘读取‘Y’或’N’，并将其作为方法的返回值。
	*/
    public static char readConfirmSelection() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1).toUpperCase();
            c = str.charAt(0);
            if (c == 'Y' || c == 'N') {
                break;
            } else {
                System.out.print("选择错误，请重新输入：");
            }
        }
        return c;
    }
	
	
    private static String readKeyBoard(int limit) {
        String line = "";

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

        return line;
    }
}

代码实现

第1步 — 实现主程序结构
1. 创建 FamilyAccount 类及 main 方法
2. 在main方法中，实现程序主体结构
3. 测试程序，确认可以正常执行第1和第4菜单选项 

主界面

根据用户的选择执行不同的语句 

功能能够循环使用，加入循环 

当选择退出时，并确认退出后，程序结束，修改循环变量 

 登记收入

1从键盘输入信息

2. 调整余额、串接信息

基本金的记录可以使用int类型的局部变量来实现：
int balance = 10000;
收支明细记录可以使用string类型的变量来实现，其初始值为明细表表头。例如：

String details = "收支 \t账户金额 \t收支金额 \t说 明\n";
在登记收支时，将收支金额与balance相加或相减，收支记录直接串到 相加或减，收支记录直接串接到details后面即可。 
说明：因为余额和详细信息是多个功能，以及在程序退出之前次登记是共享的，因此必须把这两个变量声明在循环之上 。

登记支出 

收入明细 

 

项目二  客户信息管理软件 

目 标

1.模拟实现一个基于文本界面的《客户信息管理软件》

2.进一步掌握编程技巧和调试技巧，熟悉面向对象编程

3.主要涉及以下知识点：

类结构的使用：属性、方法及构造器

对象的创建与使用

类的封装性

声明和使用数组

数组的插入、删除和替换

关键字的使用：this

 

需求说明

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

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

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

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

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

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

软件设计结构 

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

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

键盘访问的实现

   项目中提供了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’，并将其作为方法的返回值。

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;
    }
}

Customer类的设计

Customer为实体类，用来封装客户信息
该类封装客户的以下信息：
String name ：客户姓名
char gender  ：性别
int age          ：年龄
String phone：电话号码
String email ：电子邮箱
提供各属性的get/set方法
提供所需的构造器（可自行确定）
 

public class Customer {
	private String name;
	private char gender;
	private int age;
	private String phone;
	private String 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 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;
	}
}

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 int getTotal()

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指定所替换对象在数组中的位置，从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对象

public class CustomerList {
	Customer[] customers;
	int total = 0;
	/**
	 * 用于初始customers数组的构造器
	 * @param totalCustomer:指定数组的长度
	 */
	public CustomerList(int totalCustomer) {
		customers = new Customer[totalCustomer];
	}
	/**
	 * 将参数customer添加到数组中最后一个客户对象记录之后
	 * @param customer 指定要添加的客户对象 
	 * @return 添加成功返回true；false表示数组已满，无法添加
	 */
	public boolean addCustomer(Customer customer){
			if (this.total >= customers.length  ) {
				return false;
			}else {
				customers[total++] = customer;
				return true;
			}
	}
	/**
	 * 用参数customer替换数组中由index指定的对象
	 * @param index index指定所替换对象在数组中的位置，从0开始
	 * @param cust	customer指定替换的新客户对象 
	 * @return 替换成功返回true；false表示索引无效，无法替换
	 */
	public boolean replaceCustomer(int index, Customer cust) {
			if (index < 0 || index >= total) {
				return false;
			}else {
				customers[index] = cust;
				return true;
			}
	}
	
	/**
	 * 从数组中删除参数index指定索引位置的客户对象记录
	 * @param index index指定所删除对象在数组中的索引位置，从0开始
	 * @return 删除成功返回true；false表示索引无效，无法删除
	 */
	public boolean deleteCustomer(int index) {
		if (index < 0 || index >= total) {
			return false;
		}else {
			for (int i = index;i < total-1;i++) {
				customers[i] = customers[i+1];
			}
			//最后有数据的元素需要置空
//			customers[total-1] =null;
//			total--;
			customers[--total] =null;
			return true;
		}
	}
	/**
	 * 返回数组中记录的所有客户对象
	 * @return Customer[] 数组中包含了当前所有客户对象，该数组长度与对象个数相同。
	 */
	public Customer[] getAllCustomers(){
		Customer[] cust = new Customer[total];
		for (int i = 0;i < total;i++) {
			cust[i] = customers[i];
		}
		return cust;
	}
	/**
	 * 返回参数index指定索引位置的客户对象记录
	 * @param index 指定所要获取的客户在数组中的索引位置，从0开始
	 * @return 封装了客户信息的Customer对象
	 */
	public Customer getCustomer(int index){
		if (index < 0 || index >=total) {
			return null;
		}else {
			return customers[index];
		}
	}
	public int getTotal() {
		return total;
	}
}

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()方法以执行程序。
 

package com.sxt.p2.ui;
import com.sxt.p2.bean.Customer;
/**
 * 
 * @Description 主模块，负责菜单的显示和处理用户操作
 * @author fish
 * @since 2021.03.14
 */
import com.sxt.p2.service.CustomerList;
import com.sxt.p2.util.CMUtility;
public class CustomerView {
	private CustomerList customerList = new CustomerList(10);
	
	/**
	 * 测试代码
	 */
//	public CustomerView(){
//		Customer customer = new Customer("王涛", '男', 14, "12333334", "wt@gmail.com");
//		customerList.addCustomer(customer);
//	}
	
	/**
	 * 显示主菜单，响应用户输入，根据用户操作分别调用其他相应的成员方法（
	 * 如addNewCustomer），
	 * 以完成客户信息处理。
	 */
	/**
	 * 
	 */
	public void enterMainMenu() {
		boolean loopFlag = true;
			do {
			System.out.println("\n---------客户信息管理软件---------");
			System.out.println("             1.添加客户");
			System.out.println("             2.修改客户");
			System.out.println("             3.删除客户");
			System.out.println("             4.客户列表");
			System.out.println("             5.退       出\n");
			System.out.println("             请选择(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.println("确认是否退出(Y/N):");
				char isExit = CMUtility.readConfirmSelection();
				if (isExit == 'Y') {
					loopFlag = false;
				}
			}		
			}while(loopFlag);
	}
	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("-------客户目录满，添加失败-------");
		}
	}
	
	private void modifyCustomer() {
		System.out.println("---------修改客户--------");
		Customer cust;
		int number;
		while(true) {
			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.println("姓名（"+cust.getName()+"):");
		String name = CMUtility.readString(10, cust.getName());//用户输入，以输入为准。换行，以原始为准
		System.out.println("性别（"+cust.getGender()+"):");
		char gender = CMUtility.readChar(cust.getGender());
		System.out.println("年龄（"+cust.getAge()+"):");
		int age = CMUtility.readInt(cust.getAge());
		System.out.println("电话（"+cust.getPhone()+"):");
		String phone = CMUtility.readString(13, cust.getPhone());
		System.out.println("邮箱（"+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("---------修改失败---------");
		}
	}
	private void deleteCustomer() {
		System.out.println("---------删除客户---------");
		int number;
		while(true) {
			System.out.print("请选择待修改的客户编号(-1退出)：");
			number = CMUtility.readInt();
			if(number == -1) {
				return;
			}

			Customer cust = customerList.getCustomer(number-1);
			if (cust == 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("---------删除失败---------");
			}
		}
	}
	private void listAllCustomers() {
		//System.out.println("查询客户");
		System.out.println("---------客户列表---------");
		int total = customerList.getTotal();
		if (total == 0) {
			System.out.println("目前没有客户");
		}else {
			System.out.println("编号\t姓名\t性别\t年龄\t电话\t\t邮箱\t");
			Customer[] custs = customerList.getAllCustomers();
			for (int i =0;i < total;i++) {
				System.out.println((i+1)+"\t"+custs[i].getName()+"\t"+
				custs[i].getGender()+"\t"+custs[i].getAge()+"\t"+
				custs[i].getPhone()+"\t"+custs[i].getEmail());
			}
			
		}
		System.out.println("-------客户列表完成---------\n");
		
	}
	public static void main(String[] args) {
		CustomerView view = new CustomerView();
		view.enterMainMenu();
	}
}

项目三 开发团队调度软件

目标

•模拟实现一个基于文本界面的《开发团队调度软件》

•熟悉Java面向对象的高级特性，进一步掌握编程技巧和调试技巧

•主要涉及以下知识点：

    类的继承性和多态性

    对象的值传递、接口

    static和final修饰符

    特殊类的使用：包装类、抽象类、内部类

    异常处理

需求说明

该软件实现以下功能：

软件启动时，根据给定的数据创建公司部分成员列表（数组）

根据菜单提示，基于现有的公司成员，组建一个开发团队以开发一个新的项目

组建过程包括将成员插入到团队中，或从团队中删除某成员，还可以列出团队中现有成员的列表

开发团队成员包括架构师、设计师和程序员

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

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

添加成功后，按回车键将重新显示主界面。
开发团队人员组成要求–最多一名架构师–最多两名设计师最多三名程序员

如果添加操作因某种原因失败，将显示类似以下信息（失败原因视具体原因而不同）：

 

当选择“删除团队成员”菜单时，将执行从开发团队中删除指定（通过TeamID）成员的功能，删除成功后，按回车键将重新显示主界面。 

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

 软件设计结构

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

com.atguigu.team.view模块为主控模块，负责菜单的显示和处理用户操作

com.atguigu.team.service模块为实体对象(Employee及其子类如程序员等)的管理模块，NameListService和TeamService类分别用各自的数组来管理公司员工和开发团队成员对象

domain模块为Employee及其子类等JavaBean类所在的包

•com.atguigu.team.domain模块中包含了所有实体类：

  •其中程序员(Programmer)及其子类，均会领用某种电子设备(Equipment)。

实现

第1步 — 创建项目基本组件

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

TSUtility.java

package com.atguigu.team.view;

import java.util.*;
/**
 * 
 * @Description 项目中提供了TSUtility.java类，可用来方便地实现键盘访问。
 * @author shkstart  Email:shkstart@126.com
 * @version 
 * @date 2019年2月12日上午12:02:58
 *
 */
public class TSUtility {
    private static Scanner scanner = new Scanner(System.in);
    /**
     * 
     * @Description 该方法读取键盘，如果用户键入’1’-’4’中的任意字符，则方法返回。返回值为用户键入字符。
     * @author shkstart
     * @date 2019年2月12日上午12:03:30
     * @return
     */
	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') {
                System.out.print("选择错误，请重新输入：");
            } else break;
        }
        return c;
    }
	/**
	 * 
	 * @Description 该方法提示并等待，直到用户按回车键后返回。
	 * @author shkstart
	 * @date 2019年2月12日上午12:03:50
	 */
    public static void readReturn() {
        System.out.print("按回车键继续...");
        readKeyBoard(100, true);
    }
    /**
     * 
     * @Description 该方法从键盘读取一个长度不超过2位的整数，并将其作为方法的返回值。
     * @author shkstart
     * @date 2019年2月12日上午12:04:04
     * @return
     */
    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;
    }
    /**
     * 
     * @Description 从键盘读取‘Y’或’N’，并将其作为方法的返回值。
     * @author shkstart
     * @date 2019年2月12日上午12:04:45
     * @return
     */
    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;
    }
}

Data.java 

package com.atguigu.team.service;

public class Data {
    public static final int EMPLOYEE = 10;
    public static final int PROGRAMMER = 11;
    public static final int DESIGNER = 12;
    public static final int ARCHITECT = 13;

    public static final int PC = 21;
    public static final int NOTEBOOK = 22;
    public static final int PRINTER = 23;

    //Employee  :  10, id, name, age, salary
    //Programmer:  11, id, name, age, salary
    //Designer  :  12, id, name, age, salary, bonus
    //Architect :  13, id, name, age, salary, bonus, stock
    public static final String[][] EMPLOYEES = {
        {"10", "1", "马云", "22", "3000"},
        {"13", "2", "马化腾", "32", "18000", "15000", "2000"},
        {"11", "3", "李彦宏", "23", "7000"},
        {"11", "4", "刘强东", "24", "7300"},
        {"12", "5", "雷军", "28", "10000", "5000"},
        {"11", "6", "任志强", "22", "6800"},
        {"12", "7", "柳传志", "29", "10800","5200"},
        {"13", "8", "杨元庆", "30", "19800", "15000", "2500"},
        {"12", "9", "史玉柱", "26", "9800", "5500"},
        {"11", "10", "丁磊", "21", "6600"},
        {"11", "11", "张朝阳", "25", "7100"},
        {"12", "12", "杨致远", "27", "9600", "4800"}
    };
    
    //如下的EQUIPMENTS数组与上面的EMPLOYEES数组元素一一对应
    //PC      :21, model, display
    //NoteBook:22, model, price
    //Printer :23, name, type 
    public static final String[][] EQUIPMENTS = {
        {},
        {"22", "联想T4", "6000"},
        {"21", "戴尔", "NEC17寸"},
        {"21", "戴尔", "三星 17寸"},
        {"23", "佳能 2900", "激光"},
        {"21", "华硕", "三星 17寸"},
        {"21", "华硕", "三星 17寸"},
        {"23", "爱普生20K", "针式"},
        {"22", "惠普m6", "5800"},
        {"21", "戴尔", "NEC 17寸"},
        {"21", "华硕","三星 17寸"},
        {"22", "惠普m6", "5800"}
    };
}

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

Equipment.java

package com.atguigu.team.domain;

public interface Equipment {
	String getDescription();
}

 NoteBook.java

package com.atguigu.team.domain;

public class NoteBook implements Equipment{
	private String model;
	private double price;
	public NoteBook(String model,double price) {
		this.model = model;
		this.price = 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;
	}

	@Override
	public String getDescription() {
		return this.getModel()+"("+this.getPrice()+")";
	}
	
}

Printer.java 

package com.atguigu.team.domain;

public class NoteBook implements Equipment{
	private String model;
	private double price;
	public NoteBook(String model,double price) {
		this.model = model;
		this.price = 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;
	}

	@Override
	public String getDescription() {
		return this.getModel()+"("+this.getPrice()+")";
	}
	
}

PC.java

 

package com.atguigu.team.domain;

public class PC implements Equipment{
	private String model;
	private String display;
	
	public PC(String model, String display) {
		super();
		this.model = model;
		this.display = display;
	}
	public PC() {
		
	}
	
	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;
	}
	@Override
	public String getDescription() {
		return this.getModel()+"("+this.getDisplay()+")";
	}
}

• 说明：

model 表示机器的型号

display 表示显示器名称

type 表示机器的类型

• 根据需要提供各属性的 get/set 方法以及重载构造器

• 实现 类实现接口的方法，返回各自属性的信息

 

Employee类及其子类的设计

Employee.java

package com.atguigu.team.domain;

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

	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 String getDetails() {
		return id+"\t"+name+"\t"+age+"\t"+salary;
	}
	@Override
	public String toString() {
		return getDetails();
	}
}

Programmer.java

package com.atguigu.team.domain;
import com.atguigu.team.service.Status;

public class Programmer extends Employee{
		private int memberId;//memberId 用来记录成员加入开发团队后在团队中的ID
		private Status status = Status.FREE;//声明三个对象属性，分别表示成员的状态
		private Equipment equipment;
		
		public Programmer(int id, String name, int age, double salary, Equipment equipment) {
			super(id, name, age, salary);
			this.equipment = equipment;
		}
		
		public Programmer() {
			super();
		}

		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;
		}
		@Override
		public String toString() {
			return super.getDetails()+"\t程序员\t"+status+"\t\t\t"+equipment.getDescription();
		}
		
		public String getTeamBaseDetail() {
			return memberId + "/"+getId()+"\t"+getName()+"\t"+getAge()+"\t"+getSalary();
		}
		
		public String getDetailsForTeam() {
			return getTeamBaseDetail()+"\t程序员";
		}
}

•说明：

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

Status类

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

package com.atguigu.team.service;
/**
 * 
 * @Description 表示员工的状态
 * @author fish
 * @since 2021.05.02
 */
//status类中有三个对象
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 BUSY = new Status("BUSY");
	public static final Status VOCATION = new Status("VOCATION");
	
	
	public String getNAME() {
		return NAME;
	}


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

Designer.java

package com.atguigu.team.domain;

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

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

	public double getBonus() {
		return bonus;
	}

	public void setBonus(double bonus) {
		this.bonus = bonus;
	}
	@Override
	public String toString() {	
		//调用的是上级的，无法引用父类的父类
		//return super.toString()+"\t"+bonus"\t";
		return getDetails()+"\t设计师\t"+getStatus()+"\t"+bonus+"\t\t"+getEquipment().getDescription();
	}
	
	public String getDetailsForTeam() {
		return getTeamBaseDetail()+"\t设计师\t"+getBonus();
	}
}

Architect.java

package com.atguigu.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 getTeamBaseDetail()+"\t架构师\t"+getBonus()+"\t"+getStock();
	}
}

 •说明：

b onus 表示奖金

s tock 表示公司奖励的股票数量

 •可根据需要为类提供各属性的get/set方法以及重载构造器  

 第2步 — 实现service包中的类

1.按照设计要求编写NameListService类
2.在NameListService类中临时添加一个main方法中，作为单元测试方法。
3.在方法中创建NameListService对象，然后分别用模拟数据调用该对象的各个方法，以测试是否正确。 注：测试应细化到包含了所有非正常的情况，以确保方法完全正确。
4.重复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

•另外，可根据需要自行添加其他方法或重载构造器

package com.atguigu.team.service;
import com.atguigu.team.domain.*;

import static com.atguigu.team.service.Data.*;
/**
 * 
 * @Description 负责将Data中的数据封装到Employee[]数组中，同时提供相关操作Employee[]的方法。
 * @author fish
 * @since 2021.05.02
 */
public class NameListService {
	private Employee[] employees;
	/**
	 * 给employees及数组元素进行初始化
	 */
	public NameListService() {
		//根据项目提供的Data类构建相应大小的employees数组
		
		//再根据Data类中的数据构建不同的对象，包括Employee、Programmer、Designer和Architect对象，以及相关联的Equipment子类的对象将对象存于数组中
		//Data类位于com.atguigu.team.service包中
		employees = new Employee[EMPLOYEES.length];
		for (int i=0;i<employees.length;i++) {
			//获取员工的类型
			int type = Integer.parseInt(EMPLOYEES[i][0]);
			//获取Employee的四个基本信息
			int id = Integer.parseInt(EMPLOYEES[i][1]);
			String name = EMPLOYEES[i][2];
			int age = Integer.parseInt(EMPLOYEES[i][3]);
			double salary = Integer.parseInt(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;
	}
	/**
	 * 获取当前所有的员工
	 * @return
	 */
	public Employee[] getAllEmployees() {
		return employees;
	}
	/**
	 * 获取指定id的员工
	 * @param id
	 * @return
	 */
	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("找不到指定的员工");//对编译时异常要进行处理
	}
}

TeamException.java 

package com.atguigu.team.service;
/**
 * 自定义异常类
 * @Description 
 * @author fish
 * @since 2021.05.03
 */
public class TeamException extends Exception{
	static final long serialVersionUID = -3387516993124229948L;
	
	public TeamException() {
		
	}
	public TeamException(String msg) {
		super(msg);
	}
}

TeamService类的设计

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

• 说明：

counter 为 静态变量 ，用来为开发团队新增成员自动生成团队中的唯一 ID ，即 memberId 。（提示：应使用增 1 的方式）

MAX_MEMBER ：表示 开发团队最大成员数

team 数组：用来 保存当前团队中的各成员对象

total ： 记录 团队成员的实际人数

• 说明：

getTeam () 方法：返回当前团队的所有对象

返回：包含所有成员对象的 数组 ， 数组大小与成员人数一致

addMember (e: Employee) 方法：向团队中添加成员

参数：待添加成员的对象

异常： 添加失败， TeamException 中包含了失败原因

removeMember ( memberId : int ) 方法：从团队中删除成员

参数：待删除成员的 memberId

异常： 找不到指定 memberId 的员工，删除失败

• 另外，可根据需要 自行添加其他方法或 重载构造器

package com.atguigu.team.service;
import com.atguigu.team.domain.*;

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 = 0;//记录开发团队的实际人数
	/**
	 * 获取开发团队中的所有成员（有几个列出几个）
	 * @return
	 */
	public Programmer[] getTeam() {
		Programmer[] team = new Programmer[total];
		for (int i = 0;i<team.length;i++) {
			team[i] = this.team[i];
		}
		return team;
	}
	
	/**
	 * 将指定的员工添加到开发团队中
	 * 
	 * @param e
	 */
	
	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;//一定不会出现强转类型异常
		//if(p.getStatus().getNAME().equals("BUSY"){
		if("BUSY".equalsIgnoreCase(p.getStatus().getNAME())){	//减少空指针异常风险
			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添加到现有的team中
		team[total++] = 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;
		for (i = 0;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] = null;
	}	
}

第3步 — 实现view包中类

1. 按照设计要求编写 TeamView 类，逐一实现各个方法，并编译

2. 执行 main 方法中，测试软件全部功能

• 说明：

listSvc 和 teamSvc 属性：供类中的方法使用

enterMainMenu () 方法：主界面显示及控制方法。

以下方法仅供 enterMainMenu () 方法调用：

ü listAllEmployees () 方法：以表格形式列出公司所有成员

ü getTeam () 方法：显示团队成员列表操作

ü addMember () 方法：实现添加成员操作

ü deleteMember () 方法：实现删除成员操作

搭建TeamView 的框架

package com.atguigu.team.view;

import com.atguigu.team.service.NameListService;
import com.atguigu.team.service.TeamService;

public class TeamView {
	private NameListService listSvc = new NameListService();
	private TeamService teamSvc = new TeamService();
	
	public void enterMainMenu() {
		boolean loopFlag  = true;
		while(loopFlag) {
			listAllEmployee();
			System.out.print("1-团队列表 2-添加团队成员 3-删除团队成员 4-退出 请选择(1-4):");
			char menu = TSUtility.readMenuSelection();
			switch(menu) {
			case '1':
				getTeam();
				break;
			case '2':
				addMember();
				break;
			case '3':
				deleteMember();
				break;
			case '4':
				System.out.println("退出");
				break;
			}
		}
	}
	/**
	 * 显示所有的员工信息
	 */
	private void listAllEmployee() {
		System.out.println("显示公司所有的员工信息");
	}
	
	private void getTeam() {
		System.out.println("查看开发团队情况");
	}
	
	private void addMember() {
		System.out.println("添加团队成员");
	}
	
	private void deleteMember() {
		System.out.println("删除团队成员");
		
	}
	
	public static void main(String[] args) {
		TeamView view = new TeamView();
		view.enterMainMenu();//进入界面
	}
}

TeamView退出功能的实现

case '4':
		System.out.println("确认是否退出？");
		char isExit = TSUtility.readConfirmSelection();
		if (isExit == 'Y') {
			loopFlag = false;
		}
		break;

TeamView中显示所有员工的功能

private void listAllEmployee() {
		//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("----------------------------------------");
		
	}

TeamView中显示开发团队成员

	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股票");
			for (int i = 0;i<team.length;i++) {
				System.out.println(team[i].getDetailsForTeam());
			}
		}
		System.out.println("----------------------------------");
	}

TeamView中添加开发团队成员

private void addMember() {
//		System.out.println("添加团队成员");
		System.out.println("------------添加成员--------------");
		System.out.println("请输入要添加员工的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();
	}

 TeamView中删除开发团队成员

private void deleteMember() {
		//System.out.println("删除团队成员");
		System.out.println("----------删除成员----------");
		System.out.println("请输入要删除员工的TID:");
		int memberId = TSUtility.readInt();
		System.out.println("确认是否删除(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();
	}

TeamView.java

package com.atguigu.team.view;
import com.atguigu.team.domain.*;
import com.atguigu.team.service.NameListService;
import com.atguigu.team.service.TeamException;
import com.atguigu.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') {
			listAllEmployee();
			}
			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.println("确认是否退出？");
				char isExit = TSUtility.readConfirmSelection();
				if (isExit == 'Y') {
					loopFlag = false;
				}
				break;
			}
		}
	}
	/**
	 * 显示所有的员工信息
	 */
	private void listAllEmployee() {
		//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股票");
			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.println("请输入要添加员工的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.println("请输入要删除员工的TID:");
		int memberId = TSUtility.readInt();
		System.out.println("确认是否删除(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();//进入界面
	}
}