JAVA面试题——JAVA编程题1（2015.07.22——湛耀）

---

实现代码很简单：

 

package com.xiaozan.shopping;

 

import java.util.Arrays;

 

public class ShoppingCart {

    

    public final static int PRODUCT_1_PRICE = 2000;    // 产品编号第一个数字为1的单价，单位（分）

    public final static int PRODUCT_2_PRICE = 1000;    // 其他产品编号的单价，单位 （分）

    public final static int PRODUCT_1_TYPE = 1;    // 产品编号第一个数字为1的商品定义为类型1产品

    

    /**

     * 

     * @方法说明 按从小到大排列数组

     * @param data

     * @return void

     */

    public void sort(int[] data) {

        Arrays.sort(data);

    }

    

    /**

     * 

     * @方法说明 传入已排序的数据，计算数组中产品编号第一个数字为1的个数

     * @param data

     * @return

     * @return int

     */

    public int countProduct1(int[] data) {

        int product1Sum = 0;

        for (int i = 0; i < data.length; i++) {

            int theFirstNumber = data[i]/100;    // 产品编号的第一个数字

            if (theFirstNumber == PRODUCT_1_TYPE) {

                // 产品类型1的数量 +1

                product1Sum++;

            } else {

                // 因为已经排序，如果不是产品类型1，则剩余的都不是产品类型1的产品

                return product1Sum;

            }

        }

        return product1Sum;

    }

    

    /**

     * 

     * @方法说明 计算购物车总金额

     * @param data

     * @return

     * @return int

     */

    public int sum(int[] data) {

        int sum = 0;    // 总金额

        sort(data);    // 按从小到大排列产品编号

        int product1Sum = countProduct1(data);    // 类型1产品的个数

        sum = (product1Sum / 4) * (PRODUCT_1_PRICE * 3)    // 买4件类型1的产品只需付3件的钱 

                + (product1Sum % 4) * PRODUCT_1_PRICE     // 不足4件类型1的产品按类型1的产品单价结算

                + (data.length - product1Sum) * PRODUCT_2_PRICE;    // 其他类型的产品按其他类型单价结算

        // 如果折后金额大于等于50元，则全单八折

        if (sum >= 5000) {

            sum *= 0.8;

        }

        return sum;

    }

    

}

---

个人对测试仍不是很熟练，对Junit的一次练手：

package com.xiaozanoa.shopping;

 

import static org.junit.Assert.assertArrayEquals;

import static org.junit.Assert.assertEquals;

 

import java.util.Arrays;

import java.util.Collection;

 

import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.junit.runners.Parameterized;

import org.junit.runners.Parameterized.Parameters;

 

import com.xiaozan.shopping.ShoppingCart;

 

@RunWith(Parameterized.class)

public class TestShoppingCart {

 

    ShoppingCart shoppingCart = null;

    int[] data = null;    // 预设购物车购买下产品编号

    int[] expectedSort = null;    // 预期的排序结果

    int expectedSum = 0;    // 预期产品总金额

    int expectedProduct1Sum = 0;    // 预期产品1总数

    

    @Parameters

    public static Collection<Object[][]> prepareData() {

        Object[][][] objects = {

                // 含产品1和其他产品，产品1多于4件，金额大于50

                { {229, 132, 129, 217, 190, 118, 387, 124}, 

                  {118, 124, 129, 132, 190, 217, 229, 387}, {5}, {8800} },    

                // 没有产品1 ，金额小于50

                { {229}, {229}, {0}, {1000} },    

                // 没有产品1 ，金额等于50

                { {229, 217, 387, 222, 345}, {217, 222, 229, 345, 387}, {0}, {4000} },    

                // 只有产品1 且少于4件,金额小于50

                { {118}, {118}, {1}, {2000} },    

                // 只有产品1 且等于4件,金额大于50

                { {129, 190, 118, 124}, {118, 124, 129, 190}, {4}, {4800} },    

                // 只有产品1 且大于4件,金额大于50

                { {132, 129, 190, 118, 124}, {118, 124, 129, 132, 190}, {5}, {6400} } };    

        return  Arrays.asList(objects); // 将数组转换成集合返回

    }

    

    public TestShoppingCart(Object[] _data, Object[] _expectedSort, 

            Object[] _expectedProduct1Sum, Object[] _expectedSum) {

        // 构造方法

        // JUnit会使用准备的测试数据传给构造函数

        data = new int[_data.length];

        expectedSort = new int[_expectedSort.length];

        for (int i = 0; i < _data.length; i++) {

            data[i] = (Integer) _data[i];

        }

        for (int i = 0; i < _expectedSort.length; i++) {

            expectedSort[i] = (Integer) _expectedSort[i];

        }

        this.expectedProduct1Sum = (Integer) _expectedProduct1Sum[0];

        this.expectedSum = (Integer) _expectedSum[0];

    }

    

    @Before

    public void setUp() {

        shoppingCart = new ShoppingCart();

    }

    

    @Test

    public void testCountProduct1() {

        int result = shoppingCart.countProduct1(expectedSort);    //计算产品1的数量是在已排序的数组的基础上计算的

        assertEquals(expectedProduct1Sum, result);

    }

    

    @Test

    public void testSort() {

        shoppingCart.sort(data);

        assertArrayEquals(expectedSort, data);

    }

    

    @Test

    public void testSum() {

        int result = shoppingCart.sum(data);

        assertEquals(expectedSum, result);

    }

    

 

}

---

测试覆盖率：

---

测试时主要遇到的问题在参数化测试。

常规一般见的参数化例子都是单个数字，如：

@Parameters
public static Collection prepareData()
{
   // 测试数据
   Object[][] objects = { { 3, 1, 2 }, { -4, -1, -3 }, { 5, 2, 3 },{ 4, -4, 8 } };
   return Arrays.asList(objects);// 将数组转换成集合返回
}

所以我在做的时候就想当然的仿照着做：

---

错误1：argument type mismatch

public TestShoppingCart(int[] _data, int[] _expectedSort, int[] _expectedProduct1Sum, int[] _expectedSum) {

    ……        

}

原因：<Object[][]> List<Object[][]> java.util.Arrays.asList(Object[][]... a)，返回的是对象数组

---

错误2：

Type mismatch: cannot convert from Object[] to int[]

int[] data = null;    // 预设购物车购买下产品编号

int[] expectedSort = null;    // 预期的排序结果

public TestShoppingCart(Object[] _data, Object[] _expectedSort, 

            Object[] _expectedProduct1Sum, Object[] _expectedSum) {

        ……

}

---

错误3：java.lang.NullPointerException

int[] data = null;    // 预设购物车购买下产品编号

int[] expectedSort = null;    // 预期的排序结果

原因：没有创建对象

---

错误4：计算的总额与预期的不一致

int[] data = new int[8];    // 预设购物车购买下产品编号

int[] expectedSort = new int[8];    // 预期的排序结果

错误原因：固定了数组大小为8，不足8位，补0填充，这样放到该代码中就有问题了

---

一分耕耘一分收获…

来自为知笔记(Wiz)