Spielerisch Java lernen

[Johannes Schneider]

Hallo,


wahrscheinlich werde ich das Vergüngen haben, mit ein paar 16jährigen
einen Java-Kurs machen zu dürfen.

Ich möchte sie nicht unbedingt zu Hardcore-Java-Freaks machen sondern
vor allem die "Denkweise" eines Programmierers nahelegen. Und vor allem
Spass vermitteln sich hinter ein Problem zu klemmen und es zu lösen...


Jetzt suche ich eine Umgebung, die das spielerisch unterstützt und vor
allem schnelle Erfolge bietet.

Ich bin unter anderem auf folgendes gestoßen - bin aber noch nicht so
zufrieden. Vielleicht hat einer einen Tipp.


Hamster-Simulator:
------------------
http://www-is.informatik.uni-oldenburg.de/~dibo/hamster/index.html

Sehr schön gemacht, eventuell sogar für jüngere geeignet? Allerdings
stört mich, dass man auf den eingebauten Editor angewiesen ist, der
nicht direkt Java-Klassen schreibt, sondern eine Art "Zwischenforma",
welches dann in .java-Files umgewandelt wird.
Ich würde aber gerne irgendwann mit Eclipse weitermachen... Einfach
wegen der Code Complition und der Einbindung der Doku etc.


Robocode:
---------
http://robocode.alphaworks.ibm.com/home/home.html

Ist persönlich mein Favorit. Betont den Wettbewerb und ist somit wohl
motivationsfördernd.
Eclipse ist ohne Einschränkung nutzbar - grafisch sieht es sehr gut aus,
es gibt viele "Gegner" im Internet zum Download.
Eigentlich perfekt - nur der etwas martialische Hintergrund hält mich
momentan noch davon ab... Killerspiele sind an Schulen nunmal sehr
schlecht angesehen ;).
Außerdem scheint das Projekt "tot" zu sein...




mfg

Johannes Schneider

[Kai-Uwe Klavei]

Post by Johannes Schneider
Jetzt suche ich eine Umgebung, die das spielerisch unterstützt und vor
allem schnelle Erfolge bietet.
---------
http://robocode.alphaworks.ibm.com/home/home.html

Es gibt zwei weitere Spiele bei alphaworks:
http://www.alphaworks.ibm.com/keywords/learn%20Java

Gruß Kai-Uwe

[Johannes Schneider]

Post by Kai-Uwe Klavei
http://www.alphaworks.ibm.com/keywords/learn%20Java

Hey - vielen Dank ;)...
Wie ich das übersehen konnte...


mfg

Johannes Schneider

[Frank Radermacher]

Hi Johannes,

schau Dir mal http://www.bluej.org an.

Frank

[Johannes Schneider]

Post by Frank Radermacher
schau Dir mal http://www.bluej.org an.

Danke für den Tipp. Scheint mir aber vor allem eine "einfache" IDE zu
sein... Hab ich das "Spiel" irgendwie verpasst??


mfg

Johannes Schneider

[Frank Radermacher]

Post by Johannes Schneider
sein... Hab ich das "Spiel" irgendwie verpasst??

Nee. Aber da steht in den anderen Threads ja genug. ;-)

Ich arbeite mit Eclipse, wuerde aber fuer einen Kurs sicherlich BlueJ
nehmen.

Frank

[Johannes Schneider]

Post by Frank Radermacher
Ich arbeite mit Eclipse, wuerde aber fuer einen Kurs sicherlich BlueJ
nehmen.

Hoi,

okay - vielen Dank. Dann werde ich mir das mal ausführlichst zu Gemüte
führen...


Johannes Schneider

[Christoph Happich]

Post by Johannes Schneider
Hallo,
wahrscheinlich werde ich das Vergüngen haben, mit ein paar 16jährigen
einen Java-Kurs machen zu dürfen.
Ich möchte sie nicht unbedingt zu Hardcore-Java-Freaks machen sondern
vor allem die "Denkweise" eines Programmierers nahelegen. Und vor allem
Spass vermitteln sich hinter ein Problem zu klemmen und es zu lösen...

Generell: Bist du auf Java angewiesen? Die "Denkweise" eines
Programmierers kann man auch mit anderen Sprachen und Paradigmen
erlernen: Hast du z.B. mal ueber eine funktionale oder logische
Programmiersprache nachgedacht?

Post by Johannes Schneider
Jetzt suche ich eine Umgebung, die das spielerisch unterstützt und vor
allem schnelle Erfolge bietet.
Ich bin unter anderem auf folgendes gestoßen - bin aber noch nicht so
zufrieden. Vielleicht hat einer einen Tipp.
------------------
http://www-is.informatik.uni-oldenburg.de/~dibo/hamster/index.html
Sehr schön gemacht, eventuell sogar für jüngere geeignet? Allerdings
stört mich, dass man auf den eingebauten Editor angewiesen ist, der
nicht direkt Java-Klassen schreibt, sondern eine Art "Zwischenforma",
welches dann in .java-Files umgewandelt wird.
Ich würde aber gerne irgendwann mit Eclipse weitermachen... Einfach
wegen der Code Complition und der Einbindung der Doku etc.

Ich selbst habe mit einem "Hamster" gelernt. Prinzipiell war das schon
ganz gut, ich hab aber ein paar Vorbehalte: Da wird was von
objektorientierter Programmierung erzaehlt, aber ich vermute, dass es
auf einen sehr imperativen Programmierstil hinauslaeuft. Polymorphie und
Rekursion sind ziemlich wichtig und nicht wirklich kompliziert.

Post by Johannes Schneider
---------
http://robocode.alphaworks.ibm.com/home/home.html
Ist persönlich mein Favorit. Betont den Wettbewerb und ist somit wohl
motivationsfördernd.

Bei dem Hamster kann man aber auch einen Wettbewerb einbauen ... Du
musst nur die Probleme richtig stellen. Ausserdem glaube ich, dass das
ganz schoen dauern kann, bis da der erste einigermassen nicht-stumpfe
Robot bei raus kommt. Evtl. ueberfordern die Moeglichkeiten auch etwas
-- das laeuft dann darauf hinaus, dass etwas programiert wird was man
nicht so richtig durchschaut.

Ich wuerde dir eher zum Hamster raten. Klar, imperativ, aber fuer den
Anfang schon OK.

Post by Johannes Schneider
Eclipse ist ohne Einschränkung nutzbar - grafisch sieht es sehr gut aus,

Warum moechtest du denn unbedingt Eclipse? Damit kann man doch viel zu
viel rumfummeln. Dann funktioniert irgendetwas nicht, etc. Da handelt
man sich doch nur unnoetig Aufwand mit ein.

Christoph

[Johannes Schneider]

Post by Christoph Happich
Hast du z.B. mal ueber eine funktionale oder logische
Programmiersprache nachgedacht?

Ja - aber, aber wurde von mir abgelehnt ;). Danke für die Anregung -
soll jetzt hier keine Diskussion diesbezüglih werden.

Post by Christoph Happich
Ich selbst habe mit einem "Hamster" gelernt. Prinzipiell war das schon
ganz gut, ich hab aber ein paar Vorbehalte: Da wird was von
objektorientierter Programmierung erzaehlt, aber ich vermute, dass es
auf einen sehr imperativen Programmierstil hinauslaeuft. Polymorphie und
Rekursion sind ziemlich wichtig und nicht wirklich kompliziert.

Zumindest am Anfang ist es in der Tat äußerst imperativ. Zumindest was
ich gesehen habe... Aber Polymorphie halte ich persönlich für ziemlich
schwierig - zumindest kenne ich viele Leute, die behaupten Java zu
können, aber noch nie was von Polymorphie gehört haben...
Und bezüglich Rekursion: Ich will ja kein Lisp unterrichten ;)

Post by Christoph Happich
Bei dem Hamster kann man aber auch einen Wettbewerb einbauen ... Du
musst nur die Probleme richtig stellen. Ausserdem glaube ich, dass das
ganz schoen dauern kann, bis da der erste einigermassen nicht-stumpfe
Robot bei raus kommt. Evtl. ueberfordern die Moeglichkeiten auch etwas
-- das laeuft dann darauf hinaus, dass etwas programiert wird was man
nicht so richtig durchschaut.
Ich wuerde dir eher zum Hamster raten. Klar, imperativ, aber fuer den
Anfang schon OK.

Hmm. Hört sich (leider) ziemlich schlüssig an. Wie gesagt: Wenn das Ding
mit einem "vernünftigen" Editor zu programmieren wäre, fänd ich das gut.
Eclipse ist kein Muss - ich selbst setzte es gar nicht ein (Intellij
Idea ist nunmal besser ;).
Trotzdem gefällt es mir nicht, wirklich *alles* vor den Leuten zu
verstecken was die Internas betrifft. Aber das ist nicht der eigentliche
Punkt.

Mir geht es um die angesprochenen Komfort-Funktionen... Das vermeidet
(hoffentlich) ein bissl Frustration bezüglich vieler Syntax-Fehler...


mfg

Johannes Schneider

[Christoph Happich]

Post by Johannes Schneider

Post by Christoph Happich
Hast du z.B. mal ueber eine funktionale oder logische
Programmiersprache nachgedacht?

Ja - aber, aber wurde von mir abgelehnt ;). Danke für die Anregung -
soll jetzt hier keine Diskussion diesbezüglih werden.

*mund halt*

Post by Johannes Schneider

Post by Christoph Happich
Ich selbst habe mit einem "Hamster" gelernt. Prinzipiell war das schon
ganz gut, ich hab aber ein paar Vorbehalte: Da wird was von
objektorientierter Programmierung erzaehlt, aber ich vermute, dass es
auf einen sehr imperativen Programmierstil hinauslaeuft. Polymorphie
und Rekursion sind ziemlich wichtig und nicht wirklich kompliziert.

Zumindest am Anfang ist es in der Tat äußerst imperativ. Zumindest was
ich gesehen habe... Aber Polymorphie halte ich persönlich für ziemlich
schwierig - zumindest kenne ich viele Leute, die behaupten Java zu
können, aber noch nie was von Polymorphie gehört haben...

