Wie programm eine JFrame schließen

Question

Was ist der richtige Weg, einen JFrame zu schließen zu bekommen, das gleiche wie wenn der Benutzer die X Schließen-Schaltfläche getroffen hatte, oder gedrückt Alt + F4 (unter Windows) ?

Ich habe meinen Standard-Schließ-Vorgang, wie ich will, setzen über:

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Es tut genau das, was ich mit den oben genannten Kontrollen werden soll. Diese Frage ist nicht darüber.

Was will ich wirklich zu tun ist, zu bewirken, dass die GUI in der gleichen Weise wie eine Presse von X Schließen-Schaltfläche, es würde dazu führen, verhalten sich verhalten soll.

Nehmen wir an, ich wäre WindowAdaptor zu verlängern und dann eine Instanz meines Adapter als Zuhörer über addWindowListener() hinzufügen. Ich möchte die gleiche Sequenz von Anrufen durch windowDeactivated(), windowClosing() und windowClosed() sehen, wie mit der X Schließen-Schaltfläche auftreten würde. Nicht so sehr zerreißt das Fenster so zu sagen es selbst zu zerreißen, so zu sprechen.

Answer 1

Wenn Sie die GUI verhalten soll, als ob Sie die X Schließen-Schaltfläche geklickt dann müssen Sie ein Fenster Abschlussveranstaltung zum Window versenden. Die ExitAction von eine Anwendung schließen diese Funktionalität hinzufügen können einen Menüpunkt oder jede Komponente, die Actions leicht verwendet.

frame.dispatchEvent(new WindowEvent(frame, WindowEvent.WINDOW_CLOSING));

Answer 2

setVisible(false); //you can't see me!
dispose(); //Destroy the JFrame object

Nicht zu heikel.

Answer 3

Wenn von Alt-F4 oder X Sie bedeuten „Beenden Sie die Anwendung sofort ohne Rücksicht auf, was andere Windows bzw. Threads laufen“, dann wird System.exit(...) genau das tun, , was Sie in einem sehr abrupten wollen, Brute -force und möglicherweise problematische Art und Weise.

Wenn von Alt-F4 oder X Sie das Fenster bedeuten verstecken, dann ist frame.setVisible(false), wie Sie „Schließen“ das Fenster. Das Fenster wird auch weiterhin Ressourcen / Speicher verbrauchen kann aber sichtbar sehr schnell wieder hergestellt werden.

Wenn von Alt-F4 oder X Sie das Fenster bedeuten verstecken und entsorgen Sie alle Ressourcen, die sie verbraucht, dann ist frame.dispose(), wie Sie „Schließen“ das Fenster. Wenn der Rahmen das letzte sichtbare Fenster war und es keine andere nicht-Daemon laufenden Threads, wird das Programm verlassen. Wenn Sie das Fenster wieder zeigen, wird es alle nativen Ressourcen neu zu initialisieren wieder (Grafik-Puffer, Fenstergriffe, etc.).

dispose() könnte am nächsten zu dem Verhalten, das Sie wirklich wollen. Wenn Ihre App mehrere Fenster geöffnet hat, wollen Sie Alt-F4 oder X die App verlassen oder einfach nur das aktive Fenster schließen?

Die Java Swing Tutorial auf Fenster Hörer kann zur Klärung Dinge für Sie.

Answer 4

Wenn Sie dies getan haben, um sicherzustellen, dass der Benutzer nicht das Fenster schließen kann:

frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);

Dann sollten Sie Ihre pullThePlug() Methode ändern sein

public void pullThePlug() {
    // this will make sure WindowListener.windowClosing() et al. will be called.
    WindowEvent wev = new WindowEvent(this, WindowEvent.WINDOW_CLOSING);
    Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(wev);

    // this will hide and dispose the frame, so that the application quits by
    // itself if there is nothing else around. 
    setVisible(false);
    dispose();
    // if you have other similar frames around, you should dispose them, too.

    // finally, call this to really exit. 
    // i/o libraries such as WiiRemoteJ need this. 
    // also, this is what swing does for JFrame.EXIT_ON_CLOSE
    System.exit(0); 
}

ich dies fand der einzige Weg zu sein, die mit den WindowListener und JFrame.DO_NOTHING_ON_CLOSE schön spielt.

Answer 5

Hier würde Ihre Optionen sein:

System.exit(0); // stop program
frame.dispose(); // close window
frame.setVisible(false); // hide window

Answer 6

Beenden von Java laufenden Prozess sehr einfach ist, im Grunde brauchen Sie nur zwei einfache Dinge zu tun:

1. Anruf Java-Methode System.exit(...) bei bei Anwendung beenden Punkt. Zum Beispiel, wenn Ihre Anwendung Rahmen basiert, können Sie Zuhörer WindowAdapter und und rufen System.exit(...) innerhalb seiner Methode windowClosing(WindowEvent e) hinzufügen.

. Hinweis: Sie müssen rufen System.exit(...) ansonsten Ihr Programm Fehler beteiligt

