Ein Taschenrechner mit Java in der 10. Klasse (1)

Mit meiner 10. Klasse habe ich im ersten Halbjahr einen Taschenrechner programmiert, ziemlich bald, als Einstieg in die Algorithmik, die ich dafür dieses Jahr vorgezogen habe. Als BlueJ-Projekt sieht der Rechner so aus:

taschenrechner_bluej_rot

Objektorientiert programmieren heißt, dass man die Programmieraufgabe auf verschiedene, relativ unabhängige Einheiten verteilt. Der Bauplan für diese Einheiten heißt “Klasse”, und eben diese programmiert man.


1. Die Klasse GUI

Die Klasse GUI kann ein guter Schüler machen. Sie übernimmt das, was vom Programm äußerlich sichtbar ist. (GUI steht für Graphical User Interface.) Das ist quasi das Plastik-und-Alu-Gehäuse des Rechners. Den hat ein freiwilliger Schüler schon gleich am Anfang programmiert, und zwar mit dem Java-Editor. Dieses Programm von Gerhard Röhner ist eigens für Schulen und Schüler entwickelt, um leichter diese grafischen Benutzeroberflächen zu erstellen, die in Java, ehrlich gesagt, recht umständlich sind.

Die Klasse GUI braucht einen Bereich, in dem man die Ergebnisse anzeigen lassen kann (im Java-Editor-JFrame-Projekt: JLabel oder JTextField), und viele Knöpfe mit unterschiedlichen Beschriftungen (JButton). Nach diesen Angaben hat ein Schüler folgendes Taschenrechner-GUI angelegt, nachdem wir vorher noch ausgemacht hatten, welche Knöpfe es geben soll:

taschenrechner_gui_ansicht_leer

Ich hätte die Knöpfe anders platziert und benannt, aber hey, es ist nicht mein Taschenrechner. Und hier ist auch ein Vorteil des objektorientierten Programmierens: Wem dieses GUI nicht gefällt, der kann es einfach durch ein anderes, eigenes ersetzen, ohne dass die anderen am Programm beteiligten Klassen geändert werden müssen.

Noch passiert allerdings nichts, wenn man auf die Knöpfe drückt. Viel soll auch gar nicht passieren: für das Innenleben des Taschenrechners sind wieder andere Klassen zuständig. Der Taschenrechner muss nur Bescheid geben, welche Taste gedrückt ist, und zwar einem Objekt der Klasse Steuerung. Damit das geht, muss man die mit dem Java-Editor erstellte GUI-Klasse etwas ergänzen:

1. Ein GUI-Objekt muss ein Steuerung-Objekt kennen, dem es die Benachrichtigung schicken soll (Referenzattribut auf ein Objekt der Klasse Steuerung); das geht in einer Zeile:

Steuerung steuerung;

2. Wenn eine Taste gedrückt wird, muss an die Steuerung eine Nachricht gesendet werden. Die Vorarbeit dazu erledigt der Java-Editor, man muss nur – nach dem TODO-Kommentar – eine einzige Zeile in jeder Knopfgedrückt-Methode ergänzen (es gibt für jeden Knopf eine solche Methode):

private void jButton1_ActionPerformed(ActionEvent evt) {
  // TODO hier Quelltext einfügen
  senden ("1");
} // end of jButton1_ActionPerformed

Der Einfachheit halber benutzen alle diese Knopfdruckmethoden die ebenfalls zu ergänzende Sendemethode der Klasse GUI:

void senden(String s) {
  steuerung.empfangen(s);
}

Das war es fast. Damit das GUI auch Text ausgeben kann, muss man nur diese Methode ergänzen:

void ausgeben(String s) {
  ausgabefeld.setText(s);
}

Und damit ist die Klasse GUI fertig. Wenn eine Taste gedrückt wird, wird eine Nachricht an die verbundene Steuerung geschickt, und wenn man das GUI-Objekt anweist, Text auszugeben, dann macht es das. Mehr erwartet man von einer Taschenrechnerhülle nicht.


2. Die Klasse Steuerung

Diese Klasse sollte man den Schülern fertig vorgeben. Sie macht eigentlich gar nicht so viel, ist aber umständlicher zu programmieren, als man meint. Sie macht zwei Dinge: Erstens nimmt sie in Empfang, welche Nachrichten, also Tastendrucke, vom GUI gesendet werden. Und gleich darauf sagt sie der Steuerung, was diese anzeigen soll. Wenn am Anfang die Taste 1 gedrückt wird, soll das GUI “1” anzeigen. Wenn danach die Taste 2 gedrückt wird, soll das GUI “12” anzeigen. Wenn dann die Mal-Taste gedrückt wird, soll das GUI “*” anzeigen. (Die bisher eingegebene Zahl 12 muss sich die Steuerung aber merken.) Und so weiter, bis es nach dem Eingeben der zweiten Zahl ans eigentliche Rechnen geht. Dieses Rechnen übernimmt dann wieder eine dritte Klasse, nämlich die Klasse Calculator.

Die Klasse Steuerung kann man sicher sauberer programmieren, als ich das getan habe. Sie muss sich im Prinzip zwei Zahlen merken können, eine erste und eine zweite. Dazu muss sie wissen, ob sie jetzt schon rechnen soll oder erst auf die Eingabe einer zweiten Zahl warten muss. Manchmal muss sie auch schon nach der Eingabe einer einzigen Zahl rechnen, nämlich bei allen Operationen mit nur einem Operanden – Quadratwurzel, Fakultät, Betrag und so weiter.

Ein Grund dafür, dass die Steuerung so arbeitet, ist folgender: Die Rechenarbeit soll ganz von der Klasse Calculator übernommen werden. Denn da schlägt die Stunde der Schüler.


3. Die Klasse Calculator und Unterklassen dazu

Die Klasse Calculator – beziehungsweise eine eigene Unterklasse dazu – ist die Klasse, mit der Schüler fast ausschließlich arbeiten. Sie enthält alle Rechenmethoden, die der Taschenrechner beherrscht. Über die muss man sich natürlich vorher verständigen, schon mal, damit es genügend Knöpfe dafür gibt. Da wären die Grundrechenarten, aber auch Wurzel, Potenzierung, Prozent, Betrag, Kehrwert und was es noch alles gibt. Ich habe auch noch ein paar exotische Sachen ergänzt (Collatz, Fibonacci, Primzahltest, größter gemeinsamer Teiler), auch wenn wir erst später im Schuljahr darauf zurückkommen werden:

taschenrechner_calculator

Im Klassendiagramm sind die Methoden alphabetisch sortiert, den Schülern muss man eine Liste mit einer anderen Reihenfolge vorgeben! Meine Liste war – leider erst am Ende der Sequenz – sortiert nach:

  • Einfach: Grundrechenarten (addieren, subtrahieren, multiplizieren, dividieren)
  • Leicht: negation, kehrwert, hochDrei, quadrat, prozent (wobei wir uns erst mal einigen mussten, was diese Prozenttaste bewirken soll)
  • Mit bedingter Anweisung: betrag
  • Mit while-Schleife: potenz. modulo, fakultaet, summeVonBis

Und so weiter. Die Schüler arbeiteten dann in ihrem eigenen Tempo und in ihrer eigenen Geschwindigkeit an diesen Methoden. Denn darum ging es eigentlich vor allem: Einführung in die Algorithmik und Kontrollstruktoren. Nur: ohne den graphischen Taschenrechnerkrimskrams drumherum macht das den Schülern viel weniger Spaß. Einige kamen nicht sehr weit über die Grundrechenarten hinaus, die meisten kamen bis Fakultät/Potenz, andere schlugen bei Wikipedia nach und fanden Lösungen für Wurzel und Sinus/Cosinus heraus. Die hatte ich nur aufgenommen, weil der GUI-Programmierer die vorgegeben hatte. Später im Jahr werde ich dann noch auf einige der exotischeren Methoden zurückkommen.

(Zur Klasse Taschenrechner: Die Klasse Calculator enthält zwar alle Methoden, aber sie funktionieren noch nicht richtig. Standardmäßig kommt dabei immer 99 heraus. Aufgabe der Schüler ist es, eine Unterklasse zu Calculator zu programmieren und die Methoden der Oberklasse durch ihre eigenen, verbesserten Methoden zu überschreiben. Sinnvoller wäre es natürlich gewesen, die Klasse Calculator als Interfache anzulegen. Aber dann müssten die Schüler immer wieder in den Code des Interface, um auszukommentieren, was sie noch nicht verbessert haben. Deshalb habe ich mich für diese eigentlich unelegante Lösung entschieden.)


4. Der Rest

Die Klasse Starter legt je ein Objekt der Klassen GUI, Steuerung und Calculator-Unterklasse an und macht sie miteinander bekannt. Sie enthält außerdem die main-Methode, mit der man den Taschenrechner auch außerhalb von BlueJ als echtes kleines Java-Programm unter Windows, Mac oder Linux laufen lassen kann.


Ziel der Sequenz: Einführung in Algorithmik und Programmierung. Daneben schon mal ein Vorgeschmack auf Vererbung und Referenzattribute. Außerdem sehen die Schüler bereits das objektorientierte Prinzip der Arbeitsteilung in Klassen angewendet. Gute Schüler können sich an ein GUI wagen, alle machen die algorithmisch interessanten Rechenmethoden, und der Verwaltungskram der Steuerung bleibt den Schülern verborgen.

Download des ganzen BlueJ-Projekts mit zwei Arbeitsblättern dazu.

(Fortsetzung morgen.)

5 Gedanken zu “Ein Taschenrechner mit Java in der 10. Klasse (1)

  1. Markus Hagemann on 15.5.2013 at 18:01 sagte:

    Vielen Dank für diesen Artikel! Ich berichte nach meinem Einsatz im Unterricht!

  2. Wenn ich irgendetwas erklären soll, mache ich gerne. Die aktuelle Fassung enthält dann doch noch Interfaces und macht das Projekt unübersichtlicher, aber dafür habe ich eine zweite Steuerungsklasse angelegt (als Automat), die aber noch nicht fertig implementiert ist.
    Viel Spaß beim Basteln.

  3. Simon on 7.10.2013 at 18:51 sagte:

    Programmiere einen Taschenrechner.

    Der Benutzer gibt die beiden Operanden (Zahlen mit denen gerechnet wird)

    und den Operator als Zahl ein.

    Der Taschenrechner soll folgende Rechenoperationen beherrscht:

    1 = Addieren

    2 = Subtrahieren

    3= Multiplizieren

    4= Dividieren (Überprüfe,ob der Divisor ungleich null ist!) (5 / 0 = nicht definiert)

    5= Modulo (Rest)(Überprüfe,ob der Divisor ungleich null ist!) (5 / 0 = nicht definiert)

    Das Programm soll nur die gewählte Rechenoperation ausführen und das Ergebnis ausgeben.

    Achte auf die Variablennamen und kommentiere dein Programm.

  4. Simon on 7.10.2013 at 18:53 sagte:

    Danke im Voraus

  5. Bitte.

Hinterlasse eine Antwort

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert *

Du kannst folgende HTML-Tags benutzen: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>

Manchmal sollte man anderen das letzte Wort lassen, selbst wenn sie eine andere Meinung haben als man selber.

Post Navigation