Java Generics Interview Questions and Answers for internship

What are Java Generics?

• Answer: Java Generics allow you to write type-safe code that can operate on various types without knowing the specific type at compile time. They enhance code reusability and reduce the risk of runtime type errors (ClassCastException).

What is the benefit of using Generics?

• Answer: Generics improve type safety by catching type errors at compile time rather than runtime. They enhance code reusability by allowing you to write algorithms and data structures that can work with various data types without modification. They also improve code readability by making the intended type explicit.

Explain the concept of type erasure in Generics.

• Answer: Type erasure is a process where the generic type information is removed during compilation. The compiler replaces the generic type parameters with their upper bound (usually `Object`), ensuring backward compatibility with older Java versions. This means at runtime, there's no generic type information available.

How do you create a generic class?

• Answer: You create a generic class by using angle brackets `<>` after the class name, placing the type parameter(s) inside. For example: `public class MyClass { ... }` where `T` is a type parameter.

How do you create a generic method?

• Answer: You create a generic method by placing the type parameter(s) before the return type. For example: `public T myMethod(T arg) { ... }`

What is a bounded wildcard? Give an example.

• Answer: A bounded wildcard restricts the types that can be used with a generic type. `? extends Number` means the wildcard can be any subtype of Number (including Number itself). `? super Integer` means the wildcard can be Integer or any supertype of Integer (including Object).

What is an unbounded wildcard?

• Answer: An unbounded wildcard, represented by `?`, means that any type is allowed. It's less type-safe than bounded wildcards.

Explain the difference between `List` and `List`

• Answer: `List` is a list that can only contain Strings. `List` is a list that can contain objects of any single type, but you don't know what that type is at compile time. You can't add anything to a `List` except `null`.

Can you explain the use of `extends` and `super` in generics?

• Answer: `extends` in a bounded wildcard specifies an upper bound; only subtypes of the specified type are allowed. `super` specifies a lower bound; only supertypes of the specified type are allowed.

What are generic interfaces? Provide an example.

• Answer: Generic interfaces are interfaces that use type parameters. Example: `interface MyInterface { void myMethod(T t); }`

Explain how generics work with inheritance.

• Answer: A generic class or interface can be extended or implemented, but the type parameter may need to be specified or may be inherited, depending on the implementation.

What are some common pitfalls to avoid when using Generics?

• Answer: Common pitfalls include unchecked warnings, improper use of wildcards, misunderstanding type erasure, and using raw types excessively.

How do you handle unchecked warnings in Generics?

• Answer: Unchecked warnings indicate potential type safety issues. You should address the root cause, typically by using proper generics or bounded wildcards, rather than suppressing the warnings.

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

• Answer: A raw type is a generic type without any type arguments. Avoid them because they defeat the purpose of generics, leading to potential runtime type errors. They should generally be avoided unless dealing with legacy code.

Describe a scenario where you would use a generic class.

• Answer: A common scenario is creating a generic `Pair` class to store two objects of any type. This is more flexible than having separate classes for `StringPair`, `IntegerPair`, etc.

Describe a scenario where you would use a generic method.

• Answer: A generic method could be used to create a method that finds the maximum value in an array of any comparable type.

How do generics help with code maintainability?

• Answer: Generics reduce code duplication by allowing you to write a single algorithm or data structure usable for multiple types. They also improve readability and make it easier to understand the intended type usage.

Explain the concept of variance in Generics (covariance, contravariance, invariance).

• Answer: Covariance allows a subtype to be used where a supertype is expected (e.g., `List` is a subtype of `List`). Contravariance allows a supertype to be used where a subtype is expected (less common with lists, more so with methods). Invariance means neither covariance nor contravariance is allowed (e.g., `List` is not a subtype of `List