Common OOPs Concepts with Pseudocode

Problem Explain common OOP concepts and write pseudocode demonstrating one — for example polymorphism via method overriding.

Be ready to discuss

• The four pillars stated crisply: encapsulation (bundle state with behavior, hide the state), abstraction (expose the contract, hide the implementation), inheritance (is-a reuse), polymorphism (one interface, many behaviors).
• Writing executable-looking pseudocode rather than reciting definitions — the code is what distinguishes understanding from memorization:

class Shape:
  method area() -> abstract

class Circle extends Shape:
  radius
  method area(): return PI * radius * radius

class Rectangle extends Shape:
  width, height
  method area(): return width * height

for shape in [Circle(5), Rectangle(3,4)]:
  print(shape.area())   // runtime polymorphism resolves the correct area()

• Runtime versus compile-time polymorphism: overriding with dynamic dispatch through a vtable, versus overloading resolved by the compiler from the signature.
• Composition over inheritance: pseudocoding a has-a design and arguing why it yields more flexible, testable code than a deep is-a hierarchy — the fragile base class and rigid-taxonomy problems.
• Abstract class versus interface: when shared implementation justifies the former, and why "program to an interface" underpins dependency injection and mocking in tests.
• SOLID as the connective tissue — especially Liskov substitution (a subclass must be usable wherever the parent is) and open/closed (add a Shape subclass, do not edit a switch statement).