Introdução ao encapsulamento e à abstração

O encapsulamento e a abstração são princípios fundamentais da Programação Orientada a Objetos (POO) que ajudam a gerenciar a complexidade e melhorar a organização do código.

O encapsulamento restringe o acesso direto aos dados de um objeto, enquanto a abstração oculta os detalhes de implementação e expõe apenas os recursos essenciais.

O que é encapsulamento?

Encapsulamento significa reunir dados (atributos) e métodos em uma classe e restringir o acesso direto a eles.

# 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())

Atributos privados

Em Python, os atributos privados são indicados por dois sublinhados __. Eles não podem ser acessados diretamente fora da classe.

# 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

O que é abstração?

A abstração oculta os detalhes internos de implementação de uma classe e expõe apenas as funcionalidades necessárias ao usuário.

# 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

Classes abstratas

Classes abstratas são classes que não podem ser instanciadas diretamente. Elas são usadas para definir uma interface comum para suas 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

Encapsulamento vs. abstração

Encapsulamento e abstração são conceitos estreitamente relacionados, mas distintos:

• Encapsulamento: restringe o acesso aos dados dentro de uma classe.
• Abstração: oculta os detalhes de implementação e fornece uma interface clara.

Vantagens do encapsulamento e da abstração

Veja algumas vantagens importantes:

• Melhora a segurança e a capacidade de manutenção do código.
• Incentiva um código modular e reutilizável.
• Facilita a leitura e a compreensão do código.

Erros comuns com encapsulamento e abstração

Veja alguns erros que devem ser evitados:

• Acessar atributos privados diretamente em vez de usar métodos de obtenção e definição.
• Instanciar classes abstratas diretamente.
• Não implementar todos os métodos abstratos nas subclasses.

O que aprendemos?

Nesta lição, você aprendeu:

• O que é encapsulamento e como restringir o acesso aos dados usando atributos privados.
• O que é abstração e como usar classes abstratas para definir interfaces comuns.
• As diferenças e os benefícios do encapsulamento e da abstração.

Muito bem! Vamos passar ao próximo tópico.