Felipe Leme's Blog

J2SE Archives

Final? Not yet...

semifinal class SuperClass {
   protected void m1() { 
   }
   protected void m2() { 
   }
   public void m3() {
   }
}

class SubClass extends SuperClass { 

   // declaration below is valid: same access level (protected)
   protected void m1() { 
   }

   // declaration below is not valid: more accessible (public)
   public void m2() { 
   }

   // declaration below is valid: overriding public method
   public void m3() { 
   }

   // declaration below is valid: new method, but private
   private void myMethod() { 
   }

   // declaration below is not valid: new public method
   public void myExtendedMethod() { 
   }
} 

semifinal MyObject o = getMyObject();
if ( o == null ) {
  o = new MyObject();
}
// from this point on, o is final and cannot be changed

final MyObject tmpObject = getMyObject(); // dirty hack
final MyObject o = tmpObject != null ? tmpObject : new MyObject();

MyObject o = getMyObject();
if ( o == null ) {
  o = new MyObject();
}
// o can be changed, as it is not final

semifinal MyObject o = null;
try {
   o = getMyObject(); // getMyObject() throws NastyException, which is checked
   // from this point on, o is final and cannot be changed
} catch( NastyException e ) {
  throw new NastyRuntimeException( "o is a nasty reference. No dessert for it!", e ); 
}
// we must use o from this point on, but it should not be changed

MyObject tmpObject = null;
try {
   tmpObject = getMyObject(); // getMyObject() throws NastyException, which is checked
   // from this point on, o is final and cannot be changed
} catch( NastyException e ) {
  throw new NastyRuntimeException( "o is a nasty reference. No dessert for it!", e ); 
}
final MyObject o = tmpObject;

MyObject o = null;
try {
   o = getMyObject(); // getMyObject() throws NastyException, which is checked
   // from this point on, o is final and cannot be changed
} catch( NastyException e ) {
  throw new NastyRuntimeException( "o is a nasty reference. No desert for it!", e ); 
}
// we must use o from this point on, but it can be changed as it is not final

protected abstract semifinal void doIt();

Who let the bugs out?

package net.felipeal;

import java.util.ArrayList;

public abstract class DAO<EntityInterface, EntityImpl extends EntityInterface> {
  
  private final Class<EntityImpl> entityClass;
  
  public DAO( final Class<EntityImpl> clazz ) {
    this.entityClass = clazz;
  }

  public List<EntityInterface> getEntities() {
    return getObjects(this.entityClass);
   }

  public <TInterface, TImpl extends TInterface> List<TInterface> getObjects(Class<TImpl> clazz) {
    return new ArrayList<TInterface>();
  }

}

package net.felipeal;

import java.util.List;

public class ProductDAO extends DAO<Product, ProductImpl> {

  public ProductDAO {
    super(ProductImpl.class);
  }
  
  public static void main(String[] args) {
    final ProductDAO dao = new ProductDAO();
    final List<Product> products = dao.getEntities();
    final List<Customer> customers = dao.getObjects(CustomerImpl.class);
  }

}

[felipeal@localhost src]$ javac net/felipeal/DAO.java
net/felipeal/DAO.java:15: incompatible types
found   : java.util.List
required: java.util.List
    return getObjects(this.entityClass);
                     ^
1 error

package net.felipeal;

import java.util.ArrayList;
import java.util.List;

public class DAO<EntityInterface, EntityImpl extends EntityInterface> {
  
  private final Class<EntityImpl> entityClass;
  
  public DAO( final Class<EntityImpl> clazz ) {
    this.entityClass = clazz;
  }

  public List<EntityInterface> getEntities() {
    final List<EntityInterface> list =  getObjects(this.entityClass);
    return list;
   }

  public <TInterface> List<TInterface> getObjects(Class<? extends TInterface> clazz) {
    return new ArrayList<TInterface>();
  }

}

Type mismatch: cannot convert from List to List  bug-generics/src/net/felipeal DAOB.java line 15

Maven 1.0 released

JDK 1.4.2_02 released

It's time to move on

Running ant in loop mode

Once in a while I work in a Java project where I need to run a simple Ant task many times in a short period of time. Like web projects where the JSP files are located in a directory under source control and are deployed in another directory by an Ant task. If I change a JSP file, I need to run Ant again, and it takes an eternity (about 5-6 seconds), due to the overhead of running the JVM, reading the XML files, etc...

Wouldn't it be nice if I could leave Ant running in a loop mode in those situations, so when I change the file I could redeploy it without that overhead?

For me, the answer is "Yes, that would be nice". But Ant doesn't have that feature, so now what? Now I can change Ant to include that feature, and that is the beauty of open source projects: if you want a new feature, you can just grab the code and implement it yourself. The same with bugs: rather than wait for the vendor to fix, test and publish a patch, you can open the code and nail the bug!

Now back to that new Ant feature: I created such patch and opened a bug for it.

This work is licensed under a Creative Commons License.