español - swing java

Cómo cerrar programáticamente un JFrame

Question

¿Cuál es la forma correcta de cerrar un JFrame , de la misma forma que si el usuario hubiera presionado el botón de cerrar X , o hubiera presionado Alt + F4 (en Windows)?

Tengo mi operación de cierre predeterminada configurada como deseo, a través de:

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Hace exactamente lo que quiero con los controles antes mencionados. Esta pregunta no es sobre eso.

Lo que realmente quiero hacer es hacer que la GUI se comporte de la misma manera que presionar el botón X cerrar causaría que se comporte.

Supongamos que extiendo WindowAdaptor y luego agregue una instancia de mi adaptador como oyente a través de addWindowListener() . Me gustaría ver la misma secuencia de llamadas a través de windowDeactivated() , windowClosing() y windowClosed() que se produciría con el botón X cerrar. No tanto rasgar la ventana como decirle que se rasgue, por así decirlo.

Answer 1

setDefaultCloseOperation (WindowConstants.EXIT_ON_CLOSE);

No solo cierra el JFrame sino que cierra toda la aplicación, por lo tanto, "EXIT ON CLOSE"

Para lograr el mismo resultado, debe salir de la aplicación de manera efectiva, para eso simplemente llame

 System.exit(0);

El efecto es exactamente el mismo.

Answer 2

Basado en las respuestas ya proporcionadas 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 hace que el evento se cierre y, al cerrarse, sale.

Answer 3

Debe insertar la llamada en la cola de mensajes de AWT para que todo el tiempo suceda correctamente, de lo contrario no enviará la secuencia de eventos correcta, especialmente en un programa de subprocesos múltiples. Una vez hecho 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));
            }
        });
    }
}

Answer 4

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

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

Answer 5

Estas serían tus opciones:

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

Answer 6

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 a EXIT_ON_CLOSE o DO_NOTHING_ON_CLOSE dependiendo de su respuesta en el OptionDialog .

El método closeWindow de ConfirmedCloseWindow dispara un evento de ventana cercana 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));
    }
}

Answer 7

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 desea salir del marco o la aplicación.

Answer 8

La mejor manera de cerrar un marco de 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 configurar la operación de cierre predeterminada del marco para que no haga nada (DO_NOTHING_ON_CLOSE).

Inicializa tu marco de esta manera:

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, como esto:

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

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

Answer 9

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

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

Answer 10

Publicando lo que estaba en el cuerpo de la pregunta como respuesta CW.

Quería compartir los resultados, derivados principalmente del siguiente enlace de camickr. Básicamente necesito lanzar un WindowEvent.WINDOW_CLOSING en 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();

Answer 11

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

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

Nota: debe llamar a System.exit(...) contrario, su programa tiene un error.

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

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

** La siguiente es una muestra más simple (basada en JFrame ) 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);
   }
}

Answer 12

Si al presionar Alt-F4 o X quiere decir "Salir de la aplicación inmediatamente sin considerar lo que se está ejecutando otras ventanas o System.exit(...) ", entonces System.exit(...) hará exactamente lo que desea de forma muy brusca, fuerza bruta, y posiblemente la moda problemática.

Si con Alt-F4 o X quiere decir que oculta la ventana, entonces frame.setVisible(false) es la forma en que "cierra" la ventana. La ventana continuará consumiendo recursos / memoria, pero puede hacerse visible de nuevo muy rápidamente.

Si con Alt-F4 o X quiere decir que oculta la ventana y frame.dispose() recursos que consume, entonces frame.dispose() es la forma en que "cierra" la ventana. Si el marco fue la última ventana visible y no hay otros subprocesos que no sean de demonio 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, manejadores de ventanas, etc.).

dispose() podría ser el más cercano al comportamiento que realmente deseas. Si su aplicación tiene varias ventanas abiertas, ¿desea que Alt-F4 o X salga de la aplicación o simplemente cierre la ventana activa?

El Tutorial de Java Swing en Window Listeners puede ayudar a aclarar las cosas para usted.

Answer 13

Si desea que la GUI se comporte como si hiciera clic en el botón de cerrar X , debe enviar un evento de cierre de ventana a la Window . ExitAction de Closing An Application le permite agregar esta funcionalidad a un elemento del menú o cualquier componente que use las Action facilidad.

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

Answer 14

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

frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);

Entonces debes cambiar tu método pullThePlug() para que sea

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

Descubrí que esta es la única forma de jugar bien con WindowListener y JFrame.DO_NOTHING_ON_CLOSE .

Answer 15

Si no desea que su aplicación finalice cuando se cierre 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 haga 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) : oculta automáticamente el marco después de invocar cualquier objeto registrado de WindowListener.

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

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

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

copiado de Peter Lang

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

Answer 16

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

use: setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

en lugar 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));

Answer 17

 setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

Answer 18

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

No es demasiado complicado.