Advanced OOP & Design Patterns

1️⃣ Abstract Base Classes (ABC)

Abstract Base Classes (ABCs) wo classes hoti hain jinse direct object create nahi karte. Ye ek “blueprint” provide karti hain taaki subclasses me specific methods implement kar sakein.

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, r):
        self.r = r
    
    def area(self):
        return 3.14 * self.r * self.r

c = Circle(5)
print(c.area())  # Output: 78.5

2️⃣ Multiple Inheritance & MRO (Method Resolution Order)

Python me ek class multiple parent classes se inherit kar sakti hai. MRO (Method Resolution Order) decide karta hai ki agar same method multiple parents me ho, to kaunsa call hoga.

class A:
    def greet(self): print("Hello from A")

class B(A):
    def greet(self): print("Hello from B")

class C(A):
    def greet(self): print("Hello from C")

class D(B, C):
    pass

d = D()
d.greet()  # Output: Hello from B
print(D.mro())

3️⃣ Metaclasses

Metaclasses define karti hain ki classes kaise banti hain. Ye ek advanced concept hai jo framework design me use hota hai.

class Meta(type):
    def __new__(cls, name, bases, dct):
        print(f"Creating class {name}")
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=Meta):
    pass

4️⃣ Design Patterns

Singleton Pattern

Singleton pattern ensure karta hai ki ek class ka sirf ek hi instance bane.

class Singleton:
    _instance = None

    def __new__(cls):
        if not cls._instance:
            cls._instance = super().__new__(cls)
        return cls._instance

a = Singleton()
b = Singleton()
print(a is b)  # True

Factory Pattern

Factory pattern me hum ek class banate hain jo alag-alag subclasses ke objects create karti hai input ke hisaab se.

class Dog:
    def speak(self): return "Woof!"

class Cat:
    def speak(self): return "Meow!"

def get_pet(pet="dog"):
    pets = dict(dog=Dog(), cat=Cat())
    return pets.get(pet)

p = get_pet("cat")
print(p.speak())  # Meow!

💡 Summary

• ABCs help enforce structure
• MRO decides inheritance order
• Metaclasses control class creation
• Design Patterns make reusable code