Easy-to-follow video tutorials help you learn software, creative, and business skills.Become a member
There will be times in your applications when you need to convert values from one data type to another. It's important to understand how data types are converted especially when working with primitives. Here are the primitive numeric data types arranged in order from the greatest memory usage and the largest ranges to the smallest memory usage again the smallest ranges. So the double takes 64-bits and can handle the greatest precession or as the byte has the smallest range. When you convert a value from say a byte to a short, a short to an int or an int to a long, we call that converting upward, you're taking a value that fits easily into the next value upward.
You can do this sort of conversion with very simple syntax. Here I'm declaring an integer value of 120 and then passing that value to a new variable data typed as a double, the value of 120 can fit easily in either data type. And so the result is that you have a value of 120, the double version would have the decimal value of 0, the integer value would be truncated but they would fundamentally have the same value. We call this sort of numeric conversion implicit you can simply assign a value from one variable to another without any special notation and because all of the conversion is reliable that is the values will fit in both variables easily you don't have to say anything specific in your code about it.
When you're converting values in the other direction though you can run into some trouble and so Java requires you to be explicit in these sorts of conversions, once again here is my listing of the numeric data types, but now I'm indicating through the arrows that I'm going to do the conversions in the other direction from a double to a float or a float to a long. We call these downward conversions. Here is an example, I'm starting with the double value of 3.99 and then I try to convert the value to an integer by simply assigning the value to the new variable.
You won't even be able to compile this code because Java knows that you're in danger of loosing data. So if you add this code to your Java class and try to save and compile you'll get a compile-time error. The compiler will tell you that those two data types aren't compatible with each other. So you instead have to explicitly tell the compiler that you know what you're doing and you do this by adding the target data type before the original value wrapped in parenthesis, here is the added syntax this means take the doubleValue and cast or convert the value to an integer and then you can pass the value over.
You're still in danger of loosing data; the value of 3.99 which fits fine in a doubleValue doesn't fit in an integer value, because integers can't have fractional amounts. So when you do this you're going to truncate the value, it's going to end up as the value 3, but you've told the Java compiler that that's what you want to do and so the compiler will let you do it. The double value will still be 3 .99, but the integer will be 3. So the lesson to take from this is that when you converting downward you have to be explicit in your code and you have to know that you might change the data.
The dangers of downward conversion aren't limited to simply truncating and loosing values you could actually change values pretty dramatically. Let's take an example where you start off with an integer and you want to convert it to a byte. Well, the ranges of integers and bytes are very different; integers can handle values in the two millions both positive and negative whereas bytes can only handle values from negative 128 to positive 127. So what happens if you start off with an integer say if 128 that exceeds the range of the byte and then you explicitly tell Java I want to turn this into a byte what is it going to do.
Well it's going to take the value that exceeds the range of the target data type the byte and it's going to wrap around and assign an opposite value. So if you start off with a positive you end up with a negative, the result of this code would be a Value of b of -128. Remember the range of a byte goes from negative 128 to positive 127. I'm trying to assign a value that exceeds that range by 1, so it wraps around by 1 and becomes negative 128, the smallest possible number instead of the greatest possible number.
You'll see this sort of conversion this wrapping around whenever you try to convert a value downward from one data type to another. Finally, in the discussion of converting numeric values it's worth mentioning that there are two possible ways of doing it. When you're converting between primitive data types you can either use this casting syntax that I've shown or you can use those helper classes, the double class, the byte class, the integer class and so on. The simple casting syntax uses the target data type wrapped in parenthesis right before the original value.
So here I have a double value, a primitive double starting off a 3.99, I explicitly convert that to an integer using the casting syntax and now I can assign that to an int. Again I'm going to truncate values, I'm going to loose data but it's going to work. So use the helper class approach, the first step is to create an instance of the helper class wrapped around the primitive value. So here I'm starting once again with a primitive and then I'm creating an instance of the double class wrapped around the primitive, I'm calling that double0bj.
Once I have that reference that complex object I can then call any of its method, so now I'm going to call the intValue method, it's going to return an integer and I can assign that to the primitive int. Either of the syntax styles will work fine. There is a minor advantage to the simple casting syntax clearly it takes less code, but also you're not adding another object to memory. When you use the helper class method you are creating an instance of that double class that you really don't need. So for the most part the simple casting syntax is preferred and the only time I would recommend using the helper class approach is when you want to store that data for the longer term and do multiple things with it.
Convert it to an integer and a byte and a float and so on. So that to look at issues around converting numeric values from one data type to another. You can use either the casting of the helper class method syntax and always be aware of what happens when you try to cast from one data type to another. When you are converting the data upward through the data types all the conversions are implicit and safe, when you're converting downward beware of loosing data, wrapping values around, and also note that you have to be explicit in your instructions to the compiler.
Get unlimited access to all courses for just $25/month.Become a member
82 Video lessons · 102103 Viewers
61 Video lessons · 88826 Viewers
71 Video lessons · 72639 Viewers
56 Video lessons · 104271 Viewers
Access exercise files from a button right under the course name.
Search within course videos and transcripts, and jump right to the results.
Remove icons showing you already watched videos if you want to start over.
Make the video wide, narrow, full-screen, or pop the player out of the page into its own window.
Click on text in the transcript to jump to that spot in the video. As the video plays, the relevant spot in the transcript will be highlighted.
Your file was successfully uploaded.