# Problem mit Kontoverwaltung



## WusAA28 (6. Jan 2014)

Hallo 
Ich habe ein Problem mit meiner Kontoverwaltung und hoffe ihr könnt mir weiter helfen 

Und zwar habe ich schon folgenden Java code programmiert 


```
import javax.swing.JOptionPane;


public class Main {

	public static void main(String[] args) 
	{
	// Variabeln definieren
		
		
		String[] Kontoname = new String[20];
		int[] Kontonummer = new int[20];
		int[] Kontobestand = new int[20];
		
		
		Object[] options = {"Konto anlegen", "Abbrechen"};
		 
         int auswahl1 = JOptionPane.showOptionDialog(null,
                                                     "Treffen Sie eine Auswahl",
                                                     "Überischt",
                                                     JOptionPane.DEFAULT_OPTION, 
                                                     JOptionPane.INFORMATION_MESSAGE, 
                                                     null, options, options[0]);
         System.out.println(auswahl1);
         
         switch(auswahl1){
         case 0:
        	 for(int i=0; i<5; i++)
     		{
        		 
     				Kontoname[i] = JOptionPane.showInputDialog(null,"Name des Kontoinhabers",
                     "Kontoverwaltung",
                     JOptionPane.PLAIN_MESSAGE);
     				System.out.println(Kontoname[i]);
     				
     				Kontonummer[i] = Integer.valueOf(JOptionPane.showInputDialog(null,"Kontonummer des Kontoinhabers",
     		        "Kontoverwaltung",
     		        JOptionPane.PLAIN_MESSAGE));
     				System.out.println(Kontonummer[i]);
     						
     				Kontobestand[i] = Integer.valueOf(JOptionPane.showInputDialog(null,"Kontobestand des Kontoinhabers",
     		        "Kontoverwaltung",
     		        JOptionPane.PLAIN_MESSAGE));
     				System.out.println(Kontobestand[i]);		
	
     		}

             break; 
         case 1:
        	 JOptionPane.showMessageDialog(null,
                     "Kontoverwaltung wurde abgebrochen",
                     "Abbruch",                                       
                     JOptionPane.WARNING_MESSAGE);	 
	}

         Object[] options2 = {"Konten anlegen", "Konto löschen" , "Einzahlen" , "Auszahlen" , "Abbrechen"};
         
    	 
		int auswahl2 = JOptionPane.showOptionDialog(null,
    			 "Inhaber: " +	Kontoname[i]+" KtoNr. :  "+ Kontonummer[i] + " Ktobst. : " + Kontobestand[i] +"\n" ,
                 "Kontoverwaltung" ,
                 JOptionPane.DEFAULT_OPTION, 
                 JOptionPane.INFORMATION_MESSAGE, 
                 null, options2, options[0]);
	
    	 System.out.println(auswahl2);
    	 
    	 switch(auswahl2){
         case 0:
        	 for(int i=; i<6; i++)
        {			 Kontoname[i] = JOptionPane.showInputDialog(null,"Name des Kontoinhabers",
                     "Kontoverwaltung",
                     JOptionPane.PLAIN_MESSAGE);
     				System.out.println(Kontoname[i]);
     				
     				Kontonummer[i] = Integer.valueOf(JOptionPane.showInputDialog(null,"Kontonummer des Kontoinhabers",
     		        "Kontoverwaltung",
     		        JOptionPane.PLAIN_MESSAGE));
     				System.out.println(Kontonummer[i]);
     						
     				Kontobestand[i] = Integer.valueOf(JOptionPane.showInputDialog(null,"Kontobestand des Kontoinhabers",
     		        "Kontoverwaltung",
     		        JOptionPane.PLAIN_MESSAGE));
     				System.out.println(Kontobestand[i]);
        }
             break;
         case 1:
             System.out.println("i ist eins");
             break;
         case 2:
             System.out.println("i ist zwei");
             break;
         case 3:
             System.out.println("i ist drei");
             break;
         case 4:
        	 JOptionPane.showMessageDialog(null,
                     "Kontoverwaltung wurde abgebrochen",
                     "Abbruch",                                       
                     JOptionPane.WARNING_MESSAGE);
         } 
    	
    	 
    	 
    	 
}
}
```

Nun möchte ich mir meine erstellten Konten mit dem Befehl anzeigen lassen, doch leider klappt dies nicht =(

```
nt auswahl2 = JOptionPane.showOptionDialog(null,
    			 "Inhaber: " +	Kontoname[i]+" KtoNr. :  "+ Kontonummer[i] + " Ktobst. : " + Kontobestand[i] +"\n" ,
                 "Kontoverwaltung" ,
                 JOptionPane.DEFAULT_OPTION, 
                 JOptionPane.INFORMATION_MESSAGE, 
                 null, options2, options[0]);
```

Ich hoffe ihr versteht mein Problem und könnt mir helfen


----------



## turtle (6. Jan 2014)

Mir fallen verschiedene Dinge im Code auf, die du zunächst ändern solltest.

Variable beginnen per Konvention mit einem kleinBuchstabe.
Es gehören Konto-nummer(bestand, name) zusammen und dafür solltest du eine eigene Klasse schreiben.

```
class Konto {
private String nummer;
private String bestand; // oder private double bestand?)
private String name;
// getter/setter
}
```
Ich finde Kommentare eigentlich fast immer schlecht. Der Code ist dann nicht aussagekräftig genug. Und dein Kommentar "Variabeln definieren" ist schlichtweg überflüssig.
Du solltest dir überlegen, wie der Benutzer mit deinem Programm arbeitet. Erst durch den Blick in den Code sah ich, dass du anscheinend 5 Konten einrichten möchtest. Das ist aber zum Test einer Abfrage hinderlcch weil ich erst durch eine Unmenge an Fragen "genervt" bin. 
Nichts spricht dagegen eine Abfrage bereits zu machen, nachdem ein Konto eingerichtet ist. Dies scheinst du aber gar nicht vorzusehen

```
Object[] options = {"Konto anlegen", "Abbrechen"};
```
Hier ist schlecht, das du sobald du die reihenfolge änderst, auch den Code anpassen muss.

Dein Programm sollte vielleicht besser so etwas machen

```
Map<String, Konto> alleKonten = new HashMap<>();
/// Beim Einrichten
alleKonten.put(kontoNummer, new Konto(kontoNummer, kontoName, kontoBestand));
// Bei abfrage
Konto konto = alleKonten.get(kontoNummer);
System.out.println(konto.getBestand());
```


----------



## WusAA28 (6. Jan 2014)

Hallo
Schon mal vielen Dank für deine Antwort. Das Problem ist nur das ich ein totaler Anfänger in Java bin und ich vieles von deinen Tipps nicht einmal umsetzen kann. Ich werde es trotzdem mal probieren.


----------



## turtle (6. Jan 2014)

> Ich werde es trotzdem mal probieren.


Das finde ich gut:toll:

In der Zwischenzeit habe ich das Programm geändert,so das wir Schritt für Schritt durchgehen können.
Was ich gemacht habe:

Kommentare entfernt
Eigene Kontoklasse
enum für Aktion (Anlegen, Abfragen, Cancel)
Kontobestand als double
Parsen der Eingabe und Wandeln in double Wert
Sag mir bei welchem Schritt du weitere Hilfe benötigst.


----------



## WusAA28 (7. Jan 2014)

Hallo, ich finde es schon mal super nett das du mit weiter hilfst 

Nun habe ich deinen 1  Schritt befolgt, das heißt die Kommentare gelöscht doch schon beim 2 Schritt fangen bei mir die Probleme an . Ich habe probiert diese Kontoklassen anzulegen doch wie kann ich dieses jetzt wieder als Arrays setzten. 

Das einzige was bis jetzt schon an der Kontoverwaltung funktioniert ist das Abbrechen ;(

Was ich immer noch nicht verstehe ist wie ich mein Übersichtsfenster nach jeden Befehl aktualisiert wieder angezeigt bekomme. Was ich meine ist zum Beispiel wenn ich am Anfang meine 5 Konten angelegt habe und dann auf neues Konto anlegen drücke, dort ein Konto anlege das es mir dann als 6 Konto angezeigt wird, doch leider wird es mir dann nur in der Konsole ausgegeben.


----------



## turtle (7. Jan 2014)

Eines nach dem Anderen...

 Zunächst wäre es hilfreich wenn du deinen aktuellen Code zeigen könntest, damit ich es mit meiner Version abgleichen kann.


> Ich habe probiert diese Kontoklassen anzulegen doch wie kann ich dieses jetzt wieder als Arrays setzten.


Das liegt daran, das ich kein Freund von Arrays bin. Diese haben den gravierenden Nachteil, das sie nicht ihre Größe ändern können.  Das ist doof, da wir ja eine beliebige Anzahl von Konten haben möchten.

Daher scheint mir ein List<Konto> besser zu sein. Aber halt, Suchen wollen wir ja später auch und wollen zu einer Kontonummer alle Kontodaten wissen. Dies nennt man eine Map. Also habe ich 
Map<Integer, Konto> genommen.
Und da wir ja in main alleKonten wissen müssen, steht bei mir

```
Map<Integer, Konto> alleKonten = new HashMap<>();
```
Damit solltest du in der Lage sein, weiter zu machen


> mein Übersichtsfenster nach jeden Befehl aktualisiert wieder angezeigt bekomme


Es sollte dir jetzt klar sein. Weil in main ALLE Konten bekannt sind, kann das Übersichtsfenster auf alle Konten zugreifen und anzeigen. Es ist klar, das dies bereits definierte Konten (ohne Benutzereingabe) oder neu angelegte Konten sein können.


----------



## WusAA28 (7. Jan 2014)

Ich habe die Sachen die du mir oben empfohlen hast in meinen Code eingefügt. Dieser sieht jetzt wie folgt aus:


```
import javax.swing.JOptionPane;


public class Main {

	public static void main(String[] args) 
	{
	
	    class Konto {
	        private String nummer;
	        private String bestand; 
	        private String name;
	        
	        }
		
	
	    Map<String, Konto> alleKonten = new HashMap<>();
	    
	    alleKonten.put(kontoNummer, new Konto(kontoNummer, kontoName, kontoBestand));
	   
	    Konto konto = alleKonten.get(kontoNummer);
	    System.out.println(konto.getBestand());
	   
		
		Object[] options = {"Konto anlegen", "Abbrechen"};
		 
         int auswahl1 = JOptionPane.showOptionDialog(null,
                                                     "Treffen Sie eine Auswahl",
                                                     "Überischt",
                                                     JOptionPane.DEFAULT_OPTION, 
                                                     JOptionPane.INFORMATION_MESSAGE, 
                                                     null, options, options[0]);
         System.out.println(auswahl1);
         
         switch(auswahl1){
         case 0:
        	 for(int i=0; i<1; i++)
     		{
        		 
     				Konto.name[i] = JOptionPane.showInputDialog(null,"Name des Kontoinhabers",
                     "Kontoverwaltung",
                     JOptionPane.PLAIN_MESSAGE);
     				System.out.println(Kontoname[i]);
     				
     				Konto.nummer[i] = Integer.valueOf(JOptionPane.showInputDialog(null,"Kontonummer des Kontoinhabers",
     		        "Kontoverwaltung",
     		        JOptionPane.PLAIN_MESSAGE));
     				System.out.println(Kontonummer[i]);
     						
     				Konto.bestand[i] = Integer.valueOf(JOptionPane.showInputDialog(null,"Kontobestand des Kontoinhabers",
     		        "Kontoverwaltung",
     		        JOptionPane.PLAIN_MESSAGE));
     				System.out.println(Kontobestand[i]);		
	
     		}

             break; 
         case 1:
        	 JOptionPane.showMessageDialog(null,
                     "Kontoverwaltung wurde abgebrochen",
                     "Abbruch",                                       
                     JOptionPane.WARNING_MESSAGE);	 
	}

         Object[] options2 = {"Konten anlegen", "Konto löschen" , "Einzahlen" , "Auszahlen" , "Abbrechen"};
         
    	 
		int auswahl2 = JOptionPane.showOptionDialog(null,
    			 "Inhaber: " +	Kontoname[1]+" KtoNr. :  "+ Kontonummer[1] + " Ktobst. : " + Kontobestand[1] +"\n" ,
                 "Kontoverwaltung" ,
                 JOptionPane.DEFAULT_OPTION, 
                 JOptionPane.INFORMATION_MESSAGE, 
                 null, options2, options[0]);
	
    	 System.out.println(auswahl2);
    	 
    	 switch(auswahl2){
         case 0:
        	 for(int i=1; i<2; i++)
        {			 Kontoname[i] = JOptionPane.showInputDialog(null,"Name des Kontoinhabers",
                     "Kontoverwaltung",
                     JOptionPane.PLAIN_MESSAGE);
     				System.out.println(Kontoname[i]);
     				
     				Kontonummer[i] = Integer.valueOf(JOptionPane.showInputDialog(null,"Kontonummer des Kontoinhabers",
     		        "Kontoverwaltung",
     		        JOptionPane.PLAIN_MESSAGE));
     				System.out.println(Kontonummer[i]);
     						
     				Kontobestand[i] = Integer.valueOf(JOptionPane.showInputDialog(null,"Kontobestand des Kontoinhabers",
     		        "Kontoverwaltung",
     		        JOptionPane.PLAIN_MESSAGE));
     				System.out.println(Kontobestand[i]);
        }
             break;
         case 1:
             System.out.println("i ist eins");
             break;
         case 2:
             System.out.println("i ist zwei");
             break;
         case 3:
             System.out.println("i ist drei");
             break;
         case 4:
        	 JOptionPane.showMessageDialog(null,
                     "Kontoverwaltung wurde abgebrochen",
                     "Abbruch",                                       
                     JOptionPane.WARNING_MESSAGE);
         } 
    	
    	 
    	 
    	 
}
}
```

Doch irgendwie stimmen jetzt meine Variabeln alle nicht mehr, wobei es sich doch um die gleichen Namen handelt.

Die Logik hinter deinen Vorschlägen verstehe ich auch und finde sie auch wirklich gut nur leider weis ich diese nicht umzusetzen.


----------



## turtle (7. Jan 2014)

> alleKonten.put(kontoNummer, new Konto(kontoNummer, kontoName, kontoBestand));


Das sieht für mich korrekt aus, aber..:toll:

Diese Zeile würde ich machen, innerhalb des Handlings von "Konto anlegen". Da wäre aus meiner Sicht keine Schleife, sonder "nur" die Abfrage der Daten zu einem Konto. dann Erzeugen new Konto(...) und am Schluss der Map bekannt machen (alleKonten.put)

Damit du beim Testen  nicht jedesmal erst ein Konto angelegen musst, beginnt meine main folgendermassen

```
Map<Integer, Konto> alleKonten = new HashMap<>();
	    // @formatter:off
	    Konto[] defaultKonten = new Konto[] { 
		    new Konto(4711, "Turtle", 1234.56), };
	    // @formatter:on
	    for (Konto konto : defaultKonten) {
		alleKonten.put(konto.getKontoNummer(), konto);
	    }
```



> Konto konto = alleKonten.get(kontoNummer);
> System.out.println(konto.getBestand());


Das sieht für mich korrekt aus, aber..:toll:
Diese Zeilen würde ich machen, innerhalb des Handlings von "Konto abfragen".


----------



## WusAA28 (7. Jan 2014)

Um ehrlich zu ein komm ich jetzt überhaupt nicht mehr mit ;shock::bahnhof:

Der Code läst sich jetzt auch nicht mehr ausführen und ich habe  26 Errors :autsch:

Das Problem beginnt schon am Anfang das er die Variableln nicht mehr anerkennt, da steht dann immer " i cannot be resolved to a variable" 

Mit deinen Code ausschnitten kann ich leider auch nichts anfangen weil ich schlicht weg nicht weis wo ich sie einzufügen haben 

Wie oben empfohlen habe ich die Codezeile jetzt dort eingefügt

```
witch(auswahl1){
         case 0:
        	 alleKonten.put(kontoNummer, new Konto(kontoNummer, kontoName, kontoBestand));
     		{
        		 
     				Konto.name[i] = JOptionPane.showInputDialog(null,"Name des Kontoinhabers",
                     "Kontoverwaltung",
                     JOptionPane.PLAIN_MESSAGE);
     				System.out.println(Kontoname[i]);
     				
     				Konto.nummer[i] = Integer.valueOf(JOptionPane.showInputDialog(null,"Kontonummer des Kontoinhabers",
     		        "Kontoverwaltung",
     		        JOptionPane.PLAIN_MESSAGE));
     				System.out.println(Kontonummer[i]);
     						
     				Konto.bestand[i] = Integer.valueOf(JOptionPane.showInputDialog(null,"Kontobestand des Kontoinhabers",
     		        "Kontoverwaltung",
     		        JOptionPane.PLAIN_MESSAGE));
     				System.out.println(Kontobestand[i]);		
	
     		}

             break;
```

Doch das nützt mir leider alles nichts da sich mein Programm nicht mehr ausführen lässt.


----------



## turtle (7. Jan 2014)

Nur keine Panik



> Konto.name_
> _


_
Wir haben kein Array von Konten mehr. Weiterhin hast du dann natürlich auch keinen i-Index mehr.


		Java:In die Zwischenablage kopieren


                   JOptionPane.showInputDialog(null,"Name des Kontoinhabers",
                     "Kontoverwaltung",
                     JOptionPane.PLAIN_MESSAGE);

Diese Funktion liefert dir genau den String zurück der eingegeben wurde. Also musst du den Rückgabewert nur in einer variable speichern.


		Java:In die Zwischenablage kopieren


String kontoName = JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE)

;
Analog bei den anderen Abfragen.

Und NACH der Zeile 
   System.out.println(Kontobestand);
ist doch die Eingabe aller Kontodaten fertig. Also können wir hier ein Konto erzeugen und dann der Map hinzufügen._


----------



## WusAA28 (7. Jan 2014)

Meine Code sieht jetzt so aus 

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

import javax.swing.JOptionPane;


public class Main {

	public static void main(String[] args) 
	{
	
	    class Konto {
	        private String nummer;
	        private String bestand; 
	        private String name;
	        
	        }
		
	
	    Map<Integer, Konto> alleKonten = new HashMap<>();   
		
		Object[] options = {"Konto anlegen", "Abbrechen"};
		 
         int auswahl1 = JOptionPane.showOptionDialog(null,
                                                     "Treffen Sie eine Auswahl",
                                                     "Überischt",
                                                     JOptionPane.DEFAULT_OPTION, 
                                                     JOptionPane.INFORMATION_MESSAGE, 
                                                     null, options, options[0]);
         System.out.println(auswahl1);
         
         switch(auswahl1){
         case 0:
        	 
			alleKonten.put(Konto.nummer, new Konto(kontonummer, kontoName, kontoBestand));
     		{
        		 
     		    String kontoName = JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE);
     				
     		    String kontoNummer = JOptionPane.showInputDialog(null, "Kontonummer", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE);		
	
     		    String kontobestand = JOptionPane.showInputDialog(null, "Kontobestand", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE);		
     		}

             break; 
         case 1:
        	 JOptionPane.showMessageDialog(null,
                     "Kontoverwaltung wurde abgebrochen",
                     "Abbruch",                                       
                     JOptionPane.WARNING_MESSAGE);	 
	}

         Object[] options2 = {"Konten anlegen", "Konto löschen" , "Einzahlen" , "Auszahlen" , "Abbrechen"};
         
    	 
		int auswahl2 = JOptionPane.showOptionDialog(null,
    			 "Inhaber: " +	Konto.name +" KtoNr. :  "+ Konto.nummer + " Ktobst. : " + Konto.bestand +"\n" ,
                 "Kontoverwaltung" ,
                 JOptionPane.DEFAULT_OPTION, 
                 JOptionPane.INFORMATION_MESSAGE, 
                 null, options2, options[0]);
	
    	 System.out.println(auswahl2);
    	 
    	 switch(auswahl2){
         case 0:
        
             break;
         case 1:
             System.out.println("i ist eins");
             break;
         case 2:
             System.out.println("i ist zwei");
             break;
         case 3:
             System.out.println("i ist drei");
             break;
         case 4:
        	 JOptionPane.showMessageDialog(null,
                     "Kontoverwaltung wurde abgebrochen",
                     "Abbruch",                                       
                     JOptionPane.WARNING_MESSAGE);
         } 
    	
    	 
    	 
    	 
}
}
```


Doch ich bekomme immer noch Fehler hier 

```
alleKonten.put(Konto.nummer, new Konto(kontonummer, kontoName, kontoBestand));
```

und dort 

```
int auswahl2 = JOptionPane.showOptionDialog(null,
    			 "Inhaber: " +	Konto.name +" KtoNr. :  "+ Konto.nummer + " Ktobst. : " + Konto.bestand +"\n" ,
                 "Kontoverwaltung" ,
                 JOptionPane.DEFAULT_OPTION, 
                 JOptionPane.INFORMATION_MESSAGE, 
                 null, options2, options[0]);
```
angezeigt. Ich weis nicht warum aber irgendwie nimmt er diese Variabeln nicht an:bahnhof:

Und dann hätte ich nochmal eine Frage könnte ich mir das erste switch case nicht vollkommen sparen?


----------



## turtle (7. Jan 2014)

na, du musst aber schon den Haupcomputer (der zwischen deinen beiden Ohren booten

```
alleKonten.put(Konto.nummer, new Konto(kontonummer, kontoName, kontoBestand));
            {
                 
                String kontoName = JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE);
                    
                String kontoNummer = JOptionPane.showInputDialog(null, "Kontonummer", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE);        
    
                String kontobestand = JOptionPane.showInputDialog(null, "Kontobestand", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE);      
            }
```
Wo kann hier der Fehler sein?

Nun du willst ein Konto erzeugen mit einer kontnummer, kontoName und kontoBestand. Aber diese Werte fragst du ja gar nicht vorher ab!
Mein Code sieht an dieser Stelle so aus:

```
String kontoName = JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE);
		    System.out.println(kontoName);

		    int kontonummer = Integer.valueOf(JOptionPane.showInputDialog(null, "Kontonummer des Kontoinhabers", "Kontoverwaltung",
			    JOptionPane.PLAIN_MESSAGE));
		    System.out.println(kontonummer);

		    String kontobestand = JOptionPane.showInputDialog(null, "Kontobestand des Kontoinhabers", "Kontoverwaltung",
			    JOptionPane.PLAIN_MESSAGE);
		    NumberFormat numberFormat = NumberFormat.getInstance(Locale.GERMAN);
		    Number number = numberFormat.parse(kontobestand);
		    System.out.println(kontobestand);
		    alleKonten.put(kontonummer, new Konto(kontonummer, kontoName, number.doubleValue()));
```
Der Code mit NumberFormat war eigentlich für später gedacht (Punkt-5)


> Und dann hätte ich nochmal eine Frage könnte ich mir das erste switch case nicht vollkommen sparen?


Ganz im Gegenteil. Bei mir sehen die Option aber auch anders aus.

```
Object[] options = { "Konto anlegen", "Konto abfragen", "Abbrechen" };
```
Aber dann ist "Konto anlegen"=Index:0, "Konto abfragen"=Index:1, ""Abbrechen"=Index:2 
Deshalb musst du dann die Abfragen anpassen.
Ich sehe auch (noch) nicht, das du ein Default-Konto anlegst, damit du dir die Tipparbeit sparst. Fände ich hilfreich, weil du dann weisst das zumindest ein Konto angelegt worden ist.

```
// @formatter:off
	    Konto[] defaultKonten = new Konto[] { 
		    new Konto(4848, "Turtle", 1234.56), };
	    // @formatter:on
	    for (Konto konto : defaultKonten) {
		alleKonten.put(konto.getKontoNummer(), konto);
	    }
	    Object[] options = ...
```


----------



## WusAA28 (8. Jan 2014)

Hallo

Ich habe jetzt erstmal bei meinem Code die zweite switch case Anweisung rausgenommen und probiere jetzt erstmal die erste Fehlerfrei hinzubekommen. Mein Code sieht jetzt wie folgt aus:


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

import javax.swing.JOptionPane;


public class Main {

	private static final char[] Konto = null;

	public static void main(String[] args) 
	{
	
	    class Konto {
	        private String nummer;
	        private String bestand; 
	        private String name;
			public Konto(int i, String string, double d) {
				
			}
			public Integer getKontoNummer() {
				
				return null;
			}
	        
	        }
		
	
	    Map<Integer, Konto> alleKonten = new HashMap<>();   
		
	    Object[] options = { "Konto anlegen", "Konto abfragen", "Abbrechen" };
		 
         int auswahl1 = JOptionPane.showOptionDialog(null,
                                                     "Treffen Sie eine Auswahl",
                                                     "Überischt",
                                                     JOptionPane.DEFAULT_OPTION, 
                                                     JOptionPane.INFORMATION_MESSAGE, 
                                                     null, options, options[0]);
         System.out.println(auswahl1);
         
         switch(auswahl1){
         case 0:
        	 
        	    String kontoName = JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE);
                System.out.println(kontoName);
     
                int kontonummer = Integer.valueOf(JOptionPane.showInputDialog(null, "Kontonummer des Kontoinhabers", "Kontoverwaltung",
                    JOptionPane.PLAIN_MESSAGE));
                System.out.println(kontonummer);
     
                String kontobestand = JOptionPane.showInputDialog(null, "Kontobestand des Kontoinhabers", "Kontoverwaltung",
                    JOptionPane.PLAIN_MESSAGE);
                System.out.println(kontobestand);
                    
                
                // @formatter:off
                Konto[] defaultKonten = new Konto[] {
                    new Konto(4848452, "Hans", 10), };
                // @formatter:on
                for (Konto konto : defaultKonten) {
                alleKonten.put(konto.getKontoNummer(), konto);
                }
                
                
             break; 
         case 1:
        	 
        	 break;
         case 2:
        	 JOptionPane.showMessageDialog(null,
                     "Kontoverwaltung wurde abgebrochen",
                     "Abbruch",                                       
                     JOptionPane.WARNING_MESSAGE);	 
	}

         
        
    	 
    	 
    	 
}
}
```

Nun läuft er auch schonmal wieder 

Doch leider habe ich immer noch einige Probleme, undzwar vestehe ich nicht ganz warum ich eine class Konto habe, was ist der nutzen davon? Vorher hatte ich das Problem damit das er mir die Variabeln nicht anerkannt hatte.

Das zweite Problem wäre das ich nun ein Default- Konto angelegt habe es aber nicht angezeigt bekomme.

Da ich ja jetzt keine Arrays mehr benutze, woher weis ich denn wie viele Konten ich erstellen kann? Oder ist das jetzt unbegrenzt?


----------



## turtle (8. Jan 2014)

Das sieht ja in Teilen besser aus.:applaus:



> Doch leider habe ich immer noch einige Probleme, undzwar vestehe ich nicht ganz warum ich eine class Konto habe, was ist der nutzen davon?



Nun, das ist eine normale Vorgehensweise. Man teilt ein grosses Problem in mehrere kleine auf und kann sich darauf konzentrieren die kleineren (hoffentlich einfacheren) Problemchen zu lösen. 

Du schreibst ja auch kein Programm und füllst alles in eine Klasse. Erstens wird die Klasse riesig und ist nicht mehr wartbar. Daher ist es sinnvoller kleinere Klassen zu schreiben, die genau EINEN Aspekt der Problemstellung behandeln. Bei einer KontoApp sind also alle Funktionen, die mit einem Konto zu tun haben in der Klasse Konto zu finden.

Es ist denkbar, das eine spätere Version alle Konten nicht im Speicher sondern in einer Datenbank oder Datei speichert. Es bleibt aber die Datenstruktur Konto gleich und darin die Daten (kontoNummer, kontoBestand, kontoName) zusammengefasst sind. Fällt dir später auf, das du noch beispielsweise die kontoArt (Giro,Sparbuch,...) haben möchtest, weißt du, das es ein Memberattribut von Konto sein muss.
Übrigens fehlen einige Attribute in deiner Kontoklasse.



> Das zweite Problem wäre das ich nun ein Default- Konto angelegt habe es aber nicht angezeigt bekomme.


Ich glaube, nachdem ich den Code gesehen habe, muss ich näher auf die switch-Anweisung eingehen.

Es wird eine Bedingung abgefragt und derjenige case-Fall durchlaufen bis zum nächsten Break.

Der Benutzer wählt "Konto anlegen", das ist Index-0 aus dem options-Array. 

Also springt er zum case 0. Im case-Zweig fragst du nach kontoName, kontoName, kontonummer und  kontobestand. 

Soweit richtig. Danach aber machst du etwas mit defaultKonten und das gehört hier definitiv nicht hin. Stattdessen musst du aus den angegebenen Daten ein Konto-Objekt erzeugen und 
der Map alleKonten hinzufügen. Und fertig mit Konto anlegen also break für den case-Fall.



> Da ich ja jetzt keine Arrays mehr benutze, woher weis ich denn wie viele Konten ich erstellen kann? Oder ist das jetzt unbegrenzt?


Ich habe oben ja schon beschrieben, das der Teil mit defaultKonten im Zweig bei Konto anlegen falsch ist. Der geeignete Platz ist dann gleich nach der Erstellung der Map alleKonten. 

Warum? Nun bei "Konto anlegen" wird ebenfalls der Map ein Eintrag hinzugefügt und dieses tun wir auch am Anfang ohne Eingaben gemacht zu haben. Und ja, die Anzahl ist unbegrenzt. 
Nur der verfügbare Speicher limitiert die Anzahl und wenn kein Speicher mehr vorhanden stürzt das Programm mit einer Out-of-memory-Exception (oder kurz OOME).

Oops, ist doch länger geraten.
Und wird noch länger, weil ich dir mal meine Konto-Klasse zeige

```
class Konto {
    private int kontoNummer;
    private double kontoBestand;
    private String kontoName;

    public Konto(int kontoNummer, String kontoName, double kontoBestand) {
	this.kontoNummer = kontoNummer;
	this.kontoBestand = kontoBestand;
	this.kontoName = kontoName;
    }

    public int getKontoNummer() {
	return kontoNummer;
    }

    public void setKontoNummer(int kontoNummer) {
	this.kontoNummer = kontoNummer;
    }

    public double getKontoBestand() {
	return kontoBestand;
    }

    public void setKontoBestand(double kontoBestand) {
	this.kontoBestand = kontoBestand;
    }

    public String getKontoName() {
	return kontoName;
    }

    public void setKontoName(String kontoName) {
	this.kontoName = kontoName;
    }

    @Override
    public String toString() {
	return kontoNummer + ":" + kontoBestand + ":" + kontoName;
    }
}
```


----------



## Unlikus (8. Jan 2014)

Kurze Zwischenfrage von einem Außenstehenden. Wieso ein @Override bei der toString Mehtode, Konto erbt doch von nichts?


----------



## ChristianK (8. Jan 2014)

Von Object?


----------



## turtle (8. Jan 2014)

> Wieso ein @Override bei der toString Mehtode, Konto erbt doch von nichts?


Konto erbt von Object. 

Die Override-Annotation ist ein Hinweis, das eine Methode einer Vaterklasse überschrieben wird. 

Dies gibt einen Fehler, wenn die Methode in der Oberklasse (hier Object) geändert wird, weil halt dann nicht mehr überschrieben würde, sondern eine neue Methode definiert würde. Das ist häufig nicht beabsichtigt.

Die Annotation ist also mehr Hinweis und "defensives Programmieren".


----------



## WusAA28 (8. Jan 2014)

Zunächst möchte ich mich erstmal ganz herzlich bei dir bedanken ) Ich würde ohne dich verzweifeln...???:L

Ich habe meinen Code wie von dir empfohlen überarbeitet, dennoch tun sich mir noch einige Fragen auf. 

1. Den Default Befehl habe ich nun nach oben geschoben. Doch wenn ich das Programm nun ausführe bekomme ich ihn nicht in der Console ausgegeben. Habe es auch schon mit "System.out.println" probiert, nur da weis ich nicht welche variable ich da ausgeben soll.

2. Gibt es eine möglichkeit wie ich bei meiner Switch Anfrage immer wieder zum Ursprungsort gelangen kann? Sprich wenn sich das Programm zum ersten mal öffnet das ich dann ein Konto anlege und sich dann ein weiteres  Fenster öffnet mit verschiedenen Optionen oder muss sich dafür jedes mal eine neue Switch Anweisung machen ?

3. In welcher Variable speichern sich denn alle meine Konten, damit ich sie mir später in einer Übersicht anschauen kann?


----------



## turtle (8. Jan 2014)

> Den Default Befehl habe ich nun nach oben geschoben. Doch wenn ich das Programm nun ausführe bekomme ich ihn nicht in der Console ausgegeben. Habe es auch schon mit "System.out.println" probiert, nur da weis ich nicht welche variable ich da ausgeben soll.


Code?



> 2. Gibt es eine möglichkeit wie ich bei meiner Switch Anfrage immer wieder zum Ursprungsort gelangen kann? Sprich wenn sich das Programm zum ersten mal öffnet das ich dann ein Konto anlege und sich dann ein weiteres Fenster öffnet mit verschiedenen Optionen oder muss sich dafür jedes mal eine neue Switch Anweisung machen ?


Du bist ja anscheinend ein Fan von JOptionPane Natürlich kannst du weitere Fenster öffnen. Dies würde aber gravierende Änderungen bedeuten. Ich schlage vor, erst mal dieses kleine Dinge fertig zu machen und komplett zu verstehen. Danach kannst du gerne ändern, was du möchtest!



> 3. In welcher Variable speichern sich denn alle meine Konten, damit ich sie mir später in einer Übersicht anschauen kann?


Deswegen mein obiger Kommentar. Du solltest verstanden haben, das alle Konten in der Variable alleKonten gespeichert sind. Beim Start enthält die Variable keine Konten,weshalb wir ja automatisch ein defaultKonto abspeichern. Weitere können über das Programm mit "Konto anlegen" gespeichert werden.


----------



## Unlikus (8. Jan 2014)

Du kannst es ja so machen wie in vielen Konsolenanwenungen üblich, dass du unter jeder Auswahl eine möglichkeit setzt eine Ebene zurück zu gehen. Das könntest du auch mit verschachtelten switch machen, oder besser noch jede Auswahl als ein Objekt zu definieren, die sich verschachteln.


----------



## WusAA28 (8. Jan 2014)

So sieht der Code zur Zeit aus


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

import javax.swing.JOptionPane;


public class Main {

	private static final char[] Konto = null;

	public static void main(String[] args) 
	{
	
	    class Konto {
	        private int kontoNummer;
	        private double kontoBestand;
	        private String kontoName;
	     
	        public Konto(int kontoNummer, String kontoName, double kontoBestand) {
	        this.kontoNummer = kontoNummer;
	        this.kontoBestand = kontoBestand;
	        this.kontoName = kontoName;
	        }
	     
	        public int getKontoNummer() {
	        return kontoNummer;
	        }
	     
	        public void setKontoNummer(int kontoNummer) {
	        this.kontoNummer = kontoNummer;
	        }
	     
	        public double getKontoBestand() {
	        return kontoBestand;
	        }
	     
	        public void setKontoBestand(double kontoBestand) {
	        this.kontoBestand = kontoBestand;
	        }
	     
	        public String getKontoName() {
	        return kontoName;
	        }
	     
	        public void setKontoName(String kontoName) {
	        this.kontoName = kontoName;
	        }
	     
	        @Override
	        public String toString() {
	        return kontoNummer + ":" + kontoBestand + ":" + kontoName;
	        }
	    }
		
	
	    Map<Integer, Konto> alleKonten = new HashMap<>();   
	    
	 // @formatter:off
        Konto[] defaultKonten = new Konto[] {
            new Konto(4848452, "Hans", 10), };
        // @formatter:on
        for (Konto konto : defaultKonten) {
        alleKonten.put(konto.getKontoNummer(), konto);
        }
        
        System.out.println(alleKonten);
		
	    Object[] options = { "Konto anlegen", "Konto abfragen", "Abbrechen" };
		 
         int auswahl1 = JOptionPane.showOptionDialog(null,
                                                     "Treffen Sie eine Auswahl",
                                                     "Überischt",
                                                     JOptionPane.DEFAULT_OPTION, 
                                                     JOptionPane.INFORMATION_MESSAGE, 
                                                     null, options, options[0]);
         System.out.println(auswahl1);
         
         switch(auswahl1){
         case 0:
        	 
        	    String kontoName = JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE);
                System.out.println(kontoName);
     
                int kontonummer = Integer.valueOf(JOptionPane.showInputDialog(null, "Kontonummer des Kontoinhabers", "Kontoverwaltung",
                    JOptionPane.PLAIN_MESSAGE));
                System.out.println(kontonummer);
     
                String kontobestand = JOptionPane.showInputDialog(null, "Kontobestand des Kontoinhabers", "Kontoverwaltung",
                    JOptionPane.PLAIN_MESSAGE);
                System.out.println(kontobestand);
                  
             break; 
         case 1:
        	 
        	 JOptionPane.showMessageDialog(null,
                     alleKonten ,
                     "Abbruch",                                       
                     JOptionPane.WARNING_MESSAGE);	
        	  
			
        	 break;
         case 2:
        	 JOptionPane.showMessageDialog(null,
                     "Kontoverwaltung wurde abgebrochen",
                     "Abbruch",                                       
                     JOptionPane.WARNING_MESSAGE);	 
	}

         
        
    	 
    	 
    	 
}
}
```

Wenn ich das Programm nun starte und einen Button klicke bekomme ich auch die gewünschte Aktion, nur dann müsste ich halt wieder auf ein "Übersichtsfenster" gelangen wo ich dann weitere schritten vernehmen kann. Nur weis ich jetzt wieder überhaupt nicht wie ich da vorgehen soll 

Eine weitere Frage wäre wenn ich jetzt ein vorhandenes Konto löschen möchte wie spreche ich dieses nun in alleKonten an?


----------



## turtle (8. Jan 2014)

Wir nähern uns

Du solltest aber nicht versuchen in einer JOptionPane mehrere tausen Konten anzuzeigen. Erstens hast du nicht genügend Platz auf dem Schirm und zweitens macht es wenig Sinn.
Mein Code an der Stelle

```
case 1:
	    kontonummer = Integer.valueOf(JOptionPane.showInputDialog(null, "Kontonummer des Kontoinhabers", "Kontoverwaltung",
		    JOptionPane.PLAIN_MESSAGE));
	    Konto konto = alleKonten.get(kontonummer);

	    JOptionPane.showMessageDialog(null, konto, "Abbruch", JOptionPane.WARNING_MESSAGE);

	    break;
```
Du siehst, ich frage die Kontonummer ab und zeige die Daten des Kontos an. Man muss da noch prüfen, wenn der Benutzer eine Nummer eingibt die nicht bekannt ist, denn da kriegst du null von alleKonten.get zurück. Eine if-Anweisung ist da genug.



> halt wieder auf ein "Übersichtsfenster" gelangen


Wenn du dir den Codefluss anschaust, was das Programm nach einer Kontoabfrage macht. Wo läuft er weiter? Nun switch-Anweisung wurde abgearbeitet und dann passiert nix mehr. Also beendet das Programm.
Also müssen wir solange (while) nach einer Anweisung den Benutzer fragen bis er die Applikation beendet. Ist bei mir im Code

```
int auswahl1 = 0;
	while (auswahl1 != 2) {
	    auswahl1 = JOptionPane.showOptionDialog(null, "Treffen Sie eine Auswahl", "Überischt", JOptionPane.DEFAULT_OPTION,
		    JOptionPane.INFORMATION_MESSAGE, null, options, options[0]);
```


----------



## WusAA28 (9. Jan 2014)

Hey Super diese While Schleife ist genau das was ich gemeint habe 

Dennoch habe ich schon wieder eine Frage.
Wenn ich jetzt mein Programm durchlaufen lasse und auf Konto anlegen klicke , komme ich zuerst einmal wieder auf das "Übersichtsfenster" beim zweiten mal anklicken fragt er mich dann meine Eingaben ab. Wenn ich dann aber auf Konto abfragen klicke bekomme ich nur das Default Konto angezeigt und nicht auch mein gerade eben erstelltes Konto. Woran liegt das?

Und dann wollte ich noch Fragen kann ich meinem Default Konto auch gleich mehre Konten hinzufügen sprich das ich mit zum Beispiel 5 Konten anfange ?

Wenn ich jetzt zum Beispiel ein Konto löschen will wie bekomme ich dieses angesprochen. Hat jedes Konto eine eigene ID oder wie ist das?

Mein Code sieht jetzt so aus 

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

import javax.swing.JOptionPane;


public class Main {

	private static final char[] Konto = null;

	public static void main(String[] args) 
	{
	
	    class Konto {
	        private int kontoNummer;
	        private double kontoBestand;
	        private String kontoName;
	     
	        public Konto(int kontoNummer, String kontoName, double kontoBestand) {
	        this.kontoNummer = kontoNummer;
	        this.kontoBestand = kontoBestand;
	        this.kontoName = kontoName;
	        }
	     
	        public int getKontoNummer() {
	        return kontoNummer;
	        }
	     
	        public void setKontoNummer(int kontoNummer) {
	        this.kontoNummer = kontoNummer;
	        }
	     
	        public double getKontoBestand() {
	        return kontoBestand;
	        }
	     
	        public void setKontoBestand(double kontoBestand) {
	        this.kontoBestand = kontoBestand;
	        }
	     
	        public String getKontoName() {
	        return kontoName;
	        }
	     
	        public void setKontoName(String kontoName) {
	        this.kontoName = kontoName;
	        }
	     
	        @Override
	        public String toString() {
	        return kontoNummer + ":" + kontoBestand + ":" + kontoName;
	        }
	    }
		
	
	    Map<Integer, Konto> alleKonten = new HashMap<>();   
	    
	 // @formatter:off
        Konto[] defaultKonten = new Konto[] {
            new Konto(4848452, "Hans", 10) , };
        // @formatter:on
        for (Konto konto : defaultKonten) {
        alleKonten.put(konto.getKontoNummer(), konto);
        }
        
        System.out.println(alleKonten);
        
        
		
	    Object[] options = { "Konto anlegen", "Konto abfragen", "Konto löschen", "Einzahlen", "Auszahlen","Abbrechen" };
		 
         int auswahl1 = JOptionPane.showOptionDialog(null,
                                                     "Treffen Sie eine Auswahl",
                                                     "Überischt",
                                                     JOptionPane.DEFAULT_OPTION, 
                                                     JOptionPane.INFORMATION_MESSAGE, 
                                                     null, options, options[0]);
         System.out.println(auswahl1);
         
          auswahl1 = 0;
         while (auswahl1 != 5) {
             auswahl1 = JOptionPane.showOptionDialog(null, "Treffen Sie eine Auswahl", "Überischt", JOptionPane.DEFAULT_OPTION,
                 JOptionPane.INFORMATION_MESSAGE, null, options, options[0]);
         
         switch(auswahl1){
         case 0:
        	 
        	    String kontoName = JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE);
                System.out.println(kontoName);
     
                int kontonummer = Integer.valueOf(JOptionPane.showInputDialog(null, "Kontonummer des Kontoinhabers", "Kontoverwaltung",
                    JOptionPane.PLAIN_MESSAGE));
                System.out.println(kontonummer);
     
                String kontobestand = JOptionPane.showInputDialog(null, "Kontobestand des Kontoinhabers", "Kontoverwaltung",
                    JOptionPane.PLAIN_MESSAGE);
                System.out.println(kontobestand);
                
                
                  
             break; 
         case 1:
        	 
        	 JOptionPane.showMessageDialog(null,
                     alleKonten ,
                     "Abbruch",                                       
                     JOptionPane.WARNING_MESSAGE);	
        	  
			
        	 break;
         case 2:
        	  
       
         case 3:
        	 
        	 
        	  
			
        	 break;
         case 4:
        	 
        	 	
        	  
			
        	 break;	 
         case 5:
        	 JOptionPane.showMessageDialog(null,
                     "Kontoverwaltung wurde abgebrochen",
                     "Abbruch",                                       
                     JOptionPane.WARNING_MESSAGE);	
        	  
			
        	 break;
        
	}

         
        
    	 
    	 
    	 
}
}}
```


----------



## turtle (9. Jan 2014)

> Wenn ich jetzt mein Programm durchlaufen lasse und auf Konto anlegen klicke , komme ich zuerst einmal wieder auf das "Übersichtsfenster" beim zweiten mal anklicken fragt er mich dann meine Eingaben ab. Wenn ich dann aber auf Konto abfragen klicke bekomme ich nur das Default Konto angezeigt und nicht auch mein gerade eben erstelltes Konto. Woran liegt das?


Nun, schau mal GENAU in deine Code.
Da steht 	

```
int auswahl1 = JOptionPane.showOptionDialog(null, "Treffen Sie eine Auswahl", "Überischt", JOptionPane.DEFAULT_OPTION,
		JOptionPane.INFORMATION_MESSAGE, null, options, options[0]);
	System.out.println(auswahl1);

	auswahl1 = 0;
	while (auswahl1 != 5) {
	    auswahl1 = JOptionPane.showOptionDialog(null, "Treffen Sie eine Auswahl", "Überischt", JOptionPane.DEFAULT_OPTION,
		    JOptionPane.INFORMATION_MESSAGE, null, options, options[0]);
```
Also machst du eine Abfrage "Treffen sie eine Auswahl" und egal was gewählt wird, noch einmal die Abfrage "Treffen sie eine Auswahl". Logisch, oder?
Also entferne einfach die Abfrage VOR der while-Schleife.



> Und dann wollte ich noch Fragen kann ich meinem Default Konto auch gleich mehre Konten hinzufügen sprich das ich mit zum Beispiel 5 Konten anfange ?


Klar geht das. Sogar ziemlich einfach und beliebig viele

```
Konto[] defaultKonten = new Konto[] {
            new Konto(4848452, "Hans", 10) ,
            new Konto(4848, "Turtle", 10) ,
            new Konto(3, "Konto3", 30) ,
            new Konto(4, "Konto4", 40) ,
            new Konto(5, "Konto5", 50) ,
            new Konto(6, "Konto5", 60) ,
            };
```
Allerdings hast du immer noch nicht richtigen Code für die Kontoabfrageueh:

```
case 1:
		kontonummer = Integer.valueOf(JOptionPane.showInputDialog(null, "Kontonummer des Kontoinhabers", "Kontoverwaltung",
			JOptionPane.PLAIN_MESSAGE));
		Konto konto = alleKonten.get(kontonummer);
		if (konto != null) {
		    JOptionPane.showMessageDialog(null, konto, "Abbruch", JOptionPane.WARNING_MESSAGE);
		}
		break;
```



> Wenn ich jetzt zum Beispiel ein Konto löschen will wie bekomme ich dieses angesprochen. Hat jedes Konto eine eigene ID oder wie ist das?


ja, klar und zwar ist alleKonten ja eine Map. Dies bedeutet, das einem Schlüssel ein Wert zugeordnet wird. Hier ist es Schlüssel=Kontonummer und Wert das komplette Konto-Objekt. Daher kannst du auch so einfach die Abfrage machen (Siehe oben): alleKonten.get(kontonummer) holt also zum Schlüssel (kontonummer) das komplette Objekt (Konto) aus der Map. Eventuell ist es aber gar nicht drin und daher die Abfrage auf null, Hatte ich aber bereits erwähnt gehabt.


----------



## WusAA28 (9. Jan 2014)

Das mit dem Konto abfragen war eigentlich gewollt da ich mir dort gerne alle vorhandenen Konten anzeigen lassen möchte und wenn ich ein neues Konto erstelle sollte dies dann dort auch erscheinen

Wenn bei meiner Map jetzt kontonummer der Schlüssel ist, müsste ich ja immer eine ziemlich lange Nummer eingeben um das Konto anzusprechen, kann ich diesen Schlüssel nicht auf eine Zahl ändern. Sprich das die Konten sich durch nummerieren?

Desweiteren bekomme ich wenn ich auf Konto abfragen klicke folgendes ausgegeben "3786424=3786424:30.:Karl}" gibt er die Kontonummer zweimal aus weil das eine der Schlüssel ist?

Das mit den Default Konten hat geklappt nur wenn ich jetzt auf Konto abfragen klicke bekomme ich alle meine Konten in einer Reihnfolge angezeigt, eigentlich erzeugt man ja durch \n einen Zeilenumbruch nur das ich bei mir leider nicht der Fall ???:L


```
// @formatter:off
        Konto[] defaultKonten = new Konto[] {
            new Konto(4848452, "Hans", 10  ) , "\n"
            new Konto(5486562, "Peter", 100),
            new Konto(3786424, "Karl", 30) ,
            new Konto(4889642, "Thorsten", 40) ,
            new Konto(5742563, "Dieter", 50) ,
        	};
        // @formatter:on
        for (Konto konto : defaultKonten) {
        alleKonten.put(konto.getKontoNummer(), konto);
        }
```


----------



## turtle (9. Jan 2014)

> Das mit dem Konto abfragen war eigentlich gewollt da ich mir dort gerne alle vorhandenen Konten anzeigen lassen möchte und wenn ich ein neues Konto erstelle sollte dies dann dort auch erscheinen


JOPtionDialog zeigt eine Message an und erwartet eigentlich das es ein kurzer Text ist (möglichst in einer Zeile). Du kannst natürlich einen String zusammenbauen, der alle Konten trennt.

```
StringBuilder sb = new StringBuilder();
		Set<Entry<Integer, Konto>> entrySet = alleKonten.entrySet();
		for (Entry<Integer, Konto> entry : entrySet) {
		    sb.append(entry.getValue());
		    sb.append("\n");
		}
		JOptionPane.showMessageDialog(null, sb.toString(), "Abbruch", JOptionPane.WARNING_MESSAGE);
```



> Wenn bei meiner Map jetzt kontonummer der Schlüssel ist, müsste ich ja immer eine ziemlich lange Nummer eingeben um das Konto anzusprechen, kann ich diesen Schlüssel nicht auf eine Zahl ändern.


Ich habe mich mal entschieden die Kontonummer zu nehmen, da diese (wahrscheinlich) eindeutig ist. Du kannst aber jedes andere Attribut nehmen und dies als Schlüssel der Map definieren (beispielsweise name). Dann kannst du aber nur ein Konto zu jedem Namen einfügen.
Das mit einer laufenden Nummer geht natürlich auch. Dann musst du in einer Schleife die default-Konten in die Map einfügen und beim Konto anlegen den nächsten Index abrufen. Fand ich damals einfach zu aufwendig. Du kannst ja zum Test auch einfachere Kontonummern bei defaultKonten eintragen.


> Desweiteren bekomme ich wenn ich auf Konto abfragen klicke folgendes ausgegeben "3786424=3786424:30.:Karl}" gibt er die Kontonummer zweimal aus weil das eine der Schlüssel ist?


Wenn du ein Objekt ausgibst, wird das Objekt in eine "menschenlesbare" Textform gebracht. Dafür wird die Methode toString() aufgerufen. Und da du ein Konto ausgibst, schau dir mal die Routine davon an.


----------



## WusAA28 (9. Jan 2014)

```
StringBuilder sb = new StringBuilder();
            Set<Entry<Integer, Konto>> entrySet = alleKonten.entrySet();
            for (Entry<Integer, Konto> entry : entrySet) {
                sb.append(entry.getValue());
                sb.append("\n");
            }
            JOptionPane.showMessageDialog(null, sb.toString(), "Abbruch", JOptionPane.WARNING_MESSAGE);
```

Wenn ich diesen Code bei mir einfüge bekomme ich Fehler an folgender Stelle angezeigt


```
Set<Entry<Integer, Konto>> entrySet = alleKonten.entrySet();
            for (Entry<Integer, Konto> entry : entrySet) {
```

"Entry cannot be resolved to a type"

Nun weis ich das ich den Schlüssel meiner Map ändern kann nur leider finde ich die entsprechende Code zeile jetzt nicht , handelt es sich denn um diese hier 

```
alleKonten.put(konto.getKontoNummer(), konto);
```

Wie bekomme ich denn meine neu angelegten Konten auch bei Konto abfragen angezeigt?


----------



## turtle (9. Jan 2014)

> Wenn ich diesen Code bei mir einfüge bekomme ich Fehler


Mach mal ein Organize Imports
Gibt bei mir folgende Imports

```
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import javax.swing.JOptionPane;
```



> alleKonten.put(konto.getKontoNummer(), konto);


Sehr gut erkannt, aber...
Neben dieser Stelle wo die Kontonummer verwendet wird, musst du ebenfalls die Deklaration von alleKonten anpassen.
Bisher

```
Map<Integer, Konto> alleKonten
```
also ist kontonummer ein Integer Typ.



> Wie bekomme ich denn meine neu angelegten Konten auch bei Konto abfragen angezeigt?


Der Fehler muss raus, dann solltes klappen.


----------



## WusAA28 (9. Jan 2014)

So ich habe jetzt folgende Codezeilen geändert

```
Map<String, Konto> alleKonten = new HashMap<>();
```


```
alleKonten.put(konto.getKontoName(), konto);
```

Sowie es ausschaut scheint auch alles zu funktionieren.

Die Kontoabfrage klappt jetzt auch 

Jetzt muss ich nur noch meine neu angelegten Konten mit angezeigt bekommen.???:L???:L


```
kontoName = (JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung",
        	            JOptionPane.PLAIN_MESSAGE));
        	        Konto konto = alleKonten.get(kontoName);
        	        if (konto != alleKonten) {
        	            JOptionPane.showMessageDialog(null, "Zu diesem Namen liegt kein Konto vor", "Abbruch", JOptionPane.WARNING_MESSAGE);
        	            
        	        }
```

So habe ich den Code bis jetzt schonmal umgebaut, gibt es einen löschen Befehl in Java?


----------



## turtle (9. Jan 2014)

> Jetzt muss ich nur noch meine neu angelegten Konten mit angezeigt bekommen


Ja, sieht so aus, das du nach Eingabe NICHT das Konto der Map hinzufügst. Mein Code

```
case 0:

		try {
		    String kontoName = JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE);
		    System.out.println(kontoName);

		    int kontonummer = Integer.valueOf(JOptionPane.showInputDialog(null, "Kontonummer des Kontoinhabers", "Kontoverwaltung",
			    JOptionPane.PLAIN_MESSAGE));
		    System.out.println(kontonummer);

		    String kontobestand = JOptionPane.showInputDialog(null, "Kontobestand des Kontoinhabers", "Kontoverwaltung",
			    JOptionPane.PLAIN_MESSAGE);
		    NumberFormat numberFormat = NumberFormat.getInstance(Locale.GERMAN);
		    Number number = numberFormat.parse(kontobestand);

		    alleKonten.put(kontonummer, new Konto(kontonummer, kontoName, number.doubleValue()));
		    System.out.println(kontobestand);
		} catch (HeadlessException e) {
		    e.printStackTrace();
		} catch (NumberFormatException e) {
		    e.printStackTrace();
		} catch (ParseException e) {
		    e.printStackTrace();
		}

		break;
```



> ibt es einen löschen Befehl in Java?


Das verstehe ich nicht.
Wenn du ein Konto löschen möchtest und das gemint hast, musst du das Mapping zwischen Schlüssel und Wert aus der Map entfernen und das geht via

```
alleKonten.remove(key)
```
Also bei dir unter Angabe der Kontonummer (oder neuerdings der Kontoname).


----------



## WusAA28 (9. Jan 2014)

Ich habe es jetzt so gemacht:

```
String kontoName = JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE);
                System.out.println(kontoName);
     
                int kontonummer = Integer.valueOf(JOptionPane.showInputDialog(null, "Kontonummer des Kontoinhabers", "Kontoverwaltung",JOptionPane.PLAIN_MESSAGE));
                System.out.println(kontonummer);
     
                double kontobestand = Double.valueOf(JOptionPane.showInputDialog(null, "Kontobestand des Kontoinhabers", "Kontoverwaltung",JOptionPane.PLAIN_MESSAGE));
                System.out.println(kontobestand);
                
                alleKonten.put(kontoName, new Konto(kontonummer, kontoName, kontobestand));
```

So funktioniert es auch fast schon wie ich es mir vorstelle das einzige was ich nicht ganz verstehe ist das mir mein erstes neu erstelltes Konto immer an die 2 Position gesetzt wird 

Genau das habe ich damit gemeint, ich habe jetzt folgenden Code

```
kontoName = (JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung",
        	            JOptionPane.PLAIN_MESSAGE));
        	        Konto konto = alleKonten.get(kontoName);
        	        if (konto != alleKonten) {
        	            JOptionPane.showMessageDialog(null, "Zu diesem Namen liegt kein Konto vor", "Abbruch", JOptionPane.WARNING_MESSAGE);
        	            
        	        }
        	        else
        	            alleKonten.remove(kontoName);
```

Doch wenn ich jetzt zum Beispiel "Hans" eingebe gibt er mir "Zu diesem Namen liegt kein Konto vor" aus wobei das Konto von Hans doch existiert???:L


----------



## turtle (9. Jan 2014)

> mir mein erstes neu erstelltes Konto immer an die 2 Position gesetzt wird


Du iterierst ja über einen entrySet einer Map. In einer Map gibt es aber normalerweise KEINE Reihenfolge. Daher kann beim Abruf ein Konto eher kommen als ein anderes das zuvor schon eingefügt wurde.
Änderst du diese Zeile, werden die Einträge in der Reihenfolge ihres Einfügens zurückgegeben.

```
Map<String, Konto> alleKonten = new LinkedHashMap<>();
```
Man kann sich auch vorstellen, die Konten nach einem Kriterium zu sortieren. 

Aber dies überlasse ich dir zur Übung.

Ich zeige dir mal meinen Code, der noch die Behandlung der einzelnen Aktionen anders handhabt. Da es schlechter Code ist, wenn da konstante int-Werte irgendwo im Code stehen, von denen man nicht versteht, wofür diese stehen (beispielsweise 5 bedeutet Abbruch gewählt). Hierfür KANN man Konstante definieren oder besser einen geeigneten Enum.

```
import java.awt.HeadlessException;
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import javax.swing.JOptionPane;

public class KontoApp {
    enum Aktion {
	ANLEGEN("Konto anlegen"), ABFRAGE("Konto abfragen"), CANCEL("Abbrechen"), LOESCHEN("Konto löschen"), EINZAHLEN("Einzahlen"), AUSZAHLEN("Auszahlen"), NOP("");
	private String txt;

	private Aktion(String txt) {
	    this.txt = txt;
	}
    }

    public static void main(String[] args) {
	try {
	    Map<String, Konto> alleKonten = new LinkedHashMap<>();
	    setupDefaultKonten(alleKonten);
	    Aktion aktion = Aktion.NOP;
	    while (aktion != Aktion.CANCEL) {
		aktion = leseAktion();
		switch (aktion) {
		case ANLEGEN:
		    kontoAnlegen(alleKonten);
		    break;
		case ABFRAGE:
		    kontoAbfragen(alleKonten);
		    break;
		case CANCEL:
		    JOptionPane.showMessageDialog(null, "Kontoverwaltung wurde abgebrochen", "Abbruch", JOptionPane.WARNING_MESSAGE);
		case LOESCHEN:
		    break;
		case EINZAHLEN:
		    break;
		case AUSZAHLEN:
		    break;
		default:
		    break;
		}
	    }
	} catch (HeadlessException e) {
	    e.printStackTrace();
	} catch (NumberFormatException e) {
	    e.printStackTrace();
	} catch (ParseException e) {
	    e.printStackTrace();
	}
    }

    private static void kontoAbfragen(Map<String, Konto> alleKonten) {
	StringBuilder sb = new StringBuilder();
	Set<Entry<String, Konto>> entrySet = alleKonten.entrySet();
	for (Entry<String, Konto> entry : entrySet) {
	    sb.append(entry.getValue());
	    sb.append("\n");
	}
	JOptionPane.showMessageDialog(null, sb.toString(), "Abbruch", JOptionPane.WARNING_MESSAGE);
    }

    private static void kontoAnlegen(Map<String, Konto> alleKonten) throws ParseException {
	String kontoName = JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE);
	kontoName = verifyContent(kontoName);
	String nummer = JOptionPane.showInputDialog(null, "Kontonummer des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE);
	nummer = verifyContent(nummer);
	Integer kontoNummer = null;
	if (nummer != null) {
	    kontoNummer = Integer.valueOf(nummer);
	}
	String bestand = JOptionPane.showInputDialog(null, "Kontobestand des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE);
	bestand = verifyContent(bestand);
	Number number = null;
	if (bestand != null) {
	    NumberFormat numberFormat = NumberFormat.getInstance(Locale.GERMAN);
	    number = numberFormat.parse(bestand);
	}
	if ((kontoNummer != null) && (kontoName != null) && (number != null)) {
	    alleKonten.put(kontoName, new Konto(kontoNummer, kontoName, number.doubleValue()));
	}
    }

    private static String verifyContent(String bestand) {
	if (bestand == null)
	    return null;
	if (bestand.length() == 0)
	    return null;
	return bestand;
    }

    private static Aktion leseAktion() {
	Aktion[] aktionen = { Aktion.ANLEGEN, Aktion.ABFRAGE, Aktion.LOESCHEN, Aktion.EINZAHLEN, Aktion.AUSZAHLEN, Aktion.CANCEL };
	String[] options = new String[aktionen.length];
	int i = 0;
	for (Aktion aktion : aktionen) {
	    options[i++] = aktion.txt;

	}
	int auswahl = JOptionPane.showOptionDialog(null, "Treffen Sie eine Auswahl", "Übersicht", JOptionPane.DEFAULT_OPTION,
		JOptionPane.INFORMATION_MESSAGE, null, options, options[0]);
	String selected = options[auswahl];
	for (Aktion aktion : aktionen) {
	    if (aktion.txt.equals(selected))
		return aktion;
	}
	return Aktion.NOP;
    }

    private static void setupDefaultKonten(Map<String, Konto> alleKonten) {
	// @formatter:off
        Konto[] defaultKonten = new Konto[] {
                new Konto(4848452, "Hans", 10) ,
                new Konto(4848, "Turtle", 10) ,
                new Konto(3, "Konto3", 30) ,
                new Konto(4, "Konto4", 40) ,
                new Konto(5, "Konto5", 50) ,
                new Konto(6, "Konto5", 60) ,
                };
         // @formatter:on
	for (Konto konto : defaultKonten) {
	    alleKonten.put(konto.getKontoName(), konto);
	}
    }
}
```
Ich hoffe du bist mit mir und meiner Betreuung zufrieden und würde mich über das Eine oder Andere Danke (über Forum-Button) freuen.

Viel Spass weiterhin mit Java


----------



## WusAA28 (10. Jan 2014)

Hallo,
zu erstmal muss ich sagen das ich sehr zufrieden bin =) Wüsste nicht was ich ohne dich machen würde 

Das mit dem 

```
new LinkedHashMap<>();
```
funktioniert jetzt auch 

Nur leider besteht weiter hin mein Problem das er mir die Konten nicht löscht obwohl ich einen bestehenden Namen eingebe.


```
kontoName = (JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung",
        	            JOptionPane.PLAIN_MESSAGE));
        	        Konto konto = alleKonten.get(kontoName);
        	        if (konto != alleKonten) {
        	            JOptionPane.showMessageDialog(null, "Zu diesem Namen liegt kein Konto vor", "Abbruch", JOptionPane.WARNING_MESSAGE);
        	            
        	        }
        	        else
        	            alleKonten.remove(kontoName);
```

Dann hätte ich noch eine Frage zum Ein- und Auszahlen. Undzwar muss ich dafür doch eine neue Variable anlegen zum Beispiel "betrag" und diese dann zu meinem kontobestand addieren oder? Kann ich dort auch wieder so beginnen ?


```
kontoName = (JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung",
        	            JOptionPane.PLAIN_MESSAGE));
        	        Konto konto = alleKonten.get(kontoName);
```


Das mit den Konten sortieren wollte ich eigentlich auch noch einbauen aber erstmal probiere ich jetzt das Programm mit den zur Zeit behinalteten Befehlen zum laufen zu bekommen.


----------



## turtle (10. Jan 2014)

> if (konto != alleKonten)


Diese Zeile sollte dir suspekt vorkommen. Es kann ja NIE EIN Konto einer Map entsprechen. Also geht er IMMER in den if-Zweig und nie in den else.
Richtiger wäre

```
String kontoName = (JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE));
		Konto konto = alleKonten.get(kontoName);
		if (konto != null) {
		    alleKonten.remove(kontoName);
		} else {
		    JOptionPane.showMessageDialog(null, "Zu diesem Namen liegt kein Konto vor", "Abbruch", JOptionPane.WARNING_MESSAGE);
		}
		break;
```



> Dann hätte ich noch eine Frage zum Ein- und Auszahlen. Undzwar muss ich dafür doch eine neue Variable anlegen zum Beispiel "betrag" und diese dann zu meinem kontobestand addieren oder? Kann ich dort auch wieder so beginnen ?


Das hört sich nach einem Plan an und zwar eine guten. Du fragst ja bereits an mehreren Stellen de Benutzer nach verschiedenen Dingen. Also muss du nun Kontoname UND Betrag fragen. Letzteres in der Tat in einer NEUEN Variable speichern. Ich würde dann eine Funktion in Konto schreiben, wo der diesen Betrag als Parameter reinkommt und dem Konto gutgeschrieben wird.


----------



## WusAA28 (10. Jan 2014)

Hey super mein Programm funktioniert mittlerweile immer besser 

Ich habe jetzt folgenden Code für Einzahlen geschrieben


```
kontoName = (JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE));
             Konto konto1 = alleKonten.get(kontoName);
			if (konto1 != null) {
				double money = 0;
				Double.valueOf(JOptionPane.showInputDialog(null, "Wie viel möchten Sie Einzahlen?", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE));
				kontobestand = kontobestand + money;
			}
          else {
             JOptionPane.showMessageDialog(null, "Zu diesem Namen liegt kein Konto vor", "Abbruch", JOptionPane.WARNING_MESSAGE);
         }
```

Doch leider bekomme ich hier einen Fehler angezeigt 

```
kontobestand = kontobestand + money;
```


----------



## thezecke11 (10. Jan 2014)

kontostand ist ein Attribut der Konto-Klasse.

Da du ja Objekte der Klasse Konto erstellst, enthält jedes Objekt

das Attribut kontostand.

Damit java nun weiß, welches Objekt mit welchem kontostand-Wert

referenziert werden muss, musst du dieses durch Punktnotation angeben,

in deinem Fall also:


```
konto1.kontobestand = konto1.kontobestand + money ;
```
, 
verkürzt: 
	
	
	
	





```
konto1.kontobestand += money;
```

optimal wäre, in der Konto-klasse eine Methode zu deklarieren,

die als Parameter den Änderungswert (money) übergibt, um den

direkten Variablenzugriff zu vermeiden


----------



## turtle (11. Jan 2014)

Wie thezecke11 richtig bemerkte, musst du auf das Konto zugreifen.

Wie ich bereits sagte, würde ich eine Methode in Konto eine Methode schreiben

```
public void einzahlen(double betrag) {
		kontoBestand += betrag;
	}
```
Dann ist der Zugriff nach der Abfrage im Code

```
konto1.einzahlen(money);
```


----------



## WusAA28 (12. Jan 2014)

Hallo, 
jetzt funktioniert es schonmal 

Nur wenn ich mir jetzt ein Konto aussuche und dort dann einen Betrag einzahlen will und anschließend auf Konto abfragen klicke steht dort nicht der dazu addierte Wert.

Den Code muss ich doch eigentlich nur ein ganz wenig verändern wenn ich etwas auszahlen will oder?

Mein Code 

```
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import javax.swing.JOptionPane;



public class Main {

	private static final char[] Konto = null;

	public static void main(String[] args) 
	{
	
	    class Konto {
	        private int kontoNummer;
	        private double kontoBestand;
	        private String kontoName;
			
	     
	        public Konto(int kontoNummer, String kontoName, double kontoBestand) {
	        this.kontoNummer = kontoNummer;
	        this.kontoBestand = kontoBestand;
	        this.kontoName = kontoName;
	        }
	       
	        public void einzahlen(double betrag) {
	            kontoBestand += betrag;
	        }
	        
			public int getKontoNummer() {
	        return kontoNummer;
	        }
	     
	        public void setKontoNummer(int kontoNummer) {
	        this.kontoNummer = kontoNummer;
	        }
	     
	        public double getKontoBestand() {
	        return kontoBestand;
	        }
	     
	        public void setKontoBestand(double kontoBestand) {
	        this.kontoBestand = kontoBestand;
	        }
	     
	        public String getKontoName() {
	        return kontoName;
	        }
	     
	        public void setKontoName(String kontoName) {
	        this.kontoName = kontoName;
	        }
	     
	        @Override
	        public String toString() {
	        return "Name: " + kontoName +" " + "KontoNr: " + kontoNummer + " " +"Guthaben: " + kontoBestand;
	        }
	    }
		
	   
	
	    Map<String, Konto> alleKonten = new LinkedHashMap<>(); 
	    
	 // @formatter:off
        Konto[] defaultKonten = new Konto[] {
            new Konto(4848452, "Hans", 10  ) , 
            new Konto(5486562, "Peter", 100),
            new Konto(3786424, "Karl", 30) ,
            new Konto(4889642, "Thorsten", 40) ,
            new Konto(5742563, "Dieter", 50) ,
        	};
        // @formatter:on
        for (Konto konto : defaultKonten) {
        alleKonten.put(konto.getKontoName(), konto);
        }
        
        System.out.println(alleKonten);
        
        
		
	    Object[] options = { "Konto anlegen", "Konto abfragen", "Konto löschen", "Einzahlen", "Auszahlen","Abbrechen" };
		 
         
         int auswahl1 = 0;
         while (auswahl1 != 5) {
             auswahl1 = JOptionPane.showOptionDialog(null, "Treffen Sie eine Auswahl", "Überischt", JOptionPane.DEFAULT_OPTION,
                 JOptionPane.INFORMATION_MESSAGE, null, options, options[0]);
             
         System.out.println(auswahl1);
         
         switch(auswahl1){
         case 0:
        	 
        	    String kontoName = JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE);
                System.out.println(kontoName);
     
                int kontonummer = Integer.valueOf(JOptionPane.showInputDialog(null, "Kontonummer des Kontoinhabers", "Kontoverwaltung",JOptionPane.PLAIN_MESSAGE));
                System.out.println(kontonummer);
     
                double kontobestand = Double.valueOf(JOptionPane.showInputDialog(null, "Kontobestand des Kontoinhabers", "Kontoverwaltung",JOptionPane.PLAIN_MESSAGE));
                System.out.println(kontobestand);
                
                alleKonten.put(kontoName, new Konto(kontonummer, kontoName, kontobestand));  
                  
             break; 
         case 1:
        	    StringBuilder sb = new StringBuilder();
                Set<Entry<String, Konto>> entrySet = alleKonten.entrySet();
                for (Entry<String, Konto> entry : entrySet) {
                    sb.append(entry.getValue());
                    sb.append("\n");
                }
                JOptionPane.showMessageDialog(null, sb.toString(), "Abbruch", JOptionPane.WARNING_MESSAGE);
			
        	 break;
         case 2:
        	     	 
        	    kontoName = (JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE));
                Konto konto = alleKonten.get(kontoName);
                if (konto != null) {
                    alleKonten.remove(kontoName);
                    JOptionPane.showMessageDialog(null, "Das Konto wurde gelöscht", "Hinweis", JOptionPane.WARNING_MESSAGE);
                } else {
                    JOptionPane.showMessageDialog(null, "Zu diesem Namen liegt kein Konto vor", "Abbruch", JOptionPane.WARNING_MESSAGE);
                }
                break;
       
         case 3:
        	 
        	 kontoName = (JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE));
             Konto konto1 = alleKonten.get(kontoName);
			if (konto1 != null) {
				double money = 0;
				Double.valueOf(JOptionPane.showInputDialog(null, "Wie viel möchten Sie Einzahlen?", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE));
			    konto1.einzahlen(money);
			}
          else {
             JOptionPane.showMessageDialog(null, "Zu diesem Namen liegt kein Konto vor", "Abbruch", JOptionPane.WARNING_MESSAGE);
         }
        	 break;
        	 
         case 4:
        	 
        	 	
        	  
			
        	 break;	 
        	 
         case 5:
        	 JOptionPane.showMessageDialog(null,
                     "Kontoverwaltung wurde abgebrochen",
                     "Abbruch",                                       
                     JOptionPane.WARNING_MESSAGE);	
        	  
			
        	 break;
        
	}

         
        
    	 
    	 
    	 
}
}}
```


----------



## turtle (12. Jan 2014)

Ist auch wirklich eine Kleinigkeit

Du fragst zwar den Betrag zum Einzahlen bei Benutzer ab, SPEICHERST den aber nicht in der Variablen money.

```
double money = Double.valueOf(JOptionPane.showInputDialog(null, "Wie viel möchten Sie Einzahlen?",
							"Kontoverwaltung", JOptionPane.PLAIN_MESSAGE));
					konto1.einzahlen(money);
```


----------



## WusAA28 (13. Jan 2014)

Ohh stimmt , danke dir )

Bei meinem Programm funktioniert jetzt alles. Das einzige was jetzt noch fehlt wäre eine Sortierfunktion. Ist so etwas denn noch möglich bei einer Map? Besteht die Möglichkeit das ich nach Namen, Nummer und Betrag sortieren kann?

Mein aktuelles Programm 

```
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import javax.swing.JOptionPane;



public class Main {

	private static final char[] Konto = null;

	public static void main(String[] args) 
	{
	
	    class Konto {
	        private int kontoNummer;
	        private double kontoBestand;
	        private String kontoName;
			
	     
	        public Konto(int kontoNummer, String kontoName, double kontoBestand) {
	        this.kontoNummer = kontoNummer;
	        this.kontoBestand = kontoBestand;
	        this.kontoName = kontoName;
	        }
	       
	        public void einzahlen(double betrag) {
	            kontoBestand += betrag;
	        }
	        
	        public void auszahlen(double betrag) {
	            kontoBestand -= betrag;
	        }
	        
	        
			public int getKontoNummer() {
	        return kontoNummer;
	        }
	     
	        public void setKontoNummer(int kontoNummer) {
	        this.kontoNummer = kontoNummer;
	        }
	     
	        public double getKontoBestand() {
	        return kontoBestand;
	        }
	     
	        public void setKontoBestand(double kontoBestand) {
	        this.kontoBestand = kontoBestand;
	        }
	     
	        public String getKontoName() {
	        return kontoName;
	        }
	     
	        public void setKontoName(String kontoName) {
	        this.kontoName = kontoName;
	        }
	     
	        @Override
	        public String toString() {
	        return "Name: " + kontoName +" " + "KontoNr: " + kontoNummer + " " +"Guthaben: " + kontoBestand;
	        }
	    }
		
	   
	
	    Map<String, Konto> alleKonten = new LinkedHashMap<>(); 
	    
	 // @formatter:off
        Konto[] defaultKonten = new Konto[] {
            new Konto(4848452, "Hans", 10  ) , 
            new Konto(5486562, "Peter", 100),
            new Konto(3786424, "Karl", 30) ,
            new Konto(4889642, "Thorsten", 40) ,
            new Konto(5742563, "Dieter", 50) ,
        	};
        // @formatter:on
        for (Konto konto : defaultKonten) {
        alleKonten.put(konto.getKontoName(), konto);
        }
        
        System.out.println(alleKonten);
        
        
		
	    Object[] options = { "Konto anlegen", "Konto abfragen", "Konto löschen", "Einzahlen", "Auszahlen","Abbrechen" };
		 
         
         int auswahl1 = 0;
         while (auswahl1 != 5) {
             auswahl1 = JOptionPane.showOptionDialog(null, "Treffen Sie eine Auswahl", "Überischt", JOptionPane.DEFAULT_OPTION,
                 JOptionPane.INFORMATION_MESSAGE, null, options, options[0]);
             
         System.out.println(auswahl1);
         
         switch(auswahl1){
         case 0:
        	 
        	    String kontoName = JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE);
                System.out.println(kontoName);
     
                int kontonummer = Integer.valueOf(JOptionPane.showInputDialog(null, "Kontonummer des Kontoinhabers", "Kontoverwaltung",JOptionPane.PLAIN_MESSAGE));
                System.out.println(kontonummer);
     
                double kontobestand = Double.valueOf(JOptionPane.showInputDialog(null, "Kontobestand des Kontoinhabers", "Kontoverwaltung",JOptionPane.PLAIN_MESSAGE));
                System.out.println(kontobestand);
                
                alleKonten.put(kontoName, new Konto(kontonummer, kontoName, kontobestand));  
                  
             break; 
         case 1:
        	    StringBuilder sb = new StringBuilder();
                Set<Entry<String, Konto>> entrySet = alleKonten.entrySet();
                for (Entry<String, Konto> entry : entrySet) {
                    sb.append(entry.getValue());
                    sb.append("\n");
                }
                JOptionPane.showMessageDialog(null, sb.toString(), "Abbruch", JOptionPane.WARNING_MESSAGE);
			
        	 break;
         case 2:
        	     	 
        	    kontoName = (JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE));
                Konto konto = alleKonten.get(kontoName);
                if (konto != null) {
                    alleKonten.remove(kontoName);
                    JOptionPane.showMessageDialog(null, "Das Konto wurde gelöscht", "Hinweis", JOptionPane.WARNING_MESSAGE);
                } else {
                    JOptionPane.showMessageDialog(null, "Zu diesem Namen liegt kein Konto vor", "Abbruch", JOptionPane.WARNING_MESSAGE);
                }
                break;
       
         case 3:
        	 
        	 kontoName = (JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE));
             Konto konto1 = alleKonten.get(kontoName);
			if (konto1 != null) {
			    double money = Double.valueOf(JOptionPane.showInputDialog(null, "Wie viel möchten Sie Einzahlen?",
                        "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE));
                konto1.einzahlen(money);
			}
          else {
             JOptionPane.showMessageDialog(null, "Zu diesem Namen liegt kein Konto vor", "Abbruch", JOptionPane.WARNING_MESSAGE);
         }
        	 break;
        	 
         case 4:
        	 
        	 kontoName = (JOptionPane.showInputDialog(null, "Name des Kontoinhabers", "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE));
             Konto konto2 = alleKonten.get(kontoName);
			if (konto2 != null) {
			    double money = Double.valueOf(JOptionPane.showInputDialog(null, "Wie viel möchten Sie Auszahlen?",
                        "Kontoverwaltung", JOptionPane.PLAIN_MESSAGE));
                konto2.auszahlen(money);
			}
          else {
             JOptionPane.showMessageDialog(null, "Zu diesem Namen liegt kein Konto vor", "Abbruch", JOptionPane.WARNING_MESSAGE);
         }
        	  
			
        	 break;	 
        	 
         case 5:
        	 JOptionPane.showMessageDialog(null,
                     "Kontoverwaltung wurde abgebrochen",
                     "Abbruch",                                       
                     JOptionPane.WARNING_MESSAGE);	
        	  
			
        	 break;
        
	}

         
        
    	 
    	 
    	 
}
}}
```


----------



## turtle (14. Jan 2014)

> Das einzige was jetzt noch fehlt wäre eine Sortierfunktion. Ist so etwas denn noch möglich bei einer Map?
> Besteht die Möglichkeit das ich nach Namen, Nummer und Betrag sortieren kann?



Ja, das geht auf einer Map nicht so einfach.

Daher würde ich die Datenstruktur in eine List<Konto> ändern. Darauf kannst du in einer Klasse, die eine Comparator realsiiert, das Sortierkriterium realisieren.

Ich rate dringend sich in jUnit einzuarbeiten, weil du dann einen Test schreiben kannst, der prüft, ob die Sortierung richtig läuft und dies BEVOR du anfängst das zu realisieren und in deine KontoApp einbaust.
Wenn du aber die Reihenfolge änderst, musst bei der Abfrage ändern, das in der Liste gesucht wird. Ist dann natürlich langsamer.

Ich habe das mal gerade gemacht, damit du siehst was ich meine. Der Code sortiert alle Konten nach Betrag absteigend.

```
import static org.junit.Assert.assertEquals;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.junit.Test;

public class SortKonto {

    @Test
    public void test() {
	List<Konto> alleKonten = new ArrayList<>();

	alleKonten.add(new Konto(4848452, "Hans", 10));
	alleKonten.add(new Konto(4848, "Turtle", 10));
	alleKonten.add(new Konto(3, "Konto3", 30));
	alleKonten.add(new Konto(4, "Konto4", 40));
	alleKonten.add(new Konto(5, "Konto5", 50));
	alleKonten.add(new Konto(6, "Konto5", 60));
	Comparator<Konto> comparator = new BetragSorter();
	Collections.sort(alleKonten, comparator);
	List<Konto> sortedKonten = new ArrayList<>();

	sortedKonten.add(new Konto(6, "Konto5", 60));
	sortedKonten.add(new Konto(5, "Konto5", 50));
	sortedKonten.add(new Konto(4, "Konto4", 40));
	sortedKonten.add(new Konto(3, "Konto3", 30));
	sortedKonten.add(new Konto(4848452, "Hans", 10));
	sortedKonten.add(new Konto(4848, "Turtle", 10));
	for (int i = 0; i < sortedKonten.size(); i++) {
	    assertEquals("Sortierung falsch", sortedKonten.get(i), alleKonten.get(i));
	}
    }

}

class BetragSorter implements Comparator<Konto> {

    @Override
    public int compare(Konto o1, Konto o2) {
	return (int) (o2.getKontoBestand() - o1.getKontoBestand());
    }
}
```
Basiert aber darauf das auch Konto angepasst wurde. Denn hier muss festgelegt werden, wann ein Konto gleich zu einem anderen Konto ist.   
	
	
	
	





```
@Override
    public boolean equals(Object obj) {
	if (!(obj instanceof Konto))
	    return false;
	Konto aKonto = (Konto) obj;
	if (!kontoName.equals(aKonto.kontoName))
	    return false;
	if (!(kontoNummer == aKonto.kontoNummer))
	    return false;
	if ((kontoBestand - aKonto.kontoBestand) > 0.0001)
	    return false;
	return true;
```
}


----------



## WusAA28 (14. Jan 2014)

Hey okay danke ich werde mich mal in das Thema hineinlesen. Somit ist das Thema hier jetzt erledigt. 
Ich bedanke mich noch mal recht herzlich bei allen die mir geholfen haben


----------

