Have you seen? It is easy to transfer water from a small container to a larger one, but what happens when you want to do it in reverse, from a larger to a smaller one?. Similarly, type conversion in Java works. We will further see in this article how we convert the data type of a larger size into a smaller size, and also, we will discuss different types of type conversion in Java.<\/p>\n
As you must already be familiar with, Java does have a lot of primitive data types. This means there is often confusion about which datatype to use. There is also the case where you have to change the datatypes on the fly to keep up with the dynamics of the program. Let us look at how we do type conversion in Java.<\/p>\n
Yes, you guessed it right. Type Conversion is indeed the conversion of variables from one data type to another. In Java, there are two main types of type conversion.<\/p>\n
Before we understand that we have to know the size hierarchy of data types.
\nLet us observe all of them in increasing order in the list below.<\/p>\n
Java converts shorter data types to larger data types when they are assigned to the larger variable.<\/p>\n
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.<\/p>\n
This is similar to the fact that you can put a raisin in an XXL polythene bag. However, if you want to put the inverse, you have to work out a solution because it is not going to be easy.<\/p>\n
Let us look at examples now!<\/p>\n
Java program to illustrate automatic type conversion.<\/strong><\/p>\n Output:<\/strong><\/p>\n Observe how the value in short automatically got converted to int without any explicit action by the programmer.<\/p>\n Java carries out an operation known as type promotion in automatic type conversion. Before carrying out an operation, Java promotes both operands involved in an expression that involves different data types to a common data type. The following is the hierarchy of promotions.<\/p>\n byte -> short -> int -> long -> float -> double<\/p>\n Java does this when you assign a smaller variable to a larger variable.<\/p>\n If you are having trouble learning about the different types of datatypes, please read the \u201cDatatypes in Java\u201d article first.<\/p>\n Okay, back to where we were. Now, if you go ahead and try a different way of converting the data types, the compiler would not be happy. Don\u2019t believe me? Let us try it out then.<\/p>\n Java program to discuss the problem with type conversion:<\/strong><\/p>\n Output:<\/strong><\/p>\n ^<\/p>\n The conversion is lossy because the variable int is larger in size than the data type byte. That is why the compiler thinks it\u2019s not safe to convert the entire data type because it would lose data.<\/p>\n Do not worry just yet, there is a beautiful workaround for this problem, and we are going to see that now.<\/p>\n Java program to illustrate the working of explicit conversion in Java<\/p>\n Whenever you want to explicitly convert the value of a certain data type to one of a lesser size, you must use the name of the data type bound by round brackets in front of the variable name.<\/p>\n Output:<\/strong><\/p>\n Hah! The output confused you? Well, if it did not, your concepts are solid! For those who did not understand why this output changed and did not print 257, the byte is actually capable of storing a max value of 255.<\/p>\n A single byte consists of 8 bits, and it can store anything between -127 to 127. So the value is actually N mod 256. Here, in this case, 257 mod 256 equals 1, hence the output only shows 1.<\/p>\n This is the loss the compiler was talking about previously.<\/p>\n Choosing the correct data type is extremely important in programming and it comes with a lot of practice and knowledge.<\/p>\n This is a very interesting thing to ponder about. When there is an expression, what happens to the datatypes? Do they all remain exactly as they were before, or do they get promoted to other data types?<\/p>\n Well, in a particular expression, Java promotes all the short, byte and char characters to the int datatype. However, if there are float or double data types present in the expression, then all the values are promoted to the highest value datatype in the expression.<\/p>\n Confused? Don\u2019t worry, we have got you covered.<\/p>\n Java program to illustrate the promotion of type in expressions:<\/strong><\/p>\n Output:<\/strong><\/p>\n Observe how the resultant data type is a double. This is an automatic type promotion.<\/p>\n Last but not least, we have to understand that the automatic promotion may get us in trouble sometimes.<\/p>\n This is evident because as soon as you perform some operation on a shorter datatype, Java converts it to a larger data type.<\/p>\n What if we do not want the variable to change its type? For that, we have to use explicit type conversion just like the one we learned in the previous topic.<\/p>\n After performing operations, we need to explicitly convert the resultant variable to the intended one if we want to preserve its type. How? Let us see.<\/p>\n Java program to illustrate the use of explicit type casting in expressions:<\/strong><\/p>\n Output:<\/strong><\/p>\n Let us look at an example of a character for a better understanding:<\/p>\n Output:<\/strong><\/p>\n This is a classic example where you can see that the value gets converted from a character to an integer upon performing operations on it with an int value.<\/p>\n This is beautiful to observe.<\/p>\n Phew! We are now at the end of another exciting article about type conversions in Java. One step closer to being a Java developer.<\/p>\n Now we know what \u2018type conversion\u2019 in Java is, how automatic and explicit type conversion work, how to avoid getting errors and how to explicitly convert any data type to a datatype of your choice. Efficient programs carefully use as much memory as they require.<\/p>\n","protected":false},"excerpt":{"rendered":" Have you seen? It is easy to transfer water from a small container to a larger one, but what happens when you want to do it in reverse, from a larger to a smaller...<\/p>\n","protected":false},"author":5,"featured_media":85707,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[32],"tags":[20826,20825,7727,20824],"class_list":["post-12393","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-java-automatic-type-conversion","tag-java-explicit-type-conversion","tag-java-type-casting","tag-java-type-conversion"],"yoast_head":"\npackage com.dataflair.typeconversion;\r\npublic class ImplicitConversion\r\n{\r\n public static void main(String[] args) {\r\n \r\n int numberint;\r\n short numbershort;\r\n byte numberbyte;\r\n float numberfloat;\r\n double numberdouble;\r\n long numberlong;\r\n\r\n \/\/We have the datatypes we need. Now let us set a value to the shortest datatype. \r\n \/\/That is byte. \r\n\r\n numberbyte=21;\r\n numbershort=numberbyte;\r\n numberint=numbershort;\r\n numberlong=numberint;\r\n numberfloat=numberlong;\r\n numberdouble=numberfloat;\r\n\r\n System.out.println(\"The short value is \"+numbershort);\r\n System.out.println(\"The byte value is \"+numberbyte);\r\n\r\n System.out.println(\"The int value is \"+numberint);\r\n\r\n System.out.println(\"The long value is \"+numberlong);\r\n System.out.println(\"The float value is \"+numberfloat);\r\n System.out.println(\"The long value is \"+numberdouble);\r\n \r\n System.out.println(\"This is explicit conversion\");\r\n }\r\n}\r\n<\/pre>\n
\nThe byte value is 21
\nThe int value is 21
\nThe long value is 21
\nThe float value is 21.0
\nThe long value is 21.0
\nThis is explicit conversion<\/div>\npackage com.dataflair.typeconversion;\r\npublic class ExplicitProblem {\r\n public static void main(String[] args) {\r\n \r\n int a=57;\r\n byte b =a;\r\n System.out.print(b);\r\n \r\n }\r\n \r\n}\r\n<\/pre>\n
\nbyte b =a;<\/div>\nExplicit Type Conversion in Java<\/h4>\n
package com.dataflair.\r\npublic class ExplicitProblem {\r\n public static void main(String[] args) {\r\n \r\n int a=257;\r\n byte b =(byte)a;\r\n System.out.print(b);\r\n\r\n }\r\n \r\n}\r\n<\/pre>\nType Promotion in Expressions<\/h3>\n
package com.dataflair.typeconversion;\r\npublic class TypePromotionExpression {\r\n public static void main(String[] args) {\r\n \r\n System.out.println(\"This program will illustrate the automatic type promotion of Java\");\r\n\r\n\r\n int a=76;\r\n long l=65123l;\r\n float f = 70.26f;\r\n double d=98.9898d;\r\n char c='z';\r\n\r\n System.out.println(a+c\/d-f+l);\r\n }\r\n}\r\n<\/pre>\n
\n65129.97244807581<\/div>\nExplicit Type Casting in Java<\/h3>\n
package com.dataflair.typeconversion;\r\npublic class TypePromotionExpression {\r\n public static void main(String[] args) {\r\n \r\n System.out.println(\"This program will illustrate the automatic type promotion of Java\");\r\n\r\n\r\n byte a= 127;\r\n a++;\r\n System.out.println(\"Now the datatype of a has changed to int. a => \"+a);\r\n a=(byte)a;\/\/explicit conversion of int c to char c. \r\n System.out.println(\"Now it\u2019s back to a byte. a=> \"+a);\r\n \r\n }\r\n}\r\n<\/pre>\n
\nNow the datatype of a has changed to int. a => -128
\nNow it\u2019s back to a byte. a=> -128<\/div>\npackage com.dataflair.typeconversion;\r\npublic class TypePromotionExpression {\r\n public static void main(String[] args) {\r\n \r\n System.out.println(\"This program will illustrate the automatic type promotion of Java\");\r\n\r\n\r\n char c='s';\r\n int a=1;\r\n int b=c+a;\r\n System.out.println(\"This means that b is now an int value \"+b);\r\n System.out.println(\"We can explicitly typecast it to a character like this \"+(char)(b));\r\n \r\n \r\n }\r\n}\r\n<\/pre>\n
\nThis means that b is now an int value 116
\nWe can explicitly typecast it to a character like this t<\/div>\nSummary<\/h3>\n