tournierprogramm mit DB

[annalena]

hallo ich hab mir mal ein Programm vorgenommen was ich mal schreiben wollte...

dabei möchte ich in einem fenster zunächst die anzahl der spieler ermitteln.....wenn ich das hab dann möchte ich die namen eintragen...
ich möchte dann mittels random die spieler in Teams einsotieren..(mgl. teamgröße ebenfalls mitangeben) dann sollen die spieler in die Teams per zufall einsortiert werden..zuletzt soll nochmal randomisiert werden um die Teams per zufall gegeneinander spielen zu lassen.

dies soll natürlich alles in die Datenbank...wenn ich die Teams mit sammt allen spielern vermischt habe eine übersicht in dem ich das sieg/verlust Verhältnis eintragen kann...um all dies in die Datenbank zu tragen um später Auswertungen zu ziehen...und für das derzeitige spiel alle Ergebnisse addieren...zB spieler a,b,c,d win /lose
runde1
a=1/0
b=1/0
c=0/1
d=0/1
somit würde ich dem Programm die Logik beibringen das immer gewinner mit einander spielen also in diesem Beispiel 1 und b....und um die letzten beiden plätze auszuknobeln c und d
somit würde dann in
runde 2
a=2/0 (platz 1)
b=1/1 (platz 3)
c=1/1 (platz 3)
d=0/2 (platz4)
vllt sollte man dann noch eine runde spielen um ganz sicher zu gehen den es hätte ja auch jeder 1/1 haben können..also 3 runden wäre schon das mindeste...

um so mehr spieler um so mehr runden müssen initialisiert werden...

und nach jeder runde muss ich die Ergebnisse eintragen...also sieg/niederlage der gegeneinander angetretenen Teams (Team besteht aus min. 1 spieler)

und dann die Ergebnisse eintragen...

habt ihr ne Idee wo ich bei sowas anfangen soll? Gedanken hab ich mir gemacht..und ein kleines testfenster hab ich auch schon

 

[kneitzel]

Wo ist denn das genaue Problem? Du hast eine Reihe von Spielern. Die kannst Du am Anfang einmal mischen. Dann treten die einfach gegeneinander an. Also immer 2 Zusammen.
Zu jedem Spieler speicherst Du die Anzahl der Kämpfe.
Dann kannst Du den Wettkampf durchführen:
Immer 2 Spieler zusammen - die sollen gegeneinander spielen. Wer gewinnt kommt in die Liste Gewinner, die Verlierer in die Liste Verlierer
Wenn ein Spieler übrig bleibt, dann kommt dieser direkt in die Liste Gewinner und steht damit ganz am Anfang und wird damit so schnell nicht wieder aussetzen.

Dann kannst Du entscheiden, wie Du weiter vorgehst:
- Verlierer kannst Du entfallen lassen (K.O. System) oder einfach weiter Kämpfen lassen.
- Die Gewinner kämpfen weiter.
Das Mischen machst du aber nur ganz am Anfang - sonst hast Du hinterher jemanden, der bei ungünstiger Anzahl ohne jeden Kampf bis ins Halbfinale / Finale kommt (je nachdem, wie das Finale organisiert ist. Doppeltes KO System ist ja, wenn am Ende der Sieger der Verlierer nochmal gegen den Gewinner auf Seiten der Sieger kämpfen darf wenn ich mich nicht irre.

So kann es aber dann zu ungleicher Anzahl der Wettkämpfe kommen. Du hast aber Teams angesprochen. Du kannst natürlich hin gehen und "teams" bilden. Dann hast Du - je nach Anzahl der Teilnehmer, Teams gebildet. Z.B. 4 oder 8 Teams. Und diese Teams kämpfen dann erst einmal jeder gegen jeden um dann eine Reihenfolge zu bekommen. Und dann kommen je Team die besten 2 weiter, die dann nach oben genanntem System den Sieger ausmachen. Hat den Vorteil, dass die Anzahl beim KO System eine Zweierpotenz ist und daher dann niemand mehr aussetzen muss.

Hier musst Du aber ganz genau entscheiden, was Du wie haben willst. Die Wettkampfmodalitäten müssen halt einmal festgelegt sein, damit du die dann entsprechend umsetzen kannst.

 

[Joose]

Gedanken hab ich mir gemacht..und ein kleines testfenster hab ich auch schon

Welche Gedanken denn? Das UI solltest du dir als letztes vornehmen ... ohne passende Logik bringt dir das beste UI nichts

habt ihr ne Idee wo ich bei sowas anfangen soll?

Indem du uns eine konkrete Frage stellst bzw. genau sagst wo das Problem liegt.
So wie es auschaut hast du dir ja ein Konzept überlegt. Bei diesem ist mir die Einteilung aber noch unklar ... Spieler werden Teams zugeteilt und spielen innerhalb der Teams gegeneinander? Meinst du eher die Spieler werden in Gruppen eingeteilt? (die Spieler eines Teams spielen normalerweise gemeinsam gegen ein anderes Team )

dabei möchte ich in einem fenster zunächst die anzahl der spieler ermitteln.....wenn ich das hab dann möchte ich die namen eintragen...

Wie schon oben gesagt das UI sollte erst später implementiert werden.
Überlege dir am besten welche Daten du zu den Spielern erfassen willst. Auch welche Daten für Gruppen/Teams und Begegnungen/Matches du speichern willst und brauchts.
Anhand dieser Überlegungen kannst du dir mal ein Datenmodell erstellen.

dies soll natürlich alles in die Datenbank...wenn ich die Teams mit sammt allen spielern vermischt habe eine übersicht in dem ich das sieg/verlust Verhältnis eintragen kann...um all dies in die Datenbank zu tragen um später Auswertungen zu ziehen...und für das derzeitige spiel alle Ergebnisse addieren...zB spieler a,b,c,d win /lose

Um die Daten dann in die Datenbank zu schreiben wirst du wahrscheinlich eine Datenzugriffsschicht schreiben welche mit der Datenbank kommuniziert.
Welche Daten wann und wie dort eingetragen werden, entscheidet dann eben dein Programm.

Die eigentliche Logik von deinem Programm betrifft dann eigentlich die Zulosung der Gegner und die Auswertung der abgelaufenen Matches.


EDIT: Ich habe das Thema mal verschoben. Das Problem betrifft nicht direkt die DB sondern das Programm bzw. die Programmstruktur/den Programmablauf an sich.

 

[annalena]

naja mein Lehrer sagte ich sollte direkt mit der Datenbank anfangen...also die Verbindung und dann direkt nur noch mit er DB kommunizieren..weil alles später einbauen wäre zuviel umgemodel und umbau...alles tote zeit..nun habe ich aber mit Java noch nie mit einer mysql Datenbank zuammen gearbeitet..^^ gerade mal damals mit c# und mssql...da ich es ja modular haben möchte allein der Ordnung halber...lege ich eine neue class in equlipse an schreibe dort den Connection string rein? und alle lese und schreib arbeiten die ich brauche?...also jede Methode die ich brauche meine ich..lesen schreiben...überschreiben abfragen etc?

 

[Joose]

naja mein Lehrer sagte ich sollte direkt mit der Datenbank anfangen

Hat er auch recht, das richtige Datenbankmodell solltest du dir schon überlegen bevor du anfängst du implementieren.

...also die Verbindung und dann direkt nur noch mit er DB kommunizieren..

Hört sich so an wie wenn laut Lehrer alles auf der Datenbank ablaufen soll
Was aber unsinnig ist.

weil alles später einbauen wäre zuviel umgemodel und umbau...alles tote zeit..

Ansichtsache ... du sollst den Code den du schreibst ja selbst ohne Probleme verstehen und auch anpassen können. Auch sollte Code geschrieben werden der eine spätere Anforderungänderung keinen Umbau notwendig macht.
Aber wie schon gesagt die eigentliche Logik vom Programm sollte Vorrang haben, danach kann man sich immer noch um ein hübsches UI kümmern.

nun habe ich aber mit Java noch nie mit einer mysql Datenbank zuammen gearbeitet..^^ gerade mal damals mit c# und mssql

Daher würde ich diese Aufgabe/das Projekt eher ungeeignet finden um das Arbeiten mit Datenbanken zu üben. Aber gut die Aufgabe kannst du schwer ändern ...

...da ich es ja modular haben möchte allein der Ordnung halber...lege ich eine neue class in equlipse an schreibe dort den Connection string rein? und alle lese und schreib arbeiten die ich brauche?...also jede Methode die ich brauche meine ich..lesen schreiben...überschreiben abfragen etc?

Jein ... natürlich gibt es eine Klasse welche die Verbindung zu der Datenbank aufbaut (und verwaltet). Aber ansonsten würde ich dir zum DAO Pattern raten oder du setzt zum Beispiel Hibernate ein um deine Daten zu lesen/schreiben. Also nicht für alle Lese-/Schreiboperationen eine Methode sondern ein etwas mehr objektorientierter Ansatz.

 

[annalena]

Jein ... natürlich gibt es eine Klasse welche die Verbindung zu der Datenbank aufbaut (und verwaltet). Aber ansonsten würde ich dir zum DAO Pattern raten oder du setzt zum Beispiel Hibernate ein um deine Daten zu lesen/schreiben. Also nicht für alle Lese-/Schreiboperationen eine Methode sondern ein etwas mehr objektorientierter Ansatz.

magst mir da mal etwas drüber erzählen bitte?

Hört sich so an wie wenn laut Lehrer alles auf der Datenbank ablaufen soll
Was aber unsinnig ist.

naja es soll nicht alles auf der DB laufen, also nicht in diesem sinne..ich möchte nunmal (vorerst in die Konsole) spieler anzahl abfragen..dann wird n int eingegeben..dann wird abgefragt wie große die Teams sind...da sollte dann min 1 maximal gesammtspieler/2 möglichsein.....optional spielernamen eintragen...sooo dann hatte ich mir gedacht diese werte in die DB einzutragen..sagen wir mal mit namen...diese werden dann ja durch knopf RANDOM vermischt und in ihre FESTEN Teams(ein Team kann auch aus nur einem einziegen spieler bestehen) gelegt..brauche ich da dann ein 3d Array? oder eher eine liste ...weiß nicht was effizienter bzw. einfacher ist für die Datenbank...

nächste frage wäre dann nach dem mischen wie Team x gegen Team x gespielt hat..optional mit einem Counter (bei Teams von 2 spieler gegen 2 spieler würde ich gern mit aufzeichnen welcher spiele in Team 1 wieviele spieler in Team zwei auf dem gewissen hat...kann ja sein das im Team 1 ein spieler die anderen beiden allein besiegt...und der zweite vllt gar nichts macht oder schlechte karten zieht oder eine schlechte waffe hat (das Programm wollte ich so allgemein und wiederverwertbar wie möglich machen) oder eine schlechte Internet Verbindung hat oder technischen ausfall etc.)um dort eine besondere Statistik oder siegererhung zu ziehen...und deswegen möchte ich ja viel mehr mit der Datenbank arbeiten..
...
wenn dann alle Teams durch sind mit abgefragt werden wie sie spielten..ist die erste runde beendet..und alles wird in die DB getragen..also die spielergebnisse...jetzt würde dann runde zwei beginnen..also irgendwann knopf Datenbank speicher und neu radomisieren...nun kommt die erste größere Logik...um die Mischungen auszuwerten...weil die gewinner treten gegeneinander an..und die verlierer ja ebenfalls und die gleichstarken...und auch guter einfall das mit der ungeraden zahl..das der eine höhere Priorität genießt dran zu kommen...da wüsste ich jetzt noch nicht wie ich das ausprogrammieren sollte...

jedenfalls ist es dann in Ziehung zwei so...das starke gegen starke antreten und schwache gegen schwache..und keine Teams doppelt gegen einander spielen..das darf niemals der fall sein...bei einer größe von beispielsweise 10 Teams..muss ich zudem ermitteln wie viele runden gespielt werden um eine sichere Gewinnermittlung durchzuführen..bei 10 Teams sind das sicher 4 oder 5 runden wenn man das best of three Prinzip anwendet



meine Datenbank hätte dann ja nur eine Tabelle mit den spalten ID, PLAYER, TEAM,KILLS,WIN,LOSE,DATE

das heisst ich muss dann auch noch eine überischt schafen in dem ich das Datum zuerst auswähle und zB in eine Combobox lese um die Auswertung eines vergangenen spiels zu lesen..oder ein neues spiel zu starten,...aber das ist vorerst nicht wichtig..das kann man später noch nachträglich einbauen wenn mans braucht ^^

 

[annalena]

das ist nun mein erster versuch...also ich gebe die anzahl der spieler und größe des Teams ein..jedoch sollte ich diese in ein Array eintragen nehme ich an..oder in eine liste? was wäre den hier am sinnvollsten...den ich möchte ja die eingetragenen werte in die DB einlesen und ebenso wieder ausgeben wenn ich neu randomisiere...oder wie?

package winCalc;
import java.util.Scanner;
public class WinCalc /*extends JFrame implements WindowListener*/
{
  public static void main( String[] args ){
    new WinCalc();
  }
  public WinCalc(){
    MainFrame();
  }
  private void MainFrame(){
    Scanner sc = new Scanner( System.in );
    System.out.println( "spieleranzahl?: " );
    int playerNo = sc.nextInt();
    System.out.println( "teamgröße: " );
    int teamSize = sc.nextInt();
    System.out.println( "anzahl der teams: " + ( playerNo / teamSize ) );
    System.out.println( "name spieler " + playerNo + " eingeben: " ); // playerNo sollte Array sein
    String playerName = sc.nextLine();

    sc.close();
   }
}

 

[Joose]

magst mir da mal etwas drüber erzählen bitte?

Bei "DAO" handelt es sich um ein Design Pattern
http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/dao.html
http://www.tutorialspoint.com/design_pattern/data_access_object_pattern.htm
Es soll einfach den Zugriff auf die Daten besser kapseln.

Bei "Hibernate" um ein ORM Framework um deine Objekte einfach in die Datenbank zu speichern und wieder zu laden.
https://de.wikipedia.org/wiki/Hibernate_(Framework)

Zu beiden kann man viel erzählen, am besten liest du dich wenn erstmal ein und fragst dann was konkretes.

naja es soll nicht alles auf der DB laufen, also nicht in diesem sinne..ich möchte nunmal (vorerst in die Konsole) spieler anzahl abfragen..dann wird n int eingegeben..dann wird abgefragt wie große die Teams sind...da sollte dann min 1 maximal gesammtspieler/2 möglichsein.....optional spielernamen eintragen...sooo dann hatte ich mir gedacht diese werte in die DB einzutragen..sagen wir mal mit namen...diese werden dann ja durch knopf RANDOM vermischt und in ihre FESTEN Teams(ein Team kann auch aus nur einem einziegen spieler bestehen) gelegt..brauche ich da dann ein 3d Array? oder eher eine liste ...weiß nicht was effizienter bzw. einfacher ist für die Datenbank...

Ja dann fang einfach mal damit an deine Model Klassen (Spieler, Team) zu erstellen.
Dann eben eine Klasse um die Spieler in Teams einzuteilen, usw.
Die Funktionalität der Klassen testest du mit Unit Tests (oder die schlechtere Variante: eine main Methode und mal Dummy Spieler und Team Objekte erstellen und die Methode aufrufen und das Ergebnis kontrollieren)

Du beschreibst hier schon detailierter den Programmablauf (was wird wann geklickt und abgefragt ....). Der sollte für dich anfangs nicht so interessant sein.
Sondern welche Daten willst du abbilden? -> Dafür brauchst du eben Modelklassen
Welche Aufgaben fallen im Programm an? -> Einteilung der Teams, Auswertung der Ergebnisse (sind auch schon wieder 2 Klassen), laden/speichern der Daten (die DAO Klassen zum Beispiel)
Und Schritt für Schritt entwickelst du das Programm weiter.

nächste frage wäre dann nach dem mischen wie Team x gegen Team x gespielt hat..optional mit einem Counter (bei Teams von 2 spieler gegen 2 spieler würde ich gern mit aufzeichnen welcher spiele in Team 1 wieviele spieler in Team zwei auf dem gewissen hat...kann ja sein das im Team 1 ein spieler die anderen beiden allein besiegt...und der zweite vllt gar nichts macht oder schlechte karten zieht oder eine schlechte waffe hat (das Programm wollte ich so allgemein und wiederverwertbar wie möglich machen) oder eine schlechte Internet Verbindung hat oder technischen ausfall etc.)um dort eine besondere Statistik oder siegererhung zu ziehen...und deswegen möchte ich ja viel mehr mit der Datenbank arbeiten..

Wie oben schon geschrieben: Du willst eine Auswertung der (Kampf)daten haben, daher brauchst du Modelklasse(n) welche diese Daten abbilden.
Du gehst hier schon auf "Karten" und "Waffen" ein ... ich würde dir raten anfangs nur nicht zuviele Features einzubauen. Sondern diese nach und nach hinzuzufügen. Es ist motivierender einen brauchebaren Prototypen zu haben und diesen um Features zu erweitern als ewig zu coden und nie etwas lauffähiges zu haben.

Der Punkt mit "schlechter Internetverbindung" ist für den Anfang auch nicht relevant. Konzentriere dich darauf das dein Programm lokal läuft danach kann man es für Netzwerke anpassen/optimieren.

wenn dann alle Teams durch sind mit abgefragt werden wie sie spielten..ist die erste runde beendet..und alles wird in die DB getragen..also die spielergebnisse...jetzt würde dann runde zwei beginnen..also irgendwann knopf Datenbank speicher und neu radomisieren...nun kommt die erste größere Logik...um die Mischungen auszuwerten...weil die gewinner treten gegeneinander an..und die verlierer ja ebenfalls und die gleichstarken...und auch guter einfall das mit der ungeraden zahl..das der eine höhere Priorität genießt dran zu kommen...da wüsste ich jetzt noch nicht wie ich das ausprogrammieren sollte...

Wie oben schon erwähnt wird auch hier der Programmablauf beschrieben. Dieser ganze Ablauf sollte eben in einer Klasse entsprechend definiert/festgelegt sein.

jedenfalls ist es dann in Ziehung zwei so...das starke gegen starke antreten und schwache gegen schwache..und keine Teams doppelt gegen einander spielen..das darf niemals der fall sein...bei einer größe von beispielsweise 10 Teams..muss ich zudem ermitteln wie viele runden gespielt werden um eine sichere Gewinnermittlung durchzuführen..bei 10 Teams sind das sicher 4 oder 5 runden wenn man das best of three Prinzip anwendet

Das muss dann in einer entsprechende Bedingung in deiner Logik definiert sein.

meine Datenbank hätte dann ja nur eine Tabelle mit den spalten ID, PLAYER, TEAM,KILLS,WIN,LOSE,DATE

Sehe ich nicht so. Angeblich willst du ja auswerten, wer wen gekillt hat. Es soll Karten und Waffen geben, wo werden die Werte der Karten gespeichert?
Mit dieser einen Tabelle lässt sich auch schwer abbilden wer gegen wen schon mal gespielt hat. Hier kann man nur rauslesen "Spieler A" gehört zu "Team A" und hatt X Kills.
Gehört ein Spieler immer zum gleichen Team oder kann er es auch wechseln? -> mit diesem Modell nicht möglich.

das heisst ich muss dann auch noch eine überischt schafen in dem ich das Datum zuerst auswähle und zB in eine Combobox lese um die Auswertung eines vergangenen spiels zu lesen..oder ein neues spiel zu starten,...aber das ist vorerst nicht wichtig..das kann man später noch nachträglich einbauen wenn mans braucht ^^

Ja wenn es keine Kernanforderung an das Programm ist, kann die Auswertung auch nachträglich eingebaut werden.

ALLGEMEIN:
Du solltest dir eben wirklich überlegen was sind die genauen (Kern)Anforderungen an dein Programm und schreibe sie auf (kannst sie auch hier posten, dann kennen wir uns auch etwas aus und können vielleicht besser helfen). Besondere Features oder sonstiges schreibst du ebenfalls auf, sollten aber eben vorerst nur ein Nice-to-have bleiben.
Überlege dir ein passendes Datenbankmodell, du wirst mehr als eine Tabelle brauchen.
Um das UI kannst du dir schon Gedanken machen, aber du solltest mit der Logik deines Programmes anfangen und erst dann das passende UI dazu entwickeln. (konzentrier dich beim UI eher auf die Funktionalität und das Layout, ein schönes Design kann man nachträglich noch verwenden).

 

[annalena]

ich bin bestimmt doof oder so...aber meine for each funktioniert nicht wie ich es mir dachte... -.-

private void MainFrame()
  {
    Scanner sc = new Scanner( System.in );
    System.out.println( "spieleranzahl?: " );
    int playerNo = sc.nextInt();
    System.out.println( "teamgröße: " );
    int teamSize = sc.nextInt();
    System.out.println( "anzahl der teams: " + ( playerNo / teamSize ) + "\n\n" );

    List<String> playerName = new ArrayList<String>();

    int j = 0;
    for( int i = 0; i <= playerNo; i++ )
    {
      System.out.println( "Spieler " + j );
      String playerNam = sc.nextLine();
      playerName.add( playerNam );
      //System.out.println( "durchlauf " + j + "" );
      j++;
    }
    System.out.println( "auflistung inhalt" );
    System.out.println( playerName );

    sc.close();
  }

das hier wäre die ausgabe in der konsole

spieleranzahl?:
3
teamgröße:
1
anzahl der teams: 3

Spieler 0
Spieler 1
a
Spieler 2
s
Spieler 3
d
auflistung inhalt
[, a, s, d]

wieso überspringt er spieler 0 und beginnt mit spieler1 der erste index ist ja auch leer );

also ich hab den code deswegen so umgeschrieben, dass ich alle spieler eintragen kann ungeachtet das der index 0 leer bleibt..aber ich möchte lieber beim index 0 beginnen die liste beschreiben

 

[Joose]

Lies dir diesen Thread durch: http://www.java-forum.org/thema/scanner-problem.172019/
Dort wird genau dein Problem behandelt, gelöst und erklärt warum es auftritt

 

[annalena]

danke das hat geholfen..so simple..mhh..

nun Shuffle ich es mit collections.shuffle(listenname);
ist es sinnvoll jetzt nach dem shuffln dem neuen festen index ein team zuzuweisen? anhand der maximal möglichen Teams? weil ich nunmal ja die größe des Teams ausreche..
oder wie handhabt man sowas der Lesbarkeit des codes sowie des weiterarbeitens

 

[Joose]

ist es sinnvoll jetzt nach dem shuffln dem neuen festen index ein team zuzuweisen? anhand der maximal möglichen Teams? weil ich nunmal ja die größe des Teams ausreche..
oder wie handhabt man sowas der Lesbarkeit des codes sowie des weiterarbeitens

Was ist "der neue feste Index"? Und auch die restlichen Sätze/Fragen sind für mich etwas wirr und unverständlich was du genau wissen willst.

 

[annalena]

ok..also folgende ausgabe erhalte ich mit meinem code wenn ich jetzt beispielsweise anzahl spieler:6 eingebe...namen: a,b,c,d,e,f und teamgröße 2...

dann erhalte ich ja [a,b,c,d,e,f]
geshufflt dann meinetwegen sowas..[b,e,a,d,c,f]

nun möchte ich diese namentlich angegebenen spieler einem team zuweisen..und habe keinen lösungsansatz bis auf die idee , die liste durchein for laufen zu lassen und nach und nach ein team zu vergeben bis die größe des Teams erreicht worden ist...also in dem fall 2...und er dann weiter geht...und dann teamcounter um einen hoch setzt und team2 vergibt weil team 1 voll ist

 

[Joose]

Wie schon weiter oben geschrieben: Überlege dir eine passende Datenstruktur für dein Program, dadurch vereinfachst du dir manches.

Zu deinem Problem: Simple Überlegung -> erstelle soviele Listen wie du Teams haben willst. Der erste Spieler kommt ins 1.Team, der 2.Spieler ins 2.Team, der 3.Spieler ins 1.Team (bei 2 Teams), usw ....

 

[annalena]

Hallo, aufgrund einer verletzung meines Auges konnte ich langezeit nicht auf einen Monitor starren..nun gehts halbwegs, das ist bisher mein code...

ich frage mich, wie ich die zahlen die ich als anzahlspieler und größe des teams so hinpacke das ich eine auflistung bekomme, und das instant um daunter direkt die namen einzugeben...also ich gebe oben anzahl spieler ein...und möchte dann unten direkt n-anzahl textfelder generieren..

ist dies möglich? oder muss ich erst einen verarbeitungsschrit zb auslösen eines buttons einbauen?

dezeitige funktionen hauptfenster mit "start des programs" also löschung der eingaben und des "start" buttons...

rundenzähler "count" zählt nicht, warum kann ich mir nicht erklären, obwohl ich ihn ja hochsetze wenn ich new round knopf drücke

overview funktioniert auch wie gewünscht mit dem toggle...nun muss ich dort nur irgendwann die werte der spieler und rundenergebnisse einbauen

package s;

/*#### INCLUDES ##############################################*/
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;

/*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
/*#### VARETC ################################################*/
public class TourMain extends JFrame implements ActionListener, ComponentListener
{

  private JTextField displayText  = new JTextField( 30 );                          // textfield 30 charakter
  private JTextField displayText2 = new JTextField( 30 );                          // textfield 30 charakter
  private JLabel     MLabel       = new JLabel();
  private JLabel     MLabel2      = new JLabel();
  private JLabel     MLabel3      = new JLabel();

  private JButton[]  button       = new JButton[4];                                //number of buttons
  private String[]   keys         = { //and order of buttons
                                  "Randomize", "New Round", "Overview", "SaveDB" };
  boolean            toggle       = true;
  JFrame             ov           = new JFrame( "Overview" );
  int                count        = 0;

  /*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
/*#### WINDOWBUTTONS #########################################*/
  public TourMain()
  {
    setTitle( "Tournament 0.1" ); //frame settings
    this.setBounds( 250, 200, 800, 500 ); //pos x/y ; size x/y
    this.addComponentListener( this );
    Container pane = getLayeredPane(); //container

    MLabel.setBounds( 10, 10, 135, 15 );
    MLabel.setText( "Anzahl Spieler (2 - 16) :" );
    displayText.setBounds( 150, 10, 20, 17 );
    displayText.setHorizontalAlignment( JTextField.RIGHT );

    MLabel2.setBounds( 10, 30, 135, 15 );
    MLabel2.setText( "Größe Teams   (1 -  4)  : " );
    displayText2.setBounds( 150, 30, 20, 17 );
    displayText2.setHorizontalAlignment( JTextField.RIGHT );

    MLabel3.setBounds( 725, 10, 135, 15 );
    MLabel3.setText( "Round: " + count );

    pane.add( MLabel, 2, 0 ); //add label
    pane.add( MLabel2, 2, 0 ); //add label2
    pane.add( MLabel3, 2, 0 ); //add label3
    pane.add( displayText ); //add displaytextfield
    pane.add( displayText2 ); //add displaytextfield2

    int x, y; //start position buttons
    x = 12;
    y = 416;
    pane.setLayout( null );
    //initializing buttons
    for( int indicator = 0; indicator < 4; indicator++ ) //for to indicate all buttons
    {
      button[indicator] = new JButton( keys[indicator] );
      button[indicator].addActionListener( this );
      button[indicator].setSize( 100, 30 ); //standartbutton size
      button[indicator].setLocation( x, y );
      pane.add( button[indicator] );
      x = x + 105;
    }
    button[1].setVisible( false );
    ov.setBounds( 0, 0, 500, 500 );
    ov.setVisible( false );

    this.addWindowListener( new WindowAdapter() //listener for all buttons in the switch case
    {
      @Override
      public void windowClosing( WindowEvent e )
      {
        System.exit( 0 );
      }
    }
        );
    setVisible( true );
  }
/*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
  /*#### LISTENER ##############################################*/
  @Override
  public void actionPerformed( ActionEvent e )
  {
    //    String resultStr;
    String str = String.valueOf( e.getActionCommand() );
    switch( str )
    //switch case for better overview all buttons
    {
      case "Randomize":
        if ( count == 0 )
        {
          button[0].setVisible( false );
          button[1].setVisible( true );
          displayText.setVisible( false );
          displayText2.setVisible( false );
          MLabel.setVisible( false );
          MLabel2.setVisible( false );
          count++;
        }
        break;
      case "New Round":
        count++;
        break;
      case "Overview":
        if ( toggle )
        {
          ov.setVisible( true );
        }
        else ov.setVisible( false );
        toggle = !toggle;
        break;
      case "Save DB":
        break;
    }
  }
/*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
  /*#### MAIN ##################################################*/
  public static void main( String[] args )
  {
    TourMain C = new TourMain();
    //    overview O = new overview();

  }
/*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/

  @Override
  public void componentHidden( ComponentEvent arg0 )
  {}

  @Override
  public void componentMoved( ComponentEvent arg0 )
  {
    ov.setLocation( this.getX() + this.getWidth(), this.getY() );
  }

  @Override
  public void componentResized( ComponentEvent arg0 )
  {}

  @Override
  public void componentShown( ComponentEvent arg0 )
  {}
}
/*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/