Object-Oriented Programming (OOP) in JavaScript is a programming paradigm that uses objects as the core building blocks for structuring and organizing code. It allows you to model real-world entities and their interactions in a more intuitive and modular way. JavaScript is a versatile language that supports OOP principles, and here are some key concepts of OOP in JavaScript:

• Objects: In JavaScript, objects are collections of key-value pairs, where the keys are known as properties, and the values can be data or functions. Objects are used to encapsulate data and behavior related to a specific entity.
• Classes: ES6 introduced class syntax to JavaScript, allowing you to define blueprints for creating objects. Classes define the structure and behavior of objects, including properties and methods. They make it easier to create multiple instances of objects with the same structure.

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

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

const person1 = new Person("Alice", 25);
const person2 = new Person("Bob", 30);

• Inheritance: JavaScript supports inheritance, allowing you to create subclasses that inherit properties and methods from a parent class. This promotes code reuse and hierarchy in your object structure.

class Student extends Person {
  constructor(name, age, studentId) {
    super(name, age); // Call the constructor of the parent class
    this.studentId = studentId;
  }

  study() {
    console.log(`${this.name} is studying.`);
  }
}

const student1 = new Student("Eve", 22, "12345");
student1.sayHello(); // "Hello, my name is Eve and I am 22 years old."
student1.study();    // "Eve is studying."

• Encapsulation: Encapsulation is the practice of bundling data (properties) and the methods (functions) that operate on that data within an object. Private and public access control can be emulated in JavaScript to protect and control access to object properties and methods.

class BankAccount {
  constructor(balance) {
    let _balance = balance; // Private variable

    this.getBalance = function() {
      return _balance;
    };

    this.deposit = function(amount) {
      if (amount > 0) {
        _balance += amount;
      }
    };
  }
}

const account = new BankAccount(1000);
console.log(account.getBalance()); // 1000
account.deposit(500);
console.log(account.getBalance()); // 1500

• Polymorphism: Polymorphism allows objects of different classes to be treated as objects of a common superclass. In JavaScript, polymorphism is achieved through dynamic typing and duck typing, where objects are evaluated based on their capabilities rather than their specific types.

OOP in JavaScript helps organize code into manageable, reusable, and self-contained units, making it easier to maintain and extend applications. It's a powerful paradigm for building complex software systems with clear structures and interactions.