Java-Datentypen (Typ) können in zwei Hauptkategorien unterteilt werden: primitive Typen und Referenztypen (Referenztypen). Das Folgende ist ein Power-Knoten, um Wissen über die grundlegenden Datentypen von Java zu organisieren.
1 > Im Java-Quellcode muss jede Variable einen Typ deklarieren. Java-Datentypen (Typen) können in zwei Hauptkategorien unterteilt werden: primitive Typen und Referenztypen. Zu den primitiven Typen gehören boolesche Typen und
numerische Typen (numerische Typen). Numerische Typen werden weiter in Ganzzahltypen und Gleitkommatypen unterteilt. Es gibt 5 Arten von Ganzzahlen: Byte Short Int Long Char (Char ist im Wesentlichen ein spezieller Typ von Int). Gleitkommatypen umfassen Float und Double. Die Beziehung ist wie folgt organisiert:
2. Grundtypen:
Java ist Die Basistypen bieten Unterstützung auf Sprachebene, das heißt, sie sind bereits in Java vordefiniert und werden durch entsprechende reservierte Schlüsselwörter dargestellt. Der Basistyp ist ein einzelner Wert, kein komplexes Objekt. Der Basistyp ist nicht
objektorientiert. Er dient hauptsächlich aus Effizienzgründen, bietet aber auch Objektversionen von Basic Typen, d. h. grundlegender Typ-Wrapper. Sie können diese Basistypen direkt verwenden oder Sie können Basistypen verwenden, um Arrays oder andere benutzerdefinierte Typen zu erstellen. Primitive Typen haben explizite Wertebereiche und mathematisches Verhalten. 2.1 Ganzzahltyp
Der Ganzzahltyp umfasst Byte Short Int Long Char, die durch 8, 16, 32, 64 bzw. 16 Bit dargestellt werden. An manchen Stellen ist char möglicherweise nicht in der Integer-Kategorie enthalten, aber im Wesentlichen ist der char-Typ eine Teilmenge von int. Die Breite einer Ganzzahl sollte nicht als die Größe des von der Ganzzahl belegten Speicherplatzes betrachtet werden, sondern als das Verhalten einer Variablen oder eines
Ausdrucks, der als Ganzzahl definiert ist. JVMs können beliebig großen Speicherplatz nutzen, solange sich der Typ gemäß der Spezifikation verhält. Byte Short Int Long sind alle vorzeichenbehaftet und werden durch das Zweierkomplement (Zweierkomplement) dargestellt. Char wird durch 16 Bit dargestellt, ist ohne Vorzeichen und stellt den UTF-16-Codierungssatz dar. 2.1.1 Byte
Byte wird durch 1 Byte mit 8 Bits dargestellt und ist der kleinste Ganzzahltyp. Wird hauptsächlich verwendet, um Schlüsselspeicherplatz zu sparen. Der Byte-Typ ist besonders nützlich, wenn Datenströme aus dem Netzwerk, Dateien oder anderen E/A verarbeitet werden. Der Wertebereich ist: [-128, 127]. Der Standardwert von Byte ist (Byte)0. Wenn wir versuchen, einer Variablen vom Typ Byte einen Wert zuzuweisen, tritt ein Kompilierungsfehler auf, z. B. Byte b = 128; Diese Anweisung kann nicht kompiliert werden. Eine interessante Frage, wenn wir eine Methode haben: public void test(byte b). Es ist falsch, diese Methode wie folgt aufzurufen: test(0); Der Compiler meldet einen Fehler, Typinkompatibilität! ! ! Wir erinnern uns an Byte b =0; das ist überhaupt kein Problem, warum geht es hier schief?
Hierbei handelt es sich um ein Problem namens Literalwert. Der Wert auf der Oberfläche lautet beispielsweise 5, 0, -200. Wenn L oder l am Ende der Ganzzahl hinzugefügt wird, ist der Literalwert vom Typ long. Beispiel: 1000L stellt einen Wert vom Typ long dar. Wenn L oder l nicht hinzugefügt wird, ist es vom Typ int. Unter den Grundtypen kann Byte Short Int Long durch Integer-Literale erstellt werden, ohne L hinzuzufügen (nennen wir sie Int-Literale), zum Beispiel Byte B = 100 für den Long-Typ, wenn die Größe den Bereich überschreitet dass int (32 Bit) darstellen kann, muss mit einer L-Endung ausgedrückt werden. Ganzzahlige Literale können auf verschiedene Arten ausgedrückt werden: hexadezimal [0X oder 0x], dezimal [nichts], oktal [0], binär [0B oder 0b] usw. Binäre Literale sind erst nach der JDK 7-Funktion verfügbar. Bei der Zuweisungsoperation kann ein int-Literalwert dem Byte short int long zugewiesen werden, und die Java-Sprache übernimmt diesen Vorgang automatisch. Wenn die Methodenaufrufe unterschiedlich sind und test(0) aufgerufen wird, ist die Methode, mit der es übereinstimmen kann, test(int), und natürlich kann es nicht mit der test(byte)-Methode übereinstimmen. Warum Java solche Methodenaufrufe nicht unterstützt Unterstützt Zuweisungsvorgänge, es gibt keine Wahl. Beachten Sie den Unterschied zwischen Wrappern und der automatischen Konvertierung primitiver Typen (Anto-Boxing, Auto-Unboxing). byte d = 'A'; ist ebenfalls zulässig, Zeichenliterale können automatisch in 16-Bit-Ganzzahlen umgewandelt werden.
Wenn mathematische Operationen am Byte-Typ ausgeführt werden, wird dieser automatisch zum Typ int hochgestuft. Wenn der Ausdruck Typen wie double oder float enthält, wird er ebenfalls automatisch hochgestuft. Der folgende Code ist also falsch:
byte s2 = 'a'; byte sum = s1 + s2;//should cast by (byte)</span></span></span>
2.1.2 short
wird durch 16 dargestellt und der Wertebereich ist: [- 2^15, 2 ^15 - 1]. short ist wahrscheinlich der am wenigsten verwendete Typ. Werte können durch ganzzahlige Literale oder Zeichenliterale zugewiesen werden, sofern sie den Bereich (16 Bit) nicht überschreiten. Wenn der kurze Typ an Operationen teilnimmt, wird er auch auf int oder einen höheren Typ heraufgestuft. (Die Reihenfolge ist Byte Short Int Long Float Double).
2.1.3 int
32 Bits, [- 2^31, 2^31 - 1 ]. Ganzzahl dargestellt durch vorzeichenbehaftetes Zweierkomplement . Häufig verwendete Ausdrücke steuern die -Schleife . Beachten Sie, dass Byte und Short während des Betriebs auf den Typ int oder höher heraufgestuft werden. Nach Java 8 können Sie den Typ int verwenden, um vorzeichenlose 32-Bit-Ganzzahlen [0, 2^31 - 1] darzustellen.
2.1.4 lang
64 Bit, [- 2^63, 2^63 - 1, Standardwert ist 0L]. Wenn Sie sehr große Zahlen berechnen müssen und int nicht groß genug ist, um die Größe aufzunehmen, können Sie den langen Typ verwenden. Wenn long nicht ausreicht, können Sie die BigInteger-Klasse verwenden.
2.1.5 char
16 Bits, [0, 65535], [0, 2^16 -1], ab 'u0000 'zu 'uffff'. Ohne Vorzeichen, Standardwert ist „u0000“. Java verwendet den Unicode--Zeichensatz zur Darstellung von Zeichen. Unicode ist ein vollständig internationaler Zeichensatz, der Zeichen in allen menschlichen Sprachen darstellen kann. Unicode erfordert eine Breite von 16 Bit, daher wird der char-Typ in Java auch durch 16 Bit dargestellt. Die Zuweisung könnte so aussehen:
char ch1 = 88; char ch2 = 'A';
Der ASCII-Zeichensatz belegt die ersten 127 Werte von Unicode. Der Grund, warum char als ganzzahliger Typ klassifiziert wird, liegt darin, dass Java arithmetische Operationen für char unterstützt, z. B. ch2++, dann wird ch2 zu Y. Wenn char Additions-, Subtraktions-, Multiplikations- und Divisionsoperationen ausführt, wird es auch in den Typ int konvertiert und muss explizit zurückkonvertiert werden.
2.2 Gleitkommatyp
umfasst Float mit einfacher Genauigkeit und Double mit doppelter Genauigkeit, die gemäß der IEEE 754-Spezifikation durch 32 bzw. 64 Bit dargestellt werden.
2.2.1 float
wird durch 32 Bits dargestellt, was Gleitkommazahlen mit einfacher Genauigkeit entspricht. Es wird jedoch schneller ausgeführt als mit doppelter Genauigkeit Der Wert ist sehr groß. Er wird ungenau, wenn er groß oder sehr klein ist. Wenn die Genauigkeitsanforderungen nicht hoch sind, können Sie den Float-Typ verwenden. Beispiel für die Deklarationszuweisung:
f1 = 10L; f1 = 10.0f; //f1 = 10.0;默认为double</span></span></span>
Sie können dem Float-Typ Byte, Short, Int, Long und Char zuweisen schließt die -Konvertierung automatisch ab.
2.2.2 double
64 bedeutet, dass beim Zuweisen eines Gleitkommawerts zu einer Variablen f oder F nach dem Literalwert nicht angezeigt wird, dann Der Standardwert ist vom Typ Double. Die -Funktionen in java.lang.Math übernehmen alle den Double-Typ.
Wenn weder Double noch Float die gewünschte Genauigkeit erreichen können, können Sie die BigDecimal-Klasse verwenden.
2.3 boolescher Typ
Der boolesche Typ hat nur zwei Werte, wahr und falsch, und der Standardwert ist falsch. Boolescher Wert hat nichts damit zu tun, ob er 0 ist oder nicht, sondern kann entsprechend der gewünschten Logik konvertiert werden. Der Typ boolean wird an vielen Stellen benötigt.
3. Literalwert
Im Java-Quellcode wird ein Literalwert verwendet, um einen festen Wert darzustellen. Numerische Literalwerte sind die häufigsten. Der Literalwert String kann natürlich auch als ein Typ betrachtet werden. Literalwerte können grob in Ganzzahlliterale, Gleitkommaliterale, Zeichen- und Zeichenfolgenliterale sowie spezielle Literale unterteilt werden. 3.1. 整型字面值 从形式上看是整数的字面值归类为整型字面值。例如： 10, 100000L, 'B'、0XFF这些都可以称为字面值。整型字面值可以用十进制、16、8、2进制来表示。十进制很简单，2、8、16进制的表示分别在最前面加上0B（0b）、0、0X（0x）即可，当然基数不能超出进制的范围，比如09是不合法的，八进制的基数只能到7。一般情况下，字面值创建的是int类型，但是int字面值可以赋值给byte short char long int，只要字面值在目标范围以内，Java会自动完成转换，如果试图将超出范围的字面值赋给某一类型（比如把128赋给byte类型），编译通不过。而如果想创建一个int类型无法表示的long类型，则需要在字面值最后面加上L或者l。通常建议使用容易区分的L。所以整型字面值包括int字面值和long字面值两种。 3.2. 浮点字面值 浮点字面值简单的理解可以理解为小数。分为float字面值和double字面值，如果在小数后面加上F或者f，则表示这是个float字面值，如11.8F。如果小数后面不加F（f），如10.4。或者小数后面加上D（d），则表示这是个double字面值。另外，浮点字面值支持科学技术法表示。下面是一些例子： 3.3 字符及字符串字面值 Java中字符字面值用单引号括起来，如‘@'‘1'。所有的UTF-16字符集都包含在字符字面值中。不能直接输入的字符，可以使用转义字符，如‘\n'为换行字符。也可以使用八进制或者十六进制表示字符，八进制使用反斜杠加3位数字表示，例如'\141'表示字母a。十六进制使用\u加上4为十六进制的数表示，如'\u0061'表示字符a。也就是说，通过使用转义字符，可以表示键盘上的有的或者没有的所有字符。常见的转义字符序列有： \ddd(八进制) 、 \uxxxx(十六进制Unicode字符)、\'（单引号）、\"（双引号）、\\ （反斜杠）\r（回车符） \n（换行符） \f（换页符） \t（制表符） \b（回格符） 字符串字面值则使用双引号，字符串字面值中同样可以包含字符字面值中的转义字符序列。字符串必须位于同一行或者使用+运算符，因为java没有续行转义序列。 3.4 特殊字面值 null是一种特殊的类型（type），可以将它赋给任何引用类型变量，表示这个变量不引用任何东西。如果一个引用类型变量为null，表示这个变量不可用。 还有一种特殊的class literal，用type name加上.class表示,例如String.class。首先，String是类Class（java.lang.Class)的一个实例（对象），而"This is a string"是类String的一个对象。然后，class literal用于表示类Class的一个对象，比如String.class用于表示类Class的对象String。简单地说，类子面子（class literal）就是诸如String.class 、Integer.class这样的字面值，它所表示的就是累String、类Integer。如果输出Integer.class，你会得到class java.lang.Integer。List.class的输出为interface java.util.List。总之，class literal用于表示类型本身！ 3.5 在数值型字面值中使用下划线。 JDK7开始，可以在数值型字面值（包括整型字面值和浮点字面值）插入一个或者多个下划线。但是下划线只能用于分隔数字，不能分隔字符与字符，也不能分隔字符与数字。例如 int x = 123_456_789.在编译的时候，下划线会自动去掉。可以连续使用下划线，比如float f = 1.22_3344.二进制或者十六进制的字面值也可以使用下划线，记住一点，下划线只能用于数字与数字之间，初次以外都是非法的。例如1._23是非法的，_123、11000_L都是非法的。 4. 基本类型之间的转换 我们看到，将一种类型的值赋给另一种类型是很常见的。在Java中，boolean类型与所有其他7种类型都不能进行转换，这一点很明确。对于其他7中数值类型，它们之间都可以进行转换，但是可能会存在精度损失或者其他一些变化。转换分为自动转换和强制转换。对于自动转换（隐式），无需任何操作，而强制类型转换需要显式转换，即使用转换操作符（type）。首先将7种类型按下面顺序排列一下： 如果从小转换到大，可以自动完成，而从大到小，必须强制转换。short和char两种相同类型也必须强制转换。 4.1 自动转换 自动转换时发生扩宽（widening conversion）。因为较大的类型（如int）要保存较小的类型（如byte），内存总是足够的，不需要强制转换。如果将字面值保存到byte、short、char、long的时候，也会自动进行类型转换。注意区别，此时从int（没有带L的整型字面值为int）到byte/short/char也是自动完成的，虽然它们都比int小。在自动类型转化中，除了以下几种情况可能会导致精度损失以外，其他的转换都不能出现精度损失。 除了可能的精度损失外，自动转换不会出现任何运行时（run-time）异常。 4.2 强制类型转换 如果要把大的转成小的，或者在short与char之间进行转换，就必须强制转换，也被称作缩小转换（narrowing conversion）,因为必须显式地使数值更小以适应目标类型。强制转换采用转换操作符（）。严格地说，将byte转为char不属于narrowing conversion），因为从byte到char的过程其实是byte-->int-->char，所以widening和narrowing都有。强制转换除了可能的精度损失外，还可能使模（overall magnitude）发生变化。强制转换格式如下： 如果整数的值超出了byte所能表示的范围，结果将对byte类型的范围取余数。例如a=256超出了byte的[-128,127]的范围，所以将257除以byte的范围（256）取余数得到b=1；需要注意的是，当a=200时，此时除了256取余数应该为-56，而不是200. 将浮点类型赋给整数类型的时候，会发生截尾（truncation）。也就是把小数的部分去掉，只留下整数部分。此时如果整数超出目标类型范围，一样将对目标类型的范围取余数。 7种基本类型转换总结如下图： 4.3 赋值及表达式中的类型转换： 4.3.1 字面值赋值 在使用字面值对整数赋值的过程中，可以将int literal赋值给byte short char int，只要不超出范围。这个过程中的类型转换时自动完成的，但是如果你试图将long literal赋给byte，即使没有超出范围，也必须进行强制类型转换。例如 byte b = 10L；是错的，要进行强制转换。 4.3.2 表达式中的自动类型提升 除了赋值以外，表达式计算过程中也可能发生一些类型转换。在表达式中，类型提升规则如下： 》所有byte/short/char都被提升为int。 》如果有一个操作数为long，整个表达式提升为long。float和double情况也一样。 Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Grafikcodes der Java-Grunddatentypen (Anordnung der Leistungsknoten). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!double d2 = 11.4;
double d3 = 1.23E3;
double d4 = 10D;
double d5 = 0.4D;
float f1 = 10;
float f2 = 11.1F;
float f3 = 1.23e-4F;
float f4 = 1.23E0F;</span>
byte <（short=char）< int < long < float < double
》int--> float
》long--> float
》long--> double
》float -->double without strictfp
byte b;
b = (byte)a;//1</span>
