Question

So I have seen a lot of different coding styles, but I’m only going to talk about two big ones. I use a style where I just name everything like their class name when used in a general sense, like this:

String str = "This is some text";

But over at Java Practices, I see a style where they will put an ‘I’ in front of Interfaces class names, or they put ‘f’ or ‘a’ in front of object names. Take this snippet from “Don’t subclass JDialog or JFrame”‘:

/**
  Constructor.

  <P>Called when adding a new {@link Movie}.
*/
MovieView(JFrame aParent) {
    fEdit = Edit.ADD;
    buildGui(aParent, "Add Movie");
    fStandardDialog.display();
}

Why do programmers code in this style? Do a lot of people use it? And also, do professional programmers use this style?

Thanks in advance 🙂

Answer 1

This my personal opinion.

I prefer not to use prefixes on interface (or anything else for that matter). I just prefer to call it what it is. Interfaces are meant to represent an object (or part of it) without making any implication towards it’s actual implementation.

Say you have a Car interface. And AudiA4 could be an implementation of that car. If you just bought a new Audi A4, you say, “I bought a new AudiA4” to those you think care about the kind of car you bought. To others, you can say “I bought a new Car”. Certainly, you never say, I bought a new IAudiA4 or a new ICar.

The JFrame naming came about because it’s a Swing Frame and Swing came after AWT (the original Java windowing toolkit, which already had a Frame class). Since both AWT and Swing where available at the same time, they used the ‘J’ prefix to demarcate the toolkits (note that JFrame extends Frame, btw). They could have called it SwingFrame but the ‘J’ prefix was apparently a good choice to represent the Swing package. So basically this prefix is just a naming choice, not a convention similar to the ‘I’ for interfance (or Impl suffix for implementations you see sometimes as well)

My point is you always have to name your classes and interface according to exactly what they represent. No more, no less. No point having a CarImpl class. Who cares that it’s an implementation. Which implementation is it? Why does it need its own class? What more do I get when I use a CarImpl? What happens when I make a second implementation, I call it CarImpl2? All this is very constraining and doesn’t bring much value.

Call it what it is. That’s the only rule I’d set forth.

All this being said, the Eclipse project, amongst many others, does indeed use the I-for interface notation (WIKI). But it’s their choice. I’ve seen professionals use it as well. I don’t like it, but generally speaking, I respect the team’s naming convention.