Supponiamo di voler fornire un'astrazione di un "conto" in una banca. Ecco un approccio, usando un functionoggetto in 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 dispatchEcco un altro approccio che utilizza l'astrazione del tipo (ovvero la classparola chiave in 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.balanceIl mio insegnante ha iniziato l'argomento "Programmazione orientata agli oggetti" introducendo la classparola chiave e mostrandoci questi punti elenco:
Programmazione orientata agli oggetti
Un metodo per organizzare programmi modulari:
- Barriere di astrazione
- Messaggio che passa
- Raggruppamento di informazioni e comportamenti correlati
Pensi che il primo approccio sarebbe sufficiente per soddisfare la definizione di cui sopra? Se sì, perché abbiamo bisogno della classparola chiave per eseguire una programmazione orientata agli oggetti?
Se si desidera una risposta dettagliata, è necessario porre un'altra domanda o unirsi alla chat room, ma la risposta breve è (se si ignora completamente l'ereditarietà del prototipo, gli array, ecc.) Questo è fondamentalmente vero; la maggior parte degli oggetti JS non sono altro che dizionari di chiavi di stringa a valori arbitrari.
—
Ixrec,
foo.bar()di solito è identico a foo['bar'](), e in rare occasioni quest'ultima sintassi è effettivamente utile.
Questa è una domanda davvero importante sulla strada per una comprensione fondamentale di OOP. Se sei interessato, puoi leggere un mio post sul blog in cui creo un semplice sistema a oggetti in JavaScript senza fare affidamento su nessuna delle parti OOP della lingua. Il tuo primo esempio ha un difetto importante: dove scriverai
—
amon,
object['method'](args), gli oggetti Python fanno effettivamente l'equivalente di object['method'](object, args). Ciò diventa rilevante quando una classe base chiama metodi in una classe figlio, ad esempio nel modello di strategia.
Come altri hanno notato, questa è una domanda percettiva su OOP. Ne approfitterò comunque per notare che non è affatto così che le banche reali rappresentano i conti bancari. Le banche non dispongono di un oggetto "conto" mutabile che cambia quando viene addebitato e accreditato; hanno un elenco di transazioni di sola scrittura e quindi calcolano il saldo dall'elenco delle transazioni. Come buon esercizio, prova ad attuare quel meccanismo in varie lingue.
—
Eric Lippert,
classesegua un'ottimizzazione simile).