variablen

Learning By Doing
Variablenkonzept
Klassisch, in Java Basistyp
• Variablendeklaration reserviert Speicherplatz im Hauptspeicher
• Speicherplatz wird zu Compilationszeit reserviert
• Initialisierung setzt einen Wert
• Variable besteht aus Name und Wert
Nach Deklaration/Initialisierung:
int x = 5;
int y = 2;
int z = 7;
Adresse
x
y
z
Inhalt
5
2
7
Nach Zuweisung
y = 5;
Adresse
x
y
z
Inhalt
5
5
7
Learning By Doing
Für Objekte werden Referenzvariablen verwendet:
• Für Objekte wird in einem dynamischen Speicherbereich (Heap)
zu Laufzeit Speicherplatz reserviert
• Um eine Objekt anzusprechen muss eine Referenzvariable (Referenz)
verwendet werden, welche die Adresse des Objekts enthält. Der Wert
der Referenz (also die Adresse des Objekts) ist nicht zugänglich
• Objekte werden mit dem Erzeugungsoperator new erzeugt. Der Rückgabewert wir einer Referenzvariable zugewiesen
Deklaration einer
Referenzvariablen
Erzeugung eines Objekts
t = new T();
T t;
a
t
n ull
t
Objekt
a
Heap
Learning By Doing
Zuweisung und Vergleich von Referenzvariablen
• Zugewiesene Referenzvariablen zeigen auf dasselbe Objekt
• Verändert man mit einer dieser Variablen das Objekt, so ist es
automatisch auch für die andere Variable geändert
• Der Vergleich von Referenzvariablen mit == prüft, ob die beiden
Variablen auf das gleiche Objekt verweisen und nicht, ob die beiden
Objekte gleich sind
T t = new T();
T u;
u = t;
a
t
u
Objekt
a
a
Heap
Learning By Doing
Basistypen versus Referenztypen
// WbzEx2.java
// WbzEx2a.java
import static ch.aplu.util.Console.*;
import ch.aplu.turtle.*;
import java.awt.Color;
class WbzEx2
{
WbzEx2()
{
int hans = 3;
println("hans: " + hans);
class WbzEx2a
{
WbzEx2a()
{
Turtle hans = new Turtle(Color.red);
int peter;
peter = hans;
println("peter: " + peter);
Turtle peter;
peter = hans;
hans = 7;
println("hans: " + hans);
println("peter: " + peter);
hans.setColor(Color.blue);
peter.back(100);
}
}
public static void main(String[] args)
{
new WbzEx2a();
}
}
J2SE V1.4:
public static void main(String[] args)
{
new WbzEx2a();
}
}
statt import static nur import
dafür statt println() überall Console.println()
Learning By Doing
Referenzvariablen (Referenzen) dienen nicht
dazu, Objekte zu speichern, sondern mit ihnen
zu kommunizieren
Heap
Instanz von john
john
Referenz von john
Learning By Doing
Basistypen
Datentyp/
Schlüsselwort
Ganzzahlen
byte
short
int
long
s. Buch S. 66
Beschreibung
Größe/Format
Ganze Zahlen von -128 bis +127 (–27 bis 27-1)
8-bit Zweierkomplement
(1 byte)
16-bit Zweierkomplement
Ganze Zahlen von -32'768 bis +32'767 (–215 bis 215-1)
(2 bytes)
32-bit Zweierkomplement
Ganze Zahlen von -2 147 483 648 bis 2 147 483 647 (–231
(4 bytes)
bis 231-1)
Ganze Zahlen von -9 223 372 036 854 775 808 bis 9 223 372 64-bit Zweierkomplement
(8 bytes)
036 854 775 807 (-263 bis 263-1)
Fliesskommazahlen
float
Dezimalzahl, ungefähr 7 Ziffern, Exponent 10 -38..10+38
double
Dezimalzahl, ungefähr 16 Ziffern, Exponent 10 -308..10+308
Andere Typen
char
boolean
Zeichen
Wahrheitswert wahr oder falsch
32-bit IEEE 754 (24-bit Mantisse/8-bit
Exponent)
64-bit IEEE 754 (53-bit Mantisse/11-bit
Exponent)
16-bit Unicode (kein Vorzeichen)
true/false (1 byte)
Learning By Doing
Ausdrücke/Operatoren
Operator
s. Buch S. 72/73
.
[]
()
++, -+, ~
!
(type)
*, /, %
Rangordnung
0
0
0
1
1
1
1
1
2
Typ
syntaktisch
syntaktisch
syntaktisch
arithmetisch
arithmetisch
int
boolean
jeder
arithmetisch
+, +
<<
>>
3
3
4
4
arithmetisch
String
int
int
>>>
4
int
<, <=, >, >=
instanceof
==, !=
5
5
6
arithmetisch
Objekt
alle
Beschreibung
Klassenmember
Arrayindex
Parameterklammer
Inkrement u. Dekrement
Unäres Plus u. Minus
Bitweises Komplement
Logisches Komplement
Cast
Multiplikation, Division,
Modulo
Addition und Subtraktion
Stringkonkatenation
Shift links
Shift rechts mit
Vorzeichenerweiterung
Shift rechts ohne
Vorzeichenerweiterung
Numerische Vergleiche
Typvergleich
Gleich-/Ungleichheit
Learning By Doing
Ausdrücke/Operatoren
Operator
&
&
^
^
|
|
&&
Rangordnung
7
7
8
8
9
9
10
Typ
int
boolean
int
boolean
int
boolean
boolean
||
11
boolean
?:
=
*=,
/=,
%=,
+=, -=, <<=,
>>=, >>>=, &=,
^=, |=
12
13
14
alle
alle
alle
s. Buch S. 72/73
Beschreibung
Bitweises Und
Logisches Und
Bitweises Xor
Logisches Xor
Bitweises Oder
Logisches Oder
Logisches Und,
Kurzschluss
Logisches Oder,
Kurzschluss
Bedingungsoperator
Zuweisung
Zuweisung mit Operation
Learning By Doing
Strings
• Nicht einfach Zeichenketten, sondern Instanzen einer Klasse
• In Java eine sehr spezielle Implementierung
 unveränderlich (immutable)
 in einem speziellen Speicherbereich (String pool)
 + - Operator überladen (Konkatenation)
 Erzeugung mit String-Literal (Anführungszeichen)
