| << Chapter < Page | Chapter >> Page > |
interface X{
public void intfcMethodX();}//end X Class A extends Base and implements X
The next fragment shows the definition of a class named A that extends Base and implements X .
class A extends Base implements X{
public void inherMethod(){System.out.print(
" A-inherMethod ");}//end inherMethod()public void intfcMethodX(){
System.out.print("A-intfcMethodX ");
}//end intfcMethodX()}//end class A Defining interface method
Because the class named A implements the interface named X , it must provide a concrete definition of all the methods declared in X .
In this case, there is only one such method. That method is named intfcMethodX . A concrete definition for the method is provided in the class named A .
Class B also extends Base and implements X
The next fragment shows the definition of another class (named B ), which also extends Base and implements X .
class B extends Base implements X{
public void inherMethod(){System.out.print(
" B-inherMethod ");}//end inherMethod()public void intfcMethodX(){
System.out.print("B-intfcMethodX ");
}//end intfcMethodX()}//end class B Defining the interface method
Because this class also implements X , it must also provide a concrete definition of the method named intfcMethodX .
Different behavior for interface method
However (and this is extremely important) , there is no requirement for this definition of the method to match the definition in the class named A , or to match the definition in any other class that implements X .
Only the method signature for the method named intfcMethodX is necessarily common among all the classes that implement the interface.
The definition of the method named intfcMethodX in the class named A is different from the definition of the method having the same name in the class named B .
The interesting behavior
The interesting behavior of this program is illustrated by the code in the following fragment.
void doIt(){
X myVar1 = new A();myVar1.intfcMethodX();X myVar2 = new B();
myVar2.intfcMethodX();System.out.println("");
}//end doIt() Store object's references as interface type X
The code in the above fragment causes one object to be instantiated from the class named A , and another object to be instantiated from the class named B .
The two object's references are stored in two different reference variables, each declared to be of the type of the interface X .
Call the interface method on each reference
A method named intfcMethodX is called on each of the reference variables. Despite the fact that both object's references are storedas type X , the system selects and calls the appropriate method, (as defined by the class from which each object was instantiated) , on each of the objects. This causes the following text to appear on the screen:
A-intfcMethodX B-intfcMethodX No subclass-superclass relationship exists
Thus, the use of an interface makes it possible to call methods having the same signatures on objects instantiated from different classes, without anyrequirement for a subclass-superclass relationship to exist among the classes involved.
Notification Switch
Would you like to follow the 'Object-oriented programming (oop) with java' conversation and receive update notifications?
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|