写在前面
经过两个多星期的学习，超梦终于把面向对象以及异常的基本知识学完了，在学习后半部分的内容之前，做了这个小项目，也困扰了我一天半。就在昨晚，终于把该项目的第一遍写完了！趁热打铁，赶紧把内容梳理一遍~~
本项目来自尚硅谷宋红康老师的JavaSE课程！强烈推荐！老师的课讲的真的很好！！！
文章目录
- 涉及知识点
- 需求
- 详细步骤及代码实现
- 总体框架实现
- （一）Equipment接口及其子类的实现
- （二）Employee及其子类的实现
- （三）NameListService类的实现
- （四）部分功能的测试
- （五）TeamService的实现
- （六）TeamView类的实现
- （七）测试各个功能
- 小结
涉及知识点
1.类的继承性和多态性
2.对象的值传递、接口
3.static和final修饰符
4.特殊类的使用：包装类、抽象类、内部类
5.异常处理
需求
功能概述
功能视图
添加团队
添加过程异常处理
删除功能
团队功能菜单
软件总体架构
MVC三层架构
详细步骤及代码实现
总体框架实现
建立的包：
关于工具类的说明
主要用途是键盘输入各种数据时避免很多重复性代码
正式开始进入写代码过程
（一）Equipment接口及其子类的实现
Equipment接口实现
主要是提供getDescription抽象方法
package com.deserts.domain;
public interface Equipment {
public abstract String getDescription();
}
PC类继承接口并实现
package com.deserts.domain;
public class PC implements Equipment {
String model;//型号
String display;//外观
public PC() {
super();
}
public PC(String model, String display) {
super();
this.model = model;
this.display = display;
}
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 model + "(" + display + ")";
}
}
NoteBook类继承接口并实现
package com.deserts.domain;
public class NoteBook implements Equipment {
String model;// 机型
double 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;
}
public NoteBook(String model, double price) {
super();
this.model = model;
this.price = price;
}
public NoteBook() {
super();
}
@Override//接口的实现
public String getDescription() {
return model + "(" + price + ")";
}
}
Printer类继承接口并实现
package com.deserts.domain;
public class Printer implements Equipment {
String name;//名字
String type;//类别
public Printer() {
super();
}
public Printer(String name, String type) {
super();
this.name = name;
this.type = type;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
@Override//接口的实现
public String getDescription() {
return name + "(" + type + ")";
}
}
（二）Employee及其子类的实现
注意，后面还会添加方法来完善显示功能
Employee类的基本实现
package com.deserts.domain;
public class Employee {
private int id;//公司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;
}
}
Programmer继承Employee的基本实现
package com.deserts.domain;
import com.deserts.services.Status;
/**
*
* @author HP
* 该类继承Employee，增加了属性memberId、status、equipment
* 提供了成员变量的get、set方法以及构造器
*/
public class Programmer extends Employee {
private int memberId;//团队ID
private Status status = Status.FREE;//状态（BUSY、FREE\VOCATION）
private Equipment equipment;//领用的设备
public Programmer() {
super();
}
public Programmer(int id, String name, int age, double salary, Equipment equipment) {
super(id, name, age, salary);
this.equipment = equipment;
}
public int getMemberId() {
return memberId;
}
public void setNumberId(int numberId) {
this.memberId = numberId;
}
public Status getStatus() {
return status;
}
public void setStatus(Status status) {
this.status = status;
}
public Equipment getEquiment() {
return equipment;
}
public void setEquiment(Equipment equipment) {
this.equipment = equipment;
}
}
其中Status类需要我们去实现，由于我还没学枚举，就跟着老师一起这样写Status类了，Stutus类放在com.deserts.services包下
package com.deserts.services;
public class Status {
private final String NAME;//常量
//利用私有构造器赋初值，私有是为了不在类外建对象
private Status(String name) {
this.NAME = name;
}
//下面是在类内创建静态公有对象，类外可以直接调用
public static final Status FREE = new Status("FREE");
public static final Status VOCATION = new Status("VOCATION");
public static final Status BUSY = new Status("BUSY");
public String getName() {
return NAME;
}
@Override
public String toString() {
return NAME;
}
}
Designer类继承Programmer的实现
package com.deserts.domain;
/**
*
* @author HP
* 该类继承Programmer，增加了属性bonus
* 提供了成员变量的get、set方法以及构造器
*/
public class Designer extends Programmer {
private double bonus;//奖金
public Designer() {
super();
}
public Designer(int id, String name, int age, double salary, Equipment equipment, double bonus) {
super(id, name, age, salary, equipment);
this.bonus = bonus;
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
}
Architect类继承Designer的实现
package com.deserts.domain;
/**
*
* @author HP
* 该类继承Designer，增加了属性stock
* 提供了成员属性的get、set方法以及构造器
*/
public class Architect extends Designer {
private int stock;//股票
public Architect() {
super();
}
public Architect(int id, String name, int age, double salary, Equipment equiment, double bonus, int stock) {
super(id, name, age, salary, equiment, bonus);
this.stock = stock;
}
public int getStock() {
return stock;
}
public void setStock(int stock) {
this.stock = stock;
}
}
（三）NameListService类的实现
该类位于com.deserts.view包下，主要功能：
负责将Data中的数据封装到Employee[]数组中，同时提供相关操作Employee[]的方法。
说明：
1.employees用来保存公司所有员工对象
2.NameListService()构造器：
01.根据项目提供的Data类构建相应大小的employees数组；
02.再根据Data类中的数据构建不同的对象，包括Employee、 Programmer、Designer和Architect对象，以及相关联的Equipment子类的对象；
03.将对象存于数组中
3…Data类位于com.atguigu.team.service包中
uml类图
导入的包
package com.deserts.services;
import static com.deserts.services.Data.*;
import com.deserts.domain.*;
先实现构造器NameListService()
NameListService()构造器说明：
01.根据项目提供的Data类构建相应大小的employees数组；
02.再根据Data类中的数据构建不同的对象，包括Employee、 Programmer、Designer和Architect对象，以及相关联的Equipment子类的对象；
03.将对象存于数组中
项目提供的Data类
package com.deserts.services;
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"}
};
}
创建对象数组及构造器的实现
//创建未分配空间的Employee对象数组
private Employee[] employees;
public NameListService() {
employees = new Employee[EMPLOYEES.length];
for (int i = 0; i < employees.length; i++) {
//获取员工类型以便switch里面创建对象
int type = Integer.parseInt(EMPLOYEES[i][0]);//员工类型
//Employee类只有四个属性，继承的类也都有，统一赋值
int id = Integer.parseInt(EMPLOYEES[i][1]);//员工ID
String name = EMPLOYEES[i][2];//员工名字
int age = Integer.parseInt(EMPLOYEES[i][3]);//年龄
double salary = Double.parseDouble(EMPLOYEES[i][4]);//工资
//以下是子类才有的属性，在switch里赋值
Equipment equipment;//设备
double bonus;//奖金
int stock;//股票
switch (type) {
case EMPLOYEE:
//根据属性创建对象
employees[i] = new Employee(id, name, age, salary);
break;
case PROGRAMMER:
//由于创建设备过程较复杂，不同类型人员所用设备不同，
//可以封装到createEquipment()里创建设备对象
equipment = createEquipment(i);
//根据属性创建对象
employees[i] = new Programmer(id, name, age, salary, equipment);
break;
case DESIGNER:
equipment = createEquipment(i);//创建设备
//对Data类EMPLOYEES数组的奖金元素拆箱，转化为int型
bonus = Integer.parseInt(EMPLOYEES[i][5]);
//根据属性创建对象
employees[i] = new Designer(id, name, age, salary, equipment, bonus);
break;
case ARCHITECT:
equipment = createEquipment(i);//创建设备
//对Data类EMPLOYEES数组的奖金、股票元素拆箱，转化为int型
bonus = Integer.parseInt(EMPLOYEES[i][5]);
stock = Integer.parseInt(EMPLOYEES[i][6]);
//根据属性创建对象
employees[i] = new Architect(id, name, age, salary, equipment, bonus,stock);
break;
}
}
}
创建设备对象
创建设备对象过程用到的知识是多态，该函数返回三种设备类型的其中一种，创建Equipment类型变量指向子类的对象
private Equipment createEquipment(int index) {
//获取机器类型
int type = Integer.parseInt(EQUIPMENTS[index][0]);
String model = EQUIPMENTS[index][1];//三种机器的model/name
String display = EQUIPMENTS[index][2];//PC的display及Printer的type
switch (type) {
case PC:
return new PC(model, display);
case NOTEBOOK:
int price = Integer.parseInt(EQUIPMENTS[index][2]);
return new NoteBook(model, price);
case PRINTER:
return new Printer(model, display);
}
return null;
}
getAllEmployees()方法的实现
/**
*
* @return Employee[]
* 获取所有员工对象构成的数组
*/
public Employee[] getAllEmployees() {
return employees;
}
getEmployee(int id)方法的实现
/**
*
* @param id
* @return Employee
* @throws TeamException
* 返回对象数组中指定id的员工对象
* 如果找不到，抛出TeamException异常
*/
public Employee getEmployee(int id) throws TeamException {
for(Employee e : employees) {
if (e.getId() == id)
return e;
}
throw new TeamException("该员工不存在");
}
该过程抛出的异常需要我们来定义
TeamException类的实现
package com.deserts.services;
public class TeamException extends Exception {
private static final long serialVersionUID = 123216548979L;
public TeamException(String msg) {
super(msg);
}
}
（四）部分功能的测试
项目进程已经过半，应及时用单元测试方法进行测试
创建NameListServiceTest测试NameListService类几个方法的功能
package com.deserts.junit;
import org.junit.Test;
import com.deserts.domain.Employee;
import com.deserts.services.NameListService;
import com.deserts.services.TeamException;
public class NameListServiceTest {
@Test
public void testGetAllEmployees() {
NameListService service = new NameListService();
Employee[] emps = service.getAllEmployees();
for(int i = 0; i < emps.length; i++) {
System.out.println(emps[i]);
}
}
@Test
public void testGetEmployee() {
NameListService service = new NameListService();
int id = 1;
try {
Employee emp = service.getEmployee(id);
System.out.println(emp);
} catch (TeamException e) {
System.out.println(e.getMessage());
}
}
}
看看运行结果
我们发现，显示的是地址值，原因是我们没有对Employee及其子类的toString方法进行重写，这时我们需要回到几个类中重写toString方法，显示结果应为接近这样：
重写Employee的toString方法
//用于封装几个类的共同属性显示，减少代码冗余
public String getEmpMsg() {
return id + "\t" + name + "\t" + age +"\t" + salary ;
}
@Override//方法重写
public String toString() {
return getEmpMsg();
}
重写Programmer的toString方法
@Override
public String toString() {
return getEmpMsg() + "\t程序员\t" + status + "\t\t\t" + getEquiment().getDescription();
}
重写Designer的toString方法
@Override
public String toString() {
return getEmpMsg() + "\t设计师\t" + getStatus() + "\t" + bonus + "\t\t" + getEquiment().getDescription();
}
重写Architect的toString方法
@Override
public String toString() {
return getEmpMsg() + "\t架构师\t" + getStatus() + "\t" + getBonus()
+ "\t" + getStock() + "\t" + getEquiment().getDescription();
}
接下来再进行测试
（五）TeamService的实现
主要是添加功能和删除功能的实现，两个过程若输入错误都会抛出异常
package com.deserts.services;
import com.deserts.domain.Architect;
import com.deserts.domain.Designer;
import com.deserts.domain.Employee;
import com.deserts.domain.Programmer;
public class TeamService {
private static int counter = 1;//用于给memberId赋值
private final int MAX_MEMBER = 5;//总人数
Programmer[] team = new Programmer[MAX_MEMBER];//团队数组
private int total = 0;//用于计算团队人数
//获取团队所有成员
public Programmer[] getTeam() {
Programmer[] team = new Programmer[total];
for (int i = 0; i < total; i++) {
team[i] = this.team[i];
}
return team;
}
//添加团队成员，各种添加不成功的情况会
public void addMember(Employee e) throws TeamException {
// 成员已满，无法添加
if(total >= MAX_MEMBER) {
throw new TeamException("成员已满，无法添加");
}
// 该成员不是开发人员，无法添加
if(!(e instanceof Programmer)) {
throw new TeamException("该成员不是开发人员，无法添加");
}
// 该员工已在本开发团队中
for(int i = 0; i < total; i++) {
if(e.getId() == team[i].getId()) {
throw new TeamException("该员工已在本开发团队中");
}
}
// 该员工已是某团队成员
// 该员正在休假，无法添加
Programmer p = (Programmer)e;
if("BUSY".equals(p.getStatus().getName())){
throw new TeamException("该员工已是某团队成员");
}
if("VOCATION".equals(p.getStatus().getName())){
throw new TeamException("该员正在休假，无法添加");
}
// 团队中至多只能有一名架构师
// 团队中至多只能有两名设计师
// 团队中至多只能有三名程序员
int numOfAri = 0, numOfDes = 0, numOfPro = 0;
//遍历计算三种类型人数
for(int i = 0; i < total; i++) {
if(team[i] instanceof Architect) {
numOfAri++;
}else if (team[i] instanceof Designer) {
numOfDes++;
}else {
numOfPro++;
}
}
//判断情况并抛出异常
if(p instanceof Architect) {
if(numOfAri >= 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("团队中至多只能有三名程序员");
}
}
//若无异常，可以开始添加
team[total++] = p;//将传入对象赋给数组，团队人数加一
p.setStatus(Status.BUSY);//修改状态
p.setNumberId(counter++);//设置新成员团队id，并将计数器加一
}
//删除成员，删除失败会抛出异常
public void removeMember(int memberId) throws TeamException {
int i = 0;
for(; i < total; i++) {
if(memberId == team[i].getMemberId()) {
team[i].setStatus(Status.FREE);
break;
}
}
//如果遍历成功结束，说明没有找到
if(i == total) {
throw new TeamException("找不到指定memberId的员工，删除失败");
}
//开始删除，团队数组从找到的下标开始后一个对象进行覆盖
for(int j = i; j < total - 1; j++) {
team[j] = team[j+1];
}
//将数组最后一个对象指向空，总数减一
team[--total] = null;
}
}
（六）TeamView类的实现
项目提供的工具类
package com.deserts.view;
import java.util.*;
/**
*
* @Description 项目中提供了TSUtility.java类，可用来方便地实现键盘访问。
* @author shkstart Email:[email protected]
* @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;
}
}
TeamView类的实现
导入的包
package com.deserts.view;
import com.deserts.domain.Employee;
import com.deserts.domain.Programmer;
import com.deserts.services.NameListService;
import com.deserts.services.TeamException;
import com.deserts.services.TeamService;
创建对象及菜单功能，菜单中退出的实现
NameListService listSvc = new NameListService();//创建名单服务类对象
TeamService teamSvc = new TeamService();//创队团队功能类
//进入菜单
public void enterMainMenu() {
boolean loopFlag = true;//循环结束的标志
char select = ' ';//输入选择
while (loopFlag) {
//菜单页面循环
if (select != '1') {
listAllEmployees();
}
System.out.print("1-团队列表 2-添加团队成员 3-删除团队成员 4-退出 请选择(1-4)：");
select = TSUtility.readMenuSelection();
switch (select) {
case '1':
listTeam();
break;
case '2':
addMember();
break;
case '3':
deleteMember();
break;
case '4':
//退出功能的实现
System.out.print("确认是否退出(Y/N)：");
char isExit = TSUtility.readConfirmSelection();
if (isExit == 'Y')
loopFlag = false;
break;
}
}
}
接下来是对几个封装的方法进行实现
listAllEmployees()的实现
private void listAllEmployees() {
System.out.println("\n-------------------------------开发团队调度软件--------------------------------\n");
System.out.println("ID\t姓名\t年龄\t工资\t职位\t状态\t奖金\t股票\t领用设备");
Employee[] emps = listSvc.getAllEmployees();
for (int i = 0; i < emps.length; i++) {
System.out.println(emps[i]);
}
System.out.println("\n-------------------------------------------------------------------------------");
}
listTeam()功能的实现
//显示团队成员功能的实现
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 (int i = 0; i < team.length; i++) {
System.out.println(team[i].getTeamMemberInfo());
}
System.out.println("-----------------------------------------------------");
}
在这里，我们需要注意，显示团队的界面和显示公司所有员工的界面并不相同
吸取前面的教训，我们不能用toString方法，应在Programmer类提供getTeamMemberInfo()方法来显示，及对其子类的getTeamMemberInfo()方法进行重写
Programmer的getTeamMemberInfo()方法
//封装共有属性的显示
public String getMemnerInfoDetails() {
return getMemberId() + "/" + getId() + "\t" + getName() + "\t" + getAge() + "\t" + getSalary();
}
//显示团队成员信息
public String getTeamMemberInfo() {
return getMemnerInfoDetails() + "\t程序员";
}
Designer类getTeamMemberInfo()方法重写
@Override
public String getTeamMemberInfo() {
return getMemnerInfoDetails() + "\t设计师\t" + getBonus();
}
Architect类getTeamMemberInfo()方法重写
@Override
public String getTeamMemberInfo() {
return getMemnerInfoDetails() + "\t架构师\t" + getBonus() + "\t" + getStock();
}
（七）测试各个功能
添加功能
显示功能
删除功能
退出功能
小结
1.本次项目大约花了一天半的时间，在C++的课设做完疲惫的状态来做这个东西真不是明智的选择，效率太低
2.整个项目是看两三集视频做一部分功能，跟着宋红康老师的思路写的，过程中也遇到几个bug寻求别人的帮助，也交到了新朋友，后面需要找个时间独立完成一遍
3.就以这个项目暂时告别JavaSE基础部分的学习，开始后半部分，今天就可以开始多线程啦~开开心心！希望暑假的学习生活能顺顺利利、开开心心！
写在最后
Java的学习之路漫长也艰难，超梦将会把每一阶段的学习状况在博客展示，欢迎你的阅读！自学Java的朋友也可以跟我交流学习方面的内容哦，欢迎打扰~