LLD — Junior · Resources

1The four OOP pillars

0/5▶

Junior LLD checks that you can turn a problem into clean classes. Use the pillars deliberately, not as recitation.

Apply each with an example

Encapsulation — hide state behind methods; expose intent, not fields.

GfG — Encapsulation.

Abstraction — model essentials via interfaces/abstract classes.

GfG — Abstraction.

Inheritance — the "is-a" relationship and its pitfalls.

GfG — Inheritance.

Polymorphism — one interface, many implementations (overriding).

GfG — Polymorphism.

Access modifiers (public/protected/private) and why they matter.

GfG — Access modifiers.

2Class relationships

0/4▶

Interviewers listen for whether you model relationships correctly rather than defaulting to inheritance.

Model connections

Composition over inheritance — prefer "has-a"; why deep trees hurt.

Composition over inheritance.

Association vs aggregation vs composition (ownership & lifetime).

GfG — Association/aggregation/composition.

Interfaces vs abstract classes — when to use each.

GfG — Abstract vs interface.

Enums & value objects vs entities.

Fowler — Value object.

3UML & modelling

0/3▶

Turn nouns into classes and verbs into methods. Draw a simple class diagram before coding.

From problem to classes

Identify entities (nouns), responsibilities (verbs), relationships (has-a / is-a).

GfG — UML class diagrams.

Read/draw a class diagram: fields, methods, associations, multiplicity.

GfG — UML class diagrams.

Sequence diagram basics — how objects interact over time.

GfG — Sequence diagrams.

4Intro to SOLID

0/4▶

Even at junior level, naming a SOLID principle when it applies signals maturity.

One line each

S — Single Responsibility: one reason to change.

SRP.

O — Open/Closed: extend, don't modify.

OCP.

L — Liskov Substitution: subtypes are usable as their base.

LSP.

I / D — Interface Segregation & Dependency Inversion in a sentence each.

DIP.

5Patterns at a glance

0/4▶

Recognise a few patterns by the problem they solve — depth comes at mid level.

Name the problem each solves

Factory — create objects without hard-coding the class.

Refactoring Guru — Factory.

Strategy — swap an algorithm at runtime.

Refactoring Guru — Strategy.

Singleton — one shared instance (and why it's often overused).

Refactoring Guru — Singleton.

Observer — publish/subscribe events.

Refactoring Guru — Observer.

6Warm-up designs

0/4▶

Small, self-contained designs to practise the loop: entities → relationships → methods → runnable core.

Design these

A deck of cards + shuffle/deal — enums, Card, Deck, Shuffler.

awesome-low-level-design.

A simple library — Book, Member, Loan; borrow/return.

awesome-low-level-design.

Tic-tac-toe — Board, Player, move validation, win check.

awesome-low-level-design — Tic-tac-toe.

A parking lot (basic) — Spot, Vehicle, Ticket.

awesome-low-level-design — Parking lot.

7Clean-code basics

0/4▶

Junior interviewers reward readable, well-named code more than clever code.

Habits

Meaningful names; small methods that do one thing.

Clean Code (Martin).

Avoid magic numbers; use enums/constants.

Refactoring Guru — Magic numbers.

Write a tiny main()/test to prove your design runs.

Fowler — Unit test.

DRY vs premature abstraction — don't over-engineer a small design.

Fowler — YAGNI.