Casting

[Rajnarayan Deenadayalan]

What is meant by upcasting and Downcasting?
please provide a clear solution

[Paul Sturrock]

Upcasting is when we handle an object as if it were of its base type, down casting is the opposite. For example:

class BaseType {
     public static void doStuff(BaseType baseType) {
         ...
     }
}
 
class ExtendedBaseType extends BaseType {
 
}

This defines two classes, one which extends from the other. If I write a program like this:

class Upcasting {
     public static void main(String [] args) {
          ExtendedBaseType foo = new ExtendedBaseType();
          BaseType.doStuff(foo); // this is upcasting.
 
     }
 
}

[ January 19, 2005: Message edited by: Paul Sturrock ]

[Stan James]

Upcasting is always safe - the compiler will tell you if it's not. Something as simple as:

List myList = new ArrayList();

creates a real ArrayList but references it as a List. This is actually a pretty good idea as long as none of the later code needs methods that are on ArrayList but not on List.

A down cast might or might not work. At runtime it might throw an exception.

public void doSomething(List someList)
{
   ArrayList myList = (ArrayList)someList;
   myList.some method that only ArrayList has ...
}

The parameter passed to this method must be a List. It might or might not be an ArrayList. If I'm real sure it's an ArrayList I can try to cast it to ArrayList as shown, but I'd be smart to remember it might not work.

Casting is very common with collections. If I know my Map only contains Widgets, I can write this:

Widget myWidget = (Widget)myMap.get("key");

But I run the risk of an exception if some other type of object gets into the list!

[marc weber]

class Vehicle{}
class Car extends Vehicle{}
 
public class TestCasting{
  public static void main(String[] args){
    // make a Vehicle
    Vehicle v = new Vehicle();
 
    // Vehicle to Car is a downcast (unsafe)
    // because a Vehicle is NOT always a car
    // so implicit conversion won't compile
    // Car c = v;
 
    // explicit cast forces to compile
    // but throws exception at runtime
    // because THIS Vehicle is NOT a Car
    // Car c = (Car)v;
 
    // make a Car
    Car c1 = new Car();
    
    // Car to Vehicle is an upcast (safe)
    // because a Car IS always a Vehicle
    // so implicit conversion compiles and runs
    Vehicle v1 = c1;
 
    // as before, Vehicle to Car is a downcast
    // so implicit conversion won't compile 
    // Car c2 = v1;
 
    // explicit cast forces to compile
    // and now runtime is ok
    // because THIS Vehicle IS really an upcast Car
    Car c2 = (Car)v1;
  }
}