Integer aus Textdatei auslesen

Eigentlich wollt ich das Thema für heute ruhen lassen, weil mich das heute genug Nerven gekostet hat.
Aber ich habs noch einmal versucht:

            String gastkartewiederhergestellt = spielstand.getProperty("gastkarten" + n);
            String[] einzelkarte = gastkartewiederhergestellt.split(":");
            System.out.println(einzelkarte[0]);
            System.out.println(einzelkarte[1]);
      }```

Das gibt mir alle Gastkarten in Reihenfolge und in Land und Geschlecht gesplitet aus. Feine Sache.:D

`gastkarten.add(new Gastkarte(einzelkarte[0], einzelkarte[1]));` funktioniert nicht:

> Der Konstruktor Gastkarte(string, string) ist nicht definiert


Ich hab mich mehr schlecht als Recht mit diesem komischen valueOf beschäftigt. Das Internet kennt dazu echt keine seriösen Anleitungen. Und irgendwie weiß ich auch nicht, wieso ich das für mein Problem brauchen könnte?

So, wie ich das verstanden habe, soll das so funktionieren:
```Land land = Land.valueOf(Gastkarte);```
Bis auf das Element in den Klammern macht er auch keinen Stress.-_-

> Gastkarte cannot be resolved to a variable.

heißt es hier.

Aber mal im Ernst, wozu brauche ich das? Kann ich das nicht auch so irgendwie in diese Liste einfügen?

Gruß
Lukas

[quote=FranzFerdinand]gastkarten.add(new Gastkarte(einzelkarte[0], einzelkarte[1])); funktioniert nicht:
Der Konstruktor Gastkarte(string, string) ist nicht definiert[/quote]
Die Meldung ist doch ziemlich deutlich. Für die Klasse Gastkarte gibt es nur einen Konstruktor und der erwartet ein Enum vom Typ Land und als zweites einen Enum vom Typ Geschlecht.
einzelkarte ist aber ein String Array und einzelkarte[0] bzw. [1] sind Strings. Zur Lösungsfindung einfach ein bisschen über die Ausgangsituation nachdenken. Gegen sind zwei Strings, benötigt werden entweder zwei Enums oder ein zusätzlicher Konstruktor in der Klasse Gastkarte der mit Strings umgehen kann.
Hier hilft die Methode valueof: Land.valueOf("Brite") liefert den Enum Land.Brite und Geschlecht.valueof("weiblich") liefert Geschlecht.weiblich. Nun hast Du einen Enum Land und Geschlecht und kannst z.B. damit über den gegebenen Konstruktor eine Gastkarte erzeugen.

Jetzt verstehe ich das ganze auch, danke schön. Ich hab ewig danach gegooglet, wie das funktioniert. Naja, mein Englisch ist auch nicht das beste und das Internet hatte keine Anleitungen, die mir das korrekt verdeutlicht haben.
Ich konnte die Werte nun korrekt kompilieren.

Also, mein Code an dieser Stelle sieht nun folgendermaßen aus:

      jListGastkartenModel.clear();
      Geschlecht.valueOf("männlich");
      Geschlecht.valueOf("weiblich");
      Land.valueOf("Deutscher");
      Land.valueOf("Franzake");
      Land.valueOf("Brite");
      Land.valueOf("Amerikaner");
      Land.valueOf("Türke");
      Land.valueOf("Inder");
      Land.valueOf("Chinese");
      Land.valueOf("Russe");
      Land.valueOf("Spanier");
      Land.valueOf("Kubaner");
      Land.valueOf("Afrikaner");
      Land.valueOf("Italiener");
      Land.valueOf("Joker");
      for (int n=0;n<restkartengast;n++) {
            String gastkartewiederhergestellt = spielstand.getProperty("gastkarten" + n);
            String[] einzelkarte = gastkartewiederhergestellt.split(":");
            System.out.println(einzelkarte[0]);
            System.out.println(einzelkarte[1]);
            
            for(Land land : Land.values()) {
            	for(Geschlecht geschlecht : Geschlecht.values()) {
            		gastkarten.add(new Gastkarte(geschlecht, land));
            	}
            } 
      }
      for(int y=0;y<gastkarten.size();y++){
	    	jListGastkartenModel.addElement(gastkarten.get(y));
	    }
      System.out.println("Ein altes Spiel wurde wiederhergestellt");```
Anfangs leere ich erstmal sowohl meine Liste, als auch meine jList. Kann ich mir zwar nicht vorstellen, aber kann ja sein, dass da irgendwelche Rückstände drin sind. Anschließend wandle ich mir mit valueOf meine 13 Länder und 2 Geschlechter um, das läuft auch.
Es läuft alles bis zum Splitten der Elemente und dem Ausgeben der Einzelteile. Also bis hierhin: `System.out.println(einzelkarte[1]);`
De Konsole gibt mir dann tatsächlich alle Elemente in der Reihenfolge, wie ich sie vorher in der Datei abgespeichert habe, ab. Natürlich wie vorgesehen getrennt.
Also:

> Amerikaner
> Weiblich
> Deutscher
> Männlich
> Türke
> Weiblich
> usw.


Läuft alles. Doch dann geht das nicht korrekt weiter. Der nächste und letzte Schrift wäre das ganze in die Liste einzubauen und dann in die jList komplett sortiert zu integrieren.
Leider passiert da etwas unerwartetes. Wie ich es mir eigentlich vorher hätte denken müssen. Die For-Schleife geht alles in Reihenfolge durch und arbeitet das sortiert ab und fügt alles ein. Und das in unvorstellbarer Menge. Also nicht nur 100 Karten, sondern eine Vielzahl davon. Vielleicht bzw. wahrscheinlich `y<gastkarten.size()`.
Ich wollte es mit einem Zähler mitzählen, aber der Zähler hat mir wegen einer zu großen Zahl nichts ausgegeben. Und auch meine bisherigen Methode: Strg+A in der jList und dann in Excel einfügen und die Zeilennummer ablesen ging nicht. Es war eine so große Masse an Elementen, dass Excel das nicht durchgehalten hat.
Also es sind auf jeden Fall zu viele.

Das hier war bis dato aber eigentlich meine einzige Idee das zuzuordnen, aber ist ja auch logisch, der zählt dann alles durch, ohne vorher meine Sortierreihenfolge zu beachten. Blöd.
```for(Land land : Land.values()) {
            	for(Geschlecht geschlecht : Geschlecht.values()) {```

Hat jemand einen klugen Einfall dazu?

gruß
Lukas

[quote=FranzFerdinand]Also, mein Code an dieser Stelle sieht nun folgendermaßen aus:

      jListGastkartenModel.clear();
      Geschlecht.valueOf("männlich");
      Geschlecht.valueOf("weiblich");
      Land.valueOf("Deutscher");
      Land.valueOf("Franzake");
      Land.valueOf("Brite");
      Land.valueOf("Amerikaner");
      Land.valueOf("Türke");
      Land.valueOf("Inder");
      Land.valueOf("Chinese");
      Land.valueOf("Russe");
      Land.valueOf("Spanier");
      Land.valueOf("Kubaner");
      Land.valueOf("Afrikaner");
      Land.valueOf("Italiener");
      Land.valueOf("Joker");
      for (int n=0;n<restkartengast;n++) {
            String gastkartewiederhergestellt = spielstand.getProperty("gastkarten" + n);
            String[] einzelkarte = gastkartewiederhergestellt.split(":");
            System.out.println(einzelkarte[0]);
            System.out.println(einzelkarte[1]);
           
            for(Land land : Land.values()) {
                for(Geschlecht geschlecht : Geschlecht.values()) {
                    gastkarten.add(new Gastkarte(geschlecht, land));
                }
            }
      }
      for(int y=0;y<gastkarten.size();y++){
            jListGastkartenModel.addElement(gastkarten.get(y));
        }
      System.out.println("Ein altes Spiel wurde wiederhergestellt");```
[/quote]
Was bezweckst Du mit dem Code? Ist Dir bewusst was hier passiert?
Zeile 2 bis 17 sind eigentlich überflüssig, da sie nichts bewirken.
Die Information aus Zeile 19 und 20 wird auch nur dafür genutzt, um sie auf der Konsole auszugeben.

Mit den drei ineinander verschachtelten Schleifen erzeugst Du restkartengast * Land.values().length * Geschlecht.value().length Gastkarten. Das ist zumindest ein Grund warum die Liste soviele Elemente enthält.

Hallo und Danke für Deine Antwort,

ich bin mir dem Code bewusst, ja, war wohl eine kleine Unachtsamkeit, keine Ahnung wieso ich das jetzt so eingebaut habe, wie es ist.
Wieso nutzen die Zeilen 2 bis 17 nichts? Das ist doch gerade das, was ich brauche zum Umwandeln?

Und ich habe ehrlich gesagt nach wie vor keine Idee, wie ich der list Gastgarten die Info übergeben kann, dass diese 100 Karten aus der Speicherdatei wiedereingefügt werden sollen. :frowning:
Hat da wer einen kleinen Einfall, gerne auch mit Code?

Schönen Sonntag!
Lukas :slight_smile:

[quote=FranzFerdinand]Und ich habe ehrlich gesagt nach wie vor keine Idee, wie ich der list Gastgarten die Info übergeben kann, dass diese 100 Karten aus der Speicherdatei wiedereingefügt werden sollen.[/quote]Darüber hatten wir doch schon gesprochen und Du hast behauptet, dass Du die Karten programmatisch erzeugts.

Also sind nicht die Karten aus der Datei zu laden, sondern deren Zuordnung zu den Spielern.

Leider konnte ich Deinen Codegewirr nicht entnehmen, wie Du diese Zuordnug in Deinem Programm realisierst. Und ich denke, dass hier auch Dein Haupt-Problem liegt: Du hast eine Vorstellung davon, wie Dein Spiel auf dem Bildschirm aussehen soll. Was Du nicht hast ist ein Plan, welche Objekte in Deinem Spiel existieren und wie diese miteinander in Beziehung stehen.

Momentan bist Du in Deiner “Lösung” festgefahren. Wenn Du so weiter machst wirst Du Dein Projekt nicht fertig bekommen.

Auch wenn es hart ist: Vergiss was Du bisher hast und fang noch mal sauber mit den Grundlagen an. Konzentriere Dich zunächst auf das Modell (also die Spieler und die Karten und deren Interaktionen) ohne an die GUI zu denken.

Wenn die “Engine” funktioniert kannst Du an Speichern/Laden und Visualisierung arbeiten.

bye
TT

denke nicht in abstrakten Zauber-Sphären, sondern ganz ordinär, was leisten diese Zeilen?
was ist der Unterschied von vorher zu nachher?
direkt eine lokale Variable ist ja nicht beteiligt,
sollte sich in der Enum-Klasse was ändern, die Enum-Werte initialisiert werden oder so?
nein, es passiert exakt nichts dauerhaftes

an der Stelle, an der du Strings einliest und Enum-Werte für den Konstruktor haben willst, da machst du dagegen nichts,
was haben Codezeilen irgendwo anders im Programm damit zu tun? (außer mal wichtiges wie überhaupt Definition der Klassen)

es würde dir in der Schleife ja auch nicht helfen wenn du irgendwo anders einmal String.split() ausprobierst…
einfaches Bauen: dort wo du den String hast, dort musst du diesen konkreten String umwandeln in einen Enum-Wert, diesen für den Konstruktor verwenden

            String gastkartewiederhergestellt = spielstand.getProperty("gastkarten" + n);
            String[] einzelkarte = gastkartewiederhergestellt.split(":");
            System.out.println(einzelkarte[0]);
            System.out.println(einzelkarte[1]);
            Geschlecht g = Geschlecht.valueOf(einzelkarte[0]);
            Land l = Land.valueOf(einzelkarte[1]);
            gastkarten.add(new Gastkarte(g, l));
      }

die inneren Schleifen waren genauso verrückt, über so einfache Dinge musst du einen klaren Kopf behalten,
eine Schleife ist natürlich nicht undenkbar wenn sie einen Zweck hat:
gäbe es etwa die valueOf-Methode nicht, dann könntest du tatsächlich über alle Enum-Werte iterieren,
Strings vergleichen und so den Enum-Wert heraussuchen, der aktuell benötigt wird,
die valueOf-Methode macht das intern auf falls nicht mit Map noch besser gelöst

das wäre eine Schleife mit klarer Aufgabe und klarem Code (oder mit Fehler und dran zu arbeiten),
aber eine Schleife über alle bekannten Werte und damit Gastkarte-Objekte zu erstellen, ohne Bezug auf aktuellen Property, das ist Unsinn,

passiert natürlich, nicht schlimm, aber bitte den Unterschied zu normalen Programmierfehlern erkennen,
beliebig Code aneinanderreihen ist kein erlaubtes Konzept

Einen wunderschönen Guten Tag und vielen Liebe Dank euch beiden und allen, die mir geholfen haben.

Das Programm funktioniert nun so, wie es sollte. Dies tut es dank des Vorschlages von SlaterB. Du wolltest mich sicherlich testen:

            String gastkartewiederhergestellt = spielstand.getProperty("gastkarten" + n);
            String[] einzelkarte = gastkartewiederhergestellt.split(":");
            System.out.println(einzelkarte[0]);
            System.out.println(einzelkarte[1]);
            Geschlecht g = Geschlecht.valueOf(einzelkarte[0]);
            Land l = Land.valueOf(einzelkarte[1]);
            gastkarten.add(new Gastkarte(g, l));
      }```

Bei `Geschlecht g` und `Land l` waren die Parameter von `einzelkarte`, also 0 und 1 vertauscht. Hätte wahrscheinlich zu ein paar kleinen Fehlern geführt.
So wie es jetzt ist, läuft es.
Das `System.out.prinln` habe ich wieder entfernt und lasse einfach ganz am Ende einmal die ganze Liste Gastkarten zum testen in der Konsole ausgeben. So macht er das auch am Anfang des Spiels, wenn er aus einem neuen Spiel heraus startet.

Das ist mein Endcode, den ich noch dahinter gebastelt habe:
```for(int y=0;y<gastkarten.size();y++){
	    	jListGastkartenModel.addElement(gastkarten.get(y));
	  }
      System.out.println("Ein altes Spiel wurde wiederhergestellt");
      System.out.println(gastkarten);```

Der ist auch schon generell beim Gastkarten mischen dabei, der fügt das Zeuchs aus der List einfach in Reihenfolge in die jList ein. So läuft das ganze nun.

=====
Und nun noch einmal etwas generelles:

> Momentan bist Du in Deiner "Lösung" festgefahren. Wenn Du so weiter machst wirst Du Dein Projekt nicht fertig bekommen.
> 
> Auch wenn es hart ist: Vergiss was Du bisher hast und fang noch mal sauber mit den Grundlagen an. Konzentriere Dich zunächst auf das Modell (also die Spieler und die Karten und deren Interaktionen) ohne an die GUI zu denken. 
> 
> Wenn die "Engine" funktioniert kannst Du an Speichern/Laden und Visualisierung arbeiten.

Ich bin mir dem durchaus bewusst. Ich bin leider etwas beratungsresistent, muss ich zugeben. Ich wollte das mit der korrekten Kartenerzeugung und die Spielstandsspeicherung gleich zu Anfang weg haben, weil das meine beiden größten Baustellen sind. Was den Rest des Projektes angeht, arbeite ich immer nebenbei separat weiter, das ist eigentlich relativ einfach und stellt keine größeren Herausforderungen mehr dar.
Was ich persönlich noch dringend machen muss, ist das auslagern in Methoden und Klassen, da ich bisher mehr Schlecht als Recht mit Objektorientierung gearbeitet habe.

Ich persönlich habe mich eine Menge mit Swift und Python beschäftigt und arbeite daran auch. Java wurde mir leider nur Halbherzig im Informatikunterricht übergeholfen und nun ein ganzes Projekt ans Bein gebunden. Unser Infolehrer hat im Unterricht nicht einmal die Wörter "Klasse", "Methode" oder "Vererbung" in den Mund genommen. Unglaublich schade.
Auch wenn es manchmal so aussieht. Ich mag es nicht, wenn man mir alles vorsagt, ich recherchiere und teste alles mögliche nebenbei und belese mich weiter zu dem Thema. Ich versuche weitgehend den Code, den man mir angibt zu verstehen und nachvollziehen. Sieht halt manchmal etwas unbeholfen aus.

Wunderschöne Grüße und vielmals Dankeschön!
```for(int n;n<∞;n++) {
System.out.println("Dankeschön! :)");
}

Lukas :slight_smile:

[quote=FranzFerdinand]Das ist mein Endcode, den ich noch dahinter gebastelt habe:

    jListGastkartenModel.addElement(gastkarten.get(y));
}```

Der ist auch schon generell beim Gastkarten mischen dabei, der fügt das Zeuchs aus der List einfach in Reihenfolge in die jList ein. So läuft das ganze nun.[/quote]
Auch wenn's jetzt läuft noch ein Hinweis zum obigen Code:
Wenn Du das direkt beim Befüllen der ArrayList machst, kannst Du Dir die zweite Schleife sparen. Wenn Du die ArrayList in dem Fall nur zum Befüllen benötigst, könnte man sich auch die ArrayList bzw. deren Befüllen sparen.

[QUOTE=_Michael;104988]Auch wenn’s jetzt läuft noch ein Hinweis zum obigen Code:
Wenn Du das direkt beim Befüllen der ArrayList machst, kannst Du Dir die zweite Schleife sparen. Wenn Du die ArrayList in dem Fall nur zum Befüllen benötigst, könnte man sich auch die ArrayList bzw. deren Befüllen sparen.[/QUOTE]

Hallöle,

vielen Dank für den Hinweis. Das ist mir inzwischen schon aufgefallen. Nach Finden meiner oben geposteten Lösung hab ich mich ein wenig mit Codekosmetik befasst, da ist das natürlich ein sehr offensichtliches Element.

Vielen Dank trotzdem! Jemand der meinen Code gelesen hat. :slight_smile:

Gruß
Lukas

allgemein ist die längere Variante aber auch nicht zu verachten:
Aufgaben trennen, das Einlesen von der Datei muss nicht mit der GUI verknüpft sein,
gerade zum Testen kann der Aufrufer einer solchen Methode System.out.println() verwenden :wink: oder eine Test-Klasse sein

an das JList-Model will man vielleicht nicht nur Daten aus Datei sondern auch direkt generierte Liste übergeben,
in solch aufgeräumten Fällen mit getrennten Methoden kommt es auf eine Schleife mehr oder weniger nicht an,
einfache Listen zur Übertragung eine gute Sache dann

Hallöle ihr Leute,

ich habe nochmal eine Frage zu dem Reader, der mir alles einliest. Da läuft irgendwie was nicht so, wie es sein soll.
Ich habe neuerdings alles in Methoden und Klassen ausgelagert, also zumindest einen relevanten Teil ausgelagert. Klappt auch alles soweit.
Hier mal ein Ausschnitt aus meiner Unterklasse Spielstart.java.


import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.util.Collections;
import java.util.Properties;

import javax.swing.JOptionPane;
import javax.swing.JTextField;

import spiel.Gastkarte.Geschlecht;
import spiel.Gastkarte.Land;

public class Spielstart extends CafeRoot{
	
	private static final long serialVersionUID = 4759436681262448461L;
	
	public Spielstart() throws IOException{
		
		super(spielname);
	}
	
	 public static void neuesspiel() throws IOException{
		  Reader reader = new BufferedReader(new FileReader("neuesspiel.txt"));
		    Properties neuesspiel = new Properties();
		    try {
		      neuesspiel.load(reader);
		    }catch(FileNotFoundException ex){
		       ex.printStackTrace();
		       System.out.println("Die Datei neuesspiel.txt existiert nicht!");
		    }
		    reader.close();
		  String string_restkartentisch = neuesspiel.getProperty("restkartentisch", "24");
	      restkartentisch = Integer.parseInt(string_restkartentisch);
	      jLabelRestkartenTisch.setText("Resttische: "+restkartentisch);
	      String string_restkartengast = neuesspiel.getProperty("restkartengast", "0");
	      restkartengast = Integer.parseInt(string_restkartengast);
	      jLabelRestkartenGast.setText("Restgäste: "+restkartengast);
	      String string_restbarplaetze = neuesspiel.getProperty("restbarplaetze", "21");
	      restbarplaetze = Integer.parseInt(string_restbarplaetze);
	      jLabelRestbarplaetze.setText("Barplätze übrig: "+restbarplaetze); 
	      String string_handkartenspieler1 = neuesspiel.getProperty("handkartenspieler1", "0");
	      handkartenspieler1 = Integer.parseInt(string_handkartenspieler1);
	      jLabelHandkartenSpieler1.setText("Karten "+spielername1+": "+handkartenspieler1);
	      String string_handkartenspieler2 = neuesspiel.getProperty("handkartenspieler2", "0");
	      handkartenspieler2 = Integer.parseInt(string_handkartenspieler2);
	      jLabelHandkartenSpieler2.setText("Karten "+spielername2+": "+handkartenspieler2);
	      String string_punktespieler1 = neuesspiel.getProperty("punktespieler1", "0");
	      punktespieler1 = Integer.parseInt(string_punktespieler1);
	      jLabelPunkteSpieler1.setText("Punkte "+spielername1+": "+punktespieler1);
	      String string_punktespieler2 = neuesspiel.getProperty("punktespieler2", "0");
	      punktespieler2 = Integer.parseInt(string_punktespieler2);
	      jLabelPunkteSpieler2.setText("Punkte "+spielername2+": "+punktespieler2);
	      String string_spieler = neuesspiel.getProperty("spieler", "1");
	      spieler = Integer.parseInt(string_spieler);
	      if(spieler == 1){
	      	jLabelSpieler.setText("Am Zug: "+spielername1);
	      }
	      else{
	      	jLabelSpieler.setText("Am Zug: "+spielername2);
	      }
	      System.out.println("Neues Spiel gestartet");
	  }
	 public static void spielstand() throws IOException{
		  Reader reader2 = new BufferedReader(new FileReader("spielstand.txt"));
		  Properties spielstand = new Properties();
		  try {
		    spielstand.load(reader2);
		  }catch(FileNotFoundException ex){
		     ex.printStackTrace();
		     System.out.println("Die Datei spielstand.txt existiert nicht!");
		  }
		  reader2.close(); 
		  JOptionPane.showMessageDialog(null, "Ein Zwischengespeichertes Spiel wird wiederhergestellt!", "Weiterspielen", JOptionPane.INFORMATION_MESSAGE);
	      String spielername1 = spielstand.getProperty("spielername1", "Nicht vorhanden");
	      String spielername2 = spielstand.getProperty("spielername2", "Nicht vorhanden");
	  	  String string_restkartentisch = spielstand.getProperty("restkartentisch", "0");
	      restkartentisch = Integer.parseInt(string_restkartentisch);
	      jLabelRestkartenTisch.setText("Resttische: "+restkartentisch);
	      String string_restkartengast = spielstand.getProperty("restkartengast", "0");
	      restkartengast = Integer.parseInt(string_restkartengast);
	      jLabelRestkartenGast.setText("Restgäste: "+restkartengast);
	      String string_restbarplaetze = spielstand.getProperty("restbarplaetze", "21");
	      restbarplaetze = Integer.parseInt(string_restbarplaetze);
	      jLabelRestbarplaetze.setText("Barplätze übrig: "+restbarplaetze); 
	      String string_handkartenspieler1 = spielstand.getProperty("handkartenspieler1", "0");
	      handkartenspieler1 = Integer.parseInt(string_handkartenspieler1);
	      jLabelHandkartenSpieler1.setText("Karten "+spielername1+": "+handkartenspieler1);
	      String string_handkartenspieler2 = spielstand.getProperty("handkartenspieler2", "0");
	      handkartenspieler2 = Integer.parseInt(string_handkartenspieler2);
	      jLabelHandkartenSpieler2.setText("Karten "+spielername2+": "+handkartenspieler2);
	      String string_punktespieler1 = spielstand.getProperty("punktespieler1", "0");
	      punktespieler1 = Integer.parseInt(string_punktespieler1);
	      jLabelPunkteSpieler1.setText("Punkte "+spielername1+": "+punktespieler1);
	      String string_punktespieler2 = spielstand.getProperty("punktespieler2", "0");
	      punktespieler2 = Integer.parseInt(string_punktespieler2);
	      jLabelPunkteSpieler2.setText("Punkte "+spielername2+": "+punktespieler2);
	      String string_spieler = spielstand.getProperty("spieler", "1");
	      spieler = Integer.parseInt(string_spieler);
	      if(spieler == 1){
	      	jLabelSpieler.setText("Am Zug: "+spielername1);
	      }
	      else{
	      	jLabelSpieler.setText("Am Zug: "+spielername2);
	      }
	      gastkarten.clear();
	      jListGastkartenModel.clear();
	      for (int n=0;n<restkartengast;n++) {
	          String gastkartewiederhergestellt = spielstand.getProperty("gastkarten" + n);
	          String[] einzelkarte = gastkartewiederhergestellt.split(":");
	          Geschlecht geschlecht = Geschlecht.valueOf(einzelkarte[1]);
	          Land land = Land.valueOf(einzelkarte[0]);
	          gastkarten.add(new Gastkarte(geschlecht, land));
	          jListGastkartenModel.addElement(gastkarten.get(n));
	      }
	      System.out.println("Ein altes Spiel wurde wiederhergestellt");
	      System.out.println(gastkarten);
	  }
	 public static void namensfrage() {
		  JTextField spielername01 = new JTextField(new MaxSizeDocument(12), "", 0);
		  JTextField spielername02 = new JTextField(new MaxSizeDocument(12), "", 0);
	      Object[] namensfrage = {"Name von Spieler 1", spielername01, "Name von Spieler 2", spielername02};
	      JOptionPane pane = new JOptionPane(namensfrage, JOptionPane.PLAIN_MESSAGE, JOptionPane.DEFAULT_OPTION);
	      pane.createDialog(null, "Wie heißen die Spieler?").setVisible(true);
	      spielername1 = spielername01.getText();
	      spielername2 = spielername02.getText();
	      if(spielername1.equals("") || spielername2.equals("")) {
	    	  JOptionPane.showMessageDialog(null, "Bitte gib beide Spielernamen ein!", "Unvollständige Eingabe", JOptionPane.ERROR_MESSAGE);
	    	  System.out.println("Es wurden nicht alle Spielernamen eingetragen");
	    	  namensfrage(); 
	  	  }
	      else if(spielername1.equalsIgnoreCase(spielername2)) {
	    	  JOptionPane.showMessageDialog(null, "Bitte benenne die Spieler unterschiedlich!", "Namensgleichheit", JOptionPane.ERROR_MESSAGE);
	    	  System.out.println("Es wurde bei beiden Namen \""+spielername1+"\" eingetragen");
	    	  namensfrage(); 
	      }
	      else{
	    	  spielernamenkorrekt = true;
	      }
	  }
	 public static void gastkartenmischen() {
		  for(int j=0;j<2;j++){
		    	for(Land land : Land.values()) {
		            int anzahl = 2;
		            if (land == Land.Joker) {
		               anzahl = 1;
		            }
		            for(int i = 0; i < anzahl; i++) {
		                for(Geschlecht geschlecht : Geschlecht.values()) {
		                    gastkarten.add(new Gastkarte(geschlecht, land));
		                    restkartengast = restkartengast + 1;
		                }    
		            }
		        }
		    }
		  	
		  	/*Gastkarte eineGastkarte = gastkarten.get(0);
		  	Geschlecht geschlecht = eineGastkarte.geschlecht;
		  	Land land = eineGastkarte.land;
		    
		    if(land == Land.Chinese) {
		       System.out.println("Nihao!");
		    }*/
		    jLabelRestkartenGast.setText("Restgäste: "+restkartengast);
		    Collections.shuffle(gastkarten);
		    for(int n=0;n<gastkarten.size();n++){
		    	jListGastkartenModel.addElement(gastkarten.get(n));
		    }
		    System.out.println("Die Gastkarten wurden gemischt");
		    System.out.println(gastkarten);
	  }
	 public static boolean isWindows() {
			return (OS.indexOf("win") >= 0);
	 }
	 public static void reader1() throws IOException{
		 Reader reader = new BufferedReader(new FileReader("neuesspiel.txt"));
		    Properties neuesspiel = new Properties();
		    try {
		      neuesspiel.load(reader);
		    }catch(FileNotFoundException ex){
		       ex.printStackTrace();
		       System.out.println("Die Datei neuesspiel.txt existiert nicht!");
		    }
		    reader.close();
	 }
	 public static void reader2() throws IOException{
		 Reader reader2 = new BufferedReader(new FileReader("spielstand.txt"));
		    Properties spielstand = new Properties();
		    try {
		      spielstand.load(reader2);
		    }catch(FileNotFoundException ex){
		       ex.printStackTrace();
		       System.out.println("Die Datei spielstand.txt existiert nicht!");
		    }
		    reader2.close();
	 }
	

}```

Aber nun kommt da ein kleiner Fehler:
Ich habe, wie bereits erkannt die 2 Reader in zwei Methoden ausgelagert, weil ich die auch bis dato sicherlich 10 mal eingefügt habe und das mal in eine Methode rutschen sollte.
Siehe unten:
`reader1` & `reader2`
Nun das Problem:
Die Zeilen 27 bis 35 beispielsweise würde ich dann durch den Methodenaufruf ersetzen können.
Also habe ich `reader1();` hingeschrieben, wie ich auch alle anderen Methoden aufrufe. Aber das klappt nicht in der Form.
Wenn ich das tue, gibt es in den Zeilen danach lauter Fehler, dass Variablen nicht aufgelöst werden könnten.
```String string_restkartentisch = neuesspiel.getProperty("restkartentisch", "24");
          restkartentisch = Integer.parseInt(string_restkartentisch);
          jLabelRestkartenTisch.setText("Resttische: "+restkartentisch);
          String string_restkartengast = neuesspiel.getProperty("restkartengast", "0");```

Explizit überall wo `neuesspiel.getProperty` steht, da kann er `neuesspiel` nicht auflösen.
Dieses ist aber in der Methode eigentlich so definiert.


Bis hierhin ist das Projekt gut vorangekommen und ich habe jetzt auch eine Menge Sachen allein zusammenbasteln können, ich lese ja nebenbei zu Java diverse Bücher. Aber das ist mir jetzt echt suspekt.

Kann mir das jemand erklären und korrigieren?

Schönen Samstag!
Lukas :)

Dass die Klasse von CafeRoot erbt und dann nur statische Methoden besitzt, schaut ganz schon gefährlich aus. Da müsste einiges aufgeräumt werden.
Direkte Hilfestellung kann ich so spontan nicht geben, außer den Hinweis, dass wenn eine Variable nicht aufgelöst werden kann, dann liegt es daran, dass die Variable im Gültigkeitsbereich des Codes nicht bekannt ist. Das war bei Deinem Code bereits mehrfach der Fall. Vielleicht mal grundsätzlich mit dem Thema beschäftigen?

[quote=FranzFerdinand]Explizit überall wo neuesspiel.getProperty steht, da kann er neuesspiel nicht auflösen.
Dieses ist aber in der Methode eigentlich so definiert.[/quote]
Methoden sind keine direkt einzufügenden Codezeilen die nur im Moment woanders stehen,
da sähe man ja überhaupt nicht durch, vielleicht noch

double betrag = 100;
updateGUI();
ueberweiseAnXy(betrag); // Methode hat betrag auf 300.000 geändert..

ok, in gewisser Form gibt es das, mit Instanzattributen,
wäre betrag ein solches statt lokaler Variable, dann änderbar,
sogar nicht nur durch eigene Untermethodenaufrufe sondern beliebig nebenläufig durch andere Threads,

naja, eins nach dem anderen, Instanzattribute hast du gar nicht, auch ok sofern noch nicht benötigt

die Untermethode kann Zeile 27-35 haben und Properties statt void als Rückgabewert definieren und return neuesspiel;
und der Aufrufer schreibt Properties neuSpiel = readNeuesSpiel();

Methoden gleich sinnvoll benennen,
und je nach Gesschmack gibt es mehr oder weniger Verwirrung, wenn man in verschiedenen Methoden unterschiedliche Variablennamen vergibt statt alles ‘neuesspiel’ zu nennen,
lokale Variablen sind jeweils eigenständig, auch wenn sie auf dieselben Objekte im Speicher zeigen sollten

Hallihallöle und danke für Deine Antwort,

ich hab das nochmal gelesen mit void und Properties. Okay, hast Recht, da war jetzt mein Wissen nicht so weit, um das wissen zu können.
Ich hab die zwei Methoden nun hierhin geändert:

         Reader reader = new BufferedReader(new FileReader("neuesspiel.txt"));
            Properties neuesspiel = new Properties();
            try {
              neuesspiel.load(reader);
            }catch(FileNotFoundException ex){
               ex.printStackTrace();
               System.out.println("Die Datei neuesspiel.txt existiert nicht!");
            }
            reader.close();
			return neuesspiel;
     }
	 
	 public static Properties reader2() throws IOException{
         Reader reader2 = new BufferedReader(new FileReader("spielstand.txt"));
            Properties spielstand = new Properties();
            try {
              spielstand.load(reader2);
            }catch(FileNotFoundException ex){
               ex.printStackTrace();
               System.out.println("Die Datei spielstand.txt existiert nicht!");
            }
            reader2.close();
            return spielstand;
     }
	 ```

Das dort klappt alles ohne irgendwelche Beanstandungen durch Java.
Ich kann jedoch weiterhin aus dem gleichen Grund wie bisher nicht `reader();` und `reader2();` in den Code einfügen.
Dann kennt er die Parameter Spielstand und Neuesspiel weiterhin nicht.

Kann man mir erklären, was da faul ist?

Gruß
Lukas

wie du die Methoden aufrufst schreibst du nicht eindeutig, daher unbekannte Fehlerursache, die durch Code vollkommen bekannt wäre…

den Andeutungen nach ist aber zu vermuten, dass du als Aufruf-Codezeile tatsächlich nur reader(); hast,
also das komplette aktuelle Thema, Implementierung und auch NUTZUNG des Rückgabewertes ignorierst,
ebenso wie die von mir gepostete FERTIGE Code-Zeile beim Aufrufer

→ nur dann nämlich ist beim Aufrufer eine Properties-Variable mit dem dort gewählten Namen bekannt

wenn real, dann bemerkenswert unproduktiv,
meine allgemeinen Befürchtungen gehen bei sowas immer Richtung Troll…,
nimm es als Feedback hin und gelobe insgeheim Besserung wenn nicht Troll

SlaterBs Anmerkungen ist eigentlich nichts hinzuzufügen, da potentiell Fehler verursachender Code nicht gepostet.

Ich gehe mal von Nicht Troll aus.
Zum geposteten Code:
Es ist eigentlich Blödsinn zwei Methoden zu schreiben, die dasselbe machen. Doppelten Code solltest Du nach Möglichkeit vermeiden.
Definiere eine wiederverwendbare Methode:

        Reader reader = new BufferedReader(new FileReader(filename));
           Properties prop = new Properties();
           try {
             prop.load(reader);
           }catch(FileNotFoundException ex){
              ex.printStackTrace();
              System.out.println("Die Datei " + filename + " existiert nicht!");
           }
           reader.close();
           return prop;
    }```

Und nutze sie an passender Stelle z.B. `Properties neuesSpiel = loadProperties("neuesspiel.txt");` bzw. `Properties spielstand = loadProperties("spielstand.txt");`

Dann noch allgemein: Ist es das Ziel das Spiel "Cafe International" komplett in Java abzubilden? Das wäre nach drei Monaten Schulunterricht Java mehr als wagemutig. Zumal es schon mit so einfachen Sachen Probleme gibt und sofern Schulunterricht überhaupt Wissen vermitteln kann, das Wissen für so ein Spiel nach drei Monaten nicht vorhanden sein kann.

Warum nicht etwas einfachere Spiele z.B. Tic Tac Toe?

Hallihallöle und vielen Dank für eure beiden Antworten,

verdammt Michael, das ist brillant.
Reader reader = new BufferedReader(new FileReader(filename));
Ich arbeite manchmal partiell ineffektiv, stimmt, dass mir sowas nicht direkt aufgefallen ist, ist mir im Nachhinein etwas peinlich. Dass ich da mit zwei Readern gearbeitet habe…

Naja, wie dem auch sei. Ich bin kein Troll, keinesfalls, ich arbeite nur ineffektiv. Glaubt mir, wie ihr sehen könnt gebe ich mir beim Verfassen meiner Beiträge mühe sie verständlich, umfänglich und grammatikalisch sowie orthografisch korrekt zu halten, was man hier wahrlich nicht überall sieht. Wenn ich mal zusammenaddiere, wie viel Zeit ich für das Beiträge schreiben in diesem Thema investiert habt, dann glaubt mir, hätte ich gewusst, wie es geht, hätte ich es allein schneller gemacht. Aber ich wusste es nicht…

@michael : Das soll ein umfangreiches Jahresprojekt werden, da kauft mir kein Infolehrer, auch der inkompetente Mann, der unsere Javakenntnisse verpfuscht hat nichts ab. Ich selbst habe schon Kniffel, TicTacToe, Stein-Schere-Papier und Zahlen raten selbst programmiert, ohne große Probleme. Aber sowas ist nun wirklich leider ne Sache von 10 Minuten und das kann man nicht für nen Jahr abgeben.

Deshalb arbeite ich daran und studiere nebenbei ein paar Javabücher, sonst würde ich hier noch unbeholfener Herüberkommen.
Aber meine Zwei Fragen in diesem Forum, zur Generierung der Gastkarten und zum Speichermanagement waren jetzt ehrlich gesagt aber auch die schwersten Sachen des Projekts. Ich bin mir ziemlich sicher, den Rest ohne größere Probleme hinzubekommen. Das basiert nun zumeist nur noch auf Logik, wann der Computer Karten an bestimmten Stellen akzeptiert oder ablehnt. Höchstens die Grafische Oberfläche könnte mir aufgrund meiner Kreativfreiheit nochmal ein wenig Kopfzerbrechen bereiten.

Vielen Dank an alle, die sich die Zeit genommen haben.

Bussy
Lukas

Achso, ups: Ich hatte vergessen zu erwähnen, das klappt nun alles. :slight_smile: