13.19 Swing入门（注释⑦）

通过这一章的学习，当我们的工作方法在AWT中发生了巨大的改变后（如果可以回忆起很久以前，当Java第一次面世时SUN公司曾声明Java是一种“稳定，牢固”的编程语言），可能一直有Java还不十分的成熟的感觉。的确，现在Java拥有一个不错的事件模型以及一个优秀的组件复用设计——JavaBeans。但GUI组件看起来还相当的原始，笨拙以及相当的抽象。

⑦：写作本节时，Swing库显然已被Sun“固定”下来了，所以只要你下载并安装了Swing库，就应该能正确地编译和运行这里的代码，不会出现任何问题（应该能编译Sun配套提供的演示程序，以检测安装是否正确）。若遇到任何麻烦，请访问http://www.BruceEckel.com，了解最近的更新情况。

而这就是Swing将要占领的领域。Swing库在Java 1.1之后面世，因此我们可以自然而然地假设它是Java 1.2的一部分。可是，它是设计为作为一个补充在Java 1.1版中工作的。这样，我们就不必为了享用好的UI组件库而等待我们的平台去支持Java 1.2版了。如果Swing库不是我们的用户的Java 1.1版所支持的一部分，并且产生一些意外，那他就可能真正的需要去下载Swing库了。

Swing包含所有我们缺乏的组件，在整个本章余下的部分中：我们期望领会现代化的UI，来自按钮的任何事件包括到树状和网格结构中的图片。它是一个大库，但在某些方面它为任务被设计得相应的复杂——如果任何事都是简单的，我们不必编写更多的代码但同样设法运行我们的代码逐渐地变得更加的复杂。这意味着一个容易的入口，如果我们需要它我们得到它的强大力量。

Swing相当的深奥，这一节不会去试图让读者理解，但会介绍它的能力和Swing简单地使我们着手使用库。请注意我们有意识的使用这一切变得简单。如果我们需要运行更多的，这时Swing能或许能给我们所想要的，如果我们愿意深入地研究，可以从SUN公司的在线文档中获取更多的资料。

13.19.1 Swing有哪些优点

当我们开始使用Swing库时，会注意到它在技术上向前迈出了巨大的一步。Swing组件是Bean，因此他们可以支持Bean的任何开发环境中使用。Swing提供了一个完全的UI组件集合。因为速度的关系，所有的组件都很小巧的（没有“重量级”组件被使用），Swing为了轻便在Java中整个被编写。

最重要的是我们会希望Swing被称为“正交使用”；一旦我们采用了这种关于库的普遍的办法我们就可以在任何地方应用它们。这主要是因为Bean的命名规则，大多数的时候在我编写这些程序例子时我可以猜到方法名并且第一次就将它拼写正确而无需查找任何事物。这无疑是优秀库设计的品质证明。另外，我们可以广泛地插入组件到其它的组件中并且事件会正常地工作。

键盘操作是自动被支持的——我们可以使用Swing应用程序而不需要鼠标，但我们不得不做一些额外的编程工作（老的AWT中需要一些可怕的代码以支持键盘操作）。滚动被毫不费力地支持——我们简单地将我们的组件到一个JScrollPane中，同样我们再增加它到我们的窗体中即可。其它的特征，例如工具提示条只需要一行单独的代码就可执行。

Swing同样支持一些被称为“可插入外观和效果”的事物，这就是说UI的外观可以在不同的平台和不同的操作系统上被动态地改变以符合用户的期望。它甚至可以创造我们自己的外观和效果。

13.19.2 方便的转换

如果我们长期艰苦不懈地利用Java 1.1版构建我们的UI，我们并不需要扔掉它改变到Swing阵营中来。幸运的是，库被设计得允许容易地修改——在很多情况下我们可以简单地放一个J到我们老AWT组件的每个类名前面即可。下面这个例子拥有我们所熟悉的特色：

  1. //: JButtonDemo.java
  2. // Looks like Java 1.1 but with J's added
  3. package c13.swing;
  4. import java.awt.*;
  5. import java.awt.event.*;
  6. import java.applet.*;
  7. import javax.swing.*;
  9. public class JButtonDemo extends Applet {
  10.   JButton
  11.     b1 = new JButton("JButton 1"),
  12.     b2 = new JButton("JButton 2");
  13.   JTextField t = new JTextField(20);
  14.   public void init() {
  15.     ActionListener al = new ActionListener() {
  16.       public void actionPerformed(ActionEvent e){
  17.         String name =
  18.           ((JButton)e.getSource()).getText();
  19.         t.setText(name + " Pressed");
  20.       }
  21.     };
  22.     b1.addActionListener(al);
  23.     add(b1);
  24.     b2.addActionListener(al);
  25.     add(b2);
  26.     add(t);
  27.   }
  28.   public static void main(String args[]) {
  29.     JButtonDemo applet = new JButtonDemo();
  30.     JFrame frame = new JFrame("TextAreaNew");
  31.     frame.addWindowListener(new WindowAdapter() {
  32.       public void windowClosing(WindowEvent e){
  33.         System.exit(0);
  34.       }
  35.     });
  36.     frame.getContentPane().add(
  37.       applet, BorderLayout.CENTER);
  38.     frame.setSize(300,100);
  39.     applet.init();
  40.     applet.start();
  41.     frame.setVisible(true);
  42.   }
  43. } ///:~

这是一个新的输入语句，但此外任何事物除了增加了一些J外，看起都像这Java 1.1版的AWT。同样，我们不恰当的用add()方法增加到Swing JFrame中，除此之外我们必须像上面看到的一样先准备一些“content pane”。我们可以容易地得到Swing一个简单的改变所带来的好处。

因为程序中的封装语句，我们不得不调用像下面所写的一样调用这个程序：

  1. java c13.swing.JbuttonDemo

在这一节里出现的所有的程序都将需要一个相同的窗体来运行它们。

13.19.3 显示框架

尽管程序片和应用程序都可以变得很重要，但如果在任何地方都使用它们就会变得混乱和毫无用处。这一节余下部分取代它们的是一个Swing程序例子的显示框架：

  1. //: Show.java
  2. // Tool for displaying Swing demos
  3. package c13.swing;
  4. import java.awt.*;
  5. import java.awt.event.*;
  6. import javax.swing.*;
  8. public class Show {
  9.   public static void
  10.   inFrame(JPanel jp, int width, int height) {
  11.     String title = jp.getClass().toString();
  12.     // Remove the word "class":
  13.     if(title.indexOf("class") != -1)
  14.       title = title.substring(6);
  15.     JFrame frame = new JFrame(title);
  16.     frame.addWindowListener(new WindowAdapter() {
  17.       public void windowClosing(WindowEvent e){
  18.         System.exit(0);
  19.       }
  20.     });
  21.     frame.getContentPane().add(
  22.       jp, BorderLayout.CENTER);
  23.     frame.setSize(width, height);
  24.     frame.setVisible(true);
  25.   }
  26. } ///:~

那些想显示它们自己的类将从JPanel处继承并且随后为它们自己增加一些可视化的组件。最后，它们创建一个包含下面这一行程序的main()：

  1. Show.inFrame(new MyClass(), 500, 300);

最后的两个参数是显示的宽度和高度。

注意JFrame的标题是用RTTI产生的。

13.19.4 工具提示

几乎所有我们利用来创建我们用户接口的来自于JComponent的类都包含一个称为setToolTipText(string)的方法。因此，几乎任何我们所需要表示的（对于一个对象jc来说就是一些来自JComponent的类）都可以安放在窗体中：

  1. jc.setToolTipText("My tip");

并且当鼠标停在JComponent上一个超过预先设置的一个时间，一个包含我们的文字的小框就会从鼠标下弹出。

13.19.5 边框

JComponent同样包括一个称为setBorder()的方法，该方法允许我们安放一些各种各样有趣的边框到一些可见的组件上。下面的程序例子利用一个创建JPanel并安放边框到每个例子中的被称为showBorder()的方法，示范了一些有用的不同的边框。同样，它也使用RTTI来找我们使用的边框名（剔除所有的路径信息），然后将边框名放到面板中间的JLable里：

  1. //: Borders.java
  2. // Different Swing borders
  3. package c13.swing;
  4. import java.awt.*;
  5. import java.awt.event.*;
  6. import javax.swing.*;
  7. import javax.swing.border.*;
  9. public class Borders extends JPanel {
  10.   static JPanel showBorder(Border b) {
  11.     JPanel jp = new JPanel();
  12.     jp.setLayout(new BorderLayout());
  13.     String nm = b.getClass().toString();
  14.     nm = nm.substring(nm.lastIndexOf('.') + 1);
  15.     jp.add(new JLabel(nm, JLabel.CENTER),
  16.       BorderLayout.CENTER);
  17.     jp.setBorder(b);
  18.     return jp;
  19.   }
  20.   public Borders() {
  21.     setLayout(new GridLayout(2,4));
  22.     add(showBorder(new TitledBorder("Title")));
  23.     add(showBorder(new EtchedBorder()));
  24.     add(showBorder(new LineBorder(Color.blue)));
  25.     add(showBorder(
  26.       new MatteBorder(5,5,30,30,Color.green)));
  27.     add(showBorder(
  28.       new BevelBorder(BevelBorder.RAISED)));
  29.     add(showBorder(
  30.       new SoftBevelBorder(BevelBorder.LOWERED)));
  31.     add(showBorder(new CompoundBorder(
  32.       new EtchedBorder(),
  33.       new LineBorder(Color.red))));
  34.   }
  35.   public static void main(String args[]) {
  36.     Show.inFrame(new Borders(), 500, 300);
  37.   }
  38. } ///:~

这一节中大多数程序例子都使用TitledBorder，但我们可以注意到其余的边框也同样易于使用。能创建我们自己的边框并安放它们到按钮、标签等等内——任何来自JComponent的东西。

13.19.6 按钮

Swing增加了一些不同类型的按钮，并且它同样可以修改选择组件的结构：所有的按钮、复选框、单选钮，甚至从AbstractButton处继承的菜单项（这是因为菜单项一般被包含在其中，它可能会被改进命名为AbstractChooser或者相同的什么名字）。我们会注意使用菜单项的简便，下面的例子展示了不同类型的可用的按钮：

  1. //: Buttons.java
  2. // Various Swing buttons
  3. package c13.swing;
  4. import java.awt.*;
  5. import java.awt.event.*;
  6. import javax.swing.*;
  7. import javax.swing.plaf.basic.*;
  8. import javax.swing.border.*;
  10. public class Buttons extends JPanel {
  11.   JButton jb = new JButton("JButton");
  12.   BasicArrowButton
  13.     up = new BasicArrowButton(
  14.       BasicArrowButton.NORTH),
  15.     down = new BasicArrowButton(
  16.       BasicArrowButton.SOUTH),
  17.     right = new BasicArrowButton(
  18.       BasicArrowButton.EAST),
  19.     left = new BasicArrowButton(
  20.       BasicArrowButton.WEST);
  21.   public Buttons() {
  22.     add(jb);
  23.     add(new JToggleButton("JToggleButton"));
  24.     add(new JCheckBox("JCheckBox"));
  25.     add(new JRadioButton("JRadioButton"));
  26.     JPanel jp = new JPanel();
  27.     jp.setBorder(new TitledBorder("Directions"));
  28.     jp.add(up);
  29.     jp.add(down);
  30.     jp.add(left);
  31.     jp.add(right);
  32.     add(jp);
  33.   }
  34.   public static void main(String args[]) {
  35.     Show.inFrame(new Buttons(), 300, 200);
  36.   }
  37. } ///:~

