What is LEGO, and How Does It Relate to OOP?

LEGO is a famous toy system where you build things using small, reusable building blocks. Just like you can combine different LEGO pieces to make a car, house, or spaceship, in OOP, you combine objects (small reusable code blocks) to build apps.

How LEGO Relates to OOP Concepts

1️⃣ Encapsulation → Hiding Details

• In LEGO, some pieces have internal mechanisms (like gears inside a LEGO car), but you only interact with the outside (wheels, doors, etc.).
• In OOP, objects hide internal logic and only expose necessary functionality.

Example:

class Car {
  // Private property (hidden from the outside)
  int _enginePower = 100;  

  // Public method (exposed to users)
  void drive() {
    print("Car is driving with $_enginePower horsepower.");
  }
}

void main() {
  Car myCar = Car();
  myCar.drive();  // ✅ Allowed
  // myCar._enginePower = 200;  ❌ Not allowed (encapsulated)
}

2️⃣ Abstraction → Hiding Complexity

• When you build a LEGO car, you don’t worry about how the wheels connect inside—you just attach them and drive!
• In OOP, users don’t need to know internal code details—they only use the provided interface.

Example:

abstract class CoffeeMachine {
  void makeCoffee();  // Hides complex details
}

class SimpleMachine extends CoffeeMachine {
  @override
  void makeCoffee() {
    print("Grinding beans...");
    print("Boiling water...");
    print("Pouring coffee... ☕");
  }
}

void main() {
  SimpleMachine machine = SimpleMachine();
  machine.makeCoffee();  // The user doesn’t need to know how it works!
}

3️⃣ Inheritance → Reusing Code

• LEGO pieces can be reused in different sets (a LEGO car's wheels can be used in a LEGO truck).
• In OOP, child classes inherit from parent classes, reusing code instead of rewriting it.

Example:

class Vehicle {
  void move() {
    print("This vehicle is moving!");
  }
}

class Car extends Vehicle {}  // 🚗 Car inherits from Vehicle
class Bike extends Vehicle {} // 🚲 Bike inherits from Vehicle

void main() {
  Car myCar = Car();
  myCar.move();  // ✅ Uses move() from Vehicle

  Bike myBike = Bike();
  myBike.move();  // ✅ Reuses move() without rewriting it
}

4️⃣ Polymorphism → One Function, Different Results

• In LEGO, the same piece (e.g., a LEGO brick) can fit into different builds (a LEGO house, a LEGO car, etc.).
• In OOP, the same method can work differently in different objects.

Example:

class Shape {
  void draw() {
    print("Drawing a shape...");
  }
}

class Circle extends Shape {
  @override
  void draw() {
    print("Drawing a circle 🟢");
  }
}

class Square extends Shape {
  @override
  void draw() {
    print("Drawing a square 🔲");
  }
}

void main() {
  Shape shape1 = Circle();
  Shape shape2 = Square();

  shape1.draw(); // Outputs: "Drawing a circle 🟢"
  shape2.draw(); // Outputs: "Drawing a square 🔲"
}

Why Compare OOP to LEGO?

✅ Both use small, reusable parts → LEGO bricks / OOP objects.
✅ Both allow flexibility → You can combine pieces in many ways.
✅ Both help avoid redundancy → You don’t need to create a new LEGO piece for every structure—just reuse!

So, LEGO = OOP in the real world! 🚀