eclipes常见操作总结及项目2和3经验总结

eclipes常见操作总结及项目2经验总结

eclipes提示：

打开eclipes 选择window->perference->java->editor->content assistant

 * Eclipse中的快捷键：
 * 1.补全代码的声明：alt + /
 * 2.快速修复: ctrl + 1
 * 3.批量导包：ctrl + shift + o
 * 4.使用单行注释：ctrl + /
 * 5.使用多行注释： ctrl + shift + /
 * 6.取消多行注释：ctrl + shift + \
 * 7.复制指定行的代码：ctrl + alt + down 或 ctrl + alt + up
 * 8.删除指定行的代码：ctrl + d
 * 9.上下移动代码：alt + up  或 alt + down
 * 10.切换到下一行代码空位：shift + enter
 * 11.切换到上一行代码空位：ctrl + shift + enter
 * 12.如何查看源码：ctrl + 选中指定的结构   或  ctrl + shift + t
 * 13.退回到前一个编辑的页面：alt + left
 * 14.进入到下一个编辑的页面(针对于上面那条来说的)：alt + right
 * 15.光标选中指定的类，查看继承树结构：ctrl + t
 * 16.复制代码： ctrl + c
 * 17.撤销： ctrl + z
 * 18.反撤销： ctrl + y
 * 19.剪切：ctrl + x
 * 20.粘贴：ctrl + v
 * 21.保存： ctrl + s
 * 22.全选：ctrl + a
 * 23.格式化代码： ctrl + shift + f
 * 24.选中数行，整体往后移动：tab
 * 25.选中数行，整体往前移动：shift + tab
 * 26.在当前类中，显示类结构，并支持搜索指定的方法、属性等：ctrl + o
 * 27.批量修改指定的变量名、方法名、类名等：alt + shift + r
 * 28.选中的结构的大小写的切换：变成大写： ctrl + shift + x
 * 29.选中的结构的大小写的切换：变成小写：ctrl + shift + y
 * 30.调出生成getter/setter/构造器等结构： alt + shift + s
 * 31.显示当前选择资源(工程 or 文件)的属性：alt + enter
 * 32.快速查找：参照选中的Word快速定位到下一个 ：ctrl + k
 *
 * 33.关闭当前窗口：ctrl + w
 * 34.关闭所有的窗口：ctrl + shift + w
 * 35.查看指定的结构使用过的地方：ctrl + alt + g
 * 36.查找与替换：ctrl + f
 * 37.最大化当前的View：ctrl + m
 * 38.直接定位到当前行的首位：home
 * 39.直接定位到当前行的末位：end
 //注意：部分操作需要选中代码

当eclipes中默认快捷键与电脑冲突时，可以设置eclipses的默认快捷键：

项目二：

customer类：

public class Customer {
   private String name;
   private char gender;
   private int age;
   private String phone;
   private String email;

   public Customer(String name, char gender, int age) {
      this(name, gender, age, "", "");
   }

   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\t" + phone + "\t" + email;
   }
}

CustomerView类：

public class CustomerView {
   private CustomerList customers = new CustomerList(10);

   public CustomerView() {
      Customer cust = new Customer("张三", '男', 30, "010-56253825",
            "abc@email.com");
      customers.addCustomer(cust);
   }

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

         char key = CMUtility.readMenuSelection();
         System.out.println();
         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("---------------------添加客户---------------------");
      System.out.print("姓名：");
      String name = CMUtility.readString(4);
      System.out.print("性别：");
      char gender = CMUtility.readChar();
      System.out.print("年龄：");
      int age = CMUtility.readInt();
      System.out.print("电话：");
      String phone = CMUtility.readString(15);
      System.out.print("邮箱：");
      String email = CMUtility.readString(15);

