哈工大軟體構造Lab1(2022)

来源:https://www.cnblogs.com/kalesky/archive/2022/05/09/16250628.html
-Advertisement-
Play Games

哈爾濱工業大學2022春軟體構造Lab1實驗經歷與實驗心得,可供後來學子借鑒 ...


目錄

一、實驗目標概述

二、實驗環境配置

1、安裝編寫java程式的IDE——IntelliJ IDEA

2、安裝Git

3、安裝Junit

 4、GitHub Lab1倉庫的URL地址

三、實驗過程

1、Magic Squares

(1)isLegalMagicSquare()

(2)generateMagicSquare()

 (3)源代碼

2、Turtle Graphics

(1)Problem 1:Clone and import

(2)Problem 3:Turtle graphics and drawSquare

(3)Problem 5:Drawing polygons

 (4)Problem 6:Calculating Bearings

(5)Problem 7:Convex Hulls

(6)Problem 8:Personal Art

(7)Submitting

3、Social Network

(1)設計/實現FriendshipGraph類

(2)設計實現Person類

(3)設計/實現​​​​​​客戶端代碼main()

(4)設計/實現測試用例

四、實驗收穫

1、經驗/教訓

2、感想


一、實驗目標概述

        本次實驗通過求解三個問題,訓練基本 Java 編程技能,能夠利用 Java OO 開發基本的功能模塊,能夠閱讀理解已有代碼框架並根據功能需求補全代碼,能夠為所開發的代碼編寫基本的測試程式並完成測試,初步保證所開發代碼的正確性。另一方面,利用 Git 作為代碼配置管理的工具,學會 Git 的基本使用方法。

  1. 基本的 Java OO 編程
  2. 基於 Eclipse IDE 進行 Java 編程
  3. 基於 JUnit 的測試
  4. 基於 Git 的代碼配置管理

二、實驗環境配置

1、安裝編寫java程式的IDE——IntelliJ IDEA

        由於2021夏季小學期選擇了田英鑫老師的JavaEE課程,所以已經下載並配置好了編寫Java程式的IDE:IntelliJ IDEA 

2、安裝Git

        打開Git官網準備安裝時發現,自己原來在大一時便已安裝並配置好了Git工具,因此不需要再重覆安裝配置。

        已於2021年11月14日安裝完成Git。

3、安裝Junit

        打開IDEA的擴展市場:

         在糾結下載安裝哪一款插件時咨詢了同學,經同學告知,下載瞭如下插件並安裝在IDEA上:

 4、GitHub Lab1倉庫的URL地址

https://github.com/ComputerScienceHIT/HIT-Lab1-120L022408

三、實驗過程

1、Magic Squares

        本題與Magic Square有關,Magic Square,即幻方,查閱百科後瞭解到,幻方是一種將數字安排在正方形格子中,使每行、列和對角線上的數字和都相等的方法。題目1要求編寫一個Java程式(MagicSquare)先來檢查給定txt文檔中所記錄點五個矩陣的行/列/對角線值,然後分別判斷它們是否是一個幻方。題目2要求對給出的產生幻方的代碼(generateMagicSquare)進行改進擴展後加入MagicSquare類中進行測試。

(1)isLegalMagicSquare()

a、函數分析

        本題要求編寫一個函數isLegalMagicSquare()判斷一個txt文件中保存的矩陣是否為符合幻方要求的矩陣。輸入參數為txt文件的文件路徑,函數返回一個boolean值,若符合要求返回true,否則返回false。

判斷幻方的合法性:

根據幻方的定義,首先需要判斷幻方必須是行數與列數相等的矩陣,假設幻方為N * N的矩陣,那麼幻方的元素值都是自然數集上從1到N * N的一個排列,不能為負數,不能為浮點數,兩兩元素值也不能相同。最後確定行列和、對角線和之間是否全部相等,若是,則為幻方,函數返回true。

