Deep Learning

1. Encapsulation

Definition: Encapsulation is the bundling of data (attributes) and methods (functions) into a single unit (class) and restricting direct access to some of the object’s components. Encapsulation also involves restricting direct access to certain parts of an object to ensure better control and data integrity.
Purpose: Protect the data from unauthorized access and ensure proper control.
Example: Using private attributes and getter/setter methods (as explained above).

2. Abstraction

Definition: Abstraction is the concept of hiding unnecessary implementation details and showing only the essential features of an object.
Purpose: Simplifies complexity by focusing on what an object does rather than how it does it.

Example in Python:

from abc import ABC, abstractmethod

class Animal(ABC):  # Abstract class
    @abstractmethod
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "Bark!"

class Cat(Animal):
    def make_sound(self):
        return "Meow!"

dog = Dog()
print(dog.make_sound())  # Output: Bark!

Animal defines an abstract class with an abstract method make_sound. The subclasses (Dog and Cat) provide specific implementations.

3. Inheritance

Definition: Inheritance allows one class (child/subclass) to acquire the properties and behaviors of another class (parent/superclass).
Purpose: Promotes code reuse and establishes a hierarchical relationship between classes.

Example in Python:

class Vehicle:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def display_info(self):
        return f"Vehicle: {self.brand} {self.model}"

class Car(Vehicle):  # Inheriting from Vehicle
    def __init__(self, brand, model, doors):
        super().__init__(brand, model)
        self.doors = doors

    def display_info(self):
        return f"Car: {self.brand} {self.model}, Doors: {self.doors}"

car = Car("Toyota", "Corolla", 4)
print(car.display_info())  # Output: Car: Toyota Corolla, Doors: 4

Car inherits from Vehicle and adds its own specific behavior (doors attribute).

4. Polymorphism

Definition: Polymorphism allows objects of different classes to be treated as objects of a common superclass. It enables the same method to behave differently based on the object calling it.
Purpose: Promotes flexibility and scalability in code.

Example in Python:

class Shape:
    def area(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

shapes = [Rectangle(4, 5), Circle(3)]

for shape in shapes:
    print(shape.area())

Output:
```
20
28.26
```
Both Rectangle and Circle have the area method, but they implement it differently.

Summary of OOP Principles: