Sie sind auf Seite 1von 13

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

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;

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

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;

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

Arbeitsspeicher
k

k
10

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

Variablen in Java Schreibtischlauf

Variablen in Java Schreibtischlauf

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

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

Arbeitsspeicher

ergeb.

10

120

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

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)
Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

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

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

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.

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

byte
8 Bit (1 Byte)
-128

15

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

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!)

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

17

Wertebereiche

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

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)
Wintersemester 2014/15 | F. Bauer | https://gdi.cs.fau.de | Grundlagen der Informatik

19

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

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

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

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

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

23

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

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

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

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

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

final double PI;


PI = 3.14159265; // unsch
on, aber kein Fehler
PI = 3.14159265; // Fehler beim Kompilieren

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

27

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

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

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

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

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

31

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

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

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

33

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

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 {


public static void main(String[] args) {
System.out.println("Hallo Welt!");
}
}

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

36

Gltigkeitsbereiche von Variablen


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

Gltigkeitsbereiche von Variablen

public class Scope {


public static void main(String[] args) {
double radius = 10;
{
double umfang = 2 * radius * Math.PI;
radius = 7;
System.out.println("Umfang: " + umfang);
}
double umfang = 2 * radius * Math.PI;
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

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

37

Gltigkeitsbereiche von Variablen


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

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

38

Gltigkeitsbereiche von Variablen

public class Scope {


public static void main(String[] args) {
double radius = 10;
{
double umfang = 2 * radius * Math.PI;
radius = 7;
System.out.println("Umfang: " + umfang);
}
double umfang = 2 * radius * Math.PI;
System.out.println("Umfang: " + umfang);
}
}

nach Zeile

public class Scope {


public static void main(String[] args) {
double radius = 10;
{
double umfang = 2 * radius * Math.PI;
radius = 7;
System.out.println("Umfang: " + umfang);
}
double umfang = 2 * radius * Math.PI;
System.out.println("Umfang: " + umfang);
}
}

nach Zeile

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

Arbeitsspeicher

public class bloecke {


public static void main(String[] args) {
double radius = 10;
{
double umfang = 2 * radius * Math.PI;
radius = 7;
System.out.println("Umfang: " + umfang);
}
double umfang = 2 * radius * Math.PI;
System.out.println("Umfang: " + umfang);
}
}

nach Zeile

Arbeitsspeicher

nach Zeile

radius

Arbeitsspeicher

10

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

39

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

40

Gltigkeitsbereiche von Variablen


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

Gltigkeitsbereiche von Variablen

public class bloecke {


public static void main(String[] args) {
double radius = 10;
{
double umfang = 2 * radius * Math.PI;
radius = 7;
System.out.println("Umfang: " + umfang);
}
double umfang = 2 * radius * Math.PI;
System.out.println("Umfang: " + umfang);
}
}

nach Zeile

nach Zeile

Arbeitsspeicher

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

Arbeitsspeicher

nach Zeile

radius

public class bloecke {


public static void main(String[] args) {
double radius = 10;
{
double umfang = 2 * radius * Math.PI;
radius = 7;
System.out.println("Umfang: " + umfang);
}
double umfang = 2 * radius * Math.PI;
System.out.println("Umfang: " + umfang);
}
}

10

radius

umfang

10

62.8318

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

41

Gltigkeitsbereiche von Variablen

nach Zeile

Arbeitsspeicher

radius

radius

umfang

10

62.8318

radius

umfang

62.8318

umfang

10

62.8318

radius

umfang

62.8318

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

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

42

Arbeitsspeicher

public class bloecke {


public static void main(String[] args) {
double radius = 10;
{
double umfang = 2 * radius * Math.PI;
radius = 7;
System.out.println("Umfang: " + umfang);
}
double umfang = 2 * radius * Math.PI;
System.out.println("Umfang: " + umfang);
}
}

nach Zeile

radius

10

radius

Gltigkeitsbereiche von Variablen

public class bloecke {


public static void main(String[] args) {
double radius = 10;
{
double umfang = 2 * radius * Math.PI;
radius = 7;
System.out.println("Umfang: " + umfang);
}
double umfang = 2 * radius * Math.PI;
System.out.println("Umfang: " + umfang);
}
}

nach Zeile

Arbeitsspeicher

radius
10

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

nach Zeile

Arbeitsspeicher

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

nach Zeile

Arbeitsspeicher

radius

43

radius
7

10

Arbeitsspeicher

radius

umfang

10

62.8318

radius

umfang

62.8318

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

radius

umfang

43.9822

44

Gltigkeitsbereiche von Variablen

Gltigkeitsbereiche von Variablen


1
2
3
4
5
6
7
8
9

1
2
3
4
5
6
7
8
9

final double PI = 3.14159265;


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

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

nach Zeile

Arbeitsspeicher

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

45

Gltigkeitsbereiche von Variablen


1
2
3
4
5
6
7
8
9

1
2
3
4
5
6
7
8
9

final double PI = 3.14159265;


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

Arbeitsspeicher

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

nach Zeile

PI
3.1415

Arbeitsspeicher
PI
3.1415

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

46

Gltigkeitsbereiche von Variablen

nach Zeile

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

PI

radius

3.1415

47

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

48

Gltigkeitsbereiche von Variablen


1
2
3
4
5
6
7
8
9

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

nach Zeile

Arbeitsspeicher
PI
3.1415

PI

radius

3.1415

PI

radius

radius

3.1415

10

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

Fehler:
Namenskonflikt

49