Object-Oriented Programming (OOP): The Core Mindset in Modern Software Development

Object-Oriented Programming (OOP): The Core Mindset in Modern Software Development

Object-Oriented Programming (OOP) is a programming approach that has become familiar to many developers. However, OOP is not always as “glamorous” as it often appears in textbooks or lectures. In reality, when applied to real projects, OOP can be quite challenging and is not entirely straightforward.

Nevertheless, understanding and correctly applying the basic concepts of OOP remains a crucial foundation that helps you write clear, manageable, and more maintainable code in the long run. In this article, we will explore the most essential aspects of object-oriented programming together.

1. What is Object-Oriented Programming (OOP)? The History and Evolution of OOP

Object-Oriented Programming (OOP) is a programming approach based on the concept of “objects” – entities that represent real-world items or abstract concepts. Each object can contain data (called attributes) and behaviors (called methods). The main goal of OOP is to help developers model complex problems into smaller, independent components that can interact with each other through objects, making the code more understandable, manageable, and reusable.

The development of OOP began in the 1960s with the Simula language, considered the first object-oriented programming language. This idea was later refined and popularized through languages such as Smalltalk in the 1970s and especially C++ in the 1980s. Since then, OOP has become one of the main approaches in software development, particularly with the rise of languages like Java, C#, and Python, which provide strong support for this model.

Compared to Procedural Programming, OOP has several fundamental differences. Procedural Programming focuses on writing functions and sequential data processing steps, whereas OOP focuses on building objects that contain both data and related behaviors. This approach allows OOP to represent complex real-world relationships more intuitively and increases code reusability. At the same time, OOP also provides better support for maintaining and scaling software as projects grow in size and complexity.

2. The Main Components of Object-Oriented Programming (OOP)

2.1 Class

What is a Class?
A class is a blueprint, template, or design used to create objects. It defines the common structure and behavior for a group of similar objects. A class consists of attributes (data) and methods (behaviors) that the objects of that class will possess.

The Role of a Class in OOP
A class helps developers encapsulate data and related functions into a single logical unit. This makes managing, maintaining, and extending the program easier. Additionally, a class allows the creation of multiple distinct objects that share the same structure and behavior, saving time and effort.

Example:
Imagine you want to program a car management system. The “Car” class would serve as a common blueprint defining attributes such as color, manufacturer, and year of production, along with methods like start, stop, and accelerate.

class Car:
    def __init__(self, brand, color, year):
        self.brand = brand
        self.color = color
        self.year = year
    
    def start_engine(self):
        print(f"{self.brand} engine started.")
    
    def stop_engine(self):
        print(f"{self.brand} engine stopped.")

class Car:
    def __init__(self, brand, color, year):
        self.brand = brand
        self.color = color
        self.year = year
    
    def start_engine(self):
        print(f"{self.brand} engine started.")
    
    def stop_engine(self):
        print(f"{self.brand} engine stopped.")

2.2 Object

Definition of an Object
An object is a concrete entity created from a class. Each object has the attributes and methods defined in the class but holds its own unique data values. In other words, an object is a specific instance of a class with its own state and behavior.

The Relationship Between Classes and Objects
A class acts as a blueprint, while an object is the “product” created based on that blueprint. Multiple objects can be created from the same class, each with different data but sharing the same methods.

Example:
Based on the “Car” class above, we can create different objects representing individual cars:

class Car:
    def __init__(self, brand, color, year):
        self.brand = brand
        self.color = color
        self.year = year

    def start_engine(self):
        print(f"{self.brand} engine started.")


# Tạo các đối tượng Car
car1 = Car("Toyota", "Red", 2020)
car2 = Car("Honda", "Blue", 2018)

# Gọi phương thức start_engine
car1.start_engine()  # Output: Toyota engine started.
car2.start_engine()  # Output: Honda engine started.

class Car:
    def __init__(self, brand, color, year):
        self.brand = brand
        self.color = color
        self.year = year

    def start_engine(self):
        print(f"{self.brand} engine started.")


# Tạo các đối tượng Car
car1 = Car("Toyota", "Red", 2020)
car2 = Car("Honda", "Blue", 2018)

# Gọi phương thức start_engine
car1.start_engine()  # Output: Toyota engine started.
car2.start_engine()  # Output: Honda engine started.

Each car (car1, car2) is a separate object with the same attributes and behaviors but with different specific values.

2.3 Attributes and Methods