Eben. Meine Erfahrung hat zeigt allerdings, dass Polymorpie von den
meisten als voellig natuerlich empfunden wird, man bloss durch "zu viel
C" verzogen wurde. Je frueher, desto besser also. Ein sinnvolles
Beispiel fuer den Hamster faellt mir allerdings nicht ein :(

Post by Johannes Schneider
Und bezüglich Rekursion: Ich will ja kein Lisp unterrichten ;)

Aua! Fuer Rekursion gilt dasselbe wie fuer Polymorpie (ist allerdings in
funktionalen PS deutlich verstaendlicher). Da koennte mir jetzt sogar
ein Beispiel fuer den Hamster einfallen ...

Post by Johannes Schneider

Post by Christoph Happich
Bei dem Hamster kann man aber auch einen Wettbewerb einbauen ... Du
musst nur die Probleme richtig stellen. Ausserdem glaube ich, dass das
ganz schoen dauern kann, bis da der erste einigermassen nicht-stumpfe
Robot bei raus kommt. Evtl. ueberfordern die Moeglichkeiten auch etwas
-- das laeuft dann darauf hinaus, dass etwas programiert wird was man
nicht so richtig durchschaut.
Ich wuerde dir eher zum Hamster raten. Klar, imperativ, aber fuer den
Anfang schon OK.

Hmm. Hört sich (leider) ziemlich schlüssig an. Wie gesagt: Wenn das Ding
mit einem "vernünftigen" Editor zu programmieren wäre, fänd ich das gut.
Eclipse ist kein Muss - ich selbst setzte es gar nicht ein (Intellij
Idea ist nunmal besser ;).

Ack!

Post by Johannes Schneider
Trotzdem gefällt es mir nicht, wirklich *alles* vor den Leuten zu
verstecken was die Internas betrifft. Aber das ist nicht der eigentliche
Punkt.

Der Schritt von dem Editor zu "so und jetzt zeig ich euch jetzt mal ein
richtiges Programm und was man da alles noch beachten muss" ist, hmm klein.

Post by Johannes Schneider
Mir geht es um die angesprochenen Komfort-Funktionen... Das vermeidet
(hoffentlich) ein bissl Frustration bezüglich vieler Syntax-Fehler...

Bei der Sprache? tststs ...

Christoph

[Johannes Schneider]

Post by Christoph Happich
Eben. Meine Erfahrung hat zeigt allerdings, dass Polymorpie von den
meisten als voellig natuerlich empfunden wird, man bloss durch "zu viel
C" verzogen wurde. Je frueher, desto besser also. Ein sinnvolles
Beispiel fuer den Hamster faellt mir allerdings nicht ein :(

So sehe ich das auch... Deshalb halte ich das Hello-World-Beispiel auch
für, naja, nicht ganz optimal. Es ist eben nicht ganz reinrassige
Objektorientierung ;).

Post by Christoph Happich
Aua! Fuer Rekursion gilt dasselbe wie fuer Polymorpie (ist allerdings in
funktionalen PS deutlich verstaendlicher). Da koennte mir jetzt sogar
ein Beispiel fuer den Hamster einfallen ...

Ein sinnvolles Beispiel für Rekursion? Sach ma...



Anhand welchen "Hamsters" hast du gelernt?


mfg

Johannes Schneider

[Stefan Ram]

Deshalb halte ich das Hello-World-Beispiel auch für, naja,
nicht ganz optimal. Es ist eben nicht ganz reinrassige
Objektorientierung (...)

Deswegen paßt es ja gerade zu Java: Java ist keine reinrassige
objektorientierte Sprache.

In Smalltalk wäre das "Hello-World-Beispiel" eben rein
objektorientiert.

[Christoph Happich]

Post by Stefan Ram

Deshalb halte ich das Hello-World-Beispiel auch für, naja,
nicht ganz optimal. Es ist eben nicht ganz reinrassige
Objektorientierung (...)

Deswegen paßt es ja gerade zu Java: Java ist keine reinrassige
objektorientierte Sprache.
In Smalltalk wäre das "Hello-World-Beispiel" eben rein
objektorientiert.

Blup. Was ist denn an

'hello world' out.

so unglaublich toller objektorientiert als an

System.lang.out( "hello world" );

[Stefan Ram]

Post by Stefan Ram
In Smalltalk wäre das "Hello-World-Beispiel" eben rein
objektorientiert.

(...) Was ist denn an
'hello world' out.
so unglaublich toller objektorientiert als an
System.lang.out( "hello world" );

Die letzte Zeile ist ja keine Übersetzungseinheit, also kein
"Hello-World-Programm" in Java.

Ich antwortete ja auf Johannes Schneider, der das
Hello-World-Programm in Java für nicht "reinrassig"
objektorientiert hält. Daher kann ich nur vermuten, woran er
dabei dachte. Vielleicht daran, daß man dabei zur Deklaration
einer /statischen/ Methode gezwungen wird, also einer
Methode, die nicht zu einem Objekt gehört.

Man sieht dann im Hello-World-Programm in Java auch noch einen
Block, der kein Objekt ist. Und (implizit) Packages, die weder
Klassen noch Objekte sind. Vielleicht will Johannes auch noch
einmal beschreiben, warum er das Hello-World-Programm in Java
für nicht "reinrassig" objektorientiert hält.

[Johannes Schneider]

Post by Stefan Ram
Ich antwortete ja auf Johannes Schneider, der das
Hello-World-Programm in Java für nicht "reinrassig"
objektorientiert hält. [...] Vielleicht will Johannes auch noch
einmal beschreiben, warum er das Hello-World-Programm in Java
für nicht "reinrassig" objektorientiert hält.

Naja, eigentlich ganz einfach - wie du bereits richtig vermutet hast.
Man hat zwar eine Klasse, instanziiert diese aber nicht.
Diese Klasse hat zwar eine Methode, diese ist jedoch statisch.

"System.out" ist auch "statisch", println() stellt wenigstens eine
Objekt-Methode dar - wenn sie innerhalb des ganzen Konklomerats auch gut
versteckt ist. Und der String "Hello World" ist auch nicht gerade
intuiitiv als Objekt erkennbar.

Die Frage ist also eher, inwiefern sich anhand des Programms überhaupt
irgendetwas Objektorientiertes demonstieren/erkennen lässt...


mfg

Johannes Schneider

[Stefan Ram]

Post by Johannes Schneider
Die Frage ist also eher, inwiefern sich anhand des Programms
überhaupt irgendetwas Objektorientiertes demonstieren/erkennen
lässt...

Das "Halloprogramm" verwende ich, um am Anfang eines Kurses
die Bedienung der Entwicklungsumgebung (javac und java) zu
üben. Dafür sollte das Programm eine Wirkung haben und sonst
möglichst kurz sein. Dabei müssen IMO nicht gleich typische
Begriffe der objekt-orientierten Programmierung behandelt
werden.

Danach lehre ich Programmieren und Java. Zunächst einmal
fundamentale Dinge: Literale (welchen Wert hat "012"?),
Datentypen, Operatoren (Welchen Typ und Wert hat "1/2" oder
"1E20+1-1E20"?), Aufrufe, Anweisungen, Blöcke. Diese
Reihenfolge ergibt sich aus einer topologischen Sortierung
der Themen aufgrund ihrer Abhängigkeiten: Wenn Kenntnisse über
Thema A zum Verständnis von Thema B vorausgesetzt werden, dann
kann man zuerst A und dann B behandeln.

Ich unterrichte oft Teilnehmer ohne Vorkenntnisse im
Programmieren. Da behandle ich in den ersten Stunden meist
Themen und Übungen, die in vielen Lehrbüchern als
selbstverständlich vorausgesetzt werden und deswegen darin oft
gar nicht vorkommen. Die Bearbeitung von Übungsaufgaben zeigt
mir dann, daß diese Themen für jene Teilnehmer in Wirklichkeit
nicht selbstverständlich sind.

So wird etwa nach Beispielen zu Aufrufen statischer
Standardmethoden, die Aufgabe gestellt, eine Methode anhand
ihrer Kurzbeschreibung aufzurufen:

Etwa soll "toLowerCase" anhand der "Method Summary"
auf das Argument 65 angewendet werden, um den Gemeinen
zur Versalie 65 zu ermitteln:

java.lang
Class Charachter
public static char toLowerCase( int codePoint )
Converts the character (Unicode code point) argument
to lowercase using case mapping information from the
UnicodeData file.

Obwohl vorher darauf hingewiesen wurde, daß dies nicht
zielführend ist, wird oft die dritte Zeile der obigen "Method
Summary" in das Programm kopiert und nicht weiter verändert.
Nur einige Teilnehmer finden die gesuchte Lösung "toLowerCase(
65 )", mamchmal weniger als die Hälfte. Dabei gab es dazu
vorher schon verschiedene Beispiele, wie etwa die Method
Summary

java.lang
Class Math
public static double abs( double number )
Returns the absolute value of a double value.

mit dem Beispielprogramm

public class Abs
{ public static void main( String[] args )
{ System.out.println( Math.abs( -2 )); }}

Die Bedeutung von "double" und "double number" in der
Method Summary wurde zuvor erklärt.

Eine typische Teilnehmerlösung könnte in etwas so aussehen:

public class Loesung
{ public static void main( String[] args )
{ char toLowercase( int codePoint 65 ); }}

Wenn man es gewohnt ist, in Java zu programmieren, fällt es
manchmal schwer, sich in die Schwierigkeiten
zurückzuversetzen, die man am Anfang des Lernens haben kann.

Bei den geschilderten Problemen mit einfachen Notationen von
Aufrufen sollten IMO zuerst diese Grundlagen geklärt werden,
bevor man darauf aufbauende Begriffe der objektorientierten
Programmierung behandeln kann. (Das kann aber natürlich auch
spielerisch mit einer Schildkröte geschehen - dagegen habe ich
nichts einzuwenden.)

Das mag bei Lehrveranstaltungen für Teilnehmer mit
Vorkenntnissen im Programmieren oder mehr Vertrautheit mit
mathematischen Schreibweisen schon wieder anders sein.

[Stefan Ram]

Post by Johannes Schneider
Die Frage ist also eher, inwiefern sich anhand des Programms
überhaupt irgendetwas Objektorientiertes demonstieren/erkennen
lässt...

Das "Halloprogramm" verwende ich, um am Anfang eines Kurses
die Bedienung der Entwicklungsumgebung (javac und java) zu
üben. Dafür sollte das Programm eine Wirkung haben und sonst
möglichst kurz sein. Dabei müssen IMO nicht gleich typische
Begriffe der objekt-orientierten Programmierung behandelt
werden.

Danach lehre ich Programmieren und Java. Zunächst einmal
fundamentale Dinge: Literale (welchen Wert hat "012"?),
Datentypen, Operatoren (Welchen Typ und Wert hat "1/2" oder
"1E20+1-1E20"?), Aufrufe, Anweisungen, Blöcke. Diese
Reihenfolge ergibt sich aus einer topologischen Sortierung
der Themen aufgrund ihrer Abhängigkeiten: Wenn Kenntnisse über
Thema A zum Verständnis von Thema B vorausgesetzt werden, dann
kann man zuerst A und dann B behandeln.

Ich unterrichte oft Teilnehmer ohne Vorkenntnisse im
Programmieren. Da behandle ich in den ersten Stunden meist
Themen und Übungen, die in vielen Lehrbüchern als
selbstverständlich vorausgesetzt werden und deswegen darin oft
gar nicht vorkommen. Die Bearbeitung von Übungsaufgaben zeigt
mir dann, daß diese Themen für jene Teilnehmer in Wirklichkeit
nicht selbstverständlich sind.

So wird etwa nach Beispielen zu Aufrufen statischer
Standardmethoden, die Aufgabe gestellt, eine Methode anhand
ihrer Kurzbeschreibung aufzurufen:

Etwa soll "toLowerCase" anhand der "Method Summary"
auf das Argument 65 angewendet werden, um den Gemeinen
zur Versalie 65 zu ermitteln:

java.lang
Class Charachter
public static int toLowerCase( int codePoint )
Converts the character (Unicode code point) argument
to lowercase using case mapping information from the
UnicodeData file.

Obwohl vorher darauf hingewiesen wurde, daß dies nicht
zielführend ist, wird oft die dritte Zeile der obigen "Method
Summary" in das Programm kopiert und nicht weiter verändert.
Nur einige Teilnehmer finden die gesuchte Lösung "toLowerCase(
65 )", mamchmal weniger als die Hälfte. Dabei gab es dazu
vorher schon verschiedene Beispiele, wie etwa die Method
Summary

java.lang
Class Math
public static double abs( double number )
Returns the absolute value of a double value.

mit dem Beispielprogramm

public class Abs
{ public static void main( String[] args )
{ System.out.println( Math.abs( -2 )); }}

Die Bedeutung von "double" und "double number" in der
Method Summary wurde zuvor erklärt.

Eine typische Teilnehmerlösung könnte in etwas so aussehen:

public class Loesung
{ public static void main( String[] args )
{ int toLowercase( int codePoint 65 ); }}

Wenn man es gewohnt ist, in Java zu programmieren, fällt es
manchmal schwer, sich in die Schwierigkeiten
zurückzuversetzen, die man am Anfang des Lernens haben kann.

Bei den geschilderten Problemen mit einfachen Notationen von
Aufrufen sollten IMO zuerst diese Grundlagen geklärt werden,
bevor man darauf aufbauende Begriffe der objektorientierten
Programmierung behandeln kann. (Das kann aber natürlich auch
spielerisch mit einer Schildkröte geschehen - dagegen habe ich
nichts einzuwenden.)

Das mag bei Lehrveranstaltungen für Teilnehmer mit
Vorkenntnissen im Programmieren oder mehr Vertrautheit mit
mathematischen Schreibweisen schon wieder anders sein.

[Stefan Matthias Aust]

Post by Johannes Schneider
Und der String "Hello World" ist auch nicht gerade
intuiitiv als Objekt erkennbar.

In Java vielleicht nicht - aber in einer "echten" OO-Sprache gilt "alles
ist ein Objekt" und daraus würde folgen: es muss ein Objekt sein, denn
es gibt nichts anderes.

Die primitiven Datentypen bei Java sind ein weiterer Grund, warum mit
Java schwerer OO beizubringen ist als mit anderen Sprachen (Ruby,
Python, ja sogar Scheme oder Lisp).

Natürlich muss man nicht objektorientiert programmieren und kann auch
mit Java zumindest das imperative, prozedurale Programmieren lernen.


bye

[Stefan Matthias Aust]

Post by Stefan Ram
In Smalltalk wäre das "Hello-World-Beispiel" eben rein
objektorientiert.

Da wäre das Beispiel absolut hinfällig. Was willst du machen? Einen String

'Hallo Welt'

hinschreiben, dann selektieren und print-it sagen? Dann erscheint
nochmal Hallo Welt - toll. Oder inspect-it? Dann hat man wenigstens
ein Fenster mit dem Aufbau des Strings - schon besser. Irgendwie aber
nicht überzeugend. Das Beispiel ist einfach viel zu trivial :)


bye

[Frank Buss]

Post by Johannes Schneider
Zumindest am Anfang ist es in der Tat äußerst imperativ. Zumindest was
ich gesehen habe... Aber Polymorphie halte ich persönlich für ziemlich
schwierig - zumindest kenne ich viele Leute, die behaupten Java zu
können, aber noch nie was von Polymorphie gehört haben...

dann können die nicht Java. Polymorphie ist meiner Meinung nach sehr
wichtig, besonders wenn man den Anspruch hat, objektorientiert zu
programmieren und es ist auch nicht schwierig. Um beim Hamster zu
bleiben: Sieht so aus, als gäbe es Wände und den Hamster. Also könnte man
ein Grundobjekt definieren, davon abgeleitet der Hamster und die Wand,
alles als "Grundobjekt" in einem Array, polymorph per draw-Method
gezeichnet.

In der Java-Bibliothek selbst wird Polymorphie auch an vielen Stellen
eingesetzt und man sollte das Konzept zumindest verstanden haben, um Java
sinnvoll einsetzen zu können.

Post by Johannes Schneider
Und bezüglich Rekursion: Ich will ja kein Lisp unterrichten ;)

ist keineswegs auf Lisp beschränkt und man kann damit auch manche
Algorithm sehr einfach beschreiben, z.B. für den Hamster ein
Suchalgorithmus, der von einem Eingang zu einem Ausgang in einem
Labyrinth findet.

[Johannes Schneider]

Post by Frank Buss

Post by Johannes Schneider
können, aber noch nie was von Polymorphie gehört haben...

dann können die nicht Java.

Da stimme ich dir voll und ganz zu. Meine Aussage war genau darauf hin
bezogen. --> Viele, die meinen Java zu können, haben damit Probleme. Von
daher kann es nicht so einfach sein ;).

Post by Frank Buss

Post by Johannes Schneider
Und bezüglich Rekursion: Ich will ja kein Lisp unterrichten ;)

ist keineswegs auf Lisp beschränkt und man kann damit auch manche
Algorithm sehr einfach beschreiben, z.B. für den Hamster ein
Suchalgorithmus, der von einem Eingang zu einem Ausgang in einem
Labyrinth findet.

Naja. Ein Großteil der Rekursionen kann durch eine vernünftige
Schleiferei abgefangen werden. Die in Java dann noch vorkommenden
Rekursionen sind meiner Ansicht nach eher "trivial" und ergeben sich von
alleine (z.B. beim Ablaufen eines Baumes bis zu den kleinsten Ästen), da
die Rekursion zwar die gleiche Methode aber immer andere Objekte betrifft.
Die "klassische Lisp-Rekursion" ist mir in Java jetzt noch nicht sehr
oft begegnet...



Johannes Schneider

[Frank Buss]

Post by Johannes Schneider
Naja. Ein Großteil der Rekursionen kann durch eine vernünftige
Schleiferei abgefangen werden.

klar, man kann jede Rekursion auch mit einer Schleife programmieren,
fragt sich nur, wie aufwendig das dann wird, wenn man einen eigenen Stack
programmieren muß, z.B. für dein Baum-Beispiel oder den Suchalgorithmus,
der ähnlich funktionieren würde.

Post by Johannes Schneider
Die in Java dann noch vorkommenden
Rekursionen sind meiner Ansicht nach eher "trivial" und ergeben sich
von alleine (z.B. beim Ablaufen eines Baumes bis zu den kleinsten
Ästen), da die Rekursion zwar die gleiche Methode aber immer andere
Objekte betrifft. Die "klassische Lisp-Rekursion" ist mir in Java
jetzt noch nicht sehr oft begegnet...

was ist denn für dich eine "klassische Lisp-Rekursion"? In Lisp kann man
auch wunderbar mit Schleifen programmieren und für sowas wie Fakultät
berechnen würde ich sowieso Primzahlen verwenden, was dann ohne Rekursion
geht :-)

http://www.luschny.de/math/factorial/FastFactorialFunctions.htm

Ansonsten lassen sich aber viele Algorithmen küzer und leichter
verständlich als Rekursion formulieren. Leider gibt es bei Java Grenzen
bei der Stack-Größe, was man dabei immer beachten sollte und Tail-
Rekursionen werden meines Wissens auch nicht optimiert.

[Johannes Schneider]

Post by Frank Buss
was ist denn für dich eine "klassische Lisp-Rekursion"? In Lisp kann man
auch wunderbar mit Schleifen programmieren und für sowas wie Fakultät
berechnen würde ich sowieso Primzahlen verwenden, was dann ohne Rekursion
geht :-)

Mit "klassischer Rekursion" meine ich ein Aufrufen einer Methode aus
sich selbst. Was in prozedurealen Programmiersprachen natürlich am
einfachsten zu sehen ist.

In Java dagegen wird zwar oft der selbe Methodenname verwendet, es
handelt sich dabei aber meistens/oft um verschiedene Objekte, zu denen
die Methode gehört.
Von daher könnte man ja sagen, dass es streng genommen nicht die selbe
Methode ist (wenn Methoden zu einem Objekt gehören und nicht zu einer
Klasse).
Wobei bei einer prozeduralen Sprache der übergebene Parameter oftmals
die Rolle dieses Objekts übernimmt - von daher... Naja. Ist auch wurscht.



Um die Sache mal etwas zu entschärfen:
Ich liebe Rekursion und setze sie gerne und oft ein (auch in Java). ;)



mfg

Johannes Schneider

[Stefan Ram]

Post by Johannes Schneider

Post by Frank Buss

