Beispiele und Analyse des automatischen Typkonvertierungsmechanismus in Java

Analyse des automatischen Typkonvertierungsmechanismus

Übersicht

• Die automatische Typkonvertierung wird auch als implizite Typkonvertierung bezeichnet

• Der Datentyp des Ausdrucks wird automatisch heraufgestuft

Alle Byte-, Kurz- und Zeichenwerte wird zum Typ int hochgestuft.

Wenn ein Operand vom Typ long ist, ist das berechnete Ergebnis vom Typ long;

Wenn ein Operand vom Typ float ist, ist das berechnete Ergebnis vom Typ float;

Wenn ein Operand vom Typ double ist, ist das berechnete Ergebnis vom Typ Double.

Der Datentyp wird nur automatisch erhöht, nicht automatisch verringert.

Int-Werte können Variablen vom Typ Long, Float und Double zugewiesen werden, nicht jedoch Variablen vom Typ Byte, Short und Char. Das Gleiche gilt für Funktionsparameter

Natürlich wählt der Java-Compiler im Falle einer Funktionsüberladung automatisch die am besten passende Funktion zum Aufruf aus

Der Standarddatentyp für Ganzzahlen in Java ist der Typ int

Alle diejenigen mit einer Länge kleiner als int Das Ergebnis des Typs (Byte, Short, Char) wird nach der Operation zum Typ int heraufgestuft

Natürlich gibt es die folgende Situation, weil wir eine Zuweisungsoperation durchführen Der Java-Compiler kann eindeutig feststellen, ob das Ergebnis der Operation den Wertebereich von Byte oder Short überschreitet, sodass Byte a = 1 + 1 keinen Fehler meldet. Der Grund für den obigen Kompilierungsfehler byte c = a + b liegt darin, dass a und b beide Variablen sind und der Compiler nicht weiß, ob das hinzugefügte Ergebnis den Wertebereich von byte überschreitet, sodass der Compiler das Ergebnis auf den Typ int hochstuft . .

Zusammenfassend:

Wenn der Compiler eindeutig weiß, dass das Ergebnis der Ganzzahloperation nicht den Darstellungsbereich von int erreicht, wird das Operationsergebnis vom Typ Byte, Short oder Char nicht automatisch zu int heraufgestuft Typ

• Wenn der Compiler eindeutig weiß oder nicht, ob das Ergebnis der Ganzzahloperation den Darstellungsbereich von int erreicht, konvertiert der Compiler das Operationsergebnis automatisch in int, auch wenn es ursprünglich vom Typ Byte, Short oder Char ist.

• Automatische Typkonvertierung und erzwungene Typkonvertierung
  Wann findet die Typkonvertierung statt?

Antwort: Während des Zuweisungsvorgangs findet die Typkonvertierung statt, wenn die Datentypen auf beiden Seiten inkonsistent sind Screenshot:

Typkonvertierungsklassifizierung

Automatische Typkonvertierung

Erzwungene Typkonvertierung

• Automatische Typkonvertierung (implizite Typkonvertierung)

Regel:
• Von klein nach groß, niedrig zu High-Byte Automatische Heraufstufung von

Byte (1 Byte) – > int (4 Bytes) – > (4 Bytes) > double(8 Bytes)-- > int(4 Bytes) --> ; double (8 Bytes)

Zeichnungsanalyse:

Codeanzeige:

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
    }
}

Laufender Screenshot:

Hinweis:

Byte und Short können nicht in und aus Zeichen konvertiert werden

Codeanzeige:

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
    }
}

Kompilierungsfehler-Screenshot:

Obwohl Float 4 Bytes groß ist, stellt Float einen größeren Datenbereich dar als Long. Es zeigt, dass die Größe des Datenbereichs und die Größe der Bytes nicht unbedingt zusammenhängen.

Codeanzeige:

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);
    }
}

Laufender Screenshot:

boolescher Typ kann nicht an der Typkonvertierung teilnehmen

Codeanzeige:

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

Kompilierungsfehler-Screenshot:

Zwang (explizite Typkonvertierung)

Regel:

Von groß zu klein, High-Byte zu Low-Byte, manueller Zwang

Reihenfolge:

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);
   } 
}

运行截图：

Das obige ist der detaillierte Inhalt vonBeispiele und Analyse des automatischen Typkonvertierungsmechanismus in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!