Skip to main content

Durch Instanzmethoden können deine Java Objekte richtig coole Sachen machen


Java Objekt Instanzmethode content

Du ahnst es.

Im letzten Artikel hast du von mir erfahren, wie du ein Java Objekt erstellst und wie du dann auf die Instanzvariablen des Objektes zugreifen kannst.

Bei den Instanzmethoden funktioniert es auch so.
Du erschaffst beliebig viele Java Objekte und per Punktnotation, greifst du auf die Methode des Objektes zu.

Und das Ganze machst du in der main Methode.

Und das war es dann auch schon.

Aber hier nochmal ganz konkret.
Unser bisheriger Code:

Code für die Klasse „Human“:

public class Human {
int size=156;//size in centimeter
String firstName;//Vorname als Textwert


void grow(int growthRate){
size=size+growthRate;
}
}


Code der Klasse „ProgrammStart“:

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

Human mathias=new Human();
Human stefan=new Human();
stefan.size=182;
mathias.firstName="Mathias";
stefan.firstName="Stefan";
System.out.println(mathias.firstName+" ist "+mathias.size+" Zentimeter groß");
System.out.println(stefan.firstName+" ist "+stefan.size+" Zentimeter groß");
}
}

Im Code siehst du, dass wir per Punkt-Notation auf mathias.size, stefan.size , mathias.fistName usw zugreifen.
Wir haben somit den Zugriff auf die Variablen der einzelnen Java Objekte.

Und das Ganze stecken wir in die Klammer der System.out.println() Anweisung.
Das Ergebnis ist, dass uns eine Konsolenausgabe den Wert der Variablen zurückgibt.

Und jetzt stecken wir eine weitere Anweisung in die main Methode.
mathias.grow(25) und stefan.grow(10)

Code der Klasse „ProgrammStart“:

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

Human mathias=new Human();
Human stefan=new Human();
stefan.size=182;
mathias.firstName="Mathias";
stefan.firstName="Stefan";
System.out.println(mathias.firstName+" ist "+mathias.size+" Zentimeter groß");
System.out.println(stefan.firstName+" ist "+stefan.size+" Zentimeter groß");
mathias.grow(25);
stefan.grow(10);
}
}

Was passiert hier?
Du hast der grow-Methode den Parameter 25 übergeben.
Du erinnerst dich, dass diese Methode einen Parameter erwartet.

Klicke auf „Run“ und das Programm startet.

Und…..
Hat sich in der Konsolenausgabe etwas verändert?

Warum passiert eigentlich nichts?
Wenn du dir den Methodenrumpf, der grow-Methode, mal anschaust, wird zur ursprünglichen Variable „size“ der Wert des Parameters hinzuaddiert.

Mehr passiert nicht.

Wir haben die Methode als void Methode geschrieben und somit gibt diese auch nichts zurück.
Aber du kannst direkt in die grow Methode eine Anweisung schreiben.

Setze doch einfach mal die System.out.println() Anweisung in die grow-Methode ein.

Und in die Klammer schreibst du jetzt „size“.
Da das ganze wieder etwas blöd aussehen würde, verbindest du dies wieder mit der „firstName“ Variablen und einem netten Text.

Code für die Klasse „Human“:

public class Human {
int size=156;//size in centimeter
String firstName;//Vorname als Textwert


void grow(int growthRate){
size=size+growthRate;
System.out.println("Die Größe von "+firstName+" beträgt jetzt "+size);
}
}

Klicke nochmal auf Run, um das Programm zu starten.

Code der Klasse „ProgrammStart“:

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

Human mathias=new Human();
Human stefan=new Human();
stefan.size=182;
mathias.firstName="Mathias";
stefan.firstName="Stefan";
System.out.println(mathias.firstName+" ist "+mathias.size+" Zentimeter groß");
System.out.println(stefan.firstName+" ist "+stefan.size+" Zentimeter groß");
mathias.grow(25);
stefan.grow(10);
}
}

Jetzt wird beim Programmstart wieder die grow-Methode aufgerufen.

Und die grow-Methode addiert den Wert der size Variablen mit dem Wert, welchen du der Methode übergeben hast.
Und jetzt gibt sie eine Bildschirmausgabe aus.

Cool oder?

Aber was mache ich, wenn beide Menschen immer nur um 10 Zentimeter wachsen sollen?
Und das immer.
Die Methode soll immer nur um 10 erhöhen.

Dann darfst du der Methode beim Aufruf (in der main Methode) keinen Parameter übergeben.

Das bedeutet auch, dass du die Methode ohne Parameterliste anlegen musst.

Code für die Klasse „Human“:

public class Human {
int size=156;//size in centimeter
String firstName;//Vorname als Textwert


void grow(){ //Methode erwartet keinen Parameter
size=size+growthRate;
System.out.println("Die Größe von "+firstName+" beträgt jetzt "+size);
}
}

Schreib diese falsch angelegte Methode einmal so ab und schau was passiert.

Eclipse kann natürlich mit der Variablen „growthRate“ nichts mehr anfangen.

Ersetze deshalb in der Anweisung size=size+growthRate; die Variable durch einen Wert.
Beispielsweise 10.

