Introduction to Encapsulation and Abstraction

Encapsulation and abstraction are fundamental principles of Object-Oriented Programming (OOP) that help manage complexity and improve code organization.

Encapsulation restricts direct access to an object's data, while abstraction hides implementation details and exposes only essential features.

What Is Encapsulation?

Encapsulation means bundling data (attributes) and methods together within a class and restricting direct access to them.

# Example of encapsulation
class Person:
    # Private attribute (indicated by double underscores)
    def __init__(self, name):
        self.__name = name

    # Public method to access the private attribute
    def get_name(self):
        return self.__name

person = Person("Alice")
# Accessing private data via a public method
print(person.get_name())

Private Attributes

In Python, private attributes are denoted by double underscores __. They cannot be accessed directly outside the class.

# Private attributes
class Car:
    def __init__(self, brand):
        self.__brand = brand  # Private attribute

    def get_brand(self):
        # Public method to access the private attribute
        return self.__brand

car = Car("Toyota")
print(car.get_brand())  # Outputs: Toyota

What Is Abstraction?

Abstraction hides the internal implementation details of a class and exposes only the necessary functionality to the user.

# Example of abstraction
from abc import ABC, abstractmethod

# Abstract Base Class
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

# Subclass implementing the abstract method
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

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

circle = Circle(5)
print(circle.area())  # Outputs: 78.5

Abstract Classes

Abstract classes are classes that cannot be instantiated directly. They are used to define a common interface for their subclasses.

# Abstract Base Class with multiple subclasses
from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Dog barks")

class Cat(Animal):
    def speak(self):
        print("Cat meows")

dog = Dog()
cat = Cat()
dog.speak()  # Outputs: Dog barks
cat.speak()  # Outputs: Cat meows

Encapsulation vs. Abstraction

Encapsulation and abstraction are closely related but distinct concepts:

• Encapsulation: Restricts access to data within a class.
• Abstraction: Hides implementation details and provides a clear interface.

Advantages of Encapsulation and Abstraction

Here are some key advantages:

• Improves code security and maintainability.
• Encourages modular and reusable code.
• Makes the code easier to read and understand.

Common Mistakes with Encapsulation and Abstraction

Here are some mistakes to avoid:

• Accessing private attributes directly instead of using getter and setter methods.
• Instantiating abstract classes directly.
• Not implementing all abstract methods in subclasses.

What Did We Learn?

In this lesson, you learned:

• What encapsulation is and how to restrict access to data using private attributes.
• What abstraction is and how to use abstract classes to define common interfaces.
• The differences and benefits of encapsulation and abstraction.

Great job! Let’s move to the next topic.