Question

要求重新设计这两个Java类，以避免代码重复并提高可维护性。

public class Adder {
  public int sum(int[] array) {
    int result = 0;
    for (int i = 0; i < array.length; i++) {
      result += array[i];
    }
  return result;
}

public class Multiplier {
  public int multiply(int[] array) {
    int result = 1;
    for (int i = 0; i < array.length; i++) {
      result *= array[i];
    }
  return result;
}

注意不同的result初始化;这是我的主要问题。

Answer 1

如果你真的认为这需要一些重构，请考虑这个：

public class Calculator {
    public int multiply(int[] array) {
        return calculate(1, array, (a, b) -> a * b);
    }

    public int sum(int[] array) {
        return calculate(0, array, (a, b) -> a + b);
    }

    public int calculate(int initValue, int[] array, IntBinaryOperator operator) {
        return Arrays.stream(array).reduce(initValue, operator);
    }

    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        System.out.println(calculator.multiply(new int[]{1, 2, 3, 4}));
        System.out.println(calculator.sum(new int[]{1, 2, 3, 4}));
    }
}

Answer 2

这是我的建议。它将迭代作为超抽象类中指定的公共代码。初始值和数学运算被委托给具体实现

public abstract class CommonMath {
    public int calculate(int initialValue, int[] array) {
        int result = initialValue;
        for (int i = 0; i < array.length; i++) {
            result = mathOperation(result, array[i]);
        }
        return result;
    }

    public abstract int mathOperation(int result, int arrayItem);
}

public class Adder extends CommonMath {
    public int sum(int[] array) {
        return calculate(0, array);
    }

    @Override
    public int mathOperation(int result, int arrayItem) {
        return result + arrayItem;
    }
}

public class Multiplier extends CommonMath {
    public int multiply(int[] array) {
        return calculate(1, array);
    }

    @Override
    public int mathOperation(int result, int arrayItem) {
        return result * arrayItem;
    }
}

// test
public static void main(String[] args) {
    try {
        int[] array; {
            array = new int[3];
            array[0] = 1;
            array[1] = 2;
            array[2] = 4;
        }
        System.out.println("sum " + Arrays.toString(array) + " " + new Adder().sum(array));
        System.out.println("multi " + Arrays.toString(array) + " " + new Multiplier().multiply(array));
    } catch (Exception e) {
        e.printStackTrace();
    }
}

输出

sum [1, 2, 4] 7
multi [1, 2, 4] 8

Answer 3

我想发布我的答案，尽管问题已经有了一个很好的答案（我太慢了）。我的解决方案中的一点是对新操作开放，您不必知道不同的函数名称（因此您可以将ArrayFunction注入其他类）：

public abstract class ArrayFuntion {

    public int compute(int[] array) {
        int result = initResult();
        for (int i = 0; i < array.length; i++) {
            result = compute(result, array[i]);
        }
        return result;
    }

    protected abstract int compute(int result, int i);

    protected abstract int initResult();

}


public class Adder extends ArrayFuntion{

    @Override
    protected int compute(int result, int arrayItem) {
        return result + arrayItem;
    }

    @Override
    protected int initResult() {
        return 0;
    }

}


public class Multiplier extends ArrayFuntion {

    @Override
    protected int compute(int result, int arrayItem) {
        return result * arrayItem;
    }

    @Override
    protected int initResult() {
        return 1;
    }

}

Answer 4

怎么样

public abstract class Calculator {
   protected int aggregate(int[] array, int startValue) {
       int result = startValue;
       for (int i = 0; i < array.length; i++) {
          result = this.aggregateSingle(array[i], result);
       }
       return result;
    }

    protected abstract int aggregateSingle(int nextValue, int oldAggregation);
}

public class Adder extends Calculator {
   public int sum(int[] array) {
      return this.aggregate(array, 0);
   }
   protected int aggregateSingle(int nextValue, int oldAggregation) {
      return nextValue + oldAggregation;
   }
}

public class Multiplier extends Calculator {
   public int multiply(int[] array) {
      return this.aggregate(array, 1);
   }
   protected int aggregateSingle(int nextValue, int oldAggregation) {
      return nextValue * oldAggregation;
   }
}

这种方法甚至保留了类结构，这在外部使用类Adder和Multiplier的情况下很重要（它们是public！）

就个人而言，我并不认为这整个活动是对可维护性的改进＆＃34;因此：由于这种继承性，它更多的是LoC，甚至更复杂。对我来说这个问题感觉就像是一些理论问题，它应该教会你的思想应该如何进行重构 - 但确切地忽略了最重要的一点：保持简单的事情 - 即使它们可能有点多余。

Java重新设计了两个类

4 个答案: