Records and Generics
27 interview questions and answers in the Records and Generics section.
Questions in this section
- What is Record in Java and since which version are they available
- What are the main differences between Record and regular class
- Can you inherit from Record or have Record inherit from another class
- Can you add additional methods to a Record
- What methods are automatically generated for a Record
- Can you override constructor in Record
- What is compact constructor in Record
- Can you declare static fields and methods in Record
- Are Record fields final
- Can you use Record as a key in HashMap
- What are Generics in Java
- What are the advantages of using Generics
- What is type erasure
- Can you create an array of generic type
- What are bounded type parameters
- What is the difference between <? extends T> and <? super T>?
- What is PECS (Producer Extends Consumer Super)
- Can you use primitive types as generic parameters
- What are raw types and why should you avoid them
- What happens when trying to create an instance of generic type via new T()
- [What is the difference between List<?> and List
- Can you overload methods that differ only in generic parameters?
- What is recursive type bound
- How do Generics work with inheritance
- What are bridge methods and why are they needed
- Can you use multiple bounds for a single type parameter?
- How to implement Singleton pattern with Record
Study navigator
27 questions for Middle Java Developer interview preparation.
📋 All Questions
🗺️ Topic Dependency Map
┌──────────────────────────────────────────┐
│ RECORDS (1-10) │
│ 1. What is Record (Java 16) │
│ 2. Record vs regular class │
│ 3. Inheritance (not allowed) │
│ 4. Additional methods │
│ 5. Auto-generated methods │
│ 6. Constructors │
│ 7. Compact constructor │
│ 8. Static fields and methods │
│ 9. Final fields │
│ 10. Record as HashMap key │
└──────────────────┬───────────────────────┘
│
┌──────────────────────────┼──────────────────────────┐
▼ ▼ ▼
┌───────────────┐ ┌───────────────┐ ┌────────────────────┐
│ GENERICS │ │ WILDCARDS │ │ ADVANCED │
│ BASICS │ │ AND ERASURE │ │ GENERICS │
│ (11-12, 18) │ │ (13-14, 19-21) │ │ (22-26) │
│ 11. Generics │ │ 13. Erasure │ │ 22. Overloading │
│ 12. Advantages │ │ 14. Generic │ │ 23. Recursive bound│
│ 18. Primitives │ │ arrays │ │ 24. Inheritance │
│ │ │ 19. Raw types │ │ 25. Bridge methods │
│ │ │ 20. new T() │ │ 26. Multiple bounds│
│ │ │ 21. List<?> vs │ │ │
│ │ │ List<Obj> │ │ │
└───────┬───────┘ └───────┬───────┘ └────────┬───────────┘
│ │ │
└────────────────────────┼────────────────────────┘
▼
┌──────────────────────────────────────────┐
│ PATTERNS (15-17, 27) │
│ 15. Bounded type parameters │
│ 16. extends T vs super T │
│ 17. PECS │
│ 27. Singleton with Record │
└──────────────────────────────────────────┘
🎯 Recommended Study Order
🟢 Junior Level (weeks 1-2)
| Step | Topic | Files | Goal |
|---|---|---|---|
| 1 | Records basics | Q1-Q3 | What is Record, differences from class, cannot inherit |
| 2 | Record methods | Q4, Q5, Q8, Q9 | Additional methods, auto-generation, static, final |
| 3 | Generics basics | Q11, Q12 | What are generics, why they are needed |
| 4 | Primitives | Q18 | Autoboxing overhead, why primitives are not allowed |
🟡 Middle Level (weeks 3-4)
| Step | Topic | Files | Goal |
|---|---|---|---|
| 1 | Record constructors | Q6, Q7 | Overriding, compact constructor |
| 2 | Record + HashMap | Q10 | Why Records are ideal as keys |
| 3 | Type Erasure | Q13, Q14 | How erasure works, generic arrays |
| 4 | Bounded types | Q15, Q19 | Type constraints, raw types |
| 5 | Wildcards | Q21, Q20 | List<?> vs List |
🔴 Senior Level (weeks 5-6)
| Step | Topic | Files | Goal |
|---|---|---|---|
| 1 | PECS | Q16, Q17 | Producer Extends, Consumer Super |
| 2 | Overloading | Q22 | Cannot overload by generics |
| 3 | Recursive bounds | Q23 | Comparable<? super T>, CRTP |
| 4 | Inheritance + Generics | Q24 | Covariant returns, generics invariance |
| 5 | Bridge methods | Q25 | Why needed, how they are generated |
| 6 | Multiple bounds | Q26 | Intersection types, first bound erasure |
🔗 Key Topic Connections
Topic: Records
Q1 (Record) → Q2 (vs regular class) → Q3 (inheritance)
↓
Q4 (Additional methods) → Q5 (Auto-generation) → Q6 (Constructors) → Q7 (Compact)
↓
Q8 (Static) → Q9 (Final) → Q10 (HashMap key)
Topic: Generics Basics
Q11 (Generics) → Q12 (Advantages) → Q18 (Primitives)
Topic: Erasure and Wildcards
Q13 (Type Erasure) → Q14 (Generic arrays) → Q19 (Raw types) → Q20 (new T()) → Q21 (List<?> vs List<Object>)
Topic: PECS
Q15 (Bounded types) → Q16 (extends vs super) → Q17 (PECS)
Topic: Advanced
Q22 (Overloading) → Q23 (Recursive bound) → Q24 (Inheritance) → Q25 (Bridge methods) → Q26 (Multiple bounds)
🎓 Cheat Sheet: What to Know for Each Level
🟢 Junior
- Record = immutable data class, Java 16+
- Auto-generated: constructor, accessors, equals/hashCode/toString
- Cannot inherit, cannot have instance fields (only static)
- Generics = type parameterization, compile-time type safety
- Primitives cannot be used in generics — autoboxing to wrappers
🟡 Middle
- Compact constructor: no signature, validation only
- Type erasure: generics exist only at compile-time, runtime = Object
- Raw types — backwards compatibility, but unchecked warnings
<? extends T>= read-only (producer),<? super T>= write (consumer)new T()is impossible — type variable has no constructor
🔴 Senior
- PECS: Producer Extends, Consumer Super
- Bridge methods: compiler generates for covariant returns after erasure
- Multiple bounds:
<T extends A & B>— erasure by first bound - Generic arrays are impossible — heap pollution risk
- List
is NOT a subtype of List — generics are invariant - Recursive bound:
T extends Comparable<? super T>for inheritable compareTo
📝 Format of Each File
Each file contains:
- 🟢 Junior Level — basic understanding, simple analogies, examples
- 🟡 Middle Level — internals, common mistakes, practical examples
- 🔴 Senior Level — deep dive, edge cases, production experience, monitoring
- 🎯 Interview Cheat Sheet — key points, common questions, red flags, related topics