Teil #1
(Alle Beispiele sind für die AutoIt Version 3.3.12.0 geschrieben und laufen eventuell auf älteren Versionen nicht!)
+ ++ +++ ++++ +++++ ++++++ +++++++ ++++++++ +++++++++ ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
Teil #2
Teil #3
+ ++ +++ ++++ +++++ ++++++ +++++++ ++++++++ +++++++++ ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
Was ist OOP?
Normalerweise kennen wir als AutoIt Programmierer ausschließlich die prozedurale Programmierung mit normalen Variablen und Funktionen. Ein typisches AutoIt Skript ist eigentlich immer Prozedural aufgebaut. Jedoch existiert auch ein objektorientiertes Konzept welche in vielen anderen Programmiersprachen bereits nativ nutzbar ist. Das Konzept verfolgt eigentlich eine einfache Idee. Stellen wir uns einmal vor, dass wir einen Menschen programmieren wollten. Wir müssen diesen Menschen durch sein Aussehen und seinem Charakter (oder Verhalten) definieren. Dabei behalten wir im Hinterkopf, dass jeder Mensch individuell ist und deshalb nicht alle Eigenschaften oder Eigenarten auf jeden Menschen zutreffen. Diese sind also auf den individuellen Menschen bezogen. Bei der OOP ist dies genauso, wir haben ein Objekt welches wir durch Attribute (Eigenschaften) und Methoden (Verhalten) definieren können. Alle Attribute und Methoden beziehen sich dann auf dieses eine Objekt. Diese Grundidee verfolgt OOP. Wie wir dieses Konzept für die AutoIt Programmierung einsetzen können, möchte ich im folgendem erklären. Wer noch vorab weitere Informationen benötigt kann sich in der Wikipedia schlau machen: http://de.wikipedia.org/wiki/Objektori…_Programmierung
OOP und AutoIt:
AutoIt unterstützt nativ kein OOP, daher wurde 2010 die AutoItObject UDF ins Leben gerufen. Mithilfe dieser UDF wurde OOP in AutoIt nutzbar. Damit sind neue Möglichkeiten für uns AutoIt Programmierer eingeräumt. Es wird (und kann) ausschließlich nur mit dieser UDF im gesamten Tutorial gearbeitet, daher ist es empfehlenswert die AutoItObject UDF hier zu downloaden: http://www.autoitscript.com/forum/topic/11…toitobject-udf/
AutoItObject UDF
Die UDF liefert eine Hilfedatei sowie Beispiele und zwei DLLs mit. Im Grunde reicht nur die AutoItObject.au3 Datei aus um OO zu programmieren. Vorab muss stetig die UDF initialisiert werden, dass kann mit der Funktion _AutoItObject_Startup() erreicht werden. Zwar ist es nicht nötig die UDF wieder zu schließen, jedoch gehört dies zum guten Programmierstil und deswegen sollte die Funktion _AutoItObject_Shutdown() vor dem Programmende aufgerufen werden.
Für alle die für die UDF Syntax Highlights und Calltips für die UDF wünschen, ich habe ein kleines Präsent für euch:
calltips
_AutoItObject_AddDestructor ( ByRef $oObject, $sAutoItFunc ) Adds a destructor to an AutoIt-object
_AutoItObject_AddEnum ( ByRef $oObject, $sNextFunc, $sResetFunc [, $sSkipFunc = ""] ) Adds an Enum to an AutoIt-object
_AutoItObject_AddMethod ( ByRef $oObject, $sName, $sAutoItFunc [, $fPrivate = False] ) Adds a method to an AutoIt-object
_AutoItObject_AddProperty ( ByRef $oObject, $sName [, $iFlags = $ELSCOPE_PUBLIC [, $vData = ""]] ) Adds a property to an AutoIt-object
_AutoItObject_Class ( ) AutoItObject COM wrapper function
_AutoItObject_CLSIDFromString ( $sString ) Converts a string to a CLSID-Struct (GUID-Struct)
_AutoItObject_CoCreateInstance ( $rclsid, $pUnkOuter, $dwClsContext, $riid, ByRef $ppv ) Creates a single uninitialized object of the class associated with a specified CLSID
_AutoItObject_Create ( [$oParent = 0] ) Creates an AutoIt-object
_AutoItObject_DllOpen ( $sDll [, $sTag = "" [, $iFlag = 0]] ) Creates an object associated with specified dll
_AutoItObject_DllStructCreate ( $sTag [, $vParam = 0] ) Object wrapper for DllStructCreate and related functions
_AutoItObject_IDispatchToPtr ( ByRef $oIDispatch ) Returns pointer to AutoIt's object type
_AutoItObject_IUnknownAddRef ( $vUnknown ) Increments the refrence count of an IUnknown-Object
_AutoItObject_IUnknownRelease ( $vUnknown ) Decrements the refrence count of an IUnknown-Object
_AutoItObject_ObjCreate( $sID [, $sRefId = Default [, $tagInterface = Default]] ) Creates a reference to a COM object
_AutoItObject_ObjCreateEx ( $sModule, $sCLSID [, $sRefId = Default [, $tagInterface = Default [, $fWrapp = False]]] ) Creates a reference to a COM object
_AutoItObject_ObjectFromDtag ( $sFunctionPrefix, $dtagInterface [, $fNoUnknown = False] ) Creates custom object defined with "dtag" interface description string
_AutoItObject_PtrToIDispatch ( $pIDispatch ) Converts IDispatch pointer to AutoIt's object type
_AutoItObject_RegisterObject ( $vObject, $sID ) Registers the object to ROT
_AutoItObject_RemoveMember ( ByRef $oObject, $sMember ) Removes a property or a function from an AutoIt-object
_AutoItObject_Shutdown ( [$fFinal = False] ) frees the AutoItObject DLL
_AutoItObject_Startup ( [$fLoadDLL = False [, $sDll = "AutoitObject.dll"]] ) Initializes AutoItObject
_AutoItObject_UnregisterObject ( $iHandle ) Unregisters the object from ROT
_AutoItObject_VariantClear( $pvarg ) Clears the value of a variant
_AutoItObject_VariantCopy ( $pvargDest, $pvargSrc ) Copies a VARIANT to another
_AutoItObject_VariantFree ( $pvarg ) Frees a variant created by _AutoItObject_VariantSet
_AutoItObject_VariantInit ( $pvarg ) Initializes a variant
_AutoItObject_VariantRead ( $pVariant ) Reads the value of a VARIANT
_AutoItObject_VariantSet ( $pVar, $vVal [, $iSpecialType = 0] ) sets the value of a varaint or creates a new one.
_AutoItObject_WrapperAddMethod ( ByRef $oWrapper, $sReturnType, $sName, $sParamTypes, $ivtableIndex ) Adds additional methods to the Wrapper-Object, e.g if you want alternative parameter types
_AutoItObject_WrapperCreate ( $pUnknown, $tagInterface [, $fNoUnknown = False [, $fCallFree = False]] ) Creates an IDispatch-Object for COM-Interfaces normally not supporting it
syntax highlight
; AutoItObject UDF \
_autoitobject_adddestructor \
_autoitobject_addenum \
_autoitobject_addmethod \
_autoitobject_addproperty \
_autoitobject_class \
_autoitobject_clsidfromstring \
_autoitobject_cocreateinstance \
_autoitobject_create \
_autoitobject_dllopen \
_autoitobject_dllstructcreate \
_autoitobject_idispatchtoptr \
_autoitobject_iunknownaddref \
_autoitobject_iunknownrelease \
_autoitobject_objcreate \
_autoitobject_objcreateex \
_autoitobject_objectfromdtag \
_autoitobject_ptrtoidispatch \
_autoitobject_registerobject \
_autoitobject_removemember \
_autoitobject_shutdown \
_autoitobject_startup \
_autoitobject_unregisterobject \
_autoitobject_variantclear \
_autoitobject_variantcopy \
_autoitobject_variantfree \
_autoitobject_variantinit \
_autoitobject_variantread \
_autoitobject_variantset \
_autoitobject_wrapperaddmethod \
_autoitobject_wrappercreate
Hinweis: Die Referenz sollte im Verlauf dieses Tutorials parallel genutzt werden.
Objekte erstellen:
Uns stehen zwei Möglichkeiten zur Verfügung neue Objekte zu erstellen. Die erste Funktion die das bewerkstelligen kann nennt sich _AutoItObject_Create(), die zweite _AutoItObject_Class(). Im Grunde liefern beide Funktionen das gleiche Ergebnis, aber sind von der Verwendung her unterschiedlich. Dazu später mehr, vorab werden wir nur mit der _AutoItObject_Create() Funktion arbeiten.
Um also ein neues Objekt zu erstellen ist nur die Funktion _AutoItObject_Create() aufzurufen.
Spoiler anzeigen
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]#include <AutoItObject.au3>
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Startup()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Global $oObj = _AutoItObject_Create()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]ConsoleWrite(@CRLF & '! IsObj = ' & IsObj($oObj) & @CRLF & @CRLF)
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Shutdown()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit]Jedoch enthält das Objekt weder Attribute oder Methoden. Das können wir jedoch mit den Funktionen _AutoItObject_AddProperty() und _AutoItObject_AddMethod() sehr schnell ändern.
Attribute
Attribute sind die Eigenschaften eines Objektes. Diese sind im Grunde nichts anderes als Variablen die mit jedem X beliebigen Wert gefüllt werden können. Um einem Objekt neue Attribute zuzuordnen, kann die Funktion _AutoItObject_AddProperty() verwendet werden. Mithilfe des vierten Parameters kann dem Attribut direkt ein Wert zugewiesen werden:
Spoiler anzeigen
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]#include <AutoItObject.au3>
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Startup()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Global $oObj = _AutoItObject_Create()
_AutoItObject_AddProperty($oObj, 'x', Default, 1)
_AutoItObject_AddProperty($oObj, 'y')
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]$oObj.y = 7
ConsoleWrite(@CRLF & ' (' & $oObj.x & '|' & $oObj.y & ')' & @CRLF & @CRLF)
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Shutdown()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit]Selbst Arrays, weitere Objekte oder gar Funktionen können in den Attributen hinterlegt werden:
Spoiler anzeigen
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]#include <Array.au3>
#include <AutoItObject.au3>
_AutoItObject_Startup()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Global $aiArray[3][3], $hFunc
[/autoit] [autoit][/autoit] [autoit]Global $oTmp = _AutoItObject_Create()
_AutoItObject_AddProperty($oTmp, 'var')
Global $oObj = _AutoItObject_Create()
_AutoItObject_AddProperty($oObj, 'arr', Default, $aiArray)
_AutoItObject_AddProperty($oObj, 'obj', Default, $oTmp)
_AutoItObject_AddProperty($oObj, 'fnc', Default, _fnc)
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]$oObj.arr(1, 1) = 5
$oObj.obj.var = 321
$aiArray = $oObj.arr
$hFunc = $oObj.fnc
ConsoleWrite(@CRLF & ' ' & $oObj.obj.var & @CRLF & $hFunc() & @CRLF & '[1][1] = ' & $oObj.arr[1][1] & @CRLF & @CRLF)
_ArrayDisplay($aiArray)
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Shutdown()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Func _fnc()
Return '! Func'
EndFunc
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit]Methoden
Methoden sind nichts anderes als Funktionen. Deswegen werden die Methoden auch nur als normale Funktionen definiert. Das wichtige ist jedoch, dass bei jeder Methoden Funktion über den ersten Parameter eine Referenz des Objektes übergeben wird, von dem es aufgerufen wurde. Alles andere bleibt wie gewohnt. Um die Funktion als Methode für ein Objekt zu registrieren, ist die Funktion _AutoItObject_AddMethod() zu nutzen:
Spoiler anzeigen
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]#include <AutoItObject.au3>
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Startup()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Global $oObj = _AutoItObject_Create()
_AutoItObject_AddProperty($oObj, 'var')
_AutoItObject_AddMethod($oObj, 'fvar', '_Obj_Var')
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]$oObj.fvar('Set')
ConsoleWrite(@CRLF & '! var = ' & $oObj.fvar() & @CRLF)
$oObj.fvar = 'Set it too'
ConsoleWrite('! var = ' & $oObj.fvar & @CRLF & ' ' & $oObj.var & @CRLF & @CRLF)
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Shutdown()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Func _Obj_Var($oSelf, $vValue = Null)
If $vValue Then $oSelf.var = $vValue
Return $oSelf.var
EndFunc
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit]Zugriffsbeschränkungen
Es ist möglich Attribute und Methoden mit Zugriffsbeschränkungen zu belegen. Bei den Attributen gibt es drei, bei den Methode zwei mögliche Beschränkungen.
$ELSCOPE_PUBLIC (Attribut)
Das Attribut ist von außerhalb lesbar und veränderbar.
$ELSCOPE_READONLY (Attribut)
Das Attribut ist von außerhalb nur lesbar.
$ELSCOPE_PRIVATE (Attribut)
Das Attribut ist von außerhalb überhaupt nicht ansprechbar.
Diese Zugriffsbeschränkungen gelten nur, wenn man versucht auf das Attribut von außerhalb irgendwie zuzugreifen. Geschehen die Zugriffe direkt in eines der Methoden des entsprechenden Objektes gibt es keine Probleme. So können z.B. intern irgendwelche wichtigen Attribute angelegt werden ohne sich sorgen machen zu müssen dass sie außerhalb irgendwie manipuliert werden können. Es stellt eine Art Schutzmechanismus dar. Die Zugriffsberechtigungen können bei der Funktion _AutoItObject_AddProperty() im dritten Parameter übergeben werden.
Wird bei der _AutoItObject_AddMethod() Funktion der vierte Parameter auf True gesetzt, so kann die Methode außerhalb nicht aufgerufen werden. Andere Methoden im gleichen Objekt hingegen können diese Methode ohne weiteres benutzen. Wird der Parameter jedoch weggelassen oder auf False gesetzt, so kann die Methode außerhalb aufgerufen werden.
Klassen erstellen:
Eine Klasse beinhalten ausschließlich die Definition eines Objektes. Das Objekt selber wird bei einer Klasse nicht erstellt. Durch die Klassen ist es möglich ein Objekt nur einmal zu definieren, aber dafür beliebig oft das selbe Objekt zu erstellen. Um eine neue Klasse zu erstellen liefert uns die AutoItObject UDF die Funktion _AutoItObject_Class mit.
Spoiler anzeigen
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]#include <AutoItObject.au3>
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Startup()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Global $oOne = Class().Object
Global $oTwo = Class().Object
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]$oOne.fvar = 7
$oTwo.fvar = 9
ConsoleWrite(@CRLF & ' One = ' & $oOne.fvar & @CRLF & ' Two = ' & $oTwo.fvar & @CRLF & @CRLF)
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Shutdown()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Func Class()
Local $oClass = _AutoItObject_Class()
$oClass.AddProperty('var')
$oClass.AddMethod('fvar', '_Obj_Var')
Return $oClass
EndFunc
Func _Obj_Var($oSelf, $vValue = Null)
If $vValue Then $oSelf.var = $vValue
Return $oSelf.var
EndFunc
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit]Die Klasse sollte dabei in eine eigene Funktion ausgelegt werden da nach der Verwendung des Attribut .Object die gesamte Klasse gelöscht wird. Die bereits erlernten Funktionen müssen bei einer Klasse als Methoden genutzt werden. Im weiteren Verlauf des Tutorials werde ich nur noch ausschließlich mit Klasse arbeiten. Natürlich bleibt es jeden selber überlassen ob das Objekt direkt erstellt wird oder mit Klassen gearbeitet wird. Beides liefert (wie bereits erwähnt) das selbe Ergebnis.
Objekte Kopie / Referenz erzeugen:
Was genau ist nun eine Kopie und was nun eine Referenz bezogen auf OOP? Bei einer Kopie handelt es sich um ein komplett neues Objekt welche alle Attribute und Methoden eines anderen Objektes kopiert. Bei einer Referenz hingegen, zeigt diese Referenz auf ein bereits existierende Objekt und greift auf die fremden Attribute und Methoden zu. Doch alles der Reihe nach.
Kopie
Um ein Objekt vollständig zu kopieren benötigen wir unsere bekannte Funktion _AutoItObject_Create(). Geben wir dort als Parameter des zu kopierenden Objektes mit, erhalten wir eine vollständige Kopie des Objektes:
Spoiler anzeigen
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]#include <AutoItObject.au3>
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Startup()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Global $oOne = Class().Object
$oOne.fvar = 7
Global $oTwo = _AutoItObject_Create($oOne)
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]ConsoleWrite(@CRLF & ' One = ' & $oOne.fvar & @CRLF & ' Two = ' & $oTwo.fvar & @CRLF & @CRLF)
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Shutdown()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Func Class()
Local $oClass = _AutoItObject_Class()
$oClass.AddProperty('var')
$oClass.AddMethod('fvar', '_Obj_Var')
Return $oClass
EndFunc
Func _Obj_Var($oSelf, $vValue = Null)
If $vValue Then $oSelf.var = $vValue
Return $oSelf.var
EndFunc
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit]Referenz
Um eine Referenz zu einem Objekt zu erzeugen, müssen wir lediglich den = Operator verwenden. Bedenke jedoch, wir erstellen damit kein neues Objekt, sondern zeigen auf ein existierendes Objekt:
Spoiler anzeigen
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]#include <AutoItObject.au3>
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Startup()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Global $oOne = Class().Object
$oOne.fvar = 7
Global $oTwo = $oOne
$oTwo.fvar = 9
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]ConsoleWrite(@CRLF & ' One = ' & $oOne.fvar & @CRLF & ' Two = ' & $oTwo.fvar & @CRLF & @CRLF)
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Shutdown()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Func Class()
Local $oClass = _AutoItObject_Class()
$oClass.AddProperty('var')
$oClass.AddMethod('fvar', '_Obj_Var')
Return $oClass
EndFunc
Func _Obj_Var($oSelf, $vValue = Null)
If $vValue Then $oSelf.var = $vValue
Return $oSelf.var
EndFunc
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit]Konstruktor / Destruktor:
In der OOP gibt es die Möglichkeit einen Konstruktor und einen Destruktor anzugeben. Beides sind nur Methoden in eines Objektes die jedoch nicht irgendwann, sondern zu einem ganz bestimmten Zeitpunkt aufgerufen werden. Der Konstruktor wird aufgerufen wenn ein Objekt erstellt wird, der Destruktor wenn dieses Objekt gelöscht wird. Jedoch bietet die AutoItObject UDF nur die Möglichkeit einen Destruktor anzugeben. Jedoch können wir unseren Konstruktor auch mit einem einfachen Workaround selber erstellen.
Konstruktor
Wie bereits erwähnt können wir so nicht direkt einen Konstruktor angeben, wir können aber Code ausführen unmittelbar nach der Erstellung eines Objektes. Somit haben wir die Funktionsweise eines Konstruktors mithilfe eines Workarounds nachgebaut:
Spoiler anzeigen
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]#include <AutoItObject.au3>
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Startup()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Global $oObj = Obj()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]ConsoleWrite(@CRLF & ' var = ' & $oObj.fvar & @CRLF & @CRLF)
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Shutdown()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Func Obj()
Local $oClass = _AutoItObject_Class()
$oClass.AddProperty('var')
$oClass.AddMethod('fvar', '_Obj_Var')
Local $oObj = $oClass.Object
$oObj.fvar = 7
Return $oObj
EndFunc
Func _Obj_Var($oSelf, $vValue = Null)
If $vValue Then $oSelf.var = $vValue
Return $oSelf.var
EndFunc
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit]Destruktor
Um eine Methode als Destruktor für ein Objekt zu definieren, benötigen wir einfach die Funktion _AutoItObject_AddDestructor(). Wird nun das Objekt gelöscht, so wird die zugewiesene Methode aufgerufen. Wir können sogar mehrere Destruktors zuweisen, sie werden dann in der umgekehrten Reihenfolge aufgerufen, in der sie zugewiesen wurden:
Spoiler anzeigen
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]#include <AutoItObject.au3>
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Startup()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Global $oObj = Class().Object
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]$oObj = Null
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Shutdown()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Func Class()
Local $oClass = _AutoItObject_Class()
$oClass.AddDestructor('_Dest1')
$oClass.AddDestructor('_Dest2')
$oClass.AddDestructor('_Dest3')
Return $oClass
EndFunc
Func _Dest1($oSelf)
ConsoleWrite('Dest 1' & @CRLF)
EndFunc
Func _Dest2($oSelf)
ConsoleWrite('Dest 2' & @CRLF)
EndFunc
Func _Dest3($oSelf)
ConsoleWrite('Dest 3' & @CRLF)
EndFunc
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit]Die Destruktors werden jedoch nur aufgerufen, wenn dass Objekt „per Hand“ gelöscht wird.
Vererbung:
Klassen können beliebig erweitert werden. Dies ist z.B. hilfreich wenn man eine bestehende Klasse einfach erweitern möchte. Wir benötigen nur eine Kopie der Klasse die wir erweitern möchten:
Spoiler anzeigen
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]#include <AutoItObject.au3>
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Startup()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Global $oObj = ClassChild().Object
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]$oObj.a = 5
$oObj.b = 7
ConsoleWrite(@CRLF & ' a = ' & $oObj.a & @CRLF & ' b = ' & $oObj.b & @CRLF & @CRLF)
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Shutdown()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Func ClassParent()
$oClass = _AutoItObject_Class()
$oClass.AddProperty('a')
Return $oClass
EndFunc
Func ClassChild()
Local $oClass = ClassParent()
$oClass.AddProperty('b')
Return $oClass
EndFunc
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit]Auch Objekte zu erweitern ist kein Problem, dafür stehen uns ja die Funktionen _AutoItObject_Create(), _AutoItObject_AddProperty(), _AutoItObject_AddMethod() und _AutoItObject_AddDestructor() zur Verfügung. Zudem haben wir auch die Möglichkeit mit _AutoItObject_RemoveMember bereits existierende Attribute und Methoden von einem Objekt zu löschen. Für Klassen steht parallel die Methode .RemoveMember() zur Verfügung:
Spoiler anzeigen
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]#include <AutoItObject.au3>
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Startup()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Global $oObj = ClassChild().Object
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]$oObj.a = 5
$oObj.b = 7
ConsoleWrite(@CRLF & ' a = ' & $oObj.a & @CRLF & ' b = ' & $oObj.b & @CRLF & @CRLF)
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]_AutoItObject_Shutdown()
[/autoit] [autoit][/autoit] [autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Func ClassParent()
$oClass = _AutoItObject_Class()
$oClass.AddProperty('a')
Return $oClass
EndFunc
Func ClassChild()
Local $oClass = ClassParent()
$oClass.AddProperty('b')
$oClass.RemoveMember('a')
Return $oClass
EndFunc
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit]Vielleicht wunderst du dich jetzt warum AutoIt kein Fehler entgegen schmeißt. Da alle Objekte extern gehandhabt wird, weiß AutoIt beim Syntax Check nicht, ob das Attribut oder die Methode wirklich existiert. Stattdessen geben unzulässige Abrufe im besten Fall einfach einen Leerstring zurück.
Abschluss Teil 1:
OOP ist ein umfassendes Thema, deshalb sind mehrere Teile geplant welche immer das jeweilige Teilgebiet größtmöglich abdecken soll. In zukünftigen Teilen wird dann darauf eingegangen wie Objekte in DLLs angesprochen werden können. Doch zunächst möchte ich im nächsten Teil näher darauf eingehen wie sinnvolle Anwendungen / Spiele mit OOP realisiert werden können. Kritik, Anregungen und Wünsche sind gerne gesehen und willkommen!