modul:m320_2024:learningunits:lu02:klassendiagramm

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Nächste Überarbeitung		 Vorhergehende Überarbeitung
modul:m320_2024:learningunits:lu02:klassendiagramm [2024/04/17 18:15] – angelegt - Externe Bearbeitung 127.0.0.1modul:m320_2024:learningunits:lu02:klassendiagramm [2025/11/17 08:33] (aktuell) – Externe Bearbeitung 127.0.0.1
Zeile 3: Zeile 3:
 In einem ersten Schritt beschränken wir uns auf die Darstellung einer Klasse in der Notationssprache UML ([[https://de.wikipedia.org/wiki/Unified_Modeling_Language|Unified Modelling Language]]).\\ In einem ersten Schritt beschränken wir uns auf die Darstellung einer Klasse in der Notationssprache UML ([[https://de.wikipedia.org/wiki/Unified_Modeling_Language|Unified Modelling Language]]).\\
 {{:modul:m320:learningunits:lu01:theorie:abb._8_-_klassendiagramm.png?700|}}\\ {{:modul:m320:learningunits:lu01:theorie:abb._8_-_klassendiagramm.png?700|}}\\
-//Abb:// Klassendigramm nach UML\\ +//Abb: Klassendigramm nach UML//
-[[https://de.wikipedia.org/wiki/Klassendiagramm]]\\ +
  
 +[[wpde>Klassendiagramm]]
  
 Die <<Übersetzung>> des Klassendiagramms in der Abbildung in den entsprechenden Code finden Sie weiter unten. Die <<Übersetzung>> des Klassendiagramms in der Abbildung in den entsprechenden Code finden Sie weiter unten.
  
 Erklärung zu den Elementen des Klassendiagramms: Erklärung zu den Elementen des Klassendiagramms:
-  * **Attribute** sollten immer private deklariert werden, um deren Wertebereich garantieren zu können. [//Die Erklärung zu data hiding folgt in Kapitel 5//]\\+  * **Attribute** sollten immer private deklariert werden, um deren Wertebereich garantieren zu können. //(Die Erklärung zu **data hiding** folgt in [[modul:m320_2024:learningunits:lu02:datahiding|]])//
   * **Konstruktoren** werden bei der Erzeugung eines Objekts als erstes ausgeführt und dienen primär dem Initilaisieren der Attribute.   * **Konstruktoren** werden bei der Erzeugung eines Objekts als erstes ausgeführt und dienen primär dem Initilaisieren der Attribute.
   * **Methoden** stellen die Funktionalität der Klasse dar. Oft wird die Gesamtheit aller Methoden auch als <<die Schnittstelle>> der Klasse bezeichnet.   * **Methoden** stellen die Funktionalität der Klasse dar. Oft wird die Gesamtheit aller Methoden auch als <<die Schnittstelle>> der Klasse bezeichnet.
 Im folgenden Code-Stück werden diese Elemente zusätzlich beschrieben. Im folgenden Code-Stück werden diese Elemente zusätzlich beschrieben.
----- + 
-//Beispiel 1.5: Abstraktion einer Türe// \\+==== Beispiel: Abstraktion einer Türe ====
  
 <code python> <code python>
Zeile 26: Zeile 25:
     Das Verriegeln selber delegiert die Türe an ein Objekt vom Typ Door_lock (Türschloss).     Das Verriegeln selber delegiert die Türe an ein Objekt vom Typ Door_lock (Türschloss).
     """     """
-# Mit dem Keyword def wird eine Funktion bzw. eben ein Konstruktor deklariert. + 
-# Der Konstruktor trägt IMMER den Namen __init__ und weist als ersten Parameter den Wert self auf. +    # Mit dem Keyword def wird eine Funktion bzw. eben ein Konstruktor deklariert. 
-# Danach folgen die Übergabeparameter, deren Werte dann den Attributen zugewiesen werden. +    # Der Konstruktor trägt IMMER den Namen __init__ und weist als ersten Parameter den Wert self auf. 
-# Attribute können aber auch mit einem fixen Wert initialisiert werden. +    # Danach folgen die Übergabeparameter, deren Werte dann den Attributen zugewiesen werden. 
-# Konstruktoren werden als Erstes im Programm angeschrieben.+    # Attribute können aber auch mit einem fixen Wert initialisiert werden. 
 +    # Konstruktoren werden als Erstes im Programm angeschrieben.
     def __init__(self, ref2door_lock, base_color):     def __init__(self, ref2door_lock, base_color):
         """         """
Zeile 37: Zeile 37:
         :param base_color:         :param base_color:
         """         """
-# ein privates Attribut muss im Konstruktor initialisiert werden und ist dann in der Klasse +        # ein privates Attribut muss im Konstruktor initialisiert werden und ist dann in der Klasse 
-# über self.__name_des_Attributs ansprechbar. +        # über self.__name_des_Attributs ansprechbar. 
-        self._the_door_lock  = ref2door_lock +        self._the_door_lock = ref2door_lock 
-# Hier wird der Setter eines Attributs aufgerufen (siehe unten) +        # Hier wird der Setter eines Attributs aufgerufen (siehe unten) 
-        self.color            = base_color +        self._color = base_color 
-        self._door_is_open   = False+        self._door_is_open = False
         self._door_is_locked = False         self._door_is_locked = False
  
-# Nach den Konstruktoren folgen Methoden, die eine Verarbeitung auslösen. +    # Nach den Konstruktoren folgen Methoden, die eine Verarbeitung auslösen. 
-# Danach folgen Methoden, die auf ein Ereignis reagieren+    # Danach folgen Methoden, die auf ein Ereignis reagieren
     def open_the_door(self):     def open_the_door(self):
         """         """
-        Methode für das öffnen der Türe.+        Methode für das Öffnen der Türe.
         Das ist aber nur möglich, wenn die Türe nicht verriegelt ist.         Das ist aber nur möglich, wenn die Türe nicht verriegelt ist.
         """         """
-        if self._door_is_locked == False:+        if not self.door_is_locked:
             self._door_is_open = True             self._door_is_open = True
  
Zeile 64: Zeile 64:
     def lock_the_door(self):     def lock_the_door(self):
         """         """
-        Methode für das verriegeln der Türe.+        Methode für das Verriegeln der Türe.
         Das ist nur möglich, wenn die Türe nicht offen ist.         Das ist nur möglich, wenn die Türe nicht offen ist.
-        Für das verriegeln ist aber das Türschloss zuständig. Es weiss wie das geht.+        Für das Verriegeln ist aber das Türschloss zuständig. Es weiss wie das geht.
         """         """
-        if self._door_is_open == False:+        if self._door_is_open is False:
             self._door_is_locked = self._the_door_lock.lock()             self._door_is_locked = self._the_door_lock.lock()
  
     def unlock_the_door(self):     def unlock_the_door(self):
         """         """
-        Methode für das entriegeln der Türe+        Methode für das Entriegeln der Türe
         Das ist nur möglich, wenn die Türe verriegelt ist.         Das ist nur möglich, wenn die Türe verriegelt ist.
-        Für das entriegeln ist aber das Türschloss zuständig. Es weiss wie das geht.+        Für das Entriegeln ist aber das Türschloss zuständig. Es weiss wie das geht.
         """         """
-        if self._door_is_locked:+        if self.door_is_locked:
             self._door_is_locked = self._the_door_lock.unlock()             self._door_is_locked = self._the_door_lock.unlock()
  
Zeile 88: Zeile 88:
         print(f'Türe verriegelt: {self._door_is_locked}')         print(f'Türe verriegelt: {self._door_is_locked}')
  
-# Am Ende folgen die getter- und setter-Methoden für die Attribute der Klasse +    # Am Ende folgen die getter- und setter-Methoden für die Attribute der Klasse 
-# getter werden mit der Anotation @property markiert.+    # getter werden mit der Anotation @property markiert.
     @property     @property
     def door_is_open(self):     def door_is_open(self):
Zeile 99: Zeile 99:
  
     @property     @property
-    def door_ist_locked(self):+    def door_is_locked(self):
         """         """
         getter-Methode für den Zustand door_is_locked         getter-Methode für den Zustand door_is_locked
Zeile 114: Zeile 114:
         return self._color         return self._color
  
-# setter werden mit der Anotation @name.setter markiert.+    # setter werden mit der Anotation @name.setter markiert.
     @color.setter     @color.setter
     def color(self, new_color):     def color(self, new_color):
Zeile 124: Zeile 124:
  
  
- 
-""" 
-nur für die korrekte Übersetzung und Ausführung  
-""" 
 class DoorLock: class DoorLock:
     """     """
     dummy Klasse, damit in der Klasse Tuere kein Fehler auftritt     dummy Klasse, damit in der Klasse Tuere kein Fehler auftritt
     """     """
 +
     def __init__(self):     def __init__(self):
         print("ein Schloss erzeugt")         print("ein Schloss erzeugt")
Zeile 140: Zeile 137:
     def unlock(self):     def unlock(self):
         return False         return False
 +
  
 # Hier die main-Methode festlegen # Hier die main-Methode festlegen
-if __name__  == '__main__':+if __name__ == '__main__':
     print('Test für Tür-Objekt')     print('Test für Tür-Objekt')
     the_door_lock = DoorLock()     the_door_lock = DoorLock()
-    the_door      = Door(the_door_lock, 'grün')+    the_door = Door(the_door_lock, 'grün')
     the_door.test()     the_door.test()
     print('-- Türe jetzt öffnen')     print('-- Türe jetzt öffnen')
     the_door.open_the_door()     the_door.open_the_door()
     the_door.test()     the_door.test()
 +
 </code> </code>
  
 ---- ----
-[[https://creativecommons.org/licenses/by-nc-sa/4.0/|{{https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png}}]] (c) René Probst+[[https://creativecommons.org/licenses/by-nc-sa/4.0/|{{https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png}}]] René Probst, bearbeitet durch Marcel Suter
  
  • modul/m320_2024/learningunits/lu02/klassendiagramm.1713370502.txt.gz
  • Zuletzt geändert: 2024/04/17 18:15
  • von 127.0.0.1