Question

我有一个将双精度整数部分和小数部分分开的类。从该类创建对象时，我想分别使用它们。

我尝试将此作为函数，但是一个函数只有1个返回值，或者我可以将其作为一个返回数组，我知道这一点。我只是想知道我是否可以更优雅地完成它

该类的构造函数

    public wholeAndFraction(double db){
    String st=""+db;
    st=st.replace(".", "-");
    String[] str=st.split("-");
    int whole=Integer.parseInt(str[0]);
    int fraction=Integer.parseInt(str[1]);}

当我生成一个对象时，我想邀请全部或小数部分，例如

    wholeAndFraction first=new wholeAndFraction(5.32);
    System.out.println(first.whole);

或带有吸气剂，但这也会给我一个错误

Answer 1

您需要一个课程：

class WholeAndFraction {
    long whole;    // or String I do not know
    long fraction; // or String I do not know

    // constructor, getters
}

并传递此类的实例。

无法从方法返回2个值。您可以返回一个List或其中包含2个值的数组，但是无论是否优雅，它都是有争议的。

Answer 2

构造函数中的这两行声明了 local 变量：

int whole=Integer.parseInt(str[0]);
int fraction=Integer.parseInt(str[1]);

这些仅存在于构造函数内部。

您需要将whole和fraction声明为类成员（如另一个答案所示）。在构造函数中，您将删除指示变量声明的数据类型：

whole=Integer.parseInt(str[0]);
fraction=Integer.parseInt(str[1]);

Answer 3

当分配需要是实例变量（可用于getter方法）时，构造函数将分配给方法变量（在构造函数完成后消失）。

尝试更改：

public wholeAndFraction(double db) {
    String st= "" + db;
    st=st.replace(".", "-");
    String[] str=st.split("-");
    int whole=Integer.parseInt(str[0]);
    int fraction=Integer.parseInt(str[1]);
}

收件人

public class WholeAndFraction {
    private final int whole;
    public int getWhole() { return whole; }

    private final int fraction;
    public int getFraction() { return fraction; }

    public WholeAndFraction(double db){
        String st=""+db;
        st=st.replace(".", "-");
        String[] str=st.split("-");
        this.whole=Integer.parseInt(str[0]);
        this.fraction=Integer.parseInt(str[1]);
    }
}

我已经在赋值语句中对此实例变量进行了限定，但这是为了清楚起见。

这是主要的首要问题。还有其他问题，例如，如果数字为负，则使用“-”将中断。一种 ”。”如果数字已经是整数，则不会出现。而且，实现的小数部分不会捕获值小数部分的所有详细信息。使用上面的代码，“ 1.02”和“ 1.0002”都具有相同的小数部分。

Answer 4

使用如下所示的类：

class WholeAndFraction {
    int whole;
    int fraction;

    // constructor & getters
}

另外，在单独的注释上，从双精度码中提取整数和小数部分的方法也不是很优雅，也不适合您编写的内容。可以改写为：

public WholeAndFraction extractParts(double db) {
    WholeAndFraction  obj = new WholeAndFraction();
    BigDecimal bigDecimal = new BigDecimal(String.valueOf(db));
    obj.whole = bigDecimal.intValue();
    obj.fraction = Integer.parseInt(bigDecimal.subtract(new BigDecimal(obj.whole)).toPlainString().substring(2));
    return obj;
}

Answer 5

您还可以使用st=st.replace(".", "-");来跳过String[] str=st.split("\\.");

Answer 6

使用这种方法可能会遇到很多问题，但是如果您绝对必须这样做，那么这里是其中一些解决方案，请查看评论以获取更多信息。如果您只需要知道数字是否为负，则可以执行以下操作，但这完全取决于您的用例。使用Integers也是一个坏主意，因为如果double足够大，它将不适合...

public class WholeAndFraction {

    // You have to use String because numbers like this exists:
    // 1123.0001020
    // 141.07 <- this would become an octal number
    // 6,9   6,09  <- these would give you the same value with doubles
    private boolean negative;
    private String whole;
    private String fraction;

    public WholeAndFraction(Double number){
        String numberAsString = String.valueOf(number);
        if (numberAsString.startsWith("-")){
            this.negative = true;
            numberAsString = numberAsString.replaceFirst("-", "");
        }

        // Based on Locale you can have . or , as separator
        String[] splitted = numberAsString.split("[\\.,]");
        this.whole = splitted[0];
        this.fraction = splitted[1];
    }

    // getters, setters, toString etc... or just use Lombok to generate it for you
}

从类中编写一个构造函数，该构造函数返回2个值

6 个答案: