对话框分模态对话框和非模态对话框，当模态对话框显示时，主程序会暂停执行，直至莫泰对话框关闭返回后，继续执行；非模态对话框的显示不影响主程序的执行。对话框的创建,先创建一个对话框资源，并与一个类相关联。
模态对话框的创建：
CSDialog dlg;//dlg可以使局部的也可以是全局的，但是非模态的就必须是全局的
dlg.DoModule();
非模态对话框的创建：
CSDialog dlg;

dlg.Create（）；
dlg.showwindow（）；
//也可以是一个局部指针，单位指针时，要New一个对象，但是程序结束时要析构掉，也可以重载PostNcDestorpy()函数,在里面添加代码 delete this；



单击对话框上的按钮OK，对于模态和非模态对话框都会消失，但是原理不一样。对于模态，对话框类会去调用基类的CDialog::OnOK（）函数，在CDIalog::OnOK（）中调用EndDialog()函数来终止模态对话框，销毁模态对话框对象。对于非模态对话框，EndDialog()函数只是是对话框不可见（隐藏了），并未销毁。对于非模态对话框，要销毁对话框对象，必须重载基类的OnOK函数(),在其中调用DestroyWindow（），并在其后不再调用基类的OnOK函数，对于CANCEL的响应也是如此。


基本控件的应用：
获取控件对象：GetGlgItem（）；
获取文本：GetWindowText(),设置文本SetWindowText();   | GetDlgItemText()、SetDlgItemText();
禁用控件：EnableWindow（）；
显示控件：ShowWindow（）；
CStatic 控件响应鼠标单击事件的做法：修改控件ID，勾选Notify选项
CEdit控件涉及数值时，先获取字符串文本，GetWindowText(),再用atoi(),itoa()进行文本类型转换；获或者直接用GetDlgItemInt()；z再或者是绑定一个控件类型变量，用UpdateData（），更新控件上的文本信息；再或者通过发消息WM_GETTEXXT,和WM_SETTEXT，Send Message()，注意参数设置


对话框程序在显示对话框时的执行顺序：
先进入_tWinmain（），AfxWinmain( ),app类的Instance（）函数，有一个本对话框类对象时，调用构造函数，调用InitDialog()函数，在InitDialog 函数内进行初始化工作。

MFC中对话框有两种形式，一个是模态对话框（model dialog box），一个是非模态对话框（modeless dialog box）。


 一、模态对话框（model dialog box）

        在程序运行的过程中，若出现了模态对话框，那么主窗口将无法发送消息，直到模态对话框退出才可以发送。

       点击模态对话框中的OK按钮，模态对话框会被销毁。

        创建一个模态对话框的代码：

	//创建一个模态对话框
	CTestDialog td;
	td.DoModal(); 

        其中CTestDialog为我自己所新建和一个对话框资源相关联的对话框类。

        可以创建一个布局模态对话框类变量，不用担心它会随着所在函数返回而被销毁。因为DoModal()函数的一个功能是，当前只能运行此模态对话框，且停止主窗口的运行，直到模态对话框退出，才允许主窗口运行。

        DoModal()函数也有显示对话框的功能，所以也无需调用其他函数来显示对话框。

二、非模态对话框（modaless dialog box）

        在程序运行的过程中，若出现了非模态对话框，主窗口还可以发送消息。

        点击非模态对话框中的OK按钮，非模态对话框没有销毁，只是隐藏了。若想点击OK按钮时，非模态对话框也销毁，那么CTestDialog类必须重载其基类CDialog的虚函数OnOK()，在此函数里调用DestroyWindow()来销毁此对话框。

        若和上面一样的方式创建一个非模态对话框：

           CTestDialog td;
	td.Create(IDD_DIALOG1); //创建一个非模态对话框
	td.ShowWindow(SW_SHOWNORMAL); //显示非模态对话框

        那么，在运行时，你会发现此对话框无法显示。这是因为你声明的对话框变量td是局部变量，但这个函数返回时，td也被析构了，所以无法显示此对话框。

        创建非模态对话框，必须声明一个指向CTestDialog类的指针变量，且需要显示的调用ShowWindow()才能将对话框显示出来。有两种创建方法：

