Object-Oriented JavaScript (OOJS) Kya Hoti Hai?

OOJS ka Introduction

Object-Oriented JavaScript (OOJS) ek programming style hai jisme code ko objects ke form mein organize kiya jata hai. Ek object data (properties) aur behavior (methods) ko ek saath bundle karta hai. OOJS ka main goal code ko reusable, maintainable, aur modular banana hai.

JavaScript mein objects create karne ke liye hum constructor functions, prototypes ya ES6 classes ka use karte hain. Inheritance, encapsulation aur abstraction jaise concepts OOJS mein follow kiye jaate hain. Jab kisi object se related logic ko alag rakha jata hai, code samajhna aur manage karna asaan ho jata hai.

1. Object Literals

Object literals, objects create karne ka sabse simple tareeka hai. Yeh key-value pairs ki ek comma-separated list hoti hai, jo curly braces {} ke andar likhi jaati hai. Yeh tabhi best hai jab aapko sirf ek ya do objects banane ho.

let person = {
  name: "Sandeep",
  age: 24,
  greet: function () {
    console.log("Hello, " + this.name);
  }
};
person.greet(); // Output: Hello, Sandeep

2. Constructor Functions

Agar aapko ek hi structure ke kai objects banane ho, to constructor functions ka use hota hai. Yeh ek blueprint ki tarah kaam karte hain.

function Person(name, age) {
  this.name = name;
  this.age = age;
  this.greet = function () {
    console.log("Hi, my name is " + this.name);
  };
}

let p1 = new Person("Amit", 30);
let p2 = new Person("Priya", 28);

p1.greet(); // Hi, my name is Amit
p2.greet(); // Hi, my name is Priya

Problem: Is approach me, har naye object ke saath `greet` method ki ek nayi copy banti hai, jo memory efficient nahi hai. Iska solution prototype ya ES6 Classes hain.

3. ES6 Classes & Inheritance

ES6 classes object-oriented programming ko easy aur readable banata hai. Yeh asal me prototype-based inheritance ke upar ek syntactic sugar hai.

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

  greet() {
    console.log(`Hello, I am ${this.name}`);
  }
}

let p = new Person("Neha", 22);
p.greet(); // Output: Hello, I am Neha

Inheritance with `extends`

Inheritance se ek class (child) doosri class (parent) ke features ko inherit kar sakti hai. Isse code reuse hota hai.

class Student extends Person {
  constructor(name, age, grade) {
    super(name, age); // parent class ka constructor call
    this.grade = grade;
  }

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

let s1 = new Student("Rahul", 15, 10);
s1.greet(); // Inherited from Person
s1.study(); // Own method

4. Static & Instance Methods

JavaScript mein methods do tarah ke hote hain — Static methods aur Instance methods.

Static methods kisi class ke naam se direct call kiye jaate hain, bina object banaye. Example: `Math.random()`.

Instance methods object ke instance par kaam karte hain. Inhe use karne ke liye class ka object banana padta hai.

class Car {
  // Instance Method
  drive() {
    console.log("Driving the car");
  }
  
  // Static Method
  static add(a, b) {
    return a + b;
  }
}

let myCar = new Car();
myCar.drive(); // Instance method call

console.log(Car.add(5, 3)); // Static method call

Key Takeaways

• OOJS code ko objects me organize karne ka ek style hai, jisse code reusable aur maintainable banta hai.
• Object Literals simple, one-off objects ke liye best hain.
• ES6 Classes ek hi structure ke multiple objects banane ke liye modern blueprint provide karte hain.
• Inheritance (`extends` keyword) se code reusability badhti hai.
• Static Methods class ke level par kaam karte hain, jabki Instance Methods object ke level par kaam karte hain.