Post by Johannes Schneider
können, aber noch nie was von Polymorphie gehört haben...

dann können die nicht Java.

Da stimme ich dir voll und ganz zu. Meine Aussage war genau darauf hin
bezogen. --> Viele, die meinen Java zu können, haben damit Probleme. Von
daher kann es nicht so einfach sein

"Polymorphie" bezeichnet die Eigenschaft eines Ausdrucks für
ein Objekt stehen zu können, dessen Klasse durch den Ausdruck
nicht festgelegt ist. Es gibt also mehrere (gr. "poly-")
Möglichkeiten für die Klasse (Gestalt, gr. "-morphie") solch
eines Ausdrucks.

Beispiel in Java:

public class Polymorphism { public static void main( String[] args ) {
( Math.random() > .5 ?( Object )System.out : System.in )
.
hashCode()
; }}

Hier ist der Ausdruck in Zeile 2 der polymorphe Empfänger
der Nachricht aus Zeile 4. Man kann auch sagen: der
polymorphe Implementator der Operation der Zeile 4.

Die Methode, welche die Operation "hashCode()" dann
ausführt, wird zur Laufzeit ermittelt.

Das gibt es im Alltag auch: Der Kommandeur einer Arbeitsgruppe
befiehlt allen Arbeitern, am Montag um 8 Uhr zum nördlichen
Stadttor zu kommen. /Wie/ ein Mitarbeiter dies dann umsetzt
(per Auto, Hubschrauber, Rad oder zu Fuß) ist seine Sache.
Dadurch muß sich der Kommandeur nicht mit
Implementationsdetails beschäftigen, die der einzelne Arbeiter
besser zeitnah selber entscheidet.

Diese Form der Entscheidung zur Realisierung einer Operation
anhand des zur Laufzeit ermittelten Typs des implementierenden
Dienstes ersetzt in der OOP die switch-Anweisung, die anhand
eines Typs verzweigt und die an der "falschen Stelle" stehen
würde (nämlich beim Kommandeur, der sich dann mit den Details
der Anfahrt der einzelnen Arbeiter beschäftigen müßte). Vgl.:

http://c2.com/cgi/wiki?ReplaceConditionalWithPolymorphism

Da dieser Refaktor ziemlich zentral für die OOP ist, wird man
ohen Verständnis für ihn, im besten Fall etwas von dem
Vokabular der OOP verwenden, aber ohne sie ganz begriffen zu
haben. So betont ja auch Alan Kay, der Schöpfer des Begriffs
"object-oriented programming", in seiner Defintion von
"object-oriented programming" die Wichtigkeit der Polymorphie,
oder - in seinen Worten - der "extreme late-binding of all
things".

Noch ein paar Notizen von mir:

http://www.purl.org/stefan_ram/pub/java_polymorphie_de

Noch ein Gedanken zum "Hello World": Der Aufruf

java.lang.System.out.println( "Hello" )

ist bereits "polymorph", denn das Feld java.lang.System.out
kann ein Objekt einer beliebigen Unterklasse von
java.io.PrintStream enthalten. Welches Objekt ist i.A.
erst zur Laufzeit bekannt - und /wie/ dieses die
Operation «println( "Hello" )» implementiert auch.

[Stefan Matthias Aust]

Post by Stefan Ram
Das gibt es im Alltag auch: Der Kommandeur einer Arbeitsgruppe
befiehlt allen Arbeitern, am Montag um 8 Uhr zum nördlichen

Kommandeure für Arbeiter? Ich würde den Vorarbeiter oder Polier oder
Chef oder so nennen. Kommandeur ist für mich rein millitärisch und
dann wären es Soldaten (oder meintwegen Krieger oder Bewaffnete), keine
Arbeiter. Allerdings ist das Militär ein schlechtes Beispiel, weil es
das Konzept des selbstverantworlichen Handeln nicht wirklich kennt. Da
wäre es nicht egal, wie die Soldaten zum Tor kommen... es müsste ihnen
befohlen werden :)


bye

[Stefan Ram]

Post by Stefan Matthias Aust

Post by Stefan Ram
Das gibt es im Alltag auch: Der Kommandeur einer Arbeitsgruppe
befiehlt allen Arbeitern, am Montag um 8 Uhr zum nördlichen

Kommandeure für Arbeiter? Ich würde den Vorarbeiter oder Polier oder
Chef oder so nennen.

Ja, das würde besser passen.

[Christoph Happich]

Post by Johannes Schneider

Post by Frank Buss

Post by Johannes Schneider
können, aber noch nie was von Polymorphie gehört haben...

dann können die nicht Java.

Da stimme ich dir voll und ganz zu. Meine Aussage war genau darauf hin
bezogen. --> Viele, die meinen Java zu können, haben damit Probleme. Von
daher kann es nicht so einfach sein ;).

Wenn man eine Klasse als Klasse begreift und nicht als Sammelbegriff
fuer ein paar Methoden auf gemeinsamen Variablen, ist Polymorpie das
einzig einleuchtende. Es ist mir ein voelliges Raetsel wie man
objektorientiert ohne sowas programmieren moechte.

Post by Johannes Schneider

Post by Frank Buss

Post by Johannes Schneider
Und bezüglich Rekursion: Ich will ja kein Lisp unterrichten ;)

ist keineswegs auf Lisp beschränkt und man kann damit auch manche
Algorithm sehr einfach beschreiben, z.B. für den Hamster ein
Suchalgorithmus, der von einem Eingang zu einem Ausgang in einem
Labyrinth findet.

Naja. Ein Großteil der Rekursionen kann durch eine vernünftige
Schleiferei abgefangen werden. Die in Java dann noch vorkommenden
Rekursionen sind meiner Ansicht nach eher "trivial" und ergeben sich von
alleine (z.B. beim Ablaufen eines Baumes bis zu den kleinsten Ästen), da
die Rekursion zwar die gleiche Methode aber immer andere Objekte betrifft.
Die "klassische Lisp-Rekursion" ist mir in Java jetzt noch nicht sehr
oft begegnet ...

Mit solchen Aussagen steuerst du dich in Abseits ;) Rekursion bietet
sich staendig an. Gutes Beispiel: der Nachbar-Thread "Farbattribute fuer
alle Components ..." Schleifen nerven da nur.
Super-Extrem-Mega-Wichtig finde ich es aber auch nicht. Eher schade. Du
kannst also auch (erstmal) drauf verzichten.

Christoph

[Stefan Matthias Aust]

Post by Johannes Schneider
Die "klassische Lisp-Rekursion" ist mir in Java jetzt noch nicht sehr
oft begegnet...

Dann kennst du meine Programm nicht :)

Rekursion ist IMHO ein wichtiges Konzept, dass man zuerst verstehen
sollte. Dann kann man sehen, wie man endrekursive Algorithmen auch
durch while-Schleifen ausdrücken kann und schließlich, dass eine
for-Schleife eine Sonderform der while-Schleife ist.

Alternativ würde ich überhaupt keine Schleifen erwähnen, sondern nur
über (innere) Iteratoren reden, das funktioniert in Java nicht.

Smalltalk (Squeak z.B.) würde sich IMHO eh besser für Kinder oder
Jugendliche zum Lernen von Objektorientierung eignen. Da wäre das dann
das natürlich Konzept.


bye

[Johannes Schneider]

Post by Stefan Matthias Aust

Post by Johannes Schneider
Die "klassische Lisp-Rekursion" ist mir in Java jetzt noch nicht sehr
oft begegnet...

Dann kennst du meine Programm nicht :)

Das könnte natürlich der Fall sein ;)

Post by Stefan Matthias Aust
Rekursion ist IMHO ein wichtiges Konzept, dass man zuerst verstehen
sollte. Dann kann man sehen, wie man endrekursive Algorithmen auch
durch while-Schleifen ausdrücken kann und schließlich, dass eine
for-Schleife eine Sonderform der while-Schleife ist.

Das ganze wird ja jetzt etwas OffTopic. Trotzdem ;)
Da bin ich ehrlich gesagt nicht ganz deiner Meinung. Warum mühsam
Rekursion lernen (die für Anfänger gerne zu Hirnverknotungen führt ;),
und dann wieder davon weg gehen zu Schleifen.
Ich halte Schleifen für "einfacher" bzw. intuiitiver erlernbar. Und wie
gesagt: Bei dem berühmten Baum wird die Rekursion (hoffentlich)
automatisch entstehen, wenn ein Anfänger alle Knoten durchlaufen will
(per While-Schleife). Vielleicht nicht beim ersten Versuch, aber relativ
früh...
--> Rekursion nicht gepaukt, sondern "selbst entwickelt"...

Post by Stefan Matthias Aust
Alternativ würde ich überhaupt keine Schleifen erwähnen, sondern nur
über (innere) Iteratoren reden, das funktioniert in Java nicht.
Smalltalk (Squeak z.B.) würde sich IMHO eh besser für Kinder oder
Jugendliche zum Lernen von Objektorientierung eignen. Da wäre das dann
das natürlich Konzept.

Jo gut. Das muss ich jetzt unbesehen glauben, da ich über keinerlei
Smalltalk-Erfahrung verfüge...


mfg

Johannes Schneider

[Stefan Matthias Aust]

Post by Johannes Schneider
Das ganze wird ja jetzt etwas OffTopic. Trotzdem ;)

Offtopic heißt die Würze, die diese Newsgroup lesenwert macht...

Post by Johannes Schneider
Da bin ich ehrlich gesagt nicht ganz deiner Meinung. Warum mühsam
Rekursion lernen (die für Anfänger gerne zu Hirnverknotungen führt ;),

Dem widerspreche ich. Rekursion ist nicht mühsam. Tatsächlich finde
ich eine Erklärung wie "n! = (n-1)! * n", also die Fakultät von N ist N
mal die nächstkleinere Fakultät sehr einfach. Teile-und-herrsche ist
wohl eines der ältesten Prinzipien überhaupt und Rekursion ist IMHO eine
Variante davon.

Für eine Schleife brauchst du meist "Variablen", genauer veränderbare
Speicherstellen, die zusätzliche Komplexität bedeuten.

Zudem ist Rekursion das grundlegende Prinzip der natürlichen Zahlen,
denn merke: Wenn N eine natürliche Zahl ist, ist deren Nachfolger N+1
ebenfalls eine. 0 ist eine natürliche Zahl. Daraus lassen sich jetzt
alle mathematischen Operationen auf natürlichen Zahlen ableiten. Das
man Multiplikation durch mehrfaches Anwenden von Addition ausdrücken
kann, sollte klar sein: Schon wieder Rekursion: N*M = (N*(M-1))+N.


bye

[Wanja Gayk]

Stefan Matthias Aust said...

Post by Stefan Matthias Aust
Dem widerspreche ich. Rekursion ist nicht mühsam. Tatsächlich finde
ich eine Erklärung wie "n! = (n-1)! * n", also die Fakultät von N ist N
mal die nächstkleinere Fakultät sehr einfach.

[...]

Post by Stefan Matthias Aust
Für eine Schleife brauchst du meist "Variablen", genauer veränderbare
Speicherstellen, die zusätzliche Komplexität bedeuten.

Eben hier ist ein Problem, fass ich bei Anfängern sehr oft beobachten
konnte: viele kapieren nicht, dass in einem Rekursionsschritt die
variable "n" eben nicht _das_ "n" ist, sondern ein anderes "n" (nämlich
das oberste auf dem Stack, das bei jedem Aufruf dazu kommt).

Gruß,
-Wanja-

[Stefan Ram]

Post by Wanja Gayk
Stefan Matthias Aust said...
Eben hier ist ein Problem, [das] ich bei Anfängern sehr oft
beobachten konnte: viele kapieren nicht, dass in einem
Rekursionsschritt die variable "n" eben nicht _das_ "n" ist,
sondern ein anderes "n" (nämlich das oberste auf dem Stack, das
bei jedem Aufruf dazu kommt).

Oder man kann auch sagen: Viele Lehrende schaffen es nicht,
das für einen Anfänger verständlich zu machen.

Da hilft die Beobachtung schon etwas, daß man dafür gar
keine Variable braucht: Konstanten ("final") reichen.

Sie "erzwingen" auch ein Verständnis, weil wegen ihrer
Konstantheit, es eben gar nicht möglich ist, anzunehmen,
daß das "n" einer innern Inkarnation das einer äußeren
ist, wenn es einen anderen Wert hat.

Ich betone von Anfang an den Unterschied zwischen einer
Methodendeklaration (statisch, Quelltext) und einer
Methodeninkarnation (dynamisch, Laufzeit) und weise darauf
hin, daß eine einmal deklarierte Methode mehrfach
inkarniert werden kann.

Dazu habe ich einige Abbildungen erstellt, wie etwa:

Mehrfache Uebergabe eines Arguments

