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())) + "\n");
            }
        }
    }

}

　　運行如下

 

　　點擊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游戲編程原理與實踐教程》