Kapitel 3 - Algorithmen und Methoden

3. Algorithmen und Methoden 

� Vertiefende Diskussion über Algorithmen 

Praktische Informatik I 

04.11.2003 

– Definition 

– Eigenschaften 

– Klassifizierung 

� Schrittweise Verfeinerung von Algorithmen 

� Aufbau von Algorithmen und Methoden sowie Kontrollstrukturen in 

Java 

– Folge (Sequenz) 

– Selektion 

– Wiederholung 

– Prozedur / Methode 

– Rekursion 

� Zustandsbasierte Algorithmen 

© Prof. Dr. Andreas Henrich, Universität Bayreuth und Prof. Dr. Bernhard Seeger, Universität Marburg 

67

Methoden – Was wir schon wissen 

� Das Verhalten der Objekte ist durch seine Methoden bestimmt. 


04.11.2003 

– Methoden können entweder den Objektzustand verändern (Mutatoren) 

• Dann wird das Schlüsselwort void vor den Methodennamen geschrieben, d. h. es wird kein 

Ergebnis produziert. 

oder ein Ergebnis liefern. 

• Dann muss noch der gewünschte Ergebnistyp vor den Methodennamen geschrieben 

werden. 

� Methoden können Parameter besitzen 

– Ein Parameter hat einen Typ (und einen Namen). Wir sprechen dann auch vom 

Formalparameter. 

� Methoden können sich direkt auf die Datenfelder des Objekts beziehen. 

� Eine Methode kann nur im Kontext eines Objekts aufgerufen werden. 

– Beispiel: Eine Methode m() eines Objekts o wird durch o.m() aufgerufen. 

– Methoden können Parameter besitzen 

• Ein Parameter hat ein Typ (und einen Namen). Wir sprechen dann auch vom 

Formalparameter. 

• Beim Aufruf der Methode werden diese Parameter mit einem Wert belegt. Wir sprechen 

dann vom Aktualparameter. 


68

Methoden – Was noch unklar ist 

� Wie können wir nun ein konkretes Problem durch eine 

Methode lösen? 

� Welche Hilfsmechanismen stehen uns zur Verfügung, um 

die Lösung zu formulieren? 

� Wie kann ich überhaupt erkennen, dass die Methode 

tatsächlich das Gewünschte leistet? 


04.11.2003 


69

3.1 Algorithmen und ihre Spezifikationen 

� Algorithmen sind allgemeine Lösungsverfahren zu Problemen 

� Problemspezifikation: 

ist eine vollständige und unzweideutige Problembeschreibung. 


04.11.2003 

– vollständig: 

Angabe aller Rahmenbedingungen (Eingabe) 

– detailliert: 

Voraussetzungen über Hilfsmittel und Grundoperationen (Prozessor) 

– unzweideutig: 

klare Beschreibung, was der Algorithmus tun soll (Ausgabe). 

� Beschreibungsverfahren zur Problemspezifikationen 

– Informelle in Umgangssprache formulierte Spezifikationen genügen i.a. nicht den 

obigen Kriterien. 

– Spezifikationen können ganz formal in speziellen, auf der Logik basierenden 

Spezifikationssprachen ausgedrückt werden: 

– Beispiele für formale Spezifikationssprachen: Z, VDM 


70

Beispiel: Suche nach einer Telefonnummer 

� informelle Beschreibung: Suche zu einem beliebigen Namen die 

zugehörige Telefonnummer. 

Offene Fragen: 

� Vollständigkeit: 


04.11.2003 

– Wie setzt sich ein Name zusammen? 

• Buchstaben des deutschen Alphabets 

• Sind auch Ziffern und Sonderzeichen erlaubt ? Beispiel „1&1“ 

• Besteht ein Name aus Vor- und Nachname? 

� Detailliertheit: 

– Welche Hilfsmittel stehen zur Verfügung? 

• Der Adressenkalender von meinem Freund / meiner Freundin? 

• Telefonbuch 

• CD-ROM 

– Was bieten die einzelnen Hilfsmittel an Funktionalität? 

� Unzweideutigkeit: 

– Wie soll die Ausgabe meiner Suche aussehen? 

– Was passiert, wenn ich mehrere Telefonnummern finde 


71

Beispiel: größter gemeinsamer Teiler 

� informelle Problembeschreibung: Für beliebige Zahlen M und N 

berechne den größten gemeinsamen Teiler 

Offene Fragen 

� Vollständigkeit: 


04.11.2003 

– Welche Zahlen sind zugelassen? 

• Ganze Zahlen, rationale Zahlen, oder sonstige? 

• Dürfen M und N auch 0 sein? 

� Detailliertheit: 

– Welche Operationen sind auf den ganzen Zahlen erlaubt? 

• +, - oder auch div (ganzzahlige Division), mod (Divisionsrest)? 

� Unzweideutigkeit: 

– Was bedeutet „ggt“ überhaupt? 

• Welche Zahlen sind als Ergebnis zugelassen? 


72

Beispiel: Fahrkartenautomat 

� Ziel: Entwicklung eines Automaten zum Kaufen von Fahrkarten 


04.11.2003 

– Modellbildung 

� Was sind die algorithmischen Problemstellungen? 

• Eine Methode des Automaten sollte entscheiden, ob genügend Wechselgeld im 

Automat ist. 

• Eine Methode des Automaten müsste berechnen, wie viele Münzen einer 

Stücklung ausgegeben werden. 

– Vollständigkeit: 

• Kann der Benutzer eine Aktion abbrechen? Soll Stromausfall als Fehlerfall 

mitberücksichtigt werden? 

• Sind verschiedene Münzen zugelassen? 

– Detailliertheit: 

• Welche Operationen werden innerhalb des Automaten unterstützt? 

– Unzweideutigkeit 

• Genaue Bedeutung von Kaufen einer Fahrkarte muss klar definiert sein. 


73

Vorbedingung - Nachbedingung 

� Probleme können über ein Paar {P} {Q} formal spezifiziert werden 


04.11.2003 

– P (Vorbedingung): 

alle relevanten Eigenschaften, die anfangs gelten 

– Q (Nachbedingung): 

alle relevanten Eigenschaften, die am Ende gelten sollen 

– P und Q können als Funktionen aufgefasst werden, die nur zwei Werte 

(„wahr“ und „falsch“) als Resultat zulassen. 

Beispiel (ggt): 

� P: M und N sind ganze Zahlen mit M > 0 und N > 0. 

� Q: das Ergebnis z aus den ganzen Zahlen mit z > 0 erfüllt folgende 

Bedingungen: 

– z ist Teiler von M 

– z ist Teiler von N 

– für jede ganze Zahl y, die N und M teilt, gilt y ≤ z 


74

Algorithmus 

� Definition: 


04.11.2003 

– Ein Algorithmus ist eine präzise, endliche Beschreibung eines allgemeinen 

Verfahrens zur schrittweisen Lösung eines Problems. Der Algorithmus 

besteht aus einzelnen Schritten und Vorschriften, welche die Ausführung 

dieser Schritte kontrollieren. 

– Jeder Schritt muss 

• klar und eindeutig beschrieben sein und 

• mit endlichem Aufwand in endlicher Zeit ausführbar sein. 

– Ein Algorithmus wird durch einen Prozessor ausgeführt. 

– Ein (sequentieller) Prozess bezeichnet die sequentielle Folge von 

Ausführungsschritten, die durch einen Prozessor bei der Verarbeitung 

eines Algorithmus erzeugt wird. 

� Der Mensch übernimmt beim Algorithmus oft die Rolle des Prozessors 

– Ziel: Zu einer Spezifikation eines Problems einem anderen Menschen 

(„Programmierer“) mitteilen, wie etwas berechnet wird. 


75

Eigenschaften von solchen Algorithmen 

� Details spezieller Programmiersprachen (oder gar Maschinen) sind irrelevant. 

� besitzt einen der Kommunikation zwischen Menschen angemessenen 

Abstraktionsgrad (dieser ist i.a. nicht durch eine Programmbeschreibung zu 

erzielen) 

� der Autor eines Algorithmus macht gewisse Annahmen über die Zielgruppe. 

Beispiele: 

� Tanzen (Grundschritt Langsamer Walzer) 

Vorbedingung: linker und rechter Fuß stehen nebeneinander 

Nachbedingung: linker und rechter Fuß stehen nebeneinander 


04.11.2003 

1. RF vorwärts (RF = rechter Fuß) 

2. LF seitwärts 

3. RF schließt zum LF 

4. LF vorwärts 

5. RF seitwärts 

6. LF schließt zum RF 


76

� Schneiden von Ziegeln (aus „Das große Handwerker Buch“) 

Vorbedingung: Ziegel (nach DIN); 

Nachbedingung: ein in zwei Teile zerlegter Ziegel 


04.11.2003 

1. Zeichnen Sie die Schnittlinie auf jeder Seite mit Kreide ein. 

2. Machen Sie auf ganzem Umfang entlang der Schnittlinie eine Kerbe. 

3. Falls der Ziegel hart ist, wird Schritt 2 wiederholt. 

4. Legen Sie die Ziegelunterseite auf Gras, Sand oder eine Zeitung. 

5. Drücken Sie die Schneide der Kelle in die Kerbe und schlagen Sie mit dem 

Hammer auf den Griff. 

� Berechnung des ggT zweier natürlicher Zahlen a, b > 0 

Vor- und Nachbedingung sind bereits bekannt. 

while (a != b) { 

if (a > b) 

a = a – b; 

else 

b = b – a; 

} 

eine Variable 

Vergleich zweier Variablen 

Zuweisung 


77

Gegenbeispiele: Was ist kein Algorithmus! 

� Beschreibung durch Analogien 

Das Zerteilen von Fliesen läuft im Prinzip so wie das Zerteilen eines Ziegels. 

� Beschreibung durch Beispiele 

Berechne die ersten 10 Zahlen der Folge 2, 3, 5, 7, 11, ... . 


04.11.2003 

– Was ist die nächste Zahl der Folge? 

� Verwendung nicht-ausführbarer und nicht-Grundoperationen 

– Leg die nächsten 100 Meter in 5 Sekunden zu Fuß zurück. 

– Zur besseren Anbindung des Campus an die Stadt, soll die aus der SF-Literatur 

bekannte Beam-Technik eingesetzt werden. 

� Verletzung der Allgemeinheit (Problem: Addieren der Zahlen 12 und 13) 

– 2 und 3 ergibt zusammen 5 

– 10 und 10 ergibt 20 

� Ein Algorithmus lässt sich stets auf eine Klasse von Problemstellungen 

anwenden (z.B. die Addition zweier Zahlen). 

� Jeder Algorithmus besitzt deshalb Eingabeparameter, die beim Start eines 

Prozesses mit konkreten Werten zu belegen sind. 


78

Qualität von Algorithmen 

� Zwingend notwendig ist die Korrektheit, d.h. der Algorithmus muss 

tatsächlich die Spezifikation erfüllen: 


04.11.2003 

– Für jeden möglichen Prozess eines Algorithmus muss folgender 

Sachverhalt gelten: 

• Falls beim Start des Prozesses die Funktion P wahr liefert, 

• muss auch am Ende des Prozesses die Funktion Q wahr liefern 

– Erfüllt ein Algorithmus A die Spezifikation {P}{Q}, so schreiben wir auch 

{P}A{Q} 

– Die Vorbedingung P ist i.a. bzgl. der Eingabeparameter und die 

Nachbedingung ist i.a. bzgl. der Ausgabeparameter definiert. 

� weitere (wünschenswerte) Eigenschaften: 

– einfach zu verstehen 

– einfache Umsetzung in ein Programm 

– Laufzeit- und Platzbedarf sollten möglichst niedrig sein 


79

Eigenschaften von Algorithmen 

Definition (Terminierung) 

� Ein Prozess terminiert, wenn er aus einer endlichen Anzahl von 

Ausführungsschritten besteht. 

� Ein Algorithmus terminiert, wenn jeder seiner möglichen Prozesse 

terminiert. 

� Bemerkungen 


04.11.2003 

– Oft ist „Algorithmus“ in der Literatur so definiert, dass die Terminierung 

bereits inhärent gefordert wird (z.B. Suche nach Webseiten). 

– nicht-terminierende Algorithmen sind aber auch von Interesse 

• iterative Berechnung der Zahl e 

• Ampelsteuerung 

• Verarbeitung von Daten eines Sensors oder Tickers: 

kontinuierliche Berechnung des durchschnittlichen Börsenwertes einer Aktie 


80

Determinismus und Determiniertheit 

� Determinismus bezieht sich auf den Prozess 


04.11.2003 

– Ein Algorithmus ist deterministisch, wenn es zu jeder möglichen Eingabe 

genau einen Prozess gibt. 

– Kann bei nicht-deterministischen Algorithmen den zu einer Eingabe 

gehörenden Prozessen eine Wahrscheinlichkeit zugeordnet werden, so 

spricht man auch von stochastischen Algorithmen. 

– Beispiele für nichtdeterministische Algorithmen 

• Spielzüge bei einem Schachspiel 

• Verkehrsreglung an einer Kreuzung 

� Determiniertheit bezieht sich auf das Ergebnis eines Algorithmus 

– Ein Algorithmus ist determiniert, wenn die Eingabe das Resultat des 

Algorithmus eindeutig bestimmt. 

– Beispiele für nichtdeterminierte Algorithmen 

• Spielzüge bei Spielen mit Würfeln 

• approximative Suchverfahren für Probleme, zu denen es keinen schnellen 

Algorithmus gibt. 


81

Sequentielle und parallele Algorithmen 

� beziehen sich auf die Prozesse 


04.11.2003 

– Ein Prozess heißt parallel, wenn Einzelschritte gleichzeitig ausgeführt 

werden. 

– Ein Algorithmus heißt parallel, wenn er parallele Prozesse zulässt. 

Andernfalls heißt er sequentiell. 

� Beispiele: 

– Beim Hausbau kann eine Wand aus Ziegeln gemauert werden und 

gleichzeitig die Ziegel zugeschnitten werden. 

– Beim Tanzen können mehrere Paare gleichzeitig langsamen Walzer 

tanzen (Kollisionen möglich, da alle auf der gleichen Tanzfläche!) 

– Bei der Berechnung von a² + b² kann die Quadratberechnung der Zahlen a 

und b parallel zueinander ablaufen. 

– Suchen in Telefonbüchern kann parallel erfolgen (wenn es mehrere 

Telefonbücher gibt, ansonsten ist Parallelität nicht sehr effektiv) 


82

(nach U. Nikolaus: Uni Regensburg, Lehrst. für Wirtschaftsinf. III Vorlesungsunterlagen Multimedia I, 1997) 

3.2 Einfache Kontrollstrukturen 

� Kontrollstrukturen sind Bestandteile von Algorithmen, die 

den Ablauf der Schritte innerhalb eines Algorithmus 

dynamisch steuern. 


04.11.2003 

– Aus einer endlichen Beschreibung können unendlich lange 

Prozesse werden. 

� Dem Prozessor muss die Bedeutung der Kontrollstrukturen 

klar sein. Ansonsten wird zu einem Algorithmus und einer 

Eingabe nicht der korrekte Prozess erzeugt. 

� wichtige Kontrollstrukturen: 

– Sequenz (Blockbildung) 

– Selektion (bedingte Anweisung) 


83

(nach U. Nikolaus: Uni Regensburg, Lehrst. für Wirtschaftsinf. III Vorlesungsunterlagen Multimedia I, 1997) 

Sequenz 

� = zusammenhängende Teilfolge von Schritten innerhalb eines Algorithmus. 

Alle Prozesse führen eine Sequenz nach folgenden Regeln aus: 


