ES6 Classes

ES6 Classes provide a cleaner, more familiar syntax for creating objects and implementing inheritance in JavaScript, built on top of prototypes.

🤔 What are ES6 Classes?

ES6 Classes are syntactic sugar over JavaScript's existing prototype-based inheritance. They provide a clearer and more familiar syntax for OOP programming.

Syntactic Sugar - Built on prototypes
Constructor Method - Called when creating instances
Instance Methods - Methods on prototype
Static Methods - Methods on class itself

💡 Class Features

constructor() - Initialization method
extends - Inheritance between classes
super() - Call parent constructor/methods
static - Static methods and properties
get/set - Getter and setter methods
Private fields/methods (ES2022)

Under the Hood

Classes are still prototype-based. class Person creates a function Person with methods on its prototype.

📝 Class Basics

Basic class syntax with constructors, methods, getters, setters, and statics.

JavaScript Editor

// ES6 Classes Basics
console.log('=== ES6 Classes ===');

// Basic class definition
class Person {
  // Constructor method (called when creating new instance)
  constructor(name, age) {
    this.name = name;
    this.age = age;
    this.createdAt = new Date();
  }
  
  // Instance method
  introduce() {
    return `Hello, my name is ${this.name} and I'm ${this.age} years old.`;
  }
  
  // Another instance method
  celebrateBirthday() {
    this.age++;
    console.log(`Happy Birthday ${this.name}! You are now ${this.age}.`);
    return this.age;
  }
  
  // Getter (computed property)
  get birthYear() {
    const currentYear = new Date().getFullYear();
    return currentYear - this.age;
  }
  
  // Setter
  set birthYear(year) {
    const currentYear = new Date().getFullYear();
    this.age = currentYear - year;
  }
  
  // Static method (called on class, not instance)
  static compareAges(person1, person2) {
    return person1.age - person2.age;
  }
  
  // Static property
  static species = 'Homo sapiens';
}

// Creating instances
const alice = new Person('Alice', 30);
const bob = new Person('Bob', 25);

console.log(alice.introduce());
console.log(bob.introduce());

// Using getter
console.log(`${alice.name} was born in ${alice.birthYear}`);

// Using setter
alice.birthYear = 1985;
console.log(`After setting birth year, Alice is ${alice.age} years old`);

// Calling instance method
alice.celebrateBirthday();

// Static method
console.log(`Age difference: ${Person.compareAges(alice, bob)} years`);

// Static property
console.log(`Species: ${Person.species}`);

// Checking types
console.log('\n=== Type Checking ===');
console.log('alice instanceof Person:', alice instanceof Person);
console.log('alice.constructor === Person:', alice.constructor === Person);
console.log('typeof Person:', typeof Person);
console.log('typeof alice.introduce:', typeof alice.introduce);

// Class expressions (alternative syntax)
const Animal = class {
  constructor(name) {
    this.name = name;
  }
  
  speak() {
    return `${this.name} makes a sound.`;
  }
};

const dog = new Animal('Dog');
console.log('\nClass expression:', dog.speak());

Key Components:

Constructor - Initializes object properties
Instance Methods - Available on all instances
Getters/Setters - Computed properties
Static Methods - Called on class, not instances
Static Properties - Shared across all instances

🧬 Class Inheritance

Creating class hierarchies with extends and super.

JavaScript Editor

// Class Inheritance
console.log('=== Class Inheritance ===');

// Base class
class Vehicle {
  constructor(make, model, year) {
    this.make = make;
    this.model = model;
    this.year = year;
    this.mileage = 0;
  }
  
  drive(distance) {
    this.mileage += distance;
    console.log(`Driving ${distance} miles. Total mileage: ${this.mileage}`);
  }
  
  honk() {
    return 'Beep beep!';
  }
  
  getInfo() {
    return `${this.year} ${this.make} ${this.model}`;
  }
  
  // Private method convention (using underscore)
  _performMaintenance() {
    console.log('Performing maintenance...');
  }
}

// Derived class (inherits from Vehicle)
class Car extends Vehicle {
  constructor(make, model, year, doors) {
    // Call parent constructor
    super(make, model, year);
    this.doors = doors;
    this.fuelLevel = 100;
  }
  
  // Override parent method
  honk() {
    return 'Honk honk!';
  }
  
