Methoden - Codeabschnitte für Funktionalität

[hdi]

Eine Methode ist nichts weiter als ein Teil von einem Programm, d.h. in Methoden schreibt man den Code,
der ausgeführt werden soll. Jede Java-Applikation hat mindestens eine Methode:

public static void main(String[] args){ ... }

wobei diese Methode (bis auf den Namen des Parameters, also "args) immer genau so aussehen muss.
Beim Start eines Programms wird diese Methode automatisch ausgeführt, d.h. hier beginnt jedes Programm.

Eine Methode besteht aus 3 Dingen:

1) ihre Definition
2) ihre Signatur (Parameterliste)
3) ihr Rumpf

wobei "Rumpf" all das ist, was innerhalb der "{" und "}" Klammern steht. Das ist dann der Code, also das,
was diese Methode tut, wenn sie aufgerufen wird.

Die Definition ist alles davor, und teilt sich in folgende Dinge ein (in dieser Reihenfolge):

1) Sichtbarkeit (kann man weglassen)
2) statisch (kann man weglassen)
3) Rückgabewert
4) Name
5) Parameter (kann man weglassen)

Die Definition der main-Methode:

public (1) static (2) void (3) main (4) (String[] args (5))

zu 1)
es gibt die Sichtbarkeiten public, private und protected. public heisst, die Methode ist überall im Programm bekannt,
d.h. wenn diese Methode in der Klasse A steht, kann ich sie auch aus Klasse B aufrufen.
private heisst, sie ist nur in Klasse A sichtbar. Aus Klasse B könnte ich diese Methode nicht aufrufen.
protected ist ein Zwischending und heisst, die Methode ist im package sichtbar. Wenn also Klasse B im selben
package wie Klasse A ist, kann ich die protected Methoden von A in B aufrufen.

zu 2)
man kann "static" hinschreiben oder weglassen. Wenn man es hinschreibt, heisst das, dass diese Methode
nicht auf Instanzen der Klasse aufgerufen wird, sondern einfach als "stand-alone" Teil eines Programms.
Wie eben die main-Methode.

Lässt man "static" weg, hat man eine nicht-statische Methode, und das bedeutet, man ruft sie auf Instanzen
der Klasse auf:

class Konto{
     public void setInhaber(String name){...}
}

Ich kann jetzt nicht einfach sagen (zB in der main-Methode) :

setInhaber("Thomas"); // falsch

sondern muss die Methode auf einem Objekt aufrufen:

Konto k = new Konto();
k.setInhaber("Thomas"); // richtig

I.d.R. sind die meisten Methoden nicht-statisch, weil genau das der Sinn von OO-Programmierung ist:
Man hat Objekte und kann damit etwas tun.
Statische Methoden sind dann meist irgendwelche Hilfs-Methoden oder rein mathematische Berechnungen,
die keinem Objekt zugrunde liegen.

zu 3)
Der Rückgabewert ist der Typ der Variablen, die von der Methode zurückgegeben wird, bzw. eine primitiver Typ.
Wenn eine Methode nichts zurückliefert, schrebit man "void" hin.

Soll sie allerdings etwas zurückliefern, schreibt man eben diesen Typ hin, und muss dann auch innerhalb
der Methode das Schlüsselwort "return" verwenden, um den gewünschten Wert zurückzugeben.

Bsp:

public int getTemperatur(){
       return 24; // MUSS (als letzte Anweisung) im Rumpf der Methode stehen: Der Typ hinter "return" muss 
       // mit dem Typ in der Definition übereinstimmen.
}

Noch ein Bsp:

public static int getTemperatur(){
       return "Hallo" // FALSCH: String != int
}

Der Sinn eines Rückgabewertes ist nur der, dass man das, was eine Methode returned, dann dort, wo
diese Methode aufgerufen wurde, abspeichern kann:

int temperatur = getTemperatur();
// in "temperatur" ist jetzt 24 gespeichert

zu 4)
Naja zu dem Namen muss ich wohl nicht viel sagen. Man sollte natürlich immer möglichst Namen wählen,
die erahnen lassen, was eine Methode tut

zu 5)
Die Parameter schreibt man in runde Klammern, und das ist das, was die Methode "mitbekommt", wenn
man sie aufruft. Eine Methode muss keine Parameter bekommen, wie zB die getTemperatur() von oben.
Dann ist die Klammer halt leer.

Möchte man allerdings Parameter übergeben, schreibt man sie durch "," getrennt in die Klammern,
und zwar jeweils den Typ, sowie einen Variablen-Namen.

Bsp:

public int getTemperatur(String stadt){
         if ( stadt.equals ("Miami"){
              return 37;
         }
         if (stadt.equals( "London"){
              return 9;
         }       
}

Wie man sieht kann man dann diese Variable im Rumpf verwenden.

Aufrufen muss man jetzt diese Methode mit dem passenden Parameter:

int tempInLondon = getTemperatur("London");
int temp = getTemperatur(); // FALSCH! Die Methode erwartet einen Parameter
int temp2 = getTemperatur( 30 ); // FALSCH! Die Methode erwartet einen Parameter vom Typ String

Zusammenfassung
Eine Methode besteht aus einem oder mehreren Modifizierern, einem Rückgabewert, einem Namen, und einem Rumpf. Beim Aufruf einer Methoden muss man
auf 2 Dinge achten:
1) Ist sie statisch? Wenn nein, brauch ich ein passendes Objekt. Wenn ja, brauch ich keins
2) Will sie Parameter? Wenn ja, muss ich welche übergeben, und zwar die richtigen!

Ein gutes Programm kapselt verschiedene Teil-Aufgaben in einzelne Methoden mit passenden Namen, was den Code
übersichtlich macht und wiederverwendbar. Statt also 2x an verschiedenen Stellen im Programm einen gewissen
Code zu schreiben, schreibt man ihn in eine eigene Methode, und ruft dann jeweils an den Stellen nur noch die
Methode auf.

Wenn es Fragen gibt, bitte eine PN (Private Nachricht) an mich schicken.

PS: Diese Einführung ist für Anfänger gedacht und es wurden bewusst Dinge weggelassen, die für
das Grund-Verständnis von Methoden nicht relevant sind.