#Region - TimeStamp ; 2012-04-22 01:57:39 #EndRegion - TimeStamp #Include ;==================================================================================================== ; BAO = Basic-AutoIt-Object ( oder BugFix-AutoIt-Object ;=) ) ;==================================================================================================== ; FUNKTIONEN ; _BAO_Class_Create Erstellt eine Objekt-Klasse ; _BAO_Class_MethodSet Registriert eine Methode für die Klasse ; _BAO_Class_PropSet Registriert oder ändert eine Property der Klasse ; _BAO_Class_ObjCreate Erstellt ein Klassen-Objekt ; _BAO_Class_ObjMethodSet Registriert eine Methode für ein Klassen-Objekt ; _BAO_Class_ObjPropSet Registriert oder ändert eine Property eines Klassen-Objektes ; _BAO_Class_ObjGet Abfragen von Informationen der Klasse und/oder des Klassen-Objektes ; _BAO_Class_ObjMethodCall Aufrufen von Methoden ;==================================================================================================== ;==================================================================================================== ; KLASSEN ;==================================================================================================== ; Funktion zum Erstellen einer Klasse Func _BAO_Class_Create($_sClass, $_sIndexClass='self') Local Static $aClass_MethodsTmp, $aClass_PropsTmp, $sClassTmp Local $aClass[4] ; == Array zum Speichern der Mitglieder dieser Klasse (KlassenObjekte), [Klassenname, Array-Methoden, Array-Properties, Array-KlassenObjekte] If $_sIndexClass = 'self' Then Local $aClass_Methods[1] = [0] ; == Array zur Aufnahme der Methoden, Erstellen mit Anzahl der akt. Methoden als erstem Element Local $aClass_Props[1][2] = [[0]] ; == 2D-Array zur Aufnahme der Properties, Erstellen mit Anzahl der akt. Properties als erstem Element, [['property','value']] Local $aMembers[1] = [0] If IsArray($aClass_MethodsTmp) Then $aClass_Methods = $aClass_MethodsTmp If IsArray($aClass_PropsTmp) Then $aClass_Props = $aClass_PropsTmp If $sClassTmp <> '' Then $_sClass = $sClassTmp $aClass[0] = $_sClass $aClass[1] = $aClass_Methods $aClass[2] = $aClass_Props $aClass[3] = $aMembers $aClass_MethodsTmp = '' $aClass_PropsTmp = '' $sClassTmp = '' Return $aClass Else $sClassTmp = $_sClass ; == zu verwendender KlassenObjekt-Name Local $aTmp = Execute('$' & $_sIndexClass) ; == alle zu vererbenden Informationen aus der "Index-Klasse" abfragen (Methoden und Eigenschaften) $aClass_MethodsTmp = $aTmp[1] $aClass_PropsTmp = $aTmp[2] Return _BAO_Class_Create($_sClass) EndIf EndFunc ; == die Klasse "Programmierer" erstellen als Array mit Elementen für Klassennamen, Array Methoden, Array Properties, Array Member Global $Programmierer = _BAO_Class_Create('Programmierer') ; == WICHTIG! Variablenname == '$' & 'Klassenname' ;==================================================================================================== ; METHODEN ;==================================================================================================== ; == Methoden für diese Klasse erstellen ;************************************************************************************************************** ; == HINWEIS: Als erster Parameter sind zwingend alle Methoden mit "$_self" zu versehen. ; == In der Funktion zum Aufruf der Methode wird an diesen Paramter das aufrufende Objekt übergeben. ; == Somit kann in den Methoden auf die Properties des KlassenObjektes zugegriffen werden. ; == ZUSÄTZLICHE Parameter werden von der aufrufenden Funktion IMMER als Array übergeben!! ;************************************************************************************************************** ; == unser Programmierer benötigt natürlich Methoden, er sollte zwei Dinge können: Kaffee trinken und Programmieren ;-) Func DrinkCoffee($_self) ConsoleWrite('-> ' & _BAO_Class_ObjGet($_self, 'name') & ' schlürft Kaffee:' & @CRLF) ; Name des KlassenObjektes aus dem übergebenen Objekt abfragen ConsoleWrite('>> Hm… lecker Kaffe!' & @CRLF) EndFunc Func DoSomething($_self) Local Static $iDone = 0 $iDone += 1 ConsoleWrite('-> ' & _BAO_Class_ObjGet($_self, 'name') & ' tut etwas:' & @CRLF) If $iDone = 2 Then $iDone = 0 ConsoleWrite(">> Man kann's auch übertreiben, erst mal Pause machen!" & @CRLF) _BAO_Class_ObjMethodCall($_self, 'DrinkCoffee') Else ConsoleWrite('>> *programmier*' & @CRLF) EndIf EndFunc ; == noch sind die Methoden "herrenlos", wir müssen sie jetzt mit der Klasse "Programmierer" verknüpfen ; == dazu bauen wir uns eine Funktion, die die Methoden setzt: Func _BAO_Class_MethodSet(ByRef $_aClass, $_sMethod) ; == Parameter: Klassen-Array, Methode als String Local $aMethods = $_aClass[1] ; == das Methoden-Array zum Bearbeiten aus dem Klassen-Array auslesen $aMethods[0] += 1 ; == Anzahl Methoden um 1 erhöhen ReDim $aMethods[$aMethods[0]+1] ; == Array vergrößern $aMethods[$aMethods[0]] = $_sMethod ; == Methode eintragen $_aClass[1] = $aMethods ; == bearbeitetes Methoden-Array zurückschreiben in Klassen-Array EndFunc ; == nun weisen wir mit dieser Funktion die erstellten Methoden der Klasse "Programmierer" zu _BAO_Class_MethodSet($Programmierer, 'DrinkCoffee') _BAO_Class_MethodSet($Programmierer, 'DoSomething') ;==================================================================================================== ; PROPERTIES ;==================================================================================================== ; == Objekte haben neben den Methoden auch Eigenschaften (Properties) ; == Der Unterschied sollte klar sein: Methoden sind ausführbare Funktionen, Properties sind Werte die gelesen/geschrieben werden können ; == Nun wollen wir für unsere Klasse "Programmierer" allgemeingültige Eigenschaften setzen, wahlweise gleich mit Wertzuweisung Func _BAO_Class_PropSet(ByRef $_aClass, $_sProp, $_vProp='') ; == Parameter: Klassen-Array, Eigenschaft als String, [optional] Wert der Eigenschaft Local $aProps = $_aClass[2] ; == das Properties-Array zum Bearbeiten aus dem Klassen-Array auslesen If $aProps[0][0] > 0 Then ; == suchen ob Property vorhanden ==> dann aktualisieren For $i = 1 To $aProps[0][0] If $aProps[$i][0] = $_sProp Then $aProps[$i][1] = $_vProp $_aClass[2] = $aProps Return EndIf Next EndIf $aProps[0][0] += 1 ; == Anzahl Properties um 1 erhöhen ReDim $aProps[$aProps[0][0]+1][2] ; == Array vergrößern $aProps[$aProps[0][0]][0] = $_sProp ; == Eigenschaft eintragen $aProps[$aProps[0][0]][1] = $_vProp ; == Wert eintragen $_aClass[2] = $aProps ; == bearbeitetes Properties-Array zurückschreiben in Klassen-Array EndFunc ; == Als Eigenschaften der Klasse Programmierer legen wir jetzt fest: _BAO_Class_PropSet($Programmierer, 'Arbeitsintensität', 'hoch') _BAO_Class_PropSet($Programmierer, 'Kaffee-Konsum', 'extrem') ;==================================================================================================== ; KLASSENOBJEKT ;==================================================================================================== ; == jetzt erstellen wir ein Klassenobjekt, also einen Programmierer, der die Eigenschaften der Klasse "Programmierer" besitzt Func _BAO_Class_ObjCreate(ByRef $_aClass, $_sName) ; == Parameter: Klassen-Array, Name des Klassen-Objektes als String Local $aClassObj_Methods[1] = [0] ; == Array zur Aufnahme der Methoden erstellen mit Anzahl der akt. Methoden als erstem Element Local $aClassObj_Props[1][2] = [[0]] ; == 2D-Array zur Aufnahme der Properties erstellen mit Anzahl der akt. Properties als erstem Element, [['property','value']] Local $objClass[4] = [$_sName, $_aClass[0], $aClassObj_Methods, $aClassObj_Props] ; == [Objektname, Klassenname, Array Objekt-Methoden, Array Objekt-Properties] Local $aMembers = $_aClass[3] ; == neues KlassenObjekt unter Members in der Klasse registrieren $aMembers[0] += 1 ReDim $aMembers[$aMembers[0]+1] $aMembers[$aMembers[0]] = $_sName $_aClass[3] = $aMembers Return $objClass EndFunc Global $Klaus = _BAO_Class_ObjCreate($Programmierer, 'Klaus') Global $Peter = _BAO_Class_ObjCreate($Programmierer, 'Peter') ; == Klaus und Peter sind jetzt "Objekte" mit den ; == Lokalen Eigenschaften: "name" und "class" und den ; == Globalen Methoden der Klasse: "DrinkCoffee" und "DoSomething" ;==================================================================================================== ; Wir wollen natürlich jetzt auch für das einzelne Klassenobjekt individuelle Methoden und Properties setzen können Func _BAO_Class_ObjMethodSet(ByRef $_objClass, $_sMethod) ; == Parameter: Klassen-Objekt, Methode als String Local $aMethods = $_objClass[2] ; == das Methoden-Array zum Bearbeiten aus dem KlassenObjekt-Array auslesen $aMethods[0] += 1 ; == Anzahl Methoden um 1 erhöhen ReDim $aMethods[$aMethods[0]+1] ; == Array vergrößern $aMethods[$aMethods[0]] = $_sMethod ; == Methode eintragen $_objClass[2] = $aMethods ; == bearbeitetes Methoden-Array zurückschreiben in KlassenObjekt-Array EndFunc Func _BAO_Class_ObjPropSet(ByRef $_objClass, $_sProp, $_vProp='') ; == Parameter: KlassenObjekt, Eigenschaft als String, [optional] Wert der Eigenschaft Local $aProps = $_objClass[3] ; == das Properties-Array zum Bearbeiten aus dem KlassenObjekt-Array auslesen If $aProps[0][0] > 0 Then ; == suchen ob Property vorhanden ==> dann aktualisieren For $i = 1 To $aProps[0][0] If $aProps[$i][0] = $_sProp Then $aProps[$i][1] = $_vProp $_objClass[3] = $aProps Return EndIf Next EndIf $aProps[0][0] += 1 ; == Anzahl Properties um 1 erhöhen ReDim $aProps[$aProps[0][0]+1][2] ; == Array vergrößern $aProps[$aProps[0][0]][0] = $_sProp ; == Eigenschaft eintragen $aProps[$aProps[0][0]][1] = $_vProp ; == Wert eintragen $_objClass[3] = $aProps ; == bearbeitetes Properties-Array zurückschreiben in KlassenObjekt-Array EndFunc ; == Wir erstellen nun eine Methode, die nur einer unserer Programmierer als Lokale Methode zugewiesen bekommt Func JustABreake($_self) ConsoleWrite('-> Anordnung von: ' & _BAO_Class_ObjGet($_self, 'name') & @CRLF) ConsoleWrite('!> Jetzt ist PAUSE!' & @CRLF) EndFunc ; == Diese Methode darf nur Klaus ausführen _BAO_Class_ObjMethodSet($Klaus, 'JustABreake') ; == Und nun weisen wir den beiden noch ein paar individuelle Eigenschaften zu _BAO_Class_ObjPropSet($Klaus, 'Position', 'Chef') _BAO_Class_ObjPropSet($Klaus, 'Gehalt', 4500) _BAO_Class_ObjPropSet($Peter, 'Hobby', 'Nerd') _BAO_Class_ObjPropSet($Peter, 'Freundin', 'keine') ;==================================================================================================== ; == Wäre natürlich schick, wenn man diese Informationen abfragen kann, also brauchen wir eine Funktion dafür ; == Wobei wir jetzt aufpassen müssen, da es sowohl Lokale (nur für das einzeln Klassenobjekt gültige) als auch Globale (für alle Objekte der Klasse gültige) Eigenschaften und Methoden geben kann. ; == Priorität haben also Lokale Einträge, sollte dort nichts gefunden werden, wird auf Globale Einträge geprüft. ; == Parameter $_sWhat: ; == "about" gibt alle vorhandenen Informationen zum KlassenObjekt aus als 2D-Array: [[name], [class], [Lokale_Meth,..,..], [Globale_Meth,..,..], [Lokale_Props,..,..], [Globale_Props,..,..]] ; == "count" gibt die Anzahl der Mitglieder der Klasse zurück ; == "members" gibt ein Array mit den Mitgliedern der Klasse zurück ; == "name" gibt den Name des Klassenobjektes zurück ; == "class" gibt den Name der Klasse zurück ; == "methods_l" gibt ein Array aller Lokalen Methoden zurück ; == "methods_g" gibt ein Array aller Globalen Methoden zurück ; == "props_l" gibt ein 2D-Array aller Lokalen Properties zurück ; == "props_g" gibt ein 2D-Array aller Globalen Properties zurück ; == alles_andere Abfrage bezieht sich auf eine einzelne Property Func _BAO_Class_ObjGet($_objClass, $_sWhat, $_sAlternative=-1) ; == Parameter: Klassen-Objekt, Abfragebegriff als String, "$_sAlternative": bei Abfrage einer Propertie - wenn nicht gefunden wird dieser Alternativwert zurückgegeben (Standard: -1) Local $aClass = Execute('$' & Execute('$_objClass[1]')); == Zugriff auf das Klassenarray über den im Klassenobjekt hinterlegten Klassennamen [name, Array-Meth, Arr-Props, Array-Member] Local $vRet, $aProps, $fFound = False, $aAbout[6][2], $aTmp Switch $_sWhat ; == was wird abgefragt Case 'about' ; == Alle Informationen zum KlassenObjekt abfragen $aAbout[0][0] = $_objClass[0] ; == Objekt-Name $aAbout[1][0] = $_objClass[1] ; == Klassen-Name $aTmp = $_objClass[2] ; == Lokale Methoden If $aTmp[0] > 0 Then If UBound($aAbout,2) < $aTmp[0] Then ReDim $aAbout[6][$aTmp[0]] For $i = 1 To $aTmp[0] $aAbout[2][$i-1] = $aTmp[$i] Next EndIf $aTmp = $aClass[1] ; == Globale Methoden If $aTmp[0] > 0 Then If UBound($aAbout,2) < $aTmp[0] Then ReDim $aAbout[6][$aTmp[0]] For $i = 1 To $aTmp[0] $aAbout[3][$i-1] = $aTmp[$i] Next EndIf $aTmp = $_objClass[3] ; == Lokale Properties If $aTmp[0][0] > 0 Then If UBound($aAbout,2) < $aTmp[0][0] Then ReDim $aAbout[6][$aTmp[0][0]] For $i = 1 To $aTmp[0][0] $aAbout[4][$i-1] = $aTmp[$i][0] Next EndIf $aTmp = $aClass[2] ; == Globale Properties If $aTmp[0][0] > 0 Then If UBound($aAbout,2) < $aTmp[0][0] Then ReDim $aAbout[6][$aTmp[0][0]] For $i = 1 To $aTmp[0][0] $aAbout[5][$i-1] = $aTmp[$i][0] Next EndIf $vRet = $aAbout Case 'count' ; == Anzahl der Mitglieder der Klasse ausgeben $aTmp = $aClass[3] $vRet = $aTmp[0] Case 'members' ; == Mitglieder der Klasse ausgeben (Array) $aTmp = $aClass[3] $vRet = $aTmp Case 'name' ; == Name des KlassenObjektes ausgeben $vRet = $_objClass[0] Case 'class' ; == Name der Klasse ausgeben $vRet = $_objClass[1] Case 'methods_g' ; == das Methoden-Array aus dem Klassen-Array auslesen $vRet = $aClass[1] Case 'props_g' ; == das Properties-Array aus dem Klassen-Array auslesen $vRet = $aClass[2] Case 'methods_l' ; == das Methoden-Array aus dem KlassenObjekt-Array auslesen $vRet = $_objClass[2] Case 'props_l' ; == das Properties-Array aus dem KlassenObjekt-Array auslesen $vRet = $_objClass[3] Case Else ; == alles andere ist eine Abfrage zu einer einzelnen Eigenschaft $aProps = $_objClass[3] ; == Priorität beachten, zuerst lokal abfragen If $aProps[0][0] > 0 Then For $i = 1 To $aProps[0][0] If $aProps[$i][0] = $_sWhat Then $vRet = $aProps[$i][1] $fFound = True ExitLoop EndIf Next EndIf If Not $fFound Then $aProps = $aClass[2] ; == danach global abfragen If $aProps[0][0] > 0 Then For $i = 1 To $aProps[0][0] If $aProps[$i][0] = $_sWhat Then $vRet = $aProps[$i][1] $fFound = True ExitLoop EndIf Next EndIf If Not $fFound Then $vRet = $_sAlternative ; == abgefragte Property gibt es nicht EndIf EndSwitch Return $vRet EndFunc ; == Dann lassen wir uns doch mal die Anzahl der Mitglieder der Klasse von Klaus (also "Programmierer") ausgeben ; == Wobei wir hier direkt das KlassenObjekt (also Klaus oder Peter) zur Abfrage verwenden ConsoleWrite('Anzahl Mitglieder der Klasse "' & _BAO_Class_ObjGet($Klaus, 'class') & '": ' & _BAO_Class_ObjGet($Klaus, 'count') & @CRLF) ; == das stimmt ; == und nun wollen wir alle Mitglieder der Klasse auslesen, laut Definition erhalten wir ein Array $aMembers = _BAO_Class_ObjGet($Klaus, 'members') If $aMembers[0] > 0 Then ConsoleWrite('Mitglieder der Klasse "' & _BAO_Class_ObjGet($Klaus, 'class') & '": ' & @CRLF) For $i = 1 To $aMembers[0] ConsoleWrite(@TAB & $aMembers[$i] & @CRLF) Next EndIf ; == Nun schauen wir uns mal zuerst die Übersicht zu Klaus und Peter an $aAbout = _BAO_Class_ObjGet($Klaus, 'about') _ArrayDisplay($aAbout) $aAbout = _BAO_Class_ObjGet($Peter, 'about') _ArrayDisplay($aAbout) ; == Jetzt prüfen wir mal, ob die Zuordnung der lokalen und globalen Properties stimmt. ; == 'Kaffee-Konsum' ist Global und muss bei beiden vorhanden sein: ConsoleWrite('Kaffee-Konsum von ' & _BAO_Class_ObjGet($Klaus, 'name') & ': ' & _BAO_Class_ObjGet($Klaus, 'Kaffee-Konsum') & @CRLF) ConsoleWrite('Kaffee-Konsum von ' & _BAO_Class_ObjGet($Peter, 'name') & ': ' & _BAO_Class_ObjGet($Peter, 'Kaffee-Konsum') & @CRLF) ; == OK, das passt schon mal ; == Nun fragen wir mal das Gehalt ab, dürfte ja nur bei Klaus vorhanden sein. Bei Peter muß der Standardwert (-1) zurückgegeben werden ConsoleWrite('Gehalt von ' & _BAO_Class_ObjGet($Klaus, 'name') & ': ' & _BAO_Class_ObjGet($Klaus, 'Gehalt') & @CRLF) ConsoleWrite('Gehalt von ' & _BAO_Class_ObjGet($Peter, 'name') & ': ' & _BAO_Class_ObjGet($Peter, 'Gehalt') & @CRLF) ; == Und auch das tut, was es soll. ; == noch für Hobby, das nur bei Peter sein darf ConsoleWrite('Hobby von ' & _BAO_Class_ObjGet($Klaus, 'name') & ': ' & _BAO_Class_ObjGet($Klaus, 'Hobby') & @CRLF) ConsoleWrite('Hobby von ' & _BAO_Class_ObjGet($Peter, 'name') & ': ' & _BAO_Class_ObjGet($Peter, 'Hobby') & @CRLF) ; == Auch, wie gewünscht. ; == Jetzt wollen wir mal eine Property ändern _BAO_Class_ObjPropSet($Peter, 'Hobby', 'Schachspiel') ConsoleWrite('Hobby von ' & _BAO_Class_ObjGet($Peter, 'name') & ': ' & _BAO_Class_ObjGet($Peter, 'Hobby') & @CRLF) ; == auch das ist OK ; == Nun noch mal alle Lokalen Properties mit Werten von Klaus und Peter jeweils auf einen Blick $aProps = _BAO_Class_ObjGet($Klaus, 'props_l') _ArrayDisplay($aProps) $aProps = _BAO_Class_ObjGet($Peter, 'props_l') _ArrayDisplay($aProps) ;==================================================================================================== ; Methoden aufrufen ; == Nun müssen wir nur noch die Methoden aufrufen und auch hierbei die Gültigkeit Lokaler und Globaler Methoden prüfen ; == Wenn die Methode mehrere Parameter erfordert, diese als Array übergeben; ein Einzelparameter braucht nicht in ein Array gepackt werden ; == als erster Parameter wird IMMER das Klassenobjekt selbst mit übergeben, somit kann in der Methode auf Properties dieses Objekts zugegriffen werden Func _BAO_Class_ObjMethodCall($_objClass, $_sMethod, $_vParam='') Local $aParam[1], $fFound = False If Not IsArray($_vParam) Then $aParam[0] = $_vParam Else $aParam = $_vParam EndIf Local $aMethods = $_objClass[2] ; == zuerst bei den Lokalen Methoden nachschauen If $aMethods[0] > 0 Then For $i = 1 To $aMethods[0] If $aMethods[$i] = $_sMethod Then $fFound = True ExitLoop EndIf Next EndIf If Not $fFound Then ; == dann bei den Globalen Local $aClass = Execute('$' & Execute('$_objClass[1]')) $aMethods = $aClass[1] If $aMethods[0] > 0 Then For $i = 1 To $aMethods[0] If $aMethods[$i] = $_sMethod Then $fFound = True ExitLoop EndIf Next EndIf EndIf If Not $fFound Then Return -1 ; == Aufruf enthält keine gültige Methode If $_vParam = '' Then Return Call($_sMethod, $_objClass) ; == evtl. Rückgabewert der Funktion wird ausgegeben Else Return Call($_sMethod, $_objClass, $aParam) ; == evtl. Rückgabewert der Funktion wird ausgegeben EndIf EndFunc ; == Also jetzt das Wichtigste im Programmierer-Alltag: Kaffee Trinken :D ConsoleWrite(@CRLF & 'Klaus soll Kaffee trinken:' & @CRLF) _BAO_Class_ObjMethodCall($Klaus, 'DrinkCoffee') ; == Na, das klappt doch prima ; == Und nun Arbeiten, am Besten wir sagen es ihm 2-mal. ;-) ConsoleWrite(@CRLF & 'Klaus soll Arbeiten:' & @CRLF) _BAO_Class_ObjMethodCall($Klaus, 'DoSomething') _BAO_Class_ObjMethodCall($Klaus, 'DoSomething') ; == Tja, so reagieren die Jungs. ; == Wir hatten ja eine Lokale Methode für Klaus erstellt, das wollen wir nun testen ConsoleWrite(@CRLF & 'Klaus darf Pause ansagen:' & @CRLF) _BAO_Class_ObjMethodCall($Klaus, 'JustABreake') ; == Das funktioniert, wie erwartet. ; == Nun wollen wir testen, ob Peter darauf Zugriff hat. Das darf er ja nicht. Der Aufruf muß in diesem Fall "-1" zurückgeben. ConsoleWrite(@CRLF & 'Peter versucht eine Pause anzusagen:' & @CRLF) ConsoleWrite( _BAO_Class_ObjMethodCall($Peter, 'JustABreake') & @CRLF) ; == Und auch das klappt prima. ;==================================================================================================== ; VERERBUNG ;==================================================================================================== ; == Bis hierher waren das mehr oder weniger parametrisierte Funktionsaufrufe. Allerdings übersichtlicher, als wenn man nur die Funktionen ohne das Objekt-Modell nutzt. ; == Ein Wesenspunkt von Objekten ist die Vererbung. D.h., wenn ich ein Objekt als Abkömmling eines existierenden Objekts erstelle, besitzt dieses von vornherein dieselben ; == Methoden und Eigenschaften, wie das "Elternteil". ; == Wir haben z.Zt. eine Klasse "Programmierer" ; == Methoden: "DrinkCoffee" und "DoSomething" ; == Properties: "Arbeitsintensität" und "Kaffee-Konsum" ; == Jetzt erstellen wir eine neue Klasse "Codierer". Bei der Erstellung geben wir als Index die Klasse an, von der geerbt werden soll. Global $Codierer = _BAO_Class_Create('Codierer', 'Programmierer') ; == Wir erstellen gleich ein Objekt dieser Klasse und testen, ob es auf die ererbten Methoden zugreifen kann Global $Maria = _BAO_Class_ObjCreate($Codierer, 'Maria') ConsoleWrite(@CRLF & 'Maria soll Kaffee trinken:' & @CRLF) _BAO_Class_ObjMethodCall($Maria, 'DrinkCoffee') ConsoleWrite(@CRLF & 'Maria soll arbeiten:' & @CRLF) _BAO_Class_ObjMethodCall($Maria, 'DoSomething') ; == Das klappt, Maria als Mitglied der Klasse "Codierer" hat die Methoden von "Programmierer" geerbt ; == Nun noch die Prperties überprüfen $aProps = _BAO_Class_ObjGet($Maria, 'props_g') _ArrayDisplay($aProps, 'Props Maria') ; == Auch hier sind alle Eigenschaften vorhanden