Object-Oriented Programming

// Defining a Car class (the blueprint)
class Car {
    // Constructor - runs when we create a new car
    constructor(brand, color) {
        this.brand = brand;    // The car's brand
        this.color = color;    // The car's color
        this.speed = 0;        // Speed starts at 0
        this.fuelLevel = 100;  // Full tank!
    }

    // Method - what the car can do
    startEngine() {
        console.log(`🔥 ${this.brand} engine started! Vroom vroom!`);
    }

    accelerate() {
        this.speed += 10;
        console.log(`🏎️ ${this.brand} speeding up! Current speed: ${this.speed} km/h`);
    }

    brake() {
        this.speed = 0;
        console.log(`🛑 ${this.brand} stopped safely!`);
    }

    honk() {
        console.log(`📢 ${this.brand} says: Beep beep!`);
    }
}

// Creating objects from the Car class (using the blueprint)
let myTesla = new Car("Tesla", "Red");
let myFord = new Car("Ford", "Blue");
let myBMW = new Car("BMW", "Black");

// Each object is independent!
console.log(myTesla.color);   // "Red"
console.log(myFord.color);    // "Blue"

// Using methods on each object
myTesla.startEngine();  // 🔥 Tesla engine started!
myTesla.accelerate();    // 🏎️ Tesla speeding up! Current speed: 10 km/h
myTesla.accelerate();    // 🏎️ Tesla speeding up! Current speed: 20 km/h

myFord.startEngine();    // 🔥 Ford engine started!
myFord.honk();           // 📢 Ford says: Beep beep!

// They don't affect each other!
console.log(myTesla.speed);   // 20 (Tesla is fast!)
console.log(myFord.speed);    // 0 (Ford hasn't moved yet)

// Creating a game character example
class Player {
    constructor(name, character) {
        this.name = name;
        this.character = character;
        this.score = 0;
        this.lives = 3;
    }

    jump() {
        console.log(`🦘 ${this.name}'s ${this.character} jumped!`);
    }

    collectCoin() {
        this.score += 100;
        console.log(`💰 ${this.name} got a coin! Score: ${this.score}`);
    }
}

let player1 = new Player("Alex", "Mario");
let player2 = new Player("Sam", "Luigi");

player1.collectCoin();  // 💰 Alex got a coin! Score: 100
player2.collectCoin();  // 💰 Sam got a coin! Score: 100
player1.collectCoin();  // 💰 Alex got a coin! Score: 200
// Alex has 200, Sam has 100 - they're separate!

// BankAccount with encapsulated (protected) data
class BankAccount {
    // The # makes these properties private (protected)
    #balance;
    #accountNumber;
    #pin;

    constructor(accountNumber, initialBalance, pin) {
        this.#accountNumber = accountNumber;
        this.#balance = initialBalance;
        this.#pin = pin;
    }

    // Public method to check balance (controlled access)
    getBalance(enteredPin) {
        if (enteredPin === this.#pin) {
            return this.#balance;
        } else {
            return "❌ Incorrect PIN!";
        }
    }

    // Public method to deposit money (controlled way to add)
    deposit(amount) {
        if (amount > 0) {
            this.#balance += amount;
            console.log(`💰 Deposited $${amount}. New balance: $${this.#balance}`);
        } else {
            console.log("❌ Cannot deposit negative amount!");
        }
    }

    // Public method to withdraw (controlled way to remove)
    withdraw(amount, enteredPin) {
        if (enteredPin !== this.#pin) {
            console.log("❌ Incorrect PIN!");
            return;
        }
        if (amount > this.#balance) {
            console.log("❌ Insufficient funds!");
        } else if (amount > 0) {
            this.#balance -= amount;
            console.log(`💸 Withdrew $${amount}. Remaining: $${this.#balance}`);
        }
    }
}

// Using the encapsulated account
let myAccount = new BankAccount("ACC123", 1000, "1234");

// Can't access private data directly!
// myAccount.#balance = 999999; // ❌ ERROR!

// Must use controlled methods
myAccount.deposit(500);              // ✅ Works! Balance: 1500
myAccount.withdraw(200, "1234");   // ✅ Works! Remaining: 1300
myAccount.withdraw(200, "0000");   // ❌ Incorrect PIN!

console.log(myAccount.getBalance("1234"));  // 💵 1300

// Parent Class (The base blueprint)
class Animal {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }

    eat() {
        console.log(`🍽️ ${this.name} is eating.`);
    }

    sleep() {
        console.log(`😴 ${this.name} is sleeping.`);
    }
}

// Child Class (inherits from Animal)
class Dog extends Animal {
    constructor(name, age, breed) {
        // Call parent's constructor
        super(name, age);
        this.breed = breed;  // New property just for dogs
    }