（1）采用局部变量创建一个非模态对话框

	//采用局部变量创建一个非模态对话框
	CTestDialog *pTD = new CTestDialog();
	pTD->Create(IDD_DIALOG1); //创建一个非模态对话框
	pTD->ShowWindow(SW_SHOWNORMAL); //显示非模态对话框

       因为指针在声明的时候是被放在堆栈中，只有整个应用程序关闭后才会被销毁，所以可以正常显示对话框。

        这种方法虽然不影响程序的运行，可是指针pTD所指向的内存却导致不可用，这样的编程很不好。

（2）采用成员变量创建一个非模态对话框

        首先在你所要编写的类的头文件中声明一个指针变量：

private:
	CTestDialog *pTD;

        然后再在相应的CPP文件，在你要创建对话框的位置添加如下代码：

	//采用成员变量创建一个非模态对话框
	pTD = new CTestDialog(); //给指针分配内存
	pTD->Create(IDD_DIALOG1); //创建一个非模态对话框
	pTD->ShowWindow(SW_SHOWNORMAL); //显示非模态对话框

        最后在所在类的析构函数中收回pTD所指向的内存：

	delete pTD;

 

本文链接: https://blog.csdn.net/xietansheng/article/details/75948933
Java Swing 图形界面开发（目录）
1. 概述
官方JavaDocsApi:
javax.swing.JDialog
javax.swing.JOptionPane
JDialog，对话框。使用 JDialog 类可以创建自定义有的对话框，或者调用 JOptionPane 中的多个静态方法快速创建各种标准的对话框。
JOptionPane是 JavaSwing 内部已实现好的，以静态方法的形式提供调用，能够快速方便的弹出要求用户提供值或向其发出通知的标准对话框。
JOptionPane 提供的 标准对话框 类型分为以下几种:

方法名
描述
showMessageDialog
消息对话框，向用户展示一个消息，没有返回值。
showConfirmDialog
确认对话框，询问一个问题是否执行。
showInputDialog
输入对话框，要求用户提供某些输入。
showOptionDialog
选项对话框，上述三项的大统一，自定义按钮文本，询问用户需要点击哪个按钮。
这些标准对话框的基本外形布局通常如下图所示:

上述四个类型的方法（包括其若干重载）的参数遵循一致的模式，下面介绍各参数的含义:
(1) parentComponent: 对话框的父级组件，决定对话框显示的位置，对话框的显示会尽量紧靠组件的中心，如果传 null，则显示在屏幕的中心。
(2) title: 对话框标题。
(3) message: 消息内容。
(4) messageType: 消息类型，主要是提供默认的对话框图标。可能的值为：
JOptionPane.PLAIN_MESSAGE 简单消息（不使用图标）
JOptionPane.INFORMATION_MESSAGE 信息消息（默认）
JOptionPane.QUESTION_MESSAGE 问题消息
JOptionPane.WARNING_MESSAGE 警告消息
JOptionPane.ERROR_MESSAGE 错误消息
(5) icon: 自定义的对话框图标，如果传 null，则图标类型由 messageType 决定。
(6) optionType: 选项按钮的类型。
(7) options、initialValue: 自定义的选项按钮（如果穿 null，则选项按钮由 optionType 决定），以及默认选中的选项按钮。
(8) selectionValues、initialSelectionValue: 提供的输入选项，以及默认选中的选项。
下面是 JOptionPane 类中各标准对话框的静态方法重载:
消息对话框:
static void showMessageDialog(Component parentComponent, 
                              Object message)
                              
static void showMessageDialog(Component parentComponent, 
                              Object message, 
                              String title, 
                              int messageType)
                              
static void showMessageDialog(Component parentComponent, 
                              Object message, 
                              String title, 
                              int messageType, 
                              Icon icon)

确认对话框:
static int showConfirmDialog(Component parentComponent, 
                             Object message)
                             
static int showConfirmDialog(Component parentComponent, 
                             Object message, 
                             String title, 
                             int optionType)
                             
static int showConfirmDialog(Component parentComponent, 
                             Object message, 
                             String title, 
                             int optionType, 
                             int messageType)

static int showConfirmDialog(Component parentComponent, 
                             Object message, 
                             String title, 
                             int optionType, 
                             int messageType, 
                             Icon icon)

输入对话框:
static String showInputDialog(Component parentComponent, 
                              Object message)

static String showInputDialog(Component parentComponent, 
                              Object message, 
                              Object initialSelectionValue)

static String showInputDialog(Component parentComponent, 
                              Object message, 
                              String title, 
                              int messageType)

static Object showInputDialog(Component parentComponent, 
                              Object message, 
                              String title, 
                              int messageType, 
                              Icon icon, 
                              Object[] selectionValues, 
                              Object initialSelectionValue)

选项对话框:
static int showOptionDialog(Component parentComponent, 
                            Object message, 
                            String title, 
                            int optionType, 
                            int messageType, 
                            Icon icon, 
                            Object[] options, 
                            Object initialValue)

2. 代码实例: 标准对话框的显示（JOptionPane）
package com.xiets.swing;

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

public class Main {

    public static void main(String[] args) throws Exception {
        final JFrame jf = new JFrame("测试窗口");
        jf.setSize(400, 400);
        jf.setLocationRelativeTo(null);
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        /*
         * 1. 消息对话框（信息消息）
         */
        JButton btn01 = new JButton("showMessageDialog（信息消息）");
        btn01.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 消息对话框无返回, 仅做通知作用
                JOptionPane.showMessageDialog(
                        jf,
                        "Hello Information Message",
                        "消息标题",
                        JOptionPane.INFORMATION_MESSAGE
                );
            }
        });

        /*
         * 2. 消息对话框（警告消息）
         */
        JButton btn02 = new JButton("showMessageDialog（警告消息）");
        btn02.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 消息对话框无返回, 仅做通知作用
                JOptionPane.showMessageDialog(
                        jf,
                        "Hello Warning Message",
                        "消息标题",
                        JOptionPane.WARNING_MESSAGE
                );
            }
        });

        /*
         * 3. 确认对话框
         */
        JButton btn03 = new JButton("showConfirmDialog");
        btn03.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                /*
                 * 返回用户点击的选项, 值为下面三者之一:
                 *     是:   JOptionPane.YES_OPTION
                 *     否:   JOptionPane.NO_OPTION
                 *     取消: JOptionPane.CANCEL_OPTION
                 *     关闭: JOptionPane.CLOSED_OPTION
                 */
                int result = JOptionPane.showConfirmDialog(
                        jf,
                        "确认删除？",
                        "提示",
                        JOptionPane.YES_NO_CANCEL_OPTION
                );
                System.out.println("选择结果: " + result);
            }
        });

        /*
         * 4. 输入对话框（文本框输入）
         */
        JButton btn04 = new JButton("showInputDialog（文本框输入）");
        btn04.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 显示输入对话框, 返回输入的内容
                String inputContent = JOptionPane.showInputDialog(
                        jf,
                        "输入你的名字:",
                        "默认内容"
                );
                System.out.println("输入的内容: " + inputContent);
            }
        });

        /*
         * 5. 输入对话框（下拉框选择）
         */
        JButton btn05 = new JButton("showInputDialog（下拉框选择）");
        btn05.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                Object[] selectionValues = new Object[]{"香蕉", "雪梨", "苹果"};

                // 显示输入对话框, 返回选择的内容, 点击取消或关闭, 则返回null
                Object inputContent = JOptionPane.showInputDialog(
                        jf,
                        "选择一项: ",
                        "标题",
                        JOptionPane.PLAIN_MESSAGE,
                        null,
                        selectionValues,
                        selectionValues[0]
                );
                System.out.println("输入的内容: " + inputContent);
            }
        });

        /*
         * 6. 选项对话框
         */
        JButton btn06 = new JButton("showOptionDialog");
        btn06.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 选项按钮
                Object[] options = new Object[]{"香蕉", "雪梨", "苹果"};

                // 显示选项对话框, 返回选择的选项索引, 点击关闭按钮返回-1
                int optionSelected = JOptionPane.showOptionDialog(
                        jf,
                        "请点击一个按钮选择一项",
                        "对话框标题",
                        JOptionPane.YES_NO_CANCEL_OPTION,
                        JOptionPane.ERROR_MESSAGE,
                        null,
                        options,    // 如果传null, 则按钮为 optionType 类型所表示的按钮（也就是确认对话框）
                        options[0]
                );

                if (optionSelected >= 0) {
                    System.out.println("点击的按钮: " + options[optionSelected]);
                }
            }
        });

        // 垂直排列按钮
        Box vBox = Box.createVerticalBox();
        vBox.add(btn01);
        vBox.add(btn02);
        vBox.add(btn03);
        vBox.add(btn04);
        vBox.add(btn05);
        vBox.add(btn06);

        JPanel panel = new JPanel();
        panel.add(vBox);

        jf.setContentPane(panel);
        jf.setVisible(true);
    }

}


3. 代码实例: 自定义对话框的显示（JDialog）
对话框 JDialog 和 JFrame 都是继承自 java.awt.Window，用法与 JFrame 类似。
对话框分为 模态 和 非模态:
模态: 弹出对话框后，对话框的父级窗口不可操作。
非模态: 弹出对话框后，对话框的父级窗口可以正常操作。
对话框不能最小化。
package com.xiets.swing;

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

public class Main {

    public static void main(String[] args) throws Exception {
        final JFrame jf = new JFrame("测试窗口");
        jf.setSize(300, 300);
        jf.setLocationRelativeTo(null);
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        JButton btn = new JButton("显示自定义对话框");
        btn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                showCustomDialog(jf, jf);
            }
        });

        JPanel panel = new JPanel();
        panel.add(btn);

        jf.setContentPane(panel);
        jf.setVisible(true);
    }

    /**
     * 显示一个自定义的对话框
     *
     * @param owner 对话框的拥有者
     * @param parentComponent 对话框的父级组件
     */
    private static void showCustomDialog(Frame owner, Component parentComponent) {
        // 创建一个模态对话框
        final JDialog dialog = new JDialog(owner, "提示", true);
        // 设置对话框的宽高
        dialog.setSize(250, 150);
        // 设置对话框大小不可改变
        dialog.setResizable(false);
        // 设置对话框相对显示的位置
        dialog.setLocationRelativeTo(parentComponent);

        // 创建一个标签显示消息内容
        JLabel messageLabel = new JLabel("对话框消息内容");

        // 创建一个按钮用于关闭对话框
        JButton okBtn = new JButton("确定");
        okBtn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 关闭对话框
                dialog.dispose();
            }
        });

        // 创建对话框的内容面板, 在面板内可以根据自己的需要添加任何组件并做任意是布局
        JPanel panel = new JPanel();

        // 添加组件到面板
        panel.add(messageLabel);
        panel.add(okBtn);

        // 设置对话框的内容面板
        dialog.setContentPane(panel);
        // 显示对话框
        dialog.setVisible(true);
    }

}

Java Swing 自定义Dialog确认对话框
Java Swing 自定义Dialog

Java Swing 自定义Dialog

需求：当点击JFrame窗口的关闭按钮时，弹框询问是否确定关闭窗口，如果是则关闭程序，否就让弹框消失什么也不做（使用Dialog）。
分析：虽然Java提供了 JOptionPane 类，用来创建标准对话框，但是此处需要使用Dialog来提供弹框。所以可以通过扩展 JDialog 类创建自定义的对话框。

实现如下：

package com.tianjh.dialog;

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

/**
 * @author tianjh
 * @date 2021/3/8
 * 当点击JFrame窗口的关闭按钮时，触发窗口监听事件
 * 弹框询问是否真的需要关闭程序
 */
public class MyDialog extends JFrame {
    JPanel jPanel;
    static final String TITLE = "提示";
    static final String CONTENT = "确定要关闭JFrame窗口吗？";

    public MyDialog() {
        jPanel = new JPanel();
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                new CustomDialog(TITLE, CONTENT).setVisible(true);
            }
        });
        JButton jButton = new JButton("点我或关闭按钮看看效果");
        jButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                new CustomDialog(TITLE, CONTENT).setVisible(true);
            }
        });
        jPanel.add(jButton,BorderLayout.CENTER);
        add(jPanel);
        setTitle("JFrame窗口");
        setSize(500, 300);
        setLocationRelativeTo(null);
        setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
        setVisible(true);
    }

    public static void main(String[] args) {
        new MyDialog();
    }

}

/**
 * 自定义Dialog对话框
 */
class CustomDialog extends JDialog implements ActionListener {
    String title;
    String content;
    String ok = "确定";
    String cancel = "取消";

    public CustomDialog(String title, String content) {
        this.title = title;
        this.content = content;
        int width = 45, height = 45;
        // 创建1个图标实例,注意image目录要与src同级
        ImageIcon icon = new ImageIcon("image//tu.png");
        icon.setImage(icon.getImage().getScaledInstance(width, height, Image.SCALE_DEFAULT));
        // 1个图片标签,显示图片
        JLabel jlImg = new JLabel(icon);
        jlImg.setSize(width, height);
        jlImg.setBounds(20, 44, width, height);
        // 1个文字标签,显示文本
        JLabel jLabel = new JLabel(content);
        jLabel.setFont(new Font("", Font.PLAIN, 14));
        // 设置文字的颜色为蓝色
        jLabel.setForeground(Color.black);
        jLabel.setBounds(75, 43, 180, 45);
        JButton okBut = new JButton(ok);
        JButton cancelBut = new JButton(cancel);
        okBut.setBackground(Color.LIGHT_GRAY);
        okBut.setBorderPainted(false);
        okBut.setBounds(65, 126, 98, 31);
        cancelBut.setBounds(175, 126, 98, 31);
        cancelBut.setBackground(Color.LIGHT_GRAY);
        cancelBut.setBorderPainted(false);
        // 给按钮添加响应事件
        okBut.addActionListener(this);
        cancelBut.addActionListener(this);
        // 向对话框中加入各组件
        add(jlImg);
        add(jLabel);
        add(okBut);
        add(cancelBut);
        // 对话框流式布局
        setLayout(null);
        // 窗口左上角的小图标
        setIconImage(icon.getImage());
        // 设置标题
        setTitle(title);
        // 设置为模态窗口,此时不能操作父窗口
        setModal(true);
        // 设置对话框大小
        setSize(300, 210);
        // 对话框局域屏幕中央
        setLocationRelativeTo(null);
        // 对话框不可缩放
        setResizable(false);
        // 点击对话框关闭按钮时,销毁对话框
        setDefaultCloseOperation(DISPOSE_ON_CLOSE);
    }

    /**
     * 当按钮被点击时会执行下面的方法
     *
     * @param e 事件
     */
    @Override
    public void actionPerformed(ActionEvent e) {
        // 判断是不是确定按钮被点击
        if (ok.equals(e.getActionCommand())) {
            // 对话框不可见
            this.setVisible(false);
            System.out.println("我退出程序了...");
            System.exit(0);
        }
        if (cancel.equals(e.getActionCommand())) {
            this.setVisible(false);
            this.dispose();
            System.out.println("我啥也没干...");
        }
    }
}


JFrame界面如下所示：


点击JFrame窗口中的按钮或者关闭按钮即可触发确认对话框，点击之后的结果如下：


如果点击确定，则退出该程序，否则退回到Jframe窗口撒事也不干，视频演示如下：


                        
                        
Java Swing 自定义Dialog弹框演示