Code für die Klasse „Human“:

public class Human {
int size=156;//size in centimeter
String firstName;//Vorname als Textwert


void grow(){ //Methode erwartet keinen Parameter
size=size+10;
System.out.println("Die Größe von "+firstName+" beträgt jetzt "+size);
}
}

Und niemand meckert mehr, oder?

Nicht ganz…
Schauen wir uns jetzt die main-Methode an.

Du siehst, dass wir durch die Anweisung grow(25); einen Parameter übergeben haben.
Unsere grow-Methode ist jetzt aber parameterlos.

Das heißt wir müssen die Parameter 25 und 10 aus dem Methodenaufruf löschen.
Und dann läufts wieder.

Code der Klasse „ProgrammStart“:

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

Human mathias=new Human();
Human stefan=new Human();
stefan.size=182;
mathias.firstName="Mathias";
stefan.firstName="Stefan";
System.out.println(mathias.firstName+" ist "+mathias.size+" Zentimeter groß");
System.out.println(stefan.firstName+" ist "+stefan.size+" Zentimeter groß");
mathias.grow();
stefan.grow();
}
}

Klicke auf „Run“ und los gehts.
Durch den Programmstart springt das Programm in die grow-Methode und rechnet zur „size“ Variablen den Wert 10 hinzu.

Was sagt uns das jetzt?
Du entscheidest also, ob du einer Methode einen Parameter übergeben willst, oder nicht.

Wenn du keinen Parameter übergeben willst, musst du die Methode parameterlos (kein Wert in den Klammern) aufrufen.

Wenn die Methode einen Parameter erwartet, musst du diesen beim Aufruf der Methode in die Klammer (Parameterliste) schreiben.

Na ist dein Spieltrieb geweckt?
Dann lass uns rumspielen….

Jetzt übergeben wir der Instanzmethoden einen weiteren Parameter

Ich möchte erreichen, dass wir mit zwei oder mehreren Wachstumsraten rechnen.

Also können wir doch einfach den „growthRate“ Parameter wieder in die Methode stecken und die Methode entsprechend anpassen.

Okay machen wir.
Jetzt übergeben wir aber noch einen weiteren Parameter „Anzahl der Wachstumsraten“ oder englisch „numberOfGrowthRate“.

Da dieser neue Parameter wieder eine Zahl ist, müssen wir wieder einen Integer Datentyp festlegen.
Beide Parameter werden durch ein Komma getrennt.

Du hast den neuen Parameter in die Liste eingefügt?

Toll dann müssen wir diesen noch in die Programmlogik integrieren.

Code für die Klasse „Human“:

public class Human {
int size=156;//size in centimeter
String firstName;//Vorname als Textwert


void grow(int growthRate, int numberOfGrowthRate){
size=size+growthRate*numberOfGrowthRate;
System.out.println("Die Größe von "+firstName+" beträgt jetzt "+size);
}
}

Was rechnet unsere Methode?

Als erstes werden beide Parameter mit einander multipliziert.
Denn Punktrechnung geht auch in Java vor Strichrechnung.

Und diesem Teilergebnis wird jetzt der Wert der Instanzvariablen hinzuaddiert.

Passen wir die main Methode noch an.

In der main Methode ist jetzt der Methodenaufruf parameterlos.

Wir müssen jetzt zwei Parameter in die jeweiligen Anweisungen eingeben und fertig.

Bei „stefan“ wähle ich jetzt 3 Durchläufe mit jeweils 15 Zentimetern.
Und bei „mathias“ wähle ich 4 Durchläufe mit jeweils 8 Zentimetern.
Bitte trenne auch hier die Parameter durch ein Komma.

Code der Klasse „ProgrammStart“:

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

Human mathias=new Human();
Human stefan=new Human();
stefan.size=182;
mathias.firstName="Mathias";
stefan.firstName="Stefan";
System.out.println(mathias.firstName+" ist "+mathias.size+" Zentimeter groß");
System.out.println(stefan.firstName+" ist "+stefan.size+" Zentimeter groß");
mathias.grow(15 ,3 ); //Wachstumsrate in cm: 15 , Anzahl der Wachstumsarten: 3
stefan.grow(8 , 4);//Wachstumsrate in cm: 8 , Anzahl der Wachstumsarten: 4
}
}

Dann lassen wir unser Programm mal rechnen.

Drücke auf „Run“, lehn dich zurück und genieß die Show. 🙂

Zusammenfassung:

  • Eine Instanzmethode kannst du auf allen Java Objekten per Punkt-Notation aufrufen.
  • Du kannst jeder Instanzmethode verschiedene Parameter übergeben.
  • Dabei solltest du nur beachten, dass du dies entsprechend im Methodenaufruf (Stichwort: main Methode) anpasst.
  • Du kannst in deinen Methodenrümpfen verschiedene Anweisungen einpflegen und diese dann ausführen lassen.

Na hast du etwas herumgespielt?
Welche Erfahrungen hast du gemacht?
Vielleicht möchtest du mir einen Kommentar unter diesen Beitrag schreiben.
Dann nutze doch bitte das Kommentarfeld direkt unter dem Beitrag.