FSc Part 2 Computer Science Chapter 3 Complete Guide Book — Object Oriented Programming Using Python | PunjabTest.com

Object-Oriented Programming (OOP) is a method of designing programs using objects and classes. Each object represents a real-world entity with specific properties and behaviors. Classes act as templates for creating multiple objects with similar characteristics. OOP emphasizes encapsulation, inheritance, and polymorphism to manage data and behavior efficiently. This approach helps in modeling real-world problems in programming.

Benefits of OOP — Modularity, Reusability, and Easier Maintenance: OOP allows code to be divided into modules, making it easier to manage. Classes and objects can be reused in multiple programs or parts of a program, reducing repetition. Programs built with OOP are easier to maintain and update because changes in one part do not affect the entire system. The structure of OOP supports scalability and adaptability in software development. It also improves collaboration by making code more understandable and organized.

Core concepts of OOP: classes and objects, encapsulation, inheritance, and polymorphism. These concepts make programs organized, reusable, and easier to manage.

A class is a blueprint or template that defines the properties (attributes) and actions (methods) of an entity. An object is an instance of a class that holds actual values for its attributes. Classes and objects allow programs to model real-world entities in code. Using classes and objects helps organize data and related functionality together, making programs more structured.

Book example — Class: Person: attributes name, age, gender; methods eat(), sleep(), work(). Object P1: name = Bob, age = 34, gender = Male. Object P2: name = Jenny, age = 27, gender = Female. Same class, different data.

class Student:
    def __init__(self, name):
        self.name = name

    def display(self):
        print("Student Name:", self.name)

# Creating objects
object1 = Student("Ali")
object2 = Student("Ahmed")

# Using objects
object1.display()
object2.display()

Line by line: class Student → defines a blueprint for students. __init__ → sets the name when an object is created. self.name → stores the student's name. display() → prints the student's name. object1 and object2 → two different student objects. Each object has its own data (Ali, Ahmed).

Note: self is the reference to the current object, passed automatically to instance methods.

Encapsulation is a concept in OOP where we bundle data (variables) and methods (functions) into a single unit (class) and restrict direct access to the data. Unlike languages like Java or C++, Python does not have strict "private" or "protected" keywords. Instead, it relies on naming conventions to signal how data should be accessed. Rule of thumb: hide the data and control access using methods.

Why Encapsulation is important: protects data from unwanted access; improves security; makes code easier to manage; allows controlled modification.

Example: think of a bank account — your balance is hidden. You can access it using deposit() and withdraw(). You cannot directly change the balance. This is encapsulation.

Levels of Access Control: in Python, you can control the visibility of class members using specific naming prefixes:
• Public Members: accessible from anywhere — inside or outside the class. By default, all members in Python are public. Syntax: self.attribute_name
• Protected Members: intended for internal use within the class and its subclasses. It is a convention (not a restriction) to signal to other developers that the member should not be accessed from outside. Syntax: self._attribute_name (single underscore)
• Private Members: highly restricted and cannot be easily accessed from outside the class. Python uses a mechanism called Name Mangling to change the internal name of the variable to prevent accidental access. Syntax: self.__attribute_name (double underscore)

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance   # Private variable

    def deposit(self, amount):
        self.__balance += amount
    def withdraw(self, amount):
        if amount <= self.__balance:
            self.__balance -= amount
        else:
            print("Insufficient balance")

    def get_balance(self):
        return self.__balance

# Usage
account = BankAccount(1000)
account.deposit(500)
account.withdraw(300)

print(account.get_balance())   # Output: 1200

# Direct access will fail
# print(account.__balance)     # Error

Inheritance allows a class to take properties and methods from another class. The new class, called a subclass, can add or modify features of the parent class. Inheritance promotes code reuse and reduces redundancy. It also makes it easier to extend programs without rewriting existing code.

Parent Class (Base Class): the class whose properties are inherited. In the example below, Animal is the parent class.
Child Class (Derived Class): the class that inherits from the parent. It is defined by passing the parent class name in parentheses: class Child(Parent).
Method Overriding: a child class can provide a specific implementation of a method that is already provided by its parent. You can use the super() function to call the parent's version of that method.

# Parent class (Superclass)
class Animal:
    def __init__(self, name):
        self.name = name

    def eat(self):
        print(f"{self.name} is eating.")

# Child class (Subclass) inheriting from Animal
class Dog(Animal):
    def bark(self):
        print(f"{self.name} says Woof!")

# Create an object of the child class
my_dog = Dog("Buddy")

# Access method from Parent class
my_dog.eat()    # Output: Buddy is eating.

# Access method from Child class
my_dog.bark()   # Output: Buddy says Woof!

Single Inheritance: a child class (subclass) inherits attributes and methods from exactly one parent class (superclass). This is the most fundamental form of inheritance in Python, promoting code reusability by allowing the child class to extend or modify the behavior of the parent.

Multiple Inheritance: allows a single class to inherit features (attributes and methods) from more than one parent class. This enables a child class to combine behaviors from different sources, such as a Smartphone class inheriting from both a Camera and a Computer class. Book example: Child(Father, Mother) can access skill1() (Father's skill: Gardening), skill2() (Mother's skill: Cooking), and its own skill own_skill() (Child's skill: Coding).

Multilevel Inheritance: occurs when a class inherits from another derived class, creating a chain of inheritance similar to a family tree (Grandparent → Parent → Child). In this structure, the "grandchild" class has access to all methods and attributes from both its immediate parent and its grandparent. Book example: ElectricCar inherits from Car, which in turn inherits from Vehicle — my_tesla.start_engine() (from Vehicle), my_tesla.drive() (from Car), my_tesla.charge() (defined in ElectricCar).

Polymorphism means "many forms". It refers to the ability of an entity (like a function or object) to perform different actions based on the context. Technically, polymorphism allows the same method, function, or operator to behave differently depending on the object it is working with. This makes code more flexible and reusable.

Example: in a backend payment system, multiple payment options are available, such as Credit Card, UPI, NetBanking, and Wallet. All payment types use a common method named processPayment(), but different implementations — e.g. NetBanking Payment redirects to bank login. The method name remains the same, but the action changes based on the payment type.

Types of Polymorphism: mainly compile-time and runtime polymorphism.

1. Compile-time Polymorphism: means deciding which method or operation to run during compilation, usually through method or operator overloading. Languages like Java or C++ support this. But Python does not support true method overloading based on function signatures like statically typed languages (e.g., Java or C++). Because Python is dynamically typed, a single function can accept arguments of different types, making signature-based overloading unnecessary. Instead, similar behavior can be achieved using default arguments, variable-length arguments (*args, **kwargs), or conditional logic inside the function.

class Calculator:
    def multiply(self, a=1, b=1, *args):
        result = a * b
        for num in args:
            result *= num
        return result

# Create object
calc = Calculator()

# Using default arguments
print(calc.multiply())        # Output: 1
print(calc.multiply(4))       # Output: 4

# Using multiple arguments
print(calc.multiply(2, 3))    # Output: 6
print(calc.multiply(2, 3, 4)) # Output: 24

2. Runtime Polymorphism (Overriding): means that the behavior of a method is decided while the program is running, based on the object calling it. This happens through Method Overriding: a child class provides its own version of a method already defined in the parent class.

class Animal:
    def sound(self):
        return "Some generic sound"

class Dog(Animal):
    def sound(self):
        return "Bark"

class Cat(Animal):
    def sound(self):
        return "Meow"

# Polymorphic behavior
animals = [Dog(), Cat(), Animal()]
for animal in animals:
    print(animal.sound())
# Output: Bark / Meow / Some generic sound

Here, the sound() method behaves differently depending on whether the object is a Dog, Cat, or Animal, and this decision happens at runtime. This dynamic nature makes Python particularly powerful for runtime polymorphism.

Answer key (from the book): 1–C, 2–B, 3–A, 4–A, 5–A, 6–B, 7–B, 8–B, 9–A, 10–B.