BUAA_OO_Unit3 单元总结

BUAA_OO_Unit3 单元总结

测试方法：

在本单元的测试中，我采取的测试方法主要分为黑盒与白盒测试两种类型。黑盒测试的主要模式就是通过自动数据生成器产生随机数据，然后将结果与多个同学对拍以发现代码中的bug。这样的好处是数据遍历性较广，可以找出一些难以想到的bug，但是自动生成的数据一般条数较多，在后续定位复现的过程比较耗时。在此基础上，我结合了白盒测试的思想，针对自动测试中出现问题的指令来仔细阅读JML规格，然后针对规格的各种可能情况构建较为简单的数据，从而更好的找到bug。

架构分析：

整体的架构其实已经由源代码设计好，大部分指令只需要按照JML的规格进行编写就可以。但是针对一些较为复杂的指令，完全按照JML来翻译编写，要么直接实现难度较大，要么是实现的时间代价过高，因此我在三次作业中进行了一些额外建模来优化指令代价。

第一次作业：

针对MyNetWork中的isCircle、queryBlockSum两条指令，我建了一个新的类MyMap来维护并查集。

public class MyMap {
    private final HashMap<Integer, Integer> unions;
    private final HashMap<Integer, Integer> roots;
​
    public MyMap() {
        unions = new HashMap<>();
        roots = new HashMap<>();
    }
​
    public void addPoint(int id) {
        unions.put(id, id);
        roots.put(id, 1);
    }
​
    public void addEdge(int id1, int id2) {
        merge(findRoot(id1), findRoot(id2));
    }
​
    public int findRoot(int id) {
        int nowId = id;
        int father = unions.get(id);
        while (nowId != father) {
            nowId = father;
            father = unions.get(nowId);
        }
        return nowId;
    }
​
    public void merge(int root1, int root2) {
        int count1 = roots.get(root1);
        int count2 = roots.get(root2);
        if (root1 != root2) {
            if (count1 < count2) {
                unions.put(root1, root2);//root2 is the father of root1
                roots.put(root2, count1 + count2);
                roots.remove(root1);
            } else {
                unions.put(root2, root1);//root1 is the father of root2
                roots.put(root1, count1 + count2);
                roots.remove(root2);
            }
        }
    }
​
    public int getRootsNum() {
        return roots.size();
    }
}

其中进行了一个优化为在合并两个并查集时，会将所含结点更多的根节点作为另一个根节点的父节点，以减少整个树的深度。

第二次作业：

本次作业中的query least connection指令需要我们找到最小生成树，因此在之前的MyMap类中进行了边集的维护（以更好的找到最小生成树）

private final HashMap<Integer, ArrayList<MyEdge>> edges;
​
 public int getMinTree(int id) {
        HashMap<Integer, Integer> unions = new HashMap<>();
        int root = findRoot(id, this.unions);
        int value = 0;
        ArrayList<MyEdge> myEdges = edges.get(root);
        for (MyEdge myEdge : myEdges) {
            int id1 = myEdge.getBegin();
            int id2 = myEdge.getEnd();
            if (!unions.containsKey(id1)) {
                unions.put(id1, id1);
            }
            if (!unions.containsKey(id2)) {
                unions.put(id2, id2);
            }
            int root1 = findRoot(id1, unions);
            int root2 = findRoot(id2, unions);
            if (root1 != root2) {
                //set root2 the father of root1
                unions.put(root1, root2);
                value += myEdge.getValue();
            }
        }
        return value;
    }

最小生成树算法采取了并查集的优化，整体最小生成树算法采取的是Kruskal算法。

第三次作业：

本次作业中的send indirect message需要找到一个Group里面的最短路径。整体实现采取了使用了堆优化的Dijkstra算法。

private final HashMap<Integer, Boolean> vis;
private final HashMap<Integer, Integer> dis;
private final HashMap<Integer, ArrayList<MyEdge>> findEdges;
​
public int getMinPath(int begin, int end) {
        int root = findRoot(begin, unions);
        ArrayList<Integer> myPoints = points.get(root);
        PriorityQueue<MyPoint> priQueue = new
                PriorityQueue<>(Comparator.comparingInt(MyPoint::getDis));
        int value = -1;
        for (Integer id : myPoints) {
            if (id == begin) {
                dis.replace(id, 0);
                MyPoint myPoint = new MyPoint(id, 0);
                priQueue.add(myPoint);
            }
            else {
                dis.replace(id, maxValue);
            }
            vis.replace(id, false);
        }
        while (!priQueue.isEmpty()) {
            MyPoint point = priQueue.poll();
            int id = point.getId();
            boolean isVis = vis.get(id);
            if (!isVis) {
                vis.replace(id, true);
                for (MyEdge edge : findEdges.get(id)) {
                    int linkId = edge.getBegin();
                    if (linkId == id) {
                        linkId = edge.getEnd();
                    }
                    if (!vis.get(linkId)) {
                        int newDis = dis.get(id) + edge.getValue();
                        if (dis.get(linkId) > newDis) {
                            dis.replace(linkId, newDis);
                            MyPoint myPoint = new MyPoint(linkId, newDis);
                            priQueue.add(myPoint);
                        }
                    }
                }
                if (id == end) {
                    value = point.getDis();
                    break;
                }
            }
        }
        return value;
    }

本次代码的编写利用到了java中自带的PriorityQueue来实现堆优化，带来了很大的便利性。

性能问题与修复情况：

三次作业中，我出现的bug为在部分指令反复调用时没有进行数据记录，而是反复进行重复计算，导致了超时；另外就是初版的Kruskal算法与Dijkstra算法优化做的不够到位，导致了cpu运行时间超时。

NetWork扩展

要求：

假设出现了几种不同的Person

• Advertiser：持续向外发送产品广告

• Producer：产品生产商，通过Advertiser来销售产品

• Customer：消费者，会关注广告并选择和自己偏好匹配的产品来购买 -- 所谓购买，就是直接通过Advertiser给相应Producer发一个购买消息

• Person：吃瓜群众，不发广告，不买东西，不卖东西

如此Network可以支持市场营销，并能查询某种商品的销售额和销售路径等 请讨论如何对Network扩展，给出相关接口方法，并选择3个核心业务功能的接口方法撰写JML规格（借鉴所总结的JML规格模式）

实现：

Advertiser、Producer、Customer三个类均继承Person类，Advertiser类中包含有Advertise的实例化对象以及它的id，Producer类可以生产Product对象，Product对象中包含了价值与id两个属性。

发布广告信息：

/*@ public normal_behavior
  @ requires containsAdvertiserid(Advertiserid) && containsId(personid) && getperson(Advertiseid).isLinked(personid);
  @ assignable getperson(personid).getadvertise;
  @ ensures getperson(personid).getadvertise.size() = \old(getperson(personid).getadvertise.size()) + 1;
  @ ensures (\forall int i; 0 <= i && i < \old(getperson(personid).getadvertise.size()); getperson(personid).getadvertise[i+1] == \old(getperson(personid).getadvertise[i]));
  @ ensures (getperon(personid).getadvertise[0] == newadvertise);
  @ also
  @ public exception_behavior
  @ assignable nothing
  @ requires !containsAdvertiseid(Advertiseod) || !containsid(personid) || !getperson(Advertiseid).isLinked(getperson(personid));
  @ signals (PersonIdNotFoundException e) !containsAdvertiseid(Advertiseod);
  @ signals (PersonIdNotFoundException e) !containsid(personid);
  @ signals (RelarionNotFoundException e) !getperson(Advertiseid).isLinked(getperson(personid));
  @*/
public void sendadvertise(int Advertiserid, int personid) throws PersonIdNotFoundException, RelarionNotFoundException;

向顾客发送信息：

/*@ public normal_behavior
  @ requires containspersonid(personid)
  @ assignable getcustomer(personid).itsproducts;
  @ ensures (\forall int i; i >= 0 && i <= advertise.size(); getcustomer(personid).itsproducts.add(advertise2produce(advertise[i])));
  @ ensures itsproducts.size() == \old(itsproducts.size()) + advertise.size();
  @ ensures advertise.size() == 0;
  @ public exception_behavior
  @ assignable nothing
  @ requires !containspersonid(personid)
  @ signals (PersonIdNotFoundException e) !containspersonid(personid);
  @*/
public void sendmessageToCustomer(int personid) throws PersonIdNotFoundException;

查询商品销售额：

/*@ public normal_behavior
  @ requires containsproid(proid);
  @ ensures \result == getpro(proid).getvalue;
  @ also 
  @ public exception_behavior
  @ requires !containsproid(proid);
  @ signals (ProductionidNotFoundException e) !containsproid(proid);
public /*pure*/ int getvalueodproduction(int proid) throws ProductionidNotFoundException;

体会感想：

这个单元我们接触到了JML规格与契约式编程，表面上这个单元的思考难度下降了很多，因为大部分代码的编写只需要照着规格翻译编写即可。这也让我认识到了在多人协作的任务之中，拥有一种标准化的语言规范的重要性，这能够帮我们解决掉很多自然语言的二义性，准确的传答出程序的目的性与限制之处。

但是在本单元的程序编写中，我也难免会出现一些bug，经过观察发现大部分bug主要是代码性能不够好所致。因此我们不难发现JML只是确保了程序的正确性，对于程序的高性能的追求，是我们在规格之下的自由之处，也是我们需要努力学习做到的。