Java对两个类的重新设计

它被要求重新设计这两个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;
}

公共类加法器{
公共整数和（整数[]数组）{
int结果=0；
for（int i=0；i

---

注意不同的<代码>结果<代码>初始化；这是我的主要问题。

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

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}));
    }
}

---

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

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}));
    }
}

---

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

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();
    }
}

---

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

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();
    }
}

怎么样

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;
   }
}

公共抽象类计算器{
受保护的整数聚合（int[]数组，int startValue）{
int结果=起始值；
for（int i=0；i

这种方法甚至保留了类结构，这在外部使用类

加法器

和

乘法器

时可能很重要（它们是

公共的

！）

个人而言，我不认为这整个活动是“可维修性的改进”。因此：由于继承的这种性质，它更为复杂。这个问题对我来说就像是一个理论问题，它应该教育你如何进行重构——但恰恰忽略了最重要的一点：让简单的事情保持简单——即使它们可能有点多余。

如何

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;
   }
}

公共抽象类计算器{
受保护的整数聚合（int[]数组，int startValue）{
int结果=起始值；
for（int i=0；i

这种方法甚至保留了类结构，这在外部使用类

加法器

和

乘法器

时可能很重要（它们是

公共的

！）

---

个人而言，我不认为这整个活动是“可维修性的改进”。因此：由于继承的这种性质，它更为复杂。我觉得这个问题像是一个理论问题，它应该教育你如何进行重构——但恰恰忽略了最重要的一点：让简单的事情保持简单——即使它们可能有点多余。

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

公共抽象类arrayFunction{
公共整数计算（整数[]数组）{
int result=initResult（）；
for（int i=0；i

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

公共抽象类arrayFunction{
公共整数计算（整数[]数组）{
int result=initResult（）；
for（int i=0；i