Règles de diffusion pour les types primitifs dans Java

En java,

Il y a des types intégraux(char/short/int/long/byte)

Il y a des types flottants(float/double)

Il est de type booléen(boolean), ne faisant pas partie intégrante de type, à la différence du langage C.

Question 1)

Est-il un générique règle pour la coulée(comme par JLS) qui parle, le type peut être converti en un autre type? De bon sens, je sais que, de l'intégrale et les types flottants casting pour boolean n'est pas autorisé

La Question 2)

Merci de m'aider à comprendre les raisons pour ci-dessous de sortie:

        /*
         * Casting rules for primitive types
         */
        double aDoubleValue = 30000000000000000000.123438934;
        int doubleToInt = (int)aDoubleValue; //stores max value 2147483647, makes sense!!
        byte doubleToByte = (byte)aDoubleValue; //stores -1, why not 127?
        short doubleToShort = (short)aDoubleValue; //stores -1, why not 32767?
        long doubleToLong = (long)aDoubleValue; //stores 9223372036854775807, makes sense!!
        float doubleToFloat = (float)aDoubleValue; //stores 3.0E19, 3.0 x 10^19  max value of float
        char doubleToChar = (char)aDoubleValue; //what does this store?

source d'informationauteur overexchange

  1. 15

    La JLS listes

    19 conversions spécifiques sur les types primitifs sont appelé à l'élargissement du primitif conversions:

    • byte short, int, long, float, double ou
    • short int, long, float, double ou
    • char, int, long, float, double ou
    • int, long, float ou double
    • long float ou double
    • float double

    Tout le reste a besoin d'un cast explicite. Rétrécissement est un peu plus complexe:

    • double à float utilise la norme IEEE 754 arrondissement.
    • valeurs entières ont leurs bits les plus significatifs dépouillé de la largeur disponible au type de cible. Cela peut entraîner un bit de signe apparaissant, par exemple,(byte)0xfff == (byte)-1;
    • Si la source est de type virgule flottante et le type de cible est longla valeur est convertie par l'arrondi vers zéro.
    • Si la source est de type virgule flottante et le type de cible est une partie intégrante, mais pas longla valeur est d'abord converti en int par l'arrondi vers zéro. Alors la résultante int est convertie dans le type de cible à l'aide de conversion d'entier.

    Exemples:

    int doubleToInt = (int)aDoubleValue;

    rendements Integer.MAX_VALUE selon les règles d'arrondi.

    byte doubleToByte = (byte)aDoubleValue;

    premiers convertis à intproduisant Integer.MAX_VALUE et puis la convertit en byte. Integer.MAX_VALUE est 0x7fffffffd'où la valeur de l'octet 0xff qui est -1.

    short doubleToShort = (short)aDoubleValue;

    même: convertit à intproduisant Integer.MAX_VALUE. 0x7fffffff à short rendements 0xffffc'est à dire -1.

    La chose la plus délicate est en fait lachar de conversion. char est un seul de caractères unicode 16 bits, donc char doubleToChar = (char)aDoubleValue vous donne '\uffff' maintenant par les règles habituelles.

    Comme on peut le voir il y a une différence entre les nombres à virgule flottante et entier rétrécissement des opérations. Les opérations en virgule flottante faire effectivement l'arrondissement, alors que les opérations sur entiers effectuer au niveau du bit de serrage.

    L'entier de la sémantique sont probablement hérité de C. Au moins la première étape du char-à-intégrale rétrécissement de la fpo sont aussi ce qui vous attend. La deuxième rétrécissement étapes, à partir de double/à flotteur à court, byte et l'omble chevalier peut paraître un peu surprenant, mais si vous avez vraiment cast flotter à court, vous devriez probablement vérifier que vous savez ce que vous faites de toute façon.