Jar h�ngt sich nach 2 oder mehreren restarts immer auf

Question

hallo leute!
bin neu hier und habe ein bisschen stress, habe morgen projektabgabe und bin zwar mit unserem "hangman" spiel jetzt fertig aber wenn ich das spiel 2 mal, 4mal ... neustarte h�ngt sich die jar datei immer auf, was das problem ist das hinter dem aufh�ngen kein rythmus steckt und ich einfach nicht verstehe mit was das zusammenh�ngt
k�nnt ihr mir helfen bzw was ben�tigt ihr?
jar datei hochladen , quellcode angeben ........

Answer 1

hallo leute!
bin neu hier und habe ein bisschen stress, habe morgen projektabgabe und bin zwar mit unserem "hangman" spiel jetzt fertig aber wenn ich das spiel 2 mal, 4mal ... neustarte h�ngt sich die jar datei immer auf, was das problem ist das hinter dem aufh�ngen kein rythmus steckt und ich einfach nicht verstehe mit was das zusammenh�ngt
k�nnt ihr mir helfen bzw was ben�tigt ihr?
jar datei hochladen , quellcode angeben ........
he guys
i am new here and i am stressed a little couse of our java project we have to hand in tomorrow. we made a little hangman game and now when i want to replay the jar hangs up after 2 or more times
- i do not no where the problem is?
i am going to post the code and i hope u can help me:
package adi2;
import java.util.Random;
import javax.swing.JLabel;
public class Woerter {
     private String Wort[]; // F�r ausgew�hltes Wort
     private String Woerter[]; // F�r alle verf�gbaren W�rter
     // Konstruktormethode
          public Woerter(){
               // W�rter festlegen
                    woerterFestlegen();
     // Prozedur, zum festlegen aller verf�gbaren W�rter
          public void woerterFestlegen(){
               // Neudimensionieren des passenden Arrays
                    Woerter = new String[16];
               // F�llen des Arrays -> Wichtig: Wort muss aus Gro�buchstaben bestehen
                    Woerter[0] = "HAUSABSTURZ";
                    Woerter[1] = "ALLIGATOR";
                    Woerter[2] = "JAVA";
                    Woerter[3] = "PROGRAMMIERSPRACHEN";
                    Woerter[4] = "AUSDAUERTRAINING";
                    Woerter[5] = "VAIO";
                    Woerter[6] = "SCHNEESTURM";
                    Woerter[7] = "DATENMODELL";
                    Woerter[8] = "FRANKREICH";
                    Woerter[9] = "BRILLENSCHLANGE";
                    Woerter[10] = "OSTRAPEZOIDEUM";
                    Woerter[12] = "MANAGEMENT";
                    Woerter[13] = "FERNBEDIENUNG";
                    Woerter[14] = "DREIERSTECKDOSE";
     // Prozedur zum zuf�lligen holen eines verf�gbaren Wortes und setzen des passenden Arrays
          public String[] wortHolen(){
               // Zufallsgenerator instanzieren
                    Random rnd = new Random();
               // Zufallszahl holen -> Ober- und Untergrenze beachten
               int zufallszahl = (int) ((Woerter.length - 0 +1) * rnd.nextDouble() +0);
               // Passendes Array f�r ausgew�hltes Wort neu dimensionieren
                    Wort = new String[Woerter[zufallszahl].length()];
               // Auslesen jedes einzelnen Buchstabens
                    for (int i = 0; i < Woerter[zufallszahl].length(); i++) {
                         // Passender Buchstabe wird dem Wort-Array an passende Position �bergeben
                              Wort[i] = Woerter[zufallszahl].substring(i, i+1);
               // Wort zur�ckgeben
                    return Wort;
package adi2;
import javax.swing.JFrame;
public class Start extends JFrame {
     * @param args
//     Main-Prozedur, zum laden und starten des Fensters bzw. Anwendung
     public static void main(String[] args) {
          // TODO Auto-generated method stub
               // Instanziere neues Fenster
                    Fenster f = new Fenster();
                    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Fenster schlie�t, wenn schlie�en gedr�ckt wird
                    f.setTitle("Hangman");
               // Setze Fenstergr��e
                    f.setSize(600, 300);
               // Fenster sichtbar machen
                    f.setVisible(true);
// Packagename
     package adi2;
// Importieren ben�tigter Klassen
     import java.awt.BorderLayout;
     import java.awt.Color;
     import java.awt.Container;
     import java.awt.FlowLayout;
     import java.awt.Graphics;
     import java.awt.GridLayout;
     import java.awt.event.ActionEvent;
     import java.awt.event.ActionListener;
     import java.util.Random;
     import javax.swing.JButton;
     import javax.swing.JFrame;
     import javax.swing.JLabel;
import javax.swing.JPanel;
// Klasse Fenster
     public class Fenster extends JFrame{
          // Variablen definieren
               // Normale
                    String Wort[];
                    boolean sperre = false; // F�r die Tastensperre
               // Container
                    Container cMain; // Maincontainer
                    Container cNorth = new Container(); // Oberen Bereich -> Wortausgabe
                    Container cTastatur = new Container(); // Unterer Bereich -> Tastatur
               // Zeichenklasse f�r die Fehler (Hangman)
                    zeichnenMaennchen zMaennchen = new zeichnenMaennchen();
               // Listenerklasse
                    ActListener aListener = new ActListener();
               // Wortklasse
                    Woerter woerter = new Woerter();
               // Label
                    JLabel lBuchstabe; // Ausgabe des "Wortes"
               // Buttons -> Tastatur
                    JButton bA = new JButton("A");
                    JButton bB = new JButton("B");
                    JButton bC = new JButton("C");
                    JButton bD = new JButton("D");
                    JButton bE = new JButton("E");
                    JButton bF = new JButton("F");
                    JButton bG = new JButton("G");
                    JButton bH = new JButton("H");
                    JButton bI = new JButton("I");
                    JButton bJ = new JButton("J");
                    JButton bK = new JButton("K");
                    JButton bL = new JButton("L");
                    JButton bM = new JButton("M");
                    JButton bN = new JButton("N");
                    JButton bO = new JButton("O");
                    JButton bP = new JButton("P");
                    JButton bQ = new JButton("Q");
                    JButton bR = new JButton("R");
                    JButton bS = new JButton("S");
                    JButton bT = new JButton("T");
                    JButton bU = new JButton("U");
                    JButton bV = new JButton("V");
                    JButton bW = new JButton("W");
                    JButton bX = new JButton("X");
                    JButton bY = new JButton("Y");
                    JButton bZ = new JButton("Z");
          // Konstruktormethode
               public Fenster(){
                    // Grundeinstellungen festlegen
                    // Stelle Verbindung zum Fenster-Content auf
                         cMain = getContentPane();
                    // Setze Layouts
                         cMain.setLayout(new BorderLayout());
                         cNorth.setLayout(new FlowLayout());
                         cTastatur.setLayout(new GridLayout(3,11));
                    // Setze Listener
                         bA.addActionListener(aListener);
                         bB.addActionListener(aListener);
                         bC.addActionListener(aListener);
                         bD.addActionListener(aListener);
                         bE.addActionListener(aListener);
                         bF.addActionListener(aListener);
                         bG.addActionListener(aListener);
                         bH.addActionListener(aListener);
                         bI.addActionListener(aListener);
                         bJ.addActionListener(aListener);
                         bK.addActionListener(aListener);
                         bL.addActionListener(aListener);
                         bM.addActionListener(aListener);
                         bN.addActionListener(aListener);
                         bO.addActionListener(aListener);
                         bP.addActionListener(aListener);
                         bQ.addActionListener(aListener);
                         bR.addActionListener(aListener);
                         bS.addActionListener(aListener);
                         bT.addActionListener(aListener);
                         bU.addActionListener(aListener);
                         bV.addActionListener(aListener);
                         bW.addActionListener(aListener);
                         bX.addActionListener(aListener);
                         bY.addActionListener(aListener);
                         bZ.addActionListener(aListener);
                    // F�ge Buttons f�r die Tastatur ein -> Baue Tastatur zusammen
                         cTastatur.add(bQ);
                         cTastatur.add(bW);
                         cTastatur.add(bE);
                         cTastatur.add(bR);
                         cTastatur.add(bT);
                         cTastatur.add(bZ);
                         cTastatur.add(bU);
                         cTastatur.add(bI);
                         cTastatur.add(bO);
                         cTastatur.add(bP);
                         cTastatur.add(bA);
                         cTastatur.add(bS);
                         cTastatur.add(bD);
                         cTastatur.add(bF);
                         cTastatur.add(bG);
                         cTastatur.add(bH);
                         cTastatur.add(bJ);
                         cTastatur.add(bK);
                         cTastatur.add(bL);
                         cTastatur.add(bY);
                         cTastatur.add(bX);
                         cTastatur.add(bC);
                         cTastatur.add(bV);
                         cTastatur.add(bB);
                         cTastatur.add(bN);
                         cTastatur.add(bM);
                    // Hole ein zuf�lliges Wort
                         Wort = woerter.wortHolen();
                    // Labels f�r das Wort erstellen
                         // Neus Label laden und ersten Buchstaben aus Wort-Array als Text holen
                              lBuchstabe = new JLabel(Wort[0]);
                         // Name f�r Erstes Label festlegen
                              lBuchstabe.setName("lBst1");
                         // Einf�gen in passenden Container
                              cNorth.add(lBuchstabe);
                         // Restliche Labels erstellen
                              for (int i = 2; i <= Wort.length; i++) {
                                   // Neues Label laden und "_" als Text �bergeben
                                        lBuchstabe = new JLabel("_");
                                   // Name festlegen -> Format: "lBst" und die Zahl der Buchstabenposition
                                        lBuchstabe.setName("lBst" + String.valueOf(i).toString());
                                   // �bergeben des Labels an passenden Container
                                        cNorth.add(lBuchstabe);
                    // F�lle Main-Container -> Baue alles als ein Fenster zusammen
                         cMain.add(cNorth, BorderLayout.NORTH);
                         cMain.add(zMaennchen, BorderLayout.CENTER);
                         cMain.add(cTastatur, BorderLayout.SOUTH);
          // Setzen der Sperrenvariable, damit die Tastaturdrucke ignoriert werden
               public void setSperre(){
                    // Variable anpassen
                         sperre = true;
          // Zur�ckgeben des Sperrstatuses
               public boolean getSperre(){
                    return sperre;
          // Fehler setzen
               public void setFehler(){
                    zMaennchen.setFehler();
          // Wort zur�ckgeben
               public String[] getWort(){
                    return Wort;
          // Complete setzen
               public void setComplete(){
                    zMaennchen.setComplete();
package adi2;
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import adi2.Fenster;
//Klasse zum Zeichnen des Hangmans
     public class zeichnenMaennchen extends JPanel{
          // Variablen definieren
               int fehlerzahl = 0; // Fehleranzahl -> Regelt, was alles gezeichnet wird
               boolean complete = false; // Wurde Wort komplett erkannt
          // Konstrukturmethode
               public zeichnenMaennchen(){
                    // Setze Hintergrundfarbe
                         setBackground(Color.WHITE);
          // Prozedur zum Anpassen, �berpr�fen der Fehlerzahl (Zeichnung) und was/wie gezeichnet werden soll
               public void setFehler(){
                    // Fehlerzahl erh�hen
                         fehlerzahl++;
                    // �berpr�fen, ob Wort komplett und maximale Fehlerzahl noch nicht erreicht
                    if(complete == true & fehlerzahl <= 6){
                         // Hintergrundfarbe auf Gr�n setzen
                              setBackground(Color.GREEN);
                              // Fenster welches nach neuem Spiel fragt?
                              if(JOptionPane.showConfirmDialog(this, "Sie haben gewonnen! Noch ein Spiel?", "Gewonnen", JOptionPane.YES_NO_OPTION)== JOptionPane.YES_OPTION){
                                   Fenster f = (Fenster) getParent().getParent().getParent().getParent();
                                   f.dispose();
                                   Start start = new Start();
                                   start.main(new String[] {});
                              else if(JOptionPane.NO_OPTION == 1) {
                                   System.exit(0);
                         // Fehleranzahl um 1 zur�cksetzen -> sonst w�rde eine falsche Zeichnung erscheinen
                              fehlerzahl--;
                    // �berpr�fen, ob maximale Fehlerzahl erreicht, bevor Wort erkannt wurde
                         if(fehlerzahl >=6){
                              // Hintergrundfarbe auf Rot setzen
                                   setBackground(Color.RED);
                                   if(JOptionPane.showConfirmDialog(this, "Sie haben verloren! Noch ein Spiel?", "Game Over", JOptionPane.YES_NO_OPTION)== JOptionPane.YES_OPTION){
                                        Fenster f = (Fenster) getParent().getParent().getParent().getParent();
                                        f.dispose();
                                        Start start = new Start();
                                        start.main(new String[] {});
                                   else if(JOptionPane.NO_OPTION == 1) {
                                        System.exit(0);
                              // Fehleranzahl um 1 zur�cksetzen -> sonst w�rde eine falsche Zeichnung erscheinen
                                   fehlerzahl--;
                              // Fenster holen
                                   Fenster f = (Fenster) getParent().getParent().getParent().getParent();
                                   // Layout->Container->getContentPane->Fenster
                              // Tastatur sperren
                                   f.setSperre();
                    // Neuzeichnen
                         repaint();
          // Festlegen, dass Wort komplett erkannt wurde und anpassen der Darstellung
               public void setComplete(){
                    // Variable anpassen
                         complete = true;
                    // Darstellung anpassen
                         setFehler();
          // Zeichnenprozedur
               protected void paintComponent(Graphics g){
                    // Verbindung zum Zeichnen aufbauen, damit auch alles korrekt gezeichnet wird, was man mag
                         super.paintComponent(g);
                    // Zeichenfarbe setzen -> So zu sagen die Stiftfarbe
                         g.setColor(Color.BLACK);
                         g.drawArc(20, 160, 60, 40, 0, 180); // Bogen bzw. Boden
                         g.drawLine(50,160, 50, 50); // Balken nach oben
                         g.drawLine(50, 50, 120, 50); // Balken nach rechts
                         g.drawLine(120, 50, 120, 70); // Balken diagonal
                         g.drawLine(50, 80, 80, 50); // Seil
                    // Zeichnen der Teile
                              if(fehlerzahl >= 1){
                                   g.drawArc(110, 70, 20, 20, 0, 360);// Hangmann - Kopf
//                              Hangman - Wirbels�ule
                              if(fehlerzahl >= 2){
                                   g.drawLine(120, 90, 120, 130);
                              if(fehlerzahl >= 3){
                                   g.drawLine(120, 130, 100, 150);// Hangman - Linker Fu�
                              if(fehlerzahl >= 4){// Hangman - Rechter Fu�
                                   g.drawLine(120, 130, 140, 150);
                              if(fehlerzahl >= 5){
                                   g.drawLine(120, 115, 95, 100);// Hangman - Linker Arm
                              if(fehlerzahl >= 6){
                                   g.drawLine(120, 115, 145, 100);//     Hangman - Rechter Arm
                              if(fehlerzahl >= 7){
package adi2;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JLabel;
public class ActListener implements ActionListener{
     // Variablen
          String Wort[];
          JButton button;
          Fenster fenster;
          Container cNorth;
     // ActionListener Methode
          public void actionPerformed(ActionEvent aEvent) {
               // Fenster holen
                    button = (JButton) aEvent.getSource();
                    fenster = (Fenster) button.getParent().getParent().getParent().getParent().getParent();
                    cNorth = (Container) button.getParent().getParent().getComponent(0);
                    Wort = fenster.getWort();
               // �berpr�fen, ob Tastaturdrucke ignoriert werden sollen
                    if(fenster.getSperre() == false){  // Tastaturdrucke nicht ignorieren
                         // Button als inaktiv setzen
                              button.setEnabled(false);
                         // Hilsvariable zur Ermittlung wie viele gleiche gedr�ckte Buchstaben im Wort vorhanden sind
                              int anzahl = 0;
                         // Ermitteln wie viele gleiche gedr�ckte Buchstaben vorhanden sind
                              for (int i = 0; i < Wort.length; i++) {
                                   // �berpr�fen, ob derzeitiger Buchstabe der gedr�ckte ist
                                        if(Wort.equals(aEvent.getActionCommand()) == true){
                                             // Anzahl anpassen
                                                  anzahl++;
                         // Hilfsarray zur Ermittlung der Position der gleichen Buchstaben
                              int wo[] = new int[anzahl];
                         // Hilfsvariable f�r korrektes Einf�gen der Positionszahl
                              int iHilf = 0;
                         // Hilsvariable zur �berpr�fung, ob eingegebener Buchstabe �berhaupt im Wort vorhanden
                              boolean ok = false;
                         // Finden von Position(en) des gedr�ckten Buchstaben im Wort
                              for (int i = 0; i < Wort.length; i++) {
                                   // �berpr�fen, ob derzeitiger Buchstabe der gedr�ckte ist
                                        if(Wort[i].equals(aEvent.getActionCommand()) == true){
                                             // Hilfsvariable anpassen
                                                  ok = true;
                                             // Buchstabenposition an korrekte Hilfsarrayposition einf�gen
                                                  wo[iHilf] = i;
                                             // Hilsfvariable erh�hen
                                                  iHilf++;
                         // �berpr�fen, ob Buchstabe �berhaupt vorhanden gewesen
                              if(ok == false){ // Buchstabe nicht vorhanden gewesen
                                   // Fehlerzahl anpassen und passend Zeichnen lassen
                                        fenster.setFehler();
                              }else{ // Buchstabe vorhanden gewesen
                                   // Durchlaufen der Positionen
                                        for (int i = 0; i < wo.length; i++) {
                                             // Passendes Label f�r den Buchstaben holen
                                                  JLabel label = (JLabel) cNorth.getComponent(wo[i]);
                                             // Text des Labels anpassen bzw. gedr�ckter Buchstabe ist jetzt der Text des Labels
                                                  label.setText(aEvent.getActionCommand());
                         // Hilfsvariable f�r die Ermittlung, noch fehlender Buchstaben
                              boolean schauenStrich = false;
                         // �berpr�fen, ob noch offene Buchstaben vorhanden sind
                              for (int i = 0; i < cNorth.getComponentCount(); i++) { // Schleife, welche alle Labels durchl�uft
                                   // Holen des Labels
                                        JLabel label = (JLabel) cNorth.getComponent(i);
                                   // �berpr�fen, ob der Text des Labels noch "_" ist
                                        if(label.getText().equals("_") == true){
                                             // Hilfsvariable anpassen
                                                  schauenStrich = true;
                         // �berpr�fen, ob keine Striche mehr vorhanden
                              if(schauenStrich == false){
                                   // Tastatur sperren
                                        fenster.setSperre();
                                   // Grafik sagen, dass das Wort korrekt ist
                                        fenster.setComplete();
the start class is the main one - the zeichnenmaenchen does the main stuff - fenster is the panel class - ...