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

eclipes提示：

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

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

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

项目二：

customer类：

  1. public class Customer {
  2.    private String name;
  3.    private char gender;
  4.    private int age;
  5.    private String phone;
  6.    private String email;
  8.    public Customer(String name, char gender, int age) {
  9.       this(name, gender, age, "", "");
  10.    }
  12.    public Customer(String name, char gender, int age, String phone,
  13.          String email) {
  14.       this.name = name;
  15.       this.gender = gender;
  16.       this.age = age;
  17.       this.phone = phone;
  18.       this.email = email;
  19.    }
  21.    public String getName() {
  22.       return name;
  23.    }
  25.    public void setName(String name) {
  26.       this.name = name;
  27.    }
  29.    public char getGender() {
  30.       return gender;
  31.    }
  33.    public void setGender(char gender) {
  34.       this.gender = gender;
  35.    }
  37.    public int getAge() {
  38.       return age;
  39.    }
  41.    public void setAge(int age) {
  42.       this.age = age;
  43.    }
  45.    public String getPhone() {
  46.       return phone;
  47.    }
  49.    public void setPhone(String phone) {
  50.       this.phone = phone;
  51.    }
  53.    public String getEmail() {
  54.       return email;
  55.    }
  57.    public void setEmail(String email) {
  58.       this.email = email;
  59.    }
  61.    public String getDetails() {
  62.       return name + "\t" + gender + "\t" + age + "\t\t" + phone + "\t" + email;
  63.    }
  64. }

CustomerView类：

  1. public class CustomerView {
  2.    private CustomerList customers = new CustomerList(10);
  4.    public CustomerView() {
  5.       Customer cust = new Customer("张三", '男', 30, "010-56253825",
  6.             "abc@email.com");
  7.       customers.addCustomer(cust);
  8.    }
  10.    public void enterMainMenu() {
  11.       boolean loopFlag = true;
  12.       do {
  13.          System.out
  14.                .println("\n-----------------客户信息管理软件-----------------\n");
  15.          System.out.println("                   1 添 加 客 户");
  16.          System.out.println("                   2 修 改 客 户");
  17.          System.out.println("                   3 删 除 客 户");
  18.          System.out.println("                   4 客 户 列 表");
  19.          System.out.println("                   5 退       出\n");
  20.          System.out.print("                   请选择(1-5)：");
  22.          char key = CMUtility.readMenuSelection();
  23.          System.out.println();
  24.          switch (key) {
  25.          case '1':
  26.             addNewCustomer();
  27.             break;
  28.          case '2':
  29.             modifyCustomer();
  30.             break;
  31.          case '3':
  32.             deleteCustomer();
  33.             break;
  34.          case '4':
  35.             listAllCustomers();
  36.             break;
  37.          case '5':
  38.             System.out.print("确认是否退出(Y/N)：");
  39.             char yn = CMUtility.readConfirmSelection();
  40.             if (yn == 'Y')
  41.                loopFlag = false;
  42.             break;
  43.          }
  44.       } while (loopFlag);
  45.    }
  47.    private void addNewCustomer() {
  48.       System.out.println("---------------------添加客户---------------------");
  49.       System.out.print("姓名：");
  50.       String name = CMUtility.readString(4);
  51.       System.out.print("性别：");
  52.       char gender = CMUtility.readChar();
  53.       System.out.print("年龄：");
  54.       int age = CMUtility.readInt();
  55.       System.out.print("电话：");
  56.       String phone = CMUtility.readString(15);
  57.       System.out.print("邮箱：");
  58.       String email = CMUtility.readString(15);
  60.       Customer cust = new Customer(name, gender, age, phone, email);
  61.       boolean flag = customers.addCustomer(cust);
  62.       if (flag) {
  63.          System.out
  64.                .println("---------------------添加完成---------------------");
  65.       } else {
  66.          System.out.println("----------------记录已满,无法添加-----------------");
  67.       }
  68.    }
  70.    private void modifyCustomer() {
  71.       System.out.println("---------------------修改客户---------------------");
  73.       int index = 0;
  74.       Customer cust = null;
  75.       for (;;) {
  76.          System.out.print("请选择待修改客户编号(-1退出)：");
  77.          index = CMUtility.readInt();
  78.          if (index == -1) {
  79.             return;
  80.          }
  82.          cust = customers.getCustomer(index - 1);
  83.          if (cust == null) {
  84.             System.out.println("无法找到指定客户！");
  85.          } else
  86.             break;
  87.       }
  89.       System.out.print("姓名(" + cust.getName() + ")：");
  90.       String name = CMUtility.readString(4, cust.getName()); //如果没有输入字符串就以原先对象的值为返回值
  92.       System.out.print("性别(" + cust.getGender() + ")：");
  93.       char gender = CMUtility.readChar(cust.getGender());
  95.       System.out.print("年龄(" + cust.getAge() + ")：");
  96.       int age = CMUtility.readInt(cust.getAge());
  98.       System.out.print("电话(" + cust.getPhone() + ")：");
  99.       String phone = CMUtility.readString(15, cust.getPhone());
  101.       System.out.print("邮箱(" + cust.getEmail() + ")：");
  102.       String email = CMUtility.readString(15, cust.getEmail());
  104.       cust = new Customer(name, gender, age, phone, email);
  106.       boolean flag = customers.replaceCustomer(index - 1, cust); //将修改信息创建新的对象调用flag判断成立
  107.       if (flag) {
  108.          System.out
  109.                .println("---------------------修改完成---------------------");
  110.       } else {
  111.          System.out.println("----------无法找到指定客户,修改失败--------------");
  112.       }
  113.    }
  115.    private void deleteCustomer() {
  116.       System.out.println("---------------------删除客户---------------------");
  118.       int index = 0;//将index和cust定义在循环外，使循环内的各处都可以访问变量
  119.       Customer cust = null;
  120.       for (;;) {//这种for循环的目的是为了在输入错误的条件下继续一直输入，直至正确
  121.          System.out.print("请选择待删除客户编号(-1退出)：");
  122.          index = CMUtility.readInt();
  123.          if (index == -1) {
  124.             return; //跳出循环，即进入entMainMune（因为在entMainMune中被调用）
  125.          }
  127.          cust = customers.getCustomer(index - 1);
  128.          if (cust == null) {
  129.             System.out.println("无法找到指定客户！");
  130.          } else
  131.             break;
  132.       }
  134.       System.out.print("确认是否删除(Y/N)：");
  135.       char yn = CMUtility.readConfirmSelection();
  136.       if (yn == 'N')
  137.          return;
  139.       boolean flag = customers.deleteCustomer(index - 1);
  140.       if (flag) {
  141.          System.out
  142.                .println("---------------------删除完成---------------------");
  143.       } else {
  144.          System.out.println("----------无法找到指定客户,删除失败--------------");
  145.       }
  146.    }
  148.    private void listAllCustomers() {
  149.         System.out.println("---------------------------客户列表---------------------------");
  150.         Customer[] custs = customers.getAllCustomers();
  151.         if (custs.length == 0) {
  152.             System.out.println("没有客户记录！");
  153.         } else {
  154.             System.out.println("编号\t姓名\t性别\t年龄\t\t电话\t\t邮箱");
  155.             for (int i = 0; i < custs.length; i++) {
  156. //            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());
  157.                System.out.println((i+1) + "\t" + custs[i].getDetails());
  158.             }
  159.         }
  161.         System.out.println("-------------------------客户列表完成-------------------------");
  162.     }
  164.    public static void main(String[] args) {
  165.       CustomerView cView = new CustomerView();
  166.       cView.enterMainMenu();
  167.    }
  168. }

