web-dev-qa-db-fra.com

Java double.MAX_VALUE?

Pour ma mission, je dois créer un système de compteur de gaz pour une entreprise gazière afin de permettre aux employés de créer de nouveaux comptes clients et de modifier des données telles que le nom et les coûts unitaires, tout en prenant (déposant) de l'argent de leur compte.

J'ai créé mon constructeur et même ajouté à une méthode de surcharge bien que je rencontre actuellement un problème lors du lancement de l'une de mes méthodes que j'ai nommées dépôt, cela est supposé prendre de l'argent du compte de l'utilisateur tout en d'autres méthodes telles que recordUnits permettent à l'employé d'importer un compteur de gaz indiquant le nombre d'unités utilisées par le client et de mettre à jour le solde du compte client, qui correspond essentiellement à ce que le client doit à la société.

Lorsque je teste le programme avec uniquement des informations prédéfinies lorsqu’on tente d’initier la méthode de dépôt, je reçois

Account.deposit(Double.MAX_VALUE);

Je ne suis pas trop sûr de ce que cela signifie et n'arrive pas à trouver quoi que ce soit pour le surmonter!

données de test et code vu ci-dessous:

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

pause

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;

     }

}
javadouble
18
Kriss Brown

Double.MAX_VALUE est la valeur maximale qu'un double peut représenter (environ 1,7 * 10 ^ 308).

Cela devrait aboutir à certains problèmes de calcul si vous essayez de soustraire la valeur maximale possible d'un type de données.

Même si vous traitez avec de l'argent, vous ne devriez jamais utiliser de valeurs en virgule flottante, surtout si vous arrondissez, cela peut poser problème (vous aurez alors beaucoup ou moins d'argent dans votre système).

24
Kuchi

Ressusciter les morts ici, mais juste au cas où quelqu'un trébuche contre cela comme moi. Je sais où obtenir la valeur maximale d'un double, la partie (plus) intéressante est de savoir comment ils ont obtenu ce nombre.

le double a 64 bits. Le premier est réservé au signe.

Les 11 suivants représentent l’exposant (c’est-à-dire 1023 biaisés). C'est juste une autre façon de représenter les valeurs positives/négatives. S'il y a 11 bits, la valeur maximale est 1023.

Ensuite, il y a 52 bits qui contiennent la mantisse.

Ceci est facilement calculé comme ceci par exemple:

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

}

Vous pouvez également le prouver dans l'ordre inverse:

    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
8
Eugene

cela indique que Account.deposit(Double.MAX_VALUE); il définit la valeur de dépôt sur la valeur MAX de Double dataType.to pour l'exécution des tests.

1
NPKR