Swing学习篇 API [一]Swing常用组件

1.按钮(Jbutton)

      Swing中的按钮是Jbutton,它是javax.swing.AbstracButton类的子类，swing中的按钮可以显示图像，并且可以将按钮设置为窗口的默认图标，而且还可以将多个图像指定给一个按钮。

      在JButton中有如下几个比较常用的构造方法。

• JButton(Icon icon): 按钮上显示图标。
• JButton(String text): 按钮上显示字符。
• JButton(String text,Icon icon): 按钮上既显示图标又先施字符。

      JButton类的方法:

• setText(String text): 设置按钮的标签文本。
• setIcon(Icon defaultIcon): 设置按钮在默认状态下显示的图片。
• setRolloverIcon(Icon rolloverIcon): 设置当光标移动到按钮上方时显示的图片。
• setPressedIcon(Icon pressedIcon): 设置当按钮被按下时显示的图片。
• setContentAreaFilled(boolean b): 设置按钮的背景为同名，当设为fase时表示不绘制，默认为绘制。
• setBorderPainted(boolean b): 设置为不绘制按钮的边框，当设为false时表示不绘制，默认为绘制。

      按钮组件是GUI中最常用的一种组件。按钮组件可以捕捉到用户的单击事件，同时利用按钮事件处理机制响应用户的请求。JButton类是Swing提供的按钮组件，在单击JButton类对象创建的按钮时，会产生一个ActionEvent事件。

      代码实例：

package jFrameDemo;

import java.applet.*;
import java.awt.*;
import java.awt.event.*;

@SuppressWarnings("all")
public class ButtonDemo extends Applet implements ActionListener {
    String msg = "";
    Button yes,no,undecided;
    
    public void init() {
        yes = new Button("Yes");
        no = new Button("No");
        undecided = new Button("Undecided");
        
        add(yes);
        add(no);
        add(undecided);
        
        yes.addActionListener(this);
        no.addActionListener(this);
        undecided.addActionListener(this);
    }
    
    public void actionPerformed(ActionEvent ee) {
        String str = ee.getActionCommand();
        if (str.equals("Yes")) {
            msg = "您选择了Yes!";
        }else if (str.equals("No")) {
            msg = "您选择了No!";
        }else {
            msg = "您选择了Undecided!";
        }
        repaint();
    }
    
    public void paint(Graphics g){
        g.drawString(msg, 6, 100);
    }
}

运行效果如下：

2.单选按钮(JRadioButton)

      JRadioButton组件实现的是一个单选按钮。JRadioButton类可以单独使用，也可以与ButtonGroup类联合使用，当单独使用时，该单选按钮可以被选定和取消选定；当与ButtonGroup类联合使用，需要使用add()方法将JRadioButton添加到ButtonGroup中，并组成一个单选按钮组。此时用户只能选定按钮组中的一个单选按钮。

      JRadioButton组件的常用方法:

• setText(String text):设置单选按钮的标签文本。
• setSelected(boolean b):设置单选按钮的状态，默认情况下未被选中，当设为true时表示单选按钮被选中。
• add(AbatractButton b):添加按钮到按钮组中。
• remove(AbatractButton b):从按钮组中移除按钮。
• getButtonCount():返回按钮组中包含按钮的个数，返回值为int型。
• getElements():返回一个Enumeration类型的对象，通过该对象可以遍历按钮组中包含的所有按钮对象。
• isSelected():返回单选按钮的状态，当设为true时为选中。
• setSelected(boolean b):设定单选按钮的状态。

【例】实例功能是选择用户所喜欢的城市。

package com.sy.swing;

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

public class JRadioButtonTest extends JFrame {

    /**
     * Launch the application.
     */
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    JRadioButtonTest frame = new JRadioButtonTest();
                                                         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                    frame.setBounds(100, 100, 450, 300);
                    frame.setTitle("单选框示例");
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the frame.
     */
    public JRadioButtonTest() {
        Container contentPane = getContentPane(); //创建一个内容面板容器
        contentPane.setLayout(new FlowLayout()); //设置该窗口的布局
        JPanel p1 = new JPanel(); //创建一个面板对象p1
        p1.setLayout(new GridLayout(1, 3)); //设置布局管理器的格式
        p1.setBorder(BorderFactory.createTitledBorder("选择你喜欢的城市"));
        //定义3个JRadioButton单选按钮
        JRadioButton r1 = new JRadioButton("北京");
        JRadioButton r2 = new JRadioButton("上海");
        JRadioButton r3 = new JRadioButton("青岛");
        p1.add(r1);
        p1.add(r2);
        p1.add(r3);
        r1.setSelected(true); //设置"北京"单选按钮的状态为被选中
        contentPane.add(p1); // 面板对象p1加到窗口内容面板容器中
        pack();
        addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e){
                System.exit(0);
            }
        });
    }
}

　　代码运行结果如下

      程序运行结果如图所示。程序首先创建JFrame窗口对象,内容版面(contentPane)，并设置窗口的布局格式为流布局FlowLayout();之后定义3个JRadioButton对象，并设置各自的现实文本同事添加到面板对象p1中；然后为窗口设置事件监听。

3.复选框(JCheckBox)

　　使用复选框可以完成多项选择。Swing中的复选框与awt中的复选框相比，优点是Swing复选框中可以添加图片。复选框可以为每一次的单击操作添加一个事件。

　　复选框的构造方法如下。

• JCheckBox(Icon icon):创建一个有图标，但未被选中的复选框。
• JCheckBox(Icon icon,boolean selected):创建一个有图标复选框，并且制定是否被选中。
• JCheckBox(String text):创建一个有文本，但未被选中的复选框。
• JCheckBox(String text,boolean selected):创建一个有文本复选框，并且制定是否被选中。
• JCheckBox(String text,Icon icon):创建一个指定文本和图标，但未被选中的复选框。
• JCheckBox(String text,Icon icon,boolean selected):创建一个指定文本和图标，并且制定是否被选中的复选框。

　　常用方法：

• public boolean isSelected():返回复选框状态，true时为选中。
• public void setSelected(boolean b):设定复选框状态。

　　代码实例：

package jFrameDemo;

import java.applet.*;
import java.awt.*;
import java.awt.event.*;

@SuppressWarnings("all")
public class CheckboxDemo extends Applet implements ItemListener {
    String msg = "";
    Checkbox windows,android,solaris,mac;
    
    public void init() {
        windows = new Checkbox("Windows",null,true);
        android = new Checkbox("Android");
        solaris = new Checkbox("Solaris");
        mac = new Checkbox("Mac");
        
        add(windows);
        add(android);
        add(solaris);
        add(mac);
        
        windows.addItemListener(this);
        android.addItemListener(this);
        solaris.addItemListener(this);
        mac.addItemListener(this);
    }
    
    public void itemStateChanged(ItemEvent ie){
        repaint();
    }
    
    public void paint(Graphics g){
        msg = "Current state:";
        g.drawString(msg, 6, 80);
        msg = "Windows: " + windows.getState();
        g.drawString(msg, 6, 100);
        msg = "Android: " + android.getState();
        g.drawString(msg, 6, 120);
        msg = "Solaris: " + solaris.getState();
        g.drawString(msg, 6, 140);
        msg = "Mac OS: " + mac.getState();
        g.drawString(msg, 6, 160);
    }
}

代码运行展示如下:

 4.组合框(JComboBox)

　　JComboBox组件用来创建组合框对象。通常，根据组合框是否可编辑的状态，可以将组合框分成两种常见的外观。可编辑状态外观可视为文本框和下拉列表的组合，不可编辑状态的外观可视为按钮和下拉列表的组合。在按钮或文本框的右边有一个带三角符号的下拉按钮，用户可以单击该下拉按钮，便可出现一个内容列表，这也是组合框的得名。组合框通常用于从列表的”多个项目中选择一个”的操作。

　　JComboBox的构造方法有如下几种：

• JComboBox():创建一个默认模型的组合框。
• JComboBox(ComboBoxModel aModel):创建一个指定模型的组合框。

　　JComboBox(Object[] items):创建一个具有数组定义列表内容的组合框。

　　实例代码如下

package JFrameTest;

import java.awt.BorderLayout;

@SuppressWarnings("all")
public class ComboBoxFrame extends JFrame {

    private JComboBox faceCombo;
    private JLabel label;
    private static final int DEFAULT_SIZE = 24;

    /**
     * Launch the application.
     */
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    ComboBoxFrame frame = new ComboBoxFrame();
                    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                    frame.setBounds(100, 100, 450, 300);
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the frame.
     */
    public ComboBoxFrame() {
        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);
        
        faceCombo = new JComboBox();
        faceCombo.addItem("Serif");
        faceCombo.addItem("SnsSerif");
        faceCombo.addItem("Monospaced");
        faceCombo.addItem("Dialog");
        faceCombo.addItem("DialogInput");
        
        faceCombo.addActionListener(new ActionListener() {
            
            @Override
            public void actionPerformed(ActionEvent e) {
                // TODO Auto-generated method stub
                label.setFont(new Font((String) faceCombo.getItemAt(faceCombo.getSelectedIndex()),Font.PLAIN,DEFAULT_SIZE));
            }
        });
        
        JPanel comboJPanel = new JPanel();
        comboJPanel.add(faceCombo);
        add(comboJPanel,BorderLayout.SOUTH);
        pack();
    }

}

　　代码运行结果如图

5.列表(JList)

　　JList组件用于定义列表，允许用户选择一个或多个项目。与JTextArea类似，JList本身不支持滚动功能，如果要显示超出显示范围的项目，可以将JList对象放置到滚动窗格JScrollPane对象中，变可以为列表对象实现滚动操作。

　　JList的构造方法如下：

• JList():创建一个空模型的列表。
• JList(ListModel dataModel):创建一愕指定模型的列表。
• JList(Object[] listdatas):创建一个具有数组指定项目内容的列表。

　　常用方法如下：

• int getFirstVisibleIndex():获取第一个可见单元的索引。
• void setFirstVisibleIndex(int):设置第一个可见单元的索引。
• int getLastVisibleIndex():获取最后一个可见单元的索引。
• void setLastVisibleIndex(int):设置最后一个可见单元的索引。
• int getSelectedIndex():获取第一个已选的索引。
• void setSelectedIndex(int):设置第一个已选的索引。
• Object getSelectedValue():获取第一个已选的对象。
• void setSelectedValue(Object):设置第一个已选的对象。
• Object[] getSelectedValues():获取已选的所有对象。
• Color getSelectionBackground():获取选中项目的背景色。
• void setSelectionBackground():设置选中项目的背景色。
• Color getSelectionForeground():获取选中项目的前景色。
• void setSelectionForeground():设置选中项目的前景色。

6.文本框(JTextField和JPasswordField)

　　JTextField组件用于创建文本框。文本框是用来接收用户的单行文本信息输入的区域。通常文本框用于接收用户信息或其他文本信息的输入。当用户输入文本信息后，如果为JTextField对象添加了事件处理，按回车键后就会触发一定的操作。

　　JPasswordField是JTextField的子类，是一种特殊的文本框，也是用来接收单行文本信息输入的区域，但是会用回显字符串代替输入的文本信息。因此，JPasswordField组件也称为密码文本框。JPasswordField默认的是回显字符是”*”，用户可以自行设置回显字符。

　　JTextField的常见构造方法有如下几种：

• JTextField():创建一个空文本框。
• JTextField(String text):创建一个具有出事文本信息text的文本框。
• JTextField(String text,int columns):创建一个具有出事文本信息text以及制定列数的文本框。

　　JTextField的常用方法：

• void setText(String):设置显示内容。
• String getText():获取显示内容。

　　JPasswordField的构造方法有如下几种：

