02 Variablen - Print

2 - Variablen
Grundlagen der Informatik

Wintersemester 2014/15
Friedrich-Alexander-Universitt Erlangen-Nrnberg
Einfhrung
Dies sind die in der obenstehenden Vorlesung verwendeten Folien. Sie sind ausschlielich fr den persnlichen Gebrauch zur
Prfungsvorbereitung bestimmt. Eine Verffentlichung, Vervielfltigung oder Weitergabe ist ohne unsere schriftliche
Zustimmung nicht gestattet.
Die Folie wurde von F. Bauer und vom Lehrstuhl fr Informatik 9 erstellt.
Friedrich-Alexander-Universitt Erlangen-Nrnberg
Erlangen, 07. April 2014 F. Bauer
Arbeitsspeicher
Gedankenexperiment
Was ergibt (7+3) * 12?
(7 +10
3) 120
* 12
Zusammengefasst:
Zuerst rechnen wir (oder die meisten) 7 + 3 = 10
Wir merken uns den Wert 10
Jetzt ersetzen wir in der Originalrechnung den Term (7+3) durch dem gemerkten Wert 10
und rechnen 10 * 12 = 120
Um das Ergebnis zu bestimmen, mssen wir nicht nur Rechenregeln anwenden (das erledigt die CPU)
knnen, sondern brauchen auch die Mglichkeit, uns Zwischenergebnisse zu merken.
Arbeitsspeicher =
Erinnerungsvermgen
Formal kann man das Ergebnis mithilfe einer (Hilfs-)Variablen in zwei Schritten bestimmen:
k = (7+3)
k*12
www.oldcalculatormuseum.com
Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik
Variablen in Java Schreibtischlauf
Variablen in Java
Rechnung formal
und in Java
k = (7+3)
k*12
k = 7 + 3;
int k;
ergebnis
= k * 12;
kint
=* 712;
+ 3;
1
2
Hier wird
4 int ergebnis;
gerechnet, aber das
5 ergebnis = k * 12;
Kan man noch
Ergebnis wird nicht
bersichtlicher
gespeichert!
schreiben
nach Zeile
Arbeitsspeicher
1
2
int k;
k = 7 + 3;
4
5
int ergebnis;
ergebnis = k * 12;
nach Zeile
1
2
int k;
k = 7 + 3;
4
5
int ergebnis;
ergebnis = k * 12;
Arbeitsspeicher
nach Zeile
1
2
int k;
k = 10
7 + 3;
4
5
int ergebnis;
ergebnis = k * 12;
Arbeitsspeicher
k
k
10
nach Zeile
1
2
int k;
k = 7 + 3;
4
5
int ergebnis;
ergebnis = k * 12;
Arbeitsspeicher
nach Zeile
k
10
k
ergeb.
10
1
2
int k;
k = 7 + 3;
4
5
int ergebnis;
ergebnis = 120
k ** 12
12;
10
ergeb.
10
10
Arbeitsspeicher
ergeb.
10
120
10
Deklaration einer Variable

Variablen knnen nur innerhalb von Methoden angelegt (deklariert) werden.
Formal wird eine Variable in Java wie folgt deklariert:
2 - Variablen
in Java
<Datentyp> <Variablenname>;
Also zum Beispiel:
1
2
3
int a;
float x3;
int meineGroesse;
Nach der Deklaration hat eine Variable noch keinen Wert. Dieser muss zunchst noch zugewiesen
werden. Man spricht vom Initialisieren einer Variable.
1
2
int k;
k = 7 + 3;
4
5
int ergebnis;
ergebnis = k * 12;
oder in verkrzter Schreibweise

1 int k = 7 + 3;
2 int ergebnis = k * 12;
Das Anlegen von Variablen ist also immer ein zweistufiger Vorgang:
Variable deklarieren (also einen Platz im Arbeitsspeicher reservieren)
Werte zuweisen (also in den reservierten Platz einen Wert schreiben)
12
Deklaration einer Variable

In dieser Form ist das Programm noch nutzlos. Das Ergebnis wird zwar in einer Variablen gespeichert,
der Benutzer kann dieses aber nicht erkennen.
1
2
int k;
k = 7 + 3;
4
5
int ergebnis;
ergebnis = k * 12;
2 - Variablen
Das Ergebnis sollte dem Benutzer noch mit

