{"id":1046,"date":"2015-05-27T07:53:17","date_gmt":"2015-05-27T07:53:17","guid":{"rendered":"https:\/\/theoryofprogramming.wordpress.com\/?p=1046"},"modified":"2023-12-12T03:26:29","modified_gmt":"2023-12-12T03:26:29","slug":"java-tutorials-data-types-input-operators-in-java","status":"publish","type":"post","link":"https:\/\/theoryofcoding.com\/index.php\/2015\/05\/27\/java-tutorials-data-types-input-operators-in-java\/","title":{"rendered":"Data Types, Input and Operators in Java"},"content":{"rendered":"

Hello people…! This is a new post in Java Tutorials \u2013 Data Types, Input and Operators in Java. In my previous post, Java Tutorials – An Introduction<\/a><\/strong>, I introduced you to the Java programming language. We didn’t do anything more than printing text on the terminal. Now, we will learn to write short programs which will involve a little computation.<\/p>\n

\u00a0Data Types in Java<\/h3>\n
\"Data<\/a>
Data Types in Java<\/figcaption><\/figure>\n

These are the data types in Java. The primitive data types are much like the C++ data types. But, unlike C++, String is not a primitive data type. Strings in Java are objects<\/strong>. The Java library has the String class and we create their objects when we deal with strings. When it comes to numeric data types, Java does not have any notion of unsigned integers. So, the numeric data types in Java can always store positive and negative values. We will talk about the non-primitive data types later. For now, focus on getting comfy with the primitive data types.<\/p>\n

The sizes of the primitive data types are –<\/p>\n

    \n
  • byte<\/span><\/b> – 1 Byte<\/li>\n
  • short<\/span><\/b> – 2 Bytes<\/li>\n
  • int<\/span><\/b> – 4 Bytes<\/li>\n
  • long<\/span><\/b> – 8 Bytes<\/li>\n
  • float<\/span><\/b> – 4 Bytes – up to 7 digits of precision<\/li>\n
  • double<\/span><\/b> – 8 Bytes – up to 15 digits of precision<\/li>\n
  • char<\/span><\/b> – 2 Bytes – But holds only up to 1 character<\/li>\n
  • boolean<\/span><\/b> – JVM Dependant<\/li>\n<\/ul>\n

    Taking Input on Terminal<\/h3>\n

    Before we start writing programs, we need to learn how to take input from the user, so that, we can keep testing our code for various inputs. There are several methods to take input from the user. We will look at the simplest one, by using the Scanner Class. Scanner is a class in the java.util<\/strong> package, or, library, a more familiar term. It has all the functions related to taking input from the user. So, to use those methods, we must first create an object of class Scanner.<\/p>\n

    \nScanner scan = new Scanner(System.in);\n<\/pre>\n
    This is how we create a an object of the class Scanner. An object is an instance (an occurrence) of a class. We use the new<\/span><\/b> keyword to create an object. We will have a detailed discussion about classes and objects later. The memory for the object is dynamically allocated by the JVM. And it looks like we are calling, some sort of a function, it is a Constructor<\/strong>…! It is used to instantiate an object. We will have a detailed discussion about Constructors later, but for now, I must ask you not to panic looking at that statement… \ud83d\ude1b …. We will learn everything..!<\/p>\n
    On the right hand side, we have “Scanner scan”. The “Scanner” is to specify the data type of the variable\u00a0“scan”. This variable, “scan”, is called an Object Reference<\/strong>. It stores the address of the newly allocated memory (by using new<\/span><\/b>) for the object. We access this object by the Object Reference. But remember, this is not a pointer..! With pointers, we can add or subtract values, called Pointer Arithmetic, but we can do no such thing with Object References.<\/p>\n
    Having created an object, we can access the methods that are provided by the Scanner Class, by using the “.” operator. Let’s look at an example program to make things clear. This program is an interest calculator, which takes the necessary information from the user –<\/p>\n
    \nimport java.util.Scanner;\n\npublic class InterestCalculator {\n\n    public static void main(String[] args) {\n        Scanner scan = new Scanner(System.in);\n\n        System.out.println(&quot;Hello..! Enter your name -&quot;);\n\n        String name = scan.nextLine();\n\n        System.out.println(&quot;Hello &quot; + name + &quot;..!&quot;\n                + &quot; Please enter the principal amount -&quot;);\n\n        int amount = scan.nextInt();\n\n        System.out.println(&quot;Enter the rate percentage -&quot;);\n\n        float rate = scan.nextFloat();\n\n        System.out.println(&quot;Enter the time period -&quot;);\n\n        int time = scan.nextInt();\n        float interest = amount * time * rate;\n\n        System.out.println(&quot;Your interest amount is - &quot;\n                + interest);\n    }\n\n}\n<\/pre>\n
    This is the program. It demonstrates how we scan for the most basic data types, integer, string and float. The methods that scan the specific data types return that value, which was used to initialise the variables in the above program. The one new thing there is while printing, we can use the “+” operator to concatenate the strings. The other is the import<\/span><\/b> statement. It is used to include library files. You can think of it as #include<\/span><\/b> of C for now. It was used to include the Scanner class which is in java.util<\/strong>.<\/p>\n
    Now, let’s look at the various operators in Java and later, we will have some really cool discussion about the data types. The operators are very much like the operators in C. So, if you know C well, you enjoy the dividends of your efforts here, otherwise, you pay for your sins…! \ud83d\ude1b<\/p>\n
    Arithmetic Operators in Java<\/h3>\n\n\n\n\n<\/colgroup>\n\n\n\n\n\n\n\n\n\n
     
    Operator<\/th>\nMeaning<\/th>\nExample<\/th>\n<\/tr>\n
    +<\/td>\nAddition<\/td>\n\n
    \nint a = 10;\nint b = a + 10; \/\/ 20\n<\/pre>\n<\/td>\n<\/tr>\n
    –<\/td>\nSubtraction<\/td>\n\n
    \nint a = 10;\nint b = a - 5; \/\/ 5\n<\/pre>\n<\/td>\n<\/tr>\n
    *<\/td>\nMultiplication<\/td>\n\n
    \nint a = 10;\nint b = a * 7; \/\/ 70\n<\/pre>\n<\/td>\n<\/tr>\n
    \/<\/td>\nDivision<\/td>\n\n
    \nint a = 50;\nint b = a \/ 5; \/\/ 10\n<\/pre>\n<\/td>\n<\/tr>\n
    %<\/td>\nRemainder \/ Modulo<\/td>\n\n
    \nint a = 11;\nint b = a % 3; \/\/ 2\n<\/pre>\n<\/td>\n<\/tr>\n
    ++<\/td>\nIncrement<\/td>\n\n
    \nint a = 10;\n++a; \/\/ 11\na++; \/\/ 12\n<\/pre>\n<\/td>\n<\/tr>\n
    —<\/td>\nDecrement<\/td>\n\n
    \nint a = 10;\na--; \/\/ 9\n--a; \/\/ 8\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
    Relational Operators in Java<\/h3>\n\n\n\n\n<\/colgroup>\n\n\n\n\n\n\n\n\n
     
    Operator<\/th>\nMeaning<\/th>\nExample<\/th>\n<\/tr>\n
    <<\/td>\nless than<\/td>\n\n
    \nint a = 10, b = 20;\n\nif (a &lt; b) {\n    \/\/ true\n}\n<\/pre>\n<\/td>\n<\/tr>\n
    ><\/td>\ngreater than<\/td>\n\n
    \nint a = 10, b = 20;\n\nif (a &gt; b) {\n    \/\/ false\n}\n<\/pre>\n<\/td>\n<\/tr>\n
    <=<\/td>\nless than or equal to<\/td>\n\n
    \nint a = 10;\n\nif (a &lt;= 10) {\n    \/\/ true\n}\n<\/pre>\n<\/td>\n<\/tr>\n
    >=<\/td>\ngreater than or equal to<\/td>\n\n
    \nint b = 20;\n\nif (b &gt;= 20) {\n    \/\/ true\n}\n<\/pre>\n<\/td>\n<\/tr>\n
    ==<\/td>\nis it equal to<\/td>\n\n
    \nint a = 10, b = 20;\n\nif (a == b) {\n    \/\/ false\n}\n<\/pre>\n<\/td>\n<\/tr>\n
    !=<\/td>\nis not equal to<\/td>\n\n
    \nint a = 10, b = 20;\n\nif (a != b) {\n    \/\/ true\n}\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
    Logical Operators in Java<\/h3>\n\n\n\n\n<\/colgroup>\n\n\n\n\n\n
     
    Operator<\/th>\nMeaning<\/th>\nExample<\/th>\n<\/tr>\n
    &&<\/td>\nAND<\/td>\n\n
    \nboolean a = true, b = false;\n\nif (a &amp;&amp; b) {\n    \/\/ false\n}\n<\/pre>\n<\/td>\n<\/tr>\n
    ||<\/td>\nOR<\/td>\n\n
    \nboolean a = true, b = false;\n\nif (a || b) {\n    \/\/ true\n}\n<\/pre>\n<\/td>\n<\/tr>\n
    !<\/td>\nNOT<\/td>\n\n
    \nboolean a = true;\n\nif (!a) {\n    \/\/ false\n}\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
    Bitwise Operators in Java<\/h3>\n\n\n\n\n<\/colgroup>\n\n\n\n\n\n\n\n\n\n
     
    Operator<\/th>\nMeaning<\/th>\nExample<\/th>\n<\/tr>\n
    &<\/td>\nbitwise AND<\/td>\n\n
    \nint a = 2;\n\na = a &amp; 1; \/\/ 0\n<\/pre>\n<\/td>\n<\/tr>\n
    |<\/td>\nbitwise OR<\/td>\n\n
    \nint a = 2;\n\na = a | 1; \/\/ 3\n<\/pre>\n<\/td>\n<\/tr>\n
    ^<\/td>\nbitwise XOR<\/td>\n\n
    \nint a = 3;\n\na = a ^ 1; \/\/ 2\n<\/pre>\n<\/td>\n<\/tr>\n
    ~<\/td>\nbitwise NOT \/ complement<\/td>\n\n
    \nint  a = 8;\n\na = ~a; \/\/ -9\n\/\/ 2's complement\n<\/pre>\n<\/td>\n<\/tr>\n
    <<<\/td>\nleft shift<\/td>\n\n
    \nint a = 8;\n\na = a &lt;&lt; 1; \/\/ 16\n<\/pre>\n<\/td>\n<\/tr>\n
    >><\/td>\nright shift<\/td>\n\n
    \nint a = 8;\n\na = a &gt;&gt; 1; \/\/ 4\n<\/pre>\n<\/td>\n<\/tr>\n
    >>><\/td>\nright shift with zero fill<\/td>\n\n
    \nint a = 8;\n\na = a &gt;&gt;&gt; 1; \/\/ 4\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
    Shorthand Operators<\/h3>\n\n\n\n\n<\/colgroup>\n\n\n\n\n\n\n\n
     
    Operator<\/th>\nMeaning<\/th>\nExample<\/th>\n<\/tr>\n
    x += 1;<\/td>\nx = x + 1;<\/td>\n\n
    \nint a = 2;\n\na += 1; \/\/ 3\n<\/pre>\n<\/td>\n<\/tr>\n
    x -= 1;<\/td>\nx = x – 1;<\/td>\n\n
    \nint a = 8;\n\na -= 1; \/\/ 7\n<\/pre>\n<\/td>\n<\/tr>\n
    x *= 2;<\/td>\nx = x * 2;<\/td>\n\n
    \nint a = 8;\n\na *= 2; \/\/ 16\n<\/pre>\n<\/td>\n<\/tr>\n
    x \/= 2;<\/td>\nx = x \/ 2;<\/td>\n\n
    \nint a = 8;\n\na \/= 2; \/\/ 4\n<\/pre>\n<\/td>\n<\/tr>\n
    x %= 2;<\/td>\nx = x % 2;<\/td>\n\n
    \nint a = 8;\n\na %= 2; \/\/ 0\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
    Operator Precedence in Java<\/h3>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
    Operator<\/th>\nMeaning<\/th>\n<\/tr>\n
    .<\/td>\nMember Selection<\/td>\n<\/tr>\n
    function()<\/td>\nFunction Call<\/td>\n<\/tr>\n
    arr[]<\/td>\nArray’s\u00a0Random\u00a0Access<\/td>\n<\/tr>\n
    -var<\/td>\nUnary Minus<\/td>\n<\/tr>\n
    var++<\/td>\nPostfix Increment<\/td>\n<\/tr>\n
    var–<\/td>\nPostfix Decrement<\/td>\n<\/tr>\n
    ++var<\/td>\nPrefix Increment<\/td>\n<\/tr>\n
    –var<\/td>\nPrefix Decrement<\/td>\n<\/tr>\n
    !<\/td>\nLogical Negation<\/td>\n<\/tr>\n
    ~<\/td>\nComplement<\/td>\n<\/tr>\n
    (data_type)<\/td>\nType Casting<\/td>\n<\/tr>\n
    *<\/td>\nMultiplication<\/td>\n<\/tr>\n
    \/<\/td>\nDivision<\/td>\n<\/tr>\n
    %<\/td>\nModulo Division<\/td>\n<\/tr>\n
    +<\/td>\nAddition<\/td>\n<\/tr>\n
    –<\/td>\nSubtraction<\/td>\n<\/tr>\n
    <<<\/td>\nLeft Shift<\/td>\n<\/tr>\n
    >><\/td>\nRight Shift<\/td>\n<\/tr>\n
    >>><\/td>\nRight Shift with Zero\u00a0Fill<\/td>\n<\/tr>\n
    <<\/td>\nLess than<\/td>\n<\/tr>\n
    <=<\/td>\nLess than or equal to<\/td>\n<\/tr>\n
    ><\/td>\nGreater than<\/td>\n<\/tr>\n
    >=<\/td>\nGreater than or equal to<\/td>\n<\/tr>\n
    instanceof<\/td>\nObject-Class comparison<\/td>\n<\/tr>\n
    ==<\/td>\nIs it equal to<\/td>\n<\/tr>\n
    !=<\/td>\nIs not equal to<\/td>\n<\/tr>\n
    &<\/td>\nBitwise AND<\/td>\n<\/tr>\n
    ^<\/td>\nBitwise XOR<\/td>\n<\/tr>\n
    |<\/td>\nBitwise OR<\/td>\n<\/tr>\n
    &&<\/td>\nLogical AND<\/td>\n<\/tr>\n
    ||<\/td>\nLogical OR<\/td>\n<\/tr>\n
    (condition) ? true : false<\/td>\nTernary Operator<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
    These are the precedence levels. We still haven’t discussed a few operators, such as instanceof<\/span><\/b>. We will discuss them soon when we talk more about classes. You need not mug up the whole hierarchy, but if you have an idea of the hierarchy between the arithmetic operators, relational operators and logical operators, it’s enough, because those are the most frequently used ones. But if you ever need, you can always come here to lookup the precedence levels of various operators.<\/p>\n
    Automatic Type Conversions<\/h3>\n
    Java employs “widening type conversion<\/strong>” between the primitive data types. Which means that if a binary operator has operands of two different data types, the data type of the result will be the data type of the bigger operator (which occupies more memory). And an operation between a floating point operand \u00a0and an integer type operand always yield\u00a0a floating point result. This is because Java considers integer-to-floating-point to be a widening conversion. The widening conversion is safe and integer-to-floating-point conversion preserves accuracy. All through, we talked about the data type of the resulting expression. The value which is stored may ultimately depend on the LHS variable.<\/p>\n
    This is the automatic type conversion in Java. The widening type conversion is implicit, that is, it is done by Java automatically. But, sometimes we may want to do a narrowing type conversion. We can do this, but we must ask Java explicitly for it, by using the type casting syntax.<\/p>\n
    LHS \u00a0= (data_type) (expression)<\/strong><\/p>\n
    It is a good practice to enclose the expression in parenthesis too, so that we can avoid logical errors, because type casting has a very\u00a0high precedence.<\/p>\n
    Here are some examples –<\/p>\n
    \npublic class CircleArea {\n\n    public static void main(String[] args) {\n        float radius = 49f \/ 13;   \/\/ 3.7692308\n\n        System.out.println(radius * Math.PI);\n        \/\/ 11.841387924765852\n\n        int area = (int) (2 * radius * Math.PI);\n\n        System.out.println(area);   \/\/ 23\n    }\n\n}\n<\/pre>\n
    The points to be noted in the program are –<\/p>\n
      \n
    • Math.PI is of type double<\/span><\/b> which has the value of\u00a0\u03a0. It is multiplied with a float<\/span><\/b> number, giving a double<\/span><\/b>, demonstrating the widening type conversion.<\/li>\n
    • If you don’t enclose the expression within parenthesis, it’s a compilation error, saying, “incompatible types: possible lossy conversion from double to int”. This is because of the precedence of the type casting.<\/li>\n<\/ul>\n
      Default Numeric Data Types<\/h3>\n
      We must take a small note on how Java treats numeric data types. There are only two things to keep in mind –<\/p>\n
      Firstly, whenever Java sees a constant floating point number in an expression, it treats its data type to be double<\/span>, not float<\/span><\/strong>. So, the declaration –<\/p>\n
      \nfloat f = 3.14;\n<\/pre>\n
      Gives a compilation error, saying, “incompatible types: possible lossy conversion from double to float”. So, what Java is doing here is –<\/p>\n
        \n
      • It treats the floating point constant, 3.14, as a double<\/span><\/b> value.<\/li>\n
      • It tries to convert the value to what is expected, which is float<\/span><\/b>.<\/li>\n
      • If it feels that the conversion may cause a loss of information, it gives a compilation error, saying “incompatible types: possible lossy conversion from ____ to _____”.<\/li>\n
      • If it is so, we must explicitly type cast the value to the required data-type.<\/li>\n<\/ul>\n
        Remember, there can possibly be a loss of conversion only, if we are assigning a bigger data type (here double<\/span><\/b>), to a smaller data type (float<\/span><\/b>). So, the remedy for initialising float<\/span><\/b> variables is –<\/p>\n
        \nfloat num = (float) 3.14;\nfloat var = 3.14f;\n<\/pre>\n
        The first is type casting, and the second is giving a suffix ‘f<\/strong>‘, to tell Java to treat it as a float<\/span><\/b> number. Be careful and keep these concepts in mind because we will use them again very shortly.
        \nSecondly, whenever Java sees an integer constant, it treats its data type to be int<\/span><\/strong>. So, this declaration will cause an error –<\/p>\n
        \nbyte b = 12345;\n<\/pre>\n
        Therefore, we must use type casting –<\/p>\n
        \nbyte b = (byte) 12345;\n<\/pre>\n
        In that case, what value is stored in the variable b<\/em>..? We know that 12345\u00a0won’t fit in a byte<\/span><\/b>. In such a situation, the excess bits\u00a0are truncated<\/strong>..! So, the variable b<\/em> would take only the first 8 bytes of 12345 (0011000000111001), that is 00111001… From the right..! \ud83d\ude09 … So, the variable b<\/em> has the value 57. And don’t forget that the last bit is used for the sign..!<\/p>\n
        The same goes when we want to initialise long<\/span><\/b> variables. The following initialisation won’t work –<\/p>\n
        \nlong l = -123456789123456;\n<\/pre>\n
        But we all know that the given constant is well within the range of long<\/span><\/b>. The compiler gives an error saying, “integer number too large: -123456789123456”. And we know why..! Java is treating the integer constant’s data type to be int<\/span><\/b>..! And what’s worse, type casting won’t work here..! Why would it work..? We can’t even store the value in the first place…! So, how on earth could we initialize double<\/span><\/b> variables…? We can do, by giving a suffix, ‘l’ or ‘L’ to tell Java to treat it as a long<\/span><\/b>\u00a0value –<\/p>\n
        \nlong l = -123456789123456l;\n<\/pre>\n
        This is a little advanced discussion about the data types in Java. I can perfectly understand if you don’t follow me on this topic… \ud83d\ude42 … But I wan’t you to remember how to initialize float<\/span><\/b>, byte<\/span><\/b> and long<\/span><\/b> variables.<\/p>\n
        What Compliers\u00a0know and don’t…!<\/h3>\n
        This too, is a little advanced discussion, feel free to skip this…! \ud83d\ude09 …. I hope you got an idea about the problem we faced with –<\/p>\n
        \nbyte b = 12345;\n<\/pre>\n
        Now, what if we do something like –<\/p>\n
        \nbyte b = 57;\n<\/pre>\n
        Does this too cause a compilation error..? No..! This is because, Java knows that 57 is well within the range of byte<\/span><\/b>. So there is no “lossy conversion” here. So, Java does not complaint…! Feeling good..? Check this out..!<\/p>\n
        \nint num = 57;\nbyte b = num;\n<\/pre>\n
        This gives a compilation error..! Regarding assigning the value of num<\/em> to b<\/em>, the compiler repeats its dull old story, “incompatible types: possible lossy conversion from int to byte”. Now what is this…? We know that logically, we are trying to assign 57 to b<\/em>, which seems to be perfectly all right..! So, what’s the compiler whining about…?
        \nThe thing is that – “A compiler knows about the data types only. It knows nothing about the values<\/strong>“. This is because values are a runtime stuff. So, when the compiler comes to Line 2, it sees that we are assigning a variable of type int<\/span><\/b> to byte<\/span><\/b>. It knows that the range of int<\/span><\/b> is more than that of byte<\/span><\/b>, so there is a possibility of information loss during the conversion. This is why the compiler gives an error.
        \nBut then, the 57 being assigned to num<\/em> on Line 1.. isn’t that a value..? Well, yes, we are assigning a value, but what we are assigning is a constant. A constant is not a runtime stuff, it does not change, but a variable could change. I could to hell a lot of computation between Line 1 and 2. So, Java doesn’t want to take a chance, so it gives a compilation error, which can be resolved by explicit type casting.<\/p>\n
        So, golden rule here is that the compiler doesn’t know about the values. This is a very very important one..! This can be used in many places and is really helpful in solving problems, which would otherwise baffle other programmers..! So, trust me, you’ve just added something really powerful in your arsenal..! \ud83d\ude09 … And, you are a real genius if you already know this..! \ud83d\ude1b<\/p>\n
        Summary<\/h3>\n
          \n
        • The primitive data types in Java are divided to numeric and non-numeric. The numeric data types are –\n
            \n
          • byte<\/span><\/b> – 1 Byte<\/li>\n
          • short<\/span><\/b> – 2 Bytes<\/li>\n
          • int<\/span><\/b> – 4 Bytes<\/li>\n
          • long<\/span><\/b> – 8 Bytes<\/li>\n
          • float<\/span><\/b> – 4 Bytes – up to 7 digits of precision<\/li>\n
          • double<\/span><\/b> – 8 Bytes – up to 15 digits of precision<\/li>\n<\/ul>\n
            The non-numeric data types are –<\/p>\n
              \n
            • char<\/span><\/b> – 2 Bytes – But holds only up to 1 character<\/li>\n
            • boolean<\/span><\/b> – 1 Bit<\/li>\n<\/ul>\n<\/li>\n
            • We take input from the user using the functions in Scanner Class. Some of the useful functions are (if “scan” is the Object Reference) –\n
                \n
              • scan.nextLine() – to scan a String<\/li>\n
              • scan.nextInt() – to scan a int<\/span><\/b>.<\/li>\n
              • scan.nextLong() – to scan a long<\/span><\/b>.<\/li>\n
              • scan.nextFloat() – to scan a float<\/span><\/b>.<\/li>\n
              • scan.nextDouble() – to scan a double<\/span><\/b>.<\/li>\n<\/ul>\n<\/li>\n
              • The operators in Java are much like the operators in C.<\/li>\n
              • Java employs widening automatic type conversion.<\/li>\n
              • We initialize the respective data types as follows –\n
                \nfloat var1 = 5.1236f;\nfloat var2 = (float) 5.1236;\nlong var3 = 12346876314l;\nbyte var4 = (byte) 12345;\n<\/pre>\n<\/li>\n
              • A compiler knows about the data types only. It knows nothing about the values.<\/li>\n<\/ul>\n
                Practice<\/h3>\n
                  \n
                • There is really nothing challenging except for the discussions we had on the data types. I don’t want to give problem which asks you to lookup into the table of precedence levels. It is monotonous. So, it only makes sense to work a little on the data types. So, try to make a table between data types and fill out the table with either “implicit” or “explicit” or “not possible” according to the type of conversion required between those two data types. Try to include all types of primitive data types.<\/li>\n<\/ul>\n
                  This was to get you started with the data types in Java. It is very much like C. So, I hope you were comfortable with this post. Feel free to comment your doubts..! We will cover more topics in another post… Till then… Keep practising…! Happy Coding…! \ud83d\ude00<\/p>\n","protected":false},"excerpt":{"rendered":"
                  Hello people…! This is a new post in Java Tutorials \u2013 Data Types, Input and Operators in Java. In my previous post, […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[9],"tags":[24,62,63,64,67,98],"class_list":["post-1046","post","type-post","status-publish","format-standard","hentry","category-java","tag-automatic-type-conversion","tag-java","tag-java-compiler","tag-java-data-types","tag-java-tutorials","tag-scanner-class"],"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"","jetpack-related-posts":[],"_links":{"self":[{"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/posts\/1046","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/comments?post=1046"}],"version-history":[{"count":4,"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/posts\/1046\/revisions"}],"predecessor-version":[{"id":3952,"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/posts\/1046\/revisions\/3952"}],"wp:attachment":[{"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/media?parent=1046"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/categories?post=1046"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/tags?post=1046"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}