In order to try and explain the important topic of polymorphism in Java, I will use the following class hierarchy as an example:


  class Device { }

  class MobileDevice extends Device {}
  class DesktopDevice extends Device {}
  class WearableDevice extends Device {}

class Device { }

class MobileDevice extends Device {}

class DesktopDevice extends Device {}

class WearableDevice extends Device {}

Given this class hierarchy, what could we say about MobileDevice? It’s a descendant from Device (and implicitly from Object) so we could say:

A MobileDevice is a Device and is also an Object and so it can be used wherever Device or Object objects are called for
But the reverse is not necessarily true: a Device may be a MobileDevice, but it also may not be

There are two important concepts involved in the this example:

Implicit casting (Widening)	Assigning a subclass reference to a base class reference This is always OK
Explicit casting (Narrowing)	Assigning (casting) a base class reference to a subclass reference This is OK at compile time but could lead to a runtime error if the assigned reference is not referencing a subclass instance

Below are examples of both concepts:


  // WIDENING EXAMPLE
  MobileDevice md = new MobileDevice();

  // OK: a MobileDevice is always a Device
  Device d = md; 

  // OK: a Device is always an Object
  Object o = new Device();

// WIDENING EXAMPLE

MobileDevice md = new MobileDevice();

// OK: a MobileDevice is always a Device

Device d = md;

// OK: a Device is always an Object

Object o = new Device();


  // NARROWING EXAMPLE
  Device d = new MobileDevice();

  // OK: d can be a MobileDevice (runtime error if it's not)
  MobileDevice md1 = (MobileDevice) d; 

  // compiler error (no casting)
  MobileDevice md2 = d;

// NARROWING EXAMPLE

Device d = new MobileDevice();

// OK: d can be a MobileDevice (runtime error if it's not)

MobileDevice md1 = (MobileDevice) d;

// compiler error (no casting)

MobileDevice md2 = d;

Virtual Method Invocation

Let’s say the class Device has a method getType() that it is overridden in the subclass MobileDevice. When the following code is run:


  Device d = new MobileDevice();
  int type = d.getType();

Device d = new MobileDevice();

int type = d.getType();

What method is actually invoked? The one in MobileDevice or the one in Device? Yes… it’s the one in MobileDevice because the JVM knows at runtime that the object referenced by d is a MobileDevice even although the type of the reference variable is Device.

This is known as virtual method invocation or dynamic binding and it works only for instance methods (non-static methods). For the exam, it’s very important to know how virtual method invocation works, so be sure you understand the following table:

Kind of member	When you access a member of this kind, what type is invoked?
Instance methods (non-static)	The type of the actual object that is referred by the variable
Static methods	The type of the reference variable
Fields (static or not)	The type of the reference variable

Polymorphism

Virtual Method Invocation

Leave a Reply Cancel Reply