Java 方法返回双精度 |整数答案

【问题标题】：Java method returns double | intJava 方法返回双精度 |整数
【发布时间】：2015-06-03 22:31:27
【问题描述】：

我需要一个接受字符串数字作为参数的方法，如果有余数则返回双精度，如果是十进制则返回整数。

我写了这样的代码：

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

但由于此方法的签名是双倍的，因此无论如何它都会返回双倍。

请给我一些提示。

【问题讨论】：

如何调用这个函数？
私人双 currentTotal; public void divide(String number) { currentTotal /= convertToNumber(number); }
这只是一个例子，我还会在其他一些操作中使用它。如果这个数字是整数，没有点，我需要一个 int 的问题。
@DimaSan 其他操作怎么称呼它？
同理，请看link

标签： java int double primitive

【解决方案1】：

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

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

这样的操作

int a = 3 / 2;

将a设置为1而不是1.5

【讨论】：

当然，这是真的。谢谢！

【解决方案2】：

为什么不从您的方法中返回 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 的子类。

【讨论】：

因为 Number 是一个抽象类
这是怎么回事？
他会遇到和以前一样的问题。函数返回后他有 int 还是 double ？两者都没有，他有一个号码。
我知道他的问题在于隐式类型转换为double，即使该方法返回int（因为签名具有double作为返回类型）。使用Number 作为返回值，您可以在客户端代码中检查instanceof 以区分Integers 和Doubles。
这意味着如果他必须一遍又一遍地调用这个函数，他的代码中就会有很多 instanceof 检查。写这个函数的点很可能符合 DRY 原则。如果他必须进行 instanceof 检查，他最好摆脱这个函数并在不调用该函数的情况下进行解析。

【解决方案3】：

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

我想我从您的示例代码中了解到，如果从您提供的link 将一个字符串（例如，“123.0”与多少尾随零无关）传递到CalculatorEngine，您希望它被视为 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

【讨论】：

非常感谢！现在一切都按我的预期工作了！我喜欢你在这里使用enum 的想法。我真的很感谢你的建议。可惜我还是不能投票。
@DimaSan 不客气。如果您发现此答案有用，请单击复选标记以便您的问题得到解决并考虑投票:-)
一个方法完全有可能返回不同的类型——只要这些类型存在共同的超类型（class 或interface）。

【解决方案4】：

在 Java 中不能有两种不同的返回类型或更改方法的返回类型。你可以有不同的方法签名和不同的返回类型，但是你调用了两个单独的方法，这违背了你想要完成的目的。

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

当方法返回布尔标志时，将告诉客户端代码哪个值是正确的消费。

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

【讨论】：

private void convertToNumber 既不能返回 int 也不能返回 double。
@DimaSan - 糟糕，抱歉。很着急。应该没有返回值。只是对变量的赋值。请查看我的编辑。

【解决方案5】：

你能做的最好的就是创建一个基类和两个扩展第一个类的类。

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

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

【讨论】：