If... is not an int

siggi571

Mitglied
Hallo Community,

ich versuch derzeit ein kleines Programm zu schreiben, um in Zukunft mein Darttraining zu optimieren.

Leider schaffe ich es nicht bei einer Eingabe mit dem JOptionPane.showInputDialog alles abzufangen, was ich gerne möchte.

Ich möchte nämlich dass sich die Eingabeaufforderung wiederholt, sobald ein String eingegeben wird.
Außerdem möchte ich nur werte zwischen 0 und 180 zulassen. Das habe ich mir aber durch if bereits abgefangen.

Für das erste Problem funktioniert die Eingabe if (a != int) leider nicht.

wie kann man sowas machen?
Try und Catch habe ich nicht hinbekommen
 

kaoZ

Top Contributor
du versuchst hier einen Primitiven Datentyp unter Zuhilfenahme von Logischen Operatoren auf ungleichheit in Verbindung mit einem String zu überprüfen ( insofern a eine Referenz auf String sein sollte), das funktioniert nicht......

JOptionPane, bzw der Dialog dazu liefert einen Integer, der entweder 0 oder 1 ist , je nachdem welchen dialog du wählst und wieviel möglichkeiten der Auswahl du hast, oder hast du 180 Buttons ?

Selbst wenn du die Rückgabe in einer Wrapperklasse verpacken würdest und diese dann unter verwendung von instanceOf oder getClass() verlgeichen würdest würde dies denke ich nicht funktionieren.

Poste mal deinen Code damit man sich ein Bild davon machen kann was genau du vorhast, anhand deiner Beschreibung kann man leider nicht viel erkennen.

Meinst du sowas in der Art ?

Java:
public class DartPane extends JOptionPane{
    private static final long serialVersionUID = 1L;
    
    public DartPane() {
    	String input = super.showInputDialog("Wieviel augen haben Sie geworfen ?");
    	
    	int value = Integer.parseInt(input);
    	
    	System.out.println(value + 12);
    }
    
    public static void main(String[] args) {
	    new DartPane();
    }

}

Falls das deinem Ziel nahekommen sollte, dann musst du die Eingabe parsen , ggf. ungültige eingaben abfagen und entsprechend darauf reagieren.

[EDIT]Sollte dem so sein kümmren wir uns dann gleich um deine Möglichkeit zur mehrfacheingabe
;)

Sorry stg :D
[/EDIT]
 
Zuletzt bearbeitet:

stg

Top Contributor
Zeig doch mal ein wenig Code. Es ist schwer zu verstehen, was du überhaupt fragen willst.

int ist jedenfalls ein reserviertes Wort für den primitiven Datentyp Integer. Eine Vergleichsoperation macht da wenig Sinn. Willst du prüfen, ob der Wert, der in a steckt ein Integer ist, oder was hast du vor? Falls ja, dann mach dir bewusst, dass eine Variable Typ int auch nur Werte vom Typ int aufnehmen kann. Ein solcher Vergleich ist also sinnlos.
Was ist denn überhaupt dieses a in deinem Code?

[OT]
...und schon wieder mal war kaoz schneller ^^
[/OT]
 
Zuletzt bearbeitet:

siggi571

Mitglied
Sorry, den habe ich ganz vergessen einzufügen

