Unit 12: Object-Oriented Programming (OOP)

class Student:
    # Class Variable: Shared by ALL student objects
    college_name = "DevAscent Academy"

    # Constructor: Initializes unique attributes per instance
    def __init__(self, name, roll_no, gpa):
        self.name = name          # Instance variable
        self.roll_no = roll_no    # Instance variable
        self.gpa = gpa            # Instance variable

    # Instance Method: Uses self to access calling object's data
    def get_details(self):
        return f"Roll #{self.roll_no}: {self.name} | GPA: {self.gpa} | College: {Student.college_name}"

# Creating two separate instances in memory
s1 = Student("Aman Gupta", 101, 8.9)
s2 = Student("Neha Sharma", 102, 9.4)

print(s1.get_details())
print(s2.get_details())

# Proof of Class Variable sharing: Update college name once
Student.college_name = "DevAscent University"
print("\nAfter updating Class Variable:")
print(f"{s1.name}'s College -> {s1.college_name}")
print(f"{s2.name}'s College -> {s2.college_name}")

class BankAccount:
    def __init__(self, account_holder, initial_balance):
        self.holder = account_holder     # Public
        self.__balance = initial_balance # PRIVATE: double underscore prevents direct tampering!

    # Getter: Securely read balance
    def get_balance(self):
        return self.__balance

    # Setter: Enforce business validation rules
    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Deposit amount must be positive!")
        self.__balance += amount
        return self.__balance

account = BankAccount("Rahul Verma", 5000)
print("Account Holder:", account.holder)
print("Current Balance:", account.get_balance())

account.deposit(2500)
print("Balance after ₹2500 deposit:", account.get_balance())

# Attempting direct access to private variable throws an AttributeError!
try:
    print(account.__balance)
except AttributeError:
    print("🛑 BLOCKED: 'BankAccount' object has no attribute '__balance' (Private Protection!)")

# Parent Base Class
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        return f"Hello, my name is {self.name} and I am {self.age} years old."

# Child Derived Class (Single Inheritance)
class Professor(Person):
    def __init__(self, name, age, department, salary):
        # Delegate core attributes to Person's constructor via super()
        super().__init__(name, age)
        self.department = department
        self.salary = salary

    # Extended method specific to Professor
    def conduct_lecture(self, topic):
        return f"Prof. {self.name} ({self.department}) is delivering lecture on: {topic}"

prof = Professor("Dr. Arvind Mehta", 48, "Computer Science", 120000)
print(prof.introduce())        # Inherited directly from Person!
print(prof.conduct_lecture("Algorithms & Dynamic Programming"))

class PaymentMethod:
    def pay(self, amount):
        raise NotImplementedError("Subclasses must implement pay()!")

# Child 1: Overrides pay() with Credit Card logic
class CreditCardPayment(PaymentMethod):
    def __init__(self, card_no):
        self.card_no = card_no[-4:]

    def pay(self, amount):
        return f"💳 Paid ₹{amount} using Credit Card ending in **{self.card_no}"

# Child 2: Overrides pay() with UPI logic
class UPIPayment(PaymentMethod):
    def __init__(self, upi_id):
        self.upi_id = upi_id

    def pay(self, amount):
        return f"📱 Paid ₹{amount} via UPI handle: {self.upi_id}"

# Polymorphic Dispatcher Function: Works with ANY payment object!
def checkout(payment_gateway, bill_amount):
    print(payment_gateway.pay(bill_amount))

payments = [
    CreditCardPayment("4532118944528901"),
    UPIPayment("shivan@okaxis")
]

for p in payments:
    checkout(p, 2499)

from abc import ABC, abstractmethod
import math

# Abstract Contract Class
class Shape(ABC):
    @abstractmethod
    def calculate_area(self):
        """Every concrete child class MUST implement calculate_area."""
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    # Fulfilling the abstract contract
    def calculate_area(self):
        return round(math.pi * (self.radius ** 2), 2)

class Rectangle(Shape):
    def __init__(self, length, width):
        self.length = length
        self.width = width

    # Fulfilling the abstract contract
    def calculate_area(self):
        return self.length * self.width

c = Circle(7)
r = Rectangle(10, 5)

print("Circle Area   :", c.calculate_area())
print("Rectangle Area:", r.calculate_area())

# Attempting to instantiate an Abstract Class fails immediately!
try:
    s = Shape()
except TypeError as err:
    print("🛑 Abstraction Enforced:", err)

class Book:
    def __init__(self, title, author, price):
        self.title = title
        self.author = author
        self.price = price

    # User-facing string representation for print()
    def __str__(self):
        return f"📖 '{self.title}' by {self.author} (₹{self.price})"

    # Developer-facing unambiguous representation for debugging
    def __repr__(self):
        return f"Book(title='{self.title}', author='{self.author}', price={self.price})"

b = Book("Fluent Python", "Luciano Ramalho", 1850)

print("Calling print(b)   -> Triggers __str__ :", b)
print("Calling repr(b)    -> Triggers __repr__:", repr(b))

from abc import ABC, abstractmethod

# 1. Abstraction
class BankAccount(ABC):
    def __init__(self, account_no, holder, initial_balance):
        self.account_no = account_no
        self.holder = holder
        self.__balance = initial_balance  # 2. Encapsulation: Private state

    def get_balance(self):
        return self.__balance

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            return self.__balance
        raise ValueError("Deposit must be positive!")

    def _withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            return True
        return False

    @abstractmethod
    def apply_monthly_interest(self):
        pass

    # 3. Special Dunder Method
    def __str__(self):
        return f"[{self.__class__.__name__}] #{self.account_no} ({self.holder}) Balance: ₹{self.__balance:,.2f}"

# 4. Inheritance & Method Overriding
class SavingsAccount(BankAccount):
    INTEREST_RATE = 0.04  # 4% annual interest

    def apply_monthly_interest(self):
        interest = self.get_balance() * (self.INTEREST_RATE / 12)
        self.deposit(round(interest, 2))
        return interest

class CurrentAccount(BankAccount):
    OVERDRAFT_LIMIT = 25000

    def apply_monthly_interest(self):
        return 0.0  # Current accounts do not earn interest

# 5. Polymorphic Execution
accounts = [
    SavingsAccount("SB-1001", "Ananya Roy", 50000),
    CurrentAccount("CA-5002", "Apex Technologies Ltd", 180000)
]

print("--- Monthly Batch Processing ---")
for acc in accounts:
    interest_earned = acc.apply_monthly_interest()
    print(acc)
    print(f"  -> Monthly Interest Credited: ₹{interest_earned:.2f}\n")