So implementierst du Instanzmethoden in deine Java Klasse
In einen der letzten Beiträge habe ich dir gezeigt, wie du eine Klasse anlegen kannst.
Ich habe die Klasse „Mensch“ oder „Human“ angelegt und wir haben die erste Instanzvariable implementiert.
Dein Code sollte jetzt so aussehen:
public class Human {
int size=156;//size in centimeter
}
In diesem Beitrag werde ich dir zeigen, wie du Java Methoden, sogenannte Instanzmethoden, in deine Klasse implementierst.
Aber bevor wir anfangen Code zu schreiben, lass mich kurz sagen, was eine Instanzmethode ist.
Und vorallem, wofür du diese brauchst.
Inhalt
Was sind Instanzmethoden in Java
In Java erzeugst du Klassen.
Und so eine Klasse ist ein Bauplan für ein Objekt.
Unsere Klasse „Human“ ist somit ein Bauplan für einen Menschen.
Die Instanzvariable „size“ beschreibt die Größe des Menschen.
Somit sind Instanzvariablen die Eigenschaften, welche den Menschen später ausmachen.
Aber so ein Mensch kann ja etwas.
Er kann laufen, er kann stehen, er kann essen, reden usw.
Und alles was dein Mensch zukünftig können soll, vereinbarst du in Methoden.
Und Methoden, welche auf Objekte wirken, nennen sich Instanzmethoden.
Also beschreiben Instanzmethoden die Interaktionen deiner Objekte.
Die Größe des Menschen haben wir als Variable definiert.
Jetzt implementierst du eine Methode, welche mit dieser Variablen irgendetwas etwas macht.
Ich nenne unsere Methoden einmal „wachsen“ oder englisch „grow“.
Und so erweiterst du deine Java-Klasse um eine Instanzmethode
Ich pack mal gleich den Code aus.
public class Human {
int size=156;//size in centimeter
void grow(){
}
}
Ganz oben im Code haben wir den Klassennamen.
In unseren Fall „Human“.
Darunter steht die Instanzvariable „size“ und deren Kommentar.
Und jetzt folgt die Methodendefinition zur Instanzmethode „grow()“.
Ganz vorn siehst du das Keywort void.
Das Keywort „void“ bedeutet, dass diese Methode kein Rückgabewert erwartet.
Danach folgt der Methodenname, „grow“.
Hier wendest du die Namenskonvention lowerCaseCamelCase an.
Das heißt: Jeder Methodenname beginnt klein.
Und sobald es ein zusammengesetzter Name ist, beginnt das zweite Wort groß.
Falls dein Methodenname einen Bezug auf den Menschen haben soll.
Nenne diese nach CamelCase „growHuman“.
Dann folgen zwei Klammern.
In der Parameterliste können den Methoden bestimmte Startvariablen (Parameter) übergeben werden. Bei unserem Beispiel ist diese leer, also wird ohne Startparameter gestartet
Das ist eine Parameterliste. Dazu später mehr.
Dann erfolgt die geschweifte öffnende Klammer und zum Schluss siehst du noch eine geschweifte schließende Klammer.
Bevor du dich totsuchst…
Die geschweifte öffnende Klammer ist die Tastenkombination: Steuerung+Alt+7
Die geschweifte schließende Klammer: Steuerung+Alt +0
Der Bereich zwischen den beiden Klammern nennt sich Methodenrumpf.
Und hier packst du die komplette Programmlogik bzw. deinen Programmablauf hinein.
Ganz Schluss folgt wieder eine Klammer. Diese Klammer schließt die Klasse „Human“.
Also ganz wichtig.
Alles was in eine Klasse soll, muss innerhalb der Klammer stehen.
Du kannst die untere Klammer einmal markieren und du siehst, dass Eclipse dir farblich die öffnende Klammer anzeigt.
Markiere die schließende Klassenklammer und Eclipse hebt die öffnende Klammer für dich hervor.
Markierst du die vorletzte Klammer, siehst du das Eclipse dir die öffnende Klammer zur Instanzmethode anzeigt.
Markiere die Klammer, welche die Methode schließt und Eclipse zeigt dir auch hier die öffnende Klammer.
Bevor wir jetzt weitermachen, fasse ich das Ganze noch einmal kurz zusammen.
Alle Java Methoden beginnen mit einem Rückgabewert. Dann folgt der Methodenname. Dann folgt die Parameterliste (zwei Klammern) und dann folgt der Methodenrumpf (zwei geschweifte Klammern).
Jede Instanzmethode kannst du als eine Art Baustein verstehen. Und diesen Baustein platzierst du in die Java Klasse.
Die Klasse „Human“ hat ein Anfang und ein Ende. Und der Anfang und das Ende werden durch die geschweiften Klammern verdeutlicht.
Und innerhalb der Klassenklammern packst du jetzt deine Methoden. Dabei ist wichtig, dass du die Methoden ebenfalls als Bausteine verstehst. Diese haben also auch ein Anfang und ein Ende.
Und dies machst du ebenfalls mit den geschweiften Methodenklammern deutlich.
Klassen sind Bausteine innerhalb deines späteren Java Programmes. Die Instanzmethoden sind wiederum die Bausteine in einer Java Klasse. Die Klammern dienen dazu die Grenzen zwischen den Bausteinen klar abzustecken.
Soweit so gut.
Lass uns die Instanzmethode jetzt erweitern
Hier nochmal der Code
public class Human {
int size=156;//size in centimeter
void grow(){
}
}
Jetzt stecken wir mal die Instanzvariable „size“ in die Methode.
Wenn die Methode „wachsen“ oder „grow“ heißen soll, muss der Mensch ja um eine bestimmte Zahl wachsen.
public class Human {
int size=156;//size in centimeter
void grow(){
size=size+15;
}
}
Du siehst im Methodenrumpf, dass ich zur Instanzvariable „size“ 15 hinzuaddiert habe.
Somit wäre der Wert der „size-Variablen“ von 156 auf 171=156+15 gewachsen.
Denke daran in Java immer von rechts nach links lesen.
Wichtig ist, dass hinter jeder Anweisung ein Semikolon folgt. Java bzw. der Compiler registriert dann, dass diese Anweisung abgeschlossen ist.
Die Methode wäre jetzt soweit fertig.
Was wäre, wenn wir den Menschen jetzt nicht um 15 sondern um 30 Zentimeter wachsen lassen möchten.
Klar wir könnten in der Methode die Zahl 15 durch 30 ersetzen.
Wir könnten später beim Programmablauf die Methode auch zweimal durchlaufen lassen.
Oder wir übergeben der Methode einen Parameter.
Und so übergibst du deinen Java Methoden einen Parameter
Hier nochmal der bisherige Code.
public class Human {//die Klasse Human
int size=156;//size in centimeter
void grow(){ //die parameterlose Methode grow verlangt kein Rückgabewert deshalb void
size=size+15;//Der Wert der Instanzvariable size wird durch die Methode grow um 15 erhöht
} //schließende Methodenklammer
}//schließende Klassenklammer
Da das ganze bisher schon eine Menge Stoff ist, habe ich die einzelnen Zeilen jetzt auskommentiert.
Ich weise dich aber gleich daraufhin, dass die Formatierung nicht ganz „javakonform“ ist.
Ich möchte aber erreichen, dass du den Überblick nicht verlierst.
Wenn wir jetzt der Methode einen Parameter übergeben möchten, machen wir dies in der Parameterliste.
public class Human {//die Klasse Human
int size=156;//size in centimeter
void grow(int growthRate){ //Der Methode grow wird der Parameter growthRate vom Datentyp Integer übergeben
size=size+growthRate;
//Der Wert der Instanzvariable size wird durch die Methode grow um den Wert der Variablen "growthRate" erhöht
} //schließende Methodenklammer
}//schließende Klassenklammer
Du siehst jetzt, dass ich der Methode einen Parameter „wachstumsrate“ oder englisch „growthRate“ vom Typ Integer übergeben habe.
Dadurch konnte ich die Zahl 15 durch diese Variable ersetzen.
Dadurch wird das Programm flexibler.
Später kann das Programm vom User eine „wachstumsrate“ oder „growthRate“ abfordern und diese verarbeiten.
Die Methode kann somit nicht nur mit einer Wachstumsrate von 15 rechnen, sondern mit jeder Wachstumsrate, welche der Nutzer später eingibt.
Cool, oder?
Was ist hinsichtlich des Parameters zu beachten.
Der Parameter oder die Variable „growthRate“ kann nur innerhalb der Methode grow() genutzt werden.
Außerhalb dieser Methode, kennt Java diese Variable gar nicht.
Variablen, welche nur innerhalb einer Methode genutzt werden können, bezeichnet man als lokale Variable.
Da „growthRate“ eine Variable ist, gilt hier wieder die Namenskonvention lowerCaseCamelCase.
Die Variable muss einem Datentyp entsprechen.
Als „Wachstumsrate“ oder „growthRate“ wählte ich den Datentyp Integer.
Zusammenfassung:
Eine Instanzmethode stellt immer die Interaktion eines Objektes dar.
Für die Java Programmierung gilt, dass Methodennamen immer in lowerCaseCamelCase geschrieben werden.
Eine Methode besteht immer aus den Bausteinen:
- Rückgabedatentyp (wenn kein Rückgabetyp erwartet, dann void)
- Name
- Parameterliste
- Methodenrumpf
Falls die Methode kein Rückgabetyp erwartet, muss die Methode mit dem Keywort „void“ gekennzeichnet werden.
Du kannst deiner Instanzmethode eine lokale Variable als Parameter übergeben.
Aber diese Variable kann dann nur innerhalb dieser Java Methoden genutzt werden.
Über den Autor
