Foliensatz 13 (1 auf 1)

4. Prozedurales Programmieren
4.1 Der Begriff des Algorithmus
Begriffsklärung: (Effizienz) (2)
Mit den gemachten Präzisierungen lässt sich der Aufwand einer
Ausführung quantifizieren:
• Zeitkomplexität: Wie viele Schritte braucht der Algorithmus in
Abhängigkeit von den Eingabewerten?
• Raumkomplexität: Wie viel Speicherplatz braucht der Algorithmus
in Abhängigkeit von den Eingabewerten?
©Arnd Poetzsch-Heffter
TU Kaiserslautern
565
4. Prozedurales Programmieren
4.1 Der Begriff des Algorithmus
Begriffsklärung: (deterministisch)
Ein Algorithmus heißt deterministisch, wenn für alle Eingabedaten
der Ablauf des Algorithmus eindeutig bestimmt ist.
Andernfalls heißt er nicht-deterministisch.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
566
4. Prozedurales Programmieren
4.1 Der Begriff des Algorithmus
Beispiel: (nicht-deterministischer Algorithmus)
Aufgabe:
Erkenne, ob eine Eingabezeichenreihe über Kleinbuchstaben eines
der Worte " otto" , "toto", "total" enthält.
Eingabe: Eingabezeichenreihe über Kleinbuchstaben
Ausgabe:
ja/nein
Nicht-deterministischer Algorithmus:
• Seien
I
z die Eingabe und
I
pflän(z) = { 0, . . . , länge(z) − 4 }
©Arnd Poetzsch-Heffter
TU Kaiserslautern
567
4. Prozedurales Programmieren
4.1 Der Begriff des Algorithmus
Beispiel: (nicht-deterministischer Algorithmus) (2)
• Solange pflän, ∅ tue Folgendes:
I
wähle ein x aus pflän aus;
I
pflän = pflän\{x};
I
w = "z ohne die ersten x Buchstaben";
I
prüfe, ob w mit " otto" , " toto" , " total" beginnt ;
I
wenn ja, terminiert der Algorithmus mit "ja"; andernfalls setze die
Schleife fort.
• Terminiere mit "nein".
©Arnd Poetzsch-Heffter
TU Kaiserslautern
568
4. Prozedurales Programmieren
4.1 Der Begriff des Algorithmus
Begriffsklärung: (determiniert)
Ein Algorithmus heißt determiniert, wenn er bei gleichen zulässigen
Eingabewerten stets das gleiche Ergebnis liefert.
Andernfalls heißt er nicht-determiniert.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
569
4. Prozedurales Programmieren
4.1 Der Begriff des Algorithmus
Beispiele: (Determiniertheit)
• Jeder Algorithmus, der eine Funktion berechnet, ist determiniert.
• Der Algorithmus von der letzten Folie ist determiniert.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
570
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Abschnitt 4.2
Grundkonzepte prozeduraler Programmierung
©Arnd Poetzsch-Heffter
TU Kaiserslautern
571
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Grundkonzepte prozeduraler Programmierung
Algorithmen lassen sich mit unterschiedlichen Sprachmitteln
beschreiben:
• umgangssprachlich
• mit graphischen Notationen
• mit mathematischer Sprache
• mit programmiersprachlichen Mitteln.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
572
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Begriffsklärung: (prozedurales Paradigma)
Gemäß des prozeduralen Paradigmas (vgl. Folie 155) wird
• der Zustand eines Systems mit Variablen beschrieben
• werden die möglichen Systemabläufe algorithmisch formuliert und
• bilden Prozeduren das zentrale Strukturierungs- und
Abstraktionsmittel.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
573
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Prozedurale Systemsicht)
Ein Rechensystem (z.B. PC) kann man prozedural wie folgt
beschreiben:
• Jede Datei ist eine Variable für Listen von Bytes.
• Nach dem Starten des Rechners wird ein nicht-terminierender
Algorithmus ausgeführt:
while( true ) {
warte auf Eingabe eines Programmnamens;
starte Programm mit eingegebenem Namen
als parallelen Algorithmus;
}
• Jedes Programm entspricht dabei einer Prozedur.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
574
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Unterabschnitt 4.2.1
Sprachliche Basis: Teilsprache von Java
©Arnd Poetzsch-Heffter
TU Kaiserslautern
575
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Sprachliche Basis: Teilsprache von Java
Der Abschnitt 4.2 stellt diejenigen Grundkonzepte der prozeduralen
Programmierung vor, die als Voraussetzung für die objektorientierte
Programmierung benötigt werden:
• Deklaration und Verwendung von Variablen
• Anweisungen
• Deklaration und Verwendung von Prozeduren
©Arnd Poetzsch-Heffter
TU Kaiserslautern
576
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Sprachliche Basis: Teilsprache von Java (2)
Zur Programmierung verwenden wir eine Teilsprache von Java.
Vorteile:
• Der Übergang zur objektorientierten Programmierung wird
einfacher.
• Der Zusammenhang zwischen prozeduraler und objektorientierter
Programmierung wird klarer.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
577
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Sprachliche Basis: Teilsprache von Java (3)
Nachteile:
• Da klassenlose, rein prozedurale Programmierung von Java nicht
unterstützt wird, entsteht ein notationeller Mehraufwand.
• Bestimmte Sprachelemente bleiben zunächst unerklärt.
Vorgehen:
• Basisdatentypen
• Ausdrücke
• Variablendeklarationen
• Programmstruktur und vereinfachte Notation
©Arnd Poetzsch-Heffter
TU Kaiserslautern
578
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Basisdatenstrukturen in Java:
Java bietet insbesondere Basisdatenstrukturen mit den Typen
boolean
char
int , long , short ,
float , double
sowie entsprechende Funktionen und Konstanten.
Die nichtstrikten Operationen sind:
_?_ : _
_ && _
_ || _
©Arnd Poetzsch-Heffter
statt
wie
wie
if _ then _ else _
in Haskell
in Haskell
TU Kaiserslautern
in Haskell
579
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Ausdrücke in Java:
Mittels der Konstanten und Funktionen der elementaren
Datenstrukturen lassen sich analog zu Haskell Ausdrücke bilden.
(Darüber hinaus kann man deklarierte Prozeduren in Ausdrücken
aufrufen. Dadurch können bei der Auswertung von Ausdrücken
Seiteneffekte entstehen.)
©Arnd Poetzsch-Heffter
TU Kaiserslautern
580
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Ausdrücke in Java)
5 + 89
45 / 6
47474747 L * a
23+3
d == 78 + e
7 >= 45 == true
abs(a) + abs(d)
sein | !sein
true || tuEs ()
a > b ? a : b
©Arnd Poetzsch-Heffter
für geeignetes a
für geeignete d, e
für geeignete a, d, abs
für geeignete Variable sein
für geeignete Prozedur tuEs
// liefert max(a, b)
TU Kaiserslautern
581
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Variablendeklarationen in Java:
Eine Variablendeklaration hat die Form:
<Typbezeichner >
<Variablenbezeichner > ;
und definiert eine neue Variable vom angegebenen Typ mit dem
angegebenem Bezeichner. Beispiele:
int a;
boolean b;
float meineGleitkommavariable ;
char cvar;
Eine Variablendeklarationsliste entsteht durch Aneinanderreihen von
einzelnen Deklarationen.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
582
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Programmstruktur und -syntax:
Ein prozedurales Programm besteht aus:
• einer Liste von Typdeklaration
• einer Liste von globalen Variablendeklarationen
• einer Liste von Prozedurdeklarationen
• einer Hauptprozedur
In Java lassen sich prozedurale Programme mit folgendem
Programmrahmen formulieren:
©Arnd Poetzsch-Heffter
TU Kaiserslautern
583
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Programmstruktur und -syntax: (2)
<Programmname>.java
public class <Programmname > {
static <Typdeklaration 1 >
...
static <Typdeklaration k >
static <Variablendeklaration 1 >
...
static <Variablendeklaration m >
static <Prozedurdeklaration 1 >
...
static <Prozedurdeklaration n >
public static void main( String [] args)
<Prozedurrumpf >
}
wobei k ≥ 0, m ≥ 0, n ≥ 0.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
584
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Bemerkung:
• Die Reihenfolge der Deklarationen kann vertauscht werden.
• Die hier nicht erklärten Sprachkonstrukte werden in Kapitel 5
behandelt.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
585
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Konventionen:
• Wir gehen davon aus, dass die Datei InputOutput.java im
aktuellen Dateiverzeichnis liegt. Sie stellt bereit:
public class IO
public static
public static
public static
public static
public static
}
©Arnd Poetzsch-Heffter
{
int readInt (){.. .}
String readString (){.. .}
char readChar (){.. .}
void print ( Object o){.. .}
void println ( Object o){.. .}
TU Kaiserslautern
586
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Konventionen: (2)
• Mit den Prozeduren print und println können insbesondere
Werte und Objekte der Typen int, char und String ausgegeben
werden.
• Im Folgenden werden wir die ersten beiden und die letzte Zeile
des Programmschemas der letzten Folie sowie die
Schlüsselwörter static und public auf Folien der
Übersichtlichkeit halber weglassen.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
587
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Notation prozeduraler Programme)
Foo.java
public class Foo {
static int a;
static boolean bvar;
static int abs( int n ) {
if( n >= 0 ){
return n;
} else {
return -n;
}
}
©Arnd Poetzsch-Heffter
TU Kaiserslautern
588
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Notation prozeduraler Programme) (2)
static void setA () {
a = abs(a);
}
public static void main( String [] args ){
IO. println (" Eingabe von a:");
a = IO. readInt ();
setA ();
IO. println ( a );
}
}
©Arnd Poetzsch-Heffter
TU Kaiserslautern
589
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Notation prozeduraler Programme) (3)
Abkürzend schreiben wir hier:
int a;
boolean bvar;
int abs( int n ) {
if( n≥0 ){
return n;
} else {
return -n;
}
}
©Arnd Poetzsch-Heffter
TU Kaiserslautern
590
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Notation prozeduraler Programme) (4)
void setA () {
a = abs(a);
}
void main( String [] args ){
println (" Eingabe von a:");
a = readInt ();
setA ();
println ( a );
}
©Arnd Poetzsch-Heffter
TU Kaiserslautern
591
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Überblick übers weitere Vorgehen:
• Anweisungen
• Prozeduren
• Variablen in Programm und Speicher
• Felder
• Benutzerdefinierte Typen
• Sichtbarkeit von Bindungen
• Iteration und Rekursion
• Weitere prozedurale Sprachkonzepte
©Arnd Poetzsch-Heffter
TU Kaiserslautern
592
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Bemerkung:
• Die Konzepte sind rekursiv von einander abhängig:
I
Anweisungen benutzen Variablen und Ausdrücke
I
Prozeduren basieren auf Anweisungen
I
Verwendung von Variablen kann nur im Kontext von Anweisungen
und Prozeduren erklärt werden.
I
Ausdrücke erlauben die Verwendung von Prozeduren.
• In der programmiersprachlichen Realisierung der Konzepte
verwischen ihre Grenzen; z.B.:
I
Parameter lassen sich wie Variable verwenden.
I
Einfache Anweisungen lassen sich in Ausdrücken verwenden.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
593
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Unterabschnitt 4.2.2
Anweisungen
©Arnd Poetzsch-Heffter
TU Kaiserslautern
594
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Begriffsklärung: (Anweisung)
Anweisungen sind programmiersprachliche Beschreibungsmittel:
• Einfache Anweisungen beschreiben Aktionen.
• Zusammengesetzte Anweisungen beschreiben, wie mehrere
Aktionen auszuführen sind, also Teile von Algorithmen.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
595
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Anweisungen)
1. Zuweisung eines Werts an eine Variable:
<Variable > = <Wert > ;
2. Schleifenanweisung:
while ( <Bedingung > ) {
<Anweisungen >
}
©Arnd Poetzsch-Heffter
TU Kaiserslautern
596
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Bemerkung:
Unterschied: Anweisung / Ausdruck
• Die Auswertung von Ausdrücken liefert ein Ergebnis.
• Die Ausführung von Anweisungen verändert den Zustand. Im Allg.
liefert sie kein Ergebnis.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
597
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Bemerkung: (2)
Wir betrachten die folgenden Anweisungen und ihre Realisierung in
Java:
• Einfache Anweisungen:
I
Zuweisung
I
Prozeduraufruf
• Anweisungsblöcke
• Schleifenanweisungen:
I
while-, do-, for-Anweisung
©Arnd Poetzsch-Heffter
TU Kaiserslautern
598
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Bemerkung: (3)
• Verzweigungsanweisungen:
I
bedingte Anweisung
I
Fallunterscheidung
I
Auswahlanweisung
• Sprunganweisungen:
I
Abbruchanweisung
I
Rückgabeanweisung
©Arnd Poetzsch-Heffter
TU Kaiserslautern
599
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Einfache Anweisungen
Zuweisung: (engl. assignment)
Syntax in Java:
<Variable >
=
<Ausdruck > ;
Semantik:
Werte den Ausdruck aus und weise das Ergebnis der Variablen zu. (In
Java ist eine Zuweisung syntaktisch ein Ausdruck, liefert also einen
Wert und zwar das Ergebnis der Auswertung von der rechten Seite der
Zuweisung.)
©Arnd Poetzsch-Heffter
TU Kaiserslautern
600
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Einfache Anweisungen (2)
Beispiele:
a = 27 % 23;
b = true;
meineGleitkommavariable = 3.14;
Sprechweise:
"Variable b ergibt sich zu true" oder
"Variable b wird true zugewiesen".
©Arnd Poetzsch-Heffter
TU Kaiserslautern
601
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Bemerkung:
In einer Zuweisung (und anderen Sprachkon- strukten) kann eine
Variable v mit zwei Bedeutungen vorkommen:
1. Das Vorkommen links vom Zuweisungszeichen meint die Variable.
Man spricht vom L-Wert (engl. l-value) des Ausdrucks v .
2. Das Vorkommen rechts vom Zuweisungszeichen meint den in v
gespeicherten Wert. Man spricht
vom R-Wert (engl. r -value) des Ausdrucks v .
Die Unterscheidung wird wichtiger, wenn auch links des
Zuweisungszeichens komplexere Ausdrücke stehen.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
602
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (L-Wert, R-Wert)
%
L-Wert
a = 7 + a;
©Arnd Poetzsch-Heffter
R-Wert
TU Kaiserslautern
603
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Prozeduraufruf: (engl. procedure call)
Syntax:
<Prozedurbezeichner > ( <AktuelleParameterliste > ) ;
<AktuelleParameterliste > → ε | <Ausdrucksliste >
<Ausdrucksliste > → <Ausdruck >
| <Ausdruck > , <Ausdrucksliste >
Semantik:
Werte die Ausdrücke der aktuellen Parameter aus. übergebe die
Ergebnisse an die formalen Parameter. Führe die Anweisungen der
Prozedur aus. Liefere den Rückgabewert, wenn vorhanden.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
604
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Prozeduraufruf: (engl. procedure call) (2)
Beispiele:
1. Prozeduraufruf mit Ergebnis:
a = ggt(a,abs (45 -87));
// Zuweisung
2. Prozeduraufruf mit Seiteneffekt:
print ( ggt (24 ,248));
// Anweisung
©Arnd Poetzsch-Heffter
TU Kaiserslautern
605
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Anweisungsblöcke
Ein Anweisungsblock (engl. block statement) ist eine Liste bestehend
aus Deklarationen und Anweisungen.
Syntax in Java:
{ <DeklAnweisListe > }
<DeklAnweisListe > → ε
| <Deklaration >
| <Anweisung >
| <Deklaration > <DeklAnweisListe >
| <Anweisung > <DeklAnweisListe >
Semantik:
Stelle den Speicherplatz für die Variablen bereit und führe die
Anweisungen der Reihe nach aus.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
606
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel:
{ int i; i = 7; int a; a = 27 % i; }
Üblicherweise schreibt man Deklarationen und Anweisungen
untereinander, so dass ein Textblock entsteht.
{
}
int
int
i =
x =
i;
x;
readInt ();
abs(i);
©Arnd Poetzsch-Heffter
TU Kaiserslautern
607
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Schleifenanweisungen
Schleifenanweisungen (engl. loop statements) steuern die iterative,
d.h. wiederholte Ausführung von Anweisungen/Anweisungsblöcken.
while-Anweisung:
Syntax in Java:
while ( <boolescherAusdruck > )
<Anweisung >
Semantik:
Werte den Ausdruck aus, die sogenannte Schleifenbedingung. Ist
die Bedingung erfüllt, führe die Anweisung aus, den sogenannten
Schleifenrumpf , und wiederhole den Vorgang. Andernfalls beende
die Ausführung der Schleifenanweisung.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
608
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel:
Aus der Prozedur ggt:
while (
{
v =
n =
m =
}
m >0 )
n % m;
m;
v;
while (
v =
n =
m =
}
m >0 ) {
n % m;
m;
v;
Bemerkung:
Der Schleifenrumpf ist in den meisten Fällen ein Anweisungsblock.
Syntaktisch korrekt ist aber auch z.B.:
while( true ) print (i);
©Arnd Poetzsch-Heffter
TU Kaiserslautern
609
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
do-Anweisung:
Syntax in Java:
do
<Anweisung >
while ( <boolescherAusdruck > ) ;
Semantik:
Führe die Anweisung aus. Werte danach den booleschen Ausdruck
aus. Ist die Bedingung erfüllt ist, wiederhole den Vorgang. Andernfalls
beende die Ausführung der Schleifenanweisung.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
610
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Bemerkung:
Die do-Anweisung ist immer dann sinnvoll, wenn man einen Vorgang
mindestens einmal ausführen muss.
In solchen Situationen spart man sich gegenüber der Verwendung der
while-Schleife die anfänglich unnötige Auswertung der Bedingung.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
611
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel:
Wir betrachten die Ausgabe der Elemente einer nicht-leeren Liste. Wir
gehen davon aus, dass es einen Typ IntList mit Prozeduren head, tail
und isempty gibt:
IntList grades ;
int g;
...
// Zuweisung an die Variable noten
// Ausgabe der nicht - leeren Notenliste
do {
g = head( grades );
println (g);
grades = tail( grades );
} while ( ! isempty ( grades ) );
©Arnd Poetzsch-Heffter
TU Kaiserslautern
612
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (2)
for-Anweisung (Zählanweisung):
Die for-Anweisung dient vorrangig zur Bearbeitung von Vektoren und
Matrizen, deren einzelne Komponenten über Indizes angesprochen
werden.
Wir betrachten zunächst ein Beispiel:
©Arnd Poetzsch-Heffter
TU Kaiserslautern
613
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Zählanweisung)
// Skalarprodukt
void main( String [] args ){
int i;
// zwei Vektoren mit jeweils 3 Elementen
int v1 [] = new int [3];
int v2 [] = new int [3];
int skalprod ;
v1 [0] = 1;
v1 [1] = 3;
v1 [2] = 8;
©Arnd Poetzsch-Heffter
TU Kaiserslautern
614
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Zählanweisung) (2)
v2 [0] = 2;
v2 [1] = 3;
v2 [2] = 4;
skalprod = 0;
}
for( i = 0; i <3; i++ ) {
skalprod = skalprod + v1[i]* v2[i] ;
}
println ( skalprod );
©Arnd Poetzsch-Heffter
TU Kaiserslautern
615
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Syntax in Java:
for(< Ausdrucksanweisung1 > ;
<boolescherAusdruck > ;
<Ausdrucksanweisung2 > )
<Anweisung >
<Ausdrucksanweisung > → <Variable > = <Ausdruck >
|
<Variable > ++
|
<Variable > --
©Arnd Poetzsch-Heffter
TU Kaiserslautern
616
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Semantik:
Ausdrucksanweisung:
1. Produktion: wie bei Zuweisung.
2./3. Produktion: Lese den Wert der Variablen.
Erhöhe/erniedrige den Wert der Variablen um 1.
Liefere den gelesenen Wert zurück.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
617
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Verzweigungsanweisungen
Verzweigungsanweisungen (engl. branch statements) stellen
Bedingungen an die Ausführung einer Anweisung oder wählen einen
von mehreren Zweigen zur Ausführung aus.
Bedingte Anweisung:
Syntax in Java:
if( <boolescherAusdruck > )
<Anweisung >
Semantik:
Werte den Ausdruck aus. Ist das Ergebnis true, führe die Anweisung
aus. Andernfalls ist die Ausführung sofort beendet.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
618
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Bedingte Anweisung)
if( i != 0 ) { n = k/i; }
if(
{
}
gute_Idee_vorhanden
&& genug_Zeit_zur_Vorbereitung )
halte_anregende_Weihnachtsvorlesung ();
mache_schneller_damit_frueher_fertig ();
©Arnd Poetzsch-Heffter
TU Kaiserslautern
619
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Fallunterscheidung:
Syntax in Java:
if( <boolescherAusdruck > )
else
<Anweisung1 >
<Anweisung2 >
Semantik:
Werte den Ausdruck aus. Ist das Ergebnis true, führe Anweisung1,
andernfalls Anweisung2 aus.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
620
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Fallunterscheidung)
if( i!=0 ) {
n = k/i;
n++;
} else {
fehlerbehandlung (" Division durch Null");
}
©Arnd Poetzsch-Heffter
TU Kaiserslautern
621
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Auswahlanweisung:
Auswahlanweisungen erlauben es, in Abhängigkeit von dem Wert
eines Ausdrucks direkt in einen von endlich vielen Fällen zu
verzweigen. In Java gibt es dafür die switch-Anweisung. Wir verzichten
hier auf eine genaue Beschreibung von Syntax und Semantik und
betrachten ein Beispiel:
©Arnd Poetzsch-Heffter
TU Kaiserslautern
622
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Auswahlanweisung)
void main( String [] args ){ // AuswahlanweisungsTest
char c;
boolean machWeiter = true;
do {
print ("Ein Zeichen aus {a,b,c,e}:");
c = readChar ();
switch ( c ) {
case ’a’: proza (); break ;
case ’b’: prozb (); break ;
case ’c’: prozc (); break ;
case ’e’:
machWeiter = false ; break ;
default :
print (" Falsches Eingabezeichen ");
}
} while ( machWeiter );
}
©Arnd Poetzsch-Heffter
TU Kaiserslautern
623
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Auswahlanweisung) (2)
wobei proza, prozb, prozc beliebige Prozeduren sind, zum Beispiel:
void proza () {
/* hier koennte ’was Interessantes stehen */
println (" Ich bin Prozedur A. Alles gut ?");
println (" Probleme mit dem Weina ’stress ?\n");
}
void prozb () {
/* hier natuerlich auch */
println ("Wer A sagt , muss auch B sagen .");
println (" Haben Sie schon A gesagt .\n");
}
void prozc () {
println ("C wie no comment . Cool ,oder ?\n");
}
©Arnd Poetzsch-Heffter
TU Kaiserslautern
624
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Sprunganweisungen
Sprunganweisungen (engl. jump statements) legen eine
Fortsetzungsstelle der Ausführung fest, die möglicherweise weit von
der aktuellen Anweisung entfernt liegt. Wir betrachten hier nur
Sprünge, die der Programmstruktur folgen.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
625
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Abbruchanweisung:
Syntax in Java:
break;
Semantik:
Die Ausführung wird am Ende der umfassenden zusammengesetzen
Anweisung fortgesetzt.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
626
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Auswahlanweisung)
1. In Auswahlanweisung: siehe oben.
2. In Schleifenanweisungen:
while ( true ) {
...
if( <Abbruchbedingung > ) break ;
...
}
©Arnd Poetzsch-Heffter
TU Kaiserslautern
627
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Rückgabeanweisung:
Syntax in Java:
return ;
return <Ausdruck > ;
Semantik:
1. Fall/Produktion:
Nur in Prozeduren ohne Rückgabewert erlaubt. Beende die
Ausführung der Prozedur. Setze die Ausführung an der
Aufrufstelle fort.
2. Produktion:
Nur in Prozeduren mit Rückgabewert erlaubt. Werte den Ausdruck
aus. Beende die Ausführung der Prozedur. Liefere den Wert des
Ausdrucks als Ergebnis und setze die Ausführung an der
Aufrufstelle fort.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
628
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Rückgabeanweisung)
int abs( int n ) {
if( n ≥ 0 ) {
return n;
} else {
return -n;
}
}
©Arnd Poetzsch-Heffter
TU Kaiserslautern
629
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Unterabschnitt 4.2.3
Prozeduren
©Arnd Poetzsch-Heffter
TU Kaiserslautern
630
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Prozeduren
Prozeduren erlauben es, von konkreten Anweisungen bzw.
Anweisungssequenzen zu abstrahieren.
D.h. Prozeduren legen die Parameter einer zusammengesetzten
Anweisung fest und geben ihr einen Namen.
Dies ermöglicht:
• Wiederverwendung,
• Schnittstellenbildung und Information Hiding.
Darüber hinaus ermöglichen Prozeduren die rekursive Ausführung von
Anweisungen.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
631
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Begriffsklärung: (Prozedur)
Eine Prozedur ist eine Abstraktion einer Anweisung. Sie gibt der
Anweisung einen Namen und legt fest, das die Parameter der
Anweisung sind. Prozeduren können Ergebnisse liefern.
Bemerkung
Prozeduren abstrahieren Anweisungen genauso, wie Funktionen
Ausdrücke abstrahieren.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
632
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Prozedur als Abstraktion
Aufgabe:
Berechne den Absolutbetrag einer ganzen Zahl gespeichert in Variable
i und schreibe ihn in die Variable x.
Algorithmus:
Wenn i größer oder gleich 0, liefere i als Ergebnis; andernfalls −i.
Weise das Ergebnis an x zu.
©Arnd Poetzsch-Heffter
TU Kaiserslautern
633
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Prozedur als Abstraktion (2)
void
int
int
i =
main(.. .){
i;
x;
readInt ();
int result ;
if( i>=0 ) {
result = i;
} else {
result = -i;
}
}











 Abstraktion bzgl. i,



result wird zum Ergebnis.








x = result ;
©Arnd Poetzsch-Heffter
TU Kaiserslautern
634
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Beispiel: (Prozedur als Abstraktion (3)
int abs( int n ) {
if( n ≥ 0 ) {
return n;
} else {
return -n;
}
}
void main(.. .){
int i;
int x;
i = readInt ();
}
x = abs(i);
©Arnd Poetzsch-Heffter
TU Kaiserslautern
635
4. Prozedurales Programmieren
4.2 Grundkonzepte prozeduraler Programmierung
Deklaration von Prozeduren/Methoden:
Syntax in Java:
<Typ > <Prozedurbezeichner > ( <formaleParameter > )
<Anweisungsblock >
Semantik:
Die Semantik ist durch den Aufrufmechanismus und den
Anweisungsblock, den sogenannten Prozedurrumpf bestimmt
(Genaueres siehe unten).
©Arnd Poetzsch-Heffter
TU Kaiserslautern
636