04.11.2003 

– Bearbeitung der Sequenz beginnt mit dem ersten Schritt der Sequenz 

– zu einem Zeitpunkt wird dann nur ein Schritt ausgeführt 

– jeder Schritt wird genau einmal ausgeführt: keine Wiederholung, kein Auslassen 

– Reihenfolge der Bearbeitung der Schritte ist identisch mit der des Algorithmus 

– Bearbeitung der Sequenz endet mit dem letzten Schritt 

Bemerkungen 

oder auch komplexere Strukturen 

• Eine Sequenz kann logisch wieder als ein einziger Schritt aufgefasst werden! 

• Dies wird in Java durch eine spezielle Notation gekennzeichnet: “{ “ und “}”. 

Schritte, die nicht weiter strukturiert sind, werden auch als atomare Schritte 

bezeichnet. 

• Ein Algorithmus besitzt mindestens eine Sequenz 

• Algorithmen, die aus nur einer Sequenz bestehen, sind sehr unflexibel 


84

Beispiel 

� Wir haben bereits im letzten Kapitel folgende Methode 

kennen gelernt: 


04.11.2003 

void maleHaus( ) { 

} 

sonne.makeVisible(); 

sonne.changeColor(“yellow“); 

sonne.moveHorizontal(100); 

dach.changeSize(100,150); 

dach.makeVisible(); 


85

(nach Ralf Steinmetz: Multimedia-Technologie, 2. Auflage, Springer, 1999) 

Selektion 

� Algorithmen erzeugen in Abhängigkeit von den Eingabeparametern 

verschiedene Prozesse. 

� Bei Algorithmen benötigt man eine von einer Bedingung abhängige 

Selektionsmöglichkeit, mit welchen Schritten fortgefahren wird. 


04.11.2003 

if (Bedingung) 

Schritt 

� Bedingung liefert entweder wahr oder falsch. 

– Zunächst wird die Bedingung ausgewertet. 

– Bei wahr wird die Sequenz ausgeführt und bei falsch übersprungen. 

� Beispiel: 

Algorithmus Maximum 

eine atomare Anweisung oder eine in 

„{“ und „} “ eingeschlossene Sequenz 

// Gegeben ganze Zahlen x und y. Resultat ist die größte der beiden Zahlen. 

if (x > y) 

Resultat ist x 

Resultat ist y 


86

(nach Ralf Steinmetz: Multimedia-Technologie, 2. Auflage, Springer, 1999) 

Ein Algorithmus in Java 

� Ein Algorithmus wird in Java als eigenständige Methode implementiert. 


04.11.2003 

int max2(int x, int y) { 

if (x > y) { 

return x; 

} 

return y; 

} 

Bemerkungen 

Einrückungen dienen nur der 

Lesbarkeit durch den Menschen! 

Java interpretiert (im Gegensatz z.B. 

zu Python) die Einrückungen nicht! 

� Jeder Schritt eines Algorithmus wird mit einem Semikolon abgeschlossen. 

� Das berechnete Ergebnis wird nach dem Schlüsselwort return angegeben. 

� Durch das Schlüsselwort int wird klargestellt, dass der berechnete Wert und 

die Eingabeparameter des Algorithmus ganze Zahlen sind. 

� Mit dem Schlüsselwort if kennzeichnet man eine bedingte Anweisung. 


87

Verallgemeinerung der Selektion 

� Abarbeitung: 


04.11.2003 

if (Bedingung) 

Schritt1 

else Schritt2 

– Wiederum wird zunächst die Bedingung ausgewertet. 

– Falls die Bedingung wahr ist, wird mit Schritt1 fortgefahren. 

– Andernfalls (Bedingung ist falsch) wird mit Schritt2 fortgefahren. 

– Nach vollständiger Abarbeitung von Schritt1 bzw. Schritt2 wird mit dem 

nachfolgenden Schritt fortgefahren. 

� Beispiel: 

/** Es wird das Maximum von drei ganzen Zahlen berechnet */ 

int max3(int x, int y, int z) { 

if (x > y) 

return max2 (x, z); // Was passiert hier ? 

else 

return max2 (y, z); 

} 


88

Anwendungsbeispiel 

� Wir wollen die bisherigen Kontrollstrukturen an Hand eines Beispiels 

illustrieren. 

� Aufgabe: 

Implementieren Sie einen Fahrkartenautomaten, der nach Einwurf von 

Münzen die gewünschte Fahrkarte ausgibt. 


04.11.2003 

– Der Automat hat einen Geldvorrat, der beliebig verwendet werden kann. 

• Es gibt keine Stückelung. 

– Der Automat soll die Eingabe auf Korrektheit überprüfen. 

• Es soll geprüft werden, ob genügend viel Geld in den Automaten eingeworfen 

wurde. 

– Der Automat soll die Fahrkarte und das genaue Wechselgeld ausgeben. 

– Der Automat soll eine Fahrkarte drucken. 


89

Erste Lösung: Teil 1 

public class FahrkartenAutomat { 

// Der Preis einer Fahrkarte = 100 Cent 

private int preis = 100; 

// Der bisher eingezahlte Betrag 

private int bisherGezahlt = 0; 

// Der Geldvorrat im Automat 

private int geldVorrat = 0; 

/** 

* getPreis liefert den Preis einer Fahrkarte. 

*/ 

public int getPreis() { 

return preis; 

} 

/** 

* getBisherGezahltenBetrag liefert die Höhe des bisher eingeworfenen Betrags 

*/ 

public int getBisherGezahltenBetrag() { 

return bisherGezahlt; 

} 

/** 

* geldEinwerfen erhöht den bisher gezahlten Betrag um betrag. 

*/ 

public void geldEinwerfen(int betrag) { 

bisherGezahlt += betrag; 

} 


04.11.2003 

Dies sind Kommentarzeilen 

Hier beginnt ein Kommentar 

und dort endet der Kommentar 

Hier wird das Ergebnis zum Aufrufer der 

Methode zurückgegeben. Danach ist die 

Methode beendet. 

Der Wert von bisherGezahlt wird 

um den Wert von betrag erhöht 


90

} 

Erste Lösung: Teil 2 

/** 

* ticketDrucken druckt ein Fahrschein, 

* aktualisiert den Geldvorrat und 

* setzt den bisher gezahlten Betrag auf 0. 

*/ 

public void fahrscheinDrucken() { 

System.out.println("##########################"); 

System.out.println("# Lummerland Verkehrsverbund"); 

System.out.println("# Fahrschein"); 

System.out.print("# "); 

System.out.print(preis); 

System.out.println(" Cent."); 

System.out.println("###########################"); 

System.out.println(); 

/* Jetzt wird Folgendes noch erledigt: 

geldVorrat erhöht und bisherGezahl initialisiert. */ 

geldVorrat += bisherGezahlt; 

bisherGezahlt = 0; 

} 


04.11.2003 

Textuelle Ausgabe des 

Aktualparameters 

Aber was passiert 

an dieser Stelle? 

Dies sind 2 Kommentarzeilen. 


91

Kommentare im Quellprogramm 

� wichtige Zusatzinformationen zur Klasse 


04.11.2003 

– Autor der Klasse, Erstellungsdatum 

– Erläuterungen zur Klasse und insbesondere zu den Methoden, um die 

Verständlichkeit des Quellprogramms zu verbessern. 

• Bedeutung jedes Datenfeldes 

• Vor- und Nachbedingungen für Methoden 

� Syntax für Kommentare 

– // Der Rest der Zeile ist Kommentar. 

Hierfür benötigen wir also keine weitere Kennung für das Ende des 

Kommentars. 

– /** Beginn des Kommentars 

*/ und Ende des Kommentars 

– /* Beginn des Kommentars 

*/ und Ende des Kommentars 

Gibt es ein 

Unterschied? 


92

Elementare Befehle 

� int preis = 100; 

