Was sind die acht grundlegenden Datentypen?

Die acht grundlegenden Datentypen sind: 1. 4 Ganzzahltypen (Byte, Short, Int, Long); 2. 2 Gleitkommatypen (Float, Double); 1 Zeichentyp „char“; „Boolescher Wert“.

Die Betriebsumgebung dieses Tutorials: Windows7-System, Java8-Version, DELL G3-Computer.

8 grundlegende Datentypen

In Java gibt es 8 grundlegende Datentypen, die zum Speichern von Ganzzahlen, Gleitkommazahlen, Zeichendaten und booleschen Daten verwendet werden. Es ist zu beachten: Was jetzt eingeführt wird, sind nur die grundlegenden Datentypen, und viele nicht grundlegende Datentypen werden später eingeführt. Die grundlegenden Datentypen sind in Abbildung 1 dargestellt:

Abbildung - 1

Wie aus Abbildung - 1 ersichtlich ist, sind die grundlegenden Datentypen hauptsächlich in 4 Kategorien unterteilt (Ganzzahltyp, Gleitkomma). Typ, Char, Boolean), Integer-Typen sind in 4 Unterkategorien unterteilt (Byte, Short, Int, Long) und Gleitkommatypen sind ebenfalls in 2 Unterkategorien unterteilt (Float, Double). Was sind die Unterschiede zwischen diesen Datentypen? Abbildung 2 zeigt den Speicherplatz und die Nutzungsszenarien dieser 8 Datentypen:

Abbildung -2

Unter den 8 oben genannten Datentypen gibt es die 5 am häufigsten verwendeten, nämlich int, long, double, char, boolean. Die übrigen Datentypen werden fast nicht verwendet. Sie müssen sich auf die Beherrschung dieser fünf grundlegenden Datentypen konzentrieren. Wenn Sie mehr über die anderen Datentypen erfahren möchten.

2. Int-Typ

int ist der am häufigsten verwendete Integer-Typ, der 4 Bytes belegt, was 32 Bit Speicherplatz entspricht. Der maximale Darstellungsbereich von Int beträgt: -231 ~ 231-1, also -2147483648 ~ 2147483647, was etwa plus oder minus 2,1 Milliarden entspricht.

2.2. Integer-Literale sind int-Typen

Die sogenannten Integer-Literale (literal) sind direkt geschriebene Ganzzahlen. In der folgenden Anweisung ist 100 ein Literal.

int a = 100；
int a = 100；

Bei Integer-Literalen müssen Sie auf die folgenden Punkte achten:

Der Typ von Integer-Literalen ist standardmäßig der Typ

int. Wenn die direkt geschriebene Ganzzahl den Ausdrucksbereich von int überschreitet, tritt ein Kompilierungsfehler auf. Die folgende Anweisung ist ein Kompilierungsfehler, der durch das Überschreiten des Ganzzahlbereichs verursacht wird.

int d = 10000000000; // 编译错误10000000000这个数值写出来就是错误的，因为Java认为所有直接写出的整数都是int类型，而这个数值超过了int的表达范围。
int d = 10000000000; // 编译错误10000000000这个数值写出来就是错误的，因为Java认为所有直接写出的整数都是int类型，而这个数值超过了int的表达范围。

Zusätzlich zur üblichen dezimalen Zahlenform können ganzzahlige Literale auch in hexadezimaler Form (beginnend mit 0X oder 0x) oder oktaler Form (beginnend mit 0) geschrieben werden :

int a = 100000; // 10进制 
int b = 0x186a0; // 16进制 
int c = 0303240; // 8进制 
int a = 100000; // 10进制
int b = 0x186a0; // 16进制
int c = 0303240; // 8进制

2.3. Runden bei der Division ganzer Zahlen

Wenn zwei ganze Zahlen dividiert werden, wird der Dezimalteil verworfen (Hinweis: nicht gerundet) und das Ergebnis ist ebenfalls eine ganze Zahl. Der Beispielcode lautet wie folgt:

int c = 5/3;
System.out.println(c);  // c的值为1，取整
int total = 87;    
int error = 23;
int percent = error / total * 100;
System.out.println(percent+"%");  //结果为0%，23除以87整数部分为0，乘以100，为0 
percent = 100 * error / total;
System.out.println(percent + "%");  // 结果为26%，230除以87整数部分为26 
int c = 5/3;
System.out.println(c);  // c的值为1，取整
int total = 87;    
int error = 23;
int percent = error / total * 100;
System.out.println(percent+"%");  //结果为0%，23除以87整数部分为0，乘以100，为0
 
