Encapsulamento
Explore conceitos avançados de POO.
Encapsulamento é uma aula grátis de Python For Kids no CoddyKit. Esta é a aula 4 de 5. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python For Kids, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python For Kids inclui 5 aulas no total.
Encapsulamento
Boas-vindas novamente à lição de Programação Orientada a Objetos (POO)! Hoje, vamos aprender sobre encapsulamento em Python, um conceito fundamental que ajuda a proteger seus dados e métodos dentro das classes.
O que é encapsulamento?
Encapsulamento é o conceito de agrupar dados (attributes) e métodos (funções) que operam sobre esses dados em uma única unidade, conhecida como classe. Ele também restringe o acesso direto a alguns componentes de um objeto, o que significa que a representação interna de um objeto fica oculta do exterior.
- Ocultação de dados: proteção do estado interno de um objeto contra interferências não intencionais.
- Controle de acesso: definição de como os dados e métodos podem ser acessados ou modificados.
O encapsulamento garante que os objetos controlem seus próprios dados e exponham apenas o que é necessário.
Modificadores de acesso
Em Python, o encapsulamento é implementado usando modificadores de acesso para controlar a visibilidade dos membros da classe (attributes e métodos). Há três tipos de modificadores de acesso:
- Público: acessível de qualquer lugar.
- Protegido: acessível dentro da classe e de suas subclasses.
- Privado: acessível apenas dentro da própria classe.
Vamos ver como usar esses modificadores de acesso em Python.
Attributes e métodos públicos
Membros públicos podem ser acessados de fora da classe. Por padrão, todos os attributes e métodos são públicos, a menos que seja especificado o contrário.
Exemplo:
# Defines the Person class with public attributes and methods
class Person:
def __init__(self, name, age):
self.name = name # Public attribute
self.age = age # Public attribute
def greet(self):
print("Hello, my name is " + self.name + "!") # Public method
# Creates an object of the Person class
person1 = Person("Alice", 30)
# Accesses public attributes and methods
print(person1.name) # Output: Alice
person1.greet() # Output: Hello, my name is Alice!
Attributes e métodos protegidos
Membros protegidos são indicados por um prefixo de sublinhado simples (_). Eles podem ser acessados dentro da classe e de suas subclasses, mas não devem ser acessados diretamente de fora da classe.
Exemplo:
# Defines the Employee class with protected attributes and methods
class Employee:
def __init__(self, name, salary):
self._name = name # Protected attribute
self._salary = salary # Protected attribute
def _increase_salary(self, amount):
self._salary += amount # Protected method
print(self._name + "'s new salary is " + str(self._salary))
# Creates an object of the Employee class
employee1 = Employee("Bob", 50000)
# Accesses protected attributes and methods (not recommended)
print(employee1._name) # Output: Bob
employee1._increase_salary(5000) # Output: Bob's new salary is 55000
Attributes e métodos privados
Membros privados são indicados por um prefixo de sublinhado duplo (__). Eles podem ser acessados apenas dentro da própria classe e não podem ser acessados diretamente de fora dela.
Exemplo:
# Defines the BankAccount class with private attributes and methods
class BankAccount:
def __init__(self, owner, balance):
self.__owner = owner # Private attribute
self.__balance = balance # Private attribute
def deposit(self, amount):
self.__balance += amount # Modifies private attribute
print("Deposited:", amount)
self.__show_balance()
def __show_balance(self):
print("Current Balance:", self.__balance) # Private method
# Creates an object of the BankAccount class
account1 = BankAccount("Charlie", 1000)
# Attempts to access private attributes and methods (will cause errors)
# print(account1.__owner) # AttributeError
# account1.__show_balance() # AttributeError
# Uses public methods to interact with private attributes
account1.deposit(500) # Output:
# Deposited: 500
# Current Balance: 1500
Por que usar encapsulamento?
O encapsulamento oferece vários benefícios:
- Controle: controle como os dados são acessados ou modificados.
- Segurança: proteja o estado interno de um objeto contra alterações não intencionais.
- Manutenibilidade: torna o código mais fácil de manter e menos sujeito a erros.
O encapsulamento ajuda a criar aplicações robustas e seguras.
Exemplo de encapsulamento: classe Car
Vamos criar uma classe Car que usa encapsulamento para proteger seus atributos e métodos.
Código:
# Defines the Car class with encapsulated attributes and methods
class Car:
def __init__(self, make, model, year):
self.make = make # Public attribute
self.model = model # Public attribute
self.__year = year # Private attribute
def get_year(self):
return self.__year # Public method to access private attribute
def set_year(self, year):
if year > 0:
self.__year = year # Public method to modify private attribute
print("Year updated to", self.__year)
else:
print("Invalid year!")
def __display_info(self):
print(self.make, self.model, self.__year) # Private method
def show_info(self):
self.__display_info() # Public method that calls a private method
# Creates an object of the Car class
car1 = Car("Tesla", "Model S", 2020)
# Accesses public attributes and methods
print(car1.make) # Output: Tesla
print(car1.get_year()) # Output: 2020
# Modifies the private attribute using a public method
car1.set_year(2021) # Output: Year updated to 2021
# Calls a public method that interacts with a private method
car1.show_info() # Output: Tesla Model S 2021
# Attempts to access private attributes and methods directly (will cause errors)
# print(car1.__year) # AttributeError
# car1.__display_info() # AttributeError
# Defines the Student class with encapsulated attributes
class Student:
def __init__(self, name, grade):
self.name = name # Public attribute
self.__grade = grade # Private attribute
def get_grade(self):
return self.__grade # Public method to access private attribute
def set_grade(self, grade):
if 0 <= grade <= 100:
self.__grade = grade # Updates the grade
else:
print("Invalid grade!")
# Creates an object of the Student class
student1 = Student("Diana", 85)
# Accesses and modifies the grade using public methods
print(student1.get_grade()) # Output: 85
student1.set_grade(90)
print(student1.get_grade()) # Output: 90
# Attempts to access the private attribute directly (will cause an error)
# print(student1.__grade) # AttributeError
Muito bem!
Você aprendeu a usar encapsulamento em Python para proteger seus dados e métodos dentro das classes. O encapsulamento ajuda a controlar o acesso aos dados dos seus objetos, tornando seus programas mais seguros e fáceis de manter. Continue praticando ao projetar classes com modificadores de acesso adequados para aprimorar suas habilidades de programação!
Perguntas Frequentes
A aula “Encapsulamento” é grátis?
Sim — o texto completo de “Encapsulamento” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python For Kids, atualize para CoddyKit PRO. O curso de Python For Kids inclui 5 aulas no total.
O que vou aprender em “Encapsulamento”?
Explore conceitos avançados de POO. Você pratica Python For Kids com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Python For Kids?
Nenhuma experiência prévia é necessária. Python For Kids no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 5.
Quanto tempo leva a aula “Encapsulamento”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Python For Kids?
Sim. Cada aula de Python For Kids inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.