      Customer cust = new Customer(name, gender, age, phone, email);
      boolean flag = customers.addCustomer(cust);
      if (flag) {
         System.out
               .println("---------------------添加完成---------------------");
      } else {
         System.out.println("----------------记录已满,无法添加-----------------");
      }
   }

   private void modifyCustomer() {
      System.out.println("---------------------修改客户---------------------");

      int index = 0;
      Customer cust = null;
      for (;;) {
         System.out.print("请选择待修改客户编号(-1退出)：");
         index = CMUtility.readInt();
         if (index == -1) {
            return;
         }

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

      System.out.print("姓名(" + cust.getName() + ")：");
      String name = CMUtility.readString(4, 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(15, cust.getPhone());

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

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

      boolean flag = customers.replaceCustomer(index - 1, cust); //将修改信息创建新的对象调用flag判断成立
      if (flag) {
         System.out
               .println("---------------------修改完成---------------------");
      } else {
         System.out.println("----------无法找到指定客户,修改失败--------------");
      }
   }

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

      int index = 0;//将index和cust定义在循环外，使循环内的各处都可以访问变量
      Customer cust = null;
      for (;;) {//这种for循环的目的是为了在输入错误的条件下继续一直输入，直至正确
         System.out.print("请选择待删除客户编号(-1退出)：");
         index = CMUtility.readInt();
         if (index == -1) {
            return; //跳出循环，即进入entMainMune（因为在entMainMune中被调用）
         }

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

      System.out.print("确认是否删除(Y/N)：");
      char yn = CMUtility.readConfirmSelection();
      if (yn == 'N')
         return;

      boolean flag = customers.deleteCustomer(index - 1);
      if (flag) {
         System.out
               .println("---------------------删除完成---------------------");
      } else {
         System.out.println("----------无法找到指定客户,删除失败--------------");
      }
   }

   private void listAllCustomers() {
        System.out.println("---------------------------客户列表---------------------------");
        Customer[] custs = customers.getAllCustomers();
        if (custs.length == 0) {
            System.out.println("没有客户记录！");
        } else {
            System.out.println("编号\t姓名\t性别\t年龄\t\t电话\t\t邮箱");
            for (int i = 0; i < custs.length; i++) {
//            System.out.println(i + 1 + "\t" + custs[i].getName() + "\t" + custs[i].getGender() + "\t" + custs[i].getAge() + "\t\t" + custs[i].getPhone() + "\t" + custs[i].getEmail());
               System.out.println((i+1) + "\t" + custs[i].getDetails());
            }
        }

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

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

CustomerList类：

public class CustomerList {
    private Customer[] customers;
    private int total = 0;

    public CustomerList(int totalCustomer) {
        customers = new Customer[totalCustomer];
    }

    public boolean addCustomer(Customer customer) {
        if (total >= customers.length) return false;

        customers[total++] = customer;
        return true;
    }

    public boolean replaceCustomer(int index, Customer cust) {
        if (index < 0 || index >= total) return false;

        customers[index] = cust;
        return true;
    }

    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;

        return true;
    }

    public Customer[] getAllCustomers() {
        Customer[] custs = new Customer[total];
        for (int i = 0; i < total; i++) {
            custs[i] = customers[i];
        }
        return custs;
    }

    public int getTotal() {
        return total;
    }

    public Customer getCustomer(int index) {
        if (index < 0 || index >= total) return null;

        return customers[index];
    }
}

CMUtility类：

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

项目三:

软件设计架构：

package com.atguigu.team.service;

import com.atguigu.team.domain.*;

import static com.atguigu.team.service.Data.*;//直接导入data类，可直接引用data中的静态量

public class NameListService {
	private Employee[] employees;//employees多处使用在外声明

    /*根据项目提供的Data类构建相应大小的employees数组
再根据Data类中的数据构建不同的对象，包括Employee、Programmer、Designer和Architect对象，以及相关联的Equipment子类的对象
将对象存于数组中
    */
	public NameListService() {
		employees = new Employee[EMPLOYEES.length];//如果前面没有导入Data类，必须写成Data.EMPLOYEES.length，下同

		for (int i = 0; i < employees.length; i++) {
			// 获取通用的属性
			int type = Integer.parseInt(EMPLOYEES[i][0]);
			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 eq; //case下的多种情况都需要使用，直接定义在循环外可减少多次定义相同变量的问题，下同
			double bonus;
			int stock;

			switch (type) {
			case EMPLOYEE:  //case 变量名可以防止之后变量的值改变导致的程序修改问题
				employees[i] = new Employee(id, name, age, salary);
				break;
			case PROGRAMMER:
				eq = createEquipment(i); //多态
				employees[i] = new Programmer(id, name, age, salary, eq);
				break;
			case DESIGNER:
				eq = createEquipment(i);//因为每个人的equipment不一样，所以应该写一个方法选择，且data中知与employees一一对应
				bonus = Integer.parseInt(EMPLOYEES[i][5]);
				employees[i] = new Designer(id, name, age, salary, eq, bonus);
				break;
			case ARCHITECT:
				eq = createEquipment(i);
				bonus = Integer.parseInt(EMPLOYEES[i][5]);
				stock = Integer.parseInt(EMPLOYEES[i][6]);
				employees[i] = new Architect(id, name, age, salary, eq, bonus,
						stock);
				break;
			}
		}
	}

	private Equipment createEquipment(int index) {
		int type = Integer.parseInt(EQIPMENTS[index][0]);
		switch (type) {
		case PC:
			return new PC(EQIPMENTS[index][1], EQIPMENTS[index][2]); //返回一个对象
		case NOTEBOOK:
			int price = Integer.parseInt(EQIPMENTS[index][2]);
			return new NoteBook(EQIPMENTS[index][1], price);
		case PRINTER:
			return new Printer(EQIPMENTS[index][1], EQIPMENTS[index][2]);
		}
		return null;
	}

	public Employee[] getAllEmployees() {
		return employees;
	}

	public Employee getEmployee(int id) throws TeamException {
		for (Employee e : employees) {//java for each循环 ：遍历数组或集合 for(var i: arr)
			if (e.getId() == id)
				return e;
		}
		throw new TeamException("该员工不存在");//注意这里为什么不用try catch,因为这里的需要被调用才执行，所以因写成throw
	}//向被调用者抛异常，再对被调用者try catch
}

Data类：

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

自定义的异常类：

public class TeamException extends Exception {
	static final long serialVersionUID = -33875169124229948L;

	public TeamException() {
	}

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

teamservice:

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;//团队实际人数

    public TeamService() {
    }
    //返回team中所有程序员构成的数组
    public Programmer[] getTeam() {
        Programmer[] team = new Programmer[total];

        for (int i = 0; i < total; i++) {
            team[i] = this.team[i];//this使用当前类的属性或方法
        }
        return team;
    }

    public void addMember(Employee e) throws TeamException {
        if (total >= MAX_MEMBER)
            throw new TeamException("成员已满，无法添加");
        if (!(e instanceof Programmer))
            throw new TeamException("该成员不是开发人员，无法添加");

        Programmer p = (Programmer)e; //因为对象e一定是programer或其子类,可将其强转为programer
       //(因为如果不是的话上面必定报错，同时上面数组也是programer)
        if (isExist(p))
        	throw new TeamException("该员工已在本团队中");

        if(p.getStatus().getNAME().equals("BUSY")) { //避免出现空指针异常，getName方法得到的是一个String类型的返回值
            //像String、Date、File、包装类都重写了object类中的equals（）方法，重写以后比较的不是引用地址是否相同，而是比较两个对象的“实体内容”是否相同
        	throw new TeamException("该员工已是某团队成员");
        }else if(p.getStatus().getNAME().equals("VOCATION")) {
        	throw new TeamException("该员正在休假，无法添加");
        }

//        switch (p.getStatus()) {
//            case BUSY    :throw new TeamException("该员工已是某团队成员");
//            case VOCATION:throw new TeamException("该员正在休假，无法添加");
//        }

        int numOfArch = 0, numOfDsgn = 0, numOfPrg = 0;
        for (int i = 0; i < total; i++) {
            if (team[i] instanceof Architect) numOfArch++;  //注意先判断类型小的
            else if (team[i] instanceof Designer) numOfDsgn++;
            else if (team[i] instanceof Programmer) numOfPrg++;
        }
	//面向对象的角度来说p指向的是一个地址值
        if (p instanceof Architect) {
            if (numOfArch >= 1) throw new TeamException("团队中至多只能有一名架构师");
        } else if (p instanceof Designer) {
            if (numOfDsgn >= 2) throw new TeamException("团队中至多只能有两名设计师");
        } else if (p instanceof Programmer) {
            if (numOfPrg >= 3) throw new TeamException("团队中至多只能有三名程序员");
        }
        //添加到数组
        p.setStatus(Status.BUSY);
        p.setMemberId(counter++);
        team[total++] = p;
    }

    private boolean isExist(Programmer p) {
        for (int i = 0; i < total; i++) {
            if (team[i].getId() == p.getId()) return true;
        }

        return false;
    }
    //删除指定memberId的程序员
    public void removeMember(int memberId) throws TeamException {
        int n = 0;
        //找到指定memberId的员工，并删除
        for (; n < total; n++) {
            if (team[n].getMemberId() == memberId) {
                team[n].setStatus(Status.FREE);
                break;
            }
        }
        //如果遍历一遍，都找不到，则报异常
        if (n == total)
            throw new TeamException("找不到该成员，无法删除");
        //后面的元素覆盖前面的元素
        for (int i = n + 1; i < total; i++) {
            team[i - 1] = team[i];
        }
        team[--total] = null;
    }
}

Team View类：

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

public class TeamView {
	private NameListService listSvc = new NameListService();
	private TeamService teamSvc = new TeamService();

	public void enterMainMenu() {
		boolean loopFlag = true;
		char key = 0;

		do {
			if (key != '1') {    //在进行1操作时不执行entMainMenu
				listAllEmployees();
			}
			System.out.print("1-团队列表  2-添加团队成员  3-删除团队成员 4-退出   请选择(1-4)：");
			key = TSUtility.readMenuSelection();
			System.out.println();
			switch (key) {
			case '1':
				listTeam();
				break;
			case '2':
				addMember();
				break;
			case '3':
				deleteMember();
				break;
			case '4':
				System.out.print("确认是否退出(Y/N)：");
				char yn = TSUtility.readConfirmSelection();
				if (yn == 'Y')
					loopFlag = false;
				break;
			}
		} while (loopFlag);
	}

	// 显示所有的员工成员
	private void listAllEmployees() {
		System.out
				.println("\n-------------------------------开发团队调度软件--------------------------------\n");
		Employee[] emps = listSvc.getAllEmployees();
		if (emps.length == 0) {
			System.out.println("没有客户记录！");
		} else {
			System.out.println("ID\t姓名\t年龄\t工资\t职位\t状态\t奖金\t股票\t领用设备");
		}

		for (Employee e : emps) {
			System.out.println(" " + e);//注意：这里要重写Employ类及其子类的toString()方法，不然输出的是地址值
		}
		System.out
				.println("-------------------------------------------------------------------------------");
	}

	// 显示开发团队成员列表
	private void listTeam() {
		System.out
				.println("\n--------------------团队成员列表---------------------\n");
		Programmer[] team = teamSvc.getTeam();
		if (team.length == 0) {
			System.out.println("开发团队目前没有成员！");
		} else {
			System.out.println("TID/ID\t姓名\t年龄\t工资\t职位\t奖金\t股票");
		}

		for (Programmer p : team) {
			System.out.println(" " + p.getDetailsForTeam());  //每个子类根据拥有内容的差异分别被
            //重写getDetailsForTeam()方法
            /*1.employee类中的getDetails()方法：
            protected String getDetails() {
        	return id + "\t" + name + "\t" + age+ "\t" +salary;
    		}

             2.programmer中的getDetailsForTeam()方法：
             public String getDetailsForTeam() {
       		 return getMemberDetails() + "\t程序员";
    		}
            */
		}
		System.out
				.println("-----------------------------------------------------");
	}

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

		try {
			Employee e = listSvc.getEmployee(id);
			teamSvc.addMember(e);
			System.out.println("添加成功");
		} catch (TeamException e) {
			System.out.println("添加失败，原因：" + e.getMessage());
		}
		// 按回车键继续...
		TSUtility.readReturn();
	}

	// 从团队中删除指定id的成员
	private void deleteMember() {
		System.out.println("---------------------删除成员---------------------");
		System.out.print("请输入要删除员工的TID：");
		int id = TSUtility.readInt();
		System.out.print("确认是否删除(Y/N)：");
		char yn = TSUtility.readConfirmSelection();
		if (yn == 'N')
			return;

		try {
			teamSvc.removeMember(id);
			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();
	}
}