# Programm stoppen - nicht beenden!



## Maddili (10. Mai 2010)

hi, wie kann ich mein Programm stoppen,  ohne es zu beenden (System.exit(0) )

Folgender Code:


```
public static void erstellen(){

         auslesen_head();
         auslesen_options();
// [.....]
// Hier kommen noch weitere Befehle bzw. Methoden-Aufrufe.
```


```
public static void auslesen_head(){


    	sopname = Output.tf_PrgNr.getText();

        // Prüfen, ob File bereits vorhanden ist
        File tempfile = new File(xml.getSettings("sopout"), sopname);



        if(tempfile.exists() ){
            System.out.println("File existiert bereits");

            //Dialog, ob gespeichert werden soll

            //Custom button text
            Object[] options = {"Ja",
                                "Nein",
                                "Abbruch"};
            int n = JOptionPane.showOptionDialog(new JFrame(),
                "Die Datei '" + Output.tf_PrgNr.getText()+".txt" + "' ist bereits vorhanden!" +
                "\n Datei überschreiben?",
                "Warnung!",
                JOptionPane.YES_NO_CANCEL_OPTION,
                JOptionPane.QUESTION_MESSAGE,
                null,
                options,
                options[2]);

            switch(n){
            case 0: System.out.println("case0");
            		if(Output.tf_Revision.getText().equals("")){
            			System.out.println("Revision ist leer");
            		}else{
            			System.out.println("Revision: " + Output.tf_Revision);
            		}            		break;
            case 1: System.out.println("case1");
            		DateiChooser.auswahlDatei();
                    break;

            case 2: System.out.println("Abbruch!");
            		break;


            }




        } else{
            System.out.println("File existiert noch nicht")	;

    }
```




Wie kann ich den rot gefärbten Code schreiben, dass wenn das "RevisionsFeld" tf_revision leer ist, das Programm nicht in der "erstellen"-Methode weitermacht

mfg 
Maddin


----------



## zerix (10. Mai 2010)

Hallo,

ich glaube du musst da noch ein paar Sachen erklären. Was meinst du mit "Programm stoppen"? Also was soll das gewünschte Verhalten sein. 



> Wie kann ich den rot gefärbten Code schreiben, dass wenn das "RevisionsFeld" tf_revision leer ist, das Programm nicht in der "erstellen"-Methode weitermacht


Welche erstellen-Methode?

Gruß

Sascha


----------



## vfl_freak (10. Mai 2010)

Moin,

was genau meinst Du mit "nicht weitermacht" 
Soll das Programm an der Stelle einfrieren  ==> programmiere eine Endlosschleife 
Willst Du warten, bis das Feld gefüllt ist  ==> dann würde vlt. in einer Schleife den Wert solange abfragen, bis er nicht mehr leer ist 
Willst gezielt aus Deiner Funktion "erstellen" aussteigen  ==> dann hier mit 'break' rausgehen und (bspw. mit einem Rückgabeparameter) dafür sorgen, dass "auslesen_options()" nicht aufgerufen wird 

Gruß
Klaus


----------



## Maddili (10. Mai 2010)

Hui, das ging schnell... Also:



zerix hat gesagt.:


> Hallo,
> 
> Welche erstellen-Methode?



Naja, ich rufe in der erstellen()-Methode die auslesen_head()-Methode auf. (und eben noch weitere Methoden)




			
				vfl_freak hat gesagt.:
			
		

> Willst Du warten, bis das Feld gefüllt ist  ==> dann würde vlt. in einer Schleife den Wert solange abfragen, bis er nicht mehr leer ist



Hmm, hört sich gut an. Wie kann ich das umsetzen?




			
				vfl_freak hat gesagt.:
			
		

> Willst gezielt aus Deiner Funktion "erstellen" aussteigen  ==> dann hier mit 'break' rausgehen und (bspw. mit einem Rückgabeparameter) dafür sorgen, dass "auslesen_options()" nicht aufgerufen wird



Hört sich auch gut an. Nur genau das ist mein Problem: Wie steige ich aus der "erstellen" Funktion aus?
Wenn ich in meiner Switch-Case nen Break mache, macht das Prog ja trotzdem mit der "erstellen"-Fkt. weiter. ->und genau das will ich nicht!

mfg Maddin


----------



## zerix (10. Mai 2010)

Also wenn auslesen_head() in  erstellen aufgerufen wird und du nicht möchtest, dass erstellen() weiter ausgeführt wird, wenn bei auslesen_head irgendwas passiert, könntest du es über einen Rückgabe-Parameter machen. Du könntest in auslesen_head einfach true zurück geben. Das kannst du dann bei erstellen abfragen, wenn true, dann mach weiter, wenn false, mach nicht weiter.



> > Willst Du warten, bis das Feld gefüllt ist ==> dann würde vlt. in einer Schleife den Wert solange abfragen, bis er nicht mehr leer ist
> 
> 
> Hmm, hört sich gut an. Wie kann ich das umsetzen?



Ich kenne dein Programm nicht, aber da hast du eventuell ein schlechtes Design, wenn du mit einer Schleife auf eine Eingabe im Textfeld warten musst. 

Könntest du mal genau erklären was du da machen möchtest?

Gruß

Sascha


----------



## vfl_freak (10. Mai 2010)

Moin,



Maddili hat gesagt.:


> Hmm, hört sich gut an. Wie kann ich das umsetzen?



na, etwa so (an der 'roten' Stelle:

```
while( Output.tf_Revision.getText().equals("") )
{
    System.out.println("Warten, da die Revision ist leer");
}
```




Maddili hat gesagt.:


> Hört sich auch gut an. Nur genau das ist mein Problem: Wie steige ich aus der "erstellen" Funktion aus?
> Wenn ich in meiner Switch-Case nen Break mache, macht das Prog ja trotzdem mit der "erstellen"-Fkt. weiter. ->und genau das will ich nicht!



bspw. so (ist aber VHIDT )

```
// statt "void auslesen_head()" bspw.:
boolean auslesen_head()
{
    boolean bResult = true;
    // ...
    case 0: 
        if(Output.tf_Revision.getText().equals(""))
        {
            System.out.println("Revision ist leer");
            bResult = false;
        }
        else
        {
            System.out.println("Revision: " + Output.tf_Revision);
        }
    // ...
    return bResult;
}   

// ...

public static void erstellen()
{
     boolean bRes = auslesen_head();
     if( true == bRes )
     {
         auslesen_options();
    }
}
```

Gruß
Klaus


----------



## Maddili (10. Mai 2010)

zerix hat gesagt.:


> Könntest du mal genau erklären was du da machen möchtest?



Also per Button wird erstellen() aufgrufen. In der Funktion werden weitere funktionen aufgerufen, welche aus Textfeldern, Checkboxes usw. Werte/Daten auslesen.
Letztendlich wird mit den ausgelesenen Daten eine Textdatei erstellt.

So, jetzt habe ich in der auslesen_head() eine abfrage, ob ich (wenn der Dateiname gleich ist) die Datei überschreiben will.
Bei klick auf "JA" soll er überprüfen, ob im Textfeld Revision etwas steht (Was wichtig ist, wenn man die Datei überschreibt - hier soll rein, WER, WANN und WAS geändert wurde.)

Also in meinem Code, wo jetzt (rot) steht:             System.out.println("Revision ist leer");  Soll jetzt das Programm abbrechen - damit sowohl die auslesen_head(), als auch die erstellen() Funktion stoppen (-> jetzt wird noch mit der erstellen() weitergemacht und die txt-Datei geschrieben.) Also brauche ich HIER einen "Stop-Befehl" (wenns sowas gibt)

Sorry, wenn ic hmich so schwammig ausdrücke, aber ich bin nicht so der Java-Rul0r.

mfg
Maddin


----------



## Vereth (10. Mai 2010)

Einen OptionDialog brauchst du nicht, für deine Zwecke ist ein ConfirmDialog völlig aureichend.
Du kannst von jeder Stelle aus deine Funktion mit return abbrechen, auch wenn du in einer Schleife oder einem switch-case bist.
Man muss nicht alles mit einem switch erschlagen wollen, manchmal sind if-Abfragen sinnvoller.
Beispiel:

```
//
  private static boolean test()
  {
    String str = "Testtext";
    int ret 
    = JOptionPane.showConfirmDialog(null//this
    , str
    , "Info"
    , JOptionPane.YES_NO_CANCEL_OPTION);
    if ( ret == JOptionPane.CANCEL_OPTION )
    { return false;}
    // hier kannst du noch mehr Anweisungen folgen lassen
    return true;
  }
```


----------



## zerix (10. Mai 2010)

vfl_freak hat genau das gezeigt was ich meine. Das wäre bei deinem Programm die beste Lösung. 

Richtig implementiert sollte es so aussehen

- User klickt Button. -> Abfrage -> Ja -> Textfeld leer ->Nichts passiert -> User muss wieder auf Button klicken
- User klickt Button -> Abfrage -> Ja -> Textfeld nicht leer -> weitere Bearbeitung.

Gruß

Sascha


----------



## miffi (11. Mai 2010)

Howdie.

Solche Überprüfungen würde ich auch nur Event-basiert durchführen, wie Sascha & co. bereits gesagt haben. 
Ein grobes Beispiel, wie ich es (vor langer Zeit) mal gelöst habe, ohne dass ein Button gedrückt werden muss:
Als Eingabefeld habe ich ein _JFormattedTextField_ genommen und seinem Datenmodell über 

```
myField.getDocument().addDocumentListener(myDocListenerInstance);
```
einen Listener hinzugefügt. Müsstest du aber auch mit einem normalen _JTextField_ und einem _ActionListener_ machen können, es waren halt recht spezielle Anforderungen damals. 
Die Methoden zum Abfangen der Events des Listener-Interfaces rufen eine von mir geschriebene Validierungs-Methode auf, die überprüft, ob alle nötigen Daten vorhanden sind und dementsprechend reagiert.

Gruß und viel Erfolg
miffi


----------



## youza (11. Mai 2010)

Achte Vielleicht noch drauf, dass wenn du die überprüfungsschleife schreibst(Da es eine theoretische Endlosschleife ist), dass du einen kurzen Sleep einbaust da sonst der Prozessor unnötig beansprucht wird:

```
while(true)
{
System.out.println("Endlos");
try {
	Thread.sleep(100);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
}
```
Mit Sleep hats eine Prozessor auslastung von 2% ohne von 80% bei mir jetzt.


----------



## zerix (11. Mai 2010)

Man sollte es gar nicht mit einer Schleife lösen. 
Wenn ein Event ausgelöst wurde, sollte es "abgebrochen" werden, wenn die Daten nicht valide sind und später eventuell, wenn gefordert nochmal ausgelöst werden.
Es ist schlecht zu warten, bis die Daten korrekt eingegeben wurde, da man ja nicht weiß, ob der Nutzer das eventuell machen möchte.

Gruß

Sascha


----------



## youza (11. Mai 2010)

Da gebe ich dir vollkommen recht eine Schleife die Endlos sein kann sollte man nie Programmieren. Aber wenn dann sollte man zumindest dabei seinen Prozessor schonen und des wollt ich nur anmerken

VFL_Freak beschreibt des ja eigentlich perfekt mit dem Rückgabewert und wenn dieser true ist dann mach weiter ansonsten nicht. 

Meiner Meinung nach sollten Buttons die nicht ausgeführt werden sollen ausgegraut sein und ohne Funktion. Mit KeyListener könnte dann darauf gewartet werden, dass im Feld Revision etwas eingetragen wird und wenn dieser eintrag gemäß der Vorgabe ist kann die Aktion erst angestoßen werden.
Das wäre zumindest meine Vorgehensweise dann muss man nichts überprüfen sondern weiß schon vor dem Anstoß der Funktion, dass die Daten ok sind.

Grüße
Anton


----------

