What Are the Three Fundamental Concepts of Object-Oriented Programming?


Heather Bennett

What Are the Three Fundamental Concepts of Object-Oriented Programming?

Object-oriented programming (OOP) is a programming paradigm that emphasizes the use of objects and classes to organize and structure code. It is widely used in modern programming languages like Java, C++, and Python. To understand OOP, it is important to grasp its three fundamental concepts: encapsulation, inheritance, and polymorphism.


Encapsulation is the process of bundling data and methods that operate on that data into a single unit called an object. In other words, it combines data (attributes or properties) and behaviors (methods or functions) into a single entity.

A class is used to define the blueprint for creating objects. It encapsulates the properties and methods that define the behavior of those objects. The class serves as a template or a blueprint from which multiple instances or objects can be created.


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

    def start_engine(self):
        print("The car engine has started.")

my_car = Car("Toyota", "Camry")

In this example, the Car class encapsulates the brand and model properties along with the start_engine() method. The my_car object is an instance of this class.


Inheritance is a mechanism that allows one class to inherit properties and methods from another class. It promotes code reuse and helps in creating a hierarchy of classes.

Inheritance is implemented using the concept of a parent or base class and a child or derived class. The child class inherits all the attributes and behaviors of the parent class, allowing the child class to reuse and extend the functionality provided by the parent class.

class Animal:
    def __init__(self, name):
        self.name = name

    def eat(self):
        print(f"{self.name} is eating.")

class Dog(Animal):
    def bark(self):

my_dog = Dog("Buddy")

In this example, the Animal class serves as the parent class, which has an eat() method. The Dog class is a child class that inherits from the Animal class and adds its own method called bark(). The my_dog object can access both inherited methods.


Polymorphism, derived from Greek meaning “many forms,” refers to the ability of an object to take on many forms or have multiple behaviors. It allows objects of different classes to be treated as objects of a common superclass.

This concept enables code to be written that can work with objects of different types, providing flexibility and extensibility. Polymorphism is achieved through method overriding and method overloading.

class Shape:
    def area(self):

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):
        return 3.14 * self.radius**2

shapes = [Rectangle(4, 5), Circle(3)]

for shape in shapes:

In this example, the Shape class defines a common method called area(). The Rectangle and Circle classes inherit from the Shape class and provide their own implementation of the area() method. By treating both objects as instances of the Shape class, we can iterate through a list of shapes and call the area() method on each object.

To summarize, encapsulation helps in bundling data and methods into objects, inheritance promotes code reuse by allowing one class to inherit from another, and polymorphism enables objects of different types to be treated as objects of a common superclass. Understanding these three fundamental concepts is crucial when working with object-oriented programming.

Discord Server - Web Server - Private Server - DNS Server - Object-Oriented Programming - Scripting - Data Types - Data Structures

Privacy Policy