Zurück

Objektorientierte Programmierung

Übungen

Übung 3-1

Die Java-Klasse Bruch: toString() und equals()

Nehmen Sie bitte in Ihre Java-Implementierung der Klasse Bruch die beiden Methoden toString() und equals() auf.
Beide Methoden werden in der Java-Oberklasse Object bereits vorgehalten, hier soll nun die Semantik der Klasse Bruch implementiert werden:

// Code-Auszug aus der main()-Methode
Bruch q1 = new Bruch(1,3);
Bruch q2 = new Bruch(2,6);
if (q1.equals(q2))
{
   System.out.println(q1 + " und " + q2 + " sind gleich.");
}

Übung 3-2

Die Klasse Bruch - Operator Overload in C++

Nachstehend finden Sie (erneut) die C++-Datei brueche.cpp, in der eine einfache (rudimentäre) Klasse Bruch definiert wird. Auf dieser Version wollen wir wiederum aufsetzen.

Hier noch einmal ein Ausschnitt aus der Vereinbarung (Deklaration) dieser Klasse.

class Bruch
{
   private:
      int z, n;            // Zaehler und Nenner

   public:
      Bruch();             // Default-Konstruktor
      Bruch(int,int);      // Konstruktor
      Bruch addiere(Bruch);
      // ...
      void ausgabe();

}; // end class Bruch

Wir gehen davon aus, dass Sie zwischenzeitlich die vorherigen Aufgaben gelöst haben (siehe Aufgabe 2-4 für C++ und für Java die Aufgabe 2-5), die Klasse Bruch nunmehr also u.a. über die Methoden subtrahiere(), multipliziere() und dividiere() verfügt.

Ersetzen Sie nun die folgenden Methoden durch die genannten Operatoren.

  1. Die Methode addiere() soll ersetzt werden durch eine Operatormethode + (operator+).
  2. subtrahiere() soll ersetzt werden durch operator-.
  3. multipliziere() soll ersetzt werden durch operator*.
  4. dividiere() soll ... genau!

Die Nachstehende Teilaufgabe ist eine Sternchen-Aufgabe; der hier angesprochene Operator wird voraussichtlich erst später in der Vorlesung detaillierter besprochen werden.

// ---------------------------------------------------------------------------------
// Dateiname:   brueche.cpp
// Aufgabe:     Elementare Arbeit mit Bruechen zur Erlaeuterung des Klassenbegriffs.
// ---------------------------------------------------------------------------------

#include <iostream>
#include <cstdlib>

using namespace std;


class Bruch
{
   private:
      int z, n;            // Zaehler und Nenner

   public:
      Bruch();             // Default-Konstruktor
      Bruch(int,int);      // Konstruktor
      Bruch addiere(Bruch);
      void ausgabe();
      // ...
};

// Implementation der Klassen-Methoden (Mitgliedsfunktionen)
// ---------------------------------------------------------

Bruch::Bruch()             // Default-Konstruktor
{
   z=0;
   n=1;
} // end Bruch::Bruch()

Bruch::Bruch(int zaehler, int nenner) // weiterer Konstruktor
{
   // Minimale Notfallbehandlung bei nenner==0 ! 
   if (nenner!=0)
   {
      z=zaehler;    // ausfuehrlich:  this->z=zaehler;
      n=nenner;     // this ist ein Zeiger auf das aktuelle Objekt
   }
   else
   {
      z=0;
      n=1;
   }
} // end Bruch::Bruch(int,int)

Bruch Bruch::addiere(Bruch q1)
{
   Bruch q;
   q.z = z*q1.n + q1.z*n;
   q.n = n * q1.n;
   return(q);
} // end Bruch::addiere 

void Bruch::ausgabe()
{
   cout << z << "/" << n;
} // end Bruch::ausgabe

// ---------------------------------------------------------

int main() // synonym fuer int main(void) 
{
   Bruch q1(1,1), q2(1,2), q3;    // q3 ist defaultmaessig 0/1

   // Die Anweisung q1.z=1; ist nun illegal, da z ein privates
   // Datenelement des Objektes q1 ist!

   // Addieren von q1 und q2 in die Variable q3     
   q3=q1.addiere(q2);

   // Ausgabe der Summe 
   q1.ausgabe();
   cout << " + ";
   q2.ausgabe();
   cout << " = ";
   q3.ausgabe();
   cout << endl;

   return EXIT_SUCCESS;
   
} // end main 

// end of file brueche.cpp 

Übung 3-3

Die Klasse Bruch - Der Kopierkonstruktor

Ergänzen Sie - zumindest zu Übungszwecken - die C++- und die Java-Klasse Bruch jeweils um einen Kopierkonstruktor. Welche Aufgaben hat dieser zu erfüllen? Ist bzw. wäre dieser Kopierkonstruktor im hier dargestellten Kontext erforderlich?

Übung 3-4

Die C++-Klasse IntArray

Entwerfen (und implementieren) Sie eine Klasse IntArray, die dynamische Arrays von int-Werten realisiert. (Diese Aufgabe ist evtl. auch während der Veranstaltung als Präsenz- und HeimarbeitsÜbung verteilt worden. Sie finden die vollumfängliche Darstellung hierzu in dem Arbeitsblatt auf dem Edu-Server.)

Ein Objekt dieser Klasse soll bei seiner "Geburt" die Information mitbekommen, wieviele int-Werte abgespeichert werden sollen; entsprechend viele Speicherplätze sollen damit dann implizit auch angelegt und verwaltet werden.

Über den []-Operator (operator[]) soll dann der Zugriff wie bei den gewohnten "echten" Arrays erfolgen. (Dabei bleibt es im Detail Ihnen überlassen, ob Sie für den Anwender Ihrer Klasse den Indexbereich des ("logischen") Arrays bei 0 oder bei 1 beginnen lassen möchten; in C++ können Sie beides realisieren.)

Nachstehendes Code-Schnipsel möge hierzu einiges illustrieren. (Hier wird ein Index-Beginn bei 0 dargestellt.)

IntArray ia1(10), ia2(20); // Zwei Objekte werden deklariert. ia1 kann 10, ia2 20 int-Werte aufnehmen.

ia1[0] = 13;                // Die nachstehenden Anweisungen setzen konkrete Werte in die Arrays
ia1[1] = 14;
// ...
for (int i=0; i<20; i++)
{
   ia2[i] = i;
}

// ...
cout << ia2[0] << endl;     // Der "nullte" Wert in ia2 wird ausgegeben, hier also die Zahl 0

Übung 3-5

Die Klassen Mitarbeiter und Abteilung

Modellieren Sie bitte jeweils eine Klasse für Mitarbeiterinnen und Mitarbeiter, die wir mit MA abkürzen wollen, und für Abteilungen.
Ein/e Mitarbeiter/in verfüge über einen Nachnamen, einen Vornamen, eine (maximal) zehnstellige alphanumerische (MA-)Nummer, ein (Monats-)Gehalt sowie eine Abteilung bzw. einen Bezug zu einer Abteilung.
Eine Abteilung soll eine Bezeichnung und grundsätzlich eine Abteilungsleiterin oder einen Abteilungsleiter sowie eine numerische (Abteilungs-)Nummer besitzen.

Implementieren Sie bitte die beiden Klassen MA und Abteilung in C++ und stellen Sie (mindestens) die nachfolgend beschriebenen Funktionalitäten bereit.

  1. Die Klasse MA soll einen kanonischen Konstruktor besitzen. Hierbei soll der Parameter für das Gehalt mit 0.0 vorbelegt sein, d.h. es soll möglich sein, MA-Objekte zu kreieren, die (zunächst) mit diesem (provisorischen) Wert "starten".
  2. Weiterhin soll die Klasse MA (mindestens) die Methoden ausgabe(), getGehalt() und setGehalt() bekommen. (Die Aufgaben dieser Methoden sind vermutlich offensichtlich.)
  3. Die Klasse Abteilung soll ebenfalls einen kanonischen Konstruktor erhalten. Hierbei soll der Parameter für die (Abteilungs-)Nummer mit 0 vorbelegt werden. Auch soll der fachliche Fall abgebildet werden können, dass ein konkretes Abteilungs-Objekt zu einem bestimmten Zeitpunkt (noch) keine/n Abteilungsleiter/in besitzt.
  4. Auch die Klasse Abteilung soll eine ausgabe()-Methode besitzen. Bei der Konsolen-Ausgabe soll, sofern vorhanden, die Abteilungsleiterin oder der Abteilungsleiter mit ausgegeben werden.
  5. Ergänzen Sie Ihren Code noch um eine Methode istIn(), die prüft, ob ein/e bestimmte/r Mitarbeiter/in einer Abteilung zugeordnet ist. Trifft dies zu, so soll istIn() den Wert 1 (oder true) zurückliefern, andernfalls eine 0 (oder false).

Übung 3-6

Die Java-Klasse Vector

Im Paket java.util findet sich die Klasse Vector, zu der Sie sich an vielen Stellen, zum Beispiel bei Tutorialspoint, weitere Informationen abrufen können. Nachstehend ein ganz kleines Stückchen Beispiel-Code zur ersten Illustration.

        Vector<Bruch> v = new Vector<Bruch>(); 
        v.add( new Bruch(1,3) );

        Bruch b1 = new Bruch(2,5);
        v.add( b1 );

        Bruch b2 = new Bruch(3,7);
        v.add( b2 );

        b1 = b1.addiere( b2 );
        v.add( b1 );

        System.out.println("Vector of Bruch v:");
        for (Bruch b : v)
        { 
            System.out.println("> " + b);
        }

Erzeugen Sie bitte (in einer Demo-Klasse) ein Vector-Objekt, in das Sie endlich viele Bruch-Objekte aufnehmen (können). Ermitteln Sie zu diesem "Vector of Bruch" das kleinste und das größte Element und berechnen Sie die Summe aller Brüche in diesem Vektor.


© 1999-2021 FHDW/Peter Baeumle-Courth. Document-Id: fhdwbap:opg:027973-4