CustomerList类：

  1. public class CustomerList {
  2.     private Customer[] customers;
  3.     private int total = 0;
  5.     public CustomerList(int totalCustomer) {
  6.         customers = new Customer[totalCustomer];
  7.     }
  9.     public boolean addCustomer(Customer customer) {
  10.         if (total >= customers.length) return false;
  12.         customers[total++] = customer;
  13.         return true;
  14.     }
  16.     public boolean replaceCustomer(int index, Customer cust) {
  17.         if (index < 0 || index >= total) return false;
  19.         customers[index] = cust;
  20.         return true;
  21.     }
  23.     public boolean deleteCustomer(int index) {
  24.         if (index < 0 || index >= total) return false;
  26.         for (int i = index; i < total - 1; i++) {
  27.             customers[i] = customers[i + 1];
  28.         }
  30.         customers[--total] = null;
  32.         return true;
  33.     }
  35.     public Customer[] getAllCustomers() {
  36.         Customer[] custs = new Customer[total];
  37.         for (int i = 0; i < total; i++) {
  38.             custs[i] = customers[i];
  39.         }
  40.         return custs;
  41.     }
  43.     public int getTotal() {
  44.         return total;
  45.     }
  47.     public Customer getCustomer(int index) {
  48.         if (index < 0 || index >= total) return null;
  50.         return customers[index];
  51.     }
  52. }

CMUtility类：

  1. import java.util.*;
  2. /**
  3. CMUtility工具类：
  4. 将不同的功能封装为方法，就是可以直接通过调用方法使用它的功能，而无需考虑具体的功能实现细节。
  5. */
  6. public class CMUtility {
  7.     private static Scanner scanner = new Scanner(System.in);
  8.     /**
  9.    用于界面菜单的选择。该方法读取键盘，如果用户键入’1’-’5’中的任意字符，则方法返回。返回值为用户键入字符。
  10.    */
  11.    public static char readMenuSelection() {
  12.         char c;
  13.         for (; ; ) {
  14.             String str = readKeyBoard(1, false);
  15.             c = str.charAt(0);
  16.             if (c != '1' && c != '2' &&
  17.                 c != '3' && c != '4' && c != '5') {
  18.                 System.out.print("选择错误，请重新输入：");
  19.             } else break;
  20.         }
  21.         return c;
  22.     }
  23.    /**
  24.    从键盘读取一个字符，并将其作为方法的返回值。
  25.    */
  26.     public static char readChar() {
  27.         String str = readKeyBoard(1, false);
  28.         return str.charAt(0);
  29.     }
  30.    /**
  31.    从键盘读取一个字符，并将其作为方法的返回值。
  32.    如果用户不输入字符而直接回车，方法将以defaultValue 作为返回值。
  33.    */
  34.     public static char readChar(char defaultValue) {
  35.         String str = readKeyBoard(1, true);
  36.         return (str.length() == 0) ? defaultValue : str.charAt(0);
  37.     }
  38.    /**
  39.    从键盘读取一个长度不超过2位的整数，并将其作为方法的返回值。
  40.    */
  41.     public static int readInt() {
  42.         int n;
  43.         for (; ; ) {
  44.             String str = readKeyBoard(2, false);
  45.             try {
  46.                 n = Integer.parseInt(str);
  47.                 break;
  48.             } catch (NumberFormatException e) {
  49.                 System.out.print("数字输入错误，请重新输入：");
  50.             }
  51.         }
  52.         return n;
  53.     }
  54.    /**
  55.    从键盘读取一个长度不超过2位的整数，并将其作为方法的返回值。
  56.    如果用户不输入字符而直接回车，方法将以defaultValue 作为返回值。
  57.    */
  58.     public static int readInt(int defaultValue) {
  59.         int n;
  60.         for (; ; ) {
  61.             String str = readKeyBoard(2, true);
  62.             if (str.equals("")) {
  63.                 return defaultValue;
  64.             }
  66.             try {
  67.                 n = Integer.parseInt(str);
  68.                 break;
  69.             } catch (NumberFormatException e) {
  70.                 System.out.print("数字输入错误，请重新输入：");
  71.             }
  72.         }
  73.         return n;
  74.     }
  75.    /**
  76.    从键盘读取一个长度不超过limit的字符串，并将其作为方法的返回值。
  77.    */
  78.     public static String readString(int limit) {
  79.         return readKeyBoard(limit, false);
  80.     }
  81.    /**
  82.    从键盘读取一个长度不超过limit的字符串，并将其作为方法的返回值。
  83.    如果用户不输入字符而直接回车，方法将以defaultValue 作为返回值。
  84.    */
  85.     public static String readString(int limit, String defaultValue) {
  86.         String str = readKeyBoard(limit, true);
  87.         return str.equals("")? defaultValue : str;
  88.     }
  89.    /**
  90.    用于确认选择的输入。该方法从键盘读取‘Y’或’N’，并将其作为方法的返回值。
  91.    */
  92.     public static char readConfirmSelection() {
  93.         char c;
  94.         for (; ; ) {
  95.             String str = readKeyBoard(1, false).toUpperCase();
  96.             c = str.charAt(0);
  97.             if (c == 'Y' || c == 'N') {
  98.                 break;
  99.             } else {
  100.                 System.out.print("选择错误，请重新输入：");
  101.             }
  102.         }
  103.         return c;
  104.     }
  106.     private static String readKeyBoard(int limit, boolean blankReturn) {
  107.         String line = "";
  109.         while (scanner.hasNextLine()) {
  110.             line = scanner.nextLine();
  111.             if (line.length() == 0) {
  112.                 if (blankReturn) return line;
  113.                 else continue;
  114.             }
  116.             if (line.length() < 1 || line.length() > limit) {
  117.                 System.out.print("输入长度（不大于" + limit + "）错误，请重新输入：");
  118.                 continue;
  119.             }
  120.             break;
  121.         }
  123.         return line;
  124.     }
  125. }

项目三:

软件设计架构：

  1. package com.atguigu.team.service;
  3. import com.atguigu.team.domain.*;
  5. import static com.atguigu.team.service.Data.*;//直接导入data类，可直接引用data中的静态量
  7. public class NameListService {
  8. 	private Employee[] employees;//employees多处使用在外声明
  10.     /*根据项目提供的Data类构建相应大小的employees数组
  11. 再根据Data类中的数据构建不同的对象，包括Employee、Programmer、Designer和Architect对象，以及相关联的Equipment子类的对象
  12. 将对象存于数组中
  13.     */
  14. 	public NameListService() {
  15. 		employees = new Employee[EMPLOYEES.length];//如果前面没有导入Data类，必须写成Data.EMPLOYEES.length，下同
  17. 		for (int i = 0; i < employees.length; i++) {
  18. 			// 获取通用的属性
  19. 			int type = Integer.parseInt(EMPLOYEES[i][0]);
  20. 			int id = Integer.parseInt(EMPLOYEES[i][1]);
  21. 			String name = EMPLOYEES[i][2];
  22. 			int age = Integer.parseInt(EMPLOYEES[i][3]);
  23. 			double salary = Double.parseDouble(EMPLOYEES[i][4]);
  25. 			//
  26. 			Equipment eq; //case下的多种情况都需要使用，直接定义在循环外可减少多次定义相同变量的问题，下同
  27. 			double bonus;
  28. 			int stock;
  30. 			switch (type) {
  31. 			case EMPLOYEE:  //case 变量名可以防止之后变量的值改变导致的程序修改问题
  32. 				employees[i] = new Employee(id, name, age, salary);
  33. 				break;
  34. 			case PROGRAMMER:
  35. 				eq = createEquipment(i); //多态
  36. 				employees[i] = new Programmer(id, name, age, salary, eq);
  37. 				break;
  38. 			case DESIGNER:
  39. 				eq = createEquipment(i);//因为每个人的equipment不一样，所以应该写一个方法选择，且data中知与employees一一对应
  40. 				bonus = Integer.parseInt(EMPLOYEES[i][5]);
  41. 				employees[i] = new Designer(id, name, age, salary, eq, bonus);
  42. 				break;
  43. 			case ARCHITECT:
  44. 				eq = createEquipment(i);
  45. 				bonus = Integer.parseInt(EMPLOYEES[i][5]);
  46. 				stock = Integer.parseInt(EMPLOYEES[i][6]);
  47. 				employees[i] = new Architect(id, name, age, salary, eq, bonus,
  48. 						stock);
  49. 				break;
  50. 			}
  51. 		}
  52. 	}
  54. 	private Equipment createEquipment(int index) {
  55. 		int type = Integer.parseInt(EQIPMENTS[index][0]);
  56. 		switch (type) {
  57. 		case PC:
  58. 			return new PC(EQIPMENTS[index][1], EQIPMENTS[index][2]); //返回一个对象
  59. 		case NOTEBOOK:
  60. 			int price = Integer.parseInt(EQIPMENTS[index][2]);
  61. 			return new NoteBook(EQIPMENTS[index][1], price);
  62. 		case PRINTER:
  63. 			return new Printer(EQIPMENTS[index][1], EQIPMENTS[index][2]);
  64. 		}
  65. 		return null;
  66. 	}
  68. 	public Employee[] getAllEmployees() {
  69. 		return employees;
  70. 	}
  72. 	public Employee getEmployee(int id) throws TeamException {
  73. 		for (Employee e : employees) {//java for each循环 ：遍历数组或集合 for(var i: arr)
  74. 			if (e.getId() == id)
  75. 				return e;
  76. 		}
  77. 		throw new TeamException("该员工不存在");//注意这里为什么不用try catch,因为这里的需要被调用才执行，所以因写成throw
  78. 	}//向被调用者抛异常，再对被调用者try catch
  79. }

