jar hängt sich nach 2 oder mehreren restarts immer auf

baldrian_IBK

Grünschnabel
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 ?

ich glaube das der hacken irgendwo in der zeichnen maenchen classe bzw start classe ist

Java:
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[i].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();
						}
				}
		}
}

sorry wusste ich nicht
 
Zuletzt bearbeitet:
Du gehst auf Beitrag editieren und setzt vor den Code [.java] und hinter den Code [./java], jeweils ohne den . und du wirst sehen, dass dein Code wesentlich lesbarer erscheint.
 
Hi,

führe deine .jar-Datei mal über die Windows Konsole auf
(Start -> Ausführen -> "cmd")

In der Konsole gibst du dann

Code:
java -jar dateiname.jar

ein. Musst natürlich darauf achten, dass du vorher das richtige Verzeichnis wählst...

Vorteil an der Sache:
Wenn druch den Programm eine Exception geworfen wird, bekommst du sie in der Konsole angezeigt...startest du über Doppelklick auf die jar, erhälst du die Exception nicht....

HTH
 
Zurück