Zweite Version des Bruchrechners (mit GUI)

Informatikkurs 2. Semester, Humboldt-Oberschule, Berlin-Tegel

Kapitel 7

Dr. Bernd Kokavecz


Dazu beachten: Übungsmaterial aus der Fortbildung (BICS)

Bildschirmausdruck der Bedienoberfläche
(Zwischenstand)

Rechner1

Gerade wurde die Multiplikation zweier Brüche durchgeführt.

Hinweise zum Vorgehen

Die Anforderungsdefinition für den Bruchrechner wurde mit den Schülern gemeinsam erarbeitet. Auch ein Entwurf der grafischen Oberfläche wurde im Unterricht vorgenommen.

Die Schüler haben dann die entsprechenden Klassen des Fachkonzepts festgelegt. Sie haben die Aufgabe, die einzelnen Klassen zu programmieren und mit Hilfe von Testumgebungen zu testen.

Die grafische Oberfläche (siehe Bild oben) wird vom Lehrer erstellt. Die Schüler haben die Aufgabe, die Oberfläche zu erweitern und zu verbessern. So kann z.B. ein "Knopf" mit Eingabefeld für eine Methode "Erweitern um" hinzugefügt werden und es müssen die Berechnungsmethoden implementiert, d.h. entsprechende Methoden aus der Klasse "Bruchrechner" aufgerufen werden.

Weitere Hinweise

Die Methode "Kürzen" ist in keiner Weise mathematisch elegant oder optimiert!

Es wurde auf eine weitgehende Trennung zwische GUI und Fachkonzept Wert gelegt.

Das Ergebnis der Programmierung wird zeigen, dass der Entwurf - bzw. bereits die Anforderungsdefinition - nicht gründlich genug erarbeitet wurde. So wäre es sinnvoll, die Operationen sofort beim Drücken der entsprechenden Tasten auszuführen (ähnl. umgekehrter polnischer Notation). Das Ergebnis des Kürzens sollte den zu kürzenden Bruch überschreiben usw... (Aus Fehlern lernen hoffentlich auch die Schüler).

Anforderungsdefinition

(Schülertext, Moritz Schindler)

Es soll ein Taschenrechner für Bruchrechnungen programmiert werden. Seine Rechenmöglichkeiten müssen das Addieren, Subtrahieren, Multiplizieren und Dividieren zweier Brüche abdecken. Die Eingabe wie auch die Ausgabe soll in Form von Brüchen erfolgen. Das Ergebnis muss vollsständig gekürzt ausgegeben werden. Eine weitere Funktion des Rechners soll darin bestehen, einen angegebenen Bruch so weit wie möglich zu kürzen oder ihn mit einem Faktor zu erweitern. Eine Darstellung der Zwischenschritte ist nicht erforderlich, ebenso die Fähigkeit des Rückwärtsrechnens. Als Interface wird ein Grafik-Front-End gewünscht, die Zahleneingabe soll per Tastatur erfolgen. Das Frontend soll vollständig vom Kernprogramm getrennt sein.

Entwurf des Interfaces:

entwurf

Die Bedienung des Rechners erfolgt in folgender Weise:

  1. Um eine der Grundrechenarten zwischen den zwei Brüchen zu wählen:
    Es werden die beiden Brüche eingegeben indem man mit der Maus das betreffende Feld selektiert und mit der Tastatur den Wert eingibt. Die Rechenart wird über die 4 Buttons zwischen den Brüchen festgelegt. Nachdem die Eingabe erfolgt ist, wird der '='-Button der sich zwischen dem zweiten und dem dritten Bruch befindet gedrückt. Nun erfolgt die Berechnung, das Ergebnis wird vollständig gekürzt angegeben.
  2. Um einen Bruch vollständig zu kürzen
    Der zu kürzende Bruch wird in den Feldern des 1. Bruches eingetragen. Nach dem Drücken des "Kürzen"- Buttons erfolgt die Ausgabe des Ergebnisses im 3. Bruchfeld.
  3. Um einen Bruch mit einer Zahl zu erweitern
    Der zu erweiternde Bruch wird in den Feldern des ersten Bruches eingegeben, die Zahl mit der zu erweitern ist in das dafür vorgesehene Feld neben dem "Erweitern"-Button. Nach Drücken dieses Buttons erfolgt die Ausgabe des Ergebnisses.
  4. Zurücksetzen der Eingabemaske
    Durch das Drücken des Clear-Buttons werden alle Eingabefelder gelöscht, eine neue Berechnung kann gestartet werden.
  5. Beenden des Programms:
    Es besteht die Möglichkeit, das Programm zu beenden. Die erste Möglichkeit stellt der "Beenden"-Button dar, des weiteren kann das Programm mit dem X-Button rechts oben geschlossen werden.