Data类：

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

自定义的异常类：

  1. public class TeamException extends Exception {
  2. 	static final long serialVersionUID = -33875169124229948L;
  4. 	public TeamException() {
  5. 	}
  7. 	public TeamException(String message) {
  8. 		super(message);
  9. 	}
  10. }

teamservice:

  1. package com.atguigu.team.service;
  3. import com.atguigu.team.domain.*;
  5. public class TeamService {
  6.     private static int counter = 1;//用于自动生成团队成员的memberId
  7.     private final int MAX_MEMBER = 5;//团队人数上限
  8.     private Programmer[] team = new Programmer[MAX_MEMBER];//保存当前团队成员
  9.     private int total = 0;//团队实际人数
  11.     public TeamService() {
  12.     }
  13.     //返回team中所有程序员构成的数组
  14.     public Programmer[] getTeam() {
  15.         Programmer[] team = new Programmer[total];
  17.         for (int i = 0; i < total; i++) {
  18.             team[i] = this.team[i];//this使用当前类的属性或方法
  19.         }
  20.         return team;
  21.     }
  23.     public void addMember(Employee e) throws TeamException {
  24.         if (total >= MAX_MEMBER)
  25.             throw new TeamException("成员已满，无法添加");
  26.         if (!(e instanceof Programmer))
  27.             throw new TeamException("该成员不是开发人员，无法添加");
  29.         Programmer p = (Programmer)e; //因为对象e一定是programer或其子类,可将其强转为programer
  30.        //(因为如果不是的话上面必定报错，同时上面数组也是programer)
  31.         if (isExist(p))
  32.         	throw new TeamException("该员工已在本团队中");
  34.         if(p.getStatus().getNAME().equals("BUSY")) { //避免出现空指针异常，getName方法得到的是一个String类型的返回值
  35.             //像String、Date、File、包装类都重写了object类中的equals（）方法，重写以后比较的不是引用地址是否相同，而是比较两个对象的“实体内容”是否相同
  36.         	throw new TeamException("该员工已是某团队成员");
  37.         }else if(p.getStatus().getNAME().equals("VOCATION")) {
  38.         	throw new TeamException("该员正在休假，无法添加");
  39.         }
  41. //        switch (p.getStatus()) {
  42. //            case BUSY    :throw new TeamException("该员工已是某团队成员");
  43. //            case VOCATION:throw new TeamException("该员正在休假，无法添加");
  44. //        }
  46.         int numOfArch = 0, numOfDsgn = 0, numOfPrg = 0;
  47.         for (int i = 0; i < total; i++) {
  48.             if (team[i] instanceof Architect) numOfArch++;  //注意先判断类型小的
  49.             else if (team[i] instanceof Designer) numOfDsgn++;
  50.             else if (team[i] instanceof Programmer) numOfPrg++;
  51.         }
  52. 	//面向对象的角度来说p指向的是一个地址值
  53.         if (p instanceof Architect) {
  54.             if (numOfArch >= 1) throw new TeamException("团队中至多只能有一名架构师");
  55.         } else if (p instanceof Designer) {
  56.             if (numOfDsgn >= 2) throw new TeamException("团队中至多只能有两名设计师");
  57.         } else if (p instanceof Programmer) {
  58.             if (numOfPrg >= 3) throw new TeamException("团队中至多只能有三名程序员");
  59.         }
  60.         //添加到数组
  61.         p.setStatus(Status.BUSY);
  62.         p.setMemberId(counter++);
  63.         team[total++] = p;
  64.     }
  66.     private boolean isExist(Programmer p) {
  67.         for (int i = 0; i < total; i++) {
  68.             if (team[i].getId() == p.getId()) return true;
  69.         }
  71.         return false;
  72.     }
  73.     //删除指定memberId的程序员
  74.     public void removeMember(int memberId) throws TeamException {
  75.         int n = 0;
  76.         //找到指定memberId的员工，并删除
  77.         for (; n < total; n++) {
  78.             if (team[n].getMemberId() == memberId) {
  79.                 team[n].setStatus(Status.FREE);
  80.                 break;
  81.             }
  82.         }
  83.         //如果遍历一遍，都找不到，则报异常
  84.         if (n == total)
  85.             throw new TeamException("找不到该成员，无法删除");
  86.         //后面的元素覆盖前面的元素
  87.         for (int i = n + 1; i < total; i++) {
  88.             team[i - 1] = team[i];
  89.         }
  90.         team[--total] = null;
  91.     }
  92. }

Team View类：

  1. import com.atguigu.team.domain.*;
  2. import com.atguigu.team.service.*;
  4. public class TeamView {
  5. 	private NameListService listSvc = new NameListService();
  6. 	private TeamService teamSvc = new TeamService();
  8. 	public void enterMainMenu() {
  9. 		boolean loopFlag = true;
  10. 		char key = 0;
  12. 		do {
  13. 			if (key != '1') {    //在进行1操作时不执行entMainMenu
  14. 				listAllEmployees();
  15. 			}
  16. 			System.out.print("1-团队列表  2-添加团队成员  3-删除团队成员 4-退出   请选择(1-4)：");
  17. 			key = TSUtility.readMenuSelection();
  18. 			System.out.println();
  19. 			switch (key) {
  20. 			case '1':
  21. 				listTeam();
  22. 				break;
  23. 			case '2':
  24. 				addMember();
  25. 				break;
  26. 			case '3':
  27. 				deleteMember();
  28. 				break;
  29. 			case '4':
  30. 				System.out.print("确认是否退出(Y/N)：");
  31. 				char yn = TSUtility.readConfirmSelection();
  32. 				if (yn == 'Y')
  33. 					loopFlag = false;
  34. 				break;
  35. 			}
  36. 		} while (loopFlag);
  37. 	}
  39. 	// 显示所有的员工成员
  40. 	private void listAllEmployees() {
  41. 		System.out
  42. 				.println("\n-------------------------------开发团队调度软件--------------------------------\n");
  43. 		Employee[] emps = listSvc.getAllEmployees();
  44. 		if (emps.length == 0) {
  45. 			System.out.println("没有客户记录！");
  46. 		} else {
  47. 			System.out.println("ID\t姓名\t年龄\t工资\t职位\t状态\t奖金\t股票\t领用设备");
  48. 		}
  50. 		for (Employee e : emps) {
  51. 			System.out.println(" " + e);//注意：这里要重写Employ类及其子类的toString()方法，不然输出的是地址值
  52. 		}
  53. 		System.out
  54. 				.println("-------------------------------------------------------------------------------");
  55. 	}
  57. 	// 显示开发团队成员列表
  58. 	private void listTeam() {
  59. 		System.out
  60. 				.println("\n--------------------团队成员列表---------------------\n");
  61. 		Programmer[] team = teamSvc.getTeam();
  62. 		if (team.length == 0) {
  63. 			System.out.println("开发团队目前没有成员！");
  64. 		} else {
  65. 			System.out.println("TID/ID\t姓名\t年龄\t工资\t职位\t奖金\t股票");
  66. 		}
  68. 		for (Programmer p : team) {
  69. 			System.out.println(" " + p.getDetailsForTeam());  //每个子类根据拥有内容的差异分别被
  70.             //重写getDetailsForTeam()方法
  71.             /*1.employee类中的getDetails()方法：
  72.             protected String getDetails() {
  73.         	return id + "\t" + name + "\t" + age+ "\t" +salary;
  74.     		}
  76.              2.programmer中的getDetailsForTeam()方法：
  77.              public String getDetailsForTeam() {
  78.        		 return getMemberDetails() + "\t程序员";
  79.     		}
  80.             */
  81. 		}
  82. 		System.out
  83. 				.println("-----------------------------------------------------");
  84. 	}
  86. 	// 添加成员到团队
  87. 	private void addMember() {
  88. 		System.out.println("---------------------添加成员---------------------");
  89. 		System.out.print("请输入要添加的员工ID：");
  90. 		int id = TSUtility.readInt();
  92. 		try {
  93. 			Employee e = listSvc.getEmployee(id);
  94. 			teamSvc.addMember(e);
  95. 			System.out.println("添加成功");
  96. 		} catch (TeamException e) {
  97. 			System.out.println("添加失败，原因：" + e.getMessage());
  98. 		}
  99. 		// 按回车键继续...
  100. 		TSUtility.readReturn();
  101. 	}
  103. 	// 从团队中删除指定id的成员
  104. 	private void deleteMember() {
  105. 		System.out.println("---------------------删除成员---------------------");
  106. 		System.out.print("请输入要删除员工的TID：");
  107. 		int id = TSUtility.readInt();
  108. 		System.out.print("确认是否删除(Y/N)：");
  109. 		char yn = TSUtility.readConfirmSelection();
  110. 		if (yn == 'N')
  111. 			return;
  113. 		try {
  114. 			teamSvc.removeMember(id);
  115. 			System.out.println("删除成功");
  116. 		} catch (TeamException e) {
  117. 			System.out.println("删除失败，原因：" + e.getMessage());
  118. 		}
  119. 		// 按回车键继续...
  120. 		TSUtility.readReturn();
  121. 	}
  123. 	public static void main(String[] args) {
  124. 		TeamView view = new TeamView();
  125. 		view.enterMainMenu();
  126. 	}
  127. }

