Un­ter­richts­ver­lauf

Hin­ter­grund

Ziel die­ser Ein­heit ist es, dass die Schü­le­rin­nen und Schü­lern eine tex­tu­el­le Pro­gram­mier­spra­che er­ler­nen. Dabei wer­den die in der block­ba­sier­ten Pro­gram­mier­spra­che ein­ge­führ­ten Kon­zep­te auf die tex­tu­el­le Pro­gram­mier­spra­che über­tra­gen.

Pro­gram­mier­spra­che / Pro­gram­mier­um­ge­bung

Grund­sätz­lich schreibt der Bil­dungs­plan weder eine be­stimm­te Pro­gram­mier­spra­che noch eine be­stimm­te Pro­gram­mier­um­ge­bung vor. Die Wahl bleibt dem Leh­rer über­las­sen und soll­te nach di­dak­ti­schen Ge­sichts­punk­ten ge­fällt wer­den:

• Ist ein ein­fa­cher Ein­stieg ohne viel Over­head mög­lich?
• Wird die Suche nach Feh­lern gut durch An­zei­ge von Syn­tax­feh­lern und einen guten De­bug­ger un­ter­stützt? Wird der Quell­text struk­tu­riert dar­ge­stellt?
• Trägt die Pro­gram­mier­spra­che/Pro­gram­mier­um­ge­bung lang­fris­tig, d.h. kann sie auch in den kom­men­den Schul­jah­ren ein­ge­setzt wer­den?
• Gibt es an­de­re di­dak­ti­sche Tools für die ein­ge­führ­te Pro­gram­mier­spra­che, die im wei­te­ren Un­ter­richts­ver­lauf hilf­reich sein kön­nen?

In die­sem Un­ter­richts­vor­schlag kommt die Pro­gram­mier­spra­che Java zum Ein­satz, da die Zahl der di­dak­ti­schen Hilfs­mit­tel für Java zur Zeit am größ­ten ist. Java kann als ob­jekt­ori­en­tier­te Pro­gram­mier­spra­che bis zum Ab­itur fort­ge­führt wer­den.

Einen Über­blick über die schon be­kann­ten oder jetzt hin­zu­kom­men­den Kon­troll­struk­tu­ren in Java im Ver­gleich zum MIT App In­ven­tor 2 oder zu Scratch bie­ten die bei­den Do­ku­men­te im Ord­ner Hin­ter­grund: 03_al­g_ver­gleich_ai_ja­va.odt bzw. 03_al­g_ver­gleich_­scratch_ja­va.odt. Sie sind für Sie als Lehr­kraft ge­dacht, kön­nen aber auch am Ende der Ein­heit den Schü­le­rin­nen und Schü­lern zur Ver­fü­gung ge­stellt wer­den.

Um den Ein­stieg zu er­leich­tern, schlägt die­ser Un­ter­richts­gang vor, gra­phi­sche Aus­ga­ben (op­ti­sche Täu­schun­gen und Bal­ken- und XY-Dia­gram­me) zu er­zeu­gen, da man dort die Wir­kung der ein­ge­setz­ten Be­feh­le di­rekt sieht. Um gra­phi­sche Aus­ga­ben zu er­zeu­gen, eig­net sich die Java-Va­ri­an­te Pro­ces­sing¹, die eine Viel­zahl von Zei­chen­be­feh­len mit­bringt. Er­gänzt wird dies durch ein­fach zu ver­wen­den­de Bi­blio­the­ken für den Zu­griff auf CSV- und XML-Da­tei­en. Es ist in Pro­ces­sing ohne Rah­men­pro­gramm, ohne De­kla­ra­ti­on von Klas­sen und ohne auf­wän­di­ge De­fi­ni­ti­on einer GUI mög­lich, auf einer Zei­chen­flä­che zu zeich­nen. Tex­ter­gän­zun­gen (Strg+Leer­zei­chen) las­sen sich in den Ein­stel­lun­gen ak­ti­vie­ren. Das Ani­mie­ren von Al­go­rith­men ist sehr ein­fach. Der Ein­stieg fällt den Schü­le­rin­nen und Schü­lern daher sehr leicht². Lei­der ist die Un­ter­stüt­zung der Schü­ler durch Syn­tax­her­vor­he­bung von Schlei­fen und Ent­schei­dun­gen und den ein­fa­chen ge­hal­te­nen De­bug­ger nicht so ef­fek­tiv wie bei an­de­ren Pro­gram­mier­um­ge­bun­gen. GUIs las­sen sich zwar mit zu­sätz­li­chen Tools er­zeu­gen, sind aber keine voll­wer­ti­gen Swing oder Ja­vaFX-Ober­flä­chen.

