zoukankan      html  css  js  c++  java
  • 201771010113 李婷华 《面向对象程序设计(java)》

    一.理论知识部分

    设计模式(Design pattern)是设计者一种流行的思考设计问题的方法,是一套被反复使用,多数人知晓的,经过分类编目的,代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。每一个模式描述了一个不断重复发生的设计问题,以及该问题的核心解决方案

    模型-视图-控制器设计模式(Model –ViewController )是Java EE平台下创建 Web 应用程序 的重要设计模式。

    MVC设计模式 – Model(模型):是程序中用于处理程序数据逻辑的部分,通常模型负责在数据库中存取数据。– View(视图):是程序中处理数据显示的部分,通常视图依据模型存取的数据创建。 – Controller(控制器):是程序中处理用户交互的部分。通常控制器负责从视图读取数据,控制用户输入,并向模型发送数据。

    MVC模式可应用于Java的GUI组件设计中。MVC模式GUI组件设计的唯一的模式,还有很多设计的模式(设计方法)。

    Java组件有内容、外观、行为三个主要元素;这三个主要元素与模型—视图—控制器模式的 三部件的对应关系为:内容——控制器(作用:处理用户输入)  外观——视图(作用:显示内容)行为——模型(作用:存储内容)

    布局管理器是一组类。实现 java.awt.LayoutManager 接口;决定容器中组件的位置和大小

    Java.awt包中定义了5种布局管理类,每一种布局管理类对应一种布局策略。每个容器都有与之相关的默认布局管理器。当一个容器选定一种布局策略时,它应该创建该 策略对应的布局管理器对象,并将此对象设置为 自己的布局管理器。

    5种布局管理器:(1)FlowLayout:流布局(Applet和Panel的默认布局管理器) (2)BorderLayout:边框布局( Window、Frame和Dialog的默认布局管理器)(3)GridLayout:网格布局(4)GridBagLayout: 网格组布局(5)CardLayout :卡片布局

    FlowLayout Manager 组件采用从左到右,从上到下逐行摆放。

    GridBagLayout不需要组件的尺寸一致,容许组件扩展到多行、多列。

    文本输入

    (1)文本域(JTextField) : 用于获取单行文本输入。

    (2)文本区(JTextArea)组件可让用户输入多行文 本。生成JTextArea组件对象时,可以指定文本 区的行数和列数: textArea = new JTextArea(8, 40);

    (3)文本区与文本域的异同相同之处: 文本域和文本区组件都可用于获取文本输入。

    不同之处:  文本域只能接受单行文本的输入;  文本区能够接受多行文本的输入。

    (4)文本区JTextArea的常用API:Java.swing. JTextArea 1.2 – JTextArea(int rows, int cols)

    构造一个rows行cols列的文本区对象 – JTextArea(String text,int rows, int cols)

    用初始文本构造一个文本区对象 – void setRows(int rows)

    设置文本域使用的行数 – void append(String newText)

    将给定文本附加到文本区中已有文本的后面 – void setLineWrap(boolean wrap)

    打开或关闭换行

    (5)标签组件:标签是容纳文本的组件。它们没有任何修饰(如没有边界 ),也不响应用户输入。

     标签的常用用途之一就是标识组件,例如标识文本域。

    二.实验部分

    1、实验目的与要求

    (1) 掌握GUI布局管理器用法;

    (2) 掌握各类Java Swing组件用途及常用API;

    2、实验内容和步骤

    实验1: 导入第12章示例程序,测试程序并进行组内讨论。

    测试程序1

    l 在elipse IDE中运行教材479页程序12-1,结合运行结果理解程序;

    l 掌握各种布局管理器的用法;

    l 理解GUI界面中事件处理技术的用途。

    l 在布局管理应用代码处添加注释;

    package calculator;
    
    import java.awt.*;
    import javax.swing.*;
    
    /**
     * @version 1.34 2015-06-12
     * @author Cay Horstmann
     */
    public class Calculator
    {
       public static void main(String[] args)
       {
          EventQueue.invokeLater(() -> {
             CalculatorFrame frame = new CalculatorFrame();
             frame.setTitle("Calculator");
             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
             frame.setVisible(true);
          });
       }
    }
    Calculator
    package calculator;
    
    import javax.swing.*;
    
    /**
     * A frame with a calculator panel.
     */
    public class CalculatorFrame extends JFrame
    {
       public CalculatorFrame()
       {
          add(new CalculatorPanel());
          pack();
       }
    }
    CalculatorFrame
    package calculator;
    
    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    
    /**
     * A panel with calculator buttons and a result display.
     */
    public class CalculatorPanel extends JPanel
    {
       private JButton display;
       private JPanel panel;
       private double result;
       private String lastCommand;
       private boolean start;
    
       public CalculatorPanel()//生产GUI的组件写在构造器中
       {
          setLayout(new BorderLayout());
    
          result = 0;
          lastCommand = "=";
          start = true;
    
          // add the display
    
          display = new JButton("0");//初始化的Label值,完成计算结果的显示内容
          display.setEnabled(false);//定义为flase,计算结果不能更改,仅具有显示功能
          add(display, BorderLayout.NORTH);//显示在最上方
    
          ActionListener insert = new InsertAction();
          ActionListener command = new CommandAction();
    
          // add the buttons in a 4 x 4 grid
    
          panel = new JPanel();//panel是一个容器组件
          panel.setLayout(new GridLayout(4, 4));//设置一个4*4的网格布局管理器
    
          addButton("0", insert);//
          addButton("1", insert);
          addButton("2", insert);
          addButton("/", command);
    
          addButton("3", insert);
          addButton("4", insert);
          addButton("5", insert);
          addButton("*", command);
    
          addButton("6", insert);
          addButton("7", insert);
          addButton("8", insert);
          addButton("-", command);
    
          addButton("9", insert);
          addButton(".", insert);
          addButton("=", command);
          addButton("+", command);
          
          add(panel, BorderLayout.CENTER);
          
          /*JButton b1=new JButton("验证");
          add(b1,BorderLayout.SOUTH);
          
          JButton bl=new JButton("验证 1");
          add(bl,BorderLayout.WEST);
          JButton br=new JButton("验证2");
          add(br,BorderLayout.EAST);*/
    
       }
    
       /**
        * Adds a button to the center panel.
        * @param label the button label
        * @param listener the button listener
        */
       private void addButton(String label, ActionListener listener)
       {
          JButton button = new JButton(label);
          button.addActionListener(listener);//将一个监听器添加到按钮中
          panel.add(button);//将button添加到panel组件上
       }
    
       /**
        * This action inserts the button action string to the end of the display text.
        */
       private class InsertAction implements ActionListener//实现了一个监听器接口
       {
          public void actionPerformed(ActionEvent event)
          {
             String input = event.getActionCommand();
             if (start)
             {
                display.setText("");
                start = false;
             }
             display.setText(display.getText() + input);
          }
       }
    
       /**
        * This action executes the command that the button action string denotes.
        */
       private class CommandAction implements ActionListener
       {
          public void actionPerformed(ActionEvent event)
          {
             String command = event.getActionCommand();//发出动作上的label
    
             if (start)
             {
                if (command.equals("-"))
                {
                   display.setText(command);//setTest在display上显示“-”
                   start = false;
                }
                else lastCommand = command;
             }
             else
             {
                calculate(Double.parseDouble(display.getText()));//通过parseDouble转换成数字
                lastCommand = command;
                start = true;
             }
          }
       }
    
       /**
        * Carries out the pending calculation.
        * @param x the value to be accumulated with the prior result.
        */
       public void calculate(double x)
       {
          if (lastCommand.equals("+")) result += x;
          else if (lastCommand.equals("-")) result -= x;
          else if (lastCommand.equals("*")) result *= x;
          else if (lastCommand.equals("/")) result /= x;
          else if (lastCommand.equals("=")) result = x;
          display.setText("" + result);//进行字符串的转换
       }
    }
    CalculatorPanel

    测试程序2

    l 在elipse IDE中调试运行教材486页程序12-2,结合运行结果理解程序;

    l 掌握各种文本组件的用法;

    l 记录示例代码阅读理解中存在的问题与疑惑。

    package text;
    
    import java.awt.*;
    import javax.swing.*;
    
    /**
     * @version 1.41 2015-06-12
     * @author Cay Horstmann
     */
    public class TextComponentTest
    {
       public static void main(String[] args)
       {
          EventQueue.invokeLater(() -> {
             JFrame frame = new TextComponentFrame();//生成 TextComponentFrame类的GUI界面对象
             frame.setTitle("TextComponentTest");
             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭界面的按钮操作
             frame.setVisible(true);//使结果可见
          });
       }
    }
    TextComponentTest
    package text;
    
    import java.awt.BorderLayout;
    import java.awt.GridLayout;
    
    import javax.swing.JButton;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JPanel;
    import javax.swing.JPasswordField;
    import javax.swing.JScrollPane;
    import javax.swing.JTextArea;
    import javax.swing.JTextField;
    import javax.swing.SwingConstants;
    
    /**
     * A frame with sample text components.
     */
    public class TextComponentFrame extends JFrame
    {  //定义网格的行数、列数
       public static final int TEXTAREA_ROWS = 8;
       public static final int TEXTAREA_COLUMNS = 20;
    
       public TextComponentFrame()
       {
          JTextField textField = new JTextField();//创建一个新的文本域
          JPasswordField passwordField = new JPasswordField();
    
          JPanel northPanel = new JPanel();//构造一个JPanel组件
          northPanel.setLayout(new GridLayout(2, 2));//设置布局管理器
          northPanel.add(new JLabel("User name: ", SwingConstants.RIGHT));//指定右对齐标签
          northPanel.add(textField);
          northPanel.add(new JLabel("Password: ", SwingConstants.RIGHT));
          northPanel.add(passwordField);
    
          add(northPanel, BorderLayout.NORTH);//add方法
    
          JTextArea textArea = new JTextArea(TEXTAREA_ROWS, TEXTAREA_COLUMNS);
          JScrollPane scrollPane = new JScrollPane(textArea);
    
          add(scrollPane, BorderLayout.CENTER);
    
          // add button to append text into the text area
    
          JPanel southPanel = new JPanel();
    
          JButton insertButton = new JButton("Insert");
          southPanel.add(insertButton);
          insertButton.addActionListener(event ->
             textArea.append("User name: " + textField.getText() + " Password: "
                + new String(passwordField.getPassword()) + "
    "));
    
          add(southPanel, BorderLayout.SOUTH);
          pack();
       }
    }
    TextComponentFrame

    测试程序3

    l 在elipse IDE中调试运行教材489页程序12-3,结合运行结果理解程序;

    l 掌握复选框组件的用法;

    l 记录示例代码阅读理解中存在的问题与疑惑。

    package checkBox;
    
    import java.awt.*;
    import javax.swing.*;
    
    /**
     * @version 1.34 2015-06-12
     * @author Cay Horstmann
     */
    public class CheckBoxTest
    {
       public static void main(String[] args)
       {
          EventQueue.invokeLater(() -> {
             JFrame frame = new CheckBoxFrame();
             frame.setTitle("CheckBoxTest");
             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
             frame.setVisible(true);
          });
       }
    }
    CheckBoxTest
    package checkBox;
    
    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    
    /**
     * A frame with a sample text label and check boxes for selecting font attributes.
     */
    public class CheckBoxFrame extends JFrame
    {
       private JLabel label;
       private JCheckBox bold;
       private JCheckBox italic;
       private static final int FONTSIZE = 24;
    
       public CheckBoxFrame()
       {
          // 添加示例文本标签
    
          label = new JLabel("The quick brown fox jumps over the lazy dog.");
          label.setFont(new Font("Serif", Font.BOLD, FONTSIZE));
          add(label, BorderLayout.CENTER);
    
          // 字体属性
          // 复选框状态的标签
    
          ActionListener listener = event -> {
             int mode = 0;
             if (bold.isSelected()) mode += Font.BOLD;
             if (italic.isSelected()) mode += Font.ITALIC;
             label.setFont(new Font("Serif", mode, FONTSIZE));
          };
    
          // 添加复选框
    
          JPanel buttonPanel = new JPanel();
    
          bold = new JCheckBox("Bold");
          bold.addActionListener(listener);
          bold.setSelected(true);
          buttonPanel.add(bold);
    
          italic = new JCheckBox("Italic");
          italic.addActionListener(listener);
          buttonPanel.add(italic);
    
          add(buttonPanel, BorderLayout.SOUTH);
          pack();
       }
    }
    CheckBoxFrame

    测试程序4

    l 在elipse IDE中调试运行教材491页程序12-4,运行结果理解程序;

    l 掌握单选按钮组件的用法;

    l 记录示例代码阅读理解中存在的问题与疑惑。

    package radioButton;
    
    import java.awt.*;
    import javax.swing.*;
    
    /**
     * @version 1.34 2015-06-12
     * @author Cay Horstmann
     */
    public class RadioButtonTest
    {
       public static void main(String[] args)
       {
          EventQueue.invokeLater(() -> {
             JFrame frame = new RadioButtonFrame();
             frame.setTitle("RadioButtonTest");
             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
             frame.setVisible(true);
          });
       }
    }
    RadioButtonTest
    package radioButton;
    
    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    
    /**
     * A frame with a sample text label and radio buttons for selecting font sizes.
     */
    public class RadioButtonFrame extends JFrame//单选按钮
    { //定义四个私有属性
       private JPanel buttonPanel;
       private ButtonGroup group;
       private JLabel label;
       private static final int DEFAULT_SIZE = 36;
    
       public RadioButtonFrame()
       {      
          // add the sample text label
    
          label = new JLabel("The quick brown fox jumps over the lazy dog.");
          label.setFont(new Font("Serif", Font.PLAIN, DEFAULT_SIZE));//设置新字体
          add(label, BorderLayout.CENTER);
    
          // add the radio buttons
    
          buttonPanel = new JPanel();
          group = new ButtonGroup();
         //添加单选框按钮
          addRadioButton("Small", 8);
          addRadioButton("Medium", 12);
          addRadioButton("Large", 18);
          addRadioButton("Extra large", 36);
    
          add(buttonPanel, BorderLayout.SOUTH);
          pack();//调整窗口的大小
       }
    
       /**
        * Adds a radio button that sets the font size of the sample text.
        * @param name the string to appear on the button
        * @param size the font size that this button sets
        */
       public void addRadioButton(String name, int size)
       {
          boolean selected = size == DEFAULT_SIZE;//布尔类型,大小的定义
          JRadioButton button = new JRadioButton(name, selected);
          group.add(button);
          buttonPanel.add(button);
    
          // this listener sets the label font size
          //这个监听器设置标签字体大小
    
          ActionListener listener = event -> label.setFont(new Font("Serif", Font.PLAIN, size));//表明新的字体,大小
    
          button.addActionListener(listener);
       }
    }
    RadioButtonFrame

    测试程序5

    l 在elipse IDE中调试运行教材494页程序12-5,结合运行结果理解程序;

    l 掌握边框的用法;

    l 记录示例代码阅读理解中存在的问题与疑惑。

    package border;
    
    import java.awt.*;
    import javax.swing.*;
    
    /**
     * @version 1.34 2015-06-13
     * @author Cay Horstmann
     */
    public class BorderTest
    {
       public static void main(String[] args)
       {
          EventQueue.invokeLater(() -> {
             JFrame frame = new BorderFrame();
             frame.setTitle("BorderTest");
             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
             frame.setVisible(true);
          });
       }
    }
    BorderTest
    package border;
    
    import java.awt.*;
    import javax.swing.*;
    import javax.swing.border.*;
    
    /**
     * A frame with radio buttons to pick a border style.
     */
    public class BorderFrame extends JFrame
    {
       private JPanel demoPanel;
       private JPanel buttonPanel;
       private ButtonGroup group;
    
       public BorderFrame()
       {
          demoPanel = new JPanel();
          buttonPanel = new JPanel();
          group = new ButtonGroup();
          
          //设置不同的边框类型按钮,共六种(提供标准 Border 对象的工厂类)
          addRadioButton("Lowered bevel", BorderFactory.createLoweredBevelBorder());
          addRadioButton("Raised bevel", BorderFactory.createRaisedBevelBorder());
          addRadioButton("Etched", BorderFactory.createEtchedBorder());
          addRadioButton("Line", BorderFactory.createLineBorder(Color.BLUE));
          addRadioButton("Matte", BorderFactory.createMatteBorder(10, 10, 10, 10, Color.BLUE));
          addRadioButton("Empty", BorderFactory.createEmptyBorder());
          
          Border etched = BorderFactory.createEtchedBorder();
          Border titled = BorderFactory.createTitledBorder(etched, "Border types");
          buttonPanel.setBorder(titled);
    
          setLayout(new GridLayout(2, 1));
          add(buttonPanel);
          add(demoPanel);
          pack();
       }
    
       public void addRadioButton(String buttonName, Border b)
       {
          JRadioButton button = new JRadioButton(buttonName);
          button.addActionListener(event -> demoPanel.setBorder(b));
          group.add(button);
          buttonPanel.add(button);
       }
    }
    BorderFrame

    测试程序6

    l 在elipse IDE中调试运行教材498页程序12-6,结合运行结果理解程序;

    l 掌握组合框组件的用法;

    l 记录示例代码阅读理解中存在的问题与疑惑。

    package comboBox;
    
    import java.awt.*;
    import javax.swing.*;
    
    /**
     * @version 1.35 2015-06-12
     * @author Cay Horstmann
     */
    public class ComboBoxTest
    {
       public static void main(String[] args)
       {
      
          EventQueue.invokeLater(() -> {
         
             JFrame frame = new ComboBoxFrame();
          
             frame.setTitle("ComboBoxTest");
            
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
          
             frame.setVisible(true);
          });
       }
    }
    ComboBoxTest
    package comboBox;
    
    import java.awt.BorderLayout;
    import java.awt.Font;
    
    import javax.swing.JComboBox;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JPanel;
    
    /**
     * A frame with a sample text label and a combo box for selecting font faces.
     */
    public class ComboBoxFrame extends JFrame
    {
       private JComboBox<String> faceCombo;//定义组合框面
       private JLabel label;//定义标签
       private static final int DEFAULT_SIZE = 24;
    
       public ComboBoxFrame()
       {
          // add the sample text label
    
          label = new JLabel("The quick brown fox jumps over the lazy dog.");
          label.setFont(new Font("Serif", Font.PLAIN, DEFAULT_SIZE));//设置组件的字体
          add(label, BorderLayout.CENTER);
    
          // make a combo box and add face names
          //调用addItem方法添加选项
          faceCombo = new JComboBox<>();
          faceCombo.addItem("Serif");
          faceCombo.addItem("SansSerif");
          faceCombo.addItem("Monospaced");
          faceCombo.addItem("Dialog");
          faceCombo.addItem("DialogInput");
    
          // the combo box listener changes the label font to the selected face name
    
          faceCombo.addActionListener(event ->//组合框产生一个动作事件
             label.setFont(
                new Font(faceCombo.getItemAt(faceCombo.getSelectedIndex()), 
                   Font.PLAIN, DEFAULT_SIZE)));
    
          // add combo box to a panel at the frame's southern border
    
          JPanel comboPanel = new JPanel();
          comboPanel.add(faceCombo);
          add(comboPanel, BorderLayout.SOUTH);
          pack();
       }
    }
    ComboBoxFrame

    测试程序7

    l 在elipse IDE中调试运行教材501页程序12-7,结合运行结果理解程序;

    l 掌握滑动条组件的用法;

    l 记录示例代码阅读理解中存在的问题与疑惑。

    package slider;
    
    import java.awt.*;
    import javax.swing.*;
    
    /**
     * @version 1.15 2015-06-12
     * @author Cay Horstmann
     */
    public class SliderTest
    {
       public static void main(String[] args)
       {
          EventQueue.invokeLater(() -> {
             SliderFrame frame = new SliderFrame();
             frame.setTitle("SliderTest");
             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
             frame.setVisible(true);
          });
       }
    }
    SliderTest
    package slider;
    
    import java.awt.*;
    import java.util.*;
    import javax.swing.*;
    import javax.swing.event.*;
    
    /**
     * A frame with many sliders and a text field to show slider values.
     */
    public class SliderFrame extends JFrame {
        private JPanel sliderPanel;
        private JTextField textField;
        private ChangeListener listener;
    
        public SliderFrame() {
            sliderPanel = new JPanel();
            sliderPanel.setLayout(new GridBagLayout());
    
            // common listener for all sliders
            listener = event -> {
                // update text field when the slider value changes
                JSlider source = (JSlider) event.getSource();
                textField.setText("" + source.getValue());
            };
    
            // add a plain slider
    
            JSlider slider = new JSlider();
            addSlider(slider, "Plain");
    
            // add a slider with major and minor ticks
    
            slider = new JSlider();
            slider.setPaintTicks(true);
            slider.setMajorTickSpacing(20);
            slider.setMinorTickSpacing(5);
            addSlider(slider, "Ticks");
    
            // add a slider that snaps to ticks
    
            slider = new JSlider();
            slider.setPaintTicks(true);
            slider.setSnapToTicks(true);
            slider.setMajorTickSpacing(20);
            slider.setMinorTickSpacing(5);
            addSlider(slider, "Snap to ticks");
    
            // add a slider with no track
    
            slider = new JSlider();
            slider.setPaintTicks(true);
            slider.setMajorTickSpacing(20);
            slider.setMinorTickSpacing(5);
            slider.setPaintTrack(false);
            addSlider(slider, "No track");
    
            // add an inverted slider
    
            slider = new JSlider();
            slider.setPaintTicks(true);
            slider.setMajorTickSpacing(20);
            slider.setMinorTickSpacing(5);
            slider.setInverted(true);
            addSlider(slider, "Inverted");
    
            // add a slider with numeric labels
    
            slider = new JSlider();
            slider.setPaintTicks(true);
            slider.setPaintLabels(true);
            slider.setMajorTickSpacing(20);
            slider.setMinorTickSpacing(5);
            addSlider(slider, "Labels");
    
            // add a slider with alphabetic labels
    
            slider = new JSlider();
            slider.setPaintLabels(true);
            slider.setPaintTicks(true);
            slider.setMajorTickSpacing(20);
            slider.setMinorTickSpacing(5);
    
            Dictionary<Integer, Component> labelTable = new Hashtable<>();
            labelTable.put(0, new JLabel("A"));
            labelTable.put(20, new JLabel("B"));
            labelTable.put(40, new JLabel("C"));
            labelTable.put(60, new JLabel("D"));
            labelTable.put(80, new JLabel("E"));
            labelTable.put(100, new JLabel("F"));
    
            slider.setLabelTable(labelTable);
            addSlider(slider, "Custom labels");
    
            // add a slider with icon labels
    
            slider = new JSlider();
            slider.setPaintTicks(true);// 显示标记
            slider.setPaintLabels(true);// 确定是否在滑块上绘制标签
            slider.setSnapToTicks(true);// 最靠近用户放置滑块处的刻度标记的值
            slider.setMajorTickSpacing(20);// 大标尺标记
            slider.setMinorTickSpacing(20);// 小标尺标记
    
            labelTable = new Hashtable<Integer, Component>();
    
            // add card images
    
            labelTable.put(0, new JLabel(new ImageIcon("nine.gif")));
            labelTable.put(20, new JLabel(new ImageIcon("ten.gif")));
            labelTable.put(40, new JLabel(new ImageIcon("jack.gif")));
            labelTable.put(60, new JLabel(new ImageIcon("queen.gif")));
            labelTable.put(80, new JLabel(new ImageIcon("king.gif")));
            labelTable.put(100, new JLabel(new ImageIcon("ace.gif")));
    
            slider.setLabelTable(labelTable);
            addSlider(slider, "Icon labels");
    
            // add the text field that displays the slider value
    
            textField = new JTextField();
            add(sliderPanel, BorderLayout.CENTER);
            add(textField, BorderLayout.SOUTH);
            pack();
        }
    
        /**
         * Adds a slider to the slider panel and hooks up the listener
         * 
         * @param s           the slider
         * @param description the slider description
         */
        public void addSlider(JSlider s, String description) {
            s.addChangeListener(listener);
            JPanel panel = new JPanel();
            panel.add(s);
            panel.add(new JLabel(description));
            panel.setAlignmentX(Component.LEFT_ALIGNMENT);
            GridBagConstraints gbc = new GridBagConstraints();
            gbc.gridy = sliderPanel.getComponentCount();
            gbc.anchor = GridBagConstraints.WEST;
            sliderPanel.add(panel, gbc);
        }
    }
    SliderFrame

    测试程序8

    l 在elipse IDE中调试运行教材512页程序12-8,结合运行结果理解程序;

    l 掌握菜单的创建、菜单事件监听器、复选框和单选按钮菜单项、弹出菜单以及快捷键和加速器的用法。

    l 记录示例代码阅读理解中存在的问题与疑惑。

    package menu;
    
    import java.awt.*;
    import javax.swing.*;
    
    /**
     * @version 1.24 2012-06-12
     * @author Cay Horstmann
     */
    public class MenuTest
    {
       public static void main(String[] args)
       {
          EventQueue.invokeLater(() -> {
             JFrame frame = new MenuFrame();
             frame.setTitle("MenuTest");
             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
             frame.setVisible(true);
          });
       }
    }
    MenuTest
    package menu;
    
    import java.awt.event.*;
    import javax.swing.*;
    
    /**
     * A frame with a sample menu bar.
     */
    public class MenuFrame extends JFrame
    {
       private static final int DEFAULT_WIDTH = 300;
       private static final int DEFAULT_HEIGHT = 200;
       private Action saveAction;
       private Action saveAsAction;
       private JCheckBoxMenuItem readonlyItem;
       private JPopupMenu popup;
    
       /**
        * A sample action that prints the action name to System.out
        */
       class TestAction extends AbstractAction
       {
          public TestAction(String name)
          {
             super(name);
          }
    
          public void actionPerformed(ActionEvent event)
          {
             System.out.println(getValue(Action.NAME) + " selected.");
          }
       }
    
       public MenuFrame()
       {
          setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
    
          JMenu fileMenu = new JMenu("File");
          fileMenu.add(new TestAction("New"));
    
          //演示加速器
    
          JMenuItem openItem = fileMenu.add(new TestAction("Open"));
          openItem.setAccelerator(KeyStroke.getKeyStroke("ctrl O"));
    
          fileMenu.addSeparator();
    
          saveAction = new TestAction("Save");
          JMenuItem saveItem = fileMenu.add(saveAction);
          saveItem.setAccelerator(KeyStroke.getKeyStroke("ctrl S"));
    
          saveAsAction = new TestAction("Save As");
          fileMenu.add(saveAsAction);
          fileMenu.addSeparator();
    
          fileMenu.add(new AbstractAction("Exit")
             {
                public void actionPerformed(ActionEvent event)
                {
                   System.exit(0);
                }
             });
    
          //演示复选框和单选按钮菜单
    
          readonlyItem = new JCheckBoxMenuItem("Read-only");
          readonlyItem.addActionListener(new ActionListener()
             {
                public void actionPerformed(ActionEvent event)
                {
                   boolean saveOk = !readonlyItem.isSelected();
                   saveAction.setEnabled(saveOk);
                   saveAsAction.setEnabled(saveOk);
                }
             });
    
          ButtonGroup group = new ButtonGroup();
    
          JRadioButtonMenuItem insertItem = new JRadioButtonMenuItem("Insert");
          insertItem.setSelected(true);
          JRadioButtonMenuItem overtypeItem = new JRadioButtonMenuItem("Overtype");
    
          group.add(insertItem);
          group.add(overtypeItem);
    
          //演示图标
    
          Action cutAction = new TestAction("Cut");
          cutAction.putValue(Action.SMALL_ICON, new ImageIcon("cut.gif"));
          Action copyAction = new TestAction("Copy");
          copyAction.putValue(Action.SMALL_ICON, new ImageIcon("copy.gif"));
          Action pasteAction = new TestAction("Paste");
          pasteAction.putValue(Action.SMALL_ICON, new ImageIcon("paste.gif"));
    
          JMenu editMenu = new JMenu("Edit");
          editMenu.add(cutAction);
          editMenu.add(copyAction);
          editMenu.add(pasteAction);
    
          // 演示嵌套菜单
    
          JMenu optionMenu = new JMenu("Options");
    
          optionMenu.add(readonlyItem);
          optionMenu.addSeparator();
          optionMenu.add(insertItem);
          optionMenu.add(overtypeItem);
    
          editMenu.addSeparator();
          editMenu.add(optionMenu);
    
          // 说明助记符
    
          JMenu helpMenu = new JMenu("Help");
          helpMenu.setMnemonic('H');
    
          JMenuItem indexItem = new JMenuItem("Index");
          indexItem.setMnemonic('I');
          helpMenu.add(indexItem);
    
          //您还可以向操作添加助记符键
          Action aboutAction = new TestAction("About");
          aboutAction.putValue(Action.MNEMONIC_KEY, new Integer('A'));
          helpMenu.add(aboutAction);
          
          // 将所有顶级菜单添加到菜单栏
    
          JMenuBar menuBar = new JMenuBar();
          setJMenuBar(menuBar);
    
          menuBar.add(fileMenu);
          menuBar.add(editMenu);
          menuBar.add(helpMenu);
    
          // 显示弹出窗口
    
          popup = new JPopupMenu();
          popup.add(cutAction);
          popup.add(copyAction);
          popup.add(pasteAction);
    
          JPanel panel = new JPanel();
          panel.setComponentPopupMenu(popup);
          add(panel);
       }
    MenuFrame

    测试程序9

    l 在elipse IDE中调试运行教材517页程序12-9,结合运行结果理解程序;

    l 掌握工具栏和工具提示的用法;

    l 记录示例代码阅读理解中存在的问题与疑惑。

    package toolBar;
    
    import java.awt.*;
    import javax.swing.*;
    
    /**
     * @version 1.14 2015-06-12
     * @author Cay Horstmann
     */
    public class ToolBarTest
    {
       public static void main(String[] args)
       {
          EventQueue.invokeLater(() -> {
             ToolBarFrame frame = new ToolBarFrame();
             frame.setTitle("ToolBarTest");
             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
             frame.setVisible(true);
          });
       }
    }
    ToolBarTest
    package toolBar;
    
    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    
    /**
     * A frame with a toolbar and menu for color changes.
     */
    public class ToolBarFrame extends JFrame
    {  //定义两个私有属性
       private static final int DEFAULT_WIDTH = 300;
       private static final int DEFAULT_HEIGHT = 200;
       private JPanel panel;
    
       public ToolBarFrame() //定义工具提示类
       {
          setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
    
          // add a panel for color change
    
          panel = new JPanel();//创建新的JPanel
          add(panel, BorderLayout.CENTER);
    
          // set up actions
          //建立动作
    
          Action blueAction = new ColorAction("Blue", new ImageIcon("blue-ball.gif"), Color.BLUE);
          Action yellowAction = new ColorAction("Yellow", new ImageIcon("yellow-ball.gif"),
                Color.YELLOW);
          Action redAction = new ColorAction("Red", new ImageIcon("red-ball.gif"), Color.RED);
    
          Action exitAction = new AbstractAction("Exit", new ImageIcon("exit.gif"))
             {
                public void actionPerformed(ActionEvent event)
                {
                   System.exit(0);
                }
             };
          exitAction.putValue(Action.SHORT_DESCRIPTION, "Exit");
    
          // populate toolbar
    
          JToolBar bar = new JToolBar();
          bar.add(blueAction);//用Action对象填充工具栏
          bar.add(yellowAction);
          bar.add(redAction);
          bar.addSeparator();//用分隔符将按钮分组
          bar.add(exitAction);
          add(bar, BorderLayout.NORTH);
    
          // populate menu
    
          JMenu menu = new JMenu("Color");//显示颜色的菜单
          menu.add(yellowAction);//在菜单添加颜色动作
          menu.add(blueAction);
          menu.add(redAction);
          menu.add(exitAction);
          JMenuBar menuBar = new JMenuBar();
          menuBar.add(menu);
          setJMenuBar(menuBar);
       }
    
       /**
        * The color action sets the background of the frame to a given color.
        */
       class ColorAction extends AbstractAction
       {
          public ColorAction(String name, Icon icon, Color c)
          {
             putValue(Action.NAME, name);//动作名称,显示在按钮和菜单
             putValue(Action.SMALL_ICON, icon);//存储小图标的地方;显示在按钮、菜单项或工具栏中
             putValue(Action.SHORT_DESCRIPTION, name + " background");
             putValue("Color", c);
          }
    
          public void actionPerformed(ActionEvent event)
          {
             Color c = (Color) getValue("Color");
             panel.setBackground(c);
          }
       }
    }
    ToolBarFrame

    测试程序10

    l 在elipse IDE中调试运行教材524页程序12-10、12-11,结合运行结果理解程序,了解GridbagLayout的用法。

    l 在elipse IDE中调试运行教材533页程序12-12,结合程序运行结果理解程序,了解GroupLayout的用法。

    l 记录示例代码阅读理解中存在的问题与疑惑。

    package gridbag;
    
    import java.awt.EventQueue;
    
    import javax.swing.JFrame;
    
    /**
     * @version 1.35 2015-06-12
     * @author Cay Horstmann
     */
    public class GridBagLayoutTest {
        public static void main(String[] args) {
            EventQueue.invokeLater(() -> {
                JFrame frame = new FontFrame();
                frame.setTitle("GridBagLayoutTest");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
            });
        }
    }
    GridBagLayoutTest
    package gridbag;
    
    import java.awt.Font;
    import java.awt.GridBagLayout;
    import java.awt.event.ActionListener;
    
    import javax.swing.BorderFactory;
    import javax.swing.JCheckBox;
    import javax.swing.JComboBox;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JTextArea;
    
    /**
     * A frame that uses a grid bag layout to arrange font selection components.
     */
    public class FontFrame extends JFrame
    {
       public static final int TEXT_ROWS = 10;
       public static final int TEXT_COLUMNS = 20;
    
       private JComboBox<String> face;
       private JComboBox<Integer> size;
       private JCheckBox bold;
       private JCheckBox italic;
       private JTextArea sample;
    
       public FontFrame()
       {
          GridBagLayout layout = new GridBagLayout();
          setLayout(layout);
    
          ActionListener listener = event -> updateSample();
    
          // 构建组件
    
          JLabel faceLabel = new JLabel("Face: ");
    
          face = new JComboBox<>(new String[] { "Serif", "SansSerif", "Monospaced",
                "Dialog", "DialogInput" });
    
          face.addActionListener(listener);
    
          JLabel sizeLabel = new JLabel("Size: ");
    
          size = new JComboBox<>(new Integer[] { 8, 10, 12, 15, 18, 24, 36, 48 });
    
          size.addActionListener(listener);
    
          bold = new JCheckBox("Bold");
          bold.addActionListener(listener);
    
          italic = new JCheckBox("Italic");
          italic.addActionListener(listener);
    
          sample = new JTextArea(TEXT_ROWS, TEXT_COLUMNS);
          sample.setText("The quick brown fox jumps over the lazy dog");
          sample.setEditable(false);
          sample.setLineWrap(true);
          sample.setBorder(BorderFactory.createEtchedBorder());
    
          // 使用GBC便利类向网格添加组件
    
          add(faceLabel, new GBC(0, 0).setAnchor(GBC.EAST));
          add(face, new GBC(1, 0).setFill(GBC.HORIZONTAL).setWeight(100, 0)
                .setInsets(1));
          add(sizeLabel, new GBC(0, 1).setAnchor(GBC.EAST));
          add(size, new GBC(1, 1).setFill(GBC.HORIZONTAL).setWeight(100, 0)
                .setInsets(1));
          add(bold, new GBC(0, 2, 2, 1).setAnchor(GBC.CENTER).setWeight(100, 100));
          add(italic, new GBC(0, 3, 2, 1).setAnchor(GBC.CENTER).setWeight(100, 100));
          add(sample, new GBC(2, 0, 1, 4).setFill(GBC.BOTH).setWeight(100, 100));
          pack();
          updateSample();
       }
    
       public void updateSample()
       {
          String fontFace = (String) face.getSelectedItem();
          int fontStyle = (bold.isSelected() ? Font.BOLD : 0)
                + (italic.isSelected() ? Font.ITALIC : 0);
          int fontSize = size.getItemAt(size.getSelectedIndex());
          Font font = new Font(fontFace, fontStyle, fontSize);
          sample.setFont(font);
          sample.repaint();
       }
    FontFrame
    package gridbag;
    
    import java.awt.*;
    
    /**
     * This class simplifies the use of the GridBagConstraints class.
     * 
     * @version 1.01 2004-05-06
     * @author Cay Horstmann
     */
    public class GBC extends GridBagConstraints {
        /**
         * Constructs a GBC with a given gridx and gridy position and all other grid bag
         * constraint values set to the default.
         * 
         * @param gridx the gridx position
         * @param gridy the gridy position
         */
        public GBC(int gridx, int gridy) {
            this.gridx = gridx;
            this.gridy = gridy;
        }
    
        /**
         * Constructs a GBC with given gridx, gridy, gridwidth, gridheight and all other
         * grid bag constraint values set to the default.
         * 
         * @param gridx      the gridx position
         * @param gridy      the gridy position
         * @param gridwidth  the cell span in x-direction
         * @param gridheight the cell span in y-direction
         */
        public GBC(int gridx, int gridy, int gridwidth, int gridheight) {
            this.gridx = gridx;
            this.gridy = gridy;
            this.gridwidth = gridwidth;
            this.gridheight = gridheight;
        }
    
        /**
         * Sets the anchor.
         * 
         * @param anchor the anchor value
         * @return this object for further modification
         */
        public GBC setAnchor(int anchor) {
            this.anchor = anchor;
            return this;
        }
    
        /**
         * Sets the fill direction.
         * 
         * @param fill the fill direction
         * @return this object for further modification
         */
        public GBC setFill(int fill) {
            this.fill = fill;
            return this;
        }
    
        /**
         * Sets the cell weights.
         * 
         * @param weightx the cell weight in x-direction
         * @param weighty the cell weight in y-direction
         * @return this object for further modification
         */
        public GBC setWeight(double weightx, double weighty) {
            this.weightx = weightx;
            this.weighty = weighty;
            return this;
        }
    
        /**
         * Sets the insets of this cell.
         * 
         * @param distance the spacing to use in all directions
         * @return this object for further modification
         */
        public GBC setInsets(int distance) {
            this.insets = new Insets(distance, distance, distance, distance);
            return this;
        }
    
        /**
         * Sets the insets of this cell.
         * 
         * @param top    the spacing to use on top
         * @param left   the spacing to use to the left
         * @param bottom the spacing to use on the bottom
         * @param right  the spacing to use to the right
         * @return this object for further modification
         */
        public GBC setInsets(int top, int left, int bottom, int right) {
            this.insets = new Insets(top, left, bottom, right);
            return this;
        }
    
        /**
         * Sets the internal padding
         * 
         * @param ipadx the internal padding in x-direction
         * @param ipady the internal padding in y-direction
         * @return this object for further modification
         */
        public GBC setIpad(int ipadx, int ipady) {
            this.ipadx = ipadx;
            this.ipady = ipady;
            return this;
        }
    }
    GBC

    package groupLayout;
    
    import java.awt.EventQueue;
    
    import javax.swing.JFrame;
    
    /**
     * @version 1.01 2015-06-12
     * @author Cay Horstmann
     */
    public class GroupLayoutTest {
        public static void main(String[] args) {
            EventQueue.invokeLater(() -> {
                JFrame frame = new FontFrame();
                frame.setTitle("GroupLayoutTest");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
            });
        }
    }
    GroupLayoutTest
    package groupLayout;
    
    import java.awt.Font;
    import java.awt.event.ActionListener;
    
    import javax.swing.BorderFactory;
    import javax.swing.GroupLayout;
    import javax.swing.JCheckBox;
    import javax.swing.JComboBox;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JScrollPane;
    import javax.swing.JTextArea;
    import javax.swing.LayoutStyle;
    import javax.swing.SwingConstants;
    
    /**
     * A frame that uses a group layout to arrange font selection components.
     */
    public class FontFrame extends JFrame {
        public static final int TEXT_ROWS = 10;
        public static final int TEXT_COLUMNS = 20;
    
        private JComboBox<String> face;
        private JComboBox<Integer> size;
        private JCheckBox bold;
        private JCheckBox italic;
        private JScrollPane pane;
        private JTextArea sample;
    
        public FontFrame() {
            ActionListener listener = event -> updateSample();
    
            // construct components
    
            JLabel faceLabel = new JLabel("Face: ");
    
            face = new JComboBox<>(new String[] { "Serif", "SansSerif", "Monospaced", "Dialog", "DialogInput" });
    
            face.addActionListener(listener);
    
            JLabel sizeLabel = new JLabel("Size: ");
    
            size = new JComboBox<>(new Integer[] { 8, 10, 12, 15, 18, 24, 36, 48 });
    
            size.addActionListener(listener);
    
            bold = new JCheckBox("Bold");
            bold.addActionListener(listener);
    
            italic = new JCheckBox("Italic");
            italic.addActionListener(listener);
    
            sample = new JTextArea(TEXT_ROWS, TEXT_COLUMNS);
            sample.setText("The quick brown fox jumps over the lazy dog");
            sample.setEditable(false);
            sample.setLineWrap(true);
            sample.setBorder(BorderFactory.createEtchedBorder());
    
            pane = new JScrollPane(sample);
    
            GroupLayout layout = new GroupLayout(getContentPane());
            setLayout(layout);
            layout.setHorizontalGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)
                    .addGroup(layout.createSequentialGroup().addContainerGap()
                            .addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)
                                    .addGroup(GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                                            .addGroup(layout.createParallelGroup(GroupLayout.Alignment.TRAILING)
                                                    .addComponent(faceLabel).addComponent(sizeLabel))
                                            .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED)
                                            .addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING, false)
                                                    .addComponent(size).addComponent(face)))
                                    .addComponent(italic).addComponent(bold))
                            .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED).addComponent(pane).addContainerGap()));
    
            layout.linkSize(SwingConstants.HORIZONTAL, new java.awt.Component[] { face, size });
    
            layout.setVerticalGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)
                    .addGroup(layout.createSequentialGroup().addContainerGap()
                            .addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)
                                    .addComponent(pane, GroupLayout.Alignment.TRAILING)
                                    .addGroup(layout.createSequentialGroup()
                                            .addGroup(layout.createParallelGroup(GroupLayout.Alignment.BASELINE)
                                                    .addComponent(face).addComponent(faceLabel))
                                            .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED)
                                            .addGroup(layout.createParallelGroup(GroupLayout.Alignment.BASELINE)
                                                    .addComponent(size).addComponent(sizeLabel))
                                            .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED)
                                            .addComponent(italic, GroupLayout.DEFAULT_SIZE, GroupLayout.DEFAULT_SIZE,
                                                    Short.MAX_VALUE)
                                            .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED).addComponent(bold,
                                                    GroupLayout.DEFAULT_SIZE, GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)))
                            .addContainerGap()));
            pack();
        }
    
        public void updateSample() {
            String fontFace = (String) face.getSelectedItem();
            int fontStyle = (bold.isSelected() ? Font.BOLD : 0) + (italic.isSelected() ? Font.ITALIC : 0);
            int fontSize = size.getItemAt(size.getSelectedIndex());
            Font font = new Font(fontFace, fontStyle, fontSize);
            sample.setFont(font);
            sample.repaint();
        }
    }
    FontFrame

    测试程序11

    l 在elipse IDE中调试运行教材539页程序12-13、12-14,结合运行结果理解程序;

    l 掌握定制布局管理器的用法。

    l 记录示例代码阅读理解中存在的问题与疑惑。

    package circleLayout;
    
    import java.awt.*;
    import javax.swing.*;
    
    /**
     * @version 1.33 2015-06-12
     * @author Cay Horstmann
     */
    public class CircleLayoutTest {
        public static void main(String[] args) {
            EventQueue.invokeLater(() -> {
                JFrame frame = new CircleLayoutFrame();
                frame.setTitle("CircleLayoutTest");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
            });
        }
    }
    CircleLayoutTest
    package circleLayout;
    
    import javax.swing.*;
    
    /**
     * A frame that shows buttons arranged along a circle.
     */
    public class CircleLayoutFrame extends JFrame {
        public CircleLayoutFrame() {
            setLayout(new CircleLayout());
            add(new JButton("Yellow"));
            add(new JButton("Blue"));
            add(new JButton("Red"));
            add(new JButton("Green"));
            add(new JButton("Orange"));
            add(new JButton("Fuchsia"));
            add(new JButton("Indigo"));
            pack();
        }
    }
    CircleLayoutFrame
    package circleLayout;
    
    import java.awt.*;
    
    /**
     * A layout manager that lays out components along a circle.
     */
    public class CircleLayout implements LayoutManager {
        private int minWidth = 0;
        private int minHeight = 0;
        private int preferredWidth = 0;
        private int preferredHeight = 0;
        private boolean sizesSet = false;
        private int maxComponentWidth = 0;
        private int maxComponentHeight = 0;
    
        public void addLayoutComponent(String name, Component comp) {
        }
    
        public void removeLayoutComponent(Component comp) {
        }
    
        public void setSizes(Container parent) {
            if (sizesSet)
                return;
            int n = parent.getComponentCount();
    
            preferredWidth = 0;
            preferredHeight = 0;
            minWidth = 0;
            minHeight = 0;
            maxComponentWidth = 0;
            maxComponentHeight = 0;
    
            // compute the maximum component widths and heights
            // and set the preferred size to the sum of the component sizes.
            for (int i = 0; i < n; i++) {
                Component c = parent.getComponent(i);
                if (c.isVisible()) {
                    Dimension d = c.getPreferredSize();
                    maxComponentWidth = Math.max(maxComponentWidth, d.width);
                    maxComponentHeight = Math.max(maxComponentHeight, d.height);
                    preferredWidth += d.width;
                    preferredHeight += d.height;
                }
            }
            minWidth = preferredWidth / 2;
            minHeight = preferredHeight / 2;
            sizesSet = true;
        }
    
        public Dimension preferredLayoutSize(Container parent) {
            setSizes(parent);
            Insets insets = parent.getInsets();
            int width = preferredWidth + insets.left + insets.right;
            int height = preferredHeight + insets.top + insets.bottom;
            return new Dimension(width, height);
        }
    
        public Dimension minimumLayoutSize(Container parent) {
            setSizes(parent);
            Insets insets = parent.getInsets();
            int width = minWidth + insets.left + insets.right;
            int height = minHeight + insets.top + insets.bottom;
            return new Dimension(width, height);
        }
    
        public void layoutContainer(Container parent) {
            setSizes(parent);
    
            // compute center of the circle
    
            Insets insets = parent.getInsets();
            int containerWidth = parent.getSize().width - insets.left - insets.right;
            int containerHeight = parent.getSize().height - insets.top - insets.bottom;
    
            int xcenter = insets.left + containerWidth / 2;
            int ycenter = insets.top + containerHeight / 2;
    
            // compute radius of the circle
    
            int xradius = (containerWidth - maxComponentWidth) / 2;
            int yradius = (containerHeight - maxComponentHeight) / 2;
            int radius = Math.min(xradius, yradius);
    
            // lay out components along the circle
    
            int n = parent.getComponentCount();
            for (int i = 0; i < n; i++) {
                Component c = parent.getComponent(i);
                if (c.isVisible()) {
                    double angle = 2 * Math.PI * i / n;
    
                    // center point of component
                    int x = xcenter + (int) (Math.cos(angle) * radius);
                    int y = ycenter + (int) (Math.sin(angle) * radius);
    
                    // move component so that its center is (x, y)
                    // and its size is its preferred size
                    Dimension d = c.getPreferredSize();
                    c.setBounds(x - d.width / 2, y - d.height / 2, d.width, d.height);
                }
            }
        }
    }
    CircleLayout

    测试程序12

    l 在elipse IDE中调试运行教材544页程序12-15、12-16,结合运行结果理解程序;

    l 掌握选项对话框的用法。

    l 记录示例代码阅读理解中存在的问题与疑惑。

    package optionDialog;
    
    import java.awt.*;
    import javax.swing.*;
    
    /**
     * @version 1.34 2015-06-12
     * @author Cay Horstmann
     */
    public class OptionDialogTest {
        public static void main(String[] args) {
            EventQueue.invokeLater(() -> {
                JFrame frame = new OptionDialogFrame();
                frame.setTitle("OptionDialogTest");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
            });
        }
    }
    OptionDialogTest
    package optionDialog;
    
    import java.awt.*;
    import java.awt.event.*;
    import java.awt.geom.*;
    import java.util.*;
    import javax.swing.*;
    
    /**
     * A frame that contains settings for selecting various option dialogs.
     */
    public class OptionDialogFrame extends JFrame {
        private ButtonPanel typePanel;
        private ButtonPanel messagePanel;
        private ButtonPanel messageTypePanel;
        private ButtonPanel optionTypePanel;
        private ButtonPanel optionsPanel;
        private ButtonPanel inputPanel;
        private String messageString = "Message";
        private Icon messageIcon = new ImageIcon("blue-ball.gif");
        private Object messageObject = new Date();
        private Component messageComponent = new SampleComponent();
    
        public OptionDialogFrame() {
            JPanel gridPanel = new JPanel();
            gridPanel.setLayout(new GridLayout(2, 3));//创建2行3列的网格布局
    
            typePanel = new ButtonPanel("Type", "Message", "Confirm", "Option", "Input");
            messageTypePanel = new ButtonPanel("Message Type", "ERROR_MESSAGE", "INFORMATION_MESSAGE", "WARNING_MESSAGE",
                    "QUESTION_MESSAGE", "PLAIN_MESSAGE");
            messagePanel = new ButtonPanel("Message", "String", "Icon", "Component", "Other", "Object[]");
            optionTypePanel = new ButtonPanel("Confirm", "DEFAULT_OPTION", "YES_NO_OPTION", "YES_NO_CANCEL_OPTION",
                    "OK_CANCEL_OPTION");
            optionsPanel = new ButtonPanel("Option", "String[]", "Icon[]", "Object[]");
            inputPanel = new ButtonPanel("Input", "Text field", "Combo box");
    
            gridPanel.add(typePanel);
            gridPanel.add(messageTypePanel);
            gridPanel.add(messagePanel);
            gridPanel.add(optionTypePanel);
            gridPanel.add(optionsPanel);
            gridPanel.add(inputPanel);//添加按钮
    
            // add a panel with a Show button
    
            JPanel showPanel = new JPanel();
            JButton showButton = new JButton("Show");//创建一个带"Show"的按钮。
            showButton.addActionListener(new ShowAction());
            showPanel.add(showButton);
    
            add(gridPanel, BorderLayout.CENTER);//中间区域的布局约束(容器中央)。
            add(showPanel, BorderLayout.SOUTH);//南区域的布局约束(容器底部)。
            pack();
        }
    
        /**
         * Gets the currently selected message.
         * 
         * @return a string, icon, component, or object array, depending on the Message
         *         panel selection
         */
        public Object getMessage() {
            String s = messagePanel.getSelection();
            if (s.equals("String"))//将此字符串与指定的对象比较
                return messageString;
            else if (s.equals("Icon"))
                return messageIcon;
            else if (s.equals("Component"))
                return messageComponent;
            else if (s.equals("Object[]"))
                return new Object[] { messageString, messageIcon, messageComponent, messageObject };
            else if (s.equals("Other"))
                return messageObject;
            else
                return null;
        }
    
        /**
         * Gets the currently selected options.
         * 
         * @return an array of strings, icons, or objects, depending on the Option panel
         *         selection
         */
        public Object[] getOptions() {
            String s = optionsPanel.getSelection();
            if (s.equals("String[]"))
                return new String[] { "Yellow", "Blue", "Red" };
            else if (s.equals("Icon[]"))
                return new Icon[] { new ImageIcon("yellow-ball.gif"), new ImageIcon("blue-ball.gif"),
                        new ImageIcon("red-ball.gif") };
            else if (s.equals("Object[]"))
                return new Object[] { messageString, messageIcon, messageComponent, messageObject };
            else
                return null;
        }
    
        /**
         * Gets the selected message or option type
         * 
         * @param panel the Message Type or Confirm panel
         * @return the selected XXX_MESSAGE or XXX_OPTION constant from the JOptionPane
         *         class
         */
        public int getType(ButtonPanel panel) {
            String s = panel.getSelection();
            try {
                return JOptionPane.class.getField(s).getInt(null);
            } catch (Exception e) {
                return -1;
            }
        }
    
        /**
         * The action listener for the Show button shows a Confirm, Input, Message, or
         * Option dialog depending on the Type panel selection.
         */
        private class ShowAction implements ActionListener {
            public void actionPerformed(ActionEvent event) {
                if (typePanel.getSelection().equals("Confirm"))
                    JOptionPane.showConfirmDialog(OptionDialogFrame.this, getMessage(), "Title", getType(optionTypePanel),
                            getType(messageTypePanel));
                else if (typePanel.getSelection().equals("Input")) {
                    if (inputPanel.getSelection().equals("Text field"))
                        JOptionPane.showInputDialog(OptionDialogFrame.this, getMessage(), "Title",
                                getType(messageTypePanel));
                    else
                        JOptionPane.showInputDialog(OptionDialogFrame.this, getMessage(), "Title",
                                getType(messageTypePanel), null, new String[] { "Yellow", "Blue", "Red" }, "Blue");
                } else if (typePanel.getSelection().equals("Message"))
                    JOptionPane.showMessageDialog(OptionDialogFrame.this, getMessage(), "Title", getType(messageTypePanel));
                else if (typePanel.getSelection().equals("Option"))
                    JOptionPane.showOptionDialog(OptionDialogFrame.this, getMessage(), "Title", getType(optionTypePanel),
                            getType(messageTypePanel), null, getOptions(), getOptions()[0]);
            }
        }
    }
    
    /**
     * A component with a painted surface
     */
    
    class SampleComponent extends JComponent {
        public void paintComponent(Graphics g) {
            Graphics2D g2 = (Graphics2D) g;
            Rectangle2D rect = new Rectangle2D.Double(0, 0, getWidth() - 1, getHeight() - 1);//根据指定的 double 坐标构造和初始化 Rectangle2D
            g2.setPaint(Color.YELLOW);
            g2.fill(rect);
            g2.setPaint(Color.BLUE);
            g2.draw(rect);
        }
    
        public Dimension getPreferredSize() {
            return new Dimension(10, 10);//构造一个 Dimension,并将其初始化为指定宽度和高度。
        }
    }
    OptionDialogFrame
    package optionDialog;
    
    import javax.swing.*;
    
    /**
     * A panel with radio buttons inside a titled border.
     */
    public class ButtonPanel extends JPanel {
        private ButtonGroup group;
    
        /**
         * Constructs a button panel.
         * 
         * @param title   the title shown in the border
         * @param options an array of radio button labels
         */
        public ButtonPanel(String title, String... options) {
            setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(), title));//设置组件的边框,向现有边框添加一个标题
            setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));//从上到下垂直布置组件
            group = new ButtonGroup();
    
            // make one radio button for each option
            for (String option : options) {
                JRadioButton b = new JRadioButton(option);//创建一个具有指定文本的状态为未选择的单选按钮
                b.setActionCommand(option);//设置此按钮的动作命令
                add(b);
                group.add(b);//将按钮添加到组中
                b.setSelected(option == options[0]);//设置按钮的状态
            }
        }
    
        /**
         * Gets the currently selected option.
         * 
         * @return the label of the currently selected radio button.
         */
        public String getSelection() {
            return group.getSelection().getActionCommand();//返回该按钮的动作命令字符串
        }
    }
    ButtonPanel

    测试程序13

    l 在elipse IDE中调试运行教材552页程序12-17、12-18,结合运行结果理解程序;

    l 掌握对话框的创建方法;

    l 记录示例代码阅读理解中存在的问题与疑惑。

    第十三小组负责的部分

    package dialog;
    
    import java.awt.*;
    import javax.swing.*;
    
    /**
     * @version 1.34 2012-06-12
     * @author Cay Horstmann
     */
    public class DialogTest
    {
       public static void main(String[] args)
       {
          EventQueue.invokeLater(() -> {
             JFrame frame = new DialogFrame();
             frame.setTitle("DialogTest");
             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
             frame.setVisible(true);
          });
       }
    }
    DialogTest
    package dialog;
    
    import javax.swing.JFrame;
    import javax.swing.JMenu;
    import javax.swing.JMenuBar;
    import javax.swing.JMenuItem;
    
    /**
     * A frame with a menu whose File->About action shows a dialog.
     */
    public class DialogFrame extends JFrame
    {
       private static final int DEFAULT_WIDTH = 300;
       private static final int DEFAULT_HEIGHT = 200;
       private AboutDialog dialog;
    
       public DialogFrame()
       {
          setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
    
          // Construct a File menu.
    
          JMenuBar menuBar = new JMenuBar();//菜单栏的实现
          setJMenuBar(menuBar);//设置此窗体的菜单栏
          JMenu fileMenu = new JMenu("File");//菜单的该实现是一个包含 JMenuItem 的弹出窗口,用户选择 JMenuBar 上的项时会显示该 JMenuItem。
          menuBar.add(fileMenu);//将指定的菜单追加到菜单栏的末尾
    
          // Add About and Exit menu items.
    
          // The About item shows the About dialog.
    
          JMenuItem aboutItem = new JMenuItem("About");//菜单中的项的实现
          aboutItem.addActionListener(event -> {
             if (dialog == null) // first time
                dialog = new AboutDialog(DialogFrame.this);
             dialog.setVisible(true); // 设置是否可见
          });
          fileMenu.add(aboutItem);//将某个菜单项追加到此菜单的末尾。返回添加的菜单项
    
          // The Exit item exits the program.
    
          JMenuItem exitItem = new JMenuItem("Exit");
          exitItem.addActionListener(event -> System.exit(0));
          fileMenu.add(exitItem);
       }
    }
    DialogFrame
    package dialog;
    
    import java.awt.BorderLayout;
    
    import javax.swing.JButton;
    import javax.swing.JDialog;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JPanel;
    
    /**
     * A sample modal dialog that displays a message and waits for the user to click the OK button.
     */
    public class AboutDialog extends JDialog
    {
        //创建一个具有指定标题、所有者 Frame 和模式的对话框。如果 owner 为 null,则一个共享的、隐藏的窗体将被设置为该对话框的所有者。
       public AboutDialog(JFrame owner)
       {
          super(owner, "About DialogTest", true);
    
          // add HTML label to center
    //将指定的组件添加到此容器的尾部
          add(
                new JLabel(
                      "<html><h1><i>Core Java</i></h1><hr>By Cay Horstmann</html>"),
                BorderLayout.CENTER);
    
          // OK button closes the dialog
    
          JButton ok = new JButton("OK");//创建一个新的按钮
          ok.addActionListener(event -> setVisible(false));
    
          // add OK button to southern border
    
          JPanel panel = new JPanel();
          panel.add(ok);
          add(panel, BorderLayout.SOUTH);//边框布局,显示在下边
    
          pack();
       }
    }
    AboutDialog

    点击File会出现About和Exit

    点击About后出现如下界面

    点击Exit后,程序退出

    测试程序14

    l 在elipse IDE中调试运行教材556页程序12-19、12-20,结合运行结果理解程序;

    l 掌握对话框的数据交换用法;

    l 记录示例代码阅读理解中存在的问题与疑惑。

    package dataExchange;
    
    import java.awt.*;
    import javax.swing.*;
    
    /**
     * @version 1.34 2015-06-12
     * @author Cay Horstmann
     */
    public class DataExchangeTest {
        public static void main(String[] args) {
            EventQueue.invokeLater(() -> {
                JFrame frame = new DataExchangeFrame();
                frame.setTitle("DataExchangeTest");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
            });
        }
    }
    DataExchangeTest
    package dataExchange;
    
    /**
     * A user has a name and password. For security reasons, the password is stored
     * as a char[], not a String.
     */
    public class User {
        private String name;
        private char[] password;
    
        public User(String aName, char[] aPassword) {
            name = aName;
            password = aPassword;
        }
    
        public String getName() {
            return name;
        }
    
        public char[] getPassword() {
            return password;
        }
    
        public void setName(String aName) {
            name = aName;
        }
    
        public void setPassword(char[] aPassword) {
            password = aPassword;
        }
    }
    User
    package dataExchange;
    
    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    
    /**
     * A frame with a menu whose File->Connect action shows a password dialog.
     */
    public class DataExchangeFrame extends JFrame {
        public static final int TEXT_ROWS = 20;
        public static final int TEXT_COLUMNS = 40;
        private PasswordChooser dialog = null;
        private JTextArea textArea;
    
        public DataExchangeFrame() {
            // construct a File menu
    
            JMenuBar mbar = new JMenuBar();
            setJMenuBar(mbar);
            JMenu fileMenu = new JMenu("File");
            mbar.add(fileMenu);
    
            // add Connect and Exit menu items
    
            JMenuItem connectItem = new JMenuItem("Connect");
            connectItem.addActionListener(new ConnectAction());
            fileMenu.add(connectItem);
    
            // The Exit item exits the program
    
            JMenuItem exitItem = new JMenuItem("Exit");
            exitItem.addActionListener(event -> System.exit(0));
            fileMenu.add(exitItem);
    
            textArea = new JTextArea(TEXT_ROWS, TEXT_COLUMNS);
            add(new JScrollPane(textArea), BorderLayout.CENTER);
            pack();
        }
    
        /**
         * The Connect action pops up the password dialog.
         */
        private class ConnectAction implements ActionListener {
            public void actionPerformed(ActionEvent event) {
                // if first time, construct dialog
    
                if (dialog == null)
                    dialog = new PasswordChooser();
    
                // set default values
                dialog.setUser(new User("yourname", null));
    
                // pop up dialog
                if (dialog.showDialog(DataExchangeFrame.this, "Connect")) {
                    // if accepted, retrieve user input
                    User u = dialog.getUser();
                    textArea.append("user name = " + u.getName() + ", password = " + (new String(u.getPassword())) + "
    ");
                }
            }
        }
    }
    DataExchangeFrame
    package dataExchange;
    
    import java.awt.BorderLayout;
    import java.awt.Component;
    import java.awt.Frame;
    import java.awt.GridLayout;
    
    import javax.swing.JButton;
    import javax.swing.JDialog;
    import javax.swing.JLabel;
    import javax.swing.JPanel;
    import javax.swing.JPasswordField;
    import javax.swing.JTextField;
    import javax.swing.SwingUtilities;
    
    /**
     * A password chooser that is shown inside a dialog
     */
    public class PasswordChooser extends JPanel {
        private JTextField username;
        private JPasswordField password;
        private JButton okButton;
        private boolean ok;
        private JDialog dialog;
    
        public PasswordChooser() {
            setLayout(new BorderLayout());
    
            // construct a panel with user name and password fields
    
            JPanel panel = new JPanel();
            panel.setLayout(new GridLayout(2, 2));
            panel.add(new JLabel("User name:"));
            panel.add(username = new JTextField(""));
            panel.add(new JLabel("Password:"));
            panel.add(password = new JPasswordField(""));
            add(panel, BorderLayout.CENTER);
    
            // create Ok and Cancel buttons that terminate the dialog
    
            okButton = new JButton("Ok");
            okButton.addActionListener(event -> {
                ok = true;
                dialog.setVisible(false);
            });
    
            JButton cancelButton = new JButton("Cancel");
            cancelButton.addActionListener(event -> dialog.setVisible(false));
    
            // add buttons to southern border
    
            JPanel buttonPanel = new JPanel();
            buttonPanel.add(okButton);
            buttonPanel.add(cancelButton);
            add(buttonPanel, BorderLayout.SOUTH);
        }
    
        /**
         * Sets the dialog defaults.
         * 
         * @param u the default user information
         */
        public void setUser(User u) {
            username.setText(u.getName());
        }
    
        /**
         * Gets the dialog entries.
         * 
         * @return a User object whose state represents the dialog entries
         */
        public User getUser() {
            return new User(username.getText(), password.getPassword());
        }
    
        /**
         * Show the chooser panel in a dialog
         * 
         * @param parent a component in the owner frame or null
         * @param title  the dialog window title
         */
        public boolean showDialog(Component parent, String title) {
            ok = false;
    
            // locate the owner frame
    
            Frame owner = null;
            if (parent instanceof Frame)
                owner = (Frame) parent;
            else
                owner = (Frame) SwingUtilities.getAncestorOfClass(Frame.class, parent);
    
            // if first time, or if owner has changed, make new dialog
    
            if (dialog == null || dialog.getOwner() != owner) {
                dialog = new JDialog(owner, true);
                dialog.add(this);
                dialog.getRootPane().setDefaultButton(okButton);
                dialog.pack();
            }
    
            // set title and show dialog
    
            dialog.setTitle(title);
            dialog.setVisible(true);
            return ok;
        }
    }
    PasswordChooser

    测试程序15

    l 在elipse IDE中调试运行教材556页程序12-21、12-2212-23,结合程序运行结果理解程序;

    l 掌握文件对话框的用法;

    l 记录示例代码阅读理解中存在的问题与疑惑。

    package fileChooser;
    
    import java.awt.*;
    import javax.swing.*;
    
    /**
     * @version 1.25 2015-06-12
     * @author Cay Horstmann
     */
    public class FileChooserTest {
        public static void main(String[] args) {
            EventQueue.invokeLater(() -> {
                JFrame frame = new ImageViewerFrame();
                frame.setTitle("FileChooserTest");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
            });
        }
    }
    FileChooserTest
    package fileChooser;
    
    import java.io.*;
    import javax.swing.*;
    import javax.swing.filechooser.*;
    import javax.swing.filechooser.FileFilter;
    
    /**
     * A file view that displays an icon for all files that match a file filter.
     */
    public class FileIconView extends FileView {
        private FileFilter filter;
        private Icon icon;
    
        /**
         * Constructs a FileIconView.
         * 
         * @param aFilter a file filter--all files that this filter accepts will be
         *                shown with the icon.
         * @param         anIcon--the icon shown with all accepted files.
         */
        public FileIconView(FileFilter aFilter, Icon anIcon) {
            filter = aFilter;
            icon = anIcon;
        }
    
        public Icon getIcon(File f) {
            if (!f.isDirectory() && filter.accept(f))
                return icon;
            else
                return null;
        }
    }
    FileIconView
    package fileChooser;
    
    import java.awt.*;
    import java.io.*;
    
    import javax.swing.*;
    
    /**
     * A file chooser accessory that previews images.
     */
    public class ImagePreviewer extends JLabel {
        /**
         * Constructs an ImagePreviewer.
         * 
         * @param chooser the file chooser whose property changes trigger an image
         *                change in this previewer
         */
        public ImagePreviewer(JFileChooser chooser) {
            setPreferredSize(new Dimension(100, 100));
            setBorder(BorderFactory.createEtchedBorder());
    
            chooser.addPropertyChangeListener(event -> {
                if (event.getPropertyName() == JFileChooser.SELECTED_FILE_CHANGED_PROPERTY) {
                    // the user has selected a new file
                    File f = (File) event.getNewValue();
                    if (f == null) {
                        setIcon(null);
                        return;
                    }
    
                    // read the image into an icon
                    ImageIcon icon = new ImageIcon(f.getPath());
    
                    // if the icon is too large to fit, scale it
                    if (icon.getIconWidth() > getWidth())
                        icon = new ImageIcon(icon.getImage().getScaledInstance(getWidth(), -1, Image.SCALE_DEFAULT));
    
                    setIcon(icon);
                }
            });
        }
    }
    ImagePreviewer
    package fileChooser;
    
    import java.io.*;
    
    import javax.swing.*;
    import javax.swing.filechooser.*;
    import javax.swing.filechooser.FileFilter;
    
    /**
     * A frame that has a menu for loading an image and a display area for the
     * loaded image.
     */
    public class ImageViewerFrame extends JFrame {
        private static final int DEFAULT_WIDTH = 300;
        private static final int DEFAULT_HEIGHT = 400;
        private JLabel label;
        private JFileChooser chooser;
    
        public ImageViewerFrame() {
            setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
    
            // set up menu bar
            JMenuBar menuBar = new JMenuBar();
            setJMenuBar(menuBar);
    
            JMenu menu = new JMenu("File");
            menuBar.add(menu);
    
            JMenuItem openItem = new JMenuItem("Open");
            menu.add(openItem);
            openItem.addActionListener(event -> {
                chooser.setCurrentDirectory(new File("."));
    
                // show file chooser dialog
                int result = chooser.showOpenDialog(ImageViewerFrame.this);
    
                // if image file accepted, set it as icon of the label
                if (result == JFileChooser.APPROVE_OPTION) {
                    String name = chooser.getSelectedFile().getPath();
                    label.setIcon(new ImageIcon(name));
                    pack();
                }
            });
    
            JMenuItem exitItem = new JMenuItem("Exit");
            menu.add(exitItem);
            exitItem.addActionListener(event -> System.exit(0));
    
            // use a label to display the images
            label = new JLabel();
            add(label);
    
            // set up file chooser
            chooser = new JFileChooser();
    
            // accept all image files ending with .jpg, .jpeg, .gif
            FileFilter filter = new FileNameExtensionFilter("Image files", "jpg", "jpeg", "gif");
            chooser.setFileFilter(filter);
    
            chooser.setAccessory(new ImagePreviewer(chooser));
    
            chooser.setFileView(new FileIconView(filter, new ImageIcon("palette.gif")));
        }
    }
    ImageViewerFrame

    测试程序16

    l 在elipse IDE中调试运行教材570页程序12-24,结合运行结果理解程序;

    l 了解颜色选择器的用法。

    l 记录示例代码阅读理解中存在的问题与疑惑。

    package colorChooser;
    
    import java.awt.*;
    import javax.swing.*;
    
    /**
     * @version 1.04 2015-06-12
     * @author Cay Horstmann
     */
    public class ColorChooserTest {
        public static void main(String[] args) {
            EventQueue.invokeLater(() -> {
                JFrame frame = new ColorChooserFrame();
                frame.setTitle("ColorChooserTest");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
            });
        }
    }
    ColorChooserTest
    package colorChooser;
    
    import javax.swing.*;
    
    /**
     * A frame with a color chooser panel
     */
    public class ColorChooserFrame extends JFrame {
        private static final int DEFAULT_WIDTH = 300;
        private static final int DEFAULT_HEIGHT = 200;
    
        public ColorChooserFrame() {
            setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
    
            // add color chooser panel to frame
    
            ColorChooserPanel panel = new ColorChooserPanel();
            add(panel);
        }
    }
    ColorChooserFrame
    package colorChooser;
    
    import java.awt.Color;
    import java.awt.Frame;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    
    import javax.swing.JButton;
    import javax.swing.JColorChooser;
    import javax.swing.JDialog;
    import javax.swing.JPanel;
    
    /**
     * A panel with buttons to pop up three types of color choosers
     */
    public class ColorChooserPanel extends JPanel {
        public ColorChooserPanel() {
            JButton modalButton = new JButton("Modal");
            modalButton.addActionListener(new ModalListener());
            add(modalButton);
    
            JButton modelessButton = new JButton("Modeless");
            modelessButton.addActionListener(new ModelessListener());
            add(modelessButton);
    
            JButton immediateButton = new JButton("Immediate");
            immediateButton.addActionListener(new ImmediateListener());
            add(immediateButton);
        }
    
        /**
         * This listener pops up a modal color chooser
         */
        private class ModalListener implements ActionListener {
            public void actionPerformed(ActionEvent event) {
                Color defaultColor = getBackground();
                Color selected = JColorChooser.showDialog(ColorChooserPanel.this, "Set background", defaultColor);
                if (selected != null)
                    setBackground(selected);
            }
        }
    
        /**
         * This listener pops up a modeless color chooser. The panel color is changed
         * when the user clicks the OK button.
         */
        private class ModelessListener implements ActionListener {
            private JDialog dialog;
            private JColorChooser chooser;
    
            public ModelessListener() {
                chooser = new JColorChooser();
                dialog = JColorChooser.createDialog(ColorChooserPanel.this, "Background Color", false /* not modal */,
                        chooser, event -> setBackground(chooser.getColor()), null /* no Cancel button listener */);
            }
    
            public void actionPerformed(ActionEvent event) {
                chooser.setColor(getBackground());
                dialog.setVisible(true);
            }
        }
    
        /**
         * This listener pops up a modeless color chooser. The panel color is changed
         * immediately when the user picks a new color.
         */
        private class ImmediateListener implements ActionListener {
            private JDialog dialog;
            private JColorChooser chooser;
    
            public ImmediateListener() {
                chooser = new JColorChooser();
                chooser.getSelectionModel().addChangeListener(event -> setBackground(chooser.getColor()));
    
                dialog = new JDialog((Frame) null, false /* not modal */);
                dialog.add(chooser);
                dialog.pack();
            }
    
            public void actionPerformed(ActionEvent event) {
                chooser.setColor(getBackground());
                dialog.setVisible(true);
            }
        }
    }
    ColorChooserPanel

    实验2:组内讨论反思本组负责程序,理解程序总体结构,梳理程序GUI设计中应用的相关组件,整理相关组件的API,对程序中组件应用的相关代码添加注释。

    实验3:组间协同学习:在本班课程QQ群内,各位同学对实验1中存在的问题进行提问,提问时注明实验1中的测试程序编号,负责对应程序的小组需及时对群内提问进行回答。

    3.实验总结:

    本章的学习容量还是比较多的,就示例程序来说有十几个,在分组学习的情况下,学习相对轻松了不少,简单的来说,这种分小组学习的方式还是不错的。在本周的学习中,我学到了5中布局管理器:流式布局管理器、边框布局管理器、网格布局管理器、网格组布局管理器、卡片布局管理器。

  • 相关阅读:
    我的WCF之旅(1):创建一个简单的WCF程序
    与众不同 windows phone (15) Media(媒体)之后台播放音频
    与众不同 windows phone (14) Media(媒体)之音频播放器, 视频播放器, 与 Windows Phone 的音乐和视频中心集成
    与众不同 windows phone (10) Push Notification(推送通知)之推送 Tile 通知, 推送自定义信息
    与众不同 windows phone (17) Graphic and Animation(画图和动画)
    与众不同 windows phone (5) Chooser(选择器)
    与众不同 windows phone (26) Contacts and Calendar(联系人和日历)
    与众不同 windows phone (7) Local Database(本地数据库)
    与众不同 windows phone (19) Device(设备)之陀螺仪传感器, Motion API
    与众不同 windows phone (16) Media(媒体)之编辑图片, 保存图片到相册, 与图片的上下文菜单“应用程序...”和“共享...”关联, 与 Windows Phone 的图片中心集成
  • 原文地址:https://www.cnblogs.com/litinghua/p/10054085.html
Copyright © 2011-2022 走看看