Is there a good reason why you can or cannot have an inner interface within a Java class?

Question

Is there a good reason why you can or cannot have an inner interface within a Java class? (like you would an inner class). I couldn't find a definitive answer with Google, but it appears as though you can't embed an interface the same way you would with an inner class. My guess is that the Java creators didn't see a great reason to make it possible, and so it isn't but maybe there are really good reasons?

for example I can't get this to compile (it's all one big class)

package buttonGetSourceObject;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class ClassWithButton implements ActionListener, ButtonOwner{

    private String objectName = "";

    public ClassWithButton(String string) {
        objectName = string;
        JFrame f = new JFrame();
        JPanel p = new JPanel();
        MyJButton b = new MyJButton(this,"Press This Button for Name of Owner of Button");
        b.addActionListener(this);
        f.add(p);
        p.add(b);
            f.pack();
        f.setVisible(true);


    }

    public static void main(String[] args){
        ClassWithButton c = new ClassWithButton("object1name");
    }

    @Override
    public void actionPerformed(ActionEvent arg0) {
        ((ButtonOwner)((MyJButton)arg0.getSource()).getOwner()).printInstanceName();

    }


    public interface ButtonOwner {
        public void printInstanceName();
    }


    private class MyJButton extends JButton {

        /**
         * 
         */
        private static final long serialVersionUID = 1L;
        Object owner = null;

        public Object getOwner() {
            return owner;
        }

        public void setOwner(Object owner) {
            this.owner = owner;
        }

        public MyJButton(Object o, String string){
            owner = o;
            this.setText(string);
        }
    }


   @Override
    public void printInstanceName() {

        System.out.println(this);

    }

    public String getObjectName() {
        return objectName;
    }

    public void setObjectName(String objectName) {
        this.objectName = objectName;
    }

    public String toString(){
        return this.getObjectName();
    }

} //end

the compiler doesn't seem to recognize the inner Interface "ButtonOwner" as existing at all

Answer 1

Because it's an inner class, you must use the full name of the class that you're extending (e.g. use ClassWithButton.ButtonOwner instead of just ButtonOwner):

public class ClassWithButton implements ActionListener, ClassWithButton.ButtonOwner

This won't work however, as you're extending an inner interface:

Cycle detected: the type ClassWithButton cannot extend/implement itself or one of its own member types

As to why a class cannot implement an inner interface, a comment on the above question indicates that it could be because:

how class loading works. Normal references to other classes are loaded lazily, but outer classes, superclasses and implemented interfaces are loaded automatically before the class itself is loaded. When your outer class implements an inner interface and that construct would have been valid, you'd get a StackOverflowError in the class loader when loading the class at runtime...

Answer 2

Here is a definitive answer: JLS Chapter 9:

"A nested interface is any interface whose declaration occurs within the body of another class or interface."

"A top level interface is an interface that is not a nested interface."

And the syntax is in Chapter 18:

ClassBody: 
    { { ClassBodyDeclaration } }

ClassBodyDeclaration:
    ; 
    {Modifier} MemberDecl
    [static] Block

MemberDecl:
    ...
    InterfaceDeclaration

---

The reason that your code won't compile is that you are trying to make the outer class a subtype of an nested interface of itself. (I cannot find the JLS section that forbids this, but the compiler error message makes it clear that this is forbidden.)

---

I'm not sure about "why" they decided to forbid a class extending an inner class or interface of itself. It could simply be that they thought that the specification and implementation effort involved out-weighed the utility of allowing it.

(The explanation that it is to prevent a StackOverflowError during class loading doesn't hold water:

• Nested classes are actually compiled to free-standing ".class" files.
• The JLS does not specify the order in which classes are loaded. (Initialization is another matter.
• Resolution of the linkages between classes (including links to superclasses) actually happens after the classes have been loaded ... according to the JLS.
• In fact, you can "achieve" this kind of problem anyway (e.g. by messing around with the ".class" files to create loop in the inheritance graph) ... and the verifier will detect it before it does any harm.)