Java is one of the most famous strongly typed programming languages, and one of its most remarkable characteristics are its many primitive data types. This means there often needs to be clarity about which data type conversion to use in Java.
There is also a prevalent scenario where you need to change on the fly to keep up with the dynamics of the program. In essence, type conversion means changing the data type of variables. There are two primary types of type conversion in Java:
The size hierarchy of data types is necessary to understand this. Let’s review each of them in the list below in order of increasing importance:
Implicit Type Java Data Conversion
Java engine converts shorter data types to larger data types when they are assigned to a larger variable. For example, if you assign a short value to an int variable then Java does the work for you and converts the short value to an int and stores it in the int variable.
However, if you want to produce a reverse way to convert the data types you have to work out a solution because it is going to take a lot of work. Let’s dive in on an example:
The Output would be:
In this example, the value in short automatically got converted to int without any explicit action by the coder, this is the Java automated conversion when a lower size variable is assigned to a larger one.
The compiler will not be pleased if you tried to convert the data types differently now. Let’s give it a try.
Because the variable int is bigger than the data type byte, the conversion is lossy. Because data would be lost, the compiler considers it unsafe to transform the full data type.
Explicit Type Java Data Conversion
This is not going to be a big problem, in this case, Java offers a different way to execute this conversion. Anytime you wish to explicitly change a data type’s value to one with a smaller size, you must put the name of the data type enclosed in round brackets in front of the variable name.
There is no output because the byte is capable of storing a max value of 255. Consider this as a flash test of your Java skills. A single byte has 8 bits and can store values ranging from -127 to 127. Therefore, the value is N mod 256. Since 257 mod 256 in this instance equals 1, the result only displays 1.
Choosing the correct data type is crucial when you are coding, so having a good base is key to handling data type conversion in Java.
Type Promotions in Expressions
It’s very interesting to think about this. What happens to the datatypes if there is an expression? Do they all stay precisely the same or do any of them advance to other data types? Java particularly promotes all the short, byte, and the char characters to int datatype, but if there are float, and double data types present in the expression then all the values are promoted to the highest value datatype in the expression.
let’s see an example:
Now we can see how the resultant data type is double. This is an automatic type of promotion.
Explicit Type Casting in Expressions
The last point we must review is that automatic promotion may get us in trouble sometimes. This is clear because Java converts shorter datatypes to larger ones as soon as you execute an action on them.
What happens if we don’t want the variable’s type to change? To do that, we must employ explicit type conversion, just as we did in the last section.
Let us look at an example of character for a better understanding:
This is a typical illustration of how executing operations on a value with an int value causes it to change from being a character to an integer.
For a developer, data type conversions happen frequently. An experienced programmer will be familiar with the majority of these conversions because they are simple. However, string-to-date conversion can be challenging, particularly for newcomers. If you can’t differentiate between explicit and implicit data type conversion, errors may occur, identifying these types of conversions could save you a ton of time when attempting to determine why a particular conversion is failing to compile or run.