项目开发团队分配管理系统

m0_71467744

已于 2022-07-25 10:32:42 修改

阅读量324

点赞数

文章标签： java 面试开发语言

于 2022-07-23 11:19:06 首次发布

本文链接：https://blog.csdn.net/m0_71467744/article/details/125943143

版权

一、项目目标

1.模拟实现一个基于文本界面的《项目开发团队分配管理软件》

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

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

（1）类的继承性和多态性

（2）对象的值传递、接口 static和final修饰符

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

（4）异常处理

（5）Java基本语法和流程控制

（6）数组，ArrayList集合

二、项目需求说明

1.软件实现功能：

（1）软件启动时，首先进入登录界面进行注册和登录功能。

（2）当登陆成功后，进入菜单，首先就可以对开发人员账户和密码进行修改。

（3）然后可以对开发人员进行增删改操作

（4）人员添加成功后，根据菜单提示，基于现有的公司成员，组建一个开发团队以开发一个新的项目。

（5）组建过程包括将成员插入到团队中，或从团队中删除某成员，还可以列出团队中现有成员的列表，开发团队成员包括架构师、设计师和程序员。

（6）团队组建成功，则可以进入项目模块，添加项目，分配开发团队进行开发。

三、软件基本结构

1.软件主要分为：登录注册模块（启动软件首页，功能模块Logic）、软件主菜单页面（展示软件功能模块‘主控模块’SoftwareMainMenu）、开发人员管理模块（功能模块Domain）、开发团队管理模块（功能模块Team）、开发项目管理模块（功能模块Iteam）以及视图展示模块（Runview）

四、系统基本流程图

五、功能结构图

六、功能模块简述

package SoftwareMainMenu;
//工具类
import Domain.CXDeveloper;
import Iteam.ITeams;

import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

public class TSUtility {
    private static Scanner scanner = new Scanner(System.in);

    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;
    }
    public static char readMenuSelection1() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1, false);
            c = str.charAt(0);
            if (c != '1' && c != '2') {
                System.out.print("选择错误，请重新输入：");
            } else break;
        }
        return c;
    }
    public static char readMenuSelectionPro() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1, false);
            c = str.charAt(0);
            if (c != '1' && c != '2' &&
                    c != '3' && c != '4' && c != '5'&&c!='6') {
                System.out.print("选择错误，请重新输入：");
            } else break;
        }
        return c;
    }
    public static char readMenuSelectionPro1() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1, false);
            c = str.charAt(0);
            if (c != '1' && c != '2' &&
                    c != '3' && c != '4' && c != '5') {
                System.out.print("选择错误，请重新输入：");
            } else break;
        }
        return c;
    }
    public static int readMenuSelectionPro2(ArrayList<CXDeveloper> array) {
        int c =0;
        for (; ; ) {
            String str = readKeyBoard(3, false);
            try {
                c= Integer.parseInt(str);
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
            if (c <=0 || c>array.size() ) {
                System.out.print("员工不存在，请重新输入：");
            } else break;
        }
        return c;
    }
    public static int readMenuSelectionPro3(ArrayList<CXDeveloper[]> tm) {
        int c =0;
        for (; ; ) {
            String str = readKeyBoard(3, false);
            try {
                c= Integer.parseInt(str);
                if (c <=0 || c>tm.size() ) {
                    System.out.print("团队不存在，请重新输入：");
                } else break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return c;
    }
    public static int readMenuSelectionPro5(ArrayList<ITeams> itm) {
        int c =0;
        for (; ; ) {
            String str = readKeyBoard(3, false);
            try {
                c= Integer.parseInt(str);
                if (c <=0 || c>itm.size() ) {
                    System.out.print("该项目不存在，请重新输入：");
                } else break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return c;
    }
    public static int readMenuSelectionPro4(CXDeveloper[] cx ,int in) {
        int c =0;
        for (; ; ) {
            String str = readKeyBoard(3, false);
            try {
                c= Integer.parseInt(str);
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
            if (c <=0 || c>in ) {
                System.out.print("该员工不在此团队中，请重新输入：");
            } else break;
        }
        return c;
    }
    public static void readReturn() {
        System.out.print("按回车键继续...");
        readKeyBoard(100, true);
    }

    public static int readInt() {
        int n;
        for (; ; ) {
            String str = readKeyBoard(2, false);
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }
    /**
     从键盘读取一个长度不超过2位的整数，并将其作为方法的返回值。
     如果用户不输入字符而直接回车，方法将以defaultValue 作为返回值。
     */
    public static int readInt(int defaultValue) {
        int n;
        for (; ; ) {
            String str = readKeyBoard(2, true);
            if (str.equals("")) {
                return defaultValue;
            }

            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }
    public static double readDouble(double defaultValue) {
        double n;
        for (; ; ) {
            String str = readKeyBoard(6, true);
            if (str.equals("")) {
                return defaultValue;
            }

            try {
                n = Double.parseDouble(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }

    public static int readstock() {
        int n;
        for (; ; ) {
            String str = readKeyBoard(6, false);
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }
    public static Double readDouble() {
        Double n;
        for (; ; ) {
            String str = readKeyBoard(6, false);
            try {
                n = Double.parseDouble(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }

    public static char readConfirmSelection() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1, false).toUpperCase();
            c = str.charAt(0);
            if (c == 'Y' || c == 'N') {
                break;
            } else {
                System.out.print("选择错误，请重新输入：");
            }
        }
        return c;
    }
    public static char readConfirmSelection1() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1, false).toUpperCase();
            c = str.charAt(0);
            if (c == 'A' || c == 'B'||c=='C') {
                break;
            } else {
                System.out.print("选择错误，请重新输入：");
            }
        }
        return c;
    }
    /**
     从键盘读取一个长度不超过limit的字符串，并将其作为方法的返回值。
     如果用户不输入字符而直接回车，方法将以defaultValue 作为返回值。
     */
    public static String readString(int limit, String defaultValue) {
        String str = readKeyBoard(limit, true);
        return str.equals("")? defaultValue : str;
    }

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

    public static void loadSpecialEffects() throws InterruptedException {
        System.out.println("请稍等：");
        for (int i1 = 1; i1 <= 100; i1++) {
            System.out.print("加载中：" + i1 + "%");
            Thread.sleep(new Random().nextInt(25) + 1);
            if (i1 == 100) {
                Thread.sleep(50);
            }
            System.out.print("\r");
        }
    }

}

1.用户注册和登录模块

实现注册方法如果没有账户则需要注册如果有账号则直接进行登录实现登录功能判断用户输入的值是否正确如果正确则进入软件菜单如果错误则重新输入，限制次数只有5次，超过次数则程序停止，重新启动实现修改用户密码功能可以实现对用户名，密码，或者两者都可以进行修改即可。

package Logic;
//注册页
import SoftwareMainMenu.TSUtility;
import Runview.MenuVue;

import java.util.ArrayList;
import java.util.Scanner;

public class Login {

    static Scanner sc=new Scanner(System.in);
    public static void login(ArrayList<User> arry) throws InterruptedException {
        System.out.print("请输入您的用户名：");
        //判断用户名是否重复
        String name=judge(arry);
        System.out.print("请输入您的密码（由数字或大小写字母组成且长度大于等于6位）：");
        //密码限制
        String password=judgepassword();
        //延时加载
        TSUtility.loadSpecialEffects();
        if (name.equals("")||password.equals("")){
            System.out.println("用户名和密码不能为空，注册失败！\n");
            //回车继续
            TSUtility.readReturn();
            //登录注册页面展示
            MenuVue.member();
        }else {
            User u = new User();
            u.setName(name);
            u.setPassword(password);
            arry.add(u);
            System.out.println("注册成功！\n");
            //回车继续
            TSUtility.readReturn();
            //登录注册页面展示
            MenuVue.member();
        }
    }
    //判断用户名是否重复
    public static String judge(ArrayList<User> arry) {
        String name="";
        if(arry.size()==0){
            name=TSUtility.readString(15,"");
        }else {
            boolean flag = true;
            while (flag) {
                name = TSUtility.readString(15,"");
                for (int i = 0; i < arry.size(); i++) {
                    User u = arry.get(i);
                    flag = false;
                    if (name.equals(u.getName())) {
                        System.out.print("用户名已存在，请重新输入：");
                        flag = true;
                        break;
                    }
                }

            }
        }
        return name;
    }
    public static String judgepassword(){
        boolean flag = true;
        String password="";
        while (flag) {
            password = TSUtility.readString(15,"");
            flag = false;
            for (int i = 0; i < password.length(); i++) {
                if (password.charAt(i) >= 'a' && password.charAt(i) <= 'z' ||
                        password.charAt(i) <= 'Z' && password.charAt(i) >= 'A' ||
                        password.charAt(i) >= '0' && password.charAt(i) <= '9') {

                } else {
                    System.out.println("密码格式有误！由数字或大小写字母组成且长度大于等于6位，请重新输入：");
                    flag = true;
                    break;
                }
            }
            if(password.length()>=6){
                int index=0,index1=0,index2=0;
                for (int i = 0; i < password.length(); i++) {
                    if (password.charAt(i) >= 'a' && password.charAt(i) <= 'z'){
                        index++;
                    }else if(password.charAt(i) <= 'Z' && password.charAt(i) >= 'A'){
                        index1++;
                    }else {
                        index2++;
                    }
                }
                if (index==0||index1==0||index2==0){
                    System.out.println("密码格式有误！由数字或大小写字母组成且长度大于等于6位，请重新输入：");
                    flag = true;
                }
            }else {
                System.out.println("密码格式有误！由数字或大小写字母组成且长度大于等于6位，请重新输入：");
                flag = true;
            }
        }
        return password;
    }
}

package Logic;

//登录页
import Domain.CXDeveloper;
import SoftwareMainMenu.MainMenu;
import SoftwareMainMenu.TSUtility;
import Runview.MenuVue;

import java.util.ArrayList;
import java.util.Scanner;

import static Runview.MenuVue.registerview;


public class Register {
    static Scanner sc=new Scanner(System.in);
    public static void register(ArrayList<User> arry,ArrayList<CXDeveloper> array) throws InterruptedException {
        boolean flag = true;
        int in = 5;
        while (flag) {
            System.out.print("请输入用户名：");
            String name = sc.next();
            System.out.print("请输入密码：");
            String password = sc.next();
            TSUtility.loadSpecialEffects();
            if (arry.size() == 0) {
                System.out.println("您的账号还未注册，请先注册！\n");
                //工具类调用，回车继续操作
                TSUtility.readReturn();
                //登录注册页面展示
                MenuVue.member();
                flag=false;
            } else {
                for (int i = 0; i < arry.size(); i++) {
                    User u = arry.get(i);
                    if (name.equals(u.getName())) {
                        if (password.equals(u.getPassword())) {
                            //登录成功页展示
                            registerview(u.getName());
                            //工具类调用，回车继续操作
                            TSUtility.readReturn();
                            //进入主菜单页
                            MainMenu.Mainmenu(arry,array);
                            //登录注册页面展示
                            MenuVue.member();
                            flag=false;
                        } else {
                            in--;
                            if (in>0) {
                                System.out.println("您输入的密码不正确！请重新输入账户密码");
                                System.out.println("您还有" + in + "次机会");
                            }else {
                                System.out.println("您已输入5次登录失败！\n");
                                flag=false;
                                TSUtility.readReturn();
                                //退出程序
                                //System.exit(0);
                                //登录注册页面展示
                                MenuVue.member();
                            }
                        }
                    } else {
                        in--;
                        if (in>0) {
                            System.out.println("您输入的账户名不正确！请重新输入账户密码");
                            System.out.println("您还有"+in+"次机会");
                        }else {
                            System.out.println("您已输入5次登录失败！\n");
                            flag=false;
                            TSUtility.readReturn();
                            //退出程序
                            //System.exit(0);
                            //登录注册页面展示
                            MenuVue.member();
                        }
                    }
                }
            }
        }
    }
}

2.开发人员管理

实现员工的添加(根据职业添加（无，程序员，设计师，架构师）) 实现员工的修改（至少修改员工的姓名，年龄，工资）实现员工的删除（注意员工id需要动态显示，也就是删除后，员工id需要更新）实现员工的查看（显示所有数据）；实现以上功能需要先建立员工抽象类，无职位人员实体类，构架师实体类，设计师实体类以及程序员实体类，重写toString方法，方便打印出人员信息

部分代码实现

构架师实体类

package Domain;
//构架师人员类
public class Developer extends CXDeveloper{
    private double salary;//工资
    private String position;//职位
    private boolean state;//状态
    private double bonus;//奖金
    private double stock;//股票
    public Developer(){}

    public Developer(String model, String display, String name, int age, double salary, String position, boolean state, double bonus, double stock) {
        super(model, display, name, age);
        this.salary = salary;
        this.position = position;
        this.state = state;
        this.bonus = bonus;
        this.stock = stock;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    public void setPosition(String position) {
        this.position = position;
    }

    public void setState(boolean state) {
        this.state = state;
    }

    public void setStock(double stock) {
        this.stock = stock;
    }

    public double getBonus() {
        return bonus;
    }

    public double getSalary() {
        return salary;
    }

    public double getStock() {
        return stock;
    }

    public String getPosition() {
        return position;
    }
    public boolean getState(){
        return state;
    }

    @Override
    public String toString() {
        return super.toString()+"\t"+salary + "\t"+position + '\t'+ state + " "+bonus +" "+
                 stock +"\t"+super.getModel()+"("+super.getDisplay()+")";
    }
}

人员管理

package Domain;

import Runview.MenuVue;
import SoftwareMainMenu.TSUtility;

import java.util.ArrayList;

//开发人员管理主页
public class MDeveloper {
    //人员管理主页功能模块
    public static void mdeveloper(ArrayList<CXDeveloper> array) throws InterruptedException {
        //延时加载方法调用
        TSUtility.loadSpecialEffects();
        System.out.println("\n");
        //人员管理功能菜单
        MenuVue.mdeveloperview();
        boolean flag=true;
        while (flag){
            char a=TSUtility.readMenuSelectionPro1();
            switch (a){
                case '1':
                    //添加开发人员信息
                    AddMDeveloper.addMDeveloper(array);
                    break;
                case '2':
                    //查看开发人员信息
                    AdminMDeveloper.adminmdeveloper1(array);
                    break;
                case '3':
                    //修改开发人员信息
                    ModifyMDeveloper.modifyMDeveloper(array);
                    break;
                case '4':
                    //删除开发人员信息
                    DeleteMDeveloper.deleteMDeveloper(array);
                    break;
                case '5':
                    //返回软件菜单页
                    flag=false;
                    //延时加载
                    TSUtility.loadSpecialEffects();
                    System.out.println("\n");
                    //软件主菜单
                    MenuVue.Mainmenuview();
                    break;
            }
        }
    }

添加开发人员信息（构架师添加）

package Domain;
//添加开发人员信息
import Logic.User;
import Runview.MenuVue;
import SoftwareMainMenu.TSUtility;

import java.util.ArrayList;
import java.util.Scanner;

public class AddMDeveloper {
    static Scanner sc=new Scanner(System.in);
    public static void addMDeveloper(ArrayList<CXDeveloper> array) throws InterruptedException {
        //延时加载方法调用
        TSUtility.loadSpecialEffects();
        //添加开发人员功能展示
        MenuVue.AddMdeveloperview();
        boolean flag=true;
        while (flag){
            char a=TSUtility.readMenuSelectionPro1();
            switch (a){
                case '1':
                    //添加无职位人员
                    addLaborialStaff(array);
                    break;
                case '2':
                    //添加构架师人员
                    addDeveloper(array);
                    break;
                case '3':
                    //添加设计师人员
                    addDesigner(array);
                    break;
                case '4':
                    //添加程序员人员
                    addProgrammer(array);
                    break;
                case '5':
                    flag=false;
                    System.out.println("\n");
                    //延时加载方法调用
                    TSUtility.loadSpecialEffects();
                    //开发人员管理主菜单
                    MenuVue.mdeveloperview();
                    break;
            }
        }
    }
    //添加构架师人员
    public static void addDeveloper(ArrayList<CXDeveloper> array) throws InterruptedException {
        System.out.println("**构架师人员添加**");
        System.out.print("请输入添加人员姓名：");
        Developer dlp=new Developer();
        dlp.setName(sc.next());
        System.out.print("请输入添加人员年龄（不能超过两位数）：");
        dlp.setAge(TSUtility.readInt());
        System.out.print("请输入添加人员的工资（不能超过六位数）：");
        dlp.setSalary(TSUtility.readDouble());
        dlp.setPosition("构架师");
        dlp.setState(true);
        System.out.print("请输入添加人员的奖金（不能超过六位数）：");
        dlp.setBonus(TSUtility.readDouble());
        System.out.print("请输入添加人员的股票（不能超过六位数）：");
        dlp.setStock(TSUtility.readDouble());
        System.out.println("**请配置构架师的设备电脑**");
        System.out.print("请输入配置电脑型号：");
        dlp.setModel(sc.next());
        System.out.print("请输入显示器型号名称：");
        dlp.setDisplay(sc.next());
        array.add(dlp);
        System.out.println("**人员添加成功！**");
        System.out.println("**设备添加成功！**");
        //回车继续
        TSUtility.readReturn();
        //延时加载方法调用
        TSUtility.loadSpecialEffects();
        System.out.println("\n");
        //添加开发人员功能展示
        MenuVue.AddMdeveloperview();
    }

初始化，修改，添加以及删除后课查看人员信息

package Domain;

import Runview.MenuVue;
import SoftwareMainMenu.TSUtility;

import java.util.ArrayList;

//查看人员信息
public class AdminMDeveloper {
    public static void adminmdeveloper1(ArrayList<CXDeveloper> array) throws InterruptedException {
        //延时加载方法调用
        TSUtility.loadSpecialEffects();
        System.out.println("\n");
        System.out.println("ID  姓名\t年龄 工资\t 职位\t状态   奖金\t  股票\t 领用设备");
        for (int i=0;i<array.size();i++){
            System.out.print(i+1+"\t");
            System.out.println(array.get(i));
        }
        //回车继续
        TSUtility.readReturn();
        System.out.println("\n");
        //人员管理功能菜单
        MenuVue.mdeveloperview();
    }
}

3.团队管理

如果添加操作因某种原因失败，将显示类似以下信息（失败原因视具体原因而不同）： 1-团队列表 2-添加团队成员 3-删除团队成员 4-退出请选择(1-4)：2

---------------------添加成员---------------------

请输入要添加的员工ID：

2 添加失败，原因：该员工已是某团队成员按回车键继续...

失败信息包含以下几种：

(需要抛出自定义异常) 成员已满，无法添加

该成员不是开发人员，无法添加

该员工已在本开发团队中

该员工已是某团队成员团队中至多只能有一名架构师（以下判断可借用instanceof进行判断）

团队中至多只能有两名设计师

团队中至多只能有三名程序员

部分代码实现：

团队的创建与删除：

package Team;


import Domain.CXDeveloper;
import Iteam.ITeams;
import Runview.MenuVue;
import SoftwareMainMenu.TSUtility;

import java.util.ArrayList;


//开发团队调度管理
public class TeamMenu {
    public static void team(ArrayList<CXDeveloper> array,ArrayList<CXDeveloper[]> tm,ArrayList<ITeams> itm,int ranNum) throws InterruptedException {
        //延时加载方法调用
        TSUtility.loadSpecialEffects();
        System.out.println("\n");
        //开发团队管理主菜单视图
        MenuVue.Teamview();
        boolean flag=true;
        while (flag){
            char a=TSUtility.readMenuSelection();
            switch (a){
                case '1':
                    //查看团队
                    AdminTeam.adminTeam(array,tm,ranNum,itm);
                    break;
                case '2':
                    //添加团队
                    addTeam(tm);
                    break;
                case '3':
                    //删除团队
                    deleteTeam(array,tm,itm,ranNum);
                    break;
                case '4':
                    //返回软件菜单页
                    flag=false;
                    //延时加载
                    TSUtility.loadSpecialEffects();
                    System.out.println("\n");
                    //软件主菜单
                    MenuVue.Mainmenuview();
                    break;
            }
        }
    }
    public static void addTeam(ArrayList<CXDeveloper[]> tm) throws InterruptedException {
        CXDeveloper []cx=new CXDeveloper[5];
        tm.add(cx);
        //延时加载
        TSUtility.loadSpecialEffects();
        System.out.println("团队创建完成！\n");
        //回车继续操作
        TSUtility.readReturn();
        //开发团队管理主菜单视图
        MenuVue.Teamview();
    }
    public static void deleteTeam(ArrayList<CXDeveloper> array,ArrayList<CXDeveloper[]> tm,ArrayList<ITeams> itm,int ranNum) throws InterruptedException {
        //延时加载
        TSUtility.loadSpecialEffects();
        if (tm.size()==0) {
            System.out.println("您还未建立团队！请先建立团队\n");
        }else {
            System.out.print("请输入您想要删除的团队编号：");
            int index = TSUtility.readMenuSelectionPro3(tm);
            int JS=0;
            if (itm.size() != 0) {
                for (int i=0;i<itm.size();i++){
                    if(itm.get(i).getState()){
                        JS++;
                    }
                }
                if (index == ranNum+1&&JS!=0) {
                    System.out.println("该团队正在开发项目中，不能删除，删除失败！\n");
                }else {
                    deleteteam(tm,array,index);
                }
            } else {
               deleteteam(tm,array,index);
            }
        }
        //回车继续操作
        TSUtility.readReturn();
        //开发团队管理主菜单视图
        MenuVue.Teamview();
    }
    public static void deleteteam(ArrayList<CXDeveloper[]> tm,ArrayList<CXDeveloper> array,int index) throws InterruptedException {
        System.out.print("您确定要删除该团队吗？请输入（y/n）：");
        char b = TSUtility.readConfirmSelection();
        //加载延时
        TSUtility.loadSpecialEffects();
        if (b == 'Y' || b == 'y') {
            int in = 5;
            CXDeveloper[] cx = tm.get(index - 1);
            if (cx[0] == null) {
                tm.remove(index - 1);
                System.out.println("删除成功！\n");
            } else {
                for (int i = 0; i < cx.length; i++) {
                    if (cx[i] == null) {
                        in = i;
                        break;
                    }
                }
                for (int j = 0; j < in; j++) {
                    for (int k = 0; k < array.size(); k++) {
                        if (cx[j].getName().equals(array.get(k).getName())) {
                            array.get(k).setState(true);
                            break;
                        }
                    }
                }
                tm.remove(index - 1);
                System.out.println("删除成功！\n");
            }
        } else {
            System.out.println("您选择了No，该团队未删除！\n");
        }
    }
}

团队成员管理：

package Team;

import Domain.CXDeveloper;
import Iteam.ITeams;
import Runview.MenuVue;
import SoftwareMainMenu.TSUtility;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class AdminTeam {
    public static void adminTeam(ArrayList<CXDeveloper> array,ArrayList<CXDeveloper[]> tm,int ranNum,ArrayList<ITeams> itm) throws InterruptedException {
        //延时加载方法调用
        TSUtility.loadSpecialEffects();
        System.out.println("\n");
        //团队成员管理
        MenuVue.adminTeamView(array);
        boolean flag=true;
        while (flag){
            char a=TSUtility.readMenuSelection();
            switch (a){
                case '1':
                    //查看团队列表
                    adminteam(tm,array);
                    //团队成员管理
                    MenuVue.adminTeamView(array);
                    break;
                case '2':
                    //添加团队成员
                    addTeamMembers(tm,array);
                    break;
                case '3':
                    //删除团队成员
                    deleteTeamMembers(tm,array,ranNum,itm);
                    break;
                case '4':
                    //返回软件菜单页
                    flag=false;
                    //延时加载
                    TSUtility.loadSpecialEffects();
                    System.out.println("\n");
                    //开发团队管理主菜单
                    MenuVue.Teamview();
                    break;
            }
        }
    }
    //查看团队列表
    public static void adminteam(ArrayList<CXDeveloper[]> tm,ArrayList<CXDeveloper> array) throws InterruptedException {
        //延时加载
        TSUtility.loadSpecialEffects();
        if (tm.size()==0){
            System.out.println("您还未建立团队！请先建立团队\n");
        }else {
            System.out.println("--------------------------团队成员列表------------------------------\n");
            System.out.println("TID/ID  姓名\t年龄 工资\t 职位\t状态   奖金\t  股票\t 领用设备");
            for (int i=0;i<tm.size();i++){
                System.out.println("（团队"+(i+1)+"）");
                CXDeveloper[] cx=tm.get(i);
                if (cx[0] == null){
                    System.out.println("该团队中还未添加成员！请先添加成员！");
                }else {
                    //获取团队中的成员人数
                    int a=5;
                    for (int j=0;j<cx.length;j++){
                        if (cx[j]==null){
                            a=j;
                            break;
                        }
                    }
                    //打印出团队成员
                    for (int j=0;j<a;j++){
                        //TID
                        System.out.print((j+1)+"/");
                        for (int k=0;k<array.size();k++){
                            //获取团队中成员的开发人员id
                            if (cx[j].getName().equals(array.get(k).getName())){
                                System.out.print(k+1+"\t\t");
                                break;
                            }
                        }
                        System.out.println(cx[j]);
                    }
                }
                System.out.println("-------------------------------------------------------------------\n");
            }
            //System.out.println("-------------------------------------------------------------------\n");
        }
        //回车继续操作
        TSUtility.readReturn();
    }
    //添加团队成员
    public static void addTeamMembers(ArrayList<CXDeveloper[]> tm,ArrayList<CXDeveloper> array) throws InterruptedException {
        //延时加载
        TSUtility.loadSpecialEffects();
        int id=0;
        if (tm.size()==0){
            System.out.println("您还未建立团队！请先建立团队\n");
        }else {
            System.out.println("++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
            System.out.println("++ 每一个团队最多一名构架师，最多两名设计师，最多三名程序员 ++");
            System.out.println("++                   每个团队最多五名成员               ++");
            System.out.println("++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
            System.out.print("请输入团队编号：");
            int index=TSUtility.readMenuSelectionPro3(tm);
            int in=0;
            CXDeveloper[] cx = tm.get(index-1);
            for (int i=0;i<cx.length;i++){
                if (cx[i] == null){
                    in=i;
                    break;
                }
            }
            if (cx[in] == null) {
                System.out.print("请输入您要添加的成员ID：");
                id=decideID(array,cx,in);
                cx[in] = array.get(id - 1);
                tm.set(index-1, cx);
                System.out.println("添加完成！\n");
            }else {
                System.out.println("该团队人员已满！\n");
            }
        }
        //回车继续操作
        TSUtility.readReturn();
        //团队成员管理
        MenuVue.adminTeamView(array);
    }
    //判断人员是否已经是团队中的人员
    public static int decideID(ArrayList<CXDeveloper> array,CXDeveloper[] cx,int in){
        int id=0;
        boolean flag=true;
        while (flag) {
            id= TSUtility.readMenuSelectionPro2(array);
            //id对象
            CXDeveloper cdl=array.get(id-1);
            if (!cdl.getState()||cdl.getPosition().equals("")){
                System.out.print("该成员已是某团队中的成员或是无职位成员，添加失败！请重新输入成员ID:");
            }else {
                //限制职位人数
                if(in==0){
                    cdl.setState(false);
                    flag=false;
                }else {
                    flag=restriction(cdl,cx,in,flag);
                }
            }
        }
        return id;
    }
    //限制职位人数
    public static boolean restriction(CXDeveloper cdl,CXDeveloper[] cx,int in,boolean flag){
        int index=0;
        int index1=0;
        int index2=0;
        for (int i=0;i<in;i++) {
            CXDeveloper cpr = cx[i];
            if (cpr.getPosition().equals("构架师")) {
                index2++;
            }
            if(cpr.getPosition().equals("设计师")) {
                index1++;
            }
            if(cpr.getPosition().equals("程序员")) {
                index++;
            }
        }
        if(cdl.getPosition().equals("构架师")){
            if (index2==0){
                cdl.setState(false);
                flag=false;
            }else {
                System.out.print("每一个团队最多一名构架师，该团队中已有构架师！请重新输入成员ID:");
            }
        }
        if(cdl.getPosition().equals("设计师")){
            if (index1<2){
                cdl.setState(false);
                flag=false;
            }else {
                System.out.print("每一个团队最多两名设计师，该团队中已有设计师！请重新输入成员ID:");
            }
        }
        if(cdl.getPosition().equals("程序员")){
            if (index<3){
                cdl.setState(false);
                flag=false;
            }else {
                System.out.print("每一个团队最多三名程序员，该团队中已有程序员！请重新输入成员ID:");
            }
        }
        return flag;
    }
    //删除团队成员
    public static void deleteTeamMembers(ArrayList<CXDeveloper[]> tm,ArrayList<CXDeveloper> array,int ranNum,ArrayList<ITeams> itm) throws InterruptedException {
        //延时加载
        TSUtility.loadSpecialEffects();
        if (tm.size()==0){
            System.out.println("您还未建立团队！请先建立团队\n");
        }else {
            System.out.print("请输入团队编号：");
            int index=TSUtility.readMenuSelectionPro3(tm);
            int JS=0;
            if (itm.size() != 0) {
                for (int i = 0; i < itm.size(); i++) {
                    if (itm.get(i).getState()) {
                        JS++;
                    }
                }
                if (index == ranNum + 1 && JS != 0) {
                    System.out.println("该团队正在开发项目中，不能删除成员，删除失败！\n");
                }else {
                    delete(tm,array,index);
                }
            }else {
                delete(tm,array,index);
            }
        }
        //回车继续操作
        TSUtility.readReturn();
        //团队成员管理
        MenuVue.adminTeamView(array);
    }
    public static void delete(ArrayList<CXDeveloper[]> tm,ArrayList<CXDeveloper> array,int index) throws InterruptedException {
        int in=0;
        CXDeveloper[] cx = tm.get(index-1);
        if (cx[0]==null){
            System.out.println("该团队中没有成员，删除失败！");
        }else {
            for (int i = 0; i < cx.length; i++) {
                if (cx[i] == null) {
                    in = i;
                    break;
                }
            }
            System.out.print("请输入您要删除的成员TID：");
            int id = TSUtility.readMenuSelectionPro4(cx, in);
            System.out.println("您确定要删除该团队成员吗？请输入（y/n）：");
            char b=TSUtility.readConfirmSelection();
            //加载延时
            TSUtility.loadSpecialEffects();
            if(b=='Y'||b=='y'){
                for (int i=0;i<array.size();i++){
                    if (cx[id-1].getName().equals(array.get(i).getName())){
                        array.get(i).setState(true);
                    }
                }

                List<CXDeveloper> cx1 = Arrays.stream(cx).collect(Collectors.toList());
                cx1.remove(id - 1);
                CXDeveloper []cx2=new CXDeveloper[5];
                for (int i=0;i<cx1.size();i++){
                    cx2[i]=cx1.get(i);
                }
                tm.set(index-1,cx2);
                System.out.println("删除完成！\n");
            }else {
                System.out.println("您选择了No,该团队成员未删除！\n");
            }
        }
    }
}

注意：团队成员删除条件：删除需要删除的成员，又不改变团队数组的长度

解题思路，将原数组转为集合删除，用一个新的数组接收删除后的集合，再将新数组存放到原数组集合中原数组所在位置。

List<CXDeveloper> cx1 = Arrays.stream(cx).collect(Collectors.toList());
cx1.remove(id - 1);
CXDeveloper []cx2=new CXDeveloper[5];
for (int i=0;i<cx1.size();i++){
cx2[i]=cx1.get(i);
}
tm.set(index-1,cx2);

4.项目管理：

项目的创建，项目分配团队，项目删除，项目查看几个小功能及项目的属性和状态

部分代码实现

package Iteam;

import Domain.CXDeveloper;
import Runview.MenuVue;
import SoftwareMainMenu.TSUtility;
import Team.AdminTeam;

import java.util.ArrayList;
import java.util.Random;

//开发项目管理页面
public class ITeam {
    public static int iteam(ArrayList<CXDeveloper[]> tm,ArrayList<CXDeveloper> array,ArrayList<ITeams> itm) throws InterruptedException {
        int ranNum=0;
        //延时加载方法调用
        TSUtility.loadSpecialEffects();
        System.out.println("\n");
        //开发项目管理主菜单
        MenuVue.iteamView();
        boolean flag=true;
        while (flag){
            char a=TSUtility.readMenuSelectionPro1();
            switch (a){
                case '1':
                    //添加项目
                    AddiTeam.additeam(itm);
                    break;
                case '2':
                    //项目分配开发团队
                    ranNum=distribution(tm,array,itm);
                    break;
                case '3':
                    //查看项目
                    alt(itm);
                    break;
                case '4':
                    //删除项目
                    deleteITeam(itm);
                    break;
                case '5':
                    //返回软件菜单页
                    flag=false;
                    //延时加载
                    TSUtility.loadSpecialEffects();
                    System.out.println("\n");
                    //软件主菜单
                    MenuVue.Mainmenuview();
                    break;
            }
        }
        return ranNum;
    }
    //查看项目
    public static void alt(ArrayList<ITeams> itm) throws InterruptedException {
        //延时加载方法调用
        TSUtility.loadSpecialEffects();
        System.out.println("\n");
        System.out.println("*******************************************************************");
        System.out.println("**                                                               **");
        System.out.println("**                        项目展示                                **");
        System.out.println("**                                                               **");
        System.out.println("*******************************************************************");
        if (itm.size()==0){
            System.out.println("您还未创建项目！请先创建项目！");
        }else {
            System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
            for (int i=0;i<itm.size();i++){
                if (!itm.get(i).getState()) {
                    System.out.print("项目号：'" + (i + 1) + "'");
                    System.out.println(itm.get(i));
                    System.out.println("项目名："+itm.get(i).getName()+"开发状态：未被开发！");
                    System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
                }else {
                    System.out.print("项目号：'" + (i + 1) + "'");
                    System.out.println(itm.get(i));
                    System.out.println("项目名："+itm.get(i).getName()+"开发状态：开发中！");
                    System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
                }
            }
        }
        System.out.println("\n");
        //回车继续操作
        TSUtility.readReturn();
        //开发项目管理主菜单
        MenuVue.iteamView();
    }
    //项目分配
    public static int distribution(ArrayList<CXDeveloper[]> tm,ArrayList<CXDeveloper> array,ArrayList<ITeams> itm) throws InterruptedException {
        int ranNum=0;
        if (itm.size()==0){
            //延时加载方法调用
            TSUtility.loadSpecialEffects();
            System.out.println("\n");
            System.out.println("您还未创建项目！请先创建项目！\n");
        }else {
            if (tm.size() == 0) {
                //延时加载方法调用
                TSUtility.loadSpecialEffects();
                System.out.println("\n");
                System.out.println("您还没有创建团队，请先创建团队！\n");
            } else {
                System.out.println("****当前有以下几个团队****");
                AdminTeam.adminteam(tm,array);
                int JS=0;
                for (int i=0;i<tm.size();i++){
                    if (tm.get(i)[0]==null){
                        System.out.println("团队"+(i+1)+"中团队未分配人员，请先管理团队（删除团队或添加成员）！\n");
                        JS++;
                    }
                }
                if (JS==0) {
                    System.out.print("请输入你要分配的项目编号：");
                    int in = TSUtility.readMenuSelectionPro5(itm);
                    //随机将项目分配给团队
                    Random ra = new Random();
                    ranNum = ra.nextInt(tm.size());
                    System.out.print("项目已分配给" + (ranNum + 1) + "号团队，请给当前团队创建一个名字（团队名不能超过十个字）：");
                    itm.get(in - 1).setTname(TSUtility.readString(10, "") + "（团队" + (ranNum + 1) + ")");
                    itm.get(in - 1).setState(true);
                    System.out.println("项目分配成功！\n");
                }
            }
        }
        //回车继续操作
        TSUtility.readReturn();
        //开发项目管理主菜单
        MenuVue.iteamView();
        return ranNum;
    }
    //删除项目
    public static void deleteITeam(ArrayList<ITeams> itm) throws InterruptedException {
        //延时加载方法调用
        TSUtility.loadSpecialEffects();
        System.out.println("\n");
        if (itm.size()==0) {
            System.out.println("您还未创建项目！请先创建项目！\n");
        }else {
            System.out.print("请输入你要删除的项目编号：");
            int in=TSUtility.readMenuSelectionPro5(itm);
            System.out.println("您确定要删除该项目吗？请输入（y/n）：");
            char b=TSUtility.readConfirmSelection();
            //加载延时
            TSUtility.loadSpecialEffects();
            if(b=='Y'||b=='y'){
                itm.remove(in-1);
                System.out.println("项目删除成功！\n");
            }else {
                System.out.println("您选择了No,该项目未删除！\n");
            }
        }
        //回车继续操作
        TSUtility.readReturn();
        //开发项目管理主菜单
        MenuVue.iteamView();
    }
}

七、

m0_71467744

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
项目开发团队分配管理系统

实现员工的添加(根据职业添加（无，程序员，设计师，架构师）)实现员工的修改（至少修改员工的姓名，年龄，工资）实现员工的删除（注意员工id需要动态显示，也就是删除后，员工id需要更新）实现员工的查看（显示所有数据）（5）组建过程包括将成员插入到团队中，或从团队中删除某成员，还可以列出团队中现有成员的列表，开发团队成员包括架构师、设计师和程序员。---------------------添加成员---------------------（1）软件启动时，首先进入登录界面进行注册和登录功能。......
复制链接

扫一扫