    // New method just for dogs
    bark() {
        console.log(`🐕 ${this.name} says: Woof woof!`);
    }

    // New method just for dogs
    wagTail() {
        console.log(`🐕 ${this.name} is wagging tail happily!`);
    }
}

// Grandchild Class (inherits from Dog)
class GoldenRetriever extends Dog {
    constructor(name, age) {
        // Call Dog's constructor
        super(name, age, "Golden Retriever");
        this.furColor = "golden";
    }

    // Special method just for Golden Retrievers
    fetch() {
        console.log(`🎾 ${this.name} fetched the ball! Good dog!`);
    }

    // Override parent's method (customize it)
    bark() {
        console.log(`🐕 ${this.name} says: Woof! (so friendly!)`);
    }
}

// Using the classes
let genericAnimal = new Animal("SomeAnimal", 5);
let myDog = new Dog("Rex", 3, "German Shepherd");
let myGolden = new GoldenRetriever("Buddy", 2);

// Animal can only do Animal things
genericAnimal.eat();    // ✅ Works!
// genericAnimal.bark();  // ❌ Error! Animals don't bark

// Dog can do Animal things AND Dog things
myDog.eat();       // ✅ Inherited from Animal
myDog.bark();      // ✅ Dog's own method

// Golden Retriever can do everything!
myGolden.eat();      // ✅ From Animal
myGolden.bark();     // ✅ From Dog (customized)
myGolden.fetch();    // ✅ Its own special method

// Parent class with a generic method
class Animal {
    constructor(name) {
        this.name = name;
    }

    // Generic version (can be overridden)
    makeSound() {
        console.log(`🔊 ${this.name} makes a sound.`);
    }

    move() {
        console.log(`🐾 ${this.name} moves.`);
    }
}

// Each child customizes the behavior
class Dog extends Animal {
    makeSound() {
        console.log(`🐕 ${this.name} barks: Woof! Woof!`);
    }

    move() {
        console.log(`🐕 ${this.name} runs on four legs.`);
    }
}

class Cat extends Animal {
    makeSound() {
        console.log(`🐱 ${this.name} meows: Meow~`);
    }

    move() {
        console.log(`🐱 ${this.name} sneaks quietly.`);
    }
}

class Bird extends Animal {
    makeSound() {
        console.log(`🐦 ${this.name} chirps: Tweet tweet!`);
    }

    move() {
        console.log(`🐦 ${this.name} flies in the sky!`);
    }
}

// The power of polymorphism!
let animals = [
    new Dog("Rex"),
    new Cat("Whiskers"),
    new Bird("Tweety")
];

console.log("=== Animal Concert ===");

// Same code works for ALL animals!
for (let animal of animals) {
    animal.makeSound();  // Each responds differently!
}

console.log("\n=== Animal Race ===");

for (let animal of animals) {
    animal.move();  // Each moves differently!
}

// Output:
// === Animal Concert ===
// 🐕 Rex barks: Woof! Woof!
// 🐱 Whiskers meows: Meow~
// 🐦 Tweety chirps: Tweet tweet!
//
// === Animal Race ===
// 🐕 Rex runs on four legs.
// 🐱 Whiskers sneaks quietly.
// 🐦 Tweety flies in the sky!

// Complex inner workings (HIDDEN - private)
class CoffeeMachine {
    // Private complex stuff users don't need to see
    #waterTemperature = 0;
    #pressure = 0;
    #beanGrinderStatus = "off";
    
    constructor() {
        this.#waterTemperature = 90;  // Celsius
        this.#pressure = 9;         // Bars
    }
    
    // Private methods - internal complexity
    #heatWater() {
        console.log("🌡️ Heating water to " + this.#waterTemperature + "°C...");
    }
    
    #grindBeans() {
        console.log("☕ Grinding beans...");
    }
    
    #applyPressure() {
        console.log("💨 Applying " + this.#pressure + " bars of pressure...");
    }
    
    // PUBLIC simple interface - this is what users see!
    makeEspresso() {
        console.log("⏳ Making your espresso...");
        this.#heatWater();
        this.#grindBeans();
        this.#applyPressure();
        console.log("✅ Here's your espresso! ☕");
    }
    
    makeLatte() {
        console.log("⏳ Making your latte...");
        this.#heatWater();
        this.#grindBeans();
        this.#applyPressure();
        this.#steamMilk();
        console.log("✅ Here's your latte! 🥛☕");
    }
    
    steamMilk() {
        console.log("🥛 Steaming milk...");
    }
}

// Using the machine - SO SIMPLE!
let myMachine = new CoffeeMachine();

// Just press a button - no need to understand complex engineering!
myMachine.makeEspresso();  // Easy!
myMachine.makeLatte();     // Easy!

// Can't access private stuff (and shouldn't need to!)
// myMachine.#heatWater();  // ❌ Error - not accessible
// myMachine.#pressure;     // ❌ Error - hidden data

class VideoGameCharacter {
    // Constructor - runs automatically when "new" is called
    constructor(name, characterClass, color) {
        // "this" refers to the NEW object being created
        this.name = name;           // "My name is..."
        this.class = characterClass; // "I am a warrior"
        this.color = color;         // "My color is red"
        
        // Set default values
        this.health = 100;          // Everyone starts healthy
        this.level = 1;             // Everyone starts at level 1
        this.inventory = [];        // Empty backpack
        
        console.log(`🎮 Created ${this.name} the ${this.class}!`);
    }
    
    jump() {
        // "this" refers to whoever called the method
        console.log(`🦘 ${this.name} jumped!`);
    }
    
    takeDamage(amount) {
        this.health -= amount;
        console.log(`💔 ${this.name} took ${amount} damage! Health: ${this.health}`);
        
        if (this.health <= 0) {
            console.log(`💀 ${this.name} has fallen!`);
        }
    }
    
    levelUp() {
        this.level++;
        this.health = 100;  // Restore health
        console.log(`⭐ ${this.name} leveled up to ${this.level}!`);
    }
}

// Creating characters - constructor runs automatically!
let mario = new VideoGameCharacter("Mario", "Plumber", "Red");
// Output: 🎮 Created Mario the Plumber!

let luigi = new VideoGameCharacter("Luigi", "Plumber", "Green");
// Output: 🎮 Created Luigi the Plumber!

// Each has their own properties
console.log(mario.color);   // "Red"
console.log(luigi.color);    // "Green"

// Methods use "this" to know WHO they are
mario.jump();      // 🦘 Mario jumped!
luigi.jump();      // 🦘 Luigi jumped!

mario.takeDamage(30);   // 💔 Mario took 30 damage! Health: 70
mario.levelUp();        // ⭐ Mario leveled up to 2!

class Employee {
    constructor(name, salary) {
        this.name = name;
        this.salary = salary;
    }
    
    // Parent method - can be overridden
    calculateBonus() {
        return this.salary * 0.05;  // 5% bonus
    }
    
    introduce() {
        return `Hi, I'm ${this.name} and I earn $${this.salary}.`;
    }
}

class Manager extends Employee {
    constructor(name, salary, teamSize) {
        super(name, salary);
        this.teamSize = teamSize;
    }
    
    // OVERRIDE: Managers get bigger bonus!
    calculateBonus() {
        return this.salary * 0.10;  // 10% bonus - different from parent!
    }
    
    // OVERRIDE: Custom introduction
    introduce() {
        return `Hi, I'm ${this.name}, a manager leading ${this.teamSize} people!`;
    }
    
    // NEW method only for managers
    conductMeeting() {
        console.log(`📊 ${this.name} is conducting a team meeting.`);
    }
}

class Developer extends Employee {
    constructor(name, salary, programmingLanguage) {
        super(name, salary);
        this.language = programmingLanguage;
    }
    
    // OVERRIDE: Developers get different bonus calculation
    calculateBonus() {
        let baseBonus = super.calculateBonus();  // Get parent's calculation
        return baseBonus + 500;  // Add extra $500 for coding skills!
    }
    
    // OVERRIDE: Custom introduction
    introduce() {
        return `Hi, I'm ${this.name}, a ${this.language} developer!`;
    }
}

let regularEmployee = new Employee("Bob", 50000);
let manager = new Manager("Alice", 80000, 10);
let developer = new Developer("Charlie", 70000, "JavaScript");

// Same method name, different results!
console.log(regularEmployee.calculateBonus());  // 2500 (5% of 50000)
console.log(manager.calculateBonus());         // 8000 (10% of 80000)
console.log(developer.calculateBonus());       // 4000 (5% + 500)

// Custom introductions
console.log(regularEmployee.introduce());  // Hi, I'm Bob...
console.log(manager.introduce());          // Hi, I'm Alice, a manager...
console.log(developer.introduce());        // Hi, I'm Charlie, a JavaScript developer...

class Student {
    constructor(name, grade) {
        this.name = name;
        this.grade = grade;
        
        // Track total students created
        Student.totalStudents++;
    }
    
    // Instance method - needs a specific student
    study() {
        console.log(`${this.name} is studying hard! 📚`);
    }
    
    // Instance method
    getInfo() {
        return `${this.name}: Grade ${this.grade}`;
    }
    
    // ============================================
    // STATIC METHODS - Belong to the CLASS
    // ============================================
    
    // Static property (belongs to class, not objects)
    static totalStudents = 0;
    
    // Static method - utility function
    static isValidGrade(grade) {
        return grade >= 0 && grade <= 100;
    }
    
    // Static method - compare two students
    static compareGrades(student1, student2) {
        if (student1.grade > student2.grade) {
            return `${student1.name} has better grades!`;
        } else if (student2.grade > student1.grade) {
            return `${student2.name} has better grades!`;
        } else {
            return "They're tied!";
        }
    }
    
    // Static method - get statistics
    static getTotalStudents() {
        return `Total students: ${Student.totalStudents}`;
    }
    
    // Static method - factory method
    static createHonorStudent(name) {
        // Create a student with automatic A+ grade
        return new Student(name, 100);
    }
}

// Using INSTANCE methods (need objects)
let alice = new Student("Alice", 85);
let bob = new Student("Bob", 92);

alice.study();              // ✓ Instance method
console.log(alice.getInfo()); // ✓ Instance method

// Using STATIC methods (no object needed!)
console.log(Student.isValidGrade(95));      // ✓ true
console.log(Student.isValidGrade(150));     // ✓ false
console.log(Student.compareGrades(alice, bob)); // ✓ "Bob has better grades!"
console.log(Student.getTotalStudents());    // ✓ "Total students: 2"

// Factory method - creates object for you
let starStudent = Student.createHonorStudent("Charlie");
console.log(starStudent.getInfo());  // Charlie: Grade 100

class Person {
    constructor(name, age) {
        this.name = name;
        this.age = age;
        this.energy = 100;
    }
    
    introduce() {
        return `Hi, I'm ${this.name}, ${this.age} years old.`;
    }
    
    rest() {
        this.energy = 100;
        console.log(`${this.name} is fully rested! ⚡`);
    }
}

class Employee extends Person {
    constructor(name, age, jobTitle, salary) {
        // MUST call super() first before using this!
        super(name, age);  // Calls parent's constructor
        
        // Now add employee-specific properties
        this.jobTitle = jobTitle;
        this.salary = salary;
    }
    
    // Override but also use parent's version
    introduce() {
        // Get parent's introduction
        let parentIntro = super.introduce();
        
        // Add our custom part
        return `${parentIntro} I work as ${this.jobTitle}.`;
    }
    
    work() {
        if (this.energy > 20) {
            this.energy -= 20;
            console.log(`${this.name} is working hard! 💼`);
        } else {
            // Call parent's method when tired
            console.log(`${this.name} is too tired to work...`);
            super.rest();  // Use parent's rest method
        }
    }
}

let person = new Person("Grandma", 70);
let employee = new Employee("Alice", 30, "Developer", 80000);

// Both can use Person methods
console.log(person.introduce());     // "Hi, I'm Grandma..."
console.log(employee.introduce());   // "Hi, I'm Alice... I work as Developer."

// Employee can work (Person can't)
employee.work();  // Alice is working!
employee.work();  // Alice is working!
employee.work();  // Alice is working!
employee.work();  // Tired, automatically rests!

// Component classes - simple, reusable parts
class Engine {
    constructor(horsepower) {
        this.horsepower = horsepower;
        this.isRunning = false;
    }
    
    start() {
        this.isRunning = true;
        console.log(`🔥 Engine started! (${this.horsepower} HP)`);
    }
    
    stop() {
        this.isRunning = false;
        console.log("🔌 Engine stopped.");
    }
}

class Wheel {
    constructor(size) {
        this.size = size;
    }
    
    rotate() {
        console.log(`🔄 ${this.size}" wheel spinning!`);
    }
}

// Car class uses composition - it HAS these parts
class Car {
    constructor(make, model, engineHP, wheelSize) {
        this.make = make;
        this.model = model;
        
        // Composition: Car HAS an engine
        this.engine = new Engine(engineHP);
        
        // Composition: Car HAS wheels (array of objects)
        this.wheels = [
            new Wheel(wheelSize),
            new Wheel(wheelSize),
            new Wheel(wheelSize),
            new Wheel(wheelSize)
        ];
    }
    
    start() {
        console.log(`🚗 Starting ${this.make} ${this.model}...`);
        this.engine.start();  // Delegate to engine
    }
    
    drive() {
        if (this.engine.isRunning) {
            this.wheels.forEach(wheel => wheel.rotate());  // All wheels spin!
            console.log("🚗💨 Car is moving!");
        } else {
            console.log("❌ Start the engine first!");
        }
    }
}

// Build a car from parts!
let myCar = new Car("Toyota", "Camry", 200, 17);

// Car coordinates its components
myCar.start();   // Delegates to engine.start()
myCar.drive();   // Delegates to wheels

// You can swap parts! (Flexible!)
myCar.engine = new Engine(300);  // Upgrade to stronger engine!