|Zeit main
| .----------------.
| | |
| | |
| | ausgeben( 7 ) | public static void ausgeben
| | | .---------------------------------.
| | | | ( final int | Erste
| | '-----> zahl ) | Inkarnation
| | Wert | { System.out.println( zahl ); } | der Methode
| | | | | "ausgeben"
| | '-------------|-------------------'
| | | | Wirkung
| | | V
| | | "7" und Zeilenende ist ausgegeben
| | |
| | |
| | ausgeben( 3 ) | public static void ausgeben
| | | .---------------------------------.
| | | | ( final int | Zweite
| | '-----> zahl ) | Inkarnation
| | Wert | { System.out.println( zahl ); } | der Methode
| | | | | "ausgeben"
| | '-------------|-------------------'
| | | | Wirkung
| | | V
| | | "3" und Zeilenende ist ausgegeben
| | |
V '----------------'

In der Lektion

http://www.purl.org/stefan_ram/pub/java_konstantenparameterdefinition_de

Die erste nicht-endlos Rekursion in meinem Lehrgang wird vor
den Variablen und Iterationen behandelt. Zu diesem Zeitpunkt
sind nur Konstanten und Konstantenparameter bekannt. Auch die
if-Verzweigung ist dort noch nicht behandelt worden. Sie
findet sich in der folgenden Lektion:

http://www.purl.org/stefan_ram/pub/java_bedingter_ausdruck_de

Nachdem die Fakultät als Beispiel vorgestellt wurde, soll dann
in einer Übungsaufgabe daraus eine Methode gebastelt werden,
die ein bestimmte Zahl von Sternchen ausgibt.

[Stefan Ram]

Post by Stefan Ram
| | ausgeben( 7 ) | public static void ausgeben
| | | .---------------------------------.
| | | | ( final int | Erste
| | '-----> zahl ) | Inkarnation
| | ausgeben( 3 ) | public static void ausgeben
| | | .---------------------------------.
| | | | ( final int | Zweite
| | '-----> zahl ) | Inkarnation

Ich möchte noch einmal den Punkt betonen:

Die beiden Aufrufe "ausgeben( 7 )" und "ausgeben( 3 )" führen
auf ein Paradoxon:

Der Parameter "zahl" ist konstant ("final").
Wie kann er dann zuerst den Wert "7" und
später den Wert "3" haben?

Dieses Paradoxon kann nur auflösen, wer verstanden hat, daß
hier /zwei verschiedene Konstanten existieren/, nämlich
jeweils eine pro Inkarnation. Beide Inkarnationen teilen sich
dieselbe Deklaration im Quelltext, beide Konstanten teilen
sich dieselbe Deklaration im Quelltext, und beide Konstanten
teilen sich daher auch den Namen.

Durch diese Vorgehensweise sorge ich für ein Verständnis
dieses Unterschieds zwischen Deklaration und Inkarnation schon
/vor/ der ersten Begegnung mit der Rekursion. Dadurch wird
beim Lernen ein Zwischenschritt eingefügt: Wenn man dann
diesem Phänomen bei der Rekursion wieder begegnet, ist es
schon nicht mehr ganz so fremd und neu, wie ohne diesen
Zwischenschritt. So wird der eine große Schritt zum Verstehen
der Rekursion in zwei kleinere Schritte zerlegt, die
einzeln jeweils etwas leichter zu bewältigen sind.

[Stefan Ram]

Post by Stefan Ram
Durch diese Vorgehensweise sorge ich für ein Verständnis
dieses Unterschieds zwischen Deklaration und Inkarnation schon
/vor/ der ersten Begegnung mit der Rekursion.

Und natürlich ist dies auch eine Vorbereitung auf die OOP,
denn statt "Inkarnation einer Methode" kann man auch sagen
"Erzeugung eines Exemplars der Methode". Die Rekursion beruht
auf der gleichtzeitigen Erzeugung mehrerer "Exemplare" einer
Methode.

Diese "Methodenexemplare" sind allerdings nicht so flexibel
wie die Exemplare einer Klasse: Ihre Lebenszeit ist durch die
Dauer einer Aktivierung fest vorgegeben und ihre Daten noch
nicht von der speziellen Operation der Methode entkoppelt.
Trotzdem ist das Verständnis der Inkarnationsdynamik auch als
Zwischenschritt zum Erlernen der Exemplarerzeugung dienlich.

Versuchte man die Lebensdauer einer Methode über einen
einzelnen Aufruf hinweg zu verlängern, wäre man auf dem
Weg, "Objekte" neu zu erfinden.

[Wanja Gayk]

Stefan Ram said...

Post by Stefan Ram

Post by Wanja Gayk
Stefan Matthias Aust said...
Eben hier ist ein Problem, [das] ich bei Anfängern sehr oft
beobachten konnte: viele kapieren nicht, dass in einem
Rekursionsschritt die variable "n" eben nicht _das_ "n" ist,
sondern ein anderes "n" (nämlich das oberste auf dem Stack, das
bei jedem Aufruf dazu kommt).

Oder man kann auch sagen: Viele Lehrende schaffen es nicht,
das für einen Anfänger verständlich zu machen.
Da hilft die Beobachtung schon etwas, daß man dafür gar
keine Variable braucht: Konstanten ("final") reichen.
Sie "erzwingen" auch ein Verständnis, weil wegen ihrer
Konstantheit, es eben gar nicht möglich ist, anzunehmen,
daß das "n" einer innern Inkarnation das einer äußeren
ist, wenn es einen anderen Wert hat.

An dieser stelle möchte ich festhalten, dass ich eher sehe, dass die
Leute etwas an dem Namen festmachen, nicht an den Eigenschaften (lokal,
konstant..) also das "final" Attribut führt IMO eher zu der Frage "warum
kann das einen anderen Wert haben, ich denke das ist konstant?", womit
man wieder am Anfang wäre.

Post by Stefan Ram
Ich betone von Anfang an den Unterschied zwischen einer
Methodendeklaration (statisch, Quelltext) und einer
Methodeninkarnation (dynamisch, Laufzeit) und weise darauf
hin, daß eine einmal deklarierte Methode mehrfach
inkarniert werden kann.
Mehrfache Uebergabe eines Arguments

[snip]
Auch ne Idee!

Meine erfolgreichste Methode bestand darin, die selbe Methode auf
mehrere Post-it Zettel zu schreiben und bei dem Aufruf der Methode aus
sich selbst ein neues postit über die betrachtete Methode zu legen und
zu sagen: "siehst du, hier fangen wir also an und hier ist n=2, weil wir
es ja mit 2 aufgerufen haben..." und das geht so lange weiter, bis eine
Methode einen return macht. Dann nehme ich das oberste Zettelchen wieder
weg, zeige auf die Stelle, wo der Aufruf zurück kehrt und sage: "so,
hier liefert der return von eben also die Zahl 1 zurück.. und jetzt geht
es damit hier zu diesem Return.." nehme das nächste postit weg.. und
mache so weiter, bis man wieder am Einstieg ist. Und wenn man dabei
immer schön mitrechnet und das gewünschte Ergebnis raus kommt, kapieren
es dann die meisten (weil man mit den postit ja praktisch den Stack
symbolisiert).

Gruß,
-Wanja-

[Stefan Matthias Aust]

Post by Wanja Gayk
Eben hier ist ein Problem, fass ich bei Anfängern sehr oft beobachten
konnte: viele kapieren nicht, dass in einem Rekursionsschritt die
variable "n" eben nicht _das_ "n" ist, sondern ein anderes "n" (nämlich
das oberste auf dem Stack, das bei jedem Aufruf dazu kommt).

Nix Stack, das ist schon wieder das falsche Konzept. N ist ein Name.
Und genau wie verschiedene Menschen Wanja heißen können, so können eben
auch verschiedene Rechenergebnisse N heißen.


bye

[Wanja Gayk]

Stefan Matthias Aust said...

Post by Stefan Matthias Aust

Post by Wanja Gayk
Eben hier ist ein Problem, fass ich bei Anfängern sehr oft beobachten
konnte: viele kapieren nicht, dass in einem Rekursionsschritt die
variable "n" eben nicht _das_ "n" ist, sondern ein anderes "n" (nämlich
das oberste auf dem Stack, das bei jedem Aufruf dazu kommt).

Nix Stack, das ist schon wieder das falsche Konzept. N ist ein Name.
Und genau wie verschiedene Menschen Wanja heißen können, so können eben
auch verschiedene Rechenergebnisse N heißen.

Das war im Grunde meine Aussage.
das mit dem Stack ist eine Ausdruckweise, die ich benutze, weil ich im
Hinterkopf denke: "Status der Methode und Rücksprungadresse auf Stack
schieben". Alte Assemblerdenkweise halt.

Gruß,
-Wanja-

[Stefan Matthias Aust]

Ach noch was, ich hatte mal das unter www.3plus4.de/stuff/wc.html
beschriebene Spiel benutzt, um OOA und OOD zu lehren und das dann in
Java umzusetzen (der Artikel beschäftigt sich mit der Sprache Scala, das
sei jetzt mal egal). Das war allerdings nicht für 16 jährige
Programmieranfänger gedacht...


bye

[Wanja Gayk]

Christoph Happich said...

Post by Christoph Happich

Post by Johannes Schneider
Eclipse ist ohne Einschränkung nutzbar - grafisch sieht es sehr gut aus,

Warum moechtest du denn unbedingt Eclipse? Damit kann man doch viel zu
viel rumfummeln. Dann funktioniert irgendetwas nicht, etc. Da handelt
man sich doch nur unnoetig Aufwand mit ein.

Ich halte Eclipse für eine gute Idee, ich habe gemerkt, dass es den
Tutoriumsteinehmern von mir immer eine Menge Arbeit abgenommen hat, vor
allem was z.B. die ewigen Imports angeht und die Tatsache, dass man
viele Fehler schon bei dem Editieren gemeldet bekommt.

Gruß,
-Wanja-

[Wanja Gayk]

Johannes Schneider said...

Post by Johannes Schneider
Hallo,
wahrscheinlich werde ich das Vergüngen haben, mit ein paar 16jährigen
einen Java-Kurs machen zu dürfen.
Ich möchte sie nicht unbedingt zu Hardcore-Java-Freaks machen sondern
vor allem die "Denkweise" eines Programmierers nahelegen. Und vor allem
Spass vermitteln sich hinter ein Problem zu klemmen und es zu lösen...
Jetzt suche ich eine Umgebung, die das spielerisch unterstützt und vor
allem schnelle Erfolge bietet.
Ich bin unter anderem auf folgendes gestoßen - bin aber noch nicht so
zufrieden. Vielleicht hat einer einen Tipp.

Hamster und Logo habe ich mir rein getan, als ich 13 war. Mit 16 hab ich
auf nem C64 Assembler programmiert. Ein 16-jähriger ist mit Hamster
sicher ein wenig unterfordert, sofern er Interesse an der Materie hat.

Habe mal einen passenden Spruch gelesen:
"Als Lehrer sollte man nie mit seinen Pascal-Kenntnissen protzen, denn
schon bald wird einem ein 11 jähriger über den Weg rennen, der schon
seit 4 Jahren Assembler programmiert."

IMO ist der beste Weg etwas einfaches zu machen, was viel Effekt hat,
also visuellen Effekt, Formeln ausrechnen ist und war immer sehr
langweilig. Von daher ist Logo ja schon immer ganz süß gewesen.

Wenn wir von einem Javakurs reden (frage: wie lange soll er dauern?),
dann versuch eine einfache Darstellung zu machen:
Ein Diagramm von Punkten, z.B.: da hast du z.B. mindestens die Punkte
als Objekte, also ist etwas Objektorientiert drin.

Für ein Erfolgserlebnis leg einen Satz Demodaten an, der z.B. auf der
XZ-Ebene einen Smiley zeigt, aber auf der XY-Ebene relativ
unübersichtlich wirkt. Wer das zuerst raus bekommt, was sich dahinter
versteckt, bekommt irgend eine Kleinigkeit.

Du kannst ja ein Gerüst vorgeben, so dass der Schüler im Grunde nur noch
die paintComponent(Graphics g) Methode implemetieren muss.

Gruß,
-Wanja-

[Johannes Schneider]

Post by Wanja Gayk
Wenn wir von einem Javakurs reden (frage: wie lange soll er dauern?),

Ist im Rahmen einer AG. Von daher nicht besonders "intensiv". Maximal
1,5h pro Woche. Jetzt mal ein halbes Jahr - eventuell länger...

Post by Wanja Gayk
Ein Diagramm von Punkten, z.B.: da hast du z.B. mindestens die Punkte
als Objekte, also ist etwas Objektorientiert drin.
Für ein Erfolgserlebnis leg einen Satz Demodaten an, der z.B. auf der
XZ-Ebene einen Smiley zeigt, aber auf der XY-Ebene relativ
unübersichtlich wirkt. Wer das zuerst raus bekommt, was sich dahinter
versteckt, bekommt irgend eine Kleinigkeit.
Du kannst ja ein Gerüst vorgeben, so dass der Schüler im Grunde nur noch
die paintComponent(Graphics g) Methode implemetieren muss.

Hört sich sehr gut an. Danke für die Idee. Werd ich mir auf jeden Fall
merken...

Was ich so bissl erreichen möchte (bin aber noch sehr unbeleckt im
pädagogischen Bereich), ist die Unabhänigkeit von gestellten Aufgaben.
Mir wäre es am liebsten, wenn sich die Aufgaben "selbst stellen" würden.
Wenn quasi ein höheres Ziel durch immer weitere und bessere Lösungen
perfektioniert werden kann... Ich habe die Hoffnung, dass sich da so
eine Art Selbstläufer entwickeln könnte.
Aber natürlich ist dies erst für "spätere" Zeitpunkte realisitsch, wenn
wenigstens ein wenig Programmier-Erfahrung vorhanden ist...


mfg

Johannes Schneider

[HaJo Rode]

Hallo Johannes,

hast du dir schon mal Jumli angeschaut?

http://www.jumli.de/index.html

Es bietet u.a. auch noch UML

LG

HaJo

Post by Johannes Schneider
Hallo,
wahrscheinlich werde ich das Vergüngen haben, mit ein paar 16jährigen
einen Java-Kurs machen zu dürfen.
Ich möchte sie nicht unbedingt zu Hardcore-Java-Freaks machen sondern
vor allem die "Denkweise" eines Programmierers nahelegen. Und vor allem
Spass vermitteln sich hinter ein Problem zu klemmen und es zu lösen...
Jetzt suche ich eine Umgebung, die das spielerisch unterstützt und vor
allem schnelle Erfolge bietet.
Ich bin unter anderem auf folgendes gestoßen - bin aber noch nicht so
zufrieden. Vielleicht hat einer einen Tipp.
------------------
http://www-is.informatik.uni-oldenburg.de/~dibo/hamster/index.html
Sehr schön gemacht, eventuell sogar für jüngere geeignet? Allerdings
stört mich, dass man auf den eingebauten Editor angewiesen ist, der
nicht direkt Java-Klassen schreibt, sondern eine Art "Zwischenforma",
welches dann in .java-Files umgewandelt wird.
Ich würde aber gerne irgendwann mit Eclipse weitermachen... Einfach
wegen der Code Complition und der Einbindung der Doku etc.
---------
http://robocode.alphaworks.ibm.com/home/home.html
Ist persönlich mein Favorit. Betont den Wettbewerb und ist somit wohl
motivationsfördernd.
Eclipse ist ohne Einschränkung nutzbar - grafisch sieht es sehr gut aus,
es gibt viele "Gegner" im Internet zum Download.
Eigentlich perfekt - nur der etwas martialische Hintergrund hält mich
momentan noch davon ab... Killerspiele sind an Schulen nunmal sehr
schlecht angesehen ;).
Außerdem scheint das Projekt "tot" zu sein...
mfg
Johannes Schneider

[Johannes Schneider]

Post by HaJo Rode
hast du dir schon mal Jumli angeschaut?
http://www.jumli.de/index.html
Es bietet u.a. auch noch UML

Hallo,

danke für den Tipp. Scheint ja in die Richtung von BlueJ zu gehen. Hast
du Jumli schon mal (erfolgreich) eingesetzt?


Johannes Schneider

[Markus L. Dechert]

Post by Johannes Schneider
Hallo,

Hallo Johannes,

Post by Johannes Schneider
wahrscheinlich werde ich das Vergüngen haben, mit ein paar 16jährigen
einen Java-Kurs machen zu dürfen.
Ich möchte sie nicht unbedingt zu Hardcore-Java-Freaks machen sondern
vor allem die "Denkweise" eines Programmierers nahelegen. Und vor allem
Spass vermitteln sich hinter ein Problem zu klemmen und es zu lösen...
Jetzt suche ich eine Umgebung, die das spielerisch unterstützt und vor
allem schnelle Erfolge bietet.

ich wurde in Java über Karel J. Robot eingeführt. Material dazu findest
du unter
http://member.melbpc.org.au/~tgosbell/karel/
wobei besonders der Link
http://member.melbpc.org.au/~tgosbell/articles/karel-intro/environment/
in Bezug auf die BlueJ-Geschichte interessant sein dürfte (hab ihn nicht
gelesen.) Die Veranstalter damals haben eigene Modifikationen
vorgenommen und das Zeug auf
http://www.st.informatik.tu-darmstadt.de:8080/lehre/ws01/inf1/karelj/welcome.html
gelegt. Am Ende des Semesters haben wir für diese Sprache einen
Interpreter (ja in Java :-]) geschrieben, war sehr spaßig.

[snip]

Post by Johannes Schneider
mfg
Johannes Schneider

Gruß
Markus

[Jonathan Heinen]

Hallo Johannes,

also ich habe nicht mit 16 Assemlbler programmiert und habe dann erst mit 22
notgedrungen an der Uni meine ersten Erfahrungen gemacht, die jetzt nicht
gerade so was wie Begeisterung ausgelöst haben *G* =)

Also ich würde gerade am Anfang den Hamster nehmen! Und ich finde auch mit
16 kann das für völlig Unerfahrene (und ich denke an die richtet sich deine
AG) schon sehr anspruchsvoll sein! ... Ich hab damals in der schule Pascal
programmiert mit Niki dem Roboter! .. Wusstest du das man das einsteiger
Labyrinth mit rekursion bestens in wenigen Zeilen bewältigen kann?

Naja tut ja nix zur Sache =) Auf jeden Fall finde ich eignet sich so etwas
am besten um zu zeigen was eine Funktion/Methode ist und was Rekursionen
sind (Niki der Roboter ist es schuld das ich am liebsten alles rekursiv
machen würde =) ) und uach andere konzepte die für Einsteiger durchaus sehr
interessant sind lassen sich hier gut veranschaulichen und vor allem auch
einfach umsetzen, wenn man noch nicht weiß was eine Klasse ist und was das
ganze cahos über der main-Methode eigentlich soll!