Aufstellung der benötigten Klassen für das Fachkonzept ("Kernprogramm"):

GZahl
Wert
setWert(Wert)
getWert
Bruch
Zähler: GZahl
Nenner: GZahl
setZähler (Wert)
setNenner (Wert)
getZähler
getNenner
Kürzen
ErweiternMit (Zahl)
Invertieren
KürzenDurch (Zahl)
Bruchrechner
Ergebnis: Bruch
Bruch1: Bruch
Bruch2: Bruch
Operation: Char
Berechne
setOperation (Oper)
getOperation
Kürzen (BruchNr)
ErweiternMit (Zahl)
getBruch (BruchNr)
setBruch (Z, N, BruchNr)

Teil-Quelltext für Bruchrechner Version 2
===========================================
--------------------------------------------------------------------
Bruchrechner HAT 3 Brüche
Datei bruchrechner.py  --DOC--
--------------------------------------------------------------------

from xterm import * # für Testumgebung
from bruch import *
import string

class Bruchrechner:
   """
   /* stellet das Fachkonzept für einen Bruchrechner dar
   """
   def __init__(self):
      """
      /* Attribute sind: Bruch1, Bruch2, Ergebnis, Operator (default: +)
      """

   def setOperator(self,wert):
      """
      /* Der Operator wird auf eine der Operationen + - * : gesetzt
      /* Es erfolgt noch keine Berechnung
      /* ----------------------------------------------------------
      /* wert : character : gewünschte Operation (ohne Fehlerabfragen)
      """

   def getOperator(self):
      """
      /* liefert die ausgewählte Operation zurück
      """

   def setBruch(self,zaehler,nenner,Nr):
      """
      /* Bruch1 oder Bruch2 können definiert werden. 
      /* --------------------------------------------
      /* zaehler : integer 
      /* nenner  : integer 
      /* Nr      : integer : 1 oder 2  für Bruch1 oder Bruch2
      """

   def getBruch(self,Nr):
      """
      /* liefert den Bruch als Zahlenpaar zurück 
      /* -----------------------------------------------
      /* Nr: integer : 1,2 oder 3 für Ergebnisbruch
      /* -----------------------------------------------
      /* Rückgabe : Paar : (integer,integer)
      """

   def erweitern_mit(self,n):
      """
      /* Bruch1 wird mit n erweitert (monadische Operation)
      /* -----------------------------------------------
      /* n : integer
      """

   def kuerzen(self,Nr):
      """
      /* Bruch1, Bruch2 oder ergebnis werden soweit wie möglich gekürzt
      /* --------------------------------------------------------------
      /* Nr : 1,2 oder 3 für Ergebnisbruch
      """

   def berechne(self):
      """
      /* Entsprechend der Operations-Vorwahl wird die Berechnung aus den
      /* beiden Brüchen durchgeführt und als Ergebnisbruch gespeichert.
      /* (diadische Operationen: + - * : ). 
      /* Fehlermeldung, wenn Nenner 0 über StdIO
      """


Dr. Bernd Kokavecz
Datum: 11.03.2001
dr.bernd@kokavecz.de

angepasst: Bombei, BICS, 9.5.2001