7.7. Casting in Java

● What is Casting? ○ Casting is the process of converting one data type to another. In Java, there are two types of casting: ■ Implicit Casting (Widening): Automatically performed by Java when converting a smaller data type to a larger data type (e.g., from int to float). ■ Explicit Casting (Narrowing): Manually performed by the programmer when converting a larger data type to a smaller one (e.g., from double to int).

Casting in Java is a method for changing a variable from one data type to another. There are primarily two types of casting:

1. Implicit Casting (Widening): This type of casting is done automatically by the Java compiler. It happens when a smaller data type (like an int) is converted to a larger data type (like a double). The conversion is safe because there’s no risk of losing information.
2. Explicit Casting (Narrowing): This is when a larger data type (like a double) gets converted into a smaller data type (like an int). This needs to be done manually by the programmer, as it may lead to loss of information—it truncates the decimal part.

Think of casting like transferring liquid from one container to another. When pouring water from a small cup (int) into a larger bottle (double), it’s easy and there’s no risk of overflow—this is implicit casting. However, if you try to pour water from a large jug (double) into a small cup (int), you can’t just do it without deciding how much to fill the cup; you need to make a choice about how much to pour. This is explicit casting.

Example of Implicit Casting: int num = 10; double result = num; // Implicit casting from int to double System.out.println(result); // Output: 10.0

In this example, we have an integer variable named num which is assigned a value of 10. When we assign num to a new variable result of type double, Java automatically converts the integer value to a double value. Since the double type can hold the integer value without any loss of data, this process is done seamlessly, and we get an output of 10.0, reflecting that it's now treated as a double.

Imagine you have a 10-dollar bill (represented by num as an integer). If you wanted to give someone that same $10 but in a more flexible format (like a digital currency represented by `result` as a double), you can easily convert it. The$10 bill can effortlessly become $10.00 in digital currency without losing any value.

Example of Explicit Casting: double num = 9.99; int result = (int) num; // Explicit casting from double to int System.out.println(result); // Output: 9

In this example, we start with a double variable num that has a value of 9.99. When we convert num to an integer using explicit casting (as indicated by (int)), we are telling Java to take that double value and change it to an integer. This process strips away the decimal part, resulting in result being assigned the value 9. Thus, the output is 9, demonstrating that the decimal part has been lost in the conversion.

Think about measuring the height of a plant. If you measure it and get 9.99 inches (like num), but for simplicity, you need to tell your friend the whole inches only, you would say it’s 9 inches (like result). The conversion drops the decimal, just as the explicit casting drops the decimal part of the number.

--