# Object-Oriented Programming (OOP) in JavaScript Explained for Beginners

# Understanding Object-Oriented Programming (OOP) in JavaScript

When programs become larger, managing variables and functions separately can become messy. Object-Oriented Programming (OOP) helps us organize code in a structured and reusable way.

In JavaScript, OOP allows us to create **objects** that contain both **data (properties)** and **behavior (methods)**.

This makes code easier to maintain, reuse, and understand.

* * *

# What is Object-Oriented Programming?

Object-Oriented Programming is a programming style where we structure code using **objects**.

An object typically contains:

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

For example:

```javascript
let person = {
  name: "Rahul",
  age: 22,
  greet() {
    console.log("Hello!");
  }
};
```

Here:

*   `name` and `age` are **properties**
    
*   `greet()` is a **method**
    

OOP helps group related data and functionality together.

* * *

# Real-World Analogy: Blueprint → Objects

Think about how cars are made.

A **blueprint** defines how a car should look and behave:

*   brand
    
*   color
    
*   engine type
    
*   speed
    

But the blueprint itself is **not an actual car**.

Using that blueprint, factories can create many cars.

```javascript
Blueprint → Car Design

Objects created from blueprint:
Car 1 → Red Toyota
Car 2 → Blue Honda
Car 3 → Black BMW
```

In programming terms:

**Class → Blueprint**  
  
**Object → Actual item created from the blueprint**

* * *

# What is a Class in JavaScript?

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

It defines the structure and behavior that objects will have.

Example:

```javascript
class Person {

}
```

Right now the class is empty.  
  
Next, we add properties and methods.

* * *

# The Constructor Method

The **constructor** is a special method that runs automatically when a new object is created.

It is used to initialize properties.

Example:

```javascript
class Person {

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

}
```

Explanation:

*   `constructor()` runs when a new object is created
    
*   `this` refers to the current object
    
*   we assign values to object properties
    

* * *

# Creating Objects from a Class

Objects are created using the **new** keyword.

```javascript
class Person {

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

}

let person1 = new Person("Rahul", 22);
let person2 = new Person("Anita", 25);
```

Now we have two objects:

```javascript
person1 → { name: "Rahul", age: 22 }
person2 → { name: "Anita", age: 25 }
```

Both objects were created using the same class.

* * *

# Methods Inside a Class

Classes can also contain **methods**, which define behavior.

Example:

```javascript
class Person {

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

  introduce() {
    console.log("Hi, my name is " + this.name);
  }

}
```

Using the method:

```javascript
let person1 = new Person("Rahul", 22);

person1.introduce();
```

Output:

```javascript
Hi, my name is Rahul
```

Methods allow objects to perform actions.

* * *

# Basic Idea of Encapsulation

**Encapsulation means combining data and behavior in a single structure.**

Instead of storing data and functions separately, they are grouped together inside a class.

Example:

```javascript
class Car {

  constructor(brand, speed) {
    this.brand = brand;
    this.speed = speed;
  }

  accelerate() {
    this.speed += 10;
    console.log(this.brand + " speed is now " + this.speed);
  }

}
```

Here:

*   `brand` and `speed` → data
    
*   `accelerate()` → behavior
    

Everything related to the **Car** is contained inside one structure.

This keeps code organized and easier to maintain.

* * *

# Why OOP is Useful

Object-Oriented Programming helps in several ways.

### Code Reusability

We can create many objects from the same class.

### Better Organization

Related data and behavior stay together.

### Easier Maintenance

When projects grow, structured code is easier to manage.

* * *

# Assignment

Create a **Student class** with the following requirements.

**Properties**

*   name
    
*   age
    

**Method**

*   `printDetails()`
    

Expected output example:

```javascript
Name: Rahul
Age: 20
```

Create multiple student objects and call the method.

* * *

# Example Solution

```javascript
class Student {

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

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

}

let student1 = new Student("Rahul", 20);
let student2 = new Student("Anita", 21);

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

* * *

# Simple Diagram

```javascript
Class (Blueprint)

        Student
   -----------------
   name
   age
   printDetails()

        ↓

Objects (Instances)

student1 → { name: "Rahul", age: 20 }
student2 → { name: "Anita", age: 21 }
```