Java/Datentypen: Unterschied zwischen den Versionen
Markierung: 2017-Quelltext-Bearbeitung |
(-l) Markierung: 2017-Quelltext-Bearbeitung |
||
Zeile 1: | Zeile 1: | ||
== Einstieg == | ==Einstieg== | ||
{{Idee| | {{Idee| | ||
* Gerade für Anfänger ist es sinnvoll, die Möglichkeiten der Programmiersprache zunächst nicht auszuschöpfen. Es genügen für Zahlen die Datentypen <code>double</code> und <code>int</code> für nahezu alle Anwendungen. | * Gerade für Anfänger ist es sinnvoll, die Möglichkeiten der Programmiersprache zunächst nicht auszuschöpfen. Es genügen für Zahlen die Datentypen <code>double</code> und <code>int</code> für nahezu alle Anwendungen. | ||
Zeile 22: | Zeile 22: | ||
vgl. [[Java/Online-Bank#Die_Klasse_Konto|Java-Reader: Kapitel 3]] | vgl. [[Java/Online-Bank#Die_Klasse_Konto|Java-Reader: Kapitel 3]] | ||
=== Elementare numerische Datentypen in Java === | ===Elementare numerische Datentypen in Java=== | ||
{| {{prettytable}} | {| style="margin:1em 1em 1em 0; border:solid 1px #AAAAAA; border-collapse:collapse; background-color:#F9F9F9; empty-cells:show; font-size:95%" rules="all" cellspacing="0" cellpadding="4" {{prettytable}} | ||
! Datentyp | !Datentyp | ||
! Größe | !Größe | ||
! Wrapper-Klasse | !Wrapper-Klasse | ||
! Wertebereich | !Wertebereich | ||
! Beschreibung | !Beschreibung | ||
|----- | |----- | ||
| byte ||align="right"| 8 Bit || java.lang.Byte | |byte|| align="right" |8 Bit||java.lang.Byte | ||
| −128 ... +127 | |−128 ... +127 | ||
| Zweierkomplement-Wert | |Zweierkomplement-Wert | ||
|----- | |----- | ||
| short ||align="right"| 16 Bit || java.lang.Short | |short|| align="right" |16 Bit||java.lang.Short | ||
| −32.768 ... +32.767 | |−32.768 ... +32.767 | ||
| Zweierkomplement-Wert | |Zweierkomplement-Wert | ||
|----- | |----- | ||
| int ||align="right"| 32 Bit || java.lang.Integer | |int|| align="right" |32 Bit||java.lang.Integer | ||
| −2.147.483.648 ... +2.147.483.647 | |−2.147.483.648 ... +2.147.483.647 | ||
| Zweierkomplement-Wert | |Zweierkomplement-Wert | ||
|----- valign="top" | |----- valign="top" | ||
| long ||align="right"| 64 Bit || java.lang.Long | |long|| align="right" |64 Bit||java.lang.Long | ||
| −9.223.372.036.854.775.808 ...<br />+9.223.372.036.854.775.807 | |−9.223.372.036.854.775.808 ...<br />+9.223.372.036.854.775.807 | ||
| Zweierkomplement-Wert | |Zweierkomplement-Wert | ||
|----- | |----- | ||
| float ||align="right"| 32 Bit || java.lang.Float | |float|| align="right" |32 Bit||java.lang.Float | ||
| ±1,4E−45 ... ±3,4E+38 | |±1,4E−45 ... ±3,4E+38 | ||
| [[Gleitkommazahl]] ) | |[[Gleitkommazahl]] ) | ||
|----- valign="top" | |----- valign="top" | ||
| double ||align="right"| 64 Bit || java.lang.Double | |double|| align="right" |64 Bit||java.lang.Double | ||
| ±4,9E−324 ... ±1,7E+308 | |±4,9E−324 ... ±1,7E+308 | ||
| Gleitkommazahl doppelter Genauigkeit (IEEE 754) | |Gleitkommazahl doppelter Genauigkeit (IEEE 754) | ||
|} | |} | ||
nach {{wpde|Java-Syntax}} | nach {{wpde|Java-Syntax}} | ||
== primitive Datentypen == | ==primitive Datentypen== | ||
{| | {| | ||
|- | |- | ||
! | ! | ||
! Size (bits) | !Size (bits) | ||
! Example | !Example | ||
! Minimum Value | !Minimum Value | ||
! Maximum Value | !Maximum Value | ||
! Wrapper Objects | !Wrapper Objects | ||
|- | |- | ||
![[char]] | ![[char]] | ||
| 16 | |16 | ||
| char c = 'A'; | |char c = 'A'; | ||
| Unicode 0 | |Unicode 0 | ||
| Unicode 2<sup>16</sup>-1 | |Unicode 2<sup>16</sup>-1 | ||
| Character | |Character | ||
|- | |- | ||
![[short]] | ![[short]] | ||
| 16 | |16 | ||
| short s = 65; | |short s = 65; | ||
| -2<sup>15</sup> | | -2<sup>15</sup> | ||
| 2<sup>15</sup>-1 | |2<sup>15</sup>-1 | ||
| Short | |Short | ||
|- | |- | ||
![[int]] | ![[int]] | ||
| 32 | |32 | ||
| int i = 65; | |int i = 65; | ||
| -2<sup>31</sup> | | -2<sup>31</sup> | ||
| 2<sup>31</sup>-1 | |2<sup>31</sup>-1 | ||
| Integer | |Integer | ||
|- | |- | ||
![[long]] | ![[long]] | ||
| 64 | |64 | ||
| long l = 65l; | |long l = 65l; | ||
| -2<sup>63</sup> | | -2<sup>63</sup> | ||
| 2<sup>63</sup>-1 | |2<sup>63</sup>-1 | ||
| Long | |Long | ||
|- | |- | ||
![[float]] | ![[float]] | ||
| 32 | |32 | ||
| float f = 65f; | |float f = 65f; | ||
| | | | ||
| Float | | | ||
|Float | |||
|- | |- | ||
![[double]] | ![[double]] | ||
| 64 | |64 | ||
| double d = 65.55d; | |double d = 65.55d; | ||
| | | | ||
| | | | ||
| Double | |Double | ||
|- | |- | ||
![[byte]] | ![[byte]] | ||
| 8 | |8 | ||
| byte b = 65; | |byte b = 65; | ||
| -128 | | -128 | ||
| 127 | |127 | ||
| Byte | |Byte | ||
|- | |- | ||
![[boolean]] | ![[boolean]] | ||
| 1 | |1 | ||
| boolean b = true; | |boolean b = true; | ||
| | | | ||
| | | | ||
| Boolean | |Boolean | ||
|- | |- | ||
![[void]] | ![[void]] | ||
Zeile 129: | Zeile 129: | ||
| -- | | -- | ||
| -- | | -- | ||
| Void | |Void | ||
|- | |- | ||
|} | |} | ||
== Casting in Java == | ==Casting in Java== | ||
Casting nennt man die '''Überführung eines Datentypen in einen Anderen'''. Wie man an der Tabelle zu Beginn dieser Seite sehen kann, gibt es verschiedene '''Basisdatentypen''' (boolean, Ganzzahl, Gleitkomma) mit verschiedener Größe (Bit). So sind z.B. int und byte beide Ganzzahl-Datentypen. int ist aber wesentlich '''mächtiger''' (hat mehr Bytes) als byte. Wie man sich jetzt einfach vorstellen kann ist es kein Problem vom kleineren Typ (byte) eine Zuweisung zum mächtigeren Typ (int) zu machen, da hier kein Verlust in der Genauigkeit oder der Darstellbarkeit auftreten kann. In diesem Fall nimmt unser Java-Laufzeitsystem ein '''implizites "automatisches" Casting''' vor. Anders herum ist es aber möglich mit int Zahlen zu beschreiben, die mit byte nicht mehr dargestellt werden können. Darum braucht man für diese Richtung (vom mächtigeren Typ zum kleineren Typ) ein '''explizites Casting'''. Dazu wird bei der Zuweisung der Zieldatentyp in Klammern vor den zuzuweisenden Wert gesetzt. Damit wird der Zuzuweisende Wert zuerst in den gewünschten Datentyp umgewandelt und im zweiten Schritt dem Zieldatentypen zugewiesen. Dazu ein kleines Beispiel: | Casting nennt man die '''Überführung eines Datentypen in einen Anderen'''. Wie man an der Tabelle zu Beginn dieser Seite sehen kann, gibt es verschiedene '''Basisdatentypen''' (boolean, Ganzzahl, Gleitkomma) mit verschiedener Größe (Bit). So sind z.B. int und byte beide Ganzzahl-Datentypen. int ist aber wesentlich '''mächtiger''' (hat mehr Bytes) als byte. Wie man sich jetzt einfach vorstellen kann ist es kein Problem vom kleineren Typ (byte) eine Zuweisung zum mächtigeren Typ (int) zu machen, da hier kein Verlust in der Genauigkeit oder der Darstellbarkeit auftreten kann. In diesem Fall nimmt unser Java-Laufzeitsystem ein '''implizites "automatisches" Casting''' vor. Anders herum ist es aber möglich mit int Zahlen zu beschreiben, die mit byte nicht mehr dargestellt werden können. Darum braucht man für diese Richtung (vom mächtigeren Typ zum kleineren Typ) ein '''explizites Casting'''. Dazu wird bei der Zuweisung der Zieldatentyp in Klammern vor den zuzuweisenden Wert gesetzt. Damit wird der Zuzuweisende Wert zuerst in den gewünschten Datentyp umgewandelt und im zweiten Schritt dem Zieldatentypen zugewiesen. Dazu ein kleines Beispiel: | ||
Zeile 168: | Zeile 168: | ||
;Eine entsprechende Tabelle: | ;Eine entsprechende Tabelle: | ||
{| | {| | ||
|- | |- | ||
! | ! | ||
! Size (bits) | !Size (bits) | ||
! Example | !Example | ||
! Minimum Value | !Minimum Value | ||
! Maximum Value | !Maximum Value | ||
! Wrapper Objects | !Wrapper Objects | ||
|- | |- | ||
![[char]] | ![[char]] | ||
| 16 | |16 | ||
| char c = 'A'; | |char c = 'A'; | ||
| Unicode 0 | |Unicode 0 | ||
| Unicode 2<sup>16</sup>-1 | |Unicode 2<sup>16</sup>-1 | ||
| Character | |Character | ||
|- | |- | ||
![[int]] | ![[int]] | ||
| 32 | |32 | ||
| int i = 65; | |int i = 65; | ||
| -2<sup>31</sup> | | -2<sup>31</sup> | ||
| 2<sup>31</sup>-1 | |2<sup>31</sup>-1 | ||
| Integer | |Integer | ||
|- | |- | ||
![[double]] | ![[double]] | ||
| 64 | |64 | ||
| double d = 65.55d; | |double d = 65.55d; | ||
| | | | ||
| | | | ||
| Double | |Double | ||
|- | |- | ||
![[boolean]] | ![[boolean]] | ||
| 1 | |1 | ||
| boolean b = true; | |boolean b = true; | ||
| | | | ||
| | | | ||
| Boolean | |Boolean | ||
|- | |- | ||
![[void]] | ![[void]] | ||
Zeile 210: | Zeile 211: | ||
| -- | | -- | ||
| -- | | -- | ||
| Void | |Void | ||
|- | |- | ||
|} | |} | ||
== Casting primitiver Datentypen in tabellarischer Übersicht == | ==Casting primitiver Datentypen in tabellarischer Übersicht== | ||
The following table shows the conversions between primitive types, it shows the casting operation for explicit conversions: | The following table shows the conversions between primitive types, it shows the casting operation for explicit conversions: | ||
Zeile 220: | Zeile 221: | ||
|- | |- | ||
! | ! | ||
! from | !from char | ||
! from | !from short | ||
! from | !from int | ||
! from | !from long | ||
! from | !from float | ||
! from | !from double | ||
! from | !from byte | ||
! from | !from boolean | ||
|- | |- | ||
! to | !to char | ||
| - | | - | ||
| (char) | |(char) | ||
| (char) | |(char) | ||
| (char) | |(char) | ||
| (char) | |(char) | ||
| (char) | |(char) | ||
| | | | ||
| N/A | |N/A | ||
|- | |- | ||
! to | !to short | ||
| (short) | |(short) | ||
| - | | - | ||
| (short) | |(short) | ||
| (short) | |(short) | ||
| (short) | |(short) | ||
| (short) | |(short) | ||
| | | | ||
| N/A | |N/A | ||
|- | |- | ||
! to | !to int | ||
| | | | ||
| | | | ||
| - | | - | ||
| (int) | |(int) | ||
| (int) | |(int) | ||
| (int) | |(int) | ||
| | | | ||
| N/A | |N/A | ||
|- | |- | ||
! to | !to long | ||
| | | | ||
| | | | ||
| | | | ||
| - | | - | ||
| (long) | |(long) | ||
| (long) | |(long) | ||
| | | | ||
| N/A | |N/A | ||
|- | |- | ||
! to | !to float | ||
| | | | ||
| | | | ||
| | | | ||
| | | | ||
| - | | - | ||
| (float) | |(float) | ||
| | | | ||
| N/A | |N/A | ||
|- | |- | ||
! to | !to double | ||
| | | | ||
| | | | ||
| | | | ||
| | | | ||
| | | | ||
| - | | - | ||
| | | | ||
| N/A | |N/A | ||
|- | |- | ||
! to | !to byte | ||
| (byte) | |(byte) | ||
| (byte) | |(byte) | ||
| (byte) | |(byte) | ||
| (byte) | |(byte) | ||
| (byte) | |(byte) | ||
| (byte) | |(byte) | ||
| - | | - | ||
| N/A | |N/A | ||
|- | |- | ||
! to | !to boolean | ||
| N/A | |N/A | ||
| N/A | |N/A | ||
| N/A | |N/A | ||
| N/A | |N/A | ||
| N/A | |N/A | ||
| N/A | |N/A | ||
| N/A | |N/A | ||
| - | | - | ||
|- | |- | ||
Zeile 331: | Zeile 332: | ||
==Siehe auch== | ==Siehe auch== | ||
* [[Java]] | |||
* [[Informatik]] | *[[Java]] | ||
* [[Mathematik]] | *[[Informatik]] | ||
*[[Mathematik]] | |||
[[Kategorie:Java]] | [[Kategorie:Java]] | ||
[[Kategorie:Unterrichtsidee]] | [[Kategorie:Unterrichtsidee]] | ||
[[Kategorie:Informatik]] | [[Kategorie:Informatik]] |
Version vom 21. November 2021, 05:31 Uhr
Einstieg
- Gerade für Anfänger ist es sinnvoll, die Möglichkeiten der Programmiersprache zunächst nicht auszuschöpfen. Es genügen für Zahlen die Datentypen
double
undint
für nahezu alle Anwendungen. - Thematisiert werden sollte das Verlassen des Gültigkeitsbereiches und die amerikanische Schreibweise (
.
statt,
).
Regel: Es gilt die amerikanische Zahlennotation: Punkt statt Komma.Die Zahl 7,34 wird in Java 7.34 geschrieben
- Welchen Datentypen würden Sie wählen:
- Simulation eines Thermometers
- „Was bin ich“-Fragen
- TOP 10 Chartposition
- Preise im Supermarkt
- Personalausweisnummer
- Was macht Java, wenn der Wertebereich einer Variable verlassen wird?
- Was macht Java, wenn man eine int Variable so dividiert, dass keine ganze Zahl herauskommt?
- Was macht Java, wenn man durch 0 dividieren möchte?
Elementare numerische Datentypen in Java
Datentyp | Größe | Wrapper-Klasse | Wertebereich | Beschreibung |
---|---|---|---|---|
byte | 8 Bit | java.lang.Byte | −128 ... +127 | Zweierkomplement-Wert |
short | 16 Bit | java.lang.Short | −32.768 ... +32.767 | Zweierkomplement-Wert |
int | 32 Bit | java.lang.Integer | −2.147.483.648 ... +2.147.483.647 | Zweierkomplement-Wert |
long | 64 Bit | java.lang.Long | −9.223.372.036.854.775.808 ... +9.223.372.036.854.775.807 |
Zweierkomplement-Wert |
float | 32 Bit | java.lang.Float | ±1,4E−45 ... ±3,4E+38 | Gleitkommazahl ) |
double | 64 Bit | java.lang.Double | ±4,9E−324 ... ±1,7E+308 | Gleitkommazahl doppelter Genauigkeit (IEEE 754) |
nach Java-Syntax
primitive Datentypen
Size (bits) | Example | Minimum Value | Maximum Value | Wrapper Objects | |
---|---|---|---|---|---|
char | 16 | char c = 'A'; | Unicode 0 | Unicode 216-1 | Character |
short | 16 | short s = 65; | -215 | 215-1 | Short |
int | 32 | int i = 65; | -231 | 231-1 | Integer |
long | 64 | long l = 65l; | -263 | 263-1 | Long |
float | 32 | float f = 65f; | Float | ||
double | 64 | double d = 65.55d; | Double | ||
byte | 8 | byte b = 65; | -128 | 127 | Byte |
boolean | 1 | boolean b = true; | Boolean | ||
void | -- | -- | -- | -- | Void |
Casting in Java
Casting nennt man die Überführung eines Datentypen in einen Anderen. Wie man an der Tabelle zu Beginn dieser Seite sehen kann, gibt es verschiedene Basisdatentypen (boolean, Ganzzahl, Gleitkomma) mit verschiedener Größe (Bit). So sind z.B. int und byte beide Ganzzahl-Datentypen. int ist aber wesentlich mächtiger (hat mehr Bytes) als byte. Wie man sich jetzt einfach vorstellen kann ist es kein Problem vom kleineren Typ (byte) eine Zuweisung zum mächtigeren Typ (int) zu machen, da hier kein Verlust in der Genauigkeit oder der Darstellbarkeit auftreten kann. In diesem Fall nimmt unser Java-Laufzeitsystem ein implizites "automatisches" Casting vor. Anders herum ist es aber möglich mit int Zahlen zu beschreiben, die mit byte nicht mehr dargestellt werden können. Darum braucht man für diese Richtung (vom mächtigeren Typ zum kleineren Typ) ein explizites Casting. Dazu wird bei der Zuweisung der Zieldatentyp in Klammern vor den zuzuweisenden Wert gesetzt. Damit wird der Zuzuweisende Wert zuerst in den gewünschten Datentyp umgewandelt und im zweiten Schritt dem Zieldatentypen zugewiesen. Dazu ein kleines Beispiel:
int ii = 42;
byte bb = 100;
// implizites Casting ("automatisches Casting") weil int mächtiger als byte ist
ii = bb;
// explizites Casting ("direktes Casting") weil byte weniger mächtig als int ist
bb = (byte) ii;
Casting kann auch sehr effektiv genutzt werden um z.B. die ASCII-Tabelle auszugeben. Dazu läßt man eine int-Variable von 0 bis 255 laufen und castet die jeweilige Zahl einfach nach char und erhält das entsprechende ASCII-Zeichen:
for( int i=0; i<256; i++ )
System.out.println( i+" = "+(char) i ); // Ausgabe z.B. 50 = a
Java Standard: Primitive Datentypen
- Nennen Sie günstige Anwendungsbeispiele für jeden primitiven Datentypen und grenzen Sie ihn von den anderen ab.
- Nennen Sie Beispiele, für die die Genauigkeit und der Wertebereich des Datentypen double nicht ausreicht. Wie könnte man dieses Problemn lösen?
- Erläutern Sie, wann Casting eingesetzt werden muss.
- Was passiert mit den Nachkommastellen, wenn man mit int-Variablen dividiert?
- Fortgeschrittene: Warum besitzt Java primitive Datentypen? Könnten diese nicht auch Klassen sein (wie z.B. String)?
Didaktische Reduktion
Da die Anzahl der Möglichkeiten für Anfänger sehr hoch sind, könnte die Behandlung folgender Datentypen im Unterricht zunächst ausreichend sein.:
- boolean, int, double, char, (ggf. Void)
- String
Begründung: Es genügen für fast alle Beispiele im Unterricht ein Typ für Ganze- und einer für Dezimalzahlen. Auf Speicherplatz und Geschwindigkeit muss kaum Rücksicht genommen werden.
Hervorhebung- Eine entsprechende Tabelle
Size (bits) | Example | Minimum Value | Maximum Value | Wrapper Objects | |
---|---|---|---|---|---|
char | 16 | char c = 'A'; | Unicode 0 | Unicode 216-1 | Character |
int | 32 | int i = 65; | -231 | 231-1 | Integer |
double | 64 | double d = 65.55d; | Double | ||
boolean | 1 | boolean b = true; | Boolean | ||
void | -- | -- | -- | -- | Void |
Casting primitiver Datentypen in tabellarischer Übersicht
The following table shows the conversions between primitive types, it shows the casting operation for explicit conversions:
from char | from short | from int | from long | from float | from double | from byte | from boolean | |
---|---|---|---|---|---|---|---|---|
to char | - | (char) | (char) | (char) | (char) | (char) | N/A | |
to short | (short) | - | (short) | (short) | (short) | (short) | N/A | |
to int | - | (int) | (int) | (int) | N/A | |||
to long | - | (long) | (long) | N/A | ||||
to float | - | (float) | N/A | |||||
to double | - | N/A | ||||||
to byte | (byte) | (byte) | (byte) | (byte) | (byte) | (byte) | - | N/A |
to boolean | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - |
nach: http://en.wikibooks.org/w/index.php?title=Java_Programming/Primitive_Types
Typumwandlung (typecasting) - Von double zu int zu String zu double
Die folgende Methode demonstriert, wie man in Java den Datentypen wechseln kann.
public void demonstriereDatentypWechsel(double dezimalZahl)
{
int ganzeZahl;
ganzeZahl=(int) dezimalZahl;
double dezimalZahl2;
dezimalZahl2=(double) ganzeZahl;
String eigentlichKeineZahl;
eigentlichKeineZahl=""+dezimalZahl2;
dezimalZahl2=Double.parseDouble(eigentlichKeineZahl);
ganzeZahl=Integer.parseInt(eigentlichKeineZahl);
}