How to use the implementation class with the interface class

Interface: summary

Summary of interface:

An interface contains:

Syntax of the definition of an interface:

public interface interfaceName { method-header1; method-header2; ... }

Things you can do with an interface:

Define (reference) variables

Stack s ; // s is a (reference) variable

Use an interface variable to invoke a method specified in an interface

Thing you cannot do with an interface:

you cannot create objects of the data type of an interface:

s = new Stack( ) ; // Use of new operator with an interface // is DISALLOWED

Requirement:

In order to use an interface, you must first write (= implement) all the methods specified in the interface inside an implementation class of that interface

Implementation class of an interface: summary

Summary of implementation class of an interface:

Requirement:

Syntax to express the implementation relationship:

public class ImplementationClassName implemenets InterfaceName { ... body contains variables and methods (just like an ordinary class) BUT: body must contain definitions of all methods specified in the interface InterfaceName }

Example: the Stack interface and its implementation class ArrayStack

The Stack interface:

public interface Stack { public void push( int x ); public int pop ( ); }

The implementation class ArrayStack:

public class ArrayStack { /* ================================================== Variables to represent a stack ================================================== */ public int[] item; public int stackTop; /* ================================================== Constructor: create an array of given size ================================================== */ public ArrayStack( int size ) { item = new int[size]; // Make an array of size as stack storage stackTop = 0; } /* ================================================================= The push() method ================================================================= */ public void push( int x ) { item[stackTop] = x; // Store x in next slot stackTop++; // Advance one slot location } /* ================================================================= The pop() method ================================================================= */ public int pop ( ) { int returnItem; returnItem = item[ stackTop-1 ]; // Get last stored item stackTop--; // Back up one slot location return returnItem; } }

Converting between an interface and its implementation class

Fact:
We have seen this kind of similarity relationship before:

Java will therefore allow the same conversion rules between interface (= base class) and its implementation class (= derived class):

Java allows the assignment of a implementation class (reference) value to its corresponding interface variable without casting

Example:

Stack s = new ArrayStack( ... ) ;
Note: new ArrayStack( ... ) returns an address to an implementation class object

Java allows the recovery of a implementation class (reference) value from to its corresponding interface variable with casting

Example:

Stack s = new ArrayStack( ... ) ; ArrayStack x; x = (ArrayStack) s; // Recover the ArrayStack reference
Note: recovery is necessary if you want access to the other methods that is not specified in the interface !

Note: these rules are same as the ones for base/derived classes !

Dynamic binding using interface

Fact:

Therefore:

After the assignment:

Stack s = new ArrayStack( ... ) ;

the calls:

s.push( ... ) s.pop( )

will invoke the methods defined inside the implementation class ArrayStack !!!

Polymorphism using Interface and Implementation classes

Recall: polymorphism
Polymorphism is also possible using:

Example:

Stack interface:

public interface Stack { public void push(int x); public int pop(); }

Implementation 1:

public class ArrayStack implements Stack { public void push(int x) { // version 1 of push() } public int pop() { // version 1 of pop() } }

Implementation 2:

public class AnotherStack implements Stack { public void push(int x) { // version 2 of push() } public int pop() { // version 2 of pop() } }

Then:

Stack s = new ArrayStack( ... ); s.push( 4 ); <--- will call push() in ArrayStack (version 1)
Stack s = new AnotherStack( ... ); s.push( 4 ); <--- Same expression will now call push() in AnotherStack (version 2)

Note:

I will show you an example later...
But if you understood the polymorphism concept from the base class/derived class material, the above is no different than what you have seen in the polymorphism examples in base class/derived class.

The purpose of the interface mechanism

Facts:

Important fact:

For one interface (e.g., Stack), there may exist many different implementation classes !!!

Example:

Implementation class 1 using an array:

public class ArrayStack implements Stack { ... (we have seen this class before !) }

A different implementation class may use a linked list (lists will be discussed later in this course):

public class ListStack implements Stack { ... (we have seen this class before !) }

Purpose of an interface:

The interface variable along with dynamic binding enables us to select a different implementation (i.e., use different variables and methods) by:

Why do we need different implementations:

Example: using an interface and its implementation class

Now you can fully understand the following example:

public class testProg1 { public static void main( String[] args ) { int x; Stack s; s = new ArrayStack( 10 ); // We will use methods from the ArrayStack class x = 4; s.push(x); System.out.println("push(" + x + ");"); x = 7; s.push(x); System.out.println("push(" + x + ");"); x = 8; s.push(x); System.out.println("push(" + x + ");"); x = 9; s.push(x); System.out.println("push(" + x + ");"); x = s.pop(); System.out.println("pop() ---> " + x ); x = s.pop(); System.out.println("pop() ---> " + x ); x = s.pop(); System.out.println("pop() ---> " + x ); x = s.pop(); System.out.println("pop() ---> " + x ); } }

Key to understand the behavior of the above program:

Through dynamic binding:

the call s.push(x) will call the push() method defined inside the ArrayStack class
the call s.pop() will call the pop() method defined inside the ArrayStack class

Example Program: (Demo above code)
- The Stack interface Prog file: click here
- The ArrayStack interface Prog file: click here
- The test program Prog file: click here
How to run the program: