# Bank Überweisung



## Phoenixrl (13. Jun 2012)

Hallo zusammen, da ich eigentlich noch ein Anfänger bin und nicht weiter komme bitte ich euch um Hilfe.

Hier mein Code


```
class Konto{
	
	private String a_Name;
	private String a_Vorname;
	private int a_Kontonummer;
	private double a_Kontostand;
	
	
	Konto(String Name, String Vorname, int Kontonummer, double Kontostand){
		a_Name = Name;
		a_Vorname = Vorname;
		a_Kontonummer = Kontonummer;
		a_Kontostand = Kontostand;
	}
	
	void datenAusgeben(){
		System.out.println("---------------------------------");
		System.out.println("Information über Kontonummer: " +a_Kontonummer);
		System.out.println("Name:\t\t " +a_Name);
		System.out.println("Vorname:\t " +a_Vorname);
		System.out.println("Kontostand:\t " +a_Kontostand);
	}
	void überweisen(Konto zielKonto, double betrag) { 
        a_Kontostand -= betrag; 
        zielKonto.a_Kontostand += betrag;
		
	}
}

class Girokonto extends Konto{
	
	Girokonto(String Name, String Vorname, int Kontonummer, int Kontostand){
		super(Name, Vorname, Kontonummer, Kontostand);
	}	
}

class Festgeldkonto extends Konto{
	
	Festgeldkonto(String Name, String Vorname, int Kontonummer, int Kontostand){
		super(Name, Vorname, Kontonummer, Kontostand);
	}
}
class Sparbuch extends Konto{
	
	Sparbuch(String Name, String Vorname, int Kontonummer, int Kontostand){
		super(Name, Vorname, Kontonummer, Kontostand);
	}
}

public class Bankenprogramm {

	public static void main(String[] args) {
		Konto Kontonummer[] = new Konto[10000];
		Kontonummer[1423] = new Girokonto("Papadomus", "Assa", 1423, 10000);
		Kontonummer[1526] = new Girokonto("Proper", "Meister", 1526, 2563);
		Kontonummer[1444] = new Sparbuch("Gates", "Bill", 1444, 15425);
		Kontonummer[1423].datenAusgeben();
		Kontonummer[1526].datenAusgeben();
		Kontonummer[1423].überweisen(1526, 300);
		Kontonummer[1423].datenAusgeben();
		Kontonummer[1526].datenAusgeben();
		
	}

}
```

Mein Problem: bei überweisung wie schaffe ich es das er den Betrag von einem Konto abhebt und auf ein anderes Transferiert. Egal was ich auch probiere geht nicht. 

Bin für jegliche Hilfe dankbar

MFG


----------



## faetzminator (13. Jun 2012)

Statt [c]Kontonummer[1423].überweisen(1526, 300);[/c] müsste es [c]Kontonummer[1423].überweisen(Kontonummer[1526], 300);[/c] lauten.

Zu deinem Code style:
1. Variablen schreibt man Lower Camel Case, sicherlich ohne _, also z.B. [c]ichBinEineVariable[/c]
2. Gleiches für Methoden, z.B. [c]ichBinEineMethode()[/c]
3. Man sollte keine Umlaute verwenden, auch wenn das der Compiler inzwischen kann: überweisen -> ueberweisen
4. Wenn möglich, gleich englische Begriffe verwenden (transfer() statt ueberweisen())


----------



## AquaBall (13. Jun 2012)

Ist ja für einen Anfänger schon recht gut!

Und würde (sollte) an sich schon funktionieren.
Aber dein Problem liegt im Array! Du must statt der Nummer das Objekt übergeben:

```
Kontonummer[1423].überweisen(knotonummer[1526], 300);
```

Das Problem liegt in:

```
void überweisen(Konto zielKonto, double betrag) { 
        a_Kontostand -= betrag; 
        zielKonto.a_Kontostand += betrag; // Da hast du keinen Zugriff!! Wäre ja noch schöner!
    }
```

Dir fehlt noch eine Funktion Einzahlen:

```
void einzahlen(double betrag) { 
        if (betrag>0) 
            a_Kontostand += betrag; 
        else
            System.out.println("Es können nur positive Beträge eingezahlt werden!");
    }
```

Dann kannst du überweisen:

```
void überweisen(Konto zielKonto, double betrag) { 
        a_Kontostand -= betrag; 
        zielKonto.einzahlen(betrag);
    }
```

Außerdem ist das ganze als Array[] denkbar ungünstig. (Denk nur an die neue IBAN: 20 stellig!)
Das sollte mit HashMap oder etwas ähnlichem gelöst werden, ist aber nicht unbedingt eine Anfänger-Thema!
Also arbeite vorläufig nur mit (max) 3-stelligen Kontonummern!

---

Edit:
HimBromBeere hat wahrscheinlich sogar recht:
Du könntest technisch schon darauf zugreifen. 
Logisch ist's aber "nicht erlaubt".
Außerdem gehört eine Prüfung auf Positive Werte irgendwo hinein.


----------



## HimBromBeere (13. Jun 2012)

> [JAVA=59] Kontonummer[1423].überweisen(1526, 300);[/code]


Du musst der Methode aber auch ein Konto übergeben, keine einfache Zahl. Also so:
[JAVA=59]Kontonummer[1423].überweisen(knotonummer[1526], 300);[/code]

[EDIT]





			
				AquaBall hat gesagt.:
			
		

> [JAVA=25]zielKonto.a_Kontostand += betrag; // Da hast du keinen Zugriff!! Wäre ja noch schöner![/code]


[/EDIT]
Klar darf er, er befindet sich ja schließlich in der gleichen Klasse (wenngleich auch einer anderen Instanz derselben)


----------



## Phoenixrl (13. Jun 2012)

Ich danke euch vielmals für die Antworten 

hier nun der funktionierende Code:

```
class Konto{
    
    private String a_Name;
    private String a_Vorname;
    private int a_Kontonummer;
    private double a_Kontostand;
    
    
    Konto(String Name, String Vorname, int Kontonummer, double Kontostand){
        a_Name = Name;
        a_Vorname = Vorname;
        a_Kontonummer = Kontonummer;
        a_Kontostand = Kontostand;
    }
    
    void datenAusgeben(){
        System.out.println("---------------------------------");
        System.out.println("Information über Kontonummer: " +a_Kontonummer);
        System.out.println("Name:\t\t " +a_Name);
        System.out.println("Vorname:\t " +a_Vorname);
        System.out.println("Kontostand:\t " +a_Kontostand);
    }
    void überweisen(Konto zielKonto, double betrag) { 
        a_Kontostand -= betrag; 
        zielKonto.a_Kontostand += betrag;
        
    }
}
 
class Girokonto extends Konto{
    
    Girokonto(String Name, String Vorname, int Kontonummer, int Kontostand){
        super(Name, Vorname, Kontonummer, Kontostand);
    }   
}
 
class Festgeldkonto extends Konto{
    
    Festgeldkonto(String Name, String Vorname, int Kontonummer, int Kontostand){
        super(Name, Vorname, Kontonummer, Kontostand);
    }
}
class Sparbuch extends Konto{
    
    Sparbuch(String Name, String Vorname, int Kontonummer, int Kontostand){
        super(Name, Vorname, Kontonummer, Kontostand);
    }
}
 
public class Bankenprogramm {
 
    public static void main(String[] args) {
        Konto Kontonummer[] = new Konto[10000];
        Kontonummer[1423] = new Girokonto("Papadomus", "Assa", 1423, 10000);
        Kontonummer[1526] = new Girokonto("Proper", "Meister", 1526, 2563);
        Kontonummer[1444] = new Sparbuch("Gates", "Bill", 1444, 15425);
        Kontonummer[1423].datenAusgeben();
        Kontonummer[1526].datenAusgeben();
        Kontonummer[1423].überweisen(Kontonummer[1526], 300);
        Kontonummer[1423].datenAusgeben();
        Kontonummer[1526].datenAusgeben();   
    }
}
```

