Lehrzeit

Schule & Informatik

Kategorie: Aufgaben (Seite 1 von 33)

Programmieraufgabe 96

Processing hat sich in meinen Augen bislang als Erfolg gezeigt. Die Tatsache, dass die Schüler sofort eine sichtbare Reaktion bekommen motiviert sie mehr als vieles, was ich bisher versucht habe. Nachdem sie Processing ein wenig kennengelernt hatten und einen Ball automatisch im Fenster haben rumfliegen lassen war eine leicht fortgeschrittene Aufgabe das Programmieren eines Bildschirmschoners, wie er früher öfter zu sehen war.

Aufgabe

Erstelle mit Hilfe von Processing einen Bildschirmschoner, der wie folgt aussieht:

Der Ehrlichkeit halber muss ich aber dazu sagen, dass die Schüler nur eine dieser Linien selbst programmieren sollten. Ich habe dann das Einführen der zweiten Linie dazu genutzt, um das Definieren von Klassen zu erläutern. Dabei muss man allerdings etwas aufpassen, denn die gewünschte Klasse Linie muss innerhalb der Klasse Bildschirmschoner definiert sein, sonst kann Linie nicht die gewünschten Methoden von Processing direkt nutzen.

Weiter habe ich die Idee hinter diesem Schliereneffekt erklärt, da ich beim Erstellen der Musterlösung auch ein bisschen rumprobieren musste bis es klappte. Und mir kam es für die Schüler in erster Linie auf die if-Abfragen an.

Lösung: Bildschirmschoner

Programmieraufgabe 95

Wow, es ist tatsächlich 10 Monate her seit ich das letzte Mal eine Programmieraufgabe hier vorstellte. Höchste Zeit das zu ändern. Diesmal natürlich zum Thema Array und for-Schleife. Kann man aber auch wunderbar in der 11. Jahrgangsstufe zum Üben des Kompositummusters nehmen.

Aufgabe

Schreibe, basierend auf der angefügten Vorlage, ein Programm mit den folgenden Eigenschaften:

  1. Durch Klicken auf den Hintergrund wird eine Blase erzeugt.
  2. Kommt man bei gedrückter Maustaste über eine Blase, so wird diese grau eingefärbt.
  3. Lässt man die Maustaste über einer Blase los, so zerplatzt sie.

Anhang: BubbleGameStart

Jetzt noch ein paar Erweiterungen für die guten Schüler:

  • Die Blasen sollen zufällige Farben haben
  • Je länger die Maustaste beim Erzeugen einer neuen Blase gedrückt wird, desto größer wird sie (Variante A: Radius hängt linear von den draw()-Aufrufen habe; Variante B: Die Fläche nimmt linear mit der Anzahl der draw()-Aufruf zu, d.h. die Fläche der Blase ist ein Maß für die Anzahl der Aufrufe)
  • Bewegung der Blasen ändern:
    1. Die Blasen sollen vom Rand abprallen
    2. Die Blasen prallen untereinander ab
    3. Es gibt eine Schwerkraft

Aufgabengenerator Java

Vor kurzem hat Herr Rau auf seinem Blog einen Aufgabegenerator zum Erzeugen von Klassenkarten und zugehörigen Testklassen zum Download angeboten. Das habe ich nun getan und wollte hierzu kurz wie versprochen mein Feedback schreiben.

Zunächst mal muss ich sagen, dass ich Aufgabengeneratoren klasse finde. Ich selbst habe früher einige auf JavaScript-Basis für meinen Mathe-Unterricht geschrieben. Immer angeregt durch die Seite von Arndt Brünner. Manchmal bin ich aber auch an meinen Erwartungen gescheitert. So habe ich für geometrische Konstruktionen mal einen Parser schreiben wollen, hatte aber zum damaligen Zeitpunkt noch keine Ahnung wie man so etwas macht. Habe ich auch immer noch nicht zu 100%, deswegen kann man nur den Ansatz anschauen. Irgendwann sollte ich das noch mal neu ansetzen. Genauso wie den Aufgaben-Generator zum Üben der Potenzgesetze. Noch weniger fertig und mit noch höheren Ambitionen angefangen (Zwei Potenzen anklicken und das zugehörige Gesetz auswählen mit dem vereinfacht werden soll). Beides habe ich im Übrigen vor knapp 15 Jahren angefangen zu schreiben. Wahnsinn, wozu ich früher noch Zeit hatte.

