Java程序设计学习笔记（四）—— GUI

时间：2016-3-24 11:24

天道酬勤

 

——GUI（图形用户界面）
    1、GUI
        Graphical User Interface（图形用户接口）。
        用图形的方式，来显示计算机操作的界面，这样更方便更直观。
        图形化界面不是main线程控制，是用另外的前台线程来控制的。
    2、CLI
        Command line User Interface（命令行用户接口）。
        就是常见的DOS命令操作。
        需要记忆一些常用的命令，操作不直观。
        Java为GUI提供的对象都存在于java.Awt和javax.Swing两个包中。

        需要记住的Java命令：
            javac
            javadoc
            jar

    3、Awt和Swing
        java.Awt：
            Abstract Window ToolKit（抽象窗口工具包），是第一代的Java GUI工具包需要调用本地系统方法实现功能。
            例如：有可能依赖Windows操作系统，依赖
            平台，跨平台性稍弱，所以称之为重量级控件。
        为了增强跨平台性，出现了swing类。
        javax.Swing：
            在AWT的基础上，建立的一套图形界面系统，其中提供了更多的组件，而且完全由Java实现，增强了移植性，使用swing开发完
            的组件，在任何平台显示效果一模一样，不依赖于平台，所以属于轻量级控件。

    4、继承关系
        
        Label：
            不能把文字直接放到组件上时，就需要把文字封装成组件对象，就是Label。
            Label的功能就是封装文字，但凡是想在组件上添加文字，先Label。
        TextComponent：
            文本组件，包括文本框和文本域，也就是TextArea和TextField。
            文本框是单行文本，文本域是多行文本。
        Container：
            Container是一个容器，它可以存放许多组件，组件就是对象，其实就是在Container内部封装了一个集合，都具备脚标，所以可
            以通过Component add(Component comp, int index)方法在任意位置添加元素。
            Container包含了Window和Panel，Window下又包含了Frame和Dialog-->FileDialog（文件对话框，可以进行文件的选取
            和操作）。

            Container作为一个组件，其内部可以添加组件，该组件可以通过add方法添加其他组件，而button、label、
            checkbox、textcomponent等组件虽然和Container平级，但是它们内部不能添加组件。

    5、布局管理器
        容器中的组件的排列方式，就是布局。
        常见的布局管理器：

            FlowLayout（流式布局管理器）
                从左到右的顺序排列。
                Panel默认的布局管理器。
                流式布局默认组件都是居中，可以设置偏左偏右。
                添加第二个组件时第一个组件就会向左移动，在右侧放下第二个组件，第一行装不下时自动换行。

            BorderLayout（边界布局管理器）
                东、南、西、北、中。
                Frame默认的布局管理器。
                默认居中，如果不指定位置，则以最大面积填充窗体，添加第二个组建时覆盖第一个。

            GridLayout（网格布局管理器）
                规则的矩阵。

            GridBagLayout（网格包布局管理器）
                非规则的矩阵。

            CardLayout（卡片布局管理器）
                选项卡。
                参见Windows操作系统的“文件夹选项”。

            坐标式布局

        需要用什么布局管理器就new什么布局管理器的对象。如果想在同一个Frame中添加多个布局，需要先在Frame中添加Panel

    6、AWT体系
        java.awt.*;
            | -- Component 
                    | -- Checkbox
                    | -- Label
                    | -- TextComponent
                            | -- TextField
                            | -- TextArea
                    | -- Container —— 容器
                            | -- Panel
                            | -- Window
                                    | -- Frame
                                    | -- Dialog
                                            | -- FileDialog

        java.awt.event.*;
            | -- EventListener
                | -- WindowListener
                    | -- WindowEvent
                    | -- WindowAdapter
                | -- ActionListener
                | -- KeyListener
                | -- MouseListener
                    | -- MouseAdapter
                | -- TextListener

        java.awt.event.*;
            | -- AWTEvent
                | -- ActionEvent
                | -- TextEvent
                | -- WindowEvent
                | -- ComponentEvent
                        | -- InputEvent
                                | -- KeyEvent
                                | -- MouseEvent
                        | -- WindowEvent

        Component
            因为几乎所有的组件都支持鼠标和键盘操作，所以鼠标事件和键盘事件就放在了Component类下。

                输入事件
                    void addInputMethodListener(InputMethodListener l)
                        添加指定的输入方法监听器，以接收发自此组件的输入方法事件。

                鼠标事件
                    当ActionListener和MouseListener同时存在时，先执行MouseListener。
                    鼠标不点击按钮，但是键盘操作按钮，也会触发ActionListener，只要按钮被执行就会触发ActionListener。
                    MouseListener
                    void addMouseListener(MouseListener l)
                        添加指定的鼠标监听器。
                    void addMouseWheelListener

                键盘事件
                    void addKeyListener(KeyListener l)
                        添加指定的按键监听器。
            方法摘要
                void repaint()
                void repaint(long time)
                void repaint(long time,int x, int y, int width, int height)
                    在time毫秒内重绘组件的指定矩形区域。
                    repaint()会默认调用内部的paint方法。
                void update(Graphics g)
                    更新组件，repaint()方法会默认先调用update方法。
                void setBackground(Color bg)
                    设置此组件的背景色。
                void setEnable(boolean enabled)
                    设置是否启用此组件。
                void setFont(Font font)
                    设置字体。
                void setForeground(Color fg)
                    设置此组件的前景色。
                void update(Graphics g)
                    调用paint方法。
                

        Container
            方法摘要        
                Component add(Component comp)
                    将指定组件追加到此容器的尾部。
                Component add(Component comp, int index)
                    将指定组件添加到容器指定位置。
                int getComponentCount()
                    获取此面板中的组件个数。
                LayoutManager getLayout()
                    获取此容器的布局管理器。
                void remove(Component comp)
                    从容器中移除指定组件。
                void remove(int index)
                    从此容器中移除指定位置的组件。
                void removeAll()
                    从此容器中移除所有组件。
                void paint(Graphics g)
                    绘制容器。

                    paint()方法的调用是awt线程来控制的，jvm提供了这样一个线程来管理组件的各种工作。一旦这个组件被某个其它窗口
                    覆盖之后，或者最小化最大化的过程中，组件本身都会接到awt的重绘事件申请，组件便调用paint()方法来绘制自身
                    和add到组件之上的各种对象。

                    也就是说一旦发生变化，自动调用paint()进行重绘。
                void update(Graphics g)
                    更新容器。 

Graphics

            方法摘要
                abstract void dispose()
                    释放此图形的上下文以及它使用的所有系统资源。
                
                abstract Color getColor()
                    获取当前图形上下文的颜色。
                abstract Font getFont()
                    获取当前字体。
                abstract void setColor(Color c)
                    将此图形上下文的当前颜色设置为指定颜色
                abstract setFont(Font f)
                    将此图形上下文的字体设置为指定字体。
                abstract void fillOval(int x,int y,int width,int height)
                    使用当前颜色填充外接指定矩形框的椭圆。
                    x，y是左上角方框的位置，也就是圆形上方切线和左边切线想交的位置，w，h是方框的宽度和高度。

        Frame 

            Frame是带有标题和边框的顶层窗口
            Frame窗体在创建完成后，默认使用的是边界式布局，BorderLayout。

            构造方法：
                Frame()
                    构造一个最初不可见的Frame对象。
                Frame(String title)
                    构造一个新的、最初不可见的、具有指定标题的Frame对象。

            方法摘要：

                Component add(Component com)
                    将指定组件追加到此容器尾部。

                void setBounds(int x, int y, int width, int height)
                    设置组件起始位置，并设置组件大小。

                void setVisiable(boolean b)
                    该方法继承自Window类。
                    用于设置窗体是否可见。

                    图形化界面是由另外的线程来控制的，只要开启一个图形化界面，就会多开启一个线程，
                    当主线程结束之后，只要窗口还在，程序就不终止。

                void setSize(int width, int height)
                    用于设置窗体的长和宽，width是X轴，height是Y轴。

                    通常情况下，这种方法接收的参数，第一个是横向的，第二个是纵向的。

                void setLocation(int x, int y)
                    该方法继承自Component类。
                    设置窗体出现的位置。

        JButton
            
            JButton扩展自javax.swing.AbstractButton，是swing中最简单的按钮类型，包含文本或图标，主要响应单击事件。
            构造方法
                JButton(String text)
                JButton(Icon icon)
                    创建一个带图标的按钮。
            方法摘要
                void addActionListener(ActionListener l)
                    添加指定动作的监听器。
                void setText(String s)
                    给按钮添加文本。
                String getText()
                    获取按钮文本。
                void seEnabled(boolean b)
                    启用或禁用按钮（该按钮上的触发事件启用或禁用）。
                    
                

        JCheckbox
            复选框是一个可处于“开（true）”或“关（false）”状态的图形组件，单击复选框可更改其开关状态。
    
            可以用CheckboxGroup类将复选框分组，作为单个对象来控制，当多个复选框组合成一个复选框时，在任何给定时间，
            最多只能有一个按钮处于“开”状态，单击并打开一个复选框会强迫同组中的其它原来处于打开状态的复选框变
            为“关闭“状态。

            构造方法
                JCheckBox()
                    创建一个没有文本，没有图标并且未被选定的复选框。
                JCheckBox(Icon icon)
                    创建一个有图标，最初未被选定的复选框。
                JCheckBox(Icon icon, boolean selected)
                    创建一个带图标的复选框，并指定其最初是否处于选定状态。
                JCheckBox(String text)
                    创建一个带文本的、最初未被选定的复选框。
                JCheckBox(String text, Icon icon, boolean selected)
                    创建一个带文本和图标的复选框，并指定其最初是否处于选定状态。

            方法摘要
                void addItemListener(ItemListener l)
                    添加指定的监听器，以接收来自此复选框的事件。
                CheckboxGroup getCheckboxGroup()
                    确定此复选框的组。
                String getLabel()
                    获取此复选框的标签。
                boolean getState()
                    确定此复选框是处于“开启”状态，还是处于“关闭”状态。
                String getText()
                    返回按钮的文本。
                void removeItemListener(ItemListener l)
                    移除此项监听器，这样监听器将不再接收发自此复选框的事件。
                void setCheckboxGroup(CheckboxGroup g)
                    将此复选框的组设置为指定复选框组。
                void setLabel(String label)
                    将此复选框的标签设置为字符串参数。
                void setState(boolean state)
                    将此复选框的状态设置为指定状态。
                boolean isSelected()
                    返回按钮的状态，如果选定了切换按钮，则返回true，否则返回false。
                void setSelected(boolean b)
                    设置按钮的状态。

        JRadioButton
            
            JRadioButton实现一个单选按钮，此按钮项可被选择或取消选择，并可为用户显示其状态。
            它与ButtonGroup对象配合使用可创建一组按钮，一次只能选择其中的一个按钮。
            
            方法摘要
                String getText()
                    返回按钮的文本。
                void setText(String s)
                    设置按钮的文本。
                boolean isSelected()
                    返回按钮的状态。
                    如果选定了切换按钮，则返回true，否则返回false。
                void setSelected(boolean b)
                    设置按钮的状态。
                    默认初始选中调用该方法的按钮对象。

            使用ButtonGroup创建按钮组
                ButtonGroup sexGroup()
                    创建按钮组。
                JRadioButton rdoboy；
                JRadioButton rodGirl；
                    在构造方法中将按钮添加到按钮组（通常在initComponent方法之后添加）。

        JLabel

            Lable对象时一个可以在容器中放置文本的组件，一个标签只能显示一行只读文本。
            文本可由应用程序更改，用户不能直接对其进行编辑。
            提供可带图形的标签，可以试文本或者图片，主要是对其他组件进行提示说明，通常标签不对输入事件做出反应。

            静态常量
                static int CENTER
                    标签居中显示。
                static int LEFT
                    标签左对齐。
                static int RIGHT
                    标签右对齐。

            构造方法
                Lable()
                    构造一个空标签。
                Label(String text)
                    使用指定的文本字符串构造一个新的标签，其文本对齐方式为左对齐。
                Label(String text, int alignment)
                    指定文本并指定对齐方式。

            方法摘要
                int getAlignment()
                    获取当前标签的对齐方式。
                String getText()
                    获取此标签的文本。
                void setAlignment(int alignment)
                    将此标签的对齐方式设置为指定的方式。
                void setText(String text)
                    将此标签的文本设置为指定的文本。
                void setIcon(Icon icon)
                    指定标签图标。
                    label.setIcon(new ImageIcon("/image/***.jpg"))

        JList

            现实对象列表并允许用户选择一个或多个项的组件，单独的模型ListModel维护列表的内容。
            使用能自动构建只读ListModel实例的JList构造方法，可以方便的显示对象数组或对象Vector。
            可以通过构造方法或setModel方法向JList直接提供ListModel。
            JList不实现直接滚动，要创建一个滚动的列表，必须使用JScrollPane的视图窗口。
            构造方法
                JList(Object[] listData)
                    构造一个JList，使其显示指定数组中的元素。
                JList(Vector listData)
                    构造一个JList，使其显示指定Vector中的元素。
            方法摘要
                void addListSelectionListener(ListSelectionListener listener)
                    将监听器添加到列表，每次选择发生改变时都会获得通知，这是监听选择状态更改的首选方式。
                void clearSelection()
                    清除选择，调用此方法后，isSelectionEmpty()将返回true。

        JTextField

            JTextField允许编辑单行文本，当文本长度超过字段实际长度，它会自动滚动文本。

            构造方法
                TextField()
                    构造新的文本框。
                TextField(int columns)
                    构造具有指定列数的新空文本框。
                    只能控制列数，因为TextField只有一行。
                TextField(String text)
                    构造使用指定文本初始化的新文本框。
                TextField(String text, int columns)
                    同理。

            方法摘要
                void setEchoChar(char c);
                    通过指定字符设置回显字符，一般用于实现密码。

                void setEditable(boolean b)
                    设置文本框是否可编辑。 
                    setEditable(false)设置文本不可编辑。
                    也可以通过setText("")来动态设置显示内容。

                String getText()
                      获取文本字段中的文本。
                void setText(String s)
                    设置文本。 

        JTextArea
            
            JTextArea是显示纯文本的多行区域，但是只能使用单一的字体和格式显示文本。
            记事本就属于单一的字体和格式。
            
            方法摘要
                String getText()
                    返回此文本域中的文字。
                String getSelectedText()
                    返回选中的文本。
                void setText(String s)
                    将该文本域设置为指定文本。
                void append(String str)
                    将指定文本追加到文档结尾。

            特殊应用
                this.testTextArea.setSelectionStart(0)
                    将光标设置到末尾。
                this.testTextArea.setSelectionEnd(0)
                    将光标设置到开头。

        JPasswordField
        
            JPasswordField继承自JTextFile，允许编辑单行文本，但不现实原始字符，一般作为密码输入框。
            方法摘要
                char[] getPassword()
                    返回此口令字段中所包含的实际文本。
                    需要注意的是，该方法返回的文本是字符数组，通常将返回的字符数组通过String类的构造方法转换成字符串进行处理。

        JComboBox

            JComboBox是将按钮或可编辑字段与下拉列表组合的组件。
            用户可以从下拉列表中选择值，下拉列表在用户请求（点击）时显示
            方法摘要
                void addItem(Object obj)
                    为项列表添加项。
                void removeItemAt(int index)
                    从项列表中移除项。
                void removeAllItems()
                    清空列表。
                Object getSelectedItem()
                    返回当前所选项。
                void setSelectedIndex(int index)
                    将组合框显示区域中所选项设置为参数中索引所在项。
            可视化添加项列表
                1、选中组合框，在属性面板中选择“model”。
                2、删除原始的项列表，选中第一个项，点击删除。
                3、在项中输入要添加的项列表，单击添加。
                4、添加完毕后单击确定。
            触发事件
                item-itemStateChanged()

        Dialog

            Dialog是一个带标题和边界的顶层窗口，边界一般用于从用户处获得某种形式的输入。
            对话框依赖于窗体。
            Dialog默认布局模式是边界式布局，BorderLayout
            
            构造方法
                Dialog(Dialog owner)
                    构造一个最初不可见的、无模式的Dialog，它带有指定所有者Dialog和一个空标题。
                Dialog(Frame owner, boolean modal)
                    通常情况下对话框不会单独存在，因为一般只有在事件发生时才会出现对话框

            方法摘要
                String getTitle()
                    返回此Dialog的标题。
                boolean isResizable()
                    判断此Dialog是否可以由用户调整大小。
                void setTitle(boolean resizable)
                    设置此dialog是否可以由用户调整大小。
                void setTitle(String title)
                    设置此Dialog的标题。

        Window
            
            方法摘要
                void addWindowListener(WindowListener l)
                    添加窗口监听器。

        JPanel
        
            JPanel组件是一般轻量级容器，可以先将组件放置到JPanel中，然后再将Panel放置到框架中，常用于复杂界面设计。

        JOptionPane

            使用JOptionPane可以创建相对简单的常用的模式对话框。
                模式：
                    当前对话框关闭之前，主窗体不能进行其他操作。
                非模式：
                    当前对话框关闭之前，主窗体可以进行其他操作。
            弹出提示信息或简单的输入信息对话框
                JOptionPane类中提供了四种静态方法，用以显示四种常用的对话框
                    showMessageDialog
                        消息对话框。
                    showConfirmDialog
                        确认对话框。
                    showInputDialog
                        输入对话框。
                    showOptionDialog
                        选项对话框。
            常用的对话框
                showMessageDialog
                    showMessageDialog(父窗体,"消息","标题",messagetype);
                        messagetype
                            ERROR_MESSAE    
                            INFORMATION_MESSAGE
                            WARNING_MESSAGE
                            QUESTION_MESSAGE
                            PLAIN_MESSAGE
                    showMessageDialog(父窗体,"消息")
                showMessageDialog特征
                    有一个确定按钮。
                    该对话框的操作不影响主程序，只是做消息提示。
                showConfirmDialog
                    int result = showConfirmDialog(父窗体,"消息","标题",optiontype);
                        optiontype
                            DEFAULT_OPTION
                            YES_NO_OPTION
                            YES_NO_CANCEL_OPTION
                            OK_CANCEL_OPTION
                    int result = showConfirmDialog(父窗体,"消息");
                        默认是YES_NO_CANCEL
                判断
                        if(result == JOptionPane.YES_OPTION)
                            System.out.println("您选择的是YES按钮");
                        if(result == JOption.NO_OPTION
                            System.out.println("您选择的是NO按钮");JOptionPane图标

            对于对话框，系统提供了四种图标：
                    
                    四个图标对应的常量是：
                        QUESTION_MESSAGE
                        INFORMATION_MESSAGE
                        ERROR
                        PLAIN_MESSAGE    //不使用图标。

        JDialog

            在javax.swing包中提供了一个专门创建对话框的类：JDialog
            使用JDialog创建的对话框有模式和非模式之分
                模式对话框在处理完之前不能与程序的主窗口进行交互。
                非模式对话框允许用户同时在对话框和程序的主窗口中输入信息。
            JDialog有模式和非模式之分，其他使用方式与JFrame没有太大区别。

            公共对话框JFileChooser
                打开对话框
                    //启动打开对话框
                    JFileChooser openDlg = new JFileChooser();

                    int flag = openDlg.showOpenDialog(this);

                    if(flag == JFileChooser.APPROVE_OPTION)
                    {

                        //如果点击了打开按钮,获取文件路径

                         File file = openDlg.getSelectedFile();

                         System.out.println("文件名："+file.getAbsolutePath());

                    }

                保存对话框
                    //启动保存对话框
                    JFileChooser saveDlg = new JFileChooser();

                    int flag = saveDlg.showSaveDialog(this);

                    if(flag == JFileChooser.APPROVE_OPTION)
                    {

                        //如果点击了保存按钮,获取保存的路径

                         File file = saveDlg.getSelectedFile();

                         System.out.println("文件名："+file.getAbsolutePath());

                    }
 

窗体之间的传值问题：
                    静态变量
                        将值传给窗体的静态变量
                    构造方法重载
                        重载构造方法，并加参数
                        修改main函数中创建窗体的方法

 
        Image
            抽象类Image是表示图形图像的所有类的超类，必须以特定于平台的方式获取图像。
            方法摘要
                abstract Graphics getGraphics()
                    创建提供绘制图像的图形上下文背景。

        ImageIcon
            
            一个Icon接口的实现，它根据Image绘制Icon。
            构造方法
                ImageIcon()
                    创建一个未初始化的图像图标。
                imageIcon(Image image)
                    根据图像创建一个ImageIcon。
            方法摘要
                Image getImage()
                    返回此图标的Image。

        WindowListener
            因为WindowListener是一个接口，所以如果想要使用该接口中的方法，需要实现该接口并复写所有方法，这样做非常麻烦。
            所以JDK提供了一个实现了WindowListener接口的子类——WindowAdapter，这个类是一个抽象类。

        WindowAdapter
                接收窗口事件的抽象适配器类，此抽象类复写了WindowListener的全部方法，
                但是没有定义方法内容，此类存在的目的是方便创建监听器对象。
                为什么将WindowAdapter定义为抽象类呢？
                    因为WindowAdapter类中的方法都为空（也就是所说的抽象类中一个抽象方法都没有），创建对象无意义，所以如果想要
                    使用该类中的方法，必须继承该抽象类。
            方法摘要
                void windowActivated(WindowEvent e)
                    激活窗口时调用。
                    也就是每次选中窗口或者将窗口前端显示就会激活该方法。
                void windowClosed(WindowEcent e)
                    当窗口已被关闭时调用。
                void windowClosing(WindowEvent e)
                    当窗口正处在关闭过程中调用。
                void windowOpened(WindowEvent e)
                    已打开窗口时调用。
                    也就是在窗口第一次打开（线程开启）的时候调用该方法，只执行一次。
                    有时候有的软件一打开会有一些动作，就可以使用该方法完成。

        MouseAdapter
            方法摘要
                void mouseClicked(MouseEvent e)
                    鼠标在组件上单击（按下并释放）时调用。
                void mouseDragged(MouseEvent e)
                    鼠标拖动时调用。
                void mouseEntered(MouseEvent e)
                    鼠标进入组件时调用。
                void mouseExited(MouseEvent e)
                    鼠标离开组件时调用。
                void mousePressed(MouseEvent e)
                    鼠标在组件上按下时调用。
                void mouseReleased(MouseEvent e)
                    鼠标按钮在组件上释放时调用。
                void mouseWheelMoved(MouseEvent e)
                    鼠标滚轮旋转时调用。

        KeyAdapter
            方法摘要
                void keyPress(KeyEvent e)
                    按下某个键时调用此方法。
                void keyReleased(KeyEvent e)
                    释放某个键时调用此方法。
                void keyTyped(KeyEvent e)
                    键入某个键时调用此方法。

        MouseEvent
            字段摘要
                static int BUTTON1
                    左键
                static int BUTTON2
                    右键
                static int BUTTON3
                    中键
            方法摘要
                int getClickCount()
                    返回与此事件关联的鼠标单击次数。
                    可以判断鼠标是否双击。

        KeyEvent
            当按下某个键的时候，需要将对应键封装成对象传入KeyEvent中，在KeyEvent中，将对应键固定成常量了，
            所以在使用KeyEvent时需要查阅KeyEvent类。
            
            如果想使用组合键，可以在InputEvent中查找对应方法并使用，因为KeyEvent已经继承了InputEvent，所以KeyEvent对象可以
            直接调用InputEvent类的方法。
            
            字段摘要
                static int VK_0 ~~~ static int VK_9：对应键盘的0123456789
                static int VK_Enter
                    回车键。
                static int VK_escape
                    ESC键。
                static int VK_CONTROL
                    control键。
                static int VK_F1 ~~ *
                    多功能键，PC机只支持到Function12。

            方法摘要
                char getKeyChar()
                    返回与此事件中的键关联的字符。
                int getKeyCode()
                    返回与此事件中的键关联的整数keyCode。
                int getKeyLocation()
                    返回产生此按键时间的键位置。
                static String getKeyText(int keyCode)
                    根据传入的keyCode，返回描述keyCode的文本表现形式，如"HOME","SHIFT"。
                
        InputEvent
            方法摘要
                boolean isControlDown()
                    判断Control是否被按下。
                boolean isShiftDown()
                    判断Shift是否被按下。
                void consume()
                    屏蔽键。
                    使用此事件，但是并不处理此事件（例如在文本中按键输入，会触发事件，但该键对应字符不会存入文本）

    6、创建图形化界面
        Container常用子类：Window、Panel（面板，不能单独存在）。
        Window常用子类：Frame、Dialog。
        简单的创建过程：
        （1）创建Frame窗口对象。
                Frame f = new Frame("my frame");
        （2）对窗口进行基本设置。
                f.setLayout(new flowLayout());
                f.setSize(200,300);
                f.setLocation(200,200);
        （3）定义组件。
                Button b = new Button("按钮");
        （4）将组件通过窗口的add方法添加到Frame窗口中。
                f.add(b);
        （5）让窗口显示。
                f.setVisible(true);
    7、事件监听机制
        
        事件监听机制的特点：
            （1）事件源（组件）
            （2）事件（Event）
                    事件会被封装成一个对象，该对象至少包含事件源，监听器会根据不同对象采用不同的处理方式。
            （3）监听器（Listener）
                    监听器中定义的都是处理方式（动作）。
            （4）事件处理（引发事件后的处理方式）

        事件源：就是awt包或者swing包中的那些图形界面组件。
        事件：每一个事件源都有自己特有的对应事件和共性事件。         
        监听器：将可以触发某一个事件的动作（不止一个动作）都已经封装到了监听器中。

        以上三者，在Java中都已经定义好了，直接获取其对象来用就可以了，我们需要做的就是对产生的动作进行处理。 
        凡是监听器，结尾都是Listener。
 
        注意：
                监听器（Listener）只是一个动作，真正的操作类型封装到事件（Event）中了。

        /**

            对创建窗体进行优化

            2016年4月6日20:15:27

        */

 

        import java.awt.*;

        import java.awt.event.*;

    

        public class AwtDemo01

        {

            private static Frame f = null;

            private static Button but = null;

 

            AwtDemo01()

            {

                init();

            }

 

            public void init()

            {

                //创建窗体

                f = new Frame("my frame");

                //设置窗体大小

                f.setSize(300,300);

                //设置窗体初始位置

                f.setLocation(100,100);

                //设置窗体布局格式

                f.setLayout(new FlowLayout());

                //创建按钮

but = new Button("我是一个按钮");

                //添加基本窗体事件

                myEvent();

                //添加按钮

                f.add(but);

                //设置窗体是否可见

                f.setVisible(true);

            }

 

            public void myEvent()

            {

                f.addWindowListener(new WindowAdapter()

                {

                    public void windowClosing(WindowEvent e)

                    {

                        System.out.println("窗口关闭");

                        System.exit(0);

                    }

                    public void windowActivated(WindowEvent e)

                    {

                        System.out.println("窗口被激活");

                    }

                    public void windowOpened(WindowEvent e)

                    {

                        System.out.println("窗口被打开");

                    }

                });
                /*
                    让按钮具备退出程序的功能：
                        按钮就是事件源，那么选择哪个监听器呢？
                        通过关闭窗体示例（windowClosing）了解到，想要知道哪个组件具备什么样的特有监听器，
                        需要查看该组件对象的所在类的方法，也就是添加监听器的方法。
                        因为组件支持哪些监听器，只有组件自己知道，所以添加监听器的方法肯定定义在组件内部。
                        通过查阅Button类，发现Button支持一个特有的监听器：
                        ActionListener，通过addActionListener(ActionListener l)添加。
                */ 
                but.addActionListener(new ActionListener()
                {
                    public void actionListener(ActionEvent e)
                    {
                        System.out.println("点击按钮，退出程序");
                        System.exit(0);
                    }
                }); 

            }

 

            public static void main(String[] args)

            {

                new AwtDemo01();

            }

        }

——界面布局

    LayoutManager
        
        所有的布局管理器都实现了该接口。

        void addLayoutComponent(String name, Component comp)
            如果布局管理器使用组件字符串，则将组件comp添加到布局，并将它与name指定的字符串相关联。
        void removeLayoutComponent(Component comp)
            从布局删除指定组件。

    BorderLayout -- 边界布局管理器
        这是一个布置容器的边框布局，它可以对容器进行安排，并调整其大小，使其符合下列五个区域：东西南北中，每个区域最多包含
        一个组件，并通过相应的常量进行标识。

        可以在添加组件时使用常量指定位置：
            NORTH  SOUTH  EAST  WEST CENTER
        格式为：
            f.setLayout(new BorderLayout());
            f.add(new Button("b1"),BorderLayout.CENTER)   //将组件添加到中间位置。

        构造方法：
            BorderLayout(int hgap, int vgap);
                构造一个具有指定组件间距的边框布局。
        方法摘要：
            String toString();
                返回此边框布局的状态的字符串表示形式。

                    javax.swing.JFrame[frame0,200,200,600x600,layout=java.awt.BorderLayout,title=JFr

                    ame,resizable,normal,defaultCloseOperation=HIDE_ON_CLOSE,rootPane=javax.swing.JR

                    ootPane[,8,30,584x562,layout=javax.swing.JRootPane$RootLayout,alignmentX=0.0,ali

                    gnmentY=0.0,border=,flags=16777673,maximumSize=,minimumSize=,preferredSize=],roo

                    tPaneCheckingEnabled=true]

CardLayout -- 卡片布局管理器
        CardLayout对象时容器的布局管理器，它将容器中的每个组件看做一张卡片，一次只能看到一张卡片，容器则充当卡片的堆栈，
        当容器第一次显示时，第一个添加到CardLayout对象的组件为可见组件。
    
        CardLayout的存储顺序相当于队列，先进先出，可以使用操作队列的方式操作CardLayout。
        
        卡片的顺序由组件对象本身在容器内部的顺序决定，CardLayout定义了一组方法，这些方法允许应用程序按顺序的浏览这
        些卡片，或者显示指定的卡片。
        
        方法摘要：
            void first(Container parent)
                翻转到容器的第一张卡片。
            void last(Container parent)
                翻转到容器的最后一张卡片。
            void next(Container parent)
                翻转到指定容器的下一张卡片。
            void previous(Container parent)
                翻转到指定容器的前一张卡片。
            void show(Container parent, String name)
                翻转到指定name的卡片。 

    FlowLayout -- 流式布局管理器
        流式布局用于有流动型的组件，这非常类似于段落中的文本（如果文本超出范围，自动流向下一行）
        流的方向取决于容器的componentOrientation属性，它可以试以下两个值中的任意一个：
            ComponentOrientation.LEFT_TO_RIGHT;
            ComponentOrientation.RIGHT_TO_LEFT;
        流式布局一般用来安排面板中的按钮，它使得按钮呈水平放置，直到同一条线上再也没有空间。
        线的对齐方式由align属性确定：
            static int CENTER
            static int LEFT
                左对齐。
            static int RIGHT
                右对齐。
            static int LEADING
                此值知识每一行组件都应该与容器防线的开始边对齐。
                例如，对于从左到右的方向，则左对齐。
            static int TRAILING
                与LEADING相反。
        
        方法摘要：
            int getAlignment()
                获取此布局的对齐方式。
                返回的值是LEFT，RIGHT，CENTER等。
            void setAlignment(int lign)
                设置此布局的对齐方式。

    GridLayout -- 网格布局管理器
        网格布局管理器，它以矩形网格形式对容器的组件进行布置，容器被分成大小相等的矩形，一个矩形中放置一个组件。
        与FlowLayout不同的是，GridLayout不改变位置，只改变大小，FlowLayout只改变位置，不改变大小。
        网格布局默认排列方式为从左向右，可以通过指定行数和列数来控制组件分布（不能填充的位置为空白）
        构造方法：
            GridLayout(int rows, int cols)
                创建具有指定行数和列数的网格布局。
        方法摘要：
            int getColumns()
                获取此布局中的列数。
            int getRows()
                获取此布局中的行数。
            void setColumns(int cols)
                设置列数。
            void setRows(int rows)
                设置行数。

    GridBagLayout -- 网格包布局管理器

    BoxLayout -- 

——Swing

    Swing具有更丰富，更方便的

    应用场合
        桌面程序
            C/S架构
            需要安装客户端程序
        工控程序

    Swing组件
        顶层组件类：
            JFrame
            Japplet
            JDialog
            JWindow
        中间组件
            中间类容器
                JPanel
                JScrollPane
                JSplitPane
                JToolBar
            特殊中间容器类
                JInternalFrame
                JLayeredPane
                JRootPane
        基本组件类

    图形界面程序开发总结
        图形界面类设计
            1、继承顶层容器：JFrame或者JDialog
            2、声明需要的其他的基本GUI组件
            3、声明构造方法
            4、定义初始化组件方法：initComponents()
            5、实现initComponents方法
                    1）定义组件对象。
                    2）设置布局
                    3）添加组件
        创建窗体
            创建对象：自定义类  对象  =  new  自定义类();
            

——可视化编程
    1、NetBeans使用
        1）创建Java项目
                给项目命名，指定存放位置
        2）创建包
        3）创建JFrame窗体
        4）设置窗体组件
        5）编辑组件名
        6）给组件定义变量名（更改变量名称，通常只对需要获取或显示数据的组件进行更改，Label标签通常不更改）
        7）添加事件
        8）编写事件处理代码
    2、NetBeans中GUI项目说明
    3、常用重要组件
    4、作业

——GUI3
    菜单
        1、添加菜单栏
                放置到窗体顶部。
        2、向菜单中添加菜单
                修改菜单属性
                        text：菜单文本
                        mnemonic：助记符。     文件(F)
                更改菜单变量名
        3、添加菜单项
                添加纯菜单项
                        修改菜单属性
                        icon：菜单项图标
                        text：菜单项文本
                        accelerator：快捷键
                        更改菜单项变量名
                添加子菜单
                        可添加下级菜单项，在菜单项中添加菜单。
        4、给菜单项添加事件（同按钮事件）
                使用菜单弹出窗体，需要对菜单进行设置：defaultCloseOperation。
        5、案例任务
                记事本
                个人银行业务

    多文档
        主窗体设置多文档模式
                主窗体添加属性
                        JDesktopPane mydesk = new JDesktopPane();
                构造方法
                        this.setContentPane(mydesk)
        创建内部窗体
                JInternalFrame
                设计内部窗体组件
                        关闭按钮
                        最小化
                        最大化
                        Title
        显示内部窗体
                1、获得内部窗体对象：xxxFrame
                2、this.remove(xxxFrame)
                3、this.add(xxxFrame)
                4、xxFrame.setVisible(true)
                5、xxFrame.toFront()    //设置窗体前端显示。
        工厂模式
                1、获得内部窗体的工厂
                        根据集合是否存在来获得实际对象
                                1）判断集合中是否有该对象，如果有直接返回
                                2）如果没有，根据传入键来判断是new哪个类的对象。
                2、内部窗体添加关闭事件并且在关闭时移除内部窗体。
                3、显示内部窗体的公共方法。
        窗体显示位置
    表格
        表格通常可以通过友好的方式显示多个数据
                收支明细
                课程信息
        设计表格
                添加表格
                设计表格变量名
                设计表格标题及行列属性
                        表格的model属性
                显示数据
                表格行列操作