OOP Concepts: Inheritance and Polymorphism Go deeper into OOP by explaining inheritance and polymorphism with examples.

 

Inheritance

Inheritance is a mechanism in OOP that allows a new class (child or derived class) to inherit attributes and methods from an existing class (parent or base class). This promotes code reusability and establishes a hierarchical relationship between classes.

Key Points:

  • Single Inheritance: A derived class inherits from a single base class.
  • Multiple Inheritance: A derived class inherits from multiple base classes.
  • Method Overriding: A derived class can provide a specific implementation of a method that is already defined in its base class.

Example of Inheritance

# Base class
class Animal:
    def __init__(self, name):
        self.name = name
   
    def speak(self):
        return "Animal speaks"

# Derived class
class Dog(Animal):
    def speak(self):  # Overriding the base class method
        return "Woof"

class Cat(Animal):
    def speak(self):  # Overriding the base class method
        return "Meow"

# Creating instances
my_dog = Dog("Buddy")
my_cat = Cat("Whiskers")

print(my_dog.name)

 # Output: Buddy
print(my_dog.speak())

 # Output: Woof
print(my_cat.name)

 # Output: Whiskers
print(my_cat.speak())

 # Output: Meow

Polymorphism

Polymorphism is the ability of different classes to be treated as instances of the same class through a common interface. It allows methods to be defined in a base class and overridden in derived classes, enabling the same method to behave differently based on the object that is calling it.

Key Points:

  • Method Overriding: As shown in the inheritance example, derived classes can override base class methods.
  • Duck Typing: In Python, polymorphism can also be achieved through duck typing, where the type or class of an object is less important than the methods it defines.

Example of Polymorphism

class Bird:
    def fly(self):
        return "Flies high"

class Penguin(Bird):
    def fly(self):  # Overriding the base class method
        return "Cannot fly"

class Sparrow(Bird):
    pass  # Inherits fly method from Bird

def make_bird_fly(bird):
    print(bird.fly())

# Creating instances
sparrow = Sparrow()
penguin = Penguin()

make_bird_fly(sparrow)

 # Output: Flies high
make_bird_fly(penguin)

 # Output: Cannot fly

Summary

  • Inheritance allows for the creation of a new class based on an existing class, promoting code reuse and establishing a relationship between classes.
  • Polymorphism enables methods to be used interchangeably across different classes, allowing for flexibility and dynamic behavior in programs.

Both concepts are fundamental in OOP and help in building scalable and maintainable code.

Comments

Post a Comment

Popular posts from this blog

Hash Tables and Hashing

  Hash Tables and Hashing A hash table is a data structure that maps keys to values for efficient data retrieval. The underlying concept is based on hashing , which involves using a hash function to compute an index (or hash code) for each key. This index determines where the value associated with the key will be stored in the table. Key Features of Hash Tables Fast Lookup : Hash tables offer average O(1) time complexity for lookups, insertions, and deletions. Key-Value Pair Storage : Data is stored as key-value pairs. Dynamic Size : Many implementations dynamically resize the hash table as the number of elements grows. How Hashing Works A hash function converts a key into a numerical hash code. The hash code is mapped to an index in an array (or bucket) of fixed size. If two keys produce the same hash code (a collision ), a collision resolution strategy is used, such as: Chaining : Store multiple values in a linked list or similar structure at the same index. Open Addressing...
Read more

Stacks and Queues

Image
 Stacks and queues are essential data structures in programming, each with unique characteristics and uses. 1.Stack (LIFO - Last In, First Out) A stack is a LIFO (Last In, First Out) data structure, where the last element added is the first one removed. Think of it like a stack of plates: you add to the top, and you also remove from the top. In Python, we can use a list to implement a stack because lists support adding and removing items from the end in constant time, which aligns with stack operations. Stack Operations Push : Add an item to the stack. Pop : Remove the last item added. Peek : Get the value of the last item without removing it. IsEmpty : Check if the stack is empty. Here's a simple implementation of a stack using a list in Python: class Stack :     def __init__ ( self ):         self . stack = []     def push ( self , item ):         self . stack . append ( item )     def pop ( self ): ...
Read more

introduction to Algorithms and Complexity Analysis

Image
 An algorithm is a finite sequence of well-defined steps used to solve a problem or perform a computation. However, not all algorithms are created equal. Some are faster or more efficient than others for the same task. Evaluating an algorithm’s performance is crucial to determine its suitability for a given problem, especially when working with large datasets. Why Evaluate Algorithm Performance? Scalability : To understand how an algorithm performs as input size grows. Efficiency : To compare multiple algorithms and choose the most efficient one. Resource Usage : To analyze memory and processing power requirements. Real-World Constraints : Efficient algorithms are critical in applications like real-time systems, where delays can have serious consequences. Algorithm Complexity Algorithm complexity measures the amount of time and space an algorithm consumes relative to the size of its input. Time Complexity : Measures the number of basic operations or steps an algorithm takes to c...
Read more