Conversion de type de données Java (conversion automatique et conversion de coulée)
La conversion des types de données est divisée en conversion automatique et conversion de moulage. La conversion automatique est une conversion qui est "discrètement" effectuée par le programme pendant l'exécution. Bits.
Conversion automatique du type de données
Les conversions automatiques sont converties de faibles à haut. La relation prioritaire entre les différents types de données est la suivante:
Faible ------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ------
octet, court, char-> int -> long -> float -> double
En fonctionnement, différents types de données sont d'abord convertis en même type, puis le calcul est effectué.
Conversion de type de données forcées
Le format CAST consiste à ajouter "()" avant les données qui doivent être transformées, puis ajouter le type de données qui doit être transformé entre parenthèses. Certaines données seront perdues après les opérations de transformation, tandis que d'autres seront plus précises.
classe publique Demo {public static void main (String [] args) {int x; ; Résultats en cours:
x = 45y = 56,0
Analysez soigneusement le segment de programme ci-dessus: Puisqu'il y a une conversion de type forcé d'Int avant 34,56, 34,56 devient 34. De même, 11,2 devient 11, donc le résultat de x est 45. Il y a un double casting avant x, donc la valeur de x devient 45,0, et l'avant de 10 est également forcé de double type, donc il devient également 10,0, donc la valeur de Y devient 56 à la fin.
Types de données Java et définitions variables
Java est un langage fortement tapé et le type de données doit être spécifié lors de la déclaration des variables. La valeur d'une variable occupe une certaine quantité d'espace mémoire. Différents types de variables occupent différentes tailles.
Il existe 8 types de données de base en Java, y compris 4 types entiers, 2 types de points flottants, 1 type de caractère et 1 type booléen.
Pour les données entières, le type int est généralement utilisé. Mais si cela signifie que l'énergie libérée par la bombe atomique est tombée d'Hiroshima Nagasaki, vous devez utiliser le type long. Les types d'octets et de courtes sont principalement utilisés dans des scénarios d'application spécifiques, tels que le traitement de fichiers sous-jacent ou les grandes tableaux qui doivent contrôler la quantité d'espace de stockage.
En Java, la longueur des données entiers est liée à la plate-forme, ce qui résout de nombreux problèmes que le logiciel apporte aux programmeurs lors du portage d'une plate-forme à une autre. En revanche, la durée des données entières C / C ++ est liée à la plate-forme, et les programmeurs doivent sélectionner des entiers appropriés pour différentes plates-formes, ce qui peut entraîner des programmes de manière stable sur des systèmes 64 bits à compléter sur des systèmes 32 bits.
Octal a un préfixe de 0, par exemple, 010 correspond à 8 en décimal; correspond à 9 en décimal. À partir également de Java 7, les soulignements peuvent être utilisés pour séparer les nombres, similaires à l'écriture numérique anglaise, par exemple, 1_000_000 signifie 1 000 000, ce qui représente un million. Les soulignements sont juste pour rendre le code plus lisible et le compilateur supprimera ces soulignements.
De plus, contrairement à C / C ++, Java ne prend pas en charge les types non signés.
Le type de flotteur a une longueur maximale de 7 chiffres, et la longueur du nombre significatif comprend la partie entière et la partie décimale. Par exemple:
float x = 223,56f;
Remarque: chaque type de flotteur a un drapeau "f" ou "f".
Le double type a un nombre significatif maximum de 15 chiffres. Comme le type de flotteur, Double a également le drapeau "D" ou "D" après. Par exemple:
double x = 23,45d; double y = 422,22d; double z = 562,234;
Remarque: Données de points flottants sans indice, le système est par défaut à double type.
Dans la plupart des cas, le double type est utilisé et la précision du flotteur est difficile à répondre aux besoins.
Exemples de différents types de données:
classe publique Demo {public static void main (String [] args) {// type de caractère webname1 = 'micro'; Char webname2 = 'science'; du site Web Oui: "+ webname1 + webname2 + webname3); // entier court x = 22; // decimal int y = 022; // octal long z = 0x22l; // hexadecimal system.out.println (" Conversion décimal : x = "+ x +", y = "+ y +", z = "+ z); // Float type float m = 22,45f; double n = 10; System.out.println (" Calculer le produit: " + m + "*" + n + "=" + m * n); Résultats en cours:
Le nom du site Web est: Weixueyuan converti en décimal: x = 22, y = 18, z = 34 Calculer le produit: 22,45 * 10.0 = 224.50000762939453
D'après les résultats en cours d'exécution, nous pouvons voir que même si les données à virgule flottante n'ont que des entiers et aucune décimale, le système ajoutera automatiquement un point décimal lorsque la sortie sur la console, et toutes les décimales sont définies sur 0.
Description de Boolean
Si vous avez une expérience de programmation et comprenez les types booléens, veuillez sauter le tutoriel ci-dessous.
Dans la langue C, si la condition de jugement est valide, elle reviendra 1, sinon elle reviendra 0, par exemple:
#include <stdio.h> int main () {int x = 100> 10; int y = 100 <10; d / n ", y); retour 0;} Résultats en cours:
100> 10 = 1100 <10 = 0
Mais c'est différent dans Java. Par exemple:
classe publique Demo {public static void main (String [] args) {// Caractère Boolean a = 100> 10; Boolean B = 100 <10; out.println ("100 <10 =" + b); )); Résultats en cours:
100> 10 = true100 <10 = false100 <10 est correct
En fait, True est équivalent à 1 et FAUX équivaut à 0, mais il a changé son nom et devient un type de données séparément.