目录
整体结构：
系统功能结构：
系统流程：
结构分析：
可以看出这个管理系统分别由用户注册版块，开发人员管理版块，开发团队调度管理版块和开发项目管理版块组成。只要分别把四个版块写出来，最后再连接再一起即可。
需求说明：
需求分析：
首先是第一个模块需要登录，注册与修改用户信息功能，意味着需要存储每个用户信息，用户信息里包含了用户名和密码。由此可以想到使用一个对象来代表一个用户信息，里面的属性包括用户名和密码，使用一个ArrayList或是一个数组来存储每个用户的信息即可，这里包括之后的代码我都使用的是ArrayList，因为使用时不知道具体存储信息的个数，所以使用数组不要好定义数组的长度，而ArrayList它的长度可以自己动态增大。存储好后再使用对应方法即可完成用户的注册，登录，修改功能。
第二个是开发人员模块，需要对开发人员进行增删改查，同样是用一个对象来代表一个开发人员的信息，用一个ArrayList来存储整个所有开发人员的信息，再通过编写对应的方法来完成对应的功能即可。
第三个是开发团队调度管理模块，可以说是这个管理系统的核心模块之一。由需求说明可以分析出，这个模块可以与第二模块相同，使用一个对象来代表开发人员的具体信息，用一个ArrayList来存储被分配到一个团队的所有的开发人员的信息，也就是可以理解为这个ArrayList代表一个团队，再创建一个ArrayList来存储所有的团队信息，也就是需要用到一个二维ArrayList。而具体的添加团队，查看团队等功能与第二模块类似，也是通过对应的方法来完成即可。
第四个是开发项目管理模块，也是系统的核心模块之一。由需求说明可以分析得到，可以使用一个对象来代表项目的信息，一个ArrayList来代表所有的项目的信息即可。需要注意的是，这里项目的信息肯定会用到第三模块的团队信息，所以编写方法实现功能的时候需要注意一点。
代码实现：
一、准备工作
分三个包，分别为view包，里面是界面代码，主要是展示用的，service包，里面是逻辑代码，都是一些方法，来实现代码的逻辑，domain方法，里面是所有需要用到的类。
二、用户登录注册模块：
首先，需要创建Users对象来存储每个用户的具体信息，用户信息的属性需要有用户名以及密码，添加相关get/set方法，属性里还有一个ArrayList<User>属性，用来之后存储所有用户的信息（本来应该是在主界面创建ArrayList，但是我创建对象的时候脑子抽了一下创建了，之后发现了不想改了，因为我是大懒比
），对象里还有一个add方法，我用来初始化ArrayList。
再创建一个注册登录界面，将展示界面代码实现出来，到时候这个就是测试的主函数（TSUtility为一个工具类，里面提供了输入的一些限制，以及一些其他展示功能）。
/**
* @author 张天霸
*
* 编程思想主要是通过对象里的ArrayList来存储数据
* ArrayList里一个对象就是一个用户或者一个人员的数据
*/
public class LoginView{
private static Scanner scanner = new Scanner(System.in); //创建Scanner类以便TSUtility工具类里的输入方法使用
public static void main(String[] args) {
Users users1 = new Users();
users1.setUsername("001"); //添加一个初始值，不然的话用add方法会报错
users1.setPassword("001");
Users USERS = new Users();
USERS.add(users1);
int flag = 0;
while (flag == 0){
int times = 4;
while (flag == 0) {
System.out.println("--------登录界面--------");
System.out.print("用户名：");
String username = TSUtility.readKeyBoard(20, false); //输入用户名，20长度以内，false代表不能为空
System.out.print("密码：");
String password = TSUtility.readKeyBoard(20, false); //输入密码，20长度以内，false代表不能为空
int res = UserMethod.login(username, password, USERS,times); //登录方法，方法内判断是否有该用户，如果没有用户就提示需要注册，返回值-1代表需要注册，1代表登录成功，0代表登录用户名密码错误
flag = res;
times = times - 1;
}
if (flag == 1){
break;
}
while (flag == -1) {
System.out.println("--------注册界面--------");
System.out.print("用户名：");
String registername = TSUtility.readKeyBoard(20, false); //输入注册名，20长度以内，不能为空
System.out.print("密码：");
String registerpassword = TSUtility.readKeyBoard(20, false); //输入注册密码，20长度以内，不能为空
int res1 = UserMethod.register(registername, registername, USERS); //注册方法
flag = res1;
}
}
MainView.mainview(USERS); //进入软件主菜单
}
}然后创建UserMethod类来实现对应的注册，登录等功能。
public class UserMethod {
public static int login(String username, String password, Users USER, int times) { //登录方法
int res = 0;
Users user1 = new Users();
user1.setUsername(username);
user1.setPassword(password);
ArrayList<Users> arr = USER.getUsers();
for (int i = 0; i < arr.size(); i++) {
if (i == arr.size() - 1 && !arr.get(i).getUsername().equals(username)) { //查看ArrayList里是否有该用户信息，没有就需要注册
System.out.println("未检测到账号，需注册！");
res = -1;
break;
}
if (arr.get(i).getUsername().equals(username) && arr.get(i).getPassword().equals(password)) { //可以登录成功
res = 1;
break;
} else if (i == arr.size() - 1 && (arr.get(i).getUsername().equals(username) || arr.get(i).getPassword().equals(password))) {
if (times == 0) { //次数用完
res = 1;
} else { //账号或密码错误
System.out.println("账号或密码错误！还有" + times + "次机会");
}
}
}
return res;
}
public static int register(String registername, String registerpassword, Users USER) { //注册方法
int res = 0;
Users registeruser = new Users();
registeruser.setUsername(registername);
registeruser.setPassword(registerpassword); //将用户输入的用户名和密码暂存在一个对象内
ArrayList<Users> arr = USER.getUsers();
for (int i = 0; i < arr.size(); i++) {
if (arr.get(i).getUsername().equals(registername)) { //检查用户名是否重复
System.out.println("此用户名已被注册！请重新注册");
res = -1;
break;
} else {
res = 0;
}
}
USER.add(registeruser); //将暂存用户名和密码的对象添加的主对象USER的ArrayList里，完成添加
return res;
}
}界面及功能展示
总的来说第一个模块还算比较简单，只需要搞清楚Users对象和ArrayList两者代表的是啥东西以及两者的联系就可以做出来。
三、开发人员管理模块：
开发管理模块包括了对于用户信息，包括用户名和密码的修改，对开发人员的增加，删除，修改，查看功能的使用。
首先，需要创建父类Developer开发人员类，属性包括人员编号，姓名，年龄，工资，职位，状态（true和false），使用设备（本来该用接口来实现设备，但我忘了，我直接加到属性了，后面也不想改了，还是因为我是懒比）。再创建相应的set/get方法，创建一个无参的构造方法，一个有人员编号，姓名，年龄，工资，职位参数的构造方法（后面用来对无职位人员创建用），一个有所有参数的构造方法。再重写toString方法以便测试代码时使用，重写equals方法以便后面进行判断使用。
public class Developer {
private int id;
private String name;
private int age;
private double salary;
private String position;
private Boolean status;
private String equipment;
private ArrayList<Developer> developers = new ArrayList<>();
public Developer() {
}
public Developer(int id, String name, int age, double salary, String position) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
this.position = position;
}
public Developer(int id, String name, int age, double salary, String position, Boolean status, String equipment) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
this.position = position;
this.status = status;
this.equipment = equipment;
}
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 getPosition() {
return position;
}
public void setPosition(String position) {
this.position = position;
}
public Boolean getStatus() {
return status;
}
public void setStatus(Boolean status) {
this.status = status;
}
public String getEquipment() {
return equipment;
}
public void setEquipment(String equipment) {
this.equipment = equipment;
}
public ArrayList<Developer> getDevelopers() {
return developers;
}
public void setDevelopers(ArrayList<Developer> developers) {
this.developers = developers;
}
@Override
public String toString() {
return "Developer{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", salary=" + salary +
", position='" + position + '\'' +
", status=" + status +
", equipment='" + equipment + '\'' +
", developers=" + developers +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false; // 如果不注释或删掉这句，会导致只能相同类型的对象进行比较
Developer developer = (Developer) o;
if (age != developer.age) return false;
if (Double.compare(developer.salary, salary) != 0) return false;
return name != null ? name.equals(developer.name) : developer.name == null;
}
@Override
public int hashCode() {
int result;
long temp;
result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
temp = Double.doubleToLongBits(salary);
result = 31 * result + (int) (temp ^ (temp >>> 32));
return result;
}
}然后，需要创建Developer的子类，包括架构师类Architect，设计师类Designer，程序员类Programmer，在代码里面这几个子类继承TeamNumber类，TeamNumer类继承Team类，Team类继承Developer类，TeamNumber和Team类是后面第三模块需要用到的类，这里先不细说，就理解为Architect，Designer，Programmer都是Develpor的子类就行。
三个子类：
public class Architect extends TeamNumber {
private double bonus;
private double stock;
public Architect() {
}
public Architect(int id, String name, int age, double salary, String position, Boolean status, double bonus, double stock, String equipment) {
super(id, name, age, salary, position, status, equipment);
this.bonus = bonus;
this.stock = stock;
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
public double getStock() {
return stock;
}
public void setStock(double stock) {
this.stock = stock;
}
@Override
public String toString() {
return "Architect{" +
"bonus=" + bonus +
", stock=" + stock +
'}';
}
}public class Designer extends TeamNumber {
private double bonus;
public Designer(int id, String name, int age, double salary, String position, Boolean status, double bonus, String equipment) {
super(id, name, age, salary, position, status, equipment);
this.bonus = bonus;
}
public Designer() {
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
@Override
public String toString() {
return "Designer{" +
"bonus=" + bonus +
'}';
}
}public class Programmer extends TeamNumber {
public Programmer() {
}
public Programmer(int id, String name, int age, double salary, String position, Boolean status, String equipment) {
super(id, name, age, salary, position, status, equipment);
}
}再之后，创建MainView类，表示软件主界面，里面可以展示用户的修改，成员的增删改查。
public class MainView {
private static Scanner scanner = new Scanner(System.in);
public static void mainview(Users USERS){
int flag = 0;
Team TEAM = new Team();
Project PROJECT = new Project();
ProjectImplementation projectImplementation = new ProjectImplementation();
Developer DEVELOPERS = new Developer(); //用于储存所有开发人员信息
DeveloperMethod.developerInitialize(DEVELOPERS); //初始化开发人员列表，自己随便设置的
while (flag == 0) {
System.out.println("--------软件主菜单--------");
System.out.println("1. <用户信息修改>");
System.out.println("2. <开发人员管理>");
System.out.println("3. <开发团队调度管理>");
System.out.println("4. <开发项目管理>");
System.out.println("5. <退出软件>");
System.out.print("请选择：");
DEVELOPERS = DeveloperMethod.developerReturn(DEVELOPERS);
ArrayList<Users> arr = USERS.getUsers();
char c = TSUtility.readMenuSelectionPro();
switch (c) { //使用switch循环来实现选择功能的效果
case '1':
int flag11 = 0;
int flag1 = -1;
int res = -1;
System.out.println("--------用户信息修改--------");
while (flag1 == -1) {
System.out.println("请输入你要更改用户信息的用户名(输入-1退出)：");
String username = TSUtility.readKeyBoard(20, false);
if (username.equals("-1")) {
flag11 = 1; //如果输入-1代表退出，需要跳出两个循环
break; //-1退出
}
res = UserMethod.clientCheck(USERS, username); //检查是否有该用户名来进行修改
flag1 = res;
}
if (flag11 == 1){ //用于跳出switch循环，回到主界面
break;
}
System.out.println("用户名：");
String newname = TSUtility.readString(20,arr.get(res).getUsername()); //第一个参数为字数长度限制，第二个参数为默认值，如果输入回车就默认输入默认值
System.out.println("密码：");
String password = TSUtility.readString(20,arr.get(res).getPassword());
UserMethod.clientSet(USERS,res,newname,password); //用于用户修改账户名或密码
break;
case '2':
DEVELOPERS = DeveloperView.developerview(DEVELOPERS); //将改变后的开发人员信息列表更新，防止退出后更新信息消失
break;
case '3':
TEAM = TeamDispatchView.teamdispatchview(DEVELOPERS, TEAM); //将改变后的团队信息列表更新，防止退出后更新信息消失
break;
case '4':
ProjectView.projectview(PROJECT,projectImplementation, TEAM);
break;
case '5':
System.exit(0);
break;
}
}
}
}注意：做完第二和第三模块记得将数据返回出来，因为二三四的数据都是有联系的，之前作者运行的时候忘记返回，脑壳都要想破了，后面学了数据库更新数据应该就方便了。
用户信息修改的方法创建在UserMethod类中，包括查看是否有该用户，以及修改用户信息方法。
public static int clientCheck(Users USERS, String username) { //判断是否有该用户
int res = -1;
ArrayList<Users> arr = USERS.getUsers();
for (int i = 0; i < arr.size(); i++) {
if (i == arr.size() - 1 && !arr.get(i).getUsername().equals(username)) {
System.out.println("输入有误，未找到该用户信息！");
break;
}
if (arr.get(i).getUsername().equals(username)) {
res = i;
break;
}
}
return res;
}
public static void clientSet(Users USERS, int index, String newname, String password) { //修改用户信息
ArrayList<Users> arr = USERS.getUsers();
Users user = new Users();
user.setUsername(newname);
user.setPassword(password);
arr.set(index, user); //将输入的新的用户名和密码暂存在对象里，通过ArrayList的set方法来进行修改
System.out.println("修改成功！");
}开发人员的添加，删除，修改，查看方法，统一写在方法类DeveloperMethod类中。
public class DeveloperMethod {
public static void developerInitialize(Developer DEVELOPER){ //开发人员信息的初始化
ArrayList<Developer> arr = DEVELOPER.getDevelopers();
arr.add(new Developer(1,"张天霸",21,3000," "));
arr.add(new Architect(2,"金多贤",23,18000,"架构师",true,60000,5000,"联想4T(6000)"));
arr.add(new Designer(3,"凑崎纱夏",25,10000,"设计师",true,5000,"激光(佳能2900)"));
arr.add(new Programmer(4,"周子瑜",22,7000,"程序员",true,"戴尔(NEC 17寸)"));
arr.add(new Programmer(5,"孙彩瑛",22,7300,"程序员",true,"戴尔(三星 17寸)"));
arr.add(new Programmer(6,"名井南",24,9000,"程序员",true,"华硕(三星 17寸)"));
arr.add(new Architect(7,"林娜琏",26,25000,"架构师",true,30000,4800,"针式(爱普生24K)"));
arr.add(new Designer(8,"俞定延",25,12000,"设计师",true,8000,"华硕(三星 17寸)"));
arr.add(new Designer(9,"平井桃",25,9800,"设计师",true,3000,"惠普m6(5800.0)"));
arr.add(new Designer(10,"朴志效",24,9600,"设计师",true,4000,"惠普m6(5800.0)"));
arr.add(new Programmer(11,"王嘉尔",27,7100,"程序员",true,"戴尔(NEC 17寸)"));
arr.add(new Programmer(12,"张子枫",20,6600,"程序员",true,"华硕(三星 17寸)"));
}
public static Developer developerReturn(Developer DEVELOPER){ //返回更新的DEVELOPER，以便团队调度时使用
return DEVELOPER;
}
public static void changeStatus(Developer DEVELOPERS, int index){ //用于开发调度时将正在开发的开发人员的状态变为false
ArrayList<Developer> arr = DEVELOPERS.getDevelopers();
arr.get(index).setStatus(false);
}
public static void developerCheck(Developer DEVELOPER){ //开发人员信息的查看
System.out.println("ID\t姓名\t年龄\t工资\t职位\t状态\t奖金\t股票\t领用设备");
ArrayList<Developer> arr = DEVELOPER.getDevelopers();
for (int i = 0; i<arr.size(); i++){
if (arr.get(i) instanceof Architect){
System.out.println(arr.get(i).getId()+"\t"+arr.get(i).getName()+"\t"+arr.get(i).getAge() +"\t\t"+arr.get(i).getSalary()+"\t"+arr.get(i).getPosition()+"\t" +arr.get(i).getStatus()+"\t"+((Architect) arr.get(i)).getBonus()+"\t" +((Architect) arr.get(i)).getStock()+"\t"+arr.get(i).getEquipment());
continue;
}
if (arr.get(i) instanceof Designer){
System.out.println(arr.get(i).getId()+"\t"+arr.get(i).getName()+"\t"+arr.get(i).getAge() +"\t\t"+arr.get(i).getSalary()+"\t"+arr.get(i).getPosition()+"\t" +arr.get(i).getStatus()+"\t"+((Designer) arr.get(i)).getBonus()+"\t\t\t" +arr.get(i).getEquipment());
continue;
}
if (arr.get(i) instanceof Programmer){
System.out.println(arr.get(i).getId()+"\t"+arr.get(i).getName()+"\t"+arr.get(i).getAge() +"\t\t"+arr.get(i).getSalary()+"\t"+arr.get(i).getPosition()+"\t" +arr.get(i).getStatus()+"\t\t\t\t\t"+arr.get(i).getEquipment());
continue;
}
if (arr.get(i) instanceof Developer){
System.out.println(arr.get(i).getId()+"\t"+arr.get(i).getName()+"\t"+arr.get(i).getAge() +"\t\t"+arr.get(i).getSalary());
continue;
}
}
}
public static void noemployeeAdd(Developer DEVELOPER, String name, int age, double salary){ //无职位开发人员信息的添加
ArrayList<Developer> arr = DEVELOPER.getDevelopers();
Developer noemployee = new Developer(arr.size()+1,name,age,salary," ");
arr.add(noemployee);
System.out.println("添加成功！");
developerCheck(DEVELOPER);
}
public static void programmerAdd(Developer DEVELOPER, String name, int age, double salary, String model, String screen){ //程序员信息的添加
ArrayList<Developer> arr = DEVELOPER.getDevelopers();
Programmer programmer = new Programmer(arr.size()+1,name,age,salary,"程序员",true,model+"("+screen+")");
arr.add(programmer);
System.out.println("添加成功！");
developerCheck(DEVELOPER);
}
public static void designerAdd(Developer DEVELOPER, String name, int age, double salary, double bonus, String model, String screen){ //设计师信息的添加
ArrayList<Developer> arr = DEVELOPER.getDevelopers();
Designer designer = new Designer(arr.size()+1,name,age,salary,"设计师",true,bonus,model+"("+screen+")");
arr.add(designer);
System.out.println("添加成功！");
developerCheck(DEVELOPER);
}
public static void architectAdd(Developer DEVELOPER, String name, int age, double salary, double bonus, double stock, String model, String screen){ //架构师信息的添加
ArrayList<Developer> arr = DEVELOPER.getDevelopers();
Architect architect = new Architect(arr.size()+1,name,age,salary,"架构师",true,bonus,stock,model+"("+screen+")");
arr.add(architect);
System.out.println("添加成功！");
developerCheck(DEVELOPER);
}
public static void noemployeeSet(Developer DEVELOPER, String name, int age, double salary, int index){
ArrayList<Developer> arr = DEVELOPER.getDevelopers();
arr.get(index).setName(name);
arr.get(index).setAge(age);
arr.get(index).setSalary(salary);
developerCheck(DEVELOPER);
}
public static void programmerSet(Developer DEVELOPER, String name, int age, double salary, String equipment, int index){ //开发人员信息和程序员信息的修改
ArrayList<Developer> arr = DEVELOPER.getDevelopers();
arr.get(index).setName(name);
arr.get(index).setAge(age);
arr.get(index).setSalary(salary);
arr.get(index).setEquipment(equipment);
System.out.println("修改成功！");
developerCheck(DEVELOPER);
}
public static void designerSet(Developer DEVELOPER, String name, int age, double salary, double bonus, String equipment, int index){ //对设计师信息进行修改
ArrayList<Developer> arr = DEVELOPER.getDevelopers();
Designer d = (Designer)arr.get(index); //因为Designer里有一个特有的bonus属性，所以需要进行向下转型，将ArrayList里的对象转为Designer类才能使用setBonus方法
d.setBonus(bonus);
arr.get(index).setName(name);
arr.get(index).setAge(age);
arr.get(index).setSalary(salary);
arr.get(index).setEquipment(equipment);
System.out.println("修改成功！");
developerCheck(DEVELOPER);
}
public static void architectSet(Developer DEVELOPER, String name, int age, double salary, double bonus, double stock, String equipment, int index){
ArrayList<Developer> arr = DEVELOPER.getDevelopers();
Architect ar = (Architect)arr.get(index); //因为Architect里有特有的bonus和stock属性，所以需要进行向下转型，将ArrayList里的对象转为Architect类才能使用setBonus和setStock方法
ar.setBonus(bonus);
ar.setStock(stock);
arr.get(index).setName(name);
arr.get(index).setAge(age);
arr.get(index).setSalary(salary);
arr.get(index).setEquipment(equipment);
System.out.println("修改成功！");
developerCheck(DEVELOPER);
}
public static void developerRemove(Developer DEVELOPER, int index){ //开发人员的删除
ArrayList<Developer> arr = DEVELOPER.getDevelopers();
arr.remove(index);
for (int i = index; i<arr.size(); i++){
arr.get(i).setId(arr.get(i).getId()-1);
}
System.out.println("删除成功！");
developerCheck(DEVELOPER);
}
}最后创建DeveloperView类，来进行开发人员增删改查的展示即可，还是要记得返回更新完后的整个开发人员列表的数据
public class DeveloperView {
private static Scanner scanner = new Scanner(System.in);
public static Developer developerview(Developer DEVELOPERS) {
int flag = 0;
int res = 0;
DeveloperMethod.developerCheck(DEVELOPERS);
while (flag == 0) {
System.out.println("--------开发人员管理主菜单--------");
System.out.println("1. <开发人员的添加>");
System.out.println("2. <开发人员的查看>");
System.out.println("3. <开发人员的修改>");
System.out.println("4. <开发人员的删除>");
System.out.println("5. <退出当前菜单>");
System.out.print("请选择：");
char i = TSUtility.readMenuSelectionPro();
ArrayList<Developer> arr = DEVELOPERS.getDevelopers();
switch (i) {
case '1':
System.out.println("请输入需要添加的雇员的职位：");
System.out.println("1(无职位)");
System.out.println("2(程序员)");
System.out.println("3(设计师)");
System.out.println("4(架构师)");
char position = TSUtility.readMenuSelection(); //工具类，用于输入1-4
switch (position) {
case '1': //开发人员的添加
System.out.println("当前雇员职员分配：无职位");
System.out.println("请输入当前雇员的姓名：");
String Nname = TSUtility.readKeyBoard(4, false);
System.out.println("请输入当前雇员的年龄：");
int Nage = TSUtility.readInt();
System.out.println("请输入当前雇员的工资：");
double Nsalary = TSUtility.readDouble();
DeveloperMethod.noemployeeAdd(DEVELOPERS, Nname, Nage, Nsalary);
break;
case '2':
System.out.println("当前雇员职员分配：程序员");
System.out.println("请输入当前雇员的姓名：");
String ProgrammerName = TSUtility.readKeyBoard(4, false);
System.out.println("请输入当前雇员的年龄：");
int ProgrammerAge = TSUtility.readInt();
System.out.println("请输入当前雇员的工资：");
double ProgrammerSalary = TSUtility.readDouble();
System.out.println("请为当前程序员配一台好的台式电脑");
System.out.println("请输入需要配置的台式电脑的型号：");
String ProgrammerModel = TSUtility.readKeyBoard(10, false);
System.out.println("请输入需要配置的台式电脑的显示器名称：");
String ProgrammerScreen = TSUtility.readKeyBoard(10, false);
DeveloperMethod.programmerAdd(DEVELOPERS, ProgrammerName, ProgrammerAge, ProgrammerSalary, ProgrammerModel, ProgrammerScreen);
break;
case '3':
System.out.println("当前雇员职员分配：设计师");
System.out.println("请输入当前雇员的姓名：");
String DesignerName = TSUtility.readKeyBoard(4, false);
System.out.println("请输入当前雇员的年龄：");
int DesignerAge = TSUtility.readInt();
System.out.println("请输入当前雇员的工资：");
double DesignerSalary = TSUtility.readDouble();
System.out.println("请输入当前雇员的奖金：");
double DesignerBonus = TSUtility.readDouble();
System.out.println("请为当前程序员配一台好的台式电脑");
System.out.println("请输入需要配置的台式电脑的型号：");
String DesignerModel = TSUtility.readKeyBoard(10, false);
System.out.println("请输入需要配置的台式电脑的显示器名称：");
String DesignerScreen = TSUtility.readKeyBoard(10, false);
DeveloperMethod.designerAdd(DEVELOPERS, DesignerName, DesignerAge, DesignerSalary, DesignerBonus, DesignerModel, DesignerScreen);
break;
case '4':
System.out.println("当前雇员职员分配：架构师");
System.out.println("请输入当前雇员的姓名：");
String ArchitectName = TSUtility.readKeyBoard(4, false);
System.out.println("请输入当前雇员的年龄：");
int ArchitectAge = TSUtility.readInt();
System.out.println("请输入当前雇员的工资：");
double ArchitectSalary = TSUtility.readDouble();
System.out.println("请输入当前雇员的奖金：");
double ArchitectBonus = TSUtility.readDouble();
System.out.println("请输入当前雇员的股份：");
double ArchitectStock = TSUtility.readDouble();
System.out.println("请为当前程序员配一台好的台式电脑");
System.out.println("请输入需要配置的台式电脑的型号：");
String ArchitectModel = TSUtility.readKeyBoard(10, false);
System.out.println("请输入需要配置的台式电脑的显示器名称：");
String ArchitectScreen = TSUtility.readKeyBoard(10, false);
DeveloperMethod.architectAdd(DEVELOPERS, ArchitectName, ArchitectAge, ArchitectSalary, ArchitectBonus, ArchitectStock, ArchitectModel, ArchitectScreen);
break;
}
break;
case '2': //开发人员信息的查看
DeveloperMethod.developerCheck(DEVELOPERS);
break;
case '3': //开发人员信息的修改
System.out.println("请输入需要修改员工的id：");
int id = TSUtility.readInt();
if (id > arr.size() || id < 0){ //判断id输入是否正确
try {
throw new DeveloperException("没有该员工!");
}catch (DeveloperException e){
System.out.println("修改失败，原因为："+e.getMessage());
break;
}
}
if (arr.get(id - 1).getPosition().equals(" ")) { //无职位人员初始化时职位为一个空格，所以这里是空格
System.out.print("姓名(" + arr.get(id - 1).getName() + ")：");
String name = TSUtility.readString(4, arr.get(id - 1).getName());
System.out.print("年龄(" + arr.get(id - 1).getAge() + ")：");
int age = TSUtility.readIntSet(String.valueOf(arr.get(id - 1).getAge()));
System.out.print("工资(" + arr.get(id - 1).getSalary() + ")：");
double salary = TSUtility.readDoubleSet(String.valueOf(arr.get(id - 1).getSalary()));
DeveloperMethod.noemployeeSet(DEVELOPERS, name, age, salary, id - 1);
}
if (arr.get(id - 1).getPosition().equals("程序员")) {
System.out.print("姓名(" + arr.get(id - 1).getName() + ")：");
String name = TSUtility.readString(4, arr.get(id - 1).getName());
System.out.print("年龄(" + arr.get(id - 1).getAge() + ")：");
int age = TSUtility.readIntSet(String.valueOf(arr.get(id - 1).getAge()));
System.out.print("工资(" + arr.get(id - 1).getSalary() + ")：");
double salary = TSUtility.readDoubleSet(String.valueOf(arr.get(id - 1).getSalary()));
System.out.println("使用设备(" + arr.get(id - 1).getEquipment() + ")：");
String equipment = TSUtility.readString(10, arr.get(id - 1).getEquipment());
DeveloperMethod.programmerSet(DEVELOPERS, name, age, salary, equipment, id - 1);
}
if (arr.get(id - 1).getPosition().equals("设计师")) {
System.out.print("姓名(" + arr.get(id - 1).getName() + ")：");
String name = TSUtility.readString(4, arr.get(id - 1).getName());
System.out.print("年龄(" + arr.get(id - 1).getAge() + ")：");
int age = TSUtility.readIntSet(String.valueOf(arr.get(id - 1).getAge()));
System.out.print("工资(" + arr.get(id - 1).getSalary() + ")：");
double salary = TSUtility.readDoubleSet(String.valueOf(arr.get(id - 1).getSalary()));
Designer d = (Designer) arr.get(id - 1);
System.out.print("奖金(" + d.getBonus() + ")：");
double bonus = TSUtility.readDoubleSet(String.valueOf(d.getBonus()));
System.out.print("使用设备(" + arr.get(id - 1).getEquipment() + ")：");
String equipment = TSUtility.readString(10, arr.get(id - 1).getEquipment());
DeveloperMethod.designerSet(DEVELOPERS, name, age, salary, bonus, equipment, id - 1);
}
if (arr.get(id - 1).getPosition().equals("架构师")) {
System.out.print("姓名(" + arr.get(id - 1).getName() + ")：");
String name = TSUtility.readString(4, arr.get(id - 1).getName());
System.out.print("年龄(" + arr.get(id - 1).getAge() + ")：");
int age = TSUtility.readIntSet(String.valueOf(arr.get(id - 1).getAge()));
System.out.print("工资(" + arr.get(id - 1).getSalary() + ")：");
double salary = TSUtility.readDoubleSet(String.valueOf(arr.get(id - 1).getSalary()));
Architect ar = (Architect) arr.get(id - 1);
System.out.print("奖金(" + ar.getBonus() + ")：");
double bonus = TSUtility.readDoubleSet(String.valueOf(ar.getBonus()));
System.out.println("股份(" + ar.getStock() + ")：");
double stock = TSUtility.readDouble();
System.out.print("使用设备(" + arr.get(id - 1).getEquipment() + ")：");
String equipment = TSUtility.readString(10, arr.get(id - 1).getEquipment());
DeveloperMethod.architectSet(DEVELOPERS, name, age, salary, bonus, stock, equipment, id - 1);
}
break;
case '4':
System.out.println("请输入需要删除员工的id：");
int RemoveId = TSUtility.readInt();
if (RemoveId < 1 || RemoveId > arr.size()) { //判断id输入是否正确
try{
throw new DeveloperException("没有该员工！");
} catch (DeveloperException e) {
System.out.println("删除失败，原因为："+e.getMessage());
}
}
for (int i4 = 0; i4 < arr.size(); i4++) { //遍历整个信息列表，找到相应的进行删除
if (i4 == RemoveId - 1) {
DeveloperMethod.developerRemove(DEVELOPERS, i4);
}
}
break;
case '5':
res = 1;
break;
}
if (res == 1) {
break;
}
}
return DEVELOPERS;
}
}界面及功能展示：
人员的添加
人员的修改
人员的删除
四、开发团队调度管理模块
开发团队调度管理，需要有添加团队，删除团队，查看团队和对团队成员的增删改查的功能。要求团队只能最多有一个架构师，两个设计师，三个程序员，所以还需要对这些方法进行异常处理。团队成员的增删改查需要联系到开发人员信息。
首先需要创建TeamNumber(其实应该是TeamMember，我打错了，懒得改)类，里面属性有TID，ArrayList<TeamNumber>来存储一个团队里面的成员的信息。还需要创建Team类，TeamNumber类继承Team类，Team类里属性只有一个，ArrayList<ArrayList<TeamNumber>>来存储所有的团队，这个可以就是一个二维ArrayList，和二维数组理解差不多。
public class Team extends Developer{ //用于存储整个团队列表
private ArrayList<ArrayList<TeamNumber>> team = new ArrayList<>();
public Team() {
}
public Team(int id, String name, int age, double salary, String position, ArrayList<ArrayList<TeamNumber>> team) {
super(id, name, age, salary, position);
this.team = team;
}
public Team(int id, String name, int age, double salary, String position, Boolean status, String equipment) {
super(id, name, age, salary, position, status, equipment);
}
public ArrayList<ArrayList<TeamNumber>> getTeam() {
return team;
}
public void setTeam(ArrayList<ArrayList<TeamNumber>> team) {
this.team = team;
}
@Override
public String toString() {
return "Team{" +
"team=" + team +
'}';
}
}public class TeamNumber extends Team { //用于储存具体每个团队的开发人员信息
private int TID;
private ArrayList<TeamNumber> teamNumbers = new ArrayList<>();
public TeamNumber() {
}
public TeamNumber(int id, String name, int age, double salary, String position, ArrayList<ArrayList<TeamNumber>> team, int TID, ArrayList<TeamNumber> teamNumbers) {
super(id, name, age, salary, position, team);
this.TID = TID;
this.teamNumbers = teamNumbers;
}
public TeamNumber(int id, String name, int age, double salary, String position, Boolean status, String equipment) {
super(id, name, age, salary, position, status, equipment);
}
public int getTID() {
return TID;
}
public void setTID(int TID) {
this.TID = TID;
}
public ArrayList<TeamNumber> getTeamNumbers() {
return teamNumbers;
}
public void setTeamNumbers(ArrayList<TeamNumber> teamNumbers) {
this.teamNumbers = teamNumbers;
}
}再创建一个TeamMethod类，里面存放相关的方法。创建一个TeamException类来对方法进行异常的处理
public class TeamMethod {
public static void teamnumberAdd(Developer DEVELOPER, TeamNumber teamNumber, int index) throws TeamException { //团队的人员添加
ArrayList<Developer> arrd = DEVELOPER.getDevelopers();
ArrayList<TeamNumber> arr = teamNumber.getTeamNumbers();
int contA = 0;
int contD = 0;
int contP = 0;
for (int i = 0; i < arr.size(); i++) {
if (arr.get(i).equals(arrd.get(index))) {
throw new TeamException("该成员已是本团队成员，无需添加！");
}
if (arr.get(i) instanceof Architect) { //判断架构师人数
contA = contA + 1;
}
if (arr.get(i) instanceof Designer) { //判断设计师人数
contD = contD + 1;
}
if (arr.get(i) instanceof Programmer) { //判断程序员人数
contP = contP + 1;
}
}
if (arrd.get(index).getPosition().equals(" ")) {
throw new TeamException("该成员不是开发人员，无法添加！");
}
if (!arrd.get(index).getStatus()) {
throw new TeamException("该成员已是某团队成员，无法添加！");
}
if (arrd.get(index) instanceof Architect) {
contA = contA + 1;
if (contA > 1) {
throw new TeamException("架构师已满(最多一名)，无法添加！");
}
}
if (arrd.get(index) instanceof Designer) {
contD = contD + 1;
if (contD > 2) {
throw new TeamException("设计师已满(最多两名)，无法添加");
}
}
if (arrd.get(index) instanceof Programmer) {
contP = contP + 1;
if (contP > 3) {
throw new TeamException("程序员已满(最多三名)，无法添加");
}
}
if (arr.size() == 6) {
throw new TeamException("成员人数已满，无法添加！");
}
arr.add((TeamNumber) arrd.get(index));
DeveloperMethod.changeStatus(DEVELOPER, index);
System.out.println("添加成功");
}
public static void teamnumberCheck(TeamNumber teamNumber) { //团队开发人员信息的查看
ArrayList<TeamNumber> arr = teamNumber.getTeamNumbers();
System.out.println("TID/ID\t姓名\t年龄\t工资\t奖金\t股票");
for (int i = 0; i < arr.size(); i++) {
if (arr.get(i) instanceof Architect) {
System.out.println(String.valueOf(i + 1) + "/" + arr.get(i).getId() + "\t" + arr.get(i).getName() + "\t" + arr.get(i).getAge() + "\t\t" + arr.get(i).getSalary() + "\t" + ((Architect) arr.get(i)).getBonus() + "\t" + ((Architect) arr.get(i)).getStock());
continue;
}
if (arr.get(i) instanceof Designer) {
System.out.println(String.valueOf(i + 1) + "/" + arr.get(i).getId() + "\t" + arr.get(i).getName() + "\t" + arr.get(i).getAge() + "\t\t" + arr.get(i).getSalary() + "\t" + ((Designer) arr.get(i)).getBonus());
continue;
}
if (arr.get(i) instanceof Programmer) {
System.out.println(String.valueOf(i + 1) + "/" + arr.get(i).getId() + "\t" + arr.get(i).getName() + "\t" + arr.get(i).getAge() + "\t\t" + arr.get(i).getSalary());
continue;
}
if (arr.get(i) instanceof Developer) {
System.out.println(String.valueOf(i + 1) + "/" + arr.get(i).getId() + "\t" + arr.get(i).getName() + "\t" + arr.get(i).getAge() + "\t\t" + arr.get(i).getSalary());
continue;
}
}
}
public static void teamnumberRemove(TeamNumber teamNumber, int index) throws TeamException {//删除团队里的某个开发人员
ArrayList<TeamNumber> arr = teamNumber.getTeamNumbers();
TeamNumber res = new TeamNumber();
if (arr.size() == 0) {
throw new TeamException("还未添加开发人员，无法删除！");
}
for (int i = 0; i < arr.size(); i++) {
if (arr.get(i).getId() == index + 1) {
res = arr.get(i);
break;
} else if (i == arr.size() - 1 && arr.get(i).getId() != index + 1) {
throw new TeamException("输入错误，无法找到该成员，无法删除！");
}
}
arr.remove(res);
res.setStatus(true);
System.out.println("删除成功！");
}
public static void teamAdd(Team TEAM, TeamNumber teamNumber) throws TeamException { //将添加好的团队整个添加到TEAM里
ArrayList<ArrayList<TeamNumber>> arr = TEAM.getTeam();
if (teamNumber.getTeamNumbers().size() == 0){
throw new TeamException("未添加团队！");
}
arr.add(teamNumber.getTeamNumbers());
}
public static void teamCheck(Team TEAM) { //查看团队列表
ArrayList<ArrayList<TeamNumber>> arr = TEAM.getTeam();
for (int i = 0; i < arr.size(); i++) {
for (int j = 0; j < arr.get(i).size(); j++) {
if (arr.get(i).get(j) instanceof Architect) {
System.out.println(arr.get(i).get(j).getId() + "\t" + arr.get(i).get(j).getName() + "\t" + arr.get(i).get(j).getAge() + "\t\t" + arr.get(i).get(j).getSalary() + "\t" + arr.get(i).get(j).getPosition() + "\t" + arr.get(i).get(j).getStatus() + "\t" + ((Architect) arr.get(i).get(j)).getBonus() + "\t" + ((Architect) arr.get(i).get(j)).getStock() + "\t" + arr.get(i).get(j).getEquipment());
continue;
}
if (arr.get(i).get(j) instanceof Designer) {
System.out.println(arr.get(i).get(j).getId() + "\t" + arr.get(i).get(j).getName() + "\t" + arr.get(i).get(j).getAge() + "\t\t" + arr.get(i).get(j).getSalary() + "\t" + arr.get(i).get(j).getPosition() + "\t" + arr.get(i).get(j).getStatus() + "\t" + ((Designer) arr.get(i).get(j)).getBonus() + "\t" + arr.get(i).get(j).getEquipment());
continue;
}
if (arr.get(i).get(j) instanceof Programmer) {
System.out.println(arr.get(i).get(j).getId() + "\t" + arr.get(i).get(j).getName() + "\t" + arr.get(i).get(j).getAge() + "\t\t" + arr.get(i).get(j).getSalary() + "\t" + arr.get(i).get(j).getPosition() + "\t" + arr.get(i).get(j).getStatus() + "\t" + arr.get(i).get(j).getEquipment());
continue;
}
if (arr.get(i).get(j) instanceof Developer) {
System.out.println(arr.get(i).get(j).getId() + "\t" + arr.get(i).get(j).getName() + "\t" + arr.get(i).get(j).getAge() + "\t\t" + arr.get(i).get(j).getSalary());
continue;
}
}
System.out.println("------------------------");
}
}
public static void teamRemove(Team TEAM, int index) throws TeamException { //删除团队
ArrayList<ArrayList<TeamNumber>> arr = TEAM.getTeam();
if (arr.size() == 0) {
throw new TeamException("未添加团队，无法删除！");
}
if (index < 1 || index + 1 > arr.size()) {
throw new TeamException("输入错误，只有"+arr.size()+"个团队，无法删除！");
}
arr.remove(index);
System.out.println("删除成功！");
}
}创建一个TeamDispatchView类来展示相对应的功能。
public class TeamDispatchView {
public static Team teamdispatchview(Developer DEVELOPER, Team TEAM) {
int flag = 1;
int mark = 0;
while (flag == 1) {
TeamNumber teamNumber = new TeamNumber();
System.out.println("--------团队调度界面--------");
System.out.println("1. 添加团队");
System.out.println("2. 查看团队");
System.out.println("3. 删除团队");
System.out.println("4. 退出");
System.out.print("请选择：");
flag = 0;
char i = TSUtility.readMenuSelection();
while (flag == 0) {
switch (i) {
case '1':
System.out.println("--------开发团队调度软件--------");
System.out.println();
DeveloperMethod.developerCheck(DEVELOPER);
System.out.println("1. 团队列表");
System.out.println("2. 添加团队成员");
System.out.println("3. 删除团队成员");
System.out.println("4. 退出");
System.out.print("请选择：");
char i1 = TSUtility.readMenuSelection();
switch (i1) {
case '1':
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
TeamMethod.teamnumberCheck(teamNumber);
break;
case '2':
System.out.print("请输入要添加员工的ID：");
int id12 = TSUtility.readInt();
try {
TeamMethod.teamnumberAdd(DEVELOPER, teamNumber, id12 - 1);
} catch (TeamException e) {
System.out.println("无法添加，原因："+e.getMessage());
}
TSUtility.readReturn();
break;
case '3':
System.out.println("请输入要删除员工的ID：");
int id3 = TSUtility.readInt();
try {
TeamMethod.teamnumberRemove(teamNumber,id3-1);
} catch (TeamException e) {
System.out.println("删除失败，原因："+e.getMessage());
}
TSUtility.readReturn();
break;
case '4':
char res = TSUtility.readConfirmSelection();
if (res == 'Y' || res == 'y'){
flag = 1;
}
if (res == 'N' || res == 'n' ){
flag = 0;
}
try {
TeamMethod.teamAdd(TEAM, teamNumber);
} catch (TeamException e) {
System.out.println(e.getMessage());
}
break;
}
break;
case '2':
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("--------团队列表--------");
TeamMethod.teamCheck(TEAM);
flag = 1;
break;
case '3':
System.out.println("请选择你要删除第几个团队：");
int i3 = TSUtility.readInt();
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
TeamMethod.teamRemove(TEAM, i3-1);
} catch (TeamException e) {
System.out.println("无法删除，原因："+e.getMessage());
}
TSUtility.readReturn();
flag = 1;
break;
case '4':
flag = -1;
break;
}
}
}
return TEAM;
}
}界面功能及展示：
添加团队
添加团队成员
查看团队列表
删除团队成员
查看团队
删除团队
五、开发项目管理模块
开发项目管理模块需要有项目的添加，项目的查看，将项目随机分配给添加好的团队，项目的删除。
首先需要创建Project类，表示一个项目，属性包括项目的编号id，项目的名字name，项目的具体描述description，ArrayList<Project>来存储整个所有项目的信息。创建ProjectImplementation类，这是项目实现类，在进行项目分配功能时使用，表示一个项目的具体信息，包括开发团队，是否被开发。
public class Project { //储存项目的信息
private int ID;
private String name;
private String description;
private ArrayList<Project> PROJECT = new ArrayList<>();
public Project() {
}
public Project(int ID, String name, String description, ArrayList<Project> PROJECT) {
this.ID = ID;
this.name = name;
this.description = description;
this.PROJECT = PROJECT;
}
public Project(int ID, String name, String description) {
this.ID = ID;
this.name = name;
this.description = description;
}
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 String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public ArrayList<Project> getPROJECT() {
return PROJECT;
}
public void setPROJECT(ArrayList<Project> PROJECT) {
this.PROJECT = PROJECT;
}
}public class ProjectImplementation extends Project { //存储实现项目的相关信息
private String teamname;
private boolean status;
private ArrayList<ProjectImplementation> PROIMPLEMENTATION = new ArrayList<>();
public ProjectImplementation() {
}
public ProjectImplementation(int ID, String name, String description, ArrayList<Project> PROJECT, String teamname, boolean status, ArrayList<ProjectImplementation> PROIMPLEMENTATION) {
super(ID, name, description, PROJECT);
this.teamname = teamname;
this.status = status;
this.PROIMPLEMENTATION = PROIMPLEMENTATION;
}
public ProjectImplementation(int ID, String name, String description, String teamname, boolean status) {
super(ID, name, description);
this.teamname = teamname;
this.status = status;
}
public String getTeamname() {
return teamname;
}
public void setTeamname(String teamname) {
this.teamname = teamname;
}
public boolean getStatus() {
return status;
}
public void setStatus(boolean status) {
this.status = status;
}
public ArrayList<ProjectImplementation> getPROIMPLEMENTATION() {
return PROIMPLEMENTATION;
}
public void setPROIMPLEMENTATION(ArrayList<ProjectImplementation> PROIMPLEMENTATION) {
this.PROIMPLEMENTATION = PROIMPLEMENTATION;
}
} 创建ProjectMethod类，里面是项目的添加，分配，删除方法。还需要创建ProjectException类来进行异常的处理。主要是分配方法，由于我能力不足，分配方法也不是很完善，只做得到简易的分配，大概看看就可以了。
public class ProjectMethod {
public static void projectAdd(Project PROJECT){ //参考项目初始化
ArrayList<Project> arr = PROJECT.getPROJECT();
arr.add(new Project(1, "小米官网", "开发完成类似于小米官网的web项目"));
arr.add(new Project(2, "公益在线商城", "猫宁Morning公益商城是中国公益性电子商城"));
arr.add(new Project(3, "博客系统", "Java博客系统，让每一个有故事的人更好的表达想法！"));
arr.add(new Project(4, "在线协作文档编辑系统", "一个很常用的功能，适合小组内的文档编辑"));
}
public static void projectShow(Project PROJECT) { //参考项目的展示
System.out.println("项目参考：---------------------------------------------------");
ArrayList<Project> arr = PROJECT.getPROJECT();
for (int i = 0; i < arr.size(); i++) {
System.out.println(arr.get(i).getID() + "." + arr.get(i).getName() + "：" + arr.get(i).getDescription());
}
System.out.println("------------------------------------------------------------");
}
public static void projectimplementationAdd(ProjectImplementation projectImplementation, Project PROJECT, int index) throws ProjectException { //添加项目的方法
ArrayList<ProjectImplementation> arr = projectImplementation.getPROIMPLEMENTATION();
ArrayList<Project> arrp = PROJECT.getPROJECT();
for (int i = 0; i<arr.size(); i++){
if (arr.get(i).getID() == index+1){
throw new ProjectException("已添加过该项目，无法添加！");
}
}
arr.add(new ProjectImplementation(arrp.get(index).getID(),arrp.get(index).getName(),arrp.get(index).getDescription(),"null",false));
System.out.println("已添加项目："+arrp.get(index).getName());
}
public static void projectimplementationCheck(ProjectImplementation projectImplementation) { //查看项目的方法
ArrayList<ProjectImplementation> arr = projectImplementation.getPROIMPLEMENTATION();
for (int i = 0; i<arr.size(); i++){
if (!arr.get(i).getStatus()){
System.out.println("项目{项目号='"+arr.get(i).getID()+"' 项目名='"+arr.get(i).getName()+"', 项目描述='"+arr.get(i).getDescription()+"', 开发团队名称='"+arr.get(i).getTeamname()+"', 开发状态="+arr.get(i).getStatus()+"}");
System.out.println("项目【"+arr.get(i).getName()+"】---->未被开发！");
}else{
System.out.println("项目【"+arr.get(i).getName()+"】---->正在被团队【"+arr.get(i).getTeamname()+"】开发中！");
}
}
}
public static void projectimplementationAllocate(Team TEAM, ProjectImplementation projectImplementation) throws ProjectException { //项目分配
Random ra = new Random();
ArrayList<ArrayList<TeamNumber>> arr = TEAM.getTeam();
if (arr.size() == 0){
throw new ProjectException("未创建团队，无法分配项目！");
}
if (projectImplementation.getPROIMPLEMENTATION().size() == 0){
throw new ProjectException("未添加项目，无法分配！");
}
for (int p = 0; p<projectImplementation.getPROIMPLEMENTATION().size(); p++){
if (!projectImplementation.getPROIMPLEMENTATION().get(p).getStatus()){
break;
}
else if (p == projectImplementation.getPROIMPLEMENTATION().size()-1 && projectImplementation.getPROIMPLEMENTATION().get(p).getStatus()){
throw new ProjectException("所有项目都已在开发，无法再分配！");
}
}
int[] mark = new int[arr.size()]; //mark数组用来避免随机数生成重复的数
int k = 0;
if (projectImplementation.getPROIMPLEMENTATION().size() >= arr.size()) { //未开发项目数大于等于团队数
for (int i = 0; i < arr.size(); i++) {
int res = 0;
System.out.println("当前团队有人员：");
for (int j = 0; j < arr.get(i).size(); j++) {
if (arr.get(i).get(j) instanceof Architect) {
System.out.println(arr.get(i).get(j).getId() + "\t" + arr.get(i).get(j).getName() + "\t" + arr.get(i).get(j).getAge() + "\t\t" + arr.get(i).get(j).getSalary() + "\t" + arr.get(i).get(j).getPosition() + "\t" + arr.get(i).get(j).getStatus() + "\t" + ((Architect) arr.get(i).get(j)).getBonus() + "\t" + ((Architect) arr.get(i).get(j)).getStock() + "\t" + arr.get(i).get(j).getEquipment());
continue;
}
if (arr.get(i).get(j) instanceof Designer) {
System.out.println(arr.get(i).get(j).getId() + "\t" + arr.get(i).get(j).getName() + "\t" + arr.get(i).get(j).getAge() + "\t\t" + arr.get(i).get(j).getSalary() + "\t" + arr.get(i).get(j).getPosition() + "\t" + arr.get(i).get(j).getStatus() + "\t" + ((Designer) arr.get(i).get(j)).getBonus() + "\t" + arr.get(i).get(j).getEquipment());
continue;
}
if (arr.get(i).get(j) instanceof Programmer) {
System.out.println(arr.get(i).get(j).getId() + "\t" + arr.get(i).get(j).getName() + "\t" + arr.get(i).get(j).getAge() + "\t\t" + arr.get(i).get(j).getSalary() + "\t" + arr.get(i).get(j).getPosition() + "\t" + arr.get(i).get(j).getStatus() + "\t" + arr.get(i).get(j).getEquipment());
continue;
}
if (arr.get(i).get(j) instanceof Developer) {
System.out.println(arr.get(i).get(j).getId() + "\t" + arr.get(i).get(j).getName() + "\t" + arr.get(i).get(j).getAge() + "\t\t" + arr.get(i).get(j).getSalary());
continue;
}
}
System.out.println("请为当前团队创建一个团队名称：");
String teamname = TSUtility.readKeyBoard(10, false);
int flag = 0;
while (flag == 0) { //用来进行随机分配，并且把分配的数记录到mark数组中，以免下次分配重复
res = ra.nextInt(arr.size()) + 1;
for (int ar = 0; ar < mark.length ; ar++) {
if (mark[ar] == res) {
break;
} else if (mark[ar] != res && ar == mark.length - 1) {
projectImplementation.getPROIMPLEMENTATION().get(res ).setTeamname(teamname);
projectImplementation.getPROIMPLEMENTATION().get(res ).setStatus(true);
mark[k] = res;
flag = 1;
k++;
}
}
}
}
}
if (projectImplementation.getPROIMPLEMENTATION().size() < arr.size()){
throw new ProjectException("项目数不能小于团队数，请再添加项目！");
}
//
}
public static void projectRemove(ProjectImplementation projectImplementation, int index) throws ProjectException { //项目的删除
ArrayList<ProjectImplementation> arr = projectImplementation.getPROIMPLEMENTATION();
ProjectImplementation res = new ProjectImplementation();
if(arr.size() == 0){
throw new ProjectException("未添加项目，无法删除！");
}
for (int i = 0; i<arr.size(); i++){
if (arr.get(i).getID() == index+1){
if (arr.get(i).getStatus() == true){
throw new ProjectException("项目正在被开发，无法删除！");
}
res = arr.get(i);
break;
}else if (i == arr.size()-1 && arr.get(i).getID()!= index+1){
throw new ProjectException("项目编号输入错误，无法删除");
}
}
arr.remove(res);
}
}最后创建ProjectView类来进行展示
public class ProjectView {
public static void projectview(Project PROJECT, ProjectImplementation projectImplementation, Team TEAM) {
int flag = 0;
ProjectMethod.projectAdd(PROJECT);
while (flag == 0) {
System.out.println("--------开发项目管理主菜单--------");
System.out.println("1. <项目的添加>");
System.out.println("2. <项目分配开发团队>");
System.out.println("3. <项目的查看>");
System.out.println("4. <项目的删除>");
System.out.println("5. <退出当前菜单>");
System.out.print("请选择：");
char i = TSUtility.readMenuSelectionPro();
switch (i) {
case '1':
ProjectMethod.projectShow(PROJECT);
TSUtility.readReturn();
System.out.print("请输入你想添加的项目名：");
char i1 = TSUtility.readMenuSelection();
try {
TSUtility.loadSpecialEffects();
} catch (InterruptedException e) {
e.printStackTrace();
}
int i11 = (int) (i1) - 48;
try {
ProjectMethod.projectimplementationAdd(projectImplementation, PROJECT, i11 - 1);
} catch (ProjectException e) {
System.out.println("无法添加，原因："+e.getMessage());
}
break;
case '2':
try {
ProjectMethod.projectimplementationAllocate(TEAM, projectImplementation);
} catch (ProjectException e) {
System.out.println("无法分配任务，原因："+e.getMessage());
}
break;
case '3':
ProjectMethod.projectimplementationCheck(projectImplementation);
break;
case '4':
System.out.println("请输入需要删除项目的ID：");
int id = TSUtility.readInt();
try {
ProjectMethod.projectRemove(projectImplementation,id-1);
} catch (ProjectException e) {
System.out.println("无法删除，原因："+e.getMessage());
}
break;
case '5':
flag = 1;
break;
}
}
}
}界面及功能展示：
项目的添加
项目的查看
项目的分配
项目的删除
总结：
这次项目是我第一次做这么多的一个项目，但是虽然看着多，分个几天写，也还好。我发现写项目一定要在最开始时，把整体思路理顺，再开始写，要不然中间发现前面错了要修改的话，特别麻烦。总得来说，这是我第一次写项目，纪念一下，但是看着跟那些大佬的项目还是有很大的差距，后面时间继续学习，争取写出一个比较正规，满意的项目！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
