title: Explicit type casting example in Java
body: <p>I have come across this example on <a href="http://www.javabeginner.com/learn-java/java-object-typecasting">http://www.javabeginner.com/learn-java/java-object-typecasting</a> and in the part where it talks about explicit type casting there is one example which confuses me.</p>
  
  <p>The example:</p>
  
  <pre><code>class Vehicle {
  
      String name;
      Vehicle() {
          name = "Vehicle";
      }
  }
  
  class HeavyVehicle extends Vehicle {
  
      HeavyVehicle() {
          name = "HeavyVehicle";
      }
  }
  
  class Truck extends HeavyVehicle {
  
      Truck() {
          name = "Truck";
      }
  }
  
  class LightVehicle extends Vehicle {
  
      LightVehicle() {
          name = "LightVehicle";
      }
  }
  
  public class InstanceOfExample {
  
      static boolean result;
      static HeavyVehicle hV = new HeavyVehicle();
      static Truck T = new Truck();
      static HeavyVehicle hv2 = null;
      public static void main(String[] args) {
          result = hV instanceof HeavyVehicle;
          System.out.print("hV is an HeavyVehicle: " + result + "\n");
          result = T instanceof HeavyVehicle;
          System.out.print("T is an HeavyVehicle: " + result + "\n");
          result = hV instanceof Truck;
          System.out.print("hV is a Truck: " + result + "\n");
          result = hv2 instanceof HeavyVehicle;
          System.out.print("hv2 is an HeavyVehicle: " + result + "\n");
          hV = T; //Sucessful Cast form child to parent
          T = (Truck) hV; //Sucessful Explicit Cast form parent to child
      }
  }
  </code></pre>
  
  <p>In the last line where T is assigned the reference hV and typecast as (Truck), why does it say in the comment that this is a Successful Explicit Cast from parent to child? As I understand casting (implicit or explicit) will only change the declared type of object, not the actual type (which shouldn't ever change, unless you actually assign a new class instance to that object's field reference). If hv was already assigned an instance of a HeavyVehicle class which is a super class of the Truck class, how can then this field be type cast into a more specific subclass called Truck which extends from the HeavyVehicle class?</p>
  
  <p>The way I understand it is that casting serves the purpose of limiting access to certain methods of an object (class instance). Therefore you can't cast an object as a more specific class which has more methods then the object's actual assigned class. That means that the object can only be cast as a superclass or the same class as the class from which it was actually instantiated. Is this correct or am I wrong here? I am still learning so I am not sure if this is the correct way of looking at things.</p>
  
  <p>I also understand that this should be an example of downcasting, but I am not sure how this actually works if the actual type doesn't have the methods of the class to which this object is being downcasted. Does explicit casting somehow change the actual type of object (not just the declared type), so that this object is no longer an instance of HeavyVehicle class but now becomes an instance of Truck class?</p>