Zurück zu m Java-Generator von Herrn Rau. Ich finde den Aufgaben-Generator prima. Die Oberfläche entspricht nicht ganz meinem Stil, aber die Auswahl-Möglichkeiten sind gut. Man kann die Anzahl der Attribute bestimmen, ob 2 Konstruktoren umgesetzt werden sollen, ob es Startwerte für die Attribute geben soll, ob diese private sein sollen und ob es Methoden geben soll. Den letztere Punkt finde ich zu „übertrieben“, da es sich nur um die Standard get/set-Methoden der Attribute handelt. Herauskommen tut dann so etwas:

|--------------------
| Mensch
|--------------------
| bunt: boolean
| haeufigkeit: double
| typ: char
| postleitzahl: int
|--------------------
| Mensch()
| Mensch(boolean, double, char, int)
| getBunt(): boolean
| getHaeufigkeit(): double
| getTyp(): char
| getPostleitzahl(): int
| setBunt(boolean): void
| setHaeufigkeit(double): void
| setTyp(char): void
| setPostleitzahl(int): void
|--------------------
Der Wert des Attributs 'bunt' soll am Anfang sein: true
Der Wert des Attributs 'haeufigkeit' soll am Anfang sein: -2.447199215281726
Der Wert des Attributs 'typ' soll am Anfang sein: 'S'
Der Wert des Attributs 'postleitzahl' soll am Anfang sein: 61

Schön ist hierbei, dass die Beschreibung in UML erfolgt, also der Datentyp bzw. Rückgabewert mit Doppelpunkt angehängt wird. Das finde ich in den Schulbüchern ein Unding. Dafür fehlt mir jetzt das – bzw. + für private und public. Das das Rechteck nicht geschlossen ist, kann ich zwar nachvollziehen, hätte man aber vielleicht korrigieren können.  So sieht es irgendwie halb fertig aus. Den Startwert für den double-Wert finde ich ein wenig übertrieben. Da hätte so etwas wie „Zufallswert(0,100) . Zufallswert(0,100)“ es auch getan. Und für die Postleitzahl sollte es dann auch fünfstellig sein.

Als Methode würde ich immer auch noch eine toString()-Methode ergänzen… die kann man später immer mal gebrauchen.

Das aber absolut beste an dem Generator ist, dass er parallel eine Testklasse erzeugt. Im Gegensatz zu einer Musterlösung, die im Zweifelsfall nur irgendwie kopiert wird, lässt sich so herausfinden, ob man alle gewünschten Anforderungen erfüllt hat. Das finde ich wirklich großartig.

Hier ein kleiner Auszug:

import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class MenschTest {
    Mensch testObject;
    public MenschTest() {}

    @Before
    public void setUp() {
        testObject = new Mensch();
    }

    @Test
    public void initialisierungVonBunt() {
        assertEquals(testObject.getBunt(), true);
    }

    @Test
    public void initialisierungVonHaeufigkeit() {
        assertEquals(testObject.getHaeufigkeit(), -2.447199215281726, 0.00001);
    }

So wird mit der letzten Methode geprüft, ob der Startwert um maximal 0.00001 vom Wert -2.447199215281726 abweicht. Das macht hier zwar wenig Sinn, aber bei Methoden, die etwas wirklich berechnen sollen, macht die Benutzung einer Delta-Abweichung durchaus Sinn.

Fazit: Ich finde die Arbeit von Herrn Rau großartig und werde sie auch einsetzen. Ich würde mir für Kollegen noch ein paar einfachere Erweiterungsmöglichkeiten wünschen (Andere Klassen, Attribute, Methoden über eine Text-Datei integrieren) und das -/+ für private und public wünschen, aber das wärs auch schon. Danke Thomas für deine Arbeit.

 

Ältere Beiträge

© 2017 Lehrzeit

Theme von Anders NorénHoch ↑