Question

Requirement: I’d like all implementations of an interface to have a well-defined name.

Initially, I thought:

interface Fruit {
    public String getName();
}

But this allows the user to have a field that is modified at run-time. I want to have an immutable name that is defined before compile/build time.

I’ve been toying with a couple of other ways to do it, but each has a limitation.

1) Give the name a type, which has slightly more control than free-form strings:

interface Fruit {
    public FruitName getName();
}

abstract class FruitName  {
    public final String NAME;
    public FruitName(name) {
        this.NAME = name;
    }
}

A user of this class will look like this:

class AppleFruitName extends FruitName {
    public AppleFruitName() {
        super("apple");
    }
}

class Apple implements Fruit {
    public FruitName getName() {
        return new AppleFruitName();
    }
}

2) Force an implementor of Fruit to annotate the name with something:

class Apple implements Fruit {
    @FruitName
    public static final NAME = "apple";
    ...    
}

Clearly this implementation is far cleaner than (1), but I’m not sure if this is possible in Java? How do you get compile/build to fail if @FruitName is not present?

Answer 1

An easy way to do this – without aop, compile time weaving, runtime annotations, scanning at runtime.. etc is to encapsulate this behaviour in an abstract class:

interface Fruit {
  public String getName();
}

abstract class FruitImpl  {
  private final String name;
  public FruitImpl(name) {
    this.name = name;
  }

  public final String getFruitName(){
    return name;
  }

}

So at construction time each implementation will be forced to pass in its name and it will not be able to alter it (unless the user is being intentionally malicious). This meets the what the wording of the question suggests.

There is a difference though because some the suggestions seem to assume that all implementations of the interface will have the same name – though the question doesn’t state that. Is the idea that these implementations will be singletons?

Alternatively, you could use the decorator pattern to wrap the implementation and retrieve the field value once and then always return that value later, like this:

class FruitWrapper implements Fruit{
  private final String name;
  public FruitWrapper(Fruit fruit) {
    this.name = fruit.getFruitName();
  }

  public final String getFruitName(){
    return name;
  }

}

So you can use it everywhere you would use fruit and it will guarantee to always get the same value.

This way you move the immutability into a class you control.