Skip to main content

So kannst du deine Java Methoden ausführen

Du hast die ersten Java Methoden erstellt.

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.

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.
Vielleicht hast du noch etwas hinzu zufügen?
Na dann hinterlasse mir doch jetzt einen Kommentar.


Ähnliche Beiträge

Java for Schleifen schachteln – So funktioniert es

Java For Schleifen schachteln

Diese Situation kennst du doch auch…. Du stehst an der Haltestelle und wartest auf den Bus. Dein Blick fällt auf die Uhr.   Oder du wartest an der Ecke auf deinen Freund oder Kollegen. Immer wieder schaust du auf deine Uhr.   Sie ist kaum noch wegzudenken. Die mobile Taschenuhr.   Lange Zeit wurde die […]

Java Polymorphie – besserer Code und mehr Möglichkeiten

Java Polymorphie Vorteile

Polymorphie ist das Herzstück jeder objektorientierten Sprache. Nicht nur in Java – auch in Python, Javascript und in anderen Sprachen. Aber was bedeutet Polymorphie eigentlich? Polymorphie oder auch Polymorphismus genannt, kommt aus dem Griechischen. Es bedeutet Vielgestaltigkeit. Etwas freier übersetzt, kannst du es auch als Facettenreichtum bezeichnen. Im Grunde genommen zielt die ganze Java Vererbung […]

So kannst du Werte aus zwei oder mehreren Java Arrays verrechnen.

Java Arrays verrechnen

Wie kann man Werte aus zwei oder mehreren Java Arrays miteinander verrechnen? Zum Beispiel: Du möchtest alle Werte des ersten Arrays mit allen Werten des zweiten Arrays addieren Oder du möchtest die Summe aus beiden Arrays wissen und erst dann diese miteinander addieren. Was erwartet dich in diesem Beitrag? Zuerst werde ich dir zeigen, wie […]

Java Vererbung findet auch zwischen Einkaufstüten und Polizeiautos statt

Java Vererbung

„Manchmal findet Java Vererbung auch zwischen Einkaufstüten und Polizeiautos statt“ Irrer Titel, oder? Aber mal Hand aufs Herz. Was haben eigentlich eine Einkaufstüte und ein Polizeiwagen gemeinsam? Ich verrate dir etwas: Du kannst die Verbindung nicht erkennen, denn ich habe dir nicht alles verraten. Es fehlt noch ein wichtiger Aspekt – eine Verbindung zwischen beiden. […]

Die drei Bestandteile aller Java Klassen

Java Klassen Bestandteile

Java ist eine objektorientierte Programmiersprache. Was heißt das? Ja… Anscheinend hat es etwas mit Objekten zu tun. Also was ist ein Objekt? Ein Objekt ist ein bestimmtes Konstrukt im Programm. Bauen wir ein Spiel. Ein Grafik-Adventure. Du kennst das. Ein Held wird in eine bestimmte Spielwelt hinein gesteckt. Der Held muss mit bestimmten Personen sprechen. […]

So kannst du Java Arrays anlegen

Java Arrays anlegen

Java Arrays– Was ist das? Stell es dir einmal als ein Bücherregal vor. In einem Bücherregal befinden sich sämtliche Bücher. Und diese befinden sich schön nebeneinander. Jedes Buch hat seinen festen Platz. Du kannst die Bücher ganz genau lokalisieren. Zum Beispiel kannst du sagen. Das erste Buch von links Das dritte von rechts usw. Und […]

Polymorphie bringt Vorteile für Java Arrays

Java Polymorphie Arrays

Wenn Java Arrays, Schubladen oder Container sein sollen… Dann wäre der Gebrauch einer solchen Schublade ziemlich einseitig und festgefahren. Denn in jedes Array passen zwar mehrere Daten – aber immer nur vom gleichen Datentyp. Immer gleicher Datentyp? Also eine Schublade nur für Socken, Unterwäsche und der ganze andere Kram passt dann eben nicht hinein. Um […]