¿Cuál es la forma correcta JFramede cerrar, lo mismo que si el usuario hubiera presionado el Xbotón de cerrar o presionado Alt+ F4(en Windows)?

Tengo mi operación de cierre predeterminada configurada de la manera que quiero, a través de:

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Hace exactamente lo que quiero con los controles antes mencionados. Esta pregunta no se trata de eso.

Lo que realmente quiero hacer es hacer que la GUI se comporte de la misma manera que presionar el Xbotón de cerrar haría que se comportara.

Supongamos que extiendo WindowAdaptory luego agrego una instancia de mi adaptador como un oyente a través de addWindowListener(). Me gustaría ver la misma secuencia de llamadas a través windowDeactivated(), windowClosing()y windowClosed()como ocurriría con el Xbotón de cierre. No tanto romper la ventana como decirle que se rompa, por así decirlo.

Si desea que la GUI se comporte como si hiciera clic en el Xbotón de cierre, debe enviar un evento de cierre de ventana al Window. El ExitActionde cerrar una aplicación le permite añadir esta funcionalidad a un elemento de menú o cualquier componente que utiliza Actions fácilmente.

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

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

No muy complicado.

Si con Alt-F4 o X te refieres a "Salir de la aplicación inmediatamente sin tener en cuenta qué otras ventanas o subprocesos se están ejecutando", entonces System.exit(...)hará exactamente lo que quieras de una manera muy brusca, con fuerza bruta y posiblemente problemática.

Si con Alt-F4 o X te refieres a ocultar la ventana, entonces frame.setVisible(false)es cómo "cierras" la ventana. La ventana continuará consumiendo recursos / memoria, pero se puede volver a hacer visible muy rápidamente.

Si con Alt-F4 o X te refieres a ocultar la ventana y eliminar cualquier recurso que esté consumiendo, entonces frame.dispose()es cómo "cierras" la ventana. Si el marco era la última ventana visible y no hay otros subprocesos no daemon en ejecución, el programa se cerrará. Si vuelve a mostrar la ventana, tendrá que reinicializar todos los recursos nativos nuevamente (búfer de gráficos, identificadores de ventana, etc.).

dispose()podría estar más cerca del comportamiento que realmente quieres. Si su aplicación tiene varias ventanas abiertas, ¿desea que Alt-F4 o X salgan de la aplicación o simplemente cierren la ventana activa?

El Tutorial de Java Swing sobre Window Listeners puede ayudarlo a aclarar las cosas por usted.

Si ha hecho esto para asegurarse de que el usuario no pueda cerrar la ventana:

frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);

Entonces deberías cambiar tu pullThePlug()método para ser

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); 
}

Encontré que esta es la única manera que juega bien con el WindowListenery JFrame.DO_NOTHING_ON_CLOSE.

Estas serían tus opciones:

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

Salir del proceso de ejecución de Java es muy fácil, básicamente debes hacer solo dos cosas simples:

1. Llame al método java System.exit(...)en el punto de cierre de la aplicación. Por ejemplo, si su aplicación está basada en marcos, puede agregar oyente WindowAdaptery llamar System.exit(...)dentro de su método windowClosing(WindowEvent e).

Nota: debe llamar, de lo System.exit(...)contrario, su programa implica un error.

2. Evitar excepciones inesperadas de Java para asegurarse de que siempre se pueda llamar al método de salida. Si agrega System.exit(...)en el punto correcto, pero no significa que se pueda llamar siempre al método, ya que las excepciones inesperadas de Java pueden evitar que se llame al método.

Esto está fuertemente relacionado con tus habilidades de programación.

** A continuación se muestra una muestra más simple ( JFramebasada) que muestra cómo llamar al método de salida

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);
   }
}

No solo para cerrar JFrame sino también para activar eventos WindowListener, intente esto:

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

La mejor manera de cerrar un marco Swing mediante programación es hacer que se comporte como lo haría cuando se presiona el botón "X". Para hacerlo, deberá implementar WindowAdapter que se adapte a sus necesidades y establecer la operación de cierre predeterminada del marco para que no haga nada (DO_NOTHING_ON_CLOSE).

Inicialice su marco así:

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);
}

Puede cerrar el marco mediante programación enviándole el evento WINDOW_CLOSING, de esta manera:

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

Esto cerrará el marco como se presionó el botón "X".

Si realmente no desea que su aplicación finalice cuando se cierra un JFrame, entonces,

utilizar : setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

en vez de : setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Aquí hay una sinopsis de cómo se ve la solución,

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

Esta respuesta fue dada por Alex y me gustaría recomendarla. Funcionó para mí y otra cosa es sencilla y muy simple.

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

Este ejemplo muestra cómo realizar la operación de cierre de ventana confirmada.

La ventana tiene un adaptador de ventana que cambia la operación de cierre predeterminada EXIT_ON_CLOSEo DO_NOTHING_ON_CLOSEdepende de su respuesta en el OptionDialog.

El método closeWindowde ConfirmedCloseWindowdisparar un evento de cerrar ventana y puede usarse en cualquier lugar, es decir, como una acción de un elemento de menú

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));
    }
}

Según las respuestas que ya se proporcionan aquí, esta es la forma en que lo implementé:

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

// frame stuffs here ...

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

El JFrame cierra el evento y, al cerrar, sale.

Debe insertar la llamada en la cola de mensajes de AWT para que todos los tiempos ocurran correctamente, de lo contrario no enviará la secuencia de eventos correcta, especialmente en un programa de subprocesos múltiples. Cuando se hace esto, puede manejar la secuencia de eventos resultante exactamente como lo haría si el usuario hubiera hecho clic en el botón [x] para un JFrame decorado con sistema operativo.

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

He intentado esto, escriba su propio código para el evento formWindowClosing () .

 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);
    }
}    

Esto le pregunta al usuario si quiere salir del Marco o la Aplicación.

Publicar lo que había en el cuerpo de la pregunta como respuesta de CW.

Quería compartir los resultados, principalmente derivados del siguiente enlace de camickr. Básicamente necesito lanzar un WindowEvent.WINDOW_CLOSINGen la cola de eventos de la aplicación. Aquí hay una sinopsis de cómo se ve la solución

// 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();

Si no desea que su aplicación finalice cuando se cierra un JFrame, use: setDefaultCloseOperation (JFrame.DISPOSE_ON_CLOSE)

en lugar de: setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);

De la documentación:

DO_NOTHING_ON_CLOSE (defined in WindowConstants): No hagas nada; requiere que el programa maneje la operación en el método windowClosing de un objeto WindowListener registrado.

HIDE_ON_CLOSE (defined in WindowConstants): Ocultar automáticamente el marco después de invocar cualquier objeto registrado de WindowListener.

DISPOSE_ON_CLOSE (defined in WindowConstants): Oculta y desecha automáticamente el marco después de invocar cualquier objeto registrado de WindowListener.

EXIT_ON_CLOSE (defined in JFrame): Salga de la aplicación utilizando el método de salida del sistema. Use esto solo en aplicaciones.

aún puede ser útil: puede usarlo setVisible(false)en su JFrame si desea mostrar el mismo marco nuevamente. De lo contrario, llame dispose()para eliminar todos los recursos de la pantalla nativa.

copiado de Peter Lang

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

 setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);