Swing开发时必定会碰到的11个问题及解决方案

1.JTable ，JTable如何在内容里面存放组件（下拉框，图片）和修改数据。

2.系统托盘TrayIcon的使用

3.JPopupMenu的使用

4.JTree的使用及替换样式

5.BorderLayout的灵活使用

6.进度条的同步读取和显示

7.滚动条下拉时候滚动条自动衍生

8.监听器、适配器的使用

9.如何直接把文件、文件夹拖拉到组件

10.剪切板的使用

11.JFM拓展包

*********************

JTable放图片

package roy;   
import java.awt.Color;  
import java.awt.Component;  
import java.awt.Dimension;  
 
import javax.swing.Icon;  
import javax.swing.ImageIcon;  
import javax.swing.JFrame;  
import javax.swing.JScrollPane;  
import javax.swing.JTable;  
import javax.swing.border.LineBorder;  
import javax.swing.event.TableModelEvent;  
import javax.swing.table.AbstractTableModel;  
import javax.swing.table.DefaultTableCellRenderer;  
import javax.swing.table.DefaultTableModel;  
import javax.swing.table.TableColumnModel;  
 
//  
public class MyTable{  
    JTable table=new JTable();  
    public MyTable(){  
         JFrame frame=new JFrame("测试jtable放图片");  
         frame.setLayout(null);  
 
         table=this.getTable();  
 
         JScrollPane src=new JScrollPane(table);  
         src.setBounds(0, 0, 400, 200);  
         frame.setSize(new Dimension(400,200));  
         frame.add(src);  
         frame.setVisible(true);  
    }  
    public JTable getTable(){  
        MyTableModel dm = new MyTableModel();  
       
        JTable table = new JTable();  
        table.setModel(dm);//设置每个单元格的格式  
        table.setDefaultRenderer(Icon.class, new ImageRenderer());  
 
     return table;  
    }  
    public static void main(String args[]){  
      new MyTable();  
     }  
    }  
    class MyTableModel extends AbstractTableModel{  
     private String[] columnNames = {"First Name",  
                "Favorite Color",  
               };  
            private Object[][] data = {  
            {"Marry", new ImageIcon("1.gif")  
                },  
               {"Joe",new ImageIcon("1.jpg")  
                },  
               {"Kims", new ImageIcon("1.png")  
               }  
           };  
    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];  
    }  
   
    public Class getColumnClass(int c) {  
     if(c==1){  
      System.out.println("---"+getValueAt(0, c).getClass());  
     }  
     return c == 1 ? Icon.class : Object.class;  
 
    }  
 
    public boolean isCellEditable(int row, int col) {   
        if (col < 1) {  
            return false;  
        } else {  
            return true;  
        }  
    }  
 
    public void setValueAt(Object value, int row, int col) {  
         
 
        data[row][col] = value;  
        fireTableCellUpdated(row, col);  
 
        
    }   
}//定义  
class ImageRenderer extends DefaultTableCellRenderer {  
   
     public Component getTableCellRendererComponent(JTable table, Object value,  
       boolean isSelected, boolean hasFocus, int row, int column) {  
      setIcon(null);    
      setBorder(null);   
      System.out.println("++"+(value instanceof Icon));  
      super.getTableCellRendererComponent(table, value, isSelected,  hasFocus,  row,  column);  
      if (value instanceof Icon) {  
 
       this.setIcon((Icon) value);  
        
      if (isSelected)  
       setBorder(new LineBorder(Color.red));  
      }else if (value instanceof String)  
       setText((String) value);  
      else 
       setText("");  
 
      return this;  
     }  
 
}  
//设置图片和边框  
class TextAndIcon {  
 
     Icon icon;  
     TextAndIcon(String text, ImageIcon icon) {  
      this.text = text;  
      this.icon = icon;  
     }  
 
     String text;  
 
     public String getText() {  
      return text;  
     }  
 
     public void setText(String text) {  
      this.text = text;  
     }  
 
     public Icon getIcon() {  
      return icon;  
     }  
 
     public void setIcon(ImageIcon icon) {  
      this.icon = icon;  
     }  
 
} 

系统托盘和PopupMenu的使用

package roy;  
 
