Dietrich Boles

Programmierkurs Java 

Vorlesung 

am FB Informatik 

der Universität Oldenburg 

Vorlesung 8 

Dietrich Boles 

Programmierkurs Java Vorlesung 8 Dietrich Boles Seite 1

Gliederung von Vorlesung 8 

Strukturierte Datentypen 

Felder 

– Motivation 

– Anmerkungen 

– Definition 

– Erzeugung 

– Zugriff 

– Initialisierung 

– Zerstörung 

– mehrdimensionale Felder 

– Beispiel 

Referenzdatentypen 


– Zuweisung 

– Parameter 

– Funktionsrückgabewerte 

– lokale Variablen 

– Beispiel 

Verbunde 


– Verbundtypdefinition 

– Verbundvariablen 

– Zugriff auf Verbunde 

– Beispiel 

Beispielprogramme 


Strukturierte Datentypen 

bisher: einfache Datentypen (int, float, char, ...) 

Benutzung: Speicherung von „einfachen“ Daten in „einfachen“ 

Variablen 

häufig: besonderer Zusammenhang zwischen bestimmten Daten 

Beispiele: 

– Menge von Zahlen, die zu sortieren sind 

– Verwaltung von Personendaten (Name, Alter, Adresse, ...) 

Strukturierte Datentypen: Zusammenfassung mehrerer Daten zu 

einer Einheit 

– Felder: Daten desselben Typs 

– Verbunde: Daten mit u.U. unterschiedlichem Typ 


Felder / Motivation 

Definition: 

Ein Feld repräsentiert ein homogenes kartesisches Produkt zur 

Aufnahme mehrere Daten des gleichen Typs (genannt Elementtyp), 

wobei auf die Komponenten mit Hilfe eines Index zugegriffen wird. 

Synomyme: 

Array, Tupel, Matrix, Vektor, Tabelle 

0 

1 

2 

0 1 2 3 4 

2 -2 67 2 90 

33 3 -6 5 2 

4 2 2 78 93 

3 x 5 - Matrix (2-dimensional) 

Elementtyp: int 

3 Zeilen, 5 Spalten 

Numerierung beginnt bei 0 

m[0][0] == 2 

m[0][2] == 67 

m[5][5] → Laufzeitfehler 


Felder / Anmerkungen 

Alternative zu Arrays: int v1, v2, v3, ..., v1000; ????? 

– was ist bei 100.000 Elementen? 

– es existiert kein Zusammenhang (Index)! 

Elementtyp ist fest 

Dimension ist fest 

1-, 2-, ..., n-dimensionale Arrays erlaubt 

Zugriff über n-dimensionalen Index 

random-access-Zugriff (alternativ: sequentiell → Dateien auslesen) 

Arrays sind in Java Referenzdatentypen (wie Objekte) 

Arrays werden in Java dynamisch erzeugt 

Arrays werden in Java automatisch gelöscht, wenn sie nicht mehr benutzt 

werden (können) 


Felder / Definition einer Feldvariablen 

::= 

← Elementtyp 

„[“ „]“ { „[“ „]“ } ← Dimension 

{ „,“ } 

„;“ 

Beispiele: 

int[] vektor1; // ElemTyp: int, Dim: 1 

float[][] matrix1; // ElemTyp: float, Dim: 2 

char[] buchstaben; // ElemTyp: char, Dim: 1 

double[][][] quader1, quader2; 

// ElemTyp: double, Dim: 3 

char ziffern[]; // Definitionsalternative! 


Felder / Definition einer Feldvariablen 

Unterscheidung zwischen den eigentlichen Felder und den Feldvariablen 

Feldvariablen speichern die Adresse des eigentlichen Feldes 

Felder werden auf dem Heap angelegt 

bei der Definition einer Feldvariablen wird kein Speicherplatz für das Feld 

selbst angelegt 

vielmehr wird ein Speicherbereich reserviert, dem mittels des new-Operators 

Adressen zugewiesen werden können (→ Zeiger, Felderzeugung) 

man kann die Adressen weder auslesen noch auf den Adressen Operationen 

ausführen (wie bspw. in C oder C++) 

Default-Initialisierung einer Feldvariablen mit dem Literal null 

auch explizite Initialisierung möglich: int[] zahlen = null; 


Felder / Erzeugung eines Feldes 

::= „=“ „new“ 

„[“ „]“ 

{ „[“ „]“ } 

„;“ 

Nebenbedingung/Anmerkungen: 

– Elementyp und Dimension müssen mit der Definition der vorher definierten 

Feldvariablen übereinstimmen 

– int-Ausdrücke bestimmen die Anzahl an Elementen der jeweiligen Dimension 

– Feldelemente werden nicht implizit initialisiert! 

Beispiele: 

int[] vektor1; 

vektor1 = new int[8]; 

// Reservierung von 8 Speicherplätzen für int-Variablen 

int i = 3; 

float[][] vektor2 = new float[i][2]; 

// Reservierung von 3*2 Speicherplätzen für float-Variablen 


Felder / Erzeugung eines Feldes 

Schema: 

Stack oder Heap 

Heap 

„Zeiger“ 

 

0 1 2 3 4 5 6 7 

0 

1 

2 

0 1 


Felder / Zugriff auf Feldelemente 

::= 

„[“ „]“ 

{ „[“ „]“ } 

Nebenbedingungen / Anmerkungen: 

– Bezeichner muss gültige Feldvariable sein 

– int-Ausdruck muß Wert zwischen 0 und der Anzahl der Elemente - 1 der 

jeweiligen Dimension liefern (→ Laufzeitfehler!) 

– Zugriff auf Feldelemente nennt man Indexierung 

Beispiele: 

int[] vek = new int[5]; 

vek[0] = -23; 

vek[1] = vek[0] + 25; 

vek[vek[1]] = -4; 

vek[5] = 56; // Laufzeitfehler! 

vek 

0 1 2 3 4 


Felder / Initialisierung der Feldelemente 

Explizite Initialisierung: 

int[] vektor = new int[5]; 

