Slashdot Mirror

was

public class Test {

 public static void main(String[] args) {

  System.out.println("Hello World");

 }
}
String[] columnNames = { "col1", "col2", "col3", "col4", "col5", "col6", "col7", "col8"};
Object[][] data = new Object[20000][8];
... (get the data into the 'data' array)
final JTable table = new JTable(data, columnNames);
table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
table.setAutoResizeMode(JTable.AUTO_RESIZE_SUBSEQUENT_COLUMNS);
table.getColumnModel().getColumn(0).setPreferredWidth(50);
table.getColumnModel().getColumn(1).setPreferredWidth(250);
table.setPreferredScrollableViewportSize(new Dimension(500, 300));
table.setMaximumSize(new Dimension(2000, 1200));
table.setMinimumSize(new Dimension(250, 150));
table.setFillsViewportHeight(true);
... (create a listener)
table.getSelectionModel().addListSelectionListener(tableSelectionListener);
JScrollPane scrollPane = new JScrollPane(table);

add scrollpane to your visible panel.
Done.
>Does Java still have checked exceptions in common use?

No, I'm sorry for you. The standard platform is moving away from them and is resorting to run time exceptions being mentioned in Java doc. E.g. an excerpt from the platform standard class EntityManager:

public interface EntityManager {
    /**
     * Make an entity instance managed and persistent.
     *
     * @param entity
     * @throws EntityExistsException        if the entity already exists.
     *                                      (The EntityExistsException may be thrown when the persist
     *                                      operation is invoked, or the EntityExistsException or
     *                                      another PersistenceException may be thrown at commit
     *                                      time.)
     * @throws IllegalStateException if this EntityManager has been closed.
     * @throws IllegalArgumentException     if not an entity
     * @throws TransactionRequiredException if invoked on a
     *                                      container-managed entity manager of type
     *                                      PersistenceContextType.TRANSACTION and there is
     *                                      no transaction.
     */
    public void persist(Object entity);

Problem is: You _can't_ do things right with Java's checked exceptions.

Suppose that I have a MyGenericAlgorithm that can be adapted to different things via interface MyGenericAbstraction { void apply(int parameter); }. Now, I need to implement that interface with something that may throw an SQLException. What's the right way to handle that?

I'll answer myself:

try {
  MyGenericAlgorithm.invoke(sqlExceptionThrowingThingy.getMyAbstraction());
} catch (SQLException e) { fail(); }

Try doing that in Java without useless glue code or polluting the interfaces with stuff that doesn't belong there. Generic exceptions would make it possible but that sounds even more silly than normal Java shit.
class Foo extends Bar
class Foo: Bar
Foo() { super(123); }
Foo(): base(123) { }
__block
The problem is that the entrySet() method is returning a
"Set<Map.Entry<capture-of ? extends K, capture-of ? extends V>>",
which is incompatible with the type "Set<Map.Entry<? extends K, ?
extends V>>". It's easier to describe why if I drop the "extends K"
and "extends V" part. So we have "Set<Map.Entry<?, ?>" and
"Set<Map.Entry<capture-of ?, capture-of ?>>".

The first one, "Set<Map.Entry<?, ?>>" is a set of Map.Entries of
different types - ie it is a heterogeneous collection. It could
contain a Map.Entry<Long, Date> and a Map.Entry<String, ResultSet>>
and any other pair of types, all in the same set.

On the other hand, "Set<Map.Entry<capture-of ?, capture-of ?>>" is a
homogenous collection of the same (albeit unknown) pair of types. Eg
it might be a Set<Map.Entry<Long, Date>>, so all of the entries in the
set MUST be Map.Entry<Long, Date>.
The java language isn't that important to develop any further.
It is the platform that matters and the platform will live on long after java the language goes into decline.

Currently the successor to java looks to be Scala.
http://www.scala-lang.org/

Scala compiles to java byte code, so standard java libraries will work just fine.
It is type safe (unlike ruby and groovy)
It performs about the same as java code

If you are a java developer, I will highly recommend getting "Programming Scala"

Slashdot Mirror

Java's Backup Plan If Oracle Fumbles

276 comments