程序模塊化 與 單元測試

不知道同學們有沒有過這樣的困惑，程序寫着寫着，就奇長無比，回頭看，已經不知道這段代碼為何物，百般思索過后終於想起來，但又忘記了當前代碼寫到了哪里。如果你也有此困惑，那么就請用一點時間讀讀下面的話。

這是一個簡單的四則運算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都告訴我了。

有了這個結果，我們就可以測試任意一個模塊啦~