Als zwei­te Va­ri­an­te ist es mög­lich, Green­foot³ ein­zu­set­zen. Durch eine spe­zi­el­le Bi­blio­thek kön­nen viele der in Pro­ces­sing zur Ver­fü­gung ste­hen­den Be­feh­le auch in Green­foot ein­ge­setzt wer­den. Dort wird eine von Actor ab­ge­lei­te­te Zei­chen­flä­che ein­ge­setzt, deren Bild durch die Zei­chen­be­feh­le ver­än­dert wer­den kann. Schön ist, dass man durch das Kon­text­me­nü der Zei­chen­flä­che di­rekt Zei­chen­be­feh­le geben und deren Wir­kung be­ob­ach­ten kann. So kann man die Be­feh­le di­rekt aus­pro­bie­ren. Text­edi­tor und De­bug­ger un­ter­stüt­zen die Schü­le­rin­nen und Schü­ler ef­fek­tiv bei der Ar­beit. Nach­tei­lig ist, dass das Zeich­nen sehr lang­sam ist, da jedes Mal das Bild des Ac­tors ver­än­dert wer­den muss. Dies bremst die Aus­füh­rung der Al­go­rith­men bei grö­ße­ren Da­ten­men­gen (ca. 10000 Da­ten­sät­ze beim XY-Dia­gramm) er­heb­lich aus. Green­foot bie­tet keine Mög­lich­keit, GUIs zu er­zeu­gen, da das dem Kon­zept von Green­foot wi­der­spricht. Für die Er­zeu­gung einer gra­phi­schen Ober­flä­che (vgl. IMP Klas­se 10) muss daher zu einem an­de­ren Tool ge­wech­selt wer­den.

Die drit­te Mög­lich­keit ist der Ein­satz des Java-Edi­tors⁴ von Ger­hard Röh­ner. Der Java-Edi­tor bie­tet eine gute Un­ter­stüt­zung der Schü­le­rin­nen und Schü­ler durch farb­li­che Her­vor­he­bung von Schlei­fen und Ent­schei­dun­gen. Auch der De­bug­ger kann ef­fek­tiv ein­ge­setzt wer­den. Mit dem Java-Edi­tor kön­nen sehr gut GUIs er­zeugt wer­den (vgl. IMP Klas­se 10). Auch die Dar­stel­lung von Klas­sen und Ob­jek­ten und das di­rek­te Ar­bei­ten in der UML-Dar­stel­lung ist über­zeu­gend (ähn­lich wie bei BlueJ; vgl. Bil­dungs­plan Kurs­stu­fe). Durch eine ge­eig­ne­te Bi­blio­thek ste­hen auch hier viele der Pro­ces­sing-Be­feh­le zur Ver­fü­gung. Der Nach­teil ist, dass für die An­zei­ge eines gra­phi­schen Aus­ga­be­fens­ters eine GUI not­wen­dig ist. Diese kann den Schü­lern zwar vor­ge­ge­ben wer­den, so dass sie sie nicht selbst er­stel­len müs­sen, er­höht aber die An­zahl an Java-Klas­sen selbst für ein ein­fa­ches Pro­gramm. Die Ar­beit der Schü­le­rin­nen und Schü­ler be­schränkt sich aber auf eine ein­zi­ge über­sicht­li­che Klas­se. Etwas kom­pli­zier­ter ist die Ani­ma­ti­on von Al­go­rith­men, da hier die Pro­gram­mie­rung von Threads not­wen­dig ist, um eine Ak­tua­li­sie­rung der Aus­ga­be wäh­rend der Aus­füh­rung des selbst pro­gram­mier­ten Al­go­rith­mus zu er­mög­li­chen. Auch die­ses muss den Schü­le­rin­nen und Schü­lern vor­ge­ge­ben wer­den.

Da kei­nes der drei Tools alle ge­wünsch­ten Ei­gen­schaf­ten auf sich ver­eint, bleibt die Wahl Ihnen als Lehr­kraft über­las­sen. Die vor­lie­gen­den Ma­te­ria­li­en sind so ge­stal­tet, dass die Ar­beits­blät­ter für alle drei Pro­gram­mier­um­ge­bun­gen ein­ge­setzt wer­den kön­nen. Die Vor­la­gen, mit denen die Schü­le­rin­nen und Schü­ler ar­bei­ten sol­len, ste­hen für alle drei Um­ge­bun­gen be­reit. Die we­sent­li­chen In­hal­te der Lö­sun­gen un­ter­schei­den sich dabei nicht. Sie müs­sen den Schü­lern aber den Um­gang mit der Pro­gram­mier­um­ge­bung bei­brin­gen. Dies wird nicht auf den Ar­beits­blät­tern er­klärt.

Nut­zung der Pro­gram­mier­um­ge­bun­gen

Pro­ces­sing: Hier muss le­dig­lich die ent­spre­chen­de pde-Datei in Pro­ces­sing ge­öff­net wer­den. Glo­ba­le Va­ria­blen/At­tri­bu­te wer­den vor allen Me­tho­den de­kla­riert. Die Me­tho­de setup() wird au­to­ma­tisch aus­ge­führt und soll­te die Me­tho­de zum Zeich­nen auf­ru­fen. Al­ter­na­tiv kann die Zei­chen­me­tho­de aus der vor­de­fi­nier­ten Me­tho­de draw() auf­ge­ru­fen wer­den. Diese wird von Pro­ces­sing in re­gel­mä­ßi­gen Ab­stän­den aus­ge­führt (vgl. Ani­ma­tio­nen).

