Angenommen, wir möchten eine Abstraktion eines "Kontos" in einer Bank bereitstellen. Hier ist ein Ansatz, bei dem ein function
Objekt in Python verwendet wird:
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
Hier ist ein anderer Ansatz, der die Typabstraktion verwendet (z. B. class
Schlüsselwort 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.balance
Mein Lehrer begann das Thema "Objektorientierte Programmierung", indem er das class
Schlüsselwort einführte und uns die folgenden Stichpunkte zeigte:
Objekt orientierte Programmierung
Eine Methode zur Organisation modularer Programme:
- Abstraktionsbarrieren
- Nachrichtenübergabe
- Informationen und zugehöriges Verhalten bündeln
Glauben Sie, dass der erste Ansatz ausreichen würde, um die obige Definition zu erfüllen? Wenn ja, warum benötigen wir das class
Schlüsselwort, um objektorientiert zu programmieren?
foo.bar()
ist normalerweise identisch mit foo['bar']()
und in seltenen Fällen ist die letztere Syntax tatsächlich nützlich.
object['method'](args)
, tun Python-Objekte tatsächlich das Äquivalent von object['method'](object, args)
. Dies wird relevant, wenn eine Basisklasse Methoden in einer untergeordneten Klasse aufruft, z. B. im Strategy Pattern.
class
eine ähnliche Optimierung durchführt).