Digamos que desejamos fornecer uma abstração de uma "conta" em um banco. Aqui está uma abordagem, usando um functionobjeto em Python:
def account():
"""Return a dispatch dictionary representing a bank account.
>>> a = account()
>>> a['deposit'](100)
100
>>> a['withdraw'](90)
10
>>> a['withdraw'](90)
'Insufficient funds'
>>> a['balance']
10
"""
def withdraw(amount):
if amount > dispatch['balance']:
return 'Insufficient funds'
dispatch['balance'] -= amount
return dispatch['balance']
def deposit(amount):
dispatch['balance'] += amount
return dispatch['balance']
dispatch = {'balance': 0,
'withdraw': withdraw,
'deposit': deposit}
return dispatch
Aqui está outra abordagem usando a abstração de tipo (por exemplo, classpalavra-chave em Python):
class Account(object):
"""A bank account has a balance and an account holder.
>>> a = Account('John')
>>> a.deposit(100)
100
>>> a.withdraw(90)
10
>>> a.withdraw(90)
'Insufficient funds'
>>> a.balance
10
"""
def __init__(self, account_holder):
self.balance = 0
self.holder = account_holder
def deposit(self, amount):
"""Add amount to balance."""
self.balance = self.balance + amount
return self.balance
def withdraw(self, amount):
"""Subtract amount from balance if funds are available."""
if amount > self.balance:
return 'Insufficient funds'
self.balance = self.balance - amount
return self.balance
Meu professor iniciou o tópico "Programação orientada a objetos" introduzindo a classpalavra - chave e mostrando-nos os seguintes pontos:
Programação orientada a objetos
Um método para organizar programas modulares:
- Barreiras de abstração
- Passagem de mensagem
- Agrupando informações e comportamento relacionado
Você acha que a primeira abordagem seria suficiente para satisfazer a definição acima? Se sim, por que precisamos da classpalavra-chave para fazer programação orientada a objetos?
foo.bar()é geralmente idêntico e foo['bar'](), em raras ocasiões, a última sintaxe é realmente útil.
object['method'](args), os objetos Python realmente fazem o equivalente a object['method'](object, args). Isso se torna relevante quando uma classe base chama métodos em uma classe filho, por exemplo, no Padrão de Estratégia.
classfaça uma otimização semelhante).