Java double.MAX_VALUE?

Question

Ciao a tutti io sono nel mio primo anno di Computing System per lo sviluppo, quindi sono abbastanza nuovo a Java e alle prese delle nozioni di base!

Per il mio primo incarico, devo creare un sistema di misuratori di gas per un'azienda di gas per consentire ai dipendenti di creare nuovi conti cliente e modificare dati come il nome e il costo unitario insieme a prelevare (depositare) denaro dal proprio conto.

ho creato il mio costruttore e anche aggiunto in un metodo di sovraccarico anche se sto attualmente in esecuzione in un problema quando si inizia uno dei miei metodi ho nominato deposito, questo dovrebbe prendere i soldi da parte degli utenti rappresentano mentre altri metodi come recordUnits consenta al lavoratore di importare una lettura contatore del gas di quante unità ha usato il cliente e aggiorna l'equilibrio di che i clienti rappresentano che è essenzialmente ciò che il cliente deve alla società.

Durante il test il programma con informazioni basta preimpostata quando si cerca di avviare il metodo di deposito ottengo questo

Account.deposit(Double.MAX_VALUE); 

io non sono troppo sicuro che cosa questo significa e non riesco a trovare comunque di ottenere passato! mi scuso se questo è stato pubblicato anche se mi sono guardato intorno inutilmente per una risposta appropriata.

dati di test e il codice visto sotto:

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

rottura

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; 

    } 

} 

questo è solo l'ossatura del mio codice ho molto di più per andare, ma questo è si spera darvi un'idea .

Grazie in anticipo

Answer 1

Double.MAX_VALUE è il valore massimo di un letto può rappresentare (da qualche parte circa 1,7 * 10^308).

Questo dovrebbe terminare con alcuni problemi di calcolo, se si tenta di sottrarre il valore massimo di un tipo di dati.

Anche se quando si tratta di soldi si dovrebbe mai usare i valori in virgola mobile soprattutto mentre arrotondamento questo può causare problemi (si sia dovuto più o meno soldi nel vostro sistema allora).

Answer 2

questo afferma che Account.deposit(Double.MAX_VALUE); si tratta di impostazione valore del deposito al valore di MAX di Double dataType.to procced per l'esecuzione di test.

Answer 3

Resuscitare i morti qui, ma nel caso in cui qualcuno inciampi contro questo come me. I conoscere dove ottenere il valore massimo di un doppio, la (più) parte interessante era come hanno raggiunto quel numero.

doppia ha 64 bit. Il primo è riservato per il segno.

Successivo 11 rappresenta l'esponente (che è polarizzato 1023). È solo un altro modo per rappresentare i valori positivi/negativi. Se ci sono 11 bit, il valore massimo è 1023.

Quindi ci sono 52 bit che mantengono la mantissa.

questo è facilmente calcolato in questo modo, per esempio:

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()) { 
     if (c == '1') { 
      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); 

} 

Si può anche dimostrare questo in ordine inverso:

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