Data Type

Explanation:

• byte num1 = 120;: Here, a variable named num1 of type byte is declared and assigned the value 120. In Java, byte is an 8-bit signed integer data type that can hold values from -128 to 127. Since 120 is within this range, it is a valid value for a byte variable.
• byte num2 = -127;: Here, another variable named num2 of type byte is declared and assigned the value –127. Since num2 is declared as a byte, it can hold values from -128 to 127. Hence, –127 is also a valid value for this variable.
• The System.out.println() statements are used to print the values of num1 and num2 on the console:
• This will print: num1 = 120
• This will print: num2 = -127
• The output will display the values assigned to num1 and num2 as strings concatenated with the corresponding variable names.

Short Data Type:

In Java, the short data type is a 16-bit signed integer data type. It can store whole numbers in the range from -32,768 to 32,767. The short data type is used to save memory when you know that the values you are working with will fall within this range.

public class ShortDataTypeExapmle{
     public static void main(String[] args) {
         short n1 = 23575;
         short n2 = 13257;
         System.out.println(n1+n2);
     }
}

Explanation:

• short n1 = 23575;: In this line, a variable named n1 of type short is declared and initialized with the value 23575. Since n1 is of type short, it can store values in the range from -32,768 to 32,767, and 23575 is within this valid range.
• short n2 = 13257;: In this line, another variable named n2 of type short is declared and initialized with the value 13257. Like n1, n2 can also store values within the range from -32,768 to 32,767, and 13257 is a valid value for a short variable.
• System.out.println(n1 + n2);: In this line, you are performing the addition operation on n1 and n2. Since both n1 and n2 are of type short, the addition will be performed as a short arithmetic operation.
• However, here comes the important part: The result 36832 exceeds the maximum value that a short data type can hold, which is 32767. When the result of the addition exceeds the valid range for a short, an overflow occurs.
• In Java, when an overflow occurs for short, the value wraps around to the minimum value (-32,768) and continues from there. So, 36832 – 32768 is equal to 4074. The value 4074 is the result of the overflow.
• This behavior is a consequence of how two’s complement representation works for signed integer types like short in Java. Always be cautious of potential overflows when working with data types that have limited ranges. If the result might exceed the valid range, consider using a larger data type, such as int or long, to avoid unexpected behavior.

Int Data Type:

In Java, the int data type is a 32-bit signed integer data type. It can store whole numbers in the range from -2,147,483,648 to 2,147,483,647. The int data type is one of the most commonly used data types for representing integers in Java due to its wide range of values.

public class IntDataTypeExample{
     public static void main(String[] args) {
         int firstNumber;
         firstNumber = 12333468;
         int secondNumber;
         secondNumber = 27;
         System.out.println("secondNumber = " + secondNumber);

         System.out.println("firstNumber = " + firstNumber);
     }
}

Long Data Type:

A 64-bit signed integer data type is the Java equivalent of a long data type. It can store whole numbers in the range from approximately -9.2 quintillion (-9,223,372,036,854,775,808) to 9.2 quintillion (9,223,372,036,854,775,807). The long data type allows you to work with larger integer values than the int data type, but it uses more memory to store the values.

public class LongDataTypeExample{
     public static void main(String[] args) {
          long n1 = 23575234579800L;
          long n2 = 1325734567 ;
          System.out.println("Result is: " + (n1 -n2));
     }
}

Explanation:

• long n1 = 23575234579800L;: In this line, a variable named n1 of type long is declared and initialized with the value 23575234579800L. The ‘L’ at the end of the literal value indicates that it is of type long.
• long n2 = 1325734567;: In this line, another variable named n2 of type long is declared and initialized with the value 1325734567. The absence of ‘L’ at the end of the literal value is acceptable because the value 1325734567 fits within the range of int as well as long.
• System.out.println(“Result is: ” + (n1 – n2));: In this line, the subtraction operation (n1 – n2) is performed. Since both n1 and n2 are of type long, the subtraction will be carried out using long arithmetic.
• The result of the subtraction, 23575233254033, is a long value. To print this result along with the message “Result is: “, the + operator is used for string concatenation. The numeric result is converted to a string, and then combined with the message to be displayed on the console.
• This output represents the result of the subtraction of n2 from n1, with the result being a long value.

