Deklaration einer Methode

Syntax
METHOD (* optional_begin *) PUBLIC|PROTECTED|PRIVATE|INTERNAL FINAL|ABSTRACT OVERRIDE (* optional_end *) name_1 (* optional_begin *) : type (* optional_end *)
 
(* optional: declaration of variables/instances *)
 
(* optional: body of method *)
 
END_METHOD

Bedeutung

Deklaration einer bzw. mehrerer →Methoden (ein Feature der →objektorientierte Programmierung) , wobei name_1 ein →IEC-Bezeichner sein muss
Die Deklaration mehrerer solcher Abschnitte ist zulässig. Die Deklaration ist innerhalb der Deklaration eines →Funktionsbausteins möglich. Eine eingeschränkte Deklaration einer Methode ist als →Methoden-Prototypen bei einem →Interface möglich (siehe "Deklaration eines Interfaces mit Methoden-Prototypen" für diese Einschränkungen).

Beachten Sie:

Mögliche Schlüsselwörter für eine Methode

Mit Hilfe eines optionalen Schlüsselworts (= Modifizierer) definieren Sie, wo die Methode sichtbar ist:

Modifizierer

Bedeutung

PUBLIC

Öffentlicher Aufruf : Die Methode kann von überall aufgerufen werden.

PROTECTED (oder keiner)

Geschützter Aufruf (Standard) : Die Methode kann von innerhalb des Funktionsbausteins aufgerufen werden, in der sie definiert ist. Zusätzlich kann sie in abgeleiteten Funktionsbausteinen aufgerufen werden.

Falls keine abgeleitete Funktionsbausteine vorhanden sind, hat PROTECTED die gleiche Bedeutung wie PRIVATE .

PRIVATE

Privater Aufruf : Die Methode kann nur von innerhalb des Funktionsbaustein aufgerufen werden, in der sie definiert ist.

INTERNAL

Interner Aufruf : Die Methode kann nur von innerhalb des gleichen →Namespaces aufgerufen werden.

Zusätzlich können Sie diese Schlüsselwörter angeben:

FINAL

Die aktuelle Methode kann nicht ersetzt, d.h. überschrieben, werden.

Verwenden Sie FINAL, falls die aktuelle Methode in keinem der abgeleiteten Funktionsbausteine überschreibbar sein soll ( siehe das folgende Beispiel 5) . FINAL kann nicht gemeinsam mit ABSTRACT verwendet werden.

ABSTRACT

Die aktuelle Methode ist eine abstrakte Methode.

Verwenden Sie ABSTRACT, falls die aktuelle Methode in einem abgeleiteten Funktionsbaustein implementiert werden soll . Der Funktionsbaustein, in dem die abstrakte Methode deklariert ist, muss ein abstrakter Funktionsbaustein sein (= ein Funktionsbaustein mit dem Schlüsselwort ABSTRACT ; siehe das folgende Beispiel 4) . Weitere Hinweise zur Verwendung von ABSTRACT:

  • ABSTRACT darf nur für Methoden eines abstrakten Funktionsbausteins verwendet werden .

  • ABSTRACT darf nicht gemeinsam mit OVERRIDE verwendet werden.

  • Ein abstrakte Methode darf keine Anweisungen (keinen Body) enthalten.

Als Folge müssen alle abstrakten Methoden des abstrakten Funktionsbausteins in einem nicht-abstrakten Funktionsbaustein implementiert werden, der vom abstrakten Funktionsbaustein abgeleitet wird.

OVERRIDE

Die aktuelle Methode ersetzt, d.h. überschreibt, eine andere Methode mit dem gleichen Namen.

Verwenden Sie OVERRIDE, um eine Methode des Basis-Funktionsbaustein durch die aktuelle Methode im abgeleiteten Funktionsbaustein zu ersetzen (siehe Informationen zum Schlüsselwort EXTENDS unter "Deklaration eines Funktionsbausteins in ST" und das folgende Beispiel 3).
 Weitere Hinweise zur Verwendung von OVERRIDE:

  • Nur Methoden, die im abgeleiteten Funktionsbaustein sichtbar sind, können überschrieben werden. Das bedeutet, die Methode muss mit dem Schlüsselwort PUBLIC, PROTECTED oder INTERNAL im gleichen Namespace deklariert sein.

  • Die →Signaturen der a ktuellen Methode (im abgeleiteten Funktionsbaustein) und der überschriebenen Methode (im Basis-Funktionsbaustein) müssen übereinstimmen. Das bedeutet, dass die Namen der Methoden und die Reihenfolge aller ihrer Parameter (Eingänge, Ausgänge, Ein-/Ausgangsvariablen und Ergebnistyp) übereinstimmen muss.

  • Die Schlüsselwörter der aktuellen Methode und der überschriebenen Methode müssen ebenfalls übereinstimmen. Ausnahme: Bei der aktuellen Methode darf das Schlüsselwort FINAL angegeben werden.

  • ABSTRACT darf nicht gemeinsam mit OVERRIDE verwendet werden.


Der Datentyp : data-type ist optional, allerdings zwingend erforderlich, falls ein Ergebniswert innerhalb der Methode zugewiesen wird (siehe Methode UP im folgenden Beispiel: Zuweisung UP:= CV; ) oder die Methode als Operand zu verwenden ist.
 Informieren Sie sich unter "Unterstützte Datentypen (in ST)", welche Datentypen Sie für den Ergebniswert angeben können.

Abweichung von IEC-Norm

Bei logi.CAD 3 muss der Name einer Methode im gleichen →Gültigkeitsbereich eindeutig sein. Dies steht im Gegensatz zur →IEC-Norm, in der die →Signatur zum eindeutigen Identifizieren einer Methode verwendet wird .
Gut zu wissen

images/s/b2ic8e/9012/1ca6q62/_/images/icons/emoticons/lightbulb.svg Eine Methode verhält sich wie eine →Funktion.

In einer Methode dürfen Sie die folgenden Sprachelemente für ST verwenden:

Die Verwendung dieser Sprachelemente ermöglicht wiederum eine Verwendung von weiteren Elementen (z.B. Deklaration von STRING-Variablen im Abschnitt VAR ... END_VAR ). Dieses Elemente sind in der obigen Liste nicht angeführt.

Beispiel 1: Funktionsbaustein mit 2 Methoden zum Hochzählen
FUNCTION_BLOCK CounterWithMethod
VAR
CV: UINT; // Current value of counter
Max: UINT:= 1000;
END_VAR
 
METHOD PUBLIC UP: UINT // Method for count up by inc
VAR_INPUT INC: UINT; END_VAR // Increment
VAR_OUTPUT QU: BOOL; END_VAR // Upper limit detection
 
IF CV <= Max - INC // Count up of current value
THEN CV:= CV + INC;
QU:= FALSE; // Upper limit reached
ELSE QU:= TRUE;
END_IF;
UP:= CV; // Result of method
END_METHOD
 
METHOD PUBLIC UP5: UINT // Count up by 5
VAR_OUTPUT QU: BOOL; END_VAR // Upper limit reached
UP5:= THIS.UP(INC:= 5, QU => QU); // Internal method call: The method "UP" of the same function block is called.
END_METHOD
END_FUNCTION_BLOCK
Beispiel 2: Ein einfaches Beispiel mit Methoden
PROGRAM ExampleCircle
VAR
C1 : CIRCLE; // declaration of a CIRCLE instance
A : REAL; // circle area
D : REAL; // circle diameter
C : REAL; // circle circumference
END_VAR
// initialize the circle instance with a radius of 7.28
C1(R := 7.28);
A := C1.AREA(); // get the area
D := C1.DIAMETER(); // get the diameter
C := C1.CIRCUMFERENCE(); // get the circumference
END_PROGRAM
 
FUNCTION_BLOCK CIRCLE
VAR_INPUT
R : REAL;
END_VAR
VAR CONSTANT
PI : REAL := 3.1415927;
END_VAR
// calculate the circle area
METHOD PUBLIC AREA : REAL
AREA := PI * R * R;
END_METHOD
// calculate the diameter
METHOD PUBLIC DIAMETER : REAL
DIAMETER := 2 * R;
END_METHOD
// calculate the circumference
METHOD PUBLIC CIRCUMFERENCE : REAL
CIRCUMFERENCE := DIAMETER() * PI;
END_METHOD
END_FUNCTION_BLOCK
Beispiel 3: Methoden werden überschrieben.
FUNCTION_BLOCK LIGHTROOM (* der Basis-Funktionsbaustein "LIGHTROOM" *)
VAR
LIGHT: BOOL;
END_VAR
METHOD PUBLIC DAYTIME
LIGHT := FALSE;
END_METHOD
METHOD PUBLIC NIGHTTIME
LIGHT := TRUE;
END_METHOD
NIGHTTIME();
END_FUNCTION_BLOCK
FUNCTION_BLOCK LIGHT2ROOM EXTENDS LIGHTROOM (* der abgeleitete Funktionsbaustein "LIGHT2ROOM" *)
VAR
LIGHT2 : BOOL; // 2. Licht
END_VAR
METHOD PUBLIC OVERRIDE DAYTIME // Die Methode 'DAYTIME' wird überschrieben.
LIGHT := FALSE; // Zugriff auf Variable 'LIGHT' des Basis-Funktionsbausteins "LIGHTROOM"
LIGHT2 := FALSE; // eine zusätzliche Anweisung
END_METHOD
METHOD PUBLIC OVERRIDE NIGHTTIME // Die Methode 'NIGHTTIME' wird überschrieben.
LIGHT := TRUE; // Zugriff auf Variable 'LIGHT' des Basis-Funktionsbausteins "LIGHTROOM"
LIGHT2 := TRUE; // eine zusätzliche Anweisung
END_METHOD
super(); // Aufruf des Bodys des Basis-Funktionsbausteins "LIGHTROOM". Darin wird die Methode "NIGHTTIME" aufgerufen. Hier wird die Implementierung von "NIGHTTIME" vom (untersten) Basis-Funktionsbaustein "LIGHT3ROOM" verwendet.
super.NIGHTTIME(); // direkter Aufruf der Methode "NIGHTTIME" vom Basis-Funktionsbaustein "LIGHTROOM", wobei "LIGHT" auf "TRUE" gesetzt wird.
END_FUNCTION_BLOCK
 
FUNCTION_BLOCK LIGHT3ROOM EXTENDS LIGHT2ROOM (* der Funktionsbaustein "LIGHT3ROOM" - nun abgeleitet von "LIGHT2ROOM" *)
VAR
LIGHT3 : BOOL; // 3. Licht
END_VAR
METHOD PUBLIC OVERRIDE DAYTIME
LIGHT := FALSE; // Zugriff auf Variable 'LIGHT' des Basis-Funktionsbausteins "LIGHTROOM"
LIGHT2 := FALSE; // Zugriff auf Variable 'LIGHT2' des Basis-Funktionsbausteins "LIGHT2ROOM"
LIGHT3 := TRUE; // eine zusätzliche Anweisung
END_METHOD
METHOD PUBLIC OVERRIDE NIGHTTIME
LIGHT := TRUE; // Zugriff auf Variable 'LIGHT' des Basis-Funktionsbausteins "LIGHTROOM"
LIGHT2 := FALSE; // Zugriff auf Variable 'LIGHT2' des Basis-Funktionsbausteins "LIGHT2ROOM"
LIGHT3 := TRUE; // eine zusätzliche Anweisung
END_METHOD
super();
END_FUNCTION_BLOCK
Beispiel 4: Abstrakter Funktionsbaustein und abstrakte Methode
INTERFACE ISwitch
METHOD SwitchState
VAR_INPUT
STATE : BOOL;
END_VAR
END_METHOD
METHOD SwitchOff
END_METHOD
END_INTERFACE
FUNCTION_BLOCK ABSTRACT MySwitch IMPLEMENTS ISwitch (* der abstrakte Funktionsbaustein = der Basis-Funktionsbaustein *)
VAR
switchState : BOOL;
END_VAR
METHOD PUBLIC SwitchState
VAR_INPUT
STATE : BOOL;
END_VAR
switchState := STATE;
END_METHOD
METHOD PUBLIC ABSTRACT SwitchOff (* die abstrakte Methode *)
END_METHOD
END_FUNCTION_BLOCK
 
FUNCTION_BLOCK MySwitch2 EXTENDS MySwitch (* der nicht-abstrakte Funktionsbaustein = der abgeleitete Funktionsbaustein *)
METHOD PUBLIC OVERRIDE SwitchOff (* die Methode, die die abstrakte Methode des abstrakte Funktionsbausteins überschreibt *)
END_METHOD
END_FUNCTION_BLOCK
Beispiel 5: Funktionsbaustein und Methode mit
INTERFACE ISwitch
METHOD SwitchState
VAR_INPUT
STATE : BOOL;
END_VAR
END_METHOD
METHOD SwitchOff
END_METHOD
END_INTERFACE
FUNCTION_BLOCK FINAL MySwitch IMPLEMENTS ISwitch (* ein Funktionsbaustein, der aufgrund von "FINAL" NICHT als Basis-Funktionsbaustein verwendbar sein soll *)
VAR
switchState : BOOL;
END_VAR
METHOD PUBLIC SwitchState
VAR_INPUT
STATE : BOOL;
END_VAR
switchState := STATE;
END_METHOD
METHOD PUBLIC SwitchOff
END_METHOD
END_FUNCTION_BLOCK
FUNCTION_BLOCK MySwitch2 IMPLEMENTS ISwitch (* ein Basis-Funktionsbaustein *)
VAR
switchState : BOOL;
END_VAR
METHOD PUBLIC SwitchState
VAR_INPUT
STATE : BOOL;
END_VAR
switchState := STATE;
END_METHOD
METHOD PUBLIC FINAL SwitchOff (* eine Methode, die aufgrund von "FINAL" nicht überschreibbar sein sein soll *)
END_METHOD
END_FUNCTION_BLOCK
 
FUNCTION_BLOCK MySwitch3 EXTENDS MySwitch (* Ein Fehler wird für diesen abgeleiteten Funktionsbaustein gemeldet. Grund: "MySwitch" verwendet "FINAL" und darf nicht als Basis-Funktionsbaustein verwendet werden. *)
END_FUNCTION_BLOCK
 
FUNCTION_BLOCK MySwitch4 EXTENDS MySwitch2
METHOD PUBLIC OVERRIDE SwitchOff (* Ein Fehler wird für diese Methode gemeldet. Grund: Die Methode "SwitchOff" im Basis-Funktionsbaustein "MySwitch2" verwendete "FINAL" und darf nicht überschrieben werden. *)
END_METHOD
END_FUNCTION_BLOCK
Beispiel 6: Methoden mit unterschiedlicher Sichtbarkeit
FUNCTION_BLOCK ExampleVisibleMethods
METHOD PUBLIC m1 : INT // Die Methode kann von überall aufgerufen werden.
END_METHOD
METHOD PRIVATE m2 // Die Methode kann nur von innerhalb dieses Funktionsbaustein "ExampleVisibleMethods" aufgerufen werden.
END_METHOD
METHOD INTERNAL m3 // Die Methode kann innerhalb des gleichen Namespaces aufgerufen werden.
END_METHOD
METHOD PROTECTED m4 : BOOL // Die Methode kann von innerhalb dieses Funktionsbaustein aufgerufen werden. Zusätzlich kann sie von Funktionsbausteinen aufgerufen werden, die von "ExampleVisibleMethods" abgeleitet werden.
END_METHOD
END_FUNCTION_BLOCK

Weitere Beispiele für Methoden finden Sie unter "Beispiele für Verwendung von Interfaces und Variablen basierend auf diesen Interfaces (inkl. Zuweisungen)" und "Deklaration eines Funktionsbausteins in ST".