b、實現思路

       首先根據函數參數傳入的文件路徑new一個file對象,使用FileInputStream流讀取文件的內容,並保存在一個String類型的content字元串中。

        將文件內容讀取到String後開始對文件內容做處理,使用split("\n")方法檢測出文本中的換行標記,並以此分割出矩陣的每一行,並保存進一個字元串數組String line[]中,此時可調用length方法計算得出矩陣的行數row_num。再對矩陣的每一行進行處理,使用split("\t")方法檢測出每一行元素之間的分隔標記,並以此將其劃分為一個個數字字元串,保存在String[] line_cut中,並使用Integer.valueOf(String ).intValue()方法,得到字元串轉換為的數字num,迴圈保存至幻方中。至此,對文件的讀入及初始數據的處理完成。

        在處理文本數據的過程中已判斷了行數與列數是否相等,故之後只需判斷一個行列數相等的矩陣元素是否滿足要求。由於在之前的try-catch語句中已將非整形數據的報錯拋出,故不需要考慮int型以外的其他數據格式。設置一個boolean[]數組test來判斷元素的值是否已經出現過,初始化將其全設置為false,每讀入一個元素,若不小於0且未出現過,則將其值所對應的boolean[]數組元素的值置為true。

        最後判斷行列和、對角線和是否全部相等,若是則返回true,否則返回false。 

(2)generateMagicSquare()

a、該函數的程式流程圖

b、實現思路 

        分析該函數的內容,給定一個參數n作為幻方的行列數,將初始位置置為(0, n / 2), 之後依次對1 ~ n * n賦值給一個位置,1賦值給初始位置,然後計算下一個位置為當前位置的右上位置。對於邊界情況:若當前行是第一行,則下一行取最後一行;若當前列是最右邊的那列,則下一列取最左邊的那列。當i能被n整除時,則將當前位置正下方的第一個位置賦值為i + 1,然後繼續迴圈賦值。當迴圈n的平方次後,即對整個矩陣賦完了值,且滿足每行每列以及兩條對角線之和均相同的約束。

c、對該函數進行擴展

 I、將產生的magic square寫入文件夾\src\P1\txt\6.txt中

使用FileWriter和BufferedWriter類寫入magic數組所存儲的矩陣中保存的內容。代碼如下所示:

 II、當輸入的參數n不合法時,輸出提示和false退出

        在main()函數中給generateMagicSquare()傳遞參數前進行判斷,用String str保存從鍵盤接收到的字元串的值,並用Integer.valueOf(str)將其轉換為數值保存到num中,這一步中若catch到NumberFormatException錯誤,則說明參數num不為整形,列印錯誤信息並提示重新輸入。

        再在generateMagicSquare()函數中對參數n做判斷:若n為偶數,則列印錯誤信息並返回false;若n為負數,則catch到NegativeArraySizeException錯誤,同樣列印錯誤信息並返回false。

 (3)源代碼

package P1;

import java.io.*;
import java.util.Arrays;
import java.util.Scanner;

public class MagicSquare
{
    static final int N = 200;
    public static int[][] square = new int[N][N];
    public static boolean[] test = new boolean[N * N + 1];

    public static boolean isLegalMagicSquare (String fileName)
    {
        File file = new File(fileName);
        String content = null;
        Long file_len = file.length();
        byte[] file_content = new byte[file_len.intValue()];
        int col_num = 0, row_num = 0;
        Arrays.fill(test, false);
        try {
            FileInputStream file_In = new FileInputStream(file);
            file_In.read(file_content);
            file_In.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            content = new String(file_content, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            System.err.println("We don't support UTF-8\t");
            e.printStackTrace();
        }

        String line[] = content.split("\n");
        row_num = line.length;
        col_num = row_num;
        int sum_Row[] = new int[row_num];
        int sum_Col[] = new int[col_num];
        int sum_Dia[] = new int[2];

        for (int i = 0; i < row_num; i++)
        {
            String[] line_cut = line[i].split("\t");
            if(line_cut.length != row_num)
            {
                System.out.print("行列數不相等 或者未使用'\\t'分隔\t");
                return false;
            }
            for (int j = 0; j < row_num; j++)
            {
                try {
                    int num = Integer.valueOf(line_cut[j]).intValue();
                    square[i][j] = num;
                } catch (NumberFormatException e) {
                    System.out.print("存在非法輸入\t");
                    return false;
                }
                if (square[i][j] <= 0 || test[ square[i][j] ] == true)
                {
                    System.out.print("存在負數或至少存在兩數相等\t\t");
                    return false;
                }
                else
                {
                    test[ square[i][j] ] = true;
                    sum_Row[i] += square[i][j];
                    sum_Col[j] += square[i][j];
                    if (i == j)
                    {
                        sum_Dia[0] += square[i][j];
                    }
                    if (i + j + 1 == col_num)
                    {
                        sum_Dia[1] += square[i][j];
                    }
                }
            }
        }
        if(sum_Dia[0] != sum_Dia[1])
        {
            System.out.print("兩條對角線和不相等\t");
        }
        int Sum = sum_Dia[0];
        for(int i = 0; i < row_num; i++)
        {
            if (sum_Row[i] != Sum || sum_Col[i] !=Sum)
            {
                System.out.print("行列和與對角線和不相等\t");
                return false;
            }
        }
        return true;
    }

    public static boolean generateMagicSquare(int n)
    {
        try {
            if (n % 2 == 0)
            {
                System.out.println("輸入為偶數\t");
                return false;
            }
            else
            {
                int magic[][] = new int [n][n];
                int row = 0, col = n / 2, i, j, square = n * n;
                for (i = 1; i <= square; i++)
                {
                    try {
                        magic[row][col] = i; //遞增地給當前位置賦值
                    } catch (ArrayIndexOutOfBoundsException e) {
                        System.out.println("輸入錯誤\t");
                        return false;
                    }
                    if (i % n == 0)
                    {
                        row++; //當i恰賦完n的倍數個值時,下一位置取當前位置的正下方第一個位置
                    }
                    else
                    {
                        if (row == 0)
                        {
                            row = n - 1; //如果元素位置來到了第一行,則從最後一行開始
                        }
                        else
                        {
                            row--; //正常情況下行數-1
                        }
                        if (col == (n - 1))
                        {
                            col = 0; //如果元素位置來到了最後一列,則從第一列開始
                        }
                        else
                        {
                            col++; //正常情況下列數+1
                        }
                    }
                }
                //輸出矩陣元素
                for (i = 0; i < n; i++)
                {
                    for (j = 0; j < n; j++)
                    {
                        System.out.print(magic[i][j] + "\t");
                    }
                    System.out.println();
                }
                //寫入文件6.txt
                File writeOut = new File("src/P1/txt/6.txt");
                try {
                    writeOut.createNewFile();
                    FileWriter FWriter = new FileWriter(writeOut);
                    BufferedWriter BfWriter = new BufferedWriter(FWriter);
                    for (i = 0; i < n; i++)
                    {
                        for (j = 0; j < n; j++)
                        {
                            BfWriter.write(magic[i][j] + "\t");
                        }
                        BfWriter.write("\n");
                    }
                    BfWriter.flush();
                    BfWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

                return true;
            }
        } catch (NegativeArraySizeException e) {
            System.out.println("輸入為負數\t");
            return false;
        }
    }


    public static void main(String[] args)
    {
        System.out.println("檢測以下五個txt中是否為幻方,若是則返回true,不是則列印錯誤原因並返回false:");
        for (char i = '1'; i <= '5'; i++)
        {
            System.out.print(i + ".txt\t");
            System.out.println(isLegalMagicSquare("src/P1/txt/" + i + ".txt"));
        }

        String str;
        Scanner scan = new Scanner(System.in);

        while (true)
        {
            System.out.println("請輸入奇數的幻方寬度或輸入'stop'以結束程式:");
            str = scan.nextLine();
            if(str.equals("stop"))
            {
                System.out.println("程式結束");
                return;
            }
            else
            {
                try {
                    int num = Integer.valueOf(str);
                    if (generateMagicSquare(num) != false)
                    {
                        System.out.print("6.txt\t");
                        System.out.println(isLegalMagicSquare("src/P1/txt/6.txt"));
                    }
                } catch (NumberFormatException e) {
                    System.out.println("輸入錯誤!");
                }
            }
        }
    }
}

 

2、Turtle Graphics

       熟悉Turtle Graphics的各種函數介面,自己編寫部分函數,並使用Math庫的一些函數實現一些計算以畫出所需圖形。

(1)Problem 1:Clone and import

a、獲取任務代碼

        從報告里的鏈接上獲取了源文件,在IDEA里建立了相關文件夾後,把下載的源文件放到對應文件夾里,IDEA刷新後修改包名並使用。

b、使用Git管理本地開發

        先用Git創建本地倉庫,然後和遠程倉庫連接,git pull拉取代碼。

        實現一個功能後用git add .上傳項目文件,然後commit、push提交到遠程倉庫上。

        

(2)Problem 3:Turtle graphics and drawSquare

        題目要求使用Turtle類中給出的forward()方法和turn()方法,參數是海龜對象turtle和邊長sideLength,最後實現出能夠畫出邊長為指定數值的正方形。

實現思路:

        迴圈執行4次,每次forward前行sideLength的距離,然後畫筆方向旋轉90度,繼續下一次執行。即可得到所要求的正方形。實現結果如下(sideLength = 100):

 函數代碼如下:

public static void drawSquare(Turtle turtle, int sideLength)
    {
        turtle.color(PenColor.RED);
        for (int i = 0; i < 4; i++)
        {
            turtle.forward(sideLength);
            turtle.turn(90);
        }
    }

(3)Problem 5:Drawing polygons

        題目要求實現能夠畫出正多邊形的函數drawRegularPolygon()。

        首先需要實現一個輔助函數calculateRegularPolygonAngle()用於計算正多邊形的每個內角度數。由數學知識可知,該函數實現如下:

    public static double calculateRegularPolygonAngle(int sides)
    {
        return (sides - 2) * (180.0 / sides);
    }

通過TurtleSoupTest中的Junit測試後再調用calculateRegularPolygonAngle()得出所求正多邊形的內角度數,類比畫正方形的函數,由數學公式可知,代碼實現如下:

    public static void drawRegularPolygon(Turtle turtle, int sides, int sideLength)
    {
        double angle = 180 - calculateRegularPolygonAngle(sides);
        for (int i = 0; i < sides; i++)
        {
            turtle.forward(sideLength);
            turtle.turn(angle);
        }
    }

運行效果如下(邊長為100的正六邊形):

 (4)Problem 6:Calculating Bearings

a、實現 calculateBearingToPoint()

題目要求在已知當前起點和當前朝向角度已知的情況下,計算從起點轉動到終點的角度。因此首先使用Math.atan2()函數計算兩點之間的邊在坐標系中的角度,再減去當前朝向的角度,註意到海龜旋轉方向與坐標軸旋轉角度方向相反,因此需要取相反數。同樣,海龜的基準線是向上,坐標的基準線是向右,因此還需減去90度,最後調整結果在0~360度之間。

代碼實現如下:

    public static double calculateBearingToPoint(double currentBearing, int currentX, int currentY, int targetX, int targetY)
    {
        double degree = Math.toDegrees(Math.atan2(targetY - currentY, targetX - currentX));
        degree = (90 - degree) - currentBearing;
        if (degree < 0)
        {
            degree += 360;
        }
        return degree;
    }

運行並通過了Junit測試。

b、實現 calculateBearings()

題目要求已知若幹個點,現在想計算出從第一個點開始到第二個點,第二個點到第三個點……以此類推每次轉向的角度。

不妨記有n個點,一開始將“起點”選為第一個點,迴圈n-1次,每次將i+1個點設置為“終點”,通過calculateBearingToPoint()函數計算旋轉角度並保存到List中,再將當前“終點”當做下一次迴圈的“起點”,繼續迴圈……最後返回List。

代碼實現如下:

    public static List<Double> calculateBearings(List<Integer> xCoords, List<Integer> yCoords)
    {
        List<Double> result = new ArrayList<Double>();
        result.add(calculateBearingToPoint(0.0, xCoords.get(0), yCoords.get(0), xCoords.get(1), yCoords.get(1)));
        if (xCoords.size() > 2)
        {
            for (int i = 2; i < xCoords.size(); i++)
            {
                result.add(calculateBearingToPoint(result.get(i - 2), xCoords.get(i - 1), yCoords.get(i - 1), xCoords.get(i), yCoords.get(i)));
            }
        }
        return result;
    }

運行並通過了Junit測試。

(5)Problem 7:Convex Hulls

 根據題目提示,運用Gift wrapping algorithm演算法,每次都選擇轉向角最小且點間距離最長的點加入集合中,計算轉向角度可使用上題的calculateBearingToPoint函數。其中相同轉向角點之間的取捨,可以在迴圈中使用標記變數Dist_target記錄其與當前目標點的距離,如果之後出現了新的目標點,就用Dist_target和計算得到的當前點的距離Dist_temp來比較,取更大者為新的Dist_target。

 代碼實現如下:

    public static Set<Point> convexHull(Set<Point> points)
    {
        ArrayList<Point> Points_convex = new ArrayList<Point>();
        ArrayList<Point> Points_temp = new ArrayList<Point>();
        Points_temp.addAll(points);
        Set<Point> result = new HashSet<Point>();

        int totalNum = Points_temp.size();
        if (totalNum < 4) // 點集中點小於4時,直接返回
        {
            return points;
        }
        Point Point_first = Points_temp.get(0);
        for (Point Point_now : points)
        { // 找到起始點
            if (Point_now.x() < Point_first.x())
            {
                Point_first = Point_now;
            }
            else if (Point_now.x() == Point_first.x() && Point_now.y() < Point_first.y())
            {
                Point_first = Point_now;
            }
        }
        Points_convex.add(Point_first);//初始點加入集合
        Points_temp.remove(Point_first);//從原始集合中去除初始點

        Point Point_previous = Point_first;
        int count = 0;
        do {
            if (count == 1)
            {
                Points_temp.add(Point_first);//再把原始點加入集合,作為迴圈的終止條件
            }
            Point Point_target = null;//初始點目標點為空
            double Angle_target = 360;//每次迴圈找到的最小角度,初始化為360
            double Dist_target = 0;
            for (Point Point_now : Points_temp)
            {
                double Angle_temp = calculateBearingToPoint(0, (int) Point_previous.x(), (int) Point_previous.y(), (int) Point_now.x(), (int) Point_now.y());//計算轉向角
                double Dist_temp = Math.pow(Point_previous.x() - Point_now.x(), 2) + Math.pow(Point_previous.y() - Point_now.y(), 2);//計算距離
                if (Angle_temp < Angle_target) //如果轉向角比當前找到的最小角度要小,設置新的Angle_target和Dist_target
                {
                    Angle_target = Angle_temp;
                    Point_target = Point_now;
                    Dist_target = Dist_temp;
                }
                else if (Angle_temp == Angle_target && Dist_temp > Dist_target) //取遠端點
                {
                    Dist_target = Dist_temp;
                    Point_target = Point_now;
                }
            }
            Points_convex.add(Point_target);
            Points_temp.remove(Point_target);
            Point_previous = Point_target;
            count++;
        } while (Points_convex.get(count) != Point_first);
        result.addAll(Points_convex);
        return result;
    }

運行並通過了Junit測試。

(6)Problem 8:Personal Art

        思路:在畫正多邊形的基礎上,步長越來越長,並且角度比畫正多邊形需要的角度略多一點,每次拐彎變換一次顏色。

        其中NumColor是顏色數量,Step是每次變化的步長,Change控制螺旋的密度,其值越大拐彎幅度越大。

效果如下:

 代碼實現如下(其中Switch語句里設置畫筆的顏色):

public static void drawPersonalArt(Turtle turtle)
    {
        int NumColor = 9, Step = 1, Change = 109, Size = 360;
        for (int i = 0; i < Size; i++)
        {
            int temp = i / 18;
            switch (temp % NumColor)
            {
                case 0:
                    turtle.color(PenColor.MAGENTA);
                    break;
                case 1:
                    turtle.color(PenColor.BLUE);
                    break;
                case 2:
                    turtle.color(PenColor.RED);
                    break;
                case 3:
                    turtle.color(PenColor.PINK);
                    break;
                case 4:
                    turtle.color(PenColor.YELLOW);
                    break;
                case 5:
                    turtle.color(PenColor.GREEN);
                    break;
                case 6:
                    turtle.color(PenColor.CYAN);
                    break;
                case 7:
                    turtle.color(PenColor.ORANGE);
                    break;
                case 8:
                    turtle.color(PenColor.GRAY);
                    break;
            }
            turtle.forward(Step * i);
            turtle.turn(360 / NumColor + Change);
        }
    }

(7)Submitting

        在CSDN的博客(https://blog.csdn.net/qq_28849009/article/details/104486824)里初步學習了Git的使用。

①到要上傳的文件夾裡面

cd /d/CODES/GitHub/SoftwareConstruction/HIT-Lab1-120L022408

②初始化本地git倉庫

git init

③添加倉庫url

git remote add origin https://github.com/ComputerScienceHIT/HIT-Lab1-120L022408

④認證身份

git config --global user.name "XXX"

git config --global user.email "[email protected]"

⑤選擇所要上傳的文件

git add .

⑥添加修改日誌

git commit -m "XXX"

⑦上傳文件

git push -u origin master

3、Social Network

        題目要求設計實現一張社交關係網路圖,並編寫一個計算人機關係“距離”的函數。網路圖基於兩個類,分別是FriendshipGraph類和Person類。

(1)設計/實現FriendshipGraph類

每個成員的朋友放在List中,用Graph存取圖的映射關係。

public Map<Person,ArrayList<Person>> Graph = new HashMap<Person, ArrayList<Person>>();

a、addVertex(Person People)

用來向people列表加入新的成員,註意需要在加入之前先在圖中檢測是否有重名的成員,有則輸出錯誤提示並退出。

    public void addVertex(Person People)
    {
        for (Person p : Graph.keySet())
        {
            if (p.getName().equalsIgnoreCase(People.getName()))
            {
                System.out.println(People.getName() + "名稱重覆!");
                System.exit(0);
            }
        }
        ArrayList<Person> newArray = new ArrayList<Person>();
        this.Graph.put(People, newArray);
    }

b、addEdge(Person People1, Person People2)

函數使用Graph.get(People1).add(People2),在每個人的朋友列表中添加新的朋友。同樣,在添加朋友之前先檢查被添加朋友的成員在圖中是否存在,若不存在則報錯並退出。

    public void addEdge(Person People1, Person People2)
    {
        if (Graph.containsKey(People1))
        {
            Graph.get(People1).add(People2);
        }
        else
        {
            System.out.println(People1.getName() + "查無此人!");
            System.exit(0);
        }
    }

c、getDistance(Person People1, Person People2)

該函數首先聲明一個ArrayList<Personr> visited_Person數據結構,來保存已訪問過的成員對象。使用鄰接表廣度搜索的方法,藉助隊列,先將起點入隊,然後執行迴圈,直到隊列為空前:彈出隊列頭元素,計算當前距離,把彈出點的所有“朋友”入隊,並加入visited_Person中,設置距離為先前計算的距離+1。直到找到目標點,返回當前距離。若直到隊列為空仍未找到目標點,返回 -1。

public int getDistance(Person People1, Person People2)
    {
        Person Temp = People1, Target = People1;
        int i = 0 , distance = 0;
        Queue<Person> queue_Person = new LinkedList<Person>();
        ArrayList<Person> visited_Person = new ArrayList<Person>();
        if (People1 == People2)
        {
            return distance;
        }
        queue_Person.add(Temp);
        visited_Person.add(Temp);
        while (!queue_Person.isEmpty())
        {
            Temp = queue_Person.poll();
            distance ++;
            while (i < Graph.get(Temp).size())
            {
                Target = Graph.get(Temp).get(i);
                if (Target == People2)
                {
                    return distance; //找到了即返回當前的距離
                }
                if (!visited_Person.contains(Target))
                {
                    queue_Person.add(Target);
                    visited_Person.add(Target);
                }
                i++;
            }
            i = 0;
        }
        return -1;   //找不到說明People1和People2不存在聯繫
    }

(2)設計實現Person類

Person類:

保存對象名字的字元串private String Name

得到當前對象名字的方法getName()

判斷當前對象名字與給定名字是否相同的方法isSameName()

package P3;

public class Person
{
    private final String Name;
    public Person (String Name)
    {
        this.Name = Name;
    }
    public String getName()
    {
        return this.Name;
    }
    public boolean isSameName(String Name)
    {
        return this.Name.equals(Name);
    }
}

(3)設計/實現​​​​​​客戶端代碼main()

a、不修改提供的main()的代碼

測試結果如下:

b、註釋掉“graph.addEdge(rachel, ross)”

測試結果為:

原因是:

從rachel到ross的邊不存在了,所以rachel,和ross距離-1,其他點也無法達到。只有getDistance(rachel, rachel)返回0。

c、修改main()輸入重覆姓名測試

測試結果為:

原因是在前面代碼中設置了查找到重覆名字就退出的檢查:

(4)設計/實現測試用例

 根據FriendshipGraph類和Person類設計了一個test檢測各種距離和不可到達的情況。

package P3;

import static org.junit.Assert.assertEquals;
import org.junit.Test;

public class FriendshipGraphTest {

    @Test(expected = AssertionError.class)
    public void testAssertionsEnabled() {
        assert false; // make sure assertions are enabled with VM argument: -ea
    }

    @Test
    public void testBasicFriendshipGraph() throws Exception
    {
        FriendshipGraph graph = new FriendshipGraph();
        Person a = new Person("a");
        Person b = new Person("b");
        Person c = new Person("c");
        Person d = new Person("d");
        graph.addVertex(a);
        graph.addVertex(b);
        graph.addVertex(c);
        graph.addVertex(d);
        graph.addEdge(a, b);
        graph.addEdge(b, c);
        graph.addEdge(c, d);
        assertEquals("expected distance", 1, graph.getDistance(a, b));
        assertEquals("expected distance", 1, graph.getDistance(b, c));
        assertEquals("expected distance", 1, graph.getDistance(c, d));
        assertEquals("expected distance", 2, graph.getDistance(a, c));
        assertEquals("expected distance", 2, graph.getDistance(b, d));
        assertEquals("expected distance", 3, graph.getDistance(a, d));
        assertEquals("expected distance", -1, graph.getDistance(b, a));
    }

}

四、實驗收穫

1、經驗/教訓

        對java語言的掌握十分不足,下一次實驗前需要加強。

        認識到了趁手的工具軟體對程式員的幫助有多大,“工欲善其事必先利其器”,下一次實驗前將配置好更得心應手的工具軟體。

2、感想

(1)Java編程語言是否對你的口味?與你熟悉的其他編程語言相比,Java有何優勢和不足?

        非常對我的口味,具體就是有很多數據結構直接可以使用,Java提供的庫函數功能十分強大,深受我的喜愛。

        在此之前,我只熟悉C語言,相比之下,Java相較於C語言的優點是:C語言特別簡陋,許多常用的數據結構的實現都需要自己重新編寫;而Java簡單易上手。缺點是:C語言更接近程式的底層邏輯,運行效率更高,且更能鍛煉程式員的基礎能力;而Java並不能使程式員瞭解一些數據結構的具體實現。

(2)關於Eclipse或IntelliJ IDEA,它們作為IDE的優勢和不足;

        在2021夏季小學期開始使用過Eclipse,小學期快結束時接觸到了IDEA,因此我對其感受頗深。Eclipse的優勢在於其免費,其餘無任何優勢。IDEA的優勢在於插件豐富,集成更智能,界面更美觀,使用十分舒心,不足在於旗艦版收費,但可使用學生郵箱認證身份來免費使用。

(3)關於Git和GitHub,是否感受到了它在版本控制方面的價值;

需要繼續學習才能熟練掌握使用。

(4)關於CMU和MIT的作業,你有何感受;

能夠向世界一流電腦專業學習是邁向世界一流的必經之路。

(5)關於本實驗的工作量、難度、deadline;

工作量大,難度不小,deadline撞車《形式語言與自動機》課程的期末考試,因此時間十分緊張,高強度學習知識並編寫代碼的同時很難統籌兼顧其他課程的複習與預習。

(6)關於初接觸“軟體構造”課程;

有趣,可學習性強,頗有難度,英語閱讀困難。


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 講義: 動態sql可以定義代碼片斷,可以進行邏輯判斷,可以進行迴圈處理(批量處理),使條件判斷更為簡單。 一、動態sql核心標簽: 1、<sql>:當多種類型的查詢語句的查詢欄位或者查詢條件相同時,可以將其定義為常量,方便調用。 2、<include>:用來引用<sql>定義的代碼片斷。 <!--定 ...
  • 一、並行管道搭建: 總結下實現思路: 歸併排序:進行集合元素排序(節點),並兩兩節點歸併排序;每個節點元素要求有序的(排序),當然終點最小節點元數個數為1必是有序的; 節點:任務處理單元,歸併排序節點是處理輸出有序集合任務的單元;文件過大單台機排不了需要多台機集群; 根據粒度,單機版:非併發節點可以 ...
  • package com.oop.demo06;public class Person { public void run(){ System.out.println("run"); }} package com.oop.demo06;public class Student extends Pers ...
  • #批量入庫 因為maccms自帶的採集採集起來很慢,而且很多資源站的採集介面不能對內容排序,導致最舊的數據最後入庫。用java寫個採集程式,採集完入庫的時候發現不能一次性入庫多個數據,導致入庫也很慢,所以就在入庫控制器寫了個方法批量入庫。 Receive.php public function fo ...
  • Spring Bean的創建剛開始進行了一些準備工作,比如轉換服務的初始化,占位符解析器的初始化,BeanDefinition元數據的凍結等操作,都是為了在創建Bean的過程中保證Bean的正確的創建,接下來開始進行對Bean的創建進行解析。 Bean 的創建步驟 在Spring源碼中對Bean的創 ...
  • Spring與Web環境集成 1. ApplicationContext應用上下文獲取方式 應用上下文對象是通過 new ClassPathXmlApplicationContext(Spring配置文件) 方式獲取的,但是每次從容器中獲取Bean時都要編寫 new ClassPathXmlAppl ...
  • 第十一屆藍橋杯大賽第二次模擬(軟體類)真題 Python組 【問題描述】在電腦存儲中,12.5MB是多少位元組?【答案提交】這是一 道結果填空的題,你只需要算出結果後提交即可。本題的結果為一個整數,在提交答案時只 填寫這個整數,填寫多餘的內容將無法得分。 ''' 這裡註意是byte不是bit,byt ...
  • 要先安裝Appium,並用它來查找對應元素的id、xpath等信息 from appium import webdriver from appium.webdriver.extensions.android.nativekey import AndroidKey from selenium.webd ...
一周排行
    -Advertisement-
    Play Games
  • 經常看到有群友調侃“為什麼搞Java的總在學習JVM調優?那是因為Java爛!我們.NET就不需要搞這些!”真的是這樣嗎?今天我就用一個案例來分析一下。 昨天,一位學生問了我一個問題:他建了一個預設的ASP.NET Core Web API的項目,也就是那個WeatherForecast的預設項目模 ...
  • 很多軟體工程師都認為MD5是一種加密演算法,然而這種觀點是不對的。作為一個 1992 年第一次被公開的演算法,到今天為止已經被髮現了一些致命的漏洞。本文討論MD5在密碼保存方面的一些問題。 ...
  • Maven可以使我們在構建項目時需要用到很多第三方類jar包,如下一些常用jar包 而maven的出現可以讓我們避免手動導入jar包出現的某些問題,它可以自動下載那須所需要的jar包 我們只需要在創建的maven項目自動生成的pom.xml中輸入如下代碼 <dependencies> <!--ser ...
  • 來源:https://developer.aliyun.com/article/694020 非同步調用幾乎是處理高併發Web應用性能問題的萬金油,那麼什麼是“非同步調用”? “非同步調用”對應的是“同步調用”,同步調用指程式按照定義順序依次執行,每一行程式都必須等待上一行程式執行完成之後才能執行;非同步調 ...
  • 1.面向對象 面向對象編程是在面向過程編程的基礎上發展來的,它比面向過程編程具有更強的靈活性和擴展性,所以可以先瞭解下什麼是面向過程編程: 面向過程編程的核心是過程,就是分析出實現需求所需要的步驟,通過函數一步一步實現這些步驟,接著依次調用即可,再簡單理解就是程式 從上到下一步步執行,從頭到尾的解決 ...
  • 10瓶毒藥其中只有一瓶有毒至少需要幾隻老鼠可以找到有毒的那瓶 身似浮雲,心如飛絮,氣若游絲。 用二分查找和二進位位運算的思想都可以把死亡的老鼠降到最低。 其中,二進位位運算就是每一隻老鼠代表一個二進位0或1,0就代表老鼠存活,1代表老鼠死亡;根據數學運算 23 = 8、24 = 16,那麼至少需要四 ...
  • 一、Kafka存在哪些方面的優勢 1. 多生產者 可以無縫地支持多個生產者,不管客戶端在使用單個主題還是多個主題。 2. 多消費者 支持多個消費者從一個單獨的消息流上讀取數據,而且消費者之間互不影響。 3. 基於磁碟的數據存儲 支持消費者非實時地讀取消息,由於消息被提交到磁碟,根據設置的規則進行保存 ...
  • 大家好,我是陶朱公Boy。 前言 上一篇文章《關於狀態機的技術選型,最後一個真心好》我跟大家聊了一下關於”狀態機“的話題。從眾多技術選型中我也推薦了一款阿裡開源的狀態機—“cola-statemachine”。 於是就有小伙伴私信我,自己項目也考慮引入這款狀態機,但網上資料實在太少,能不能系統的介紹 ...
  • 使用腳本自動跑實驗(Ubuntu),將實驗結果記錄在文件中,併在實驗結束之後將結果通過郵件發送到郵箱,最後在windows端自動解析成excel表格。 ...
  • 話說在前面,我不是小黑子~ 我是超級大黑子😏 表弟大周末的跑來我家,沒事幹天天騷擾我,搞得我都不能跟小姐姐好好聊天了,於是為了打發表弟,我決定用Python做一個小游戲來消耗一下他的精力,我思來想去,決定把他變成小黑子,於是做了一個坤坤打籃球的游戲,沒想到他還挺愛玩的~ 終於解放了,於是我把游戲寫 ...