Question: After reading [Should package names be singular or plural?](https://softwareengineering.stackexchange.com/q/75919/7167) it occurred to me that I've never seen a proper debate covering one of my pet peeves: naming implementations of interfaces. 

Let's assume that you have a interface `Order` that is intended to be implemented in a variety of ways but there is only the initial implementation when the project is first created. Do you go for `DefaultOrder` or `OrderImpl` or some other variant to avoid the false dichotomy? And what do you do when more implementations come along?

**And most important... why?**

Answer: 
I agree with Nicole's answer (particularly that the interface probably isn't necessary in most cases), but for the sake of discussion I'll throw out an additional alternative other than `OrderImpl` and `DefaultOrder`: hide the implementation behind a static factory method like `Orders.create()`. For example:

```
public final class Orders {
  public static Order create() {
    return new Order() {
      // Implementation goes here.
    };
  }
}

```

With this approach, the implementation could be an anonymous inner class, or it could be a private class with `Default` or `Impl` in the name, or it could be named something else entirely. Which ever choice is made, the caller doesn't need to care, so you get more flexibility now and later on when/if you decide to change it.

Some great examples of this pattern in practice are the `java.util.Collections` and `java.util.concurrent.Executors` utility classes, whose methods return hidden implementations. As Effective Java mentions (in Item 1), this pattern can help keep the "Conceptual weight" of the API smaller.
You can name interface with prefix I (IWhatever) and then make implementation Whatever.

Official Java code conventions don't tell about this kind of naming for interfaces, however this kind of naming helps recognition and navigation.