Java 方法 returns 双 |整数

Question

我需要一个接受字符串数字作为参数的方法，return如果有余数则为 double，如果为十进制则为 int。

我写了这样的代码：

 private double convertToNumber(String number) {
    double d = Double.parseDouble(number);
    if (d % 1.0 == 0) {
        return Integer.parseInt(number);
    } else {
        return d;
    }
}

但由于此方法的签名是双倍的，因此 return 在任何情况下都是双倍的。

请给我一些提示。

Answer 1

您的函数的签名只能是一 (1) 种类型，int 或 double，但不能同时是这两种类型。如果数字有小数部分 (true) 或 (false) 没有小数部分，您可以尝试将函数重新设计为 return 布尔值。

请记住整数不能包含小数部分，所以像

这样的运算

int a = 3 / 2;

会将 a 设置为 1 而不是 1.5

Answer 2

您不能有两种不同的 return 类型，也不能更改 Java 中方法的 return 类型。您可以使用不同 return 类型的不同方法签名，但随后您调用了两个单独的方法，这违背了您要完成的目的。

在你的情况下你能做的最好的事情是创建一个对象，你将传递给函数，你将在其中设置一个标志，告诉你要读取哪个值。您还将填充 int 值或 double 值。

当方法 return 的布尔标志将告诉客户端代码哪个值是要使用的正确值。

class MyConverter {
    public String number;
    public boolean isInt;
    public double doubleVal;
    public int intVal;
}

 private void convertToNumber(MyConverter conv) {
    double d = Double.parseDouble(conv.number);
    if (d % 1.0 == 0) {
        conv.isInt = true;
        conv.intVal = Integer.parseInt(number);
    } else {
        conv.doubleVal = d;
    }
}

Answer 3

您最好的办法是创建一个基础 class 和两个 class 扩展第一个 class.

IntegerClass 具有整数属性，FloatClass 具有浮点属性。然后在方法中根据字符串设置 IntegerClass 或 FloatClass，但 returns BaseClass。

然后使用 instanceOf 确定返回哪个。

Answer 4

为什么不return Number 来自你的方法：

private Number convertToNumber(String number) {
    double d = Double.parseDouble(number);
    if (d % 1.0 == 0) {
        return Integer.parseInt(number);
    } else {
        return d;
    }
}

Integer 和 Double 都是 Number 的子类。

Answer 5

我不确定我是否理解 returning double 或 int 的意图，因为我知道单个函数不可能 return不同的数据类型。

我想我从您的示例代码中了解到，如果一个字符串（例如，“123.0”与尾随零的数量无关）从 [=] 传递到 CalculatorEngine 20=] 您提供，您希望它被视为 int 并且数学运算符使用 int 和 double 执行计算（因为 currentTotal 是 double).

现在，在完成所有计算后，如果 currentTotal 以 .0 结尾，那么您可能希望将其也视为 int 并删除该点，否则保留该点。

如果我理解正确，我认为 CalculatorEngine 可能是这样的：

public static void main(String[] args) {
    CalculatorEngine ce = new CalculatorEngine();
    ce.equal("1.01");
    ce.add("12");
    System.out.println(ce.getTotalString());
    ce.subtract("0.01");
    System.out.println(ce.getTotalString());
    ce.multiply("100.00000");
    System.out.println(ce.getTotalString());
    ce.divide("123");
    System.out.println(ce.getTotalString());
}

public static class CalculatorEngine {
    private enum Operator {
        ADD, SUBTRACT, MULTIPLY, DIVIDE
    }

    private double currentTotal;

    public CalculatorEngine() {
        currentTotal = 0;
    }

    public String getTotalString() {
        return currentTotal % 1.0 == 0 
                ? Integer.toString((int)currentTotal) 
                : String.valueOf(currentTotal);
    }

    public void equal(String number) {
        currentTotal = Double.parseDouble(number);
    }

    public void add(String number) {
        convertToDouble(number, Operator.ADD);
    }

    public void subtract(String number) {
        convertToDouble(number, Operator.SUBTRACT);
    }

    public void multiply(String number) {
        convertToDouble(number, Operator.MULTIPLY);
    }

    public void divide(String number) {
        convertToDouble(number, Operator.DIVIDE);
    }

    public void changeSign(String number) {
        Double d = Double.parseDouble(number);
        currentTotal = d * (-1);
    }

    public void dot(String number) {
        // todo
    }

    private boolean isDouble(String number) {
        double d = Double.parseDouble(number);
        return d % 1.0 != 0;
    }

    private void convertToDouble(String number, Operator operator) {
        double dblNumber = Double.parseDouble(number);
        switch (operator) {
            case ADD:
                add(dblNumber);
                break;
            case SUBTRACT:
                subtract(dblNumber);
                break;
            case MULTIPLY:
                multiply(dblNumber);
                break;
            case DIVIDE:
                divide(dblNumber);
                break;
            default:
                throw new AssertionError(operator.name());   
        }
    }

    private void add(double number) {
        currentTotal += number % 1.0 == 0 ? (int)number : number;
    }

    private void subtract(double number) {
        currentTotal -= number % 1.0 == 0 ? (int)number : number;
    }

    private void multiply(double number) {
        currentTotal *= number % 1.0 == 0 ? (int)number : number;
    }

    private void divide(double number) {
        currentTotal /= number % 1.0 == 0 ? (int)number : number;
    }
}

结果：

13.01
13
1300
10.56910569105691

Java 方法 returns 双 |整数

Java method returns double | int

java

int

double

primitive