percent = 100 * error / total;
System.out.println(percent + "%");  // 结果为26%，230除以87整数部分为26

2.4. Überlauf während des Betriebs verhindern

Wenn zwei Ganzzahlen verarbeitet werden,

kann das Ergebnis den Bereich der Ganzzahl überschreiten und es kommt zu einem Überlauf und wenn ein Überlauf auftritt, ist das Ergebnis eine negative Zahl; wenn eine negative Zahl zu groß ist, ist das Ergebnis eine positive Zahl. Der Beispielcode lautet wie folgt:

int a = 2147483647;    //int类型整数的上限
int b = -2147483648;    //int类型整数的下限
a = a + 1;
b = b - 1;
System.out.println("a=" + a);    //输出结果： a=-2147483648 溢出，结果错误。 
System.out.println("b=" + b);    //输出结果： b=2147483647溢出，结果错误。 
int a = 2147483647;    //int类型整数的上限
int b = -2147483648;    //int类型整数的下限
a = a + 1;
b = b - 1;
System.out.println("a=" + a);    //输出结果： a=-2147483648 溢出，结果错误。
System.out.println("b=" + b);    //输出结果： b=2147483647溢出，结果错误。

3. Long-Typ

Wenn bei der Darstellung einer Ganzzahl der Bereich des int-Typs nicht ausreicht, können Sie den Long-Typ verwenden Typ, eine Variable vom langen Typ, die 8 Bytes (dh 64 Bit) belegt. Der maximale Darstellungsbereich beträgt: -263 ~ 263-1, dh -9223372036854775808 ~ 9223372036854775807.

Wenn Sie eine lange direkte Menge ausdrücken möchten, muss diese mit L oder l enden. Der Beispielcode lautet wie folgt:

long a = 10000000000;   //会有编译错误，因为10000000000编译器认为是int类型，而这个值，已经超出了int的范围
long b = 10000000000l;   //正确
long a = 10000000000;   //会有编译错误，因为10000000000编译器认为是int类型，而这个值，已经超出了int的范围
long b = 10000000000l;   //正确

3.2. Verwenden Sie den Long-Typ für große Ganzzahloperationen. Für große Ganzzahloperationen (die den Ausdrucksbereich von int überschreiten) können Sie den Long-Typ verwenden. Der Beispielcode lautet wie folgt:

long distance1 = 10000 * 365 * 24 * 60 * 60 * 299792458l;  
//必须有一个long型数据参与的运算结果才是long型 
System.out.println("distance1="+distance1);//distance1=547836957965889536 结果正确 
long distance2 = 10000 * 365 * 24 * 60 * 60 * 299792458; 
System.out.println("distance2="+ distance2);  //distance2=-1973211136 溢出，=号后面的数据默认为int类型，超出了范围，发生溢出。
long distance1 = 10000 * 365 * 24 * 60 * 60 * 299792458l;  
//必须有一个long型数据参与的运算结果才是long型
System.out.println("distance1="+distance1);//distance1=547836957965889536 结果正确
 
long distance2 = 10000 * 365 * 24 * 60 * 60 * 299792458;
System.out.println("distance2="+ distance2);  //distance2=-1973211136 溢出，=号后面的数据默认为int类型，超出了范围，发生溢出。

3.3. Datum und Uhrzeit in Millisekunden speichern

JDK stellt die Methode System.currentTimeMillis() bereit, die die Anzahl der Millisekunden zurückgibt, die vom 1. Januar 1970 bis 0:00 Uhr vergangen sind dieser Moment, data Es ist zu groß, daher ist sein Datentyp lang. Der Beispielcode lautet wie folgt:

long time = System.currentTimeMillis();
System.out.println(time);     //输出的结果为： 1383835712828
long time = System.currentTimeMillis();
System.out.println(time);     //输出的结果为： 1383835712828

Wie Sie dem obigen Code entnehmen können, hat das Ausgabeergebnis den Maximalwert des

int-Typs überschritten. Daher ist der vom JDK entworfene Rückgabetyp lang, und diese Methode ist es auch Wird häufig für Zeitmessungsoperationen verwendet.

