Polymorphism via Interfaces

Some preparations

The final modifier
- Example:
```
final class MyClass {

        public final float pi = 3.1415926 f;

        public final void doIt ( ) {

              System.out.println ( "Done !" );
        }

        public void process ( final Customer customer ) {

              // not allowed
              // customer.increaseLimit( 1000 );
              // customer = new Customer();  
        }
                
        ......

}
```
- When applied to a class, no derived class can be created by inheriting from this class.
- When applied to a method, this method can not be overrided.
- When applied to an argument of method, inside the method, you cannot change what the argument (handle) is pointing to.
- When applied to a data member, the data member can not be changed.
  - This is how we define constant data members.
  - The final data members must be initialized at the time of declaration.
The static modifier

So far, we have assumed that each object of a class contains a copy of each data member and each method of the class.

This is not true if modifier static is applied to them.

When you declare a data member or method as static, only one copy of it is created, no matter how many object of this class are created.

Example:
```
	public class TestClass {

           // constant
	   public    final static float  pi = 3.1415926f;  

           // static data member
	   private         static int    count = 0;  

           // usual  data member
	   private                String name;           

           // constructor 
	   public TestClass ( String name ) {
	       this.name = name;  
	       count ++;
	   }

           // a usual method
           String getName ( ) {
               return name;
           }

           // a static method
           public static int GetCount ( ) {
               // not allowed 
               // System.out.println ( getName() ); 

               // this is ok
               return count; 
           }

        }


	public class TestClassApp {

	   public static void main ( String args[ ] ) {

               System.out.println( StaticTest.pi );
               // output 3.1415926

	       Static v ; 

	       v = new TestClass ( "AAAAA" );
	       v = new TestClass ( "BBBBB" );

	       System.out.println( TestClass.getCount() );
	       // output 2

	   }

	}       
		
```
- static data members
  - static data members must be initialized when declared.
  - Of course, these data members may be changed later if not declared as final.
  - Consider static data members as shared by all objects created.
  - Consider static data members as belonging to the class instead of objects created.
  - You can access the static data members through the class name if permitted.
- static method
  - Because static methods do not operate in the context of particular object, they cannot directly or indirectly reference non-static data members which exists only in objects of the class.
  - However, they can reference static data members because static data members exist independent of specific objects.
  - You can access the static methods through the class name (if you have access permission) without having to create an object first.
  - Questions:
    - We use Math.random( ) to generate random numers between 0 and 1 inclusive. How is method random( ) declared in the Math class ?
    - Is the following program correct ? What changes should be made ?
```
   class MyClass {

        void doIt () {
           System.out.println ( "It is done !" );
        } 

        public static void main ( String args[ ] ) {

             doIt();
        }
   }
                           
```

Interfaces in Java

Abstract Classes

An abstract class can not be used to create any object.
It represents the common set of methods that for all the derived classes.
The derived classes must implement all the abstract methods.
However, an abstract class may also have non-abstract methods and non-static non-final data members.

Interfaces

An interface is an special abstract class where
- all the methods are abstract.
- all the data members are final and static, i.e. only constants.
Consider an interface as a "more pure" abstract class which need no space.

Declare an Interfaces

Example:

public interface MyInterface {

      int  x = 0;  // considered as static and final 

      void f();    // considered as abstract

}

Similar to declaring an abstract class.
But use keyword interface instead of keyword class.
All the data members are automatically considered static and final.

Use of Interfaces

Since an interface acts as an abstract class, we can have our classes to "inherit" from it.
But we do not use keyword extends, but use keyword implements.

Example:

public interface InterfaceA {

      int  x = 0;  // considered as static and final 

      void f( );    // considered as abstract

} 

public interface InterfaceB {

      int  x = 1;  // considered as static and final 

      int  y = 0;  // considered as static and final 

      void g( );    // considered as abstract

} 

public class ClassX  implements InterfaceA, InterfaceB {

      void f( )  {   // implement the only abstract method in InterfaceA 
          ......
      }

      void g( )  {   // implement the only abstract method in InterfaceB 
          ......
      }

} 


           InterfaceA            InterfaceB
              ^                      ^
               .                    .
                .                  . 
                 .                .
                  .              .
    implements     .            .   implements
                    .          .
                     .        .
                      .      .
                       .    . 
                        .  .
                       ClassX

Your class can implement more than one interfaces.
This gives no problem because all the interfaces involve no space allocation and the effect of doing this is that your class is enforced to implement all the abstract methods declared in all the interfaces.
If a same method is declared in more than once, it does not matter.
If a same data member is declared in more than once, you use the interface name to distinguish it.
Actually, by doing this, you make your class "inherit" from more than one parent "classes", achieving the effect of "multiple inheritance".
While implementing some interfaces, your class can still inherit from a single parent class.

Example:


public class ClassX  extends Parent 
                      implements InterfaceA, InterfaceB {

       ......

} 


           ParentClass             InterfaceA            InterfaceB
              \                        ^                      ^
               \                      . .                   . .
                \                    .   .               .   .
                 \                  .     .           .     .
                  \                .       .       .       .
          inherit  \              . implements .   implements
                    \            .          .            .
                     \          .        .   .          .
                      \        .      .       .        .
                       \      .    .           .      .
                        \.  .                   .    .
                       ClassX                  ClassY

Polymorphsim via interfaces

Each interface is considered as a type.
An object of a class can be casted to the type of each interface it implements.
This is how polymorphism via interfaces work.

Example:


         void method1 ( InterfaceA a ) {
             a.f( );
         }

         void method2 ( InterfaceB b ) {
             b.g( );
         }

 
         ClassX    v = new ClassX();

         method1 ( v );  // the f( ) method of ClassX invoked

         method2 ( v );  // the g( ) method of ClassX invoked

         v = new ClassY();

         method1 ( v );  // the f( ) method of ClassY invoked

         method2 ( v );  // the g( ) method of ClassY invoked