import java.awt.AWTException;  
import java.awt.MenuItem;  
import java.awt.PopupMenu;  
import java.awt.SystemTray;  
import java.awt.TrayIcon;  
import java.awt.event.ActionEvent;  
import java.awt.event.ActionListener;  
import java.awt.event.WindowAdapter;  
import java.awt.event.WindowEvent;  
import javax.swing.ImageIcon;  
import javax.swing.JFrame;  
 
/**  
 *  Author:Roy  
 */ 
public class TestTray extends JFrame implements Runnable {  
 
    private SystemTray sysTray;// 当前操作系统的托盘对象  
    private TrayIcon trayIcon;// 当前对象的托盘  
    ImageIcon icon = null;  
 
    public TestTray()  
    {  
        this.createTrayIcon();// 创建托盘对象  
        init();  
    }  
 
    /**  
     * 初始化窗体的方法  
     */ 
     public void init()  
    {  
        this.setTitle("闪动托盘");  
        this.setSize(400, 400);  
        this.setDefaultCloseOperation(this.EXIT_ON_CLOSE);  
        this.setLocationRelativeTo(null);  
        // 添加窗口事件,将托盘添加到操作系统的托盘  
        this.addWindowListener(new WindowAdapter() {  
   
            public void windowIconified(WindowEvent e)  
            {  
                addTrayIcon();  
            }  
        });  
 
        this.setVisible(true);  
    }  
 
    /**  
     * 添加托盘的方法  
     */ 
    public void addTrayIcon()  
    {  
        try 
        {  
            sysTray.add(trayIcon);// 将托盘添加到操作系统的托盘  
            setVisible(false);// 使得当前的窗口隐藏  
            new Thread(this).start();  
        }  
        catch (AWTException e1)  
        {  
            e1.printStackTrace();  
        }  
    }  
 
    /**  
     * 创建系统托盘的对象 步骤: 1,获得当前操作系统的托盘对象 2,创建弹出菜单popupMenu 3,创建托盘图标icon  
     * 4,创建系统的托盘对象trayIcon  
     */ 
    public void createTrayIcon()  
    {  
        sysTray = SystemTray.getSystemTray();// 获得当前操作系统的托盘对象  
        icon = new ImageIcon("1.gif");// 托盘图标  
        PopupMenu popupMenu = new PopupMenu();// 弹出菜单  
        MenuItem mi = new MenuItem("弹出");  
        MenuItem exit = new MenuItem("关闭");  
        popupMenu.add(mi);  
        popupMenu.add(exit);  
        // 为弹出菜单项添加事件  
        mi.addActionListener(new ActionListener() {  
 
            public void actionPerformed(ActionEvent e)  
            {  
                setVisible(true);  
                sysTray.remove(trayIcon);  
            }  
        });  
        exit.addActionListener(new ActionListener() {  
 
            public void actionPerformed(ActionEvent e)  
            {  
                System.exit(0);  
            }  
        });  
        trayIcon = new TrayIcon(icon.getImage(), "闪动托盘", popupMenu);  
    }  
   
    public static void main(String[] args)  
    {  
        TestTray testTray = new TestTray();  
    }  
 