Schrift­ar­ten müs­sen (vom Leh­rer) vorab ge­ne­riert wer­den (Menü Tools) und lie­gen da­nach als .vlw-Datei in dem Ver­zeich­nis data. Sie wer­den am sinn­volls­ten im Setup mit dem Be­fehl loadFont("KleineSchrift.vlw") ge­la­den.

Green­foot: Öff­nen Sie das Green­foot-Pro­jekt. Jede Auf­ga­be liegt in einem ei­ge­nen Ver­zeich­nis. Die Schü­le­rin­nen und Schü­ler müs­sen je­weils eine Un­ter­klas­se von Pic­tu­re­View­er be­ar­bei­ten. Glo­ba­le Va­ria­blen/At­tri­bu­te wer­den in­ner­halb der Klas­se vor allen Me­tho­den de­kla­riert. Der Kon­struk­tor wird au­to­ma­tisch aus­ge­führt und ruft die Me­tho­de zum Zeich­nen auf. Die Welt er­zeugt au­to­ma­tisch ein Ob­jekt der je­wei­li­gen Klas­se, so dass so­fort die Zei­chen­flä­che an­ge­zeigt wird.

Die Do­ku­men­ta­ti­on der Klas­sen Pic­tu­re, Pic­tu­re­View­er, Table, Ta­ble­Row, XML er­hält man in Green­foot am ein­fachs­ten, indem man den Quell­text öff­net und dann im Edi­tor rechts oben von "Quell­text" auf "Do­ku­men­ta­ti­on" um­schal­tet. Al­ter­na­tiv steht die Do­ku­men­ta­ti­on im Hin­ter­grund-Ord­ner als HTML-Da­tei­en be­reit.

Java-Edi­tor: Für die Nut­zung der Klas­sen Table, Ta­ble­Row und XML ist die Bi­blio­thek jdom-1.1.3.jar er­for­der­lich. Daher muss dem Java-Edi­tor mit­ge­teilt wer­den, dass man diese Bi­blio­thek be­nut­zen möch­te. Das macht man unter Menü Fens­ter → Kon­fi­gu­ra­ti­on → Java → In­ter­pre­ter: Class­Path-User. Dort wählt man die jdom-Bi­blio­thek als neue Jar-Datei aus.

Da­nach öff­nen Sie die zwei Da­tei­en XYGUI.​java und XY.​java (XY steht für den Namen der Auf­ga­be: z.B. Bal­ken­dia­gramm.java). Die GUI muss ge­öff­net sein, damit der Java-Edi­tor das Pro­jekt kor­rekt star­ten kann. An die­ser Datei müs­sen/dür­fen die Schü­le­rin­nen und Schü­ler nichts än­dern. Sie be­ar­bei­ten le­dig­lich die XY.​java, die eine Un­ter­klas­se von Pic­tu­re ist. Glo­ba­le Va­ria­blen/At­tri­bu­te wer­den in­ner­halb der Klas­se vor allen Me­tho­den de­kla­riert. Der Kon­struk­tor wird au­to­ma­tisch auf­ge­ru­fen und ruft die Me­tho­de zum Zeich­nen auf. Die GUI ent­hält einen But­ton mit dem ein Ob­jekt der je­wei­li­gen Klas­se er­zeugt und im Zei­chen­fens­ter an­ge­zeigt wird.

Die Do­ku­men­ta­ti­on der Klas­sen Pic­tu­re, Pic­tu­re­View­er, Table, Ta­ble­Row, XML er­hält man im Java-Edi­tor, indem man die Quell­tex­te alle öff­net und dann im Edi­tor Menü Start → Ja­va­Doc wählt. Da die Da­tei­en in UTF-8 For­mat vor­lie­gen, muss man vor­her noch unter Menü Fens­ter → Kon­fi­gu­ra­ti­on → Java → Pro­gram­me die Pa­ra­me­ter "-encoding UTF-8 -charset UTF-8 -docencoding UTF-8" er­gän­zen. Der Java-Edi­tor er­zeugt dann ein Un­ter­ver­zeich­nis "doc", das die Do­ku­men­ta­ti­on ent­hält. Al­ter­na­tiv steht die Do­ku­men­ta­ti­on im Hin­ter­grund-Ord­ner schon als HTML-Da­tei­en be­reit.

¹ Pro­gram­mier­um­ge­bung Pro­ces­sing: https://​pro­ces­sing.​org/(Stand: 07.02.2019)

² Pro­ces­sing lässt sich durch einen An­dro­id-Modus er­gän­zen. (Siehe 04_al­g_pro­ces­sin­g_an­dro­id.odt)

³ Pro­gram­mier­um­ge­bung Green­foot: https://​www.​green­foot.​org/​door (Stand: 07.02.2019)

⁴ Pro­gram­mier­um­ge­bung Java-Edi­tor: http://​ja­va­edi­tor.​org/​doku.​php (Stand 07.02.2019)

Hin­ter­grund und Un­ter­richts­ver­lauf: Her­un­ter­la­den [odt][2 MB]

Hin­ter­grund und Un­ter­richts­ver­lauf: Her­un­ter­la­den [pdf][380 KB]

Wei­ter zu Un­ter­richts­gang