Haben deine Schüler nach einigem erschnuppern den Hamster wirklich im Griff
und können vielleicht sogar schon ohne probs so ne rekursion entwickeln (ich
weiß noch mir ist darüber früher immer der Kopf heiß gelaufen ...), dann
kannst du ja immer noch überlegen was anstehen könnte? .. Vielleicht
versuchst du dann an einfachen Beispielen zu zeigen wie man objektorientiert
programmiert und wenn das auch sitzt sollte es kein Problem sein sie in die
Gui-programmierung einzuweihen und dann schreibt ihr ein kleines Spielchen
wie z.B. Tetris oder Worms? ... Ich denke so was hätte für mich den größten
Anreiz gehabt!
Hier könnte man dann, bevor man loslegt, auch zusammen überlegen, wie man
die einzelnen Objekte am besten durch Klassen beschreibt und ein paar
Diagramme malen ... vielleicht schreibt auch jeder nur einen Teil/ein paar
Klassen und ihr versucht es am Ende alles zusammen zufügen?

Hmm .. =) ...

Auf jeden Fall wünsche ich euch viel Spass =)

jonathan

[Johannes Schneider]

Post by Jonathan Heinen
also ich habe nicht mit 16 Assemlbler programmiert und habe dann erst mit 22
notgedrungen an der Uni meine ersten Erfahrungen gemacht, die jetzt nicht
gerade so was wie Begeisterung ausgelöst haben *G* =)

Dann werde ich mir deine Ratschläge sehr zu Herzen nehmen. In der Tat
werden wohl die wenigsten in der AG
"Bereits-in-der-Wiege-Assembler-Könner" sein. ;)

Post by Jonathan Heinen
Also ich würde gerade am Anfang den Hamster nehmen! Und ich finde auch mit
16 kann das für völlig Unerfahrene (und ich denke an die richtet sich deine
AG) schon sehr anspruchsvoll sein! ... Ich hab damals in der schule Pascal
programmiert mit Niki dem Roboter! .. Wusstest du das man das einsteiger
Labyrinth mit rekursion bestens in wenigen Zeilen bewältigen kann?

Mannomann - jetzt entwicklet sich hier die gleiche Diskussion wie in den
anderen Threads ;). Rekursion, Rekursion, Rekursion ;). Ich werde mich
jetzt hinsetzen, mein aktuelles Projekt durchsuchen und überprüfen, wo
überall Rekursion vorkommt... ;)

Aber inzwischen bin ich überzeugt, mit dem Hamster anzufangen - auch
wenn es eventuell *zu* einfach sein sollte...

Post by Jonathan Heinen
Haben deine Schüler nach einigem erschnuppern den Hamster wirklich im Griff
und können vielleicht sogar schon ohne probs so ne rekursion entwickeln (ich
weiß noch mir ist darüber früher immer der Kopf heiß gelaufen ...), dann
kannst du ja immer noch überlegen was anstehen könnte? .. Vielleicht
versuchst du dann an einfachen Beispielen zu zeigen wie man objektorientiert
programmiert

Naja - das tut mir eigentlich im Herzen weh... Ich habe genug Kollegen
gehesen, die wirkliche Cracks in prozedurealen Sprachen sind, denen aber
nie der Sprung in die Objektorientierung gelungen ist...
Deshalb werde ich mal versuchen, möglichst schnell auf OO umzuschwenken...

Post by Jonathan Heinen
und wenn das auch sitzt sollte es kein Problem sein sie in die
Gui-programmierung einzuweihen und dann schreibt ihr ein kleines Spielchen
wie z.B. Tetris oder Worms? ... Ich denke so was hätte für mich den größten
Anreiz gehabt!

Jo. Das wäre dann natürlich ein Leckerli... Ich habe da nur Sorgen, dass
das zu umfangreich wird und nicht beendet werden kann. Was dann ja sowas
wie den Worst Case darstellen würde. Andererseits wären sie dann mit
einer "modernen" Projekt-Planung praktisch vertraut worden... ;)

Post by Jonathan Heinen
Hier könnte man dann, bevor man loslegt, auch zusammen überlegen, wie man
die einzelnen Objekte am besten durch Klassen beschreibt und ein paar
Diagramme malen ... vielleicht schreibt auch jeder nur einen Teil/ein paar
Klassen und ihr versucht es am Ende alles zusammen zufügen?
Hmm .. =) ...
Auf jeden Fall wünsche ich euch viel Spass =)
jonathan

Jo danke auf jeden Fall ;). Du hast mich jetzt endgültig zum "einfachen
Hamster" bekehrt...


Johannes Schneider

[Wanja Gayk]

Johannes Schneider said...

Post by Johannes Schneider

Post by Jonathan Heinen
also ich habe nicht mit 16 Assemlbler programmiert

Schade, hast was verpasst! Der C64 war ein lustg Gerät :-)

Post by Johannes Schneider

Post by Jonathan Heinen
und habe dann erst mit 22
notgedrungen an der Uni meine ersten Erfahrungen gemacht, die jetzt nicht
gerade so was wie Begeisterung ausgelöst haben *G* =)

Dann werde ich mir deine Ratschläge sehr zu Herzen nehmen. In der Tat
werden wohl die wenigsten in der AG
"Bereits-in-der-Wiege-Assembler-Könner" sein. ;)

:-)
Darum ging's mir nicht. Ich wollte eigentlich nur damit sagen, dass 16-
Jährige oft unterschätzt werden.
Maßgeblich ist IMO nur das Interesse an der Materie und wie viel
Fortschritt man macht.
Ich fand Logo und Hamster anfangs ja auch ganz nett, aber nach ein paar
StundenStunden, wenn man's dann so ungefähr geschnallt hat und merkt,
dass ausser rumrennen und Körnchen fressen nicht mehr viel geht (klar,
Labyrinth und so, ist auch nicht uninsteressant), dann verliert man IMO
schnell das Interesse.

Bei deinen 1,5 Stunden pro Woche ist aber auch kaum ein größeres Ding
drin.
Ich hatte auf der Schule damals die Möglichkeit in der Mittagspause (es
war eine Ganztagsschule) irgendwelche AGs zu besuchen, das war dann
schon besser, weil man jeden Tag eine Stunde arbeiten konnte.
Bei 1,5 Stunden die Woche hat man nächste Woche ja schon fast vergessen,
was man die vorige Woche gemacht hat, leider.

Post by Johannes Schneider
Mannomann - jetzt entwicklet sich hier die gleiche Diskussion wie in den
anderen Threads ;). Rekursion, Rekursion, Rekursion ;). Ich werde mich
jetzt hinsetzen, mein aktuelles Projekt durchsuchen und überprüfen, wo
überall Rekursion vorkommt... ;)

:-)
Ich denke bevor man die Schüler mit Rekursion quält (die schon eine
eigene Denkweise erfordert), würde ich erst einmal ganz normale
Iterative Sachen basteln lassen.

Post by Johannes Schneider
Naja - das tut mir eigentlich im Herzen weh... Ich habe genug Kollegen
gehesen, die wirkliche Cracks in prozedurealen Sprachen sind, denen aber
nie der Sprung in die Objektorientierung gelungen ist...
Deshalb werde ich mal versuchen, möglichst schnell auf OO umzuschwenken...

Ack. Ich fand den Umstieg von Assembler zu Java hammerhart, ich musste
mich Wochenlang quälen, bis ich das OO verinnerlicht hatte.
Ich halte es für eine gute Idee, wenn du schnell, bzw. direkt mit OO
anfängst.
Ich habe meinen Tutoriums-Teilnehmern einmal eiskalt verboten irgendwo,
ausser in der main-Methode das Wort "static" zu benutzen.
Das war zwar hart für sie, aber es hat gewirkt :-).

Post by Johannes Schneider

Post by Jonathan Heinen
und wenn das auch sitzt sollte es kein Problem sein sie in die
Gui-programmierung einzuweihen und dann schreibt ihr ein kleines Spielchen
wie z.B. Tetris oder Worms? ... Ich denke so was hätte für mich den größten
Anreiz gehabt!

Jo. Das wäre dann natürlich ein Leckerli... Ich habe da nur Sorgen, dass
das zu umfangreich wird und nicht beendet werden kann.

Leider ist das mit der Kollisionsabfrage in Java nicht ganz so leicht
wie mit den Sprites auf dem C64...

Aber als Tutor habe ich 2 Aufgaben für ein Spiel in Java mitbekommen,
die ich eigentlich sehr nett fand:

a) Memory

b) Dalli Klick (falls das noch einer kennt: es wird immer ein Stückchen
von einem Bild aufgedeckt und wenn einer Stoppt, darf er sagen was es
ist, wen er richtig liegt, bekommt er so viele Punkte, wie verdeckte
Teile im Bild sind.

Beide Aufgaben sind relativ gut zu schaffen.

Gruß,
-Wanja-
ps: ich kenne deinen Hamster nicht. Der, den ich programmierte lief noch
auf alten Eumel/Elan-Systemen mit 8-Zoll Schlabberscheiben und
Bernsteinmonitor :-).

[Paul Ebermann]

