Interface doubt

[Chandra Bhatt]

Which of the following are modifiers that can be applied to an interface that is a member of a directly enclosing interface?
a. abstract
b. implements
c. final
d. private
e. protected
f. public

Answer: a,f

Source of the question

Every member type declaration appearing within the body of a directly enclosing interface is implicitly static and public.

Please give me example of this statement.


Thanks and Regards,
cmbhatt

[swarna dasa]

interface InterfaceTest {
public abstract static interface InsideInterface {}
}

[marc weber]

Originally posted by Chandra Bhatt:
quote: Every member type declaration appearing within the body of a directly enclosing interface is implicitly static and public.

Please give me example of this statement...

Writing your own example would be great practice.

Define an interface with a member type (class or interface) that is not explicitly static or public. Then write code that demonstrates this member type is static (does not require an instance of the enclosing type) and public (can be accessed from another package).

[marc weber]

Originally posted by swarna dasa:

interface InterfaceTest {
public abstract static interface InsideInterface {}
}

Uh... That's rather explicit. I think we're looking for a demonstration that "public" and "static" are implicit here.

[swarna dasa]

Yup.. it is explicit, thought he was questioning the answer (a,f) abstract and public. So had an example with the possible modifiers.

Here is the one (hopefully) exhaustive example

com InterfaceTest.java

   
package com;
//InterfaceTest.java
public interface InterfaceTest {
interface InterfaceInside{
int testMethod();
class ClassInsideNestedInterface
{
protected int testNestedClassMethod() {
return 3;
}
};

}
class ClassInside 
{
protected int testClassMethod() {
return 2;
}
};
int testOuterMethod();
}
 

test ClassTest.java //name it whatever you want it

   
package test;
import com.InterfaceTest;
 
class ClassTest extends InterfaceTest.ClassInside implements InterfaceTest.InterfaceInside //interface & class implicitly static & public
{
public int testMethod() {
return 1;
}
public static void main(String[] args) {
ClassTest test = new ClassTest();
System.out.println(test.testMethod());
System.out.println(test.testClassMethod());
}
 
};
 
class ClassNestedClassTest extends InterfaceTest.InterfaceInside.ClassInsideNestedInterface //interface & class implicitly static & public
{
public static void main(String[] args) {
ClassNestedClassTest test = new ClassNestedClassTest();
System.out.println(test.testNestedClassMethod());
}
};
 

Output

>java test.ClassTest
1
2

>java test.ClassNestedClassTest
3

[Keith Lynn]

Here are a couple of examples.

Consider this code.

public class Test2 implements Test1 {
   int num;
 
   class Test3 {
   }
 
   public static void main(String[] args) {
      Test test = new Test();
 
      Test3 test3 = new Test3();
   }
}
 
interface Test1 {
 
   class Test {
   }
 
}

Notice that the main method is in a static context, and, therefore, you cannot access non-static members of the class from it.

Notice that you can create an instance of Test, the member class inherited from Test1, without any problem.

However, the inner class Test3 from the class Test2 cannot be accessed from the main method without an instance of Test2.

This shows that the class Test defined in the interface Test1 is implicitly static.

To show that the members are implictly public, you can look at the message the compiler gives you if you try to use another access keyword on the member.

public interface Test1 {
 
   private class Test {
   }
 
}

If you try to compile this, you get the following error message.

C:\>javac Test1.java
Test1.java:3: illegal combination of modifiers: public and private
   private class Test {
           ^
1 error

[Chandra Bhatt]

Thanks marc, swarna and Keith for your prompt reply.

I got my answer!


Thanks and Regards,
cmbhatt