System.out.println angezeigt werden.
Primitive Datentypen und Numerale

In diesem Beispiel wird eine fest vorgegebene
Zeichenkette (Ergebnis: ) mit einer Variablen
ergebnis vom Typ int durch den +-Operator
verknpft. Diese Besonderheit betrachten wir spter
noch genauer.
Das vollstndige (bersetzbare) Programm wrde wie folgt aussehen:

1
2
3
4
public class Calc {

public static void main(String[] args) {
int k = 7 + 3;
int ergebnis = k * 12;
System.out.println("Ergebnis: " + ergebnis);
6
7
8
Ergebnis: 120
13
Was sind Datentypen
Wertebereiche
Zur Erinnerung: Die Deklaration einer Variablen war wie folgt definiert: <Datentyp> <Variablenname>;
ganze Zahlen Type

Gre
Min. Wert
Max. Wert
Eine Variable hat also nicht nur einen Namen, sondern immer auch einen Datentyp. Dieser bestimmt
welche Art von Werten (Ganze Zahlen, Kommazahlen, Zeichen, Wahrheitswerte)
in welchem Wertebereich gespeichert werden knnen
und legt somit die Gre der Variablen im Arbeitsspeicher fest (grerer Bereich = mehr Speicher)
Fliekommazahlen Type
In Java gibt es 8 primitive Datentypen:

ganzzahlige Werte (integer): byte, short, int, long
Fliekommazahlen (floating point): float, double
Zeichen (character): char
Wahrheitswerte (true/false): boolean
Gre
Min. Wert
Max. Wert
short
int
long
16 Bit (2 Byte)
-32 768
32 Bit (4 Byte)
-2 147 483 648
64 Bit (8 Byte)
-2
+127
+32 767
+2 147 483 647
float
double
32 Bit (4 Byte)
1.40239846 E-45
64 Bit (8 Byte)
4.940656. . . E-324
3.40282347 E+38
1.797693. . . E+308
+2
Mit Gleitkommatypen kann die Menge der rationalen Zahlen angenhert

werden. Die Genauigkeit der gespeicherten Zahlen (ungefhr wieviele
Stellen nach dem Komma gespeichert werden knnen) hngt vom
Datentyp ab (spter mehr zu diesem Thema).
Die ganzen Zahlen sind in der Mathematik von - bis + definiert, warum also mehrere Datentypen?
Darber reden wir im Kapitel Ganze Zahlen genauer
Jetzt nur soviel: Im Rechner werden die Zahlen im 2-er System dargestellt. Der Wertebereich wird
durch die Anzahl der verfgbaren Stellen (Bits) im 2-er System vorgegeben.
Der primitive Datentyp legt fest, wie viele Stellen verwendet werden.
byte
8 Bit (1 Byte)
-128
15
16
Numerale
Numerale
Schreibt ein Programmierer in einem Programm einen Zahlenwert, so nennt man diesen ein Numeral.
int a = 5;
Die 5 ist
ein Numeral
Aber welchen Typ hat ein Numeral?

Ganzzahlige Numerale haben (ohne Zustze) den Typ int
Kommazahlen den Typ double
Deswegen ergibt die folgende Zeile einen Fehler:
1
Um ein ganzzahliges Numeral vom Typ long zu erzeugen, wird ein L oder l angehngt.
float b = 5.0;
1
2
int ai = 24;
long al = 24l;
4
5
int bi = -13;
long bl = -13l;
7
8
int ci = +8;
long cl = +8l;
10
float d = 3000000000L / 13;
Bei Fliekommazahlen kann man f, F, d oder D je nach Typ verwenden
5.0 ist ein double Wert

(64 Bit Speicherverbrauch) und
kann nicht in einem float (32 Bit
Speicherplatz) abgelegt
werden
1
2
3
4
5
6
7
8
double a =
double
double b =
double c =
double d =
double e =
double f =
double g =
double h =
0.24f; //Implizite Konvertierung float-Numeral ->

-3D;
2.;
+23d;
2e10;
2e+10D;
2e-10;
0.24;
1
2
3
4
5
6
7
float
float
float
float
float
float
float
a
b
c
d
e
f
g
=
=
=
=
=
=
=
0.24f;
-3f;
2.f;
+23F;
+2e10f;
2e+10f;
2e-10f;
Deswegen knnen Numerale um Zusatzinformationen erweitert werden:

Typangaben (l/L = long, f/F = float, d/D = double)
Vorzeichen
Exponenten (e oder E)
Dezimalpunkt (kein Komma!)
17
Wertebereiche
18
Wertebereiche
Zeichen Type
Wahrheitswerte Type
char
Gre
Min. Wert
Max. Wert
Gre
Wert
16 Bit (2 Byte)
Unicode-Zeichen
Der Grundtyp char ermglicht es, ein einzelnes Zeichen aus einem vorgegebenen Alphabet (in diesem
Fall Unicode, dazu spter mehr) zu speichern.
boolean
8 Bit (1 Byte)
false oder true
Der Grundtyp boolean speichert Ja/Nein-Entscheidungen. Der Wert einer Variablen vom Typ boolean ist
entweder false oder true.
Character-Literale werden in Hochkommata (') angegeben:

1 char c = a;
//Buchstabe a
2 char d = 97;
//Buchstabe a
3 char e = a + 4; //Buchstabe e
4 char f = \u0061; //Unicode-Kodierung des Buchstaben a
5 char g = \n;
//nicht darstellbares Sonderzeichen (Zeilenumbruch)
Der Typ char kann wie ein

ganzzahliger Datentyp verwendet
werden! (z.B. Zeile 2)
19
20
Wertzuweisungen
Eine Variable verhlt sich wie ein Behlter, in dem ein Wert gesammelt und spteren Verwendung
aufgehoben werden kann.
2 - Variablen
Zuweisungen werden bentigt, um

der Variablen einen initialen Wert zu geben
den Wert einer Variablen zu verndern
Zuweisungen
Zunchst bentigt man die Deklaration von Variablen

1
2
3
int i;
int theUltimateAnswer;
int value2;
5 i = 0;
6 theUltimateAnswer = 42;
7 value2
33%7 initialisiert
+ 35/9*2;werden
// das(Zuweisungsoperator
ist 5 + 6
Danach
mssen= diese
=)
1 int i;
2 int theUltimateAnswer;
<Variablenname> = <Ausdruck>;
3 int value2;
5
6
7
Links vom = kann immer nur

der Name einer bekannten
Variablen stehen
i = 0;
theUltimateAnswer = 42;
value2 = 33%7 + 35/9*2; // das ist 5 + 6
Wertzuweisungen
Definition
Bevor Variablen verwendet werden knnen (zum Beispiel in einem Ausdruck rechts des =), mssen diese
initialisiert worden sein. Eine Variable wird initialisiert, wenn ihr etwas zugewiesen wird, sie also in einer
Zuweisung links des = steht.
Variablen bezeichnen einen Speicherbereich, in dem Werte

eines bestimmten Typs gespeichert werden knnen. ber den
Variablennamen kann man auf den Speicherinhalt zugreifen,
ohne die Speicheradresse zu kennen.
Initialisierung
1
2
int a = 4;
int b = 3*a + 77;
4
5
int c;
int d = c*a; // Compiler-Fehler, c ist nicht initialisiert
22
Variablen in Java haben folgende Eigenschaften:

Name (auch Bezeichner)
Typ
Wert (Speicherinhalt, dem Typ entsprechend interpretiert)
Adresse des Speicherbereichs
Sichtbarkeitsbereich und Lebensdauer
Mit dem Zuweisungsoperator kann in einer Variable der Wert eines Ausdrucks gespeichert werden. Die
linke Seite der Zuweisung muss demnach eine Variable sein.
In die linksstehenden Variablen wird der Wert des Ausdrucks auf der rechten Seite geschrieben:
1
2
3
4
int z1, z2;

z1 = 10;
// z1 == 10
z2 = z1;
// z2 == 10
z2 = (z1 = 20); // z1 == 20, z2 == 20
23
24
Definition
Definition
Folgende Schlsselworte drfen nicht fr Variablennamen verwendet werden:
Die Vergabe von Namen an Variablen ist an bestimmte Regeln gebunden:

Der Name darf nur aus Buchstaben (a..z,A..Z), Ziffern (0..9) sowie den Zeichen $ und _
bestehen.
Der Name darf nicht mit einer Ziffer beginnen.
Der Name darf kein Schlsselwort sein.
1
2
3
4
5
6
7
8
9
10
11
12
13
Der Wert einer Variablen kann bei der Deklaration initialisiert werden.
1
2
3
4
5
int a1;
float a, b, c, b$3Step;
int anzahl_zeilen = 10;
char zeichen = a;
long 2Dim; // ERROR: Syntaxfehler!
abstract
assert
boolean
break
byte
case
catch
char
class
const
continue
default
do
double
else
enum
extends
final
finally
float
for
goto
if
implements
import
instanceof
int
interface
long
native
new
package
private
protected
public
return
short
static
strictfp
super
switch
synchronized
this
throw
throws
transient
try
void
volatile
while
Wird eine Variable nicht initialisiert, kann ihr spter mit dem Zuweisungsoperator = ein Wert zugewiesen
werden.
Die Bedeutung der noch unbekannten
Schlsselwrter wird im weiteren Verlauf der
Vorlesung deutlich.
Nicht initialisierte Variablen knnen nicht in Ausdrcken verwendet werden.

Also z.B. nicht rechts des = stehen
25
Konstanten
26
Variablen in der Mathematik
Variablen, die ihren Wert nicht ndern knnen, werden als Konstanten bezeichnet.
In der Mathematik fhrt folgender Ausdruck zum Widerspruch:

i = i + 1;
Bei der Definition wird das Schlsselwort final vorangestellt. Der Compiler garantiert dabei, dass die
Werte tatschlich konstant bleiben.
Wie bereits besprochen, wird in einem Java Programm zuerst die rechte Seite der Zuweisung
ausgewertet, d.h. in diesem Fall wird das Programm wie folgt ausgewertet:
lese den Wert von i,
addiere dazu den Wert 1 und
speichere das Ergebnis wieder in i.
final double PI = 3.14159265;
Der bersichtlichkeit wegen sollte bei Konstanten eine Trennung von Deklaration und Initialisierung
vermieden werden.
1
2
3
final double PI;

PI = 3.14159265; // unsch
on, aber kein Fehler
PI = 3.14159265; // Fehler beim Kompilieren
27
28
Typumwandlung
Bei der Zuweisungsoperation (und auch bei anderen Operationen, die wir noch kennenlernen werden)
geht der compiler davon aus, dass der Typ der Variablen links vom = und der des ausgewerteten
Ausdrucks rechts davon gleich sind.
2 - Variablen
Wir kennen schon ein Beispiel, wo diese Annahme falsch war, und daher das Programm nicht bersetzt
werden kann:
1 float b = 5.0;
Typumwandlung
Warum kann der Compiler aber die folgende Zeile fehlerfrei bersetzen?
1
float b = 5;
Im oberen Fall wird versucht, einen 64-Bit-double-Wert in einen 32-Bit-float-Wert zu schreiben. Dabei
geht Information (Genauigkeit) verloren, was der bersetzer verhindert.
Im unteren Fall wird eine ganze 32-Bit-Zahl in einen 32-Bit-float-Wert geschrieben. Die Werte knnen
verlustfrei umgerechnet werden.
Diese automatische Umrechnung nennt man impliziten (automatischen) type cast (Typumwandlung)
Als Merkregel: Es werden "kleinere" in "grere" Datentypen konvertiert
Der implizite cast ist werterhaltend
Implizite Typumwandlung
30
Explizite Typumwandlung
Diese
automatische Umrechnung nennt man impliziten (automatischen) type cast (Typumwandlung)

Merkregel: Es werden "kleinere" in "grere" Datentypen konvertiert
Der implizite cast ist werterhaltend
Als
Wenn eine implizite Typumwandlung nicht mglich ist, kann der Programmierer eine Typkonvertierung
(type cast) erzwingen.
Die explizite Typumwandlung erfolgt mit folgender Konstruktion im Quelltext:
(<Zieltyp>) <Ausdruck>
Die folgende Grafik zeigt, welche Typen in Java implizit in andere (entlang der Pfeile) Typen
umgewandelt werden.
byte
short
int
long
float
double
Beispiele
char
boolean
1
2
3
4
int i
float
float
float
=
f
g
h
(int) 1e3;
// i = 1000;
= (float) 10.0;
// f = 10.0f;
= (float) 10 / 3; // g = 10.0f / 3 (= 3.3333f);
= (float) (10 / 3); // h (= 10 / 3) = 3.0f;
Wichtig ist der Unterschied von Zeile 3 und 4:

In Zeile 3 wird erst die 10 in einen float-Wert umgewandelt, dann durch 3 geteilt
In Zeile 4 wird die ganzzahlige 10 durch die ganzzahlige 3 geteilt und das Ergebnis in einen floatWert umgewandelt
In Zeile 4 wre die explizite Typumwandlung nicht ntig gewesen
31
32
Typumwandlung Beispiele
Typumwandlung Zeichen
Folgende Beispiele fhren zu einem Compilerfehler (da kein impliziter type cast mglich ist):
1
2
3
4
int i
int j
int k
float
=
=
=
f
1e3;
// Kein impliziter
3123456789; // Das literal vom
3123456789L; // Kein impliziter
= 10.0;
// Kein impliziter
Zeichen knnen in eine Zahl konvertiert werden:
cast von double nach int

Typ int ist zu gro
cast von long nach int
cast von double nach float
Folgendes Beispiel liefert keinen Compilerfehler, aber auch nicht das erwartete Ergebnis:
1
float f = 10 / 3; // f == 3.0f
1
2
3
4
5
6
7
8
char c1 = 0;
int z1 = (int) c1;
// z1 == 48;
System.out.println("Zeichen: " + c1 + " (" + z1 + ")");
Zeichen: 0 (48)
Zeichen: a (110)
char c2 = a;
int z2 = (int) c2;
// z2 == 97;
z2 += 13;
// z2 == 110;
System.out.println("Zeichen: " + c2 + " (" + z2 + ")");
Was identisch zu dieser expliziten Typumwandlung ist:

1
float h = (float) (10 / 3); // h (= 10 / 3) = 3.0f;
Der Zahlenwert entspricht der Nummer des

Zeichens im Zeichensatz. Dazu spter mehr.
Nicht jeder cast ist sinnvoll, auch wenn der Compiler keinen Fehler meldet:
1
int i = (int) 3123456789l; // i == -1171510507
33
34
Gltigkeitsbereiche von Variablen

Variablen sind ab der Stelle im Programm, an der sie definiert wurden, bis zum Ende des aktuellen
Programmblocks gltig.
2 - Variablen
Gltigkeitsbereiche
Programmblcke:
Anfang und Ende von Blcken sind durch die Zeichen { und } definiert.
Blcke knnen geschachtelt werden.
In inneren Blcken sind die Variablen der bergeordneten Blcke sichtbar.
Zur Vermeidung von Fehlerquellen drfen in Java Variablennamen in inneren Blcken nicht identisch
mit Variablennamen aus bergeordneten Blcken sein.
Beispiel:
Der Klassenblock (Zeile 1 bis 5)
Der Methodenblock (Zeile 2 bis 4)
1
2
3
4
5
public class HalloWelt {

System.out.println("Hallo Welt!");
}
}
36

1
2
3
4
5
6
7
8
9
10
11
12
public class Scope {

double radius = 10;
{
double umfang = 2 * radius * Math.PI;
radius = 7;
System.out.println("Umfang: " + umfang);
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
Drei Blcke/Gltigkeitsbereiche:
Klassenblock (Zeile 1 - 12)
Methodenblock (Zeile 2 - 11)
Ein frei definierter Block (Zeile 4 - 8)
1
2
37

1
2
3
4
5
6
7
8
9
10
11
12
Arbeitsspeicher
Die im inneren Block

definierte Variable
umfang ist im ueren
Block nicht bekannt
Daher kann umfang in

Zeile neu deklariert
werden
dieser
Umfang: 62.83185307179586
Umfang: 43.982297150257104
38

double radius = 10;
{
radius = 7;
}
}
}
nach Zeile

double radius = 10;
{
radius = 7;
}
}
}
nach Zeile
1
2
3
4
5
6
7
8
9
10
11
12
Arbeitsspeicher
public class bloecke {

double radius = 10;
{
radius = 7;
}
}
}
nach Zeile
Arbeitsspeicher
nach Zeile
radius
Arbeitsspeicher
10
39
40

