将四种方法合并为一个

如何用一个更新变量“str”来匹配运算符“+ -/*”和“ADD，SUB，DIV或MULT”的方法？当它通过case语句运行时，我试图弄清楚如何让case语句识别通过扫描仪输入选择的操作符，并将其与其各自的描述符字符串进行匹配。将四种方法合并为一个

import java.util.Scanner; 

    public class Testor4 { 
    public static void main(String[] args) { 
    String s1 = getInput("Enter a number: "); 
    String s2 = getInput("Enter second number"); 
    String op = getInput("Enter operator: + -/* "); 
    double result = 0; 
    String str = " You chose to"; 
    try{ 
     switch(op){ 
     case "+": str += getOpNameAdd(str); result = getSum(s1,s2); break; 
     case "-": str += getOpNameSub(str); result = getSub(s1,s2); break; 
     case "/": str += getOpNameDiv(str); result = getDiv(s1,s2); break; 
     case "*": str += getOpNameMult(str); result = getMult(s1,s2); break; 
     default: System.out.println("not an operator."); return; 
     } 
    }catch(Exception e){ 
     System.out.println(e.getMessage()); 
    } 
    System.out.printf("%s%s%.2f","Result is: ",str,result); 
    } 
    private static double getSum(String s1, String s2){ 
    double d1 = Double.parseDouble(s1); 
    double d2 = Double.parseDouble(s2); 
    return d1 + d2; 
    } 
    private static double getSub(String s1, String s2){ 
    double d1 = Double.parseDouble(s1); 
    double d2 = Double.parseDouble(s2); 
    return d1 - d2; 
    } 
    private static double getDiv(String s1, String s2){ 
    double d1 = Double.parseDouble(s1); 
    double d2 = Double.parseDouble(s2); 
    return d1/d2; 
    } 
    private static double getMult(String s1, String s2){ 
    double d1 = Double.parseDouble(s1); 
    double d2 = Double.parseDouble(s2); 
    return d1 * d2; 
    } 
    public static String getOpNameAdd(String str){ 
    return str = " ADD!"; 
    } 
    public static String getOpNameSub(String str){ 
    return str = " Subtract!"; 
    } 
    public static String getOpNameDiv(String str){ 
    return str = " Divide!"; 
    } 
    public static String getOpNameMult(String str){ 
    return str = " Multiply!"; 
    } 
    public static String getInput(String prompt){ 
    System.out.println(prompt); 
    Scanner sc = new Scanner(System.in); 
    return sc.nextLine(); 
    } 
    }

来源

2016-01-12 twit ter

你看到了什么，当你通过一个调试器运行你的代码？ – shoover

什么？它工作正常。没有问题需要调试。你是否尝试过运行并失败？问题是如何组合底部的四个方法来完成一件特定的事情，并返回单词“ADD

不，我没有，但你说：“我正在设法弄清楚如何让案件陈述识别操作员”，这听起来就像你在那部分有问题。 – shoover

public class Testor4 { 
public static void main(String[] args) { 
    String s1 = getInput("Enter a number: "); 
    String s2 = getInput("Enter second number"); 
    String op = getInput("Enter operator: + -/* "); 
    double result = 0; 
    String str = " You chose to"; 
    try { 
     switch (op) { 
     case "+": 
      str += getOpName(op); 
      result = getSum(s1, s2); 
      break; 
     case "-": 
      str += getOpName(op); 
      result = getSub(s1, s2); 
      break; 
     case "/": 
      str += getOpName(op); 
      result = getDiv(s1, s2); 
      break; 
     case "*": 
      str += getOpName(op); 
      result = getMult(s1, s2); 
      break; 
     default: 
      System.out.println("not an operator."); 
      return; 
     } 
    } catch (Exception e) { 
     System.out.println(e.getMessage()); 
    } 
    System.out.printf("%s%s%.2f", "Result is: ", str, result); 
} 

private static double getSum(String s1, String s2) { 
    double d1 = Double.parseDouble(s1); 
    double d2 = Double.parseDouble(s2); 
    return d1 + d2; 
} 

private static double getSub(String s1, String s2) { 
    double d1 = Double.parseDouble(s1); 
    double d2 = Double.parseDouble(s2); 
    return d1 - d2; 
} 

private static double getDiv(String s1, String s2) { 
    double d1 = Double.parseDouble(s1); 
    double d2 = Double.parseDouble(s2); 
    return d1/d2; 
} 

private static double getMult(String s1, String s2) { 
    double d1 = Double.parseDouble(s1); 
    double d2 = Double.parseDouble(s2); 
    return d1 * d2; 
} 

public static String getOpName(String op) { 
    String opName = "not an operator."; 
    switch (op) { 
    case "+": 
     opName = " ADD!"; 
     break; 
    case "-": 
     opName = " Subtract!"; 
     break; 
    case "/": 
     opName = " Divide!"; 
     break; 
    case "*": 
     opName = " Multiply!"; 
     break; 
    } 
    return opName; 
} 

public static String getInput(String prompt) { 
    System.out.println(prompt); 
    Scanner sc = new Scanner(System.in); 
    return sc.nextLine(); 
}

}

来源

2016-01-12 01:55:34

为什么不这样做？

try{ 
    switch(op){ 
    case "+": str += " ADD!"; result = getSum(s1,s2); break; 
    case "-": str += " Subtract!"; result = getSub(s1,s2); break; 
    case "/": str += " Divide!"; result = getDiv(s1,s2); break; 
    case "*": str += " Multiply!"; result = getMult(s1,s2); break; 
    default: System.out.println("not an operator."); return; 
    } 
}catch(Exception e){ 
    System.out.println(e.getMessage()); 
}

如果字符串将在其他地方重复使用，你也可以做一个字符串常量：

public static final String OpNameAdd = " ADD!";

来源

2016-01-12 01:44:34 jack3694078

有了一个方法，更简单，你可以阅读一个输入并处理一个字符串“前缀+后缀”，其中+表示所有可能的操作，类似 static int indexOfAny(String str, char[] searchChars) 获取子字符串prefi x，后缀，然后根据操作员切换（op）。

来源

2016-01-12 01:58:19 Smer5

我会先写一个enum（如Operation这里）来封装行为，名称和符号。类似的，

enum Operation { 
    ADD("+", "Addition"), SUBTRACT("-", "Subtraction"), // 
    MULTIPLY("*", "Multiplication"), DIVIDE("/", "Division"); 
    String operSymbol; 
    String operName; 

    Operation(String operSymbol, String operName) { 
     this.operSymbol = operSymbol; 
     this.operName = operName; 
    } 

    String getName() { 
     return operName; 
    } 

    String getSymbol() { 
     return operSymbol; 
    } 

    public static Operation fromString(String str) { 
     if (str != null) { 
      str = str.trim(); 
      if (!str.isEmpty()) { 
       for (Operation o : Operation.values()) { 
        if (str.equals(o.getSymbol())) { 
         return o; 
        } 
       } 
      } 
     } 
     return null; 
    } 

    public double performOperation(String s1, String s2) { 
     Double d1 = Double.parseDouble(s1); 
     Double d2 = Double.parseDouble(s2); 
     switch (this) { 
     case SUBTRACT: 
      return d1 - d2; 
     case MULTIPLY: 
      return d1 * d2; 
     case DIVIDE: 
      return d1/d2; 
     case ADD: 
     default: 
      return d1 + d2; 
     } 
    } 
}

请不要为每个提示打开一个新的扫描仪。我会把它传递给方法。像，

public static String getInput(Scanner sc, String prompt) { 
    System.out.println(prompt); 
    return sc.nextLine(); 
}

那么你main方法很简单，你需要的输入和调用上的Operation像

public static void main(String[] args) { 
    Scanner sc = new Scanner(System.in); 
    String s1 = getInput(sc, "Enter a number: "); 
    String s2 = getInput(sc, "Enter second number"); 
    String op = getInput(sc, "Enter operator: + -/* "); 
    try { 
     Operation oper = Operation.fromString(op); 
     if (op != null) { 
      double result = oper.performOperation(s1, s2); 
      System.out.printf("%s %s %s = %.2f (%s)%n", s1, // 
        oper.getSymbol(), s2, result, oper.getName()); 
     } else { 
      System.out.println("not an operator."); 
      return; 
     } 
    } catch (Exception e) { 
     System.out.println(e.getMessage()); 
    } 
}

来源

2016-01-12 02:09:23

这是我怎么会做它的方法。启动与接口：

加法

package cruft.arithmetic; 

/** 
* BinaryOperation is the interface for binary arithmetic operations +, -, *,/
* Created by Michael 
* Creation date 1/11/2016. 
* @link https://stackoverflow.com/questions/34734228/combining-four-methods-into-one 
*/ 
public interface BinaryOperation<T> { 

    T execute(T argument1, T argument2); 
}

实现：

package cruft.arithmetic; 

/** 
* Addition implementation for BinaryOperation 
* Created by Michael 
* Creation date 1/11/2016. 
* @link https://stackoverflow.com/questions/34734228/combining-four-methods-into-one 
*/ 
public class AddOperation implements BinaryOperation<Double> { 

    @Override 
    public Double execute(Double argument1, Double argument2) { 
     return argument1 + argument2; 
    } 
}

这里的测试仪：

package cruft.arithmetic; 

/** 
* I think the class name is misspelled: "Tester". 
* Created by Michael 
* Creation date 1/11/2016. 
* @link https://stackoverflow.com/questions/34734228/combining-four-methods-into-one 
*/ 

import java.util.HashMap; 
import java.util.Map; 
import java.util.Scanner; 

public class Tester { 

    private static final Map<String, BinaryOperation<Double>> OPERATIONS = new HashMap<String, BinaryOperation<Double>>() {{ 
     put("+", new AddOperation()); 
    }}; 
    private static Scanner sc = new Scanner(System.in); 


    public static void main(String[] args) { 
     BinaryOperation<Double> operator = null; 
     do { 
      try { 
       String arg1 = getInput("1st argument : "); 
       String arg2 = getInput("2nd argument : "); 
       String oper = getInput("operator + - * /: "); 
       operator = OPERATIONS.get(oper); 
       if (operator != null) { 
        double x = Double.parseDouble(arg1); 
        double y = Double.parseDouble(arg2); 
        double z = operator.execute(x, y); 
        System.out.println(String.format("%-10.4f %s %-10.4f = %-10.4f", x, oper, y, z)); 
       } else { 
        System.out.println(String.format("No such operator '%s'", oper)); 
       } 
      } catch (NumberFormatException e) { 
       e.printStackTrace(); 
      } 
     } while (operator != null); 
    } 

    public static String getInput(String prompt) { 
     System.out.print(prompt); 
     return sc.nextLine(); 
    } 
}

来源

2016-01-12 02:09:39 duffymo

将四种方法合并为一个

回答

相关问题