Introdução à Encapsulação e à Abstração

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

Encapsulação 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 é encapsulação?

Encapsulação 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 __. Não é possível acessá-los diretamente de 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?

Abstração oculta os detalhes internos de implementação de uma classe e expõe ao usuário apenas a funcionalidade necessária.

# 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

Encapsulação versus abstração

Encapsulação e abstração são conceitos intimamente relacionados, mas distintos:

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

Vantagens da encapsulação e da abstração

Estas são algumas vantagens importantes:

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

Erros comuns com encapsulação 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 fazer o implementing de todos os métodos abstratos nas subclasses.

O que aprendemos?

Nesta lição, você aprendeu:

• O que é encapsulação 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 as vantagens da encapsulação e da abstração.

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