Post by Wanja Gayk
Ich fand Logo und Hamster anfangs ja auch ganz nett, aber nach ein paar
StundenStunden, wenn man's dann so ungefähr geschnallt hat und merkt,
dass ausser rumrennen und Körnchen fressen nicht mehr viel geht (klar,
Labyrinth und so, ist auch nicht uninsteressant), dann verliert man IMO
schnell das Interesse.

Wenn das Labyrinth groß genug ist, kann man damit eine
Turing-Maschine programmieren :-)


Paul

[Jonathan Heinen]

Post by Wanja Gayk
Leider ist das mit der Kollisionsabfrage in Java nicht ganz so leicht
wie mit den Sprites auf dem C64...

Hmm also beide Spiele kann man gut auf arrays laufen lassen und da ist die
Kollisionsabfrage nun wirklich einfach?
Aber viel arebit ist es sicherlich trotzdem noch =) ... Bei Tetris ist die
größte Herausforderung sich etwas einfallen tzu lassen, um das drehen der
Steine schön hinzubekommen!

Post by Wanja Gayk
Aber als Tutor habe ich 2 Aufgaben für ein Spiel in Java mitbekommen,
a) Memory
b) Dalli Klick (falls das noch einer kennt: es wird immer ein Stückchen
von einem Bild aufgedeckt und wenn einer Stoppt, darf er sagen was es
ist, wen er richtig liegt, bekommt er so viele Punkte, wie verdeckte
Teile im Bild sind.
Beide Aufgaben sind relativ gut zu schaffen.

Memory kann noch ziemlich nett sein! Aber Dalli Klick klingt was langweilig?
... und sollte aber mit swing ruck zuck programmiert sein? ... Naja =)

Berichte auf jeden Fall mal so ein wenig von deinen Erfahrungen =)

marsjo!

[Wanja Gayk]

Jonathan Heinen said...

Post by Jonathan Heinen

Post by Wanja Gayk
Aber als Tutor habe ich 2 Aufgaben für ein Spiel in Java mitbekommen,
a) Memory
b) Dalli Klick (falls das noch einer kennt: es wird immer ein Stückchen
von einem Bild aufgedeckt und wenn einer Stoppt, darf er sagen was es
ist, wen er richtig liegt, bekommt er so viele Punkte, wie verdeckte
Teile im Bild sind.
Beide Aufgaben sind relativ gut zu schaffen.

Memory kann noch ziemlich nett sein!

ist auch einfach zu machen:
Du nimmst ein GridLayout, füllst eine ArrayList mit Bilderpaaren, rufst
einmal shuffle auf der ArrayList auf und fügst alle Rückseiten der
Bilder in dein Panel ein.
Nun brauchst du nur noch einen Mouselistener, und einen Boolean für
jedes Rechteck.
Du klickst zwei mal. Bei jedem klick wird das enstprechende bild
aufgedeckt, war es schon aufegedeckt, wird er klick ignoriert.
Sind die aufgedeckten Bilder gleich, werden für beide Bilder die
booleans stellvertretend für "gelöst" auf true gesetzt, ansonsten werden
die beiden zurück auf false gesetzt.

Sind alle booleans "true" ist das Spiel gelöst.

So ist ganz grob der Ablauf.

Post by Jonathan Heinen
Aber Dalli Klick klingt was langweilig?
... und sollte aber mit swing ruck zuck programmiert sein? ... Naja =)

Ja, ist es.
Du brauchst nur 2 JPanels: eins, welches das Bild hält uns eins, welches
nicht opak (sprich: durchsichtig) ist und direkt darüberliegt, als
Maske.

Dann erzeugst du ein Rechteck, mit den Maßen der Spiefläche, dieses
teilst du rekursiv in eine gewünschte Anzhl anderer Rechtecke (oder
dreiecke, kannst du machen wie du willst), die allesamt in einer
Arraylist landen.

In der PaintCoponent-methode des durchsichtigen Panels malst du nun alle
Rechtecke aus der ArrayList mit schwarzer farbe.

Nun brauchst du nur einen Timer, der einmal alle x Sekunden ein Element
aus der ArrayList nimmt und repaint() aufruft.

Ist die ArrayList leer, ist das Bild aufgedeckt, so einfach ist das :-).

Gruß,
-Wanja-

[Stefan Matthias Aust]

Post by Jonathan Heinen
Memory kann noch ziemlich nett sein! Aber Dalli Klick klingt was langweilig?
... und sollte aber mit swing ruck zuck programmiert sein? ... Naja =)

IMHO sind beides keine guten Beispiele für etwas, für das mit OOA/OOD
und eben dann objektorientierte Programmierung machen kann.

Was meiner Erfahrung nach sehr gut geht, ist ein Textadventure. Das hat
auch den Vorteil, dass man auf keine komplexen Bibliotheken wie Swing
angewiesen ist.

In so einem Adventure gibt es Räume, Ausgänge, Gegenstände, Befehle,
einen Befehlsausführer und ein Person. Befehle werden erkannt,
ausgeführt und führen so Methoden der Objekte aus, die dann deren
Zustände ändern.


bye

[Wanja Gayk]

Stefan Matthias Aust said...

Post by Stefan Matthias Aust

Post by Jonathan Heinen
Memory kann noch ziemlich nett sein! Aber Dalli Klick klingt was langweilig?
... und sollte aber mit swing ruck zuck programmiert sein? ... Naja =)

IMHO sind beides keine guten Beispiele für etwas, für das mit OOA/OOD
und eben dann objektorientierte Programmierung machen kann.

Es sind vor allem einfache Beispiele, die je nach implementation mehr
oder weniger OO sind.
Wenn du jedes Rechteck als Objekt in eine ArrayList schiebst, und die
Objekte der ArrayList hintereinander malst, ist das eindeutig
Objektorientiert, insbesondere, wenn du jedem, Rechteck eine eigene draw
(Grahphics g) Method verpasst.

Post by Stefan Matthias Aust
Was meiner Erfahrung nach sehr gut geht, ist ein Textadventure. Das hat
auch den Vorteil, dass man auf keine komplexen Bibliotheken wie Swing
angewiesen ist.

Ein Textadventure ist ein besseres OO-Beispiel? Ein sehr einfaches
Textadventure schreibt man mit einem gigantischen if/then/else
Konstrukt.

Post by Stefan Matthias Aust
In so einem Adventure gibt es Räume, Ausgänge, Gegenstände, Befehle,
einen Befehlsausführer und ein Person.

Für eine Schülergruppe mit 1,5 Stunden pro Woche ist das sicher
overkill.

Gruß,
-Wanja-

[Stefan Matthias Aust]

Post by Wanja Gayk
Ich fand Logo und Hamster anfangs ja auch ganz nett, aber nach ein paar
StundenStunden, wenn man's dann so ungefähr geschnallt hat und merkt,

Logo ist mehr als einfaches Linien-Zeichnen. Als Lisp-Dialekt ist es
z.B. sehr gut geeignet, rekursive Algorithmen zu erklären... auch
symbolische Datenverarbeitung ist dank Listen und
Listenverarbeitungsfunktionen möglich.

Post by Wanja Gayk
Ich denke bevor man die Schüler mit Rekursion quält (die schon eine
eigene Denkweise erfordert), würde ich erst einmal ganz normale
Iterative Sachen basteln lassen.

Nein, die normale Denkweise sind Rekursionen. Bevor man's falsch
beibringt und es ihnen damit später schwerer macht, dann lieber gleich
richtig.

Post by Wanja Gayk
Ich habe meinen Tutoriums-Teilnehmern einmal eiskalt verboten irgendwo,
ausser in der main-Methode das Wort "static" zu benutzen.
Das war zwar hart für sie, aber es hat gewirkt :-).

Das ist ein gutes Vorgehen.

Post by Wanja Gayk
b) Dalli Klick (falls das noch einer kennt: es wird immer ein Stückchen
von einem Bild aufgedeckt und wenn einer Stoppt, darf er sagen was es
ist, wen er richtig liegt, bekommt er so viele Punkte, wie verdeckte
Teile im Bild sind.

Hans Rosenthal ist 1986 gestorben, da war ein(e) 16-jährige(r) doch noch
gar nicht geboren :)


bye

[Wanja Gayk]

Stefan Matthias Aust said...

Post by Stefan Matthias Aust

Post by Wanja Gayk
b) Dalli Klick (falls das noch einer kennt: es wird immer ein Stückchen
von einem Bild aufgedeckt und wenn einer Stoppt, darf er sagen was es
ist, wen er richtig liegt, bekommt er so viele Punkte, wie verdeckte
Teile im Bild sind.

Hans Rosenthal ist 1986 gestorben, da war ein(e) 16-jährige(r) doch noch
gar nicht geboren :)

:-)
Das Spiel ist trotzdem Legendär
:-)

Gruß,
-Wanja-

[Alexander Kaiser]

Post by Johannes Schneider
Hallo,
wahrscheinlich werde ich das Vergüngen haben, mit ein paar 16jährigen
einen Java-Kurs machen zu dürfen.
Ich möchte sie nicht unbedingt zu Hardcore-Java-Freaks machen sondern
vor allem die "Denkweise" eines Programmierers nahelegen. Und vor allem
Spass vermitteln sich hinter ein Problem zu klemmen und es zu lösen...
Jetzt suche ich eine Umgebung, die das spielerisch unterstützt und vor
allem schnelle Erfolge bietet.
Ich bin unter anderem auf folgendes gestoßen - bin aber noch nicht so
zufrieden. Vielleicht hat einer einen Tipp.

Bei der Uni Köln gibt es auch noch einen Hamster (siehe
http://www.uni-koeln.de/rrzk/kurse/unterlagen/java/einf/index.htm). Hier
kann man mit einer beliebigen IDE Java-Code schreiben, um den Hamster
dann verschiedene Aufgaben lösen zu lassen. Aus einem HamsterManager
kann zu jeder Aufgabe bequem die gewünschte IDE und der Hamster
gestartet werden. Im Internet scheint das aber immer noch nicht wirklich
ausführlich dokumentiert zu sein. Bei Interesse könntest du dich evtl.
an Michael Holst (Adresse steht auf der Seite) wenden.

Dann kenne ich noch den Marienkäfer Kara, bei dem ein ähnliches Konzept
verfolgt wird:
http://www.educeth.ch/informatik/karatojava/javakara/index.html

Tschüs,
Alexander Kaiser