java - JAVA制作存钱 jar 程序

Question

我已经离开 Java 一段时间了，但仍在努力记忆和学习很多东西。我当前有一个项目，它是一个存钱 jar ，您可以在其中添加硬币并获得各种输出。我目前的任务是 5 个方法以及构造函数的辅助方法。我知道我想做什么，但无法思考代码来完成它。 我想使用辅助方法来获取其他两个构造函数的金额，但我无法理解它，我只能看我的书这么久。任何意见都会受到赞赏。 各个方法的说明如下:

附注我所拥有的代码可能不正确。

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

publicChangeJar(intquarters, int dimes, int Nicks, int pennys) 一个构造函数，它使用转换为 25 美分、10 美分、5 美分和便士的提供值来初始化实例变量。

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

public ChangeJar(final String amount) 一个构造函数，它接受字符串作为参数，并将提供的值转换为适当数量的 25 美分、10 美分、5 美分和 10 分硬币。例如，如果金额为“1.34”，那么您将有 5 个 25 美分硬币、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)

对于具有金额的构造函数，您需要使用最大数量的 25 美分硬币，然后使用最大数量的便士，依此类推。

假设我有 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 .

我建议与 int 合作s。例如，您可以将单位从 $ 更改为至$/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;
}

这样已经好多了!

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

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

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