interfaces

[Sireesha Mullapudi]

Hi,

Can you please explain this code

interface I
{
     int i = 1, ii = Test112.out("ii", 2);
}
interface J extends I
{
     int j = Test112.out("j", 3), jj = Test112.out("jj", 4);
}
interface K extends J
{
     int k = Test112.out("k", 5);
}
class Test112
{
     public static void main(String[] args) {  System.out.println(K.j);  }
     public static int out(String s, int i)
     {
          System.out.println(s + "=" + i);
          return i;
     }
}    

I think,in interface the variables must be initialized at thier declaration.But here the code is containing method calls.And also iam not able to understand the output.

Please Help Me


Thanks,
Scjp1.4

[Joe Harry]

Hi Above,

Try to check your code. I guess you missed out the closing brabes for public static void main. I have modified the code as,

interface I
{
     int i = 1, ii = Main.out("ii", 2);
}
interface J extends I
{
     int j = Main.out("j", 3), jj = Main.out("jj", 4);
}
interface K extends J
{
     int k = Main.out("k", 5);
}
 
public class Main {
 
public static void main(String args[]){
{  
    System.out.println(K.j);
}
}
     public static int out(String s, int i)
     {
          System.out.println(s + "=" + i);
          return i;
     }
}

It gives me the O/P,


run-single:
j=3
jj=4
3
BUILD SUCCESSFUL (total time: 0 seconds)

I don't understand why it is not printing out the vakues for i and k from the out method???

Lakshmi as per your quote,

I think,in interface the variables must be initialized at thier declaration.But here the code is containing method calls

I also have the same doubt as in interface all variables are implicitly public static final. So in the above code, the call ii = Main.out("ii", 2) assigns ii the vakue of 2 only after the method returns the value. So why does this not produce any compile time errors??

Anyone please explain?

Regards,
Jothi Shankar Kumar. S

[Tilo Hemp]

Obviously, the fields of ancestors of an interface are only initialized when the corresponding interface they are declared in is accessed first (and not, how it would be expected for classes, when the child interface is loaded).

To make it clearer: when a static field of a class is first accessed, all ancestor classes are loaded recursively, including the initialization of the respective static fields.

On the other hand, when a (always static) field of an interface is first accessed, the fields of it's ancestors are not initialized. Only it's own fields are initialized.

The following code demonstrates this:

interface GrandpaInterface{
int i = InterfaceInheritance.init("GrandpaInterface.i");
}
 
interface ParentInterface extends GrandpaInterface{
int j = InterfaceInheritance.init("ParentInterface.j");
}
 
interface TheInterface extends ParentInterface{
int k = InterfaceInheritance.init("TheInterface.k");
int l = InterfaceInheritance.init("TheInterface.l");
}
 
class GrandpaClass{
static final int i = InterfaceInheritance.init("GrandpaClass.i");
}
 
class PaClass extends GrandpaClass{
static final int j = InterfaceInheritance.init("PaClass.j");
}
 
class TheClass extends PaClass{
static final int k = InterfaceInheritance.init("TheClass.k");
}
 

public class InterfaceInheritance {
 
static int x = 0; 

public static void main(String[] args) {

// first, the expected behaviour:
System.out.println(TheInterface.k); // also initializing l, but not the parent fields!
System.out.println(TheClass.k); // also initializing all static parent fields!

// test 1
x = 222;
System.out.println(TheInterface.j);

// test 2
System.out.println(TheInterface.i);
x = 333;
System.out.println(TheInterface.i); // the field is not initialized again!
}
public static int init(String s){
System.out.println("assigning " + s+ " the value " + x);
return x;
}
 
}
 

[wise owen]

In 12.4.1 When Initialization Occurs:

The reference to J.i is to a field that is a compile-time constant; therefore, it does not cause I to be initialized. The reference to K.j is a reference to a field actually declared in interface J that is not a compile-time constant; this causes initialization of the fields of interface J, but not those of its superinterface I, nor those of interface K. Despite the fact that the name K is used to refer to field j of interface J, interface K is not initialized.

[Joe Harry]

Hi Tilo Hemp,

Thanks for your explanation. I'm not quite understanding the flow of output. I tried it on my system and I fail to understand. Can you please explain me?

Regards,
Jothi Shankar Kumar. S