Basics

Generics provide compile-time type safety, reduce casting, and enable reusable APIs.

1. Definition

This topic explains the key Java concept behind the assigned section and why it matters in day-to-day engineering. In interviews, strong answers connect the definition to practical decisions rather than stopping at syntax. It sits at the boundary of language design, API usage, and runtime behavior. That is why interviewers often use it to test both fundamentals and engineering judgment.

2. Core Concepts

Concept	Meaning	Why it matters
class Box<T>	Generic class	Type parameter is chosen by the caller.
<T> T identity(T value)	Generic method	Its type parameter is local to the method.
<T extends Number>	Upper bound	Restricts the accepted type family.
Raw type	Legacy non-generic usage	Loses type safety and creates warnings.
Type inference	Compiler infers the type	Reduces boilerplate but should stay readable.

• You should understand not only what the feature does, but also what constraints or guarantees it provides.
• Good interview answers connect the concept to concrete APIs and typical use cases.
• Trade-offs matter: readability, performance, safety, and maintainability often pull in different directions.
• At senior level, the discussion usually expands from syntax to design consequences.

3. Practical Usage

With Basics, the practical question is always which solution best matches the use case. Strong interview answers explain not only what is possible, but also when it is a good idea and when it is not.

• Use the feature when it expresses the intent of the API clearly and safely.
• Avoid applying the same pattern blindly in every situation; context matters.
• Prefer explicitness when it improves readability for the next developer.
• In interviews, mention both the default choice and the situations where you would deviate from it.

4. Code Examples

Basic example

public class Box<T> {
    private T value;

    public void set(T value) {
        this.value = value;
    }

    public T get() {
        return value;
    }

    public static void main(String[] args) {
        Box<String> box = new Box<>();
        box.set("hello");
        String text = box.get();
        System.out.println(text.toUpperCase());
    }
}

Advanced example

import java.util.List;

public class GenericMethods {
    public static <T> T first(List<T> items) {
        if (items.isEmpty()) {
            throw new IllegalArgumentException("List is empty");
        }
        return items.get(0);
    }

    public static <T extends Number> double sum(List<T> numbers) {
        double total = 0;
        for (T number : numbers) {
            total += number.doubleValue();
        }
        return total;
    }
}

These examples matter in interviews because they show that you can move from theory to concrete API usage. A short, correct explanation of why the code is written that way is usually more valuable than a flashy but overcomplicated demo.

5. Trade-offs

Aspect	Advantage	Disadvantage
Expressive API	Clearer intent and safer code	Can make signatures harder to read at first
Convenience	Less boilerplate	May hide important details if overused
Flexibility	Works across more scenarios	Can increase complexity and ambiguity

6. Common Mistakes

• ❌ Wrong: You focus only on syntax. ✅ Correct: Explain the why, the trade-offs, and the real-world use case.
• ❌ Wrong: You assume one approach fits every problem. ✅ Correct: Choose the solution based on context and constraints.
• ❌ Wrong: You ignore diagnostics and maintainability. ✅ Correct: Include debuggability and readability in the decision.

7. Senior-level Insights

At senior level, this topic is less about memorization and more about choosing the right abstraction for the job.

A common follow-up is not “what is it?” but “when would you choose it, and what breaks if you choose poorly?”.

The strongest answers connect the concept to production behavior: debugging, performance, observability, and API design.

Typical follow-up interview questions:

• How would you explain Basics to a junior developer in one minute?
• Which trade-off matters most for Basics in a real project?
• Which production bug or maintenance issue is commonly linked to Basics?

8. Glossary

Term	Meaning
type parameter	A placeholder type such as T, E, K, or V.
raw type	Legacy use without generic parameters, such as List.
bounded type	A constrained type parameter such as T extends Number.
type inference	The compiler determines the type automatically.
compile-time safety	Type errors are caught during compilation.

9. Cheatsheet

• Know the definition in one sentence.
• Know the default use case.
• Know the main trade-off.
• Know at least one common mistake.
• Know one senior-level follow-up angle.

If you get stuck in an interview, return to three anchors for Basics: a precise definition, the default use case, and the main trade-off or failure mode.