图形用户界面GUI(一）

图形化编程简介

通常情况下java是一般在后台进行开发服务端程序的，事实上也可以通过我们所写的代码，在图形化界面上看到。

GUI是一种人机交互方式，通过为用户呈现图形界面，用户操作界面图标。Java提供了一系列的类和接口来帮助用户实现图形用户界面，包含AWT组件和Swing组件，容器，布局和事件相关的类和接口。

菜单，按钮等各种组件一般作为对象放置在Applet，panel(面板），Frame(窗口）等容器中。用户在窗口内选择菜单和按键的时候触发相关的事件。因此，组件，事件，面板构成了编写界面的相关元素。

AWT组件

Abstract Window Toolkit抽象窗口工具集，是java为应用程序提供的一套图形组件。
（1）AWT是窗口框架，可以从不同平台的窗口抽取出共同的组件。当程序运行的时候，将这些组件的创建和动作委托给程序所在的运行平台。
（2）使用AWT编写图形界面应用的时候，程序仅指定界面组件的位置和行为，并未提供真正的实现。JVM调用操作系统本地的图形界面来创建和平台一致的对等体。
（3）使用AWT创建的图形界面应用和所在运行的平台有极大的相关性。使用windows表现出相应的windows风格，使用unix表现出相应的unix风格。

AWT继承体系

基类

AWT编程中有俩个基类Component和MenuComponent.

• Component:代表一个能以图形化方式显示出来与用户交互的对象。Button代表一个按钮，TextField代表一个文本框。
• MenuComponent:代表图形界面的菜单组件，包括MenuBar(菜单条），MenuItem(菜单项）等子类
• Container是一种特殊的Component,代表一种容器，可以承装普通的Component
  

接口

AWT还有一个接口：LayoutManager，如果一个容器中有多个组件，那么这个容器就需要使用LayoutManager来管理这些组件的布局方式。

Container容器

Component作为基类，提供以下方法设置组件的大小，位置，可见性。
Container作为容器根类，提供一下方法访问容器中的组件：

• Window是可以独立存在的顶级窗口，默认使用BorderLayout管理其内部组件布局
• Panel可以容纳其他组件，不能独立存在。它必须内部嵌套其他容器中使用，
• ScrollPane是一个带滚动条的容器，它也不能独立存在，默认使用BorderLayout管理其内部的组件布局。

import java.awt.*;
public class FrameDemo {
    
    
    public static void main(String[] args) {
    
    
        //1.创建窗口对象
        Frame frame = new Frame("这是第一个窗口容器");
        //设置窗口的位置和大小
        //frame.setLocation(100,100);
        //frame.setSize(500,300);
        //同时设置位置和大小
        frame.setBounds(100,100,500,300);
        //设置窗口可见
        frame.setVisible(true);
    }
}


public class PanelDemo {
    
    
    public static void main(String[] args) {
    
    
        //1.创建Frame容器对象
        Frame frame = new Frame("这里在测试Panel");
        //2.创建Panel容器对象
        Panel panel = new Panel();
        //3.往Panel容器中添加组件
        panel.add(new TextField("这是一个测试文本"));
        panel.add(new Button("这是一个测试按钮"));
        //4.把Panel添加到Frame中
        frame.add(panel);
        //5.设置Frame的位置和大小
        frame.setBounds(30,30,500,300);
        //6.设置Frame可见
        frame.setVisible(true);
    }
}

import java.awt.*;
public class ScrollPaneDemo {
    
    
    public static void main(String[] args) {
    
    
        //1.创建Frame窗口对象
        Frame frame = new Frame("这里测试ScrollPane");
        //2.创建ScrollPane对象，并且指定默认有滚动条
        ScrollPane scrollPane = new ScrollPane(ScrollPane.SCROLLBARS_ALWAYS);
        //3.往ScrollPane中添加组件
        scrollPane.add(new TextField("这是测试文本"));
        scrollPane.add(new Button("这是测试按钮"));
        //4.把ScrollPane添加到Frame中
        frame.add(scrollPane);
        //5.设置Frame的位置及大小
        frame.setBounds(30,30,500,300);
        //6.设置Frame可见
        frame.setVisible(true);
    }
}

注意点：
（1）我们执行的代码时在windows系统上运行的，默认编码gbk.如果出现乱码，只需要在运行当前代码前，设置一个jvm参数-Dfile.encoding=gbk即可。或者将button写成JButton

（2）向 ScrollPane 容器中添加了 一个文本框和一个按钮，但只能看到 一个按钮，却看不到文本框 ，这是因为ScrollPane 使用 BorderLayout 布局管理器的缘故，而 BorderLayout 导致了该容器中只有一个组件被显示出来 。

LayoutManager布局管理器

我们提到setBounds()可以设置当前容器的位置和大小，但是我们手动设置位置和大小的话，可能会造成程序的不通用性。

Lable lable=new Lable("你好，世界");

(1)很多情况下，我们无法让lable组件的宽高和“你好，世界”字符串本身的宽高一致，变成最佳大小。由于操作系统的差异，我们需要设置不同的宽高才可以达到相同的效果。

（2）Java提供LayoutManager布局管理器，可以根据运行平台来自动调整组件的大小，程序员不用再手动设置组件的大小和位置，只需要为容器选择合适的布局管理器即可。

FlowLayout

在 FlowLayout 布局管理器中，组件像水流一样向某方向流动 (排列) ，遇到障碍(边界)就折回，重头开始排列 。FlowLayout 布局管理器从左向右排列所有组件，遇到边界就会折回下一行重新开始。
(1)FlowLayout 中组件的排列方向(从左向右、从右向左、从中间向两边等) ， 该参数应该使用FlowLayout类的静态常量 : FlowLayout. LEFT 、 FlowLayout. CENTER 、 FlowLayout. RIGHT ，默认是左对齐。

(2)FlowLayout中组件中间距通过参数设置，单位是像素，默认5像素。

import java.awt.*;
public class FlowLayoutDemo {
    
    
    public static void main(String[] args) {
    
    
    
        //1.创建Frame对象
        Frame frame = new Frame("这里测试FlowLayout");
        //2.修改Frame容器的布局管理器为FlowLayout
        frame.setLayout(new FlowLayout(FlowLayout.LEFT,20,20));
        //3.往Frame中添加100个button
        for (int i = 0; i < 100; i++) {
    
    
            frame.add(new Button("按钮"+i));
        }
        //4.设置Frame为最佳大小
        frame.pack();
        //5.设置Frame可见
        frame.setVisible(true);
    }
}

BorderLayout

BorderLayout 将容器分为 EAST 、 SOUTH 、 WEST 、 NORTH 、 CENTER五个区域，普通组件可以被放置在这 5 个区域的任意一个中 。
(1)当改变BorderLayout的容器大小的时候，NORTH，SOUTH和CENTER区域水平调整，而EAST，CENTER，WEST区域竖直调整。

（2）当向使用 BorderLayout 布局管理器的容器中添加组件时 ， 需要指定要添加到哪个区域中 。 如果没有指定添加到哪个区域中，则默认添加到中间区域中。

（3）如果向同一个区域中添加多个组件时 ， 后放入的组件会覆盖先放入的组件。

public class BorderLayoutDemo1 {
    
    

    public static void main(String[] args) {
    
    
        //1.创建Frame对象
        Frame frame = new Frame("这里测试BorderLayout");
        //2.指定Frame对象的布局管理器为BorderLayout
        frame.setLayout(new BorderLayout(30,5));
        //3.往Frame指定东南西北中各添加一个按钮组件
        frame.add(new Button("东侧按钮"), BorderLayout.EAST);
        frame.add(new Button("西侧按钮"), BorderLayout.WEST);
        frame.add(new Button("南侧按钮"), BorderLayout.SOUTH);
        frame.add(new Button("北侧按钮"), BorderLayout.NORTH);
        frame.add(new Button("中间按钮"), BorderLayout.CENTER);
        //4.设置Frame为最佳大小
        frame.pack();
        //5.设置Frame可见
        frame.setVisible(true);
    }
}

如果不往某个区域放入组件，那么该区域不会空白出来，而是被其他区域占用。

import java.awt.*;
public class BorderLayoutDemo2 {
    
    
    public static void main(String[] args) {
    
    
        //1.创建Frame对象
        Frame frame = new Frame("这里测试BorderLayout");
        //2.指定Frame对象的布局管理器为BorderLayout
        frame.setLayout(new BorderLayout(30,5));
        //3.往Frame指定南，北，放入一个按钮，往中间区域放入一个Panel

        frame.add(new Button("南侧按钮"), BorderLayout.SOUTH);
        frame.add(new Button("北侧按钮"), BorderLayout.NORTH);

        Panel panel = new Panel();
        panel.add(new TextField("测试文本"));
        panel.add(new Button("中间按钮"));

        frame.add(panel, BorderLayout.CENTER);
	
        //4.设置Frame为最佳大小
        frame.pack();
        //5.设置Frame可见
        frame.setVisible(true);
    }
}

GridLayout

GridLayout 布局管理器将容器分割成纵横线分隔的网格 ， 每个网格所占的区域大小相同。当向使用 GridLayout 布局管理器的容器中添加组件时， 默认从左向右、 从上向下依次添加到每个网格中 。 与FlowLayout不同的是，放置在 GridLayout 布局管理器中的各组件的大小由组件所处的区域决定(每个组件将自动占满整个区域) 。

计算器的制作：

public class jisuanji {
    
    
    public static void main(String[] args) {
    
    
        Frame frame=new Frame("计算机");
        //创建Panel对象存放TestField组件
        Panel pannl=new Panel();
        pannl.add(new TextField(30));
        //把当前的Panel添加到frame的北边区域
        frame.add(pannl,BorderLayout.NORTH);
        //创建一个对象设置GirdLayout
        Panel p2=new Panel();
        p2.setLayout(new GridLayout(3,5,4,4));
        for (int i = 0; i < 10; i++) {
    
    
            p2.add(new Button(i+""));
        }
        p2.add(new Button("+"));
        p2.add(new Button("-"));
        p2.add(new Button("*"));
        p2.add(new Button("/"));
        p2.add(new Button("."));
        //6.把上述Panel添加到Frame的中间区域中国
        frame.add(p2);
        //7.设置Frame为最佳大小
        frame.pack();

        //8.设置Frame可见
        frame.setVisible(true);
    }
}

GridBagLayout

(1)一个组件可以跨越一个或多个网格 ， 并可以设置各网格的大小互不相同，从而增加了布局的灵活性 。
(2)当窗口的大小发生变化时 , GridBagLayout 布局管理器也可以准确地控制窗口各部分的拉伸 。
(3)在GridBagLayout 布局中，每个组件可以占用多个网格，此时，我们往容器中添加组件的时候，就需要具体的控制每个组件占用多少个网格

//1.创建GridBagLaout布局管理器对象，并给容器设置该布局管理器对象；
//2.创建GridBagConstraints对象，并设置该对象的控制属性：
	//gridx: 用于指定组件在网格中所处的横向索引；
	//gridy: 用于执行组件在网格中所处的纵向索引；
	//gridwidth: 用于指定组件横向跨越多少个网格；
	//gridheight: 用于指定组件纵向跨越多少个网格；
//3.调用GridBagLayout对象的setConstraints(Component c,GridBagConstraints gbc )方法，把即将要添加到容器中的组件c和GridBagConstraints对象关联起来；
//4. 把组件添加到容器中；
public class GridBagLayoutDemo {
    
    

    public static void main(String[] args) {
    
    
        //1.创建Frame对象
        Frame frame = new Frame("这里是GridBagLayout测试");

        //2.创建GridBagLayout对象
        GridBagLayout gbl = new GridBagLayout();

        //3.把Frame对象的布局管理器设置为GridBagLayout
        frame.setLayout(gbl);

        //4.创建GridBagConstraints对象
        GridBagConstraints gbc = new GridBagConstraints();

        //5.创建容量为10的Button数组
        Button[] bs = new Button[10];

        //6.遍历数组，初始化每一个Button
        for (int i = 0; i < bs.length; i++) {
    
    
            bs[i] = new Button("按钮"+(i+1));
        }

        //7.设置所有的GridBagConstraints对象的fill属性为GridBagConstraints.BOTH,当有空白区域时，组件自动扩大占满空白区域
        gbc.fill=GridBagConstraints.BOTH;

        //8.设置GridBagConstraints对象的weightx设置为1,表示横向扩展比例为1
        gbc.weightx=1;

        //9.往frame中添加数组中的前3个Button
        addComponent(frame,bs[0],gbl,gbc);
        addComponent(frame,bs[1],gbl,gbc);
        addComponent(frame,bs[2],gbl,gbc);

        //10.把GridBagConstraints的gridwidth设置为GridBagConstraints.REMAINDER,则表明当前组件是横向最后一个组件
        gbc.gridwidth=GridBagConstraints.REMAINDER;

        //11.把button数组中第四个按钮添加到frame中
        addComponent(frame,bs[3],gbl,gbc);


        //12.把GridBagConstraints的weighty设置为1，表示纵向扩展比例为1
        gbc.weighty=1;

        //13.把button数组中第5个按钮添加到frame中
        addComponent(frame,bs[4],gbl,gbc);

        //14.把GridBagConstaints的gridheight和gridwidth设置为2，表示纵向和横向会占用两个网格
        gbc.gridheight=2;
        gbc.gridwidth=2;

        //15.把button数组中第6个按钮添加到frame中
        addComponent(frame,bs[5],gbl,gbc);

        //16.把GridBagConstaints的gridheight和gridwidth设置为1，表示纵向会占用1个网格
        gbc.gridwidth=1;
        gbc.gridheight=1;
        //17.把button数组中第7个按钮添加到frame中
        addComponent(frame,bs[6],gbl,gbc);

        //18.把GridBagConstraints的gridwidth设置为GridBagConstraints.REMAINDER,则表明当前组件是横向最后一个组件
        gbc.gridwidth=GridBagConstraints.REMAINDER;

        //19.把button数组中第8个按钮添加到frame中
        addComponent(frame,bs[7],gbl,gbc);

        //20.把GridBagConstaints的gridwidth设置为1，表示纵向会占用1个网格
        gbc.gridwidth=1;

        //21.把button数组中第9、10个按钮添加到frame中
        addComponent(frame,bs[8],gbl,gbc);
        addComponent(frame,bs[9],gbl,gbc);

        //22.设置frame为最佳大小
        frame.pack();

        //23.设置frame可见
        frame.setVisible(true);
    }

    public static void addComponent(Container container,Component c,GridBagLayout gridBagLayout,GridBagConstraints gridBagConstraints){
    
    
        gridBagLayout.setConstraints(c,gridBagConstraints);
        container.add(c);
    }
}

CardLayout

它以时间而非空间来管理它里面的组件，它将加入容器的所有组件看成一叠卡片（每个卡片其实就是一个组件），每次只有最上面的那个 Component 才可见。就好像一副扑克牌，它们叠在一起，每次只有最上面的一张扑克牌才可见.

public class code11 {
    
    
    public static void main(String[] args) {
    
    
        Frame frame=new Frame("zhe");
        //创建panel,存储多张卡片
        Panel panel=new Panel();
        //创建一个String数组，存储不同卡片的名字
        String[] names = {
    
    "第一张","第二张","第三张","第四张","第五张"};
        //给之前创建的容器设置为CardLayout对象
        CardLayout cardLayout=new CardLayout();
        panel.setLayout(cardLayout);
        for (int i = 0; i < 5; i++) {
    
    
            panel.add(names[i],new JButton(names[i]));
        }
        //创建panel容器存储5个按钮，完成卡片切换
        Panel p2=new Panel();

        //6.创建5个按钮，并给按钮设置监听器,监听按钮的点击动作
        ActionListener listener = new ActionListener() {
    
    
            @Override
            public void actionPerformed(ActionEvent e) {
    
    
                String command = e.getActionCommand();
                //这个字符串就是按钮上的文字
                switch (command){
    
    
                    case "上一张":
                        cardLayout.previous(panel);
                        break;
                    case "下一张":
                        cardLayout.next(panel);
                        break;
                    case "第一张":
                        cardLayout.first(panel);
                        break;
                    case "最后一张":
                        cardLayout.last(panel);
                        break;
                    case "第三张":
                        cardLayout.show(panel,"第三张");
                        break;
                }
            }
        };
        Button b1 = new Button("上一张");
        Button b2 = new Button("下一张");
        Button b3 = new Button("第一张");
        Button b4 = new Button("最后一张");
        Button b5 = new Button("第三张");
        b1.addActionListener(listener);
        b2.addActionListener(listener);
        b3.addActionListener(listener);
        b4.addActionListener(listener);
        b5.addActionListener(listener);
        //把监听器和按钮进行绑定

        //7.把5个按钮添加到p2中
        p2.add(b1);
        p2.add(b2);
        p2.add(b3);
        p2.add(b4);
        p2.add(b5);


        //8.把p1添加到frame的中间区域
        frame.add(panel);


        //9.把p2添加到frame的底部区域
        frame.add(p2,BorderLayout.SOUTH);

        //10设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
}

BoxLayout

BoxLayout 可以在垂直和水平两个方向上摆放 GUI 组件。
（一）案例：

import javax.swing.*;
import java.awt.*;
public class BoxLayoutDemo1 {
    
    
    public static void main(String[] args) {
    
    
        //1.创建Frame对象
        Frame frame = new Frame("这里测试BoxLayout");
        //2.创建BoxLayout布局管理器，并指定容器为上面的frame对象，指定组件排列方向为纵向
        BoxLayout boxLayout = new BoxLayout(frame, BoxLayout.Y_AXIS);
        frame.setLayout(boxLayout);

        //3.往frame对象中添加两个按钮
        frame.add(new Button("按钮1"));
        frame.add(new Button("按钮2"));


        //4.设置frame最佳大小，并可见
        frame.pack();
        frame.setVisible(true);
    }
}

（二）：
在java.swing包中，提供了一个新的容器Box，该容器的默认布局管理器就是BoxLayout,大多数情况下，使用Box容器去容纳多个GUI组件，然后再把Box容器作为一个组件，添加到其他的容器中，从而形成整体窗口布局。

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

public class BoxLayoutDemo2 {
    
    

    public static void main(String[] args) {
    
    

        //1.创建Frame对象
        Frame frame = new Frame("这里测试BoxLayout");

        //2.创建一个横向的Box,并添加两个按钮
        Box hBox = Box.createHorizontalBox();
        hBox.add(new Button("水平按钮一"));
        hBox.add(new Button("水平按钮二"));

        //3.创建一个纵向的Box，并添加两个按钮
        Box vBox = Box.createVerticalBox();
        vBox.add(new Button("垂直按钮一"));
        vBox.add(new Button("垂直按钮二"));

        //4.把box容器添加到frame容器中
        frame.add(hBox,BorderLayout.NORTH);
        frame.add(vBox);


        //5.设置frame最佳大小并可见

        frame.pack();
        frame.setVisible(true);

    }
}

（三）
在原有的组件需要间隔的地方，添加间隔即可，而每个间隔可以是一个组件，只不过该组件没有内容，仅仅起到一种分隔的作用。

public class BoxLayoutDemo3 {
    
    
    public static void main(String[] args) {
    
    
        //1.创建Frame对象
        Frame frame = new Frame("这里测试BoxLayout");

        //2.创建一个横向的Box,并添加两个按钮
        Box hBox = Box.createHorizontalBox();
        hBox.add(new Button("水平按钮一"));
        hBox.add(Box.createHorizontalGlue());//两个方向都可以拉伸的间隔
        hBox.add(new Button("水平按钮二"));
        hBox.add(Box.createHorizontalStrut(10));//水平间隔固定，垂直间方向可以拉伸
        hBox.add(new Button("水平按钮3"));



        //3.创建一个纵向的Box，并添加两个按钮
        Box vBox = Box.createVerticalBox();
        vBox.add(new Button("垂直按钮一"));
        vBox.add(Box.createVerticalGlue());//两个方向都可以拉伸的间隔
        vBox.add(new Button("垂直按钮二"));
        vBox.add(Box.createVerticalStrut(10));//垂直间隔固定，水平方向可以拉伸
        vBox.add(new Button("垂直按钮三"));


        //4.把box容器添加到frame容器中
        frame.add(hBox, BorderLayout.NORTH);
        frame.add(vBox);


        //5.设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
}

基本组件

实现下图：

public class Basic {
    
    
    Frame frame=new Frame();
    JButton ok=new JButton("确认");
    //定义一个5行，20列的多行文本域
    TextArea ta = new TextArea(5, 20);
    //定义一个50列的单行文本域
    TextField tf = new TextField(50);
    //定义复选框
    CheckboxGroup cbg=new CheckboxGroup();
    Checkbox male=new Checkbox("男",cbg,true);
    Checkbox female = new Checkbox("女", cbg, false);
    Checkbox married = new Checkbox("是否已婚？", false);
    //定义一个下拉选择框
    Choice colorChooser = new Choice();
    //定义一个列表选择框
    List colorList = new List(6, true);


    public  void init(){
    
    
        //底部区域
       Box bBox=Box.createHorizontalBox();
       bBox.add(tf);
       bBox.add(ok);
       frame.add(bBox,BorderLayout.SOUTH);
     //组装，选择区域
        colorChooser.add("红色");
        colorChooser.add("绿色");
        colorChooser.add("蓝色");
        Box cbox=Box.createHorizontalBox();
        cbox.add(colorChooser);
        cbox.add(male);
        cbox.add(female);
        cbox.add(married);
        //组装文本域和选择部分
        Box topLeft = Box.createVerticalBox();
        topLeft.add(ta);
        topLeft.add(cbox);
        //创建一个水平排列的Box容器，装载topLeft和列表选择框
        //往列表选择框中添加内容
        colorList.add("红色");
        colorList.add("绿色");
        colorList.add("蓝色");
        Box top = Box.createHorizontalBox();
        top.add(topLeft);
        top.add(colorList);
        frame.add(top);
        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);

    }
    public static void main(String[] args) {
    
    
        new Basic().init();
    }
}

对话框Dialog

1. Dialog 是 Window 类的子类，是 一个容器类，属于特殊组件 。 对话框是可以独立存在的顶级窗口， 因此用法与普通窗口的用法几乎完全一样。
2. 对话框通常依赖于其他窗口，就是通常需要有一个父窗口。
3. 对话框有非模式(non-modal)和模式(modal)两种，当某个模式对话框被打开后，该模式对话框总是位于它的父窗口之上，在模式对话框被关闭之前，父窗口无法获得焦点。

（一）：

public class DialogDemo1 {
    
    
public static void main(String[] args) {
    
    
Frame frame = new Frame("这里测试Dialog");
Dialog d1 = new Dialog(frame, "模式对话框", true);
Dialog d2 = new Dialog(frame, "非模式对话框", false);
Button b1 = new Button("打开模式对话框");
Button b2 = new Button("打开非模式对话框");
//设置对话框的大小和位置
d1.setBounds(20,30,300,400);
d2.setBounds(20,30,300,400);

//给b1和b2绑定监听事件
b1.addActionListener(new ActionListener() {
    
    
       @Override
         public void actionPerformed(ActionEvent e) {
    
    
              d1.setVisible(true);
            }
        });
b2.addActionListener(new ActionListener() {
    
    
       @Override
        public void actionPerformed(ActionEvent e) {
    
    
              d2.setVisible(true);
            }
        });

//把按钮添加到frame中
 frame.add(b1);
 frame.add(b2,BorderLayout.SOUTH);
 //设置frame最佳大小并可见
   frame.pack();
   frame.setVisible(true);
    }
}

（二）：

public class DialogDemo2 {
    
    

    public static void main(String[] args) {
    
    
        Frame frame = new Frame("这里测试Dialog");
        Dialog d1 = new Dialog(frame, "模式对话框", true);

        //往对话框中添加内容
        Box vBox = Box.createVerticalBox();
        vBox.add(new TextField(15));
        vBox.add(new JButton("确认"));
        d1.add(vBox);
        Button b1 = new Button("打开模式对话框");

        //设置对话框的大小和位置
        d1.setBounds(20,30,200,100);
        //给b1绑定监听事件
        b1.addActionListener(new ActionListener() {
    
    
            @Override
            public void actionPerformed(ActionEvent e) {
    
    
                d1.setVisible(true);
            }
        });


        //把按钮添加到frame中
        frame.add(b1);

        //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
    }
}

FileDialog

它代表一个文件对话框，用于打开或者保存文件,需要注意的是FileDialog无法指定模态或者非模态，这是因为 FileDialog 依赖于运行平台的实现，如果运行平台的文件对话框是模态的，那么 FileDialog 也是模态的;否则就是非模态的 。

public class FileDialogTest{
    
    
 public static void main(String[] args){
    
    
  Frame frame=new Frame("这里测试File");
  //打开俩个文件
  FileDialog d1 = new FileDialog(frame, "选择需要加载的文件", FileDialog.LOAD);
  FileDialog d2 = new FileDialog(frame, "选择需要保存的文件", FileDialog.SAVE);
  Button b1 = new Button("打开文件");
  Button b2 = new Button("保存文件");
   //给按钮添加事件（点击后的行为）
 b1.addActionListener(new ActionListener() {
    
    
   @Override
 public void actionPerformed(ActionEvent e) {
    
    
        d1.setVisible(true);
     //打印用户选择的文件路径和名称
System.out.println("用户选择的文件路径:"+d1.getDirectory());
System.out.println("用户选择的文件名称:"+d1.getFile());
            }
        });

b2.addActionListener(new ActionListener() {
    
    
    @Override
public void actionPerformed(ActionEvent e) {
    
    
     d2.setVisible(true);
      //打印用户选择的文件路径和名称
   System.out.println("用户选择的文件路径:"+d2.getDirectory());
   System.out.println("用户选择的文件名称:"+d2.getFile());
     //添加按钮到frame中
        frame.add(b1);
        frame.add(b2,BorderLayout.SOUTH);
      //设置frame最佳大小并可见
        frame.pack();
        frame.setVisible(true);
            }
        });