Java Generics Interview Questions and Answers for 7 years experience

1. What are Generics in Java?

   • Answer: Generics allow you to write type-safe code that can be used with different data types without sacrificing type safety. They provide compile-time type checking, eliminating the need for casting and reducing runtime errors associated with type mismatches. Essentially, they parameterize types.

2. Explain the benefits of using Generics.

   • Answer: Generics offer several key benefits: improved type safety (catching errors at compile time), increased code reusability (writing code once and using it with various types), improved code readability (making code intent clearer), and reduced code bloat (avoiding unnecessary casting and boxing/unboxing).

3. What is a generic class? Give an example.

   • Answer: A generic class is a class that is parameterized by one or more type parameters. Example: public class Box<T> { private T value; // ... methods ... } This defines a `Box` class that can hold any type `T`.

4. What is a generic interface? Give an example.

   • Answer: A generic interface is similar to a generic class, but it defines a contract for methods rather than implementing them. Example: public interface DataProcessor<T> { T process(T data); }

5. What is a generic method? Give an example.

   • Answer: A generic method is a method that uses type parameters. Example: public <T> T identity(T arg) { return arg; } This method returns the same value passed to it, for any type T.

6. Explain wildcards in generics.

   • Answer: Wildcards provide flexibility when working with generic types. `?` represents an unknown type. `? extends Number` means any type that is a subtype of Number (e.g., Integer, Double). `? super Integer` means any type that is a supertype of Integer (e.g., Number, Object).

7. What is the difference between `List` and `List`?

   • Answer: `List` is a list that specifically holds Integers. `List` is a list that can hold objects of any type, but you cannot add elements to it without knowing the exact type at compile time (except for null).

8. Explain `List` and `List`.

   • Answer: `List` can hold lists of Number or any of its subtypes (Integer, Double, etc.). You can read Number objects from it, but cannot add anything except null. `List` can hold lists of Integer or any of its supertypes (Number, Object). You can add Integers to it, but cannot read out specific types without casting.

9. What are bounded wildcards? Give examples.

   • Answer: Bounded wildcards specify constraints on the type parameter. `? extends Number` is an upper bound, meaning the type must be Number or a subtype. `? super Integer` is a lower bound, meaning the type must be Integer or a supertype.

10. How do you handle generic type erasure?

    • Answer: Generic type information is erased at runtime. To retain type information at runtime, you can use reflection or design your code to avoid relying on runtime type information. Often, using instanceof checks or casting is necessary when working with collections after type erasure.

11. Explain the concept of type inference in Java generics.

    • Answer: Type inference allows the compiler to deduce the type arguments of a generic method or class based on the context. This reduces the need to explicitly specify type parameters.

12. Can you have a generic array? Why or why not?

    • Answer: No, you cannot directly create a generic array like `T[]`. This is due to type erasure; at runtime, the compiler doesn't know the specific type of T, making array creation problematic. You can use `List` as a workaround.

13. What is a raw type? When should you avoid them?

    • Answer: A raw type is a generic type without type parameters (e.g., `List` instead of `List`). Avoid them because they defeat the purpose of generics, leading to potential runtime type errors and losing compile-time type safety.

14. Explain covariance, contravariance, and invariance in generics.

    • Answer: Covariance: `List` is covariant; if you have `List`, you can treat it as `List`. Contravariance: `List` is contravariant; a method taking `List` can accept `List`. Invariance: `List` is invariant; `List` cannot be used where `List` is expected.

15. How can you use generics with exceptions?

    • Answer: You can create generic exception classes to handle different types of errors related to the generic type. For instance, `class MyGenericException<T> extends Exception { ... }`

16. Describe a situation where you used generics to improve code quality.

    • Answer: [Provide a specific example from your experience. Describe the problem, the solution using generics, and the improvements achieved (e.g., reduced code duplication, improved readability, fewer runtime errors).]

17. How do generics interact with the Java Collections Framework?

    • Answer: The Java Collections Framework heavily utilizes generics. Classes like `ArrayList`, `HashMap`, etc., are generic, allowing you to create collections that hold specific types, eliminating the need for casting and improving type safety.

Thank you for reading our blog post on 'Java Generics Interview Questions and Answers for 7 years experience'.We hope you found it informative and useful.Stay tuned for more insightful content!