How to add an option "None" or "None of the above" to a JTable in Java?

[shri hari]

I want to use of the following piece of code. But want to modify or extend it to provide an option "none" or "none of the above" at the end of the table. The output of the code is given at this url

[/img]. I want to have a value = none or none of the above instead of Row 20. How do I achieve it?

    import java.awt.BorderLayout;
    import java.awt.Component;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.beans.PropertyChangeEvent;
    import java.beans.PropertyChangeListener;
    import java.beans.PropertyChangeSupport;
    import java.util.ArrayList;
    import java.util.List;
    
    import javax.swing.AbstractCellEditor;
    import javax.swing.JFrame;
    import javax.swing.JRadioButton;
    import javax.swing.JScrollPane;
    import javax.swing.JTable;
    import javax.swing.SwingUtilities;
    import javax.swing.UIManager;
    import javax.swing.UnsupportedLookAndFeelException;
    import javax.swing.table.AbstractTableModel;
    import javax.swing.table.TableCellEditor;
    import javax.swing.table.TableCellRenderer;
    import javax.swing.table.TableColumn;
    
    public class TestTable {
    
        public class RadioButtonCellEditorRenderer extends AbstractCellEditor implements TableCellRenderer, TableCellEditor, ActionListener {
    
            private JRadioButton radioButton;
    
            public RadioButtonCellEditorRenderer() {
                this.radioButton = new JRadioButton();
                radioButton.addActionListener(this);
                radioButton.setOpaque(false);
            }
    
            @Override
            public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
                radioButton.setSelected(Boolean.TRUE.equals(value));
                return radioButton;
            }
    
            @Override
            public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
                radioButton.setSelected(Boolean.TRUE.equals(value));
                return radioButton;
            }
    
            @Override
            public void actionPerformed(ActionEvent e) {
                stopCellEditing();
            }
    
            @Override
            public Object getCellEditorValue() {
                return radioButton.isSelected();
            }
    
        }
    
        private JFrame f;
        private JTable table;
    
        private class MyObjectManager {
            private PropertyChangeSupport propertyChangeSupport = new PropertyChangeSupport(this);
            private List<MyObject> objects = new ArrayList<TestTable.MyObject>();
    
            public void addObject(MyObject object) {
                objects.add(object);
                object.setManager(this);
                propertyChangeSupport.firePropertyChange("objects", null, object);
            }
    
            public List<MyObject> getObjects() {
                return objects;
            }
    
            public void setAsSelected(MyObject myObject) {
                for (MyObject o : objects) {
                    o.setSelected(myObject == o);
                }
            }
        }
    
        private class MyObject {
            private PropertyChangeSupport propertyChangeSupport = new PropertyChangeSupport(this);
    
            private MyObjectManager manager;
    
            private String value;
    
            private boolean selected;
    
            public MyObject(String value) {
                this.value = value;
            }
    
            public PropertyChangeSupport getPropertyChangeSupport() {
                return propertyChangeSupport;
            }
    
            public String getValue() {
                return value;
            }
    
            public void setValue(String value) {
                this.value = value;
                propertyChangeSupport.firePropertyChange("value", null, value);
            }
    
            public MyObjectManager getManager() {
                return manager;
            }
    
            public void setManager(MyObjectManager manager) {
                this.manager = manager;
                propertyChangeSupport.firePropertyChange("manager", null, manager);
            }
    
            public boolean isSelected() {
                return selected;
            }
    
            public void setSelected(boolean selected) {
                if (this.selected != selected) {
                    this.selected = selected;
                    if (selected) {
                        manager.setAsSelected(this);
                    }
                    propertyChangeSupport.firePropertyChange("selected", !selected, selected);
                }
            }
    
        }
    
        protected void initUI() {
            MyObjectManager manager = new MyObjectManager();
            for (int i = 0; i < 20; i++) {
                MyObject object = new MyObject("Row " + (i + 1));
                manager.addObject(object);
            }
            table = new JTable(new MyTableModel(manager));
            table.setRowHeight(20);
            TableColumn column = table.getColumnModel().getColumn(1);
            column.setCellEditor(new RadioButtonCellEditorRenderer());
            column.setCellRenderer(new RadioButtonCellEditorRenderer());
            f = new JFrame();
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            f.add(new JScrollPane(table), BorderLayout.CENTER);
            f.pack();
            f.setVisible(true);
    
        }
    
        public class MyTableModel extends AbstractTableModel implements PropertyChangeListener {
    
            private final MyObjectManager manager;
    
            public MyTableModel(MyObjectManager manager) {
                super();
                this.manager = manager;
                manager.propertyChangeSupport.addPropertyChangeListener(this);
                for (MyObject object : manager.getObjects()) {
                    object.getPropertyChangeSupport().addPropertyChangeListener(this);
                }
            }
    
            @Override
            public void propertyChange(PropertyChangeEvent evt) {
                if (evt.getSource() == manager) {
                    // OK, not the cleanest thing, just to get the gist of it.
                    if (evt.getPropertyName().equals("objects")) {
                        ((MyObject) evt.getNewValue()).getPropertyChangeSupport().addPropertyChangeListener(this);
                    }
                    fireTableDataChanged();
                } else if (evt.getSource() instanceof MyObject) {
                    int index = manager.getObjects().indexOf(evt.getSource());
                    fireTableRowsUpdated(index, index);
                }
            }
    
            @Override
            public int getColumnCount() {
                return 2;
            }
    
            @Override
            public int getRowCount() {
                return manager.getObjects().size();
            }
    
            public MyObject getValueAt(int row) {
                return manager.getObjects().get(row);
            }
    
            @Override
            public Object getValueAt(int rowIndex, int columnIndex) {
                switch (columnIndex) {
                case 0:
                    return getValueAt(rowIndex).getValue();
                case 1:
                    return getValueAt(rowIndex).isSelected();
                }
                return null;
            }
    
            @Override
            public void setValueAt(Object value, int rowIndex, int columnIndex) {
                if (columnIndex == 1) {
                    getValueAt(rowIndex).setSelected(Boolean.TRUE.equals(value));
                }
            }
    
            @Override
            public boolean isCellEditable(int rowIndex, int columnIndex) {
                return columnIndex == 1;
            }
    
            @Override
            public Class<?> getColumnClass(int column) {
                switch (column) {
                case 0:
                    return String.class;
                case 1:
                    return Boolean.class;
                }
                return Object.class;
            }
    
            @Override
            public String getColumnName(int column) {
                switch (column) {
                case 0:
                    return "Value";
                case 1:
                    return "Selected";
                }
                return null;
            }
    
        }
    
        public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException,
                UnsupportedLookAndFeelException {
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
            SwingUtilities.invokeLater(new Runnable() {
    
                @Override
                public void run() {
                    new TestTable().initUI();
                }
            });
        }
    
    }

[Paul Clapham]

Welcome to the Ranch, shri!

You know the part of the code where you added those 20 rows to the table? Add a bit more code to add that extra row.

[Campbell Ritchie]

Welcome again
Moving discussion because it will fit better in our GUIs forum.

[shri hari]

Hello Campbell Ritchie,
Do you want me to move the thread to GUI forums?

[shri hari]

Sorry for the quoting the post. I am newbie to ranch and wanted to edit the post, accidentally quoted it.

[Campbell Ritchie]

I often make that sort of mistake myself, so don't worry about it. Goodbye unnecessary post. I have moved the thread; the forum name is no longer shown as Beginning Java.
You can't edit posts: please post a new post with the changes in. You probably don't need to quote the whole of old posts.

[shri hari]

Thanks Campbell Ritchie.

[Campbell Ritchie]

That's a pleasure

Did you work out how to add “None of the above”? Presumably you would want a radio button with no action/option attached.
How are you going from radio buttons to options? Are you iterating an array of buttons? I am not convinced that would be an elegant solution; I can think of various other possible implementations.

[shri hari]

I am still working on it. I do not have any concrete implementation for "none of the above" as of now. I would consider your latest reply and think on it's lines.

[Campbell Ritchie]

Iterating an array would be a procedural programming solution. The object‑oriented solution would be to associate some sort of object representing the option with the button. The Listener associated with the button can activate the option, or put it in some situation where it will be executed next.

I think that is enough of hints: show us when you have got something working.