1
2
3
4
5
6
7
8
9
10
11
12

double radius = 10;
{
radius = 7;
}
}
}
nach Zeile
nach Zeile
Arbeitsspeicher
1
2
3
4
5
6
7
8
9
10
11
12
Arbeitsspeicher
nach Zeile
radius

double radius = 10;
{
radius = 7;
}
}
}
10
radius
umfang
10
62.8318
41
nach Zeile
Arbeitsspeicher
radius
radius
umfang
10
62.8318
radius
umfang
62.8318
umfang
10
62.8318
radius
umfang
62.8318
1
2
3
4
5
6
7
8
9
10
11
12
42
Arbeitsspeicher

double radius = 10;
{
radius = 7;
}
}
}
nach Zeile
radius
10
radius

double radius = 10;
{
radius = 7;
}
}
}
nach Zeile
Arbeitsspeicher
radius
10
1
2
3
4
5
6
7
8
9
10
11
12
nach Zeile
Arbeitsspeicher
nach Zeile
Arbeitsspeicher
radius
43
radius
7
10
Arbeitsspeicher
radius
umfang
10
62.8318
radius
umfang
62.8318
radius
umfang
43.9822
44

1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9

int radius = 5;
{
int radius = 10;
// Compilerfehler
double umfang = radius * 2 * PI;
}
System.out.println("Der Umfang ist " + umfang); // Fehler
}
{
int radius = 5;
{
int radius = 10;
// Compilerfehler
}
}
nach Zeile
Arbeitsspeicher
45

1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9

int radius = 5;
{
int radius = 10;
// Compilerfehler
}
}
Arbeitsspeicher
{
int radius = 5;
{
int radius = 10;
// Compilerfehler
}
}
nach Zeile
PI
3.1415
Arbeitsspeicher
PI
3.1415
46
nach Zeile
PI
radius
3.1415
47
48

1
2
3
4
5
6
7
8
9
{
int radius = 5;
{
int radius = 10;
// Compilerfehler
}
}
nach Zeile
Arbeitsspeicher
PI
3.1415
PI
radius
3.1415
PI
radius
radius
3.1415
10
Fehler:
Namenskonflikt
49

Sprache

02 Variablen - Print

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

02 Variablen - Print

Hochgeladen von

Copyright:

Verfügbare Formate

2 - Variablen

Grundlagen der Informatik

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Variablen in Java Schreibtischlauf

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Variablen in Java Schreibtischlauf

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Variablen in Java Schreibtischlauf

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Variablen in Java Schreibtischlauf

Variablen in Java Schreibtischlauf

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Deklaration einer Variable

oder in verkrzter Schreibweise

Deklaration einer Variable

Das Ergebnis sollte dem Benutzer noch mit

Primitive Datentypen und Numerale

Das vollstndige (bersetzbare) Programm wrde wie folgt aussehen:

