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

1、目标

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

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

● 主要涉及以下知识点：
类的继承性和多态性
对象的值传递、接口
static和final修饰符
特殊类的使用：包装类、抽象类、内部类
异常处理
Java基本语法和流程控制
数组，ArrayList集合

2、项目需求

该软件实现以下功能：

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

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

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

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

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

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

2.1 项目流程

3、编写各个模块的程序

3、1 domain包下的程序

domain包用来存放各种类，主要包含Employee（父类）和Equipment（接口）和他们的子类，用来构建开发人员的对象。

Employee（父类）员工父类包含3个子类：Programmer（程序员）、Designer（设计师）、Architect（架构师），他们之间存在一个多层继承关系。

Equipment（接口）设备接口包含3个实现类发，分别对应程序员、设计师、架构师的不同设备：NoteBook、PC、Printer。

Employee父类：

public class Employee {
    private int id;
    private String name;
    private int age;
    private double salary;

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

    public Employee(){

    }

    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 String toString() {
        return getDetails();
    }
    protected String getDetails() {
        return id + "\t" + name + "\t" + age+ "\t\t" +salary;
    }
}

Programmer子类：

//程序员
public class Programmer extends Employee{
    private int memberId;
    private boolean status= true;
    private Equipment equipment;

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

    public Programmer() {
    }

    public int getMemberId() {
        return memberId;
    }

    public void setMemberId(int memberId) {
        this.memberId = memberId;
    }

    public boolean getStatus() {
        return status;
    }

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

    public Equipment getEquipment() {
        return equipment;
    }

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

    protected String getMemberDetails() {
        return getMemberId() + "/" + getDetails();
    }

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



    @Override
    public String toString() {
        return getDetails() + "\t程序员\t" + status + "\t\t\t\t\t" + equipment.getDescription() ;
    }
}

Designer子类：

public class Designer extends Programmer{
    private double bonus;

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

    public Designer() {
    }

    public double getBonus() {
        return bonus;
    }

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

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

    @Override
    public String toString() {
        return getDetails() + "\t设计师\t" + getStatus() + "\t" +
                getBonus() +"\t\t\t" + getEquipment().getDescription();
    }

}

Architect子类：

public class Architect extends Designer {
    private int stock;

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

    public Architect() {

    }

    public Architect(int id, String name, int age, double salary, double bonus, int stock) {
    }

    public int getStock() {
        return stock;
    }

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

    @Override
    public String getDetailsForTeam() {
        return getMemberDetails() + "\t架构师\t" +
                getBonus() + "\t" + getStock();
    }

    @Override
    public String toString() {
        return getDetails() + "\t架构师\t" + getStatus() + "\t" +
                getBonus() + "\t" + getStock() + "\t" + getEquipment().getDescription();
    }
}

Equipment接口：

public interface Equipment {
    public abstract String getDescription();
}

NoteBook实现类：

public class NoteBook implements Equipment {
    private String model;
    private double price;

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

    public NoteBook() {
    }

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


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

}

PC实现类：

public class PC implements Equipment {
    private String model;
    private String display;

    public PC(String model, String display) {
        this.model = model;
        this.display = display;
    }

    public PC() {
    }

    public String getModel() {
        return model;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public String getDisplay() {
        return display;
    }

    public void setDisplay(String display) {
        this.display = display;
    }

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

Printer实现类：

public class Printer implements Equipment{
    private String name;
    private String type;

    public Printer(String name, String type) {
        this.name = name;
        this.type = type;
    }

    public Printer() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

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

}

Employee以及Employee的子类主要重写了toString方法还有一些其他的显示方法。由于之前写的代码很少设计到在不同的包或者不同的类下显示对象的内容，所以toString方法的重写对我来说算是一个新颖的知识。

我现在对这个知识的理解就是：一个类中存在多个变量但我可通过重写toString方法让我在其它地方调用这个方法时输出我想要的内容。如果不重写toString方法的话得到的东西就是一个内存地址。 具体可参考Java重写toString()方法的意义。

3、2 service包下的程序

service包下主要存放一些方法类，也就是实现对象的具体功能的一些方法。

NameListService 类：

package 关卡12.service;

import com.sun.org.apache.xpath.internal.objects.XObject;
import 关卡12.domain.*;
import java.util.ArrayList;
import java.util.Scanner;

import static 关卡12.view.LoginView.readKeyBoard;

public class NameListService {
    private ArrayList<Employee> employees = new ArrayList<>();

    //添加员工的id
     private int count = 1;

    //初始化默认值
    {
        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 newException{
        for (int i = 0; i <employees.size() ; i++) {
            if (employees.get(i).getId()==id){
                return employees.get(i);
            }
        }
        throw new newException("不存在此员工");
    }

    //添加
    public void addTo(){
        System.out.println("请输入需要添加雇员的职位");
        System.out.println("1(无职位)");
        System.out.println("2(程序员)");
        System.out.println("3(设计师)");
        System.out.println("4(架构师)");

        boolean choice = true;
        char x = '0';
        while (choice) {
            String a = readKeyBoard(1);
            //取a中的第一个字符
            char ch = a.charAt(0);
            if (ch != '1' && ch != '2' && ch != '3' && ch != '4') {
                System.out.println("您输入的数据有误,请重新输入");
            }else {
                x = ch;
                choice = false;
            }
        }
        System.out.println("请输入当前雇员的姓名：");
        String name = readKeyBoard(4);
        System.out.println("请输入当前雇员的年龄：");
        int age =readNumber();
        System.out.println("请输入当前雇员的工资：");
        double salary = restrictedWages();
        switch (x){
            case '1':
                System.out.println("当前雇员职位分配为：无职位");
                employees.add(new Employee(++count,name,age,salary));
                System.out.println("添加成功");
                break;
            case '2':
                //添加设备
                System.out.println("请为当前程序员分配一台好的台式电脑：");
                System.out.println("请输入要配置台式电脑的型号：");
                String modelName = readKeyBoard(5);
                System.out.println("请输入要配置电脑的显示器名称：");
                String displayName = readKeyBoard(6);
                employees.add(new Programmer(++count,name,age,salary,new PC(modelName,displayName)));
                System.out.println("添加成功");
                break;
            case '3':
                //为员工添加奖金
                System.out.println("请为当前员工添加奖金");
                double bonus = restrictedWages();
                //添加设备
                System.out.println("请输入要配置台式电脑的型号：");
                String modelName1 = readKeyBoard(5);

                System.out.println("请输入要配置电脑的显示器名称：");
                String type = readKeyBoard(6);

                employees.add(new Designer(++count,name,age,salary,new Printer(modelName1,type),bonus));
                System.out.println("添加成功");

                break;

            case '4':
                //奖金
                System.out.println("请为当前员工添加奖金：");
                double bonus1 = restrictedWages();
                //股票
                System.out.println("请为当前员工添加股票：");
                int stock = shares();

                //添加设备
                System.out.println("请为当前程序员分配一台好的笔记本电脑：");
                System.out.println("请输入要配置笔记本电脑的型号：");
                String modelName2 = readKeyBoard(5);

                System.out.println("请输入要配置电脑的价格");
                double price = restrictedWages();

                employees.add(new Architect(++count,name,age,salary,new NoteBook(modelName2,price),bonus1,stock));

                System.out.println("添加成功");
                break;
        }

    }
    //删除
    public void delete(){
        boolean a =true;
        while (a){
            System.out.println("请输入要删除对象的员工号：");
            int number = readNumber();
            if (number>employees.size() || number<=0){
                System.out.println("工号有误，请重新输入");
                continue;
            }
            for (int i = 0; i <employees.size() ; i++) {
                if (number==employees.get(i).getId()){
                    employees.remove(i);
                    //删除后面的员工信息每个ID都会-1
                    for (int j = i; j <employees.size() ; j++) {
                        employees.get(j).setId(employees.get(j).getId()-1);
                    }
                    System.out.println("删除成功！");
                    a = false;
                    break;
                }
            }
        }


    }
    //查看
    public void getAllEmployees1(ArrayList<Employee> employees){
        System.out.println("ID\t姓名\t\t年龄\t\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 void modify(){

        while (true) {
            System.out.println("请输入要修改对象的员工号：");
            int number = readNumber();
            if (number > employees.size() || number <= 0) {
                System.out.println("工号有误，请重新输入");
                continue;
            }else{
                System.out.print("姓名：("+employees.get(number-1).getName()+")");
                String name = readKeyBoard2(4);
                if (name.length()!=0){
                    employees.get(number-1).setName(name);
                }
                System.out.print("年龄：("+employees.get(number-1).getAge()+")");
                int age = readNumber1();
                if (age!=1){
                    employees.get(number-1).setAge(age);
                }
                System.out.print("工资("+employees.get(number-1).getSalary()+")");
                double salary = restrictedWages1();
//                String y =salary+"";
                if (salary!=1){
                    employees.get(number-1).setSalary(salary);
                }
                System.out.println("修改成功");
                break;
            }
        }


    }

    //限制长度
    public String readKeyBoard(int limit) {
        Scanner sc = new Scanner(System.in);
        String line = "";

//判断是否有数据输入sc.hasNext()

        while (sc.hasNext()) {
            line = sc.nextLine();
            if (line.length() < 1 || line.length() > limit) {
                System.out.println("输入长度（不大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
        }

        return line;
    }

    //限制年龄
    public int readNumber() {
        int n;
        for (; ; ) {
            String str = readKeyBoard(2);
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.println("数字输入错误，请重新输入：");
            }
        }
        return n;

    }
    //限制工资
    public double restrictedWages() {
        double n;
        for (; ; ) {
            String str = readKeyBoard(5);
            try {
                n = Double.parseDouble(str);
                break;
            } catch (NumberFormatException e) {
                System.out.println("数字输入错误，请重新输入：");
            }
        }
        return n;

    }
    //限制股票
    public int shares() {
        int n;
        for (; ; ) {
            String str = readKeyBoard(4);
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.println("数字输入错误，请重新输入：");
            }
        }
        return n;

    }

    //修改的方法


    //接收空值并且限制
    public static String readKeyBoard2(int limit) {
        Scanner sc = new Scanner(System.in);
        String line = "";
        //判断是否有数据输入sc.hasNext()
        while (sc.hasNextLine()) {
            line = sc.nextLine();
            if (line.length() > limit) {
                System.out.println("输入长度（不大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
        }

        return line;
    }
    //修改年龄
    public int readNumber1() {
        int n=1;
        for (; ; ) {
            String str = readKeyBoard2(2);
            if (str.length()==0){
                break;
            }
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.println("数字输入错误，请重新输入：");
            }
        }
        return n;

    }
    //修改工资
    public double restrictedWages1() {
        double n=1;
        for (; ; ) {
            String str = readKeyBoard2(5);
            if (str.length()==0){
                break;
            }
            try {
                n = Double.parseDouble(str);
                break;
            } catch (NumberFormatException e) {
                System.out.println("数字输入错误，请重新输入：");
            }
            if (n<0){
                System.out.println("数字输入错误，请重新输入：");
            }
        }
        return n;

    }

}

NameListService类主要完成开发人员管理模块的需求。

TeamService 类：

package 关卡12.service;

import 关卡12.domain.*;


import java.util.*;

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] = this.team[i];
        }
        return team;
    }
    //初始化当前团队成员数组
    public void clearTeam() {
        team = new Programmer[MAX_MEMBER];
        counter=1;
        total=0;
//        this.team = team;
    }


    ArrayList<Programmer[]> arr = new ArrayList<>();
    HashSet<Integer> set = new HashSet<>();

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

    if (isExist(p)) {
        throw new TeamException("该员工已在本团队中");
    }
    if(!p.getStatus()) {
        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;
}

//添加到arr
    public void addArr(){
        if (team[0]!=null){
            arr.add(team);
        }
    }

    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);
                System.out.println("删除成功");
                break;
            }
        }
        //如果遍历一遍，都找不到，则报异常
        if (n == total)
            throw new TeamException("找不到该成员，无法删除");
        //后面的元素覆盖前面的元素
        for (int i = n + 1; i < total; i++) {
            team[i - 1] = team[i];
        }
        team[--total] = null;
    }
    //限制输入ID
    public int readNumber(ArrayList<Employee> employees) {
        int n=1;
        for (; ; ) {
            String str = readKeyBoard(2);
            if (str.length()==0){
                break;
            }
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.println("数字输入错误，请重新输入：");
            }
            if (n>employees.size() ||n<1){
                System.out.println("不存在此员工，请重新输入");
            }
        }
        return n;

    }
    //限制长度
    public String readKeyBoard(int limit) {
        Scanner sc = new Scanner(System.in);
        String line = "";

//判断是否有数据输入sc.hasNext()

        while (sc.hasNext()) {
            line = sc.nextLine();
            if (line.length() < 1 || line.length() > limit) {
                System.out.println("输入长度（不大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
        }

        return line;
    }
    //限制输入删除团队
    public int readNumber() {
        int n=1;
        for (; ; ) {
            String str = readKeyBoard(2);
            if (str.length()==0){
                break;
            }
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.println("数字输入错误，请重新输入：");
            }
            if (n>arr.size() ||n<1){
                System.out.println("不存在此团队，请重新输入");
            }
        }
        return n;

    }
    //查看团队成员
    public void getMember(){
        for (int i = 0; i <arr.size() ; i++) {
            System.out.println("-------------");
            for (int j = 0; j <arr.get(i).length ; j++) {
                try{
                    System.out.println(arr.get(i)[j].getDetailsForTeam());
                }catch (NullPointerException e){
                    System.out.println("--");
                }

            }
        }
    }
    //获取随机团队
    public void getRandomTeam(){
        Random rd = new Random();
        boolean x =true;
        while (x){
            if (set.size()==arr.size()){
                break;
            }else {
                int a = rd.nextInt(arr.size());
                if (set.add(a)){
                    for (int i = 0; i <arr.get(a).length ; i++) {
                        try{
                            System.out.println(arr.get(a)[i].getDetailsForTeam());
                        }catch (NullPointerException e){
                            System.out.println("--");
                        }

                    }
                    break;
                }
            }
        }

    }
    //判断是否相等
    public boolean equalLength(){
        boolean x = false;
        if (set.size()==arr.size()){
            x=true;
        }else {
            x =false;
        }
        return x;
    }
    //删除团队
    public void deletTeam(){
        if (arr.size()==0){
            System.out.println("当前未添加团队，请添加后删除！");
            return;
        }
        while (true){
            System.out.println("请输入你要删除第几个团队：");
            int d = readNumber();
            if (d>arr.size() || d<1){
                System.out.println("不存在此团队，请重新输入");
                continue;
            }else {
                arr.remove(d-1);
                System.out.println("删除成功！");
                break;
            }
        }



    }
    //查看本团队成员
    public void getThisMember(){
        System.out.println("-------------");
        for (int i = 0; i <team.length ; i++) {
            System.out.println(team[i]);
        }

    }
    //返回arr中的数组
    public ArrayList<Programmer[]> getTeam1() {
        addArr();
        return this.arr;
    }
}

TeamService 这个类主要实现开发团队的管理功能。

ProjectService类：

package 关卡12.service;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

import 关卡12.domain.*;
import 关卡12.view.TeamView;

public class ProjectService {
    //用来存项目的集合
    ArrayList<Project> pro = new ArrayList<>();
    //添加项目的标号
    int count = 1;
    TeamView tv=new TeamView();
    TeamService ts = new TeamService();
    Programmer[] team =ts.getTeam();



    {
        pro.add(new Project(count++,"小米官网","开发完成类似于小米官网的web项目.",false));
        pro.add(new Project(count++,"公益在线商城","猫宁Morning公益商城是中国公益性在线电子商城.",false));
        pro.add(new Project(count++,"博客系统","Java博客系统，让每一个有故事的人更好的表达想法！",false));
        pro.add(new Project(count++,"在线协作文档编辑系统","一个很常用的功能，适合小组内的文档编辑.",false));
    }

    //新项目添加
    public void addProject(){
        Project pr = new Project();
        pr.setProld(count++);
        System.out.println("请输入项目名称：");
        String pn = readKeyBoard(10);
        pr.setProjectName(pn);
        System.out.println("请输入项目描述：");
        String dn = readKeyBoard(40);
        pr.setDesName(dn);
        pr.setStatus(false);
        pro.add(pr);
    }

    //项目分配团队开发
    public void dealingPro(){
        ArrayList<Programmer[]> arr = ts.getTeam1();
        Random rd = new Random();
        boolean x = true;
        int num = 0;
        //项目的判断
        for (int i = 0; i <pro.size() ; i++) {
            if (pro.get(i).getStatus()==true){
                num+=1;
                if (num==pro.size()){
                    System.out.println("所有项目都已经分配！");
                    return;
                }
            }
        }

        while (x){
            int a = rd.nextInt(count)+1;
            int b = rd.nextInt(arr.size());
            for (int i = 0; i <pro.size() ; i++) {
                if (pro.get(i).getProld()==a && pro.get(i).getStatus()==false){
                    pro.get(i).setTeam(team);
                    pro.get(i).setStatus(true);
                    System.out.println(pro.get(i));

                    System.out.println("请给当前团队取名：");
                    String name = readKeyBoard(5);
                    pro.get(i).setTeamName(name);
                    //显示当前团队
//                    for (int j = 0; j <ts.getTeam().length ; j++) {
//                        System.out.println(ts.getTeam()[j]);
//                    }

                    System.out.println("分配成功！");
                    x =false;
                    break;
                }
            }
        }
        System.out.println();

    }

    //查看项目当前状态
    public void showPro(){
        for (int i = 0; i <pro.size() ; i++) {
            System.out.println(pro.get(i));
        }

    }

    //删除选择的项目
    public void delPro(){
        boolean x = true;
        while (x){
            System.out.println("请输入要删除的项目id：");
            int a = restrictionType();
            if (a>pro.size() || a<1){
                System.out.println("项目不存在，请重新输入！");
                continue;
            }else {
                for (int i = 0; i <pro.size() ; i++) {
                    if (pro.get(i).getProld()==a){
                        pro.remove(i);
                        System.out.println("删除成功！！");
                        x = false;
                        for (int j = i; j <pro.size(); j++) {
                            pro.get(j).setProld(pro.get(j).getProld()-1);
                        }
                    }
                }
            }
        }
    }

    //限制长度
    public String readKeyBoard(int limit) {
        Scanner sc = new Scanner(System.in);
        String line = "";

//判断是否有数据输入sc.hasNext()

        while (sc.hasNext()) {
            line = sc.nextLine();
            if (line.length() < 1 || line.length() > limit) {
                System.out.println("输入长度（不大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
        }

        return line;
    }

    //限制输入类型
    public int restrictionType() {
        int n;
        for (; ; ) {
            String str = readKeyBoard(2);
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.println("数字输入错误，请重新输入：");
            }
        }
        return n;

    }
}

ProjectService类用来实现项目管理的功能。

异常类

创建了两个异常类用来处理开发人员模块，和团队管理模块产生的异常。

newException 异常类：

package 关卡12.service;

public class newException extends Exception{
    public newException() {
    }
    public newException(String message){
        super(message);

     }
}

TeamException 异常类：

package 关卡12.service;

public class TeamException extends Exception{
    public TeamException() {
    }

    public TeamException(String message) {
        super(message);
    }

}

3、3 view包下的程序

这个包下写的就是界面类，用户看见和操作的界面。

LoginView类：

编写的是账户管理模块的界面。

package 关卡12.view;

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

public class LoginView {
    ArrayList<String> arr = new ArrayList<>();
    ArrayList<String> arr1 = new ArrayList<>();
    public void initial() {

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入账号");
        String accountNumber = readKeyBoard(10);
        System.out.println("请输入密码");
        String password = readKeyBoard(11);
        if (arr.size()==0){
            System.out.println("暂无账户信息，请注册账户");
            enroll(arr,arr1);
        }
        int x =register(arr,arr1);//登录

        System.out.println("是否要对账户进行修改；1、修改账户信息   2、进入系统");
        boolean choice = true;
        while (choice){
            String a = readKeyBoard(1);
            //取a中的第一个字符
            char ch = a.charAt(0);
            if(ch != '1' && ch != '2'){
                System.out.println("您输入的数据有误,请重新输入");
            }else{
                choice=false;
                switch (ch){
                    case '1':
                        modify();
                        System.out.println("修改完毕，进入系统");
                        break;
                    case '2':
                        System.out.println("进入系统");
                        break;
                }
            }
        }

    }
    //限制长度
    public static String readKeyBoard(int limit) {
        Scanner sc = new Scanner(System.in);
        String line = "";
     //判断是否有数据输入sc.hasNext()
        while (sc.hasNext()) {
            line = sc.next();
            if (line.length() < 1 || line.length() > limit) {
                System.out.println("输入长度（不大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
        }

        return line;
    }

    //注册方法
    public static void enroll(ArrayList<String> arr,ArrayList<String> arr1){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入注册账号名称");
        String accountNumber = readKeyBoard(10);
        arr.add(accountNumber);
        System.out.println("请输入密码");
        String password = readKeyBoard(11);
        arr1.add(password);
        System.out.println("注册成功！请登录");
    }

    //登录
    public static int register(ArrayList<String> arr,ArrayList<String> arr1) {
        Scanner sc = new Scanner(System.in);
        int j=5;
        boolean a = true;
        int x = 0;
        while (a){
            System.out.println("请输入账号名称");
            String accountNumber = readKeyBoard(10);
            System.out.println("请输入密码");
            String password = readKeyBoard(11);
            for (int i = 0; i <arr.size() ; i++) {
                if (accountNumber.equals(arr.get(i))){
                    if (password.equals(arr1.get(i))){
                        System.out.println("登录成功");
                        a=false;
                        x=i;

                    }
                }else {
                    j--;
                    System.out.println("您输入的账号或密码有误，请重新输入！");
                    System.out.println("您还有"+j+"次机会");
                }
            }
            if (j==0){
                System.out.println("您输入错误的次数过多，系统将自动关闭！");
                System.exit(0);
            }
        }
        return x;
    }
    
    //修改用户密码功能
    public void modify() {
        System.out.println("请输入修改后的账号：");
        String accountNumber = readKeyBoard(10);
        arr.set(0,accountNumber);
        System.out.println("请输入修改后的密码");
        String password = readKeyBoard(11);
        arr1.set(0,password);

//        System.out.println(arr.get(x));
//        System.out.println(arr1.get(x));
        System.out.println("修改成功");

    }

}

TeamView类：

package 关卡12.view;

import 关卡12.domain.Employee;
import 关卡12.service.NameListService;
import 关卡12.service.TeamException;
import 关卡12.service.TeamService;
import 关卡12.service.newException;

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

public class TeamView {

    NameListService listSvc = new NameListService();
    TeamService teamSvc = new TeamService();

    public void teamMainInterface() {
        boolean bo = true;
        while (bo){
            System.out.println("🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣");
            System.out.println("🔣                   🔣");
            System.out.println("🔣    团队调度界面     🔣");
            System.out.println("🔣                   🔣");
            System.out.println("🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣");
            System.out.println("1-添加团队\t2-查看团队\t3-删除团队\t4-退出\t\t请选择(1-4):");
            String a = readKeyBoard(1);
            //取a中的第一个字符
            char ch = a.charAt(0);
            if (ch != '1' && ch != '2' && ch != '3' && ch != '4') {
                System.out.println("您输入的数据有误,请重新输入");
            }else {
                switch (ch){
                    case '1':
                        try{
                            teamSvc.clearTeam();
                            addMember();
//                            teamSvc.addArr();
                        }catch (newException e){
                            System.out.println(e.getMessage());
                        }catch (TeamException e){
                            System.out.println(e.getMessage());
                        }
                        break;
                    case '2':
                        teamSvc.getMember();
                        break;
                    case '3':
                        teamSvc.deletTeam();
                        break;
                    case '4':
                        System.out.print("确认是否退出(Y/N)：");
                        bo=signOut();
                        break;
                }
            }
        }
    }


    //以表格形式列出公司所有成员
    public void listAllEmployees(){
        System.out.println("ID\t姓名\t\t年龄\t\t工资\t\t职位\t\t状态\t\t奖金\t\t股票\t\t领用设备");

        for (int i = 0; i <listSvc.getAllEmployees().size() ; i++) {
            System.out.println(listSvc.getAllEmployees().get(i));
        }
//        listSvc.getAllEmployees1(listSvc.getAllEmployees());

    }

    //显示团队成员列表操作
    public void getTeam(TeamService teamSvc){
        teamSvc.getMember();

    }

    //实现添加成员操作
    public void addMember() throws newException, TeamException {
        boolean b2 = true;
        while(b2){
            System.out.println("-------------------开发团队调度软件-------------------");
            listAllEmployees();
            System.out.println("---------------------------------------------------");
            System.out.println("1-团队列表\t2-添加团队成员\t3-删除团队成员\t4-退出\t\t请选择(1-4):");
            //取a中的第一个字符
            String b = readKeyBoard(1);
            char ch1 = b.charAt(0);
            if (ch1 != '1' && ch1 != '2' && ch1 != '3' && ch1 != '4') {
                System.out.println("您输入的数据有误,请重新输入");
            }else {
                switch (ch1){
                    case '1':
                        teamSvc.getThisMember();
                        break;
                    case '2':
                        System.out.println("----------添加成员----------");
                        System.out.print("请输入要添加的员工ID：");
                        int num = teamSvc.readNumber(listSvc.getAllEmployees());
                        Employee s = listSvc.getEmployee(num);
                        teamSvc.addMember(s);
                        System.out.println("添加成功");
                        break;
                    case '3':
                        System.out.println("请输入要删除员工的ID");
                        int a =readNumber();
                        try{
                            teamSvc.removeMember(a);
                        }catch (TeamException e){
                            System.out.println("不存在该员工");
                        }

                        break;
                    case '4':

                        teamSvc.addArr();
                        System.out.print("确认是否退出(Y/N)：");
                        b2=signOut();
                        break;
                }
            }
        }
    }

    //实现删除成员操作
    public void deleteMember(TeamService teamSvc) throws TeamException {
        System.out.println("请输入想删除成员的团队id：");
        int id = readNumber();
        teamSvc.removeMember(id);

    }

    //限制输入ID
    public int readNumber() {
        int n=1;
        for (; ; ) {
            String str = readKeyBoard(1);
            if (str.length()==0){
                break;
            }
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.println("数字输入错误，请重新输入：");
            }
            if (n>5 ||n<1){
                System.out.println("不存在此员工，请重新输入");
            }
        }
        return n;

    }
    //限制长度
    public String readKeyBoard(int limit) {
        Scanner sc = new Scanner(System.in);
        String line = "";

    //判断是否有数据输入sc.hasNext()

        while (sc.hasNext()) {
            line = sc.nextLine();
            if (line.length() < 1 || line.length() > limit) {
                System.out.println("输入长度（不大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
        }

        return line;
    }

    //退出
    public boolean signOut() {
        boolean b3 = true;
        Scanner sc = new Scanner(System.in);
        while (true) {
            char n = sc.next().charAt(0);
            if (n == 'Y' || n == 'y') {
                System.out.println("您已退出!");
                b3=false;
                break;
            } else if (n == 'N' || n == 'n') {
                break;
            } else {
                System.out.println("输入有误，重新输入");
            }
        }
        return  b3;
    }
}

IndexView 类：

这个类负责把所有的程序和模块联合起来，让程序变得完整。

package 关卡12.view;

import 关卡12.domain.Project;
import 关卡12.service.NameListService;
import 关卡12.service.ProjectService;
import 关卡12.service.TeamService;

import java.util.Scanner;

public class IndexView {

    public static void main(String[] args) {
        LoginView lv = new LoginView();
        TeamView tv = new TeamView();
        ProjectService ps =new ProjectService();

        boolean b1 =true;
        System.out.println("🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣");
        System.out.println("🔣                                        🔣");
        System.out.println("🔣    欢迎来到项目开发团队分配管理软件     🔣");
        System.out.println("🔣                                        🔣");
        System.out.println("🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣");
        System.out.println("🐕");
        System.out.println("🐕");
        System.out.println("🐕");
        System.out.println("🐕-----------<请您先进行登录>-------------🐕");

        lv.initial();
        while (b1) {
            System.out.println("🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣🔣");
            System.out.println("🔣                                         🔣");
            System.out.println("🔣              ~软件主菜单~               🔣");
            System.out.println("🔣                                         🔣");
            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.println("⬇请选择：  ");

            String a = readKeyBoard(1);
            //取a中的第一个字符
            char ch = a.charAt(0);
            if (ch != '1' && ch != '2' && ch != '3' && ch != '4' && ch != '5') {
                System.out.println("您输入的数据有误,请重新输入");
            } else {
                switch (ch) {
                    case '1':
                        lv.modify();
                        break;
                    case '2':
                        mainInterface(tv.listSvc);
                        break;
                    case '3':
                        tv.teamMainInterface();
                        break;
                    case '4':
                        projectMainMenu(ps,tv,tv.teamSvc);
                        break;
                    case '5':
                        System.out.println("确认是否退出(Y/N)：");
                        b1 = signOut();
                        break;
                }
            }

        }
    }

    //限制长度
    public static String readKeyBoard(int limit) {
        Scanner sc = new Scanner(System.in);
        String line = "";
        //判断是否有数据输入sc.hasNext()
        while (sc.hasNext()) {
            line = sc.nextLine();
            if (line.length() < 1 || line.length() > limit) {
                System.out.println("输入长度（不大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
        }

        return line;
    }

    //是否退出
    public static boolean signOut() {
        Scanner sc = new Scanner(System.in);
        boolean boo = true;
        while (boo) {
            char n = sc.next().charAt(0);
            if (n == 'Y' || n == 'y') {
                System.out.println("您已退出!");
                boo=false;
                break;
            } else if (n == 'N' || n == 'n') {
                break;
            } else {
                System.out.println("输入有误，重新输入");
            }
        }
        return boo;
    }

    //开发人员菜单
    public static void mainInterface(NameListService nls) {
        boolean b1 = true;
        while (b1) {
            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.println("⬇请选择：  ");
            String b = readKeyBoard(1);
            //取a中的第一个字符
            char ch1 = b.charAt(0);
            if (ch1 != '1' && ch1 != '2' && ch1 != '3' && ch1 != '4' && ch1 != '5') {
                System.out.println("您输入的数据有误,请重新输入");
            } else {
                switch (ch1) {
                    case '1':
                        nls.addTo();
                        break;
                    case '2':
                        nls.getAllEmployees1(nls.getAllEmployees());
                        break;
                    case '3':
                        nls.modify();
                        break;
                    case '4':
                        nls.delete();
                        break;
                    case '5':
                        System.out.print("确认是否退出(Y/N)：");
                        b1=signOut();
                        break;

                }
            }
        }
    }

    //开发项目菜单
    public static void projectMainMenu(ProjectService ps,TeamView tv,TeamService ts){
        boolean bo1 = true;
        while (bo1){
            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.println("⬇请选择：  ");
            String c = readKeyBoard(1);
            //取a中的第一个字符
            char ch2 = c.charAt(0);
            if (ch2 != '1' && ch2 != '2' && ch2 != '3' && ch2 != '4' && ch2 != '5') {
                System.out.println("您输入的数据有误,请重新输入");
            }else {
                switch (ch2){
                    case '1':
                        ps.addProject();
                        break;
                    case '2':
                        if (!tv.teamSvc.equalLength()){
                            ps.dealingPro();
                            tv.teamSvc.getRandomTeam();
                        }else {
                            System.out.println("所有团队均已获得项目！！");
                        }

                        break;
                    case '3':
                        ps.showPro();
                        break;
                    case '4':
                        ps.delPro();
                        break;
                    case '5':
                        System.out.print("确认是否退出(Y/N)：");
                        bo1=signOut();
                        break;
                }
            }
        }
    }
}

总结

最后我想对我自己写的项目做一个总结，首先由于是初次接触MVC的编程思想，所以在每个包的构建或者是包下的每个类的编写的时候其实很混乱，没有严格按照MVC的格式来。以至于在修改BUG的时候很麻烦；然后是对面向对象的概念理解不够，导致在继承，多态等需求的时候项目进度很慢；对在不同的包下编写程序，但是要用到其他包下的方法时，对其他包下的方法调用不熟练；对整个程序的传参和参数的调用上都不熟练。对集合ArrayList的使用也有所欠缺。

收获

虽然整个程序编写晚用了很多时间，但是做项目才会知道自己的不足，知道自己的问题才会去克服问题，虽然整个过程很艰苦，但是自我能感觉到相比于之前，自己在Java编程上的进步真的很大。