Object-oriented programming (OOP) is a programming paradigm centred around the concept of objects.
Table of Contents
What is a Class?
- A class is a blueprint or template for creating objects.
- It defines the attributes(data members) and behaviours(methods) that objects will have.
- Classes are a fundamental concept in object-oriented programming (OOP).
- It’s a real-world entity
For example, if you want to model a Car, you would create a Car class that might have properties like colour, make, and model, and methods (functions) like start_engine() or drive().
# Defining a class
class Car:
def __init__(self, make, model, color):
self.make = make # Attribute
self.model = model # Attribute
self.color = color # Attribute
def start_engine(self): # Method
print(f"The {self.color} {self.make} {self.model}'s engine has started.")
def drive(self): # Method
print(f"The {self.color} {self.make} {self.model} is now driving.")What is an Object?
- Object is an instance of a class.
- All data members and member functions of the class can be accessed with the help of objects.
- When a class is defined, no memory is allocated, but memory is allocated when it is instantiated (i.e. an object is created).
my_car = Car(make="Toyota", model="Camry", color="Red")
# Accessing attributes and methods
print(my_car.make) # Output: Toyota
my_car.start_engine() # Output: The Red Toyota Camry's engine has started.
my_car.drive() # Output: The Red Toyota Camry is now driving.
OOP Concept
Object-oriented programming (OOP) is about classes and objects. OOP enables us to model real-world entities, making code more modular, reusable, and easier to maintain. Four fundamental principles—abstraction, encapsulation, inheritance, and polymorphism—form the backbone of OOP. Understanding these principles is crucial for writing effective and efficient object-oriented code.
Encapsulation
- Wrapping data (attributes) and functions(methods) together in a single unit is called encapsulation.
- It restricts access to certain components of an object to protect the integrity of the data and prevent unauthorized or accidental interference.
- Private Members: In many OOP languages, you can make data members private, so they cannot be accessed from outside the class. For example, in Python, you can prefix an attribute with an underscore (
_) to indicate it is private by convention only.
class BankAccount:
def __init__(self, balance):
self.__balance = balance
def deposit(self, amount):
self.__balance += amount
def withdraw(self, amount):
if amount <= self.__balance:
self.__balance -= amount
else:
print("Insufficient funds")
def get_balance(self):
return self.__balance
account = BankAccount(1000)
account.deposit(500)
print(account.get_balance()) # Output: 1500In the above code, we have wrapped all attributes and methods related to the Bank account as a single unit.
Inheritance
- It allows a new class to inherit properties and behaviour from an existing class.
- It helps in reusing code and establishing a natural hierarchy between classes.
class Vehicle:
def __init__(self, make, model):
self.make = make
self.model = model
def start(self):
return f"{self.make} {self.model} is starting."
class Car(Vehicle):
def __init__(self, make, model, doors):
super().__init__(make, model)
self.doors = doors
def open_doors(self):
return f"Opening {self.doors} doors."
my_car = Car("Honda", "Civic", 4)
print(my_car.start()) # Output: Honda Civic is starting.
print(my_car.open_doors()) # Output: Opening 4 doors.The Car doesn’t have method start(), But the Car object is using start() due to inheritance
Polymorphism
- Polymorphism means “many forms” and allows methods to do different things based on the object it is acting upon, even if they share the same name.
- The ability of a message to be displayed in more than one form.
- It can be achieved through method overloading, method overriding, and operator overloading
Example: A person can have different characteristics at the same time. Like a man at the same time is a father, a husband, and an employee. So the same person possesses different behaviors in different situations. This is called polymorphism.
Method Overloading
- Method overloading allows a class to have multiple methods with the same name but with different signatures(number, type, or order).
- Compile-time Polymorphism
- Python does not natively support method overloading in the same way as some other languages (like Java or C++). Read further
add(int item1, int item2)
add(int item1, int item2,int item3)
add(string item1, string item2)Method Overriding
- Method overriding allows a child class to provide a specific implementation of a method that is already defined in its parent class.
- Runtime polymorphism
class Animal:
def speak(self):
return "Some generic sound"
class Dog(Animal):
def speak(self):
return "Bark"
class Cat(Animal):
def speak(self):
return "Meow"
def make_animal_speak(animal):
print(animal.speak())
my_dog = Dog()
my_cat = Cat()
make_animal_speak(my_dog) # Output: Bark
make_animal_speak(my_cat) # Output: Meow
In this example, the sound method is defined in both the Animal class and its subclasses Dog and Cat. When the sound method is called on an object of the Dog or Cat class, the overridden method in the respective subclass is executed instead of the one in the Animal class.
Abstraction
- This principle involves hiding complex implementation details and showing only the essential features of an object.
- This allows the user to interact with an object without understanding its internal workings.
- In many OOP languages, abstract classes or interfaces implement abstraction.
- An abstract class cannot be instantiated and often includes one or more abstract methods that must be implemented by derived classes.
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self):
pass
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
return 3.1416 * self.radius * self.radius
my_circle = Circle(5)
print(my_circle.area()) # Output: 78.54Advantages of OOP
- Modularity: Code is organised into distinct classes, making it easier to manage and maintain.
- Reusability: Inheritance and polymorphism promote code reuse.
- Flexibility: Encapsulation and abstraction allow for changes in code with minimal impact on other parts of the program.
- Scalability: OOP provides a structured way to develop complex software that can be easily scaled.
Read about Association, Aggregation, and Composition
Important Concepts
A superclass reference variable can indeed refer to a subclass object
Java
Java/C++: A superclass reference variable can hold a reference to any subclass object, and the method that gets called depends on the actual object type at runtime.
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
void sound() {
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
Animal myAnimal = new Dog();// Superclass reference to a subclass object
myAnimal.sound(); // Output will be "Dog barks"
}
}Here, myAnimal is a reference variable of the Animal superclass, but it refers to an instance of the Dog subclass. When you call the sound() method on myAnimal, the Dog class’s version of sound() is executed, demonstrating polymorphism.
Python
Since variables are dynamically typed, any variable can hold any object. The concept of a superclass reference holding a subclass object is not explicitly enforced, but the effect is similar due to Python’s dynamic typing and polymorphism.
class Animal:
def sound(self):
print("Animal makes a sound")
class Dog(Animal):
def sound(self):
print("Dog barks")
class Cat(Animal):
def sound(self):
print("Cat meows")
my_animal = Dog() # my_animal now references a Dog object
my_animal.sound() # Output: Dog barks
my_animal = Cat() # my_animal now references a Cat object
my_animal.sound() # Output: Cat meows
In Python, my_animal can refer to any object, including an object of a subclass, and Python will determine at runtime which sound() method to call:
Alternative to OOP
Here are a few common programming paradigms:
- Procedural Programming: This is one of the earliest and simplest styles. In procedural programming, code is written in a sequence of instructions or procedures. The focus is on functions or subroutines that operate on data rather than on data itself. It’s often structured with modular design but without objects or classes. Popular languages for procedural programming include C and BASIC.
- Functional Programming (FP): Functional programming is based on mathematical functions. It emphasises immutability, where data is not modified after creation, and pure functions, where the output is determined solely by the input. FP avoids shared state and side effects, making it suitable for parallel processing. Common functional programming languages include Haskell, Lisp, and newer implementations in JavaScript and Python.
- Declarative Programming: In declarative programming, you describe what you want to achieve rather than how to achieve it. SQL, for example, is declarative; you specify what data you need but not how to retrieve it. Similarly, HTML is declarative because it defines how a webpage should look without detailing the rendering process.
- Logic Programming: This paradigm is based on formal logic. Instead of telling the computer what to do, you specify rules and relationships, and the computer deduces the solution. Prolog is a well-known logic programming language, commonly used in AI and computational linguistics.
- Event-Driven Programming: This is often used in GUIs, where program execution is driven by user actions or events (like clicks, keystrokes, etc.). It’s common in languages like JavaScript, where interactions trigger specific code routines.
- Aspect-Oriented Programming (AOP): AOP complements OOP by allowing the separation of cross-cutting concerns, such as logging, security, and error handling. It enables you to add behaviour to code without modifying the actual code, typically through the use of aspects, join points, and advice.
- Reactive Programming: Reactive programming is a paradigm focused on asynchronous data streams and the propagation of change. It’s highly suitable for applications that need to handle real-time data or user interaction, like live feeds or dynamic UI updates. This style is particularly prominent in modern JavaScript frameworks (such as RxJS in Angular) and reactive systems in languages like Java (Project Reactor) and Kotlin.
Conclusion
Object-Oriented Programming (OOP) is a powerful and flexible paradigm that allows developers to create modular, reusable, and scalable software. By organising code around objects—instances of classes—OOP makes it easier to model real-world problems and manage complex systems. The four fundamental principles of OOP—encapsulation, inheritance, polymorphism, and abstraction—provide a robust framework for designing and implementing software.
Polymorphism, in particular, plays a crucial role in OOP by allowing objects to be treated as instances of their parent class, enabling method overloading and overriding. These techniques enhance the flexibility and maintainability of code, allowing for the seamless extension and modification of software without disrupting existing functionality.
By mastering OOP concepts, developers can write more efficient, organised, and maintainable code, making it easier to collaborate on large projects and adapt to future requirements. Whether you are building small applications or large-scale systems, OOP principles serve as a foundational approach that can be applied across various programming languages and development environments.
1 thought on “Essential Concepts for Mastering OOP (Object-Oriented Programming)”