JavaScript Object-Oriented Programming (OOP) with Examples

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of "objects", which can contain data and code. In JavaScript, OOP allows for the creation of objects that represent real-world entities, facilitating code reuse and modularity.

1. Understanding Objects

In JavaScript, an object is a standalone entity with properties and type. Objects can hold data (properties) and functions (methods).

// Creating an object
const car = {
    make: 'Toyota',
    model: 'Camry',
    year: 2020,
    displayInfo: function() {
        return `${this.year} ${this.make} ${this.model}`;
    }
};

console.log(car.displayInfo()); // Output: 2020 Toyota Camry

2. Classes and Constructors

Classes are a template for creating objects. You can define a class and use a constructor to initialize properties.

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

    introduce() {
        return `Hello, my name is ${this.name} and I am ${this.age} years old.`;
    }
}

// Creating an instance of the class
const person1 = new Person('Alice', 30);
console.log(person1.introduce()); // Output: Hello, my name is Alice and I am 30 years old.

3. Inheritance

Inheritance allows one class to inherit the properties and methods of another class. This promotes code reuse.

// Base class
class Animal {
    constructor(name) {
        this.name = name;
    }

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

// Derived class
class Dog extends Animal {
    speak() {
        return `${this.name} barks.`;
    }
}

const dog = new Dog('Buddy');
console.log(dog.speak()); // Output: Buddy barks.

4. Encapsulation

Encapsulation is the bundling of data with the methods that operate on that data. It restricts direct access to some of the object’s components.

class BankAccount {
    constructor(balance) {
        this._balance = balance; // Private property
    }

    deposit(amount) {
        this._balance += amount;
    }

    withdraw(amount) {
        if (amount <= this._balance) {
            this._balance -= amount;
        } else {
            console.log('Insufficient funds');
        }
    }

    getBalance() {
        return this._balance;
    }
}

const account = new BankAccount(1000);
account.deposit(500);
account.withdraw(200);
console.log(account.getBalance()); // Output: 1300

5. Polymorphism

Polymorphism allows methods to do different things based on the object it is acting upon, often achieved through method overriding.

class Cat extends Animal {
    speak() {
        return `${this.name} meows.`;
    }
}

const cat = new Cat('Whiskers');
console.log(cat.speak()); // Output: Whiskers meows.
console.log(dog.speak()); // Output: Buddy barks.

Conclusion

JavaScript OOP allows developers to create reusable and modular code. Understanding objects, classes, inheritance, encapsulation, and polymorphism is essential for effective programming in JavaScript.

0 Interaction

1.4K Views

30 Likes

You need to be logged in to participate in this discussion.