Java Double.max_Value?

Voor mijn toewijzing moet ik een gasmetersysteem maken voor een gasbedrijf om werknemers in staat te stellen nieuwe klantaccounts te creëren en de gegevens zoals naam en eenheidskosten te wijzigen, samen met het nemen van (het deponeren van) geld van hun account.

Ik heb mijn constructeur gemaakt en zelfs toegevoegd in een methode van overbelasting, hoewel ik momenteel een probleem tegenkomt bij het initiëren van een van mijn methoden die ik Deposit heeft genoemd, moet dit geld van de Gebruikersaccount, terwijl andere methoden zoals -recordunits stelt de werknemer toe om een ​​gasmeter te importeren van hoeveel eenheden de klant heeft gebruikt en werkt de balans van die klantenaccount die in wezen is Wat de klant het bedrijf dankt.

Bij het testen van het programma met alleen vooraf ingestelde informatie wanneer u probeert de stortingsmethode te starten, ontvang ik dit

Account.deposit(Double.MAX_VALUE);

Ik ben niet al te zeker wat dit betekent en niet lijken te vinden hoe dan ook voorbij is!

Testgegevens en code hieronder gezien:

public class TestGasAccount 
{
    public static void main (String [] args)
    {
        GasAccount Account = new GasAccount (223,"Havana","TQ",1000);
        Account.getAccNo();
        Account.getName();
        Account.getAddress();
        Account.getUnits();
        Account.getBalance();
        Account.recordUnits(1000);
        Account.getUnits();
        Account.getBalance();
        Account.deposit(Double.MAX_VALUE);
    }
}

pauze

public class GasAccount 
{
    private int intAccNo;
    private String strName;
    private String strAddress; 
    private double dblBalance;
    private double dblUnits;
    protected double dblUnitCost = 0.02; 
     public GasAccount(int intNewAccNo,String strNewName,String strNewAddress,double dblNewUnits)
     {
         intAccNo = intNewAccNo;
         strName = strNewName;
         strAddress = strNewAddress;
         dblUnits = dblNewUnits;
         dblBalance = dblNewUnits * dblUnitCost;
     }
     public GasAccount (int intNewAccNo, String strNewName, String strNewAddress)
     {
         intAccNo = intNewAccNo;
         strName = strNewName;
         strAddress = strNewAddress;
     }
     public double deposit (Double dblDepositAmount)
     {
        dblBalance = dblBalance - dblDepositAmount; 
        return dblBalance;
     }
     public String recordUnits (double dblUnitsUsed)
     {
         double dblTempBalance;
         dblTempBalance = dblUnitsUsed * dblUnitCost;
         dblBalance = dblBalance + dblTempBalance;
         dblUnits = dblUnits + dblUnitsUsed;
         return "Transaction Successful"; 
     }
     public int getAccNo ()
     {
         System.out.println(intAccNo);
         return intAccNo;
     }
     public String getName()
     {
         System.out.println(strName);
         return strName; 
     }
      public String getAddress()
     {
         System.out.println(strAddress);
         return strName; 
     }
     public double getBalance()
     {
         System.out.println("£"+dblBalance);
         return dblBalance; 
     }
     public double getUnitCost()
     {
         return dblUnitCost;
     }
     public double getUnits ()
     {
         System.out.println(dblUnits);
         return dblUnits;
     }
     public void updateUnitCost (double dblNewUnitCost)
     {
         dblUnitCost = dblNewUnitCost;
     }
}

Antwoord 1, Autoriteit 100%

Double.MAX_VALUEis de maximale waarde die een double kan vertegenwoordigen (ergens rond de 1,7*10^308).

Dit zou enkele rekenproblemen moeten opleveren, als u probeert de maximaal mogelijke waarde van een gegevenstype af te trekken.

Ook al zou je, als je met geld te maken hebt, nooit drijvende-kommawaarden moeten gebruiken, vooral omdat het afronden hiervan problemen kan veroorzaken (je hebt dan ofwel te veel of minder geld in je systeem).

Antwoord 2, autoriteit 39%

Hier de doden tot leven wekken, maar voor het geval iemand hier tegenaan loopt zoals ik. Ik weetwaar ik de maximale waarde van een double kan krijgen, het (meer) interessante deel was hoe ze aan dat aantal kwamen.

double heeft 64 bits. De eerste is gereserveerd voor het bord.

De volgende 11 vertegenwoordigen de exponent (dat is 1023 vooringenomen). Het is gewoon een andere manier om de positieve/negatieve waarden weer te geven. Als er 11 bits zijn, is de maximale waarde 1023.

Dan zijn er 52 bits die de mantisse bevatten.

Dit is eenvoudig als volgt te berekenen, bijvoorbeeld:

public static void main(String[] args) {
    String test = Strings.repeat("1", 52);
    double first = 0.5;
    double result = 0.0;
    for (char c : test.toCharArray()) {
        result += first;
        first = first / 2;
    }
    System.out.println(result); // close approximation of 1
    System.out.println(Math.pow(2, 1023) * (1 + result));
    System.out.println(Double.MAX_VALUE);
} 

Je kunt dit ook in omgekeerde volgorde bewijzen:

   String max = "0" + Long.toBinaryString(Double.doubleToLongBits(Double.MAX_VALUE));
    String sign = max.substring(0, 1);
    String exponent = max.substring(1, 12); // 11111111110
    String mantissa = max.substring(12, 64);
    System.out.println(sign); // 0 - positive
    System.out.println(exponent); // 2046 - 1023 = 1023
    System.out.println(mantissa); // 0.99999...8

Antwoord 3, autoriteit 3%

dit stelt dat Account.deposit(Double.MAX_VALUE);
het stelt de stortingswaarde in op MAX waarde van DoubledataType.to procced voor het uitvoeren van tests.