क्लास और ऑब्जेक्ट
प्रोसीजरल प्रोग्रामिंग में हम कदमों और फ़ंक्शन की सूची लिखते हैं। ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग (OOP) में डेटा और उस पर काम करने वाला कोड एक साथ ऑब्जेक्ट में रखते हैं।
- क्लास एक ब्लूप्रिंट (योजना) है। यह बताती है कि ऑब्जेक्ट के पास क्या डेटा और क्या काम होंगे।
- ऑब्जेक्ट (या इंस्टेंस) क्लास से बनी एक असली चीज़ है।
- एट्रिब्यूट वह डेटा है जो ऑब्जेक्ट रखता है, जैसे रंग और गति।
- मेथड क्लास के अंदर के फ़ंक्शन हैं, जैसे accelerate()।
class Car:
def __init__(self, colour):
self.colour = colour
self.speed = 0
def accelerate(self, amount):
self.speed += amount
car1 = Car("red")
car2 = Car("yellow")
car1.accelerate(20)
print(car1.speed, car2.speed) # 20 0
कंस्ट्रक्टर, self, और क्लास बनाम इंस्टेंस वेरिएबल
कंस्ट्रक्टर ऑब्जेक्ट बनते ही अपने-आप चलता है। Python में यह __init__ है; Java में इसका नाम क्लास जैसा होता है। यह नए ऑब्जेक्ट को शुरुआती मान देता है।
self (Python) या this (Java) का मतलब है "यही ऑब्जेक्ट"। self.speed उस ऑब्जेक्ट की गति है जिस पर मेथड चला।
- इंस्टेंस वेरिएबल: हर ऑब्जेक्ट की अपनी कॉपी (रंग, गति)।
- क्लास वेरिएबल (Java में
static): सभी ऑब्जेक्ट्स में एक ही साझा कॉपी, जैसेwheels = 4या बनी कारों की गिनती।
मेथड सिग्नेचर = मेथड का नाम + पैरामीटर सूची, जैसे accelerate(amount)। Java में: public void accelerate(int amount)।
// Java
public class Car {
private String colour;
private int speed;
public Car(String colour) { this.colour = colour; this.speed = 0; }
public void accelerate(int amount) { speed += amount; }
}
एनकैप्सुलेशन और एब्स्ट्रैक्शन
एनकैप्सुलेशन का मतलब है ऑब्जेक्ट का डेटा उसके अंदर रखना और बाहर वालों को केवल मेथड से बदलने देना। एट्रिब्यूट को private बनाते हैं (Java में private; Python में नाम __ से शुरू) और getter, setter मेथड देते हैं जो मान जाँच सकें। जैसे बैंक खाते का withdraw() बैलेंस शून्य से नीचे नहीं जाने देता।
एब्स्ट्रैक्शन का मतलब है उपयोगकर्ता को केवल ज़रूरी चीज़ दिखाना और बारीकियाँ छिपाना। आप कार का एक्सीलरेटर दबाते हैं, इंजन कैसे चलता है यह जाने बिना। एब्स्ट्रैक्ट क्लास या इंटरफ़ेस वे मेथड बताते हैं जो चाइल्ड क्लास को बनाने ही होंगे।
इनहेरिटेंस और पॉलीमॉर्फ़िज़्म
इनहेरिटेंस: सबक्लास (चाइल्ड) सुपरक्लास (पैरेंट) से बनती है। उसे पैरेंट के सारे एट्रिब्यूट और मेथड मिलते हैं और वह नए जोड़ सकती है। यह "is-a" रिश्ता है: ElectricCar एक Car है।
पॉलीमॉर्फ़िज़्म ("कई रूप"): एक ही मेथड का नाम अलग क्लास में अलग काम करता है। चाइल्ड क्लास पैरेंट के मेथड को ओवरराइड कर सकती है।
class ElectricCar(Car):
def __init__(self, colour):
super().__init__(colour)
self.battery = 100
def describe(self): # Car.describe को ओवरराइड
return "electric, battery " + str(self.battery)
for c in [Car("red"), ElectricCar("blue")]:
print(c.describe())ऑब्जेक्ट से डिज़ाइन
UML क्लास डायग्राम में हर क्लास एक डिब्बा है: नाम, एट्रिब्यूट, मेथड (+ public, − private)। कंपोज़िशन "has-a" रिश्ता है: Car के पास Engine है। OOP से कोड दोबारा इस्तेमाल होता है, जाँचना आसान होता है और टीम में बाँटना आसान होता है।
करके देखो
घर की कोई चीज़ चुनो, जैसे मोबाइल फ़ोन। उसकी क्लास लिखो: 3 एट्रिब्यूट और 2 मेथड। फिर अलग मानों वाले दो ऑब्जेक्ट लिखो।
मुख्य सूत्र और परिभाषाएँ
- क्लास: एट्रिब्यूट + मेथड वाला ब्लूप्रिंट
- ऑब्जेक्ट / इंस्टेंस: क्लास से बनी एक चीज़, जैसे car1 = Car("red")
- कंस्ट्रक्टर: __init__ (Python), ClassName(...) (Java)
- एनकैप्सुलेशन: private डेटा + public मेथड (getter/setter)
- इनहेरिटेंस: class Child(Parent): "is-a" रिश्ता; super() पैरेंट को बुलाता है
- पॉलीमॉर्फ़िज़्म: एक नाम, अलग व्यवहार (ओवरराइडिंग)
- एब्स्ट्रैक्शन: क्या करता है दिखाओ, कैसे करता है छिपाओ
हल किए गए उदाहरण
1. name और marks वाली class Student लिखो, और is_pass() मेथड जो marks ≥ 33 पर True दे।
class Student: def __init__(self, name, marks): self.name = name self.marks = marks def is_pass(self): return self.marks >= 33 s = Student("Asha", 72); s.is_pass() → True
2. car1 = Car("red"); car2 = car1; car2.accelerate(10)। car1.speed कितनी है?
10। car2 = car1 नया ऑब्जेक्ट नहीं बनाता; दोनों नाम एक ही ऑब्जेक्ट की ओर इशारा करते हैं। नया ऑब्जेक्ट केवल Car(...) से बनता है।
3. एक क्लास वेरिएबल बनाओ जो गिने कि कितने Car ऑब्जेक्ट बने।
class Car: count = 0 def __init__(self, colour): self.colour = colour Car.count += 1 Car("red") और Car("blue") के बाद Car.count = 2।
4. ऐसा BankAccount बनाकर एनकैप्सुलेशन दिखाओ जो शून्य से नीचे न जाए।
class BankAccount: def __init__(self): self.__balance = 0 def deposit(self, x): if x > 0: self.__balance += x def withdraw(self, x): if x <= self.__balance: self.__balance -= x def get_balance(self): return self.__balance बाहर का कोड acc.__balance = -500 नहीं लिख सकता।
5. Animal का speak() "..." लौटाता है। Dog और Cat इसे ओवरराइड करते हैं। लूप क्या छापेगा? for a in [Dog(), Cat(), Animal()]: print(a.speak())
"Woof", "Meow", "..."। हर ऑब्जेक्ट अपनी क्लास का वर्ज़न चलाता है: यही पॉलीमॉर्फ़िज़्म है।
6. class Book का UML डिब्बा बनाओ: private title, price और public मेथड apply_discount(p)।
Book − title: str − price: float + apply_discount(p: float): void
आम गलतियाँ
- क्लास और ऑब्जेक्ट को एक समझना: क्लास योजना है, ऑब्जेक्ट उससे बनी चीज़।
- Python मेथड में self भूल जाना, जैसे def accelerate(amount) लिखना।
- सोचना कि b = a ऑब्जेक्ट की कॉपी बनाता है। यह उसी ऑब्जेक्ट का दूसरा नाम है।
- "has-a" रिश्ते के लिए इनहेरिटेंस लगाना। Car के पास Engine है; Car कोई Engine नहीं है।