• JPasswordField():创建一个空的密码文本框。
• JPasswordField(String text):创建一个指定初始文本信息的密码文本框。
• JPasswordField(String text,int columns):创建一个指定文本和列数的密码文本框。
• JPasswordField(int columns):创建一个指定列数的密码文本框。

　　JPasswordField是JTextField的子类，因此JPasswordField也具有与JTextField类似的名称和功能的方法，此外，它还具有与JTextField类似的名称和功能的方法，此外，它还具有自己的独特方法：

• boolean echoCharIsSet():获取设置回显字符的状态。
• void setEchoChar(char):设置回显字符。
• void getEchoChar():获取回显字符。
• char[] getPassword():获取组件的文本。

代码实例如下

package dataExchange;

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

@SuppressWarnings("all")
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;
    
    /**
     * Launch the application.
     */
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    DataExchangeFrame frame = new DataExchangeFrame();
                    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                    frame.setBounds(100, 100, 450, 300);
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the frame.
     */
    public DataExchangeFrame() {
        JMenuBar mbar = new JMenuBar();
        setJMenuBar(mbar);
        JMenu fileMenu = new JMenu("File");
        mbar.add(fileMenu);
        
        JMenuItem connectItem = new JMenuItem("Connect");
        connectItem.addActionListener(new ConnectAction());
        fileMenu.add(connectItem);
        
        JMenuItem exitItem = new JMenuItem("Exit");
        exitItem.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                System.exit(0);
            }
        });
        
        fileMenu.add(exitItem);
        
        textArea = new JTextArea(TEXT_ROWS,TEXT_COLUMNS);
        add(new JScrollPane(textArea),BorderLayout.CENTER);
        pack();
    }
    
    public class ConnectAction implements ActionListener{
        public void actionPerformed(ActionEvent e) {
            if (dialog == null) {
                dialog = new PasswordChooser();
            }
            
            dialog.setUser(new User("yourname", null));
            
            if (dialog.showDialog(DataExchangeFrame.this, "Connect")) {
                User user = dialog.getUser();
                textArea.append("Username = " + user.getName() + ",password = " + (new String(user.getPassword())) + "
");
            }
        }
    }

}

　　运行如下

 

　　点击file,选择connect，效果如下:

上面运行代码如下：

package dataExchange;

import java.awt.BorderLayout;

@SuppressWarnings("serial")
public class PasswordChooser extends JPanel {

    private JTextField username;
    private JPasswordField password;
    private JButton okButton;
    private boolean ok;
    private JDialog dialog;
    
    /**
     * Create the panel.
     */
    public PasswordChooser() {
        setLayout(new BorderLayout());
        JPanel panel = new JPanel();
        panel.setLayout(new GridLayout(2, 2));
        panel.add(new JLabel("Username:"));
        panel.add(username = new JTextField());
        panel.add(new JLabel("Password:"));
        panel.add(password = new JPasswordField());
        add(panel,BorderLayout.CENTER);
        
        okButton = new JButton("Ok");
        okButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                ok = true;
                dialog.setVisible(true);
            }
        });
        
        JButton cancelButton = new JButton("Cancel");
        cancelButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                dialog.setVisible(false);
            }
        });
        
        JPanel buttonPanel = new JPanel();
        buttonPanel.add(okButton);
        buttonPanel.add(cancelButton);
        add(buttonPanel,BorderLayout.SOUTH);
    }
    
    public void setUser(User u){
        username.setText(u.getName());
    }
    
    public User getUser(){
        return new User(username.getText(),password.getPassword());
    }
    
    public boolean showDialog(Component parent,String title){
        ok = false;
        Frame owner = null;
        if (parent instanceof Frame) {
            owner = (Frame)parent;
        }else {
            owner = (Frame)SwingUtilities.getAncestorOfClass(Frame.class, parent);
        }
        
        if (dialog == null || dialog.getOwner() != owner) {
            dialog = new JDialog(owner,true);
            dialog.add(this);
            dialog.getRootPane().setDefaultButton(okButton);
            dialog.pack();
        }
        
        dialog.setTitle(title);
        dialog.setVisible(true);
        return ok;
    }

}   

