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.");
}
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.
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
|
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?
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
|
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.
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-2023 FHDW/Peter Baeumle-Courth. Document-Id: fhdwbap:opg:027973-4