Du hast also deine ersten Java-Methoden erstellt. Aber wie greifst du jetzt auf diese zu? Wie kannst du diese Methoden in anderen Klassen aufrufen? In diesem Beitrag beantworte ich diese Fragen für dich.
Möglichkeiten, um Methoden in Java aufzurufen und auszuführen
Gehen wir dazu in den Garten und schauen uns Blumen an. Du hast zwei Klassen: die Klasse “Blumen” und die Klasse “Garten”. In der Klasse “Blumen” gibt es zwei Instanzmethoden: “wachsen” und “blühen”. Es gibt auch einen parameterlosen Konstruktor, der das Blumenobjekt erstellen soll. In der Klasse “Garten” gibt es die main-Methode, in der das Programm startet.
So rufst du die Instanzmethoden auf: Jede Instanz hat einen Sichtbarkeitsbereich, auch als Scope bezeichnet. Der Scope der Instanzvariablen befindet sich in den Instanzmethoden und im Konstruktor. Das bedeutet, dass du Instanzmethoden innerhalb anderer Instanzmethoden aufrufen kannst, solange sich diese in derselben Klasse befinden. Füge den Methodenaufruf der Methode “wachsen” in den Methodenrumpf der “blühen”-Methode ein.
public class Blume {
void bluehen(){
System.out.println("Die Blume blüht");
wachsen();
}
void wachsen () {
System.out.println("Die Blume wächst");
}
public Blume (){
// parameterloser Konstruktor
}
}Du kannst jetzt im Garten eine Blume anlegen und die Methode “blühen” ausführen lassen.
public class Garten {
public static void main(String[] args) {
Blume tulpe = new Blume(); // Anlegen eines Objektes
tulpe.bluehen(); // Methode "blühen" wird aufgerufen
}
}Jetzt ruft deine “blühen”-Methode automatisch die “wachsen”-Methode auf und führt sie aus. Somit wächst deine Blume immer, wenn sie blüht.
Falls sich die Java-Methoden in anderen Java-Klassen befinden, befindest du dich außerhalb des direkten Scopes. Aber kein Problem. Du musst vorher lediglich ein Objekt anlegen. Lege eine Klasse “Baum” an. Im Klassenrumpf kannst du ebenfalls eine Instanzmethode implementieren. Im Rumpf dieser Methode erzeugst du ein Objekt einer anderen Klasse und kannst dann auf die Instanzmethode des anderen Objekts zugreifen.
public class Baum {
void wachsen(){
Blume tulpe = new Blume(); // neues Blumenobjekt wird innerhalb der Baum-Methode angelegt
tulpe.wachsen(); // Methode "wachsen" aus der Blumenklasse wird ausgeführt
}
}In der main-Methode erstellst du dann ein Baumobjekt und rufst die Instanzmethode des Baumes auf.
public class Garten {
public static void main(String[] args) {
Baum eiche = new Baum(); // Baum-Objekt wird angelegt
eiche.wachsen(); // das Baum-Objekt führt die "wachsen"-Methode aus
}
}Wenn sich deine Instanzmethoden auf andere Objekte beziehen, musst du im Konstruktor ein Objekt der anderen Klasse anlegen und los geht’s.
public class Baum {
void wachsen(){
}
public Baum () {
Blume rose = new Blume(); // Instanz einer anderen Klasse wird im Konstruktor angelegt
rose.wachsen(); // Methode einer anderen Klasse wird im Konstruktor ausgeführt
}
}Wie gehabt rufst du in der main-Methode den Konstruktor auf und fertig.
public class Garten {
public static void main(String[] args) {
Baum kastanie = new Baum(); // Beim Erstellen eines Baumes werden automatisch Blumen angelegt
}
}Du siehst, du erschaffst einen Baum. Und in diesem Moment erschafft der Baum automatisch eine Blume. Dann führt der Baum die Methoden des Blumenobjekts “wachsen” und “blühen” aus. Cool oder?
Aber wie sieht das Ganze jetzt im statischen Bereich aus? Lass es uns herausfinden.
So kannst du statische Methoden innerhalb der gleichen Klasse ausführen
Klassenmethoden sind besser, denn du musst kein Objekt erzeugen, um diese auszuführen. Ändere die Instanzmethode “wachsen” einfach in eine statische Methode, indem du das Keyword “static” in den Methodenkopf einfügst.
public class Blume {
void bluehen(){
System.out.println("Die Blume blüht");
wachsen(); // die statische Methode "wachsen" wird ausgeführt
}
static void wachsen () {
System.out.println("Die Blume wächst");
}
public Blume (){
// parameterloser Konstruktor
}
}Im Garten erstellst du ein neues Blumenobjekt und lässt die Java-Methode darauf ausführen.
public class Garten {
public static void main(String[] args) {
Blume narzisse = new Blume(); // eine Narzisse wird erstellt
narzisse.bluehen(); // die Narzisse blüht und wächst
}
}Es funktioniert! Eine Instanzmethode kann eine statische Methode ausführen. Aber wie sieht es umgekehrt aus? Rufe doch die Instanzmethode im Methodenrumpf einer statischen Methode aus.
public class Blume {
void bluehen(){
System.out.println("Die Blume blüht");
}
static void wachsen () {
System.out.println("Die Blume wächst");
bluehen(); // die Instanzmethode "bluehen" wird ausgeführt
}
public Blume (){
// parameterloser Konstruktor
}
}Es kommt zur Fehlermeldung. In einer statischen Methode kannst du eine Instanzmethode nur am Objekt aufrufen. Das ergibt auch Sinn, denn jedes Objekt hat seine eigenen Variablen und Methoden. Du musst also immer ein Objekt erzeugen, bevor du die Methode ausführen kannst. Bei Klassenmethoden ist das anders. Diese stehen allen Objekten zur Verfügung.
public class Blume {
void bluehen(){
System.out.println("Die Blume blüht");
}
static void wachsen () {
System.out.println("Die Blume wächst");
}
public Blume (){
// parameterloser Konstruktor
}
}Lass uns nun eine statische Methode im Konstruktor aufrufen.
public class Blume {
void bluehen(){
System.out.println("Die Blume blüht");
}
static void wachsen () {
System.out.println("Die Blume wächst");
}
public Blume (){
wachsen(); // die statische Methode kann im Konstruktor ausgeführt werden
}
}Auch das funktioniert ohne größere Probleme.
Jetzt wechseln wir die Klasse.
So rufst du Klassenmethoden in anderen Klassen auf
Schau dir die Bäume an. Versuche einmal, die statische Methode “wachsen” in der Instanzmethode des Baumes aufzurufen. Das funktioniert jetzt nicht mehr so einfach. Du musst nämlich die Klasse angeben, aus der du die Klassenmethode beziehst. Wenn du jetzt die Methode “wachsen” in der Baumklasse aufrufen würdest, beziehst du dich auf die “wachsen”-Methode des Baums. Das ist toll, denn du hast somit die Möglichkeit, mehrere Klassenmethoden mit gleicher Signatur anzulegen, solange sie sich in unterschiedlichen Klassen befinden. Du musst per Punktnotation zuerst den Klassennamen angeben und dann die Methode aufrufen.
public class Baum {
void wachsen(){
wachsen(); // Es wird lediglich die Methode "wachsen" der Baumklasse ausgeführt. Die Methode ruft sich selbst auf.
Blume.wachsen(); // Die Methode der Blumenklasse wird ausgeführt
}
}Und natürlich kannst du die Klassenmethode auch im Konstruktor aufrufen.
public class Baum {
void wachsen(){
wachsen(); // Es wird lediglich die Methode "wachsen" der Baumklasse ausgeführt
Blume.wachsen(); // Die Methode der Blumenklasse wird ausgeführt
}
public Baum () {
wachsen(); // Im Konstruktor wird die Methode der Klasse Baum ausgeführt
Blume.wachsen(); // Die statische Methode wird ausgeführt
}
}Zusammenfassung:
- Instanzmethoden kannst du innerhalb anderer Instanzmethoden der gleichen Klasse aufrufen. Objektmethoden kannst du auch in einem Konstruktor der gleichen Klasse ausführen, ohne ein Objekt erstellen zu müssen.
- Außerhalb der Klasse kannst du Instanzmethoden ebenfalls in anderen Instanzmethoden oder Konstruktoren ausführen. Hierfür musst du jedoch ein Objekt anlegen.
- Du kannst Instanzmethoden nicht ohne weiteres in statischen Methoden ausführen, selbst wenn sich diese statischen Methoden in derselben Klasse befinden. In einer statischen Methode musst du immer ein Objekt erzeugen, um die Instanzmethode am Objekt aufzurufen.
- Statische Methoden kannst du ohne weiteres in Instanzmethoden und Konstruktoren derselben Klasse aufrufen. Du kannst Klassenmethoden auch in anderen Klassenmethoden ausführen lassen.
- Wenn du eine Klassenmethode in einer anderen Klasse ausführen möchtest, musst du explizit die Klasse angeben, in der sich die Methode befindet.
Ich gebe zu, dass das Beispiel mit den Blumen und Bäumen nicht ganz sinnvoll gewählt war. Ich hoffe dennoch, dass dir dieser Beitrag gefallen hat.
