Programming on Noman Chowdhury Munna | Blog

Demystifying Object-Oriented Programming (OOP)

Mon, 13 Jul 2026 00:00:00 +0000

Object-Oriented Programming (OOP) is a programming paradigm centered around the concept of objects, which contain data (in the form of fields or attributes) and code (in the form of procedures or methods). It is one of the most popular paradigms used in modern software engineering.

To truly master OOP, we must understand its Four Pillars: Encapsulation, Abstraction, Inheritance, and Polymorphism. Let’s demystify each of them with neat, real-world examples.

1. Encapsulation: Keeping Data Safe

Encapsulation is the bundling of data and the methods that operate on that data into a single unit (a class) while restricting direct access to some of the object’s components.

Think of encapsulation as a protective shield. Instead of letting anyone modify a variable directly, you provide controlled access through public getter and setter methods.

Why use it?

Data Validation: You can prevent invalid data from being assigned (e.g., setting a negative age).
Flexibility: You can change the internal implementation of a class without breaking external code.

Python Example

In Python, encapsulation is implemented using prefix naming conventions. While attributes are public by default, prefixing an attribute with a double underscore __ triggers name mangling, making it private and harder to access directly from outside the class.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


class BankAccount:
 def __init__(self, owner, initial_balance):
 self.owner = owner
 self.__balance = initial_balance # Private attribute (name-mangled)

 # Getter method
 def get_balance(self):
 return self.__balance

 # Setter method with safety validation
 def deposit(self, amount):
 if amount <= 0:
 raise ValueError("Deposit amount must be positive")
 self.__balance += amount

Java Example

In Java, encapsulation is strictly enforced using access modifiers. We mark fields as private and expose them only through public getter and setter methods.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


public class BankAccount {
 private String owner;
 private double balance; // Private field

 public BankAccount(String owner, double initialBalance) {
 this.owner = owner;
 this.balance = initialBalance;
 }

 // Getter method
 public double getBalance() {
 return this.balance;
 }

 // Setter method with validation
 public void deposit(double amount) {
 if (amount <= 0) {
 throw new IllegalArgumentException("Deposit amount must be positive");
 }
 this.balance += amount;
 }
}

2. Abstraction: Hiding Complexity

Abstraction is the concept of hiding complex implementation details and showing only the essential features of an object. It reduces complexity and increases usability.

Consider a car: you only need to know how to use the steering wheel, accelerator, and brakes to drive it. You do not need to understand how the internal combustion engine or fuel injection system works.

Why use it?

Simplifies Interface: Users interact with a clean, simple API.
Isolates Changes: The underlying complex mechanism can be updated without the user needing to change how they interact with it.

Python Example

In Python, abstraction is achieved using the abc (Abstract Base Classes) module to define abstract classes and methods.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


from abc import ABC, abstractmethod

class PaymentGateway(ABC):
 @abstractmethod
 def process_payment(self, amount: float) -> bool:
 pass

class StripePayment(PaymentGateway):
 def process_payment(self, amount: float) -> bool:
 # Complex API call to Stripe servers, token verification, etc.
 print(f"Processing Stripe payment of ${amount}")
 return True

Java Example

In Java, abstraction is achieved using interfaces or abstract classes.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


public interface PaymentGateway {
 boolean processPayment(double amount);
}

public class StripePayment implements PaymentGateway {
 @Override
 public boolean processPayment(double amount) {
 // Complex API call to Stripe servers, token verification, etc.
 System.out.println("Processing Stripe payment of $" + amount);
 return true;
 }
}

3. Inheritance: Reusing Code

Inheritance is a mechanism where a new class (subclass/child) inherits properties and behaviors (methods) from an existing class (superclass/parent).

It promotes the DRY (Don’t Repeat Yourself) principle by allowing developers to write common code once and reuse it across multiple specific entities.

Why use it?

Code Reusability: Avoid duplicating fields and methods.
Logical Hierarchy: Models relationships cleanly (e.g., a Dog is an Animal).

Python Example

Python supports both single and multiple inheritance using a comma-separated list in the class definition.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


class Vehicle:
 def __init__(self, brand, model):
 self.brand = brand
 self.model = model

 def start_engine(self):
 print(f"The engine of {self.brand} {self.model} is starting...")

class ElectricCar(Vehicle):
 def __init__(self, brand, model, battery_capacity):
 super().__init__(brand, model)
 self.battery_capacity = battery_capacity

 def charge(self):
 print("Charging battery...")

Java Example

Java supports single class inheritance using the extends keyword. Multiple inheritance is achieved using interfaces.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


public class Vehicle {
 protected String brand;
 protected String model;

 public Vehicle(String brand, String model) {
 this.brand = brand;
 this.model = model;
 }

 public void startEngine() {
 System.out.println("The engine of " + brand + " " + model + " is starting...");
 }
}

public class ElectricCar extends Vehicle {
 private double batteryCapacity;

 public ElectricCar(String brand, String model, double batteryCapacity) {
 super(brand, model);
 this.batteryCapacity = batteryCapacity;
 }

 public void charge() {
 System.out.println("Charging battery...");
 }
}

4. Polymorphism: Many Forms

Polymorphism means “many forms.” In OOP, it allows objects of different classes to be treated as objects of a common superclass, and behave differently based on their actual type.

For example, a draw() method would behave differently depending on whether it is called on a Circle, a Square, or a Triangle.

Why use it?

Extensibility: You can add new classes that conform to the interface without changing the calling code.
Clean Code: Replaces verbose conditional blocks (if-else / switch) with clean, dynamic method dispatch.

Python Example

Python’s dynamic nature implements polymorphism natively. We can pass any object that implements a specific method (often called duck typing).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


class Animal:
 def make_sound(self):
 pass

class Dog(Animal):
 def make_sound(self):
 return "Woof!"

class Cat(Animal):
 def make_sound(self):
 return "Meow!"

# Polymorphism in action
def play_sound(animal: Animal):
 print(animal.make_sound())

play_sound(Dog()) # Outputs: Woof!
play_sound(Cat()) # Outputs: Meow!

Java Example

In Java, polymorphism is checked at compile-time and resolved dynamically at runtime through method overriding.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


public abstract class Animal {
 public abstract String makeSound();
}

public class Dog extends Animal {
 @Override
 public String makeSound() {
 return "Woof!";
 }
}

public class Cat extends Animal {
 @Override
 public String makeSound() {
 return "Meow!";
 }
}

// Polymorphism in action
public class Test {
 public static void playSound(Animal animal) {
 System.out.println(animal.makeSound());
 }

 public static void main(String[] args) {
 playSound(new Dog()); // Outputs: Woof!
 playSound(new Cat()); // Outputs: Meow!
 }
}

Limitations of OOP

While Object-Oriented Programming is incredibly powerful, it has certain limitations depending on the programming language:

Limitations in Java

Verbosity and Boilerplate: Java is known for requiring substantial boilerplate code (getters, setters, constructors, class structures) for simple operations.
Single Inheritance Restrictions: Java does not allow multiple class inheritance to prevent the “Diamond Problem.” You must use interfaces or composition, which can occasionally complicate design.
No Top-Level Functions: Everything in Java must reside inside a class. Static utility scripts (like math helpers) must be wrapped in classes, which goes against purely procedural or functional styles.
Memory/Execution Overhead: Everything being an object leads to high memory utilization (metadata headers for objects) and increased load on the Garbage Collector (GC).

Limitations in Python

Lack of Strict Encapsulation: Python doesn’t support true private access modifiers. The double-underscore notation only delays direct modifications; name mangling is easily bypassed. This relies on the “we are all consenting adults here” convention.
Performance Penalties: Dynamic dispatch and dynamic type-checking add runtime overhead. Attribute resolution checks the object’s dictionary at runtime, which is slower than Java’s vtable lookup.
Complex Multiple Inheritance: Managing Method Resolution Order (MRO) and super() sequences can lead to subtle diamond-inheritance errors if not carefully designed.
Runtime Mutability Risks: Python classes and objects can be dynamically updated at runtime (monkey-patching). This makes debugging difficult and introduces instability if third-party modules modify base classes unpredictably.

Conclusion

Understanding the four pillars of OOP is essential for designing scalable, maintainable, and robust systems:

Encapsulation protects data integrity.
Abstraction simplifies developer interactions.
Inheritance removes redundancy.
Polymorphism introduces flexibility and custom execution flow.

By knowing both the advantages and limitations of OOP in languages like Java and Python, you can make informed decisions about when to use object-oriented patterns or shift to other paradigms like functional programming. Happy coding!

The Core Differences Between the Four Pillars of OOP

Mon, 13 Jul 2026 00:00:00 +0000

Mastering Object-Oriented Programming (OOP) requires more than just understanding its four pillars individually. To write clean and scalable systems, a developer must know how they differ, how they overlap, and how they work together.

In this article, we’ll break down the key differences between the pillars and compare them using simple code snippets in both Java and Python.

The Four Pillars at a Glance

Before comparing them, let’s look at the primary focus of each pillar:

Pillar	Core Question It Answers	Primary Objective
Encapsulation	How do I protect my data from unauthorized changes?	Data Hiding & Safety
Abstraction	What does this object do (without worrying about how it does it)?	Complexity Reduction
Inheritance	How can I reuse code from another class?	Code Reusability
Polymorphism	How can I implement a common interface in different ways?	Adaptability & Extensibility

1. Encapsulation vs. Abstraction: “How” vs. “What”

Developers often confuse Encapsulation and Abstraction because both involve hiding details. However, they operate at different levels of design:

Encapsulation (Data Hiding): Hides an object’s internal state (variables) and restricts direct access. It focuses on how data is managed and validated within a class.
Abstraction (Complexity Hiding): Hides the implementation details of a feature and exposes only a clean interface. It focuses on what the object does, hiding the underlying complexity from the caller.

Code Comparison

Python Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


# --- ABSTRACTION: Exposing a clean interface, hiding process complexity ---
from abc import ABC, abstractmethod

class Mailer(ABC):
 @abstractmethod
 def send_email(self, recipient: str, message: str):
 pass

class SendGridMailer(Mailer):
 def send_email(self, recipient: str, message: str):
 # Complex API negotiation, header formatting, and HTTP calls happen here
 print(f"Email sent via SendGrid to {recipient}")


# --- ENCAPSULATION: Hiding data variables and restricting direct access ---
class UserAccount:
 def __init__(self, username, email):
 self.username = username
 self.__email = email # Encapsulated (private) field

 def get_email(self):
 return self.__email

 def set_email(self, new_email):
 if "@" in new_email: # Validation check
 self.__email = new_email
 else:
 raise ValueError("Invalid email format")

Java Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


// --- ABSTRACTION: Exposing a clean interface, hiding process complexity ---
interface Mailer {
 void sendEmail(String recipient, String message);
}

class SendGridMailer implements Mailer {
 @Override
 public void sendEmail(String recipient, String message) {
 // Complex API negotiation, header formatting, and HTTP calls happen here
 System.out.println("Email sent via SendGrid to " + recipient);
 }
}


// --- ENCAPSULATION: Hiding data variables and restricting direct access ---
class UserAccount {
 private String username;
 private String email; // Encapsulated (private) field

 public UserAccount(String username, String email) {
 this.username = username;
 this.email = email;
 }

 public String getEmail() {
 return this.email;
 }

 public void setEmail(String newEmail) {
 if (newEmail.contains("@")) { // Validation check
 this.email = newEmail;
 } else {
 throw new IllegalArgumentException("Invalid email format");
 }
 }
}

2. Inheritance vs. Polymorphism: “Structure” vs. “Behavior”

Inheritance and Polymorphism are closely linked, but they serve different engineering goals:

Inheritance (Structural Relationship): Establishes an “is-a” relationship between a base class (parent) and a derived class (child). It is design-time structure created to share code and attributes.
Polymorphism (Behavioral Flexibility): Translates to “many forms.” It allows subclasses to override inherited behaviors, letting the program choose the correct method implementation dynamically at runtime.

Code Comparison

Python Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


# --- INHERITANCE: Reusing brand & model fields ---
class Printer:
 def __init__(self, brand):
 self.brand = brand

 def print_document(self):
 print(f"Printing document from generic {self.brand} printer.")

class LaserPrinter(Printer): # Inherits brand field & printer structure
 pass


# --- POLYMORPHISM: Overriding method to exhibit customized behavior ---
class InkjetPrinter(Printer):
 def print_document(self): # Overrides parent method
 print(f"Spraying ink to print document from {self.brand} printer.")

# Polymorphism in action: Same interface, different outcomes
def process_print_job(printer: Printer):
 printer.print_document()

process_print_job(LaserPrinter("HP")) # Outputs: Printing document from generic HP printer.
process_print_job(InkjetPrinter("Canon")) # Outputs: Spraying ink to print document from Canon printer.

Java Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


// --- INHERITANCE: Reusing brand field ---
class Printer {
 protected String brand;

 public Printer(String brand) {
 this.brand = brand;
 }

 public void printDocument() {
 System.out.println("Printing document from generic " + brand + " printer.");
 }
}

class LaserPrinter extends Printer { // Inherits brand field & printer structure
 public LaserPrinter(String brand) {
 super(brand);
 }
}


// --- POLYMORPHISM: Overriding method to exhibit customized behavior ---
class InkjetPrinter extends Printer {
 public InkjetPrinter(String brand) {
 super(brand);
 }

 @Override
 public void printDocument() { // Overrides parent method
 System.out.println("Spraying ink to print document from " + brand + " printer.");
 }
}

// Polymorphism in action: Same interface, different outcomes
public class Test {
 public static void processPrintJob(Printer printer) {
 printer.printDocument();
 }

 public static void main(String[] args) {
 processPrintJob(new LaserPrinter("HP")); // Outputs generic print behavior
 processPrintJob(new InkjetPrinter("Canon")); // Outputs overridden print behavior
 }
}

How They Work Together in Practice

The four pillars rarely work in isolation. In high-quality enterprise applications:

Abstraction defines the high-level system components and layout boundaries (e.g., an interface for database connections).
Inheritance lets you share general connection attributes across specific drivers (e.g., MySQL vs. PostgreSQL).
Polymorphism allows the application to switch drivers dynamically at runtime without modifying the caller code.
Encapsulation protects credentials and internal connection states (like socket descriptors and passwords) from external tampering.

Conclusion

Understanding the unique characteristics of each OOP pillar prevents architectural anti-patterns:

Use Encapsulation to protect and validate your object states.
Use Abstraction to clean up complicated APIs and expose only what is necessary.
Use Inheritance to reuse code, but be careful not to create tightly coupled nested structures (favor composition where appropriate).
Use Polymorphism to write flexible algorithms that adapt to new object types dynamically at runtime.

Understanding OOP Access Modifiers: Public, Private, Protected, and Default

Tue, 14 Jul 2026 00:00:00 +0000

When you start learning Object-Oriented Programming (OOP), you’ll quickly run into terms like public, private, protected, and sometimes default. These are called Access Modifiers (or Access Specifiers).

But what are they, and why do they matter?

Think of access modifiers as the security guards of your code. They control who can see and use the variables (attributes) and functions (methods) inside your classes. Without them, any part of your program could change anything else, leading to hard-to-find bugs and chaotic code.

Let’s break them down using a simple real-world analogy: Your House.

The House Analogy

Imagine you own a beautiful house. The different parts of your house have different levels of access:

Access Modifier	Analogy	Who Can Access?
`public`	The front yard & mailbox	Anyone walking down the street.
`default` (Package-Private)	The shared apartment corridor	Only neighbors who live in the same building/folder.
`protected`	The family living room	Only you and your children (and descendants).
`private`	Your personal locked diary	Only you (nobody else, not even your children).

Let’s dive deeper into each of these.

1. Public: Open to the World

The public modifier is the least restrictive. When a variable or method is marked as public, it means it can be accessed from anywhere in your program.

Analogy: Your front yard. Anyone can walk up, look at it, or drop a letter in your mailbox.
When to use: For methods or attributes that you want other parts of your program to interact with (like a button’s click() action or a library’s utility function).

Java Example

In Java, we use the public keyword:

1
2
3


public class House {
 public String mailbox = "Hello!"; // Accessible from anywhere
}

Python Example

In Python, all attributes and methods are public by default! You don’t need any special keywords:

1
2
3


class House:
 def __init__(self):
 self.mailbox = "Hello!" # Public attribute

2. Private: For Your Eyes Only

The private modifier is the most restrictive. A private variable or method can only be accessed from inside the class it was created in. External classes, and even subclasses (child classes), cannot access it.

Analogy: Your personal locked diary. Only you can read or write in it. If your children want to read it, they can’t.
When to use: To protect sensitive data (like passwords, balances, or internal system configurations) from being changed incorrectly.

Java Example

In Java, we use the private keyword:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


public class House {
 private String diary = "Dear Diary, today I learned OOP..."; // Only visible inside House class
 
 // We can expose a public method to let others view it safely (Getter)
 public String getDiaryEntry(String password) {
 if ("supersecret".equals(password)) {
 return this.diary;
 }
 return "Access Denied!";
 }
}

Python Example

Python doesn’t have strict private enforcement, but it uses a naming convention: prefixing a name with a double underscore (__). This triggers name mangling, making it harder to access from outside:

1
2
3
4
5
6
7
8


class House:
 def __init__(self):
 self.__diary = "Dear Diary, today I learned OOP..." # Private attribute
 
 def get_diary_entry(self, password):
 if password == "supersecret":
 return self.__diary
 return "Access Denied!"

3. Protected: Family-Only Access

The protected modifier is a middle ground. It allows access by the class itself, subclasses (child classes that inherit from it), and classes in the same package/folder.

Analogy: The family living room. Friends from other neighborhoods can’t walk in, but your children (subclasses) have full access to it, even if they move out to their own houses.
When to use: When you are building a class hierarchy and want child classes to inherit and use/modify internal attributes, but want to hide them from the general public.

Java Example

In Java, we use the protected keyword:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


public class ParentHouse {
 protected String familyHeirloom = "Golden Pocket Watch"; // Accessible by subclasses
}

public class ChildHouse extends ParentHouse {
 public void showHeirloom() {
 // Child class can access the parent's protected attribute!
 System.out.println("Inherited heirloom: " + this.familyHeirloom);
 }
}

Python Example

In Python, we denote a protected attribute by prefixing it with a single underscore (_). This is a convention—it tells other programmers “please don’t touch this from outside,” though Python won’t strictly block them:

1
2
3
4
5
6
7
8


class ParentHouse:
 def __init__(self):
 self._family_heirloom = "Golden Pocket Watch" # Protected attribute (by convention)

class ChildHouse(ParentHouse):
 def show_heirloom(self):
 # Child can access it safely
 print(f"Inherited heirloom: {self._family_heirloom}")

4. Default: The Neighborhood Scope

In some languages like Java, if you do not specify any access modifier, it defaults to a specific access level. In Java, this is known as package-private (often called default).

Analogy: The shared corridor in an apartment building. Anyone living in the same building (same package/folder) can walk through it, but outsiders from other buildings cannot.
When to use: When you want classes within the same functional module (package) to work closely together without exposing those helper methods to the rest of the application.

Java Example

In Java, you specify default access by simply omitting the access modifier keyword:

1
2
3


class House {
 String apartmentCorridor = "Shared hallway"; // Default (package-private) access
}

Python Example

Python does not have packages in the same compile-time scope sense for variable scoping. Since there is no default modifier in Python, standard public attributes are typically used, or modules are kept clean by prefixing internal helper classes/functions with a single underscore to keep them module-private.

Access Modifiers Cheat Sheet

Here is a handy comparison chart summarizing who can access what in Java (since Java supports all four modifiers explicitly):

Modifier	Inside Class	Same Package	Subclass (Diff Package)	World (Diff Package)
`public`	Yes	Yes	Yes	Yes
`protected`	Yes	Yes	Yes	No
`default` (No keyword)	Yes	Yes	No	No
`private`	Yes	No	No	No

Summary: How to Choose?

When deciding which access modifier to use, always start with the Principle of Least Privilege:

Make everything private by default.
If subclasses need access, change it to protected.
If classes in the same module/package need access, use default.
Only make it public if it’s absolutely necessary for the outside world to interact with it.

By keeping access as restricted as possible, you protect your objects from being put into invalid states, making your code easier to debug, maintain, and extend!