Object-oriented programming (OOP) is a programming model that organizes software around objects(data) and object manipulation. OOP’s use of objects helps to break complex problems into smaller manageable parts, thus making code more straightforward to comprehend and manage, providing developers with a sense of ease.  Over the next few minutes, we will go over the following core concepts as they relate to OOP: Class


Object


Encapsulation


Inheritance


Polymorphism


Association 📓 All upcoming examples will use python code Class a class is a template used to create objects. Classes define the attributes of objects and the methods that the class instances will share. class Parent:
    def __init__(self, name, hair_color):
        self.name = name
        self.hair_color= hair_color

    def description(self):
        print(f"I'm {self.name}, my hair is {self.hair_color}!") The above snippet creates a class named Parent, which contains attributes, name and hair_color and a method, description(). Every instance of the class will have the same attributes and methods. Object Regarding OOP, an object is an instance of a class. It has attributes and can perform actions defined by its class. The following example creates instances of the Parent class; once they have been created, we can access its publicly available attributes. For example, father.hair_color returns a value of Red. father= Parent("Dylan", "Red")
mother= Parent("Grace", "Brown")

father.hair_color # Red
mother.hair_color # Brown Encapsulation Encapsulation bundles attributes and methods within a class and can restrict access to some of the object’s components. For example, the code below defines a Parent class. The class has three attributes: name, hair_color, and __age. The name and hair_color attributes are publicly accessible; however, calling the __age attribute will result in an AttributeError. The double underscore causes an attribute to become private. To get the value of the __age attribute, the get_age() method must be called, as it will return the age attribute given to the Parent. class Parent:
    def __init__(self, name, hair_color, age):
        self.name = name
        self.hair_color= hair_color
        self.__age= age

    def description(self):
        print(f"I'm {self.name}, my hair is {self.hair_color}!") 

    def get_age(self):
        return self.__age

father= Parent("Dylan", "Red", 45)

father.name # Dylan
father.__age# will result in an AttributeError
father.get_age() # 45
father.description() # I'm Dylan, my hair color is Red! Inheritance 👀 ignore super().description() in the following example. We’ll go over this once we get to Polymorphism Inheritance occurs when a class inherits the attributes and methods of another class. In the following example, the Child class inherits the same attributes as the Parent class while creating its own unrelated attributes. class Child(Parent):
    def __init__( self, name, hair_color, age, major):
        super().__init__(name, hair_color, age)
        self.major = major

    def description(self):
        super().description()
        print(f"Name: {self.name}")
        print(f"Hair Color: {self.get_hair_color()")
        print(f"Age: {self.get_age()}")
        print(f"Major: {self.major}")

child = Child("Dwight", "Auburn", 20, "Computer Science")
child.description()
#Output
# I'm Dwight, my hair color is Auburn!
# Name: Dwight
# Hair Color: Auburn
# Age: 20
# Major: "Computer Science Polymorphism Polymorphism  allows you to override or modify class methods in subclasses. As seen in the previous snippet on Inheritance, the Child class adapts and modifies the Parent method description(). By including the super().description() within the description() method, you can adapt the inclusion of the Parent output into the Child’s description() method output. In the next snippet, the Child class inherits the attributes of the Parent class but overrides the description() method, resulting in a different output. class Child(Parent):
    def __init__(self, name, hair_color, age, major):
        super().__init__(name, hair_color, age)
        self.major = major

    def description(self):
        print(f"Hello my name is {self.name}, I'm {self.get_age()} and I major in {self.major}!")

parent = Parent("Charles", "Grey", 45)
child = Child("Dwight", "Auburn", 20, "Computer Science")
parent.description()
#Output
# I'm Charles, my hair color is Grey!

child.description()
# Hello my name is Dwight, I'm 20 and I major in Computer Science! Association Association in programming is versatile, as it can be one-to-one, one-to-many, or many-to-many. It refers to the relationship between two classes where one class uses another. In the following example, we will use a one-to-many relation between classes. The Parent class can have many children, and we can add multiple Child instances via the add_child() method. class Parent:
    def __init__(self, name):
        self.name = name
        self.children = []

    def add_child(self, child):
        self.children.append(child)

    def list_children(self):
        return [child.name for child in self.children]

    def number_of_children(self):
        if not self.children:
            return "No children"
        return len(self.children)

class Child:
    def __init__(self, name, age):
        self.name = name
        self.age = age

parent = Parent("James")
child1 = Child("James Jr.", 12)
child2 = Child("Cameron", 16)

parent.add_child(child1)
parent.add_child(child2)

# List Children
for child in parent.list_children():
    print(child)

# James Jr.
# Cameron

parent.number_of_children()

# 2 Conclusion Object-oriented programming (OOP) offers a robust framework for developing modular, reusable, and maintainable code. Its foundational concepts, such as classes, objects, encapsulation, inheritance, polymorphism, and association, enable developers to create scalable and efficient software solutions. This efficiency makes OOP an indispensable paradigm in modern programming. Embracing OOP enhances code organization and facilitates easier debugging and future-proofing of applications, making developers more productive and effective. Object-oriented programming (OOP) is a programming model that organizes software around objects(data) and object manipulation. OOP’s use of objects helps to break complex problems into smaller manageable parts, thus making code more straightforward to comprehend and manage, providing developers with a sense of ease.  Over the next few minutes, we will go over the following core concepts as they relate to OOP: Class Object Encapsulation Inheritance Polymorphism Association Class Class Object Object Encapsulation Encapsulation Inheritance Inheritance Polymorphism Polymorphism Association Association 📓 All upcoming examples will use python code 📓 All upcoming examples will use python code Class a class is a template used to create objects. Classes define the attributes of objects and the methods that the class instances will share. class Parent:
    def __init__(self, name, hair_color):
        self.name = name
        self.hair_color= hair_color

    def description(self):
        print(f"I'm {self.name}, my hair is {self.hair_color}!") class Parent:
    def __init__(self, name, hair_color):
        self.name = name
        self.hair_color= hair_color

    def description(self):
        print(f"I'm {self.name}, my hair is {self.hair_color}!") The above snippet creates a class named Parent , which contains attributes, name and hair_color and a method, description() . Every instance of the class will have the same attributes and methods. Parent name hair_color description() Object Regarding OOP, an object is an instance of a class. It has attributes and can perform actions defined by its class. The following example creates instances of the Parent class; once they have been created, we can access its publicly available attributes. For example, father.hair_color returns a value of Red . Parent father.hair_color Red father= Parent("Dylan", "Red")
mother= Parent("Grace", "Brown")

father.hair_color # Red
mother.hair_color # Brown father= Parent("Dylan", "Red")
mother= Parent("Grace", "Brown")

father.hair_color # Red
mother.hair_color # Brown Encapsulation Encapsulation bundles attributes and methods within a class and can restrict access to some of the object’s components. For example, the code below defines a Parent class. The class has three attributes: name , hair_color , and __age . The name and hair_color attributes are publicly accessible; however, calling the __age attribute will result in an AttributeError. The double underscore causes an attribute to become private. To get the value of the __age attribute, the get_age() method must be called, as it will return the age attribute given to the Parent . Parent name hair_color __age name hair_color __age __age get_age() Parent class Parent:
    def __init__(self, name, hair_color, age):
        self.name = name
        self.hair_color= hair_color
        self.__age= age

    def description(self):
        print(f"I'm {self.name}, my hair is {self.hair_color}!") 

    def get_age(self):
        return self.__age

father= Parent("Dylan", "Red", 45)

father.name # Dylan
father.__age# will result in an AttributeError
father.get_age() # 45
father.description() # I'm Dylan, my hair color is Red! class Parent:
    def __init__(self, name, hair_color, age):
        self.name = name
        self.hair_color= hair_color
        self.__age= age

    def description(self):
        print(f"I'm {self.name}, my hair is {self.hair_color}!") 

    def get_age(self):
        return self.__age

father= Parent("Dylan", "Red", 45)

father.name # Dylan
father.__age# will result in an AttributeError
father.get_age() # 45
father.description() # I'm Dylan, my hair color is Red! Inheritance 👀 ignore super().description() in the following example. We’ll go over this once we get to Polymorphism 👀 ignore super().description() in the following example. We’ll go over this once we get to Polymorphism super().description() Inheritance occurs when a class inherits the attributes and methods of another class. In the following example, the Child class inherits the same attributes as the Parent class while creating its own unrelated attributes. Child Parent class Child(Parent):
    def __init__( self, name, hair_color, age, major):
        super().__init__(name, hair_color, age)
        self.major = major

    def description(self):
        super().description()
        print(f"Name: {self.name}")
        print(f"Hair Color: {self.get_hair_color()")
        print(f"Age: {self.get_age()}")
        print(f"Major: {self.major}")

child = Child("Dwight", "Auburn", 20, "Computer Science")
child.description()
#Output
# I'm Dwight, my hair color is Auburn!
# Name: Dwight
# Hair Color: Auburn
# Age: 20
# Major: "Computer Science class Child(Parent):
    def __init__( self, name, hair_color, age, major):
        super().__init__(name, hair_color, age)
        self.major = major

    def description(self):
        super().description()
        print(f"Name: {self.name}")
        print(f"Hair Color: {self.get_hair_color()")
        print(f"Age: {self.get_age()}")
        print(f"Major: {self.major}")

