Object Oriented Design



Object Oriented Design (OOD) is a software design methodology that emphasizes the use of “objects,” which are instances of classes. Each object is responsible for maitaining its own state and provides methods to interact with that state. The key principles of OOD include encapsulation, inheritance, polymorphism, and abstraction. These principles work together to create a more modular, maintainable, and understandable codebase.

Object Oriented Design
Object Oriented Design

OOD provides several benefits, such as promoting encapsulation to maintain a clear separation of concerns, supporting inheritance to facilitate code reuse and avoid duplication, and emphasizing polymorphism to enhance the flexibility and expressiveness of the code. Despite these advantages, OOD may not always be the most suitable approach for simple or procedural applications.

Object Oriented Programming
Object Oriented Programming

feature of object oriented programming

1. Encapsulation;

The concept of encapsulation involves concealing the workings of an object, from the world. Instead only the objects methods should be accessible. This approach enables control over the data within an object. Encourages good programming practices.


Oops Concept
Oops Concept

class BankAccount:
def __init__(self, account_number, balance):
self.account_number = account_number
self.balance = balance

def deposit(self, amount):
self.balance += amount

def withdraw(self, amount):
if amount <= self.balance:
self.balance -= amount

print(“Insufficient funds”)

Inheritance; Inheritance allows a class to inherit the characteristics of another class. The class that inherits referred to as the subclass gains access to the methods and attributes of the inherited class, known as the superclass. This promotes code reuse and prevents duplication.

class SavingsAccount(BankAccount):
def __init__(self, account_number, balance, interest_rate):
super().__init__(account_number, balance)
self.interest_rate = interest_rate

def apply_interest(self):
self.balance += self.balance * (self.interest_rate / 100)

Polymorphism; Polymorphism enables objects from classes to be treated as objects of a shared superclass. This fosters. Expandability in code development.

def transfer(from_account, to_account, amount):

# Both savings and checking accounts can be used with the transfer function
savings_account = SavingsAccount(12345, 1000, 2)
checking_account = BankAccount(67890, 500)

transfer(savings_account, checking_account, 200)


Abstraction is centered around hiding the details of an objects implementation from sources. Only the interface of an object should be accessible. This principle facilitates more manageable codebases.

from abc import ABC, abstractmethod

class Account(ABC):
def deposit(self, amount):

def withdraw(self, amount):

class SavingsAccount(Account):
# …

class CheckingAccount(Account):
# …


To sum it up Object Oriented Design (OOD) is a software design methodology that emphasizes modularity, reusability and expandability in software development. By employing encapsulation, inheritance, polymorphism and abstraction principles, in OOD practices developers can create codebases that’re more resilient, maintainable and comprehensible.


frequently asked question

1. What advantages does Object Oriented Design (OOD) offer?

Encapsulation; OOD promotes the idea of encapsulation, which involves grouping data and methods that manipulate that data, within an entity. This helps maintain a separation of concerns within the code.

Inheritance; OOD supports inheritance, a mechanism that allows one class to inherit properties and methods from another class. This facilitates the creation of organized code by promoting code reuse and avoiding redundancy.

Polymorphism; OOD emphasizes polymorphism, a principle that enables methods and operators to work with types of data. This enhances the flexibility and expressiveness of the code.

Abstraction; OOD encourages abstraction, a technique that simplifies systems by breaking them down into manageable components. This makes the code more understandable and maintainable.

2. How does OOD enhance code modularity?

By emphasizing encapsulation and inheritance OOD enables developers to create code. Each class can be independently. Maintained, resulting in an organized and manageable codebase.

3. What are some limitations associated with using Object Oriented Design?

OOD can occasionally lead to execution times due to the overhead involved in method calls and the use of tables, for dynamic dispatching.
Furthermore though Object Oriented Design (OOD) promotes modularity and reusability it may not always be the strategy, for straightforward or procedural applications. Is it possible to combine Object Oriented Design with programming paradigms like Functional Programming (FP)?

Avatar Of Himani


RELATED Articles

Leave a Comment

This site uses Akismet to reduce spam. Learn how your comment data is processed.