Java Generics Interview Questions and Answers for 5 years experience

What are Java Generics?

• Answer: Java Generics are a powerful feature introduced in Java 5 that allows you to write type-safe code. They enable you to parameterize types with other types, allowing you to write code that can work with various data types without losing type safety at compile time. This reduces runtime errors caused by type mismatches.

Explain the benefits of using Generics.

• Answer: Generics offer several key benefits: improved type safety (eliminating ClassCastException at runtime), increased code reusability (writing code once for various types), improved code readability (making code intent clearer), and better performance (avoiding boxing/unboxing for primitive types).

What is a generic class? Provide an example.

• Answer: A generic class is a class that uses type parameters. For example: public class Box<T> { private T value; // ... } Here, `T` is a type parameter that can be replaced with any concrete type when creating an instance of `Box`, e.g., `Box<Integer>`, `Box<String>`.

What is a generic interface? Provide an example.

• Answer: A generic interface is similar to a generic class, but defines a contract for other classes to implement. Example: public interface DataProvider<K, V> { V get(K key); } This interface uses two type parameters, `K` (key) and `V` (value).

What is type erasure? How does it work?

• Answer: Type erasure is the process by which the compiler removes generic type information during compilation. At runtime, the JVM doesn't see the generic types; they are replaced with their raw types. This ensures backward compatibility with older Java code that didn't use generics. The compiler handles type checking at compile time.

What are unbounded wildcards? Give an example.

• Answer: Unbounded wildcards use the `?` character. They represent any type. Example: List<?> list; This `list` can hold any type of List, but you can't add elements to it without knowing the specific type. You can only retrieve elements using `Object`.

What are upper-bounded wildcards? Give an example.

• Answer: Upper-bounded wildcards specify a superclass or interface as an upper bound. Example: List<? extends Number> list; This `list` can hold `Integer`, `Double`, `Float`, etc., but not any type outside the `Number` hierarchy. You can retrieve elements but can't add anything other than `null`.

What are lower-bounded wildcards? Give an example.

• Answer: Lower-bounded wildcards specify a subclass or implemented interface as a lower bound. Example: List<? super Integer> list; This `list` can hold `Integer`, `Number`, `Object`, etc. You can add `Integer` objects but not types unrelated to the `Integer` hierarchy (e.g. String).

Explain the difference between `List` and `List`?

• Answer: `List` is a list specifically for Strings. You can only add Strings and retrieve Strings. `List` is a list of unknown type. You can retrieve objects, but you can't add anything except `null`. This is an unbounded wildcard.

Explain the difference between `List` and `List`

• Answer: `List` accepts lists of Number and its subclasses (Integer, Double, Float, etc.), allowing only retrieval (get) operations, not addition except `null`. `List` accepts lists of Integer and its superclasses (Number, Object), allowing addition of Integer and its subclasses, but retrieval only as Object.

Can you explain PECS (Producer Extends Consumer Super)?

• Answer: PECS is a mnemonic device to remember wildcard usage. "Producer Extends" means if a method produces values (returns a list), use `? extends`. "Consumer Super" means if a method consumes values (takes a list as an argument), use `? super`.

How do generics handle primitive types?

• Answer: Generics cannot directly handle primitive types (int, float, etc.). You must use their wrapper classes (Integer, Float, etc.). This is due to type erasure and the need for object references.

What are generic methods? Provide an example.

• Answer: Generic methods are methods that use type parameters. Example: public <T> T findMax(T[] array) { ... } The `<T>` indicates that the method is generic and `T` can be replaced with any type when calling the method.

How do you create a generic method that works with multiple type parameters?

• Answer: You can specify multiple type parameters within the angle brackets, separated by commas. For example: public <K, V> void printKeyValuePairs(Map<K, V> map) { ... }

What is a raw type? When should you avoid using them?

• Answer: A raw type is a generic type without type arguments. For example, `List` instead of `List`. Avoid raw types because they defeat the purpose of generics, losing type safety and potentially leading to runtime `ClassCastException` errors. Use them only when interacting with legacy code that doesn't use generics.

Explain the concept of bounded wildcards with examples.

• Answer: Bounded wildcards restrict the types that can be used with a wildcard. Upper bounds (e.g., `? extends Number`) limit the wildcard to subtypes of a specified type. Lower bounds (e.g., `? super Integer`) limit the wildcard to supertypes of a specified type. This allows for more precise type checking and flexibility.

Describe a scenario where using generics significantly improves code quality.

• Answer: Consider a utility class for sorting different types of data. Without generics, you would need separate sorting methods for integers, strings, etc. With generics, you can create a single sorting method `sort(List<T extends Comparable<T>> list)` that works for any type implementing the `Comparable` interface.

Explain how generics help in avoiding ClassCastException.

• Answer: Generics perform type checking at compile time. This eliminates the possibility of runtime `ClassCastException` that occurs when you try to cast an object to a type it doesn't belong to. By ensuring type safety at compile time, generics help prevent such exceptions.

How can generics be used with inheritance?

• Answer: Generics can be used with inheritance through bounded wildcards or type parameters. For example, a generic class `Box` would only accept types that are subtypes of Number, thus leveraging the inheritance hierarchy of Java types.

Discuss the limitations of Java Generics.

• Answer: Java generics have limitations: They don't work with primitive types directly (requiring wrapper classes), they cannot create generic arrays, and type information is erased at runtime (which impacts some reflection capabilities).

How do generics interact with exception handling?

• Answer: Generics don't directly impact exception handling. However, the type safety provided by generics can help prevent exceptions like `ClassCastException` which are often related to type errors.

Explain how to use generics with collections.

• Answer: Generics are commonly used with collections like `ArrayList`, `HashMap`, etc., to specify the type of objects stored in the collection. For example: `List stringList = new ArrayList<>();` ensures that only Strings can be added to `stringList`.

Describe a situation where you had to use generics to solve a problem in your project, and explain how you approached it.

• Answer: [This requires a personal anecdote. A good example might involve creating a reusable caching mechanism where the cache could store various object types. Describe the problem, how generics helped define the cache's type parameter, and how this solved the problem of type safety and reusability.]

Explain the concept of covariance, contravariance, and invariance in the context of generics.

• Answer: Covariance means if A is a subtype of B, then `List` is a subtype of `List`. Contravariance means if A is a subtype of B, then `List` is a subtype of `List`. Invariance means that neither covariance nor contravariance holds: `List` and `List` are neither subtypes nor supertypes of each other.