Java 窗户什么时候开？如何在不侦听窗口事件的情况下知道窗口已打开？

下面的示例允许显示、隐藏、处置和关闭窗口（通过发送事件）

示例显示，该窗口只打开一次——在第一组可见时。即使一个窗口被释放，然后再次显示，它也不会经历“打开”事件

为什么?

如何在不编写处理程序和跟踪此事件的情况下知道窗口是否已打开

如何关闭窗口，使其在设置为可见时再次经历打开事件？即，如何将窗口对象返回到初始状态

是否有任何其他状态或事件可以具有所需的属性

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.FlowLayout;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.AbstractAction;
import javax.swing.AbstractListModel;
import javax.swing.ComboBoxModel;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.event.ListDataListener;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Tester_JFrame_Closing_01 {

    private static Logger log = LoggerFactory.getLogger(Tester_JFrame_Closing_01.class);

    protected static Toolkit toolkit = Toolkit.getDefaultToolkit();
    protected static EventQueue eventQueue = toolkit.getSystemEventQueue();

    public static enum CloseOperation {

        DO_NOTHING_ON_CLOSE(JFrame.DO_NOTHING_ON_CLOSE),
        HIDE_ON_CLOSE(JFrame.HIDE_ON_CLOSE),
        DISPOSE_ON_CLOSE(JFrame.DISPOSE_ON_CLOSE),
        EXIT_ON_CLOSE(JFrame.EXIT_ON_CLOSE)
        ;

        public static ComboBoxModel newModel() {

            return new ComboBoxModel() {
                private CloseOperation selected = HIDE_ON_CLOSE;

                @SuppressWarnings("serial")
                private final AbstractListModel core = new AbstractListModel() {

                    @Override
                    public int getSize() {
                        return values().length;
                    }

                    @Override
                    public Object getElementAt(int index) {
                        return values()[index];
                    }

                };

                @Override
                public int getSize() {
                    return core.getSize();
                }

                @Override
                public Object getElementAt(int index) {
                    return core.getElementAt(index);
                }

                @Override
                public void addListDataListener(ListDataListener l) {
                    core.addListDataListener(l);
                }

                @Override
                public void removeListDataListener(ListDataListener l) {
                    core.removeListDataListener(l);
                }

                @Override
                public void setSelectedItem(Object anItem) {
                    selected = (CloseOperation) anItem;
                }

                @Override
                public Object getSelectedItem() {
                    return selected;
                }

            };

        }


        public final int Value;

        private CloseOperation(int value) {
            this.Value = value;
        }

        @Override
        public String toString() {
            switch(this) {
            case DISPOSE_ON_CLOSE:
                return "DISPOSE_ON_CLOSE";
            case HIDE_ON_CLOSE:
                return "HIDE_ON_CLOSE";
            case DO_NOTHING_ON_CLOSE:
                return "DO_NOTHING_ON_CLOSE";
            case EXIT_ON_CLOSE:
                return "EXIT_ON_CLOSE";
            default:
                return "<UNKNOWN>";
            }
        }
    }

    public static void main(String[] args) {

        WindowAdapter windowAdapter = new WindowAdapter() {
            @Override
            public void windowClosed(WindowEvent e) {
                log.debug("windowClosed");
            }

            @Override
            public void windowClosing(WindowEvent e) {
                log.debug("windowClosing");
            }

            @Override
            public void windowOpened(WindowEvent e) {
                log.debug("windowOpened");
            }

        };

        final JFrame frame = new JFrame("Controlled window");
        frame.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
        frame.addWindowListener(windowAdapter);

        final WindowEvent closeEvent = new WindowEvent(frame, WindowEvent.WINDOW_CLOSING);

        @SuppressWarnings("serial")
        AbstractAction closeAction = new AbstractAction("close") {
            @Override
            public void actionPerformed(ActionEvent e) {
                eventQueue.postEvent(closeEvent);
            }
        };

        @SuppressWarnings("serial")
        AbstractAction hideAction = new AbstractAction("hide") {
            @Override
            public void actionPerformed(ActionEvent e) {
                frame.setVisible(false);
            }
        };

        @SuppressWarnings("serial")
        AbstractAction showAction = new AbstractAction("show") {
            @Override
            public void actionPerformed(ActionEvent e) {
                frame.setVisible(true);
            }
        };

        @SuppressWarnings("serial")
        AbstractAction disposeAction = new AbstractAction("dispose") {

            @Override
            public void actionPerformed(ActionEvent e) {
                frame.dispose();
            }
        };

        JButton closeButton = new JButton(closeAction);
        JButton hideButton = new JButton(hideAction);
        JButton showButton = new JButton(showAction);
        JButton disposeButton = new JButton(disposeAction);

        ComboBoxModel closeOperationModel = CloseOperation.newModel();

        final JComboBox closeOperationCombo = new JComboBox(closeOperationModel);
        closeOperationCombo.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                log.debug("closeOperationCombo.actionPerformed({})", e);
                frame.setDefaultCloseOperation(((CloseOperation)closeOperationCombo.getSelectedItem()).Value);
            }
        });

        JPanel buttonPanel = new JPanel();
        buttonPanel.setLayout(new FlowLayout());

        buttonPanel.add(showButton);
        buttonPanel.add(hideButton);
        buttonPanel.add(disposeButton);
        buttonPanel.add(closeButton);
        buttonPanel.add(closeOperationCombo);

        JFrame controlFrame = new JFrame("Controller window");
        controlFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        controlFrame.setLayout(new FlowLayout());
        controlFrame.add(buttonPanel, BorderLayout.SOUTH);
        controlFrame.pack();
        controlFrame.setLocation(100, 100);
        controlFrame.setVisible(true);

        frame.setBounds(100, 100 + controlFrame.getHeight(), controlFrame.getWidth(), 480);

    }
}

导入java.awt.BorderLayout；
导入java.awt.EventQueue；
导入java.awt.FlowLayout；
导入java.awt.Toolkit；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.awt.event.WindowAdapter；
导入java.awt.event.WindowEvent；
导入javax.swing.AbstractAction；
导入javax.swing.AbstractListModel；
导入javax.swing.ComboxModel；
导入javax.swing.JButton；
导入javax.swing.JComboBox；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
导入javax.swing.event.ListDataListener；
导入org.slf4j.Logger；
导入org.slf4j.LoggerFactory；
公共类测试仪\u JFrame\u Closing\u 01{
专用静态记录器log=LoggerFactory.getLogger（测试仪\u JFrame\u Closing\u 01.class）；
受保护的静态Toolkit=Toolkit.getDefaultToolkit（）；
受保护的静态EventQueue EventQueue=toolkit.getSystemEventQueue（）；
公共静态枚举关闭操作{
关闭时不执行任何操作（JFrame.DO\u NOTHING\u ON\u CLOSE），
关闭时隐藏（JFrame.HIDE_ON_CLOSE），
关闭时处理（JFrame.DISPOSE\u ON\u CLOSE），
关闭时退出（JFrame.EXIT\u ON\u CLOSE）
;
公共静态ComboxModel newModel（）{
返回新的ComboBoxModel（）{
选择私有关闭操作=在关闭时隐藏；
@抑制警告（“串行”）
私有最终AbstractListModel核心=新AbstractListModel（）{
@凌驾
公共int getSize（）{
返回值（）.length；
}
@凌驾
公共对象getElementAt（int索引）{
返回值（）[index]；
}
};
@凌驾
公共int getSize（）{
返回core.getSize（）；
}
@凌驾
公共对象getElementAt（int索引）{
返回core.getElementAt（索引）；
}
@凌驾
public void addListDataListener（ListDataListener l）{
core.addListDataListener（l）；
}
@凌驾
公共void removeListDataListener（ListDataListener l）{
core.removeListDataListener（l）；
}
@凌驾
public void setSelectedItem（对象anItem）{
所选=（关闭操作）一个项目；
}
@凌驾
公共对象getSelectedItem（）{
返回选中的；
}
};
}
公共最终整数值；
私有关闭操作（int值）{
这个。值=值；
}
@凌驾
公共字符串toString（）{
开关（本）{
关闭时的案例处理：
返回“关闭时处理”；
案例隐藏\u打开\u关闭：
返回“关闭时隐藏”；
案例“不做任何事情”关闭：
返回“关闭时不执行任何操作”；
案例退出\u打开\u关闭：
返回“关闭时退出”；
违约：
返回“”；
}
}
}
公共静态void main（字符串[]args）{
WindowAdapter WindowAdapter=新的WindowAdapter（）{
@凌驾
公共无效窗口关闭（WindowEvent e）{
log.debug（“windowClosed”）；
}
@凌驾
公共无效窗口关闭（WindowEvent e）{
log.debug（“窗口关闭”）；
}
@凌驾
公共无效窗口已打开（WindowEvent e）{
log.debug（“WindowOpen”）；
}
};
最终JFrame=新JFrame（“受控窗口”）；
frame.setDefaultCloseOperation（JFrame.HIDE_ON_CLOSE）；
frame.addWindowListener（windowAdapter）；
最终WindowEvent closeEvent=新的WindowEvent（框架，WindowEvent.WINDOW\u关闭）；
@抑制警告（“串行”）
AbstractAction closeAction=新的AbstractAction（“close”）{
@凌驾
已执行的公共无效操作（操作事件e）{
eventQueue.postEvent（closeEvent）；
}
};
@抑制警告（“串行”）
AbstractAction hideAction=新的AbstractAction（“隐藏”）{
@凌驾
已执行的公共无效操作（操作事件e）{
frame.setVisible（假）；
}
};
@抑制警告（“串行”）
AbstractAction showAction=新的AbstractAction（“show”）{
@凌驾
已执行的公共无效操作（操作事件e）{
frame.setVisible（true）；
}
};
@抑制警告（“串行”）
AbstractAction disposeAction=新的AbstractAction（“dispose”）{
@凌驾
已执行的公共无效操作（操作事件e）{
frame.dispose（）；
}
};
JButton closeButton=新JButton（closeAction）；
JButton hideButton=新JButton（hideAction）；
JButton showButton=新JButton（showAction）；
JButton disposeButton=新JButton（disposeAction）；
ComboBoxModel closeOperationModel=CloseOperation.newModel（）；
最终JCOMBOX关闭操作组合=新JComb
Window getSelectedWindow(Window[] windows) {
    Window result = null;
    for (int i = 0; i < windows.length; i++) {
        Window window = windows[i];
        if (window.isActive()) {
            result = window;
        } else {
            Window[] ownedWindows = window.getOwnedWindows();
            if (ownedWindows != null) {
                result = getSelectedWindow(ownedWindows);
            }
        }
    }
    return result;
}

    WindowAdapter windowAdapter = new WindowAdapter()
    {
        boolean closed = false;

        @Override
        public void windowClosed(WindowEvent e) {
            closed = true;
            System.out.println("windowClosed");
        }

        @Override
        public void windowClosing(WindowEvent e) {
            System.out.println("windowClosing");
        }

        @Override
        public void windowOpened(WindowEvent e) {
            System.out.println("windowOpened");
            closed = false;
        }

        @Override
        public void windowActivated(WindowEvent e) {
            System.out.println("windowActivated");

            if (closed)
                windowOpened(e);

        }
    };

    frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);