To have Eclipse use a particular Java VM :

Edit the eclipse.ini file and add the vm argument below the line org.eclipse.platform

-vm /absolute/path/to/your/java/executable

I’ve found this particularly useful on Windows when I’ve installed and removed various versions of JDK and eclipse appears completely lost and confused.

Run time polymorphism vs. Compile time polymorphism

Overriding is polymorphism. Obvious enough. But how the heck is Overloading polymorphism? Which Overloaded method is called isn’t decided at runtime, that is already determined at compile time.  So is Overloading polymorphism simply because, although the signatures vary all over the place, the method name is the same?

Abstract classes vs. Interfaces:

When would one prefer to use an interface/abstract class?

Abstract class:

1. When the focus is on something an entity HAS
2. When an attribute is a common factor. E.g.: A Unicorn, a Cow, and a Triceratops are all of type Animal. They all also share the attribute Horns. A good place for inheriting from an abstract class.

Interface:

Of course, an interface is just a perfectly abstract class.

1. When the focus is on something an entity DOES
2. When the only common factor is behaviour and not attributes. E.g.: A bird flies. Ditto a Plane, Time and $hit. Nevertheless, Bird, Plane, Crap and Time classes can hardly inherit from a common abstract parent. However they can all implement the Flyable interface.

Procedural vs. OO programming:

Procedural:

1. Separation of data from operations. The idea is that data is passed with the expectation that the program at the receiving end knows what to do with the data.
2. Code is placed in procedures that manipulate the data. Procedures are mostly black boxes – input goes in, out comes output.
3. Procedural logic is splattered with if-then-else conditional statements.

Object oriented:

1. Encapsulation. Objects have attributes and behaviour.
2. Object has behaviour and thus knows what to do with its data.
3. OO depends more on polymorphism than on conditional statements. (If your OO principles aren’t good, you’ll end up writing OO code that looks like procedural, with monolithic if-then-else statements. Been there, done that. )

Is Java pure OO? Not exactly, since primitives are not implemented as objects. Smalltalk for example, is purely OO.

• Abstraction:

- Extract all the common attributes and behaviour for a given set of classes and move them one level up and that will be your first level of abstraction.

- And so on.

• Polymorphism:

Means different shapes. Yes, we have all heard that one before. We’ve also seen the example of Circle, Triangle and Square inheriting from Shape and overriding the draw() method often enough. However it all became quite clear to me only when I saw it like this:

A Triangle inherits from Shape and implements Drawable.

Triangle figure = new Triangle();
Object obj = figure;
Shape shape = figure;
Drawable drawable = figure;

Now notice that the same darned object, figure, can behave as a Shape, a Triangle, an Object or even a Drawable, all depending on the type of the reference variable. Impressive, huh?

(Also see: runtime and compile time polymorphism)

• Inheritance:

- This one is quite simple. An IS-A relationship.

- Inherit non-private attributes and methods of a super class

• Encapsulation:

- Grouping together of common functionality.

- Hiding of internal algorithms. Car.moveForward() will move the car forward. How the car implements moving forward is nobody else’s darned business.

- Only revealing the interfaces required to interact with it.

- Data protection, usually through getters and setters that will prevent data corruption.

- Prudent encapsulation = robust design = easy refactoring.

• Composition:

- HAS-A relationship. Objects built or composed from other objects. Simple concept but with profound design implications.

A long time ago, I’d come across (in Reader’s Digest, I think) these :

Two atoms are sitting at a bar. One is looking really downcast.
“I think I have lost an electron”.
“Are you sure?”
“I’m positive.”

A neutron walks into a bar, asks for a stiff one, swigs it down in one gulp and asks the bartender “How much?”
Bartender: “For you, no charge.”

And I remember thinking to myself “How incredibly clever!”

Now, I’m a programmer and hang out with similarly feathered birds most of the time but I had yet to come across arcane quips from within the developer community.

No, Dilbert doesn’t really qualify. I’m thinking something absolutely nerdy and demanding knowledge of esoteric programming principles.

And then one day, at a seminar someone mentioned this cartoon he’d read:

C++ programmer to Java programmer, looking around the latter’s messy apartment: “This is what happens when you don’t clear out your own garbage.”

Suddenly, I’m encouraged. I’ll be looking out. Watch this space.