4. double类型

4.1. 使用double进行浮点数的运算

前面所学习的int、long都是用于存储整数的，小数即为浮点数，包括： float（单精度）和double（双精度），double类型的精度值是float类型的两倍，因此而得名双精精，在实际的应用开发中，float应用极少，大多数场合使用double表示浮点数。示例代码如下：

double pi = 3.14;
double r = 8;
double s = pi * r * r;
System.out.println("s=" + s);   // 输出的结果为：s=200.96
double pi = 3.14;
double r = 8;
double s = pi * r * r;
System.out.println("s=" + s);   // 输出的结果为：s=200.96

4.2. 浮点数直接量是double类型

浮点数的直接量有两种写法：1）通常写法，如：3.14、314、0.1、.5。 2）科学计数法，如：1.25E2、1.25e2、1.25E-2。其中，1.25E2表示1.25乘以10的2次方。

默认的浮点直接量为double型，如果需要表示float类型的直接量，需要加“f”或“F”后缀。例如：

float f1 = 3.14   //编译错误，应该写成3.14f
float f1 = 3.14   //编译错误，应该写成3.14f

4.3. double运算时会出现舍入误差

2进制系统中无法精确的表示1/10，就好像十进制系统中无法精确的表示1/3一样，

所以，2进制表示10进制会有一些舍入误差，对于一些要求精确运算的场合会导致代码的缺陷。示例代码如下所示：

double money = 3.0; 
double price = 2.9; 
System.out.println(money - price);   //输出的结果是： 0.10000000000000009 
double money = 3.0;
double price = 2.9;
System.out.println(money - price);   //输出的结果是： 0.10000000000000009

如果需要精确的运算可以考虑放弃使用double或float而采用BigDecimal 类来实现。关于这一点，将在后续的章节中介绍。

5. char类型

5.1. char类型

字符类型char事实上是一个16位无符号整数（都是正数），这个值是对应字符的编码，Java字符类型采用Unicode字符集编码（通用码、统一码、万国码），而Unicode是世界通用的定长字符集，所有的字符都是16位来表示。例如：字符a实际的值为97，字符A实际的值为65，字符0实际的值为48。

字符直接量可以采用诸如：‘中’的形式，也可以采用16进制的表示形式，例如： ‘\u4e2d’，代码如下所示：

char c1 = ‘中’;   //c1中存的是”中”的编码 
char c2 = '\u4e2d';   //‘4e2d’为‘中’所对应的16位Unicode编码的16进制表示形式
System.out.println(c1);
System.out.println(c2);
char c1 = ‘中’;   //c1中存的是”中”的编码
char c2 = '\u4e2d';   //‘4e2d’为‘中’所对应的16位Unicode编码的16进制表示形式
System.out.println(c1);
System.out.println(c2);

如上代码的输出结果：c1的值为中，c2值也为中，但c1和c2内部存储的其实是”中”这个字符所对应的Unicode码，即：一个无符号的整数。

5.2. 对char型变量赋值

在对char型变量赋值时，可以采用如下三种方式：

方式一：

字符直接量：形如‘A’，变量中实际存储的是该字符的Unicode编码（无符号整数值），一个char型变量只能存储一个字符。示例如下：

char c1 = 'A';   
char c1 = 'A';

方式二：

整型直接量：范围在0~65535之间的整数，变量中实际存储的即该整数值，但表示的是该整数值所对应的Unicode字符。示例如下：

char c2 = 65;    
char c2 = 65;

Unicode形式：形如‘\u0041’,Unicode字符的16进制形式。示例如下：

char c3 = '\u0041'; 
char c3 = '\u0041';

5.3. 使用转义字符

字符直接量需要包含在一对’’单引号之中，那如果想表示单引号’的字符时，需要怎么表示？想表示回车、换行符时，怎么表示？

因为单引号为特殊意义的字符， 那么，对于不方便输出的字符可以采用转义字符来表示，示例代码如下：

char c = '\\';
System.out.println(c);  //输出的结果为：\ 
char c = '\\';
System.out.println(c);  //输出的结果为：\

常用转义字符如下图 – 2所示：

 

图- 2

6. boolean类型

6.1. 使用boolean变量进行关系运算

boolean类型适用于关系、逻辑运算， 表示某个条件是否成立， 只允许取值true或false，true表示条件成立， 而false表示条件不成立。

boolean型变量经常用于存储关系运算的结果，所谓关系运算就是比较两个变量的大小相等等关系（此知识点，后续详细介绍）。boolean示例代码如下所示：

int age = 18;
boolean isChild = age<16;  
System.out.println(isChild);   // isChild的值为false
boolean running = true; 
boolean closed = false; 
int age = 18;
boolean isChild = age<16;  
System.out.println(isChild);   // isChild的值为false
boolean running = true;
boolean closed = false;

7. 基本类型间转换

7.1. 类型间转换

不同的基本类型直接可以相互转化，主要有两种方式：

自动类型转化（隐式类型转换）：从小类型到大类型可以自动完成。类型的大小关系如下图 - 3所示：

 

图- 3

强制转化：从大类型到小类型需要强制转换符，语法如下：

（需要转换成的类型）变量

因为大类型的精度值大于小类型，取值范围大于小类型，所以，当使用强制转化时，有可能会造成精度的损失或者溢出，所以，在使用强制转化时要求显式的告诉编译器，正在进行强制转换。

7.2. 强制转换时的精度丧失和溢出

基本类型转化如下示例所示，注意强制转换时可能会造成的精度丧失和溢出。

int a = 100;
int b = 200;
long c = a + b;  //自动将int转化为long 
long l1 = 1024l; 
int i = (int) l1;  //需要加强制转化符由于1024在int的范围内，所以没有产生溢出 
long l = 1024L * 1024 * 1024 * 4;
int j = (int) l;    //会产生溢出
System.out.println(j);  // 结果为：0 
double pi = 3.1415926535897932384;
float f = (float) pi;   //会造成精度的损失，因为单精度的精确度小于double
System.out.println(f);  //结果为：3.1415927 
int a = 100;
int b = 200;
long c = a + b;  //自动将int转化为long
 
long l1 = 1024l;
int i = (int) l1;  //需要加强制转化符由于1024在int的范围内，所以没有产生溢出
 
long l = 1024L * 1024 * 1024 * 4;
int j = (int) l;    //会产生溢出
System.out.println(j);  // 结果为：0
 
double pi = 3.1415926535897932384;
float f = (float) pi;   //会造成精度的损失，因为单精度的精确度小于double
System.out.println(f);  //结果为：3.1415927

7.3. 数值运算时的自动转换

如果在一个表达式中出现了多种数据类型，则运算结果会自动的向较大的类型进行转化，

示例如下：

//由于有long型的直接量参与，整个表达式的结果为long 
long distance = 10000 * 365 * 24 * 60 * 60 * 299792458l;
 
//由于有double型的直接量599.0参与，整个表达式的结果为 double 
double change = 800 - 599.0;
    
//结果为0.0，右边都是int型数据运算结果也为int类型，结果为0，再赋值给double
将0转化为 0.0
double persent1 = 80 / 100;  
//结果为0.8，右边表达式有double型直接量参与， 运算结果为double型
double persent2 = 80.0 / 100;  
//由于有long型的直接量参与，整个表达式的结果为long
long distance = 10000 * 365 * 24 * 60 * 60 * 299792458l;
 
//由于有double型的直接量599.0参与，整个表达式的结果为 double
double change = 800 - 599.0;
    
//结果为0.0，右边都是int型数据运算结果也为int类型，结果为0，再赋值给double
型，将0转化为 0.0
double persent1 = 80 / 100;
    
//结果为0.8，右边表达式有double型直接量参与， 运算结果为double型
double persent2 = 80.0 / 100;

7.4. byte、char、short转换为int

在前面所介绍的8种数据类型中，byte、char、short、int、long都表示整数类型，而整型的直接量为int，在实际使用中，为了方便使用，遵循了如下的规则：

int直接量可以直接赋值给byte、char和short，只要不超过其表示范围。示例如下：

byte  b  = 97;
short  s  = 97;
char  c  = 97;
byte  b  = 97;
short  s  = 97;
char  c  = 97;

byte、char、short三种类型参与运算时，先一律转换成int类型再进行运算。示例如下：

byte  b  =  97;
int  num = b + b;   //num的值为194

相关视频教程推荐：Java视频教程

Das obige ist der detaillierte Inhalt vonWas sind die acht grundlegenden Datentypen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!