Core Object-Oriented Concepts Every Developer Must Know- Part 2

Object-Oriented Design (OOD) is more than a coding technique — it’s a mindset that mirrors the real-world using software. In our previous blog post, we explored what Object-Oriented Design (OOD) is and why it’s essential in building maintainable, scalable software systems.

Now, let’s go deeper into the core concepts of Object-Oriented Programming (OOP) — the foundation of OOD. These principles help represent complex systems in terms of real-world entities and make software more intuitive to build and extend.

In our previous blog post, we explored how Object-Oriented Design (OOD) is a method of building software systems by modeling them using objects— similar to how we think about things in the real world. Each object contains:

• Data (known as attributes or properties)
• Behaviors (known as methods or functions)

A helpful way to think about OOD is:
“If you can describe your system in terms of nouns (objects) and verbs (actions), you can model it using object-oriented design.”

📘 Example: The Student Object

Consider a Student object. It can be defined with:

(Data) Attributes:

• name
• age
• rollNumber

Behaviors (Methods):

• applyToCourse()
• printDetails()

This combination of data and behavior encapsulated within objects is the foundation of OOD. It leads to software that is more organized, modular, and scalable.

🔑 Four Core Pillars of OOP:

Object-Oriented Design is rooted in four fundamental principles:

These principles allow us to model real-world systems in software. Let’s dive deeper into these ideas and how C++ (or similar OOP languages) supports them.

1. 🔐 Encapsulation – Protecting the Inner Details:

Encapsulation is the practice of hiding internal details of an object and only exposing a controlled interface.

Real-Life Analogy:

Think of a medicine capsule.

A medicine capsule contains different ingredients. You don’t need to know what is inside — you just take it.

In software, objects hide internal details and expose only what other parts of the program need. This keeps code clean, organized, and easier to modify without breaking other components.

🎯 Purpose of Encapsulation:

• Keeps data and behavior together: Related data (attributes) and functions (methods) are bundled into a single unit—usually a class.
• Controls access to internal details: Only necessary parts are exposed; everything else is hidden.
• Improves maintainability: Internal changes won’t affect the rest of the system as long as the public interface remains the same.
• Protects against improper use: Prevents accidental or unauthorized access to internal state or logic.

class Student
{
private:
  std::string name;
  int age;

public:
  Student(std::string n, int a)
    : name(n)
    , age(a)
  {
  }

  void setName(std::string n) { name = n; }
  std::string getName() { return name; }
};

Here, the name and age are hidden (private), and only controlled access is allowed through getName() and setName() methods. That’s encapsulation in action.

🧱 Access Specifiers in C++

C++ has 3 primary access modifiers:

class Example
{
private:
  int secret; // Not accessible outside

protected:
  int semiSecret; // Accessible in derived class

public:
  int visible; // Accessible everywhere
};

Use:

• private: Default for sensitive data
• public: Only when absolutely safe
• protected: During inheritance

Note: Use private by default unless you have a reason to expose it.

2. Abstraction:

Abstraction is the process of exposing only the essential features of an object while hiding the unnecessary details. It allows users to interact with the system at a high level without getting involved in the complexity beneath the surface.

💡 The Million-Dollar Question: Why Use Abstraction?

Abstraction simplifies how we interact with complex systems. Instead of worrying about how something works under the hood, we use simple, meaningful methods like applyForCourse() or displayDetails() to get things done.

Users don’t need to know how data is stored, how validation happens, or how processes are triggered—they just call the method, and it works. They just call a method—and it does the job.

This separation of what something does from how it does it:

• Makes code easier to use.
• Reduces complexity.
• Enhances maintainability.
• Encourages cleaner, more focused design.

🎮 Real-World Analogy: The Remote Control (with C++ Example)

Think of a TV remote.

You press buttons to power on, change the volume, or switch channels.

But you don’t need to know:

• How infrared signals are generated?
• How the TV decodes those signals?
• How the circuits inside respond?

The system hides all that complexity. You just use the remote.

Consider the below code for better understanding.

#include <iostream>
#include <memory>
using namespace std;

// Abstract Base Class (Interface)
class RemoteControl
{
public:
  virtual void power() = 0;
  virtual void volumeUp() = 0;
  virtual void channelUp() = 0;

  virtual ~RemoteControl() = default; // Ensure proper cleanup in inheritance
};

// Concrete Implementation (encapsulates internal behavior)
class Television : public RemoteControl
{
public:
  void power() override { cout << "[TV] Powering ON..." << endl; }

  void volumeUp() override { cout << "[TV] Increasing Volume..." << endl; }

  void channelUp() override
  {
    cout << "[TV] Changing to Next Channel..." << endl;
  }
};

// User interacts only with the abstract interface
void
operateRemote(RemoteControl& remote)
{
  remote.power();
  remote.volumeUp();
  remote.channelUp();
}

int
main()
{
  // Using abstraction via interface
  unique_ptr<RemoteControl> myTV = make_unique<Television>();
  operateRemote(*myTV);

  return 0;
}

3. Inheritance (Code Reuse & Specialization):

Inheritance allows one class (called the child or derived class) to inherit common attributes and behaviors from another class (called the parent or base class). The child class represents a more specific version of the parent class.

It automatically gets all the non-private attributes and methods of the parent, and it can also define its own unique features or override existing ones.

💡 Why Use Inheritance?

Because duplication is wasteful and error prone.

When multiple types (like students and teachers) share common features—such as name, age, or a printDetails() function—it’s inefficient to define those separately for each type.

Instead, define those shared features once in a base class (e.g., Person), and then build specific roles (like Student or Teacher) on top of it.

This gives you:

• Code reuse: No need to repeat common logic.
• Consistency: Shared features behave the same everywhere.
• Flexibility: Each child class can extend or customize its behavior.

🧩 Real-World Analogy of Inheritance — Vehicles Example

Think of a Vehicle.

All vehicles—cars, bikes, trucks—have some common features:

• They have wheels.
• They can start and stop.
• They consume fuel or electricity.

So, you create a base class called Vehicle that defines those common properties and behaviors.

Now, you want to define specific types of vehicles:

• A Car has all the features of a Vehicle, plus AC, radio, and four doors.
• A Bike has the basic Vehicle features, but also adds handlebars, and has only two wheels.

Instead of writing everything from scratch for each type, you define the common features once in Vehicle and let Car and Bike inherit from it.

Consider the below code for better understanding.

#include <iostream>
using namespace std;

// Base class
class Vehicle
{
public:
  void start() { cout << "Vehicle started." << endl; }

  void stop() { cout << "Vehicle stopped." << endl; }
};

// Derived class
class Car : public Vehicle
{
public:
  void turnOnAC() { cout << "Car AC turned on." << endl; }
};

// Another derived class
class Bike : public Vehicle
{
public:
  void kickStart() { cout << "Bike kick-started." << endl; }
};

int
main()
{
  Car myCar;
  myCar.start();    // Inherited from Vehicle
  myCar.turnOnAC(); // Specific to Car
  myCar.stop();     // Inherited from Vehicle

  cout << "-------------------" << endl;

  Bike myBike;
  myBike.start();     // Inherited from Vehicle
  myBike.kickStart(); // Specific to Bike
  myBike.stop();      // Inherited from Vehicle

  return 0;
}

Summary of the Code:

• Vehicle is the parent class. It has two common actions: start() and stop().
• Car and Bike are child classes. They inherit from Vehicle, so they can also use start() and stop() without writing them again.
• Car adds a new action: turnOnAC().
• Bike adds a new action: kickStart().

4. Polymorphism:

Polymorphism means “many forms.”
In programming, it allows you to use the same function or method name to perform different tasks, depending on the object calling it.

In simpler words: One function name, but different behavior based on the object.

🎯 Why Use Polymorphism?

To make your code:

• More flexible – it works with different types of objects in a uniform way.
• Easier to extend – you can add new types without changing existing code.
• Cleaner – avoids long chains of if or switch statements.

I my view, “Polymorphism lets your code grow without getting messy.”

🧩 Real-World Analogy:

Think about a “makeSound()” function:

• If you call makeSound() on a Dog, it barks.
• If you call makeSound() on a Cat, it meows.

Same function name → different behavior depending on the animal.

That’s polymorphism.

🧠 Wrapping Up: Classes, Objects, and Memory:

As we come to the end of this post, it is important to tie everything back to the core concept of object-oriented programming:
Understanding the difference between classes and objects.

🎯 Class vs Object — Final Thoughts

• A class is just a blueprint. It defines what data an object should hold and what it can do.
• An object is a real, working unit created from that blueprint. It lives in memory and can interact with other objects in your program.

Think of a class as an architectural plan, and an object as the actual building constructed from it. You can use one plan to build many unique houses — the same applies to objects in code.

Note: Each object is independent and has its own memory.