Why embed class in interface??

[Bill Nelsen]

From a higher-level OO viewpoint, why did the Java language designers decide to allow a class to be contained within an interface?? what purpose does it serve??

interface A {
class B {
void D() { System.out.println("interface A - D"); }
void E() { System.out.println("interface A - E"); }
}
}

To me, it just seems like a corruption of the design of the interface. I am curious if I am missing something or if it is like the tail appendage in the human body.

[Peter den Haan]

Although I've not come across a good use case yet for a (named) class inside an interface, I do occasionally use an anonymous class to provide a null implementation:

interface Foo {
   /** Null implementation of Foo (null object pattern). */
   NULL = new Foo() {
      public String foo() { return null; }
   };
   /** Does something exciting. */
   String foo();
}

Client code will often use this as a default value for a Foo:

public class Bar {
   private Foo foo = Foo.NULL; // default no-op implementation
   // ... bar methods follow ...
   /** Sets a new Foo implementation. */
   public void setFoo(Foo foo) {
      this.foo = foo;
   }
}

Using this null object pattern where you would otherwise use the null value tends to simplify your code, and also make it less prone to bugs (especially NullPointerExceptions if you forgot to stick in a null check somewhere).

- Peter

[Scott Sinclair]

Oooh, What a great answer!, I'll be sure to use that myself.

[Jim Yingst]

I think that the general approach in Java for nested/inner types has been, they allow you to declare a class just about anywhere you could declare a variable, unless there's a particular reason you shouldn't be able to. They don't prevent you from doing it just because there's no particular positive reason to allow the usage. So nesting a class in an interface is allowed - why not? - even though it seems to be seldom useful.

One possible use for a nested class here is to define a new Exception type which is closely related to the interface, and generally useless to anyone not using hte interface. E.g.:

interface FooFinder {
    Foo findFoo(int id) throws BadFooException;
 
    class BadFooException extends Exception {
        public BadFooException(String message) { super(message); }
    }
}

[Murtuza Akhtari]

If you do have a class nested within an interface, it will be abstract since all interface members are implicitly abstract.

Keeping that in mind, the nested class will have to be sub-classed. So if a concrete class implements the said interface....will it automatically extend tha nested class???

or how does it work??

[Susanta Chatterjee]

Hi Murtuza,

If you do have a class nested within an interface, it will be abstract since all interface members are implicitly abstract.

A class defined inside the Interface is not a member method of the class. The statement is true only for interface methods, not for any declaration or interface fields (for e.g. interface fields are not abstract).

Here is an example:

  
interface A {
class OneNestedClass {
void foo() 
{
System.out.println("foo in OneNestedClass of interface A.") ;
}

void moo(){
System.out.println("moo in OneNestedClass of interface A.") ;
}
} ;
OneNestedClass oneObject =
new OneNestedClass() ;
} ;
 

class NestedClassInsideInterfaceTest implements A {

public static void main(String [] args) {
A.oneObject.foo() ;
A.oneObject.moo() ;
}
}
 

You could call the methods as

  
   oneObject.foo() ;
   oneObject.moo() ;

too.

How you use this feature at your work, depends on the design of the system.

[Peter den Haan]

Originally posted by Murtuza Akhtari:
If you do have a class nested within an interface, it will be abstract since all interface members are implicitly abstract.

Then how do you explain away the Foo.NULL example I gave above?

- Peter