类中的构造方法不能应用于给定的类型； 找到：java.lang.String，char原因：实际参数和形式参数列表的长度不同

Question

因此，我正在使用的计算器应用程序代码不断给我这个错误 。

错误：（18，36）java：类CalculationEngine中的构造函数CalculationEngine不能应用于给定类型； 必需：找到的java.lang.String：java.lang.String，char原因：实际参数和形式参数列表的长度不同

这是带有错误的ConsoleApp类

public class CalculatorConsoleApp {



    private static final String EXIT_OPERATOR = "c";

      public static void main(String[] args) {
        System.out.printf("Welcome to the %s!\nPlease enter a one-operator expression to evaluate, or `%s` to exit.\n", CalculatorConstants.APP_NAME, EXIT_OPERATOR);

        Scanner scanner = new Scanner(System.in);
        String input;

        // main loop
        while(!(input = (scanner.nextLine())).equalsIgnoreCase(EXIT_OPERATOR)) {
          char lastOperation = CalculatorConstants.NO_OPERATOR;

          try {
            CalculationEngine engine = new CalculationEngine(input,lastOperation);

            System.out.printf("%.2f\n", engine.result);
          } catch(Exception e) {
            e.printStackTrace();
            System.out.println(CalculatorConstants.BAD_NUMBER_MESSAGE);
          }

        }

        System.out.println("Good bye!");
      }

    }

引擎对应于ConsoleApp类

    public class CalculationEngine {

      public double result;

      public CalculationEngine(String input) {
        result = this.evaluateExpression(input);
      }


      private double evaluateExpression(String input) {
        char[] tokens = input.toCharArray();

        Stack<Double> values = new Stack<>();
        Stack<Character> operations = new Stack<>();

        for(int i = 0; i < tokens.length; i++) {
          char token = tokens[i];

          // skip whitespace
          if(token == ' ')
            continue;

          if((token >= '0' && token <= '9') || token == CalculatorConstants.DECIMAL || (token == CalculatorConstants.SUBTRACTION_OPERATOR && ((i > 0 && isOperator(tokens[i-1]) || (i == 0))))) {
            StringBuffer buffer = new StringBuffer();

            while(i < tokens.length && ((tokens[i] >= '0' && tokens[i] <= '9') || tokens[i] == '.' || (token == CalculatorConstants.SUBTRACTION_OPERATOR && ((i > 0 && isOperator(tokens[i-1]) || (i == 0)))))) {
              buffer.append(tokens[i++]);
            }

            if(buffer.toString().equals(".")) {
              values.push(0.0);
            } else {
              values.push(Double.parseDouble(buffer.toString()));
            }

            i--;
          } else if(
                  token == CalculatorConstants.ADDITION_OPERATOR ||
                          token == CalculatorConstants.SUBTRACTION_OPERATOR ||
                          token == CalculatorConstants.MULTIPLICATION_OPERATOR ||
                          token == CalculatorConstants.DIVISION_OPERATOR) {

            while(!operations.empty() && hasPrecedence(tokens[i], operations.peek()))
              values.push(applyOperation(operations.pop(), values.pop(), values.pop()));

            operations.push(tokens[i]);
          }
        }

        while(!operations.empty())
          values.push(applyOperation(operations.pop(), values.pop(), values.pop()));

        if(input.trim().length() == 1 && operations.size() == 1) {
          return 0.0;
        } else {
          return values.pop();
        }
      }

      private boolean isOperator(char operator) {
        return (operator == CalculatorConstants.ADDITION_OPERATOR) || (operator == CalculatorConstants.SUBTRACTION_OPERATOR) || (operator == CalculatorConstants.MULTIPLICATION_OPERATOR) || (operator == CalculatorConstants.DIVISION_OPERATOR);
      }

      private double applyOperation(char operation, double num2, double num1) {
        if (operation == CalculatorConstants.ADDITION_OPERATOR) {
          return num1 + num2;
        } else if (operation == CalculatorConstants.SUBTRACTION_OPERATOR) {
          return num1 - num2;
        } else if (operation == CalculatorConstants.MULTIPLICATION_OPERATOR) {
          return num1 * num2;
        } else if (operation == CalculatorConstants.DIVISION_OPERATOR) {
          return num1 / num2;
        }

        return 0;
      }

        private boolean hasPrecedence(char op1, char op2) {
        return (op1 == CalculatorConstants.ADDITION_OPERATOR || op2 == 
        CalculatorConstants.SUBTRACTION_OPERATOR) && (op1 == 
        CalculatorConstants.MULTIPLICATION_OPERATOR || op2 == 
        CalculatorConstants.DIVISION_OPERATOR);
      }

}

Answer 1

您的类CalculationEngine没有构造函数CalculationEngine（String，char）。 它仅具有CalculationEngine（String）您的语句：

CalculationEngine engine = new CalculationEngine(input,lastOperation);

您当前的构造函数：

public CalculationEngine(String input) {
    result = this.evaluateExpression(input);
}