Programmierkurs Java Vorlesung 3 Dietrich Boles Seite 1 Programmierkurs Java Vorlesung am FB Informatik der Universität Oldenburg Vorlesung 3 Dietrich

Programmierkurs Java Vorlesung 3 Dietrich Boles Seite 1

Programmierkurs Java

Vorlesung

am FB Informatik

der Universität Oldenburg

Vorlesung 3

Dietrich Boles


Gliederung von Vorlesung 3

Das Hamster-Modell

– Motivation

– Grundlagen

– Anweisungen und Programme

– Prozeduren

– Auswahlanweisungen

– Wiederholungsanweisungen

– Boolesche Funktionen

– Programmentwurf


Hamster-Modell / Motivation

• Spielerisches Erlernen wichtiger Programmierkonzepte

• Steuerung eines virtuellen Hamsters durch eine virtuelle Landschaft

• Erlernen imperativer Sprachkonstrukte

• inkrementelle Erweiterung des „Sprachschatzes“

• Syntax: an Java angelehnt

• Vorbilder: LOGO, Karel the Robot

• „Learning-by-Doing“

• Viele Übungsaufgaben


Hamster-Modell / Grundlagen

############

# # # # # # # # # # # ############# # # # # # # # # # #

#

# # # #

##

###

###

##

#o

o

o

o o o

oo oo o

oo o

o o oo o o

oo

>Symbol Bedeutung

> Hamster (Blickrichtung Ost)

v Hamster (Blickrichtung Süd)

< Hamster (Blickrichtung West)

^ Hamster (Blickrichtung Nord)

# blockierte Kachel

o Kachel mit Körnern



Hamsteraufgaben:Gegeben sei die folgende Landschaft. Der Hamster soll zwei beliebige Körner fressen.

Landschaft:

Lösung:ein Hamsterprogramm

#

#

# # # # # # # # # # #

# # # # # # # # # # #

# # # # # # # #

# # # # # # # #

######

######

v#

o

oo o

#

##

# # # # ##

## # # # #

####



• Lexikalik: 16-Bit-Zeichensatz Unicode

• Trennung von Token durch Trennzeichen (Leerzeichen, Tabulatoren, Zeilenvorschubzeichen, Seitenvorschubzeichen)

• Bezeichner:– Beginn mit Unterstrich („_“) oder Dollar („$“) oder Buchstaben

– weitere Buchstaben, Unterstriche oder Ziffern

– beliebig lang

– Unterscheidung von Groß- und Kleinbuchstaben

• Schlüsselwörter:abstractbooleanbreakbytecasecatchcharclassconstcontinuedefaultdo

doubleelseextendsfinalfinallyfloatforgotoifimplementsimportinstanceof

intinterfacelongnativenewnullpackageprivateprotectedpublicreturnshort

staticsuperswitchsynchronizedthisthrowthrowstransienttryvoidvolatilewhile


Hamster-Modell / Anweisungen / Befehle

vier Grundbefehle:

vor(); ein Feld nach vorne springen

linksUm(); 90 Grad nach links schauen

nimm(); ein Korn von der aktuellen Kachel aufnehmen

gib(); ein Korn aus dem Maul auf der aktuellen Kachel ablegen

)vor

linksUm

nimm

gib

