Type Casting in Java Interview Questions and Answers

1. What is type casting in Java?

   • Answer: Type casting, also known as type conversion, is the process of converting a variable from one data type to another. Java supports two types: implicit (automatic) and explicit (manual).

2. Explain implicit type casting with an example.

   • Answer: Implicit casting happens automatically when a smaller data type is assigned to a larger data type. No explicit conversion is needed. For example, assigning an `int` to a `double`: double d = 10; The `int` 10 is automatically widened to a `double` 10.0.

3. Explain explicit type casting with an example.

   • Answer: Explicit casting requires manual conversion using casting operators (e.g., `(int)`, `(double)`). This is necessary when converting a larger data type to a smaller one, where potential data loss may occur. Example: int i = (int) 10.5; Here, the `double` 10.5 is explicitly narrowed to an `int` 10 (the fractional part is truncated).

4. What are the different types of type casting in Java?

   • Answer: Primarily, we have widening (implicit) and narrowing (explicit) casting. Widening involves converting to a larger data type (e.g., `int` to `long`), while narrowing converts to a smaller data type (e.g., `double` to `int`).

5. What happens when you cast a larger floating-point number to an integer?

   • Answer: The fractional part of the floating-point number is truncated (discarded). For example, `(int) 3.14` results in `3`.

6. Can you cast a `String` to an `int` directly? If not, how would you do it?

   • Answer: No, you can't directly cast a `String` to an `int`. You need to use `Integer.parseInt()` method. For example: `int num = Integer.parseInt("123");`

7. What is the difference between `int` and `Integer` in Java?

   • Answer: `int` is a primitive data type, while `Integer` is its corresponding wrapper class (object). `Integer` provides methods for working with `int` values as objects, including functionalities like `parseInt()`, `toString()`, etc.

8. What is autoboxing and unboxing?

   • Answer: Autoboxing is the automatic conversion of a primitive type to its corresponding wrapper class (e.g., `int` to `Integer`). Unboxing is the reverse process – converting a wrapper class object to its primitive type (e.g., `Integer` to `int`).

9. What are the potential pitfalls of narrowing type casting?

   • Answer: Narrowing casting can lead to data loss (truncation of fractional parts) or exceptions (like `ClassCastException` if incompatible types are involved). It's crucial to handle potential loss of information appropriately.

10. How do you handle potential data loss during narrowing type casting?

    • Answer: You can check the value before casting to ensure it's within the range of the target data type. You can also round the number before casting to minimize data loss (e.g., using `Math.round()` for floating-point to integer conversions).

11. Explain the concept of casting in inheritance.

    • Answer: In inheritance, casting allows you to treat an object of a subclass as an object of its superclass (upcasting, usually implicit) or vice-versa (downcasting, explicit). Downcasting requires caution and may throw a `ClassCastException` if the object isn't actually an instance of the target subclass.

12. What is the purpose of the `instanceof` operator?

    • Answer: The `instanceof` operator checks if an object is an instance of a particular class or interface. It's essential for safe downcasting to prevent `ClassCastException`s.

13. How can you cast between different numeric types in Java?

    • Answer: Use explicit casting operators like `(byte)`, `(short)`, `(int)`, `(long)`, `(float)`, `(double)`. The compiler will perform implicit widening conversions if needed.

14. What is the difference between casting and converting data types?

    • Answer: Casting refers to changing a variable's type to another compatible type, whereas converting may involve more complex transformations (e.g., String to Integer). Casting is often a form of type conversion, but not all conversions are simple casts.

Thank you for reading our blog post on 'Type Casting in Java Interview Questions and Answers'.We hope you found it informative and useful.Stay tuned for more insightful content!