What Is Casting Upcasting and Downcasting in Java?

A type cast takes a value of one type and produces the value of another type. Assigning the resultant to a higher type is automatic. The automatic Conversion is called type coercion.

The relationship between the base Class and the derived class is called casting. The derived class is a type of base class. Also when there is a need to store a value of one type into another type of variable, we need to case the values into the new container type.Java will change one type of data into another when appropriate.

In java casting(upcasting) is safe with the exception that when we perform so called narrowing conversion(a data type that can hold more data to one which can not hold that much data), we run a risk of losing information. Here the compiler forces us to do a cast -in effect saying “This can be a dangerous thing to do” if we want the compiler to do it anyway, we must make the cast explicit.

With a widening conversion, an explicit cast is not needed because the new type will hold more information than old, hence no information is lost. Java allows casting primitive to another except boolean. The class type does not allow casting to convert one to another. There should be special methods.

Due to inheritance, all methods in the base class are available to the derived class or child class. So any message we sent to the base class can also be sent to derived class or child class.

lets us check an example:

//parent class
class Shape{
public void calculateArea(){
    System.out.println("Hello");
}
public static void createShape(Shape i)
    {
        i.calculateArea();
    }
}
//Rectangle object is a Shape as they have same interface
public class Rectangle extends Shape{
    public static void main(String args[])
    {
        Rectangle rect=new Rectangle();
        Shape.createShape(rect);
    }
}
 

The base class Shape has a method -calculate area() so as the child class-Rectangle.createShape() method accepts a Shape reference. In Rectangle class the main method call createShape() by providing the Rectangle object.

Java is popular for type checking but in this case, it accepts another type. But here Rectangle is a Shape object and there is no method that createShape() could call for an instrument that is not in Rectangle class. Inside createShape(), the code works for Shape and anything derived from Shape. The act of converting a Rectangle object (derived/child class object) reference or pointer into a Shape object is called upcasting.

When the class inheritance diagram is drawn it is traditionally downwards. Casting from derived to base moves up the inheritance diagram -popularly known as upcasting.
Upcasting is always safe as we move towards a more generic type from a specific type. The downside of upcasting is that the more we go towards up, we lose the methods.

This is why the compiler allows us to do upcasting (without any explicit casts or other specific notation).To determine whether we should use composition or inheritance, we need to ask if we need to upcast from our new class to base class. If we must upcast, then inheritance is necessary.

while casting from float or double to an int value is always truncated. like 29.7 or 29.4 will always be 29.
double top=.9
double bottom=.1

int a =(int) top will always be 0 similarly int b=(int)bottom will always be 0
char c=(char)a+top will always be a and
char d=(char)b+top/bottom will be b

Java follows a strict type conversion rules. They are as follows:

ratio=female/male;
 

ratio=(float)female/male;
 

(type-name)expression;
 

float y=21.2f
int x=(int)(y+.5)
 

class MyClass{}
 

public class ArrayListCollection{
    ArrayList list=new ArrayList();
    NumberingList(list);
    int total=0;
    Iterator iter=list.iterator();
    while(iter.hasNext())
    {
        Interger val=iter.next();
        total=total+val;
    }
    System.out.println("The total Amount is"+total);
    private static void NumberingList(ArrayList list)
    {
        list.add(new Integer(1));
        list.add(new Integer(2));
    }
}
}