Grundbefehl( ;


Hamster-Modell / Anweisungen / Befehle

Laufzeitfehler:

vor(); ... und Feld vor dem Hamster ist blockiert

nimm(); ... und kein Korn auf der aktuellen Kachel vorhanden

gib(); ... und kein Korn im Maul des Hamsters

######

# # # # # # # # # # # ####### # # # # # # # # # #

<#

#

##ooo

ooo

ooo

#

######

# # # # # # # # # # # ####### # # # # # # # # # #

<#

#

##ooo

ooooo

#

>

######

# # # # # # # # # # # ####### # # # # # # # # # #

##

##ooo

ooo

ooo

#>

######

# # # # # # # # # # # ####### # # # # # # # # # #

##

##ooo

ooo

ooo

#

vor Befehl vor(); nach Befehl vor();

vor Befehl vor(); nach Befehl vor(); Laufzeitfehler!


Hamster-Modell / Anweisungen / Programm

Anweisung (1)

Anweisung

Grundbefehl

Anweisungssequenz

Programm (1)

)void main (Anweisungs-

sequenz{ }


Hamster-Modell / Anweisungen / Kommentare

Kommentar

BereichskommentarZeichen/* */

Zeilenkommentar

Zeilenkommentar

Bereichskommentar

ZeilenendezeichenZeichen//


Hamster-Modell / Anweisungen / Beispiel

Aufgabe: Landschaft:Gegeben sei das folgende

Hamster-Territorium.

Der Hamster soll zwei Körner

einsammeln.

Programm:

#

#

# # # # # # # # # # #

# # # # # # # # # # #

# # # # # # # #

# # # # # # # #

######

######

v #o

ooo

#

##

# # # # ##

## # # # #

####

# # # # ## # # o o o o o

o o

##

void main(){ // nehme erstes Korn vor(); vor(); nimm();

/* nehme zweites Korn */ linksUm(); vor(); vor(); nimm();}


Hamster-Modell / Anweisungen / BeispielAufgabe: Landschaft:

Gegeben sei das folgende Territorium.

Der Hamster habe vier Körner im Maul.

Er soll in jeder Ecke eins ablegen und

in seine Ausgangssituation zurückkehren.

Programm:

void main() { // begib dich an den Rand vor(); linksUm(); // laufe in die rechte untere Ecke vor(); vor(); vor(); vor(); gib(); linksUm(); // laufe in die rechte obere Ecke vor(); vor(); vor(); gib(); linksUm(); // laufe in die linke obere Ecke vor(); vor(); vor(); vor(); vor(); gib(); linksUm(); // laufe in die linke untere Ecke vor(); vor(); vor(); gib(); linksUm(); // begib dich in die Ausgangsposition zurück vor(); linksUm(); vor(); linksUm(); linksUm();}

#

#

# # # # # # #

# # # # # # #

####

####

vo o

###

#

#

# # # # # # #

# # # # # # #

####

####

o o###

o

o o

o

v

vorher nachher


Hamster-Modell / Prozeduren / Motivation

Motivation:


einsammeln.

void main() { vor(); vor(); nimm(); linksUm(); linksUm(); linksUm(); vor(); vor(); linksUm(); linksUm(); linksUm(); vor(); vor(); nimm();}

#

# # # # # # # # # # #

# # # # # # # # # # #

# # # # # # #

# # # # # # # #

########

########

#o

o

o o#

##

##

## # #

#####

>

# # # # #

o o o

oo

oo

oo

oo

oo

oooo

###

###

rechtsUm();

rechtsUm();


Hamster-Modell / Prozeduren / Definition

Prozedurdefinition

ProzedurnameBezeichner

ProzedurkopfProzedurname (

Prozedurkopf

Prozedurrumpf Anweisungs-sequenz

{ }

Prozedurrumpf

)void

Prozedurdefinition: Vereinbarung eines neuen Befehls


Hamster-Modell / Prozeduren / Aufruf

Grundbefehl

Prozeduraufruf( ) ;

Anweisung (2)

Prozeduraufruf

Prozedurname

Prozeduraufruf: Aufruf eines selbstdefinierten Befehls


Hamster-Modell / Prozeduren / Programme

Programm (mit Prozeduren):

DefinitionenMainfunktionDefinitionen

Prozedur-definition

Programm (2)

Definitionen (1)

)void main Prozedurrumpf(Mainfunktion


Hamster-Modell / Prozeduren / Beispiel

Lösung des Motivationsproblems:


einsammeln.

void main() { vor(); vor(); nimm(); rechtsUm(); vor(); vor(); rechtsUm(); vor(); vor(); nimm();}

#

# # # # # # # # # # #

# # # # # # # # # # #

# # # # # # #

# # # # # # # #

########

########

#o

o

o o#

##

##

## # #

#####

>

# # # # #

o o o

oo

oo

oo

oo

oo

oooo

###

###

void rechtsUm() { kehrt(); linksUm();}

void kehrt() { linksUm(); linksUm();}


Hamster-Modell / Prozeduren / Vorteile

Vorteile von Prozeduren:

– bessere Übersichtlichkeit von Programmen

– separate Lösung von Teilproblemen

– Platzeinsparung

– einfachere Fehlerbeseitigung

– Flexibilität

– Wiederverwendbarkeit


Hamster-Modell / Prozeduren / BeispielAufgabe: Landschaft:


Der Hamster soll den Berg erklimmen.

Programm:

void main() { laufeZumBerg(); erklimmeErsteStufe(); erklimmeZweiteStufe(); erklimmeDritteStufe(); erklimmeGipfel();}

void laufeZumBerg() { vor();}

void erklimmeErsteStufe() { erklimmeStufe();}

void erklimmeZweiteStufe() { erklimmeStufe();}void erklimmeDritteStufe() { erklimmeStufe();}void erklimmeGipfel() { erklimmeStufe();}void erklimmeStufe() { linksUm(); vor(); linksUm();linksUm();linksUm(); vor();}

########

# # # # # # # # # # # ######### # # # # # # # # # #

> # # # # # # ## # # # ## # ##


Hamster-Modell / Auswahl / Test-Befehle

drei Test-Befehle:

vornFrei() ist das Feld vor dem Hamster blockiert?

maulLeer() ist das Maul des Hamsters leer?

kornDa() liegt ein Korn auf der aktuellen Kachel?

)Testbefehl

(vornFrei

maulLeer

kornDa


Hamster-Modell / Auswahl / Boolesche Ausdrücke

( )

booleschesLiteral

boolescher Ausdruck

!

&&

||

boolescher Ausdruck

boolescher Ausdruck

boolescher Ausdruck

boolescher Ausdruck

boolescher Ausdruck

Testbefehl

false

true

boolesches Literal

boolescher Ausdruck


Hamster-Modell / Auswahl / Blockanweisung

Anweisung (3)

Anweisungs-sequenz

{ }Blockanweisung

Grundbefehl

Prozeduraufruf

Blockanweisung


Hamster-Modell / Auswahl / Leeranweisung

;Leer anweisung

Anweisung (4)Grundbefehl

Prozeduraufruf

Blockanweisung

Leeranweisung


Hamster-Modell / Auswahl / bedingte Anweisung

( )

bedingte Anweisung

Auswahlanweisung (1)

boolescher Ausdruck

Anweisungbedingte Anweisung

Anweisung (5)Grundbefehl

Prozeduraufruf

Blockanweisung

Leeranweisung

Auswahl-anweisung

if


Hamster-Modell / Auswahl / bedingte Anweisung

Beispiele:

void sicheresVor() { if (vornFrei()) { vor(); }}

void sicheresGib() { if (!maulLeer()) { gib(); }}

void sicheresNimm() { if (kornDa()) nimm();}

if (kornDa() && vornFrei()){ nimm(); vor();}

if (kornDa()) if (vornFrei()) { nimm(); vor(); }

if (kornDa()) nimm(); vor();


Hamster-Modell / Auswahl / Alternativanweisung

Alternativanweisung

bedingte AweisungAuswahlanweisung (2)

else Anweisungbedingte AweisungAlternativanweisung

if (vornFrei()) { vor();} else { linksUm();}

if (maulLeer()) ;else gib();linksUm();

if (vornFrei()) vor();else if (kornDa()) nimm();else if (!maulLeer()) gib();else linksUm();


Hamster-Modell / Auswahl / BeispielAufgabe: Landschaft:


Solange möglich soll der Hamster

in jeder Ecke ein Korn ablegen.

Programm:

void main() { if (!maulLeer()) { gib(); if (!maulLeer()) { laufeInNaechsteEcke(); gib(); if (!maulLeer()) { laufeInNaechsteEcke(); gib(); if (!maulLeer()) { laufeInNaechsteEcke(); gib();} } } } }

# # # # # # #

# # # # # #

#####

######>

void laufeInNaechsteEcke() { vor(); vor(); vor(); vor(); linksUm();}


Hamster-Modell / Wiederholung / Motivation

Motivation: Der Hamster soll bis zur nächsten Wand laufen.

void main() { vor(); vor();}

# # # # # # #

# # # # # #

#####

######

>

oo

o

### o#

# # # # # # #

# # # # # #

#####

######

oo

o

##

#o #

###

^#

void main() { vor(); vor(); vor(); vor();}

Allgemeingültig: solange vornFrei(): vor();


Hamster-Modell / Wiederholung / while-Schleife

Grundbefehl

Prozeduraufruf

Blockanweisung

Leeranweisung

Auswahl-anweisung

Anweisung (6)

Wiederholungs-anweisung

while-Anweisung( )

boolescher Ausdruck

Anweisungwhile ( )boolescher Ausdruck

Anweisungwhile

while- Anweisung

Wiederholungsanweisung


Hamster-Modell / Wiederholung / Beispiele

Aufgabe: Landschaft beliebig! Der Hamster soll bis zur nächsten Wand laufen.

void main() { while (vornFrei()) { vor(); }}

# # # # # # #

# # # # # #

#####

######

>

oo

o

### o#

# # # # # # #

# # # # # #

#####

######

oo

o

##

#o #

###

^#

void laufeBisZurNaechstenWandUndSammle() { sammle(); while (vornFrei()) { vor(); sammle(); }}void sammle() { while (kornDa()) nimm();}


Hamster-Modell / Wiederholung / do-Schleife

( )

Wiederholungsanweisung (2)

boolescher Ausdruck

do - Anweisung

whiledo ;

while-Anweisung

do-Anweisung

Block-anweisung

void main() { do { nimm(); } while (kornDa());}

void main() { do { vor(); if (!maulLeer()) gib(); } while (vornFrei());}


Hamster-Modell / Wiederholung / Endlosschleife

void main() { while (vornFrei()) { linksUm(); }}

# # # # # #

# # # # #

#####

######

>

o

oo

oo

#

#

##

#


Hamster-Modell / Wiederholung / BeispielAufgabe: Typische Landschaften:Der Hamster steht vor einem

regelmäßigen Berg unbekannter

Höhe. Er soll den Gipfel erklimmen.

Programm:

void main() { laufeZumBerg(); erklimmeGipfel();}void laufeZumBerg() { while (vornFrei()) vor();}void erklimmeGipfel() { do { erklimmeEineStufe(); } while (!vornFrei());}

#

#

# # # # # # # # # # #

# # # # # # # # # # #

# #

# #

######

###### > #

####### # # # #

# # ##

#

#

# # # # # # # # # # #

# # # # # # # # # # #

# #

# #

######

###### > #

## #

void erklimmeEineStufe() { linksUm(); vor(); rechtsUm(); vor();}void rechtsUm() { linksUm(); linksUm(); linksUm();}


Hamster-Modell / Test-Funktionen / Motivation

Prozeduren: Definition neuer Befehle

Test-Funktionen: Definition neuer Test-Befehle

mauerDa()

linksFrei()

rechtsFrei()

fuenfKoernerDa()

...


Hamster-Modell / Test-Funktionen / return

;boolescher Ausdruck

Boolesche return-Anweisung return

Grundbefehl

Prozeduraufruf

Blockanweisung

Leeranweisung

Auswahl-anweisung

Anweisung (7)

Wiederholungs-anweisung

booleschereturn Anweisung

return !kornDa() && vornFrei();


Hamster-Modell / Test-Funktionen / Definition

boolescherFunktionskopf

boolescherFunktionsrumpf

boolesche Funktionsdefinition

( )booleanboolescher

FunktionsnameboolescherFunktionskopf

Bezeichnerboolescher Funktionsname

Anweisung{ }boolescherFunktionsrumpf

Prozedur-definition

Definitionen (2)

boolescheFunktions-definition

Zusatzbedingung: In jedem möglichen Weg durch den Rumpfmuss eine boolesche return-Anweisung stehen!


Hamster-Modell / Test-Funktionen / Aufruf

( )boolescher

FunktionsnameboolescherFunktionsaufruf

( )

booleschesLiteral

boolescher Ausdruck

!

&&

||

boolescher Ausdruck

boolescher Ausdruck

boolescher Ausdruck

boolescher Ausdruck

boolescher Ausdruck (2)

boolescherFunktionsaufruf

Testbefehl

boolescher Ausdruck


Hamster-Modell / Test-Funktionen / Beispiele

boolean mauerDa() { return !vornFrei();}

boolean linksFrei() { linksUm(); if (vornFrei()) { rechtsUm(); return true; } else { rechtsUm(); return false; }}

void main() { while (!mauerDa() && !linksFrei()) { vor(); } if (linksFrei()) { linksUm(); vor(); }}

void rechtsUm() { linksUm(); linksUm(); linksUm();}


Hamster-Modell / Test-Funktionen / Seiteneffekte

boolean linksFrei() { linksUm(); return vornFrei();}

void main() { if (linksFrei()) ; if (!linksFrei()) ;}

void main() { if (linksFrei()) ; else ;}

# # # # #### # # # #

##

#>o

o

^

# # # # #### # # # #

##

#oo

<

# # # # #### # # # #

##

#oo


Hamster-Modell / Testfunktionen / BeispielAufgabe: Typische Landschaft:Der Hamster (mit mindestens einem Korn im Maul)

soll entlang der Wand laufen, bis er zur Ausgangsposition

zurückgekehrt ist.

Programm:void main() { gib(); // Markierung vor(); while (!kornDa()) { while (vornFrei() && !rechtsFrei() && !kornDa()) { vor(); } if (!kornDa()) { if (rechtsFrei()) { rechtsUm(); vor(); } else { linksUm()} } } }

boolean rechtsFrei() { rechtsUm(); if (vornFrei()) { linksUm(); return true; } else { linksUm(); return false; }}void rechtsUm() { linksUm(); linksUm(); linksUm();}

#

#

# # # # # # # # # # #

# # # # # # # # # # #

# #

# #

######

###### >

##

# #

###

##

###

##

#

#

#

##

#


Hamster-Modell / Programmentwurf

Analyse:

exakte Formulierung der

Aufgabe

Entwurf:

Entwicklung eines

Algorithmus

Implementierung:

Codierung;

Eingabe in den Rechner;

Compilation

Test:

Verifikation der Korrektheit

Dokumentation:

Nachlass für andere Personen

Dokumentation

Problem

Programm

Implementierung

Analyse

Entwurf

Test


Hamster-Modell / Programm-Entwurf / Problem

Der Hamster steht vor einem Berg unbekannter Höhe. Er soll den Gipfel erklimmen und auf dem Gipfel anhalten. Auf dem Weg zum Gipfel soll er auf jeder Stufe genau ein Korn ablegen.

# # # # # # # #> # # # # #

# # ##

# # # # # # # ## # # # ## # ##

# # # # # # # #

>

# # # # ## # ##

(a) zu Anfang (a) zwischendurch (a) am Ende

^o o

oo

# # # # # # # #> #

# # # # # # # ##

# # # # # # # #

>#o o

(b) zu Anfang (b) zwischendurch (b) am Ende

# # # # # # # ##

# # # # # # # ##

# # # # # # # #

>

#^o o

(c) zu Anfang (d) zwischendurch (e) am Ende

^ ######

## # # #

# o


Hamster-Modell / Programm-Entwurf / Analyse

• Anfangsgrößen / Eingabewerte– Position des Hamsters

– Blickrichtung des Hamsters

– Anzahl Körner im Maul des Hamsters

– Körner im Territorium

– Mauern im Territorium

• Endgrößen / Ausgabewerte– Position des Hamsters

– Blickrichtung des Hamsters

– Anzahl Körner im Maul des Hamsters

– Körner im Territorium

• Constraints bzgl. des Lösungsweges

Präzisierung der Aufgabe:

Der Hamster steht mit BlickrichtungWest vor einem regelmäßigen Bergunbekannter Höhe (ohne Überhänge).Er muss nicht unbedingt direkt vor demBerg stehen. Die Stufen des Bergessind jeweils eine Mauer hoch. Der Hamster habe mindestens so viele Körnerim Maul, wie Stufen existieren. Auf demTerritorium befinden sich keine Körner.Außer den Mauern des Berges befindensich keine Mauern im Territorium.Der Hamster soll den Berg erklimmenund auf dem Gipfel anhalten. Auf jederStufe - und nur dort! - soll er ein Kornablegen. Auf dem Weg zum Gipfel musser immer in Berührung zur Wand bleiben.


Hamster-Modell / Programm-Entwurf / Entwurf

• Verfahren: Schrittweise Verfeinerung / Top-Down-Entwurf

• Ziel: Komplexitätsreduktion

• Prinzip:

– Gesamtproblem zu komplex => Aufteilung in einfachere Teilprobleme

– Lösen der Teilprobleme:

• Teilproblem zu komplex => Aufteilung in (noch) einfachere Teilprobleme

• ...

• Zusammensetzung der Lösungen der Teilprobleme zur Lösung des (übergeordneten) Teilproblems

– Zusammensetzung der Lösungen der Teilprobleme zur Lösung des Gesamtproblems

• Vergleich: Puzzlen



Gesamtproblem:Der Hamster soll bis zum Berg laufen und dann den Berg erklimmen.

Teilprobleme:• Der Hamster soll bis zum Berg laufen.• Der Hamster soll den Berg erklimmen.

// der Hamster soll bis zum Berg laufen und dann den// Berg erklimmenvoid main() { laufeZumBerg(); erklimmeDenBerg();}

// der Hamster soll bis zum Berg laufenvoid laufeZumBerg() {}

// der Hamster soll den Berg erklimmenvoid erklimmeDenBerg() {}



Teilproblem 1: Der Hamster soll bis zum Berg laufen.

// der Hamster soll bis zum Berg laufenvoid laufeZumBerg() { while (vornFrei()) { vor(); } gib();}

Teilproblem 2: Der Hamster soll den Berg erklimmen.

// der Hamster soll den Berg erklimmenvoid erklimmeDenBerg() { do { erklimmeEineStufe(); } while (!gipfelErreicht());}

void erklimmeEineStufe() {}boolean gipfelErreicht() {}

Teilproblem 2.1Teilproblem 2.2



Teilproblem 2.1: Der Hamster soll eine Stufe erklimmen.

void erklimmeEineStufe() { linksUm(); vor(); rechtsUm(); vor(); gib();}

void rechtsUm() { linksUm(); linksUm(); linksUm();}

Teilproblem 2.2: Ist der Gipfel erreicht?

boolean gipfelErreicht() { return vornFrei();}


Hamster-Modell / Programm-Entwurf / Implement.

• Codierung in die Entwurfsphase integriert

• Restaufgaben:– Eingabe des Programms in den Rechner

– Compilation

• Anmerkungen / Hinweise:– kein Spaghetti-Code!

– Entwurf mit Bleistift und Papier!

– Auf übersichtliche Strukturierung achten!

– Kommentare verwenden!

– Prozeduren / Funktionen definieren!

– Aussagekräftige Bezeichner wählen!

void main() { while (vornFrei()) vor(); gib(); while (!vornFrei()) { linksUm(); vor(); r(); vor(); gib(); }} void r() { linksUm();linksUm();linksUm();}


Hamster-Modell / Programm-Entwurf / Test

• Verifikation der Korrektheit und Vollständigkeit

• Konstruktion einer Testmenge:– disjunkte Zerlegung der Menge der zulässigen Anfangsgrößen in typische Klassen

– Vertreter jeder Klasse wählen

– Grenzwerte beachten

– erwartetes Ergebnis notieren

– Erfahrung und Intuition notwendig!

• Ausführung des Programms mit allen Elementen der Testmenge:– Ergebnisse (Lösungsweg/Endgrößen) überprüfen

– Testläufe/Ergebnisse protokollieren

# # # # # # # #> # # # # #

# # ##

(a) zu Anfang

# # # # # # # #

>

# # # # ## # ##

(a) am Ende

ooo

# # # # # # # #> #

(b) zu Anfang

# # # # # # # #

>

#o

(b) am Ende

# # # # # # # #> #

(c) zu Anfang

# # # # # # # #

>#o

(c) am Ende

### # #

#o


Hamster-Modell / Programm-Entwurf / Dokument.

Zur Dokumentation gehören:

– eine exakte Problemstellung

– eine verständliche Beschreibung des entwickelten Algorithmus

– der Programmcode

– die gewählte Testmenge mit Protokollen der durchgeführten Testläufe

– eine Beschreibung von aufgetretenen Problemen

– alternative Lösungsansätze

Documents

Programmierkurs Java Vorlesung 3 Dietrich Boles Seite 1 Programmierkurs Java Vorlesung am FB Informatik der Universität Oldenburg Vorlesung 3 Dietrich