Java - MyFunnyDev

Google engine support for java

7/04/2009

Looks like google engine will support java. Pretty exciting

SCJA and SCJP

6/11/2008

I’m planning to pass SCJA and SCJP at the end of this year. I will post all the mocks and materials which I find helpful. Here is the first list:

SCJA

Tutorials/Books

Mocks:

UML

http://www.scribd.com/doc/2584053/Pengenalan-UML

SCJP

Tutorials/Books

SCJP Sun Certified Programmer

No Comments

Define your own Annotation Type

24/10/2008

I’ve been using build-in Java annotation types (like @Overrides or @Deprecated) and those created by different vendors/services for a while now but I’ve never built my own. Here is an example of how you can define very simple annotation type and use it:

 
import java.lang.annotation.Retention;
 
public @interface SimpleMessageAnnotation {
     public String message();
}

As you can see a declaration of the new annotation type is very similar to the Java interface declaration (add ‘@’ symbol in front of the interface) There are some additional rules you have to follow:

Method declarations should not have any parameters
Method declarations should not have any throws clauses
Return types of the method should be one of the following:
primitives, String, Class, enum, array of the above types

In order to annotate a class with the new type you can write:

 
@SimpleMessageAnnotation(message = "hello world!!!")
public class TestAnnotation {
 
}

Now in order to access the message value during the runtime we can use reflection API. Before we can do that we need to change the RetentionPolicy of our new annotation type to RUNTIME. We can do it by adding Retention annotation to our SimpleMessageAnnotation:

 
import java.lang.annotation.Retention;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
@Retention(RUNTIME)
public @interface SimpleMessageAnnotation {
     public String message();
}

This will inform the compiler about the new policy. There are 3 policies which can be used by the compiler (default is CLASS):

SOURCE—Annotations are to be discarded by the compiler.
CLASS—Annotations are to be recorded in the class file by the compiler but need not be retained by the VM at runtime. This is the default behavior.
RUNTIME—Annotations are to be recorded in the class file by the compiler and retained by the VM at runtime, so they may be read reflectively.

Now by using reflection API we can access our message value like this:

public class Run {
 
	public static void main(String[] args) {
 
		Class<TestAnnotation> clazz = TestAnnotation.class;
		System.out.println(clazz.getAnnotation(SimpleMessageAnnotation.class).message());
 
	}
}