![[HaBo]](/styles/default/logoklein.png){kind=small}
Hallo Habo,
ich hab mehre Klassen zur Aufgabenstellung eines kleinen Bankprogrammes unter anderem sind da die Klassen Transaktion, Konto und ich soll nun eine Klasse schreiben, in der sowohl Transaktionsvorgänge als auch Konten in einem automatisch sich vergrößerndes Array gespeichert werden.
Was brauche ich dabei und was muss ich dabei beachten?
Würdet ihr das mit zwei Arrays, mit einem mehrdimensionalen Array oder sogar mit einem Array lösen? Mir fehlt da gerade irgendwie der Objektorientiereansatz um das Problem zu lösen.
LG
Die Dateien :
ich hab mehre Klassen zur Aufgabenstellung eines kleinen Bankprogrammes unter anderem sind da die Klassen Transaktion, Konto und ich soll nun eine Klasse schreiben, in der sowohl Transaktionsvorgänge als auch Konten in einem automatisch sich vergrößerndes Array gespeichert werden.
Was brauche ich dabei und was muss ich dabei beachten?
Würdet ihr das mit zwei Arrays, mit einem mehrdimensionalen Array oder sogar mit einem Array lösen? Mir fehlt da gerade irgendwie der Objektorientiereansatz um das Problem zu lösen.
LG
Die Dateien :
Code:
package bank;
/**
* Die Klasse Transaktionsarray stellt ein sich automatisch
* vergrößenderes Array dar.
* GPL BLABLA LBA 1.0
*/
public class Transaktionsarray {
private Transaktion[] transaktionen = new Transaktion[2];
private int zaehler=0; //Zähler für mein tolles Array
/**
* Die Methode anzahl gibt die Anzahl
* der Transaktionen zurück
* @return anzahl
*/
public int anzahl() {
//gibt die anzahl meines tollen arrays zurück
return zaehler;
}
/**
* Die Methode element gibt eine aktuelle Transaktion zurück
* @param Transaktionsnummer
* @return Transaktion
* @throws IndexOutOfBoundsException wenn auf <code>i</code> zugegriffen wurde, und
* i noch nicht gespeichert wurde.
*/
public Transaktion element(int i) {
if(zaehler-1<i){
throw new IndexOutOfBoundsException("Geht nicht");}
else
return transaktionen[i];
}
/**
* Die Methode speichere erlaubt es einen
* Wert im Transaktionsarray abzulegen.
* @param inhalt
*/
public void speichere(Transaktion transaktion) {
if(zaehler>=transaktionen.length){
Transaktion t [];
t=new Transaktion[2*transaktionen.length];
for (int i = 0;i<transaktionen.length;i++)
t[i]=transaktionen[i];
transaktionen = t;}
transaktionen[zaehler++] = transaktion;
}
/**
* Die Methode umgekehrt vertauscht die Transaktionen
* innerhalb des Arrays
* @param übergebe Transkation
* @return neue Transaktion
* @throws IndexOutofBoundsException wenn Zaehler kleiner als Index
*/
public Transaktion umgekehrt(int i) {
/*index ist eine neue Zwischenvariable
* die zur Rückgabe benötigt wird
*/
int index = (zaehler-1)-i;
if(zaehler-1<index){
throw new IndexOutOfBoundsException("Geht nicht");
}
else{
return transaktionen[index];
}
}
}
Code:
package bank;
/**
* Die Klasse Konto kapselt ein Bankkonto. Alle Kontobewungen werden in einer Transaktionsliste
* gesammelt und auf Anforderung auf der Standardausgabe ausgegeben.
*
*
*/
class Konto {
/**
* Rueckverweis auf die Bank zu der das Konto gehoert.
*/
private Bank geldInstitut;
/**
* Kontonummer unter der dieses Konto bei der Bank gefuehrt wird.
*/
private final int kontonr;
/**
* Der aktuelle Kontostand (ist immer groesser oder gleich 0).
*/
private double kontostand;
/**
* Array aller Kontobewegungen.
*/
private Transaktionsarray transaktionen = new Transaktionsarray();
/**
* Erzeugt ein neues Konto mit dem Kontostand 0.
*
* @param kontonr die Kontonummer des Kontos
*/
Konto(Bank geldInstitut, int kontonr) {
this.kontonr = kontonr;
this.geldInstitut = geldInstitut;
}
/**
* Gibt den aktuellen Kontostand zurueck.
*
* @return aktueller Kontostand
*/
double kontostand() {
return kontostand;
}
/**
* Fuehrt eine Bareinzahlung aus.
* Der eingezahlte Betrag muss groesser als 0 sein.
*
* @param betrag eingezahlter Betrag
* @throws IllegalArgumentException wenn der Betrag negativ oder 0 ist.
*/
void barEinzahlen(double betrag) {
pruefeObBetragPositiv(betrag);
kontostand += betrag;
transaktionen.speichere(Transaktion.barEingezahlt(betrag));
}
/**
* Fuehrt eine Bareausahlung aus.
* Der ausgezahlte Betrag muss groesser als 0 sein und durch das
* Konto gedeckt sein.
*
* @param betrag ausgezahlter Betrag
* @throws IllegalArgumentException wenn die Auszahlung nicht moeglich ist.
*/
void barAuszahlen(double betrag) {
pruefeObBetragPositiv(betrag);
pruefeObAuszahlungGedeckt(betrag);
kontostand -= betrag;
transaktionen.speichere(Transaktion.barAbgehoben(betrag));
}
/**
* Fuehrt eine Ueberweisung auf ein anderes Konto aus.
* Der ueberwiesene Betrag muss groesser als 0 sein und
* die Ueberweisung muss durch das Konto gedeckt sein.
* Das andere Konto muss existieren.
*
* @param betrag ausgezahlter Betrag
* @throws IllegalArgumentException wenn die Ueberweisung nicht moeglich ist.
*/
void ueberweisen(double betrag, Konto ziel) {
// pruefen ob alles locker flockig ist
pruefeObAuszahlungGedeckt(betrag);
pruefeObBetragPositiv(betrag);
ziel.kontostand += betrag;
this.kontostand -= betrag;
//Ziel ist ein Konto
//transaktionen attribut der klasse konto
//methode speichere
ziel.transaktionen.speichere(Transaktion.gebuchtVon(this.toString(), betrag));
this.transaktionen.speichere(Transaktion.abgebuchtFuer(ziel.toString(), betrag));
}
/**
* Gibt auf der Standardausgabe eine komplette Uebersicht ueber alle
* Kontobewegungen aus.
*/
void ausgabeVonAllenTransaktionen() {
System.out.println();
System.out.println("Kontobewegungen fuer " + this);
System.out.println("Der Kontostand betraegt: " + Transaktion.format(kontostand));
System.out.println("===================================");
for (int i = 0; i < transaktionen.anzahl(); i++) {
System.out.println(transaktionen.umgekehrt(i));
}
System.out.println();
}
/**
* Ueberschreibt <code>toString</code> aus der Klasse <code>Object</code>.
* @return Angabe ueber die Kontonummer.
*/
public String toString() {
return geldInstitut + ":" + kontonr;
}
/**
* Prueft ob das Konto eine Auszahlung erlaubt.
*
* @param betrag auszuzahlender Geldbetrag (ist garantiert positiv).
* @throws IllegalArgumentException wenn die Auszahlung nicht moeglich ist.
*/
private void pruefeObAuszahlungGedeckt(double betrag) {
if (betrag > kontostand)
throw new IllegalArgumentException("Abheben von " + betrag
+ " nicht moeglich, da nur " + kontostand + " vorhanden.");
}
/**
* Prueft ob ein Geldbetrag, wie verlangt, groesser als 0 ist.
*
* @param betrag zu pruefender Betrag
* @throws IllegalArgumentException wenn der Betrag illegal ist
*/
private void pruefeObBetragPositiv(double betrag) {
if (betrag <= 0)
throw new IllegalArgumentException("Betrag " + betrag + " ist nicht > 0");
}
}
Code:
package bank;
/**
* Die Klasse stellt die einzige oeffentliche Schnittstelle fuer den Umgang mit einem Konto
* dar.
* Konten werden generell ueber die von der Bank vergebene Kontonummer angesprochen.
* Alle Methoden verlangen, dass die angegebenen Konten existieren, dass Geldbetraege groesser als 0 sind
* und dass das Konto eine eventuelle Auszahlung deckt.
*
* Wenn eine der Voraussetzungen nicht zutrifft, wird eine <code>IllegalArgumentException</code> geworfen.
* a
*/
public class Bank {
private String name;
private Konto[] konten = new Konto[100];
private int nKonten = 0;
/**
* Erzeugt eine neue Bank.
* Die neue Bank hat noch keine Bankkonten.
*
* @param name Name der Bank.
*/
public Bank(String name) {
this.name = name;
}
/**
* Legt ein neues leeres Konto an. Konten werden intern
* gespeichert und koennen spaeter durch die von der Methode
* zurueckgegebene Kontonummer angesprochen werden.
*
* @return Kontonummer
*/
public int neuesKonto() {
Konto neuesKonto = new Konto(this, nKonten+1);
konten[nKonten++] = neuesKonto;
return nKonten;
}
/**
* Fuehrt eine Bareinzahlung aus. Das angegebene Konto muss existieren
* und der Geldbetrag muss groesser als 0 sein.
*
* @param nr Kontonummer
* @param betrag Geldbetrag
* @throws IllegalArgumentException bei falscher Eingabe
*/
public void barEinzahlen(int nr, double betrag) {
getKonto(nr).barEinzahlen(betrag);
}
/**
* Fuehrt eine Barauszahlung aus. Neben der Forderung, dass der
* Geldbetrag positiv ist muss auch das Konto gedeckt sein.
*
* @param nr Kontonummer
* @param betrag Geldbetrag
* @throws IllegalArgumentException bei falscher Eingabe
*/
public void barAuszahlen(int nr, double betrag) {
getKonto(nr).barAuszahlen(betrag);
}
/**
* Fuehrt eine Ueberweiung aus. Die Ueberweisung ist nur moeglich,
* wenn sie durch das Ausgangskonto (quelle) gedeckt ist.
* Es ist nicht erlaubt, negative Betraege anzugeben.
*
* @param quelle Kontonummer von der aus ueberwiesen wird
* @param ziel Kontonummer zu der ueberwiesen wird
* @param betrag Geldbetrag
* @throws IllegalArgumentException bei falscher Eingabe
*/
public void ueberweisen(int quelle, Bank zielBank, int zielKonto, double betrag) {
Konto qKonto = this.getKonto(quelle);
Konto zKonto = zielBank.getKonto(zielKonto);
qKonto.ueberweisen(betrag, zKonto);
}
/**
* Gibt den aktuellen Kontostand des angegebenen Kontos zurueck.
*
* @param nr Kontonummer
* @return aktueller Kontostand
* @throws IllegalArgumentException wenn das Konto nicht existiert.
*/
public double kontostand(int nr) {
return getKonto(nr).kontostand();
}
/**
* Gibt die Kontobewegungen fuehrt das angegebene Konto auf Standardausgabe
* aus.
*
* @param kontoNr Nummer des auszugebenden Kontos
* @throws IllegalArgumentException wenn das Konto nicht existiert
*/
public void kontobewegungenAusgeben(int kontoNr) {
getKonto(kontoNr).ausgabeVonAllenTransaktionen();
}
/**
* Gibt den Namen der Bank zurueck.
* @param Name der Bank.
*/
public String toString() {
return name;
}
/**
* Sucht das Kontoobjekt bei bekannter Kontonummer.
*
* @param kontoNr Kontonummer
* @return Kontoobjekt
* @throws IllegalArgumentException wenn das Konto nicht existiert
*/
private Konto getKonto(int kontoNr) {
if (kontoNr <= 0 || kontoNr > nKonten)
throw new IllegalArgumentException("illegale Kontonummer: " + kontoNr);
return konten[kontoNr - 1];
}
}
Code:
package bank;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.Locale;
/**
* Ein Objekt dieser Klasse speichert einen Umsatzvorgang fuer ein Konto.
* Gespeichert werden die Aktion, der Geldbetrag (immer positiv) und
* gegebenenfalls eine Angabe ueber das Zielkonto.
*
*/
final class Transaktion {
private final Aktion aktion;
private final String ziel;
private final double betrag;
/**
* Ersatz fuer auf advm1 unbrauchbares CurrencyFormat
*/
private static final NumberFormat numberFormat;
static {
numberFormat = DecimalFormat.getNumberInstance(Locale.GERMANY);
numberFormat.setMinimumFractionDigits(2);
numberFormat.setMaximumFractionDigits(2);
}
/**
* Formatiert einen Geldbetragt gemaess den deutschen Regeln.
*
* @param betrag Geldbetrag
* @return formatierter String
*/
static String format(double betrag) {
// Ersatzloesung fuer CurrencyFormat, da die advm1 kein Euro-Zeichen
// kennt.
return numberFormat.format(betrag) + " Euro ";
}
// static String format(double betrag) {
// return DecimalFormat.getCurrencyInstance(Locale.GERMANY).format(betrag);
// }
/**
* Erzeugt das Transaktionsobjekt fuer das Abheben von Bargeld.
* @param betrag Geldbetrag
*/
static Transaktion barAbgehoben(double betrag) {
return new Transaktion(Aktion.BAR_AUS, "", betrag);
}
/**
* Erzeugt das Transaktionsobjekt fuer das Einzahlen von Bargeld.
* @param betrag Geldbetrag
*/
static Transaktion barEingezahlt(double betrag) {
return new Transaktion(Aktion.BAR_EIN, "", betrag);
}
/**
* Erzeugt das Transaktionsobjekt fuer das Abbuchen einer Ueberweisung.
* @paran ziel Zielkonto
* @param betrag Geldbetrag
*/
static Transaktion abgebuchtFuer(String ziel, double betrag) {
return new Transaktion(Aktion.UEBERW_AUS, ziel, betrag);
}
/**
* Erzeugt das Transaktionsobjekt fuer das Buchen einer Ueberweisung.
* @param quelle einzahlendes Konto
* @param double betrag Geldbetrag
*/
static Transaktion gebuchtVon(String quelle, double betrag) {
return new Transaktion(Aktion.UEBERW_EIN, quelle, betrag);
}
/**
* Erzeugt eine neue Transaktion. Transaktionen werden nur in der Klasse
* Konto verwendet.
*
* @param aktion Art des Umsatzes
* @param ziel Partnerkonto (bei Ueberweisung)
* @param betrag Geldbetrag
* @param vorherige vorhergehende Transaktion in der Transaktionsliste
*/
private Transaktion(Aktion aktion, String ziel, double betrag) {
this.aktion = aktion;
this.ziel = ziel;
this.betrag = betrag;
}
/**
* Ueberschreibt <code>toString</code> aus der Klasse <code>Object</code>.
*
* @return verstaendlicher Text ueber die Kontobewegung
*/
public String toString() {
String anderesKonto = "";
if (aktion == Aktion.UEBERW_AUS)
anderesKonto = " nach " + ziel;
else if (aktion == Aktion.UEBERW_EIN)
anderesKonto = " von " + ziel;
return aktion + anderesKonto + ", Betrag: " + format(betrag);
}
}
Zuletzt bearbeitet:
