So kannst du Methoden im Java Programm aufrufen und ausführen

Doch wie greifst du jetzt auf diese zu?
Wie kannst du diese Methoden in einer anderen Klassen aufrufen?

Welcher Unterschied, hinsichtlich des Methodenaufrufes, besteht eigentlich zwischen deinen Java Methoden?

Diese Fragen möchte ich gern in diesem Beitrag beantworten.

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.

• Klasse eins Blumen.
• Und Klasse zwei wäre der Garten.

In der Klasse Blumen bietest du zwei Methoden an.
Die Methode „wachsen“ und „blühen“ sind Instanz- oder Objektmethoden.

Es existiert weiterhin ein parameterloser Konstruktor, welcher das Blumenobjekt erstellen soll.

public class Blume {

 void bluehen(){ //Instanzmethode bluehen
 System.out.println("Die Blume blüht");
 }
 
 void wachsen () { //Instanzmethode wachsen
 System.out.println("Die Blume wächst");
 }
 
 public Blume (){ //parameterloser Konstruktor
 
}
}

In der Klasse Garten bietest du die main Methode an.
Hier wird also das Programm gestartet.

So sieht das Ganze dann aus.

public class Garten {

	public static void main(String[] args) {

	}
}

So rufst du die Instanzmethoden auf.

Jede Instanz besitzt einen Scope.

Was ist das?
Der Scope ist der Sichtbarkeitsbereich des Objektes bzw. der Variablen.

Ja, okay.
Und wo ist der Scope der Instanzvariablen?
In Instanzmethoden und im Konstruktor.

Das bedeutet, dass du Instanzmethoden innerhalb des Methodenrumpfes anderer Instanzmethoden aufrufen kannst.
Die Vorraussetzung ist, dass sich diese in der gleichen Klasse befindet.

In der Praxis bedeutet das:
Füge den Methodenaufruf der Methode „wachsen“ in den Methodenrumpf der „Blühen-methode“ ein.

public class Blume {

 void bluehen(){ //Instanzmethode bluehen
 System.out.println("Die Blume blüht");
wachsen();
 }
 
 void wachsen () { //Instanzmethode wachsen
 System.out.println("Die Blume wächst");
 }
 
 public Blume (){ //parameterloser Konstruktor
 
}
}

Du kannst jetzt im Garten eine Blume anlegen.
Und dann kannst du 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 "bluehen" wird aufgerufen
	}
}

Und jetzt ruft deine „blühen Methode“ automatisch die „wachsen-Methode“ auf und führt diese aus.

Somit wächst deine Blume immer, wenn diese 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.

Also lege eine Klasse Baum an.
Im Klassenrumpf kannst du ebenfalls eine Instanzmethode implementieren.
Und im Rumpf dieser Methode erzeugst du ein Objekt einer anderen Klasse.

Und natürlich kannst du dann auf die Instanzmethode des anderen Objektes zugreifen.

public class Baum {
 
 void wachsen(){
 Blume tulpe = new Blume(); //neue Blume wird innerhalb der Baum-Methode angelegt
 tulpe.wachsen(); //Wachsen-Methode aus der Blumenklasse wird ausgeführt
 }
}

In der main Methode erstellst du dann ein Baumobjekt.
Und auf diesem neuen Objekt, rufst du 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
 }
}

Klicke auf „Run“ und sieh was passiert.

Du siehst die Instanzmethode der Klasse Baum,

• erzeugt ein neues Objekt der Klasse Blume
• und ruft die Objektmethode der Blumenklasse auf.

Und so kannst du Instanzmethoden im Konstruktor aufrufen

Es ist eigentlich das gleiche Prinzip.

Innerhalb der gleichen Klasse kannst du direkt auf Instanzmethoden zugreifen.

public class Blume {

 void bluehen(){ //Instanzmethode bluehen
 System.out.println("Die Blume blüht");
wachsen();
 }
 
 void wachsen () { //Instanzmethode wachsen
 System.out.println("Die Blume wächst");
 }
 
 public Blume (){ //parameterloser Konstruktor
bluehen(); //Methode bluehen wird im Java Konstruktor ausgeführt
wachsen(); //Ausführen der wachsen Methode
}
}

Und die Gartenklasse ruft den Konstruktor auf.
Und dieser wiederum führt automatisch alle Java Methoden aus.

public class Garten {

 public static void main(String[] args) {
Blume tulpe = new Blume(); //Blume Objekt wird angelegt und führt automatisch die Methoden aus
 }
}

Und wenn sich deine Instanzmethoden auf andere Objekte beziehen…
Na dann musst du im Konstruktor ein Objekt der anderen Klasse anlegen und los geht’s.

public class Baum {
 
 void wachsen(){

 }
 public Baum () { //Konstruktor
 Blume rose = new Blume(); //Im Konstruktor wird jetzt eine Instanz einer anderen Klasse angelegt
 rose.wachsen(); //Im Konstruktor wird eine Methode einer anderen Klasse 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 Ersschaffen eines Baumes werden automatisch Blumen angelegt
 }
}

Du siehst auch hier, erschaffst du einen Baum.
Und in diesem Moment erschafft der Baum automatisch eine Blume.
Und dann führt der Baum die Methoden des Blumenobjektes wachsen und blühen aus.

Cool oder?

Doch 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.

Wieso?
Du musst kein Objekt erzeugen, um diese auszuführen.

Ich mache aus der Instanzmethode „wachsen“ einfach eine statische Methode.

Um diese Methode statisch zu machen, fügst du lediglich das Keyword static in den Methodenkopf ein.

public class Blume {

 void bluehen(){ //Instanzmethode bluehen
 System.out.println("Die Blume blüht");
wachsen(); //die statische Methode wachsen wird ausgeführt
 }
 
 static void wachsen () { //Klassenmethode wachsen
 System.out.println("Die Blume wächst");
 }
 
 public Blume (){ //parameterloser Konstruktor

}
}

Und im Garten erstellst du ein neues Blumenobjekt.
Und auf dieses Objekt lässt du die Java Methode 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
	}
}

Was passiert?
Es funktioniert.
Eine Instanzmethode kann eine statische Methode ausführen.

Doch wie sieht es umgekehrt aus?

Rufe doch die Instanzmethode einmal im Methodenrumpf einer statischen Methode aus.

public class Blume {

 void bluehen(){ //Instanzmethode bluehen
 System.out.println("Die Blume blüht");
 }
 
 static void wachsen () { //Klassenmethode wachsen
 System.out.println("Die Blume wächst");
bluehen();//die Objektmethode bluehen wird ausgeführt
} 
public Blume (){ //parameterloser Konstruktor 
} 
}

Was passiert?
Es kommt zur Fehlermeldung.

In einer statischen Methode kannst du eine Instanzmethode nur am Objekt aufrufen.

Ist auch logisch.
Denn jedes Objekt hat seine eigenen Variablen und auch seine eigenen Methoden.
Somit musst du vorher immer ein Objekt erzeugen, bevor du die Methode ausführen kannst.

Bei den Klassenmethoden ist das anders.
Diese stehen ja allen Objekten zur Verfügung.

public class Blume {

 void bluehen(){ //Instanzmethode bluehen
 System.out.println("Die Blume blüht");
 }
 
 static void wachsen () { //Klassenmethode wachsen
Blume narzisse = new Blume();
 System.out.println("Die Blume wächst");
narzisse.bluehen();//die Objektmethode bluehen wird ausgeführt
} 
public Blume (){ //parameterloser Konstruktor 
} 
}

Lass uns eine statische Methode im Konstruktor aufrufen.

public class Blume {

 void bluehen(){ //Instanzmethode bluehen
 System.out.println("Die Blume blüht");
 }
 
 static void wachsen () { //Klassenmethode wachsen
System.out.println("Die Blume wächst");
} 
public Blume (){ //parameterloser Konstruktor 
wachsen(); //statische Methode kann im Konstruktor ausgeführt werden 
} 
}

Auch dies funktioniert ohne größere Probleme.

Jetzt lass uns die Klasse wechseln.

So rufst du Klassenmethoden in anderen Klassen auf.

Schau dir die Bäume an.

Versuch einmal die statische Methode „wachsen“ in der Instanzmethode des Baumes aufzurufen.
Dies funktioniert jetzt nicht mehr so einfach.

Du musst nämlich die Klasse angeben, aus welcher du die Klassenmethode beziehst.

Wenn du jetzt die Methode „wachsen“ in der Baumklasse aufrufen würdest, beziehst du dich auf die Baum-Methode „wachsen“.

Das ist toll..
Du hast somit nämlich die Möglichkeit mehrere Klassenmethoden mit gleicher Signatur anzulegen.
Die Voraussetzung ist allerdings, dass diese sich in unterschiedlichen Klassen befinden.

Und weil du gleiche Namen und Signaturen verwenden kannst, musst du per Punktnotation zuerst die Klasse angeben und dann die Methode.

public class Baum {
 
void wachsen(){
wachsen(); //Es wird lediglich die Methode wachsen der Baumklasse ausgführt. 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.

Es ist eigentlich ganz einfach.

Genauso wie du in den Methodenrumpf andere Klassenmethoden aufrufst….
Macht du dies auch im Konstruktor.

Achte darauf den Klassennamen der Methode zu schreiben.
Und dann kannst du per Punktnotation die Methode ausführen lassen.

So sieht der Code dazu aus:

public class Baum {
 
 void wachsen(){
wachsen(); //Es wird lediglich die Methode wachsen der Baumklasse ausgführt
Blume.wachsen();//Die Methode der Blumenklasse wird ausgeführt
 }
 public Baum () { //Konstruktor
 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.
  Du kannst Objektmethoden auch in einem Konstruktor der gleichen Klasse ausführen.
  Du musst dafür kein Objekt erzeugen.
• Außerhalb der Klasse kannst du Instanzmethoden ebenfalls in anderen Instanzmethoden oder Konstruktoren ausführen.
  Hierfür musst du allerdings ein Objekt anlegen.
• Du kannst Instanzmethoden nicht ohne weiteres in statischen Methoden ausführen.
  Selbst wenn diese statischen Methoden sich in der gleichen Klasse befinden.
  In einer statischen Methode musst du immer ein Objekt erzeugen.
  Erst dann kannst du die Instanzmethode am Objekt aufrufen.
• Statische Methoden kannst du ohne weiteres in Instanzmethoden und Konstruktoren, der gleichen Klasse, aufrufen.
  Du kannst Klassenmethoden auch in anderen Klassenmethoden ausführen lassen.
• Falls du eine Klassenmethode in einer anderen Klasse ausführen lassen möchtest, musst du explizit die Klasse ausweisen, in welche sich die Methode befindet.

Ich gebe zu, dass Beispiel mit den Blumen und Bäumen war nicht ganz sinnvoll gewählt.
Ich hoffe dennoch, dass dir dieser Beitrag gefallen hat.

Über den Autor

Folge Sciodoo und bleibe stets auf dem Laufenden. Schließ dich uns an und abonniere unseren Instagram-Kanal ein. Wir stellen täglich neue Artikel für dich rein. Weiter zum Kanal>>>