Data Types and Variables : MCQs & PYQs with Explanation

Option A

In Java, byte is a primitive integer data type that always occupies 8 bits (1 byte). An 8-bit signed value uses one bit for the sign and the remaining bits for representing the magnitude. Therefore, a Java byte can represent 256 different values, ranging from -128 to 127.
The range can be calculated as: -2⁷ to 2⁷ - 1 = -128 to 127

Java Integer Data Types:

Option A

In Java, float and double are floating-point data types used to store numbers containing fractional values. The main difference between them is their size and precision.
A float occupies 32 bits (4 bytes), while a double occupies 64 bits (8 bytes). Because double has twice as many bits as float, it generally provides greater precision and a larger range of values.
class Example
{
    public static void main(String args[])
    {
        float a = 11.5f;
        double b = 22.75;
        System.out.println("Float: " +a);
        System.out.println("Double: " +b);
    }
}
OUTPUT
Float: 11.5
Double: 22.75

Option D

In Java, variables declared as class members (fields), including static variables, receive default values automatically if they are not explicitly initialized. 
The default value of an int variable is 0. Therefore, the variable i in the given program is automatically initialized to 0, and the program prints 0.

Default Values of Java Fields:

Option B

In Java, a final variable can be assigned a value once, but it does not necessarily have to be initialized at the time of declaration. When a final local variable is declared without an initial value and is assigned a value later before its first use, it is called a blank final variable. Therefore, the following code is completely valid.
The important rule is that a final variable can be assigned only once. In the given code, x is declared first and then assigned 20. Since x has not been assigned any value before, this is its first and only assignment, so the compiler accepts the code.
Also, a local final variable does not automatically receive a default value such as 0. It must be assigned before it is used.

E.g.: 1

public class FinalVariableDemo 
{
    public static void main(String args[]) 
    {
        final int x;  // Declared but not initialized
        x=20;       // Assigned for the first and only time
    }
}

E.g.: 2

public class FinalVariableDemo 
{
    public static void main(String args[])
    {
        final int x;
        x=20;
        x=30;  // Compilation Error
    }
}

Option C

In Java, the byte data type is a signed 8-bit integer. Therefore, it can store values only in the range -128 to 127. In the given statement, b is initially assigned the value 10.
In statement b=(byte)(b+200);, an important Java rule is involved, when arithmetic is performed on a byte, the value is automatically promoted to int. Therefore, b+200 is calculated as an int, i.e., 10+200 = 210.
At this stage, the result is 210, which is an int. Since 210 cannot be directly stored in a byte, the explicit cast (byte) is used.
However, 210 is outside the valid byte range of -128 to 127. When an int value is explicitly converted to a byte, Java retains the lowest 8 bits of the value. The resulting 8-bit pattern is interpreted as a signed two's-complement value.
(210)₂ = 00000000 00000000 00000000 11010010
The lowest 8 bits: 11010010
Because the leftmost bit is 1, this represents a negative number in signed 8-bit two's-complement representation. Its decimal value is 210-256 = -46.
Therefore, the value stored in b becomes -46, and System.out.println(b); prints -46.
Note:
If the explicit cast (byte) is not present, the statement produces a Compilation Error because Java promotes the byte value to int during arithmetic. Therefore, b+200 has the type int, and Java does not allow an int value to be assigned directly to a byte variable without an explicit narrowing conversion.
E.g.:
class MyDriver 
{
    public static void main(String[] args) 
    {
        byte b=10;
        b=(b+200);
        System.out.println(b);
    }
}
When we compile the code without the explicit (byte) cast, the compiler generates an error such as “incompatible types: possible lossy conversion from int to byte” at the statement b=(b+200);.

Option D

In Java, a variable declaration must follow the rules of the specified data type. Numeric literals also have default data types in Java, so assigning a literal to a variable is allowed only when the literal is compatible with the variable type.
Option (A): float f = 1.3; This statement does not compile.
In Java, a decimal floating-point literal such as 1.3 is treated as a double literal by default. A double value cannot be assigned directly to a float variable because double has greater precision and range than float.
Option (B): char c = "a"; This statement does not compile.
A char variable stores a single character, and character literals in Java must be enclosed in single quotation marks.
Option (C): byte b = 257; This statement does not compile.
A byte in Java can store values only from -128 to 127.
Option (D): int i = 10; This statement compiles without warning or error.
An integer literal such as 10 is treated as an int by default, and the variable i is also declared as int.

Option A

Java has eight primitive data types, byte, short, int, long, float, double, char, and boolean. Primitive types represent basic values and are not objects.
In contrast, classes are reference types, not primitive data types. A class is a blueprint used to create objects. Therefore, Classes is not a primitive data type.

Option C

In Java, numeric literals have specific default data types. A decimal floating-point literal such as 10.5 is treated as a double by default. If we want a decimal literal to be treated as a float, we use the suffix f or F, as in 10.5f. Java allows a float value to be automatically converted to double because double has a larger range and greater precision. Therefore, the declaration double d = 10.5f; is valid.
Option (A): float f = 10.5; [Invalid]
Here, 10.5 is a double literal by default. The variable f is of type float. Java does not automatically convert a double into a float because this conversion can result in loss of precision.
E.g.:

• float f = 10.5; // Compilation Error
• float f = (float)10.5; // Valid
• float f = 10.5f; // Valid

Option (B): long l = 2147483648; [Invalid]
In Java, an integer literal without a suffix such as L is normally treated as an int if its value can be represented by the int data type. The maximum value of an int is 2,147,483,647, whereas 2147483648 is one greater than the maximum int value. 
Therefore, the compiler cannot treat 2147483648 as an int literal, and the statement produces a Compilation Error. Although a long variable can store this value, the literal itself must be explicitly written as a long literal using the L suffix.
E.g.:

• long l = 2147483648;   // Compilation Error
• long l = 2147483648L;  // Valid

Here, L tells the compiler that 2147483648 is a long literal, so it can be assigned to the long variable.
Option (D): byte b = 128; [Invalid]
In Java, the byte data type is a signed 8-bit integer and can store values only from -128 to 127. The value 128 is outside this range, so it cannot be directly assigned to a byte variable. Therefore, the following declaration produces a Compilation Error.
E.g.:

• byte b = 128;   // Compilation Error
• byte b = 127;   // Valid

The statement byte b = (byte)128; is valid and code will compile, but the value becomes -128 because the conversion from int to byte retains the lower 8 bits of the value and interprets them using signed 2’s-complement representation.

Option D

Java provides eight primitive data types. Primitive data types are the basic data types built into the Java language. They are used to store simple values directly rather than references to objects.
The eight primitive data types are byte, short, int, long, float, double, char, and boolean.

Option A

In Java, the char data type is used to store a single Unicode character. For a char variable that is an instance variable, static variable, or array element, Java automatically assigns the default value '\u0000', which is called the null character.
It is important not to confuse the null character '\u0000' with the character '0'. The character '0' is a printable character and has the Unicode value 48, whereas '\u0000' has the numeric value 0.
E.g.:
class Example
{
    char ch;
    public static void main(String args[])
    {
        Example obj = new Example();
        System.out.println((int)obj.ch);
        System.out.println(obj.ch == '\u0000');
    }
}
OUTPUT
0
True