21.4 Methoden aufrufen 

Nach dem Abfragen und Setzen von Variablenwerten und Konstruktor-Aufrufen zum Erzeugen eines Objekts, ist das Aufrufen von Methoden per Reflection der letzte Schritt. Wenn zur Compile-Zeit der Name der Methode nicht feststeht, so lässt sich zur Laufzeit dennoch eine im Programm definierte Methode aufrufen, wenn ihr Name als Zeichenkette vorliegt. Für überladene Methoden wird zur Unterscheidung auch noch die Parameterliste als Class-Objekte benötigt.

Zunächst einmal gehen wir wieder von einem Class-Objekt aus, welches die Klasse des Objekts beschreibt, für das eine Objektmethode aufgerufen werden soll. Anschließend wird ein Method-Objekt als Beschreibung der gewünschten Methode benötigt; wir bekommen dies mit der Funktion getMethod() aus dem Class-Exemplar. getMethod() verlangt zwei Argumente: einen String mit dem Namen der Methode und ein Array von Class-Objekten. Jedes Element dieses Arrays entspricht einem Parametertyp aus der Signatur der Methode. Damit werden überladene Methoden unterschieden. Nachdem wir das beschreibende Method-Exemplar und die Parameterwerte für den Aufruf vorbereitet haben, wird die Zielmethode mittels invoke() ausgeführt. Auch invoke() hat zwei Argumente: ein Array mit Argumenten, die der aufgerufenen Methode übergeben werden, und eine Objektreferenz, welche als this-Referenz fungiert und zur Auflösung der dynamischen Bindung dient.

Listing 21.13   InvokeMethod.java

import java.awt.*;
import java.lang.reflect.*;

class InvokeMethod
{
  public static void main( String args[] ) throws Exception
  {
    Point p = new Point( 10, 0 );

    Method method = p.getClass().getMethod( "getX", null );
    String returnType = method.getReturnType().getName();

    System.out.print( "(" + returnType + ") " );

    Object returnValue = method.invoke( p, null );
    System.out.println( returnValue );
  }
}

Und die Ausgabe ist:

(double) 10.0

21.4.1 Statische Methoden aufrufen 

Wir wollen ein Beispiel programmieren, in dem die Klasse InvokeMain die main()-Funktion mit dem Parameter einer anderen Klasse HasMain aufruft.

Listing 21.14   InvokeMain.java

import java.lang.reflect.*;

public class InvokeMain
{
  public static void main( String args[] ) throws Exception
  {
    String nargs[] = new String [] { "-option", "Parameter" };
    
    Method methode = Class.forName( "HasMain" ).getMethod( "main" ,
            new Class[] {nargs.getClass()}) ;
    
    methode.invoke( null, new Object[]{nargs} );
  }
}

class HasMain
{
  public static void main( String args[] )
  {
    System.out.println( "Hier bin ich." );
  }
}

21.4.2 Dynamische Methodenaufrufe bei festen Methoden beschleunigen 

Werden über Reflection Methoden mit erst zur Laufzeit bestimmten Namen aufgerufen, so ist die Geschwindigkeit erbärmlich. Diese Aufrufe lassen sich prinzipbedingt auch durch einen JIT-Compiler nicht weiter beschleunigen. Wir müssen also nach einer Lösung suchen, mit der wir diese Art Aufruf beschleunigen können. Der richtige Weg hierbei ist, die Existenz der Methode meth() durch eine (abstrakte) Oberklasse dem Compiler bereits bekannt zu machen. Reflection wird dann nur noch benötigt, um eine Unterklasse mit gegebenem Namen zu laden und die normale, dynamische Methodenbindung erledigt den Rest – ganz ohne versteckte Schnüre, doppelte Böden oder Spiegel (Reflection).

Listing 21.15   DynamReflection.java

import java.lang.reflect.*;

public class DynamReflection
{
  public static void main( String args[] ) throws Exception
  {
    Class clazz = Class.forName( "DynamReflectionMethod" );

    Object o = clazz.newInstance();

    Method mtd = clazz.getMethod( "meth", new Class[]{} );
    mtd.invoke( o, new Object[]{} );
  }
}

Listing 21.16   DynamReflectionMethod.java

public class DynamReflectionMethod
{
  public void meth()
  {
    System.out.println("Bewusste Raucher trinken Filterkaffee" );
  }
}

DynamReflection ist nun die Hauptklasse, die DynamReflectionMethod erst dann lädt, wenn Class.forName() aufgerufen wird. Dann erzeugen wir ein Exemplar von DynamReflection Method mit der Funktion newInstance() auf dem Class-Objekt. Anschließend sucht getMethod() die Beschreibung der Methode meth() heraus. Mit invoke() rufen wir diese anschließend auf. Und genau hier ist der Geschwindigkeitsverlust. Wenn es uns gelingen würde, um das invoke() herumzukommen, wäre das schon ein großer Fortschritt. Dies schaffen wir, indem wir eine Oberklasse (oder eine Schnittstelle) für DynamReflection Method konstruieren, die dann genau diese Methode vorschreibt. Die Unterklasse wird dann eine Implementierung angeben.

Listing 21.17   DynamAbstract.java

import java.lang.reflect.*;

class DynamAbstract
{
  public static void main( String args[] ) throws Exception
  {
    Class clazz = Class.forName( "DynamBaseMethod" );

    DynamBase o = (DynamBase)clazz.newInstance();

    o.meth();
  }
}

Listing 21.18   DynamBase.java

public abstract class DynamBase
{
  abstract void meth();
}

Listing 21.19   DynamBaseMethod.java

public class DynamBaseMethod extends DynamBase
{
  public void meth()
  {
    System.out.println( "Bewusste Raucher trinken Filterkaffee" );
  }
}

DynamBase ist eine abstrakte Klasse, die zur Übersetzungszeit bekannt ist. Die virtuelle Maschine wird nun den Aufruf selbst nach den üblichen Regeln für die dynamische Bindung auflösen und umsetzen. Die Klasse DynamBaseMethod wird allerdings immer noch erst zur Laufzeit geladen. Wir verstecken hier sehr elegant den Aufwand. Wir haben die gleiche Funktionalität und Flexibilität wie im vorangegangenen Reflection-Beispiel, aber mit der höheren Geschwindigkeit eines konventionellen Methodenaufrufs ohne Reflection.