• Attributes
  Attributes are variables within a class used to store the state or data of an object. Each object can have different attribute values, reflecting its current state.
  
• Methods
  Methods are functions within a class that describe the behaviors or actions an object can perform. Methods often manipulate attributes or carry out specific tasks related to the object.
  

Example:
Continuing with the “Car” class, attributes such as brand, color, and year represent the data specific to each car, while methods like start_engine() and stop_engine() define the car’s behaviors.

class Car:
    def __init__(self, brand, color, year):
        self.brand = brand        # Thuộc tính
        self.color = color        # Thuộc tính
        self.year = year          # Thuộc tính
    
    def start_engine(self):       # Phương thức
        print(f"{self.brand} engine started.")
    
    def stop_engine(self):        # Phương thức
        print(f"{self.brand} engine stopped.")

class Car:
    def __init__(self, brand, color, year):
        self.brand = brand        # Thuộc tính
        self.color = color        # Thuộc tính
        self.year = year          # Thuộc tính
    
    def start_engine(self):       # Phương thức
        print(f"{self.brand} engine started.")
    
    def stop_engine(self):        # Phương thức
        print(f"{self.brand} engine stopped.")

In Summary:

• Class is a general blueprint that defines attributes and methods.
  
• Object is a concrete entity created from a class, carrying its own unique data.
  
• Attributes store the data and state of an object.
  
• Methods represent the behaviors and functions of an object.
  

Understanding these components is the first step toward mastering object-oriented programming and building complex software systems with a clear structure and easy scalability.

3. Core Characteristics of Object-Oriented Programming (4 Pillars of OOP)

3.1 Encapsulation

Meaning and Benefits:
Encapsulation is the principle of protecting the data within an object, restricting direct access from outside and allowing interaction only through defined methods. This helps hide internal details (data hiding), prevents invalid data access or modification, thereby increasing safety and minimizing errors in the program.

Illustrative Example:
Suppose you have a BankAccount class managing bank accounts. You don’t want anyone to directly modify the account balance, as it could lead to errors or fraud. Instead, you only allow users to deposit or withdraw money through controlled methods.

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.__balance = balance  # thuộc tính private, không thể truy cập trực tiếp

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print(f"Deposited {amount}. New balance: {self.__balance}")
        else:
            print("Invalid deposit amount")

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            print(f"Withdrawn {amount}. New balance: {self.__balance}")
        else:
            print("Invalid withdraw amount or insufficient funds")

    def get_balance(self):
        return self.__balance

# Sử dụng
account = BankAccount("Alice", 1000)
account.deposit(500)
account.withdraw(200)
print(account.get_balance())
# Không thể truy cập trực tiếp thuộc tính __balance từ bên ngoài
# print(account.__balance)  # sẽ gây lỗi

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.__balance = balance  # thuộc tính private, không thể truy cập trực tiếp

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print(f"Deposited {amount}. New balance: {self.__balance}")
        else:
            print("Invalid deposit amount")

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            print(f"Withdrawn {amount}. New balance: {self.__balance}")
        else:
            print("Invalid withdraw amount or insufficient funds")

    def get_balance(self):
        return self.__balance

# Sử dụng
account = BankAccount("Alice", 1000)
account.deposit(500)
account.withdraw(200)
print(account.get_balance())
# Không thể truy cập trực tiếp thuộc tính __balance từ bên ngoài
# print(account.__balance)  # sẽ gây lỗi

3.2 Inheritance

Concept and Usage:
Inheritance allows a subclass to inherit attributes and methods from a parent class, while also being able to extend or override these components. This facilitates code reuse and helps build class structures with clear relationships, minimizing redundancy.

Practical Example:
In a vehicle management system, there is a parent class Vehicle that defines common attributes and methods. Subclasses like Car and Motorcycle inherit from Vehicle and add or customize their own specific features.

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

    def accelerate(self, increment):
        self.speed += increment
        print(f"Speed increased to {self.speed} km/h")

class Car(Vehicle):
    def __init__(self, brand, speed=0, doors=4):
        super().__init__(brand, speed)
        self.doors = doors

    def open_trunk(self):
        print("Trunk is opened")

car = Car("Toyota")
car.accelerate(50)
car.open_trunk()

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

    def accelerate(self, increment):
        self.speed += increment
        print(f"Speed increased to {self.speed} km/h")

class Car(Vehicle):
    def __init__(self, brand, speed=0, doors=4):
        super().__init__(brand, speed)
        self.doors = doors

    def open_trunk(self):
        print("Trunk is opened")

car = Car("Toyota")
car.accelerate(50)
car.open_trunk()

3.3 Polymorphism

Definition and How It Works:
Polymorphism allows objects from different classes to be handled through a common interface, while their actual behavior varies depending on the object’s class. This forms the basis for flexibility in software design.

Two Common Types of Polymorphism:

Overriding: A subclass redefines a method of the parent class to provide its own behavior.

Overloading: Methods share the same name but have different parameters (not directly supported in Python, but can be simulated).

Illustrative Example of Overriding:

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    // Ghi đè phương thức sound() của lớp cha
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        myAnimal.sound();  // Output: Animal makes a sound

        Dog myDog = new Dog();
        myDog.sound();     // Output: Dog barks
    }
}

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    // Ghi đè phương thức sound() của lớp cha
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        myAnimal.sound();  // Output: Animal makes a sound

        Dog myDog = new Dog();
        myDog.sound();     // Output: Dog barks
    }
}

Example illustrating Overloading:

class Calculator {
    int add(int a, int b) {
        return a + b;
    }

    // Phương thức add cùng tên nhưng khác số tham số
    int add(int a, int b, int c) {
        return a + b + c;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();

        System.out.println(calc.add(5, 10));        // Output: 15
        System.out.println(calc.add(5, 10, 15));    // Output: 30
    }
}

class Calculator {
    int add(int a, int b) {
        return a + b;
    }

    // Phương thức add cùng tên nhưng khác số tham số
    int add(int a, int b, int c) {
        return a + b + c;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();

        System.out.println(calc.add(5, 10));        // Output: 15
        System.out.println(calc.add(5, 10, 15));    // Output: 30
    }
}

3.4 Abstraction

Purpose of Abstraction:
Abstraction involves hiding complex details and only presenting the essential characteristics of an object. This allows developers to focus on “what” needs to be done without worrying about “how” it is implemented.

At the programming level, abstraction is often implemented through abstract classes or interfaces, requiring subclasses to implement specific methods.

Example of an Abstract Class in Python:

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

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

    def area(self):
        return self.width * self.height

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

    def area(self):
        import math
        return math.pi * self.radius ** 2

shapes = [Rectangle(3, 4), Circle(5)]
for shape in shapes:
    print(f"Area: {shape.area()}")

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

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

    def area(self):
        return self.width * self.height

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

    def area(self):
        import math
        return math.pi * self.radius ** 2

shapes = [Rectangle(3, 4), Circle(5)]
for shape in shapes:
    print(f"Area: {shape.area()}")

In the example above, the Shape class is an abstract class with the area method not yet defined. Subclasses like Rectangle and Circle are required to implement this method in their own way.

4. Benefits of Object-Oriented Programming (OOP)

5. OOP Compared to Other Paradigms

6. Common Mistakes in Using OOP and How to Fix Them

7. Tools and Programming Languages Supporting OOP

8. Conclusion

Object-oriented programming is not just a programming technique, but also a design mindset that helps us build software in a systematic, flexible, and sustainable way. With code reusability, easy maintenance and expansion, along with the ability to model reality closely, OOP becomes a solid foundation for all software projects, from small to large.

However, to fully harness the power of OOP, it is essential to correctly understand its principles and apply them intelligently and selectively. Hopefully, through this article, you have gained an overview and foundational knowledge to feel more confident on your journey of developing object-oriented software.

Keep exploring, learning, and creating with OOP – because it is the key to unlocking modern and effective technology solutions!

9 References:

• Object-Oriented Software Engineering – Bernd Bruegge
• Clean Code – Robert C. Martin
• Python OOP Guide – RealPython
• Design Patterns: Elements of Reusable Object-Oriented Software – Gang of Four (GoF)
• Head First Object-Oriented Analysis and Design – Brett McLaughlin, Gary Pollice, David West
• Effective Java – Joshua Bloch
• Refactoring: Improving the Design of Existing Code – Martin Fowler
• Object-Oriented Design Heuristics – Arthur J. Riel
• JavaScript: The Good Parts – Douglas Crockford
• Python 3 Object-Oriented Programming – Dusty Phillips

📚 Bài viết liên quan

What is SOLID? Principles, how it works, and practical applications

KISS, DRY, YAGNI – 3 Golden Principles in Software Development