JButton看起来像AWT按钮，但它没有更多可运行的功能（像我们后面将看到的如加入图像等）。在com.sun.java.swing.basic里，有一个更合适的BasicArrowButton按钮，但怎样测试它呢？有两种类型的“指针”恰好请求箭头按钮使用：Spinner修改一个中断值，并且StringSpinner通过一个字符串数组来移动（当它到达数组底部时，甚至会自动地封装）。ActionListeners附着在箭头按钮上展示它使用的这些相关指针：因为它们是Bean，我们将期待利用方法名，正好捕捉并设置它们的值。

当我们运行这个程序例子时，我们会发现触发按钮保持它最新状态，开或时关。但复选框和单选钮每一个动作都相同，选中或没选中（它们从JToggleButton处继承）。

13.19.7 按钮组

如果我们想单选钮保持“异或”状态，我们必须增加它们到一个按钮组中，这几乎同老AWT中的方法相同但更加的灵活。在下面将要证明的程序例子是，一些AbstruactButton能被增加到一个ButtonGroup中。

为避免重复一些代码，这个程序利用映射来生不同类型的按钮组。这会在makeBPanel中看到，makeBPanel创建了一个按钮组和一个JPanel，并且为数组中的每个String就是makeBPanel的第二个参数增加一个类对象，由它的第一个参数进行声明：

  1. //: ButtonGroups.java
  2. // Uses reflection to create groups of different
  3. // types of AbstractButton.
  4. package c13.swing;
  5. import java.awt.*;
  6. import java.awt.event.*;
  7. import javax.swing.*;
  8. import javax.swing.border.*;
  9. import java.lang.reflect.*;
  11. public class ButtonGroups extends JPanel {
  12.   static String[] ids = {
  13.     "June", "Ward", "Beaver",
  14.     "Wally", "Eddie", "Lumpy",
  15.   };
  16.   static JPanel
  17.   makeBPanel(Class bClass, String[] ids) {
  18.     ButtonGroup bg = new ButtonGroup();
  19.     JPanel jp = new JPanel();
  20.     String title = bClass.getName();
  21.     title = title.substring(
  22.       title.lastIndexOf('.') + 1);
  23.     jp.setBorder(new TitledBorder(title));
  24.     for(int i = 0; i < ids.length; i++) {
  25.       AbstractButton ab = new JButton("failed");
  26.       try {
  27.         // Get the dynamic constructor method
  28.         // that takes a String argument:
  29.         Constructor ctor = bClass.getConstructor(
  30.           new Class[] { String.class });
  31.         // Create a new object:
  32.         ab = (AbstractButton)ctor.newInstance(
  33.           new Object[]{ids[i]});
  34.       } catch(Exception ex) {
  35.         System.out.println("can't create " +
  36.           bClass);
  37.       }
  38.       bg.add(ab);
  39.       jp.add(ab);
  40.     }
  41.     return jp;
  42.   }
  43.   public ButtonGroups() {
  44.     add(makeBPanel(JButton.class, ids));
  45.     add(makeBPanel(JToggleButton.class, ids));
  46.     add(makeBPanel(JCheckBox.class, ids));
  47.     add(makeBPanel(JRadioButton.class, ids));
  48.   }
  49.   public static void main(String args[]) {
  50.     Show.inFrame(new ButtonGroups(), 500, 300);
  51.   }
  52. } ///:~

边框标题由类名剔除了所有的路径信息而来。AbstractButton初始化为一个JButton，JButtonr的标签发生“失效”，因此如果我们忽略这个异常信息，我们会在屏幕上一直看到这个问题。getConstructor()方法产生了一个通过getConstructor()方法安放参数数组类型到类数组的构造器对象，然后所有我们要做的就是调用newInstance()，通过它一个数组对象包含我们当前的参数——在这种例子中，就是ids数组中的字符串。

这样增加了一些更复杂的内容到这个简单的程序中。为了使“异或”行为拥有按钮，我们创建一个按钮组并增加每个按钮到我们所需的组中。当我们运行这个程序时，我们会注意到所有的按钮除了JButton都会向我们展示“异或”行为。

13.19.8 图标

我们可在一个JLable或从AbstractButton处继承的任何事物中使用一个图标（包括JButton，JCheckbox，JradioButton及不同类型的JMenuItem)。利用JLables的图标十分的简单容易（我们会在随后的一个程序例子中看到）。下面的程序例子探索了我们可以利用按钮的图标和它们的派生物的其它所有方法。

我们可以使用任何我们需要的GIF文件，但在这个例子中使用的这个GIF文件是这本书编码发行的一部分，可以在www.BruceEckel.com处下载来使用。为了打开一个文件和随之带来的图像，简单地创建一个图标并分配它文件名。从那时起，我们可以在程序中使用这个产生的图标。

  1. //: Faces.java
  2. // Icon behavior in JButtons
  3. package c13.swing;
  4. import java.awt.*;
  5. import java.awt.event.*;
  6. import javax.swing.*;
  8. public class Faces extends JPanel {
  9.   static Icon[] faces = {
  10.     new ImageIcon("face0.gif"),
  11.     new ImageIcon("face1.gif"),
  12.     new ImageIcon("face2.gif"),
  13.     new ImageIcon("face3.gif"),
  14.     new ImageIcon("face4.gif"),
  15.   };
  16.   JButton
  17.     jb = new JButton("JButton", faces[3]),
  18.     jb2 = new JButton("Disable");
  19.   boolean mad = false;
  20.   public Faces() {
  21.     jb.addActionListener(new ActionListener() {
  22.       public void actionPerformed(ActionEvent e){
  23.         if(mad) {
  24.           jb.setIcon(faces[3]);
  25.           mad = false;
  26.         } else {
  27.           jb.setIcon(faces[0]);
  28.           mad = true;
  29.         }
  30.         jb.setVerticalAlignment(JButton.TOP);
  31.         jb.setHorizontalAlignment(JButton.LEFT);
  32.       }
  33.     });
  34.     jb.setRolloverEnabled(true);
  35.     jb.setRolloverIcon(faces[1]);
  36.     jb.setPressedIcon(faces[2]);
  37.     jb.setDisabledIcon(faces[4]);
  38.     jb.setToolTipText("Yow!");
  39.     add(jb);
  40.     jb2.addActionListener(new ActionListener() {
  41.       public void actionPerformed(ActionEvent e){
  42.         if(jb.isEnabled()) {
  43.           jb.setEnabled(false);
  44.           jb2.setText("Enable");
  45.         } else {
  46.           jb.setEnabled(true);
  47.           jb2.setText("Disable");
  48.         }
  49.       }
  50.     });
  51.     add(jb2);
  52.   }
  53.   public static void main(String args[]) {
  54.     Show.inFrame(new Faces(), 300, 200);
  55.   }
  56. } ///:~

