Question

我需要一个接受String number作为参数的方法，如果它有一个余数则返回double，如果是十进制则返回int。

我写了这样的代码：

proc sort data=have;
by order_id item;
run;

data temp;
  set have;
  by order_id;
  retain comb;
  length comb $4;
  comb=cats(comb,item);
  if last.order_id then do;
     output;
     call missing(comb);
  end;
run;

proc freq data=temp;
   table comb/norow nopercent nocol nocum;
run;

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

请给我一些提示。

Answer 1

你的函数的签名只能是一（1）种类型，int或double，但不能两者都有。您可以尝试重新设计函数以返回布尔值（如果数字具有小数部分（true）或（false）它不会。

请记住，整数不能包含小数部分，因此操作如

int a = 3 / 2;

会将a设置为1而不是1.5

Answer 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的子类。

Answer 3

您无法使用两种不同的返回类型或更改Java中的方法返回类型。您可以使用不同的返回类型使用不同的方法签名，但之后您将调用两个单独的方法，这些方法会破坏您尝试完成的目的。

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

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

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 4

我不确定我是否理解返回double或int的意图，因为他们知道单个函数无法返回不同的数据类型。< / p>

我认为我从您的示例代码中理解的是，如果一个字符串（例如，＆＃34; 123.0＆＃34;并不是多少尾随零）被传递到{{1} }，从您提供的link，您希望将其视为CalculatorEngine，并让数学运算符使用int和int执行计算（因为currentTotal是double）。

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

如果我正确理解了这一点，我认为double可能是这样的：

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

Answer 5

您可以做的最好的事情是创建一个基类和两个扩展第一类的类。

IntegerClass有一个整数属性，FloatClass有一个浮点数atrribute。然后在方法内部根据String设置IntegerClass或FloatClass，但返回BaseClass。

然后使用instanceOf确定返回的内容。

Java方法返回double | INT

5 个答案: