Day80 - Revision of Inheritance in OOP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Revision of Inheritance in OOP**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **What is Inheritance(is a relationship)**\n",
    "\n",
    "Inheritance is one of the fundamental concepts in object-oriented programming (OOP) that allows a new class (subclass or derived class) to inherit properties and behaviors (attributes and methods) from an existing class (base class or superclass). This allows you to create a new class that is a modified or specialized version of an existing class, promoting code reuse and establishing a hierarchical relationship between classes.\n",
    "\n",
    "Inheritance is typically used to model an \"is-a\" relationship between classes, where the derived class is a more specific or specialized version of the base class. The derived class inherits the attributes and methods of the base class and can also have its own additional attributes and methods or override the inherited ones.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Buddy says Woof!\n",
      "Whiskers says Meow!\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def speak(self):\n",
    "        pass  # Base class method, to be overridden by subclasses\n",
    "\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        return f\"{self.name} says Woof!\"\n",
    "\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        return f\"{self.name} says Meow!\"\n",
    "\n",
    "# Creating objects\n",
    "dog = Dog(\"Buddy\")\n",
    "cat = Cat(\"Whiskers\")\n",
    "\n",
    "# Calling the speak method on objects\n",
    "print(dog.speak())  \n",
    "print(cat.speak())  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example:\n",
    "\n",
    "* 'Animal' is the base class, and 'Dog' and 'Cat' are subclasses of 'Animal'.\n",
    "* Both 'Dog' and 'Cat' inherit the 'name' attribute and the 'speak' method from the 'Animal' class.\n",
    "* However, each subclass overrides the 'speak' method to provide its own implementation, representing the specific behavior of each animal.\n",
    "Inheritance is a powerful mechanism in OOP because it allows you to create a hierarchy of classes, with each level of the hierarchy adding or modifying functionality as needed. This promotes code reuse, encapsulation, and abstraction, making it easier to manage and extend your codebase."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Inheritance is a fundamental concept in object-oriented programming (OOP) that offers several benefits for software development. Here are five key advantages of inheritance:\n",
    "\n",
    "1. **Code Reusability:** Inheritance allows you to reuse code from existing classes (base or parent classes) in new classes (derived or child classes). This promotes code reusability, reduces redundancy, and saves development time. Developers can leverage well-tested and established code when creating new classes.\n",
    "\n",
    "2. **Hierarchical Structure:** Inheritance enables the creation of a hierarchical structure of classes, with each derived class inheriting attributes and methods from its parent class. This hierarchical organization makes it easier to understand and manage the relationships between different classes in a complex system.\n",
    "\n",
    "3. **Promotes Polymorphism:** Inheritance is closely linked to the concept of polymorphism, which allows objects of different classes to be treated as objects of a common base class. This promotes flexibility and extensibility in your code, making it easier to work with diverse types of objects in a unified manner.\n",
    "\n",
    "4. **Supports Code Extensibility:** With inheritance, you can extend existing classes to add or modify functionality. Derived classes can override inherited methods to provide specialized behavior while still benefiting from the base class's shared attributes and methods. This makes it straightforward to adapt and extend your code to accommodate changing requirements.\n",
    "\n",
    "5. **Enhances Maintenance:** Inheritance improves code maintenance because changes made to the base class are automatically reflected in all its derived classes. This reduces the risk of introducing bugs during updates and ensures that modifications are consistently applied throughout the codebase. It also helps maintain a consistent interface for objects derived from the same base class.\n",
    "\n",
    "In summary, inheritance is a powerful mechanism in OOP that promotes code reusability, structure, flexibility, extensibility, and ease of maintenance. It is a cornerstone of building complex software systems by organizing and leveraging existing code effectively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Inheritance in summary\n",
    "\n",
    "- A class can inherit from another class.\n",
    "\n",
    "- Inheritance improves code reuse\n",
    "\n",
    "- Constructor, attributes, methods get inherited to the child class\n",
    "\n",
    "- The parent has no access to the child class\n",
    "\n",
    "- Private properties of parent are not accessible directly in child class\n",
    "\n",
    "- Child class can override the attributes or methods. This is called method overriding\n",
    "\n",
    "- super() is an inbuilt function which is used to invoke the parent class methods and constructor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Types of Inheritance\n",
    "\n",
    "1. **Single Inheritance:**\n",
    "   - In single inheritance, a class inherits properties and behaviors from a single parent class. This is the simplest form of inheritance, where each class has only one immediate base class.\n",
    "\n",
    "2. **Multilevel Inheritance:**\n",
    "   - In multilevel inheritance, a class derives from a class, which in turn derives from another class. This creates a chain of inheritance where each class extends the previous one. It forms a hierarchy of classes.\n",
    "\n",
    "3. **Hierarchical Inheritance:**\n",
    "   - In hierarchical inheritance, multiple derived classes inherit from a single base or parent class. This results in a structure where several classes share a common ancestor.\n",
    "\n",
    "4. **Multiple Inheritance (Diamond Problem):**\n",
    "   - Multiple inheritance occurs when a class inherits properties and behaviors from more than one parent class. This can lead to a complication known as the \"diamond problem,\" where ambiguity arises when a method or attribute is called that exists in multiple parent classes. Some programming languages, like Python, provide mechanisms to resolve this ambiguity.\n",
    "\n",
    "5. **Hybrid Inheritance:**\n",
    "   - Hybrid inheritance is a combination of two or more types of inheritance mentioned above. It is used to model complex relationships in a system where multiple inheritance hierarchies may intersect.\n",
    "\n",
    "These different types of inheritance allow developers to model various relationships and structures in object-oriented programming. Choosing the appropriate type of inheritance depends on the specific requirements and design of the software being developed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inside phone constructor\n",
      "Buying a phone\n"
     ]
    }
   ],
   "source": [
    "# single inheritance\n",
    "class Phone:\n",
    "    def __init__(self, price, brand, camera):\n",
    "        print (\"Inside phone constructor\")\n",
    "        self.__price = price\n",
    "        self.brand = brand\n",
    "        self.camera = camera\n",
    "\n",
    "    def buy(self):\n",
    "        print (\"Buying a phone\")\n",
    "\n",
    "class SmartPhone(Phone):\n",
    "    pass\n",
    "\n",
    "SmartPhone(1000,\"Apple\",\"13px\").buy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# multilevel\n",
    "class Product:\n",
    "    def review(self):\n",
    "        print (\"Product customer review\")\n",
    "\n",
    "class Phone(Product):\n",
    "    def __init__(self, price, brand, camera):\n",
    "        print (\"Inside phone constructor\")\n",
    "        self.__price = price\n",
    "        self.brand = brand\n",
    "        self.camera = camera\n",
    "\n",
    "    def buy(self):\n",
    "        print (\"Buying a phone\")\n",
    "\n",
    "class SmartPhone(Phone):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hierarchical\n",
    "class Phone:\n",
    "    def __init__(self, price, brand, camera):\n",
    "        print (\"Inside phone constructor\")\n",
    "        self.__price = price\n",
    "        self.brand = brand\n",
    "        self.camera = camera\n",
    "\n",
    "    def buy(self):\n",
    "        print (\"Buying a phone\")\n",
    "\n",
    "class SmartPhone(Phone):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiple\n",
    "class Phone:\n",
    "    def __init__(self, price, brand, camera):\n",
    "        print (\"Inside phone constructor\")\n",
    "        self.__price = price\n",
    "        self.brand = brand\n",
    "        self.camera = camera\n",
    "\n",
    "    def buy(self):\n",
    "        print (\"Buying a phone\")\n",
    "\n",
    "class Product:\n",
    "    def review(self):\n",
    "        print (\"Customer review\")\n",
    "\n",
    "class SmartPhone(Phone, Product):\n",
    "    pass"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}