程序模塊化 與 單元測試

不知道同窗們有沒有過這樣的困惑，程序寫着寫着，就奇長無比，回頭看，已經不知道這段代碼爲什麼物，百般思索事後終於想起來，但又忘記了當前代碼寫到了哪裏。若是你也有此困惑，那麼就請用一點時間讀讀下面的話。

這是一個簡單的四則運算java程序：

import java.util.*;
public class CalcExample2{
    public static void main(String args[]){
        ArrayList<String> al=new ArrayList<String>();
        System.out.println("請輸入要計算的式子個數:");
        Scanner sc=new Scanner(System.in);
        int count=sc.nextInt();
        System.out.println("請輸入你要求解的式子:");
        for(int i=0;i<count;i++){
            sc=new Scanner(System.in);
            al.add(sc.nextLine());
        }
        for(int i=0;i<count;i++){
            System.out.print(al.get(i)+"=");
            //f(al.get(i));
            if(al.get(i).indexOf("+")>-1){
                String[] str=al.get(i).split("[+]");
                System.out.println(Integer.parseInt(str[0])+Integer.parseInt(str[1]));
            }else if(al.get(i).indexOf("-")>-1){
                String[] str=al.get(i).split("[-]");
                System.out.println(Integer.parseInt(str[0])-Integer.parseInt(str[1]));
            }else if(al.get(i).indexOf("*")>-1){
                String[] str=al.get(i).split("[*]");
                System.out.println(Integer.parseInt(str[0])*Integer.parseInt(str[1]));
            }else if(al.get(i).indexOf("/")>-1){
                String[] str=al.get(i).split("[/]");
                System.out.println(Integer.parseInt(str[0])/Integer.parseInt(str[1]));
            }else if(al.get(i).indexOf("%")>-1){
                String[] str=al.get(i).split("[%]");
                System.out.println(Integer.parseInt(str[0])%Integer.parseInt(str[1]));
            }
        }
    }
}

可能有點簡單哈，可是你有沒有考慮過，若是這個程序的難度係數增長了呢？若是須要你寫個計算不僅有兩個運算數字的四則運算呢？若是須要你寫個帶圖形化界面的四則運算呢？就目前上邊這個這麼簡單的程序，我就已經一屏看不完了，那麼這個程序若是再發展狀大，你看了好幾屏以後，還記得以前看了什麼嗎？

這個程序的缺點就在於全部的代碼都寫在一個main方法裏了，若是程序持續增加，會致使代碼愈來愈多，以至程序到最後可能會牽一髮而動全身，好比在上面的程序中，我修改了al的名字，那麼這個程序中全部的al都須要修改，若是少修改了一處，程序就會錯誤。那麼如何讓程序看起來簡單易懂呢？那麼有一個很是不錯的方法，就是一個程序只幹一件事，也能夠說是模塊化。好比在咱們上面這個程序中，咱們能夠將運算部分提取出來，讓這個運算的部分單獨成爲一個模塊，那麼當之後修改這個運算模塊的時候就不會「動全身」啦。

import java.util.*;
public class CalcExample{
    public static void main(String args[]){
        ArrayList<String> al=new ArrayList<String>();
        System.out.println("請輸入要計算的式子個數:");
        Scanner sc=new Scanner(System.in);
        int count=sc.nextInt();
        System.out.println("請輸入你要求解的式子:");
        for(int i=0;i<count;i++){
            sc=new Scanner(System.in);
            al.add(sc.nextLine());
        }
        for(int i=0;i<count;i++){
            System.out.print(al.get(i)+"=");
            calc(al.get(i));
            
        }
    }
    public static void calc(String s){
        if(s.indexOf("+")>-1){
            String[] str=s.split("[+]");
            System.out.println(Integer.parseInt(str[0])+Integer.parseInt(str[1]));
        }else if(s.indexOf("-")>-1){
            String[] str=s.split("[-]");
            System.out.println(Integer.parseInt(str[0])-Integer.parseInt(str[1]));
        }else if(s.indexOf("*")>-1){
            String[] str=s.split("[*]");
            System.out.println(Integer.parseInt(str[0])*Integer.parseInt(str[1]));
        }else if(s.indexOf("/")>-1){
            String[] str=s.split("[/]");
            System.out.println(Integer.parseInt(str[0])/Integer.parseInt(str[1]));
        }else if(s.indexOf("%")>-1){
            String[] str=s.split("[%]");
            System.out.println(Integer.parseInt(str[0])%Integer.parseInt(str[1]));
        }
    }
}

這樣，計算的部分就從程序中脫離出來了。那麼計算的部分從主函數中脫離出來了，可是這個程序依然會存在隨着代碼增多，屏數愈來愈多的問題，可能咱們看完一個模塊就找不到原來閱讀的程序的位置了。咱們但願一個程序只作一件事，這樣就能夠實現每個程序的反覆利用。那麼咱們將計算部分自立門戶，使它成爲一個類中的方法。

CalcExample.java

import java.util.*;
public class CalcExample{
    
    public static void main(String args[]){
        ArrayList<String> al=new ArrayList<String>();
        System.out.println("請輸入要計算的式子個數:");
        Scanner sc=new Scanner(System.in);
        int count=sc.nextInt();
        System.out.println("請輸入你要求解的式子:");
        for(int i=0;i<count;i++){
            sc=new Scanner(System.in);
            al.add(sc.nextLine());
        }
        for(int i=0;i<count;i++){
            System.out.print(al.get(i)+"=");
            Calc calc = new Calc();;
            calc.calc(al.get(i));
        }
    }
}

Calc.java

public class Calc {
    private int result;
    public void calc(String s){
        if(s.indexOf("+")>-1){
            add(s);
        }else if(s.indexOf("-")>-1){
            substract(s);
        }else if(s.indexOf("*")>-1){
            multiply(s);
        }else if(s.indexOf("/")>-1){
            divide(s);
        }else if(s.indexOf("%")>-1){
            remainder(s);
        }
        System.out.println(getResult());
    }
    public void add(String s)
    {
        String[] str=s.split("[+]");
        result =Integer.parseInt(str[0])+Integer.parseInt(str[1]);
    }
    public void substract(String s)
    {
        String[] str=s.split("[-]");
        result = Integer.parseInt(str[0])-Integer.parseInt(str[1]);
    }
    public void multiply(String s)
    {
        String[] str=s.split("[*]");
        result = Integer.parseInt(str[0])*Integer.parseInt(str[1]);
    }
    public void divide(String s)
    {
        String[] str=s.split("[/]");
        result = Integer.parseInt(str[0])/Integer.parseInt(str[1]);
    }
    public void remainder(String s)
    {
        String[] str=s.split("[%]");
        result = Integer.parseInt(str[0])%Integer.parseInt(str[1]);
    }
    public int getResult()
    {
        return result;
    }
}

這樣，經過calc.calc(al.get(i));任何程序想使用這段計算的代碼均可以使用了。並且還方便咱們測試用，在保證main函數徹底沒有問題的時候，若是計算結果發生了錯誤，咱們就能夠只測試Calc一個類。

那麼如何測試一個類到底對不對呢？我使用了eclipse下的junit來測試, junit的安裝方法。如下是個人Junit的測試用例：

CalcTest.java

import static org.junit.Assert.*;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class CalcTest {

    Calc calc = new Calc();
    @Before
    public void setUp() throws Exception {
    }

    @After
    public void tearDown() throws Exception {
    }

    @Test
    public void testCalc() {
        fail("Not yet implemented");
    }

    @Test
    public void testAdd() {
        calc.add("2+3");
        assertEquals(5, calc.getResult());
    }

    @Test
    public void testSubstract() {
        calc.add("2");
        assertEquals(5, calc.getResult());
    }

    @Test
    public void testMultiply() {
        //啥也沒寫
    }

    @Test
    public void testDivide() {
        //啥也沒寫
    }

    @Test
    public void testRemainder() {
        //啥也沒寫
    }

}

程序的結果就是下面的樣子啦：

我只有加法的結果給的是正確的，別的要不就沒寫，要不就不對，junit都告訴我了。

有了這個結果，咱們就能夠測試任意一個模塊啦~