So kannst du Java Objekte bzw. Instanzen einer Klasse erstellen
Lass uns jetzt ein paar Java Objekte erstellen.
Im letzten Beitrag habe ich dir gezeigt, was nötig ist um ein Java Programm überhaupt zu starten.
Ich habe dir gezeigt, wie du eine zweite Klasse anlegst und die main Methode implementierst.
Du hast gesehen, dass die Anweisung, welche wir in die main Methode geschrieben haben, völlig willkürlich sein kann.
Diese Anweisung hatte also nichts mit unserer Java – Objekt- Klasse zu tun.
In diesem Beitrag möchte ich dir zeigen, wie du nun endlich „Menschobjekte“ erzeugen kannst.
Außerdem möchte ich dir zeigen, wie du auf Instanzvariablen zugreifen kannst.
Und ich werde dir den großen Vorteil der objektorientierten Programmierung zeigen.
Inhalt
Von der Java Klasse zum Java Objekt
public class Human {
int size=156;//size in centimeter
void grow(int growthRate){
size=size+growthRate;
}
}
public class ProgrammStart {
public static void main (String [] args){
}
}
Ein Java Objekt wird immer durch einen Konstruktor erschaffen.
Und so einen Konstruktor legen wir jetzt innerhalb der main Methode einmal an.
public class ProgrammStart {
public static void main (String [] args){
new Human();
}
}
Das Keywort „new“ weist daraufhin, dass hier ein neues Objekt geschaffen werden soll.
Der Name des Konstruktors ist „Human“.
Dieser muss dem Klassennamen des zukünftigen Objektes entsprechen.
Dann erfolgt die Parameterliste. Diese ist zu diesem Zeitpunkt leer.
Hinter jeder Anweisung kommt ein Semikolon.
Zu diesem Zeitpunkt haben wir ein Objekt aus der Klasse Human geschaffen.
Wir können aber noch nicht auf dieses Objekt zugreifen.
Wir müssen, wie bei einer Instanzvariablen einen Speicherort für dieses Objekt angeben.
Und genau wie bei der Deklaration einer Instanzvariablen melden wir einen Datentyp und einen Namen für das Objekt an.
public class ProgrammStart {
public static void main (String [] args){
Human mathias;
new Human();
}
}
Da „mathias“ der Name einer Variablen ist, wird dieser laut Namenskonvention wieder klein geschrieben.
Falls ich den Namen Mathias Mücke gewählt hätte, müsste dieser nach bestehender Namenskonvention mathiasMücke sein.
Jetzt erfolgt die Zuweisung. Wir haben eine Variable im Hauptspeicher, namens mathias angelegt und dafür einen Speicher vom Datentyp „Human“ reserviert.
Und die Zuweisung ist jetzt der Konstruktor.
public class ProgrammStart {
public static void main (String [] args){
Human mathias;
mathias=new Human();
}
}
Oder es ist vielleicht besser und einfacher, das Ganze in einem Zug zu vollziehen.
public class ProgrammStart {
public static void main (String [] args){
Human mathias=new Human();
}
}
Was ist bis jetzt passiert?
Lies von rechts nach links.
Du hast ein Objekt angelegt.
Diesem Objekt hast du den Namen „mathias“ gegeben.
Und du hast diesem Objekt einen Speicherplatz in Höhe einer Human-Variablen zugewiesen.
Mehr ist bisher nicht passiert.
Wenn du jetzt auf „Run“ klickst, passiert gar nichts. Du hast lediglich das Objekt angelegt. Du hast aber noch keine Anweisung geschrieben, was jetzt mit dem Objekt passieren soll.
Und diese Anweisung schreiben wir jetzt.
Du kannst jetzt auf das Objekt „mathias“ zugreifen.
Wir haben eine Instanzvariable „size“ in der Klasse „Human“, welche uns die Körpergröße eines Menschen zurückgibt.
Wir werden jetzt beim Programmstart auf die Variable des Objektes zugreifen.
Der Zugriff auf diese Variable erfolgt per Punkt-Notation.
Dazu musst du einfach den Objektnamen eingeben.
Dann den Punkt.
Zum Schluss gibst du die Variable ein, auf welche du zugreifen möchtest.
Und so am Beispiel: mathias.size
Da „mathias“ ein Objekt aus der Human-Klasse ist, kannst du nur auf Instanzvariablen aus der Klasse „Human“ zugreifen.
Und diese betten wir jetzt in unsere Konsolenausgabe ein. (System.out.println()-Anweisung)
public class ProgrammStart {
public static void main (String [] args){
Human mathias=new Human();
System.out.println(mathias.size);
}
}
Klicke oben auf Run und eine Konsolenausgabe wird zurückgegeben.
Die Zahl entspricht dem Wert, welchem du der Instanzvariable zugewiesen hast.
Du siehst, dass lediglich eine Zahl ausgegeben wird.
Das ist natürlich etwas blöd.
Lass uns die Anweisung erweitern.
public class ProgrammStart {
public static void main (String [] args){
Human mathias=new Human();
System.out.println("Mathias ist "+mathias.size+" Zentimeter groß");
}
}
Wir haben jetzt die Anweisung um zwei Textwerte erweitert.
Wichtig ist, dass Textwerte immer in Anführungszeichen stehen müssen.
Weiterhin wichtig ist, dass du diese Textwerte über den „+ Operator“ mit deinen Variablen verbindest.
Du fügst quasi mehrere Bildschirmausgaben zusammen zu einer.
Legen wir ein zweites Java Objekt an und es nennen es „Stefan“.
public class ProgrammStart {
public static void main (String [] args){
Human mathias=new Human();
Human stefan=new Human();
System.out.println("Mathias ist "+mathias.size+" Zentimeter groß");
}
}
Stefan ist jetzt aber nicht 156 groß. Stefan ist größer.
Wir überschreiben den Wert der Instanzvariable „size“ für das Objekt Stefan.
public class ProgrammStart {
public static void main (String [] args){
Human mathias=new Human();
Human stefan=new Human();
stefan.size=182;
System.out.println("Mathias ist "+mathias.size+" Zentimeter groß");
}
}
Und jetzt geben wir den Wert der Instanzvariablen „size“ für das Objekt Stefan aus.
public class ProgrammStart {
public static void main (String [] args){
Human mathias=new Human();
Human stefan=new Human();
stefan.size=182;
System.out.println("Mathias ist "+mathias.size+" Zentimeter groß");
System.out.println("Stefan ist "+stefan.size+" Zentimeter groß");
}
}
Klicke auf „Run“ und Die Bildschirmausgabe sollte sich jetzt für Stefan anpassen.
Was ist passiert?
Du erschaffst ein Objekt und weist diesem Objekt einen Speicherplatz zu.
Und an einer anderen Stelle erschaffst du ein zweites Objekt vom selben Typ.
Beide Objekte besitzen die gleichen Eigenschaften. Sie greifen also auf die gleichen Typen von Instanzvariablen zu.
Der Unterschied besteht darin, dass du den Instanzvariablen unterschiedliche individuelle Werte zuweisen kannst.
Deine Java Objekt führen somit für jede Instanzvariable einen eigenen unterschiedlichen Wert.
Du verwaltest deine Objekte zentral und passt diese auch zentral an. Durch eine Anpassung, in der entsprechenden Klasse, verändern sich aber die Möglichkeiten für alle Objekte.
Cool oder?
Dann lass uns doch das Ganze mal zentral für alle Java Objekte anpassen.
Wie machst du das?
In der Human Klasse setzt du eine zweite Instanzvariable ein.
public class Human {
int size=156;//size in centimeter
String firstName;//Vorname als Textwert
void grow(int growthRate){
size=size+growthRate;
}
}
String ist ein Datentyp, welcher einen Speicherplatz für einen Textwert reserviert.
Der Name der Variablen heißt „firstName“.
Die Zuweisung brauchst du an dieser Stelle nicht machen, da wir eh die Variablen beim Programmstart überschreiben können.
Das war es schon.
Jedes deiner „Mensch“ oder „Human“ Objekte kann jetzt einen individuellen Vornamen erhalten.
Und diesen weisen wir jetzt zu.
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ß");
}
}
Wichtig ist, dass die Namen „Mathias“ und „Stefan“ Textwerte sind.
Und bei der Zuweisung von Textwerten, müssen diese immer Anführungsstrichen gesetzt werden.
Du siehst, dass du per Punktnotation auf das Objekt „mathias“ und auf das Objekt „stefan“ zugreifen kannst.
Und durch diese Punktnotation kannst du auch die Werte der einzelnen objektbezogenen Instanzvariablen überschreiben.
Und letztlich kannst du diese auch ausgeben lassen.
Wenn dir der Vorteil der objektorientierten Programmierung noch nicht klar sein sollte….
dann denke bitte einmal über eine andere Möglichkeit nach.
Angenommen du möchtest Mensch-Objekte namens Michael, Mathias, Stefan, Gustav und weitere hundert schaffen.
Ohne objektorientierte Programmierung müsstest du in deiner Klasse „Human“ jetzt 100 Instanzvariablen vom Typen String anlegen.
Und die nennst du jetzt vorname1, vorname2 ….. vorname100.
Und dann könntest du in verschiedenen Anweisungen auf die einzelnen Variablen zugreifen.
Im objektorientierten Kontext machst du alles nur einmal und kannst beliebig oft darauf zu greifen.
- Somit wird die Sache richtig flexibel.
- Du hältst den Code schön klein und übersichtlich.
- Du musst dir nicht 100 verschiedene Variablennamen ausdenken.
Ist doch schon besser so, oder?
Zusammenfassung:
- Objektorientierte Programmierung setzt darauf eine Klasse zu schaffen. Dieser Klasse werden Methoden und Instanzvariablen zugewiesen.
- Und aus dieser Klasse lassen sich beliebig viele Objekte kreieren.
- Um ein Objekt zu schaffen, benötigst du einen sogenannten Konstruktor.
- Der Konstruktor beginnt immer mit dem Keyword new. Dieses Keyword ruft den Konstruktor auf.
- Dann folgt der Konstruktorname. Dies ist immer der Klassenname, aus welchem das Objekt erschaffen werden soll.
- Und dann kommt eine Parameterliste.
- Für jedes Objekt muss Speicherplatz reserviert werden. Dies erfolgt durch eine Deklaration.
- Du gibst den Namen des Objektes an und den Datentyp. Der Datentyp entspricht dem Klassennamen.
- Der Name des Objektes wird klein geschrieben. Bei zusammengesetzten Namen schreibst du den Anfang klein und das zweite Wort groß.
- Auf das Objekt und deren Instanzvariablen kannst du in Java per Punkt-Notation zugreifen.
Probier dich aus! Lege verschiedene Variablen, Klassen und Java Objekte an und kombiniere die Möglichkeiten.
Über den Autor
