Question

I ran into some Java code at work today :

public interface A {

    public static interface AObj {
         String toXml();
         int getCode();
    }

    public static interface AMap {
         String toXml();
         int blah();
    }
    ...
}

I have not encountered having static interfaces embedded in an existing interface before. It doesn’t make much sense. Can someone comment on :

a) Is this good design practice
b) What the benefits are to this vs Having individual interface files.
c) This was written by a c++ programmer, i get the impression they’re trying to re-create namespaces. If that’s the case, why not just use packages ?

Any comments most welcome.

Regards,
Alistair.

Answer 1

Good/bad practice can be debatable. Typically one would nest interfaces if the nested interface is an inseparable entity in relation to its parent.

Take a look at the source code of java.util.Map. It merrily embeds Map.Entry inside it. The author is Josh Bloch, who is definitely not an inexperienced Java developer. So I’m sure there must be a valid reasoning behind designing the interface that way.

Here is what it looks like (JavaDoc and comments stripped).

public interface Map<K,V> {
    int size();
    boolean isEmpty();
    boolean containsKey(Object key);
    boolean containsValue(Object value);
    V get(Object key);
    V put(K key, V value);
    V remove(Object key);
    void putAll(Map<? extends K, ? extends V> m);
    void clear();
    Set<K> keySet();
    Collection<V> values();
    Set<Map.Entry<K, V>> entrySet();

    interface Entry<K,V> {
        K getKey();
        V getValue();
        V setValue(V value);
        boolean equals(Object o);
        int hashCode();
    }

    boolean equals(Object o);
    int hashCode();
}