7.面板(JPanel)

　　JPanel组件定义面板实际上是一种容器组件，用来容纳各种其他轻量级组件。此外，用户还可以用这种面板容器绘制图形。

　　JPanel的构造方法如下：

• JPanel():创建具有双缓冲和流布局(FlowLayout)的面板。
• JPanel(LayoutManager layout):创建具有制定布局管理器的面板。

　　JPanel的 常用方法：

• void add(Component):添加组件。
• void add(Component,int):添加组件至索引指定位置。
• void add(Component,Object):按照指定布局限制添加组件。
• void add(Component,Object,int):按照指定布局管理器限制添加组件到指定位置。
• void remove(Component):移除组件。
• void remove(int):移除指定位置的组件。
• void removeAll():移除所有组件。
• void paintComponent(Graphics):绘制组件。
• void repaint():重新绘制。
• void setPreferredSize(Dimension):设置组件尺寸。
• Dimension getPreferredSize():获取最佳尺寸。

　　代码实例如下:

package com.sy.swing;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Graphics;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class JPanelExample extends JFrame {
    JButton[] buttons;
    JPanel panel1;
    CustomPanel panel2;
    
    public JPanelExample(){
        super("面板实例");
        Container container = getContentPane();
        container.setLayout(new BorderLayout());
        panel1 = new JPanel(new FlowLayout()); //创建一个流布局管理器的面板
        buttons = new JButton[4];
        for (int i = 0; i < buttons.length; i++) {
            buttons[i]=new JButton("按钮"+(i+1));
            panel1.add(buttons[i]); //添加按钮到面板panel1中
        }
        panel2 = new CustomPanel();
        container.add(panel1,BorderLayout.NORTH);
        container.add(panel2,BorderLayout.CENTER);
        pack();
        setVisible(true);
    }
    
    public static void main(String[] args) {
        JPanelExample jpe = new JPanelExample();
        jpe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
    
    class CustomPanel extends JPanel{ //定义内部类CustomPanel
        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            g.drawString("Welcome to Java Shape World", 20, 20);
            g.drawRect(20, 40, 130, 130);
            g.setColor(Color.GREEN);  //设置颜色为绿色
            g.fillRect(20, 40, 130, 130); //绘制矩形
            g.drawOval(160, 40, 100, 100); //绘制椭圆
            g.setColor(Color.ORANGE); //设置颜色为橙色
            g.fillOval(160, 40, 100, 100); //绘制椭圆
        }
        @Override
        public Dimension getPreferredSize() {
            // TODO Auto-generated method stub
            return new Dimension(200,200);
        }
    }

}

　　运行结果如下:

8.表格(JTable)

　　表格是Swing新增加的组件，主要功能是把数据以二维表格的形式显示出来。使用表格，一句M-V-C思想，最好先生成一个MyTableModel类型的对象来表示数据，这个类是从AbstractTableModel累中集成来的，其中有几个方法移动要重写，例如geColumnCount、getRowCount、getColumnName和getValueAt。因为JTable会从这个对象中自动获取表格显示必须的数据，AbstractTableModel类的对象负责表格大小的确定(行、列)、内容的填写、赋值、表格单元更新的检测等一切与表哥内容有关的属性及其操作。JTable类生成的对象以该TableModel为参数，并负责将TableModel对象中的数据以表格的形式显示出来。

package JFrameTest;

/*
 * TableRenderDemo.java requires no other files.
 */

import javax.swing.DefaultCellEditor;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;

import java.awt.Component;
import java.awt.Dimension;
import java.awt.GridLayout;

/** 
 * TableRenderDemo is just like TableDemo, except that it
 * explicitly initializes column sizes and it uses a combo box
 * as an editor for the Sport column.
 */
@SuppressWarnings("all")
public class TableRenderDemo extends JPanel {
    private boolean DEBUG = false;

    public TableRenderDemo() {
        super(new GridLayout(1,0));

        JTable table = new JTable(new MyTableModel());
        table.setPreferredScrollableViewportSize(new Dimension(500, 70));
        table.setFillsViewportHeight(true);

        //Create the scroll pane and add the table to it.
        JScrollPane scrollPane = new JScrollPane(table);

        //Set up column sizes.
        initColumnSizes(table);

        //Fiddle with the Sport column's cell editors/renderers.
        setUpSportColumn(table, table.getColumnModel().getColumn(2));

        //Add the scroll pane to this panel.
        add(scrollPane);
    }

    /*
     * This method picks good column sizes.
     * If all column heads are wider than the column's cells'
     * contents, then you can just use column.sizeWidthToFit().
     */
    private void initColumnSizes(JTable table) {
        MyTableModel model = (MyTableModel)table.getModel();
        TableColumn column = null;
        Component comp = null;
        int headerWidth = 0;
        int cellWidth = 0;
        Object[] longValues = model.longValues;
        TableCellRenderer headerRenderer =
            table.getTableHeader().getDefaultRenderer();

        for (int i = 0; i < 5; i++) {
            column = table.getColumnModel().getColumn(i);

            comp = headerRenderer.getTableCellRendererComponent(
                                 null, column.getHeaderValue(),
                                 false, false, 0, 0);
            headerWidth = comp.getPreferredSize().width;

            comp = table.getDefaultRenderer(model.getColumnClass(i)).
                             getTableCellRendererComponent(
                                 table, longValues[i],
                                 false, false, 0, i);
            cellWidth = comp.getPreferredSize().width;

            if (DEBUG) {
                System.out.println("Initializing width of column "
                                   + i + ". "
                                   + "headerWidth = " + headerWidth
                                   + "; cellWidth = " + cellWidth);
            }

            column.setPreferredWidth(Math.max(headerWidth, cellWidth));
        }
    }

    public void setUpSportColumn(JTable table,
                                 TableColumn sportColumn) {
        //Set up the editor for the sport cells.
        JComboBox comboBox = new JComboBox();
        comboBox.addItem("Snowboarding");
        comboBox.addItem("Rowing");
        comboBox.addItem("Knitting");
        comboBox.addItem("Speed reading");
        comboBox.addItem("Pool");
        comboBox.addItem("None of the above");
        sportColumn.setCellEditor(new DefaultCellEditor(comboBox));

        //Set up tool tips for the sport cells.
        DefaultTableCellRenderer renderer =
                new DefaultTableCellRenderer();
        renderer.setToolTipText("Click for combo box");
        sportColumn.setCellRenderer(renderer);
    }

    class MyTableModel extends AbstractTableModel {
        private String[] columnNames = {"First Name",
                                        "Last Name",
                                        "Sport",
                                        "# of Years",
                                        "Vegetarian"};
        private Object[][] data = {
        {"Kathy", "Smith",
         "Snowboarding", new Integer(5), new Boolean(false)},
        {"John", "Doe",
         "Rowing", new Integer(3), new Boolean(true)},
        {"Sue", "Black",
         "Knitting", new Integer(2), new Boolean(false)},
        {"Jane", "White",
         "Speed reading", new Integer(20), new Boolean(true)},
        {"Joe", "Brown",
         "Pool", new Integer(10), new Boolean(false)}
        };

        public final Object[] longValues = {"Jane", "Kathy",
                                            "None of the above",
                                            new Integer(20), Boolean.TRUE};

        public int getColumnCount() {
            return columnNames.length;
        }

        public int getRowCount() {
            return data.length;
        }

        public String getColumnName(int col) {
            return columnNames[col];
        }

        public Object getValueAt(int row, int col) {
            return data[row][col];
        }

        /*
         * JTable uses this method to determine the default renderer/
         * editor for each cell.  If we didn't implement this method,
         * then the last column would contain text ("true"/"false"),
         * rather than a check box.
         */
        public Class getColumnClass(int c) {
            return getValueAt(0, c).getClass();
        }

        /*
         * Don't need to implement this method unless your table's
         * editable.
         */
        public boolean isCellEditable(int row, int col) {
            //Note that the data/cell address is constant,
            //no matter where the cell appears onscreen.
            if (col < 2) {
                return false;
            } else {
                return true;
            }
        }

        /*
         * Don't need to implement this method unless your table's
         * data can change.
         */
        public void setValueAt(Object value, int row, int col) {
            if (DEBUG) {
                System.out.println("Setting value at " + row + "," + col
                                   + " to " + value
                                   + " (an instance of "
                                   + value.getClass() + ")");
            }

            data[row][col] = value;
            fireTableCellUpdated(row, col);

            if (DEBUG) {
                System.out.println("New value of data:");
                printDebugData();
            }
        }

        private void printDebugData() {
            int numRows = getRowCount();
            int numCols = getColumnCount();

            for (int i=0; i < numRows; i++) {
                System.out.print("    row " + i + ":");
                for (int j=0; j < numCols; j++) {
                    System.out.print("  " + data[i][j]);
                }
                System.out.println();
            }
            System.out.println("--------------------------");
        }
    }

    /**
     * Create the GUI and show it.  For thread safety,
     * this method should be invoked from the
     * event-dispatching thread.
     */
    private static void createAndShowGUI() {
        //Create and set up the window.
        JFrame frame = new JFrame("TableRenderDemo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        //Create and set up the content pane.
        TableRenderDemo newContentPane = new TableRenderDemo();
        newContentPane.setOpaque(true); //content panes must be opaque
        frame.setContentPane(newContentPane);

        //Display the window.
        frame.pack();
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        //Schedule a job for the event-dispatching thread:
        //creating and showing this application's GUI.
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGUI();
            }
        });
    }
}

代码运行结果如下:

参考:http://www.cnblogs.com/pzy4447/p/4925125.html

9.框架(JFrame)

　　框架SwingGUI应用程序的主窗口，窗口包括边界、标题、关闭按钮等。

　　JFrame类是java.awt包中Frame类的子类，其子类创建的对象是窗体，对象（窗体）是重量容器。不能把组件直接添加到Swing窗体中，其含有内容面板容器，应该把组件添加到内容面板中；不能为Swing窗体设置布局，而应当Swing窗体的内容面板设置布局。

　　Swing窗体通过getContentPane()方法获得JFrame的内容面板，再对其加入组件；

　　JFrame frame = new JFrame();

　　Container ct = frame.getContentPane(); //获取内容面板容器

　　Ct.add(childComponent);  //降内容面板容器加入组件

　　框架(JFrame)常用的方法和事件：

• frame.setVisibel(true):显示框架对象代表的框架窗口。
• frame.setSize(200,100)或frame.pack():设置框架的初始显示大小。
• frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE):当用户单机框架的关闭按钮则退出程序，或者添加WindowListener监听器实现关闭按钮退出程序。

　　代码实例:

package jFrameDemo;

import java.awt.EventQueue;

import javax.swing.JFrame;

public class SimpleFrameTest {
    public static void main(String[] args) {
        /*所有的Swing组件必须由事件分派线程(event dispatch thread)进行配置，
         *线程将鼠标点击和按钮控制转移到用户接口组件。下面的代码片段是事件分派线程中的执行代码。
         *现在，只需要将其看成是启动一个Swing程序的神器代码。
         */
        EventQueue.invokeLater(new Runnable(){
            @Override
            public void run() {
                // TODO Auto-generated method stub
                SimpleFrame frame = new SimpleFrame();
                frame.setTitle("JFrame测试");
                //定义一个用户关闭这个框架时的响应动作。
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                //为了框架显示，main方法需要需要调用框架的setVisible方法
                frame.setVisible(true);
            }
        });
    }
}

@SuppressWarnings("all")
class SimpleFrame extends JFrame{
    private static final int DEFAULT_WIDTH = 400;
    private static final int DEFAULT_HEIGHT = 200;
    
    public SimpleFrame(){
        setSize(DEFAULT_WIDTH,DEFAULT_HEIGHT);
    }
}

　　代码实例运行结果如下:

 文章内容参考:《Java游戏编程原理与实践教程》