一个图标可以在许多的构造器中使用，但我们可以使用setIcon()方法增加或更换图标。这个例子同样展示了当事件发生在JButton（或者一些AbstractButton）上时，为什么它可以设置各种各样的显示图标：当JButton被按下时，当它被失效时，或者“滚过”时（鼠标从它上面移动过但并不击它）。我们会注意到那给了按钮一种动画的感觉。 注意工具提示条也同样增加到按钮中。

13.19.9 菜单

菜单在Swing中做了重要的改进并且更加的灵活——例如，我们可以在几乎程序中任何地方使用他们，包括在面板和程序片中。语法同它们在老的AWT中是一样的，并且这样使出现在老AWT的在新的Swing也出现了：我们必须为我们的菜单艰难地编写代码，并且有一些不再作为资源支持菜单（其它事件中的一些将使它们更易转换成其它的编程语言）。另外，菜单代码相当的冗长，有时还有一些混乱。下面的方法是放置所有的关于每个菜单的信息到对象的二维数组里（这种方法可以放置我们想处理的任何事物到数组里），这种方法在解决这个问题方面领先了一步。这个二维数组被菜单所创建，因此它首先表示出菜单名，并在剩余的列中表示菜单项和它们的特性。我们会注意到数组列不必保持一致——只要我们的代码知道将发生的一切事件，每一列都可以完全不同。

  1. //: Menus.java
  2. // A menu-building system; also demonstrates
  3. // icons in labels and menu items.
  4. package c13.swing;
  5. import java.awt.*;
  6. import java.awt.event.*;
  7. import javax.swing.*;
  9. public class Menus extends JPanel {
  10.   static final Boolean
  11.     bT = new Boolean(true),
  12.     bF = new Boolean(false);
  13.   // Dummy class to create type identifiers:
  14.   static class MType { MType(int i) {} };
  15.   static final MType
  16.     mi = new MType(1), // Normal menu item
  17.     cb = new MType(2), // Checkbox menu item
  18.     rb = new MType(3); // Radio button menu item
  19.   JTextField t = new JTextField(10);
  20.   JLabel l = new JLabel("Icon Selected",
  21.     Faces.faces[0], JLabel.CENTER);
  22.   ActionListener a1 = new ActionListener() {
  23.     public void actionPerformed(ActionEvent e) {
  24.       t.setText(
  25.         ((JMenuItem)e.getSource()).getText());
  26.     }
  27.   };
  28.   ActionListener a2 = new ActionListener() {
  29.     public void actionPerformed(ActionEvent e) {
  30.       JMenuItem mi = (JMenuItem)e.getSource();
  31.       l.setText(mi.getText());
  32.       l.setIcon(mi.getIcon());
  33.     }
  34.   };
  35.   // Store menu data as "resources":
  36.   public Object[][] fileMenu = {
  37.     // Menu name and accelerator:
  38.     { "File", new Character('F') },
  39.     // Name type accel listener enabled
  40.     { "New", mi, new Character('N'), a1, bT },
  41.     { "Open", mi, new Character('O'), a1, bT },
  42.     { "Save", mi, new Character('S'), a1, bF },
  43.     { "Save As", mi, new Character('A'), a1, bF},
  44.     { null }, // Separator
  45.     { "Exit", mi, new Character('x'), a1, bT },
  46.   };
  47.   public Object[][] editMenu = {
  48.     // Menu name:
  49.     { "Edit", new Character('E') },
  50.     // Name type accel listener enabled
  51.     { "Cut", mi, new Character('t'), a1, bT },
  52.     { "Copy", mi, new Character('C'), a1, bT },
  53.     { "Paste", mi, new Character('P'), a1, bT },
  54.     { null }, // Separator
  55.     { "Select All", mi,new Character('l'),a1,bT},
  56.   };
  57.   public Object[][] helpMenu = {
  58.     // Menu name:
  59.     { "Help", new Character('H') },
  60.     // Name type accel listener enabled
  61.     { "Index", mi, new Character('I'), a1, bT },
  62.     { "Using help", mi,new Character('U'),a1,bT},
  63.     { null }, // Separator
  64.     { "About", mi, new Character('t'), a1, bT },
  65.   };
  66.   public Object[][] optionMenu = {
  67.     // Menu name:
  68.     { "Options", new Character('O') },
  69.     // Name type accel listener enabled
  70.     { "Option 1", cb, new Character('1'), a1,bT},
  71.     { "Option 2", cb, new Character('2'), a1,bT},
  72.   };
  73.   public Object[][] faceMenu = {
  74.     // Menu name:
  75.     { "Faces", new Character('a') },
  76.     // Optinal last element is icon
  77.     { "Face 0", rb, new Character('0'), a2, bT,
  78.       Faces.faces[0] },
  79.     { "Face 1", rb, new Character('1'), a2, bT,
  80.       Faces.faces[1] },
  81.     { "Face 2", rb, new Character('2'), a2, bT,
  82.       Faces.faces[2] },
  83.     { "Face 3", rb, new Character('3'), a2, bT,
  84.       Faces.faces[3] },
  85.     { "Face 4", rb, new Character('4'), a2, bT,
  86.       Faces.faces[4] },
  87.   };
  88.   public Object[] menuBar = {
  89.     fileMenu, editMenu, faceMenu,
  90.     optionMenu, helpMenu,
  91.   };
  92.   static public JMenuBar
  93.   createMenuBar(Object[] menuBarData) {
  94.     JMenuBar menuBar = new JMenuBar();
  95.     for(int i = 0; i < menuBarData.length; i++)
  96.       menuBar.add(
  97.         createMenu((Object[][])menuBarData[i]));
  98.     return menuBar;
  99.   }
  100.   static ButtonGroup bgroup;
  101.   static public JMenu
  102.   createMenu(Object[][] menuData) {
  103.     JMenu menu = new JMenu();
  104.     menu.setText((String)menuData[0][0]);
  105.     menu.setMnemonic(
  106.       ((Character)menuData[0][1]).charValue());
  107.     // Create redundantly, in case there are
  108.     // any radio buttons:
  109.     bgroup = new ButtonGroup();
  110.     for(int i = 1; i < menuData.length; i++) {
  111.       if(menuData[i][0] == null)
  112.         menu.add(new JSeparator());
  113.       else
  114.         menu.add(createMenuItem(menuData[i]));
  115.     }
  116.     return menu;
  117.   }
  118.   static public JMenuItem
  119.   createMenuItem(Object[] data) {
  120.     JMenuItem m = null;
  121.     MType type = (MType)data[1];
  122.     if(type == mi)
  123.       m = new JMenuItem();
  124.     else if(type == cb)
  125.       m = new JCheckBoxMenuItem();
  126.     else if(type == rb) {
  127.       m = new JRadioButtonMenuItem();
  128.       bgroup.add(m);
  129.     }
  130.     m.setText((String)data[0]);
  131.     m.setMnemonic(
  132.       ((Character)data[2]).charValue());
  133.     m.addActionListener(
  134.       (ActionListener)data[3]);
  135.     m.setEnabled(
  136.       ((Boolean)data[4]).booleanValue());
  137.     if(data.length == 6)
  138.       m.setIcon((Icon)data[5]);
  139.     return m;
  140.   }
  141.   Menus() {
  142.     setLayout(new BorderLayout());
  143.     add(createMenuBar(menuBar),
  144.       BorderLayout.NORTH);
  145.     JPanel p = new JPanel();
  146.     p.setLayout(new BorderLayout());
  147.     p.add(t, BorderLayout.NORTH);
  148.     p.add(l, BorderLayout.CENTER);
  149.     add(p, BorderLayout.CENTER);
  150.   }
  151.   public static void main(String args[]) {
  152.     Show.inFrame(new Menus(), 300, 200);
  153.   }
  154. } ///:~

这个程序的目的是允许程序设计者简单地创建表格来描述每个菜单，而不是输入代码行来建立菜单。每个菜单都产生一个菜单，表格中的第一列包含菜单名和键盘快捷键。其余的列包含每个菜单项的数据：字符串存在在菜单项中的位置，菜单的类型，它的快捷键，当菜单项被选中时被激活的动作接收器及菜单是否被激活等信息。如果列开始处是空的，它将被作为一个分隔符来处理。

为了预防浪费和冗长的多个Boolean创建的对象和类型标志，以下的这些在类开始时就作为static final被创建：bT和bF描述Booleans和哑类MType的不同对象描述标准的菜单项（mi），复选框菜单项（cb），和单选钮菜单项（rb）。请记住一组Object可以拥有单一的Object引用，并且不再是原来的值。

这个程序例子同样展示了JLables和JMenuItems（和它们的派生事物）如何处理图标的。一个图标经由它的构造器置放进JLable中并当对应的菜单项被选中时被改变。

菜单条数组控制处理所有在文件菜单清单中列出的，我们想显示在菜单条上的文件菜单。我们通过这个数组去使用createMenuBar()，将数组分类成单独的菜单数据数组，再通过每个单独的数组去创建菜单。这种方法依次使用菜单数据的每一行并以该数据创建JMenu，然后为菜单数据中剩下的每一行调用createMenuItem()方法。最后，createMenuItem()方法分析菜单数据的每一行并且判断菜单类型和它的属性，再适当地创建菜单项。终于，像我们在菜单构造器中看到的一样，从表示createMenuBar(menuBar)的表格中创建菜单，而所有的事物都是采用递归方法处理的。

这个程序不能建立串联的菜单，但我们拥有足够的知识，如果我们需要的话，随时都能增加多级菜单进去。

13.19.10 弹出式菜单

JPopupMenu的执行看起来有一些别扭：我们必须调用enableEvents()方法并选择鼠标事件代替利用事件接收器。它可能增加一个鼠标接收器但MouseEvent从isPopupTrigger()处不会返回真值——它不知道将激活一个弹出菜单。另外，当我们尝试接收器方法时，它的行为令人不可思议，这或许是鼠标单击活动引起的。在下面的程序例子里一些事件产生了这种弹出行为：

  1. //: Popup.java
  2. // Creating popup menus with Swing
  3. package c13.swing;
  4. import java.awt.*;
  5. import java.awt.event.*;
  6. import javax.swing.*;
  8. public class Popup extends JPanel {
  9.   JPopupMenu popup = new JPopupMenu();
  10.   JTextField t = new JTextField(10);
  11.   public Popup() {
  12.     add(t);
  13.     ActionListener al = new ActionListener() {
  14.       public void actionPerformed(ActionEvent e){
  15.         t.setText(
  16.           ((JMenuItem)e.getSource()).getText());
  17.       }
  18.     };
  19.     JMenuItem m = new JMenuItem("Hither");
  20.     m.addActionListener(al);
  21.     popup.add(m);
  22.     m = new JMenuItem("Yon");
  23.     m.addActionListener(al);
  24.     popup.add(m);
  25.     m = new JMenuItem("Afar");
  26.     m.addActionListener(al);
  27.     popup.add(m);
  28.     popup.addSeparator();
  29.     m = new JMenuItem("Stay Here");
  30.     m.addActionListener(al);
  31.     popup.add(m);
  32.     PopupListener pl = new PopupListener();
  33.     addMouseListener(pl);
  34.     t.addMouseListener(pl);
  35.   }
  36.   class PopupListener extends MouseAdapter {
  37.     public void mousePressed(MouseEvent e) {
  38.       maybeShowPopup(e);
  39.     }
  40.     public void mouseReleased(MouseEvent e) {
  41.       maybeShowPopup(e);
  42.     }
  43.     private void maybeShowPopup(MouseEvent e) {
  44.       if(e.isPopupTrigger()) {
  45.         popup.show(
  46.           e.getComponent(), e.getX(), e.getY());
  47.       }
  48.     }
  49.   }
  50.   public static void main(String args[]) {
  51.     Show.inFrame(new Popup(),200,150);
  52.   }
  53. } ///:~

相同的ActionListener被加入每个JMenuItem中，使其能从菜单标签中取出文字，并将文字插入JTextField。

13.19.11 列表框和组合框

列表框和组合框在Swing中工作就像它们在老的AWT中工作一样，但如果我们需要它，它们同样被增加功能。另外，它也更加的方便易用。例如，JList中有一个显示String数组的构造器（奇怪的是同样的功能在JComboBox中无效！）。下面的例子显示了它们基本的用法。

  1. //: ListCombo.java
  2. // List boxes & Combo boxes
  3. package c13.swing;
  4. import java.awt.*;
  5. import java.awt.event.*;
  6. import javax.swing.*;
  8. public class ListCombo extends JPanel {
  9.   public ListCombo() {
  10.     setLayout(new GridLayout(2,1));
  11.     JList list = new JList(ButtonGroups.ids);
  12.     add(new JScrollPane(list));
  13.     JComboBox combo = new JComboBox();
  14.     for(int i = 0; i < 100; i++)
  15.       combo.addItem(Integer.toString(i));
  16.     add(combo);
  17.   }
  18.   public static void main(String args[]) {
  19.     Show.inFrame(new ListCombo(),200,200);
  20.   }
  21. } ///:~

最开始的时候，似乎有点儿古怪的一种情况是JLists居然不能自动提供滚动特性——即使那也许正是我们一直所期望的。增加对滚动的支持变得十分容易，就像上面示范的一样——简单地将JList封装到JScrollPane即可，所有的细节都自动地为我们照料到了。

13.19.12 滑杆和进度指示条

滑杆用户能用一个滑块的来回移动来输入数据，在很多情况下显得很直观（如声音控制）。进程条从“空”到“满”显示相关数据的状态，因此用户得到了一个状态的透视。我最喜爱的有关这的程序例子简单地将滑动块同进程条挂接起来，所以当我们移动滑动块时，进程条也相应的改变：

  1. //: Progress.java
  2. // Using progress bars and sliders
  3. package c13.swing;
  4. import java.awt.*;
  5. import java.awt.event.*;
  6. import javax.swing.*;
  7. import javax.swing.event.*;
  8. import javax.swing.border.*;
  10. public class Progress extends JPanel {
  11.   JProgressBar pb = new JProgressBar();
  12.   JSlider sb =
  13.     new JSlider(JSlider.HORIZONTAL, 0, 100, 60);
  14.   public Progress() {
  15.     setLayout(new GridLayout(2,1));
  16.     add(pb);
  17.     sb.setValue(0);
  18.     sb.setPaintTicks(true);
  19.     sb.setMajorTickSpacing(20);
  20.     sb.setMinorTickSpacing(5);
  21.     sb.setBorder(new TitledBorder("Slide Me"));
  22.     pb.setModel(sb.getModel()); // Share model
  23.     add(sb);
  24.   }
  25.   public static void main(String args[]) {
  26.     Show.inFrame(new Progress(),200,150);
  27.   }
  28. } ///:~

JProgressBar十分简单，但JSlider却有许多选项，例如方法、大或小的记号标签。注意增加一个带标题的边框是多么的容易。

13.19.13 树

使用一个JTree可以简单地像下面这样表示：

  1. add(new JTree(
  2. new Object[] {"this", "that", "other"}));

这个程序显示了一个原始的树状物。树状物的API是非常巨大的，可是——当然是在Swing中的巨大。它表明我们可以做有关树状物的任何事，但更复杂的任务可能需要不少的研究和试验。幸运的是，在库中提供了一个妥协：“默认的”树状物组件，通常那是我们所需要的。因此大多数的时间我们可以利用这些组件，并且只在特殊的情况下我们需要更深入的研究和理解。

下面的例子使用了“默认”的树状物组件在一个程序片中显示一个树状物。当我们按下按钮时，一个新的子树就被增加到当前选中的结点下（如果没有结点被选中，就用根结节）：

  1. //: Trees.java
  2. // Simple Swing tree example. Trees can be made
  3. // vastly more complex than this.
  4. package c13.swing;
  5. import java.awt.*;
  6. import java.awt.event.*;
  7. import javax.swing.*;
  8. import javax.swing.tree.*;
  10. // Takes an array of Strings and makes the first
  11. // element a node and the rest leaves:
  12. class Branch {
  13.   DefaultMutableTreeNode r;
  14.   public Branch(String[] data) {
  15.     r = new DefaultMutableTreeNode(data[0]);
  16.     for(int i = 1; i < data.length; i++)
  17.       r.add(new DefaultMutableTreeNode(data[i]));
  18.   }
  19.   public DefaultMutableTreeNode node() {
  20.     return r;
  21.   }
  22. }  
  24. public class Trees extends JPanel {
  25.   String[][] data = {
  26.     { "Colors", "Red", "Blue", "Green" },
  27.     { "Flavors", "Tart", "Sweet", "Bland" },
  28.     { "Length", "Short", "Medium", "Long" },
  29.     { "Volume", "High", "Medium", "Low" },
  30.     { "Temperature", "High", "Medium", "Low" },
  31.     { "Intensity", "High", "Medium", "Low" },
  32.   };
  33.   static int i = 0;
  34.   DefaultMutableTreeNode root, child, chosen;
  35.   JTree tree;
  36.   DefaultTreeModel model;
  37.   public Trees() {
  38.     setLayout(new BorderLayout());
  39.     root = new DefaultMutableTreeNode("root");
  40.     tree = new JTree(root);
  41.     // Add it and make it take care of scrolling:
  42.     add(new JScrollPane(tree),
  43.       BorderLayout.CENTER);
  44.     // Capture the tree's model:
  45.     model =(DefaultTreeModel)tree.getModel();
  46.     JButton test = new JButton("Press me");
  47.     test.addActionListener(new ActionListener() {
  48.       public void actionPerformed(ActionEvent e){
  49.         if(i < data.length) {
  50.           child = new Branch(data[i++]).node();
  51.           // What's the last one you clicked?
  52.           chosen = (DefaultMutableTreeNode)
  53.             tree.getLastSelectedPathComponent();
  54.           if(chosen == null) chosen = root;
  55.           // The model will create the
  56.           // appropriate event. In response, the
  57.           // tree will update itself:
  58.           model.insertNodeInto(child, chosen, 0);
  59.           // This puts the new node on the
  60.           // currently chosen node.
  61.         }
  62.       }
  63.     });
  64.     // Change the button's colors:
  65.     test.setBackground(Color.blue);
  66.     test.setForeground(Color.white);
  67.     JPanel p = new JPanel();
  68.     p.add(test);
  69.     add(p, BorderLayout.SOUTH);
  70.   }
  71.   public static void main(String args[]) {
  72.     Show.inFrame(new Trees(),200,500);
  73.   }
  74. } ///:~

最重要的类就是分支，它是一个工具，用来获取一个字符串数组并为第一个字符串建立一个DefaultMutableTreeNode作为根，其余在数组中的字符串作为叶。然后node()方法被调用以产生“分支”的根。树状物类包括一个来自被制造的分支的二维字符串数组，以及用来统计数组的一个静态中断i。DefaultMutableTreeNode对象控制这个结节，但在屏幕上表示的是被JTree和它的相关（DefaultTreeModel）模式所控制。注意当JTree被增加到程序片时，它被封装到JScrollPane中——这就是它全部提供的自动滚动。

JTree通过它自己的模型来控制。当我们修改这个模型时，模型产生一个事件，导致JTree对可以看见的树状物完成任何必要的升级。在init()中，模型由调用getModel()方法所捕捉。当按钮被按下时，一个新的分支被创建了。然后，当前选择的组件被找到（如果没有选择就是根）并且模型的insertNodeInto()方法做所有的改变树状物和导致它升级的工作。

大多数的时候，就像上面的例子一样，程序将给我们在树状物中所需要的一切。不过，树状物拥有力量去做我们能够想像到的任何事——在上面的例子中我们到处都可看到“default（默认）”字样，我们可以取代我们自己的类来获取不同的动作。但请注意：几乎所有这些类都有一个具大的接口，因此我们可以花一些时间努力去理解这些错综复杂的树状物。

13.19.14 表格

和树状物一样，表格在Swing相当的庞大和强大。它们最初有意被设计成以Java数据库连结（JDBC，在15章有介绍）为媒介的“网格”数据库接口，并且因此它们拥有的巨大的灵活性，使我们不再感到复杂。无疑，这是足以成为成熟的电子数据表的基础条件而且可能为整本书提供很好的根据。但是，如果我们理解这个的基础条件，它同样可能创建相关的简单的Jtable。

JTable控制数据的显示方式，但TableModel控制它自己的数据。因此在我们创建JTable前，应先创建一个TableModel。我们可以全部地执行TableModel接口，但它通常从helper类的AbstractTableModel处简单地继承：

  1. //: Table.java
  2. // Simple demonstration of JTable
  3. package c13.swing;
  4. import java.awt.*;
  5. import java.awt.event.*;
  6. import javax.swing.*;
  7. import javax.swing.table.*;
  8. import javax.swing.event.*;
  10. // The TableModel controls all the data:
  11. class DataModel extends AbstractTableModel {
  12.   Object[][] data = {
  13.     {"one", "two", "three", "four"},
  14.     {"five", "six", "seven", "eight"},
  15.     {"nine", "ten", "eleven", "twelve"},
  16.   };
  17.   // Prints data when table changes:
  18.   class TML implements TableModelListener {
  19.     public void tableChanged(TableModelEvent e) {
  20.       for(int i = 0; i < data.length; i++) {
  21.         for(int j = 0; j < data[0].length; j++)
  22.           System.out.print(data[i][j] + " ");
  23.         System.out.println();
  24.       }
  25.     }
  26.   }
  27.   DataModel() {
  28.     addTableModelListener(new TML());
  29.   }
  30.   public int getColumnCount() {
  31.     return data[0].length;
  32.   }
  33.   public int getRowCount() {
  34.     return data.length;
  35.   }
  36.   public Object getValueAt(int row, int col) {
  37.     return data[row][col];
  38.   }
  39.   public void
  40.   setValueAt(Object val, int row, int col) {
  41.     data[row][col] = val;
  42.     // Indicate the change has happened:
  43.     fireTableDataChanged();
  44.   }
  45.   public boolean
  46.   isCellEditable(int row, int col) {
  47.     return true;
  48.   }
  49. };       
  51. public class Table extends JPanel {
  52.   public Table() {
  53.     setLayout(new BorderLayout());
  54.     JTable table = new JTable(new DataModel());
  55.     JScrollPane scrollpane =
  56.       JTable.createScrollPaneForTable(table);
  57.     add(scrollpane, BorderLayout.CENTER);
  58.   }
  59.   public static void main(String args[]) {
  60.     Show.inFrame(new Table(),200,200);
  61.   }
  62. } ///:~

DateModel包括一组数据，但我们同样能从其它的地方得到数据，例如从数据库中。构造器增加了一个TableModelListener用来在每次表格被改变后打印数组。剩下的方法都遵循Bean的命名规则，并且当JTable需要在DateModel中显示信息时调用。AbstractTableModel提供了默认的setValueAt()和isCellEditable()方法以防止修改这些数据，因此如果我们想修改这些数据，就必须重载这些方法。

一旦我们拥有一个TableModel，我们只需要将它分配给JTable构造器即可。所有有关显示，编辑和更新的详细资料将为我们处理。注意这个程序例子同样将JTable放置在JScrollPane中，这是因为JScrollPane需要一个特殊的JTable方法。

13.19.15 卡片式对话框

在本章的前部，向我们介绍了老式的CardLayout，并且注意到我们怎样去管理我们所有的卡片开关。有趣的是，有人现在认为这是一种不错的设计。幸运的是，Swing用JTabbedPane对它进行了修补，由JTabbedPane来处理这些卡片，开关和其它的任何事物。对比CardLayout和JTabbedPane，我们会发现惊人的差异。

下面的程序例子十分的有趣，因为它利用了前面例子的设计。它们都是做为JPanel的派生物来构建的，因此这个程序将安放前面的每个例子到它自己在JTabbedPane的窗格中。我们会看到利用RTTI制造的程序十分的小巧精致：

  1. //: Tabbed.java
  2. // Using tabbed panes
  3. package c13.swing;
  4. import java.awt.*;
  5. import javax.swing.*;
  6. import javax.swing.border.*;
  8. public class Tabbed extends JPanel {
  9.   static Object[][] q = {
  10.     { "Felix", Borders.class },
  11.     { "The Professor", Buttons.class },
  12.     { "Rock Bottom", ButtonGroups.class },
  13.     { "Theodore", Faces.class },
  14.     { "Simon", Menus.class },
  15.     { "Alvin", Popup.class },
  16.     { "Tom", ListCombo.class },
  17.     { "Jerry", Progress.class },
  18.     { "Bugs", Trees.class },
  19.     { "Daffy", Table.class },
  20.   };
  21.   static JPanel makePanel(Class c) {
  22.     String title = c.getName();
  23.     title = title.substring(
  24.       title.lastIndexOf('.') + 1);
  25.     JPanel sp = null;
  26.     try {
  27.       sp = (JPanel)c.newInstance();
  28.     } catch(Exception e) {
  29.       System.out.println(e);
  30.     }
  31.     sp.setBorder(new TitledBorder(title));
  32.     return sp;
  33.   }
  34.   public Tabbed() {
  35.     setLayout(new BorderLayout());
  36.     JTabbedPane tabbed = new JTabbedPane();
  37.     for(int i = 0; i < q.length; i++)
  38.       tabbed.addTab((String)q[i][0],
  39.         makePanel((Class)q[i][1]));
  40.     add(tabbed, BorderLayout.CENTER);
  41.     tabbed.setSelectedIndex(q.length/2);
  42.   }
  43.   public static void main(String args[]) {
  44.     Show.inFrame(new Tabbed(),460,350);
  45.   }
  46. } ///:~

再者，我们可以注意到使用的数组构造式样：第一个元素是被置放在卡片上的String，第二个元素是将被显示在对应窗格上JPanel类。在Tabbed()构造器里，我们可以看到两个重要的JTabbedPane方法被使用：addTab()插入一个新的窗格，setSelectedIndex()选择一个窗格并从它开始。（一个在中间被选中的窗格证明我们不必从第一个窗格开始）。

当我们调用addTab()方法时，我们为它提供卡片的String和一些组件（也就是说，一个AWT组件，而不是一个来自AWT的JComponent）。这个组件会被显示在窗格中。一旦我们这样做了，自然而然的就不需要更多管理了——JTabbedPane会为我们处理其它的任何事。

makePanel()方法获取我们想创建的类Class对象和用newInstance()去创建并转换为JPanel（当然，假定那些类是必须从JPanel继承才能增加的类，除非在这一节中为程序例子的结构所使用）。它增加了一个包括类名并返回结果的TitledBorder，以作为一个JPanel在addTab()被使用。

当我们运行程序时，我们会发现如果卡片太多，填满了一行，JTabbedPane自动地将它们堆积起来。

13.19.16 Swing消息框

开窗的环境通常包含一个标准的信息框集，允许我们很快传递消息给用户或者从用户那里捕捉消息。在Swing里，这些信息窗被包含在JOptionPane里的。我们有一些不同的可能实现的事件（有一些十分复杂），但有一点，我们必须尽可能的利用static JOptionPane.showMessageDialog()和JOptionPane.showConfirmDialog()方法，调用消息对话框和确认对话框。

13.19.17 Swing更多的知识

这一节意味着唯一向我们介绍的是Swing的强大力量和我们的着手处，因此我们能注意到通过库，我们会感觉到我们的方法何等的简单。到目前为止，我们已看到的可能足够满足我们UI设计需要的一部分。不过，这里有许多有关Swing额外的情况——它有意成为一全功能的UI设计工具箱。如果我们没有发现我们所需要的，请到SUN公司的在线文件中去查找，并搜索WEB。这个方法几乎可以完成我们能想到的任何事。

本节中没有涉及的一些要点：

  • 更多特殊的组件，例如JColorChooser,JFileChooser,JPasswordField,JHTMLPane（完成简单的HTML格式化和显示）以及JTextPane（一个支持格式化，字处理和图像的文字编辑器）。它们都非常易用。
  • Swing的新的事件类型。在一些方法中，它们看起来像异常：类型非常的重要，名字可以被用来表示除了它们自己之外的任何事物。
  • 新的布局管理：Springs & Struts以及BoxLayout
  • 分裂控制：一个间隔物式的分裂条，允许我们动态地处理其它组件的位置。
  • JLayeredPane和JInternalFrame被一起用来在当前帧中创建子帧，以产生多文件接口（MDI）应用程序。
  • 可插入的外观和效果，因此我们可以编写单个的程序可以像期望的那样动态地适合不同的平台和操作系统。
  • 自定义光标。
  • JToolbar API提供的可拖动的浮动工具条。
  • 双缓存和为平整屏幕重新画线的自动重画批次。
  • 内建“取消”支持。
  • 拖放支持。