  // Add new method
  refuel(amount) {
    this.fuelLevel = Math.min(100, this.fuelLevel + amount);
    console.log(`Refueled. Fuel level: ${this.fuelLevel}%`);
  }
  
  // Extend parent method
  drive(distance) {
    if (this.fuelLevel <= 0) {
      console.log('Cannot drive, out of fuel!');
      return;
    }
    
    const fuelUsed = distance * 0.1; // 10% per mile
    this.fuelLevel = Math.max(0, this.fuelLevel - fuelUsed);
    
    // Call parent method
    super.drive(distance);
    
    console.log(`Fuel remaining: ${this.fuelLevel.toFixed(1)}%`);
  }
  
  getInfo() {
    return `${super.getInfo()} with ${this.doors} doors`;
  }
}

// Another derived class
class Motorcycle extends Vehicle {
  constructor(make, model, year, type) {
    super(make, model, year);
    this.type = type;
    this.helmetIncluded = true;
  }
  
  honk() {
    return 'Beep!';
  }
  
  wheelie() {
    console.log('Doing a wheelie!');
  }
  
  getInfo() {
    return `${super.getInfo()} - ${this.type} motorcycle`;
  }
}

// Create instances
const myCar = new Car('Toyota', 'Camry', 2022, 4);
const myBike = new Motorcycle('Harley', 'Davidson', 2021, 'Cruiser');

console.log(myCar.getInfo());
console.log(myBike.getInfo());

// Test methods
myCar.drive(50);
myCar.refuel(20);
myCar.drive(30);
console.log('Car honk:', myCar.honk());

myBike.drive(25);
console.log('Motorcycle honk:', myBike.honk());
myBike.wheelie();

// Check inheritance
console.log('\n=== Inheritance Checks ===');
console.log('myCar instanceof Car:', myCar instanceof Car);
console.log('myCar instanceof Vehicle:', myCar instanceof Vehicle);
console.log('myCar instanceof Object:', myCar instanceof Object);

console.log('myBike instanceof Motorcycle:', myBike instanceof Motorcycle);
console.log('myBike instanceof Vehicle:', myBike instanceof Vehicle);

// Multiple levels of inheritance
class ElectricCar extends Car {
  constructor(make, model, year, doors, batteryCapacity) {
    super(make, model, year, doors);
    this.batteryCapacity = batteryCapacity;
    this.batteryLevel = 100;
  }
  
  // Override refuel method
  refuel(kwh) {
    this.batteryLevel = Math.min(100, this.batteryLevel + (kwh / this.batteryCapacity * 100));
    console.log(`Charged. Battery level: ${this.batteryLevel.toFixed(1)}%`);
  }
  
  // Override drive method for electric
  drive(distance) {
    const energyUsed = distance * 0.2; // 20% per mile
    this.batteryLevel = Math.max(0, this.batteryLevel - energyUsed);
    
    if (this.batteryLevel <= 0) {
      console.log('Cannot drive, battery empty!');
      return;
    }
    
    super.drive(distance);
    console.log(`Battery remaining: ${this.batteryLevel.toFixed(1)}%`);
  }
  
  getInfo() {
    return `${super.getInfo()} (Electric, ${this.batteryCapacity}kWh)`;
  }
}

const tesla = new ElectricCar('Tesla', 'Model 3', 2023, 4, 75);
console.log('\n' + tesla.getInfo());
tesla.drive(100);
tesla.refuel(50); // 50 kWh

Inheritance Rules:

Use extends to inherit from another class
Must call super() in derived class constructor
Can override parent methods
Can call parent methods with super.methodName()
Supports multiple levels of inheritance

🔒 Private Fields & Methods

ES2022 private fields and methods for encapsulation.

JavaScript Editor

// Private and Public Fields (ES2022)
console.log('=== Private Fields ===');

class BankAccount {
  // Public fields (instance properties)
  bankName = 'Global Bank';
  
  // Private fields (start with #)
  #accountNumber;
  #balance = 0;
  #pin;
  
  // Static private field
  static #bankCode = 'GB001';
  
  constructor(accountHolder, accountNumber, initialDeposit, pin) {
    this.accountHolder = accountHolder;
    this.#accountNumber = accountNumber;
    this.#balance = initialDeposit;
    this.#pin = pin;
    this.transactions = [];
  }
  
  // Public method
  deposit(amount) {
    if (amount <= 0) {
      throw new Error('Deposit amount must be positive');
    }
    
    this.#balance += amount;
    this.#recordTransaction('DEPOSIT', amount);
    console.log(`Deposited $${amount}. New balance: $${this.#balance}`);
    return this.#balance;
  }
  
  // Private method
  #recordTransaction(type, amount) {
    this.transactions.push({
      type,
      amount,
      date: new Date().toISOString(),
      balance: this.#balance
    });
  }
  
  // Public method that uses private method
  withdraw(amount, pin) {
    if (!this.#verifyPin(pin)) {
      throw new Error('Invalid PIN');
    }
    
    if (amount <= 0) {
      throw new Error('Withdrawal amount must be positive');
    }
    
    if (amount > this.#balance) {
      throw new Error('Insufficient funds');
    }
    
    this.#balance -= amount;
    this.#recordTransaction('WITHDRAWAL', amount);
    console.log(`Withdrew $${amount}. New balance: $${this.#balance}`);
    return this.#balance;
  }
  
  // Private method
  #verifyPin(pin) {
    return this.#pin === pin;
  }
  
  // Getter for private field
  get balance() {
    return this.#balance;
  }
  
  // Getter for formatted account number
  get maskedAccountNumber() {
    return `****${this.#accountNumber.slice(-4)}`;
  }
  
  // Static method accessing static private field
  static getBankInfo() {
    return {
      code: this.#bankCode,
      name: 'Global Bank International'
    };
  }
  
  // Public method that can't access private fields from outside
  getStatement() {
    return {
      accountHolder: this.accountHolder,
      maskedAccount: this.maskedAccountNumber,
      balance: this.#balance,
      transactions: [...this.transactions],
      bank: this.bankName
    };
  }
}

// Create account
const myAccount = new BankAccount('John Doe', '1234567890', 1000, '1234');

console.log('Account holder:', myAccount.accountHolder);
console.log('Bank name:', myAccount.bankName);
console.log('Masked account:', myAccount.maskedAccountNumber);
console.log('Balance via getter:', myAccount.balance);

