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

So verwendest du Inkrement und Dekrement Operatoren in deinen Java Programmen

Java Operatoren

In diesem Beitrag geht es um Java Operatoren. Ich möchte dir gern zwei neue Operatoren vorstellen. Diese nennen sich Inkrement und Dekrement. Ja was heißt das? Inkrementieren bedeutet eine schrittweise Erhöhung einer Zahl. Und dementsprechend bedeutet Dekrementieren: Die schrittweise Verminderung einer Zahl. Wozu brauchst du das? Stell dir vor. Du bekommst eine Liste mit Namen […]

Java for Schleifen schachteln – So funktioniert es

Java For Schleifen schachteln

Diese Situation kennst du doch auch…. Du stehst an der Haltestelle und wartest auf den Bus. Dein Blick fällt auf die Uhr.   Oder du wartest an der Ecke auf deinen Freund oder Kollegen. Immer wieder schaust du auf deine Uhr.   Sie ist kaum noch wegzudenken. Die mobile Taschenuhr.   Lange Zeit wurde die […]

Beim Aufruf werden Java Methoden auf dem Stack gestapelt

Java Methoden gestapelt

Java Methoden werden beim Aufruf gestapelt. Und jedes Element auf dem Stapel nimmt Speicherplatz weg. Und manchmal ist es so, dass der Stapel richtig hoch wird und dann…. Ja was passiert eigentlich dann? Betrachten wir einmal ein Computerspiel. Irgendeines. In diesem Computerspiel gibt es Vögel, welche abgeschossen werden sollen. Was bedeutet das denn genau? Beim […]

Java Übung 27 – Auf zur Mathe-Olympiade

Java Übung Mathe Olympiade

In dieser Java Übung möchte ich mit dir ein Programm erstellen, welches ein Mathematik-Test oder eine Mathe-Olympiade simuliert. Du kennst das vielleicht noch aus der Schule. Matheolympiade- Da wurden aus allen vier Grundrechenarten, Aufgaben formuliert. Die Schüler mussten diese Aufgaben lösen. Die Lehrer kontrollierten die Lösungen. Und der Schüler, welcher die wenigsten Fehler hatte – […]

Java Vererbung:
Die 3 Schablonen für deine Java Objekte

Java Vererbung Beispiel

Im letzten Beitrag habe ich dir das Java Vererbung Konzept an einem Beispiel vorgestellt. In dem Beispiel-Rollenspiel gab es Klassen zu Helden und Superhelden. Ich habe dir die Vererbungshierarchien theoretisch erläutert. Jetzt geht es ans Praktische. In diesen Beitrag lernst du: Wie du bestehende Java Klassen erweiterst Wie du Objekte aus den erweiterten Klassen erstellen […]

So kannst du in Java Und Verknüpfung anlegen und auswerten

Java Und

In Java stehen dir eine Menge Operatoren zur Verfügung. Einer dieser Operatoren ist der Und-Operator. Dies ist ein logischer Operator, da dieser sogenannte Wahrheitswerte mit einander verknüpft. Also…. Was erwartet dich in diesem Beitrag? Zuerst möchte ich dir die Aussagenlogik hinter dem Und-Operator zeigen. Also wann sind Aussagen wahr und wann sind diese falsch. Dann […]

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

Java Übung 16 – Bestimme den größten gemeinsamen Teiler

Java Übung Teiler

In dieser Java Übung möchte ich, dass du den größten gemeinsamen Teiler zwei Zahlen ermittelst. Ich möchte, dass du das Ganze mit einer while-Schleife umsetzt. Und wie? Du legst eine neue Klasse „GGT“ (größter gemeinsamer Teiler) an. In diese Klasse implementierst du eine Klassenmethode „berechneGGT“. Diese erwartet zwei Argumente vom Datentyp Integer.

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