Chinaunix首页 | 论坛 | 博客

飞翔的梦mylxiaoyi.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

mylxiaoyi

  • 博客访问： 900661
  • 博文数量： 96
  • 博客积分： 10681
  • 博客等级： 上将
  • 技术积分： 2449
  • 用 户 组： 普通用户
  • 注册时间： 2006-05-16 17:52
文章分类

全部博文（96）

文章存档

2011年（30）

2009年（36）

2008年（30）

我的朋友
最近访客
推荐博文
相关博文
Toggle Buttons（四）

分类： Java

2011-03-24 12:41:47

5.5 JRadionButton类

当我们希望创建一个相斥的可切换组件组时我们可以使用JRadioButton。尽管由技术上来说，我们可以将一组JCheckBox组件放在一个ButtonGroup中，并且每次只有一个可以选中，但是他们看起来并不正确。至少由预定义的观感类型来看，JRadioButton与JCheckBox组件看起来是不同的，如图5-10所示。这种外观上的区别可以告诉终端用户可以期望组件的特定行为。

swing_5_10

JRadioButton是由几方面构成的。类似于JToggleButton与JCheckBox，JRadioButton也使用一个ToggleButtonModel来表示其数据模型。他使用ButtonGroup通过AbstractButton来提供互斥的组合，并且用户界面委托是RadioButtonUI。

下面我们就来探讨如何使用JRadioButton的不同方同。

5.5.1 创建JRadioButton组件

与JCheckBox以及JToggleButton类似，JRadioButton有八个构造函数：

  1. public JRadioButton()
  2. JRadioButton aRadioButton = new JRadioButton();
  3.  
  4. public JRadioButton(Icon icon)
  5. JRadioButton aRadioButton = new JRadioButton(new DiamondIcon(Color.CYAN, false));
  6. aRadioButton.setSelectedIcon(new DiamondIcon(Color.BLUE, true));
  7.  
  8. public JRadioButton(Icon icon, boolean selected)
  9. JRadioButton aRadioButton = new JRadioButton(new DiamondIcon(Color.CYAN, false),
  10.   true);
  11. aRadioButton.setSelectedIcon(new DiamondIcon(Color.BLUE, true));
  12.  
  13. public JRadioButton(String text)
  14. JRadioButton aRadioButton = new JRadioButton("4 slices");
  15.  
  16. public JRadioButton(String text, boolean selected)
  17. JRadioButton aRadioButton = new JRadioButton("8 slices", true);
  18.  
  19. public JRadioButton(String text, Icon icon)
  20. JRadioButton aRadioButton = new JRadioButton("12 slices",
  21.   new DiamondIcon(Color.CYAN, false));
  22. aRadioButton.setSelectedIcon(new DiamondIcon(Color.BLUE, true));
  23.  
  24. public JRadioButton(String text, Icon icon, boolean selected)
  25. JRadioButton aRadioButton = new JRadioButton("16 slices",
  26.   new DiamondIcon(Color.CYAN, false), true);
  27. aRadioButton.setSelectedIcon(new DiamondIcon(Color.BLUE, true));
  28.  
  29. public JRadioButton(Action action)
  30. Action action = ...;
  31. JRadioButton aRadioButton = new JRadioButton(action);

每一个都允许我们定制一个或是多个标签，图标或是初始选中状态属性。除非特别指定，在标签中并没有文本，而且复选框的默认选中/未选中状态图标为未选中。在创建一组单选按钮组件之后，我们需要将每一个放在一个ButtonGroup中，从而他们可以正常工作，在组合中每次只有一个按钮可以选中。如果我们在构造函数中初始化图标，则是复选框未选中状态的图标，当复选框被选中时也显示相同的图标。我们或者是使用JCheckBox中所描述的setSelectedIcon(Icon newValue)方法初始选中图标，或者是确保图标是状态感知的并进行自动更新。

5.5.2 JRadioButton属性

JRadioButton具有两个覆盖了父类JToggleButton的属性，如图表5-5所示。

JRadioButton属性

属性名
数据类型

访问性
accessibleContext
AccessibleContext

只读
UIClassID
String

只读
5.5.3 将JRadioButton组件组合为一个ButtonGroup

JRadioButton是唯一一个为了正常作用需要放在ButtonGroup中的JToggleButton子类。仅仅是创建一组单选按钮并将其放置在屏幕中是不足够的。除了将每一个单选按钮放在一个容器中之外，我们需要创建一个ButtonGroup，并且将每一个单选按钮放在相同的ButtonGroup中。一旦所有的JRadioButton项目都放在一个组合中，当一个未选中的单选按钮被选中时，ButtonGroup会使得当前被选中的单选按钮取消选中。

将一个JRaidonButton组件集合放在一个ButtonGroup中是一个基本的四步过程： 1 为组合创建一个容器

JPanel aPanel = new JPanel(new GridLayout(0,1));

2 在窗口周围放置一个边框以标识组合。这是可选的一步，但是我们通常希望放置一个边框来为用户标识组合。我们将会在第7章中了解更多关于边框的内容。

Border border = BorderFactory.createTitledBorder("Slice Count"); aPanel.setBorder(border)

3 创建一个ButtonGroup

ButtonGroup aGroup = new ButtonGroup();

4 对于每一个可选择的选项，创建一个JRadioButton，将其添加到容器中，然后将其添加到组合中。

JRadioButton aRadioButton = new JRadioButton(); aPanel.add(aRadioButton); aGroup.add(aRadioButton);

我们也许会发现整个过程，特殊是第四步，在一段时间之后会显得繁琐，特殊是当我们添加处理选中事件步骤时更是如此。列表5-5所示的助手类，具有一个静态的createRadioButtonGrouping(String elements[], String title)方法，证明是有用的。这个方法需要一个单选按钮的String的数组以及边框标题，然后在一个具有标题边框的JPanel内创建一个带有通常ButtonGroup的JRadioButton对象集合。

  1. package net.ariel.ch05;
  2.  
  3. import java.awt.Container;
  4. import java.awt.GridLayout;
  5.  
  6. import javax.swing.BorderFactory;
  7. import javax.swing.ButtonGroup;
  8. import javax.swing.JPanel;
  9. import javax.swing.JRadioButton;
  10. import javax.swing.border.Border;
  11.  
  12. public class RadioButtonUtils {
  13.  
  14.     private RadioButtonUtils() {
  15.  
  16.     }
  17.  
  18.     public static Container createRadioButtonGrouping(String elements[], String title) {
  19.         JPanel panel = new JPanel(new GridLayout(0,1));
  20.  
  21.         if(title != null) {
  22.             Border border = BorderFactory.createTitledBorder(title);
  23.             panel.setBorder(border);
  24.         }
  25.  
  26.         ButtonGroup group = new ButtonGroup();
  27.         JRadioButton aRadioButton;
  28.  
  29.         for(int i=0, n=elements.length; i<n; i++) {
  30.             aRadioButton = new JRadioButton(elements[i]);
  31.             panel.add(aRadioButton);
  32.             group.add(aRadioButton);
  33.         }
  34.  
  35.         return panel;
  36.     }
  37. }

现在我们可以更为简单的创建组合了，如列表5-6中的示例程序所示。

  1. /**
  2.  *
  3.  */
  4. package net.ariel.ch05;
  5.  
  6. import java.awt.BorderLayout;
  7. import java.awt.Container;
  8. import java.awt.EventQueue;
  9.  
  10. import javax.swing.JFrame;
  11.  
  12. /**
  13.  * @author mylxiaoyi
  14.  *
  15.  */
  16. public class GroupRadio {
  17.  
  18.     private static final String sliceOptions[] = {
  19.         "4 slices", "8 slices", "12 slices", "16 slices"
  20.     };
  21.     private static final String crustOptions[] = {
  22.         "Sicilian", "Thin Crust", "Thick Crust", "Stuffed Crust"
  23.     };
  24.     /**
  25.      * @param args
  26.      */
  27.     public static void main(String[] args) {
  28.         // TODO Auto-generated method stub
  29.  
  30.         Runnable runner = new Runnable() {
  31.             public void run() {
  32.                 JFrame frame = new JFrame("Grouping Example");
  33.                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  34.  
  35.                 Container sliceContainer = RadioButtonUtils.createRadioButtonGrouping(sliceOptions, "Slice Count");
  36.                 Container crustContainer = RadioButtonUtils.createRadioButtonGrouping(crustOptions, "Crust Type");
  37.  
  38.                 frame.add(sliceContainer, BorderLayout.WEST);
  39.                 frame.add(crustContainer, BorderLayout.EAST);
  40.  
  41.                 frame.setSize(300, 200);
  42.                 frame.setVisible(true);
  43.             }
  44.         };
  45.         EventQueue.invokeLater(runner);
  46.     }
  47.  
  48. }

当我们运行这个程序时，我们将会看到图5-11所示的结果。

swing_5_11 5.5.4 处理JRadioButton选中事件

与JToggleButton以及JCheckBox类似，JRadioButton支持ActionListener，ItemListener以及ChangeListener的注册。而且，对于JRadioButton而言这些监听器的用法与其他组件的用法不同。

使用ActionListener监听JRadioButton事件

对于JRadioButton，通常是将相同的ActionListener注册到ButtonGroup中的所有单选按钮上。采用这种方法，当一个单选按钮被选中时，所订阅的ActionListener就会得到通知。通过覆盖前面的createRadioButtonGrouping()方法，这个方法就可以接受一个ActionListener作为参数，并将这个监听器对象关联到他们所创建的每一个按钮之上。

  1. public static Container createRadionButtonGrouping(String elements[], String title, ActionListener actionListener) {
  2.         JPanel panel = new JPanel(new GridLayout(0, 1)); if(title != null) {
  3.             Border border = BorderFactory.createTitledBorder(title);
  4.             panel.setBorder(border);
  5.         } ButtonGroup group = new ButtonGroup();
  6.         JRadioButton aRadioButton; for(int i=0, n=elements.length; i<n; i++) {
  7.             aRadioButton = new JRadioButton(elements[i]);
  8.             panel.add(aRadioButton);
  9.             group.add(aRadioButton);
  10.             if(actionListener != null) {
  11.                 aRadioButton.addActionListener(actionListener);
  12.             }
  13.         } return panel;
  14.     }

现在，如果使用下面的代码创建一个组合，则所创建的每一个JRadioButton组件的AcitonListener都会得到通知。这里，监听器只是输出当前选中的值。我们所选择的响应方式会有所不同。

  1. ActionListener sliceActionListener = new ActionListener() {
  2.    public void actionPerformed(ActionEvent actionEvent) {
  3.      AbstractButton aButton = (AbstractButton)actionEvent.getSource();
  4.      System.out.println("Selected: " + aButton.getText());
  5.    }
  6. };
  7. Container sliceContainer =
  8.    RadioButtonUtils.createRadioButtonGrouping(sliceOptions, "Slice Count",
  9.      sliceActionListener);

然而我们需要注意，这种方法有两个问题。首先，如果一个JRadioBtton已经处理选中状态，并且被再次选中时，任何已关联的ActionListener对象仍然会再次得到通知。尽管通过少量的工作我们并不能阻止所订阅的ActionListener的再次通知，但是我们依然可以进行正常的处理。我们需要重新获取到最后一个选中项目的引用，并且检测是否重新选中。下面修改的ActionListener进行这种检测：

  1. ActionListener crustActionListener = new ActionListener() {
  2.    String lastSelected;
  3.    public void actionPerformed(ActionEvent actionEvent) {
  4.      AbstractButton aButton = (AbstractButton)actionEvent.getSource();
  5.      String label = aButton.getText();
  6.      String msgStart;
  7.      if (label.equals(lastSelected)) {
  8.        msgStart = "Reselected: ";
  9.      } else {
  10.        msgStart = "Selected: ";
  11.      }
  12.      lastSelected = label;
  13.      System.out.println(msgStart + label);
  14.    }
  15. };

第二个需要处理的问题就是确定在任意时刻哪一个JRadioButton被选中。通过重写RadioButtonUtils.createRadioButtonGrouping()助手方法，在方法外部ButtonGroup与JRadioButton组件都是不可见的。所以，并没有直接的方法在返回容器的ButtonGroup内部确定哪一个JRadioButton对象被选中。这也许是必须的，例如，如果在屏幕上有一个Order Pizza按钮，而我们希望在用户点击这个按钮之后我们可以确定哪一个匹萨预订选项被选中。

下面的助手方法，public Enumeration getSelectedElements(Container container)，当添加到前面的RadioButtonUtils类中时将会提供这种必须的答案。助手方法只在传递给方法的容器装满AbstractButton对象时才会起作用。在前面所描述的createRadioButtonGrouping()方法所创建的容器正适合这种情况，尽管getSelectedElements()方法可以单独使用。

  1. public static Enumeration<String> getSelectedEllements(Container container) {
  2.         Vector<String> selections = new Vector<String>();
  3.         Component components[] = container.getComponents();
  4.         for(int i=0, n=components.length; i<n; i++) {
  5.             if(components[i] instanceof AbstractButton) {
  6.                 AbstractButton button = (AbstractButton)components[i];
  7.                 if(button.isSelected()) {
  8.                     selections.addElement(button.getText());
  9.                 }
  10.             }
  11.         } return selections.elements();
  12.     }

为了使用getSelectedElements()方法，我们只需要将createRadionButtonGrouping()方法中返回的容器传递经getSelectedElements()方法来获得选中项目的String对象的Enumeration。下面的示例演示了使用方法。

  1. final Container crustContainer =
  2.      RadioButtonUtils.createRadioButtonGrouping(crustOptions, "Crust Type");
  3. ActionListener buttonActionListener = new ActionListener() {
  4.    public void actionPerformed(ActionEvent actionEvent) {
  5.      Enumeration selected = RadioButtonUtils.getSelectedElements(crustContainer);
  6.      while (selected.hasMoreElements()) {
  7.        System.out.println ("Selected -> " + selected.nextElement());
  8.      }
  9.    }
  10. };
  11. JButton button = new JButton ("Order Pizza");
  12. button.addActionListener(buttonActionListener);

对于getSelectedElements()方法返回多个值也许是必要的，因为如果在容器中多个按钮之间共享ButtonModel时，ButtonGroup的多个组件将会被选中。在组件之间共享ButtonModel并不是通常用法。如果我们确定我们的按钮模型并不会被共享，那么我们也许需要提供一个返回String的类似方法。

使用ItemListener监听JRadioButton事件

依赖于我们正在尝试作的事情，对于JRadionButton使用ItemListener通常并不是所希望的事件监听方法。当注册一个ItemListener时，一个新的JRadionButton选中会通知这个监听器两次：一次用于取消旧值，一次用于选中新值。对于重新选中（选中同一选项两次），监听器并不会被通知两次。

为了进行演示，下面的监听器会检测重新选中，正如前面的AcitonListener所做的，这个监听器会报告选中（或是取消选中）的元素。

  1. ItemListener itemListener = new ItemListener() {
  2.    String lastSelected;
  3.    public void itemStateChanged(ItemEvent itemEvent) {
  4.      AbstractButton aButton = (AbstractButton)itemEvent.getSource();
  5.      int state = itemEvent.getStateChange();
  6.      String label = aButton.getText();
  7.      String msgStart;
  8.      if (state == ItemEvent.SELECTED) {
  9.        if (label.equals(lastSelected)) {
  10.          msgStart = "Reselected -> ";
  11.        } else {
  12.          msgStart = "Selected -> ";
  13.        }
  14.        lastSelected = label;
  15.      } else {
  16.        msgStart = "Deselected -> ";
  17.      }
  18.      System.out.println(msgStart + label);
  19.    }
  20. };

为了正确的作用，对于RadioButtonUtils类需一些新的方法来允许我们将ItemListener关联到ButtonGroup中的每一个JRadioButton上。相应的代码会出现在后面的完整示例代码中。

使用ChangeListener监听JRadioButton事件

对于JRadioButton而言，ChangeListener的响应类似于JToggleButton与JCheckBox中的响应。当选中的单选按钮被armed,pressed,selected,released以及按钮模型的各种其他属性变化时所订阅的监听器都会得到通知。JRadioButton的唯一区别就在于ChangeListener也会被通知关于单选按钮正被取消选中的状态变化。前面例子中的ChangeListener也可以关联到JRadioButton。他也会被经常通知。

列表5-7中的相同程序演示了注册到两种不同的JRadioButton对象事件的所有监听器。另外，JButton报告了单选按钮被选中的元素。图5-12显示了程序运行时的主窗体。

  1. /**
  2.  *
  3.  */
  4. package net.ariel.ch05; import java.awt.BorderLayout;
  5. import java.awt.Container;
  6. import java.awt.EventQueue;
  7. import java.awt.event.ActionEvent;
  8. import java.awt.event.ActionListener;
  9. import java.awt.event.ItemEvent;
  10. import java.awt.event.ItemListener;
  11. import java.util.Enumeration; import javax.swing.AbstractButton;
  12. import javax.swing.ButtonModel;
  13. import javax.swing.JButton;
  14. import javax.swing.JFrame;
  15. import javax.swing.event.ChangeEvent;
  16. import javax.swing.event.ChangeListener; /**
  17.  * @author mylxiaoyi
  18.  *
  19.  */
  20. public class GroupActionRadio { private static final String sliceOptions[] = {
  21.         "4 slices", "8 slices", "12 slices", "16 slices"
  22.     };
  23.     private static final String crustOptions[] = {
  24.         "Sicilian", "Thin Crust", "Thick Crust", "Stuffed Crust"
  25.     };
  26.     /**
  27.      * @param args
  28.      */
  29.     public static void main(String[] args) {
  30.         // TODO Auto-generated method stub Runnable runner = new Runnable() {
  31.             public void run() {
  32.                 JFrame frame = new JFrame("Grouping Example");
  33.                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); ActionListener sliceActionListener = new ActionListener() {
  34.                     public void actionPerformed(ActionEvent event) {
  35.                         AbstractButton aButton = (AbstractButton)event.getSource();
  36.                         System.out.println("Selected: "+aButton.getText());
  37.                     }
  38.                 };
  39.                 Container sliceContainer = RadioButtonUtils.createRadioButtonGrouping(sliceOptions, "Slice Count", sliceActionListener); ActionListener crustActionListener = new ActionListener() {
  40.                     String lastSelected;
  41.                     public void actionPerformed(ActionEvent event) {
  42.                         AbstractButton aButton = (AbstractButton)event.getSource();
  43.                         String label = aButton.getText();
  44.                         String msgStart;
  45.                         if(label.equals(lastSelected)) {
  46.                             msgStart = "Reselected: ";
  47.                         }
  48.                         else {
  49.                             msgStart = "Selected: ";
  50.                         }
  51.                         lastSelected = label;
  52.                         System.out.println(msgStart + label);
  53.                     }
  54.                 }; ItemListener itemListener = new ItemListener() {
  55.                     String lastSelected;
  56.                     public void itemStateChanged(ItemEvent event) {
  57.                         AbstractButton aButton = (AbstractButton)event.getSource();
  58.                         int state = event.getStateChange();
  59.                         String label = aButton.getText();
  60.                         String msgStart;
  61.                         if(state == ItemEvent.SELECTED) {
  62.                             if(label.equals(lastSelected)) {
  63.                                 msgStart = "Reselected -> ";
  64.                             }
  65.                             else {
  66.                                 msgStart = "Selected -> ";
  67.                             }
  68.                             lastSelected = label;
  69.                         }
  70.                         else {
  71.                             msgStart = "Deselected -> ";
  72.                         }
  73.                         System.out.println(msgStart + label);
  74.                     }
  75.                 }; ChangeListener changeListener = new ChangeListener() {
  76.                     public void stateChanged(ChangeEvent event) {
  77.                         AbstractButton aButton = (AbstractButton)event.getSource();
  78.                         ButtonModel aModel = aButton.getModel();
  79.                         boolean armed = aModel.isArmed();
  80.                         boolean pressed = aModel.isPressed();
  81.                         boolean selected = aModel.isSelected();
  82.                         System.out.println("Changed: "+armed+"/"+pressed+"/"+selected);
  83.                     }
  84.                 }; final Container crustContainer = RadioButtonUtils.createRadioButtonGrouping(crustOptions, "Crust Type", crustActionListener, itemListener, changeListener); ActionListener buttonActionListener = new ActionListener() {
  85.                     public void actionPerformed(ActionEvent event) {
  86.                         Enumeration<String> selected = RadioButtonUtils.getSelectedElements(crustContainer);
  87.                         while(selected.hasMoreElements()) {
  88.                             System.out.println("Selected -> "+selected.nextElement());
  89.                         }
  90.                     }
  91.                 }; JButton button = new JButton("Order Pizza");
  92.                 button.addActionListener(buttonActionListener); frame.add(sliceContainer, BorderLayout.WEST);
  93.                 frame.add(crustContainer, BorderLayout.EAST);
  94.                 frame.add(button, BorderLayout.SOUTH);
  95.                 frame.setSize(300, 200);
  96.                 frame.setVisible(true); }
  97.         };
  98.         EventQueue.invokeLater(runner);
  99.     } }

swing_5_12

为了处理向ButtonGroup中所有的单选按钮注册ChangeListener对象，我们对RadioButtonUtils类进行了一些修改。完整的最终类定义如下列表5-8所示。

  1. /**
  2.  *
  3.  */
  4. package net.ariel.ch05; import java.awt.Component;
  5. import java.awt.Container;
  6. import java.awt.event.ActionListener;
  7. import java.awt.event.ItemListener;
  8. import java.util.Enumeration;
  9. import java.util.Vector; import javax.swing.AbstractButton;
  10. import javax.swing.BorderFactory;
  11. import javax.swing.ButtonGroup;
  12. import javax.swing.JPanel;
  13. import javax.swing.JRadioButton;
  14. import javax.swing.border.Border;
  15. import javax.swing.event.ChangeListener; /**
  16.  * @author mylxiaoyi
  17.  *
  18.  */
  19. public class RadioButtonUtils2 { private RadioButtonUtils2() { } public static Enumeration<String> getSelectedElements(Container container) {
  20.         Vector<String> selections = new Vector<String>();
  21.         Component components[] = container.getComponents();
  22.         for(int i=0, n=components.length; i<n; i++) {
  23.             if(components[i] instanceof AbstractButton) {
  24.                 AbstractButton button = (AbstractButton)components[i];
  25.                 if(button.isSelected()) {
  26.                     selections.addElement(button.getText());
  27.                 }
  28.             }
  29.         } return selections.elements();
  30.     } 
  31. public static Container createRadioButtonGrouping(String elements[]) {
  32.         return createRadioButtonGrouping(elements, null, null, null, null);
  33.     } 
  34. public static Container createRadioButtonGrouping(String elements[], String title) {
  35.         return createRadioButtonGrouping(elements, title, null, null, null);
  36.     } 
  37. public static Container createRadioButtonGrouping(String elements[], String title, ItemListener itemListener) {
  38.         return createRadioButtonGrouping(elements, title, null, itemListener, null);
  39.     } 
  40. public static Container createRadioButtonGrouping(String elements[], String title, ActionListener actionListener) {
  41.         return createRadioButtonGrouping(elements, title, actionListener, null, null);
  42.     } 
  43. public static Container createRadioButtonGrouping(String elements[], String title, ActionListener actionListener, ItemListener itemListener) {
  44.         return createRadioButtonGrouping(elements, title, actionListener, itemListener, null);
  45.     } 
  46. public static Container createRadioButtonGrouping(String elements[], String title, ActionListener actionListener, ItemListener itemListener, ChangeListener changeListener) {
  47.         JPanel panel = new JPanel(); if(title != null) {
  48.             Border border = BorderFactory.createTitledBorder(title);
  49.             panel.setBorder(border);
  50.         } ButtonGroup group = new ButtonGroup();
  51.         JRadioButton aRadioButton;
  52.         for(int i=0, n=elements.length; i<n; i++) {
  53.             aRadioButton = new JRadioButton(elements[i]);
  54.             panel.add(aRadioButton);
  55.             group.add(aRadioButton);
  56.             if(actionListener != null) {
  57.                 aRadioButton.addActionListener(actionListener);
  58.             }
  59.             if(itemListener != null) {
  60.                 aRadioButton.addItemListener(itemListener);
  61.             }
  62.             if(changeListener != null) {
  63.                 aRadioButton.addChangeListener(changeListener);
  64.             }
  65.         } return panel;
  66.     }
  67. }
 5.5.5 自定义JRadioButton观感

每一个已安装的Swing观感都会提供一个不同的JRadioButton外观以及默认的UIResource值集合。图5-13显示了预安装的观感类型集合的JRadioButton组件的外观：Motif，Windows，Ocean。下图显示了Thin Crust pizza预定程序的界面。另外，Thick Crust选项具有输入焦点。

swing_5_13

表5-6显示了JRadioButton的UIResource相关的属性集合。JRadioButton组件具有20个不同的属性。

JRadioButton UIResource元素

属性字符串

对象类型

RadioButton.background

Color

RadioButton.border

Border

RadioButton.darkShadow

Color

RadioButton.disabledText

Color

RadioButton.focus

Color

RadioButton.focusInputMap

Object[]

RadioButton.font

Font

RadioButton.foreground

Color

RadioButton.gradient

List

RadioButton.highlight

Color

RadioButton.icon

Icon

RadioButton.interiorBackground

Color

RadioButton.light

Color

RadioButton.margin

Insets

RadioButton.rollover

Boolean

RadioButton.select

Color

RadioButton.shadow

Color

RadioButton.textIconGap

Integer

RadioButton.textShiftOffset

Integer

RadioButtonUI

String
5.6 小结

本章描述了可切换的组件：JToggleButton，JCheckBox与JRadioButton。我们已经了解了每一个组件如何使用JToggleButton。其数据模型ToggleButtonModel类以及如何将组件组合在一个ButtonGroup中。另外，我们同时了解了如何处理每一个组件的选中事件。

第6章将会解释如何使用各种面向菜单的Swing组件。

阅读(953) | 评论(0) | 转发(0) |
0

上一篇：Toggle Buttons（三）

下一篇：Swing菜单与工具栏（二）

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6