MyFunnyDev

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

• Certified-Associate-Study-Guide
• http://www.amazon.com/gp/product/1598729039/ref=cm_cr_asin_lnk
• j2ee 1.4 tutorial

Mocks:

• http://www.scja.de/
• http://www.ejavaguru.com/scjafreemockexam.php
• http://www.cafe4java.com/mockexams/scja/mock1/q1.php
• http://studyguides.scja.com/ExamScam/get.jsp?link=mockexams
• sun sample questions

UML

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

SCJP

Tutorials/Books

• SCJP Sun Certified Programmer

Peppy is a small and very fast css3 selector written by James Donaghue. Here is how you can use it:

var selector = "div";
var context = "#elementId";
var q = peppy.query(selector, context);

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());
 
	}
}

What can be annotated?

• package
• class ( including interface, enum)
• method
• field
• local variable, formal parameter (compile time only)

Really nice ‘introduction’ to properties pattern by Steve Yegge

Nice presentation about JavaScript closures posted by Stuart Langridge

http://code.google.com/p/protobuf/

really exciting news: http://www.google.com/chrome

http://code.google.com/p/google-guice/

http://examples.adobe.com/flex3/componentexplorer/explorer.html