child = Child("Dwight", "Auburn", 20, "Computer Science")
child.description()
#Output
# I'm Dwight, my hair color is Auburn!
# Name: Dwight
# Hair Color: Auburn
# Age: 20
# Major: "Computer Science Polymorphism Polymorphism  allows you to override or modify class methods in subclasses. As seen in the previous snippet on Inheritance, the Child class adapts and modifies the Parent method description() . By including the super().description() within the description() method, you can adapt the inclusion of the Parent output into the Child ’s description() method output. In the next snippet, the Child class inherits the attributes of the Parent class but overrides the description() method, resulting in a different output. Child Parent description() super().description() description() Parent Child description() Child Parent description() class Child(Parent):
    def __init__(self, name, hair_color, age, major):
        super().__init__(name, hair_color, age)
        self.major = major

    def description(self):
        print(f"Hello my name is {self.name}, I'm {self.get_age()} and I major in {self.major}!")

parent = Parent("Charles", "Grey", 45)
child = Child("Dwight", "Auburn", 20, "Computer Science")
parent.description()
#Output
# I'm Charles, my hair color is Grey!

child.description()
# Hello my name is Dwight, I'm 20 and I major in Computer Science! class Child(Parent):
    def __init__(self, name, hair_color, age, major):
        super().__init__(name, hair_color, age)
        self.major = major

    def description(self):
        print(f"Hello my name is {self.name}, I'm {self.get_age()} and I major in {self.major}!")

parent = Parent("Charles", "Grey", 45)
child = Child("Dwight", "Auburn", 20, "Computer Science")
parent.description()
#Output
# I'm Charles, my hair color is Grey!

child.description()
# Hello my name is Dwight, I'm 20 and I major in Computer Science! Association Association in programming is versatile, as it can be one-to-one, one-to-many, or many-to-many. It refers to the relationship between two classes where one class uses another. In the following example, we will use a one-to-many relation between classes. The Parent class can have many children, and we can add multiple Child instances via the add_child() method. Parent Child add_child() class Parent:
    def __init__(self, name):
        self.name = name
        self.children = []

    def add_child(self, child):
        self.children.append(child)

    def list_children(self):
        return [child.name for child in self.children]

    def number_of_children(self):
        if not self.children:
            return "No children"
        return len(self.children)

class Child:
    def __init__(self, name, age):
        self.name = name
        self.age = age

parent = Parent("James")
child1 = Child("James Jr.", 12)
child2 = Child("Cameron", 16)

parent.add_child(child1)
parent.add_child(child2)

# List Children
for child in parent.list_children():
    print(child)

# James Jr.
# Cameron

parent.number_of_children()

# 2 class Parent:
    def __init__(self, name):
        self.name = name
        self.children = []

    def add_child(self, child):
        self.children.append(child)

    def list_children(self):
        return [child.name for child in self.children]

    def number_of_children(self):
        if not self.children:
            return "No children"
        return len(self.children)

class Child:
    def __init__(self, name, age):
        self.name = name
        self.age = age

parent = Parent("James")
child1 = Child("James Jr.", 12)
child2 = Child("Cameron", 16)

parent.add_child(child1)
parent.add_child(child2)

# List Children
for child in parent.list_children():
    print(child)

# James Jr.
# Cameron

parent.number_of_children()

# 2 Conclusion Object-oriented programming (OOP) offers a robust framework for developing modular, reusable, and maintainable code. Its foundational concepts, such as classes, objects, encapsulation, inheritance, polymorphism, and association, enable developers to create scalable and efficient software solutions. This efficiency makes OOP an indispensable paradigm in modern programming. Embracing OOP enhances code organization and facilitates easier debugging and future-proofing of applications, making developers more productive and effective.

The code in this story is for educational purposes. The readers are solely responsible for whatever they build with it.

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Object-oriented Programming by Example

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

Objects vs. Actors

3 Simple Rules to Writing Better Code Instantly

38 Stories To Learn About Oop

An Introduction to F# as Microsoft's / .NET's Answer to a Functional-First Programming Language

Asynchronous Initialization in C#: Overcoming Constructor Limitations

Objects vs. Actors

3 Simple Rules to Writing Better Code Instantly

38 Stories To Learn About Oop

An Introduction to F# as Microsoft's / .NET's Answer to a Functional-First Programming Language

Asynchronous Initialization in C#: Overcoming Constructor Limitations

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps