Type casting in Java - Step-by-Step Execution

Concept Flow - Type casting

Start with a value

↓

Check target type

↓

Perform cast

↓

Use casted value

↓

End

Type casting changes a value from one type to another, either automatically or by explicit instruction.

Execution Sample

Java

int i = 100;
byte b = (byte) i;
System.out.println(b);

This code converts an int value to a byte using explicit casting and prints the result.

Execution Table

Step	Action	Value Before	Cast Type	Value After	Output
1	Declare int i	N/A	int	100	N/A
2	Cast int i to byte b	100	byte	100	N/A
3	Print byte b	100	byte	100	100

💡 Program ends after printing the casted byte value.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
i	undefined	100	100	100
b	undefined	undefined	100	100

Key Moments - 2 Insights

Why do we need to use (byte) before i when assigning to b?

Because int is larger than byte, Java requires explicit cast to avoid data loss, as shown in step 2 of the execution_table.

What happens if the int value is too big for byte?

The value wraps around due to overflow, changing the stored byte value. This is not shown here but is important to remember.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of b after step 2?

A 0

B 100

C -100

D undefined

💡 Hint

Check the 'Value After' column in row for step 2.

At which step is the value printed to the console?

A Step 1

B Step 2

C Step 3

D No step prints

💡 Hint

Look at the 'Output' column in the execution_table.

If we remove (byte) cast, what will happen?

A Compilation error due to incompatible types

B Runtime error occurs

C Code compiles and runs fine

D Value of b becomes zero

💡 Hint

Java requires explicit cast when assigning int to byte, see step 2 explanation.

Concept Snapshot

Type casting changes a value's type.
Implicit cast happens automatically if safe.
Explicit cast uses (type) before value.
Casting from larger to smaller type may lose data.
Example: byte b = (byte) intValue;

Full Transcript

This example shows type casting in Java. We start with an int variable i set to 100. Then we explicitly cast i to a byte and assign it to b. Finally, we print b. The execution table shows each step: declaring i, casting to b, and printing. The variable tracker shows how i and b change. Key points: explicit cast is needed when going from int to byte to avoid errors. If the int value is too large, casting can cause overflow. The quiz checks understanding of value changes and casting rules.

Practice

1.

What is type casting in Java?

easy

A. Writing a loop

B. Creating a new variable

C. Declaring a method

D. Changing a value from one data type to another

Solution

1. Step 1: Understand the meaning of type casting

   Type casting means converting a value from one data type to another, like from int to double or vice versa.

2. Step 2: Identify the correct description

   Among the options, only changing a value's data type matches the definition of type casting.

3. Final Answer:

   Changing a value from one data type to another -> Option D

4. Quick Check:

   Type casting = Changing data type [OK]

Hint: Type casting means changing data types [OK]

Common Mistakes:

• Confusing type casting with variable declaration
• Thinking type casting creates new variables
• Mixing type casting with control structures

2.

Which of the following is the correct syntax for explicit type casting from double to int in Java?

easy

A. int x = (int) 3.14;

B. int x = int(3.14);

C. int x = 3.14 as int;

D. int x = cast int 3.14;

Solution

1. Step 1: Recall Java explicit casting syntax

   In Java, explicit casting uses parentheses with the target type before the value, like (int) value.

2. Step 2: Match syntax with options

   Only int x = (int) 3.14; uses the correct syntax: int x = (int) 3.14;. Others are invalid in Java.

3. Final Answer:

   int x = (int) 3.14; -> Option A

4. Quick Check:

   Explicit cast uses (type) value [OK]

Hint: Use (type) before value for explicit cast [OK]

Common Mistakes:

• Using function-like cast syntax (e.g., int(3.14))
• Using 'as' keyword which Java doesn't support
• Writing 'cast' keyword which is invalid

3.

What is the output of the following Java code?

double d = 9.99;
int i = (int) d;
System.out.println(i);

medium

A. 9.99

B. 10

C. 9

D. Compilation error

Solution

1. Step 1: Understand explicit cast from double to int

   Casting a double to int truncates the decimal part, it does not round.

2. Step 2: Apply casting to value 9.99

   When casting 9.99 to int, the decimal .99 is dropped, resulting in 9.

3. Final Answer:

   9 -> Option C

4. Quick Check:

   Double to int cast truncates decimals = 9 [OK]

Hint: Casting double to int drops decimals, no rounding [OK]

Common Mistakes:

• Assuming casting rounds the number
• Expecting compilation error due to cast
• Confusing output with original double value

4.

Identify the error in the following Java code snippet:

byte b = 130;

medium

A. Type mismatch: possible lossy conversion from int to byte

B. No error, code runs fine

C. Syntax error: missing cast operator

D. Runtime exception: value too large

Solution

1. Step 1: Understand byte range in Java

   Byte type can hold values from -128 to 127 only.

2. Step 2: Check assigned value 130

   130 is outside byte range, so Java reports a compile-time error about possible lossy conversion.

3. Final Answer:

   Type mismatch: possible lossy conversion from int to byte -> Option A

4. Quick Check:

   Byte range exceeded causes compile error [OK]

Hint: Byte values must be between -128 and 127 [OK]

Common Mistakes:

• Thinking code runs without error
• Expecting runtime exception instead of compile error
• Missing need for explicit cast

5.

Given the code below, what will be the output?

int a = 300;
byte b = (byte) a;
System.out.println(b);

Note: byte range is -128 to 127.

hard

A. 44

B. -56

C. 300

D. Compilation error

Solution

1. Step 1: Understand casting int 300 to byte

   When casting int to byte, Java keeps only the lowest 8 bits of the int value.

2. Step 2: Calculate byte value from 300

   300 in binary is 00000001 00101100 (16 bits). The lowest 8 bits are 00101100 (decimal 44).

3. Step 3: Confirm signed byte value

   300 mod 256 = 44. However, since byte is signed, the value wraps around to -56.

4. Final Answer:

   -56 -> Option B

5. Quick Check:

   Int to byte cast wraps around signed byte range = -56 [OK]

Hint: Casting int to byte keeps lowest 8 bits and wraps signed range [OK]

Common Mistakes:

• Assuming output is original int value
• Confusing signed byte range with unsigned
• Expecting compilation error without cast