Grundlegende Prinzipien der...

Proinformatik: Objektorientierte Programmierung

Freie Universität Berlin

Dr. Marco Block-BerlitzSommersemester 2012 62

Grundlegende Prinzipien der Programmentwicklung



Dr. Marco Block-BerlitzSommersemester 2012

Grundlegende Prinzipien der Programmentwicklung

• Programm als Kochrezept• Aktivitätsdiagramm (UML)• Prinzipien der Programmerstellung• Pseudocode• Erstellen eines Javaprogramms• Einfaches Klassenkonzept• Kommentare, Syntaxhighlighting, Einrücken• Sequentielle Anweisungen• Verzweigungen• Schleifentypen• Sprunganweisungen• Wiederholende Programmabschnitte

63

Übersicht zum Vorlesungsinhalt zeitliche Abfolge und Inhalte können variieren




Rezept für sechs Portionen von Omas Eierpfannkuchen

66

Die Reihenfolge der Anweisungen ist wichtig!




Pseudocode vom Rezept

67

1 vier Eier in eine Schüssel schlagen und verrühren

2 Mehl in die Schüssel hinzugeben

3 -> wenn Teig noch nicht schwer zu rühren ist gehe zu 2

4 Milch in die Schüssel geben

5 -> wenn Teig nicht leicht zu rühren ist gehe zu 4

6 etwas Fett in einer Pfanne erhitzen

7 einen Teil in die Pfanne geben, bis Boden gut bedeckt

8 -> wenn süße Variante gewünscht gehe zu 9 ansonsten zu 10

9 Apfelscheiben hinzugeben, gehe zu 11

10 Wurst und Käse hinzugeben

11 die Eierpfannkuchen von beiden Seiten gut braun braten


13 mit Marmelade, Apfelmus oder Zucker garnieren

14 FERTIG

Mit Pseudocode bezeichnen wir die lesbare Notation eines Programms in keinerspezifischen Programmiersprache, sondern in einer allgemeineren Form:

Alltägliche Prozesse können als Programme verstanden werden. Es gibt immerwiederkehrende Vorgehensweisen. Bei genauerer Betrachtung gibt es sogar nurdrei.

Alle anderen Methoden sind leicht als Spezialfall dieser drei zu interpretieren.




Aktivitätsdiagramm

68

Eine Anweisung mit der gestartet wird, markieren wir zusätzlich mit einemausgefüllten Kreis. Eine finale Anweisung wird ebenfalls gesondert markiert.

Diese Abbildungsform wird auch als Aktivitätsdiagramm bezeichnet und gehört zumSprachumfang der grafischen Modellierungssprache UML (Unified ModelingLanguage) die aktuell in der Softwareentwicklung standardmäßig eingesetzt wird.

Ein weißes Kästchen steht für eine Anweisung, die das Programm auszuführen hat:

Start

Ende

eine Anweisung

+

zwei Anweisung verketten

AAAA BBBB

AAAA BBBB




Sequentieller Programmablauf

69

Prinzipiell kann ein Programm Anweisung für Anweisung hintereinander weggeschrieben werden. Kein Abschnitt wird dabei wiederholt:

Das könnte beispielsweise eine maschinelle Qualitätsprüfung sein (Prüfen: Größe,Form, Farbe, ...)




Verzweigungen

70

Oft kommt es vor, dass eine Entscheidung getroffen werden muss, die die Wahl dernachfolgenden Anweisungen beeinflusst:

Verzweigung

In unserem Rezeptbeispiel ist es beispielsweise die Wahl der Variante.

Es gibt auch die Möglichkeit, eine Verzweigung in beliebig vielen Wegenfortzufahren. Wir sprechen dann von einer Mehrfachverzweigung:




Sprünge

71

Sprünge sind ein Spezialfall einer Verzweigung:

Anstatt einen unabhängigen Weg zu beschreiten, springen wir zu einen späterenProgrammabschnitt und machen dort weiter. Damit können wir Programmpassagenbei Bedarf überspringen.




Schleifen

72

Schleifen sind ebenfalls ein Spezialfall einer Verzweigung:

Wir können einen bestimmten Prozessabschnitt solange wiederholen lassen (z.B.Mehl in eine Schüssel geben) bis ein gewünschtes Ergebnis erreicht ist.

Schleifen kommen oft verschachtelt vor (Mehrfachschleifen):




Parallelität

73

Das dritte wichtige Konzept, neben sequentieller Abfolge und dem Sprung ist dieParallelität:

Zwei Striche auf den Verzweigungspfeilen sollen bedeuten, dass die beiden Wegegleichzeitig bearbeitet werden sollen und sich später wieder treffen können.

beide Pfade werden parallel ausgeführt

wenn beide fertig sind, geht es weiter




Kombination zu Programmen

74

1 vier Eier in eine Schüssel schlagen und verrühren

2 Mehl in die Schüssel hinzugeben

3 -> wenn Teig noch nicht schwer zu rühren ist gehe zu 2

4 Milch in die Schüssel geben

5 -> wenn Teig nicht leicht zu rühren ist gehe zu 4

6 etwas Fett in einer Pfanne erhitzen

7 einen Teil in die Pfanne geben, bis Boden gut bedeckt


9 Apfelscheiben hinzugeben, gehe zu 11

10 Wurst und Käse hinzugeben

11 die Eierpfannkuchen von beiden Seiten gut braun braten


13 mit Marmelade, Apfelmus oder Zucker garnieren

14 FERTIG

In der Kombination ergeben die vorgestellten Methoden: Programme! Schauen wiruns dazu nochmal das Kochrezeptbeispiel an:

Dargestellt als Aktivitätsdiagramm:

Wir erlauben mehrere nacheinanderfolgende Anweisungen in einem Kästchen zunotieren, wenn es der kompakten Übersicht dienlich ist.




Erstellen eines Javaprogramms in Pseudocode

75

Wir können mal an dieser Stelle die Erstellung eines Javaprogramms mit Hilfe vonPseudocode ausdrücken:

1 öffne einen Texteditor

2 lege ein Dokument mit gewünschtem Programmnamen an

3 schreibe ein Javaprogramm

4 speichere es mit der Endung ".java" in Ordner <X>

5 gehe außerhalb des Editors in einer Konsole zu Ort <X>

6 schreibe "javac <Programmname>.java"

7 -> wenn der Javacompiler Fehler ausgibt gehe zu 8 sonst 11

8 gehe zurück zum Editor

9 korrigiere angezeigte Fehler

10 gehe zu 4

11 schreibe "java <Programmname>"

12 -> wenn das Programm noch nicht das Gewünschte tut gehe zu 8

13 FERTIG

Auch das können wir wieder als Aktivitätsdiagramm darstellen:




Erstellen eines Javaprogramms

76

Wir können Javaprogramme mit folgender Syntax in der Konsole kompilieren:

javac <Programmname>.java

und anschließend so ausführen:

java <Programmname>

Versuchen wir an dieser Stelle einmal die folgenden Programmzeilen entsprechendden Anweisungen des Pseudocodes einzugeben und das Programm zu starten.

public class TestProgramm {

public static void main(String[] args) {

System.out.println("Das habe ich ganz allein geschafft!");

}

}

C:\Java>javac TestProgramm.java

C:\Java>java TestProgramm

Das habe ich ganz allein geschafft!

Wenn wir alles richtig gemacht haben, wird eine Textzeile in der Konsole ausge-geben:




Editor und Konsole

77

Kompilieren und Ausführen von Programmen:

Java-Programmein der Konsoleausführen

Java-Programmein einem Editorerstellen




Programmieren mit einem einfachen Klassenkonzept

78

public class MeinErstesProgramm {


// HIER KOMMEN DIE ANWEISUNGEN DES PROGRAMMS HIN

}

}

Das folgende Programm tut erstmal herzlich wenig, soll aber zeigen, welche Zeilenwir für alle folgenden Beispiele benötigen:

Das Einrücken der Zeilen innerhalb eines Blocks (so wird der Abschnitt zwischen{ und } genannt) dient der Lesbarkeit.




Programme kommentieren

79

Wir müssen immer darauf achten, unsere Programme nicht nur ausreichend,sondern verständlich zu kommentieren. Es ist nicht immer einfach, ein langesProgramm ohne hilfreiche Kommentare zu verstehen. Dies trifft sogar auf selbstgeschriebene Programme zu, erst recht auf die von anderen.

Daher sind gerade in Projekten, bei denen mehrere Programmiererzusammenarbeiten, Kommentare unverzichtbar.

