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?