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.


Ähnliche Beiträge

Das Java Leben ist einfacher mit For-Schleife

Java For Schleife Aufbau

In einem anderen Artikeln habe ich bereits über Schleifen in Java gesprochen. In diesem Artikel möchte ich dir eine ganz besondere Schleife vorstellen. Warum ist diese so toll? Sie hat einen integrierten Schleifenzähler. Die Schleife zählt also bei jedem Durchlauf automatisch mit. Aber dazu gleich mehr…. Lass uns einmal so eine For Schleife anlegen.

So kannst du deine Java Methoden ausführen

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

So lassen sich Java Strings in char zerlegen

Java Strings zerlegen char

Java Strings sind Zeichenketten. Und diese Zeichenketten lassen sich aufsplitten und in ihre Einzelteile zerlegen. Ich möchte dir in diesem Beitrag Möglichkeiten vorstellen, wie du Strings in Character-Datentypen zerlegen, extrahieren und die Einzelteile in Arrays speichern kannst.

Ein Java Fenster erzeugen mit dem JFrame

Java-Fenster-erzeugen

Ein Java Fenster erzeugen mit Swing. Java Swing – was ist das? Zum Erstellen von grafischen Benutzeroberflächen, kurz GUI, bietet Java eine eigene Standardklasse an. Diese Klasse nennt sich Swing. Aus dieser Swing-Klasse heraus können Objekte erstellt werden. Diese Objekte lassen sich in vier verschiedene Kategorien einteilen. Fenster und Dialoge bilden das Grundgerüst einer grafischen […]

Java Strings landen im String Constant Pool

Java-Strings-Pool

Du kennst das. Es ist abends. Du sitzt gemütlich vor dem Fernseher. Das Smartphone bimmelt. Kein Anruf. Nein – Eine Nachricht. Du liest die Nachricht sofort und antwortest darauf. Minuten später bekommst du die nächste Nachricht. Und auch auf diese antwortest du. Im Laufe des Abends entsteht daraus eine nette kleine Konversation. Und eh du […]

Nutze das Java Switch Case Statement für komplexe Verzweigungen

Java Switch case

Java switch case statement – was ist das? Wozu brauchst du das? Lass mich anders beginnen… 🙂 In einen meiner früheren Beiträge habe ich schon einmal über bedingte Anweisungen oder Zuweisungen geschrieben. Diese if und else Konstrukte funktionieren eigentlich ganz gut. Aber was ist, wenn du mehrere Parameter abfangen möchtest. Okay ein Beispiel…

Java Objekte leben auf dem Heap

Java-Objekte-Heap

Java hat eine interne Speicherverwaltung. Eigentlich ist es nicht nur eine. Es sind mehrere.   Uns interessieren nur zwei. Methoden und lokale Variablen werden auf dem Stack verwaltet. Und die Speicherverwaltung für Java Objekte und den Instanzvariablen findet auf dem Heap statt.   Ja wieso braucht Java eigentlich zwei Speichersysteme?   Es ist ganz einfach. […]

So verwendest du in Java try und catch Blöcke

Java try und catch

Ich bereue lieber die Dinge, die ich getan habe – als die Dinge, welche ich gar nicht erst versucht habe. Ja ich würde mich als den typischen „try-and-error-Menschen“ bezeichnen. Was ich will, probiere ich einfach aus und schaue dann erst was passiert. So etwas wie Pläne kenne ich eigentlich nicht. Und wenn ich mal einen […]

So lassen sich aus Java Klassen Instanzen erstellen

Java Klassen Instanzen erstellen

Lass uns jetzt aus den Java Klassen heraus Objekte anlegen. Im Einführungsbeispiel hast du bereits gelernt, wie du: Instanzvariablen bzw. Attribute anlegst Wie du aus einer normalen Java Klasse eine Programmstart Klasse machst In diesem Artikel erfährst du: Was Objekte bzw. Instanzen sind. Wie sich Objekte zusammensetzen. Wo und wie du Instanzen aus Java Klassen […]