add override and polymorphism

Author: rubada

03.OOP_Pillars/01.oop_pillar_scripts/01g.OOP_Pillars_inheritance_override.py

@@ -0,0 +1,87 @@
+# Methods Override.
+# An override allows a subclass (child) method to provide its implementation
+# over a method (that has the same name) that is already defined in its
+# superclass (parent).
+# Let's take an example:
+class Parent:
+
+    def to_overide(self):
+        return "This method is inside the Parent class"
+
+
+class Child(Parent):
+
+    def to_overide(self):
+        return "This method is inside the Child class"
+
+
+# Create an instance of the Child class
+object_sub = Child()
+# print(object_sub.to_overide())
+
+
+# Overriding can be used in:
+# 1.Multiple Inheritance
+class Parent1:
+
+    def to_overide(self):
+        return "This method is inside the Parent1 class"
+
+
+class Parent2:
+
+    def to_overide(self):
+        return "This method is inside the Parent2 class"
+
+
+class ChildRev(Parent1, Parent2):
+
+    def to_overide(self):
+        return "Inside the Child class"
+
+
+# Create an instance of the Child class
+obj_sub = ChildRev()
+# print(obj_sub.to_overide())
+
+
+# 2.Multilevel Inheritance:
+class ParentRev:
+
+    def to_overide(self):
+        return "Inside the ParentRev class"
+
+
+class Child1(ParentRev):
+
+    def to_overide(self):
+        return "Inside the Child1 class"
+
+
+class GrandChild(Child1):
+
+    def to_overide(self):
+        return "Inside the GrandChild class"
+
+
+sub_child = Child1()
+# print(sub_child.to_overide())
+
+grand_child = GrandChild()
+# print(grand_child.to_overide())
+
+
+# Where and why do we use method overriding?
+# 1. Maintainability: When you use method overriding, you can change the
+# behavior of methods in a subclass without altering the superclass code.
+
+# 2. Polymorphism.
+# Method overriding enables polymorphism, allowing different objects to respond
+# differently to the same method call. Different versions of the methods are
+# called based on the object type.
+# Polymorphism will be discussed in the next section.
+
+# 3. Overriding is used in abstraction, which will be discussed later in this
+# section.
+
+# 4. The above points lead to code flexibility.

03.OOP_Pillars/01.oop_pillar_scripts/02.OOP_Pillars_polymorphism.py

@@ -0,0 +1,108 @@
+# The 4 Pillars of OOP in Python:
+# 2. Polymorphism
+# "Polymorphism" means "many forms", and in programming when a methods,
+# or functions, etc., have the same name and can be executed on many objects of
+# the different or same type.
+# Let's take an example:
+# The len() function, can be executed on different data types:
+# Lists
+# print(len([2, 5, 3, 1]))
+
+# Strings
+# print(len("Hello"))
+
+# Dictionary
+# print(len({"g": 1, "h": 2, "y": 4, "u": 5, "N": 7}))
+
+
+# Class Polymorphism
+# Polymorphism is used with class methods, where there is a method that has
+# the same name in multiple classes.
+# Let's take an example:
+class Dogs:
+
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+
+    def sound(self):
+        return "Heard my dog barking."
+
+
+class Cats:
+
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+
+    def sound(self):
+        return "Heard my cat meowing."
+
+
+class Roosters:
+
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+
+    def sound(self):
+        return "Heard my rooster crowing."
+
+
+# Create classes instances:
+dog = Dogs("leo", 6)
+cat = Cats("Oreo", 2)
+rooster = Roosters("RuRu", 1)
+
+# To call the sound method for all the objects, we the "for" loop:
+# for i in [dog, cat, rooster]:
+#     print(i.sound())
+
+# Because of Polymorphism we can excute the sound() method for the three
+# classes.
+
+
+# Polymorphism with Inheritance:
+class Animals:
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+
+    def sound(self):
+        return f"{self.name} voice"
+
+
+class Dog(Animals):
+
+    # Reuse and override the sound method in the Animals class in the Dog
+    # subclass
+    def sound(self):
+        return f"{super().sound()} is barking."
+
+
+class Cat(Animals):
+
+    # Override the sound method in the Animal class and inherit the Animal
+    # attributes.
+    def sound(self):
+        return f"{self.name} is meowing."
+
+
+class Rooster(Animals):
+
+    # Override the sound method in the Animal class and inherit the Animal
+    # attributes.
+    def sound(self):
+        return f"{self.name} is crowing."
+
+
+dog = Dog("leo", 6)
+cat = Cat("Oreo", 2)
+rooster = Rooster("RuRu", 1)
+names = ["dog", "cat", "rooster"]
+animals_obj = [dog, cat, rooster]
+
+for i in range(len(names)):
+    print(f"My {names[i]} {animals_obj[i].name} age is {animals_obj[i].age} \
+years old")
+    print(animals_obj[i].sound())