Danke nochmals für die super Antworten

Ausgabe:


----------



## Crian (13. Jun 2012)

Dann nimm dir bitte nun auch die anderen Bemerkungen zu Umlauten, deutschen Bezeichnern, fehlenden Abfragen auf positive Beträge etc. zu Herzen.

Diese 'a_' solltest du dir auch sparen. Jede brauchbare IDE hebt diese hervor, so dass sie sich von lokalen Variablen abheben.


----------



## faetzminator (13. Jun 2012)

Nachtrag: Falls du das versuchen wirst, wirst du sicher in das Problem laufen, dass du gleichnamige Methodenvariablen wie Klassenvariablen besitzt. Dann kannst du mit [c]this.variablenName[/c] auf die Klassenvariable zugreifen und mit [c]variablenName[/c] auf die lokale.


----------



## AquaBall (13. Jun 2012)

Noch ein Nachtrag: 
Statt 
	
	
	
	





```
datenAusgeben
```
würde es sich anbieten, die 
	
	
	
	





```
toString
```
-Methode zu überschreiben.
(soweit bist du sicher schon)

Dann würde deine Zeile heißen:
[JAVA=60]        System.out.println(Kontonummer[1423].toString());
        System.out.println(Kontonummer[1526].toString());
[/code]

Dann kannst du auch viel einfacher auf jedes Medium schreiben. (z.B. LogDatei, oder DatenExport, ...)


----------



## flopalko (13. Jun 2012)

AquaBall hat gesagt.:


> Noch ein Nachtrag:
> Statt
> 
> 
> ...



Du könntest dann auch noch ausnutzen, dass Java, wenn du System.out.print*() ein Objekt übergibst automatisch die toString-Methode ausgeführt wird. Daher kannst du dir Tipparbeit ersparen und einfach schreiben:

```
System.out.println(Kontonummer[1423]);
```


----------



## Phoenixrl (14. Jun 2012)

Hallo nochmals, nun ein ein neus Problem.
wie folgt das Problem ist jede der im obigen code bekommt über die Vererbung einen Namen Kontonummer und und und wie kann ich es machen das z.b Kunde 1 mit dem Namen Hans seine Konten aufgelistet werden. Geht das überhaupt so oder muss ich wieder eine neue Klasse erstellen und die dann miteinander verknüpfen?


----------



## flopalko (14. Jun 2012)

Also du kannst entweder durch dein array durchiterieren, den Namen zu jedem Konto mit dem gesuchten vergleichen und falls dies zutrifft die Kontodaten ausgeben. Dies ist die schlechteste Methode von denen, die ich noch erläutern werde.
Eine andere Möglichkeit wäre, dass du statt eines arrays eine Liste verwendest, denn dann hast du nicht sinnlos sehr viele leere Stellen durch die du auch durchiterieren musst. An die Liste hängst du dann einfach immer ein neues Konto an. Dann kannst du zwar nicht mehr direkt sagen, dass du auf diese Kontonummer zugreifen willst - so wie du es bei deinem array getan hast, da du da die Nummer einfach als Index genommen hast -, sondern musst dir dafür halt eine Methode schreiben. Dies ist mMn die zweitbeste Möglichkeit.

Das beste wäre meiner Meinung nach, wenn du noch eine Klasse Kunde machst - mit Attributen zB. Name, Adresse und einer Liste von Kontonummern. So kannst du dann nämlich leicht auf alle Konten eines bestimmten Kunden zugreifen.


----------



## Crian (14. Jun 2012)

Es bietet sich einen Map an um von den Kontonummern auf die Kontodaten zuzugreifen.


----------



## Crian (14. Jun 2012)

Ich hab dein Programm mal entsprechend bearbeitet:

Deine ehemalige Klasse Konto:


```
package forumProblems.bank;

public class Account {
    private Customer customer;
    private int number;
    private double balance; // sollte lieber int oder long in cent oder so sein

    public Account(Customer customer, int number, double balance){
        this.customer = customer;
        this.number = number;
        this.balance = balance;
    }

    void transfer(Account target, double ammount) {
        if (ammount < 0) {
            throw new RuntimeException("transfer: negative ammount "
                    + Double.toString(ammount) + " is not permitted");
        }
        balance -= ammount;
        target.balance += ammount;
    }

    @Override
    public String toString() {
        return "Account[customer=" + customer + ", number=" + number
                + ", balance=" + balance + "]";
    }
}
```

Eine neue Kunden-Klasse:


```
package forumProblems.bank;

public class Customer {
    private String surname;
    private String forename;

    public Customer(String surname, String forename) {
        this.surname = surname;
        this.forename = forename;
    }

    public String getSurname() {
        return surname;
    }

    public String getForename() {
        return forename;
    }

    @Override
    public String toString() {
        return "Customer[surname=" + surname + ", forename=" + forename
                + "]";
    }
}
```

Deine Klasse Girokonto:


```
package forumProblems.bank;

public class GiroAccount extends Account {
    public GiroAccount(Customer customer, int number, double balance) {
        super(customer, number, balance);
    }
}
```

Deine Klasse Sparbuch:


```
package forumProblems.bank;

public class SavingsBook extends Account {
    public SavingsBook(Customer customer, int number, double balance) {
        super(customer, number, balance);
    }
}
```

Und eine testweise Bankverwaltung:


```
package forumProblems.bank;

import java.util.HashMap;
import java.util.Map;

public class Bank {

    public static void main(String[] args) {
        /* Ein paar Kunden: */
        Customer papadomus = new Customer("Papadomus", "Assa");
        Customer proper = new Customer("Proper", "Meister");
        Customer gates = new Customer("Gates", "Bill");

        /* Kontenverwaltung: */
        Map<Integer,Account> accounts = new HashMap<Integer,Account>();

        /* Ein paar Konten anlegen: */
        int number1 = 1423;
        accounts.put(number1, new GiroAccount(papadomus, number1, 10000));

        int number2 = 1526;
        accounts.put(number2, new GiroAccount(proper, number2, 2563));

        int number3 = 1444;
        accounts.put(number3, new GiroAccount(gates, number3, 15425));

        /* Ein paar Vorgänge: */
        System.out.println("------------------Anfangs-Stand------------------");
        printAccount(accounts.get(number1));
        printAccount(accounts.get(number2));
        accounts.get(number1).transfer(accounts.get(number2), 300.0);
        System.out.println("--------------------End-Stand--------------------");
        printAccount(accounts.get(number1));
        printAccount(accounts.get(number2));
    }

    private static void printAccount(Account account) {
        System.out.println(account);
    }

}
```

Ausgabe:


```
------------------Anfangs-Stand------------------
Account[customer=Customer[surname=Papadomus, forename=Assa], number=1423, balance=10000.0]
Account[customer=Customer[surname=Proper, forename=Meister], number=1526, balance=2563.0]
--------------------End-Stand--------------------
Account[customer=Customer[surname=Papadomus, forename=Assa], number=1423, balance=9700.0]
Account[customer=Customer[surname=Proper, forename=Meister], number=1526, balance=2863.0]
```


----------



## Phoenixrl (14. Jun 2012)

Hab das erstmal so gelöst aber hab ja noch sehr viel daran zu machen und an automatisierungstechniken zu basteln.



```
class Konto{
	
	protected String Name;
	protected String Anschrift;
	protected String Ort;
	protected double Kontostand;
	protected int Kontonummer;
	protected int PLZ;
	
	Konto(int aKontonummer, double aKontostand){
		this.Kontonummer = aKontonummer;
		this.Kontostand = aKontostand;
	}
	Konto(String Name, String Anschrift, int PLZ, String Ort){
		this.Name = Name;
		this.Anschrift = Anschrift;
		this.PLZ = PLZ;
		this.Ort = Ort;
	}
	
	void datenAusgeben(){
		System.out.println("------------------------------------------");
		System.out.println("Informationen über Kunden");
		System.out.println("Kundenname: " +Name);
		System.out.println("Anschrift : " +Anschrift);
		System.out.println("PLZ ORT   : " +PLZ +" " +Ort);

	}
	void getKontostand(){
		System.out.println("-------Konto-----------");
		System.out.println(+this.Kontonummer);
		System.out.println(+this.Kontostand);
		System.out.println("-----------------------");
	}
	void überweisen(Konto zielKonto, double Betrag){
		Kontostand -= Betrag;
		zielKonto.Kontostand += Betrag;
	}
}

class Girokonto extends Konto{

	Girokonto(int Kontonummer, double Kontostand) {
		super(Kontonummer, Kontostand);		
	}
}
	
class Sparbuch extends Konto{

	Sparbuch(int Kontonummer, double Kontostand) {
		super(Kontonummer, Kontostand);

	}
}

class Festgeldkonto extends Konto{

	Festgeldkonto(int Kontonummer, double Kontostand) {
		super(Kontonummer, Kontostand);
		
	}
}

public class Bankenverwaltung {

	public static void main(String[] args) {
		Konto Kundenkonto[][] = new Konto[100][4];
		Kundenkonto[1][0] = new Konto("Bill Gates", "Microsoft Own You", 36353, "Asee");
		Kundenkonto[1][1] = new Girokonto(265899955, 20);
		Kundenkonto[1][2] = new Sparbuch(265899954, 300);
		Kundenkonto[1][0].datenAusgeben();
		Kundenkonto[1][1].getKontostand();
		Kundenkonto[1][2].getKontostand();
		Kundenkonto[2][0] = new Konto("Steve Jobs", "Apple Mania 24", 12545, "Amaesd");
		Kundenkonto[2][1] = new Girokonto(152658755, 2000);
		Kundenkonto[2][1].getKontostand();
		Kundenkonto[2][1].überweisen(Kundenkonto[1][1], 20);
		Kundenkonto[1][1].getKontostand();
		Kundenkonto[2][1].getKontostand();
			
	}
}
```

eigentlich auch nicht schlecht das mehrdimensionale array später kann ich durch eine funktionen und 2 for schleifen das array befüllen und mit length+1 ein neues erstellen (theoretisch) :bae:


----------



## AquaBall (14. Jun 2012)

Wie du selbst erkannt hast, unterscheidet sich dein 
	
	
	
	





```
Kundenkonto[x][0]
```
 von den anderen 
	
	
	
	





```
Kundenkonto[x][1-3]
```
!
Logisch, weil du ja auch KundenDaten brauchst.
Andererseits ist z.B. dein Konto 265899955 herrenlos, weil ja keine Verbindung zu einem Kunden besteht!
Nur "zufällig" steht in deinem Array als Nachbar ein Konto mit Besitzer.
Du hast keine Garantie, dass das immer gewährleistet ist, und du hast keine logische Verknüpfung 

Das SCHREIT geradezu nach einer getrennten Klasse 
	
	
	
	





```
Kunde
```
!

```
class Kunde {
... name
... liste der Konten
}
```
Und Änderung der Klasse 
	
	
	
	





```
Konto
```


```
class Konto {
... nummer
... stand
... besitzer(=Kunde)
}
```
Musst du im nächsten Wissens-Level unbedingt einführen.


----------



## HimBromBeere (15. Jun 2012)

Die Lösung als Array ist nicht wirklich gut, jedenfalls nicht aus sicht der Objektorientierung. Wie Aqua schon sagte: bau dir eine Klasse Kunde mit einer Liste von Konten darin. Dann hast du immer die Beziehung Kunde-Konto und nicht eine nur schwer zu durchschauende über den ArrayIndex. Im Übrigen wird man von einer Methode mit namen getKontostand erwarten, dass sie den Kontostand zurückgibt (als Zahl) und ihn nicht ausgibt. Benenne die methode um (z.B. printKontostand oder ausgabeKontostand) oder mach sie zu einem echten Getter.


----------



## Crian (15. Jun 2012)

Wozu hab ich das oben beispielhaft vorgeführt, mit neuer Kundenklasse?


----------

