Innerhalb eines Klassenkörpers können neben Feldern auch Methoden als Mitglieder der Klasse deklariert werden. Eine Methode beinhaltet ausführbaren Programmcode (Instruktionen der virtuellen Java-Maschine). Ein vereinfachter Aufbau einer Methodendeklaration kann wie folgt angegeben werden (die Bestandteile einer Methodendeklaration zu Generics und der throws-Klausel sollen in eigenen Abschnitten behandelt werden):

MethodenModifiers_opt ReturnTyp MethodenName(FormaleParameterListe_opt)
{
  Anweisung1;
  Anweisung2;
  ...
}

Eine Methodendeklaration besteht aus einem Methodenkopf und einem Methodenkörper. Der Methodenkopf kann mit Methodenmodifiers beginnen und der Methodenkörper fängt mit der öffnenden geschweiften Klammer "{" an und endet mit "}". Methodenmodifiers wie z.B. public und eine formale Parameterliste sind optional und müssen daher nicht zwingend in einer Methodendeklaration enthalten sein. Der Ergebnistyp, der vor dem eigentlichen Methodennamen steht, ist der Typ eines möglichen Rückgabewertes. Durch das Schlüsselwort void wird angezeigt, dass kein Wert zurückgegeben werden soll. Auf den Namen der Methode folgt direkt ein Klammerpaar "()", falls die Methode keine Parameter besitzt. Innerhalb des Klammerpaares können Parameter notiert werden. Die Angabe des Klammerpaars "()" ist zwingend und kennzeichnet die Methode als solche. Im Körper der Methode können einzelne Java-Anweisungen stehen, die jeweils durch ein Semikolon abgeschlossen werden.

Ebenso wie bei Feldern werden Methoden dadurch unterschieden, ob bei der Methodendeklaration der Modifier static verwendet wurde. Wird dieser verwendet wird die Methode als Klassenmethode (statische Methode) bezeichnet, andernfalls als Instanzmethode. Das anschließende Beispiel deklariert die Klassenmethode method1 und die Instanzmethode method2. Die beiden Methoden enthalten jeweils eine einzige Anweisung zur Ausgabe einer Zeichenkette.

/* MethodExample.java */

public class MethodExample {
  
  public static void method1() {
    System.out.println("Hello");
  }

  public void method2() {
    System.out.println("World!");
  }
}

Aufruf von Methoden

Es besteht ein Unterschied beim Aufruf von Klassenmethoden und Instanzmethoden. Ein Klassenmethode wird immer ohne eine Referenz auf ein bestimmtes Objekt aufgerufen. Der Aufruf einer Klassenmethode erfolgt ähnlich wie bei Klassenvariablen mit Hilfe der Punktnotation. Vor dem Zeichen "." wird der Name der Klasse notiert, welche die aufzurufende statische Methode deklariert. Nach dem Punkt folgt der Name der Klassenmethode.

Aufruf von Methoden (Punktnotation):

Bei Klassenmethoden:
    KlassenName.KlassenmethodenName
    
Bei Instanzmethoden:
    InstanzName.InstanzmethodenName

Der Aufruf einer Instanzmethode erfolgt ebenfalls mit Hilfe der Punktnotation. Im Gegensatz zum Aufruf von Klassenmethoden werden nicht-statische Methoden immer in Bezug auf eine bestimmte Instanz (Objekt) aufgerufen. Der Name des von einer Klasse erzeugten Objekts wird in diesem Fall vor dem Punkt angeordnet. Der Java-Quelltext MethodeExample2.java enthält die beiden Methoden method1 und method2. Der Aufruf der beiden Methoden erfolgt innerhalb der main-Methode.

/* MethodExample2.java */

public class MethodExample2 {
  
  public static void method1() {
    System.out.println("Hello");
  }

  public void method2() {
    System.out.println("World!");
  }
    
  public static void main(String[] args) {
    MethodExample2.method1();
    method1();
    
    MethodExample2 me2 = new MethodExample2();
    me2.method2();
  }
}

Das kurze Programm gibt zweimal die Zeichenkette "Hello" und einmal "World!" auf dem Bildschirm aus. Innerhalb der main-Methode wird zweimal die Klassenmethode method1 aufgerufen. Der erste Aufruf erfolgt unter Verwendung der Punktnotation. Der Aufruf der statischen Methode kann in diesem Fall auch ohne diese Notation erfolgen, indem lediglich method1(); verwendet wird. Dies ist möglich, da sich aufzurufende Klassenmethode und Aufruf innerhalb der selben Klasse befinden. Die Instanzmethode method2 wird aufgerufen, indem zunächst mit Hilfe des new-Operators ein Objekt der Klasse MethodExample2 erzeugt wird. Der gewählte Name der Instanz me2 wird nun im Rahmen der Punktnotation verwendet, um die Instanzmethode aufzurufen.

Rückgabewert

Innerhalb einer Methodendeklaration kann der Typ des Rückgabewertes der Methode angegeben werden (return type). Für die Angabe dieses Typs sind sowohl primitive Typen als auch Referenztypen (z.B. Klassentyp, Arraytyp) erlaubt. Mit Hilfe des Schlüsselwortes return kann dann ein Rückgabewert an den Aufrufer der Methode zurückgegeben werden.

return Ausdruck_opt

Hinter dem Schlüsselwort return kann ein Ausdruck angegeben werden. Hat die Methode z.B. einen Rückgabewert vom Typ int kann hinter dem Schlüsselwort der Ausdruck 3 + 4 stehen. Falls kein Wert an den Aufrufer zurückgegeben werden soll (Ergebnistyp ist void), wird nur return verwendet. Nach Ausführung einer return-Anweisung wird die Abarbeitung der Methode beendet und die Ausführung des Java-Programms wird an entsprechender Stelle des Methodenaufrufers fortgesetzt. Das folgende Beispiel enthält die Instanzmethode method3, deren Rückgabewert vom Typ int ist.

/* MethodExample3.java */

public class MethodExample3 {
  
  public int method3() {
    int a;
    a = 3 + 4;
    return a;
  }
    
  public static void main(String[] args) {
    MethodExample3 me3 = new MethodExample3();
    int b = me3.method3();
    
    System.out.println(b);
  }
}

Die lokale Variable b der main-Methode wird durch den Aufruf der Instanzmethode mit dem Wert 7 initialisiert. Für die Methode method3 wären auch die folgenden Zeilen im Quelltext möglich:

public int method3() {
  return 3 + 4;
}

Bei der Deklaration einer Methode können direkt hinter dem Methodennamen, innerhalb von runden Klammern, (formale) Parameter angegeben werden. Soll der Methode kein Argument übergeben werden, folgt dem Namen der Methode ein leeres Klammerpaar. Mehrere Parameter innerhalb des Klammerpaares werden durch Kommata voneinander getrennt. Ein Parameter kann durch die Angabe seines Typs mit anschließender Nennung seines Namens angegeben werden.

ParameterTyp ParameterName

Der Name eines Parameters bezeichnet einen Argumentwert, der der Methode durch einen Aufruf übergeben wurde. Für jeden Parameter wird jedesmal beim Aufruf der zugehörigen Methode eine neue Parametervariable erzeugt. Die Variable wird anschließend mit dem Wert des übergebenen Arguments initialisiert. Der anschließende Programmausschnitt deklariert die statische Methode method0. Die Methode besitzt einen Parameter.

public static void method0(int a) {

}  

public static void main(String[] args) {
  method0(3);
}

Die Parametervariable a ist vom Typ int und wird beim Aufruf mit dem Wert 3 initialisiert. Die Zahl 3 wird durch method0(3); der aufzurufenden Methode als Argument übergeben. Der Quelltext MethodExample4.java deklariert die Methode method4 mit zwei Parametern. Ihr werden beim Aufruf eine Ganzzahl und ein Objekt übergeben.

/* MethodExample4.java */

public class MethodExample4 {
  
  static int a = 3;
  int b = 3;
  
  public void method4(int a, MethodExample4 obj) {
    a = a + 1;
    obj.b = obj.b + 1;
    System.out.println(a);
    System.out.println(obj.b);
  }

  public static void main(String[] args) {
    MethodExample4 me4 = new MethodExample4();
    me4.method4(a, me4);
    System.out.println(a);
    System.out.println(me4.b);
  }
}

Durch das Listing werden nacheinander die Zahlenwerte 4, 4, 3 und 4 ausgegeben. Das Zustandekommen der letzten 4 der Konsolenausgabe resultiert aus der Übergabe eines Arguments, das eine Referenz auf ein Objekt ist. Diese Referenz wird innerhalb der aufgerufenen Methode genutzt, um die Instanzvariable b zu verändern. Diese Änderung hat auch nach dem Aufruf von method4 bestand.

Variable Parameterlisten (varargs)

Mit Erscheinen des JDK 5 wurde die Möglichkeit geschaffen Methoden mit einer variablen Anzahl von Argumenten aufzurufen (varargs). Der letzte formale Parameter einer Parameterliste kann ein "variable arity parameter" sein (arity: dt. Arität, Stelligkeit). Ein solcher Parameter kann ausschließlich nur als letzter Parameter der Liste notiert werden und unterliegt dem folgenden vereinfachten Aufbau:

ParameterTyp... ParameterName

Nach Angabe des Typs des Parameters folgen direkt im Anschluss drei Punkte. Nach einem Leerzeichen kann danach der Name des Parameters angegeben werden. Die drei Auslassungspunkte kennzeichnen diesen besonderen Parameter als Parameter mit variabler Stelligkeit. Eine Parameterliste, die einen Parameter mit variabler Stelligkeit enthält, wird als variable Parameterliste bezeichnet. Im folgenden Beispiel wird die Methode printHello deklariert, die eine variable Parameterliste besitzt. Der Methode können eine variable Anzahl von Zeichenketten übergeben werden.

/* MethodExample5.java */

public class MethodExample5 {
  
  public static void printHello(String... str) {
    for (int i = 0; i < str.length; i++) {
      System.out.println("Hello " + str[i] + "!");
    }
  }

  public static void main(String[] args) {
    printHello("World", "Java", "Hans");
  }
}

Das Listing gibt die drei Zeichenketten "Hello World!", "Hello Java!" und "Hello Hans!" auf dem Bildschirm aus. Im Beispiel wurden der Methode printHello drei Zeichenketten als Argumente übergeben; da die Anzahl der Argumente nicht festgelegt ist, könnten der Methode noch zusätzliche Strings übergeben werden. Ein Parameter mit variabler Stelligkeit könnte auch vom Typ eines primitiven Typs (z.B. int) sein. Auch ein Arraytyp ist in diesem Fall als Parametertyp zulässig, wie das nächste Beispielprogramm zeigt.

/* MethodExample6.java */

public class MethodExample6 {
  
  public static void printVarargs1(int... varparas) {
    for (int i : varparas) {
      System.out.println(i);
    }
  }
  
  public static void printVarargs2(int i, int[]... varparas) {
    System.out.println(i);
    for (int[] j : varparas) {
      for (int k : j) {
        System.out.print(k + " ");
      }
      System.out.println();
    }
  }

  public static void main(String[] args) {
    printVarargs1(3, 4, 5);
    printVarargs2(6, new int[]{7, 8}, new int[]{9, 10});
  }    
}

Der Java-Quelltext verwendet die erweiterte for-Schleife zur Ausgabe von Ganzzahlen der variablen Parameterlisten. Die Ausgabe würde nach Ausführung des Beispiels lauten:

3
4
5
6
7 8 
9 10 

Innerhalb einer Klasse können mehrere Methoden mit dem gleichen Namen deklariert werden. Eine Unterscheidung kann durch die Signaturen der Methoden erfolgen. Wenn mehrere Methoden innerhalb einer Klasse den selben Namen aber unterschiedliche Signaturen besitzen, wird der Methodenname auch als überladen bezeichnet. Die Signatur einer Methode besteht aus dem Namen der Methode und der Anzahl und Typ der (formalen) Parameter. Die anschließende Übersicht zeigt Methodendeklarationen mit zugehörigen Signaturangaben:

Methode:  public void add(int a, int b) { ... }
Signatur: add(int,int)

Methode:  public int add(int a, int b) { ... }
Signatur: add(int,int)

Methode:  public void add(int a, int b, int c) { ... }
Signatur: add(int,int,int)

Methode:  public void add(int a2, int b2, float c2) { ... }
Signatur: add(int,int,float)

Methoden mit gleicher Signatur können nicht unterschieden werden und sind daher auch nicht innerhalb einer Klasse zulässig. Die ersten beiden Methodendeklarationen mit jeweils zwei Parametern vom Typ int könnten zum Beispiel nicht zusammen in einer Klasse angeordnet werden. Die unterschiedlichen Typen der Rückgabewerte finden keine Berücksichtigung in einer Methodensignatur. Das folgende kurze Beispiel enthält zwei Methoden mit dem Namen add, wobei sich die Anzahl der Parameter unterscheiden. Es werden die zwei Summen 7 und 15 ausgegeben.

/* MethodExample7.java */

public class MethodExample7 {
  
  public void add(int a, int b) {
    int d = a + b;
    System.out.println(d);
  }

  public void add(int a, int b, int c) {
    int d = a + b + c;
    System.out.println(d);
  }  
  
  public static void main(String[] args) { 
    MethodExample7 me7 = new MethodExample7(); 
    me7.add(3, 4);
    me7.add(4, 5, 6);
  }
}