BUAA面向对象编程先导课程总结

代码架构：

最终架构： 

迭代过程：

第二次作业：

由于是第一次的迭代，只有六个不同的操作，并且不知道每个方法限制60行的要求，便理所当然的将操作全放入Main中，架构如下：

截取Main中一部分：

public static void main(String[] args) {
        ArrayList<Adventurer> adventurers = new ArrayList<>();
        Map<Integer, Bottle> bottleMap = new HashMap<>();
        Map<Integer, Equipment> equipmentMap = new HashMap<>();
        ArrayList<ArrayList<String>> inputInfo = new ArrayList<>(); // 解析后的输入将会存进该容器中, 类似于c语言的二维数组
        Scanner scanner = new Scanner(System.in);
        int n = Integer.parseInt(scanner.nextLine().trim()); // 读取行数
        for (int i = 0; i < n; ++i) {
            String nextLine = scanner.nextLine(); // 读取本行指令
            String[] strings = nextLine.trim().split(" +"); // 按空格对行进行分割
            inputInfo.add(new ArrayList<>(Arrays.asList(strings))); // 将指令分割后的各个部分存进容器中
        }
        for (ArrayList<String> innerList : inputInfo) {
            int type = Integer.parseInt(innerList.get(0));
            int advID = Integer.parseInt(innerList.get(1));
            if (type == 1) {
                String name = innerList.get(2);
                Adventurer adventurer = new Adventurer(advID,name);
                adventurers.add(adventurer);
            } else if (type == 2) {
                int botID = Integer.parseInt(innerList.get(2));
                String name = innerList.get(3);
                int capacity = Integer.parseInt(innerList.get(4));
                Bottle bottle = new Bottle(botID, name, capacity);
                Adventurer adventurer = findAdventurer(adventurers, advID);
                adventurer.addBottle(bottle);
                bottleMap.put(botID, bottle);
            } else if (type == 3) {
                int botID = Integer.parseInt(innerList.get(2));
                Adventurer adventurer = findAdventurer(adventurers, advID);
                Bottle bottle = bottleMap.get(botID);
                adventurer.removeBottle(bottle);
                bottleMap.remove(botID);
                System.out.println(adventurer.getBottles().size() + " " + bottle.getName());
            } else if (type == 4) {
                int equID = Integer.parseInt(innerList.get(2));
                String name = innerList.get(3);
                int star = Integer.parseInt(innerList.get(4));
                Equipment equipment = new Equipment(equID, name, star);
                Adventurer adventurer = findAdventurer(adventurers, advID);
                adventurer.addEquipment(equipment);
                equipmentMap.put(equID, equipment);
            } else if (type == 5) {
                int equID = Integer.parseInt(innerList.get(2));
                Adventurer adventurer = findAdventurer(adventurers, advID);
                Equipment equipment = equipmentMap.get(equID);
                adventurer.removeEquipment(equipment);
                equipmentMap.remove(equID);
                System.out.println(adventurer.getEquipments().size() + " "
                            + equipment.getName());
            } else if (type == 6) {
                int equID = Integer.parseInt(innerList.get(2));
                Equipment equipment = equipmentMap.get(equID);
                equipment.upgradeStar();
                System.out.println(equipment.getName() + " " + equipment.getStar());
            }
        }
    }

第三次作业：

操作数来到了13个，并且意识到操作数会继续增加，于是新加了操作类（Operate）,专门用来解析Main中读取的指令。但此时仍然将操作全放在一个方法里（不是不知道每个方法限制60行，只是当时懒得改。。。）

第四次作业：

操作数来到了17个，为了避免以后每次Checkstyle都扣20分，在Operate中进行了大修改，将每一个类型对应的具体操作作为函数，再在Operate中设立一个方法专门用来调用它们，如下：

public void choose(ArrayList<String> innerList, Scanner scanner) {
        int type = Integer.parseInt(innerList.get(0));
        switch (type) {
            case 1: operate1(innerList);
                break;
            case 2: operate2(innerList);
                break;
            case 3: operate3(innerList);
                break;
            case 4: operate4(innerList);
                break;
            case 5: operate5(innerList);
                break;
            case 6: operate6(innerList);
                break;
            case 7: operate7(innerList);
                break;
            case 8: operate8(innerList);
                break;
            case 9: operate9(innerList);
                break;
            case 10: operate10(innerList);
                break;
            case 11: operate11(innerList);
                break;
            case 12: operate12(innerList);
                break;
            case 13: operate13(innerList);
                break;
            case 14: operate14(innerList, scanner);
                break;
            case 15: operate15(innerList);
                break;
            case 16: operate16(innerList);
                break;
            case 17: operate17(innerList);
                break;
            default: break;
        }
    }

第六次作业：

没什么大改变，只是细化了Bottle和Equipment的类型，并添加了接口（虽然我觉得接口用处不大）

第七次作业：

最后一次迭代，按照作业要求添加了Store类，同时防止Operate类中代码过多，便从中分出Fight类，用于处理战斗模式，架构图在开头已经给出。

使用junit的心得体会：

junit可以检测单个方法的正确性，而不是只能整体运行，能更好的判断出bug的位置。但我觉得我并没有很好的使用它，相反还浪费了大量时间。比如只是为了达到覆盖率写test，而不是为了检查代码。而且每次迭代都要对test进行大量修改，在这上面花费很多无谓的时间。

本学期学习oopre的心得体会：

1.从对java一无所知，到能够掌握java语法并且熟练使用各种容器及内置方法，虽然每周都会花费大量时间，但这门课让我快速掌握了一门编程语言。

2.第一次接触面向对象思维，让习惯了C语言那种面向过程式的编程的我很难适应。但是经历了多次迭代以及对代码大大小小的重构后，让我逐渐接纳了面向对象思维。虽然我认为目前我在这个方面仍有欠缺，但我相信在之后的oo正课以及今后的学习过程中，我能更加深入的理解并掌握它。

对课程的简单建议:

开头的几节课可以多讲讲Java语法，照顾一下一开始不了解Java的同学。