Java JTable不会在fireXXXXX（）事件上更新

在我的项目中发生了一些不确定的事情。抱歉，这里有一大部分代码：

public abstract class RowTableModel<T> extends AbstractTableModel {
protected List<T> modelData;
protected List<String> columnNames;
@SuppressWarnings("rawtypes")
protected Class[] columnClasses;
protected Boolean[] isColumnEditable;
@SuppressWarnings("rawtypes")
private Class rowClass = Object.class;
private boolean isModelEditable = true;

@SuppressWarnings("rawtypes")
protected RowTableModel(Class rowClass) {
    setRowClass(rowClass);
}

protected RowTableModel(List<String> columnNames) {
    this(new ArrayList<T>(), columnNames);
}

protected RowTableModel(List<T> modelData, List<String> columnNames) {
    setDataAndColumnNames(modelData, columnNames);
}

@SuppressWarnings("rawtypes")
protected RowTableModel(List<T> modelData, List<String> columnNames, Class rowClass) {
    setDataAndColumnNames(modelData, columnNames);
    setRowClass(rowClass);
}

protected void setDataAndColumnNames(List<T> modelData, List<String> columnNames) {
    this.modelData = modelData;
    this.columnNames = columnNames;
    columnClasses = new Class[getColumnCount()];
    isColumnEditable = new Boolean[getColumnCount()];
    fireTableStructureChanged();
}

@SuppressWarnings("rawtypes")
protected void setRowClass(Class rowClass) {
    this.rowClass = rowClass;
}

@SuppressWarnings({"rawtypes", "unchecked"})
public Class getColumnClass(int column) {
    // Class columnClass = null;
    //
    // if (column < columnClasses.length)
    // columnClass = columnClasses[column];
    //
    // // Get the default class
    //
    // if (columnClass == null)
    // columnClass = super.getColumnClass(column);
    //
    // return columnClass;
    Class columnClass = getValueAt(0, column).getClass();
    if (columnClass != null) {
        return columnClass;
    } else {
        return String.class;
    }

}
public int getColumnCount() {
    return columnNames.size();
}

public String getColumnName(int column) {
    Object columnName = null;

    if (column < columnNames.size()) {
        columnName = columnNames.get(column);
    }

    return (columnName == null) ? super.getColumnName(column) : columnName.toString();
}

public int getRowCount() {
    return modelData.size();
}

public boolean isCellEditable(int row, int column) {
    Boolean isEditable = null;

    // Check is column editability has been set

    if (column < isColumnEditable.length)
        isEditable = isColumnEditable[column];

    return (isEditable == null) ? isModelEditable : isEditable.booleanValue();
}

public void addRow(T rowData) {
    insertRow(getRowCount(), rowData);
}

public T getRow(int row) {
    return modelData.get(row);
}

@SuppressWarnings("unchecked")
public T[] getRowsAsArray(int... rows) {
    List<T> rowData = getRowsAsList(rows);
    T[] array = (T[]) Array.newInstance(rowClass, rowData.size());
    return (T[]) rowData.toArray(array);
}

public List<T> getRowsAsList(int... rows) {
    ArrayList<T> rowData = new ArrayList<T>(rows.length);

    for (int i = 0; i < rows.length; i++) {
        rowData.add(getRow(rows[i]));
    }

    return rowData;
}

public void insertRow(int row, T rowData) {
    modelData.add(row, rowData);
    fireTableRowsInserted(row, row);
}

public void insertRows(int row, List<T> rowList) {
    modelData.addAll(row, rowList);
    fireTableRowsInserted(row, row + rowList.size() - 1);
}

public void insertRows(int row, T[] rowArray) {
    List<T> rowList = new ArrayList<T>(rowArray.length);

    for (int i = 0; i < rowArray.length; i++) {
        rowList.add(rowArray[i]);
    }

    insertRows(row, rowList);
}

public void moveRow(int start, int end, int to) {
    if (start < 0) {
        String message = "Start index must be positive: " + start;
        throw new IllegalArgumentException(message);
    }

    if (end > getRowCount() - 1) {
        String message = "End index must be less than total rows: " + end;
        throw new IllegalArgumentException(message);
    }

    if (start > end) {
        String message = "Start index cannot be greater than end index";
        throw new IllegalArgumentException(message);
    }

    int rowsMoved = end - start + 1;

    if (to < 0 || to > getRowCount() - rowsMoved) {
        String message = "New destination row (" + to + ") is invalid";
        throw new IllegalArgumentException(message);
    }

    // Save references to the rows that are about to be moved

    ArrayList<T> temp = new ArrayList<T>(rowsMoved);

    for (int i = start; i < end + 1; i++) {
        temp.add(modelData.get(i));
    }

    // Remove the rows from the current location and add them back
    // at the specified new location

    modelData.subList(start, end + 1).clear();
    modelData.addAll(to, temp);

    // Determine the rows that need to be repainted to reflect the move

    int first;
    int last;

    if (to < start) {
        first = to;
        last = end;
    } else {
        first = start;
        last = to + end - start;
    }

    fireTableRowsUpdated(first, last);
}

public void removeRowRange(int start, int end) {
    modelData.subList(start, end + 1).clear();
    fireTableRowsDeleted(start, end);
}

public void removeRows(int... rows) {
    for (int i = rows.length - 1; i >= 0; i--) {
        int row = rows[i];
        modelData.remove(row);
        fireTableRowsDeleted(row, row);
    }
}

public void replaceRow(int row, T rowData) {
    modelData.set(row, rowData);
    fireTableRowsUpdated(row, row);
}

@SuppressWarnings("rawtypes")
public void setColumnClass(int column, Class columnClass) {
    columnClasses[column] = columnClass;
    fireTableRowsUpdated(0, getColumnCount() - 1);
}

public void setColumnEditable(int column, boolean isEditable) {
    isColumnEditable[column] = isEditable ? Boolean.TRUE : Boolean.FALSE;
}

public void setModelEditable(boolean isModelEditable) {
    this.isModelEditable = isModelEditable;
}

public static String formatColumnName(String columnName) {
    if (columnName.length() < 3)
        return columnName;

    StringBuffer buffer = new StringBuffer(columnName);
    boolean isPreviousLowerCase = false;

    for (int i = 1; i < buffer.length(); i++) {
        boolean isCurrentUpperCase = Character.isUpperCase(buffer.charAt(i));

        if (isCurrentUpperCase && isPreviousLowerCase) {
            buffer.insert(i, " ");
            i++;
        }

        isPreviousLowerCase = !isCurrentUpperCase;
    }

    return buffer.toString().replaceAll("_", " ");
}

在第二种情况下，我也会这样做：

int[] selectedIndexes = lessonTable.getSelectedRows();
                    if (selectedIndexes.length == 1) {
                        int selectedIndex = lessonTable.convertRowIndexToModel(lessonTable.getSelectedRow());
                        Lesson lesson = lessonTableModel.getRow(selectedIndex);
                        LessonFrame lessonFrame = LessonFrame.show(lesson);
                        if (lessonFrame.getDialogResult() == DialogResult.OK) {
                            lessonTableModel.replaceRow(selectedIndex, lessonFrame.getLesson());
                        }
                    }

但在第一种情况下，表得到了正确的更新，在第二种情况下，在我单击表之后应用了更新。我知道有大量的代码字符串，但我真的希望有人能帮助我。尝试用fireTableDataChanged替换fireTableRowInserted，但未更改任何内容

---

提前谢谢大家，我真的很感谢你们的帮助

问题在于帧的模态。Frame教授是模态的，LessonFrame不是。这就是为什么第一种情况下的更改被正确应用，导致编辑的值被钩住，而在第二种情况下，代码在没有暂停的情况下被执行，并且没有新的值被钩住。谢谢@ HoVrCRAFTFulfFeels'为您的帮助和您的建议。

如果您没有得到一个像样的解决方案在这里很快，考虑调试通过不断淡化您的代码，消除代码逐步从程序，直到你孤立了问题或它消失。如果它消失了，很可能是刚刚删除的代码涉及其中。如果是孤立的，那么你可以重新发布一个简单易懂的小程序，我们可以运行它，重现你的问题，测试代码，修改代码，并帮助你解决它。我想知道你的lessonFrame.getDialogResult方法在做什么。这就是您发布的最后两段代码之间的最大区别。lessonFrame.getDialogResult返回对话框的结果。换句话说，它表示用户是否单击了OK或Cancel。我将尝试剪切此代码以使其更干净。我了解它返回的内容，但我很好奇该方法内部发生了什么，是占用EDT还是执行其他可能会阻止GUI正常运行的操作。下面是使用fireTableCellUpdated的工作。

public class LessonTableModel extends RowTableModel<Lesson>{
    public LessonTableModel(List<Lesson> modelData,
            List<String> columnNames) {
        super(modelData, columnNames);
    }

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        Lesson lesson = super.getRow(rowIndex);
        switch (columnIndex) {
        case 0: {
            return lesson.getId();
        }
        case 1: {
            return lesson.getProfessor();
        }
        case 2:{
            return lesson.getCourse();
        }
        case 3:{
            return lesson.getGroup();
        }
        case 4:{
            return lesson.isLab();
        }
        default:
            return null;
        }
    }

    @Override
    public boolean isCellEditable(int row, int column) {
        return false;
    }
}

int[] selectedIndexes = professorTable.getSelectedRows();
            if (selectedIndexes.length == 1) {
                int selectedIndex = professorTable.convertRowIndexToModel(professorTable.getSelectedRow());
                Professor professor = professorTableModel.getRow(selectedIndex);
                ProfessorFrame professorFrame = ProfessorFrame.show(professor);
                if (professorFrame.getDialogResult() == DialogResult.OK) {
                    professorTableModel.replaceRow(selectedIndex, professorFrame.getProfessor());
                }
            }   

int[] selectedIndexes = lessonTable.getSelectedRows();
                    if (selectedIndexes.length == 1) {
                        int selectedIndex = lessonTable.convertRowIndexToModel(lessonTable.getSelectedRow());
                        Lesson lesson = lessonTableModel.getRow(selectedIndex);
                        LessonFrame lessonFrame = LessonFrame.show(lesson);
                        if (lessonFrame.getDialogResult() == DialogResult.OK) {
                            lessonTableModel.replaceRow(selectedIndex, lessonFrame.getLesson());
                        }
                    }