2. unerwartete Java Ausnahmen Vermeiden, um sicherzustellen, kann die Exit-Methode immer dann aufgerufen werden. Wenn Sie System.exit(...) im rechten Punkt hinzufügen, aber es bedeutet nicht, dass das Verfahren immer dann aufgerufen werden kann, weil unerwartete Java Ausnahmen die Methode von genannt worden verhindern.

Dies ist stark an Ihre Programmierkenntnisse bezogen.

** Es folgt eine einfache Probe (JFrame basiert), die zeigt, wie Exit-Methode aufrufen

import java.awt.event.*;
import javax.swing.*;

public class ExitApp extends JFrame
{
   public ExitApp()
   {
      addWindowListener(new WindowAdapter()
      {
         public void windowClosing(WindowEvent e)
         {
           dispose();
           System.exit(0); //calling the method is a must
         }
      });
   }

   public static void main(String[] args)
   {
      ExitApp app=new ExitApp();
      app.setBounds(133,100,532,400);
      app.setVisible(true);
   }
}

Answer 7

Nicht nur die JFrame zu schließen, sondern auch Window Ereignisse auslösen, versuchen Sie dies:

myFrame.dispatchEvent(new WindowEvent(myFrame, WindowEvent.WINDOW_CLOSING));

Answer 8

  

setDefaultCloseOperation (WindowConstants.EXIT_ON_CLOSE);

schließt nicht nur die JFrame sondern die Abschaltungen die gesamte Anwendung, also "EXIT ON CLOSE"

, um das gleiche Ergebnis zu erzielen, die Sie haben, um effektiv die Anwendung zu beenden, denn das ist einfach anrufen

 System.exit(0);

Der Effekt ist genau das gleiche.

Answer 9

Der beste Weg, einen Schwenkrahmen programmatisch zu schließen ist, es zu machen verhalten sich wie es wäre, wenn die „X“ -Taste gedrückt wird. Dazu müssen Sie den Window implementieren müssen, die Ihren Bedürfnissen entspricht und stellen Sie den Rahmen Standard-Schließvorgang nichts zu tun (DO_NOTHING_ON_CLOSE).

initialisieren Ihren Rahmen wie folgt aus:

private WindowAdapter windowAdapter = null;

private void initFrame() {

    this.windowAdapter = new WindowAdapter() {
        // WINDOW_CLOSING event handler
        @Override
        public void windowClosing(WindowEvent e) {
            super.windowClosing(e);
            // You can still stop closing if you want to
            int res = JOptionPane.showConfirmDialog(ClosableFrame.this, "Are you sure you want to close?", "Close?", JOptionPane.YES_NO_OPTION);
            if ( res == 0 ) {
                // dispose method issues the WINDOW_CLOSED event
                ClosableFrame.this.dispose();
            }
        }

        // WINDOW_CLOSED event handler
        @Override
        public void windowClosed(WindowEvent e) {
            super.windowClosed(e);
            // Close application if you want to with System.exit(0)
            // but don't forget to dispose of all resources 
            // like child frames, threads, ...
            // System.exit(0);
        }
    };

    // when you press "X" the WINDOW_CLOSING event is called but that is it
    // nothing else happens
    this.setDefaultCloseOperation(ClosableFrame.DO_NOTHING_ON_CLOSE);
    // don't forget this
    this.addWindowListener(this.windowAdapter);
}

Sie können den Rahmen programmatisch schließen, indem sie die WINDOW_CLOSING Ereignis zu senden, wie folgt aus:

WindowEvent closingEvent = new WindowEvent(targetFrame, WindowEvent.WINDOW_CLOSING);
Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(closingEvent);

Damit wird den Rahmen wie die „X“ in der Nähe Taste gedrückt wurde.

Answer 10

Wenn Sie wirklich wollen nicht Ihre Anwendung zu beenden, wenn ein JFrame dann geschlossen wird,

Verwendung: setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

statt: setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Hier ist eine Zusammenfassung dessen, was die Lösung aussieht,

 myFrame.dispatchEvent(new WindowEvent(myFrame, WindowEvent.WINDOW_CLOSING));

Answer 11

Dieses Beispiel zeigt, wie man die bestätigten Fenster schließen Betrieb realisieren.

Das Fenster hat einen Fensteradapter, der den Standard-Schließvorgang schaltet EXIT_ON_CLOSE abhängig von Ihrer Antwort in dem DO_NOTHING_ON_CLOSE OptionDialogor.

Das Verfahren closeWindow des ConfirmedCloseWindow feuert ein close-Ereignis-Fenster und kann überall das heißt als eine Aktion eines Menüpunktes verwendet werden

public class WindowConfirmedCloseAdapter extends WindowAdapter {

    public void windowClosing(WindowEvent e) {

        Object options[] = {"Yes", "No"};

        int close = JOptionPane.showOptionDialog(e.getComponent(),
                "Really want to close this application?\n", "Attention",
                JOptionPane.YES_NO_OPTION,
                JOptionPane.INFORMATION_MESSAGE,
                null,
                options,
                null);

        if(close == JOptionPane.YES_OPTION) {
           ((JFrame)e.getSource()).setDefaultCloseOperation(
                   JFrame.EXIT_ON_CLOSE);
        } else {
           ((JFrame)e.getSource()).setDefaultCloseOperation(
                   JFrame.DO_NOTHING_ON_CLOSE);
        }
    }
}

public class ConfirmedCloseWindow extends JFrame {

    public ConfirmedCloseWindow() {

        addWindowListener(new WindowConfirmedCloseAdapter());
    }

    private void closeWindow() {
        processWindowEvent(new WindowEvent(this, WindowEvent.WINDOW_CLOSING));
    }
}

Answer 12

Auf der Grundlage der Antworten bereits hier zur Verfügung gestellt, das ist die Art, wie ich es umgesetzt:

JFrame frame= new JFrame()
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

// frame stuffs here ...

frame.dispatchEvent(new WindowEvent(frame, WindowEvent.WINDOW_CLOSING));

Die JFrame wird das Ereignis zu schließen und beim Schließen, beendet wird.

Answer 13

Diese Antwort wurde von Alex gegeben und ich möchte es empfehlen. Er arbeitete für mich und eine andere Sache, es ist einfach und so einfach.

setVisible(false); //you can't see me!
dispose(); //Destroy the JFrame object

Answer 14

Sie haben den Anruf in die AWT-Nachrichtenwarteschlange einzufügen, so dass alle das Timing richtig geschieht, sonst wird es nicht die richtige Ereignisfolge versenden, insbesondere in einem Multi-Threaded-Programm. Wenn dies geschehen ist, kann man die resultierende Ereignissequenz genau behandeln, wie würden Sie, wenn der Benutzer auf die [x] -Taste für eine OS suppled dekoriert JFrame.

geklickt hat

public void closeWindow()
{
    if(awtWindow_ != null) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                awtWindow_.dispatchEvent(new WindowEvent(awtWindow_, WindowEvent.WINDOW_CLOSING));
            }
        });
    }
}

Answer 15

ich dies versucht haben, Ihren eigenen Code für formWindowClosing () Ereignis schreiben.

 private void formWindowClosing(java.awt.event.WindowEvent evt) {                                   
    int selectedOption = JOptionPane.showConfirmDialog(null,
            "Do you want to exit?",
            "FrameToClose",
            JOptionPane.YES_NO_OPTION);
    if (selectedOption == JOptionPane.YES_OPTION) {
        setVisible(false);
        dispose();
    } else {
        setDefaultCloseOperation(javax.swing.WindowConstants.DO_NOTHING_ON_CLOSE);
    }
}    

Das fragt Benutzer, ob er den Rahmen oder Anwendung beenden möchten.

Answer 16

Posting, was in der Frage Körper als CW Antwort war.

Gesuche um die Ergebnisse zu teilen, vor allem aus abgeleitet camickr des Link folgen. Grundsätzlich muss ich bei der Ereigniswarteschlange eine WindowEvent.WINDOW_CLOSING werfen der Anwendung. Hier ist eine Zusammenfassung dessen, was die Lösung aussieht

// closing down the window makes sense as a method, so here are
// the salient parts of what happens with the JFrame extending class ..

    public class FooWindow extends JFrame {
        public FooWindow() {
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            setBounds(5, 5, 400, 300);  // yeah yeah, this is an example ;P
            setVisible(true);
        }
        public void pullThePlug() {
                WindowEvent wev = new WindowEvent(this, WindowEvent.WINDOW_CLOSING);
                Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(wev);
        }
    }

// Here's how that would be employed from elsewhere -

    // someplace the window gets created ..
    FooWindow fooey = new FooWindow();
    ...
    // and someplace else, you can close it thusly
    fooey.pullThePlug();

Answer 17

Wenn Sie nicht möchten, dass Ihre Anwendung zu beenden, wenn ein JFrame geschlossen ist, verwenden:     setDefaultCloseOperation (JFrame.DISPOSE_ON_CLOSE)

statt:     setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);

Aus der Dokumentation:

DO_NOTHING_ON_CLOSE (defined in WindowConstants): Sie nichts tun; benötigen Sie das Programm, das den Betrieb in der Methode window ein registrierten Window Objekt zu behandeln.

HIDE_ON_CLOSE (defined in WindowConstants). Automatisch den Rahmen auszublenden, nachdem alle registrierten Objekte Window Aufruf

DISPOSE_ON_CLOSE (defined in WindowConstants). Automatisch verstecken und den Rahmen entsorgen, nachdem alle registrierten Objekte Window Aufruf

EXIT_ON_CLOSE (defined in JFrame): Beenden Sie die Anwendung der Exit-Methode System. Verwenden Sie diese Option nur in Anwendungen.

könnte noch nützlich sein: Sie können setVisible(false) auf Ihrem JFrame verwenden, wenn Sie wieder den gleichen Rahmen angezeigt werden soll. Ansonsten dispose() rufen alle nativen Bildschirm Ressourcen zu entfernen.

kopiert von Peter Lang

https://stackoverflow.com/a/1944474/3782247

Answer 18

 setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);