for (int i=0; i

Felder / Initialisierung der Feldelemente 

Implizite Erzeugung und Initialisierung: 

int i = 3; 

int[] vektor = {0, 1, 4, i*i, 16}; 

vektor 

0 1 2 3 4 

0 1 4 9 16 

erzeugt Feld mit entsprechender Elementanzahl 

initialisiert die Elemente 

Initialisierungswerte können durch Ausdrücke des entsprechenden 

Elementtyps gebildet werden (i.a. Literale) 


Felder / Zerstörung eines Feldes 

Java: automatisches Garbage-Collection! 

Kein delete-Operator 

Speicherplatz wird automatisch freigegeben, wenn nicht mehr auf Heap- 

Speicherplatz referenziert („gezeigt“) wird 

Beispiel: 

int[] vek = new int[3]; 

vek[0] = 4; 

// ... 

vek = new int[5]; 

vek[2] = 45; 

vek[4] = -5; 

vek 

0 1 2 

0 1 2 3 4 


Felder / Mehrdimensionale Felder 

Normalfall: Anzahl an Elementen pro Dimension ist identisch 

float[][] vektor = new float[2][3]; 

for (int z=0; z < vektor.length; z++) 

for (int s=0; s < vektor[z].length; s++) 

vektor[z][s] = z + s; 

vektor 

0 

1 

0 1 2 

0.0 

1.0 2.0 

1.0 2.0 3.0 

vektor[0] 

vektor[1] 



Möglich: Anzahl an Elementen pro Dimension ist unterschiedlich 

float[][] vektor = new float[2][]; 

vektor[0] = new float[2]; 

vektor[1] = new float[3]; 

for (int z=0; z < vektor.length; z++) 

for (int s=0; s < vektor[z].length; s++) 

vektor[z][s] = z + s; 

vektor 

0 

1 

0 1 2 

0.0 1.0 

1.0 2.0 3.0 

vektor[0] 

vektor[1] 



Implizite Erzeugung und Initialisierung: 

char[][] zeichen = { {‘a‘, ‘b‘, ‘c‘}, 

{‘A‘, ‘B‘}, 

{‘0‘, ‘1‘, ‘2‘, ‘3‘, ‘4‘} 

}; 

zeichen 

0 

1 

2 

0 1 2 3 4 

a b c 

A B 

0 1 2 3 4 


Felder / Beispiel 

Berechnung der Summe zweier Vektoren: 

public static float min(float v1, float v2) { 

return v1

Referenzdatentypen 

Motivation 

– es existieren bestimmte Variablen, die lediglich Adressen („Referenzen“, 

„Zeiger“) auf andere Speicherbereiche speichern können 

– die Kontrolle über die referenzierten Speicherbereiche liegt beim Programmierer 

bzw. Anwendungsprogramm, nicht beim Laufzeitsystem 

– das Anwendungsprogramm kann zur Laufzeit entscheiden, wieviel Speicherplatz 

denn tatsächlich benötigt wird; diese Menge fordert es sich mittels des new- 

Operators explizit an 

– ein „Garbage Collector“ gibt automatisch nicht mehr benötigte Speicherbereiche 

frei 

Referenzdatentypen in Java sind Felder und Objekte 

es existieren einige Unterschiede zwischen „normalen“ Speicherelementen 

(Variablen von einem Standarddatentyp) und referenzierten 

Speicherelementen (Variablen vom Referenzdatentyp): 

– Zuweisung 

– Parameterübergabe 

– Funktionswert 

– lokale Variablen 


Referenzdatentypen / Zuweisung 

Adress-Zuweisung: 

int[] v = {1, 2, 3}; v[0] = -77; 

int[] w = {9, 8, 7, 6}; 

v = w; // Adress-Zuweisung 

w[0] == -77 -> true! 

v 

0 1 2 

1 2 3 

w 

0 1 2 

9 8 7 6 

v = w; 

0 1 2 

bei der Adress-Zuweisung werden lediglich die Referenzen kopiert, nicht die 

referenzierten Elemente 

v 

1 2 3 

0 1 2 

Programmierkurs Java Vorlesung 8 Dietrich Boles Seite 19 

w 

9 8 7 6

Referenzdatentypen / Zuweisung 

Element-Zuweisung (Wert-Zuweisung): 

int[] v = {1, 2, 3}; v[0] = -77; 

int[] w = {9, 8, 7, 6}; w[0] == 9 -> true 

for (int i=0; i

Referenzdatentypen / Parameterübergabe 

Sind bei einer Funktionsdefinition Referenzdatentypen als formale Parameter 

definiert, so werden als aktuelle Parameter die Referenzen als Wert übergeben 

in einer Funktionen können in diesem Fall die referenzierten Elemente 

manipuliert werden 

nicht manipuliert werden kann jedoch die Referenzvariable selbst 

public static void init(int[] vek, int value) { 

for (int i=0; i true 

} 

Heap 

vek 

werte 

0 1 2 

47 47 47 


Referenzdatentypen / Funktionswerte 

Funktionen können als Funktionswert Werte vom Referenztyp liefern 

public static int[] init(int[] vek, int value) { 


Stack 

init 

main 

} Heap 0 1 2 


w1 

vek 

w2 

47 47 47

Referenzdatentypen / lokale Variablen 

bzgl. des Gültigkeitsbereich von Variablen vom Referenztyp gilt dasselbe wie 

bei „normalen“ Variablen 

die referenzierten Elemente werden durch Anwendung des new-Operators 

lebendig; sie sind solange lebendig, bis sie nicht mehr referenziert werden, 

also u.U. länger als die Funktion lebendig ist (→ Garbage Collection) 

public static foat[] init(int[] vek) { 

float[] fvek = new float[vek.length]; 

init vek 


} 

fvek 


Referenzdatentypen / Beispiel 

Sortierung von Zahlen: 

0 

2 

1 

5 

2 

3 

3 

7 

public static void main(String[] args) { 

int[] feld = {2,5,3,7,1}; 

print(feld); 

bubbleSort(feld); 

print(feld); 

} 

public static void print(int[] vektor) { 

Terminal.out.print(“Vektor: „); 

for (int i=0; i

Referenzdatentypen / Beispiel 

public static void bubbleSort(int[] vektor) { 

boolean veraendert = false; 

do { 

veraendert = false; 

for (int i=1; i vektor[i]) { 

0 1 2 3 4 

2 5 3 7 1 

int help = vektor[i-1]; 

vektor[i-1] = vektor[i]; 

vektor[i] = help; 

veraendert = true; 

} 

} 

} while (veraendert); 

} 


Verbunde / Motivation 

Definition: 

Datenstruktur/-typ zur Zusammenfassung von mehreren u.U. Elementen 

unterschiedlichen Typs zu einer Einheit. Der Wertebereich eines 

Verbundes ist das kartesische Produkt der Wertebereiche seiner einzelnen 

Elemente. 

Synomyme: 

Records, Strukturen, Datensätze 

Anmerkungen: 

– Verbunde gibt es in Java nicht; man kann sie aber mit Hilfe von Klassen 

bzw. Objekten nachbilden 

– Verbundtypen sind Referenzdatentypen! 


Verbunde / Motivation 

Beispiel: Personaldatei 

Mitarbeiter: 

Name: char[] name; 

Alter: short alter; 

Geschlecht: boolean ist_mann; 

Gehalt: float gehalt; 

Java: 

Definition des Verbundtyps: 

class Mitarbeiter { 

char[] name; 

short alter; 

boolean maennlich; 

float gehalt = 2000.0F; 

} 

Definition einer Verbundvariablen: 

Mitarbeiter dibo; 

Nutzung der Variablen: 

dibo.alter = 37; 


Verbunde / Definition eines Verbundtyps 

::= „class“ 

„{“ { } „}“ 

Anmerkungen: 

– der Bezeichner legt den Namen für den neuen Typ fest 

– die Variablen nennt man auch Elemente 

– Ort der Definition: vor oder nach der Definition der public-Klasse: 

Beispiel: Datei Personalverwaltung.java 

class Mitarbeiter {...} 

public class Personalverwaltung {...} 


Verbunde / Verbundvariablen 

Definition einer Verbundvariablen: 

Mitarbeiter dibo; 

Mitarbeiter[] personen; 

Erzeugung eines Verbundes: 

Mitarbeiter dibo = new Mitarbeiter(); 

Mitarbeiter[] personen = new Mitarbeiter[3]; 

for (int i=0; i

Verbunde / Zugriff auf Verbunde 

Zugriff auf Verbund: (via Punkt-Notation) 

dibo.name = {‘d‘, ‘i‘, ‘b‘, ‘o‘}; 

dibo.alter = 37; 

dibo.gehalt = 2000.0F * (dibo.alter / 10); 

personen[0] = dibo; 

personen[2].maennlich = true; 

personen[2].alter = personen[0].alter + 2; 

Initialisierung eines Verbundes: 

– bei der Definition des Verbundtyps (allgemeingültig) 

– explizit für jedes Element via Punkt-Notation 


Verbunde / Beispiel 

class Mitarbeiter { 

String name; 

float gehalt = 2000.F; 

boolean maennlich = true; 

int alter; 

} 

public class Verwaltung { 


Mitarbeiter karl = genM(“Karl“, 5000, true, 30); 

Mitarbeiter ute = genM(“Ute“, 4500, false, 34); 

print(karl); 

print(ute); 

} 


Verbunde / Beispiel 

public static Mitarbeiter genM( 

String n, float gh, boolean gl, int a) { 

Mitarbeiter person = new Mitarbeiter(); 

person.name = n; person.gehalt = gh; 

person.maennlich = gl; person.alter = a; 

return person; 

} 

public static void print(Mitarbeiter person) { 

System.out.println(“Name: “ + person.name); 

System.out.println(“Geh: “ + person.gehalt); 

if (person.maennlich) 

System.out.println(“maennlich“); 

else 

System.out.println(“weiblich“); 

System.out.println(“Alter: “ + person.alter); 

} } 


Beispielprogramm 1 

import dibo.*; 

class Position { int zeile; int spalte; } 

public class SchiebeSpiel { 


int[][] matrix = { {2, 14, 5, 7}, 

{3, 4, 15, 13}, 

{6, 1, 12, 11}, 

{3, 8, 9, 0} }; 

print(matrix); 

while (!korrekt(matrix)) { 

Position position = posEingabe(matrix); 

verschieben(matrix, position); 

print(matrix); 

} } 

2 14 5 7 

3 4 15 13 

6 1 12 11 

3 8 9 

1 2 3 

4 5 6 7 

8 9 10 11 

12 13 14 


15


public static void print(int[][] matrix) { 

for (int i=0; i


public static boolean korrekt(int[][] matrix) { 

int vgl = 0; 

for (int i=0; i


public static void verschieben(int[][] m, Position pos) { 

Position frei = freiesFeld(m); 

m[frei.zeile][frei.spalte] = m[pos.zeile][pos.spalte]; 

m[pos.zeile][pos.spalte] = 0; 

} 

public static Position freiesFeld(int[][] matrix) { 

for (int i=0; i


import dibo.*; 

public class DamenProblem { 


int[] zeile = new int[8]; 

} 

boolean[] spalte = new boolean[8]; 

for (int k=0; k


public static void setze(int i, int[] zeile, 

boolean[] spalte, 

boolean[] steidiag, 

boolean[] falldiag, 

int[] loe) { 

for (int j=0; j


public static void print(int[] zeile) { 

for (int i=0; i

Dietrich Boles

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?