    /*  
     * 线程控制闪动、替换图片  
     *   
     */ 
    public void run()  
    {  
        while (true)  
        {  
            this.trayIcon.setImage(new ImageIcon("2.jpg").getImage());  
            try 
            {  
                Thread.sleep(300);  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
            this.trayIcon.setImage(icon.getImage());  
            try 
            {  
                Thread.sleep(300);  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
            
        }  
    }  
}  

实现拖拉上传效果的界面

package roy;  
 
import java.awt.BorderLayout;  
import java.awt.datatransfer.DataFlavor;  
import java.awt.dnd.DnDConstants;  
import java.awt.dnd.DropTarget;  
import java.awt.dnd.DropTargetDragEvent;  
import java.awt.dnd.DropTargetDropEvent;  
import java.awt.dnd.DropTargetEvent;  
import java.awt.dnd.DropTargetListener;  
import java.io.File;  
import java.util.Iterator;  
import java.util.List;  
import java.util.Vector;  
import java.util.logging.Logger;  
 
import javax.swing.JFrame;  
import javax.swing.JOptionPane;  
import javax.swing.JPanel;  
import javax.swing.JProgressBar;  
import javax.swing.JScrollPane;  
import javax.swing.JTable;  
import javax.swing.table.JTableHeader;  
   
/**  
 *   
 * @author Roy  
 * desc: 上传文件面板  
 */ 
public class UploadPane extends JPanel implements DropTargetListener{  
      
    private String[] columns={"文件名","路径","上传人"};//表格标题  
    private Vector data=new Vector();//表格数据  
    private JTable table;//上传表格  
    private MyTableModel model;//表格数据模型号  
    private Vector files=new Vector();//保存上传的文件路径  
    private String uploadName;//上传人的姓名  
    private JProgressBar jpb;//进度条  
    private UIFactory uiFactory=UIFactory.getInstance();//界面工厂   
      
    public UploadPane(String uploadName){  
        this.uploadName=uploadName;  
        //创建一个拖放目标，本身  
        new DropTarget(this,DnDConstants.ACTION_COPY_OR_MOVE,this);  
          
        jpb=uiFactory.createJProgressBar(0,100,0,true,true);  
        this.setLayout(new BorderLayout());  
        model=new MyTableModel(columns,data);  
        table=uiFactory.createJTable(model);  
        JTableHeader header=table.getTableHeader();  
        header.setReorderingAllowed(false);  
        JScrollPane sc=uiFactory.createJScrollPane(table);  
        this.add(sc,BorderLayout.CENTER);  
        this.add(jpb,BorderLayout.SOUTH);  
    }  
      
    public void drop(DropTargetDropEvent e) {  
        try{  
            if(e.isDataFlavorSupported(DataFlavor.javaFileListFlavor)){  
                e.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);//接受copy or move   
                List list=(List)(e.getTransferable().getTransferData(DataFlavor.javaFileListFlavor));  
                Iterator it=list.iterator();  
                while(it.hasNext()){  
                    File f=(File)it.next();  
                    if(f.isFile()){  
                        add(f);  
                    }else{  
                        JOptionPane.showMessageDialog(this,"上传文件不能为文件夹");  
                    }  
                }  
                e.dropComplete(true);  
                this.updateUI();  
            }else{  
                e.rejectDrop();  
            }  
        }catch(Exception ex){   
            ex.printStackTrace();  
        }  
    }  
      
    //提供一个添加数据的方法  
    public void add(File f){  
        jpb.setValue(0);  
        Vector row=new Vector();  
        row.add(f.getName());  
        row.add(f.getPath());  
        row.add(uploadName);  
        data.add(row);  
        table.updateUI();//向表格添加数据  
        files.add(f);  
    }  
    //提共一个移除掉的方法  
    public void remove(){  
        data.clear();  
        files.clear();  
        table.updateUI();  
    }  
      
    //getters and setters ....  
 
    public String[] getColumns() {  
        return columns;  
    }  
    public void setColumns(String[] columns) {  
        this.columns = columns;  
    }  
    public Vector getData() {  
        return data;  
    }  
    public void setData(Vector data) {  
        this.data = data;  
    }  
    public JTable getTable() {  
        return table;  
    }  
    public void setTable(JTable table) {  
        this.table = table;  
    }  
    public MyTableModel getModel() {  
        return model;  
    }  
    public void setModel(MyTableModel model) {  
        this.model = model;  
    }  
 
 
    public JProgressBar getJpb() {  
        return jpb;  
    }  
 
 
    public void setJpb(JProgressBar jpb) {  
        this.jpb = jpb;  
    }  
 
      
    public String getUploadName() {  
        return uploadName;  
    }  
 
    public void setUploadName(String uploadName) {  
        this.uploadName = uploadName;  
    }  
 
    public Vector getFiles() {  
        return files;  
    }  
 
    public void setFiles(Vector files) {  
        this.files = files;  
    }  
 
    public void dragEnter(DropTargetDragEvent e) {}  
    public void dragExit(DropTargetEvent e) {}  
    public void dragOver(DropTargetDragEvent e) {}  
    public void dropActionChanged(DropTargetDragEvent e) {}  
      
      
    public static void main(String args[]){  
        JFrame f=new JFrame();  
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
        UploadPane p=new UploadPane("Joe");  
        f.add(p);  
        f.pack();  
        f.setVisible(true);  
    }  
}  

最后再给大家一个UI的工厂来解决其他的问题，是平时常用的组件的创建（自动注册按钮、快捷键等），应有尽有。使用了单例模式。

package roy;  
 
import java.awt.BorderLayout;  
import java.awt.CardLayout;  
import java.awt.Color;  
import java.awt.Container;  
import java.awt.Dimension;  
import java.awt.FlowLayout;  
import java.awt.Font;  
import java.awt.GridLayout;  
import java.awt.MenuItem;  
import java.awt.event.ActionListener;  
import java.awt.event.ItemListener;  
import java.awt.event.WindowListener;  
import java.io.FileNotFoundException;  
import java.util.Vector;  
 
import javax.swing.Icon;  
import javax.swing.ImageIcon;  
import javax.swing.JButton;  
import javax.swing.JCheckBox;  
import javax.swing.JComboBox;  
import javax.swing.JFrame;  
import javax.swing.JLabel;  
import javax.swing.JList;  
import javax.swing.JMenuItem;  
import javax.swing.JPanel;  
import javax.swing.JPasswordField;  
import javax.swing.JProgressBar;  
import javax.swing.JRadioButton;  
import javax.swing.JScrollPane;  
import javax.swing.JSplitPane;  
import javax.swing.JTabbedPane;  
import javax.swing.JTable;  
import javax.swing.JTextArea;  
import javax.swing.JTextField;  
import javax.swing.JTextPane;  
import javax.swing.JToggleButton;  
import javax.swing.JToolBar;  
import javax.swing.KeyStroke;  
import javax.swing.event.ChangeListener;  
import javax.swing.event.ListSelectionListener;  
import javax.swing.table.AbstractTableModel;  
   
 
public class UIFactory {  
 
    private static UIFactory instance;//当前工厂的一个实例  
    //私有的构造器  
    private UIFactory(){  
          
    }  
    //获得当前工厂的实例  
    public static UIFactory getInstance(){  
        if(instance==null){  
            synchronized("key1"){  
                instance=new UIFactory();  
            }  
        }  
        return instance;  
    }  
       
    //产生一个标签  
    public JLabel createJLabel(String text){  
        JLabel l=new JLabel(text);  
        return l;  
    }  
    //产生一个带图标的标签  
    public JLabel createJLabel(String text,Icon icon){  
        JLabel l=new JLabel(text);  
        l.setIcon(icon);  
        return l;  
    }  
      
      
    //专门产生按钮，而且添加快捷键      文本显示  命令  按键   辅助键  触发范围  监听器  是否显焦  
    public JButton createJButton(String text,int mn,String command,ImageIcon icon,int key_keyEvent,int input_inputEvent,int when_invoke_jComponent,ActionListener al,boolean isFocus){  
        JButton button=new JButton(text,icon);  
        //这里默认会是alt+'mn'  
        button.setMnemonic(mn);//设置辅助键  
        button.setActionCommand(command);//设置动作  
        button.addActionListener(al);  
        KeyStroke stroke=KeyStroke.getKeyStroke(key_keyEvent,input_inputEvent,isFocus);  
        button.registerKeyboardAction(al,command,stroke,when_invoke_jComponent);  
        button.setFocusable(isFocus);  
        return button;  
    }  
    //专门产生按钮                     文本显示  命令  监听器  是否显焦  
    public JButton createJButton(String text,String command,ImageIcon icon,ActionListener al,boolean isFocus){  
        JButton button=new JButton(text,icon);  
        button.setActionCommand(command);//设置动作  
        button.addActionListener(al);//添加事件监听  
        button.setFocusable(isFocus);  
        return button;  
    }  
    //专门产生按钮，而且添加快捷键 文本显示  命令  按键   辅助键  触发范围  监听器  是否显焦  
    public JButton createJButton(String text,int mn,String command,ImageIcon icon,int width,int height,int key_keyEvent,int input_inputEvent,int when_invoke_jComponent,ActionListener al,boolean isFocus){  
 
        JButton button=new JButton(text,icon);//指定按钮的  文本和图片  
        //这里默认会是alt+'mn'  a    
        button.setMnemonic(mn);//设置辅助键  
        button.setActionCommand(command);//设置动作  【添加】  
 
 
        button.setPreferredSize(new Dimension(width,height));//指定按钮的大小  
        button.addActionListener(al);  
        KeyStroke stroke=KeyStroke.getKeyStroke(key_keyEvent,input_inputEvent,isFocus);  
        button.registerKeyboardAction(al,command,stroke,when_invoke_jComponent);  
        button.setFocusable(isFocus);  
        return button;  
    }  
    //专门产生按钮                     文本显示  命令  监听器  是否显焦  
    public JButton createJButton(String text,String command,ImageIcon icon,int width,int height,ActionListener al,boolean isFocus){  
        JButton button=new JButton(text,icon);  
        button.setActionCommand(command);//设置动作  
        button.setPreferredSize(new Dimension(width,height));  
        button.addActionListener(al);//添加事件监听  
        button.setFocusable(isFocus);  
        return button;  
    }  
    //生成文本框   默认文本  文本框大小长 是否可编辑  
    public JTextField createJTextField(String text,int cols,boolean isEditable){  
        JTextField field=new JTextField(text,cols);  
        field.setEditable(isEditable);  
        return field;  
    }  
    //生成文本框   默认文本  文本框大小长 是否可编辑  设置字体  
    public JTextField createJTextField(String text,int cols,boolean isEditable,Font f){  
        JTextField field=new JTextField(text,cols);  
        field.setEditable(isEditable);  
        field.setFont(f);  
        return field;  
    }  
    //生成文本域    默认文本  列数  行数  是否可编辑  
    public JTextArea createJTextArea(String text,int cols,int rows,boolean isEditable,boolean lineWrap,boolean wrapStyleWord){  
        JTextArea area=new JTextArea(text,cols,rows);  
        area.setEditable(isEditable);  
        area.setLineWrap(lineWrap);  
        area.setWrapStyleWord(wrapStyleWord);  
        return area;  
    }  
    //生成文本域    默认文本  列数  行数  是否可编辑  设置字体   
    public JTextArea createJTextArea(String text,int cols,int rows,boolean isEditable,boolean lineWrap,boolean wrapStyleWord,Font f){  
        JTextArea area=new JTextArea(text,cols,rows);  
        area.setEditable(isEditable);  
        area.setFont(f);  
        area.setLineWrap(lineWrap);  
        area.setWrapStyleWord(wrapStyleWord);  
        return area;  
    }  
    //生成文本域    默认文本  列数  行数  是否可编辑  设置字体  背景颜色  前景颜色  
    public JTextArea createJTextArea(String text,int cols,int rows,boolean isEditable,Font f,boolean lineWrap,boolean wrapStyleWord,Color background, Color foreground){  
        JTextArea area=new JTextArea(text,cols,rows);  
        area.setEditable(isEditable);  
        area.setFont(f);  
        area.setLineWrap(lineWrap);  
        area.setWrapStyleWord(wrapStyleWord);  
        area.setBackground(background);  
        area.setForeground(foreground);  
        return area;  
    }  
    //产生一个滚动面板  
    public JScrollPane createJScrollPane(Container c){  
        JScrollPane sc=new JScrollPane(c);  
        return sc;  
    }  
    public static void main(String args[]){  
          
        UIFactory factory = UIFactory.getInstance();  
 
        //JScrollPane pan = factory.createJScrollPane(new JFrame(),JScrollPane.horizontalScrollBar,JScrollPane.verticalScrollBarPolicy);  
          
    }  
    //产生一个指定垂直和水平滚动策略的滚动面板  水平滚动策略  垂直滚动策略  
    public JScrollPane createJScrollPane(Container c,int horizontal_policy,int vertical_policy){  
        JScrollPane sc=new JScrollPane();  
        sc.setHorizontalScrollBarPolicy(horizontal_policy);  
        sc.setVerticalScrollBarPolicy(vertical_policy);  
        return sc;  
    }  
    //设置框架属性                    传入的框架  关闭策略  x,y,width,height   
    public void setJFrameAttributes(JFrame f,String title,int close_policy,int x,int y,int width,int height,boolean isResizable){  
        f.setTitle(title);  
        f.setDefaultCloseOperation(close_policy);  
        f.setLocation(x,y);  
        f.setSize(width,height);  
        f.setResizable(isResizable);  
    }  
      
