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

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

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

下面是带有错误的控制台App类

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

}

公共类计算引擎{
公众的双重结果；
公共计算引擎（字符串输入）{
结果=此.evaluateExpression（输入）；
}
专用双evaluateExpression（字符串输入）{
char[]tokens=input.toCharArray（）；
堆栈值=新堆栈（）；
堆栈操作=新堆栈（）；
for（int i=0；i='0'&&token 0&&isOperator（令牌[i-1]）| |（i==0щ）；）{
StringBuffer=新的StringBuffer（）；
而（i='0'&&tokens[i]0&&isOperator（tokens[i-1]）| |（i==0Ю）；）{
append（令牌[i++]）；
}
if（buffer.toString（）.equals（“.”）{
值。推送（0.0）；
}否则{
value.push（Double.parseDouble（buffer.toString（））；
}
我--；
}否则如果(
令牌==计算器constants.ADDITION\u运算符||
token==CalculatorConstants.减法_运算符||
token==CalculatorConstants.MULTIPLICATION\u运算符||
令牌==CalculatorConstants.DIVISION_运算符）{
而（！operations.empty（）&&hasPreference（令牌[i]，operations.peek（））
push（applyOperation（operations.pop（）、values.pop（）、values.pop（））；
推送（代币[i]）；
}
}
而（！operations.empty（））
push（applyOperation（operations.pop（）、values.pop（）、values.pop（））；
if（input.trim（）.length（）=1&&operations.size（）=1）{
返回0.0；
}否则{
返回值。pop（）；
}
}
专用布尔等运算符（字符运算符）{
返回（运算符==CalculatorConstants.ADDITION|||（运算符==CalculatorConstants.减法||（运算符==CalculatorConstants.乘法|运算符）|（运算符==CalculatorConstants.DIVISION|运算符）；
}
专用双应用操作（字符操作、双num2、双num1）{
if（operation==CalculatorConstants.ADDITION\u运算符）{
返回num1+num2；
}else if（运算==计算器常数.减法运算）{
返回num1-num2；
}else if（运算==计算器常数.乘法\u运算符）{
返回num1*num2；
}else if（运算==计算器常数除法运算器）{
返回num1/num2；
}
返回0；
}
私有布尔值优先（char op1，char op2）{
return（op1==CalculatorConstants.ADDITION|u运算符| | op2==
计算器常数（减法算子）&&（op1==
CalculatorConstants.multiply|u运算符| | op2==
计算器常数（除法运算器）；
}
}

您的类CalculationEngine没有构造函数CalculationEngine（字符串，字符）。它只有CalculationEngine（字符串） 你的声明：

CalculationEngine engine = new CalculationEngine(input,lastOperation);

您当前的构造函数：

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

---

CalculationEngine engine=新的CalculationEngine（输入，上次操作）；应为CalculationEngine engine=新CalculationEngine（输入）；