Pour ceux qui viennent de commencer à apprendre la programmation, y compris le langage Java, et ceux qui l'ont déjà appris, pour examen J'écris pour apprendre la conversion de type.
La dernière fois, j'ai découvert Variations et types. Cette fois, à propos de la ** conversion de type **.
Il s'agit de convertir le type de données. Voici comment procéder.
-Conversion de type implicite ・ Conversion de type par fonte
Regardons chacun d'eux.
Il est possible de remplacer un petit type par un grand type. Même si nous, les programmeurs, ne convertissons pas explicitement le type, il convertira le type au moment de la compilation.
La substitution du type de gauche au type de droite est OK! byte → short、char → int → long → float → double
Main.java
class Main {
public static void main(String args[]) {
int number = 10;
//le nombre de type int devient un type flottant
float numberFloat = number;
System.out.println(numberFloat); // 10.0 ← avec un point décimal
}
}
** Veuillez noter que la conversion de type implicite n'est pas possible pour ce qui suit. ** ** ・ Lors du changement de type de caractère en type court ・ Lors du changement de type court en type de caractère Les deux sont des types de données 16 bits, mais la plage de valeurs pouvant être gérée est différente. Vous devez effectuer la conversion de type par diffusion décrite ci-dessous.
Main.java
class Main {
public static void main(String args[]) {
//・ Char → court
char a = 100;
//J'obtiens une erreur
// short b = a; // Type mismatch: cannot convert from char to short
short b = (short) a; //Conversion en type court par type Conversion par diffusion
System.out.println(b); // 100
//・ Court → caractère
short c = 100;
//J'obtiens une erreur
// char d = c; // Type mismatch: cannot convert from short to char
char d = (char) c; //Conversion en type de caractère par conversion de type par diffusion
System.out.println(d); // d
}
}
-Il est impossible de remplacer un gros type par un petit type. Une erreur de compilation se produira. La substitution du type droit au type gauche est NG! byte → short、char → int → long → float → double
Main.java
class Main {
public static void main(String args[]) {
int numberInt = 10;
//Vous ne pouvez pas attribuer d'un grand type à un petit type.
byte numberByte = numberInt; // Type mismatch: cannot convert from int to byte
System.out.println(numberByte);
}
}
Veuillez également noter qu'il existe un risque de perte de précision en raison des conversions de type suivantes **.
Main.java
class Main {
public static void main(String args[]) {
//Définissez une variable avec la valeur maximale de chaque type
int intMax = Integer.MAX_VALUE;
long longMax = Long.MAX_VALUE;
float floatMax = Float.MAX_VALUE;
//Le nombre de chiffres effectifs du type float est de 7 chiffres en décimal(24 chiffres en binaire)
// int → float
float floatFromIntMax = intMax;
System.out.println(intMax); // 2147483647
//↓ Les valeurs après 7 chiffres effectifs sont perdues (les résultats différents de ceux avant la conversion de type sont émis)
System.out.println(floatFromIntMax); // 2.14748365E9
// long → float
float floatFromLongMax = longMax;
System.out.println(longMax); // 9223372036854775807
//↓ Les valeurs après 7 chiffres effectifs sont perdues (les résultats différents de ceux avant la conversion de type sont émis)
System.out.println(floatFromLongMax); // 9.223372E18
//Le nombre de chiffres effectifs de type double est d'environ 15 chiffres en décimal(53 chiffres en binaire)
// long → double
double doubleFromLongMax = longMax;
System.out.println(longMax); // 9223372036854775807
//↓ Les valeurs après 15 chiffres effectifs sont perdues (résultats différents de ceux avant la conversion de type sont émis)
System.out.println(doubleFromLongMax); // 9.223372036854776E18
// float → double
double doubleFromFloatMax = floatMax;
System.out.println(floatMax); // 3.4028235E38
//↓ Les valeurs après 15 chiffres effectifs sont perdues (résultats différents de ceux avant la conversion de type sont émis)
System.out.println(doubleFromFloatMax); // 3.4028234663852886E38
}
}
Vous ne pouvez pas attribuer d'un grand type à un petit type.
Effectuez explicitement la conversion de type à l'aide de ** () ** cast operator.
Main.java
class Main {
public static void main(String args[]) {
double numberDouble = 3.14;
//Vous ne pouvez pas attribuer d'un grand type à un petit type.
// int numberInt = numberDobule; // Type mismatch: cannot convert from double to int
//Converti de force en type int à l'aide de l'opérateur cast
int numberInt = (int)number;
System.out.println(numberInt); //Est sortie comme 3
}
}
Veuillez noter que certains modèles ne peuvent pas être convertis. Les chaînes de caractères ne peuvent pas être converties en type int à l'aide de l'opérateur de conversion.
Main.java
class Main {
public static void main(String args[]) {
//Exemples qui ne peuvent pas être convertis
String str = "Bonjour";
int num = (int)str; // Cannot cast from String to int
System.out.println(str);
}
}
** Remarques sur la diffusion **
Veuillez noter que certaines données seront perdues en raison de la conversion de type par diffusion.
-Lorsque le type est converti d'une grande taille à une petite taille, la valeur du bit de poids fort est tronquée (débordement de données).
Main.java
class Main {
public static void main(String args[]) {
short x = 257; //16 bits-> 0000 0001 0000 0001
byte y = (byte)x; //8 bits-> 0000 0001
System.out.println(y); //Est sortie comme 1
}
}
-Lors de la conversion d'un petit nombre en un entier, les chiffres après la virgule décimale sont tronqués.
Main.java
class Main {
public static void main(String args[]) {
//De plus, lors de la conversion d'un petit nombre en un entier, les chiffres après la virgule décimale sont tronqués.
double d = 10.23;
int i = (int)d;
System.out.println(i); //Est sortie comme 10
float f = 33.44f;
int i2 = (int)f;
System.out.println(i2); //33 est la sortie
}
}
Java peut effectuer automatiquement des conversions de type qui ne sont pas prévues par le programmeur. Ceci est expliqué ci-dessous.
Main.java
class Main {
public static void main(String args[]) {
int a = 1;
long b = 2;
//La variable a est convertie en type long avant l'opération
int c = a + b; // Type mismatch: cannot convert from long to int
}
}
↓ ** Solution **
Main.java
class Main {
public static void main(String args[]) {
int a = 1;
long b = 2;
int c = (int)(a + b); //L'erreur disparaît en convertissant le résultat de l'opération en type int.
System.out.println(c); // 3
}
}
Main.java
class Main {
public static void main(String args[]) {
int a = 1;
float b = 2.0f;
//La variable a est convertie en type flottant avant l'opération
int c = a + b; // Type mismatch: cannot convert from float to int
}
}
↓ ** Solution **
Main.java
class Main {
public static void main(String args[]) {
int a = 1;
float b = 2.0f;
int c = (int)(a + b); //L'erreur disparaît en convertissant le résultat de l'opération en type int.
System.out.println(c); // 3
}
}
Main.java
class Main {
public static void main(String args[]) {
int a = 1;
double b = 2.0;
//La variable a est convertie en type double avant l'opération
int c = a + b; // Type mismatch: cannot convert from double to int
}
}
↓ ** Solution **
Main.java
class Main {
public static void main(String args[]) {
int a = 1;
double b = 2.0;
int c = (int)(a + b); //L'erreur disparaît en convertissant le résultat de l'opération en type int.
System.out.println(c); // 3
}
}
Main.java
class Main {
public static void main(String args[]) {
byte a = 1;
byte b = 2;
//Variable a avant calcul,b est converti en type int
byte c = a + b; // Type mismatch: cannot convert from int to byte
}
}
↓ ** Solution **
Main.java
class Main {
public static void main(String args[]) {
byte a = 1;
byte b = 2;
byte c = (byte)(a + b); //L'erreur disparaît en convertissant le résultat du calcul en type d'octet.
System.out.println(c); // 3
}
}
Je pense que la promotion (promotion) peut entraîner des résultats et des erreurs involontaires. Vous devez faire attention à la promotion numérique au moment du calcul.
J'ai appris la conversion de type. La prochaine fois, je me pencherai sur Variable Scope.
Recommended Posts