Das ist meine Rechenklasse. Ich würde jetzt gerne für a verhindern, dass ein String eingegeben wird.
Java:
int d, e, f;
		d=e=f=0;
		double g=0;
	
	for (int Zählvariable =1; Zählvariable<=2;Zählvariable++) {
		
		int a, b ,c;
		
	
		a = Integer.parseInt(JOptionPane.showInputDialog(null, "IhrScore?"));
		d = d + a;
		b = Integer.parseInt(JOptionPane.showInputDialog(null, "Wie oft haben Sie die 20 nicht getroffen?"));
		e = e + b;
		c = Integer.parseInt(JOptionPane.showInputDialog(null, "Wie oft haben Sie die T20 getroffen?"));
		f = f + c;
		
		g = Math.round(d/Zählvariable*100)/100.0;
 

siggi571

Mitglied
Gebe ich hier jetzt einen String ein, dann bricht mein Programm ja ab. Es soll aber stattdessen erneut die Aufforderung kommen, bis ein Int eingegeben wird.
 

kaoZ

Top Contributor
Das liegt daran das dann ein Typ als eingabeparameter eingegeben wird der nicht akzeptiert wird und daraufhin fliegt eine expeption, warte einen Moment ich Frühstücke eben und schau mir das ganze mal an :bae:
 
Zuletzt bearbeitet:

kaoZ

Top Contributor
Insofern ich dich richtig verstanden habe möchtest du deine Fortschritte im Darten erfassen und auswerten können, ist das soweit korrekt ?

Falls ja gib mir ein kurzes Feedback dazu und ich zeig dir wie mal auch anders (schöner) an dein vorhaben herangehen kann.
 

siggi571

Mitglied
Hallo KaoZ,

danke schonmal für deine Bemühungen.

Also prinzipiell habe ich nicht vor die Ergebnisse zu speichern. Ich glaube das sprengt den Rahmen.
Ich würde gerne ein Programm schreiben, welches mir (die im folgenden) aufgelisteten Werte ausspuckt.

Im Dart Training werfe ich zum Beispiel 2 Stunden permanent auf die Trippel 20. Anschließend mache ich nochmal 100 Aufnahmen (a 3 Würfe) auf die Trippel 20.
Nun möchte ich die einzelnen Scores eingeben. Daraus soll dann am Ende der 3 Dart Average ermittelt werden(also alle 100 Eingaben durch 100).

Zudem möchte ich eingeben, wie oft ich in die Trippel 20 getroffen habe. Hier müsste ich für jede Aufnahme die Möglichkeit haben 0,1,2 oder 3 einzugeben (eventuell auch als Button).

Das letzte was ich noch eingeben möchte ist, wie oft ich pro Aufnahme die 20 verfehlt habe, also wenn ein Pfeil in die 1 oder 5 abgeglitten ist.

Für die beiden letzteren eingaben brauche ich am ende lediglich die aufsummierten Werte.

Des Weiteren soll mir am Ende gesagt werden, wie oft habe ich über 100/140/180 gescored?

So, alles besagte soll dann auch noch für die Felder 19 und 18 möglich sein. Dementsprechend müssen die anderen Werte für die Topscores auf 95/133/171 bzw 90/126/162.

Das ist das Grundproblem.

Anschließend wollte ich mir gedanken über DoppelAverage machen.

Da Score ich wieder 100 Aufnahmen auf ein Doppel (20/18/16/8 und 4) und möchte nach jeder Aufnahme die Anzahl der Treffer eingeben. Am Ende soll es mir den Average in % ausgeben.
 

kaoZ

Top Contributor
Ansonsten bleiben dir nur solche Konstrukte ( hier schon in vorbereitung für einen Multi-Catch) :

Java:
int value = 0;
		
	    try {
	    	value = Integer.parseInt(JOptionPane.showInputDialog("Nummer eingeben :"));
	        System.out.println(value);
	        
        } catch (NumberFormatException ex) {
        	
	        if (ex instanceof NumberFormatException) {
	            JOptionPane.showMessageDialog(null, "Falsches Format !");
            } 
        }

in Verbindung mit einem Loop , wenn du die eingabe solange und oft wiederholen willst bis eine bestimmte bedingung eintritt.
 
Zuletzt bearbeitet:

kaoZ

Top Contributor
Also prinzipiell habe ich nicht vor die Ergebnisse zu speichern. Ich glaube das sprengt den Rahmen.
Ich würde gerne ein Programm schreiben, welches mir (die im folgenden) aufgelisteten Werte ausspuckt.

Im Dart Training werfe ich zum Beispiel 2 Stunden permanent auf die Trippel 20. Anschließend mache ich nochmal 100 Aufnahmen (a 3 Würfe) auf die Trippel 20.
Nun möchte ich die einzelnen Scores eingeben. Daraus soll dann am Ende der 3 Dart Average ermittelt werden(also alle 100 Eingaben durch 100).

Zudem möchte ich eingeben, wie oft ich in die Trippel 20 getroffen habe. Hier müsste ich für jede Aufnahme die Möglichkeit haben 0,1,2 oder 3 einzugeben (eventuell auch als Button).

Das letzte was ich noch eingeben möchte ist, wie oft ich pro Aufnahme die 20 verfehlt habe, also wenn ein Pfeil in die 1 oder 5 abgeglitten ist.

Für die beiden letzteren eingaben brauche ich am ende lediglich die aufsummierten Werte.

Des Weiteren soll mir am Ende gesagt werden, wie oft habe ich über 100/140/180 gescored?

So, alles besagte soll dann auch noch für die Felder 19 und 18 möglich sein. Dementsprechend müssen die anderen Werte für die Topscores auf 95/133/171 bzw 90/126/162.

Das ist das Grundproblem.

Anschließend wollte ich mir gedanken über DoppelAverage machen.

Da Score ich wieder 100 Aufnahmen auf ein Doppel (20/18/16/8 und 4) und möchte nach jeder Aufnahme die Anzahl der Treffer eingeben. Am Ende soll es mir den Average in % ausgeben.


Also schauen wir doch erstmal was du alles benötigst

- Dauer des Trainings ( optional )
- Liste zur Speicherung der Würfe (ArrayList)
- misses ( Anzahl der Würfe die nicht getroffen haben, ebenfalls eine Liste )
- Methode die dir die Werte aus den einzelnen Listen berechnet ( Summiert )
- Resultat in Form eines errechneten Scores


das sollte es erstmal sein für den Anfang.

Wenn wir jetzt mal OO an diese Sache herangehen,
würde ich sagen wir erstellen uns unabhängig von der späteren optischen Darstellung erst einmal eine Klasse die unseren Wurf, und somit den damit verbundenen Wert darstellt.
 
Zuletzt bearbeitet:

ssoul26

Bekanntes Mitglied
Try-Catch ist hierzu eigentlich nicht gedacht! Schreibe dir eine eigene Methode wie z.B.:

Java:
private static boolean isDigit(String eingabe) {
      for(char c : eingabe.toCharArray()){
         if(!Character.isDigit(c)){
            return false;
         }
      }
      return true;
   }

Diese überprüft, ob deine Eingabe eine Zahl ist. Wenn du weisst, dass Sie eine Zahl ist, kannst du ja dann anhand Integer.parseInt(String eingabe)... den Wert ermitteln.
 

kaoZ

Top Contributor
Try-Catch ist hierzu eigentlich nicht gedacht! Schreibe dir eine eigene Methode wie z.B.:

wenn er parst, kann eine NumberFormatException ausgelöst werden , natürlich ist dieses im normalfall in einen Try/Catch block zu verpacken...., und natürlich soll er damit nicht den Programmfluss steuern sondern lediglich eben das wofür es gedacht ist machen, nämlich Fehleingaben kenntlich machen und diese, hier Optisch in Form eines JOptionPane an den User weiterleiten.....

Ausnahmebehandlung eben.....
 
Zuletzt bearbeitet:

siggi571

Mitglied
@kaoZ,

Das Problem stellt sich nicht ganz so schwer da.
Die Dauer des Trainings ist auf 100 Aufnahmen a 3 Würfe begrenzt. Das ist das eigentlich was ich analysieren will. 100 mal ein Wert zwischen 0 und 180.

BZGL Klasse Wurf.

Das wäre mein Ansatz

Java:
public class Wurf {
	int Score;
	int Fehlwürfe;
	int TrefferTrippel;
	
	
	public Wurf (int s, int f, int T20) {
		Score = s;
		Fehlwürfe = f;
		TrefferTrippel = T20;
	}

}
 

kaoZ

Top Contributor
Ich würde Atomarer an die Sache herangehen, die Klasse Wurf repräsentiert einen einzelnen Wurf, der einen Wert besitzt:

Java:
public class DartThrow {

	private int value;
	
	public DartThrow(int value) {
	    this.value = value;
    }

	public int getValue() 			{return this.value;}

Hier würde man dann so z.B 2 Würfe erstellen , das wäre dann das was du mit klick auf einen Button auslösen könntest :

Java:
	public static void main(String[] args) {
	    new DartThrow(20);
	    new DartThrow(15);

    }

man könnte nun weitergehen und sagen alle erstellten würfe sollen bei ihrer erstellung schon in einer Liste gespeichert werden.

dies könnte man so umsetzen :

Java:
public class DartThrow {

	public static ArrayList<DartThrow> list = new ArrayList<>();
	private int value;
	
	public DartThrow(int value) {
	    this.value = value;
	    list.add(this);
    }
	
	public static int printResult(){
		
		int result = 0;
		
		for (DartThrow d : list) {
	        result += d.getValue();
        }
		
		return result;
	}
	
	public int getValue() 			{return this.value;}
}

Hier wird in der Klasse die einen Wurf repräsentiert eine Statische liste gehalten der jeder Wurf hinzugefügt wird, und man kann gleich noch ( unter anderem ) eine statische Methode anbieten welche einem alle werte der Liste aufsummiert.

Java:
public static void main(String[] args) {
	    new DartThrow(20);
	    new DartThrow(15);
	    
	    System.out.println(DartThrow.printResult());
    }

Nun könnte man weitergehen und sagen man schreibt eine Methode welche nach dem vorkommen eines bestimmten wertes in der Liste sucht , diesen nach häufigkeit zählt , und das ganze auf alle würfe die in der Liste vorhanden sind auswertet.

Java:
public static int countValue(int value){
		int result = 0;
		
		for (DartThrow d : list) {
	        if (d.getValue() == value) {
	            result++;
            }
        }
		
		return result;
	}

Java:
public static void main(String[] args) {
	    new DartThrow(20);
	    new DartThrow(15);
	    new DartThrow(20);
	    new DartThrow(20);
	    
	    
	    System.out.println(DartThrow.printResult());
	    System.out.println(DartThrow.countValue(20));
    }

Ausgabe :

Code:
75
3
 
Zuletzt bearbeitet:

siggi571

Mitglied
Danke Kaoz das du dir hierfür so ausführlich Gedanken machst.

Ich habe nur das Problem, dass ich mich mit Programmieren im generellen noch nicht wirklich gut auskenne.

Die Frage, die ich mir jetzt stelle ist, ob es Sinn macht, dass ich mich für dieses kleine Programm ausführlich in die OOP einarbeite oder ob ich es nicht doch in einer Klasse als laufenden Quellcode versuchen sollte.

Die ganzen Ergebnisse kann ich ja auch ziemlich gut mit einer Excel Tabelle rausfinden, aber mich reizt die Grafik von Java.

Also was meinst du, ist der Umfang das ganze OOP anzugehen einigermaßen begrenzt und es macht sinn für mich, dass Ganze so zu machen, oder lieber deklarativ? (Ich habe keine Ahnung wie groß so ein Projekt werden kann)

Für den reinen Quellcode würde mich interessieren, wie ich darum jetzt noch einen Loop basteln kann?
Die Bedingung hieße ja while (eingabe ist kein Int) ...

Das geht aber soweit ich weiß nicht, oder?
Java:
try {
			a = Integer.parseInt(JOptionPane.showInputDialog(null, "IhrScore?"));
		}
		catch (NumberFormatException ex) {
			if (ex instanceof NumberFormatException)
			{
				JOptionPane.showMessageDialog(null, "Bitte einen gültigen Wert eingeben");
			}
		}
 

siggi571

Mitglied
Bzgl deines Quellcodes.

Es ist dringend erforderlich, dass ich die Möglichkeit habe explizit einzugeben, wie oft ich die 20 getroffen habe. Ich werfe ja pro aufnahme 3 mal. Anschließend habe ich beispielsweise eine 123 geworfen.

Jetzt kann ich sagen: Trippel 20 2 mal, nicht in die 20 einmal, score 123.
Jeden Pfeil einzeln einzugeben wäre nicht praktikabel
 

kaoZ

Top Contributor
Ok , dann einen kleinen Moment ^^ ich wusste nicht wie weit du mit der Sprache an sich vertraut bist. Ich schau mir das flott mal an was man da machen kann.

Letzten endes möchtest du wahrscheinlich einfach nur mehrere Dialoge hintereinander , welche alle werte abfragen und dir am ende das Erbegnis ausgeben oder ?
[EDIT]
Kennst du die anzahl der Eingaben und bleibt diese immer gleich ? Sprich weißt du wieviele Dialoge du immer benötigst ?[/EDIT]
 
Zuletzt bearbeitet:

siggi571

Mitglied
Kein Problem, aber danke trotzdem!

Ich möchte genau 100 Abfragen. 100 mal was ist dein Score, 100 mal wie oft daneben, 100 mal wie oft in das Trippel.

Java:
import java.util.InputMismatchException;

import javax.swing.*;

public class Counter {
	
	public static void main(String[] args) {
		
	
        
        
		
		int d, e, f;
		d=e=f=0;
		double g=0;
	
	for (int Zählvariable =1; Zählvariable<=2;Zählvariable++) {
		
		int a, b ,c;
		
		a=0;
		
		
		try {
			a = Integer.parseInt(JOptionPane.showInputDialog(null, "IhrScore?"));
		}
		catch (NumberFormatException ex) {
			if (ex instanceof NumberFormatException)
			{
				JOptionPane.showMessageDialog(null, "Bitte einen gültigen Wert eingeben");
			}
		}
	
		
		d = d + a;
		b = Integer.parseInt(JOptionPane.showInputDialog(null, "Wie oft haben Sie die 20 nicht getroffen?"));
		e = e + b;
		c = Integer.parseInt(JOptionPane.showInputDialog(null, "Wie oft haben Sie die T20 getroffen?"));
		f = f + c;
		
		g = Math.round(d/Zählvariable*100)/100.0;
		
		JOptionPane.showMessageDialog(null, "Ihr aktueller Average liegt bei " + g 
	 + ".\nSie haben " + Zählvariable + " von 100 Aufnahmen.");
	}

	//Auswertung
	JOptionPane.showMessageDialog(null, "Ihr entgültiger Average liegt bei " + g +
			"\nDabei hatten Sie " + e + " Fehlwürfe und " + f +" Treffer in der T20" );
	
}}
 

kaoZ

Top Contributor
Ok kleinen Moment ;)

[EDIT]Nur damit ich das jetzt richtig verstehe du möchtest also 100 mal , jeweils 3 Abfragen haben ,
für Score, misses und tripple ? ^^

also 100 mal jeweils 3 Dialoge ?

bzw. 100 mal einen Dialog mit 3 eingabefeldern :) ?