public class Calc {

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Was sind Datentypen

ganze Zahlen Type

In Java gibt es 8 primitive Datentypen:

+2 147 483 647

Mit Gleitkommatypen kann die Menge der rationalen Zahlen angenhert

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Aber welchen Typ hat ein Numeral?

float d = 3000000000L / 13;

Bei Fliekommazahlen kann man f, F, d oder D je nach Typ verwenden

5.0 ist ein double Wert

0.24f; //Implizite Konvertierung float-Numeral ->

Deswegen knnen Numerale um Zusatzinformationen erweitert werden:

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Character-Literale werden in Hochkommata (') angegeben:

Der Typ char kann wie ein

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Zuweisungen werden bentigt, um

Zunchst bentigt man die Deklaration von Variablen

Links vom = kann immer nur

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Variablen bezeichnen einen Speicherbereich, in dem Werte

Variablen in Java haben folgende Eigenschaften:

int z1, z2;

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Die Vergabe von Namen an Variablen ist an bestimmte Regeln gebunden:

Nicht initialisierte Variablen knnen nicht in Ausdrcken verwendet werden.

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Variablen in der Mathematik

In der Mathematik fhrt folgender Ausdruck zum Widerspruch:

final double PI = 3.14159265;

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

final double PI;

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

automatische Umrechnung nennt man impliziten (automatischen) type cast (Typumwandlung)