Exemples et analyse du mécanisme de conversion de type automatique en Java

Analyse du mécanisme de conversion de type automatique

Vue d'ensemble

• La conversion de type automatique est également appelée conversion de type implicite

• Le type de données de l'expression est automatiquement promu

Toutes les valeurs d'octets, de courts et de caractères sera promu pour taper int.

Si un opérande est de type long, le résultat calculé est de type long ;

Si un opérande est de type float, le résultat calculé est de type float

Si un opérande est de type double ; de type double.

Le type de données sera uniquement automatiquement augmenté, pas automatiquement diminué

La valeur int peut être attribuée à des variables de type long, float, double, mais ne peut pas être attribuée à des variables de type byte, short, char

La même chose est vrai pour les paramètres de fonction

Bien sûr, en cas de surcharge de fonction, le compilateur Java sélectionnera automatiquement la fonction la plus correspondante à appeler

Le type de données par défaut des entiers en Java est le type int

Tous ceux avec une longueur inférieure à int Le résultat du type (byte, short, char) sera promu au type int après l'opération

Bien sûr, il y a la situation suivante, cette situation est due au fait que lorsque nous effectuons l'opération. Opération d'affectation, le compilateur Java peut clairement savoir si le résultat de l'opération dépasse la plage de valeurs de byte ou short, donc l'octet a = 1 + 1 ne signale pas d'erreur. La raison de l'erreur de compilation dans l'octet ci-dessus c = a + b; est que a et b sont tous deux des variables. Le compilateur ne sait pas si le résultat ajouté dépassera la plage de valeurs de l'octet, il promeut donc le résultat en int. taper. .

Pour résumer :

• Lorsque le compilateur sait clairement que le résultat de l'opération entière n'atteint pas la plage de représentation de int, le résultat de l'opération de type byte, short ou char ne sera pas automatiquement promu en int type

• Lorsque le compilateur sait clairement ou ne sait pas si le résultat de l'opération entière atteint la plage de représentation de int, le compilateur convertira automatiquement le résultat de l'opération en int, même s'il est à l'origine de type byte, short ou char.

Conversion de type automatique et conversion de type forcée

Quand la conversion de type aura-t-elle lieu ?

Réponse : lors de l'opération d'affectation, la conversion de type se produira lorsque les types de données des deux côtés sont incohérents

Comme suit :

public class TypeTest {
    public static void main(String[] args){
       	// 运算时发生的隐式类型转换,两整数相除得到的还是一个整数
        byte a  = 3;
        byte b = 4;
        int num  =  a + b;
        System.out.println(num); // 7
        // 赋值时发生的隐式类型转换
        int ch = '0';
        System.out.println(ch); // 48
        // 运算时发生的强制类型转换
        byte a1 = 12;
        byte a2 = 12;
        byte num1 = (byte)(a1  + a2);
        System.out.println(num1); // 24
        // 赋值时发生的强制类型转换
        short b3 = 1234;
        byte a3 = (byte) b3;
        System.out.println(a3); // -46
    }
}

En cours d'exécution capture d'écran :

Classification de conversion de type

• Conversion de type automatique

• Conversion de type forcée

Conversion de type automatique (conversion de type implicite)

Règle : De petit à grand, octet faible en high byte Promotion automatique de

commande :

byte (1 octet) > short (2 octets) -- > (4 octets) > double(8 octets)

char (2 octets)-- > ; double (8 octets)

Analyse du dessin :

Affichage du code :

public class TypeDemo {
    public static void main(String[] agrs){
        // byte -- > short
        byte b1 = 127;
        short s1 = b1;
        System.out.println(s1); // 127
        // short -- > int 
        short  s2 = 30000;
        int i = s2;
        System.out.println(i); // 30000
        // int  -- > long
        int num = 2100000000;
        long lg = num;
        System.out.println(num); // 2100000000
        // long -- > float 
        long lg1 = 200000000000000L;
 	    float f1 = lg1;
        System.out.println(f1);// 2.00000001E14
        // float -- > double 
        float f2 = 3.14f;
        double d1 = f2;
 	    System.out.println(d1); // 3.140000104904175
        // char -- > int
	    char ch = 'a';
        int i1 = ch ;
        System.out.println(i1); // 97
        // char -- > long
        char ch2 = 'b';
        long lg2 = ch2;
        System.out.println(lg2); // 98
        // char  -- >  double
        char ch3 = 'c';
        double dou = ch3;
        System.out.println(dou); // 99.0
        // char -- > float
        char ch4 = 'd';
        float  f3 = ch4;
        System.out.println(f3); // 100.0
    }
}

Capture d'écran en cours d'exécution :

Remarque :

l'octet et le short ne peuvent pas être convertis vers et depuis un caractère

Affichage du code :

public class TypeDemo2 {
    public static void main(String[] agrs){
 	    // byte -- > char
        byte bt = 127;
        char ch = bt;
        System.out.println(ch);
        // short -- > char
        short sh = 12;
        char ch2 = sh;
        System.out.println(ch2);
    }
}

Capture d'écran d'erreur de compilation :

Bien que float fasse 4 octets, float représente une plage de données plus grande que long. Cela montre que la taille de la plage de données et la taille des octets ne sont pas nécessairement liées.

Affichage du code :

public class TypeDemo3 {
    public static void main(String[] agrs){
        long lg = 20000000000000L;
        float f1 = lg;
        System.out.println(f1); // 1.99999997E13
    }
}

Capture d'écran en cours d'exécution :

Le type booléen ne peut pas participer à la conversion de type

Affichage du code :

public class TypeDemo4 {
    public static void main(String[] agrs) {
        boolean flag = 12;
        int flag1 = flag;
        System.out.println(flag1);
    }
}

Capture d'écran d'erreur de compilation :

Coercition (conversion de type explicite)

Règle : De grand à petit, coercition manuelle d'octets de poids élevé à d'octets de poids faible

Ordre :

double（8字节） – > float（4字节） – > long（8字节） – > int(4字节) – > short (2字节)-- > byte(1字节)

double（8字节） – > float（4字节） – > long（8字节） – > int(4字节) – > char(2字节)

画图分析：

(掌握)格式：目标数据类型 变量名 = (目标数据类型) 变量 | 常量;

代码展示：

public class TypeDemo5 {
    public static void main(String[] agrs){
        // float -- > long
        // final float  PI = 3.14f;
        // long num = (long) PI; // 3
        // float little =  3.14f;
        // long num = (long)little; // 3
 	    long num = (long)3.14f;      
        System.out.println(num);// 3 
        // double -- > float 
        // double dou = 3.14;
        // float little1 = (float)dou; // 3.14
        //  float little1 = (float) 3.14d;  // 3.14
        final double  dou = 3.14;
        float little1 = (float)dou;
        System.out.println(little1); // 3.14
        // long -- > int 
        // long  num1 = 2000000000000L;
        // int   num2 = (int)num1;  // -1454759936
        // int num2 = (int)2000000000000L; // -1454759936
       	final  long num1 = 2000000000000L;
        int num2 = (int)num1;
        System.out.println(num2);  // -1454759936
        // int --> short
        // int  num3  = 12;
        // short num4 = (short)num3; // 12
        // short num4 = (short)40000; // -25536
        final int num3 = 60;
        short num4 = (short)num3;
        System.out.println(num4); // 60
        // short -- > byte
        final short sh = 12345;
        byte bt = (byte)sh;
        System.out.println(bt); // 57
        short sh2 = 78;
	    bt = (byte) sh2;
        System.out.println(bt); // 78
    }
}

运行截图:

注意：

强制类型转换有数据丢失，一般不建议使用

代码展示：

public  class TypeDemo6 {
   public static void main(String[] agrs) {
       short a = 1245;
       byte b = (byte)a;
       System.out.println(b);
   } 
}

运行截图：

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!