Skip to main content

So kannst du Java Objekte erstellen


Java Objekte

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.

Unser bisheriger Code zur „Human-Klasse“ sieht so aus:

public class Human {
int size=156;//size in centimeter


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


Unser bisheriger Code zur „ProgrammStart-Klasse“ sieht so aus:

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.

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.

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.


Konsole gibt Wert zurück

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.

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;
}
}

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.

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ß");
}
}

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.
Schreib mir doch deine Erfahrungen unter diesen Artikel.


Ähnliche Beiträge

So nutzt du die While Schleife in deinem Java Programm

Java While Schleife

Manchmal ist es wichtig, Dinge einmal öfter zu tun. Bei der Java Programmierung kann es schonmal sein, dass du einen Code mehrfach ausführen lassen musst. Zum Beispiel die Zahlen eins bis zehn. Ein Java Programm, welches die Zahlen eins bis zehn wiedergibt. Na wie wäre das? Der Java Code dazu würde so aussehen: public class […]

So lassen sich Java Arrays kopieren

Java Arrays kopieren

Java Arrays kopieren oder klonen…. Was heißt das eigentlich? Eine Kopie ist eine Reproduktion bzw. die Nachbildung eines Originals. Somit ist jede Fotographie – die Abbildung einer bestimmten optischen Wirklichkeit, zu einem festen Zeitpunkt. Die Kopie einer Buchseite ist das optische Abbild dieser spezifischen Buchseite – auch zu einem festen Zeitpunkt. Wichtig in diesem Zusammenhang […]

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 lernen durch ständiges Testen – Nutze die Testumgebung von Eclipse

Java Programmierung lernen

Probieren geht über studieren Wenn du wirklich Java Programmierung lernen möchtest, dann solltest du Java nicht aus einem Buch lernen. Du solltest auch nicht strikt von dieser oder anderen Webseiten lernen. Etwas wirklich zu lernen, setzt die Bereitschaft voraus, etwas zu probieren. Denn nur durch eigenes Probieren gelangst du zum Wesentlichen. Durch Probieren wirst du […]

Overriding und Vererbung – So lassen sich Java Methoden überschreiben

Java Methoden überschreiben

In Deutschland entstehen jeden Tag tolle Geschichten. So wie diese hier…. Die größte Turmuhr der Welt, die Makkah Clock, steht in Saudi – Arabien. Und zwar direkt in Mekka. Hier ein paar Eckdaten zur Uhr: Höhe des Turmes 601 m. Das Ziffernblatt der Turmuhr hat einen Durchmesser von 43 Meter Die Länge des Minutenzeigers beträgt […]

So organisierst und verwaltest du ganz bequem deine Java Projekte

Du kennst das auch. Denn du bist ja fleißig. Und weil du so fleißig bist, hast du mitunter auch mehrere Java Projekte gleichzeitig laufen. Und dann kommt es vor, dass du enorm viele Java Projekte am Laufen hast. Und dein Package-Explorer wird extrem unübersichtlich. In diesem Beitrag möchte ich dir zwei Varianten vorstellen, wie du […]

So unterstützen dich Java Vererbungstabellen beim Entwurf

Java Vererbungstabellen

Bei der Java Vererbung gibt es zwei Klassenarten bzw. -stufen. Die Superklassen, welche einen allgemeinen Typen darstellen Und die spezielleren Unterklassen, welche die Superklasse um bestimmte Funktionen erweitern. Jetzt ist dieses ganze „Der-erbt-von-dem-Konzept“ mitunter sehr schwierig darzustellen. Zum Beispiel in einem Werkzeugkoffer. In einem Werkzeugkoffer befinden sich sämtliche Werkzeuge, von Säge bis Bohrmaschine. Wie machst […]