Java 在CellRenderer中显示选定的行和列

我有一个

JTable

，每次我选择一个单元格时，我都想打印它的行和列索引。因此，我使用了

getSelectedRow（）

和

getSelectedColumn（）

方法。运行以下代码：

班级考试时间表 类BoardTableCellRenderer 每次我选择一个单元格时，都会出现

JOptionPane

框架，然后应用程序冻结。所以我不得不一直打断它。谁能告诉我为什么会这样？我能做些什么来修复它？

• 从

  GetTableCellRenderComponent

  中使用、重写

  boolean isSelected，boolean hasFocus

  （内置方法），而不是引用回JTable-

  表。isCellSelected（行、列）

  ，ba重置else语句中其余单元格的颜色，例如简单躯干

• 改变

• 删除所有这些。Xxx，都是无用的

• 不要设置大小，而是使用JFrame.pack（）和/或设置JScrollPane的大小，例如

  table.setPreferredScrollableViewportSize（table.getPreferredSize（））（对于合理的数字或行和列，否则使用尺寸（x，x））
  

编辑

导入java.awt.Component；
导入java.awt.event.MouseAdapter；
导入java.awt.event.MouseEvent；
导入javax.swing.JCheckBox；
导入javax.swing.JFrame；
导入javax.swing.JLabel；
导入javax.swing.JScrollPane；
导入javax.swing.JTable；
导入javax.swing.SwingUtilities；
导入javax.swing.UIManager；
导入javax.swing.border.border；
导入javax.swing.border.EmptyBorder；
导入javax.swing.plaf.UIResource；
导入javax.swing.table.DefaultTableModel；
导入javax.swing.table.TableCellRenderer；
公共类表格{
私有JFrame=新JFrame（“TableRollorVerdemo”）；
私有JTable表=新JTable（）；
私有字符串[]columnNames=新字符串[]{“Column”}；
私有对象[][]数据=新对象[][{{false}，{false}，{true}，{true}，
{false}、{false}、{true}、{true}、{false}、{false}、{true}、{true}；
公共表格{
最终DefaultTableModel=新的DefaultTableModel（数据、列名）{
//私有布尔值ImInLoop=false；
@凌驾
公共类getColumnClass（int columnIndex）{
返回Boolean.class；
}
@凌驾
公共布尔值isCellEditable（int-rowIndex、int-columnIndex）{
如果（columnIndex==0）{
返回true；
}否则{
返回false；
}
}
@凌驾
public void setValueAt（对象有效、int行索引、int列索引）{
如果（columnIndex==0）{
//如果（！iminLop）{
//ImInLoop=真；
布尔bol=（布尔）aValue；
super.setValueAt（aValue、rowIndex、columnIndex）；
对于（int i=0；i=0和列>=0）{
table.repaint（table.getCellRect（行、列、假））；
}
如果（lastRow>=0&&lastColumn>=0）{
table.repaint（table.getCellRect（lastRow，lastColumn，false））；
}
}
@凌驾
公共无效mouseExited（MouseEvent e）{
如果（行>=0和列>=0）{
table.repaint（table.getCellRect（行、列、假））；
}
行=列=-1；
}
}
私有类RolloverBooleanRenderer扩展了JCheckBox实现
TableCellRenderer，UIResource{
私有最终边界noFocusBorder=新的清空顺序（1,1,1,1）；
专用滚动鼠标适配器；
公共RolloverBooleanRenderer（RolloverMouseAdapter适配器）{
超级（）；
this.adapter=适配器；
设置水平对齐（标记中心）；
（真实的）；
}
@凌驾
公共组件GetTableCellRenderComponent（JTable表，
对象值，布尔isSelected，布尔hasFocus，int行，
int列）{
getMode
public class TestTimeTable extends JFrame{
    private final int rows = 10;
    private final int cols = 8;
    private final String daysOfTheWeek[] = {"MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY"};
    private final JPanel jTablePanel;
    private final JScrollPane scrollPane;
    private final JTable timeTable;
    private final Object[][] rowData;

    public TestTimeTable(){
        this.rowData = new Object[this.rows][this.cols];
        this.timeTable = new JTable(this.rowData,this.daysOfTheWeek){
            @Override
            public boolean isCellEditable(int row, int column) {
                return false;
            }
        };

        this.timeTable.setRowHeight(200, 200);
        this.timeTable.setFillsViewportHeight(true);
        this.timeTable.setOpaque(true);
        this.timeTable.setColumnSelectionAllowed(true);
        this.timeTable.setRowSelectionAllowed(true);
        this.timeTable.setCellSelectionEnabled(true);
        this.timeTable.setDefaultRenderer(Object.class, new BoardTableCellRenderer());
        this.scrollPane = new JScrollPane(this.timeTable, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);

        this.jTablePanel = new JPanel();
        this.jTablePanel.add(this.scrollPane);
        getContentPane().add(new JScrollPane(this.timeTable), BorderLayout.CENTER);
    }

    public int getColumn(){
        return this.timeTable.getSelectedColumn();
    }

    public int getRow(){
        return this.timeTable.getSelectedRow();
    }

    public JTable getTimeTable(){
        return this.timeTable;
    }

    public void createAndShowUI(){
        setSize(600, 600);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }

    public static void main(String[] argas){
        TestTimeTable tt = new TestTimeTable();
        tt.createAndShowGUI();
    }
}

class BoardTableCellRenderer extends DefaultTableCellRenderer {

    Component c;
    private static final long serialVersionUID = 1L;
    private final Color selectionBlue = new Color(131,166,198);
    private final MatteBorder border = new MatteBorder(1, 1, 0, 0, Color.BLACK);

    @Override
    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
        c = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);

        if (table.isCellSelected(row, column)){
            c.setBackground(this.selectionBlue);
            setBorder(this.border);
        } else {
            c.setBackground(Color.WHITE);
        }

        if(isSelected){
            JOptionPane.showMessageDialog(null, table.getSelectedRow() + ""+table.getSelectedColumn(),null, JOptionPane.INFORMATION_MESSAGE);
        }
        return c;
    }
}

   private class StatusRenderer implements TableCellRenderer {

        private static final long serialVersionUID = 1L;

        @Override
        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
            if (isSelected) {
                setBackground(table.getSelectionBackground());
            } else {
                setBackground(table.getBackground());
            }
            return this;
        }
    }

import java.awt.Component;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.border.Border;
import javax.swing.border.EmptyBorder;
import javax.swing.plaf.UIResource;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableCellRenderer;

public class TableRolloverDemo {

    private JFrame frame = new JFrame("TableRolloverDemo");
    private JTable table = new JTable();
    private String[] columnNames = new String[]{"Column"};
    private Object[][] data = new Object[][]{{false}, {false}, {true}, {true},
        {false}, {false}, {true}, {true}, {false}, {false}, {true}, {true}};

    public TableRolloverDemo() {
        final DefaultTableModel model = new DefaultTableModel(data, columnNames) {
            //private boolean ImInLoop = false;

            @Override
            public Class<?> getColumnClass(int columnIndex) {
                return Boolean.class;
            }

            @Override
            public boolean isCellEditable(int rowIndex, int columnIndex) {
                if (columnIndex == 0) {
                    return true;
                } else {
                    return false;
                }
            }

            @Override
            public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
                if (columnIndex == 0) {
                    //if (!ImInLoop) {
                    //    ImInLoop = true;
                        Boolean bol = (Boolean) aValue;
                        super.setValueAt(aValue, rowIndex, columnIndex);
                        for (int i = 0; i < this.getRowCount(); i++) {
                            if (i != rowIndex) {
                                super.setValueAt(!bol, i, columnIndex);
                            }
                        }
                    //    ImInLoop = false;
                    //}
                } else {
                    super.setValueAt(aValue, rowIndex, columnIndex);
                }
            }
        };
        RolloverMouseAdapter rolloverAdapter = new RolloverMouseAdapter(table);
        RolloverBooleanRenderer renderer = new RolloverBooleanRenderer(rolloverAdapter);
        table.addMouseListener(rolloverAdapter);
        table.addMouseMotionListener(rolloverAdapter);
        table.setDefaultRenderer(Boolean.class, renderer);
        table.setModel(model);
        table.setPreferredScrollableViewportSize(table.getPreferredSize());
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(new JScrollPane(table));
        frame.pack();
        frame.setLocationByPlatform(true);
        frame.setVisible(true);
    }

    private class RolloverMouseAdapter extends MouseAdapter {

        private int row = -1;
        private int column = -1;
        private JTable table;

        public RolloverMouseAdapter(JTable table) {
            this.table = table;
        }

        public boolean isRolloverCell(int row, int column) {
            return this.row == row && this.column == column;
        }

        @Override
        public void mouseMoved(MouseEvent e) {
            int lastRow = row;
            int lastColumn = column;
            row = table.rowAtPoint(e.getPoint());
            column = table.columnAtPoint(e.getPoint());
            if (row == lastRow && column == lastColumn) {
                return;
            }
            if (row >= 0 && column >= 0) {
                table.repaint(table.getCellRect(row, column, false));
            }
            if (lastRow >= 0 && lastColumn >= 0) {
                table.repaint(table.getCellRect(lastRow, lastColumn, false));
            }
        }

        @Override
        public void mouseExited(MouseEvent e) {
            if (row >= 0 && column >= 0) {
                table.repaint(table.getCellRect(row, column, false));
            }
            row = column = -1;
        }
    }

    private class RolloverBooleanRenderer extends JCheckBox implements
            TableCellRenderer, UIResource {

        private final Border noFocusBorder = new EmptyBorder(1, 1, 1, 1);
        private RolloverMouseAdapter adapter;

        public RolloverBooleanRenderer(RolloverMouseAdapter adapter) {
            super();
            this.adapter = adapter;
            setHorizontalAlignment(JLabel.CENTER);
            setBorderPainted(true);
        }

        @Override
        public Component getTableCellRendererComponent(JTable table,
                Object value, boolean isSelected, boolean hasFocus, int row,
                int column) {

            getModel().setRollover(adapter.isRolloverCell(row, column));
            if (isSelected) {
                setForeground(table.getSelectionForeground());
                super.setBackground(table.getSelectionBackground());
            } else {
                setForeground(table.getForeground());
                setBackground(table.getBackground());
            }
            setSelected((value != null && ((Boolean) value).booleanValue()));
            if (hasFocus) {
                setBorder(UIManager.getBorder("Table.focusCellHighlightBorder"));
            } else {
                setBorder(noFocusBorder);
            }
            return this;
        }
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                TableRolloverDemo tableRolloverDemo = new TableRolloverDemo();
            }
        });
    }
}

JTable table = new JTable(data, columnNames)
{

    public void xxxchangeSelection(
        int row, int column, boolean toggle, boolean extend)
    {
        super.changeSelection(row, column, toggle, extend);

        System.out.println(row + " : " + column);
    }
};