[/EDIT]
 
Zuletzt bearbeitet:

kaoZ

Top Contributor
schreib nochmal schnell wie du das ganze berechnen möchtest , bzw. die Formel nach der du den Average berechnest bitte

[EDIT]
Dein Problem wird sein das der JOptionDialog , auch wenn du eine Fehlerhafte eingabe abfängst beendet wird, anders als bei selbstimplementierten JPanel oder Komponenten wo du vollen einfluss auf den Programmfluss hast.
[/EDIT]

Angenommen ich würde die erste fehlerhafte eingabe abfagen :

Java:
 for (int i = 0; i < values.length; i++) {
	    	try {
	    		values[i] = Integer.parseInt(JOptionPane.showInputDialog(messages[i]));
            } catch (NumberFormatException e) {
            	values[i] = Integer.parseInt(JOptionPane.showInputDialog(ERROR_MESSAGE));
            }
        }

und als Reaktion darauf einen neuen Dialog öffnen mit der aufforderung erneut eine Zahl einzugeben.
Gibt der User nun hier eine Falsche Eingabe ein so fliegt trotzdem eine NFE selbst wenn ich eine Hilfsmethode erstelle die ich dem Parsen noch vorschalte, bringt es nix da der JOptionPane beendet wird.
 
Zuletzt bearbeitet:

kaoZ

Top Contributor
Tu mir den gefallen und teste das hier mal , dies ist jetzt nur eine Ausführung, gib einfach mal anstelle einer Zahl einen falschen Wert ein , dann siehtst du was ich damit meine das du zwar die erste fehleingabe abfangen kannst , aber nach der 2ten der Dialog trotzdem eine NumberFormatExeption wirft, da wir uns nicht in einer Schleife befinden ist nach dem ersten Catch schluss ;)

Java:
public class JDartPane extends JOptionPane {
    private static final long serialVersionUID = 1L;

    final static String REGEX = "[0-9]+";
    final static String ERROR_MESSAGE = "Bitte Wiederholen Sie Ihre letzte Eingabe mit einer Ganzzahl !";
    
    private int[] values;
    private String[] messages = 
    	{
    		"Ihr Score ?",
    		"Wie oft haben Sie die 20 verfehlt ?",
    		"Wie oft haben Sie die T20 getroffen ?"
    	};
    
    public JDartPane() {
	    this.values = new int[3];
	   
	    for (int i = 0; i < values.length; i++) {
	    	try {
	    		values[i] = Integer.parseInt(super.showInputDialog(messages[i]));
            } catch (NumberFormatException e) {
            	values[i] = Integer.parseInt(super.showInputDialog(ERROR_MESSAGE));
            }
        }
	    
    }

    public static void main(String[] args) {
	    new JDartPane();
    }
 
Zuletzt bearbeitet:

kaoZ

Top Contributor
Btw :

Was hälst du von sowas ?



Hier wärst du um einiges flexibler als mit der Nutzung des JOptionPanes , wesentlich.... und vorallem könntest du selbst festlegen was in welchem Feld wo auf welche Fehleingaben geprüft wird, und wie reagiert werden soll ^^

und vor allem ist es Ausbaufähig ;)

Mal abgesehen davon sind es so auch keine 300 Dialoge mehr :D

[EDIT]Das non Plus ultra wäre natürlich eher eine JTable , in welcher du direkt alle durchgänge eintragen kannst.[/EDIT]

Das hier wäre z.B eines der Reaktionsszenarien :

 
Zuletzt bearbeitet:

kaoZ

Top Contributor
Hier mal eine schnelle Implementierung des ganzen, sie ist nicht zwingend schön , das ausrechnen muss auch noch korrekt implementiert werden , aber mehr hab ich jetzt auf die schnelle nicht zusammenzimmern wollen , da ich nicht weiß ob es das ist worauf du hinauswillst , falls ja lass es mich wissen und ich refactore das ganze nochmal nach deinen Vorstellungen :

Hier ein Beispiel für 5 anstelle von 100 Durchläufen, zur darstellung der Ergebnisse nutze ich hier nur für das Beispiel ein neu erzeugtes JFame :

Einfach mal ausprobieren und mir rückmeldung geben ;)

