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

So kannst du mit dem StringTokenizer Java Strings zerlegen oder splitten

Java StringTokenizer Java Strings teilen zerlegen splitten

Java StringTokenizer – was ist das? Bevor ich diese Frage kläre, schiebe ich eine zweite Frage hinterher. Denn im Wort Tokenizer steckt das Wort Token. Also was ist ein Token? Hier die Definition zum Token: Ein Token ist eine bestimmte Aneinanderreihung von Zeichen. Man kann auch sagen, eine lexikalische Einheit. Das kann zum Beispiel eine […]

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

Der wichtige Unterschied zwischen Java Methoden

Java Methoden Unterschied

Jetzt machen wir Nägel mit Köpfen. Dieses Sprichwort stammt aus den Anfängen des Industriezeitalters. Denn früher wurden Nägel nicht industriell, sondern per Hand gefertigt. Und da kam es schon einmal vor, dass versehentlich Nägel ohne Kopf produziert wurden. Was blieb ist das Sprichwort „Nägel mit Köpfen“ Und dieses steht sinngemäß für eine schnelle, qualitativ hochwertige […]

Java For Each Schleife – Aufbau und Funktionsweise

Java for each Schleife

In einer anderen Lektion habe ich dir bereits gezeigt, wie du ein Java Array mit einer for-Schleife füllen und dir später die Werte zurückgeben lassen kannst. Es gibt allerdings einen weiteren Schleifentyp, welche geradezu prädestiniert ist für Java Arrays. Dieser Schleifentyp nennt sich for each Schleife. In diesem Beitrag möchte ich dir zeigen, wie du […]

So verwendest du den Java Oder Operator

Java Oder Operator

Kennst du das auch aus deiner Schulzeit? Du schreibst eine Klassenarbeit in irgendeinem Fach. Nehmen wir einfach mal an – Mathe. Jetzt bist gerade fertig mit deiner Arbeit. Und zu Hause wirst du gefragt: „Und wie lief es?“ Du antwortet:“ Ganz gut. Es wird bestimmt eine Eins oder eine Zwei.“ Drei oder vier Tage später […]

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

Overriding und Vererbung – So lassen sich Java Methoden überschreiben

Java Methoden überschreiben

In Deutschland entstehen jeden Tag tolle Geschichten. So wie diese hier…. Die größte Turmuhr der Welt, die Makkah Clock, steht in Saudi – Arabien. Und zwar direkt in Mekka. Hier ein paar Eckdaten zur Uhr: Höhe des Turmes 601 m. Das Ziffernblatt der Turmuhr hat einen Durchmesser von 43 Meter Die Länge des Minutenzeigers beträgt […]

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.

Verwalte deine Java Klassen in packages

java klassen verwalten

Es macht durchaus Sinn deine Java Klassen in verschiedenen Paketen zu organisieren. Wieso? Es sprechen mehrere Gründe dafür: Du kannst doppelte Klassennamen verwenden Du kannst deinen Code oder deine Klassen inhaltlich trennen Du kannst Hierarchien abbilden. Und genau um diese Dinge geht es in diesem Beitrag