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

8 Java Datentypen, die du kennen solltest

Java Datentypen

Java Datentypen Ich gebe zu, ich hasse dieses Thema. Denn es ist eigentlich nichts weiter als graue Theorie. Dennoch müssen wir dieses Thema behandeln. Um schnell in das Thema zu kommen, stelle ich dir eine Übersicht aller primitiven Datentypen zur Verfügung. Wieso primitive? Es gibt außer den primitiven Datentypen, noch Referenztypen. Und diese Referenztypen sind […]

Die vier verschiedenen Zahlensysteme in der Java Programmierung

Java Zahlensysteme

Java Zahlensysteme – Was soll das? In sämtlichen Programmiersprachen werden Zahlen in Variablen abgespeichert. Wenn du dir die einzelnen primitiven Datentypen in Java einmal anschaust – wirst du feststellen – dass die Masse der Datentypen Zahlen annehmen und speichern können. Zahlen und die Mathematik dahinter spielen in der Programmierung eine sehr große Rolle. Ganz am […]

So kannst du Java Methoden überladen

Java Methoden überladen

Im Mittelalter war es üblich, dass Könige oder Adlige Briefe durch ein Siegel verschlossen. Das Siegel hatte die Aufgabe den Inhalt des Briefes vor dem gewaltsamen Öffnen zu schützen. Außerdem hatte das Siegel die Aufgabe einen Eigentumsnachweis sicher zu stellen. Und jeder, welcher das Siegel des Königs sah, wusste: „Das königliche Siegel – Oh ein […]

Eine Java Konsoleneingabe machst du über den Scanner

Es wird Zeit für die erste Java Konsoleneingabe. Und diese Eingaben machst du über den Java Scanner. Was ist das? Der Scanner ist eine vorgefertigte Java Klasse, welche Java mit seiner API anbietet. Das heißt du musst nichts selbst erschaffen. Du musst nur wissen, wie du darauf zugreifst. Erst einmal musst du einen Scanner anlegen. […]

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. […]

Das Java Vererbung Konzept in einem Rollenspiel

Java ist eine objektorientierte Programmiersprache. Und das bedeutet nicht nur, dass du Objekte einer Java Klasse erzeugen kannst. Es bedeutet auch, dass Java Klassen von anderen Klassen erben können. Wieso das Ganze? Stell dir einmal ein Rollenspiel vor. Wie würdest du ein Rollenspiel entwerfen? In einem Rollenspiel gibt es magische Gegenstände. Zauberringe, Zauberstäbe, welche bei […]

Java Duales Zahlensystem – Binäre Zahlen in Java umwandeln

Java Dual System

Das duale Zahlensystem hat viele Bezeichnungen. Oft wird auch es Dualsystem oder Binärsystem genannt. Es besteht aber immer aus 2 Zahlen. Man verwendet oft die Zahlen 0 und 1. Es können aber auch sämtliche anderen Zahlenpaare sein. Zum Beispiel 7 und 175 sind für sich genommen, auch ein normales Zahlenpaar und somit ein Dualsystem. Mit […]

Java lernen von Kopf bis Fuß

Wenn du Java lernen möchtest, kannst du an meinem kostenlosen Java Kurs teilnehmen. Aber manch Einer hätte gern eine zweite Meinung. Und da bieten sich natürlich Java Bücher an. Eines dieser Java Bücher möchte ich dir jetzt vorstellen. Dieses Buch nennt sich „Java von Kopf bis Fuß“. Was kannst du von diesem Buch erwarten? Also […]

So kannst du Instanzen in Java Klassen zählen

Wie kannst du die Instanzen der Java Klassen zählen? Ganz einfach. Am besten ist es, wir bleiben beim Einführungsbeispiel zu den Java Klassen. Und ich wähle die Klasse „Monster“. Um es einfach zu halten, soll auch der Programmstart durch die Klasse erfolgen. Die Klasse bietet somit eine main-Methode an.