Float Data Type:

In Java, the float data type is a single-precision 32-bit floating-point data type. It is used to represent decimal numbers with fractional parts. The float data type provides a good balance between precision and memory usage, making it suitable for scenarios where a wider range of values with reasonable precision is required.

public class FloatDataTypeExample{
     public static void main(String[] args) {
          float salary1 = 45.98F;
          int salary2 = 789;
          System.out.println("total: " + (salary1 + salary2));
     }
}

Explanation:

• float salary1 = 45.98F;: In this line, a variable named salary1 of type float is declared and initialized with the value 45.98F. The ‘F’ at the end of the literal value indicates that it is of type float.
• int salary2 = 789;: In this line, another variable named salary2 of type int is declared and initialized with the value 789. The value 789 is within the valid range for an int data type.
• System.out.println(“total: ” + (salary1 + salary2));: In this line, the addition operation (salary1 + salary2) is performed. Since salary1 is of type float and salary2 is of type int, the addition will be performed as a floating-point addition.
• The result of the addition, 834.98, is a float value. To print this result along with the message “total: “, the + operator is used for string concatenation. The numeric result is converted to a string, and then combined with the message to be displayed on the console.
• This output represents the total sum of salary1 and salary2, with the result being a float value. The floating-point value 45.98 was added to the integer value 789, resulting in a floating-point value 834.98.

Double Data Type:

In Java, the double data type is a double-precision 64-bit floating-point data type. It is used to represent decimal numbers with a higher range and more significant digits of precision compared to the float data type. The double data type is suitable for scenarios where a wide range of values with increased precision is required.

public class DoubleDataTypeExample{
     public static void main(String[] args) {
          double saalry = 29.99d;
          System.out.println("salary  is: " + saalry);
     }
}

Explanation:

• double salary = 29.99d;: In this line, a variable named salary of type double is declared and initialized with the value 29.99d. The ‘d’ at the end of the literal value indicates that it is of type double. While the ‘d’ suffix is not strictly necessary for double literals, it is a good practice to include it to make the code more explicit and avoid any potential confusion.
• System.out.println(“salary is: ” + salary);: In this line, the value of the salary variable is printed to the console. The + operator is used for string concatenation, which means the numeric value of salary will be converted to a string, and then combined with the message “salary is: “.
• The value of the salary variable is 29.99. When this value is combined with the message “salary is: “, it forms the following string: salary is : 29.99.
• This is the output that will be printed on the console. It displays the message “salary is: “ followed by the value of the salary variable, which is 29.99.
• In summary, the code initializes a double variable named salary with the value 29.99 and then prints the message “salary is: “ along with the value of the salary variable on the console. The output will be the concatenation of the message and the value, displaying salary is: 29.99.

Char Data Type:

In Java, the char data type is used to represent single characters. It is a 16-bit unsigned data type that can store any single Unicode character. The char data type is used to handle individual characters, such as letters, digits, punctuation marks, and other special characters.

public class calculation {
      public static void main(String[] args) {
        char ch1;
        char ch2;
          
        ch1 = 82;
        ch2 = 'H';
        System.out.println("The value of ch1 and ch2");
        System.out.println(ch1 + " " + ch2);
     }
}

• We know that java has eight data types. Boolean is one of them. This data type returns only true or false.
• Boolean values are mostly used for conditional testing.

Example:

public class BooleanDataTypeExample{
     public static void main(String[] args) {
          boolean isJavaFun = true;
          boolean isJavaHard = false;
          System.out.println("is java fun? " +isJavaFun);
          System.out.println("is java hard? " +isJavaHard);
     }
}

Output: