Skip to main content

Der wichtige Unterschied zwischen Java Methoden

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

Und was hat das mit Java Methoden zu tun?
Erst einmal nicht viel.

Aber ich möchte jetzt zwei Klassen entwerfen.
Und diese heißen….

Nägel und Köpfe.

Anhand dieser zwei Klassen möchte ich dann zwei Instanzmethoden implementieren, welche die jeweilige Anzahl und die Größe zurückgeben.

Außerdem möchte ich eine statische Methode implementieren.

Anhand dieser Java Methoden möchte ich dir den Unterschied zwischen Klassen- und Instanzmethoden zeigen.

Also lass uns Nägel mit Köpfen machen. 🙂

Diese zwei Klassen besitzen jeweils zwei Java Methoden.

Beide Java Methoden sind Instanzmethoden.

Außerdem werden jeweils zwei Instanzvariablen deklariert.

Ich verzichte auf getter und setter

  • weil es sonst sehr unübersichtlich wird
  • weil der Fokus woanders liegt.

Ich biete somit die Instanzvariablen direkt an.

Und so sehen meine Klassen aus:


public class Nagel{
public int nagelGroesse;//in Zentimeter
public int nagelAnzahl;


public void gibNagelGroesseZurueck(){
System.out.println("Die Größe des Nagels beträgt: "+nagelGroesse);
}
public void gibNagelAnzahlZurueck(){
System.out.println(nagelAnzahl+" Nägel sind vorhanden.");
}
}



public class Kopf{
public int kopfGroesse;//in Zentimeter
public int kopfAnzahl;


public void gibKopfGroesseZurueck(){
System.out.println("Die Größe des Kopfes beträgt: "+kopfGroesse);
}
public void gibKopfAnzahlZurueck(){
System.out.println(kopfAnzahl+" Köpfe sind vorrätig");
}
}

Jetzt noch die Klasse für den Programmstart, namens „Fertigungsprogramm“.
In dieser befindet sich die main Methode.


public class FertigungsProgramm{
public static void main (String [] args){
}
}

Und jetzt erstellst du über den default-Konstruktor jeweils ein Kopf- und ein Nagelobjekt.
Über die Punktnotation kannst du den Instanzvariablen Werte zuweisen.
Und du kannst die Instanzmethoden der Objekte aufrufen.


public class FertigungsProgramm{
public static void main (String [] args){
Nagel langerNagel = new Nagel();
Kopf grosserKopf= new Kopf();

langerNagel.nagelGroesse=20;
langerNagel.nagelAnzahl=200;

grosserKopf.kopfGroesse=5;
grosserKopf.kopfAnzahl=180;

grosserKopf.gibKopfAnzahlZurueck();
grosserKopf.gibKopfGroesseZurueck();
langerNagel.gibNagelAnzahlZurueck();
langerNagel.gibNagelGroesseZurueck();
}
}

Klicke auf „Run“.
Es sollten jetzt die entsprechenden Bildschirmausgaben zurück gegeben werden.

Und jetzt implementierst du die erste statische Methode

Was soll diese machen?

Diese soll die Arbeit beider Instanzmethoden übernehmen.

Und zwar möchte ich dieser Java Methode einen Parameter vom Typen des Objektes übergeben.
Und dann gibt diese Methode die Größe und die Anzahl je Objekt zurück.

Du kannst diese Methode direkt in die Klasse Fertigungsprogramm aufnehmen oder du lagerst das ganze nochmals aus.

Ich bleibe bei meinem Fertigungsprogramm.
Und so würde der Code aussehen.


public class FertigungsProgramm{
public static void gibWerteZurueck(Nagel nagelObjekt){
System.out.println("Die Größe des Nagels beträgt: "+nagelObjekt.nagelGroesse);
System.out.println(nagelObjekt.nagelAnzahl+" Nägel sind vorhanden.");
}
public static void gibWerteZurueck(Kopf kopfObjekt){
System.out.println("Die Größe des Kopfes beträgt: "+kopfObjekt.kopfGroesse);
System.out.println(kopfObjekt.kopfAnzahl+" Köpfe sind vorrätig");
}
public static void main (String [] args){
Nagel langerNagel = new Nagel();
Kopf grosserKopf= new Kopf();

langerNagel.nagelGroesse=20;
langerNagel.nagelAnzahl=200;

grosserKopf.kopfGroesse=5;
grosserKopf.kopfAnzahl=180;

gibWerteZurueck(langerNagel);
gibWerteZurueck(grosserKopf);
}
}

Was ist passiert?
Du schreibst eine überladene Methode.
Die Methode hat das Keyword static im Methodenkopf.

Dieses Keyword signalisiert Java: „Das ist eine Klassenmethode“

In der Parameterliste erwartet diese entweder ein Nagel- oder ein Kopfobjekt.

Dann rufst du die Methode auf.
Beim Aufruf übergibst du ihr die erstellten Objekte.

Und was hat das jetzt gebracht?
Wir haben entweder zwei Instanzmethoden oder zwei Klassenmethoden.
Bis jetzt hat das noch nicht viel gebracht?

Doch, wenn du jetzt nämlich einen zweiten Nagel und einen zweiten Kopf erstellen würdest….
Dann würde der Ansatz über Instanzmethoden so aussehen.


public class FertigungsProgramm{
public static void main (String [] args){
Nagel langerNagel = new Nagel();
Nagel grosserNagel = new Nagel();
Kopf grosserKopf= new Kopf();
Kopf langerKopf= new Kopf();

langerNagel.nagelGroesse=20;
langerNagel.nagelAnzahl=200;

grosserNagel.nagelGroesse=10;
grosserNagel.nagelAnzahl=220;

grosserKopf.kopfGroesse=5;
grosserKopf.kopfAnzahl=180;

langerKopf.kopfGroesse=10;
langerKopf.kopfAnzahl=70;

grosserKopf.gibKopfAnzahlZurueck();
grosserKopf.gibKopfGroesseZurueck();
langerNagel.gibNagelAnzahlZurueck();
langerNagel.gibNagelGroesseZurueck();
langerKopf.gibKopfAnzahlZurueck();
langerKopf.gibKopfGroesseZurueck();
grosserNagel.gibNagelAnzahlZurueck();
grosserNagel.gibNagelGroesseZurueck();
}
}

Und der Ansatz über die Klassenmethode so.


public class FertigungsProgramm{
public static void gibWerteZurueck(Nagel nagelObjekt){
System.out.println("Die Größe des Nagels beträgt: "+nagelObjekt.nagelGroesse);
System.out.println(nagelObjekt.nagelAnzahl+" Nägel sind vorhanden.");
}
public static void gibWerteZurueck(Kopf kopfObjekt){
System.out.println("Die Größe des Kopfes beträgt: "+kopfObjekt.kopfGroesse);
System.out.println(kopfObjekt.kopfAnzahl+" Köpfe sind vorrätig");
}
public static void main (String [] args){
Nagel langerNagel = new Nagel();
Nagel grosserNagel = new Nagel();
Kopf grosserKopf= new Kopf();
Kopf langerKopf= new Kopf();

langerNagel.nagelGroesse=20;
langerNagel.nagelAnzahl=200;

grosserNagel.nagelGroesse=10;
grosserNagel.nagelAnzahl=220;

grosserKopf.kopfGroesse=5;
grosserKopf.kopfAnzahl=180;

langerKopf.kopfGroesse=10;
langerKopf.kopfAnzahl=70;

gibWerteZurueck(langerNagel);//Und als Argument übergibst du das gewünschte Objekt
}
}

Du musst die Klassenmethoden zwar auch einmal schreiben.
Du kannst beim Methodenaufruf ihr aber alle möglichen Argumente (aller Objekte) übergeben.

Du siehst, dass du mit den Klassenmethoden in so einem Fall flexibler verfahren würdest.

Die Methoden in den Nagel- und Kopfklassen kannst du dann auch löschen.
Du hast diese beiden Java Methoden jetzt als statische (Klassenmethode) Methode implementiert.

Wir können also festhalten:
Instanzmethoden sollten für ein bestimmtes Objekt implementiert werden.

Und Klassenmethoden stehen für alle Objekte zur Verfügung.

Lass uns noch ein weiteres Beispiel durchführen.

Klassenmethoden eignen sich gut für Nebenrechnungen

Ich habe es ja schon erwähnt.

Früher hatte nicht jeder Nagel einen Kopf.

Lass uns doch einmal eine Java Methode implementieren, welche die Differenz ausrechnet.

Die Methode erwartet somit zwei Parameter:

  • Die Anzahl der Köpfe
  • Die Anzahl der Nägel

Du wirst es dir denken können.
Wir sollten eine statische Methode nutzen.

Du hast Recht.
Ich möchte dennoch das Ganze als Instanzmethode einmal durchdenken.

Also fangen wir an.
Wo implementieren wir die Instanzmethode?
In der Kopf- oder in der Nägelklasse?
Passt die Differenz mehr zu Nägeln oder doch mehr zu Köpfen?

Und wie kommen wir in einer Klasse an die Instanzvariablen aus der anderen Klasse?
Hmm…

Vielleicht sollten wir eine neue Klasse Differenz schaffen?
Und in dieser Klasse bieten wir eine Instanzmethode an?

Dann schaffen wir zum Programmstart ein Objekt dieser Klasse und rufen die Instanzmethode auf?

Eh… nein
Viel einfacher ist es wirklich, das Ganze in eine Klassenmethode zu stecken.
Du brauchst kein unnützes Objekt schaffen.
Du musst keine zusätzliche Klasse schaffen.

Jetzt kannst du der Methode beide Parameter übergeben und fertig.


public class FertigungsProgramm{
public static void berechnenDifferenz(Nagel nagelObjekt, Kopf kopfObjekt){
System.out.println("Wir benötigen "+(nagelObjekt.nagelAnzahl-kopfObjekt.kopfAnzahl)+" Nägel.");
}
public static void main (String [] args){
Nagel langerNagel = new Nagel();
Kopf grosserKopf= new Kopf();

langerNagel.nagelGroesse=20;
langerNagel.nagelAnzahl=200;

grosserKopf.kopfGroesse=5;
grosserKopf.kopfAnzahl=180;

berechnenDifferenz(langerNagel,grosserKopf );
}
}

Also halten wir fest:
Instanzmethode kannst du immer nur auf einem Objekt aufrufen.

Somit müsstest du für Nebenrechnungen immer Extra Objekte schaffen.
Und das ist total blöd.
Nutze deshalb Klassenmethoden für Nebenrechnungen.

Die wichtigste Klassenmethode ist die main Methode
Und diese ist notwendig, um das Programm zu starten.

Und diese ich nicht rein zufällig statisch.

Und dies führt uns zur dritten Einsatzmöglichkeit von Klassenmethoden.
Klassenmethoden dienen dem Programmablauf.

Zusammenfassung:

  • Klassenmethoden werden durch das Keyword static deklariert.
  • Klassenmethoden bezeichnet man auch als statische Methoden.
  • Instanzmethoden können nur für bestimmte Objekte aufgerufen werden.
  • Klassenmethoden dienen allen Objekten.
  • Klassenmethoden können weiterhin für den Programmablauf und für Nebenrechnungen verwendet werden.

Wie hat dir dieser Artikel zu den Java Methoden und deren Unterschieden gefallen?
Hast du Fragen oder Anmerkungen?
Dann nutze doch das Kommentarfeld unter dieser Beitrag und hinterlasse ein Kommentar.