eclipes常见操作总结及项目2和3经验总结的更多相关文章

  1. react-native 常见操作 及 git 补充

    一. react-native 常见操作 1.创建项目 react-native init Market(项目名称,首字母大写) 2.安装常用插件 npm install react-native-t ...

  2. github常见操作和常见错误及其解决办法

    一.常见操作 1. 使用git在本地创建一个项目的过程 $ makdir ~/hello-world //创建一个项目hello-world $ cd ~/hello-world //打开这个项目 $ ...

  3. 动态单链表的传统存储方式和10种常见操作-C语言实现

    顺序线性表的优点:方便存取(随机的),特点是物理位置和逻辑为主都是连续的(相邻).但是也有不足,比如:前面的插入和删除算法,需要移动大量元素,浪费时间,那么链式线性表 (简称链表) 就能解决这个问题. ...

  4. C#路径/文件/目录/I/O常见操作汇总

    文件操作是程序中非常基础和重要的内容,而路径.文件.目录以及I/O都是在进行文件操作时的常见主题,这里想把这些常见的问题作个总结,对于每个问题,尽量提供一些解决方案,即使没有你想要的答案,也希望能提供 ...

  5. X-Cart 学习笔记（四）常见操作

    目录 X-Cart 学习笔记(一)了解和安装X-Cart X-Cart 学习笔记(二)X-Cart框架1 X-Cart 学习笔记(三)X-Cart框架2 X-Cart 学习笔记(四)常见操作 五.常见 ...

  6. 转：jQuery 常见操作实现方式

    http://www.cnblogs.com/guomingfeng/articles/2038707.html 一个优秀的 JavaScript 框架,一篇 jQuery 常用方法及函数的文章留存备 ...

  7. jQuery 常见操作实现方式

    一个优秀的 JavaScript 框架,一篇 jQuery 常用方法及函数的文章留存备忘. jQuery 常见操作实现方式 $("标签名") //取html元素 document. ...

  8. C#路径/文件/目录/I/O常见操作汇总<转载>

    文件操作是程序中非常基础和重要的内容,而路径.文件.目录以及I/O都是在进行文件操作时的常见主题,这里想把这些常见的问题作个总结,对于每个问题,尽量提供一些解决方案,即使没有你想要的答案,也希望能提供 ...

  9. [java学习笔记]java语言基础概述之数组的定义&常见操作(遍历、排序、查找)&二维数组

    1.数组基础 1.什么是数组:           同一类型数据的集合,就是一个容器. 2.数组的好处:           可以自动为数组中的元素从零开始编号,方便操作这些数据. 3.格式:  (一 ...

随机推荐

  1. 乘风破浪，遇见Android Jetpack之Compose声明式UI开发工具包，逐渐大一统的原生UI绘制体系

    什么是Android Jetpack https://developer.android.com/jetpack Android Jetpack是一个由多个库组成的套件,可帮助开发者遵循最佳做法.减少 ...

  2. 字节跳动上传了一份“面试官版Android面试小册”，不讲一句废话，全是精华

    前言 金三银四马上就到了,很多粉丝朋友私信希望我出一篇面试专题或者分享面试相关的笔记来学习,这不今天就给大家安排上了?(都是干货,错过就是亏.) 下面的面试笔记都是精心整理好免费分享给大家的,希望新朋 ...

  3. React Class组件生命周期

    一.react组件的两种定义方式 1.函数组件,简单的函数组件像下面这样,接收Props,渲染DOM,而不关注其他逻辑 function Welcome(props) { return <h1& ...

  4. JavaGUI三种布局管理器FlowLayout,BorderLayout,GridLayout的使用

    三种布局管理器 流式布局FlowLayout package GUI; import java.awt.*; import java.awt.event.WindowAdapter; import j ...

  5. Create Virtual Machines with Vagrant and Puppet

    Create the following puppet manifest and start VM with vagrant, you get a base production environmen ...

  6. 批量删除gmail邮件

    以删除tor.com发送的邮件为例说明. 首先点击邮件搜索框右边的三角,在"发件人"下面写上"tor.com": 点"搜索"按钮,看一下范围 ...

  7. ES6继承和ES5继承是完全一样的么?

    继承方式 ES5 prototype 继承 通过原型链(构造函数 + [[prototype]])指向实现继承. (备注:后续__proto__我都会写成[[prototype]]这种形式) 子类的 ...

  8. vue 快速入门 系列 —— vue-cli 下

    其他章节请看: vue 快速入门 系列 Vue CLI 4.x 下 在 vue loader 一文中我们已经学会从零搭建一个简单的,用于单文件组件开发的脚手架:本篇,我们将全面学习 vue-cli 这 ...

  9. Git-07-分支管理

    创建与合并分支 为什么要创建分支? 假设你准备开发一个新功能,但是需要两周才能完成, 第一周你写了50%的代码,如果立刻提交,由于代码还没写完,不完整的代码库会导致别人不能干活了. 如果等代码全部写完 ...

  10. HCNA Routing&Switching之访问控制列表ACL

    前文我们了解了DHCP服务相关话题,回顾请参考https://www.cnblogs.com/qiuhom-1874/p/15147870.html:今天我们来聊一聊访问控制列表ACL: ACL(ac ...