Private / Protected Interface

[Steven Wong]

Hi all,
Can someone show me how a private / protected interface is coded?
I got the below from JLS but am still in doubt.
The access modifiers protected and private pertain only to member interfaces within a directly enclosing class declaration (�8.5) and are discussed in �8.5.1.
Thanks in advance.

[Rob Ross]

What this means is that you can't make top-level interfaces private or protected:
This won't compile:

private   interface Foo{  }
protected interface Bar{ }

But within a class, they're ok:

public class Enclosing{
private   interface Foo{  }
protected interface Bar{ }
}

External classes wishing to use the interfaces defined in Enclosing are bound by the access modifiers for each. For example, no methods outside of class Enclosing can use interface Foo, since it's private.
But, a subclass of Bar, or a class in the same package as Bar, could use this interface by qualifying it with it's Enclosing class:
public class Outside implements Enclosing.Bar {}

[Steven Wong]

Thanks Rob. But is there any use of defining interfaces in a class?

[Rob Ross]

Sure there is! It really depends on the problem you're trying to solve.
One of the keys of OO design is encapuslation. That pertains to organizing your types and namespace as well as data. If a class or set of classes need a certain definition, like an interface, but the interface isn't generally useful outside that class, or you want the class to tightly control use of the interface, then defining the interface inside the "main" class that uses it may be a good design decision.
It really depends on the nature of your particular design problem. It's good to understand how this mechanism works so you can take advantage of it when the need arises.

[Axl Rose]

Rob,
according to the JSL

[Axl Rose]

Rob,
according to the JSL 8.1.2
interfaces are never inner.
can you explain

[Rob Ross]

Nested interfaces are implicitly static; unlike a nested class, which can be static or not, interfaces can ONLY be static when declared inside another class/interface.
This makes sense, since an interface only describes an API, it provides no implementation. Since you would never be able to instantiate an interface, it would make no sense to allow an "inner" interface.

[Corey McGlone]

Axl,
An interface which is defined within a class is called a "Nested, top-level interface." The only time we use the word "inner" is when we're talking about non-static classes defined within another class - those are called "inner classes."
Hope that helps,
Corey

[Steven Wong]

Rob,
You mentioned that "Nested interfaces are implicitly static; unlike a nested class, which can be static or not, interfaces can ONLY be static when declared inside another class/interface."
As what I know, interfaces are implicitly abstract. How can the interface be static when it's abstract? Abstract and static don't go together, am I right?
Choi Nang