    //设置框架属性                    传入的框架  关闭策略  x,y,width,height   
    public void setJFrameAttributes(JFrame f,String title,int close_policy,int x,int y,int width,int height,boolean isResizable,WindowListener wl){  
        f.setTitle(title);  
        f.setDefaultCloseOperation(close_policy);  
        f.setLocation(x,y);  
        f.setSize(width,height);  
        f.setResizable(isResizable);  
        f.addWindowListener(wl);  
    }  
    //产生一条列表组件   条目宽度  
    public JList createJList(int cell_width){  
        JList list=new JList();  
        list.setFixedCellWidth(cell_width);  
        return list;  
    }  
    //产生一条列表组件   条目宽度  列表选择监听器  
    public JList createJList(int cell_width,ListSelectionListener lsl){  
        JList list=new JList();  
        list.setFixedCellWidth(cell_width);  
        list.addListSelectionListener(lsl);  
        return list;  
    }  
    //产生一条列表组件   条目宽度  条目间距  源数据  
    public JList createJList(int cell_width,int cell_height,Vector<Object> v,ListSelectionListener lsl){  
        JList list=new JList(v);  
        list.setFixedCellWidth(cell_width);  
        list.setFixedCellHeight(cell_height);  
        list.addListSelectionListener(lsl);  
        return list;  
    }  
    //产生一条列表组件   条目宽度  条目间距  源数据  
    public JList createJList(int cell_width,int cell_height,Object[] data,ListSelectionListener lsl){  
        JList list=new JList(data);  
        list.setFixedCellWidth(cell_width);  
        list.setFixedCellHeight(cell_height);  
        list.addListSelectionListener(lsl);  
        return list;  
    }  
    //获得一个具有BorderLayout布局的面板  
    public JPanel createBorderJPanel(){  
        JPanel p=new JPanel();  
        p.setLayout(new BorderLayout());  
        return p;  
    }  
    //获得一个具有BorderLayout布局的面板  
    public JPanel createBorderJPanel(int row_distance,int col_distance){  
        JPanel p=new JPanel();  
        p.setLayout(new BorderLayout(row_distance,col_distance));  
        return p;  
    }  
    //获得一个具有GridLayout布局的面板  指定行数，列数，行距，列距  
    public JPanel createGridJPanel(int rows,int cols,int col_distance,int row_distance){  
        JPanel p=new JPanel();  
        p.setLayout(new GridLayout(rows,cols,col_distance,row_distance));  
        return p;  
    }  
    //获得一个具有GridLayout布局的面板  
    public JPanel createGridJPanel(int rows,int cols){  
        JPanel p=new JPanel();  
        p.setLayout(new GridLayout(rows,cols));  
        return p;  
    }  
    //获得一个具有卡片布局的面板  
    public JPanel createCardJPanel(CardLayout card){  
        JPanel p=new JPanel();  
        p.setLayout(card);  
        return p;  
    }  
    //获得一个具有绝对布局的的面板  
    public JPanel createAbsoluteJPanel(){  
        JPanel p=new JPanel();  
        p.setLayout(null);  
        return p;  
    }  
    //获得一个具有FlowLayout流式布局的面板  
    public JPanel createFlowJPanel(){  
        JPanel p=new JPanel();  
        p.setLayout(new FlowLayout());  
        return p;  
    }  
    //获得一个具有FlowLayout流式布局的面板  
    public JPanel createFlowJPanel(int policy,int col_distance,int row_distance){  
        JPanel p=new JPanel();  
        p.setLayout(new FlowLayout( policy, col_distance, row_distance));  
        return p;  
    }  
    //获得一个具有FlowLayout流式布局的面板  指定左右对齐方式  
    public JPanel createFlowJPanel(int leftOrRight_policy){  
        JPanel p=new JPanel();  
        p.setLayout(new FlowLayout(leftOrRight_policy));  
        return p;  
    }  
    //获得一个带有监听器的菜单选项  
    public JMenuItem createJMenuItem(String text,String command,ActionListener al){  
        JMenuItem item=new JMenuItem(text);  
        item.addActionListener(al);  
        item.setActionCommand(command);  
        return item;  
    }  
    //获得一个JRadioButton按钮  
    public JRadioButton createJRadioButton(){  
        JRadioButton jrb=new JRadioButton();  
        return jrb;  
    }  
    //获得一个带ItemListener监听器的JRadioButton按钮  
    public JRadioButton createJRadioButton(ItemListener il){  
        JRadioButton jrb=new JRadioButton();  
        jrb.addItemListener(il);  
        return jrb;  
    }  
    //获得一个复选框  
    public JCheckBox createJCheckBox(){  
        JCheckBox box=new JCheckBox();  
        return box;  
    }  
    //获得一个下拉列表框  
    public JComboBox createJComboBox(String[] data){  
        JComboBox box=new JComboBox(data);  
        return box;  
    }  
    //获得一个下拉列表框  
    public JComboBox createJComboBox(Vector data){  
        JComboBox box=new JComboBox(data);  
        return box;  
    }  
    //获得一个下拉列表框  
    public JComboBox createJComboBox(String[] data,int width,int height){  
        JComboBox box=new JComboBox(data);  
        box.setPreferredSize(new Dimension(width,height));  
        return box;  
    }  
    //获得一个下拉列表框  
    public JComboBox createJComboBox(Vector data,int width,int height){  
        JComboBox box=new JComboBox(data);  
        box.setPreferredSize(new Dimension(width,height));  
        return box;  
    }  
    //获得一个带ItemListener的下拉列表框  
    public JComboBox createJComboBox(Vector data,ItemListener il){  
        JComboBox box=new JComboBox(data);  
        box.addItemListener(il);  
        return box;  
    }  
    //获得一个带ItemListener的下拉列表框  
    public JComboBox createJComboBox(String[] data,ItemListener il){  
        JComboBox box=new JComboBox(data);  
        box.addItemListener(il);  
        return box;  
    }  
    //获得一个带ItemListener的下拉列表框  
    public JComboBox createJComboBox(Vector data,int width,int height,ItemListener il){  
        JComboBox box=new JComboBox(data);  
        box.setMaximumSize(new Dimension(width,height));  
        box.setMinimumSize(new Dimension(width,height));  
        box.addItemListener(il);  
        return box;  
    }  
    //获得一个带ItemListener的下拉列表框  
    public JComboBox createJComboBox(String[] data,int width,int height,ItemListener il){  
        JComboBox box=new JComboBox(data);  
        box.setMaximumSize(new Dimension(width,height));  
        box.setMinimumSize(new Dimension(width,height));  
        box.addItemListener(il);  
        return box;  
    }  
    //产生一个选项卡面板  
    public JTabbedPane createJTabbedPane(){  
        JTabbedPane tab=new JTabbedPane();  
        return tab;  
    }  
    //产生一个指定位置的选项卡面板  
    public JTabbedPane createJTabbedPane(int pos){  
        JTabbedPane tab=new JTabbedPane(pos);  
        return tab;  
    }  
    //产生一个带ChangeListener的选项卡面板  
    public JTabbedPane createJTabbedPane(ChangeListener cl){  
        JTabbedPane tab=new JTabbedPane();  
        tab.addChangeListener(cl);  
        return tab;  
    }  
    //产生一个是否可以浮动的工具栏  
    public JToolBar createJToolBar(boolean isFloatable){  
        JToolBar bar =new JToolBar();  
        bar.setFloatable(isFloatable);  
        return bar;  
    }  
    //产生一个JTextPane面板  
    public JTextPane createJTextPane(boolean isEditable){  
        JTextPane p=new JTextPane();  
        p.setEditable(isEditable);  
        return p;  
    }  
    //产生一个JTextPane面板  
    public JTextPane createJTextPane(boolean isEditable,Color background,Color foreground){  
        JTextPane p=new JTextPane();  
        p.setEditable(isEditable);  
        p.setBackground(background);  
        p.setForeground(foreground);  
        return p;  
    }  
    //产生一个进度条  
    public JProgressBar createJProgressBar(int min,int max,int value,boolean stringPainted,boolean borderPainted){  
        JProgressBar bar=new JProgressBar();  
        bar.setMinimum(min);  
        bar.setMaximum(max);  
        bar.setBorderPainted(borderPainted);  
        bar.setStringPainted(stringPainted);  
        bar.setValue(value);  
        return bar;  
    }  
    //产生一个指定大小的进度条  
    public JProgressBar createJProgressBar(int min,int max,int value,boolean stringPainted,boolean borderPainted,Dimension d){  
        JProgressBar bar=new JProgressBar();  
        bar.setMinimum(min);  
        bar.setMaximum(max);  
        bar.setBorderPainted(borderPainted);  
        bar.setStringPainted(stringPainted);  
        bar.setValue(value);  
        bar.setPreferredSize(d);  
        return bar;  
    }  
    //产生一个分隔面板                       分隔面板1  分隔面板2   水平或垂直分割  分割条位置   分割条宽度  是否可收起  
    public JSplitPane createJSplitPane(Container c1,Container c2,int horizontalOrVertical,int dividerLoaction,int dividerSize,boolean expandable){  
        JSplitPane splitPane=new JSplitPane(horizontalOrVertical,  
                true,c1,c2);  
        splitPane.setDividerLocation(dividerLoaction);  
        splitPane.setOneTouchExpandable(expandable);  
        splitPane.setDividerSize(dividerSize);  
        return splitPane;  
    }  
    //产生一个JToggleButton  
    public JToggleButton createJToggleButton(String text,String command,Icon icon,int width,int height,ActionListener al, boolean selected){  
        JToggleButton button=new JToggleButton(text,icon,selected);  
        button.setActionCommand(command);  
        button.addActionListener(al);  
        button.setPreferredSize(new Dimension(width,height));  
        return button;  
    }  
    //产生一个JToggleButton  
    public JToggleButton createJToggleButton(String text,String command,Icon icon,int width,int height,ActionListener al){  
        JToggleButton button=new JToggleButton(text,icon);  
        button.setActionCommand(command);  
        button.addActionListener(al);  
        button.setPreferredSize(new Dimension(width,height));  
        return button;  
    }  
    //产生将组件结合起来的面板  
    public JPanel createJPanelWithComponents(JLabel label,Container field,int policy){  
        JPanel p=this.createFlowJPanel(policy);  
        p.add(label);  
        p.add(field);  
        return p;  
    }  
    //产生将两个面板整合起来的面板  
    public JPanel createJPanelWithComponents(Container c1,Container c2,int policy){  
        JPanel p=this.createFlowJPanel(policy,0,0);  
        p.add(c1);  
        p.add(c2);  
        return p;  
    }  
    //产生将三个面板整合起来的面板  
    public JPanel createJPanelWithComponents(Container c1,Container c2,Container c3,int policy){  
        JPanel p=this.createFlowJPanel(policy,0,0);  
        p.add(c1);  
        p.add(c2);  
        p.add(c3);  
        return p;  
    }  
    //产生将四个面板整合起来的面板  
    public JPanel createJPanelWithComponents(Container c1,Container c2,Container c3,Container c4,int policy){  
        JPanel p=this.createFlowJPanel(policy,0,0);  
        p.add(c1);  
        p.add(c2);  
        p.add(c3);  
        p.add(c4);  
        return p;  
    }  
    //产生一个普通表格  
    public JTable createJTable(){  
        JTable table=new JTable();  
        return table;  
    }  
    //产生一个带AbstractTableModel的表格  
    public JTable createJTable(AbstractTableModel model){  
        JTable table=new JTable(model);  
        return table;  
    }  
    //产生一个密码框  
    //生成文本框   默认文本  文本框大小长 是否可编辑  
    public JPasswordField createJPasswordField(String text,int cols,boolean isEditable){  
        JPasswordField field=new JPasswordField(text,cols);  
        field.setEditable(isEditable);  
        return field;  
    }  
       
    //产生一个带监听器的菜单项  
    public MenuItem createMenuItem(String text,ActionListener al){  
        MenuItem mi=new MenuItem(text);  
        mi.addActionListener(al);  
        return mi;  
    }  
    //产生一个带监听器的菜单项  
    public MenuItem createMenuItem(String text,String command,ActionListener al){  
        MenuItem mi=new MenuItem(text);  
        mi.setActionCommand(command);  
        mi.addActionListener(al);  
        return mi;  
    }  
}  

原文链接：http://blog.csdn.net/royliang_peng/article/details/6292841

【编辑推荐】

1. 浅析Swing线程模型和EDT
2. Swing使用Substance外观包异常问题
3. Swing多线程编码过程中的误区
4. 控件位置可以配置的Swing桌面
5. Swing特效：渐显效果