Es gibt zwei Möglichkeiten in Java Kommentare zu schreiben:

// Ich bin ein hilfreicher Kommentar in einer Zeile

/* Falls ich einen Kommentar über mehrere Zeilen

hinweg schreiben möchte, so verwende ich ein

öffnendes und schließendes Kommentarsymbol

*/

public class Kommentierung { // ich kann auch hier stehen


/* An diese Stelle schreiben wir die

Programmanweisungen */

}

}




Programme kommentieren – Variante I

80

Je besser das Programm geschrieben ist, desto weniger Kommentare sind

notwendig.

public static boolean funktion(String s) {

int i = s.toCharArray().length/2;

for (char c:s.toCharArray()) {

if (s.toCharArray()[i] != s.toCharArray()[s.toCharArray().length-i-1])

return false;

i--;

if (i==0) break;

}

return true;

}

System.out.println(args[0]+" ist "+(funktion(args[0])?"":"k")+"ein Palindrom");




Programme kommentieren – Variante II

81

public static boolean istPalindrom(String text) {

char[] zeichen = text.toCharArray();

int textMitte = text.length()/2;

boolean istPalindrom = true;

for (int i=0; i<textMitte; i++) {

char zeichenVorn = zeichen[i];

char zeichenHinten = zeichen[zeichen.length-i-1];

if (zeichenVorn != zeichenHinten) {

istPalindrom = false;

break;

}

}

return istPalindrom;

}

String programmEingabe = args[0];

if (istPalindrom(programmEingabe))

System.out.println(programmEingabe+" ist ein Palindrom");

else

System.out.println(programmEingabe+" ist kein Palindrom");




Einrücken von Anweisungsblöcken

82

public static int zaehleUmgebung(boolean[][] m, int x, int y){

int ret = 0;

for (int i=(x-1);i<(x+2);++i){

for (int j=(y-1);j<(y+2);++j){

try {if (m[i][j]) ret += 1;}catch (IndexOutOfBoundsException e){}

}

}// einen zuviel mitgezaehlt?

if (m[x][y])ret -= 1;

return ret;

}

public static int zaehleUmgebung(boolean[][] m, int x, int y) {

int ret = 0;

for (int i=(x-1); i<(x+2); ++i) {

for (int j=(y-1); j<(y+2); ++j) {

try {

if (m[i][j])

ret += 1;

} catch (IndexOutOfBoundsException e) {}

}

}

// einen zuviel mitgezaehlt?

if (m[x][y])

ret -= 1;

return ret;

}

Kommentare und Syntaxhighlighting reichen nicht!




Sequentielle Anweisungen

83

public class Sequentiell {


int a=5; // Anweisung 1

a=a*2; // Anweisung 2

a=a+10; // Anweisung 3

a=a-5; // Anweisung 4

}

}

Wir haben bereits gesehen, dass Anweisungen mit ; abgeschlossen werden:

Welchen Wert hat a?

Wir können das überprüfen: Geben wir dazu am Ende noch folgende Zeile dazu:

System.out.println("a hat den Wert: "+a);




Verzweigungen mit if I

85

Die Syntax für eine Verzweigung kann auf verschiedene Weisen formuliert werden.

Wenn eine Bedingung erfüllt ist, führe eine einzelne Anweisung aus. Die Syntaxdafür sieht wie folgt aus:

if (<Bedingung>)

<Anweisung>;

Ein Beispiel:

if (a<b)

a=b;

Welchen Wert repräsentiert a?

Es können auch mehrere Anweisungen (ein Anweisungsblock) ausgeführt werden:

if (<Bedingung>) {

<Anweisung1>;

<Anweisung2>;

...

}




Verzweigungen mit if II

86

Eine Erweiterung dazu ist die if-else-Verzweigung:

if (<Bedingung>)

<Anweisung1>;

else

<Anweisung2>;

Ein Beispiel:

if (a<b)

c=b;

else

c=a;

Wir können auch Bedingungen verknüpfen:

if (<Bedingung1>)

<Anweisung1>;

else if (<Bedingung2>)

<Anweisung2>;




Guter Programmierstil

87

Da bei einer Bedingung immer ein Ausdruck steht, der entweder true oder false ist,können wir den folgenden Abschnitt:

ersetzen durch:

if (a == true)

// tue etwas

if (a)

// ist a true, tue etwas

if (!a)

// ist a false, tue etwas

Der Grund ist einleuchtend, da bei jedem Wert von a der Ausdruck a==(a==true)erfüllt ist.

Wird a auf false getestet, machen wir das entsprechend so:




Verzweigung mit switch I

88

Um nun Mehrfachverzweigungen zu realisieren und nicht zu einer unübersichtlichenFlut von if-Verzweigungen greifen zu müssen, steht uns switch zur Verfügung:

switch (<Ausdruck>) {

case <Konstante1>:

<Anweisung1>;

[break;]

case <Konstante2>:

<Anweisung2>;

[break;]

[default:]

<Anweisung3>;

}

Leider gibt es für die Verwendung ein paar Einschränkungen, so können wir nurBedingungen überprüfen in der Form: Hat int a den Inhalt 4?

Als Ausdruck lassen sich verschiedene primitive Datentypen auf Ihren Inhaltuntersuchen. Zu den erlaubten gehören:

char, byte, short, int und (seit Java 7 auch) String.




Verzweigung mit switch II

89

Hier ein kleines Beispiel zu switch:

int i = 0; // hier mal unterschiedliche i probieren

switch(i){

case 0:

System.out.println("0");

break;

case 1:


case 2:

System.out.println("1 oder 2");

break;

case 3:


break;

default:

System.out.println("hier landen alle anderen...");

}

C:\Java>java Verzweigung

0

1

1 oder 2

1 oder 2

3

hier landen alle anderen...

Wenn wir die switch-Verzweigung beispielsweise mit den Zahlen i=0,1,2,3,4nacheinander durchlaufen würden, erhielten wir die folgende Ausgabe:




Verzweigung mit switch III

90

Variante mit Zeichenketten:

String code = "007";

switch(code) {

case "006":

System.out.println("Nigel Boswell");

break;

case "007":

System.out.println("James Bond");

break;

default:

System.out.println("kein berühmter Spion");

}




Motivation zu Schleifen

91

Folgendes Programm ist gegeben, das eine Zahl quadriert und das Ergebnisausgibt:

System.out.println("1 zum Quadrat ist "+(1*1));






Es wäre sicherlich auch eine unangenehme Aufgabe, alle ganzen Zahlen zwischen 1und 1000 auf diese Weise quadrieren und ausgeben zu lassen. Daher ist dasSchleifen-Konzept ziemlich nützlich.

Beginne mit i=1

Gib den Wert i*i aus

Falls i<=1000

-> Erhöhe i um 1 und springe zu Zeile 2

Angenommen, wir möchten die Aufgabe lösen, alle Quadrate der Zahlen zwischen1 und 1000 auszugeben. Dann könnten wir das in Pseudocode in etwa soausdrücken:

Oder in Worten ausgedrückt: Starte mit i=1 und solange i<=1000 erfüllt ist,mache folgendes: gib das Quadrat von i aus und erhöhe anschließend i um 1.




Schleife mit for

92

Wir benötigen zunächst eine Variable, die zu Beginn mit einem Startwertinitialisiert wird. Die Schleife führt den nachfolgenden Anweisungsblock solangeaus, erhöht oder verringert dabei die Variable um einen Wert, bis die angegebeneBedingung nicht mehr erfüllt ist:

for (<Initialisierungen>; <Bedingungen>; <Aktualisierungen>) {

<Anweisung>;

}

Im Programm könnten wir die zu Beginn geschilderte Aufgabe, alle Quadratzahlenfür die Werte 1 bis 1000 auszugeben, mit einer for-Schleife so lösen:

Mit int i=1 geben wir einen Startwert vor. Die Schleife führt die Anweisungeninnerhalb der geschweiften Klammern solange aus und erhöht jedes Mal i um 1 bisdie Bedingung i<=1000 nicht mehr erfüllt ist.

for (int i=1; i<=1000; i=i+1)

System.out.println(i+" zum Quadrat ist "+(i*i));




Beispiele zur for-Schleife I

93

Wir können aber auch andere Konstruktionen mit einer for-Schleife realisieren.

Beispielsweise könnten wir bei 0 anfangen, in Fünferschritten weiterlaufen und alleWerte bis einschließlich 25 erzeugen:

for (int i=0; i<=25; i=i+5)

System.out.println("Aktueller Wert für i ist "+i);

Umsetzung in Java:




Beispiele zur for-Schleife II

94

Eine Schleife muss Variablen nicht immer vergrößern, wir können auch bei 4beginnend immer 3 abziehen, bis wir bei -11 angelangt sind:

for (int i=4; i>=-11; i=i-3)

System.out.println("Aktueller Wert für i ist "+i);

Umsetzung in Java:




Beispiele zur for-Schleife III

95

Im folgenden Beispiel wollen wir mit einer Schleife die Summe der Zahlen

berechnen:

int summe=0;

for (int i=1; i<=n; i++)

summe += i;

Da bei der Definition einer for-Schleife, die drei Teile <Initialisierung>,<Bedingung> und <Aktualisierung> nicht nur optional sind, sondern sogarmehrfach eingesetzt werden dürfen, können wir die Summe sogar ganz ohneAnweisungsteil berechnen:

Soviel an dieser Stelle: Neben der for-Schleife gibt es noch mehr Schleifen-varianten. Jede hat auf Grund der Programmästhetik ihre Existenzberechtigung,obwohl leicht zu zeigen ist, dass wir mit einer Variante immer auskommenkönnten.

int summe=0;

for (int i=1; i<=n; summe+=i, i++);




Schleife mit while

96

Manchmal ist es nicht klar, wie viele Schleifendurchläufe benötigt werden, um einErgebnis zu erhalten. Da wäre es schön, eine Möglichkeit zu haben, wie diese:Wiederhole die Anweisungen solange, eine Bedingung erfüllt ist.

Genau diesen Schleifentyp repräsentiert die while-Schleife. Hier die zugehörigeSyntax:

while (<Bedingung>) {

<Anweisung>;

}

Wir werden das Beispiel aus der for-Schleife wieder aufnehmen und sehen, wie dasmit while gelöst werden kann:

int i=1;

while (i<=1000){


i=i+1;

}

Wie könnten wir die

Quadrate von 1 bis 1000

mit while lösen?




Schleife mit while - Gefahr Endlosschleife

97

Die Schleife wird einfach solange ausgeführt, bis die Bedingung hinter while nichtmehr erfüllt ist.

Hier ist natürlich auch die Gefahr gegeben, dass die Schleife endlos laufen kann,wie in diesem Beispiel zu sehen ist:

int i=1;

while (i<=1000){


}

Warum ergibt daseine Endlosschleife?




Schleife mit do-while I

98

Die do-while-Schleife führt im Gegensatz zur while-Schleife zuerst den Anwei-sungsblock einmal aus und prüft anschließend die Bedingung:

do {

<Anweisung>;

} while (<Bedingung>);

Damit haben wir im Gegensatz zur while-Schleife, die kopfgesteuert ist, einefußgesteuerte Schleife.

Schauen wir uns dazu mal folgendes Beispiel an:

Wir erhalten folgende Ausgabe:

int i=0;

do {

i++;

System.out.println("Wert von i: "+i);

} while (i<5);

C:\Java>java Schleifen

Wert von i: 1

Wert von i: 2

Wert von i: 3

Wert von i: 4

Wert von i: 5




Schleife mit do-while II

99

Wenn wir die Bedingung so ändern, dass sie von vornherein nicht erfüllt ist:

geschieht trotzdem das Folgende:

Das war auch zu erwarten, da die Überprüfung der Bedingung erst nach der erstenAusführung stattfindet und deshalb der Schleifeninhalt mindestens einmalausgeführt wird.

int i=0;

do {

i++;

System.out.println("Wert von i: "+i);

} while (i<0);

C:\Java>java Schleifen

Wert von i: 1




Sprunganweisungen

100

Es gibt Situationen in denen es notwendig ist, eine Schleife vorzeitig zu beenden.Dazu werden wir uns den Datentyp char noch einmal etwas genauer anschauen.

1) http://www.unicode.org/

Nehmen wir als Ausgangsbeispiel den folgenden Programmabschnitt:

Es werden die ersten sichtbaren Zeichen der ASCII-Tabelle ausgegeben. Mit \t wirdein Tabulatorschritt bei der Ausgabe eingefügt und alle acht Symbole einZeilenumbruch vorgenommen, um die Tabelle übersichtlich zu halten.

for (int i = 33; i < 127; i++) {

char symbol = (char)i;

System.out.print(i+": "+symbol+"\t");

if ((i%8) == 0)

System.out.println();

}

Java verwendet für den char den sogenannten Unicode-Zeichensatz1) der zweiBytes benötigt und damit umfangreicher ist, als der bekannte ASCII-Zeichensatz(American Standard Code for Information Interchange). Er soll einen universellenZeichensatz für die Darstellung unterschiedlicher Sprachen sein. Die ersten 128Zeichen entsprechen dabei dem ASCII-Zeichsatz.




ASCII-Tabelle

101

33: ! 34: " 35: # 36: $ 37: % 38: & 39: ' 40: (

41: ) 42: * 43: + 44: , 45: - 46: . 47: / 48: 0

49: 1 50: 2 51: 3 52: 4 53: 5 54: 6 55: 7 56: 8

57: 9 58: : 59: ; 60: < 61: = 62: > 63: ? 64: @

65: A 66: B 67: C 68: D 69: E 70: F 71: G 72: H

73: I 74: J 75: K 76: L 77: M 78: N 79: O 80: P

81: Q 82: R 83: S 84: T 85: U 86: V 87: W 88: X

89: Y 90: Z 91: [ 92: \ 93: ] 94: ^ 95: _ 96: `

97: a 98: b 99: c 100: d 101: e 102: f 103: g 104: h

105: i 106: j 107: k 108: l 109: m 110: n 111: o 112: p

113: q 114: r 115: s 116: t 117: u 118: v 119: w 120: x

121: y 122: z 123: { 124: | 125: } 126: ~

Wir erhalten auf der Konsole die folgende Ausgabe:

33: ! 34: " 35: # 36: $ 37: % 38: & 39: ' 40: (

41: ) 42: * 43: + 44: , 45: - 46: . 47: / 48: 0

49: 1 50: 2 51: 3 52: 4 53: 5 54: 6 55: 7 56: 8

57: 9 58: : 59: ; 60: < 61: = 62: > 63: ? 64: @

65: A 66: B 67: C 68: D 69: E 70: F 71: G 72: H

73: I 74: J 75: K 76: L 77: M 78: N 79: O 80: P

81: Q 82: R 83: S 84: T 85: U 86: V 87: W 88: X

89: Y 90: Z 91: [ 92: \ 93: ] 94: ^ 95: _ 96: `

97: a 98: b 99: c 100: d 101: e 102: f 103: g 104: h

105: i 106: j 107: k 108: l 109: m 110: n 111: o 112: p

113: q 114: r 115: s 116: t 117: u 118: v 119: w 120: x

121: y 122: z 123: { 124: | 125: } 126: ~

33: ! 34: " 35: # 36: $ 37: % 38: & 39: ' 40: (

41: ) 42: * 43: + 44: , 45: - 46: . 47: / 48: 0

49: 1 50: 2 51: 3 52: 4 53: 5 54: 6 55: 7 56: 8

57: 9 58: : 59: ; 60: < 61: = 62: > 63: ? 64: @

65: A 66: B 67: C 68: D 69: E 70: F 71: G 72: H

73: I 74: J 75: K 76: L 77: M 78: N 79: O 80: P

81: Q 82: R 83: S 84: T 85: U 86: V 87: W 88: X

89: Y 90: Z 91: [ 92: \ 93: ] 94: ^ 95: _ 96: `

97: a 98: b 99: c 100: d 101: e 102: f 103: g 104: h

105: i 106: j 107: k 108: l 109: m 110: n 111: o 112: p

113: q 114: r 115: s 116: t 117: u 118: v 119: w 120: x

121: y 122: z 123: { 124: | 125: } 126: ~

boolean a = 'a' < 'b';

boolean b = 'a' < 'A';

Demzufolge sollten die folgenden Relationen zu welchem Ergebnis führen?




Sprunganweisungen

102

Angenommen, wir suchen ein bestimmtes Symbol in der Tabelle und wollen diePosition ausgeben. Anschließend soll die Schleife beendet werden.

Das Beenden kann beispielsweise dadurch erzwungen werden, indem dieZählvariable einer for-Schleife innerhalb der Schleife auf einen Wert gesetzt wird,der die Bedingung zum Weiterlaufen nicht mehr erfüllt.

for (int i = 33; i < 127; i++) {


if (symbol == 'A'){

System.out.println("Symbol "+symbol+" an Position "+i+" gefunden.");

i=127; // schlechter Programmierstil

} else

System.out.println("bisher nichts passendes gefunden ...");

}

Schauen wir uns das Beispiel dazu an:

Das ist allerdings sehr unschön und bei komplizierteren Ausdrücken für Leserschlecht nachzuvollziehen, wann die Schleife verlassen wird.

Aus diesem Grund gibt es Sprunganweisungen!




Sprung mit break

103

Der Sprungbefehl break schließt nicht nur die case-Fälle bei switch, sondernbeendet auch unmittelbar while-, do-while- und for-Schleifen:

Die for-Schleife wird abgebrochen, wenn das Symbol 'A' identifziert worden ist.Anschließend wird mit den Anweisungen, die nach der Schleife kommen fortge-fahren.

for (int i = 33; i < 127; i++) {


if (symbol == 'A'){


break;

}

System.out.println("bisher nichts passendes gefunden ...");

}




Ergänzung zur for-Schleife I

104

An dieser Stelle wollen wir nochmal kurz auf die Konstruktion einer for-Schleifeeingehen. Wir hatten ja angedeutet, dass es auch möglich ist, eine Schleife mitleerem Definitions- und Manipulationsbereich zu definieren:

for (;;) {

// Endlosschleife

}

for (;;) {

// tue etwas

bedingung = prüfen();

if (bedingung)

break;

}

Es gibt keine Bedingung, die unsere Schleife zum Abbruch führen kann. DieseSchleife könnte beispielsweise in den Stellen Anwendung finden, in denen solangeetwas auszuführen ist, bis ein bestimmtes Ereignis auftritt.

Dann kann die Schleife mit break beendet werden:

Wenn die Funktion prüfen ein true liefert, wird die Schleife durch break beendet.




Ergänzung zur for-Schleife II

105

Besser ist es, in diesem Fall eine while-Schleife zu verwenden und die Schleifeabzubrechen, wenn die Bedingung zum Abbrechen erfüllt ist:

Dazu müssen wir die Bedingung zu Beginn auf false setzen und bei while negiertüberprüfen.

bedingung = false;

while (!bedingung) {

// tue etwas

bedingung = prüfen();

}




Sprung mit continue

106

Kommen wir zu unserem Ursprungsbeispiel mit der Suche in der ASCII-Tabelle ausdem vorhergehenden Abschnitt zurück.

Jetzt wollen wir alle Großbuchstaben identifizieren und deren Positionen ausgeben:

for (int i = 33; i < 127; i++) {


if ((symbol>='A') && (symbol<='Z'))


else

System.out.println("nichts passendes gefunden...");

}

for (int i = 33; i < 127; i++) {


if ((symbol>='A') && (symbol<='Z')){


continue;

}

System.out.println("nichts passendes gefunden...");

}

Für solche Fälle, in denen wir bei erfolgreicher Suche mit der Schleifeweitermachen wollen, können wir das Schlüsselwort continue statt dem if-else-Konstrukt verwenden:




Sprungmarken I

107

Bei verschachtelten Schleifen wird immer die aktuelle innere Schleife beendet. Umaber explizit anzugeben, zu welcher Schleife gesprungen werden soll, lassen sichMarken unterbringen (markierte Anweisungen).

Diese Marken werden mit folgender Syntax angegeben:

<Marke>:

Wenn hinter break oder continue eine Marke steht, dann springt das Programm zu der Marke und beendet die Schleife:

continue <Marke>;




Sprungmarken II

108

Die Idee besteht darin, Schleifen gezielt beenden zu können oder entsprechendweiterlaufen zu lassen.

Angenommen, wir haben zwei verschachtelte for-Schleifen, die uns die Paare vonGroß- und Kleinbuchstaben finden sollen:

Aussen:

for (int i = 33; i < 127; i++) {

for (int j = 33; j < 127; j++) {

char symbol1 = (char)i;

char symbol2 = (char)j;

if (Character.isUpperCase(symbol1) &&

(symbol2 == Character.toLowerCase(symbol1))){

System.out.println("Symbol "+symbol1+" ["+

i+"] und Symbol "+symbol2+" ["+

j+"] sind ein Paar.");

continue Aussen;

}

}

}

Symbol A [65] und Symbol a [97] sind ein Paar.

Symbol B [66] und Symbol b [98] sind ein Paar.

...

Symbol Z [90] und Symbol z [122] sind ein Paar.

Wir erhalten:




Ausgelagerte Programmabschnitte in Java

109

Programme bestehen aus Ketten von Anweisungen, das wissen wir bereits. Oftkommt es dabei vor, dass sich Folgen von Anweisungen wiederholen.

Eine Sequenz von Anweisungen, bei der sich B und C wiederholen.

Wir erstellen eine neue Anweisung mit dem Namen BC, die B und C nacheinanderausführt. Die neue Anweisung BC wird entsprechend eingesetzt:

In diesen Fällen können wir das Programm übersichtlicher gestalten, indem wirdiese Anweisungsblöcke zu einer neuen Anweisung, deren Bezeichnung wir fast freiwählen können, zusammenfassen.

Der große Vorteil besteht darin, dass wir den Anweisungsblock nur noch einmalschreiben müssen. Das vermindert die Fehleranfälligkeit.




Motivation zu Funktionen

110

public class Ausgabe{

public static void main(String[] args){

int a=4;


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

System.out.println("*** Wert der Variable ist "+a);



a=(a*13)%12;






a+=1000;






}

}




Funktionen in Java

111

Funktionen repräsentieren einen Programmabschnitt, der einmal formuliert beliebigoft aufgerufen und verwendet werden kann. Eine Funktion erhält dabei eineneindeutigen Namen (beginnend mit einem Kleinbuchstaben).

Parameterinhalte können an eine Funktion übergeben werden. Diese geltenzunächst nur innerhalb der Methode (daher werden sie auch lokale Variablengenannt) auch wenn in der main-Methode eine Variable mit dem gleichen Namenexistiert, haben diese beiden nichts miteinander zu tun.

Die Syntax unserer Funktionen sieht zunächst erstmal so aus:

public static <Datentyp> <Funktionsname>(

<Datentyp> Parameter1,

<Datentyp> Parameter2,

...) {

// Funktionskörper

}

Aus der Mathematik wissen wir, dass Funktionen auch ein Ergebnis liefern - genauein Ergebnis. Auch für unsere Funktionen gilt das. Falls, wie in unserem Fall, keinRückgabewert existiert, schreiben wir als Rückgabewert das Schlüsselwort void.




Ausgabe in Funktion auslagern

112

Jetzt wollen wir versuchen, mit Hilfe einer Funktion, die Ausgabe ein wenig zuerleichtern. In unserem Ausgabebeispiel ist a ein Eingabeparameter für die neueFunktion.

Die Funktion schreiben wir laut Konvention oberhalb der main-Funktion. Für dieLesbarkeit des Programms sind sprechende Namen, in unserem Beispiel gibAus,unerlässlich:

public class AusgabeFunktion{

public static void gibAus(int a){ // neue Funktion






}

// main-Funktion


int a=4;

gibAus(a);

a=(a*13)%12;

gibAus(a);

a+=1000;

gibAus(a);

}

}




Funktionen mit Rückgabewert

113

Schauen wir uns noch ein weiteres Beispiel an. Dazu berechnen wir in einerFunktion für die Eingabe x den Wert f(x)=x*13-1024%(34+12):

In diesem Beispiel gibt die Funktion einen int-Wert mit der Anweisung returnzurück und wird beendet. Sollten noch Zeilen nach einem return stehen, so gibtJava einen Fehler aus, denn diese Zeilen können nie ausgeführt werden.

public class Funktion{

public static int funktion(int x){

int wert=(x*13)-1024%(34+12);

return wert;

}


for (int i=0; i<10; i++)

System.out.println("x="+i+" und f(x)="+funktion(i));

}

}

C:\Java>java Funktion

x=0 und f(x)=-12

x=1 und f(x)=1

x=2 und f(x)=14

x=3 und f(x)=27

...

x=9 und f(x)=105

Als Ausgabe erhalten wir:




Wichtiges Konzept

114

Die Auslagerung von Programmabschnitten in Funktionen ist eines der wichtigstenProgrammierkonzepte.

Aus Gründen der Übersichtlichkeit und besseren Fehlersuche werden wir diesesKonzept so oft es geht einsetzen ...




Was war da gestern eigentlich los?

116

Grundlegende Prinzipien der...

Documents

Transcript of Grundlegende Prinzipien der...