// Try to access private fields (will fail)
try {
  console.log('Private balance:', myAccount.#balance); // SyntaxError
} catch (error) {
  console.log('Cannot access private field:', error.message);
}

try {
  console.log('Private method:', myAccount.#verifyPin); // SyntaxError
} catch (error) {
  console.log('Cannot access private method:', error.message);
}

// Use public methods
myAccount.deposit(500);
try {
  myAccount.withdraw(200, '1234');
  myAccount.withdraw(200, 'wrong'); // Should fail
} catch (error) {
  console.log('Withdrawal error:', error.message);
}

console.log('\nAccount statement:', myAccount.getStatement());

// Static method
console.log('Bank info:', BankAccount.getBankInfo());

// Inheritance with private fields
class SavingsAccount extends BankAccount {
  #interestRate = 0.05; // 5%
  #minBalance = 100;
  
  constructor(accountHolder, accountNumber, initialDeposit, pin) {
    super(accountHolder, accountNumber, initialDeposit, pin);
    
    if (initialDeposit < this.#minBalance) {
      throw new Error(`Minimum deposit is $${this.#minBalance}`);
    }
  }
  
  // Can't access parent's private fields directly
  // But can use parent's public methods
  
  addInterest() {
    const interest = this.balance * this.#interestRate;
    this.deposit(interest);
    console.log(`Added $${interest.toFixed(2)} interest`);
  }
  
  getAccountDetails() {
    return {
      ...super.getStatement(),
      type: 'Savings Account',
      interestRate: `${(this.#interestRate * 100)}%`,
      minimumBalance: this.#minBalance
    };
  }
}

const savings = new SavingsAccount('Jane Smith', '0987654321', 500, '4321');
console.log('\nSavings account:', savings.getAccountDetails());
savings.addInterest();

Private Features:

#fieldName - Private field
#methodName() - Private method
static #field - Static private field
Only accessible within class

Benefits:

True encapsulation
Prevents external modification
Clear public API
Better code organization

🧩 Mixins & Composition

Using mixins and composition as alternatives to deep inheritance hierarchies.

JavaScript Editor

// Mixins and Composition
console.log('=== Mixins and Composition ===');

// Instead of deep inheritance chains, use composition

// Mixin functions
const CanEat = (Base) => class extends Base {
  eat(food) {
    console.log(`${this.name} is eating ${food}`);
    this.energy += 10;
  }
};

const CanSleep = (Base) => class extends Base {
  sleep(hours) {
    console.log(`${this.name} is sleeping for ${hours} hours`);
    this.energy += hours * 5;
  }
};

const CanWork = (Base) => class extends Base {
  work(hours) {
    console.log(`${this.name} is working for ${hours} hours`);
    this.energy -= hours * 3;
  }
};

const CanCode = (Base) => class extends Base {
  code(hours) {
    console.log(`${this.name} is coding for ${hours} hours`);
    this.energy -= hours * 4;
    this.skills += hours * 0.1;
  }
};

// Base class
class LivingBeing {
  constructor(name) {
    this.name = name;
    this.energy = 100;
  }
  
  getStatus() {
    return `${this.name}: Energy=${this.energy.toFixed(1)}`;
  }
}

// Compose classes using mixins
class Human extends CanEat(CanSleep(CanWork(CanCode(CanExercise(LivingBeing))))) {
  constructor(name, occupation) {
    super(name);
    this.occupation = occupation;
    this.skills = 0;
    this.strength = 0;
  }
  
  getStatus() {
    return `${super.getStatus()}, Skills=${this.skills.toFixed(1)}, Strength=${this.strength.toFixed(1)}`;
  }
}

class Robot extends CanWork(CanCode(LivingBeing)) {
  constructor(name, model) {
    super(name);
    this.model = model;
    this.battery = 100;
    this.skills = 50; // Robots start with coding skills
  }
  
  work(hours) {
    super.work(hours);
    this.battery -= hours * 10;
    if (this.battery < 0) this.battery = 0;
  }
  
  getStatus() {
    return `${super.getStatus()}, Battery=${this.battery}%, Skills=${this.skills.toFixed(1)}`;
  }
  
  recharge() {
    this.battery = 100;
    console.log(`${this.name} is fully recharged`);
  }
}

// Create instances
const john = new Human('John', 'Developer');
const robot = new Robot('Robo', 'X-1000');

console.log(john.getStatus());
john.eat('pizza');
john.code(8);
john.exercise(30);
john.sleep(8);
console.log(john.getStatus());

console.log('\n' + robot.getStatus());
robot.code(4);
robot.work(6);
console.log(robot.getStatus());
robot.recharge();
console.log(robot.getStatus());

// Alternative: Object composition
const behaviors = {
  eater: {
    eat(food) {
      console.log(`${this.name} eats ${food}`);
    }
  },
  sleeper: {
    sleep(hours) {
      console.log(`${this.name} sleeps for ${hours} hours`);
    }
  },
  worker: {
    work() {
      console.log(`${this.name} is working`);
    }
  }
};

function createAnimal(name, ...traits) {
  const animal = { name };
  
  traits.forEach(trait => {
    Object.assign(animal, behaviors[trait]);
  });
  
  return animal;
}

const dog = createAnimal('Buddy', 'eater', 'sleeper');
const bee = createAnimal('Buzz', 'worker');

dog.eat('bone');
dog.sleep(10);
bee.work();

Composition over Inheritance:

Mixins - Functions that return classes
Object Composition - Combine objects
Traits - Reusable behaviors
Advantages - More flexible, avoids deep hierarchies

🛒 Practical Example: E-commerce

Complete e-commerce system demonstrating classes, inheritance, and encapsulation.

JavaScript Editor

// Practical Example: E-commerce System
console.log('=== E-commerce System ===');

// Base Product class
class Product {
  #id;
  #price;
  
  constructor(id, name, description, price, category) {
    this.#id = id;
    this.name = name;
    this.description = description;
    this.#price = price;
    this.category = category;
    this.createdAt = new Date();
    this.isActive = true;
  }
  
  // Getters and setters
  get id() {
    return this.#id;
  }
  
  get price() {
    return this.#price;
  }
  
  set price(newPrice) {
    if (newPrice < 0) {
      throw new Error('Price cannot be negative');
    }
    this.#price = newPrice;
  }
  
  get formattedPrice() {
    return `$${this.#price.toFixed(2)}`;
  }
  
  // Business logic methods
  applyDiscount(percentage) {
    if (percentage < 0 || percentage > 100) {
      throw new Error('Discount percentage must be between 0 and 100');
    }
    const discount = this.#price * (percentage / 100);
    this.#price -= discount;
    return this.#price;
  }
  
  getDetails() {
    return {
      id: this.#id,
      name: this.name,
      description: this.description,
      price: this.formattedPrice,
      category: this.category,
      isActive: this.isActive
    };
  }
  
  // Static method
  static validateProductData(data) {
    const errors = [];
    
    if (!data.name || data.name.trim().length < 2) {
      errors.push('Name must be at least 2 characters');
    }
    
    if (!data.price || data.price <= 0) {
      errors.push('Price must be positive');
    }
    
    if (!data.category) {
      errors.push('Category is required');
    }
    
    return {
      isValid: errors.length === 0,
      errors
    };
  }
}

// Digital Product (inherits from Product)
class DigitalProduct extends Product {
  constructor(id, name, description, price, category, fileSize, downloadLink) {
    super(id, name, description, price, category);
    this.fileSize = fileSize; // in MB
    this.downloadLink = downloadLink;
    this.downloadCount = 0;
  }
  
  download() {
    this.downloadCount++;
    console.log(`Downloading "${this.name}" (${this.fileSize}MB)...`);
    return {
      link: this.downloadLink,
      size: this.fileSize,
      downloads: this.downloadCount
    };
  }
  
  getDetails() {
    return {
      ...super.getDetails(),
      type: 'Digital',
      fileSize: `${this.fileSize}MB`,
      downloads: this.downloadCount
    };
  }
}

// Physical Product (inherits from Product)
class PhysicalProduct extends Product {
  #stock;
  
  constructor(id, name, description, price, category, weight, dimensions) {
    super(id, name, description, price, category);
    this.weight = weight; // in kg
    this.dimensions = dimensions; // {length, width, height}
    this.#stock = 0;
  }
  
  get stock() {
    return this.#stock;
  }
  
  addStock(quantity) {
    if (quantity <= 0) {
      throw new Error('Quantity must be positive');
    }
    this.#stock += quantity;
    console.log(`Added ${quantity} units to stock. Total: ${this.#stock}`);
  }
  
  sell(quantity) {
    if (quantity <= 0) {
      throw new Error('Quantity must be positive');
    }
    
    if (quantity > this.#stock) {
      throw new Error(`Insufficient stock. Available: ${this.#stock}`);
    }
    
    this.#stock -= quantity;
    const total = this.price * quantity;
    console.log(`Sold ${quantity} units. Remaining stock: ${this.#stock}`);
    
    return {
      quantity,
      unitPrice: this.price,
      total: total.toFixed(2)
    };
  }
  
  getShippingCost() {
    // Simple shipping calculation based on weight
    const baseCost = 5;
    const weightCost = this.weight * 2;
    return baseCost + weightCost;
  }
  
  getDetails() {
    return {
      ...super.getDetails(),
      type: 'Physical',
      weight: `${this.weight}kg`,
      dimensions: `${this.dimensions.length}x${this.dimensions.width}x${this.dimensions.height} cm`,
      stock: this.#stock,
      shippingCost: `$${this.getShippingCost().toFixed(2)}`
    };
  }
}

// Shopping Cart
class ShoppingCart {
  #items = new Map(); // productId -> {product, quantity}
  
  addItem(product, quantity = 1) {
    if (!(product instanceof Product)) {
      throw new Error('Only Product instances can be added to cart');
    }
    
    if (!product.isActive) {
      throw new Error('Product is not available');
    }
    
    if (product instanceof PhysicalProduct && product.stock < quantity) {
      throw new Error(`Insufficient stock. Available: ${product.stock}`);
    }
    
    const existing = this.#items.get(product.id);
    
    if (existing) {
      existing.quantity += quantity;
    } else {
      this.#items.set(product.id, { product, quantity });
    }
    
    console.log(`Added ${quantity}x "${product.name}" to cart`);
  }
  
  removeItem(productId, quantity = null) {
    if (!this.#items.has(productId)) {
      throw new Error('Product not in cart');
    }
    
    if (quantity === null) {
      this.#items.delete(productId);
      console.log('Removed product from cart');
    } else {
      const item = this.#items.get(productId);
      item.quantity -= quantity;
      
      if (item.quantity <= 0) {
        this.#items.delete(productId);
      }
      
      console.log(`Removed ${quantity} units from cart`);
    }
  }
  
  getTotal() {
    let total = 0;
    
    for (const { product, quantity } of this.#items.values()) {
      total += product.price * quantity;
    }
    
    return total;
  }
  
  getFormattedTotal() {
    return `$${this.getTotal().toFixed(2)}`;
  }
  
  checkout() {
    if (this.#items.size === 0) {
      throw new Error('Cart is empty');
    }
    
    const order = {
      id: 'ORD-' + Date.now(),
      items: [],
      subtotal: this.getTotal(),
      tax: this.getTotal() * 0.1, // 10% tax
      total: 0,
      timestamp: new Date().toISOString()
    };
    
    // Process each item
    for (const { product, quantity } of this.#items.values()) {
      order.items.push({
        productId: product.id,
        name: product.name,
        quantity,
        unitPrice: product.price,
        total: product.price * quantity
      });
      
      // Update stock for physical products
      if (product instanceof PhysicalProduct) {
        try {
          product.sell(quantity);
        } catch (error) {
          throw new Error(`Checkout failed for "${product.name}": ${error.message}`);
        }
      }
      
      // Track download for digital products
      if (product instanceof DigitalProduct) {
        product.download();
      }
    }
    
    order.total = order.subtotal + order.tax;
    
    // Clear cart
    this.#items.clear();
    
    console.log('\n✅ Checkout successful!');
    return order;
  }
  
  getCartSummary() {
    const summary = {
      itemCount: 0,
      products: [],
      total: this.getFormattedTotal()
    };
    
    for (const { product, quantity } of this.#items.values()) {
      summary.itemCount += quantity;
      summary.products.push({
        name: product.name,
        quantity,
        price: product.formattedPrice,
        total: `$${(product.price * quantity).toFixed(2)}`
      });
    }
    
    return summary;
  }
}

// Usage Example
console.log('=== Creating Products ===');

// Validate product data
const productData = {
  name: 'JavaScript Course',
  price: 99.99,
  category: 'Education'
};

const validation = Product.validateProductData(productData);
console.log('Validation:', validation);

// Create products
const ebook = new DigitalProduct(
  'D001',
  'JavaScript eBook',
  'Complete guide to JavaScript',
  29.99,
  'Books',
  5,
  'https://example.com/download/ebook'
);

const tshirt = new PhysicalProduct(
  'P001',
  'JS T-Shirt',
  'JavaScript developer t-shirt',
  24.99,
  'Apparel',
  0.3,
  { length: 70, width: 50, height: 1 }
);

// Add stock to physical product
tshirt.addStock(10);

console.log('\n=== Product Details ===');
console.log('E-book:', ebook.getDetails());
console.log('T-Shirt:', tshirt.getDetails());

// Shopping cart
console.log('\n=== Shopping Cart ===');
const cart = new ShoppingCart();

cart.addItem(ebook, 1);
cart.addItem(tshirt, 2);

console.log('Cart summary:', cart.getCartSummary());

// Apply discount
ebook.applyDiscount(20);
console.log('\nAfter 20% discount on eBook:');
console.log('E-book new price:', ebook.formattedPrice);

// Checkout
try {
  const order = cart.checkout();
  console.log('\nOrder details:', order);
} catch (error) {
  console.error('Checkout error:', error.message);
}

console.log('\nCart after checkout:', cart.getCartSummary());

💡 Class Design Best Practices:

Single responsibility per class
Use private fields for encapsulation
Prefer composition over deep inheritance
Use getters/setters for computed properties
Add validation in setters
Use static methods for utility functions
Document public API with JSDoc

Next Steps

Now that you understand ES6 classes, learn about JavaScript's underlying prototype system that powers class inheritance.

← Modules Prototypes & Inheritance →

Frontend

JavaScript & Frameworks

Backend

Artificial Intelligence

Database

CSS Frameworks

Data Analytics

Digital Marketing

Frontend

Backend

Artificial Intelligence

DevOps

Database

Cyber Security

JavaScript Tutorial

ES6 Classes

🤔 What are ES6 Classes?

💡 Class Features

Under the Hood

📝 Class Basics

Key Components:

🧬 Class Inheritance

Inheritance Rules:

🔒 Private Fields & Methods

Private Features:

Benefits:

🧩 Mixins & Composition

Composition over Inheritance:

🛒 Practical Example: E-commerce

💡 Class Design Best Practices:

Next Steps

Follow Us

Our Tools

Our Company

Special Tools