JavaScript + OOPs
Tags: webdev, javascript, beginners, programming
Published: 2024-07-09 10:29:30

OOP — or Object-Oriented Programming — can help you organize your code in a more logical and manageable way, and it can make it easier to reuse and extend your code in the future.

In JavaScript, object-oriented programming (OOP) is a programming paradigm that is based on the concept of “objects”, which are collections of data and functions that work together to perform certain tasks.

In OOP, objects are created from “classes”, which are templates that define the properties and methods of the objects they create.

**Advantages of OOP**

One of the key advantages of using OOP in JavaScript is that it allows you to organize your code in a more logical and manageable way. With OOP, you can create classes that represent real-world objects and define the properties and methods that those objects have. This makes it easier to understand and work with your code, especially as it grows in complexity.

Another benefit of OOP in JavaScript or programming is that it allows for code reuse and extensibility.

Once you have defined a class, you can create as many objects from that class as you need. This can save you a lot of time and effort because you don’t have to write the same code over and over again for each object.

Additionally, you can create new classes that inherit from existing classes, which allows you to reuse and extend the functionality of existing code.

**Getting started with OOP**
To get started with OOP in JavaScript, you first need to understand the concept of a class. In JavaScript, a class is a template that defines the properties and methods of the objects it creates. Here is an example of a simple class that represents a person:

```
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
  greet() {
    console.log(`Hi, my name is ${this.name} and I am ${this.age} years old.`);
  }
}
```

In this example, the Person class has two properties: name and age. It also has one method, greet(), which outputs a greeting to the console.

To create an object from this class, you use the new keyword followed by the name of the class, like this:

```
const person1 = new Person("John", 25);
const person2 = new Person("Jane", 30);
```

Once you have created an object, you can access its properties and methods using dot notation, like this:

**OOP Inheritance in JavaScript**
In addition to defining classes and creating objects, OOP in JavaScript also allows for inheritance. This means that you can create new classes that inherit the properties and methods of existing classes. For example, let’s say you want to create a Student class that represents a student at a school. The Student class could inherit from the Person class, like this:

```
class Student extends Person {
  constructor(name, age, school) {
    super(name, age);
    this.school = school;
  }
  info() {
    console.log(`${this.name} is ${this.age} years old and goes to ${this.school}.`);
  }
}
```

**Four Pillars of OOPS**
The four pillars of object-oriented programming (OOP) in JavaScript are:

**Encapsulation:**
Encapsulation refers to the idea of wrapping data and functionality together inside an object. In OOP, objects are the basic building blocks of your code, and each object has its own properties and methods. This allows you to organize your code in a way that makes it easier to understand and work with.

For example, you might create a Person class that has properties like name and age, and methods like greet() and introduce().

**Abstraction**:

Abstraction is the process of hiding the details of an object’s implementation and only exposing the necessary information to the user. In OOP, you can use abstraction to make your code more modular and flexible.

For example, you can define an abstract class that provides a common interface for a group of related objects, without specifying how those objects are implemented.

**Inheritance:**
Inheritance is the process of creating new classes that inherit the properties and methods of existing classes. This allows you to reuse and extend existing code, which can save you time and effort.

For example, if you have a Person class that defines common properties and methods for a person, you can create a Student class that inherits from the Person class and adds additional functionality.

**Polymorphism:**
Polymorphism is the ability of different objects to respond to the same method call in different ways. In OOP, polymorphism allows you to create objects that share a common interface, but have different implementations. This makes your code more flexible and allows you to write code that is more easily maintainable and extensible.

For example, you can create a Shape class that defines a common draw() method, and then create subclasses for different types of shapes (e.g. Circle, Rectangle, etc.) that each implement the draw() method in their own way.

Here is an example of how these pillars of OOP might be used in a JavaScript program:

```
// Encapsulation: define a Person class with properties and methods
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
  greet() {
    console.log(`Hi, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

// Inheritance: define a Student class that inherits from the Person class
class Student extends Person {
  constructor(name, age, school) {
    super(name, age);
    this.school = school;
  }
  info() {
    console.log(`${this.name} is ${this.age} years old and goes to ${this.school}.`);
  }
}

// Abstraction: define an abstract Shape class with a common draw() method
abstract class Shape {
  abstract draw(): void;
}

// Polymorphism: define subclasses of Shape that implement the draw() method in their own way
class Circle extends Shape {
  draw() {
    console.log("Drawing a circle...");
  }
}
class Rectangle extends Shape {
  draw() {
    console.log("Drawing a rectangle...");
  }
}

```

**Wrapping Up**
Object-oriented programming is a fundamental concept in JavaScript and can greatly improve the structure and organization of your code. By understanding and implementing concepts such as encapsulation, inheritance, and polymorphism, you can create more efficient and maintainable programs.

Whether you’re a beginner or an experienced developer, taking the time to master OOP in JavaScript will pay off in the long run. Thanks for reading, and happy coding.