0

我有一些相同的代码，只是某些分配序列的顺序略有不同。

很容易将其分解为 type 的方法参数int[]，它表示顺序。

但是，我发现这不是最清楚的。

另一种选择是将它们分解为 type 的对象AssignmentOrders。我还可以对对象构造函数中的值进行验证，而我无法对数组进行验证。这将是 Refactoring 书中的“引入参数对象”重构。

我想知道这种特殊的重构是否过度，我应该坚持使用int[]?

代码：

原件的三个样本：

private static PersonDetails parseLine(String line, String deliminator, int[] orderOfSections) 
            throws Exception {
        String[] sections = line.split(deliminator);

        String value1 = sections[0].trim();
        String value2 = sections[1].trim();
        String value3 = sections[4].trim();
        String value4 = sections[2].trim();
        String value5 = sections[3].trim();

        //........
    }

private static PersonDetails parseLine(String line, String deliminator) 
            throws Exception {
        String[] sections = line.split(deliminator);

        String value1 = sections[1].trim();
        String value2 = sections[0].trim();
        String value3 = sections[2].trim();
        String value4 = sections[3].trim();
        String value5 = sections[4].trim();

        //........
    }

private static PersonDetails parseLine(String line, String deliminator, int[] orderOfSections)


        throws Exception {
        String[] sections = line.split(deliminator);

        String value1 = sections[0].trim();
        String value2 = sections[1].trim();
        String value3 = sections[2].trim();
        String value4 = sections[4].trim();
        String value5 = sections[5].trim();

        //........
    }

我如何将上述 3 重构为：

private static PersonDetails parseLine(String line, String deliminator, int[] orderOfSections) 
            throws Exception {
        String[] sections = line.split(deliminator);

        String value1 = sections[orderOfSections[0]].trim();
        String value2 = sections[orderOfSections[1]].trim();
        String value3 = sections[orderOfSections[2]].trim();
        String value4 = sections[orderOfSections[3]].trim();
        String value5 = sections[orderOfSections[4]].trim();

        //........
    }

我如何在理论上将其重构为参数对象：

private static PersonDetails parseLine(String line, String deliminator, OrderOfSections order) 
        throws Exception {
        String[] sections = line.split(deliminator);

        String value1 = sections[order.getValue1Idx].trim();
        String value2 = sections[order.getValue2Idx].trim();
        String value3 = sections[order.getValue3Idx].trim();
        String value4 = sections[order.getValue4Idx].trim();
        String value5 = sections[order.getValue5Idx].trim();

        //........
    }

我想做的是创建一个特定的类而不是使用int[]......但想知道这是否会有点矫枉过正。

好处是它更具可读性。而不是orderOfSections[0]，它可能是orderOfSections.value1SectionIdx......我还可以将一些验证代码放入类中。

我相信这就是 Martin Fowler 所说的引入参数对象。

编辑：

另一种选择是使用字典。比新课程更轻，但更具描述性......然后我可以使用类似的东西orderOfSections["value1"]

4

2 回答 2

7

我不会传入一个Classor 数组来简单地指示原始项目的顺序String以及它们应该如何分配，而是将输入的解析委托line给 this Class。执行以下操作会更具可读性：

private static PersonDetails parseLine(String line, String deliminator, 
                         SectionsReader reader) throws Exception 
{
    reader.setLine(line);
    String value1 = reader.getValue1();
    String value2 = reader.getValue2();
    String value3 = reader.getValue3();
    String value4 = reader.getValue4();
    String value5 = reader.getValue5();

    //........
}

最后，这并不过分，当你在 3 个月的时间里回到这段代码并发现它更容易理解时，你会感谢自己。

于 2009-10-03T14:48:15.807 回答
1

恕我直言，最简单和最易读的方法是传递映射而不是 int 数组。

根据您的 PersonDetails 字段的外观，您甚至可以使用反射并在循环中分配值。

于 2009-10-03T13:16:09.550 回答