String s = "Heute ist der ";
...
Date today = new Date();
String s = s + today.toString();
 enger Zusammenhang mit Klassen StringBuffer und StringBuilder
sb.charAt()
sb.deleteCharAt()
sb.setCharAt()
sb.insert()
sb.append()
Learning By Doing
// WbzEx3.java
import javax.swing.JOptionPane;
class WbzEx3
{
WbzEx3()
{
String town = "Bern";
String answer = "";
boolean quitting = false;
while (!quitting)
{
String input =
JOptionPane.showInputDialog(
"Wo findet der Wbz-Kurs statt?");
if (input == null)
quitting = true;
else
{
if (input.equals(town))
{
answer = "richtig";
quitting = true;
}
else
answer = "falsch";
JOptionPane.showMessageDialog(
null, answer);
}
}
System.exit(0);
}
public static void main(String[] args)
{
new WbzEx3();
}
}
Learning By Doing
Arrays
• Analog math. Vektor: Statt von Komponenten spricht man von Elementen
• Elemente haben alle denselben Datentyp
• Elemente werden mit einem Arrayindex, der immer bei 0 beginnt, angesprochen
• Ein Array ist ein Objekt (mit etwas speziellen Eigenschaften)
• Ein Array wird mit einer Referenzvariablen (Arrayreferenz) angesprochen. Deklaration:
int[] a;
auch: int a[];
• Das Arrayobjekt (d.h. die Elemente) befinden sich auf dem Heap. Erzeugung:
a = new int[6];
Anzahl kann int-Variable sein (semistatisch)
• Übliche Kurzschreibweise:
int[] a = new int[6];
• Erzeugung/Initialisierung in Kurzschreibweise:
int[] a = {1, 2, 3, 6, 5, 4};
• Anzahl Arrayelemente:
a.length;
• Lesen/Schreiben (Random access):
a[0], a[1], a[2], a[3], a[4], a[5]
s. Buch S. 99ff
int, keine Klammern (kein Methodenaufruf)