Imagine you have an interface called Politician with three required methods:
         int numberOfLiesTold();
         int numberOfBabiesKissed();
         String getName();

Then imagine you have two classes that implement this interface, called 
Republican and Democrat.

You could do things such as:
     Republican r = new Republican("Cand1");
     Democrat d = new Democrat("Cand2");
     Politician x = new Democrat("Cand3");

You could use references of the type Politician to refer to any object
whose class implements is, such as:
        Politician a = r;                 
        Politician c = d;                
        Politician f = (Politician)d;    

However, if you had (for example) an ArrayList of Politician, you would
not know what type of object a specific Politician reference points to 
beyond knowing the class implements Politician.  

This is true of any reference of type Politician.  So, for example, if
you tried to do
        Democrat b = x;
it would not compile because Java can't be sure what type of object is
at the end of the "x" reference, even though *we* know from looking at
our code above that it *is* a Democrat object.

What we could do if tell Java "trust us" by writing
        Democrat b = (Democrat)x;
in which case Java will allow this to compile since it knows that "x" 
could possibly refer to a Democrat object.  It will then verify that
it actually was at runtime.

This also means that if we wrote
        Democrat g = (Democrat)r;
it would compile, but at runtime would throw an exception when it
saw that the actual object referred to by "r" was *not* a Democrat.