用JAVA制作存钱罐程序[关闭]

Question

我已经离开 Java 一段时间了，我仍然在努力回忆和学习很多东西。我有一个当前的项目，它是一个存钱罐，您可以向其中添加硬币并可以获得各种输出。我目前的任务是 5 种方法以及构造函数的辅助方法。我知道我想做什么，但无法通过代码来完成它。 我想使用辅助方法来获取其他两个构造函数的数量，但我无法理解它，我只能浏览我的书这么久。任何输入表示赞赏。 每种方法的描述如下：

附：我的代码可能不正确。

publicChangeJar() 将所有实例变量设置为零的默认构造函数

publicChangeJar(int Quarters, int dimes, int Nines, int pennies) 一个构造函数，用于初始化实例变量，并将提供的值转换为硬币、一角硬币、镍币和便士。

public ChangeJar(final double amount) 初始化实例变量的构造函数，将提供的值转换为硬币、硬币、镍币和便士。例如，如果金额是 1.34，那么您将有 5 个硬币、1 个镍、4 个便士

public ChangeJar(final String amount)一个构造函数，它接受一个字符串作为参数，将提供的值转换为适当数量的四分之一、一角硬币、五分钱和一分钱。例如，如果金额为“1.34”，那么您将有 5 个硬币、1 个镍、4 个便士。

public ChangeJar(final ChangeJar other)一个构造函数，用另一个对象初始化“this”ChangeJar对象的实例变量。

public class ChangeJar {
private int pennies;
private int nickels;
private int dimes;
private int quarters;

static boolean globalLock = false;

public ChangeJar(){
    this(0,0,0,0);
}

public ChangeJar(int pennies, int nickels, int dimes, int quarters)throws IllegalArgumentException {
if (pennies < 0 || nickels < 0 || dimes < 0 || quarters < 0)
    throw new IllegalArgumentException("You cannot have negative coins in the jar");
else this.pennies = this.pennies + pennies; 
    this.nickels = this.nickels + nickels;
    this.dimes = this.dimes + dimes; 
    this.quarters = this.quarters + quarters;

}

public ChangeJar(double amount){

}
public ChangeJar(final String amount){

}
private double amountHelper(double amount){
    amount = pennies*.01 + nickels*.05 + dimes*.10 + quarters*0.25;
    return amount;
}

public ChangeJar(final ChangeJar other){

}

}

编辑：我的问题是如何编写辅助方法以在两个构造函数中工作。

Answer 1

构造函数ChangeJar(double)

对于带有金额的构造函数，您希望使用最大季度数，然后是最大便士数，依此类推。

假设我有 2.87 美元。

• 首先，我将学习 11 个季度。我们还剩 0.12 美元。
• 那么，我会拿一毛钱。我们还剩 0.02 美元。
• 那么，我会拿0镍。我们还剩 0.02 美元。
• 然后，我会拿 2 便士。我们完成了。

如何实现？假设金额为2.87。

public ChangeJar(double amount) {
    // How many quarters?
    int quarters = (int) (amount / .25); // The division gives 9.48 and we cast the result to int so we get 9
    amount = amount - quarters * .25;
    System.out.println(quarters + " quarters. Remains: " + amount);

    // How many dimes?
    int dimes = (int) (amount / .10);
    amount = amount - dimes * .10;
    System.out.println(dimes + " dimes. Remains: " + amount);

    // How many nickels?
    int nickels = (int) (amount / .05);
    amount = amount - nickels * .05;
    System.out.println(nickels + " nickels. Remains: " + amount);

    // How many pennies?
    int pennies = (int) (amount / .01);
    amount = amount - pennies * .01;
    System.out.println(pennies + " pennies. Remains: " + amount);

    // Prints:
    // 11 quarters. Remains: 0.1200000000000001
    // 1 dimes. Remains: 0.0200000000000001
    // 0 nickels. Remains: 0.0200000000000001
    // 2 pennies. Remains: 1.0061396160665481E-16

    // Now we just set this in our properties:
    this.quarters = quartes;
    this.dimes = dimes;
    this.nickels = nickels;
    this.pennies = pennies;
}

如您所见，问题在于余数是奇怪的值。构造函数可以工作，但它并不是很酷。为什么？因为Java approximates the doubles。

我建议与ints 合作。例如，您可以将单位从 $ 更改为 $/100。我们使用整数值的相同示例（输入不是2.87，而是287）：

public ChangeJar(int amount) {
    // How many quarters?
    int quarters = amount / 25;
    amount = amount - quarters * 25;
    System.out.println(quarters + " quarters. Remains: " + amount);

    // How many dimes?
    int dimes = amount / 10;
    amount = amount - dimes * 10;
    System.out.println(dimes + " dimes. Remains: " + amount);

    // How many nickels?
    int nickels = amount / 5;
    amount = amount - nickels * 5;
    System.out.println(nickels + " nickels. Remains: " + amount);

    // How many pennies?
    int pennies = amount;
    amount = amount - pennies;
    System.out.println(pennies + " pennies. Remains: " + amount);

    // Prints:
    // 11 quarters. Remains: 12
    // 1 dimes. Remains: 2
    // 0 nickels. Remains: 2
    // 2 pennies. Remains: 0

    // Now we just set this in our properties:
    this.quarters = quartes;
    this.dimes = dimes;
    this.nickels = nickels;
    this.pennies = pennies;
}

那就更好了！

但是我的代码中有很多复制/粘贴...
我们怎样才能让它变得更好？

我们可以看到，对于每个硬币，我得到硬币的数量，然后从数量中减去值。

int amount = 287;

int[] values = new int[]{25, 20, 5, 1}; // The values of my coins
int[] results = new int[values.length];

for (int i = 0; i < values.length; i++) {
    int valueOfCoin = values[i];
    int numberOfCoins = amount / valueOfCoin; // Division gives the integer part of the result
    results[i] = numberOfCoins;

    amount = amount % valueOfCoin; // Modulo gives the remainder part of the result
    // Or you could simply write: amount %= valueOfCoin;
}

System.out.println("RESULTS=" + Arrays.toString(results));

// Prints:
// RESULTS=[9, 1, 0, 2]

构造函数ChangeJar(String)

我认为 String 是一个数量，所以我们只需将 String 转换为 Double 并调用另一个构造函数 (ChangeJar(double))。

public ChangeJar(String amount) {
    this(Double.valueOf(amount)); // Double.valueOf() will try to convert the String => Double
}

构造函数ChangeJar(ChangeJar)

这个想法只是复制其他ChangeJar的值：

public ChangeJar(ChangeJar other) {
    this(other.quarters, other.dimes, other.nickels, other.pennies);
}