java自定义对话框弹出
 
 
 
本次实习因为写java界面，有一个自定义对话框的需求，在网上查了一些才发现了一种方法，所以记录一下。具体需求类似于这样：按下一个按钮弹出一个输入界面，输入行李的长宽高，然后进行显示。需求很简单，最重要的是信息在两个界面之间传递。
 
 
具体实现
 
具体实现只讲比较重要的一些部分
 
编写界面继承自JDialog
 
public class BaggageGUI extends JDialog  implements ActionListener{


    JTextField LengthField = new JTextField();    //长
    JTextField WidthField = new JTextField();    //宽
    JTextField HeighField = new JTextField();    //高
    JTextField WeightField = new JTextField();    //重
    JButton  addbtu =new JButton("确定添加");
	
    public Baggage getBaggage() {
        return baggage;
    }

    Baggage baggage;	//自定义的一个类，里面有长宽高重这四个字段
    public BaggageGUI()  {

        this.setTitle("普通行李");
        this.setSize(400, 250);
        init();
        this.setLayout(null);
//        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
//        this.setVisible(true);
    }

    private void init()
    {
        JLabel jl1 = new JLabel("长:");//jl1.setOpaque(true);jl1.setBackground(Color.GREEN);
        JLabel jl2 = new JLabel("宽:");
        JLabel jl3 = new JLabel("高:");
        JLabel jl4 = new JLabel("重:");
        jl1.setBounds(10, 10, 50, 25);LengthField.setBounds(100,10,200,30);
        jl2.setBounds(10, 50, 50, 25);WidthField.setBounds(100,50,200,30);
        jl3.setBounds(10, 90, 50, 25);HeighField.setBounds(100,90,200,30);
        jl4.setBounds(10, 130, 50, 25);WeightField.setBounds(100,130,200,30);
        addbtu.setBounds(50, 170, 300, 30);
        this.add(jl1);
        this.add(jl2);
        this.add(jl3);
        this.add(jl4);
        this.add(LengthField);
        this.add(WidthField);
        this.add(HeighField);
        this.add(WeightField);
        this.add(addbtu);

        addbtu.addActionListener(this);
    }

    public void actionPerformed(ActionEvent e) {
        float length = Float.valueOf(LengthField.getText());
        float width = Float.valueOf(WidthField.getText());
        float heigh = Float.valueOf(HeighField.getText());
        float weight = Float.valueOf(WeightField.getText());
        baggage = new Baggage(width, heigh,length , weight);
        System.out.println(baggage);
        this.setVisible(false);

    }
}

 
在主界面当中创建该界面的引用，并设置setModal()函数
 
如：我的主界面是CalculatorGUI,在CalculatorGUI当中我设置一个BaggageGUI的引用，说是子窗口也行。
 
 BaggageGUI baggageGUI = new BaggageGUI();
 
然后在构造CalculatorGUI的时候调用baggageGUI的setModal()函数
 
baggageGUI.setVisible(true);
 
该函数的作用为设置对话框为模态，模态对话框，关闭当前对话框前，无法操作其他窗口，这样可以阻塞主对话框，让我在对baggageGUI输入后，再变成运行状态，然后可以顺利取得我设置的行李。
 
在按钮按下事件当中调用baggageGUI,让其显示
 
 addBagBut.addActionListener(new ActionListener(){

            public void actionPerformed(ActionEvent e) {
                baggageGUI.setVisible(true);

                Baggage baggage = baggageGUI.getBaggage();

                bagInfo.append(baggage.toString());
            }
        });
 
显示效果
 
主界面：
 
 
BaggageGUI界面：
 
 
按下“确定添加”之后：
 
 
补充java的对话框使用
 
这部分是转载别人的博客，原博客这里
 
showMessageDialog(只显示一个确定按钮的对话框)
 
普通对话框Java代码
 
JOptionPane.showMessageDialog(null, "普通对话框");
 
 
警告提示框Java代码
 
JOptionPane.showMessageDialog(null, "警告提示框", "Title",JOptionPane.WARNING_MESSAGE);
 
 
错误提示框Java代码
 
JOptionPane.showMessageDialog(null, "错误提示框", "Title",JOptionPane.ERROR_MESSAGE);
 
 
基本提示框java代码
 
JOptionPane.showMessageDialog(null, "最基本提示框", "Title",JOptionPane.PLAIN_MESSAGE);
 
 
showConfirmDialog（确认对话框，对话框的按钮通常为：“是”、“否”、“取消”和“确认”及其组合）。
 
“是” “否”对话框Java代码
 
int n = JOptionPane.showConfirmDialog(null, "你是否喜欢Java？", "Title",JOptionPane.YES_NO_OPTION); 
 
 
showOptionDialog(自定义选择提示对话框)
 
Object[] options ={ "喜欢", "不喜欢" };  //自定义按钮上的文字
int m = JOptionPane.showOptionDialog(null, "你喜欢这篇博客吗？", "Title",JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, options, options[0]); 
 
 
showInputDialog（下拉框或者输入框）
 
下拉框Java代码
 
Object[] options ={ "苹果", "橘子", "香蕉" };  
String s = (String) JOptionPane.showInputDialog(null,"请选择你喜欢吃的水果:\n", "水果", JOptionPane.PLAIN_MESSAGE, new ImageIcon("xx.png"), options, "xx");
 
 
输入框Java代码
 
JOptionPane.showInputDialog(null," Please input：\n","title",JOptionPane.PLAIN_MESSAGE);
 
 
总结
 
写了一下java对话框相关的内容，用java写界面其实用的不多，但是有备无患记录一下。
 
转载：https://blog.csdn.net/qs17809259715/article/details/88062414
 
参考：https://blog.csdn.net/ayangann915/article/details/80410788

 
 
package main;

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;

import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;

public class Test extends JFrame implements ActionListener
{

    private static final long serialVersionUID = 1L;

    JButton btn = null;

    JTextField textField = null;

    public Test()
    {
        this.setTitle("选择文件窗口");
        FlowLayout layout = new FlowLayout();// 布局
        JLabel label = new JLabel("请选择文件：");// 标签
        textField = new JTextField(30);// 文本域
        btn = new JButton("浏览");// 钮1

        // 设置布局
        layout.setAlignment(FlowLayout.LEFT);// 左对齐
        this.setLayout(layout);
        this.setBounds(400, 200, 600, 70);
        this.setVisible(true);
        this.setResizable(false);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        btn.addActionListener(this);
        this.add(label);
        this.add(textField);
        this.add(btn);

    }

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

    @Override
    public void actionPerformed(ActionEvent e)
    {
        JFileChooser chooser = new JFileChooser();
        chooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
        chooser.showDialog(new JLabel(), "选择");
        File file = chooser.getSelectedFile();
        textField.setText(file.getAbsoluteFile().toString());
    }
}
 
 
 
 
 
 
 
 
 
 

本文链接: https://blog.csdn.net/xietansheng/article/details/72814492
 
0. JavaSwing 简介
 
Java Swing 图形界面开发简介
 
1. JavaSwing 布局管理器
 
JavaSwing_1.1: FlowLayout（流式布局）
JavaSwing_1.2: GridLayout（网格布局）
JavaSwing_1.3: GridBagLayout（网格袋布局）
JavaSwing_1.4: BoxLayout（箱式布局）
JavaSwing_1.5: GroupLayout（分组布局）
JavaSwing_1.6: CardLayout（卡片布局）
JavaSwing_1.7: BorderLayout（边界布局）
JavaSwing_1.8: SpringLayout（弹性布局）
JavaSwing_1.9: null（绝对布局）
 
2. JavaSwing 基本组件
 
JavaSwing_2.1: JLabel（标签）
JavaSwing_2.2: JButton（按钮）
JavaSwing_2.3: JRadioButton（单选按钮）
JavaSwing_2.4: JCheckBox（复选框）
JavaSwing_2.5: JToggleButton（开关按钮）
JavaSwing_2.6: JTextField（文本框）
JavaSwing_2.7: JPasswordField（密码框）
JavaSwing_2.8: JTextArea（文本区域）
JavaSwing_2.9: JComboBox（下拉列表框）
JavaSwing_2.10: JList（列表框）
JavaSwing_2.11: JProgressBar（进度条）
JavaSwing_2.12: JSlider（滑块）
 
3. JavaSwing 面板组件
 
JavaSwing_3.1: JPanel（面板）
JavaSwing_3.2: JScrollPane（滚动面板）
JavaSwing_3.3: JSplitPane（分隔面板）
JavaSwing_3.4: JTabbedPane（选项卡面板）
JavaSwing_3.5: JLayeredPane（层级面板）
 
4. JavaSwing 其他组件
 
JavaSwing_4.1: JFrame（窗口）
JavaSwing_4.2: JDialog、JOptionPane（对话框）
JavaSwing_4.3: JFileChooser（文件选择器）
JavaSwing_4.4: JColorChooser（颜色选择器）
JavaSwing_4.5: JMenuBar（菜单栏）
JavaSwing_4.6: JToolBar（工具栏）
JavaSwing_4.7: JPopupMenu（弹出菜单）
JavaSwing_4.8: JTable（表格）
JavaSwing_4.9: JTree（树）
JavaSwing_4.10: JInternalFrame（内部窗口）
 
5. JavaSwing 相关特性
 
JavaSwing_5.1: 组件的位置和尺寸
JavaSwing_5.2: 组件边框（Border）
JavaSwing_5.3: 事件处理
JavaSwing_5.4: 多线程并发与线程安全
JavaSwing_5.5: 拖拽功能
JavaSwing_5.6: 系统托盘（System Tray）
JavaSwing_5.7: 闪屏（Splash Screen）
 
扩展：Java AWT/Swing 其他相关
 
Java绘图: 使用Graphics类绘制线段、矩形、椭圆/圆弧/扇形、图片、文本
Java图片操作 — 图片的读取、绘制、缩放、裁剪、保存
Java代码截屏：使用 Java 代码截取电脑屏幕并保存
Java模拟鼠标键盘输入事件 — Robot 类
Java操作桌面应用 — Desktop 类
Java操作系统剪贴板(Clipboard)实现复制和粘贴
 

本文链接: http://blog.csdn.net/xietansheng/article/details/72814531
 
Java Swing GUI 图形界面窗口开发基础教程，本教程将系统性地详细介绍 Java Swing 开发中常用的一些组件、布局管理器等相关知识技术，并且每章节都将通过代码实例展示实际应用。
 
教程总目录: Java Swing 图形界面开发（目录）
 
1. Swing简介
 
Swing 是 Java 为图形界面应用开发提供的一组工具包，是 Java 基础类的一部分。
 
Swing 包含了构建图形界面（GUI）的各种组件，如: 窗口、标签、按钮、文本框等。
 
Swing 提供了许多比 AWT 更好的屏幕显示元素，使用纯 Java 实现，能够更好的兼容跨平台运行。
 
为了和 AWT 组件区分，Swing 组件在javax.swing.*包下，类名均以 J 开头，例如: JFrame、JLabel、JButton等。
 
2. Swing组件
 
一个 Java 的图形界面，由各种不同类型的“元素”组成，例如: 窗口、菜单栏、对话框、标签、按钮、文本框等等，这些“元素”统一被称为 组件（Component）。
 
组件按照不同的功能，可分为 顶层容器、中间容器、基本组件。一个简单窗口的组成，如下层级结构所示:
 
顶层容器 
  
菜单栏
中间容器 
    
基本组件
基本组件
 
 
 
组件类型的继承关系:
 
顶层容器 属于窗口类组件，继承自java.awt.Window；
中间容器 和 基本组件 继承自javax.swing.JComponent。
 
2.1 顶层容器
 
顶层容器属于窗口类组件，可以独立显示，一个图形界面至少需要一个窗口，例如:
 
#
组件
描述
1
JFrame
一个普通的窗口（绝大多数 Swing 图形界面程序使用 JFrame 作为顶层容器）
2
JDialog
对话框
2.2 中间容器
 
中间容器充当基本组件的载体，不可独立显示。中间容器可以添加若干基本组件（也可以嵌套添加中间容器），对容器内的组件进行管理，类似于给各种复杂的组件进行分组管理。最顶层的一个中间容器必须依托在顶层容器（窗口）内。
 
常用的中间容器（面板）:
 
#
组件
描述
1
JPanel
一般轻量级面板容器组件
2
JScrollPane
带滚动条的，可以水平和垂直滚动的面板组件
3
JSplitPane
分隔面板
4
JTabbedPane
选项卡面板
5
JLayeredPane
层级面板
特殊的中间容器:
 
#
组件
描述
1
JMenuBar
菜单栏
2
JToolBar
工具栏
3
JPopupMenu
弹出菜单
4
JInternalFrame
内部窗口
2.3 基本组件
 
基本组件是直接实现人机交互的组件。
 
常用的简单的基本组件:
 
#
组件
描述
1
JLabel
标签
2
JButton
按钮
3
JRadioButton
单选按钮
4
JCheckBox
复选框
5
JToggleButton
开关按钮
6
JTextField
文本框
7
JPasswordField
密码框
8
JTextArea
文本区域
9
JComboBox
下拉列表框
10
JList
列表
11
JProgressBar
进度条
12
JSlider
滑块
选取器组件:
 
#
组件
描述
1
JFileChooser
文件选取器
2
JColorChooser
颜色选取器
其他较为复杂的基本组件:
 
#
组件
描述
1
JTable
表格
2
JTree
树
3. 布局管理器
 
把 Swing 的各种组件(JComponent)添加到面板容器中(JPanel)，需要给面板容器指定布局管理器(LayoutManager)，明确容器(Container)内的各个组件之间的排列布局方式。
 
常用的布局管理器:
 
#
布局管理器
描述
1
FlowLayout
流式布局，按组件加入的顺序，按水平方向排列，排满一行换下一行继续排列。
2
GridLayout
网格布局，把Container按指定行列数分隔出若干网格，每一个网格按顺序放置一个控件。
3
GridBagLayout
网格袋布局，按网格划分Container，每个组件可占用一个或多个网格，可将组件垂直、水平或沿它们的基线对齐。
4
BoxLayout
箱式布局，将Container中的多个组件按 水平 或 垂直 的方式排列。
5
GroupLayout
分组布局，将组件按层次分组（串行 或 并行），分别确定 组件组 在 水平 和 垂直 方向上的位置。
6
CardLayout
卡片布局，将Container中的每个组件看作一张卡片，一次只能显示一张卡片，默认显示第一张卡片。
7
BorderLayout
边界布局，把Container按方位分为 5 个区域（东、西、南、北、中），每个区域放置一个组件。
8
SpringLayout
弹性布局，通过定义组件四条边的坐标位置来实现布局。
9
null
绝对布局，通过设置组件在Container中的坐标位置来放置组件。
4. 代码实例: 一个简单的窗口程序
 
package com.xiets.swing;

import javax.swing.*;

public class Main {

    public static void main(String[] args) {
        // 1. 创建一个顶层容器（窗口）
        JFrame jf = new JFrame("测试窗口");          // 创建窗口
        jf.setSize(250, 250);                       // 设置窗口大小
        jf.setLocationRelativeTo(null);             // 把窗口位置设置到屏幕中心
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); // 当点击窗口的关闭按钮时退出程序（没有这一句，程序不会退出）

        // 2. 创建中间容器（面板容器）
        JPanel panel = new JPanel();                // 创建面板容器，使用默认的布局管理器

        // 3. 创建一个基本组件（按钮），并添加到 面板容器 中
        JButton btn = new JButton("测试按钮");
        panel.add(btn);

        // 4. 把 面板容器 作为窗口的内容面板 设置到 窗口
        jf.setContentPane(panel);

        // 5. 显示窗口，前面创建的信息都在内存中，通过 jf.setVisible(true) 把内存中的窗口显示在屏幕上。
        jf.setVisible(true);
    }

}
 
结果展示: