Now lets take a look at how the CustomJTable code looks like. In order to allow external controllers to specify which column of the JTable will render itself as JRadioButtons, we have a method called setRadioGroup. We also declare the custom Table Model which hides our internal structure and works the Model magic of Swing by extending AbstractTableModel.
|
|
RadioColumnEditor:
import java.awt.Color;
import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.EventObject;
import javax.swing.JRadioButton;
import javax.swing.JTable;
import javax.swing.SwingConstants;
import javax.swing.event.CellEditorListener;
import javax.swing.event.ChangeEvent;
import javax.swing.event.EventListenerList;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableModel;
public class RadioColumnCellEditor implements
ActionListener, TableCellEditor {
Color currentColor;
JRadioButton button;
boolean state;
public RadioColumnCellEditor() {
super();
button = new JRadioButton();
button.setOpaque(false);
button.setBackground(Color.WHITE);
button.addActionListener(this);
}
protected EventListenerList listenerList =
new EventListenerList();
protected Object value;
protected ChangeEvent changeEvent = null;
protected int clickCountToStart = 1;
public void setCellEditorValue(Object value) {
this.value = value;
}
/**
* Add a listener to the list that's notified when
* the editor starts, stops, or cancels editing.
*/
public void addCellEditorListener(
CellEditorListener l) {
listenerList.add(CellEditorListener.class, l);
}
/**
* Remove a listener from the list that's notified
*/
public void removeCellEditorListener(
CellEditorListener l) {
listenerList.remove(CellEditorListener.class,
l);
}
protected void fireEditingStopped() {
Object[] listeners =
listenerList.getListenerList();
for (int i = listeners.length - 2; i >= 0; i -=
2) {
if (listeners[i] == CellEditorListener.class) {
if (changeEvent == null)
changeEvent =
new ChangeEvent(this);
((CellEditorListener) listeners[i + 1])
.editingStopped(changeEvent);
}
}
}
protected void fireEditingCanceled() {
Object[] listeners =
listenerList.getListenerList();
for (int i = listeners.length - 2; i >= 0; i -=
2) {
if (listeners[i] == CellEditorListener.class) {
if (changeEvent == null)
changeEvent =
new ChangeEvent(this);
((CellEditorListener) listeners[i + 1])
.editingCanceled(changeEvent);
}
}
}
public void actionPerformed(ActionEvent event) {
fireEditingStopped();
}
// Implement the one CellEditor method that
// AbstractCellEditor doesn't.
public Object getCellEditorValue() {
return new Boolean(button.isSelected());
}
// Implement the one method defined by
// TableCellEditor.
public Component getTableCellEditorComponent(
JTable table, Object value,
boolean isSelected, int row, int column) {
if (!value.getClass().getName().equals(
Boolean.class.getName())) {
return null;
}
button.setSelected(value != null
&& value.getClass().getName().equals(
Boolean.class.getName())
&& ((Boolean) value).booleanValue());
TableModel model = table.getModel();
// Make all the radioButtons, except the
// selected
// TRUE
for (int i = 0; i < model.getRowCount(); i++) {
if (model.getValueAt(i, column) != null
&& model
.getValueAt(i, column)
.getClass()
.getName()
.equals(
Boolean.class
.getName())) {
model.setValueAt(Boolean.FALSE, i,
column);
}
}
model.setValueAt(Boolean.TRUE, row, column);
button
.setHorizontalAlignment(
SwingConstants.CENTER);
return button;
}
public boolean stopCellEditing() {
fireEditingStopped();
return true;
}
public void cancelCellEditing() {
fireEditingCanceled();
}
public boolean shouldSelectCell(EventObject eo) {
return true;
}
public boolean isCellEditable(EventObject eo) {
return true;
}
}
JTable provides the ability for individual columns to have different renderers and editors. This is very powerful functionality because you can have a Radio Button in one of the columns or a JButton or JComboBox in some columns.
I went ahead a wrote a small JTable Component that displays a Radio Button in one of its columns. I also customized the component to display the radio button only for specific rows in the column and also added functionality to behave as a radio button group!
The JTable that I wrote has the ability for some external controller to specify
which rows of a particular column must render its value as RadioButtons.
I achieved this by writing an interface with a single method which provided
any renderer with the ability to check if the current row, column can be
rendered by itself.
/** |
I also wrote a TableCellRenderer and TableCellEditor for the RadioButton Column. Here the code for Both.
RadioColumnRenderer:
import java.awt.Color; |
The basic idea of inheritance in the Object Oriented Paradigm is based on "is-a" kind of relationship. Any violation of this violates OO.
Its very interesting to note that, in Sun's java SDK, we have java.util.Properties extending from java.util.Hashtable. That actually sent me guessing.
If Properties was a class that will handle only string key-value pairs, what was the necessity to extend from Hashtable which supports key - Object pairs? I believe the ugly inheritance-composition confusion had forced one of Sun's engineers to make such a choice.
The store method of Properties tries to cast all values to String :P!
Properties doesnt even stop you from using Hashtables methods of put and get!
Well the actual way to have implemented properties must have been to use a Hashtable inside properties (Composition) and then expose whatever methods that you want to.
I am searching for other examples within the SDK where such a blunder still exists :)
The other day somebody asked a question about exception handling in java. The question was this:
When we override a method in java which throws an exception, why is that we cannot change the exception that the parent class throws?
Well, I set to find out what are the possible scenarios that can occur when we throw different exceptions when overriding methods.
The first case I encounted was when I had a class BaseClass which had a method called testException() throws IOException. When I override this method from a class InheritedClass with a declaration like testException() throws ArrayIndexOutOfBoundsException, the compiler did not complain. I later realised that AIOOBE is a runtime exception so behavior was right.
The second case was when I declared the overriding method to throw an exception of type which happened to be a subclass of the parent exception class. So if I declare testException() throws FileNotFoundException, with the parent class method throwing IOException the compiler behavior was as I expected. Because the subclass can always be auto casted, it did not complain.
The third case was if we try the opposite of the second case. i.r BaseClass - testException() throws FileNotFoundException and the subclass InheritedClass declares, testException() throws IOException. As expected the compiler immedtiately complained of incompatibility between the declarations from the base class to the inherited class.
The fourth case was if I try and throw a totally unrelated exception in the overriding methods throws clause, like BaseClass testException() throws IOException and InheritedClass declares testException() throws SQLException, the compiler again complained of incompatibility.
Summing up:
Case 1: Overriding method throws runtime exception - Allowed
Case 2:Overriding method throws subclass of the exception type declared by the parent method - Allowed
Case 3: Overriding method throws base class of exception type declared by the parent method - NOT Allowed
Case 4: Overriding method throws totally unrelated compile time exception replacing parent method throws clause - NOT Allowed
Basically I realised that it really did not make sense for an overriding method to throw any other class of exception than what the method in the parent class threw. Java ofcourse allows you the possiblity to add exceptions in overriding methods.
Wanting to access the transaction log, I found that dbcc is a god way to do it via the SQL Query Analyzer. However, programatically via jdbc, I was curious whether the same command will work returning a result set. It turned out to be nothing to access the transaction log using dbcc and the MSSQLServer's jdbc driver. I added three jar files in the classpath: msbase.jar, mssqlserver.jar, msutil.jar and started writing the program :
import java.sql.Connection; |
Add to Del.icio.us
