Java aufrufen

Für den Aufruf von Java™-Code bei der Generierung von Java aus EGL gibt es mehrere Möglichkeiten. Dieser Abschnitt behandelt einige der gängigsten Verfahren. Hierzu gehören unter anderem die Verwendung der Systemfunktionen in der JavaLib-Systembibliothek wie beispielsweise javaLib.invoke() sowie die Deklaration eines ExternalType-Abschnitts.

Voraussetzungen

Java-Klasse einmalig aufrufen

Falls Sie in einer Java-Klasse eine Methode nur ein einziges Mal verwenden müssen, können Sie die Systemfunktion javaLib.invoke nutzen.

Im folgenden Beispiel wird die Methode random aufgerufen. Diese Methode gehört zur Klasse java.lang.Math und gibt eine Zufallszahl zwischen 0 und 1 zurück. Im vorliegenden Fall ähnelt die Klasse einer EGL-Bibliothek und die Methode arbeitet wie eine Funktion in dieser Bibliothek.

Mit diesem Verfahren können ausschließlich als static definierte Methoden aufgerufen werden. Für den Java-Begriff 'static' gibt es keine Entsprechung in EGL. Im vorliegenden Kontext bedeutet er, dass die Methode jederzeit aufgerufen werden kann und vor ihrer Verwendung keine Initialisierung erforderlich ist.

  1. Deklarieren Sie in einer EGL-Funktion innerhalb eines Logikabschnitts alle Variablen, die übergeben werden müssen oder die einen Rückgabewert akzeptieren müssen:
    myNumber float;
  2. Rufen Sie die Methode mit der Systemfunktion javaLib.invoke() auf, wobei der Name der Klasse und die aufzurufende Methode als Parameter übergeben werden:
    myNumber = javaLib.invoke("java.lang.Math", "random");
  3. Anschließend können Sie die Ergebnises des Aufrufs verwenden:
    sysLib.writeStderr(strLib.formatNumber(myNumber));

Verwenden Sie zur Übergabe eines Parameters an die Methode den Parameter argument von javaLib.invoke().

Java-Klasse mehrfach aufrufen

Falls Sie Methoden in einer Java-Klasse mehrmals verwenden wollen oder falls die Methode, die Sie aufrufen wollen, nicht als 'static' definiert ist, sollten Sie einen ExternalType-Abschnitt erstellen. Dies ist nachfolgend unter 'ExternalType-Abschnitt für die Darstellung einer Klasse erstellen' beschrieben. Zur Kompatibilität mit migrierten Programmen und mit etwas weniger EGL-Code können Sie jedoch andere Funktionen in javaLib verwenden, um eine Klasse (selbst ihre nicht statischen Methoden) mehrmals zu initialisieren und zu verwenden.

Im folgenden Beispiel wird eine andere Klasse verwendet, die Zufallszahlen zurückgibt. Die Methode nextInt in der Klasse java.util.Random bietet ein alternatives Verfahren für die Rückgabe einer Zufallszahl. Da die Methode nicht als 'static' definiert ist, können Sie javaLib.invoke() nicht ohne Vorbereitung verwenden, um nextInt aufzurufen:
//Error! The method nextInt() is not static.
myInt int = javaLib.invoke("java.util.Random", "nextInt");
Sie müssen stattdessen zuerst die Klasse initialisieren und ihr mit javaLib.storeNew() in EGL eine Kennung zuordnen. Beachten Sie die Verwendung des Operators für die explizite Typumwandlung (AS) zum Konvertieren von Java-Typen in EGL-Typen:
javaLib.storeNew("myRandomGenerator" AS "objId:java", "java.util.Random");
Anschließend können Sie die Klasse wiederholt über javaLib.invoke verwenden:
myInt int = javaLib.invoke("myRandomGenerator" AS "objId:java", "nextInt");

In diesen Beispielen ist die Zeichenfolge myRandomGenerator eine Kennung, die die Klasse darstellt. Bei jeder Verwendung der Klasse teilen Sie EGL mit dem Code AS "objId:java" mit, dass diese Kennung nicht auf einen EGL-Abschnitt oder ein Zeichenfolgeliteral, sondern auf eine Java-Klasse verweist. Weitere Informationen finden Sie unter Operator 'as'. Zusätzliche Details über das Aufrufen von Java-Klassen und Methoden enthält der Abschnitt Java-Zugriffsfunktionen.

ExternalType-Abschnitt zur Darstellung einer Klasse erstellen

Falls Sie eine Klasse häufig verwenden wollen oder falls die Methode, die Sie verwenden wollen, nicht als 'static' definiert ist, können Sie einen EGL-ExternalType-Abschnitt erstellen. Dieser EGL-Abschnitt stellt eine Java-Klasse direkt dar. Nachdem Sie den ExternalType-Abschnitt definiert haben, können Sie auf seiner Grundlage Variablen erstellen und diese Variablen genauso wie die Namen von EGL-Bibliotheken verwenden.

Im folgenden Beispiel wird die Klasse java.util.Random verwendet. Diese Klasse enthält eine nicht statische Methode namens nextInt, die eine Zufallszahl zurückgibt. Im Zusammenhang mit der EGL-Programmierung ist diese Klasse mit einer Bibliothek und die Methoden mit Funktionen vergleichbar.

  1. Beginnen Sie die Definition des ExternalType-Abschnitts in einer EGL-Quellendatei damit, dass Sie als Name den Namen der Java-Klasse angeben, die Sie verwenden wollen.
    ExternalType Random type JavaObject
        {packageName = "java.util", 
        javaName = "Random"}
    //prototypes go here
    end
    Beachten Sie, dass der Name der Java-Klasse aus zwei Eigenschaften besteht:
    • packageName ist der Name des Pakets, in dem die Klasse enthalten ist. Die Funktionsweise von Java-Paketen und EGL-Paketen ist in vielerlei Hinsicht identisch.
    • javaName ist der Name der Java-Klasse selbst. Sie können als Namen für den ExternalType-Abschnitt auf Wunsch denselben Namen wie für die Klasse verwenden.
  2. Erstellen Sie innerhalb des ExternalType-Abschnitts so genannte Funktionsprototypen. Diese stellen die Methoden in der Klasse dar, die sie verwenden wollen:
    ExternalType Random type JavaObject
        {packageName = "java.util", 
        javaName = "Random"}
        function nextInt() returns(int);
    end
    Auch Funktionsprototypen in Java haben Ähnlichkeit mit Funktionsprototypen in EGL, z. B. solche in einem Schnittstellenabschnitt. Sie listen den Namen der Funktion oder Methode, ihre Argumente und ihre Rückgabewerte auf, besitzen jedoch keine interne Logik. Hier verknüpft ein Prototyp eine Funktion im ExternalType-Abschnitt mit einer Methode in der Java-Klasse.

    Sie müssen außerdem unbedingt darauf achten, dass Java-Typen zu kompatiblen EGL-Typen zugeordnet werden (und umgekehrt). Tabellen für die Zuordnung von EGL-Abschnitten und Java-Abschnitten sind unter EGL-Basiselemente zu Java zuordnen verfügbar.

  3. Der ExternalType-Abschnitt benötigt ebenfalls einen Konstruktor. Im Zusammenhang mit EGL ist ein Konstruktor eine Funktion, die ausgeführt wird, wenn eine neue, auf dem Abschnitt basierende Variable erstellt wird. Konstruktoren sind in EGL nicht besonders gängig. Weitere Informationen zu ihnen finden Sie unter new (Operator).
    ExternalType Random type JavaObject
        {packageName = "java.util", 
        javaName = "Random"}
        function nextInt() returns(int);
        constructor();
    end
  4. Um eine Variable auf der Basis eines ExternalType-Abschnitts zu erstellen, müssen Sie zunächst ihren Konstruktor mit dem Schlüsselwort new und dem Namen des Abschnitts aufrufen:
    myRandomGenerator Random = new Random();
    Der Code new Random() ist eigentlich ein Funktionsaufruf für den Funktionsprototyp constructor() in der Abschnittsdefinition, die wiederum auf den Konstruktor der Java-Klasse verweist.
  5. Verwenden Sie die Funktionen im ExternalType-Abschnitt genauso wie bei Verwendung einer EGL-Bibliothek:
    myInt int = myRandomGenerator.nextInt();
    sysLib.writeStderr(strLib.formatNumber(myInt));
Das folgende Beispiel zeigt ein vollständiges Programm, das einen ExternalType-Abschnitt wie oben beschrieben verwendet:
/*
Writes a random integer to the console
using an ExternalType part
*/
program ExternalTypeTest type BasicProgram

    function main()
        myRandomGenerator Random = new Random();
        myInt int = myRandomGenerator.nextInt();
        SysLib.writeStderr(StrLib.formatNumber(myInt));
    end
    
end

externalType Random type JavaObject 
    {packageName = "java.util", 
    javaName = "Random"}
    constructor();
    function nextInt() returns(int);
end

Weitere Details über den ExternalType-Abschnitt finden Sie unter ExternalType-Abschnitt.


Feedback