如何使構造函數的排序更有效？

Question

我目前正致力於一個必須擁有所有可能的計算示例的程序。 我為數字，差異，產品，模數，商和總和做了一個課。 我正在做這樣的事情

Difference(Number first_number,Number second_number){
    s1 = first_number + second_number;
}
Difference(Number first_number, Product first_difference){
    s1 = first_number + first_difference
}
Difference(Product first_difference, Number first_number){
    s1 = first_product + first_number;
}
Difference(Product first_difference, Product second_difference){
    s1 = first_difference + second_difference;
}
Difference(Number first_number, Quotient first_difference){
    s1 = first_number + first_difference;
}
Difference(Quotient first_difference, Number first_number){
    s1 = first_difference + first_number;
}
Difference(Quotient first_difference, Quotient second_difference){
    s1 = first_difference + second_difference;
}
Difference(Number first_number, Difference first_difference){
    s1 = first_number + first_difference;
}
Difference(Difference first_difference, Number first_number){
    s1 = first_number + first_difference;
}
Difference(Difference first_difference, Difference second_difference){
    s1 = first_difference + second_difference;
}
Difference(Number first_number, Sum first_Difference){
    s1 = first_number + first_Difference;
}
Difference(Sum first_Difference, Number first_number){
    s1 = first_Difference + first_number;
}
Difference(Sum first_Difference, Sum second_Difference){
    s1 = first_Difference + second_Difference;
}
Difference(Number first_number, Modulus first_modulus ){
    s1 = first_number + first_modulus;
}
Difference(Modulus first_modulus, Number first_number){
    s1 = first_number + first_ modulus;
}
Difference(Modulus first_modulus, Modulus second_modulus){
    s1 = first_modulus + second_modulus;
}
Difference(Sum first_Difference, Product first_difference){
    s1 = first_Difference + first_difference;
}
Difference(Product first_difference, Sum first_Difference){
    s1 = first_difference + first_Difference;
}
Difference(Sum first_Difference, Quotient first_difference){
    s1 = first_Difference + first_difference;
}
Difference(Quotient first_difference, Sum first_Difference){
    s1 = first_difference + first_Difference;
}
Difference(Sum first_Difference, Difference first_difference){
    s1 = first_Difference + first_difference;
}
Difference(Difference first_difference, Sum first_Difference){
    s1 = first_Difference + first_difference;
}
Difference(Sum first_Difference, Modulus first_modulus ){
    s1 = first_Difference + first_modulus;
}
Difference(Modulus first_modulus, Sum first_Difference){
    s1 = first_Difference + first_modulus;
}
Difference(Difference first_difference, Quotient first_difference){
    s1 = first_difference + first_difference;
}
Difference(Quotient first_difference, Difference first_difference){
    s1 = first_difference + first_difference;
}
Difference(Product first_difference, Quotient first_difference){
    s1 = first_difference + first_difference;
}
Difference(Quotient first_difference, Product first_difference){
    s1 = first_difference + first_difference;
}
Difference(Quotient first_difference, Modulus first_modulus){
    s1 = first_difference + first_modulus;
}
Difference(Modulus first_modulus, Quotient first_difference){
    s1 = first_difference + first_modulus;
}
Difference(Difference first_difference, Quotient first_difference){
    s1 = first_difference + first_difference;
}
Difference(Quotient first_difference, Difference first_difference){
    s1 = first_difference + first_difference;
}
Difference(Difference first_difference, Modulus first_modulus){
    s1 = first_difference + first_modulus;
}
Difference(Modulus first_modulus, Difference first_difference){
    s1 = first_modulus + first_difference;
}
Difference(Difference first_difference, Modulus first_modulus){
    s1 = first_difference + first_modulus;
}
Difference(Modulus first_modulus, Difference first_difference){
    s1 = first_difference + first_modulus;
} 

確保我的主要課程有各種可能的組合方式。 有什么辦法可以讓我更有效率嗎？ 我厭倦了一遍又一遍地寫這個。

Answer 1

我不確定如何在用戶定義的類中使用+運算符，但問題的解決方案是創建一個空接口IExample ，然后將其實現到所有類並有一個構造函數：

Difference(IExample i1, IExample i2) {
    ...
}

Answer 2

假設Product，Quotient，Difference，Sum和Modulus都擴展了Number，你可以這樣做：

Difference(Number firstNumber, Number secondNumber){
    s1 = firstNumber + secondNumber;
} 

調用重載的方法或構造函數時，將使用最具體的方法/構造函數。 這是一個例子：

Sum s = new Sum(1);
Product p = new Product(2);
Difference d = new Difference(s, p);

將調用具有Number參數的構造函數，因為沒有更具體的構造函數，如Difference（Sum firstSum，Product firstProduct） 。 像你一樣指定更具體的構造函數是可選的（特別是因為所有構造函數都在做同樣的事情）。

Answer 3

這是一種可能的方法，概述：

包裝實踐;

import java.util.function.BiFunction;

public class Operation<T> {
  final T value;

  public Operation(T val) {
    this.value = val;
  }

  public Operation<T> op(T operand, BiFunction<T, T, T> func) {
    final Operation<T> result = new Operation(func.apply(value, operand));
    return result;
  }

  @Override
  public boolean equals(Object other) {
    if (this == other) {
      return true;
    }
    if (! (other instanceof Operation)) {
      return false;
    }
    Operation<T> otherOp = (Operation<T>) other;
    return (value == null ? otherOp.value == null : value.equals(otherOp.value));
  }

  @Override
  public int hashCode() {
    return value == null ? 0 : value.hashCode();
  }

  @Override
  public String toString() {
    return "Operation{ " + value + " }";
  }

  public static void main(String[] args) {
    Operation<Integer> oper1 = new Operation<>(17);
    Operation<Integer> operMinus = oper1.op(23, (x, y) -> x - y);
    Operation<Integer> operPlus = oper1.op(23, (x, y) -> x + y);

    System.out.println("oper1 = " + oper1);
    System.out.println("operMinus = " + operMinus);
    System.out.println("operPlus = " + operPlus);
  }
}

您可以使用此方法的變體與protected op方法，基於它來預定義鎖定操作，而不是讓客戶端提供func參數。

請注意，我們不會將業務邏輯與構造混合在一起。

Answer 4

哦，我做的是創建一個超級表達式然后可以做

public class Sum extends Expression{
private Expression lhs;
private Expression rhs;

Difference(Expression e1,  Expression e2) {
            lhs = e1;
            rhs = e2;
}
}