Javascript - Object-Oriented JavaScript

Object-Oriented JavaScript

JavaScript supports object-oriented programming (OOP), though its approach differs from classical OOP languages like Java or C++. With features such as prototypes and classes, JavaScript enables the creation of complex, reusable objects.

Prototypes

Every JavaScript object has a prototype. A prototype is an object from which other objects inherit properties and methods. This prototype-based inheritance allows code sharing across instances.

Example: Using Prototypes

// Create a constructor function
function Person(name, age) {
  this.name = name;
  this.age = age;
}

// Add a method to the prototype
Person.prototype.greet = function() {
  console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
};

// Create an instance of Person
const alice = new Person('Alice', 30);
alice.greet(); // Output: Hello, my name is Alice and I am 30 years old.

The constructor sets up a blueprint for Person objects. The greet method is added to the prototype, meaning all instances of Person share it, promoting memory efficiency and code reuse.

Classes

ES6 introduced the class syntax, which provides a cleaner and more familiar structure for object-oriented code. Behind the scenes, classes still use prototypes.

Example: Defining and Using a Class

// Define a class
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  // Method defined in the class
  greet() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

// Create an instance of the class
const bob = new Person('Bob', 25);
bob.greet(); // Output: Hello, my name is Bob and I am 25 years old.

The class keyword defines the structure. The constructor initializes properties, and methods like greet are automatically placed on the prototype for sharing across instances.

Inheritance with Classes

JavaScript classes support inheritance using the extends keyword, allowing you to create subclasses that inherit and extend functionality from parent classes.

Example: Class Inheritance

// Define a parent class
class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    console.log(`${this.name} makes a noise.`);
  }
}

// Define a subclass that extends Animal
class Dog extends Animal {
  constructor(name, breed) {
    super(name); // Call the parent class constructor
    this.breed = breed;
  }

  // Override the speak method
  speak() {
    console.log(`${this.name} the ${this.breed} barks.`);
  }
}

// Create an instance of the subclass
const charlie = new Dog('Charlie', 'Labrador');
charlie.speak(); // Output: Charlie the Labrador barks.

The Dog class extends Animal, gaining access to its constructor and methods. The speak method is overridden to implement custom behavior for Dog instances.