Java:
import java.awt.Color;
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class DartAverageCalculator extends JPanel {
    private static final long serialVersionUID = 1L;
    
    final static Dimension SIZE = new Dimension(400,200);
    
    static ArrayList<int[]> results = new ArrayList<>();
    
    private String[] labelTxt = 
    	{
    		"Ihr Score :",
    		"Wie oft haben Sie die 20 verfehlt :",
    		"Wie oft haben Sie die T20 getroffen :"
    	};
    
    private int[] runResult;
    private JLabel count;
    private JLabel[] labels;
    private JTextField[] fields;
    private JButton calc;
    
    public DartAverageCalculator() {
 
    	GridBagConstraints g = new GridBagConstraints();
 
	    setPreferredSize(SIZE);
	    setLayout(new GridBagLayout());

	    fields = new JTextField[3];
	    count = new JLabel("Aktueller Durchlauf : " + results.size());
	    labels = new JLabel[3];
	    calc = new JButton("Average berechnen");
	    calc.addActionListener(new ButtonListener());
	    
	    runResult = new int[3];
	    
	    for (int i = 0; i < 3; i++) {
	        fields[i] = new JTextField();
	        fields[i].setPreferredSize(new Dimension(120,25));
	        labels[i] = new JLabel(labelTxt[i]);
        }
	    
	    g.insets = new Insets(5, 5, 5, 5);
	    g.anchor = GridBagConstraints.LINE_END;
	    
	    g.gridx = 0;
	    g.gridy = 0;
	    this.add(count, g);
	    
	    g.gridx = 0;
	    g.gridy = 1;
	    this.add(labels[0], g);
	    
	    g.gridx = 1;
	    g.gridy = 1;
	    this.add(fields[0], g);
	   
	    g.gridx = 0;
	    g.gridy = 2;
	    this.add(labels[1], g);
	    
	    g.gridx = 1;
	    g.gridy = 2;
	    this.add(fields[1], g);
	    
	    g.gridx = 0;
	    g.gridy = 3;
	    this.add(labels[2], g);
	    
	    g.gridx = 1;
	    g.gridy = 3;
	    this.add(fields[2], g);
	    
	    g.gridx = 0;
	    g.gridy = 4;
	    g.gridwidth = 2;
	    g.fill = GridBagConstraints.HORIZONTAL;
	    this.add(calc, g);
    }
    
    private int[] calculateResults(){
    	
    	int[] values = new int[3];
    	
    	for (int i = 0; i < results.size(); i++) {
    		values[0] += results.get(i)[0];
    		values[1] += results.get(i)[1];
    		values[2] += results.get(i)[2];
        }
    	
    	return values;
    }
    
    public void createResultPane(){
    	
    	int[] res = calculateResults();
    	
    	JPanel pane = new JPanel();
    	pane.setLayout(new BoxLayout(pane, BoxLayout.PAGE_AXIS));
    	pane.setPreferredSize(new Dimension(250,150));
    	
    	JLabel[] label = new JLabel[3];
    	
    	String[] txt = 
    		{
    			"Ihr Score beträgt : " + res[0],
    			"Ihr misses betragen : " + res[1],
    			"Ihre Anzahl trippel beträgt : " + res[2]
    		};
    	
    	for (int i = 0; i < label.length; i++) {
	        label[i] = new JLabel(txt[i]);
	        pane.add(label[i]);
        }
    	
    	JFrame f = new JFrame("Ergebnisse");
    	f.add(pane);
    	f.pack();
    	f.setLocationRelativeTo(null);
    	f.setVisible(true);
    	
    }
    
    public static int checkInput(JTextField field){
    	String input = field.getText();
    	
    	if (!input.matches("[0-9]+")) {
    		field.setBackground(Color.RED);
 	        field.setText("");
 	        field.requestFocus();
	        throw new NumberFormatException("Es werden nur Ganzzahlen akzeptiert!");
        }
    	else{
    		return Integer.parseInt(input);
    	}
    }
    
    public int[] getRunResult() 			{return this.runResult;}
    
    class ButtonListener implements ActionListener{

		@Override
        public void actionPerformed(ActionEvent e) {
			try {
	            runResult[0] = checkInput(fields[0]);
	            runResult[1] = checkInput(fields[1]);
	            runResult[2] = checkInput(fields[2]);
	            
	            for (int i = 0; i < fields.length; i++) {
	                fields[i].setBackground(Color.white);
	                fields[i].setText("");
                }
	            results.add(getRunResult());
	            
	            
	            count.setText("Aktueller Durchlauf : " + results.size());
	            
	            if (results.size() == 5) {
	                createResultPane();
                }
	            
            } catch (NumberFormatException ex) {
	            JOptionPane.showMessageDialog(null, "Fehler : " + ex.getMessage());
            }
        }
    	
    }
	
	public static void main(String[] args) {
	    JFrame f = new JFrame("Dart Average Calculator");
	    f.add(new DartAverageCalculator());
	    f.pack();
	    f.setLocationRelativeTo(null);
	    f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
	    f.setVisible(true);
    }

}
 
Zuletzt bearbeitet:

siggi571

Mitglied
Servus Kaoz,

Sorry für die späte Antwort!

Das von dir geschriebene Programm ist schon ziemlich der Hammer und übertrifft all das, was ich erwartet habe :D

Die Rechenschritte zu den Auswertungen sind noch nicht richtig, aber der Rest (grafisch) ist genau das, was ich wollte.

Bei der Auswertung "Ihr Score Beträgt" müsste der gesamtscore noch durch die Zahl geteilt werden, die bei "aktueller Durchlauf" steht, um den Average zu ermitteln.

Das wars dann aber eigentlich auch schon, was ich an Fehlern gefunden habe.

Welche Auswertungen zusätzlich spitze wären, wäre: wie viele der bei "Ihr Score" eingetragenen Werte sind größer/gleich 100/140/180.

Ist es bei der Eingabe zu "Score" auch möglich alle Zahlen größer 180 abzufangen?

Wie kann man es umsetzten, dass nach jeder Eingabe ein aktuelle Average berechnet wird, der alleine erscheint?
 

siggi571

Mitglied
Um nicht ganz untätig zu sein habe ich einen kleinen Willkommens Dialog drum gebastelt.
Wie findest du das?

Bzgl des Averages am Ende habe ich auch was verändert, damit das Stimmt. Der Zweite Quellcode ist quasi das was ich daraus gemacht habe.

Wie findest du diese Lösung?

Java:
import javax.swing.*;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class WelcomeDialog {

	public static void main(String[] args) {
	
	final JFrame IntroJFrame = new JFrame ();
	IntroJFrame.setTitle("Herzlich Willkommen");
	IntroJFrame.setSize(200,200);
	
	JPanel panel = new JPanel();
    panel.setBackground(Color.white);
    
    JButton Training = new JButton ("Training");
     JButton Spiel = new JButton ("Spiel");
     
    Training.addActionListener(new ActionListener() {
    	
    	  public void actionPerformed(ActionEvent evt) {
    		  IntroJFrame.dispose();
    		  JFrame f = new JFrame("Dart Average Calculator");
    	        f.add(new DartAverageCalculator());
    	        f.pack();
    	        f.setLocationRelativeTo(null);
    	        f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
    	        f.setVisible(true);
    		  }
    		});
    
    Spiel.addActionListener(new ActionListener() {
    	
  	  public void actionPerformed(ActionEvent evt) {
  		  IntroJFrame.dispose();
  		  }
  		});
    
   
    panel.add(Training);
    panel.add(Spiel);
    IntroJFrame.add(panel);
	IntroJFrame.setVisible(true);
	
	
	}
}

Java:
 public void createResultPane(){
        
        int[] res = calculateResults();
        
        JPanel pane = new JPanel();
        pane.setLayout(new BoxLayout(pane, BoxLayout.PAGE_AXIS));
        pane.setPreferredSize(new Dimension(250,150));
        
        int a = 100; //meine kleine Änderung
        JLabel[] label = new JLabel[3];
        
        String[] txt = 
            {
                "Ihr Score beträgt : " + res[0]/a, //Auch eine kleine Änderung
                "Ihr misses betragen : " + res[1],
                "Ihre Anzahl trippel beträgt : " + res[2]
            };
        
        for (int i = 0; i < label.length; i++) {
            label[i] = new JLabel(txt[i]);
            pane.add(label[i]);
        }
 

kaoZ

Top Contributor
Also, ich schau mir das ganze nun mal fix an und dann zeig ich dir wo du es dir zu kompliziert machst ;)

