Java: pourquoi je reçois le message d'erreur “incompatibilité de Type: impossible de convertir int byte”

Si vous déclarez des variables de type byte ou à court et à tenter d'effectuer des opérations arithmétiques sur ces, vous recevez le message d'erreur "incompatibilité de Type: impossible de convertir int court" (ou en conséquence "incompatibilité de Type: impossible de convertir int byte").

byte a = 23;
byte b = 34;
byte c = a + b;

Dans cet exemple, l'erreur de compilation est sur la troisième ligne.

IIRC la JVM stocke les octets et les shorts, comme ints donc il n'y a généralement très peu d'avantages à l'utilisation de ces deux types de données. Bien sûr, je me rends compte que vous êtes en train de faire quelque chose de beaucoup plus complexe que l'exemple et ont probablement une très bonne raison.

OriginalL'auteur Brad Richards | 2008-09-17

  1. 8

    Bien que les opérateurs arithmétiques sont définis pour fonctionner sur tout type numérique, selon le langage Java specification (5.6.2 Binaire Numérique de Promotion), les opérandes de type byte et court sont automatiquement promus en int avant d'être remis aux opérateurs.

    À effectuer des opérations arithmétiques sur des variables de type byte ou un court, vous devez mettre l'expression entre parenthèses (à l'intérieur de laquelle seront réalisées les opérations de type int), puis coulé le résultat dans le type souhaité.

    byte a = 23; 
byte b = 34; 
octet c = (byte) (a + b);

    Voici un suivi sur la question de la réelle Java gourous: pourquoi? Les types byte et court sont parfaitement bien les types numériques. Pourquoi Java permettent pas directement les opérations arithmétiques sur ces types? (La réponse n'est pas "une perte de précision", comme il n'y a pas de raison apparente pour convertir en int en premier lieu.)

    Mise à jour: jrudolph suggère que ce comportement est basé sur les activités disponibles dans la JVM, plus précisément, que seule la pleine et double-mot opérateurs sont mis en œuvre. Par conséquent, l'opérateur sur les octets et les shorts, ils doivent être convertis en int.

    Je suppose que c'est dû à la performance. Dans certains Processeurs, il peut être plus cher à l'utilisation des opérandes plus petits que les registres du cpu. Probablement la même utilisé un 32 bits int pour stocker des octets et bref, pour maintenir alignés dans la mémoire.
    depuis que j'ai découvert que les opérations sont effectuées dans les registres du CPU, mais oui, ils sont alignés 32bits. et vous ne pouvez pas effectuer l'opérateur + sur les caractères, soit

    OriginalL'auteur Brad Richards

  2. 5

    La réponse à votre question est ici:

    des opérandes de type byte et court sont automatiquement promus en int avant d'être remis aux opérateurs

    Donc, dans votre exemple, a et b sont à la fois converti en int avant d'être remis à l'opérateur+. Le résultat de l'ajout de deux ints ensemble est également un int. En essayant de affectez int à un byte valeur causes de l'erreur car il existe un risque de perte de précision. En faisant explicitement le casting du résultat vous dire au compilateur "je sais ce que je fais".

    OriginalL'auteur David Sykes

  3. 2

    Je pense, la question est, que la JVM prend uniquement en charge les deux types de valeurs de pile: mot de taille et de mot double de taille.

    Puis ils ont probablement décidé qu'ils auraient besoin d'une seule opération de travaux sur word de la taille des entiers sur la pile. Donc, il n'y a qu'iadd, imul et ainsi de suite au niveau du bytecode (et pas des opérateurs pour les octets et courts-métrages).

    De sorte que vous obtenez une valeur int comme le résultat de ces opérations de Java ne peut pas convertir en toute sécurité de retour pour le plus petit d'octets et de types de données court. Donc, ils ont force de vous jeter à l'étroit, la valeur de retour vers octet/court.

    Mais à la fin, vous avez raison: Ce comportement n'est pas conforme au comportement des entiers, par exemple. Vous pouvez sans problème ajouter deux ints et n'obtenez pas de message d'erreur si le résultat déborde.

    OriginalL'auteur jrudolph

  4. 1

    Le langage Java encourage toujours les arguments des opérateurs arithmétiques de type int, long, float ou double. Prenez donc l'expression:

    a + b

    où a et b sont de type byte. C'est un raccourci pour:

    (int)a + (int)b

    Cette expression est de type int. Il établit clairement le sens à donner à une erreur lors de l'affectation d'un int valeur à une variable d'octet.

    Pourquoi la langue définie de cette manière? Supposons que l'un était de 60 et b était de 70, alors a+b est -126 - débordement d'entier. Dans le cadre d'une expression plus complexe, qui devrait aboutir dans un int, cela peut devenir difficile de bug. Restreindre l'utilisation de l'octet et court à la matrice de stockage, des constantes pour les formats de fichier/protocoles de réseau et de casse-têtes.

    Il est intéressant d'enregistrement de JavaPolis 2007. James Gosling est de donner un exemple sur la façon compliqué non signé de l'arithmétique (et pourquoi il n'est pas en Java). Josh Bloch souligne que son exemple donne le mauvais exemple dans des conditions normales d'arithmétique signée trop. Pour compréhensible arithmétique, nous avons besoin d'une précision arbitraire.

    OriginalL'auteur Tom Hawtin - tackline