Composition means one object holds another and asks it to do work. Inheritance means one class is a specialised kind of another and receives its members automatically. A car has an engine, and an electric car is a car.
Three differences matter in practice.
Inheritance is fixed when the code is written, while a composed part can be swapped at runtime.
A subclass can see protected members, while a holder sees only the public members.
A subclass inherits the whole parent interface, wanted or not.
Both reuse code, but only inheritance also declares substitutability. That promise is what lets a subclass be passed where the parent is expected, and it is the part you cannot take back later. If all you want is reuse, composition makes no such promise, so the held part stays easy to change.
Rewriting in plainer words…
This answer doesn't lend itself to a diagram - it reads best . No credits were charged.
Saved in this browser - sign in to keep your review list.
How should your speech become text?
Listening… your words appear above as you speak - tap Stop when you're done.
Recording · cr - tap Stop & transcribe when you're done.
Transcribing with AI…
Voice:
Keep going - a few more words and AI can grade it.
Interview lens
How interviewers actually use this question
Likely follow-ups
Why do many teams default to composition over inheritance, and what does composition cost you?Name the costs: forwarding calls by hand, more small objects to wire up, and no substitutability unless you add an interface.
A subclass inherits a method it cannot honour. What breaks, and which principle does it violate?Code holding the parent type gets surprised at runtime. Tie it to Liskov substitution and the promise the subclass made by extending.
What is the fragile base class problem?A change inside the parent, such as one method starting to call another, changes subclass behaviour because subclasses depend on parent internals.
If you compose instead of inherit, how do you still let callers treat the new class as the old type?Implement a shared interface and forward calls to the held object. The interface carries the promise, the held part carries the code.
Give an example where inheriting the whole parent interface causes real trouble.A stack that extends a list exposes insert-at-index, so callers can break stack order. Holding a list and exposing only push and pop avoids it.
What you can say
Composition means an object holds another object and asks it to do work, while inheritance means a class is a specialised kind of another and gets its members automatically.
So a car has an engine, and an electric car is a car.
Three differences matter in practice, and the first is that inheritance is fixed when you write the code, while a composed part can be swapped at runtime.
A subclass can see protected members while a holder sees only the public ones, and a subclass takes the parent's whole interface whether it wants it or not.
Both reuse code, but inheritance also promises substitutability, so callers can pass a subclass where they expect the parent, and you can't take that promise back later.
So if all I want is reuse, I pick composition, because it makes no such promise and the held part stays easy to change.
Weak answers to avoid
Recites has-a versus is-a and stopsThat is only the definition. Give the practical differences too: runtime swapping, protected access, the whole inherited interface, and the substitutability promise.
Says composition is always betterDogma costs points. Inheritance fits when the subclass really can stand in for the parent, so say when you would pick each one.
Treats inheritance as just code reuseExtending a class also tells callers the subclass can replace the parent. Leave that out and you can't explain why inheritance is hard to undo.
Interview lens
Likely follow-ups, what you can say, and the weak answers to avoid.