Das hier z.B
Java:
  int a = 100; //meine kleine Änderung
        JLabel[] label = new JLabel[3];
        
        String[] txt = 
            {
                "Ihr Score beträgt : " + res[0]/a, //Auch eine kleine

hier bezieht sich dann die ausgabe immer auf ein Ergebnis / 100 , die 100 sollen denke ich die Versuche sein , richtig ? dann kannst du hier einfach durch die länge der statische Liste teilen, so kannst du auch gleich sicherstellen das du immer den Score anhand der Versuche berechnet bekommst, zusätzlich solltest du um Exceptions zu vermeiden auf ein int casten, da beim dividieren von Operanden im Regelfall immer eine Gleitpunktzahl entsteht :

Java:
"Ihr Score beträgt : " + (int) res[0] / results.size(),

Nun hast du gesagt du möchtest zählen wie oft Scores > 180 geworfen worden sind, hier kannst du 2 wege wählen, entweder du iterierst über die liste und suchst nach Scores die größer sind oder du zählst einen Counter hoch der schon beim einfügen in die list nach dieser Bedingung sortiert.

hier nochmal ein Beispiel mit einem Counter, denke aber daran das hier das setzen des kompletten Jlabel Textes eher eine unschöne aber schnelle Lösung ist !


Hier wird bei jeder Eingabe in dienem ersten TextFeld ein statischer Zähler hochgezählt wenn der Wert in dem Textfeld > 180 ist, und gleich noch unter dem letzen Textfeld angezeigt, genauso funktioniert das ganze leicht wenn du den Average für jeden Versuch ausgeben wollen würdest

Java:
import java.awt.Color;
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class DartAverageCalculator extends JPanel {
    private static final long serialVersionUID = 1L;
    
    final static Dimension SIZE = new Dimension(400,200);
    
    static ArrayList<int[]> results = new ArrayList<>();
    
    static int highScore;
    
    private String[] labelTxt = 
    	{
    		"Ihr Score :",
    		"Wie oft haben Sie die 20 verfehlt :",
    		"Wie oft haben Sie die T20 getroffen :"
    	};
    
    private int[] runResult;
    private JLabel count;
    private JLabel hsLabel;
    private JLabel[] labels;
    private JTextField[] fields;
    private JButton calc;
    
    public DartAverageCalculator() {
 
    	GridBagConstraints g = new GridBagConstraints();
 
	    setPreferredSize(SIZE);
	    setLayout(new GridBagLayout());

	    fields = new JTextField[3];
	    count = new JLabel("Aktueller Durchlauf : " + results.size());
	    hsLabel = new JLabel("Versuche mit einem Score über 180 : " + highScore);
	    labels = new JLabel[3];
	    calc = new JButton("Average berechnen");
	    calc.addActionListener(new ButtonListener());
	    
	    runResult = new int[3];
	    
	    for (int i = 0; i < 3; i++) {
	        fields[i] = new JTextField();
	        fields[i].setPreferredSize(new Dimension(120,25));
	        labels[i] = new JLabel(labelTxt[i]);
        }
	    
	    g.insets = new Insets(5, 5, 5, 5);
	    g.anchor = GridBagConstraints.LINE_END;
	    
	    g.gridx = 0;
	    g.gridy = 0;
	    this.add(count, g);
	    
	    g.gridx = 0;
	    g.gridy = 1;
	    this.add(labels[0], g);
	    
	    g.gridx = 1;
	    g.gridy = 1;
	    this.add(fields[0], g);
	   
	    g.gridx = 0;
	    g.gridy = 2;
	    this.add(labels[1], g);
	    
	    g.gridx = 1;
	    g.gridy = 2;
	    this.add(fields[1], g);
	    
	    g.gridx = 0;
	    g.gridy = 3;
	    this.add(labels[2], g);
	    
	    g.gridx = 1;
	    g.gridy = 3;
	    this.add(fields[2], g);
	    
	    g.gridx = 0;
	    g.gridy = 4;
	    this.add(hsLabel, g);
	    
	    g.gridx = 0;
	    g.gridy = 5;
	    g.gridwidth = 2;
	    g.fill = GridBagConstraints.HORIZONTAL;
	    this.add(calc, g);
    }
    
    private int[] calculateResults(){
    	
    	int[] values = new int[3];
    	
    	for (int i = 0; i < results.size(); i++) {
    		values[0] += results.get(i)[0];
    		values[1] += results.get(i)[1];
    		values[2] += results.get(i)[2];
        }
    	
    	return values;
    }
    
    public void createResultPane(){
    	
    	int[] res = calculateResults();
    	
    	JPanel pane = new JPanel();
    	pane.setLayout(new BoxLayout(pane, BoxLayout.PAGE_AXIS));
    	pane.setPreferredSize(new Dimension(250,150));
    	
    	JLabel[] label = new JLabel[3];
    	
    	String[] txt = 
    		{
    			"Ihr Score beträgt : " + (int) res[0] / results.size(),
    			"Ihr misses betragen : " + res[1],
    			"Ihre Anzahl trippel beträgt : " + res[2]
    		};
    	
    	for (int i = 0; i < label.length; i++) {
	        label[i] = new JLabel(txt[i]);
	        pane.add(label[i]);
        }
    	
    	JFrame f = new JFrame("Ergebnisse");
    	f.add(pane);
    	f.pack();
    	f.setLocationRelativeTo(null);
    	f.setVisible(true);
    	
    }
    
    public static int checkInput(JTextField field){
    	String input = field.getText();
    	
    	if (!input.matches("[0-9]+")) {
    		field.setBackground(Color.RED);
 	        field.setText("");
 	        field.requestFocus();
	        throw new NumberFormatException("Es werden nur Ganzzahlen akzeptiert!");
        }
    	else{
    		return Integer.parseInt(input);
    	}
    }
    
    public int[] getRunResult() 			{return this.runResult;}
    
    class ButtonListener implements ActionListener{

		@Override
        public void actionPerformed(ActionEvent e) {
			try {
	            runResult[0] = checkInput(fields[0]);
	            runResult[1] = checkInput(fields[1]);
	            runResult[2] = checkInput(fields[2]);
	            
	            for (int i = 0; i < fields.length; i++) {
	                fields[i].setBackground(Color.white);
	                fields[i].setText("");
                }
	            results.add(getRunResult());
	            
	            if(runResult[0] > 180){
	            	highScore++;
	            }
	            
	            hsLabel.setText("Versuche mit einem Score über 180 : " + highScore);
	            count.setText("Aktueller Durchlauf : " + results.size());
	            
	            if (results.size() == 5) {
	                createResultPane();
                }
	            
            } catch (NumberFormatException ex) {
	            JOptionPane.showMessageDialog(null, "Fehler : " + ex.getMessage());
            }
        }
    	
    }
	
	public static void main(String[] args) {
	    JFrame f = new JFrame("Dart Average Calculator");
	    f.add(new DartAverageCalculator());
	    f.pack();
	    f.setLocationRelativeTo(null);
	    f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
	    f.setVisible(true);
    }

}

Letzten endes musst du Entscheiden was du alles implementieren möchtest, genug Beispiele solltest du nun haben , durch das nutzen eine GridBagLayouts ist es hier auch ziemlich leicht weitere Komponenten dem bestehenden Layout hinzuzufügen ;)
 
Zuletzt bearbeitet:

kaoZ

Top Contributor
Wie kann man es umsetzten, dass nach jeder Eingabe ein aktuelle Average berechnet wird, der alleine erscheint?

Wäre dann die
Code:
Aktuelle Gesamtscore / Anzahl der Durchläufe
oder der
Code:
Aktuelle Durchlaufscore / Anzahl der Durchläufe
?


Hier nochmal ein etwas saubererer Source code mit ein wenig mehr implementierungen , unter anderem kannst du nun die anzahl an Durchläufen im Konstruktor übergeben, zusätzlich wird nach dessen erreichen und ausgeben der Ergebnisse die liste resetet und die Werte wieder auf 0 gesetzt , so das du sofort erneut loslegen könntest :

Nun musst du mir nur noch schnell ein Feedback zu meiner obigen Frage liefern, dann implementiere ich dir Formel noch korrekt.

