A member interface is implicitly static

[Soni Prasad]

"A member interface is implicitly static"

Can anybody give me some logical reasoning for this statement so that I can understand.

[Vishnu Prakash]

"A member interface is implicitly static"

I don't think this is correct.

You can say "A member interface is implicitly abstract"

This makes some sense. Because method declarations in interfaces are by default Abstract.

Modifier "abstract" can be used for top level interface declaration. But such practices are strongly discouraged.

[Tony Morris]

A member is indeed implicitly static.
This just means that it is static without explicitly specifying the static modifier. Good form also mandates that you should never explicitly specify redundant modifiers (that apply to all type declarations (class, interface, annotation, enum) and their members, not just interfaces).

[Vishnu Prakash]

I misunderstood the question. Yes member variables in interface are static and final implicitly.

[Vishnu Prakash]

Constants in interface can be hidden by subinterfaces.

 
interface X {
   int a = 100;
 }
 
 interface Y extends X{
   int a = 1;
 }
 
class B implements Y {
   public static void main(String[] args) {
System.out.println(a);
System.out.println(X.a);
   }
}
 

In the case of multiple inheritance of interface constants, any name conflicts can be resolved using fully qualified names in the constants involved.

[Jeroen Wenting]

I too read it as meaning an interface which is a member of a class being implicitly static.

Something like

public class SomeClass {
  interface SomeInterface {
    void doSomething();
  }
  
  class AnotherClass implements SomeInterface {
    public void doSomething() {
       System.out.println("something");
    }
  }
 
  public void doSomething() {
    SomeInterface some = new AnotherClass();
    some.doSomething();
  }  
 
  public static void main(String[] args) {
    SomeClass some = new SomeClass();
    some.doSomething();
  }
}

Would the interface SomeInterface be static here?
If it were the following would work:

public class YetAnotherClass {
    public static void main(String[] args) {
        YetAnotherClass yetanotherclass = new YetAnotherClass();
        SomeClass.SomeInterface f = new SomeClass().new AnotherClass();
        f.doSomething();
    }
}

And somewhat to my surprise it indeed works, proving that member interfaces are implicitly static (in contrast to inner classes).

[Vishnu Prakash]

I think it would be appropriate to call the variables in a interface as constants rather than member variables.

https://coderanch.com/t/245071/java-programmer-SCJP/certification/Non-final-member-variables-interfaces

and

https://coderanch.com/t/248449/java-programmer-SCJP/certification/final-static-int-Whizlabs-says

[Jim Yingst]

OK, to be clear - the original question was not about members inside an interface. It's about the interface itself, assuming it's nested inside another class or interface. A member interface is an interface that is a member of some other class or interface - and yes, member interfaces are implicitly static. (Mostly because there's no real use for a "this" reference inside an interface, so there's be no benefit to having a non-static interface.)

[Soni Prasad]

thanx Jim Yingst for clearifying my question.
thanx Jeroen Wenting for a good example.

[Tony Morris]

A member interface is implicitly static.

class X
{
    // implicitly static
    interface I
    {
 
    }
}

An interface member is not a constant - it is public static and final. This is not the same as a constant. A final is not synonymous with a constant.

[John Wolf]

Tony,

Could you expand on why

A final is not synonymous with a constant

Regards,
Sumit

[Jim Yingst]

Well, something like

public final StringBuffer text = new StringBuffer();

is clearly final, but it's not constant since anyone can change the contents of the StringBuffer at any time. The precise rules for what constitues a compile-time constant in Java are given in JLS 15.28.

[Tony Morris]

I'll do more than that, I'll give you an example:

When a final is not a constant
http://qa.jtiger.org/GetQAndA.action?qids=13

You should note that this kind of question will not be on your exam.

[Vishnu Prakash]

An interface member is not a constant - it is public static and final. This is not the same as a constant.

In Kathy Sierra & Bert Bates book it is given as(Page 115)

All variables defined in an interface must be coderanch, static and final - in other words interfaces can declare only constants and not instance variables.

Can u both confirm this.

Tony your example is phenomenal.

Jim the example which u had given helps to understand it is not necessary for a final variable to be constant all the time. But I want to know whether a interface variable which is implicitly final is a constant or not.

Jim if you can give simple examples for these statements it will of great help.

# Simple names that refer to final variables whose initializers are constant expressions
# Qualified names of the form TypeName . Identifier that refer to final variables whose initializers are constant expressions

[Tony Morris]

All variables defined in an interface must be coderanch, static and final - in other words interfaces can declare only constants and not instance variables.

Can u both confirm this.

I can confirm that this is incorrect.
Books are wrong all the time - they are not an eternal truth.

[Vishnu Prakash]

Jim please reply to this post.