Java JTablebackground不'；具有整数类行的t色单元格

我面临的问题是，如果我想根据TableModel a column Integer类为特定行着色，它不会更改颜色。只要我将column类更改为String，它就会工作

这里有什么问题

   private class TableRendererSelectedRow extends DefaultTableCellRenderer {

    @Override
    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
        setBackground(null);
        Component tableCellRendererComponent = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
        if (model.getSelectedRow()==row) {
            setBackground(Color.RED);
            tableCellRendererComponent.setBackground(Color.RED);
        }
        return tableCellRendererComponent;
    }
}

编辑：这里是SSCEE

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.Color;
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.
 */
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));

        table.setDefaultRenderer(Object.class, new TableRendererSelectedRow());
        //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 col) {
            if(col==3) {
            return Integer.class; 
            }
        return String.class;
        }

        /*
         * 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 class TableRendererSelectedRow extends DefaultTableCellRenderer {

        @Override
        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
            setBackground(null);
            Component tableCellRendererComponent = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
            if (2==row) {
                setBackground(Color.RED);
            }
            return tableCellRendererComponent;
        }
    }
    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();
            }
        });
    }
}

import javax.swing.DefaultCellEditor；
导入javax.swing.JComboBox；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
导入javax.swing.JScrollPane；
导入javax.swing.JTable；
导入javax.swing.table.AbstractTableModel；
导入javax.swing.table.DefaultTableCellRenderer；
导入javax.swing.table.TableCellRenderer；
导入javax.swing.table.TableColumn；
导入java.awt.Color；
导入java.awt.Component；
导入java.awt.Dimension；
导入java.awt.GridLayout；
/** 
*TableRenderDemo与TableDemo一样，只是
*显式初始化列大小，并使用组合框
*作为体育专栏的编辑。
*/
公共类TableRenderDemo扩展了JPanel{
私有布尔调试=false；
公共TableRenderDemo（）{
超级（新网格布局（1,0））；
JTable table=newjtable（newmytablemodel（））；
表.setPreferredScrollableViewportSize（新维度（500,70））；
表.setFillsViewPerthweight（真）；
//创建滚动窗格并将表添加到其中。
JScrollPane scrollPane=新的JScrollPane（表）；
//设置列大小。
初始列大小（表）；
//摆弄体育专栏的单元格编辑器/渲染器。
setUpSportColumn（table，table.getColumnModel（）.getColumn（2））；
setDefaultRenderer（Object.class，新的TableRenderSelectedRow（））；
//将滚动窗格添加到此面板。
添加（滚动窗格）；
}
/*
*此方法选择良好的列大小。
*如果所有列标题的宽度都大于列单元格的宽度
*内容，然后您可以只使用column.sizeWidthToFit（）。
*/
专用void initColumnSizes（JTable表）{
MyTableModel=（MyTableModel）table.getModel（）；
TableColumn=null；
组件comp=null；
int headerWidth=0；
int cellWidth=0；
对象[]longValues=model.longValues；
台球头球吊杆=
table.getTableHeader（）.getDefaultRenderer（）；
对于（int i=0；i<5；i++）{
column=table.getColumnModel（）.getColumn（i）；
comp=headerRenderer.GetTableCellRenderComponent(
null，column.getHeaderValue（），
假，假，0，0）；
headerWidth=组件getPreferredSize（）.宽度；
comp=table.getDefaultRenderer（model.getColumnClass（i））。
GetTableCellRenderComponent(
表，longValues[i]，
假，假，0，我）；
cellWidth=comp.getPreferredSize（）.width；
如果（调试）{
System.out.println（“初始化列的宽度”
+i+“”
+“headerWidth=“+headerWidth
+“cellWidth=“+cellWidth”）；
}
column.setPreferredWidth（Math.max（headerWidth，cellWidth））；
}
}
公共列（JTable table，
表列（表列）{
//设置运动单元格的编辑器。
JComboBox comboBox=新的JComboBox（）；
comboBox.addItem（“滑雪板”）；
组合框。附加项（“划船”）；
comboBox.addItem（“针织”）；
comboBox.addItem（“快速读取”）；
comboBox.addItem（“池”）；
comboBox.addItem（“上述任何一项”）；
setCellEditor（新的DefaultCellEditor（组合框））；
//为运动单元设置工具提示。
DefaultTableCellRenderer渲染器=
新的DefaultTableCellRenderer（）；
setToolTipText（“单击组合框”）；
sportColumn.setCellRenderer（渲染器）；
}
类MyTableModel扩展了AbstractTableModel{
私有字符串[]columnNames={“名字”，
“姓氏”，
“运动”，
“#年”，
“素食者”}；
私有对象[][]数据={
{“凯西”，“史密斯”，
“滑雪板”，新整数（5），新布尔值（假）}，
{“约翰”，“多伊”，
“划船”，新整数（3），新布尔值（真）}，
{“苏”，“黑”，
“编织”，新整数（2），新布尔值（假）}，
{“简”、“白”，
“快速读取”，新整数（20），新布尔值（真）}，
{“乔”，“布朗”，
“Pool”、新整数（10）、新布尔值（false）}
};
公共最终对象[]longValues={“Jane”，“Kathy”，
“以上都不是”，
新整数（20），Boolean.TRUE}；
public int getColumnCount（）{
返回columnNames.length；
}
public int getRowCount（）{
返回数据长度；
}
公共字符串getColumnName（int-col）{
返回列名[col]；
}
公共对象getValueAt（整数行，整数列）{
返回数据[行][col]；
}
/*
*JTable使用此方法确定默认渲染器/
*每个单元格的编辑器。如果我们没有实现此方法，
*最后一列将包含文本（“真”/“假”），
*而不是复选框。
*/
公共类getColumnClass（int-col）{
如果（列==3）{
返回Integer.class；
}
返回字符串.class；
}
/*
*不需要实现此方法，除非您的表
*可编辑。
*/
平民的