Natürlich ist dieser Code noch meilenweit von einer Professionellen Implementierung entfernt, aber ich denke für das was du damit vorhast wird es bei weitem reichen ;) außerdem will ich dir ja nicht die ganze arbeit abnehmen ;)

Java:
public static void main(String[] args) {
	    JFrame f = new JFrame("Dart Average Calculator");
	    f.add(new DartAverageCalculator(2));  // <<-- Anzahl an druchläufen
	    f.pack();
	    f.setLocationRelativeTo(null);
	    f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
	    f.setVisible(true);
    }


Java:
import java.awt.Color;
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class DartAverageCalculator extends JPanel {
    private static final long serialVersionUID = 1L;
    
    final static Dimension SIZE = new Dimension(450,250);
    
    static ArrayList<int[]> results = new ArrayList<>();
    
    static int highScore;
    static int actualAverage;
    
    private int maxTrys;
    
    private String[] labelTxt = 
    	{
    		"Aktueller Durchlauf :",
    		"Ihr Score :",
    		"Wie oft haben Sie die 20 verfehlt :",
    		"Wie oft haben Sie die T20 getroffen :",
    		"Versuche mit einem Score von > 180 :",
    		"Average (in %) im aktuellen Durchlauf :"
    	};
    
    private int[] runResult;
    private JLabel currentRun;
    private JLabel currentHighscore;
    private JLabel currentAverage;
    private JLabel[] labels;
    private JTextField[] fields;
    private JButton calc;
    
    public DartAverageCalculator(int maxTrys) {
 
    	this.maxTrys = maxTrys;
    	
    	GridBagConstraints g = new GridBagConstraints();
 
	    setPreferredSize(SIZE);
	    setLayout(new GridBagLayout());

	    fields = new JTextField[3];
	    currentRun = new JLabel(String.valueOf(results.size()));
	    currentHighscore = new JLabel(String.valueOf(highScore));
	    currentAverage = new JLabel(String.valueOf(actualAverage));
	    labels = new JLabel[6];
	    calc = new JButton("Average berechnen");
	    calc.addActionListener(new ButtonListener());
	    
	    runResult = new int[3];
	    
	    for (int i = 0; i < 3; i++) {
	        fields[i] = new JTextField();
	        fields[i].setPreferredSize(new Dimension(120,25));
        }
	    
	    for (int i = 0; i < labels.length; i++) {
	        labels[i] = new JLabel(labelTxt[i]);
        }
	    
	    g.insets = new Insets(5, 5, 5, 5);
	    g.anchor = GridBagConstraints.LINE_END;
	    
	    g.gridx = 0;
	    g.gridy = 0;
	    this.add(labels[0], g);
	    
	    g.gridx = 1;
	    g.gridy = 0;
	    g.anchor = GridBagConstraints.CENTER;
	    this.add(currentRun, g);
	    
	    g.gridx = 0;
	    g.gridy = 1;
	    g.anchor = GridBagConstraints.LINE_END;
	    this.add(labels[1], g);
	   
	    g.gridx = 1;
	    g.gridy = 1;
	    this.add(fields[0], g);
	    
	    g.gridx = 0;
	    g.gridy = 2;
	    this.add(labels[2], g);
	    
	    g.gridx = 1;
	    g.gridy = 2;
	    this.add(fields[1], g);
	    
	    g.gridx = 0;
	    g.gridy = 3;
	    this.add(labels[3], g);
	    
	    g.gridx = 1;
	    g.gridy = 3;
	    this.add(fields[2], g);
	    
	    g.gridx = 0;
	    g.gridy = 4;
	    this.add(labels[4], g);
	    
	    g.gridx = 1;
	    g.gridy = 4;
	    g.anchor = GridBagConstraints.CENTER;
	    this.add(currentHighscore, g);
	    
	    g.gridx = 0;
	    g.gridy = 5;
	    g.anchor = GridBagConstraints.LINE_END;
	    this.add(labels[5], g);
	    
	    g.gridx = 1;
	    g.gridy = 5;
	    g.anchor = GridBagConstraints.CENTER;
	    this.add(currentAverage, g);
	    
	    g.gridx = 0;
	    g.gridy = 6;
	    g.gridwidth = 2;
	    g.anchor = GridBagConstraints.LINE_END;
	    g.fill = GridBagConstraints.HORIZONTAL;
	    this.add(calc, g);
    }
    
    private int[] calculateResults(){
    	
    	int[] values = new int[3];
    	
    	for (int i = 0; i < results.size(); i++) {
    		values[0] += results.get(i)[0];
    		values[1] += results.get(i)[1];
    		values[2] += results.get(i)[2];
        }
    	
    	return values;
    }
    
    public void createResultPane(){
    	
    	int[] res = calculateResults();
    	
    	JPanel pane = new JPanel();
    	pane.setLayout(new BoxLayout(pane, BoxLayout.PAGE_AXIS));
    	pane.setPreferredSize(new Dimension(250,150));
    	
    	JLabel[] label = new JLabel[3];
    	
    	String[] txt = 
    		{
    			"Ihr Score beträgt : " + (int) res[0] / results.size(),
    			"Ihr misses betragen : " + res[1],
    			"Ihre Anzahl trippel beträgt : " + res[2]
    		};
    	
    	for (int i = 0; i < label.length; i++) {
	        label[i] = new JLabel(txt[i]);
	        pane.add(label[i]);
        }
    	
    	JFrame f = new JFrame("Ergebnisse");
    	f.add(pane);
    	f.pack();
    	f.setLocationRelativeTo(null);
    	f.setVisible(true);
    	
    }
    
    public static int checkInput(JTextField field){
    	String input = field.getText();
    	
    	if (!input.matches("[0-9]+")) {
    		field.setBackground(Color.RED);
 	        field.setText("");
 	        field.requestFocus();
	        throw new NumberFormatException("Es werden nur Ganzzahlen akzeptiert!");
        }
    	else{
    		return Integer.parseInt(input);
    	}
    }
    
    public void clearAll(){
    	results.clear();
    	
    	actualAverage = 0;
    	highScore = 0;
    	
    	currentRun.setText("0");
    	currentAverage.setText("0");
    	currentHighscore.setText("0");
    }
    
    public int[] getRunResult() 			{return this.runResult;}
    
    class ButtonListener implements ActionListener{

		@Override
        public void actionPerformed(ActionEvent e) {
			try {
	            runResult[0] = checkInput(fields[0]);
	            runResult[1] = checkInput(fields[1]);
	            runResult[2] = checkInput(fields[2]);
	            
	            for (int i = 0; i < fields.length; i++) {
	                fields[i].setBackground(Color.white);
	                fields[i].setText("");
                }
	            results.add(getRunResult());
	            
	            if(runResult[0] > 180){
	            	highScore++;
	            }
	            
	            actualAverage = runResult[0] / results.size();
	            
	            currentRun.setText(String.valueOf(results.size()));
	            currentHighscore.setText(String.valueOf(highScore));
	            currentAverage.setText(String.valueOf(actualAverage));
	            
	            if (results.size() == maxTrys) {
	                createResultPane();
	                clearAll();
                }
	            
            } catch (NumberFormatException ex) {
	            JOptionPane.showMessageDialog(null, "Fehler : " + ex.getMessage());
            }
        }
    	
    }
	
	public static void main(String[] args) {
	    JFrame f = new JFrame("Dart Average Calculator");
	    f.add(new DartAverageCalculator(2));
	    f.pack();
	    f.setLocationRelativeTo(null);
	    f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
	    f.setVisible(true);
    }

}
 
Zuletzt bearbeitet:

siggi571

Mitglied
Hey kaoZ,

vielen dank für diese wie du sie nennst "nicht professionellen" implementierung.

In meinen Augen ist die schon ziemlich genial!



Zu deiner Frage:

Der Average ist Aktueller Gesamtscore/Durchläufe. (Derzeit ist ja Durchlaufsscore/Durchläufe) implementiert.

Eine Dumme Frage noch: Wäre es eventuell möglich, dass du ein paar Kommentare in den Code setzt? Du hast mir ja eigentlich alles programmiert, ich würde das ganze aber gerne verstehen können und dann noch einmal selbst programmieren, so habe ich einen riesigen Lerneffekt!
 

siggi571

Mitglied
Eine Sache noch,

bei den größer als 180 sollte größer als 100 stehen
zusätzlich größer 140 und
genau 180.

180 ist ja der höchste Score den man erzielen kann bei einem Durchlauf.

Aber ich versuche das selbst zu implementieren!
 

siggi571

Mitglied
Hallo kaoZ,
jetzt bin ichs nocheinmal.

Ich glaube das Auswertungspanel funktioniert nicht richtig.

Ich habe jetzt mal die maximale Länge auf 3 gemacht.

gib mal exemplarisch folgende Werte ein:
100
1
1;

200
2
2;

300
3
3;


Jetzt sollte als Auswertung erscheinen:
200
6
6


Es erscheint aber:
300
9
9
 

kaoZ

Top Contributor
schau ich mir ebend an moment ;)

es scheint als würde mit der logik noch was nicht korrekt hinhauen , schaue ich mir nachher mal an muss ich dann erstmal debuggen :)
 
Zuletzt bearbeitet:

kaoZ

Top Contributor
Ich hab dir das ganze noch etwas überarbeitet und einiges der Übersichtlichkeit halber ausgelagert, ich poste dir morgen den Code mit Kommentaren damit du es halbwegs nachvollziehen kannst ;)

du kannst dann ja versuchen einfach mal selbst die abfragen der Scores == 180 zu implementieren , ich makiere dir die stellen an denen ich die abfragen für werte > 100 implementiert habe
 

kaoZ

Top Contributor
if (!a.matches("[0-9]") sollte funktionieren

Nope. ( dann kannst du keine Zahlen mehrfach eingeben ! )

der Fehler lag an der Abbruchbedingung, er hat die Letzte Eingabe zwar erfasst aber auch nur mit dieser gerechnet.

Hier mal eine Kommentierte und wie bereits gesagt ein etwas "OO -terer Lösungsansatz", dazu habe ich versucht es so auszulagern das du es nachvollziehen kannst.

Die Spielerei mit den rot hinterlegten Feldern habe ich weggelassen, damit der Code etwas übersichtlicher wird und du ihn besser nachvollziehen kannst, dafür
ist es so implementiert, das du deine Eingaben mit der Enter-Taste hinzufügen kannst (defaultbutton)

Es sollte vorallem jetzt etwas besser nachvollziehbar sein, so das du an den richtigen stellen ,
auch selbst noch implementierungen nach deinen Vorstellungen durchführen können solltest,
z.B was das Auswerten der Druchläufe angeht.
Wenn du Fragen hast / Fehler findest immer raus damit.

Das ganze schaut nun so aus , also nicht erschrecken ^^


Java:
import javax.swing.JFrame;

/**
 * 
 * @author kaoz
 * @version 1.0
 *
 */

public class Gui {
	
	/**
	 * Diese Klasse hat nur den Zweck als Einstigspunkt für die Anwendung zu dienen, 
	 * erzeugt lediglich das Frame der GUI und fügt ein DartPane hinzu
	 * 
	 * @param args
	 */
	
	public static void main(String[] args) {
	    JFrame f = new JFrame("Average Rechner");
	    
	    DartPane content = new DartPane(3);
	    
	    f.getRootPane().setDefaultButton(content.getDefaultButton());
	    f.add(content);
	    f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
	    f.pack();
	    f.setLocationRelativeTo(null);
	    f.setVisible(true);
    }

}

Java:
/**
 * 
 * @author kaoz
 * @version 1.0
 *
 */

public class InputUtil {
	
	static final String REGEX = "[0-9]+";
	static final String ERROR_MESSAGE = "Es werden nur Ganzzahlne akzeptiert";
	
	/**
	 * Statische Hilfsmethode , überprüft eingebeparameter und liefert bei erfolgreicher
	 * Bedingung den aus dem Eingabeparameter geparsten Wert, 
	 * bei nicht erfüllter Bedingung wird eine NumberFormatExepiton geworfen.
	 * 
	 * @param input Eingabeparameter vom Typ String
	 * @return Wert, gepart aus dem Eingabeparameter
	 * @throws NumberFormatException
	 */

	public static int checkInput(String input) throws NumberFormatException{

		if (!input.matches(REGEX)) {
	        throw new NumberFormatException(ERROR_MESSAGE);
        }
		else{
			return Integer.parseInt(input);
		}
		
	}
	
}

Java:
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;

/**
 * Erzeugt ein neues DartPane, Quasi die Sicht auf die Daten , hier enthält diese Klasse auch 
 * alles an Logik was nötig ist und diese Daten auszuwerten, und zu manipulieren.
 * 
 * Was genau passiert habe ich an den einzelnen Methoden kommentiert.
 * 
 * @author kaoz
 * @version 1.0
 *
 */

public class DartPane extends JPanel {
    private static final long serialVersionUID = 1L;
    
    private GridBagConstraints cons = new GridBagConstraints();
    private static Dimension fieldSize = new Dimension(120,25);
    private final static Dimension PANEL_SIZE = new Dimension(400,300);

    private JLabel currentTryLabel;
    private JLabel currentHighScoreLabel;
    private JLabel currentAverageLabel;
    
    private int currentTry;
    private int currentHighScore;
    private int currentAverage;

    private JTextField[] fields;
    private JButton button; 
    
    private ArrayList<int[]> resultList;
    private int maxTrys;
    
    private JLabel[] label;
    
    private String[] labeling = 
    	{
    		"Wie hoch ist ihr aktueller Score ?",
    		"Wie oft haben Sie die 20 verfehlt ?",
    		"Wie oft haben Sie die T20 getroffen ?",
    		"Aktueller Durchgang :",
    		"Würfe > 100 :",
    		"Aktueller Average :"
    	};

    /**
     * Konstruktor
     */

	public DartPane(int maxTrys) {
		this.maxTrys = maxTrys;
		init();
		addComponents();
    }
	
	/**
	 * Initialisiert alle Komponenten
	 */
	
	private void init(){
		this.currentTryLabel		= new JLabel("1");
		this.currentHighScoreLabel	= new JLabel("0");
		this.currentAverageLabel	= new JLabel("0");
		
		this.currentTry			 = 1;
		this.currentHighScore	 = 0;
		this.currentAverage		 = 0;
		
		resultList = new ArrayList<>();
		
		fields = new JTextField[3];
		
		//Textfelder erstellen und größe setzen
		
		for (int i = 0; i < fields.length; i++) {
	        fields[i] = new JTextField();
	        fields[i].setPreferredSize(fieldSize);
        }
		
		label = new JLabel[6];
		
		//Label erzeugen und beschriften
		
		for (int i = 0; i < label.length; i++) {
	       label[i] = new JLabel(labeling[i]);
        }
		
		button = new JButton("Nächster Durchgang");
		button.addActionListener(new ButtonListener(this));
		
		//Panelgröße festlegen und WICHTIG Layout setzen
		
		setPreferredSize(PANEL_SIZE);
		setLayout(new GridBagLayout());
	}

	/**
	 * Legt die Position der einzelnen Komponenten fest
	 */
	
	private void addComponents(){
		cons.insets = new Insets(5, 5, 5, 5);
		cons.anchor = GridBagConstraints.LINE_START;
		
		//setUp Y Components
		
		cons.gridx = 0;
		cons.gridy = 0;
		this.add(label[0], cons);
		
		cons.gridx = 0;
		cons.gridy = 1;
		this.add(label[1], cons);
		
		cons.gridx = 0;
		cons.gridy = 2;
		this.add(label[2], cons);
		
		cons.insets = new Insets(20, 5, 5, 5);
		
		cons.gridx = 0;
		cons.gridy = 3;
		this.add(label[3], cons);
		
		cons.insets = new Insets(5, 5, 5, 5);
		
		cons.gridx = 0;
		cons.gridy = 4;
		this.add(label[4], cons);

		cons.gridx = 0;
		cons.gridy = 5;
		this.add(label[5], cons);

		//setUp X Components
		
		cons.anchor = GridBagConstraints.LINE_END;

		cons.gridx = 1;
		cons.gridy = 0;
		this.add(fields[0], cons);
		
		cons.gridx = 1;
		cons.gridy = 1;
		this.add(fields[1], cons);
		
		cons.gridx = 1;
		cons.gridy = 2;
		this.add(fields[2], cons);
		
		
		cons.insets = new Insets(20, 5, 5, 5);
		cons.anchor = GridBagConstraints.CENTER;
		
		cons.gridx = 1;
		cons.gridy = 3;
		this.add(currentTryLabel, cons);
		
		cons.insets = new Insets(5, 5, 5, 5);
		
		cons.gridx = 1;
		cons.gridy = 4;
		this.add(currentHighScoreLabel, cons);
		
		cons.gridx = 1;
		cons.gridy = 5;
		this.add(currentAverageLabel, cons);
		
		cons.gridx = 0;
		cons.gridy = 6;
		cons.gridwidth = 2;
		cons.fill = GridBagConstraints.HORIZONTAL;
		this.add(button, cons);

	}
	
	/*
	 * liefert den Punktestand
	 */
	
	private int getFinalScore(){
		int score = 0;
		
		for (int i = 0; i < resultList.size(); i++) {
	        score += resultList.get(i)[0];
        }
		
		return score;
	}
	
	/*
	 * liefert den Average aller Durchgänge
	 */
	
	private int getAverage(){
		int res = 0;
		
		for (int i = 0; i < resultList.size(); i++) {
	        res += resultList.get(i)[0];
        }
		
		return res / resultList.size();
	}
	
	/*
	 * liefert die Anzahl an allen verfehlten Würfen
	 */
	
	private int getMisses(){
		int misses = 0;
		
		for (int i = 0; i < resultList.size(); i++) {
	        misses += resultList.get(i)[1];
        }
		
		return misses;
	}
	
	/*
	 * Setzt den aktuellen Score, Würfe über 100 und den Aktuellen Average
	 */
	
	private void getRunResults(){
		currentTryLabel.setText(String.valueOf(currentTry));
		currentHighScoreLabel.setText(String.valueOf(currentHighScore));
		currentAverageLabel.setText(String.valueOf(currentAverage));
	}
	
	/*
	 * Felder zurücksetzen, und Focus auf Feld 1 legen
	 */
	
	private void resetFields(){
		for (int i = 0; i < fields.length; i++) {
	        fields[i].setText("");
        }
		
		fields[0].requestFocus();
	}
	
	/*
	 * Alle Felder zurücksetzen, liste mit Druchlaufergebnissen leeren
	 */
	
	private void resetAll(){
		resetFields();
		resultList.clear();
	}
	
	/*
	 * Getter für den Button
	 */
	
	public JButton getDefaultButton() 			{return this.button;}
	
	@Override
	public void paintComponent(Graphics g){
		super.paintComponent(g);
		
		// Trennlinie zeichnen
		
		g.setColor(Color.GRAY);
		g.drawLine(10,145,395,145);
	}
	
	// Listener als Innere Klasse ( Controller )

	class ButtonListener implements ActionListener{

		private JComponent comp;
		
		public ButtonListener(JComponent comp){
			this.comp = comp;
		}
		
		@Override
        public void actionPerformed(ActionEvent e) {
	        
			int[] res = new int[3];
			
			// Abbruchbedingung / parsen der Inhalte , anzeige eines OptionsPanes bei dessen Erreichen
			
			if (currentTry <= maxTrys) {
				try {
					res[0] = InputUtil.checkInput(fields[0].getText()); 
					res[1] = InputUtil.checkInput(fields[1].getText());
					res[2] = InputUtil.checkInput(fields[2].getText());
	            } catch (NumberFormatException ex) {
		            JOptionPane.showMessageDialog(comp, "Es werden nur Ganzzahlen akzeptiert !");
		            return;
	            }
				
		        resultList.add(res);  // Rundenergebniss der Liste hinzufügen
		        
		        currentTry++;  // Aktuellen Druchgang um + 1 erhöhen
		        
		        currentAverage = getAverage(); // Average berechnen 
		        
		        if (res[0] > 100) {
		            currentHighScore++;  // Anzahl an Würfen über 100 zählen
	            }

		        // Werte setzen und Felder reseten
		        
		        getRunResults();
		        resetFields();
            }
			else{
				
				// Auswahlfenster bei erreichen der maximalen Durchgänge
				
				Object[] options = {"Neu Starten", "Auswerten"};
				
				String text = "Sie haben die Maximale Anzahl an Durchläufen erreicht, was wollen Sie tun ?";
				String title = "Keine Weiteren Versuche übrig !";
				
				int val = JOptionPane.showOptionDialog(comp, text, title, JOptionPane.OK_CANCEL_OPTION, JOptionPane.INFORMATION_MESSAGE, null, options, null);
				
				if (val == 0 ) {
	                resetAll();
                }
				else{
					JFrame f = new JFrame("Auswertung");
					f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
					f.add(new ScorePane(getFinalScore(), getMisses(), getAverage()));
					f.pack();
					f.setLocationRelativeTo(null);
					f.setVisible(true);
				}
			}
        }
	}
}

Java:
import java.awt.Dimension;

import javax.swing.BorderFactory;
import javax.swing.BoxLayout;
import javax.swing.JLabel;
import javax.swing.JPanel;

/**
 * 
 * @author kaoz
 * @version 1.0
 *
 */

public class ScorePane extends JPanel {
    private static final long serialVersionUID = 1L;
    
	final Dimension PANEL_SIZE = new Dimension(250,150);
	
	/**
	 * Erzeugt ein neues Panel welches die Ergebnisse 
	 * nach allen durchgängen nochmal dargstellt.
	 * 
	 * 
	 * @param score Der Gesamtscore
	 * @param misses Die Gesamtmisses
	 * @param average Der Gesamtaverage
	 */
	
	public ScorePane(int score, int misses, int average) {
	    
		setSize(PANEL_SIZE);
		setLayout(new BoxLayout(this, BoxLayout.PAGE_AXIS));
		setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
		
		JLabel[] label = new JLabel[3];
		
		String[] labeling = 
			{
				"Ihr Endscore beträgt : " + score,
				"Ihre Anzahl an Fehlwürfen beträgt : " + misses,
				"Ihre Average nach allen Durchgängen beträgt : " + average
			};
		
		for (int i = 0; i < label.length; i++) {
	        label[i] = new JLabel(labeling[i]);
	        this.add(label[i]);
        }
		
    }
}

[EDIT]Wer Schreibfehler findet darf Sie behalten :D ( darauf hab ich jetzt nicht wirklich geachtet)[/EDIT]
 
Zuletzt bearbeitet:

siggi571

Mitglied
Servus kaoZ,

vielen Dank nochmal.

Ich werde versuchen den Code zu verstehen. Ich finde das ganze Teil ziemlich cool :)

Weißt du eigentlich, wie man soetwas zu einer App machen kann?
Ich habe mal gehört viele apps laufen mit java und es wäre cool, das Ganze einfach ins Smartphone einzutippen
 

kaoZ

Top Contributor
Jo weiß ich ;)

der Code ist bis auf die Grafische Umsetzung / Plattformabhängige Implementierung sogar ohne weiteres unter Android nutzbar.

Normalerweise sollte man deshalb auch immer die Logik von der Datenhaltung und der Visualisierung trennen , so kann man erreichen das ein und der selbe Source Code Plattformunabhängig auf jedem System/OS in Verbindung mit einer JVM ausgeführt werden kann.

Sprich Android/Windows/MAC/ Kaffeemaschinen / DVD Player usw. usw..
 
Zuletzt bearbeitet:

Neue Themen


Oben