开发团队分配管理

项  目  开  发  团  队  分  配  管  理  软  件

(基于Java)

前言:学习了这么多知识,我们来看看项目叭,毕竟Java三大特征都搞定了,不试一下自己手感,自己都感觉对不起自己!今天和我一起来看看这个项目的开发叭!能做GUI,但我就不做,哎!就是玩!因为之前的博客并没有给大家分享GUI的相关东西,所以这里就直接做的运行台版本的,并且个人之前也做过一个简约版的GUI界面,实在惨不忍睹!这里的也是一个基础版的,对数据库连接什么的也没有连接。若大佬需要,请绕道,或很多人需要,我也可以试试去写一个!看大家的呼吁声啦!

(一)、项目需求

该软件实现以下功能:
软件启动时,首先进入登录界面进行注册和登录功能。
当登陆成功后,进入菜单,首先就可以对开发人员账户和密码进行修改。
然后可以对开发人员进行增删改操作
人员添加成功后,根据菜单提示,基于现有的公司成员,组建一个开发团队以开发一个新的项目。
组建过程包括将成员插入到团队中,或从团队中删除某成员,还可以列出团队中现有成员的列表,开发团队成员包括架构师、设计师和程序员。
团队组建成功,则可以进入项目模块,添加项目,分配开发团队进行开发。

开发人员要求:
职业分配:无->只有姓名、年龄、工资
程序员->姓名、年龄、工资、职位(程序员)、是否空闲(状态)、领用的设备(笔记本)
设计师->姓名、年龄、工资、职位(程序员)、是否空闲(状态)、奖金、领用的设备(打印机)
架构师->姓名、年龄、工资、职位(程序员)、是否空闲(状态)、奖金、股票、领用的设备(台式电脑)

团队要求:
成员最多6位其中其中,最多为一名架构师、两名设计师、三名程序员,这里的成员只能少不能多,成员为0不可保存团队
无职位成员提示该成员不是开发成员

项目管理要求:
为添加的项目随机分配开发团队
为项目添加一个状态值,第一次删除团队时,将项目关闭,显示未开发状态,第二次在进行删除

(二)、剖析架构

我们一起来看看这样子的要求所需要的框架是怎样的:
结构

构思一下流程图
在这里插入图片描述
想想我们会用到哪些学过的知识点:

①不用到数据库,但要保存数据->ArrayList集合或者数组(ArrayList可扩展,用它方便一点,本次就采用它来进行数据的保存)
②开发人员不止一个,可能需要用到继承和多态
③为了保证程序的正常运行,我们需要自定义一个异常类,就还需要用到异常和接口
④用户进行选择和判断->Java基本语法与流程控制
⑤并不是一个类里面会用到数据集,就涉及到了值传递

思路

那么有想法了吗?你能猜到我下一步想干嘛吗?
想到了要用哪些知识来做这个项目,下一步当然是,
继续想呀!!啥也不是!知识点大家都知道,但重点是这个吗?不,我们要的是你们就这
和我一起来构思呀!想啥呢,你们不是我的菜呀!(有猜对的小伙伴在评论区Q就这?)
      一个开发人员分配,主要三个方面嘛,数据的相关存储格式(就类似于同一的表格化)、数据的增删改查、界面的显示与切换对应就创建三个包诺(domain、service、view)
分析一下这三个包的作用叭

domian:用来设计人员的保存以及设备等基础数据格式,并定义一个接口来进行数据的统一化

将职业无作为最初父类,程序员用来继承它,并生成新的属性状态和写一个新的设备添加方法
设计师再继承程序员,同样生成新的属性奖金和重写设备方法
架构师再继承设计师,生成新的属性股金和重写设备方法
既然有不同的设备,设备的相关属性肯定也不一致,再写几个对象对应笔记本、打印机、台式电脑叭
再随意写一个接口,象征我们是有标准的
最后他们保存出来的是一条条的数据,再定义一个项目对象来保存着一条条数据叭!

service:员工的人员管理、团队调度管理、项目分发

view:登陆界面设计、人员的增删改查界面、团队项目管理界面、项目分发界面

(三)、项目的代码实现

① domain(基本数据)

人员对象

无职业

#### 打印标准(定义的接口类)

```java
/**
 * 工号:id
 * 团队工号:TID
 * 姓名:name
 * 年龄:age
 * 工资:salary
 * 职位:memberID
 * 状态:status
 * 奖金:bouns
 * 股票:share
 * 设备:equipment**/
public class Employee {
    private int id;//id
    private String name;//姓名
    private int age;//年龄
    private double salary;//

    public Employee() {
    }

    public Employee(int id, String name, int age, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return id == employee.id &&
                age == employee.age &&
                Double.compare(employee.salary, salary) == 0 &&
                Objects.equals(name, employee.name);
    }
	//调用接口,统一标准
    protected String getDetails() {
        return this.id + "\t" + this.name + "\t" + this.age + "\t\t" + this.salary;
    }

    public String toString() {
        return getDetails();
    }
}

程序员:继承的无职业

public class Programmer extends Employee {
    private int memberID;
    private boolean status = true;
    private Equipment equipment;

    public Programmer() {

    }

    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 setMemberID(int memberID) {
        this.memberID = memberID;
    }

    public boolean isStatus() {
        return this.status;
    }

    public void setStatus(boolean status) {
        this.status = status;
    }

    public Equipment getEquipment() {
        return equipment;
    }

    public void setEquipment(Equipment equipment) {
        this.equipment = equipment;
    }

    public String getMemberDetails() {
        return getDetails();
    }

    public String getDetailsForTeam() {
        return getMemberDetails() + "\t程序员";
    }

    @Override
    public String toString() {
        return getDetailsForTeam() + "\t" + this.status + "\t\t\t\t\t" + equipment.getDescription();
    }
}

设计师:继承程序员

public class Designer extends Programmer {
    private double bouns;

    public Designer() {
    }

    public Designer(int id, String name, int age, double salary, Equipment equipment, double bouns) {
        super(id, name, age, salary, equipment);
        this.bouns = bouns;
    }

    public double getBouns() {
        return bouns;
    }

    public void setBouns(double bouns) {
        this.bouns = bouns;
    }

    public String getDetailsForTeam() {
        return getMemberDetails() + "\t设计师\t";
    }

    @Override
    public String toString() {
        return this.getDetailsForTeam() + this.isStatus() + "\t" + this.getBouns() + "\t\t\t" + this.getEquipment().getDescription();
    }
}

架构师:继承设计师

public class Architect extends Designer {
    private int share;

    public Architect() {
    }

    public Architect(int id, String name, int age, double salary, Equipment equipment, double bouns, int share) {
        super(id, name, age, salary, equipment, share);
        this.share = share;
    }

    public int getShare() {
        return share;
    }

    public void setShare(int share) {
        this.share = share;
    }

    public String getDetailsForTeam() {
        return getMemberDetails() + "\t架构师\t" + getBouns() + "\t" + getShare();
    }

    @Override
    public String toString() {
        return this.getDetails() + "\t架构师\t" + this.isStatus() + "\t" +
                this.getBouns() + "\t" + this.getShare() + "\t" + this.getEquipment().getDescription();
    }
}

设备对象

接口类,统一设备标准

public interface Equipment {
    String getDescription();
}

笔记本电脑

package com.week_6_5.team.domain;

import com.week_6_5.team.view.TSUtility;

public class NoteBook implements Equipment {
    private String model;//机器的型号
    private double price;//价格

    public NoteBook(String model, double price) {
        super();
        this.model = model;
        this.price = price;
    }

    public NoteBook() {
        super();
    }

    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 addNoteBook() {
        System.out.println("请输入需要配置的笔记本电脑的型号:");
        String model = TSUtility.readKeyBoard(10, false);
        System.out.println("请输入需要配置的笔记本电脑的价格:");
        Double price = TSUtility.readDouble();
        System.out.println("设备添加成功!");
        return new NoteBook(model, price);
    }

    @Override
    public String getDescription() {
        return model + "(" + price + ")";
    }
}

打印机

public class Printer implements Equipment {
    private String name;//名称
    private 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;
    }

    public Printer addPrinter() {
        System.out.println("请输入需要配置的打印机的名称:");
        String model = TSUtility.readKeyBoard(10, false);
        System.out.println("请输入需要配置的打印机的类型:");
        String display = TSUtility.readKeyBoard(10, false);
        System.out.println("设备添加成功!");
        return new Printer(model, display);
    }

    @Override
    public String getDescription() {
        return name + "(" + type + ")";
    }
}

台式电脑

public class PC implements Equipment {
    //机器型号
    private String model;
    //显示器名称
    private 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;
    }

    public PC addPC() {
        System.out.println("请输入需要配置的台式电脑的型号:");
        String model = TSUtility.readKeyBoard(10, false);
        System.out.println("请输入需要配置的台式电脑的显示器名称:");
        String display = TSUtility.readKeyBoard(10, false);
        System.out.println("设备添加成功!");
        return new PC(model, display);

    }

    @Override
    public String getDescription() {
        return model + "(" + display + ")";
    }
}

项目对象利用ArrayList保存

public class Project {
    /**
     * 项目号 proId
     * 项目名称 projectName
     * 项目描述 desName
     * 开发团队 team
     * 开发团队名称 teamName
     * 开发状态 status (true为开发中,false为未开发中))
     */
    private int proId;
    private String proName;
    private String proDes;
    private Employee[] team;
    private String teamName;
    private boolean status;

    public Project() {
    }

    public Project(int proId, String proName, String proDes, Programmer[] team, String teamName, boolean status) {
        this.proId = proId;
        this.proName = proName;
        this.proDes = proDes;
        this.team = team;
        this.teamName = teamName;
        this.status = status;
    }

    public int getProId() {
        return proId;
    }

    public void setProId(int proId) {
        this.proId = proId;
    }

    public String getProName() {
        return proName;
    }

    public void setProName(String proName) {
        this.proName = proName;
    }

    public String getProDes() {
        return proDes;
    }

    public void setProDes(String proDes) {
        this.proDes = proDes;
    }

    public Employee[] getTeam() {
        return team;
    }

    public void setTeam(Employee[] team) {
        this.team = team;
    }

    public String getTeamName() {
        return teamName;
    }

    public void setTeamName(String teamName) {
        this.teamName = teamName;
    }

    public boolean isStatus() {
        return status;
    }

    public void setStatus(boolean status) {
        this.status = status;
    }

    @Override
    public String toString() {
        if (status) {
            return "Project{" +
                    "proId='" + proId + '\'' +
                    ", proName='" + proName + '\'' +
                    ", proDes='" + proDes + '\'' +
                    ", team=" + Arrays.toString(team) +
                    ", teamName='" + teamName + '\'' +
                    ", status=" + true +
                    '}' + "\n" + "项目【" + proName + "】" + "---->正在被团队【" + teamName + "】开发中!";
        } else {
            return "项目{" +
                    "项目号='" + proId + '\'' +
                    ", 项目名='" + proName + '\'' +
                    ", 项目描述='" + proDes + '\'' +
                    ", 团队=" + Arrays.toString(team) +
                    ", 团队名='" + teamName + '\'' +
                    ", 状态=" + false +
                    '}' + "\n" + "项目【" + proName + "】---->" + "未被开发!";
        }
    }
}

service(部分功能的实现以及数据的流通问题)

上面我们已经定义过对应的参数类型了,接下来我们就使用泛型的方式来保存数据叭! 泛型,即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。

这一环节还有一个重点就是->数据流通问题,我们如果在每次调用的时候,都实例化了,那样我们的数据永远都只是初始数据,没有添加和删除的意义了,我代码里面有方法的哟!欢迎各位小伙伴们来寻找呀!

NameListService![在这按照设计要求编写NameListService类

一个属性为:private ArrayList employees
一个代码块用作数据的填充,如图(注意不同人的身份和设备都不同)
在这里插入图片描述
getAllEmployees():返回employees对象即可
getEmployee(int id):得到指定id的员工,没有则抛出自定义的异常。

public class NameListService {
	//泛型使用
    public ArrayList<Employee> employees = new ArrayList<>();
    private int count = 0;

    /*添加初始数据*/ {
        employees.add(new Employee(++count, "马云 ", 22, 3000));
        employees.add(new Architect(++count, "马化腾", 32, 18000, new NoteBook("联想T4", 6000), 60000, 5000));
        employees.add(new Programmer(++count, "李彦宏", 23, 7000, new PC("戴尔", "NEC 17寸")));
        employees.add(new Programmer(++count, "刘强东", 24, 7300, new PC("戴尔", "三星 17寸")));
        employees.add(new Designer(++count, "雷军 ", 50, 10000, new Printer("激光", "佳能2900"), 5000));
        employees.add(new Programmer(++count, "任志强", 30, 16800, new PC("华硕", "三星 17寸")));
        employees.add(new Designer(++count, "柳传志", 45, 35500, new PC("华硕", "三星 17寸"), 8000));
        employees.add(new Architect(++count, "杨元庆", 35, 6500, new Printer("针式", "爱普生20k"), 15500, 1200));
        employees.add(new Designer(++count, "史玉柱", 27, 7800, new NoteBook("惠普m6", 5800), 1500));
        employees.add(new Programmer(++count, "丁磊 ", 26, 6600, new PC("戴尔", "NEC17寸")));
        employees.add(new Programmer(++count, "张朝阳 ", 35, 7100, new PC("华硕", "三星 17寸")));
        employees.add(new Designer(++count, "杨致远", 38, 9600, new NoteBook("惠普m6", 5800), 3000));
    }

    /**
     * 获得所有员工
     **/
    public ArrayList<Employee> getALLemployees() {
        return employees;
    }

    /**
     * 员工的查看
     **/
    public Employee getEmPloyee(int id) throws TeamException {

        for (Employee employee : employees) {
            if (id == employee.getId()) {
                return employee;
            }

        }
        return null;
    }

    /**
     * 员工的增加
     **/
    public void addEmployee() {
        System.out.println("请输入需要添加的雇员的职位:");
        System.out.println("1(无职位)");
        System.out.println("2(程序员)");
        System.out.println("3(设计师)");
        System.out.println("4(架构师)");
        String c = String.valueOf(TSUtility.readMenuSelection());
        switch (c) {
            case "1" -> {
                //无职位 new Employee(count++,"马云 ",22,3000)
                System.out.println("当前雇员职位分配为:无");
                System.out.println("请输入当前员工的姓名:");
                String name = TSUtility.readKeyBoard(4, false);
                System.out.println("请输入当前员工的年龄:");
                int age = TSUtility.readInt();
                System.out.println("请输入当前员工的工资:");
                Double salary = TSUtility.readDouble();
                Employee employee = new Employee(++count, name, age, salary);
                employees.add(employee);
                System.out.println("该员工添加成功!");
                TSUtility.readReturn();
                break;
            }
            case "2" -> {
                //程序员 new Programmer(count++,"张朝阳 ",35,7100,new PC("华硕","三星 17寸"))
                System.out.println("当前雇员职位分配为:程序员");
                System.out.println("请输入当前员工的姓名:");
                String name = TSUtility.readKeyBoard(4, false);
                System.out.println("请输入当前员工的年龄:");
                int age = TSUtility.readInt();
                System.out.println("请输入当前员工的工资:");
                Double salary = TSUtility.readDouble();
                System.out.println("请为当前程序员员工配一台好的台式电脑:");
                PC pc = new PC().addPC();
                Programmer programmer = new Programmer(++count, name, age, salary, pc);
                employees.add(programmer);
                System.out.println("程序员添加成功!");
                TSUtility.readReturn();
                break;
            }
            case "3" -> {
                //设计师 new Designer(count++,"史玉柱",27,7800,new NoteBook("惠普m6",5800),1500)
                System.out.println("当前员工职位分配为:设计师");
                System.out.println("请输入当前员工的姓名:");
                String name = TSUtility.readKeyBoard(4, false);
                System.out.println("请输入当前员工的年龄:");
                int age = TSUtility.readInt();
                System.out.println("请输入当前员工的工资:");
                Double salary = TSUtility.readDouble();
                System.out.println("请为当前设计师配一台好的笔记本电脑:");
                NoteBook noteBook = new NoteBook().addNoteBook();
                System.out.println("请输入当前设计师的奖金:");
                Double bonus = TSUtility.readDouble();
                Designer designer = new Designer(++count, name, age, salary, noteBook, bonus);
                employees.add(designer);
                System.out.println("人员添加成功!");
                TSUtility.readReturn();

                break;
            }
            default -> {
                //架构师 new Architect(count++,"杨元庆",35,6500,new Printer("针式","爱普生20k"),15500,1200)
                System.out.println("当前员工职位分配为:架构师");
                System.out.println("请输入当前雇员的姓名:");
                String name = TSUtility.readKeyBoard(4, false);
                System.out.println("请输入当前员工的年龄:");
                int age = TSUtility.readInt();
                System.out.println("请输入当前员工的工资:");
                Double salary = TSUtility.readDouble();
                System.out.println("请为当前架构师配一台好的打印设备:");
                Printer printer = new Printer().addPrinter();
                System.out.println("请输入当前架构师的奖金:");
                Double bonus = TSUtility.readDouble();
                System.out.println("请输入当前架构师的股票:");
                Integer stock = TSUtility.readstock();
                Architect architect = new Architect(++count, name, age, salary, printer, bonus, stock);
                employees.add(architect);
                System.out.println("员工添加成功!");
                TSUtility.readReturn();
                break;
            }
        }
    }

    /**
     * 员工的删除
     **/
    public void delEmployee(int id) {
        boolean flag = false;
        for (int i = 0; i < employees.size(); i++) {
            if (employees.get(i).getId() == id) {
                employees.remove(i);
                for (i = id; i <= employees.size(); i++) {
                    employees.get(i - 1).setId(employees.get(i - 1).getId() - 1);
                }
                flag = true;
            }
        }
        if (flag) {
            System.out.println("删除成功!");
            count--;
        } else {
            try {
                throw new TeamException("该员工不存在");
            } catch (TeamException e) {
                System.out.println("员工删除失败。原因:"+e.getMessage());
            }
        }

    }

    /**
     * 员工信息修改
     **/
    public void change(int id) throws TeamException {
        boolean flag = true;
        for (int i = 0; i < employees.size(); i++) {
            Employee emp = employees.get(i);
            if (employees.get(i).getId() == id) {
                System.out.print("姓名(" + emp.getName() + "):");
                String name = TSUtility.readString(4, emp.getName());
                System.out.print("年龄(" + emp.getAge() + "):");
                int age = Integer.parseInt(TSUtility.readString(2, emp.getAge() + ""));
                System.out.print("工资(" + emp.getSalary() + "):");
                double salary = Double.parseDouble(TSUtility.readString(10, emp.getSalary() + ""));
                emp.setName(name);
                emp.setAge(age);
                emp.setSalary(salary);
                employees.set(i, emp);
                flag = true;
            }
        }
        if (flag) {
            System.out.println("修改成功!");
        } else {
            try {
                throw new Exception("该员工不存在");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**查看员工信息**/
    public void showEmployee() throws Exception {
        TSUtility.loadSpecialEffects();
        System.out.println("ID\t 姓名\t年龄\t\t工资\t \t职位\t\t 状态\t 奖金\t 股票\t 领用设备");
        for (int i = 0; i < employees.size(); i++) {
            System.out.println(employees.get(i));
        }
    }
}
团队管理

自定义异常类

public class TeamException extends Exception {
    public TeamException() {

    }
    public TeamException(String message) {
        super(message);//打印异常信息
    }
}

团队的管理与人员限制

public class teamService {
    //用于自动生成团队成员的memberId
    private static int counter = 1;
    //团队人数上限
    private final int MAX_MEMBER = 5;
    //保存当前团队成员
    private Programmer[] team = new Programmer[MAX_MEMBER];
    //团队实际人数
    private int total = 0;

    public teamService() {
    }

    //返回team中所有程序员构成的数组
    public Programmer[] getTeam() {
        Programmer[] team = new Programmer[total];
        for (int i = 0; i < total; i++) {
            team[i] = (Programmer) this.team[i];
        }
        return team;
    }

    //初始化当前团队成员数组
    public void clearTeam() {
        team = new Programmer[MAX_MEMBER];
        counter = 1;
        total = 0;
        this.team = team;
    }

    //增加团队成员
    public void addMember(Employee e) throws TeamException {
        if (total >= MAX_MEMBER) {
            throw new TeamException("成员已满,无法添加");
        }
        if (!(e instanceof Programmer)) {
            throw new TeamException("该id对应的并不是开发人员,无法添加");
        }
        Programmer p = (Programmer) e;

        if (isExist(p)) {
            throw new TeamException("该员工已在本团队中");
        }
        if (!p.isStatus()) {
            throw new TeamException("该员工已是某团队成员");
        }


        int numOfArch = 0, numOfDsgn = 0, numOfPrg = 0;
        for (int i = 0; i < total; i++) {
            if (team[i] instanceof Architect) {
                numOfArch++;
            } else if (team[i] instanceof Designer) {
                numOfDsgn++;
            } else if (team[i] instanceof Programmer) {
                numOfPrg++;
            }
        }

        if (p instanceof Architect) {
            if (numOfArch >= 1) {
                throw new TeamException("团队中至多只能有一名架构师");
            }
        } else if (p instanceof Designer) {
            if (numOfDsgn >= 2) {
                throw new TeamException("团队中至多只能有两名设计师");
            }
        } else if (p instanceof Programmer) {
            if (numOfPrg >= 3) {
                throw new TeamException("团队中至多只能有三名程序员");
            }
        }
        //添加到数组
        p.setStatus(false);
        p.setMemberID(counter++);
        team[total++] = p;
    }

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

        return false;
    }

    //删除指定memberId的程序员
    public void removeMember(int memberId) throws TeamException {
        int n = 0;
        //找到指定memberId的员工,并删除
        for (; n < total; n++) {
            if (team[n].getMemberID() == memberId) {
                team[n].setStatus(true);
                break;
            }
        }
        //如果遍历一遍,都找不到,则报异常
        if (n == total) {
            try {
                throw new TeamException("找不到该成员,无法删除");
            } catch (TeamException e) {
                System.out.println("删除失败。原因:"+e.getMessage());
            }
        }
        //后面的元素覆盖前面的元素
        for (int i = n + 1; i < total; i++) {
            team[i - 1] = team[i];
        }
        team[--total] = null;
    }
}
项目的开发管理与分配

这里因为没有写项目的对应属性,就没有添加手动生成项目的方法

public class peojectService {
    private ArrayList<Project> pro = new ArrayList<>();
    private int count = 1;

    //添加项目
    public void addProject() throws InterruptedException {

        System.out.println("项目参考:--------------------------------------------------");
        System.out.println("1.小米官网:开发完成类似于小米官网的web项目.");
        System.out.println("2.公益在线商城:猫宁Morning公益商城是中国公益性在线电子商城.");
        System.out.println("3.博客系统:Java博客系统,让每一个有故事的人更好的表达想法!");
        System.out.println("4.在线协作文档编辑系统:一个很常用的功能,适合小组内的文档编辑。");
        System.out.println("------------------------------------------------------------");
        TSUtility.readReturn();
        System.out.println("请输入你想添加的项目名: (仅限以上有的项目)");
        char c = TSUtility.readMenuSelection();

        switch (c) {
            case '1':
                Project p1 = new Project();
                p1.setProId(count++);
                p1.setProName("小米官网");
                p1.setProDes("开发完成类似于小米官网的web项目.");
                pro.add(p1);
                TSUtility.loadSpecialEffects();
                System.out.println("已添加项目:" + p1.getProName());
                break;
            case '2':
                Project p2 = new Project();
                p2.setProId(count++);
                p2.setProName("公益在线商城");
                p2.setProDes("猫宁Morning公益商城是中国公益性在线电子商城.");
                pro.add(p2);
                TSUtility.loadSpecialEffects();
                System.out.println("已添加项目:" + p2.getProName());
                break;
            case '3':
                Project p3 = new Project();
                p3.setProId(count++);
                p3.setProName("博客系统");
                p3.setProDes("Java博客系统,让每一个有故事的人更好的表达想法!");
                pro.add(p3);
                TSUtility.loadSpecialEffects();
                System.out.println("已添加项目:" + p3.getProName());
                break;
            case '4':
                Project p4 = new Project();
                p4.setProId(count++);
                p4.setProName("在线协作文档编辑系统");
                p4.setProDes("一个很常用的功能,适合小组内的文档编辑。");
                pro.add(p4);
                TSUtility.loadSpecialEffects();
                System.out.println("已添加项目:" + p4.getProName());
                break;
            default:
                System.out.println("项目不存在");
                break;
        }
    }

    //给项目分配团队
    public void dealingPro(Employee[] team){
        if(team.length<=0){
            System.out.println("当前没有团队,请先去添加团队叭!");
            return;
        }
        System.out.println("当前团队有人员:");
        for (int i = 0; i < team.length; i++) {
            System.out.println(team[i]);
        }
        System.out.println("请为当前团队创建一个团队名称:");
        String teamName = TSUtility.readKeyBoard(8, false);
        //随机分配项目
        Random ra = new Random();
        int ranNum=0;
        if(pro.size()==0){
            System.out.println("当前没有项目哟!请先去添加项目叭!");
            return;
        }
        else {
            ranNum = new Random().nextInt(pro.size());
        }

        //实例化项目类
        Project project = this.pro.get(ranNum);
        while (project.isStatus()) {//使用一个while循环 ,判断, 如果该随机得到的项目已被开发,就会重新随机读取n,直到得到的项目为未开发 才会退出循环
            ranNum = ra.nextInt(pro.size());//该项目已被开发,重新获取随机数
            project = this.pro.get(ranNum);//集合重新取出随机的项目
        }

        project.setTeamName(teamName);
        project.setTeam(team);
        project.setStatus(true);//改变项目的状态

        pro.set(ranNum, project);

    }

    //查看目前项目情况
    public void showPro() throws InterruptedException {
        TSUtility.loadSpecialEffects();
        if (pro.size() == 0){
            try {
                throw new TeamException("还没有项目,请先添加!");
            }catch (TeamException e){
                System.out.println("还没有项目,请先添加");
            }
        }
        else {
            for (int i = 0; i < pro.size(); i++) {
                System.out.println(pro.get(i));
            }
        }
    }

    //删除选择的项目
    public void delPro(int id) {
        boolean flag = false;
        for (int i = 0; i < pro.size(); i++) {
            if (pro.get(i).getProId() == id) {
                if(pro.get(i).isStatus()){
                    System.out.println("该项目正处于开发状态,是否继续删除\n若继续删除,项目仅处于关闭状态");
                    char yn = TSUtility.readConfirmSelection();
                    if(yn == 'Y'){
                        flag=true;
                        pro.get(i).setStatus(false);
                    }
                }
                else {
                    System.out.println("该项目处于关闭状态,已直接删除!");
                    pro.remove(i);
                    System.out.println("删除成功!");
                }
                for (i = id; i <= pro.size(); i++) {
                    pro.get(i - 1).setProId(pro.get(i - 1).getProId() - 1);
                }
                flag = true;
            }
        }
        if (flag) {
            System.out.println("删除成功!");
            count--;
        } else {
            try {
                throw new TeamException("该项目不存在!");
            } catch (TeamException e) {
                System.out.println("该项目不存在!");
            }
        }
    }

    //得到所有项目数据集合
    public ArrayList<Project> getAllPro() {
        return pro;
    }
}

View部分

这里就是将前面的东西整合起来,并展示出来

ps:这里由于代码太多,我就不列出来了,有需要的小伙伴
自行下载(博主不易,打赏两分下载一下呗,下载需要两积分哟,谢谢)
源代码呀

  • 5
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 13
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 13
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值