– Dies ist eine Initialisierung eines Datenfelds. Der Wert auf der rechten Seite wird dem Datenfeld 

preis zugewiesen. 

– = wird auch als Zuweisungsoperator bezeichnet. 

� private 

– Dies ist ein sogenannter Modifikator, der das Datenfeld (bzw. Methoden) vor unberechtigten 

Zugriff von aussen schützt. 

� public 

– Ein Modifikator, der den Zugriff auf Methoden (bzw. Datenfelder) von aussen erlaubt. 

� return preis; 

– Das Schlüsselwort return stoppt die Verarbeitung der Methode. Falls die Methode ein Ergebnis 

liefern soll, muss hinter return ein Ausdruck stehen, dessen Wert nach aussen gegeben wird. 

� System.out.print("Hier wird ein Text ausgegeben."); 

– Hier erfolgt eine textuelle Ausgabe des Aktualparameters. 

– Falls der Parameter eine Zahl ist, wird die Zahl in textueller Form ausgegeben. 

� System.out.println("Hier wird ein Text ausgegeben und die Zeile abgeschlossen."); 


04.11.2003 

– Zusätzlich zu System.out.print() wird noch die Ausgabenzeile abgeschlossen. 

– Die nächste Ausgabe erfolgt am Anfang der nächsten Zeile. 


93

Formatierung des Quellprogramms 

� Zeilenumbrüche und Leerzeichen haben nur eine Bedeutung zwischen 

Schlüsselwörtern und Namen von Datenfeldern, Methoden sowie 

Klassen. 

� Äquivalentes Programm: 

class FahrkartenAutomat{private int preis = 100;private int bisherGezahlt=0; private int geldVorrat=0; public int getPreis() {return preis;}public 

int getBisherGezahltenBetrag(){return bisherGezahlt;}public void 

geldEinwerfen(int betrag){bisherGezahlt += betrag;}public void fahrscheinDrucken(){System.out.println("##########################"); 

System.out.println("# Lummerland Verkehrsverbund");System.out.println("# Fahrschein");System.out.print( 

"# ");System.out.print(preis);System.out.println("Cent.");System.out.println("###########################"); 

System.out.println();geldVorrat += bisherGezahlt;bisherGezahlt = 0;}} 

� Die Formatierung hat keinen Einfluß auf die synaktische Korrektheit 

eines Programms, sondern dient „nur“, die Lesbarkeit zu verbessern. 


04.11.2003 

– Abgabe von Programmen mit schlechter Formatierung führt zu 

Punktabzug. Im schwerwiegenden Fällen: 0 Punkte! 

– Formatierungskonventionen sollen beachtet werden. 

• Diese können auch in unseren Programmierrichtlinien nachgelesen werden. 


94

Verbesserung der Lösung 

� Defizite der bisherigen Lösung 

– Negative Einzahlung ist möglich. 

– Wird zu viel gezahlt, wird das Wechselgeld nicht zurückgegeben. 

– Beim Drucken des Fahrscheins wird nicht überprüft, ob der Betrag auch tatsächlich 

eingezahlt wurde. 

� Teil der Lösung 

public void fahrscheinDrucken() { 

if (bisherGezahlt >= preis) { 

drucken(); // Hier wird das Ticket gedruckt. 

geldVorrat += preis; 

wechselGeld = bisherGezahlt – preis; 

bisherGezahlt = 0; 

} 

else 

System.out.println("Sie müssen noch mehr Geld einwerfen."); 

} 


04.11.2003 


95

3.3 Schrittweise Verfeinerung von Algorithmen 

� Entwurf der Algorithmen ist relativ einfach solange die 

Problemstellungen einfach sind. 


04.11.2003 

– Leider sind nahezu alle interessanten Problemstellungen sehr komplex! 

Schrittweise Verfeinerung (Top-Down Ansatz) 

� Idee 

1. Zerlege das Problem geeignet in mehrere Einzelprobleme 

2. Verfahre mit jedem in Schritt 1 erzeugten Teilproblem folgendermaßen: 

• Falls das Teilproblem genügend einfach ist: Entwerfe Algorithmus für das 

Problem 

• ansonsten: Wende das Verfahren der schrittweisen Verfeinerung auf dieses 

Problem an. 


96

Beispiel 

Algorithmus für meinen Hausroboter zum Kochen einer Tasse Tee 

� erster Entwurf: 


04.11.2003 

1. Koche Wasser; 

2. Gib Tee in die Tasse; 

3. Fülle Wasser in die Tasse. 

Problem: 

– Schritte sind noch nicht detailliert genug, d.h. der Roboter kann diese noch nicht 

interpretieren und deshalb auch nicht ausführen. 

� Verfeinerung des ersten Schritts „Koche Wasser“ 

1.1 Fülle Kessel mit Wasser; 

1.2 Schalte Herdplatte an; 

1.3 Setze Kessel auf diese Herdplatte; 

1.4. Warte bis das Wasser kocht; 

1.5 Schalte Herdplatte aus; 


97

� Verfeinerung des zweiten Schrittes („Gib Tee in die Tasse“) 


04.11.2003 

2.1 Nimm einen Teefilter; 

2.2 Setze den Teefilter auf die Tasse; 

2.3 Öffne die Teedose; 

2.3 Nimm einen Löffel Tee; 

2.4 Kippe den Löffelinhalt in den Filter; 

2.5 Schließe den Teebehälter 

� Verfeinerung des dritten Schrittes („Gieße Wasser in die Tasse“) 

3.1 Gieße Wasser aus dem Kessel in die Tasse, bis die Tasse voll ist. 

Bemerkung: 

– Verfeinerung des Schritts 3 erhöht nicht die Anzahl der einzelnen Schritte, 

sondern beschreibt lediglich einen einzelnen Schritt detaillierter als zuvor. 

– einige Schritte können bereits vom Roboter direkt interpretiert werden (z.B. 

„schalte Herdplatte an“), andere benötigen wiederum eine Verfeinerung 

(z.B. „fülle Kessel mit Wasser“). 


98

... 

Ursprünglicher Algorithmuse 

Koche Wasser 

Gib Tee in die Tasse 


04.11.2003 

Nimm einen Löffel Tee 

... 

Erste Verfeinerung 

Fülle Kessel mit Wasser 

Schalte Herdplatte ein 

Setze Kessel auf die Herdplatte 

Warte bis das Wasser kocht 

Schalte Herdplatte aus 

Nimm einen Teefilter 

Setze den Teefilter auf die Tasse 

Öffne die Teedose 

Stelle Kessel unter Wasserhahn 

Drehe Wasserhahn auf 

Warte bis der Kessel voll ist 

Drehe Wasserhahn zu 

Nimm den Filterrahmen 

Nimm passenden Papierfilter 

Setze Papierfilter auf den 

Filterrahmen 

Nimm Teedose aus dem Fach 

Entferne den Deckel 


... 

Zweite Verfeinerung 

99

Aspekte bei der schrittweisen Verfeinerung 

� Kenntnisse über die Fähigkeiten des Prozessors sind von zentraler 

Bedeutung bei der schrittweisen Verfeinerung 


04.11.2003 

– wenn ein Schritt noch nicht vom Prozessor ausgeführt werden kann, muss 

noch eine Verfeinerung vorgenommen werden. 

– wünschenswert ist auch eine Verfeinerung von Schritten, deren 

Ausführung noch verbessert werden kann, z.B. 

„Warte bis der Kessel voll ist“ (wie voll?) 

– die Fähigkeiten des Prozessors legen die Richtung der Verfeinerung fest 

� Basisschritte der schrittweisen Verfeinerung können teilweise wieder 

beim Entwurf anderer Algorithmen genutzt werden, z.B. „Kochen einer 

Tasse Kaffee“ 

– erster Schritt „Koche Wasser“ ist in beiden Algorithmen identisch 

– Roboter erweckt dadurch den Anschein, komplexere Operationen direkt 

interpretieren zu können. 

100 

© Prof. Dr. Andreas Henrich, Universität Bayreuth und Prof. Dr. Bernhard Seeger, Universität Marburg

Prozeduren / Methoden 

� schrittweise Verfeinerung 


04.11.2003 

– ein Schritt eines Algorithmus wird unterteilt in viele Teilschritte 

– Teilschritte sind oft unabhängig von den anderen Schritten des Algorithmus 

� Beispiel (Schritt „Wasser kochen“ bei der Teebereitung) 

• Fülle 200 ml Wasser in den Kessel 

• Schalte Herdplatte an 

• Setze Kessel auf diese Herdplatte 

• Warte bis das Wasser kocht 

• Schalte Herdplatte aus 

– für die anderen Schritte des Algorithmus ist nur relevant, was dieser Teil bewirkt, 

aber nicht wie dies technisch realisiert wird. 

– Sequenz könnte wieder als eigenständiger Algorithmus aufgefasst werden 

Algorithmus kocheWasser200 

Eingabe: 200 ml Wasser 

Ausgabe: 200 ml kochendes Wasser 

– entsprechend Algorithmen KocheWasser300, KocheWasser400, … 

101 


Beobachtung 

� verschiedene Algorithmen zum Wasser kochen sind sehr ähnlich: 

Idee 


04.11.2003 

– Unterschied liegt nur in der Wassermenge 

� vereinige diese Algorithmen in einen gemeinsamen Algorithmus, wobei die 

Wassermenge als Parameter an den Algorithmus übergeben wird. 

– Aufruf des Algorithmus: kocheWasser(200) 

– Formulierung des Algorithmus als Prozedur (Methode): 

/** Kocht xMilliLiter Wasser */ 

void kocheWasser(int xMilliLiter) { 

if (xMilliLiter > Kapazität des Kessels) 

Melde “Wassermenge zu groß” 

else {fuelleKessel(xMilliLiter); // noch ein Methodenaufruf 

Schalte die Herdplatte an; 

… 

} 

� weitere mögliche Parameter im Algorithmus 

– Kessel 

– Herd 

102 


allgemeine Form: 

� Methode besteht aus einem Methodenkopf und einem Rumpf. 

Wünschenswert wäre auch Spezifikation (in Java aber nicht verlangt) 


04.11.2003 

• Methodenkopf 

void Methodenname(Liste von Formalparametern) 

- Schlüsselwort void signalisiert, dass die Methode keinen Ausgabewert 

berechnet. 

- Jede Methode besitzt einen Namen (Annahme: der Name sei eindeutig). 

- An den Klammern wird erkannt, dass dies eine Methodendeklaration ist. 

- Zwischen den Klammern steht eine Liste von Parametern. 

• Methodenrumpf 

- Algorithmus als Java-Programm. 

� Aufruf einer Methode: Methodenname(Liste von Aktualparametern); 

– Prozessor bearbeitet diese Anweisung wie folgt: 

• Berechnung der Werte der Aktualparameter 

• Anlegen von Speicher für die Formalparameter 

• Formalparameter bekommen die berechneten Werte zugewiesen. 

• Danach werden die Schritte des Methodenrumpfs ausgeführt. 

– Liste der Aktual- und der Formalparameter müssen kompatibel sein. 

103 


Funktionsmethoden 

� = spezielle Methoden, die 


04.11.2003 

– zusätzlich einen Wert berechnen und 

– diesen an den aufrufenden Algorithmus zurückgeben. 


int max2(int x, int y) { 

if (x > y) 

return x; 

return y; 

} 

/** es wird das Maximum für vier ganze Zahlen berechnet */ 

int max4(int w, int x, int y, int z) { 

return max2(max2(w,x), max2(y,z)); // Was passiert hier? 

} 

104 


Methodenaufruf und Speicher 

Aufruf von max4(2,3,5,4) 

Bezeichner 

max4 

Bezeichner 

max4 

max2 


04.11.2003 

Adresse 

Aufruftabelle 

Aufruf von max2(max2(2,3), max2(5,4)) 

Adresse 

Aufruftabelle 

Bezeichner 

105 


w 

x 

y 

z 

Bezeichner 

w 

x 

y 

z 

Bezeichner 

x 

y 

Wert 

2 

3 

5 

4 

Wert 

2 

3 

5 

4 

Wert 

2 

3

Methodenaufruf und Speicher 

Aufruf von max2(3, max2(5,4)) 


04.11.2003 

max4 

max2 

Bezeichner 

Bezeichner Adresse 

z 

4 

106 


w 

x 

y 

Bezeichner 

WICHTIG 

Jeder Aufruf einer Methode bekommt ihren eigenen Speicherbereich, 

in dem z. B. die Werte der Formalparameter hinterlegt werden. Nach 

dem Beenden der Methode wird der Speicher zurückgegeben. 

x 

y 

Wert 

2 

3 

5 

Wert 

5 

4

Vorteile von Methoden 

� Methode ist eine in sich abgeschlossene Komponente einer aufrufenden 

Methode 


04.11.2003 

– Entwurf des aufrufenden Algorithmus ist getrennt vom Entwurf der Methode 

� Beim Benutzen einer Methode ist nur erforderlich, was die Methode leistet, 

aber nicht, wie die Methode dies leistet (prozedurale Abstraktion). 

– Änderungen einer Methode haben keinen Einfluss auf das aufrufende Programm, 

solange die Spezifikation gleich bleibt. 

– Korrektheit eines großen Programms kann einfacher überprüft werden, wenn es 

Methoden verwendet. 

– Methoden führen zu einer erheblich kompakteren Beschreibung eines Algorithmus 

� fertige Methoden können beim Entwurf von anderen Algorithmen immer wieder 

im Programm und in anderen Programmen benutzt werden (Bibliotheken) 

107 


3.4 Rekursion 

� Wird ein Problem einer Problemklasse gelöst, indem wir es auf ein 

einfacheres Problem dieser Klasse zurückführen, nennen wir dies eine 

rekursive Lösung. 

� Beispiel (Matrioschka-Puppen): 

/** Öffnet rekursiv die Puppen, entfernt die massive Puppe und schließt die Puppen. */ 

void nimmMassivePuppe(Puppe M) { 

if (M ist massiv) 

nimm M; 

else { 

öffne M; 

nimmMassivePuppe(Inhalt von M); 

schließe M; 

} 

} 

– Zweiter Schritt im else-Zweig bewirkt, dass die gleiche Methode wieder 

aufgerufen wird, jetzt aber mit der nächst kleineren Puppe. 

– Algorithmus arbeitet in 2 Phasen 


04.11.2003 

1. Phase: Öffnen aller Puppen 

2. Phase: Schließen aller Puppen 

108 


Wichtige Anforderung an rekursive Methoden: 

� Folge von rekursiven Methodenaufrufen muss endlich sein 


04.11.2003 

– Eingabe vom nächsten rekursiven Aufruf muss „einfacher“ werden 

– Eine Selektionsanweisung (bzw. eine entsprechende Kontrollstruktur) 

muss den Fall behandeln, an dem die Rekursion nicht fortgesetzt wird. 

Berechnung der Fakultät 

fak( 

n) 

n ⎧ 1 falls n = 0 

= ∏ i = ⎨ 

i= 

1 ⎩n 

⋅ fak( 

n −1) 

sonst 

/** Berechnet Fakultät von n für alle ganzen Zahlen n mit n > 0 */ 

int fact(n) { 

if (n == 0) 

Test auf Gleichheit 

return 1; 

else 

return n * fact(n-1); 

} 

109 


Veranschaulichung des Prozesses für fact(4) 


04.11.2003 

110 


Türme von Hanoi 

Problem 

� gegeben 3 Plätze und ein Stapel von Scheiben, die auf einem der Plätze ihrer Größe 

nach aufeinander liegen 

� Ziel ist es den Stapel unter Beachtung folgender Regeln auf einen anderen Platz zu 

legen 


04.11.2003 

– pro Zug wird immer nur eine Scheibe bewegt 

– es darf nie eine größere auf einer kleineren Scheibe liegen 

� Algorithmus für 4 Scheiben von Platz 1 auf Platz 2 (3 dient als Zwischenlager) 

1. Übertrage die oberen 3 Scheiben von Platz 1 nach Platz 3 (Rekursion!) 

2. Bewege die untere Scheibe von Platz 1 nach Platz 2 

3. Übertrage die 3 Scheiben von Platz 3 nach Platz 2 (wieder Rekursion!) 

111 


1. Schritt 

2. Schritt 

3. Schritt 


04.11.2003 

112 


Algorithmus 

/** Überträgt einen Stapel von n Scheiben von Platz „von“ auf Platz „nach“ und benutzt 

* dabei den Platz „über“. 

*/ 

void bewegeStapel (int n, int von, int nach, int über) { 

if (n == 1) 

bewegeScheibe(von, nach); 

else { 

bewegeStapel(n - 1, von, über, nach); 


bewegeStapel(n - 1, über, nach, von); 

} 

} 

Bemerkungen 

� Wie oft wird bewegeStapel bei einem Problem der Größe n ausgeführt? 


04.11.2003 

– Aufrufe beim Problem der Größe n = 2 * (Aufrufe des Problems der Größe n-1) 

= 4 * (Aufrufe des Problems der Größe n-2) 

= … 

= 2n * (Aufrufe des Problems der Größe 1) 

113 


PlayHanoi: ein Spielautomat 

� Ziel ist die Entwicklung eines Automaten für das Spiel 

„Türme von Hanoi“. 


04.11.2003 

– Voraussetzungen 

– Ziel 

• Anfangs ist der komplette Stapel auf einem Platz. 

• Benutzer können mittels des Automaten den kompletten Stapel auf 

eine andere Position setzen. 

• Visualisierung der Züge durch den Automaten. 

114 


Die Klasse PlayHanoi (Teil 1) 

public class PlayHanoi{ 

private int anzahlScheiben; // Anzahl der Scheiben 

private int startPosition = 1; // Position des Stapels 

/** 

* Konstruktor für Objekte der Klasse PlayHanoi 

*/ 

public PlayHanoi(int scheiben){ 

anzahlScheiben = scheiben; 

} 


04.11.2003 

/** Überträgt einen Stapel von n Scheiben von Platz von auf Platz nach. 

* Alle Bewegungen von Scheiben werden ausgegeben. 

* Diese Methode ist nur für die interne Nutzung gedacht. 

*/ 

private void bewegeStapelIntern (int n, int von, int nach, int ueber) { 

if (n == 1) bewegeScheibe(von, nach); 

} 

else{ 

} 

bewegeStapelIntern(n - 1, von, ueber, nach); 


bewegeStapelIntern(n - 1, ueber, nach, von); 

Test auf Gleichheit 

115 


Die Klasse PlayHanoi (Teil 2) 

} 


04.11.2003 

/** Ausgabe der Bewegung einer Scheibe: 

* von ist die Startposition, nach ist die Zielposition. 

*/ 

private void bewegeScheibe(int von, int nach) { 

System.out.print("Bewege Scheibe: "); 

System.out.print(von); 

System.out.print(" --> "); 

System.out.println(nach); 

} 

/** 

* bewegeStapel bewegt den gesamten Stapel von startPosition auf zielPosition. 

*/ 

public void bewegeStapel(int zielPosition){ 

if ((zielPosition > 0) && (zielPosition < 4)){ 

if (zielPosition != startPosition) { 

bewegeStapelIntern(anzahlScheiben, startPosition, 

zielPosition, 3 - (startPosition+zielPosition)%3); 

startPosition = zielPosition; 

} 

} 

else 

System.out.println("Falsche Stapelnummer"); 

} 

Eingabe überprüfen 

Klammern, warum? 

Was ist denn das? 

116 


3.5 Zustandsbasierte Algorithmen 

Definition: 

� Ein Prozess eines imperativen Algorithmus kann Zwischenergebnisse 

erzeugen, auf die der Algorithmus sich wieder explizit beziehen kann. 


04.11.2003 

– Als Prozesszustand wird die Menge der zu den Zwischenergebnissen 

gehörenden Werte bezeichnet, die nach einer partiellen Ausführung 

existieren. 

– Der Zustandsraum eines Algorithmus bezeichnet die Menge aller erlaubten 

Prozesszustände. 

� Bemerkung: 

Frage hier: Was charakterisiert zustandsbasierte Algorithmen? 

– Zwischenergebnisse muss man sich merken, d.h. wir benötigen bei der 

Abarbeitung eines Algorithmus ein Blatt Papier (falls Prozessor = Mensch) 

oder einen Teil des Hauptspeichers (falls Prozessor = Rechner). 

• Objekte sind in diesem Sinne eine spezielle Art eines Speichers. 

– Wünschenswert wäre, dass ein Algorithmus möglichst wenig Speicher 

benötigt � Speicherplatzeffizienz 

117 


3.5.1 Variablen 

� Da ein zustandsbasierter Algorithmus mehrere Zwischenergebnisse benötigt, wird ein 

Mechanismus für den selektiven Zugriff auf einzelne Ergebnisse benötigt. 

� Unter einer Variablen, genauer gesagt Zustandsvariablen, verstehen wir einen 

Speicherbereich und einen Typ. 


04.11.2003 

– Auf den Inhalt des Speicherbereichs kann über eine eindeutige Referenz (z.B. eine Nummer) 

zugegriffen werden. 

– Der Inhalt wird entsprechend des Typs der Variablen interpretiert. 

Bemerkungen: 

� Die Referenz und der Typ einer Variablen ändern sich während der Laufzeit nicht! 

– Mittels der Referenz lässt sich die Adresse berechnen, an welcher die Variable im Speicher liegt. 

Bei vielen Programmiersprachen (z.B. C) ist die Referenz identisch zur Speicheradresse. 

� Der Wert einer Variablen kann sich ändern 

– Schreibe den Wert 2750 in die Variable mit Referenz 1 � 

1 

2 

Referenz 

Referenz 

1 

2 

Wert 

2500 

3000 

Wert 

2750 

3000 

Typ 

118 


int 

int 

Typ 

int 

int

Variablenbezeichner 

� Für die Lesbarkeit von Algorithmen: 

– Variablen werden nicht über ihre Referenz sondern über einen aussagekräftigen Namen angesprochen. 

– Im Programm muss explizit der Bezug zwischen den Namen und den Variablen hergestellt werden 

Variablendeklaration 

� In den meisten Programmiersprachen (z.B. Java) muss die Variablendeklaration vor dem ersten Zugriff auf die 

Variable erfolgen. 

� Nicht alle Namen sind erlaubt. 

– Verboten ist die Verwendung von Schlüsselwörtern. Zudem darf das erste Symbol keine Ziffer sein. 

– Als Zeichen sind Buchstaben, Ziffern und ein paar wenige Sonderzeichen erlaubt. 

� Darüber hinaus gibt es noch Konventionen 

– Variablennamen sollen mit Kleinbuchstaben beginnen, z. B. pos, suchGehalt 

– Bei zusammengesetzten Namen sollen alle angesetzten Teile mit einem Großbuchstaben beginnen, z. B. 

suchGehalt. 

� Beispiel (Java): int x 

– x ist der Bezeichner der Variablen 

– int bezeichnet den Datentyp. 


04.11.2003 

Bezeichner 

suchGehalt 

gehalt 

1 

2 

Variable 

� Zu einer Variablen gibt es höchstens einen Variablenbezeichner. 

– Umgekehrt gilt dies nicht! 

1 

2 

Referenz 

Wert 

2750 

3000 

Typ 

119 


Int 

int

Klassifizierung von Variablen 

� Instanzvariablen 


04.11.2003 

– Dies ist nur eine andere Bezeichnung von den Datenfeldern. 

– Instanzvariablen sind in der ganzen Klasse gültig, d. h. man kann den 

Namen in allen Methoden verwenden (Ausnahmen später). 

– Bei Erzeugung eines Objekts werden die zugehörigen Instanzvariablen 

erzeugt und beim Löschen des Objekts auch entsprechend die 

Instanzvariablen zerstört. 

� Lokale Variablen 

– Lokale Variablen werden innerhalb von Methoden deklariert. 

– Ihr Name ist höchstens nur in der zugehörigen Methode gültig (später 

werden wir noch genauer darauf eingehen). 

– Die Instanzvariable wird erzeugt, wenn die Deklarationsanweisung 

ausgeführt wird und spätestens beim Beenden wird die Variable zerstört 

(später genauer). 

120 


Wertzuweisung 

� Durch einen speziellen Operator kann einer Variable ein Wert zugewiesen werden. 

� in Java: Variablenbezeichner = Ausdruck 


04.11.2003 

– Wert des Ausdrucks wird zunächst berechnet (später genauer) und dann in den Speicherplatz 

der Variablen geschrieben, d.h. der alte Wert ist damit nicht mehr verfügbar. 

– Zusätzlich muss auch der Typ des Ausdrucks mit dem der Variable kompatibel sein. 


– x = 2*y + 5; 

– x = x + 1; 

– z = x*y + z; 

� Bemerkung 

– Bei der Auswertung eines Ausdrucks werden zunächst die Werte der im Ausdruck 

vorkommenden Variablen gelesen und dann in den Ausdruck eingesetzt. 

– Ein Problem in Java (und anderen Sprachen wie C und C++) ist die Verwendung des Symbols 

“=” für den Zuweisungsoperator. Es besteht stets die Gefahr einer Verwechslung mit dem 

Vergleichsoperator “==”. 

121 


Mathematische Sichtweise 

� Ein Zustand entspricht einer Funktion v, die jedem Variablennamen 

einen Wert zuweist. 

� Ein Schritt eines Algorithmus erzeugt aus dem alten Zustand einen 

neuen Zustand, d.h. die Bedeutung eines Algorithmus lässt sich als 

eine Funktion T auffassen mit 


04.11.2003 

T: Algorithmus × Zustand → Zustand 

wobei, wenn der Anfangszustand die Vorbedingung erfüllt, der 

Endzustand auch die Nachbedingung erfüllt. 

In einem späteren Kapitel werden wir genauer auf die Korrektheit von 

Algorithmen und Programmen eingehen. 

122 


3.5.2 Variablen: Namensraum, 

Gültigkeitsbereich und Lebensdauer 

� Programme werden von einem Team entwickelt. Es ist deshalb sinnvoll, ein 

Quellprogramm in Bereiche zu unterteilen (Namensräume), wo die Bezeichner 

unabhängig voneinander gewählt werden können. 


04.11.2003 

– jede Klasse besitzt einen eigenen Namensraum 

– jede Methode besitzt einen eigenen Namensraum 

� Namensraum einer Methode 

bezeichnet den Teil des Quellprogramms, der zwischen dem Bezeichner der 

Methode und dem Ende der Methode liegt. 

– Im Namensraum einer Methode können nur durch eine Variablendeklaration neue 

Bezeichner eingeführt werden. 

int test (int a, …, boolean z) { 

int aa; 

… 

} 

123 


� Namensraum einer Klasse 


04.11.2003 

bezeichnet den Teil des Quellprogramms, der zwischen dem Klassennamen 

und dem Ende der Klasse liegt. Die Namensräume der Methoden gehören 

zum Namensraum der Klasse. 

class xxx { 

private int x; 

public int test (int a, …, float z) { 

int aa; 

… 

} 

… 

} 

� Regel für Namensräume einer Klasse 

klassenbezogener Bezeichner 

methodenbezogener 

(lokaler) Bezeichner 

Zwei im gleichen Namensraum definierte Bezeichner müssen verschieden 

sein. Es gelten folgende Ausnahmen: 

– Der gleiche Bezeichner kann für eine Methode und eine Variable verwendet werden. 

– Methoden müssen sich in ihrer Signatur, aber nicht im Bezeichner unterscheiden. 

124 


Gültigkeitsbereich eines Bezeichners 

Gültigkeitsbereich lokaler Bezeichner 

� Bezeichner für Variablen, die innerhalb einer Methode deklariert wurden, 

heißen lokal. 

� Zu jedem lokalen Bezeichner gibt es einen eindeutigen Block, in dem der 

Bezeichner deklariert wurde. Die erste {, die vor der Deklaration liegt, definiert 

den Anfang des Blocks. 

� Der Gültigkeitsbereich eines lokalen Bezeichners ist der statische Teil des 

Programms, der bei der Deklaration des Bezeichners beginnt und bei der } des 

dazugehörigen Blocks endet. 

Gültigkeitsbereich von klassenbezogenen Bezeichnern 

� Der Gültigkeitsbereich eines Bezeichners, der im Namensraum der Klasse 

liegt, erstreckt sich über die gesamte Klasse (also auch über die Methoden). 

Regel für Gültigkeitsbereiche 

� Ein Bezeichner darf nur innerhalb seines Gültigkeitsbereichs benutzt werden. 


04.11.2003 

125 


Beispiel 

} 


04.11.2003 

class Beispiel { 

private int x; 

public int test1() { 

} 

} 

int y; 

y = 2; 

int z; 

… 

public int test2() { 

int b; 

… 

{ 

} 

int c; 

… 

Gültigkeitsbereich von x und den Bezeichnern 

test1 und test2. 

Gültigkeitsbereich von y 

Gültigkeitsbereich von z 

Gültigkeitsbereich von a und b 

Gültigkeitsbereich von c 

126 


Lebensdauer 

Aus einem (statischen) Quellprogramm wird dynamisch ein Prozess erzeugt. 

Zusätzlich erzeugt ein Quellprogramm dynamisch Variablen. 

class Beispiel { 

private int x = 100, y = 10; 

private int m1(int x) { 

boolean z; 

… 

} 

private int m2() { 

int b; 

… 

} 

public void run(int input) { 

int x; 

if (input > 0) 

x = m1(input*2); 

else 

x = m2(); 

System.out.print(“x = “); 

System.out.println(x); 

} 

} 


04.11.2003 

� Offensichtlich erzeugt dieses 

Programm in Abhängigkeit von der 

Eingabe verschiedene Prozesse. 

� Wenn in run die Methoden m1 oder 

m2 aufgerufen werden, müssen 

dynamisch Variablen erzeugt 

werden. 

� Die dynamische Erzeugung neuer 

Variablen muss auch bei Objekten 

vorgenommen werden. 

127 


Erzeugung von Objekten 

� Wird ein Objekt einer Klasse erzeugt, so werden alle 

Datenfelder neu angelegt. 


04.11.2003 

– Der Variablenname wird in die Bezeichnertabelle aufgenommen. 

– Dieser Name verweist auf eine Variable, die als Wert wiederum 

eine Bezeichnertabelle besitzt, in der die Bezeichner der 

Instanzvariablen liegen. 

Bezeichner 

beispielObj 

• Wir sprechen dann auch von einer Referenzvariablen. 

Variable 

1 

Bezeichnertabelle 

Referenz 

1 

2 

3 

10 

Wert 

100 

? 

Int 

int 

Typ 

Bezeichner 

128 


x 

y 

Variable 

2 

3

Erzeugung lokaler Variablen (Methodenaufruf) 

� Wird eine Methode aufgerufen, so werden alle lokalen Variablen (inkl. 

Parameter) neu angelegt. Zusätzlich wird der Name der Methode in 

einer Tabelle eingetragen und der Kontext der Methode gesetzt. 

Bezeichner 

beispielObj 


04.11.2003 

Variable 

Bezeichnertabelle 

Bezeichner 

run 

1 

Variable 

4 

Aufruftabelle 

Referenz 

1 

2 

3 

4 

5 

6 

10 

0 

Wert 

100 

200 

Typ 

? 

int 

int 

? 

int 

int 

Kontext des Methodenaufrufs 

Bezeichner 

Bezeichner 

input 

129 


x 

y 

x 

Variable 

2 

3 

5 

6 

Variable

Kontext 

� Eine Methode darf über Bezeichner auf ihre lokalen Variablen und auf die 

Instanzvariablen des Objekts direkt zugreifen. 

Diese Abbildung zwischen den Bezeichnern und den Variablen bezeichnen wir 

auch als der Kontext des Methodenaufrufs. 


04.11.2003 

– Stimmen die Bezeichner einer Instanzvariablen und einer lokalen Variablen überein, 

so muss beim Zugriff auf die Instanzvariable zusätzlich das Schlüsselwort this mit 

dem Punkt-Operator als Präfix mitangegeben werden: 

this.x ist also die Instanzvariable x und nicht die lokale Variable x. 

– allgemein gilt: „innere“ Teile des Kontexts verdecken „äußere“ 

– nach einem Bezeichner wird immer zuerst im innersten Teil des Kontextes gesucht 

� Der Methodenkontext eines Methodenaufrufs ist die Einschränkung des 

Kontexts auf den Namensraum seiner Methode. Der Objektkontext ist der 

Kontext eingeschränkt auf das Objekt der Klasse. 

Bemerkungen 

� Der Objektkontext einer Methode unterscheidet sich i. A. für jedes Objekt. 

130 


Bemerkungen 

� Pro Methodenaufruf werden lokale Variablen angelegt. 

– Wird eine Methode mehrfach aufgerufen (Rekursion), so gibt es zu einer Methode 

verschiedene Kontexte (pro Aufruf ein Kontext). 

� Beim Methodenaufruf bekommen die Variablen der Formalparameter die 

Werte der Aktualparameter zugewiesen. 

� Ist die Methode vollständig abgearbeitet, so werden die zu dem Aufruf der 

Methode erzeugten Variablen gelöscht. 

– Die Verarbeitung des Programms wird bei der aufrufenden Methode fortgesetzt 

(Kontextwechsel). 

– Es wird also insbesondere der Wert des Formalparameters nicht an den 

Aktualparameter gegeben. 

� Man beachte, dass der Kontext einer Methode (in Java) zur Laufzeit 

dynamisch entsteht, aber über den statischen Aufbau der Klasse definiert ist. 

Lebensdauer lokaler Variablen 


04.11.2003 

ich sehe also nicht den Kontext 

meiner Aufruf- sondern meiner 

Definitionsumgebung! 

� Ist der Zeitraum vom Aufruf der Methode bis zum Verarbeitungsende der 

Methode. 

131 


3.5.3 Schleifen 

� Gegeben eine Gehaltsliste und ein Gehalt. Schreiben Sie einen Algorithmus, 

der zu einem gegebenen Gehalt den zugehörigen Angestellten findet. 

Lies den ersten Eintrag aus der Gehaltsliste 

if (das Gehalt des Eintrags ist das gesuchte) 

notiere den Angestellten 

else { 

lies den nächsten Eintrag 

if (das Gehalt des Eintrags ist das gesuchte) 

notiere den Angestellten 

else { 

lies den nächsten Eintrag 

… 

} 

} 


04.11.2003 

Probleme 

� Beschreibung des 

Algorithmus ist zu 

aufwendig. 

� Algorithmus hängt direkt 

von der Dateneingabe ab: 

neue Liste ⇒ neuer 

Algorithmus 

Laut unserer Definition 

wäre dies kein 

Algorithmus!! 

132 


Ein Prozess sollte eine Sequenz beliebig oft durchlaufen dürfen 

while (Bedingung) 

Schritt1 

Schritt2 

� Bedeutung: 


04.11.2003 

– Die Bedingung der Schleife wird zuerst ausgewertet (Resultat: wahr oder falsch). 

– Falls das Resultat wahr ist, wird Schritt1 ausgeführt und danach wieder die 

Bedingung ausgewertet. 

– Dies wird solange wiederholt bis die Auswertung der Bedingung falsch ergibt. 

– Danach wird mit Schritt2 fortgefahren. 

� Begriffe 

– Bedingung wird auch als Abbruchbedingung bezeichnet. 

– Schritt1 wird auch als Schleifenrumpf bezeichnet. 

• Jeder Schritt darf wiederum ein komplexer Schritt z.B. eine Sequenz sein. 

Voraussetzung bei Schleifen 

� Der Wert der Bedingung sollte sich bei der Ausführung verändern. 

Hierzu hängt dieser Wert normalerweise von einer Variablen ab. 

133 


modifizierter Algorithmus: 

1. erzeuge zwei Variablen mit Bezeichnern suchGehalt und gehalt; 

2. suchGehalt = gesuchtes Gehalt; 

3. gehalt = Gehalt des ersten Angestellten aus der Liste; 

4. while (suchGehalt != gehalt und 

es gibt noch einen verbleibenden Eintrag in der Liste) 

4.1. gehalt = Gehalt des nächsten Angestellten aus der Liste; 

5. if (der Wert von suchGehalt ist gleich dem Wert von gehalt) 

5.1. notiere den Angestellten; 

� Der Operator „!=“ vergleicht die Werte der entsprechenden Variablen 

auf Ungleichheit. Falls dies der Fall ist, ist die Bedingung wahr 

Ansonsten falsch. 

� Entwicklung des Prozesszustandes bei der Suche 


04.11.2003 

Bezeichner 

suchGehalt 

gehalt 

Schritt 1 

Schritt 2 

2750 

Schritt 3 

2750 

1000 

Schritt 4 

2750 

1000 

Schritt 4.1 

2750 

1300 

134 


... 

... 

...

Algorithmen als Flussdiagramme 

� Algorithmen können an Hand folgender elementarer Bestandteile 

angegeben werden: 


04.11.2003 

1. In ein Rechteck wird genau eine auszuführende Elementaroperation 

geschrieben. 

2. Pfeile führen zu der als nächstes auszuführenden Aktion. 

3. In einer Raute steht eine Bedingung. Ist diese erfüllt, folgt man dem Pfeil 

mit der Marke T (für true). 

T F 

4. An diesem Kreis wird der Algorithmus begonnen. 

5. An diesem gefüllten Kreis wird der Algorithmus beendet. 

135 


Beispiel: 

Gehaltsliste 


04.11.2003 

4.1 gehalt = 

nächstes Gehalt 

aus der Liste 

1. erzeuge die 

Variablen 

suchGehalt und 

gehalt 

2. suchGehalt = 

gesuchtes Gehalt 

3. gehalt = 

erstes Gehalt aus 

der Liste 

T 4. suchGehalt 

!= gehalt 

F 

T 5. suchGehalt 

== gehalt 

F 

5.1 notiere den 

Angestellten 

136 


Zusammenfassung 

� Problemspezifikation, Algorithmus, Prozess und Prozessor 

� Konzepte beim Entwurf von Algorithmen 


04.11.2003 

– schrittweise Verfeinerung (Methode) 

– Kontrollstrukturen (Sequenz, Selektion, Schleifen) 

Problem bei der bisherigen Darstellung von Algorithmen 

� Algorithmen wurden unter dem Blickwinkel betrachtet, anderen 

Menschen Lösungswege zu Problemen mitzuteilen. 

– relativ informelle und abstrakte Beschreibung der Lösungswege 

– Studierende der Vorlesung bringen genügend an Vorwissen mit, um diese 

Beschreibung zu verstehen und in einen Prozess umzusetzen. 

� Werden Algorithmen einem Rechner mitgeteilt, wird hierfür eine 

Programmiersprache benutzt. 

– In Java erfolgt die Umsetzung eines Algorithmus in eine Methode 

137

Kapitel 3 - Algorithmen und Methoden

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?