En Java, la conversion de type peut souvent être rencontrée, de la définition des variables à la copie, le calcul des variables numériques au transfert de paramètres des méthodes, la modélisation entre les classes de base et les classes dérivées, etc. La conversion de type peut être vue partout. La conversion de type dans Java joue un rôle important dans le codage Java.
Il existe de nombreux problèmes auxquels faire attention lors de la définition des variables. Si vous ne faites pas attention, vous perdrez une précision ou des types incompatibles.
Par exemple:
1. Lors de la définition de données entières longues, le suffixe L ou L doit être ajouté.
Long L = 123456789012345L
2. Lors de la définition d'un type de précision unique (chiffre significatif 7-8 bits), le suffixe F ou F doit être ajouté.
Float F = 12,5F
3. Le type booléen ne peut pas être converti en autres types de données.
Parmi eux, nous rencontrons souvent des problèmes de conversion de type de données. Les plus courants sont la conversion implicite et la conversion de la distribution. Analyons-le.
Conversion implicite
fonctionnalité:
De petit à grand, il peut être converti implicitement et le type de données sera automatiquement amélioré.
octet, court, char -> int -> long -> float -> double
Remarque: Long est de 8 octets et le flotteur est de 4 octets.
Long est un entier, Float est un type de point flottant. Les règles de stockage pour les entiers et les numéros de points flottants sont différents. N'oubliez pas que la plage de longue durée est plus petite que le flotteur.
exemple:
octet a = 10;
int b = a;
Lorsque INTB = A est compilé, A est implicitement converti en type int.
Cas
fonctionnalité:
De grand à petit (si vous savez clairement que les données peuvent être représentées par ce type de données, vous pouvez utiliser la coulée)
Format:
(Type de données converti) Variable ou valeur.
Remarque: En général, le casting n'est pas du tout recommandé.
Exemple 1:
int a = 10; octet b = (byte) a;
Lorsque l'octet b = (octet) a est compilé, A est coulé au type d'octet.
Exemple 2:
classe qiangzhidemo {public static void main (String [] args) {byte b = (byte) 130; System.out.println (b); // Imprimer le résultat-126}}Analyse:
Données 130 par défaut vers des données décimales de type int,
Étape 1: Convertir la décimale 130 en données binaires.
10000010
Étape 2: La représentation de 130 en mémoire est la suivante
Code d'origine: 000000000000000000000 00000000 10000010
Étape 3: Trouvez le code du complément de INT130
Étant donné que 130 est un nombre positif, le code inverse et le code du complément sont cohérents avec le code d'origine.
Code du complément: 00000000000000000000000 00000000 100000010
Étape 4: Intercepter le code du complément, ne laissant que les 8 derniers chiffres.
(octet) Le code du complément du 130 est: 10000010
Étape 5: Convertissez ce complément en code d'origine.
Étant donné que le bit de signe (premier bit) est 1, le nombre est un nombre négatif.
Code inverse: 10000001 (Code du complément-1)
Code d'origine: 111111110 (le bit de symbole reste inchangé, le bit de données est inversé)
Convertissez en décimal en -126, donc enfin imprimer -126.
Exemple 3:
shorts = 1; s = s +1;
et
shorts = 1; s + = 1;
Y a-t-il un problème? Pourquoi?
Analyse:
Le premier programme rapportera une erreur: Erreur: Type incompatible: il peut y avoir des pertes lors de la conversion de l'intre
Cause: S = S + 1; S + 1 sera implicitement converti en type int. Lorsqu'un type int est affecté au type court, il peut être perdu.
Le deuxième programme peut être compilé et exécuté.
Raison: S + = 1, bien qu'il puisse être considéré comme s = s + 1, il y a toujours une différence. Il y a un moulage dans S + = 1, c'est-à-dire S = (court) (S + 1), ce qui forcera la valeur de S + 1 à un type court, il n'y aura donc pas d'erreur.
résumé:
Si le problème de la conversion du type de données se produit dans certains mini programmes, nous pouvons être en mesure de voir en un coup d'œil. Cependant, lors de l'écriture d'un système énorme et d'avoir une énorme quantité de données, ces petits problèmes peuvent entraîner des erreurs du système ou même des accidents, nous devons donc saisir la rigueur de l'écriture de code précoce.
Le contenu ci-dessus présente la conversion Java Basic Implicit VS CONTERNION, j'espère que vous l'aimez.