Implementieren von X++-Geltungsbereichen und Zugriffsbezeichnern

Abgeschlossen

Der Bereich ist der Bereich, in dem sich ein Element befindet oder in dem auf ein Element zugegriffen werden kann. X++-Variablen und ‑Methoden befinden sich in einem definierten Bereich. Der Bereich kann durch die Platzierung der Deklaration und die Verwendung von Zugriffsbezeichnern festgelegt werden.

Zugangsbezeichner sind [public], [protected] und [private].

• Öffentlich – Methoden, die als öffentlich deklariert sind, können von allen Stellen aus aufgerufen werden, an denen auf die Klasse zugegriffen werden kann. Darüber hinaus kann eine öffentliche Methode von einer Unterklasse außer Kraft gesetzt werden, wenn die Methode nicht als endgültig deklariert ist.
• Geschützt – Geschützte Methoden können in Unterklassen überschrieben werden. Als geschützt deklarierte Methoden können nur von folgenden Stellen aufgerufen werden:
  • Methoden in der Klasse.
  • Methoden in einer Unterklasse der Klasse, die die geschützte Methode enthält.
• Privat – Als privat deklarierte Methoden können nur von Methoden in der Klasse aufgerufen werden, in der die private Methode deklariert ist. Eine private Methode kann in einer Unterklasse nicht überschrieben werden. Wenn Sie eine neue Methode erstellen, ist das im Code-Editor angezeigte Zugriffsmethoden-Standardschlüsselwort „Privat“. Privat ist die konservativste Standardeinstellung, um maximale Sicherheit zu erzielen.

Intern

Intern ist ein Schlüsselwort in X++. Es hat die gleiche Semantik wie in C#; siehe intern (C#-Referenz).

Wenn Sie eine Klasse oder Methode als intern auswählen, kann auf sie nur innerhalb des Modells zugegriffen werden, in dem sie definiert ist.

internal class MyInternalClass
{
   internal void myInternalMethod()
   {
   }
}

Beachten Sie, dass Sie interne Methoden auch für öffentliche Klassen definieren können.

Instanzvariablen

Instanzvariablen haben einen großen Umfang und werden in X++ auch als „Klassenfelder“ bezeichnet. Diese Variablen werden in der Klassendeklaration deklariert und können von jeder Methode in der Klasse und den Unterklassen, die die Klasse erweitern, aufgerufen werden, wenn sie als öffentlich oder geschützt deklariert sind.

Lokale Variablen

Lokale Variablen haben einen kleinen Umfang. Diese Variablen sind in einer Methode definiert und nur in dieser Methode zugänglich.

Parameter sind eine Art lokale Variable, die in einer Methode definiert ist.

Um eine Variable aus einem Bereich in einem anderen Bereich zu verwenden, muss die Variable mithilfe von Parametern übergeben werden. Methoden können mehrere Parameter verwenden. Die Parameter werden wie lokale Variablen behandelt und mit dem Wert aus dem Parameter im Methodenaufruf initialisiert. Im folgenden Beispiel hat die Klassenmethode zwei Parameter, die method1 Zugriff auf vier Variablen ermöglichen. Es kann auf die Instanzvariablen a und b zugegriffen werden, und die Parameter x und y verhalten sich wie lokale Variablen. Durch die Verwendung von Parametern können diesen Parametern beim Aufruf der Methode Werte zugewiesen werden. Wenn Methode 1 mit dem Code Test.method1(a,b); aufgerufen wird, wird der Variablen x der Wert Auto zugewiesen. Der Variablen y wird der Wert 20 zugewiesen. Sie können anschließend die Werte der Parametervariablen verwenden, um den Instanzvariablen c und d Werte zuzuweisen.

class Test
{
   	 str a = "Car";
     int b = 20;
 	 str c;
 	 int d;

    void method1(str x, int y)
        {
          c = x;
          d = y;
        }
}

Beachten Sie, dass Sie beim Übergeben eines Werts über Parameter den Wert der ursprünglichen Variablen nicht standardmäßig ändern. Der Begriff hierfür ist „Aufruf nach Wert“ im Gegensatz zu „Aufruf nach Verweis“. Nur die lokale Variable wird geändert.

Beispiel

Im folgenden Beispiel hat Methode 2 die lokale Variable a mit dem Wert 5. Die erste info()-Anweisung zeigt den Wert von a an, d. h. 5. Sie ruft Methode 1 auf und übergibt den Wert ihrer lokalen Variablen, a. Methode 1 hat jetzt eine andere lokale Variable a mit dem Wert 5. Method1 erhöht anschließend den Wert um eins, wodurch a den Wert 2 erhält. Die info()-Anweisung zeigt anschließend den Wert 2 an. Der Code kehrt zu method2 zurück und führt die zweite info()-Anweisung aus und zeigt einen Wert von 5 an. Das Ergebnis liegt daran, dass der Umfang für die jeweiligen Methoden eindeutig ist, auch wenn der Variablenname identisch ist.

class infoValue
{
     void method1(int a)
     {
       a = 1;       
       a = a ++;
       info(int2str(a));
     }

	  void method2()
      {
        int a = 5;
        info(int2str(a));
        this.method1(a);
        info(int2str(a));
      }
}

Die folgende Abbildung zeigt, wie Info in der Benutzeroberfläche angezeigt wird.