# Understanding Object-Oriented Programming in JavaScript

Modern software applications often model **real-world entities** like users, products, cars, or students. Writing separate variables for every property quickly becomes messy.

This is where **Object-Oriented Programming (OOP)** helps.

OOP allows us to structure code using **objects that represent real-world entities**, making programs easier to organize, reuse, and maintain.

In this article, we will understand how **Object-Oriented Programming works in JavaScript** using simple examples.

## What is Object-Oriented Programming (OOP)?

**Object-Oriented Programming (OOP)** is a programming style where we organize code using **objects**.

An **object** is simply a collection of:

*   **Properties** → data about the object
    
*   **Methods** → actions the object can perform
    

### Example

A **Car** object might have:

Properties:

*   color
    
*   brand
    
*   speed
    

Methods:

*   start()
    
*   stop()
    
*   accelerate()
    

Instead of writing many unrelated variables, OOP groups everything together inside an object.

This makes code **cleaner, reusable, and easier to manage**.

## Real-World Analogy: Blueprint → Objects

To understand OOP, think about **building cars in a factory**.

### Blueprint

A **blueprint** describes how a car should be built:

*   color
    
*   engine
    
*   model
    
*   wheels
    

But the blueprint itself **is not a car**.

### Objects

Using the blueprint, the factory creates many cars:

*   Car 1
    
*   Car 2
    
*   Car 3
    

Each car follows the same blueprint but has its own values.

In programming:

| Real World | Programming |
| --- | --- |
| Blueprint | Class |
| Car | Object |

So:

**Class → Blueprint**  
**Object → Real instance created from the blueprint**

![](https://cdn.hashnode.com/uploads/covers/69517129b3f42beb72514f64/d1cbdb4e-f1f1-43e3-ae69-e8039270b894.png align="center")

## What is a Class in JavaScript?

A **class** is a blueprint used to create objects.

It defines:

*   what **properties** an object will have
    
*   what **methods** an object can perform
    

### Example

```javascript
class Car {
  constructor(brand, color) {
    this.brand = brand;
    this.color = color;
  }

  start() {
    console.log(this.brand + " car started");
  }
}
```

Here:

*   `Car` → class
    
*   `brand` and `color` → properties
    
*   `start()` → method
    

## Creating Objects Using Classes

To create objects from a class, JavaScript uses the **new keyword**.

### Example

```javascript
const car1 = new Car("Toyota", "Red");
const car2 = new Car("BMW", "Black");
```

Now we have two different objects:

| Object | Brand | Color |
| --- | --- | --- |
| car1 | Toyota | Red |
| car2 | BMW | Black |

Both were created from the same **Car class blueprint**.

## Constructor Method

The **constructor** is a special method inside a class.

It runs **automatically when an object is created**.

It is used to **initialize properties** of the object.

### Example

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

When we create an object:

```javascript
const person1 = new Person("Alice", 25);
```

JavaScript automatically calls the constructor and assigns:

```shell
name → Alice
age → 25
```

## Methods Inside a Class

Methods are functions that belong to the class.

They define **actions an object can perform**.

### Example

```javascript
class Car {
  constructor(brand) {
    this.brand = brand;
  }

  drive() {
    console.log(this.brand + " is driving");
  }
}
```

Using the method:

```javascript
const car1 = new Car("Tesla");
car1.drive();
```

Output:

```shell
Tesla is driving
```

Methods allow objects to **perform behaviour**, not just store data.

### Mental model of class -> instance visual relation

![](https://cdn.hashnode.com/uploads/covers/69517129b3f42beb72514f64/1c2d09fb-afa2-44b9-a423-5ce4b69afca1.png align="center")

## Basic Idea of Encapsulation

**Encapsulation** means **keeping data and methods together inside a class**.

Instead of spreading logic across many functions and variables, everything related to an entity stays in one place.

Example:

```javascript
class BankAccount {
  constructor(owner, balance) {
    this.owner = owner;
    this.balance = balance;
  }

  deposit(amount) {
    this.balance += amount;
  }
}
```

Here the **data (balance)** and **operation (deposit)** are grouped inside the same class.

This improves:

*   code organization
    
*   maintainability
    
*   security
    

## Assignment Example: Student Class

Let’s create a simple **Student class**.

### Step 1: Create the class

```javascript
class Student {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  printDetails() {
    console.log("Name: " + this.name);
    console.log("Age: " + this.age);
  }
}
```

### Step 2: Create objects

```javascript
const student1 = new Student("Rahul", 20);
const student2 = new Student("Ananya", 21);
```

### Step 3: Use the method

```javascript
student1.printDetails();
student2.printDetails();
```

Output:

```shell
Name: Rahul
Age: 20

Name: Ananya
Age: 21
```

Here we created **multiple student objects from one class**, which demonstrates **code reusability**.

## Why OOP is Useful

Object-Oriented Programming helps developers:

*   Organize code better
    
*   Reuse code using classes
    
*   Model real-world entities easily
    
*   Build scalable applications
    

OOP is widely used in **large applications, frameworks, and software systems**.