Java 单元编辑器中组件内的焦点遍历

我正在尝试对一个表进行简单的编辑，因为它使用一个自定义组件来显示信息。 每个单元格有3个数据文本

我想要的是：

• 如果单元格获得焦点，则开始编辑第一个值
• 编辑第一个值时，用户按[TAB]，然后编辑第二个值（不要转到下一个单元格）
• 如果在第三个值中按[TAB]，则编辑下一个单元格（输入1sr值）

我在论坛上寻找，我没有发现这个案例，这个问题。。。还在读书学秋千吗

提前感谢您的回答，这是我的代码：

public class PruebaTabla extends JFrame {

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable(){

            public void run() {
                new PruebaTabla().setVisible(true);
            }});
    }
    public PruebaTabla(){

        JTable tabla = new JTable(); 

        tabla.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        tabla.setCellSelectionEnabled(true);
        tabla.setDefaultRenderer(ModelClass.class, new ModelClassCellRederer());
        tabla.setDefaultEditor(ModelClass.class, new ModelClasstroCellEditor());
        tabla.setRowHeight(30);

        CustomModel model = new CustomModel();
        model.setModel(new ModelClass[][]{
                                        {new ModelClass(), new ModelClass(), new ModelClass()},
                                        {new ModelClass(), new ModelClass(), new ModelClass()},
                                        {new ModelClass(), new ModelClass(), new ModelClass()}});
        tabla.setModel(model);


        getContentPane().add(new JScrollPane(tabla));
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setSize(480,150);
        setLocationRelativeTo(null);

    }

    private class ModelClass {

        private String value1;
        private String value2;
        private String value3;
        public ModelClass(){
            setValue1("" + Math.round(Math.random() * 100));
            setValue2("" + Math.round(Math.random() * 100));
            setValue3("" + Math.round(Math.random() * 100));
        }
        public String getValue1() {
            return value1;
        }
        public void setValue1(String value1) {
            this.value1 = value1;
        }
        public String getValue2() {
            return value2;
        }
        public void setValue2(String value2) {
            this.value2 = value2;
        }
        public String getValue3() {
            return value3;
        }
        public void setValue3(String value3) {
            this.value3 = value3;
        }

    }

    private class CustomModel extends AbstractTableModel{

        ModelClass[][] model;
        String[] columnNames = new String[] {"Column1", "Column2", "Column3"};

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

        @Override
        public String getColumnName(int column) {
            return columnNames[column];
        }
        public int getColumnCount() {       
            return 3;
        }

        public int getRowCount() {
            return 3;
        }

        public Object getValueAt(int rowIndex, int columnIndex) {           
            return model[rowIndex][columnIndex];
        }

        public ModelClass[][] getModel() {
            return model;
        }

        public void setModel(ModelClass[][] model) {
            this.model = model;
        }

        @Override
        public boolean isCellEditable(int rowIndex, int columnIndex) {          
            return true;
        }
    }

    private class ModelClassCellRederer implements TableCellRenderer {

        JPanel panel = new JPanel();
        private JLabel label1= new JLabel();
        private JLabel label2 = new JLabel();
        private JLabel label3 = new JLabel();

        ModelClassCellRederer(){
            panel.add(label1);
            panel.add(label2);
            panel.add(label3);
        }

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

             if (isSelected) {
                 panel.setBackground(table.getSelectionBackground());
                 panel.setBorder(UIManager.getBorder("Table.focusCellHighlightBorder"));
             } else {
                 panel.setBackground(table.getBackground());
                 panel.setBorder(null);
             }

            ModelClass v = (ModelClass) value;
            label1.setText(v.getValue1());
            label2.setText(v.getValue2());
            label3.setText(v.getValue3());

            return panel;
        }

    }

    private class ModelClasstroCellEditor extends DefaultCellEditor {

        JPanel panel = new JPanel();
        private JTextField label1= new JTextField();
        private JTextField label2 = new JTextField();
        private JTextField label3 = new JTextField();
        ModelClass actual;

        public ModelClasstroCellEditor() {
            super(new JCheckBox());
            panel.add(label1);
            panel.add(label2);
            panel.add(label3);
            setClickCountToStart(1);
        }

        @Override
        public Component getTableCellEditorComponent(JTable table,
                Object value, boolean isSelected, int row, int column) {
            actual = (ModelClass) value;
            label1.setText(actual.getValue1());
            label2.setText(actual.getValue2());
            label3.setText(actual.getValue3());

            return panel;
        }

        @Override
        public Object getCellEditorValue() {
            if (actual != null){
                actual.setValue1(label1.getText());
                actual.setValue2(label2.getText());
                actual.setValue3(label3.getText());
            }
            return actual;
        }

        @Override
        public boolean isCellEditable(EventObject anEvent) {
             if (anEvent instanceof KeyEvent) {
                 final KeyEvent keyEvent = (KeyEvent) anEvent;

                 SwingUtilities.invokeLater(new Runnable() {

                    public void run() {
                       if (!Character.isIdentifierIgnorable(keyEvent.getKeyChar())) {
                           label1.setText("" + keyEvent.getKeyChar());
                       }
                       label1.setCaretPosition(label1.getText().length());
                       label1.requestFocusInWindow();
                    }
                 });
              }
              return super.isCellEditable(anEvent);

        }

    }
}

公共类PruebaTabla扩展JFrame{
公共静态void main（字符串[]args）{
SwingUtilities.invokeLater（新的Runnable（）{
公开募捐{
新的PruebaTabla（）.setVisible（true）；
}});
}
公共审慎性{
JTable tabla=新的JTable（）；
表A.setSelectionMode（ListSelectionModel.单选）；
表A.setCellSelectionEnabled（真）；
tabla.setDefaultRenderer（ModelClass.class，新的ModelClassCellRederer（））；
tabla.setDefaultEditor（ModelClass.class，新的ModelClasstroCellEditor（））；
表A.设置行高（30）；
CustomModel model=新CustomModel（）；
model.setModel（新模型类[][]{
{new ModelClass（），new ModelClass（），new ModelClass（）}，
{new ModelClass（），new ModelClass（），new ModelClass（）}，
{new ModelClass（），new ModelClass（），new ModelClass（）}}）；
表1.setModel（模型）；
getContentPane（）.add（新的JScrollPane（tabla））；
setDefaultCloseOperation（WindowConstants.EXIT_ON_CLOSE）；
设置大小（480150）；
setLocationRelativeTo（空）；
}
私有类模型类{
私有字符串值1；
私有字符串值2；
私有字符串值3；
公共模型类（）{
setValue1（“+Math.round（Math.random（）*100））；
setValue2（“+Math.round（Math.random（）*100））；
setValue3（“+Math.round（Math.random（）*100））；
}
公共字符串getValue1（）{
返回值1；
}
public void setValue1（字符串值1）{
此值为1.value1=value1；
}
公共字符串getValue2（）{
返回值2；
}
public void setValue2（字符串值2）{
此参数为0.value2=value2；
}
公共字符串getValue3（）{
返回值3；
}
public void setValue3（字符串值3）{
此值为0.3=值3；
}
}
私有类CustomModel扩展了AbstractTableModel{
ModelClass[][]模型；
字符串[]columnNames=新字符串[]{“Column1”、“Column2”、“Column3”}；
@凌驾
公共类getColumnClass（int columnIndex）{
返回ModelClass.class；
}
@凌驾
公共字符串getColumnName（int列）{
返回columnNames[列]；
}
public int getColumnCount（）{
返回3；
}
public int getRowCount（）{
返回3；
}
公共对象getValueAt（int-rowIndex，int-columnIndex）{
返回模型[rowIndex][columnIndex]；
}
公共模型类[][]getModel（）{
收益模型；
}
公共void集合模型（模型类[][]模型）{
this.model=模型；
}
@凌驾
公共布尔isCellEditable（int-rowIndex，int-columnIndex）{
返回true；
}
}
私有类ModelClassCellRederer实现TableCellRenderer{
JPanel面板=新的JPanel（）；
专用JLabel label1=新JLabel（）；
专用JLabel label2=新JLabel（）；
专用JLabel label3=新JLabel（）；
ModelClassCellRederer（）{
面板。添加（标签1）；
面板。添加（标签2）；
面板。添加（标签3）；
}
公共组件GetTableCellRenderComponent（JTable表，
对象值，布尔isSelected，布尔hasFocus，int行，
int列）{
如果（当选）{
panel.setBackground（table.getSelectionBackground（））；
panel.setboorder（UIManager.getBorder（“Table.focusCellHighlightBorder”）；
}否则{
panel.setBackground（table.getBackground（））；
面板顺序（空）；
}
ModelClass v=（ModelClass）值；
label1.setText（v.getValue1（））；
label2.setText（v.getValue2（））；
label3.setText（v.getValue3（））；
返回面板；
}
}
私有类ModelClasstroCellEditor扩展了DefaultCellEditor{
JPanel面板=新的JPanel（）；
私有JTextField label1=新JTextField（）；
私有JTextField label2=新JTextField（）；
私有JTextField label3=新JTextField（）；
模型类实际；
公共模型ClassTroCellEditor（）{
super（新JCheckBox（））；
面板。添加（标签1）；
面板。添加（标签2）；
面板。添加（标签3）；
设置ClickCountToStart（1）；
}
@凌驾
公共组件getTableCellEditorComponent（JTable表，
对象值，布尔值（选定，int行，int列）{
实际值=（模型类）值；
label1.setText（actual.getValue1（））；
label2.setText（actual.getValue2（））；
label3.setText（actual.getValue3（））；
返回面板；
}
@凌驾
公共对象getCellEditorValue（）{
如果（实际值！=null）{
actual.setValue1（label1.getText（））；
actual.setValue2（label2.getText（））；
actual.setValue3（label3.getText（））；
}
回流交流电