Zugriff auf die Attribute
Experimente mit Kartenhaufen-Objekten
Wir betrachten hier noch einmal die Simulation von Kartenhaufen.
Im letzten Abschnitt wurde eine Klasse Kartenhaufen
entwickelt,
mit der man Softwareobjekte zur Simulation realer Kartenhaufen erzeugen kann.
Hier eine Implementierung zu dieser Klasse Kartenhaufen
in Python:
class Kartenhaufen(object):
def __init__(self):
self.kartenListe = []
self.wert = 0
def hinzufuegen(self, karte):
self.kartenListe = self.kartenListe + [karte]
if karte[2] == 'A':
kartenwert = 11
elif karte[2] == 'K':
kartenwert = 4
elif karte[2] == 'D':
kartenwert = 3
elif karte[2] == 'B':
kartenwert = 2
elif karte[2] == '1':
kartenwert = 10
elif karte[2] == '9':
kartenwert = 9
elif karte[2] == '8':
kartenwert = 8
elif karte[2] == '7':
kartenwert = 7
self.wert = self.wert + kartenwert
Wir verwenden jetzt die gezeigte Implementierung wie folgt:
>>>
>>> meinKartenhaufen = Kartenhaufen()
>>> meinKartenhaufen.hinzufuegen('K-B')
>>> meinKartenhaufen.hinzufuegen('X-9')
>>> meinKartenhaufen.kartenListe = meinKartenhaufen.kartenListe + ['H-K']
>>> meinKartenhaufen.kartenListe
['K-B', 'X-9', 'H-K']
>>> meinKartenhaufen.wert
11
Aufgabe 1
(a) Welcher reale Vorgang wird hier simuliert?
(b) Stimmt der angegebene Gesamtwert der Karten? Warum ist hier etwas schiefgelaufen?
Kapselung der Daten
Objekte nutzen Attribute, um die Daten, für die sie zuständig sind, zu verwalten. Ein leichtfertiger Zugriff auf die Attribute kann leicht zu unerwünschten Objektzuständen führen. Es ist daher eine gute Strategie, solche Zugriffe zu unterlassen oder sogar zu verbieten.
Wir setzen diese Strategie im Folgenden um, indem wir nicht mehr direkt auf Objektattribute
zugreifen. Es sollen also keine direkten Zugriffe der Form objekt.attribut
mehr erfolgen.
Ein Zugriff auf die Daten eines Objekts soll ab jetzt nur noch mit Hilfe geeigneter Methoden durchgeführt werden. Damit das möglich wird, erweitern wir zuerst die Klassendeklaration.
class Kartenhaufen(object):
def __init__(self):
self.kartenListe = []
self.wert = 0
def kartenwert(self, karte):
if karte[2] == 'A':
ergebnis = 11
elif karte[2] == 'K':
ergebnis = 4
elif karte[2] == 'D':
ergebnis = 3
elif karte[2] == 'B':
ergebnis = 2
elif karte[2] == '1':
ergebnis = 10
elif karte[2] == '9':
ergebnis = 9
elif karte[2] == '8':
ergebnis = 8
elif karte[2] == '7':
ergebnis = 7
return ergebnis
def hinzufuegen(self, karte):
self.kartenListe = self.kartenListe + [karte]
self.wert = self.wert + self.kartenwert(karte)
def getKartenListe(self):
return self.kartenListe
def getWert(self):
return self.wert
def setKartenListe(self, vorgegebeneKarten):
self.kartenListe = vorgegebeneKarten
gesamtwert = 0
for karte in self.kartenListe:
gesamtwert = gesamtwert + self.kartenwert(karte)
self.wert = gesamtwert
Mit den hinzugefügten Methoden lässt sich der oben gezeigte Vorgang jetzt so simulieren:
>>>
>>> meinKartenhaufen = Kartenhaufen()
>>> meinKartenhaufen.hinzufuegen('K-B')
>>> meinKartenhaufen.hinzufuegen('X-9')
>>> meinKartenhaufen.hinzufuegen('H-K')
>>> meinKartenhaufen.getKartenListe()
['K-B', 'X-9', 'H-K']
>>> meinKartenhaufen.getWert()
15
Aufgabe 2
(a) Überzeuge dich, dass hier kein direkter Zugriff auf die Daten erfolgt. Auf welche Weise kann man sich dennoch die Daten verschaffen?
(b) Analysiere die Klassendeklaration. Welche Ergebnisse werden wohl an Stelle der Fragezeichen ausgegeben? Überprüfe deine Vermutung.
>>>
>>> meinKartenhaufen = Kartenhaufen()
>>> meinKartenhaufen.setKartenListe(['K-B', 'H-D'])
>>> meinKartenhaufen.getKartenListe()
?
>>> meinKartenhaufen.getWert()
?
>>> meinKartenhaufen.hinzufuegen('X-7')
>>> meinKartenhaufen.hinzufuegen('H-K')
>>> meinKartenhaufen.getKartenListe()
?
>>> meinKartenhaufen.getWert()
?
(c) Worin liegen die Vorteile, wenn nur die von einem Objekt bereitgestellten Methoden benutzt werden?