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

Java lernen von Kopf bis Fuß

Wenn du Java lernen möchtest, kannst du an meinem kostenlosen Java Kurs teilnehmen. Aber manch Einer hätte gern eine zweite Meinung. Und da bieten sich natürlich Java Bücher an. Eines dieser Java Bücher möchte ich dir jetzt vorstellen. Dieses Buch nennt sich „Java von Kopf bis Fuß“. Was kannst du von diesem Buch erwarten? Also […]

Achte bei Java Methoden stets auf die Wertübergabe

Java Methoden Wertübergabe

Ich lege gleich los…. Schau dir diesen Code einmal an. Welche Zahl wird wohl auf der Bildschirmanzeige zurückgegeben? public class MethodenWertUebergabe { static int verdoppele (int i){ i=i*2; return i; } public static void main(String[] args) { int i = 2; verdoppele(i); System.out.println(i); } }

So nutzt du Methoden aus der Java String Klasse

Java Strings Methoden

In einen der letzten Beiträge haben wir darüber gesprochen, dass Java Strings – Objekte sind. Dass Strings in allen Programmen äußerst häufig vorkommen Und dass sich deshalb Referenzvariablen String-Objekte im String Pool teilen. Das Konzept hinter dem String-Pool ist die Teilung der Ressourcen. Und das bedeutet: Weniger Objekte – mehr Speicher Mehr Speicher – bessere […]

Polymorphie bringt Vorteile für Java Arrays

Java Polymorphie Arrays

Wenn Java Arrays, Schubladen oder Container sein sollen… Dann wäre der Gebrauch einer solchen Schublade ziemlich einseitig und festgefahren. Denn in jedes Array passen zwar mehrere Daten – aber immer nur vom gleichen Datentyp. Immer gleicher Datentyp? Also eine Schublade nur für Socken, Unterwäsche und der ganze andere Kram passt dann eben nicht hinein. Um […]

So kannst du deine Eclipse Oberfläche anpassen

Eclipse anpassen

In diesem Beitrag möchte ich dir zwei ganz nette Features von Eclipse vorstellen. Es geht um Views und um Perspektiven. Wie du schon weißt, besteht Eclipse aus einer grafischen Oberfläche. Und in dieser Oberfläche stehen dir verschiedene Views zur Verfügung. Was ist so ein View?

Java lernen – 10 nützliche Tipps für Java Anfänger

Java Lernen Anfänger

Wenn du die Programmiersprache Java lernen möchtest, bist du hier prinzipiell erst einmal richtig. Und wenn du es wirklich ernst meinst und in die Java Programmierung einsteigen möchtest, solltest du auch meinen kostenlosen Java Kurs beanspruchen. Wenn du dabei bist, bekommst du: Eine Lektion pro Woche zu den Basics. Hier geht es um die ersten […]

So einfach lassen sich Java Strings umkehren

Java Strings umkehren

Kennst du noch das Lied „ANNA“ von Freundeskreis? Da hieß es: Du bist von hinten, wie von vorne A-N-N-A. Solche Namen oder Wörter, welche von hinten nach vorne gelesen – die gleiche Bedeutung haben, nennt man Palindrome. Anna, Ehe oder Ebbe sind recht kurze Palindrome. Aber auch längere zusammengesetzte Palindrome kennt die deutsche Sprache: Regallager […]

Sicherer Schleifendurchlauf mit Do while Schleife

Java Do While Schleife

Es ist doch eigentlich so: Immer wenn du die Anzahl der Schleifendurchläufe nicht kennst, nutzt du in deinen Java Programmen while Schleifen. Doch Java bietet dir neben der While Schleife einen weiteren Schleifentyp an. Diese nennt sich do while Schleife. Was kann die? Eigentlich genau das Gleiche, wie die while Schleife. Mit einem kleinen aber […]

So kannst du in drei einfachen Schritten Java Arrays dynamisch vergrößern

Java Arrays vergrößern

Es ist der 31.März 1727. Es ist ein Montag. Die Welt nimmt Abschied von einem sehr bedeutenden Weltveränderer. Seine Sichtweisen beeinflussen, heute noch, die Forschung und Entwicklung im Bereichen der Physik und Chemie. Ja selbst unser aller Leben – unsere Sicht auf die alltäglichen Dinge – wurden durch seine Denkstöße revolutioniert. Dieser große Vorreiter starb […]

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.