Objects and Object Oriented Programming

What is an Object and Class:

Object can be any real life entity, that has some functionalities and attributes.
Class is a blueprint that provides the functionality to the object
- e.g: Car is a object which has functionalities like movement, transport etc.
- The Car comes under a class of Vehicles
- That means Vehicle will provide blueprint of functions that car has to perform

Principles of OOP:

OOP introduced as a representation of real world scenarios
It works majorly on four principles
- Inheritence
- Abstraction
- Polymorphism
- Encapsulation
Let's look at them one by one.

Inheritence:

Inheritence is a useful concept which helps us to reuse our code
There are three types of Inheritence in python
- Single Inheritence
- Multi-level Inheritence
- Multiple Inheritence

Single Inheritence:

Here There will be only one parent class, one child class.


class Animal:
'''Parent class'''
    def __init__(self,color,legs):
    ''' Constructor of parent class'''
        self.color = color
        self.legs = 4
    def sound(self):
    '''Instance method of parent class'''
        pass
class Dog(Animal):
    '''Dog class inheriting from Animal class'''
    def __init__(self,color,legs,sound):
        super().__init__(color,legs)
        self.sound = sound
    def sound(self):
        print(self.sound)
dog = Dog('black',4,'Boww')
dog.sound()

In the above example sound method was overrided in child class.
child class can access the methods of parent class
super key word is used to call the immediate parent class constructor

Multi-level Inheritence:

Here there will be chain of class that are inheriting.

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

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

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

gc = Child('Yaswanth',22,'Andhra Pradesh')
print(gc.name(), gc.age(), gc.location())

In the above example, grandchild is inheriting attribute of parent class
child is ingeriting parent class attributes
Point to be noted is that, It's not Possible for parent class to access child class attributes or methods.

Multiple Inheritence

Python supports multiple inheritence.
It involves inheriting methods or attributes of two or more classes at same time

class A:
    def __init__(self):
        self.a = 'A class'
class B:
    def __init__(self):
        self.b = 'B class'
class C(A,B):
    def __init__(self):
        A.__init__()
        B.__init__()

c = C()
print(c.a , c.b)

Here we can access A, B attributes with c object.

Abstraction

Following use case is one of the useful case that i cam to know of Abstraction
Let's say when you are writing a class that has three methods, you know the implimentation of first two methods.
So we can impliment two methods and mention third method as abstract method so others can impliment the left out method by overriding it.
Abstract methods are declared in python by Importing ABC class from abc module as shown

from abc import ABC,abstractmethod
class A:
    def method_one(self):
        print('method one')
    def method_two(self):
        print('method two')
    @abstractmethod
    def method_three(self):
        pass
class B(A):
    def method_three(self):
        print('method three implimented')
b= B()
b.method_three()

Here method_three has been declared as a abstractmethod, so it has to be implimented to create object for B class

Polymorphism

ploymorphism means the existence in many forms
Overriding function comes under polymorphism
Operator overriding is an example of polymorphism

class A:
    def method_one(self):
        print('method from class A')
class B(A):
    def method_one(self):
        print('method from class B')
a=A()
a.method_one()
b=B()
b.method_one()

In the above example same method giving different result for different objects,hence polymorphism is achived

Encapsulation

Encapsulation refers to the scope of attributes and methods of class
In Python, this can be of three types
- Public
- Private (start with double underscore '__')
- Protected (start with single underscore '_')

class A:
    def __init__(self):
        self._a = 'A class protected attribute'
        self.__b = 'A class private attribute'
        self.c = 'A class public attribute'
class B(A):
    def __init__(self):
        super().__init__()
b=B()
print(b.c) # output : 'A class public attribute'
print(b._a) # output : 'A class protected attribute'
print(b.__b) # output :AttributeError: 'B' object has no attribute '__b'

In the above example, b.__b returned error because __b is a private attribute of class A
protected attributes can be accessed through inheritence
public attributes can be accessed any where Note: Same encapsulation applies for the methods also