Overloaded methods are methods with the same name signature 
but either a different number of parameters or different 
types in the parameter list. For example 'spinning' a 
number may mean increase it, 'spinning' an image may mean 
rotate it by 90 degrees. By defining a method for handling 
each type of parameter you achieve the effect that you want.

Overridden methods are methods that are redefined within an 
inherited or subclass. They have the same signature and the 
subclass definition is used.

Polymorphism is the capability of an action or method to do 
different things based on the object that it is acting 
upon. This is the third basic principle of object oriented 
programming. Overloading and overriding are two types of 
polymorphism . Now we will look at the third type: dynamic 
method binding.

Assume that three subclasses (Cow, Dog and Snake) have been 
created based on the Animal abstract class, each having 
their own speak() method.

Example:
--------
public class AnimalReference
{
  public static void main(String args[])
  Animal ref                    // set up var for an Animal
  Cow aCow = new Cow("Bossy");  // makes specific objects
  Dog aDog = new Dog("Rover");
  Snake aSnake = new Snake("Earnie");

  // now reference each as an Animal
  ref = aCow;
  ref.speak();
  ref = aDog;
  ref.speak();
  ref = aSnake;
  ref.speak();
}
Notice that although each method reference was to an Animal 
(but no animal objects exist), the program is able to 
resolve the correct method related to the subclass object 
at runtime. This is known as dynamic (or late) method 
binding.

Polymorphism means the ability of a single variable of a 
given type to be used to reference objects of
different types, and automatically call the method that is 
specific to the type of object the variable references.
The benefit of polymorphism is that it is very easy to add 
new classes of derived objects without breaking the calling 
code that uses the polymorphic classes or interfaces.
When you send a message to an object even though you
don’t know what specific type it is, and the right thing 
happens, that’s called polymorphism. The process used by
object-oriented programming languages to implement 
polymorphism is called dynamic binding.