class Base{
public void test(){System.out.print("Base ");
}//end test()}//end class Base
interface X{public void test();
}//end Xinterface Y{
public void test();}//end Y
class A extends Base implements X,Y{public void test(){
System.out.print("A ");}//end test()
}//end class A Classes A and B extend Base and implement X and Y
The code in the following fragment defines two classes, named A and B , each of which extends Base , and each of which implements both interfaces X and Y . Each class provides a concrete definition for the method named test , with each class providing a different definition.
class A extends Base implements X,Y{
public void test(){System.out.print("A ");
}//end test()}//end class A
class B extends Base implements X,Y{public void test(){
System.out.print("B ");}//end test()
}//end class B Override inherited method and define interface method
Each of the methods named test in the above fragment serves not only to override the method inherited from the class named Base , but also to satisfy the requirement to define the methods declared in theimplemented interfaces named X and Y . (This can also be thought of as overriding an inherited abstract method from an interface.)
Store object's references as type Base and call test method
Finally, the code in the following fragment declares a reference variable of the type Base . Objects respectively of the classes Base , A , and B are instantiated and stored in the reference variable. Then the method named test is called on each of the references in turn.
void doIt(){
Base myVar = new Base();myVar.test();
myVar = new A();myVar.test();
myVar = new B();myVar.test();
System.out.println("");}//end doIt()
}// end class Worker As you probably expected, this causes the following text to appear on the screen:
Base A B Answer 8
C. A-intfcMethodX B-intfcMethodX
Explanation 8
Similar to previous two programs
This program is very similar to the programs in Question 6 and Question 7 . The program is Question 6 exposed a specific type mismatch problem. The program in Question 7 provided one solution to the problem.
A different solution
The following fragment illustrates a different solution to the problem.
void doIt(){
X[]myArray = new X[2];myArray[0] = new A();myArray[1] = new B();for(int i=0;i<myArray.length;i++){
myArray[i].intfcMethodX();
}//end for loopSystem.out.println("");
}//end doIt() An array object of the interface type
In this case, rather than to declare the array object to be of type Object , the array is declared to be of the interface type X .
This is a less generic container than the one declared to be of type Object . Only references to objects instantiated from classes that implement the X interface, or objects instantiated from subclasses of those classes can be stored in the container. However, this is often adequate.
What methods can be called?
Since the references are stored as the interface type, any method declared in or inherited into the interface can be called on the references stored in the container.Of course, the objects referred to by those references must provide concrete definitions of those methods or the program won't compile.