« Simple and Pragmatic Thoughts » » Java

Single, Dynamic, Multiple and Double Dispatching

Isa Goksu — Mon, 07 Dec 2009 10:57:33 +0000

Today I was reading couple articles about programming languages and I noticed that there is still some confusion about dispatching. So I’ll try to explain as much as I can. Everbody is welcome to correct!

Creating Custom Annotations and Using Them

Isa Goksu — Wed, 07 Oct 2009 08:58:25 +0000

Okay, here is another topic that I couldn’t find much information in the Internet :) So I guess I’m gonna cover it quickly.

Naming the Java Implementation Classes

Isa Goksu — Sun, 19 Jul 2009 03:53:33 +0000

Today I was reading an answer to a question (http://bit.ly/FkgKB) about naming the implementation classes. People in these days are using Impl suffix to their implementation classes which implements a certain interface. For instance, if your interface name is Item, your implementation class name would be ItemImpl. Honestly I hate this bullshit naming convention. And I’ll forever blame the guy who invented such a crappy naming. Actually I first saw this naming convention in the IBM Developerworks articles. I guess it is some sort of IBM crap (I never got along with any of IBM related thing so far though). Anyways, let me tell you why it’s crappy:

Convert String to Enum

Isa Goksu — Tue, 19 May 2009 00:32:59 +0000

Last month we were coding some Groovy stuff and we needed to use Enum equivalents of couple Strings. We had couple dynamic Strings coming from off-shore developers, which defines the type of the entity. In our system, those types were represented by Enums. Anyways, basically we had to resolve the Enums from given Strings. After a little reading, we came up with following solution:

How to Avoid NullPointerExceptions (NPE)?

Isa Goksu — Mon, 04 May 2009 09:38:02 +0000

I’m sure every Java developer has had some hard times with NPEs (NullPointerException) since Java doesn’t really have a nice mechanism to avoid them :) Let’s recall something here: NPE is a run time exception and it occurs in the run time, therefore it means it is a design mistake, bad code quality or careless programming. Anyways, whatever the reason is, we all see NPEs all over our codes :) In this post, I want to cover this issue and give some tips from my experience so far.

Understanding Static Blocks

Isa Goksu — Mon, 16 Mar 2009 00:58:25 +0000

Before talking about Static Initializer, I wanna talk a little bit about what is this static thingy in Java. I hope this clarifies things a little bit :) Yes, we have couple limitations about static blocks: You shouldn't try to access super since there is no such a thing for static blocks You cannot use this keyword since there is no instance :) You cannot throw Checked Exceptions And please don't try to return anything from this block Please share your knowledge on this topic by adding new comments.

Varargs Collection Factory Method

Isa Goksu — Thu, 12 Feb 2009 03:28:27 +0000

If you read my double brace post, you might find it very handy. However, sometimes you might be warned by PMD or Checkstyle for this kind of usage. Because they don’t like this kind of usages. One way to fix this problem is putting either //no pmd or suppressing method for PMD.NonStaticInitializer.

Double Brace Initialization

Isa Goksu — Thu, 12 Feb 2009 02:50:19 +0000

Java doesn’t have a really nice way to initialize the collections. Because of this creating some constant collections, passing them to a method, or using them while unit-testing is kinda way too hard. For instance; you just need a 3 items in your list, but Java expects you to define in the following way:

What Is Hash Code

Isa Goksu — Tue, 03 Feb 2009 06:20:10 +0000

If you want to file something away for later retrieval, it can be faster if you file it numerically rather than by a long alphabetic key. A hashCode is a way of computing a small (32-bit) digest numeric key from a long String or even an arbitrary clump of bytes. The numeric key itself is meaningless and the hashCode functions for computing them can look a bit insane. However, when you go to look for something, you can do the same digest calculation on the long alphabetic key you are looking for, and no matter how bizarre an algorithm you used, you will calculate the same hashCode, and will be able to look up numerically with it. Of course there is always the possibility two different Strings will have the same digest hashCode. However, even then, all is not lost; it greatly narrows down the search, hence speeding it up. A Hashtable goes a step further, scrunching down the hashCode even further to an even smaller number that it can use to directly index an array, usually by dividing it by some (ideally prime) number and taking the remainder.

I saw this introduction in one of the site that I was surfing. The main idea of hashing was exactly this. In Java 1.0.x and 1.1, String.hashCode function was working by sampling every nth character. However, this was slowing down the Hashtable lookup. With Java 1.2, function has been improved to multiply the result by 31 then add the next character in sequence. This was much slower, but much secure to avoid the collisions. For Object.hashCode things were almost same. Then Sun came up with a much wider spec which 1.4 implementation made sense after.