SO ユーザーが書いた問題に加えて、あなたがしている算術にはもっと問題があります。Java は operator overload をサポートしていないためです。これが意味することは、クラスLiczbaZespolona( ComplexNumber ) の 2 つのオブジェクトがある場合、コンパイラはそれをどう処理すればよいかわからず、コンパイルに失敗するということです。
その問題を解決するには、いくつかのクラスでそれらの数値の算術演算を実装する 2 つのものが必要になります。確かに、開始するにはいくつかのポイントが必要であり、このインターフェイスが役立つ場合があります
private static interface IComplexNumber {
public IComplexNumber add(IComplexNumber complexNumber);
public IComplexNumber substract(IComplexNumber complexNumber);
public IComplexNumber multiply(IComplexNumber complexNumber);
public IComplexNumber divide(IComplexNumber complexNumber);
}
次に、2 つの ComplexNumber を追加する方法を知ったら、その操作を実行できるものが必要になります。このタイプの操作では、列挙型が最適です。
クラスはこれを開始するように見える可能性があります
private enum CompleNumberCalculation {
ADD('+') {
@Override
protected IComplexNumber operation(IComplexNumber left, IComplexNumber right) {
return left.add(right);
}
};
private char operator;
private CompleNumberCalculation(char operator) {
this.operator = operator;
}
protected abstract IComplexNumber operation(IComplexNumber left, IComplexNumber right);
}
あなたを助けるために、 RegularNumberMathOperationの計算を解決する簡単な列挙型を書きました
public enum RegularMathOperation {
ADD('+') {
@Override
protected BigDecimal operation(BigDecimal left, BigDecimal right) {
return left.add(right);
}
},
SUBSTRACT('-') {
@Override
protected BigDecimal operation(BigDecimal left, BigDecimal right) {
return left.subtract(right);
}
},
MULTIPLY('*') {
@Override
protected BigDecimal operation(BigDecimal left, BigDecimal right) {
return left.multiply(right);
}
},
DIVIDE('/') {
@Override
protected BigDecimal operation(BigDecimal left, BigDecimal right) {
return left.divide(right,MathContext.DECIMAL64);
}
};
private final char operator;
private RegularMathOperation(char operator) {
this.operator = operator;
}
public char operator() {
return this.operator;
}
public <T1 extends Number, T2 extends Number> T1 calculate(T1 left, T2 right) {
validateInput(left, right);
Class<? extends Number> resultType = left.getClass();
BigDecimal result = this.operation(toBigDecimal(left), toBigDecimal(right));
return (T1) toType(resultType, result);
}
protected abstract BigDecimal operation(BigDecimal left, BigDecimal right);
private void validateInput(Number left, Number right) {
if(left == null) {
throw new IllegalArgumentException("Value of left argument must not be null to perform operation " + this.name());
}
if(right == null) {
throw new IllegalArgumentException("Value of left argument must not be null to perform operation " + this.name());
}
}
private BigDecimal toBigDecimal(Number value) {
if(value instanceof BigDecimal) {
return (BigDecimal) value;
}
return new BigDecimal(value.doubleValue());
}
private Number toType(Class<? extends Number> type, BigDecimal value) {
if(Double.class.isAssignableFrom(type)) {
return type.cast(value.doubleValue());
}
if(Long.class.isAssignableFrom(type)) {
return type.cast(value.longValue());
}
if(Integer.class.isAssignableFrom(type)) {
return type.cast(value.intValue());
}
//...
throw new IllegalStateException("Type not support: "+type);
}
public static Map<Character, RegularMathOperation> operatorMap = new HashMap<Character, RegularMathOperation>();
static {//Fill map
for(RegularMathOperation mathOperation : RegularMathOperation.values()) {
operatorMap.put(mathOperation.operator(), mathOperation);
}
}
public static RegularMathOperation valueOf(char operator) {
RegularMathOperation mathOperation = operatorMap.get(Character.valueOf(operator));
if(mathOperation == null) {
throw new IllegalArgumentException("Could not find MathOperator for operartor: " + operator);
}
return mathOperation;
}
public static <T1 extends Number, T2 extends Number> T1 resultOf(char operator, T1 left, T2 right) {
return RegularMathOperation.valueOf(operator).calculate(left, right);
}
public static void main(String[] args) {
Long left = 3L;
Double right = 2D;
System.out.println(RegularMathOperation.resultOf('+', left, right));
System.out.println(RegularMathOperation.resultOf('-', left, right));
System.out.println(RegularMathOperation.valueOf('*').calculate(left, right));
System.out.println(RegularMathOperation.valueOf('*').calculate( left, right));
System.out.println(RegularMathOperation.DIVIDE.calculate(left, right));
System.out.println(RegularMathOperation.DIVIDE.calculate(right,left));
}
}