Skip to main content

Einführungsbeispiel zur Java Programmierung: Von der Klassenerstellung zum Programmstart


java programmierung einführungsbeispiel

Auf dieser Seite möchte ich dir ein Einführungsbeispiel zu den Java Klassen vorstellen.
Anhand dieses Beispiel wirst du lernen:

  • wie du eigene Klassen erstellst,
  • deine Java Klassen erweitern kannst,
  • Konstruktoren und Methoden einsetzt,
  • Objekte anlegen kannst,
  • auf diese Instanzen zugreifen kannst,
  • wie du Eigenschaften der Objekte änderst.

Das Ganze lernst du an einem Beispiel- dem Java Adventure. Dieser Artikel ist eine Zusammenführung von Einzelbeiträgen. Deshalb kann es sein, dass sich so Manches an bestimmten Stellen wiederholt.

Java-Klassen-Adventure

Der Aufbau von Java Klassen

Jedes Java Programm besteht aus Java Klassen.

  • Doch wie sind diese aufgebaut?
  • Wie setzt sich die Struktur zusammen?
  • Wo befinden sich Klassen hierarchisch?
  • Was kommt in die Klassen rein und wie wird es integriert?

Das sind die Fragen, welche ich jetzt beantworten werde.
Doch bevor wir bei den Klassen ansetzen, müssen wir eine Stufe höher gehen.
Und zwar zum Java Projekt oder Programm.

Denn..

Alle Java Klassen sind Bestandteile eines Java Programmes.

Jedes Java Programm besteht ausschließlich aus Klassen.
Die Klassen sind somit die Bausteine eines Programmes.

Du kannst dir das Ganze, wie in diesem Bild vorstellen.

Java-Klassen-Struktur-Beispiel

Ein Java Programm ist somit die Gesamtheit, aller in ihr enthaltenden Klassen.

Du kannst auch sagen, dass das Programm die erste oder all-umfassende Hierarchiestufe bildet.
Und die einzelnen Klassen bilden die zweite Stufe.

Java-Klassen-Hierarchie-Programm

Das Java Programm im Bild würde somit aus insgesamt 8 Klassen bestehen.

Nun ist es nicht so, dass die Klassen zwingend Klasse 1 bis 8 heißen müssen.
Du kannst für die Klassen ganz individuelle Namen vergeben.

Im Java Adventure könnten die Klassen so heißen:

Java-Klassen-mit-Namen

Nachdem wir die erste Hierarchieebene besprochen haben, schauen wir einmal in das Innere einer Klasse.

Der innere Aufbau von Java Klassen

Eine Java Klasse besteht aus zwei Teilen:
Dem Klassenkopf und dem Klassenrumpf.

Java-Klassen-Kopf-und-Rumpf

Im Klassenkopf befindet sich der Name der Klasse.
Der Rumpf besteht aus einer öffnenden Klammer und einer schließenden Klammer.

Diese beiden Klammern bilden die Grenzen der Klasse.
Alles was zwischen diesen beiden Klammern steht, gehört zu dieser Klasse.

Schauen wir uns die Helden-Klasse genauer an.

Java-Klassen-innerer-Aufbau

Im Klassenkopf steht der Name.
Im Klassenrumpf steht zurzeit noch gar nichts.
Hier kannst du später Methoden, Konstruktoren oder Variablen implementieren.
Und diese Programmstrukturen schreibst du dann innerhalb der festgelegten Klassengrenzen -also zwischen den Klammern.

Und somit besitzt jede Klasse ganz individuelle Methoden und Variablen.

Java-Klassen-mit-Methoden-und-Variablen

Somit besteht ein Java Programm nicht aus einer Hierarchiestufe, sondern aus mehreren.

Die Hierarchieebenen im Java Programm.

Ich sagte es bereits.
Die oberste Stufe ist das Java Projekt.

Java-Programm-Hierarchiestufen

Darunter folgen die einzelnen Klassen.
Die Klassen sind somit die elementaren Bestandteile des Programmes.
Sie bilden die zweite Hierarchiestufe.

Alle Java Klassen bieten individuelle Variablen und Methoden an.
Und diese Konstrukte sind letztlich die Bestandteile der Klasse.
Sie bilden somit die dritte Hierarchiestufe im Programm.

Schauen wir uns den Aufbau von Java Klassen am Beispiel an.

Bleiben wir bei der Heldenklasse.

Wenn du diese Klasse in Eclipse anlegst, dann sieht diese so aus:

Java-Klassen-Held

Jede Klasse beginnt beim Kopf.

Java-Klassen-Klassenkopf

Und dieser Klassenkopf beginnt mit einem sogenannten Access Modifiers.
In diesem Fall ist es public.

Und dieses Keywort public weist darauf hin, dass diese Klasse nach außen sichtbar ist.
Das wiederum bedeutet, dass andere Klassen einen Zugriff auf diese Klasse haben.

Java-Klassen-public

  • Wenn diese Held-Klasse erst einmal Methoden und Variablen anbietet, können andere Klassen diese sehen und auch nutzen.
    Schuld daran ist das Keywort public.
  • Dann folgt das Keywort class.
    Dieses Keywort signalisiert dem Java Programm: Hier ist eine Klasse.
  • Der letzte Baustein ist der Name der Klasse, welchen du gewählt hast.
    Unter diesem Namen ist die Klasse jetzt im Programm registriert.
    Mit diesem Namen können andere außenstehende Klassen auf diese Klasse zugreifen.

Und damit endet der Kopf.

Java-Klassen-Kopf

Direkt hinter dem Klassenkopf folgt die erste Klammer.
Dies ist der Beginn des Klassenrumpfes.
Java-Klassen-Rumpf

Und im Klassenrumpf implementierst du jetzt die Methoden und Variablen der Klasse.
Java-Klassen-Rumpf-Methoden

Lass uns die Java Klassen zum Einführungsbeispiel anlegen

Nachdem ich gerade beschrieben habe, was Java Klassen sind.
Lass uns jetzt Java Klassen anlegen.

Java-Klassen-Adventure

Meine Frage an Dich:
Welche Klassen könnte so ein Adventure haben?

Ich denke an:

  • Personen oder Helden
  • Gegenstände, wie Autos und Häuser.
  • Vielleicht Waffen.

Ich habe einmal so eine Übersicht zu den Klassen erstellt.
Diese 8 Java Klassen werden wir jetzt erstellen.

Java-Klassen-des-Adventures

Doch bevor es losgeht, benötigen wir ein Projekt.

Und so kannst du ein neues Java Projekt anlegen.

Deine zukünftigen Java Klassen stehen nicht alleine da.
Sie werden in einem Projekt zusammengefasst.

Innerhalb des ganzen Projektes können dann:

  • Die Klassen einen internen Zugriff auf andere Klassen haben.
  • Oder Methoden aus anderen Klassen nutzen.

Das Projekt ist somit eine übergeordnete Stelle, welche dies regelt und verwaltet.

Also dann:
Lass uns ein neues Java Projekt anlegen.

In deiner Eclipse Oberfläche siehst du ganz oben ein Menü.
Klicke dort:

  • Auf File.
  • Wähle dann New.
  • Und dann Java Project.

So wie hier:

Java-Klassen-Projekt-Anlegen

Es öffnet sich dann ein neues Fenster.
Hier kannst du einige Parameter zum Projekt festlegen.
Java-Klassen-erstellen-Namen-eingeben

Trage ganz oben den Namen deines Projektes (zB. JavaAdventure) ein.
Und klicke danach auf Finish.

Das Projekt ist somit angelegt und sollte sich ganz links im Package Explorer befinden.

Java-Klassen-Projekt-im-Package-Explorer

Falls deine Oberfläche anders als bei mir aussieht, kannst du diese anpassen über Eclipse Views anpassen.

Vor dem Projektnamen befindet sich ein kleiner Pfeil.
Durch einen Klick auf diesen Pfeil, kannst du das Projekt auf- und zuklappen.

Java-Klassen-Projekt-auf-und-zuklappen

Nachdem du auf diesen Pfeil geklickt hast, schaust du ins Innere des Projektes.
Dort befindet sich ein Ordner, namens „src“.
In diesem Ordner werden wir jetzt zusammen die Java Klassen anlegen.
Java-Klassen-Source-Ordner

So kannst du Java Klassen anlegen.

Klicke einmal mit der rechten Maustaste auf den Ordner „src“.
Es öffnet sich ein Menü.

Java-Klassen-anlegen-Ablauf

Ganz oben im Menü, siehst du den Eintrag „New“.
Wenn du einmal darüber fährst, öffnet sich ein weiteres Menü.
Du kannst dann auswählen, was du anlegen möchtest.
Du möchtest eine Klasse anlegen und deshalb wähle „class“.

Nachdem du „class“ gewählt hast, öffnet sich ein neues Fenster.
In diesem kannst du jetzt die Eigenschaften der zukünftigen Klasse festlegen.

Java-Klassen-anlegen-fenster-Ablauf

Die erste Klasse soll die Klasse „Held“ sein.

  1. Schreibe deshalb den Namen in die dafür vorgesehene Zeile (siehe Bild).
  2. Direkt darunter kannst du einen Modifiers festlegen.
    Wähle hier public (Siehe Bild).
    Dadurch sind die Klassen nach außen sichtbar. (Später mehr dazu)
  3. Klicke dann auf Finish.

Und fertig ist die erste Java Klasse.

Nach dem Erstellen der Java Klassen, sind diese sichtbar.

Und zwar siehst du die Klassen dann im Package Explorer (ganz links).

Erstellte-Java-Klassen-erscheinen-im-Package-Explorer

Wenn du auf diese Dateien mit einem Doppelklick klickst, öffnen sich diese.
Und dann erscheinen diese Klassendateien, samt Code in deiner Oberfläche.
geöffnete-Java-Klassen

Um diese Dateien wieder zu schließen, klicke auf das Kreuz neben dem Namen.
Java-Klassen-schließen-und-öffnen

Aber du siehst noch mehr.

Ganz links siehst du die Ordnerstruktur zu den erstellten Java Klassen.

Schau einmal links in den Package Explorer.
Dort siehst du die Ordnerstruktur, in der sich die Java Klassen befinden.

Java-Klassen-anlegen-Projekt-Hierarchien

  • Ganz oben steht das Projekt.
  • Direkt darunter befindet sich der „src-Ordner“.
  • Und dann folgt ein package.
    Klassen lassen sich in Pakete zusammenfassen.
    Bis jetzt steht dort nur ein default-Package.
    Dies ist das Standardpackage, welches Java bereitstellt – wenn kein echtes Package vorhanden ist.
  • Und hierarchisch ganz unten folgt die Klassendatei: Held.java.

Und mit diesem Strukturwissen, können wir eine zweite Klasse erstellen.
Und zwar etwas ausführlicher.

Das Anlegen der zweiten Java Klasse- etwas ausführlicher.

Jetzt können wir das Erstellen der zweiten Java Klasse etwas ausführlicher besprechen.

Also wie gehabt.

  • Rechtsklick auf den Ordner „src“.
  • Wähle dann „New“
  • und dann „Class“.

Java-Klassen-erstellen-Rechtsklick

Oder du klickst im Menü ganz oben auf File.
Wählst dann „New“ und dann eben „class“.
Java-Klassen-anlegen-Menüband

Wie auch immer – Es öffnet sich wieder dieses Fenster.
Java-Klassen-anlegen-Verweis-Source-Ordner

  • Ganz oben siehst du die Ordnerstruktur, welche auf den Source Ordner („src“) des Projektes verweist.
  • Falls du irgendwann einen zweiten Ordner oder ein zweites Projekt angelegt hast – kannst du auf den „Browse-Button“ klicken.
  • Es würde sich dann ein Navigationsfenster öffnen und du könntest einen anderen Speicherort bestimmen.

Aber zurück zu unserem Projekt.
Darunter siehst du das Package.

Java-Klassen-anlegen-Verweis-Package

Da du bisher nur ein default-Package hast, bleibt die Zeile leer.
Auch hier kannst du irgendwann, wenn du eigene Packages hast, durch ein Klick auf den „Browse-Button“ navigieren“.

Dann folgt der Klassenname, welchen du in der Ordnerstruktur ebenfalls siehst – sobald die Klasse erstellt ist.

Java-Klassen-erstellen-Verweis-Name

Ich wähle jetzt als Klassennamen „Monster“ und klicke dann auf „Finish“.
Java-Klassen-anlegen-Fertigstellen

Fertig.

Und auch diese Klasse erscheint dann im Package Explorer.

Java-Klassen-erstellte-geöffnet

Wenn du alle Java Klassen nach dem selben Prinzip erstellt hast, sollten alle im Explorer zu sehen sein.

Von Java Klassen zum Java Programm – Der Programmstart

Ich will dir jetzt zeigen, was nötig ist, dass du ein Java Programm ausführen kannst.
Und ich zeige dir außerdem, wie du eine Startklasse in einem x-beliebigen Javaprogramm anlegst.

In diesem Einführungsprojekt hast du bis jetzt 8 Klassen angelegt.

Java-Klassen-Uebersicht-8-Klassen

Falls du diese noch nicht angelegt haben solltest, ist das kein Problem.
Du kannst den Programmstart auch einfach so oder mit deinem eigenen Projekt nachvollziehen.

Also legen wir los..

Hier ist das entscheidende Element um aus Java Klassen heraus Programme auszuführen.

Es ist eigentlich äußerst simpel.
Um irgendein Java Programm zu starten, brauchst du eine Startmethode.

Diese Startmethode heißt main-Methode.
Und so sieht diese aus:


	public static void main(String[] args) {
		
	}

Schauen wir uns diesen Code genauer an.

  • Die Methode beginnt mit dem Keywort public.
    Dieses Keywort legt fest, dass diese Methode öffentlich ist.
    Die Methode kann also von jeder Klasse genutzt werden. (Dazu unten mehr)
  • Das Keywort static legt fest, dass es sich um eine Klassenmethode handelt.
    In Java gibt es Objekte und diese nutzen individuelle Instanzmethoden.
    Klassenmethoden hingegen dienen dem Programm und nicht zwingend einem Objekt.
  • Dann folgt void.
    Dieses Keywort legt fest, dass die Methode nichts zurückgibt.
    Normalerweise liefert jede Methode einen Wert, eine Zahl, ein Text usw.
    Diese Methode liefert nichts- und deshalb void.
  • Dann folgt der Name der Methode: main.
  • Zum Schluss befindet sich in der Klammer ein Parameter.
    Dieser dient dazu, dass du der Methode beim Start eine Zahl oder Ähnliches mitgeben könntest.
    Und diese Zahl oder was auch immer, könnte die Methode auswerten, weiter verarbeiten oder umwandeln.

Das Ganze wirkt erst einmal enorm viel.

Ich beruhige dich:
Du musst dies Alles nicht sofort wissen.
Wenn du erst einmal länger in Java programmierst, speichert sich dieses Wissen von selbst.

Was du allerdings mitnehmen solltest:
Die main-Methode brauchst du immer zum Starten eines Programmes.

Und so werden aus normalen Java Klassen – Klassen welche ein Programm ausführen

Ich beginne einfach mal bei der Klasse „Held“.
Und implementiere die main-Methode.

Ja und wie?
Hier erst einmal der Code.
Ich sage gleich mehr dazu.


public class Held {

	public static void main(String[] args) {
		
	}
}

Eigentlich brauchst du nur meinen Code kopieren oder abschreiben und in deine Klasse einfügen.

Was gilt es dabei zu beachten?
Du musst die Hierarchieebene beachten.
Und zwar muss die Methode innerhalb der Klassengrenzen gesetzt werden.

Java-Klassen-Rumpf

Die zwei äußeren Klammern bilden die Grenzen der Java Klasse.
Und innerhalb dieser Grenzen muss, alles rein – was zu dieser Klasse gehört.
Die main-Methode gehört zu dieser Klasse und befindet sich somit im Rumpf der Klasse.
(Zwischen den Klammern).
Java-Klassen-Klassengrenzen-Main-Methode

Die Methode hat ebenfalls einen Rumpf.
Auch dieser Rumpf wird durch eine öffnende Klammer geöffnet und durch die schließende Klammer geschlossen.
Somit sind die Grenzen der Methode ebenfalls klar definiert.

Java-main-Methode-Grenzen

Alles was die Methode machen soll, kommt dann in den Rumpf der Methode.

Und das war es eigentlich schon.
Wenn du jetzt das Programm ausführen würdest, würde nichts passieren.
Nicht weil die Methode falsch angelegt ist oder sich in der falschen Klasse befindet.

Es steht nichts drin.
Im Rumpf der Methode befindet sich keine Anweisung.

Das ändern wir.
Und zwar kommt dort eine Konsolenausgabe hinein.
Der Code dazu lautet:
System.out.println("Dies ist die Heldenklasse!");

Und so sollte dies jetzt bei dir aussehen.


public class Held {

	public static void main(String[] args) {
		System.out.println("Dies ist die Heldenklasse!");
	}
}

Worauf ist zu achten?

  • Diese System.out.println()-Befehl ist eine sogenannte Anweisung.
  • Hinter jede Anweisung muss ein Semikolon.
  • Innerhalb der Klammer kannst du jeden Textwert eingeben, den du willst.
  • Wichtig ist, dass du Text in Anführungsstriche setzt.

Jetzt lass uns dieses Programm endlich starten.

Ganz oben in der Menüleiste befindet sich ein Button „Run“.
Klicke dort drauf und du wirst gefragt, ob du speichern möchtest.
Dies bestätigst du und das Programm läuft.

Java-Klassen-ausführen-Ablauf

Ganz unten siehst du die Konsolenausgabe mit deinem Text.
Java-Programmstart-mit-Konsolenausgabe

Das war es.
Du hast ein Programm ausgeführt.

Später kannst du dann natürlich größere Programmstrukturen integrieren.
Auf genau die gleiche Art und Weise.
Für den Anfang reicht es aus.

Den Programmstart kannst du in allen Java Klassen einfügen.

Was hier geht – geht auch woanders.
Die main-Methode kannst du in jede Klasse einbinden.

Dadurch entstehen mehrere ausführbare Klassen.
Also Miniprogramme, welche parallel ausgeführt werden könnten.

So wie hier:

Java-Klassen-main-Methoden

Wichtig ist, dass du immer die main-Methode brauchst, um ein Java Programm zu starten.
Du in jeder x-beliebigen Klasse eine main-Methode anbieten könntest.
Und somit x-beliebig viele Programme innerhalb eines Projektes hättest.

Und das mache ich jetzt.
Ich lasse den Programmstart in der Heldenklasse.
Und ich lege in der Monsterklasse einen weiteren Programmstart an.

Dazu bräuchte ich nur die main-Methode, innerhalb der Klassengrenzen setzen.
Es gibt aber einen Trick, wie hier im Bild:

Java-main-Methode-Liste

  • Schreibe main
  • Drücke zeitgleich Steuerung+Leertaste.
    Und diese Auswahlliste erscheint.
  • Wähle dann die main-Methode aus der Liste.
  • Fertig.

Und in dieser main-Methode (innerhalb der Klammern) platziere ich jetzt wieder eine Bildschirmausgabe:

Java-Sysout

  • Auch hier reicht es aus, sys zu schreiben.
  • Dann Steuerung+Leertaste drücken
  • Die Anweisung „sysout“ auswählen.
  • Fertig.

In die Klammer kannst du jetzt wieder einen individuellen Text platzieren.
Denke an die Anführungsstriche.
Und fertig ist das zweite Programm.

Und jetzt kannst du auf „RUN“ klicken und auch dieses Programm ausführen.
Wähle danach die Held-Klasse und klicke auf „Run“ und auch dieses Programm wird ausgeführt.
Cool, oder?

Aber eigentlich trennt man die Starterklasse von den Objektklassen.
Und das solltest du auch tun.

Wir haben im Java Adventure 8 Klassen vorgesehen.
Eine davon heißt Programmstart.

Und diese erstellen wir jetzt noch.

Und so kannst du die Programmstart-Klasse anlegen.

Natürlich geht es so, dass du:

  • Die Programmstartklasse erstellst
  • und dann die main-Methode dort platzierst.

Du kannst das Ganze aber schon beim Klassen-Erstellungs-Prozess vollziehen.

Und zwar so:
Wenn du eine neue Klasse anlegst, hast du die Möglichkeit die main-Methode gleich dazu zu bekommen.

Dazu musst du bei der Methodenauswahl den Haken setzen.

Java-Klassen-Programmstart-integrieren

Klickst dann auf Finish.
Und fertig ist die Programmstart-Klasse.

So kannst du in den Java Klassen Attribute anlegen

Die bisherigen Java Klassen in unserem Einführungsbeispiel besitzen noch keine Attribute.
Das ändern wir und legen diese jetzt an.

Jetzt erfährst du:

  • Warum Variablen in deinen Klassen eine entscheidende Rolle spielen.
  • Was es bedeutet eine Variable zu deklarieren.
  • Wo du Attribute in den Java Klassen anlegen darfst und wo nicht.
  • Wie du durch die angelegten Eigenschaften, Schablonen für x-beliebig viele Objekte erstellst.

Warum ist dies so wichtig?
Bedenke…..

Heute sind es Attribute in den einzelnen Java Klassen-
Morgen sind es Eigenschaften der daraus erstellten Objekte.

So eine Java Klasse ist immer eine Gebrauchsanweisung für ein Objekt, welches kreiert werden soll.
Wirf einmal einen Blick auf das Java Adventure.

Java-Klassen-Adventure

Und dann wirf einen Blick auf die Klassen, welches dieses Adventure bereits hat.
Java-Klassen-des-Java-Adventures

Welche Variablen könnten die einzelnen Klassen besitzen?
Oder genauer gefragt:
Wenn aus der Heldenklasse irgendwann Objekte erstellt werden- welche Eigenschaften sollten diese Helden haben?

Und mit Eigenschaften meine ich nicht Charaktereigenschaften.
Denke dabei mehr in die Richtung: „Unterscheidungskriterien.“

Die Helden könnten vielleicht so aussehen:

Java-Adventure-Friedhof

Also wodurch unterscheiden sich Helden?
Na klar – es sind Eigenschaften wie:

  • Name
  • Geschlecht
  • Größe
  • Kraft
  • Augenfarbe
  • ….usw.

Und diese Eigenschaften bzw. Unterscheidungskriterien legt man in der entsprechen Klasse fest.

Nochmal:
Denke daran, dass Java Klassen – Baupläne für Objekte sind.

Also könnte doch ein Bauplan für die Heldenklasse in etwa so aussehen:

Java-Klassen-Bauplan-der-Heldenklasse

Später werden dann die einzelnen Objekte aus diesem Bauplan erzeugt.
Und dann bekommt jedes Objekt seinen individuellen Wert für jedes einzelne Attribut zugewiesen.
Java-Klassen-Attribute-Bauplan

Mit den Attributen legst du die Ausrichtung für die Java Klassen fest.

Diese Attribute haben viele Namen:

  • Attribute
  • Instanzvariablen
  • Felder
  • Instanzfelder
  • Objektvariablen

Diese Variablen legst du einmal im Bauplan an.
Du weist diesen Attributen aber noch keinen Wert zu.
Schließlich handelt es sich lediglich um einen Bauplan und noch nicht um ein fertiges Objekt.

Erst wenn das Objekt erstellt wird, bekommt jedes einen individuellen Wert.

Stell dir den ganzen Ablauf wie in einem Spiel vor.
Da findest du auch so einen Bauplan oder Schablone.
Am Anfang des Spieles wirst du gefragt:
Männlich oder Weiblich?

Java-Klassen-Geschlecht-wählen

Danach folgt der Name, die Auswahl einer Waffe usw.
Java-Klassen-Eigenschaften-Namen-festlegen

Am Ende des Vorganges hast du einen ganz individuellen Helden.
Falls du eine zweite Figur erschaffst, kann diese andere Attribute haben.

Die Grundeigenschaften, wie Geschlecht, Name und Waffe – wurden einmal im Bauplan angelegt.
Und dies ermöglicht dir dann ganz viele individuelle Helden zu bauen.

Und immer wenn du neue Eigenschaften für ein Objekt brauchst.
Zum Beispiel das Gewicht.
Dann legst du diese in der entsprechenden Java Klasse an.
Und alle Objekte können diese neue Eigenschaft nutzen.

Java-Klassen-Felder-anlegen

Somit bietet dir die Objektorientierung einen entscheidenden Vorteil.
Du musst den Code nicht für alle Helden ändern.
Stattdessen änderst du nur den Bauplan (die Klasse).
Und dadurch verändern sich alle Helden.

Und dieses Prinzip kannst du für sämtliche Software nutzen.

Vielleicht in einer Kfz-Zulassung.
Die Attribute könnten sein:

  • Farbe
  • Marke
  • Herstellungsdatum

Java-Klassen-Bauplan-Autos

Aus diesem Bauplan heraus, lassen sich dann individuelle Autos anlegen.

Oder in einer Krankenhausverwaltung:

  • Patientennummer
  • Patientenname
  • Krankheit

Java-Klassen-Bauplan-Krankenhaus

Auch hier gibt es einen Bauplan mit drei Attributen.
Aus diesem Plan heraus lassen sich sämtliche Patienten erstellen.

Diese ganze Objektorientierung lehnt sich somit sehr stark an unser reales Leben an.

So kannst du Attribute in Java Klassen deklarieren.

Das Anlegen der Felder nennt man in der Java Programmierung – deklarieren.
Das spätere Zuweisen der einzelnen Eigenschaftswerte nennt man – initialisieren.

Beim Deklarieren von Variablen stellen sich folgende drei Fragen:

  • Welche Variablen sollen deklariert werden?
  • Wo werden diese deklariert?
  • Wie werden diese deklariert?

Beginnen wir bei Frage eins.
In der Heldenklasse, kannst du nun unzählige Instanzvariablen anbieten.
Für den Anfang reichen drei.
Und das sind die Instanzvariablen der Heldenklasse:

  • der Name
  • das Alter
  • die Größe

Du kannst nachher noch selbst eigene Instanzvariablen in dieser Klasse deklarieren.
Und zwar nach genau dem gleichen Prinzip, welches ich dir jetzt zeige.

Kümmern wir uns um die Frage:
Wo werden diese deklariert?

Die Variablen bzw. Attribute legst du auf Klassenebene an.

Das bedeutet:
Falls du eine main-Methode oder eine andere Methode in der Klasse anbietest.
Dann darf die Instanzvariable nicht im Rumpf dieser Methode angelegt werden.
Denn so würde die Variable zur Methode gehören.

Die Variable gehört zum Bauplan und somit zur Klasse.
Deshalb musst du Instanzvariablen immer:

  1. außerhalb von Methoden
  2. Innerhalb des Klassenrumpfes anlegen bzw. deklarieren

Java-Klassen-Attribute-anlegen

Das Wo und das Was ist geklärt.

Bleibt die letzte Frage:
Wie werden Attribute deklariert?
Für den Namen des Helden machst du das so:


public class Held {
	String heldName;

}
  • Der Name ist ein Textwert.
  • Du wirst als Namen niemals eine Zahl vergeben.
  • Deshalb musst du den Namen in einem Datentypen speichern, welcher mit Textwerten umgehen kann.
  • Und dieser Datentyp, ist der Datentyp String.
  • Für den Namen der Variablen habe ich „heldName“ gewählt.

Worauf solltest du beim Namen der Instanzfelder achten?

  • Du kannst jeden x-beliebigen Namen wählen.
  • Der Name muss aber zusammengeschrieben sein.
    Du kannst also nicht zwei Wörter als Namen zuweisen.
    „Der Name“ oder „Held Name“ funktioniert nicht
  • Falls du dennoch zwei Wörter wählst, schreibst du diese zusammen.
    Den Namen der Variablen solltest du immer klein beginnen und den zweiten Namen dann groß schreiben.

Welche Rolle spielt der Name der Instanzvariablen?
Zum Zeitpunkt als die Variable „heldName“ deklariert wurde, geschieht folgendes:

  • Es wird ein Speicherplatz in Größe bzw. Volumen eines String-Datentypen reserviert.
  • Wenn der Wert dann später zugewiesen wird, kann auf diese Reservierung zurückgegriffen werden.
  • Diese Reservierung wird unter dem Namen der Variablen speicherintern geführt und verwaltet.

Zu diesem Zeitpunkt könntest du x-beliebig viele Helden anlegen.
Und jedem Helden könntest du einen individuellen Namen zuweisen.

Java-Klassen-Helden

Aber wir wollten noch mehr.
Und zwar sollte jeder Held noch ein Alter zugewiesen bekommen.

Also legen wir auch das Alter an.


public class Held {
	String heldName;
	int heldAlter;

}
  • Das Alter wird ein ganzzahliger Wert sein.
  • Und für ganze Zahlen nutzt du den Datentyp Integer oder int.
  • Auch hier kannst du jeden willkürlichen Namen für die Instanzvariable wählen.
  • In meinem Fall heißt diese „heldAlter“.

Falls du die Variable „das Alter des Helden“ nennen möchtest, geht das auch.

  • Schreibe den Variablennamen zusammen.
  • Schreibe diesen zu Beginn klein.
  • Und achte auf die Groß-und Kleinschreibung zwischen den Wörtern.
  • Die Variable hieße demnach: „dasAlterDesHelden“.

Die letzte Variable ist die Größe:


public class Held {
	String heldName;
	int heldAlter;
	double heldGroesse;

}
  • In diesem Fall habe ich eine Variable vom Datentyp double gewählt.
  • Diesen Datentyp nutzt du um Kommazahlen zu speichern.
  • Denn ich möchte gern die Größe in Metern angeben.
  • Und dafür sind Kommazahlen nunmal notwendig.

Somit wäre der Bauplan fertig.

Es fällt dir sicherlich auf, dass zwar die Variablen angelegt sind.
Aber nicht eine Variable einen konkreten Wert hat.

Die Zuweisung des Wertes kann jetzt erfolgen.
Aber eigentlich trennt man das Deklarieren von der Wertzuweisung.

Warum trennt man die Felderinitialisierung von der- deklarierung?

Ich sagte:
Deklarieren heißt Variable anlegen.
Initialisieren heißt Wert zuweisen.

Beides in einem Vorgang ist möglich.


public class Held {
	String heldName="Herbert";
	int heldAlter;
	double heldGroesse;

}

Aber man verändert den Bauplan.

Wenn du in der Heldenklasse beispielsweise dem „heldNamen“ den Wert Herbert zuweist.
Und dann Objekte aus der Heldenklasse anlegt.

Java-Klassen-Attribute-deklarieren-und-initialisieren

Dann haben alle Objekte beim Erstellen den Namen Herbert.
Und das wäre blöd.
Denn du willst das Programm und somit die Klasse so flexibel wie möglich halten.

Und deshalb:

  1. Lege zuerst Instanzvariablen an.
  2. Erschaffe dann das Objekt
  3. Und zum Schluss weist du den Instanzvariablen den Wert zu.

So lassen sich aus Java Klassen Instanzen erstellen

Lass uns jetzt aus den Java Klassen heraus Objekte anlegen.
Jetzt erfährst du:

  • Was Objekte bzw. Instanzen sind.
  • Wie sich Objekte zusammensetzen.
  • Wo und wie du Instanzen aus Java Klassen anlegen kannst.
  • Und was genau bei diesem Vorgang passiert.

Objekte bzw. Instanzen sind eine Zusammenfassung von Daten aus Java Klassen.

Stell es dir als Trichter vor.
Oben kommen die Instanzvariablen rein.
Diese werden dann zusammengefasst und es entsteht ein neuer Datentyp.

Java-Klassen-Datentypen-erstellen

Objekte sind somit eine Zusammenfassung von Daten aus einer bestimmten Klasse.
Und den Bauplan für die ganze Zusammenstellung liefern die Java Klassen.

Am Beispiel:
In unserem Java Adventure haben wir bisher diverse Klassen angelegt.
In der Beispielklasse Held habe ich dir bereits gezeigt, wie du Instanzvariablen anlegen kannst.
Wir haben bisher drei Attriubute der Klasse angelegt:

  • den Namen
  • das Alter
  • die Größe

Java-Klassen-Instanzvariablen-der-Klasse-Held

Wenn wir diesen Trichter jetzt einsetzen, um einen Helden zu erschaffen….
Java-Klassen-Instanzvariablen-zusammenfassen

Dann werden die Instanzvariablen „heldAlter“, „heldGroesse“ und „heldName“ zusammengefasst.
Und es entsteht ein Objekt vom Datentypen eines Helden.
Dieser neue Datentyp fasst drei primitive Daten (String, int und float) zusammen.
Man spricht deshalb auch von einem komplexen Datentypen.

Und wenn du jetzt Objekte von diesem Datentypen anlegst, nennt man diese:

  • Instanzen der Klasse
  • Objekte der Klasse
  • Oder auch Member der Klasse

Bevor wir gleich Objekte aus der Heldenklasse anlegen, lass uns noch folgende Frage klären:

In welchen Java Klassen kannst du Objekte anlegen?

Instanzen kannst du in allen Klassen anlegen.

Zum Beispiel:
Kannst du Objekte der Klasse „Held“ in der Monsterklasse anlegen.
Du kannst sogar Objekte der Klasse Start in der Klasse „Raumschiffe“ anlegen.

Das Ganze ist also recht flexibel.

Die Frage sollte somit nicht lauten:
Wo kannst du Objekte anlegen.
Sondern – wo macht es Sinn?

Und deshalb ist die Frage – „Wann sollten im Programmablauf Objekte erzeugt werden?“ – die bessere.

Schauen wir uns die bisherigen Klassen einmal an:

Java-Klassen-Instanzvariablen-der-Klasse-Held

Wo könntest du jetzt Helden erschaffen?
Klar bei den Monstern oder bei den Raumschiffen.
Möglich ist es – Aber es ergibt für unsere jetzige Konstellation wenig Sinn.

Die Helden sollen zum Programmstart erschaffen werden.

Und wo findet der Programmstart statt?
In der main-Methode.

Java-Klassen-Objekte-erschaffen-zum-Programmstart

Alles was der main-Methode übergeben wird, wird beim Programmstart ausgeführt.
Und das heißt: jede Anweisung, jeder Methodenaufruf.

Also warum übergeben wir der main-Methode nicht ein paar Helden.
Doch wo genau?
Schau dir dieses Bild dazu an:

Java-Klassen-Querschnitt-Startklasse

  • Wenn du die Heldobjekte auf Ebene der Klasse (roten Teil) anlegen würdest, gehören diese zur Klasse Start.
  • Die Startklasse hat nichts mit dem Programmstart zu tun.
    Es ist lediglich von uns gewollt, dass diese Klasse so heißt und diese Methode anbietet.
  • Das entscheidende Element für den Programmstart ist die main-Methode.
    Und diese Methode könntest du in jeder Klasse implementieren.
  • Die Objekte müssen also innerhalb des blauen Teils, dem Methodenrumpf, erstellt werden.

Ganz konkret würde dies dann so aussehen:

Java-Klassen-Start-Rumpf-der-Main-Methode

Jetzt haben wir das Was und das Wo geklärt….
Dann lass es uns endlich auch tun.

So kannst du Objekte aus Java Klassen erstellen.

Das wäre der Code zum Erstellen von zwei Java Objekten der Klasse „Held“:


public class Start {

	public static void main(String[] args) {
		Held heldEins = new Held();
		Held heldZwei = new Held();
	}
}

Schauen wir uns den Code genauer an.
Und zwar von rechts nach links.

Der rechte Teil ist der Konstruktoraufruf.

Java-Klassen-Instanz-anlegen-Konstruktoraufruf

Auf der rechten Seite der Gleichung siehst du die Anweisung: new Held().
Dies ist ein sogenannter Konstruktoraufruf, welcher ein Held-Objekt anlegt.
Java-Klassen-new-Anweisung

Da dieser Konstruktor in meinem Code zweimal aufgerufen wird, entstehen zwei Objekte.
Und da in der Anweisung Held() und nicht Monster() steht, werden Objekte der Heldenklasse erstellt.

Falls du aus allen anderen Java Klassen ebenfalls Instanzen erstellen möchtest, musst du den hinteren Teil des Codes ersetzen.

  • new Held() – erschafft einen Helden
  • new Monster ()- erschafft ein Objekt aus der Klasse Monster
  • new Raumschiff()- erschafft ein Objekt aus der Klasse Raumschiff.
  • ….usw

Okay das haben wir geklärt.
Schauen wir uns den ersten Teil der Anweisung an.

Der linke Teil ist die Variable.

Java-Klassen-Referenzvariablen-anlegen

Links der Gleichung siehst du die Variable, welche angelegt wird.
Diese Variablen heißen „heldEins“ und „heldZwei“.
Java-Klassen-Referenzvariablen

  • Die Variablen beinhalten ein Verweis auf dieses Objekt im Speicher.
  • Du kannst auch sagen: „Die Variablen zeigen auf die Objekte“.
    Und weil diese Variablen lediglich verweisen, nennt man diese auch Referenzvariablen.
  • Den Namen der Variablen kannst du frei wählen.

Weiterhin müssen alle Variablen einem gewissen Datentyp entsprechen.
In diesem Fall ist es der komplexe Datentyp „Held“.

Verbunden werden beide Seiten durch eine Zuweisung.

So jetzt haben wir die rechte und linke Seite des Codes geklärt.
Scheinbar verbunden werden beide Teile durch ein Gleichheitszeichen.
Es ist aber kein Gleichheitszeichen.
Es handelt sich hier auch nicht um eine Gleichung.

Java-Klassen-Zuweisung

Stattdessen spricht man von einer Zuweisung.
Und diesen Operator (=) nennt man Zuweisungsoperator.

Weil es wirklich wichtig ist….

Zusammenfassend nochmal den ganzen Code von links nach rechts:

Java-Klassen-Objekte-anlegen

  • Zuerst der Datentyp „Held“.
    Dieser ist ein komplexer Datentyp, da dieser die Instanzvariablen der Klasse „Held“ zusammenfasst.
  • Dann folgen die Referenzvariablen „heldEins“ und „heldZwei“.
    Diese verweisen auf zwei Objekte im Speicher.
  • Dann folgt die Zuweisung in Form eines „Gleichheitszeichens“.
  • Und schließlich – Auf der rechten Seite des Codes befindet sich ein sogenannter Konstruktoraufruf.
    Durch diesen Konstruktoraufruf werden zwei „Held-Objekte“ im Speicher angelegt.

Ich möchte dir noch ganz kurz zeigen, dass du aus allen Klassen heraus Objekte anlegen kannst.
Unsere bisherigen Klassen aus dem Einführungsbeispiel sind:

Java-Klassen-Instanzvariablen-der-Klasse-Held

Und hier der Code mit Kommentaren.


public class Start {

	public static void main(String[] args) {
		Held heldEins = new Held();//Helden Objekt 1
		Held heldZwei = new Held();//Helden Objekt 2
		Monster monsterEins = new Monster();//Monsterobjekt hat noch keine Attribute
		Start starterPacket = new Start();//Objekt der Klasse Start
		Monster heldNamen = new Monster();//Der Name der Variablen kann frei gewählt werden
		
		Monster monsterZwei = new Held();//Das geht nicht da Monster kein Held ist
	}
}

Du siehst:

  • Du kannst aus allen Klassen Objekte anlegen.
  • Der Name der Referenzvariablen ist völlig egal.
  • Einen Helden vom Datentyp Monster kannst du nicht anlegen.

Da ich bisher nur in der Heldenklasse, Instanzvariablen deklariert habe – kann ich zwar aus allen Klassen Objekte erstellen.
Diese haben aber keine Eigenschaften /Attribute.
Es ist somit zu diesem Zeitpunkt sinnlos diese Instanzen anzulegen.

Und somit zurück in die Heldenklasse.

Diese erstellten Objekte beinhalten dann alle Attribute aus den jeweiligen Java Klassen.

Ich habe einmal die Variablen der Heldenklasse durch die gelben Punkte dargestellt.

Java-Klassen-2-Objekte

Du siehst ja, dass jedes Objekt jetzt eigene gelbe Punkte hat.
Das bedeutet, dass jedes Objekt dieser Java Klasse eigene Eigenschaften bzw. Werte beinhalten kann.
Somit kannst du zwei Objekte erstellen und diesen individuelle Werte für die Instanzvariablen zuweisen.

Und dann hast du ganz individuelle Heldenobjekte, welche sich klar in ihren Eigenschaften unterscheiden.

So lassen sich die Felder der Java Klassen initialisieren

Lass uns die Attribute in den Java Klassen initialisieren.
Ich sagte es bereits, dass du Felder oder Variablen deklarieren und initialisieren kannst.

Deklarieren heißt Variable anlegen.
Und Initialisieren ist der der Variable einen Wert zuweisen.

Was bisher geschah:
In unserem Einführungsbeispiel wurden bisher:

  • Java Klassen erstellt
  • Eine Klasse für den Programmstart angelegt
  • Instanzvariablen deklariert
  • Und wir haben zwei Objekte erstellt.

Java-Klassen-Felder-Klassen-des-Adventures

In diesem Beitrag werde ich dir zuerst zeigen, wie du den Objektvariablen Werte zuweist.
Außerdem möchte ich dir zeigen, wie du diese Werte nachträglich ändern kannst.

Auf die Objekte der Java Klassen greifst du per Punktnotation zu.

In der Start-Klasse befindet sich die main-Methode zum Programmstart.

Und innerhalb dieser main-Methode haben wir zwei Referenzvariablen angelegt.
Diese heißen: „heldEins“ und „heldZwei“.


public class Start {

	public static void main(String[] args) {
		Held heldEins = new Held();
		Held heldZwei = new Held();
	}
}

Beide Referenzvariablen verweisen auf jeweils ein Objekt.

Java-Klassen-Referenzvariablen

Wichtig ist die Tatsache, dass die Variablen „heldEins“ oder „heldZwei“ nicht die Objekte sind.
In diesen Variablen wurde lediglich die Speicheradresse der Objekte hinterlegt.

Und um jetzt das Objekt anzusprechen, musst du eine Punktnotation einleiten.

Was ist das?

  • Du gibst den Namen der Variablen an.
  • Setzt einen Punkt.
  • Und dann rufst du die Instanzvariable auf.

Java-Punktnotation

Durch die Punktnotation wird genau das Objekt angesprochen, auf welches die Referenzvariable verweist.
Und Objekte sind eine Zusammenfassung der Daten einer Klasse.
Somit beinhalten die Objekte alle Instanzvariablen der entsprechenden Java Klassen.
Und diese Zusammensetzung der Variablen existiert bei zwei Objekten zweimal.
Java-Klassen-2-Objekte

Es hat somit jedes Objekt seine eigenen Instanzvariablen, abgeleitet aus der Java Klasse aus der es stammt.

Am besten am Beispiel.

So kannst du die Werte der Attribute in den Java Klassen ändern.

Am Beispiel der Heldklasse machst du es so:

  • Referenzvariable „heldEins“ oder „heldZwei“ eingeben.
  • Punkt setzen und somit das Objekt ansprechen.
  • Und dann das Element bzw. Feld eingeben, welches du ändern möchtest (das Alter).
  • Dem Element mit dem Zuweisungsoperator (=) einen Wert zuweisen.

public class Start {

	public static void main(String[] args) {
		Held heldEins = new Held();//Helden Objekt 1
		Held heldZwei = new Held();//Helden Objekt 2
		
		
		heldEins.heldAlter=24;//Zuweisung des Wertes 24
	}
}

Das war es schon.
Was heißt das jetzt?

  • Das Objekt, auf welches die Variable „heldEins“ verweist, hat drei Instanzvariablen.
  • Die Instanzvariable „heldAlter“ hat den Wert 24.
  • Die Instanzvariable „heldGroesse“ hat den Wert 0.
  • Und das Feld „heldName“ hat den Wert null.

Wieso das?
Ganz einfach.
Sobald ein Objekt erstellt wird, werden alle Instanzvariablen zum Objekt deklariert.
Und zum Programmstart werden alle Instanzvariablen initialisiert.

Die Instanzvariablen, welchen du einen Wert zugewiesen hast, erhalten diesen und alle anderen erhalten einen default-Wert.
Und dieser default-Wert richtet sich nach dem Datentypen, welchen du vereinbart hast.
Im Falle von String (heldName) ist dieser null, also nichts.
Im Falle von double (heldGroesse) ist dieser 0,0.

Du kannst es selbst testen.
Denn du kannst dir die Werte der Attribute an der Konsole ausgeben lassen.

So kannst du dir die Eigenschaftswerte der Java Klassen an der Konsole anzeigen lassen.

Eine Konsolenausgabe erzeugst du mit der Anweisung: System.out.println().

Und in die Klammern der Anweisung kannst du sämtlichen Code eingeben.
So natürlich auch den Objektaufruf mit Attribut.

  • Also Referenzvariable
  • Punkt
  • Attribut

public class Start {

	public static void main(String[] args) {
		Held heldEins = new Held();// Helden Objekt 1
		Held heldZwei = new Held();// Helden Objekt 2

		heldEins.heldAlter = 24;// Zuweisung des Wertes 24

		System.out.println(heldEins.heldName);// Rückgabe: null
		System.out.println(heldEins.heldAlter);// Rückgabe: 24
		System.out.println(heldEins.heldGroesse);// Rückgabe: 0,0

		// Und die Werte für das zweite Objekt
		System.out.println(heldZwei.heldName);// Rückgabe: null
		System.out.println(heldZwei.heldAlter);// Rückgabe: 0
		System.out.println(heldZwei.heldGroesse);// Rückgabe: 0,0
	}
}

Wenn du selbst diesen Code einmal ausführst, siehst du dass alle Felder in der Java Klasse initialisiert worden.
Du bekommst den Initialisierungswert zurück.
Du bekommst außerdem für Objekt 1 ein anderes Alter als für Objekt 2.

Jetzt lass uns etwas mit den Werten herumspielen.

Jetzt lass uns die Werte für zwei Helden anlegen.

Java-Klassen-2-Objekte

Und hier der Code:


public class Start {

	public static void main(String[] args) {
		Held heldEins = new Held();// Helden Objekt 1
		Held heldZwei = new Held();// Helden Objekt 2
		
		//Zuweisung für erstes Held-Objekt
		heldEins.heldName = "Moritz";//Zuweisung Namen für erstes Objekt
		heldEins.heldAlter = 24;// Zuweisung des Wertes 24
		heldEins.heldGroesse= 1.82;//Zuweisung Größe
		
		//Belegung für Held 2
		heldZwei.heldName = "Paula";
		heldZwei.heldAlter = 32;
		heldZwei.heldGroesse= 1.73;
		
		//Konsolenausgaben zu Held 1
		System.out.println(heldEins.heldName);// Rückgabe: Moritz
		System.out.println(heldEins.heldAlter);// Rückgabe: 24
		System.out.println(heldEins.heldGroesse);// Rückgabe: 1,82

		// Und die Werte für das zweite Objekt
		System.out.println(heldZwei.heldName);// Rückgabe: Paula
		System.out.println(heldZwei.heldAlter);// Rückgabe: 32
		System.out.println(heldZwei.heldGroesse);// Rückgabe: 1,82
	}
}

Was gilt es bei den Zuweisungen zu beachten?

  • Der Name ist ein String-Datentyp.
    Und diese Zeichenketten übergibst du immer in Anführungszeichen.
  • Die Größe ist eine Gleitkommazahl.
    Das Komma kann Java nicht verarbeiten.
    Setze stattdessen einen Punkt.
  • Achte auf das Semikolon hinter jeder Anweisung.

So- es wurden alle Felder für beide Objekte initialisiert.
Da geht aber noch mehr.

Du kannst als Wert ein Ergebnis von mathematischen Berechnungen zuweisen.

So wie hier:


public class Start {

	public static void main(String[] args) {
		Held heldEins = new Held();// Helden Objekt 1
		Held heldZwei = new Held();// Helden Objekt 2
		
		heldEins.heldAlter = 24*2;// Zuweisung einer mathematischen Berechnung

		//Konsolenausgaben zu Held 1
		System.out.println(heldEins.heldAlter);// Rückgabe: 48
	}
}

Wie wäre es, wenn Held 2 immer doppelt so alt wäre, wie Held 1.
So geht’s.


public class Start {

	public static void main(String[] args) {
		Held heldEins = new Held();// Helden Objekt 1
		Held heldZwei = new Held();// Helden Objekt 2
		
		heldEins.heldAlter = 24*2;// Zuweisung einer mathematischen Berechnung
		
		heldZwei.heldAlter = heldEins.heldAlter*2;//Held 2 ist doppelt so alt
		
		//Konsolenausgaben zu Held 1 & 2
		System.out.println(heldEins.heldAlter);// Rückgabe: 48
		System.out.println(heldZwei.heldAlter);//Rückgabe 96
	}
}

Du kannst also nicht nur reine Werte zuweisen.
Es ist auch möglich das Ergebnis von mathematischen Gleichungen in den Felder zu speichern.

Ja – es ist sogar möglich, Methoden anzulegen.
Und diese Methoden verändern die Werte der Attribute.

Stell dir vor eine wachsen-Methode, welche die Größe des Helden ändert.

Zusammenfassung:

  • Java Klassen bestehen aus einem Klassenkopf und einem Klassenrumpf.
  • Der Kopf besteht aus einem Access-Modifiers, dem Namen der Klasse und dem Keywort class.
  • Der Name der Klasse bestimmt, wie die Klasse programmintern geführt und angesprochen wird.
  • Der Access-Modifizier bestimmt, wie sichtbar die Klasse für andere Java Klassen des Programmes ist.
  • Das Keywort class signalisiert, dass es sich um eine Klasse handelt.
  • Der Klassenrumpf wird begrenzt durch eine öffnende und eine schließende Klammer.
    Innerhalb dieses Klammerpaares werden dann die Methoden und Variablen der entsprechenden Java Klassen integriert.
  • Du kannst Java Klassen auf zwei verschiedene Art und Weisen erstellen.
  • Entweder du klickst einmal auf der Source-Ordner im package Explorer.
    Und wählst dann New und dann Class.
  • Oder du klickst im oberen Menüband auf „File“, dann auf „New“ und dann auf „Class“.
  • Im neuen Fenster musst du zwingend einen Speicherort (1. Zeile) und einen Namen (3. Zeile) vergeben.
  • Klicke auf Finish und die Java Klasse ist erstellt.
  • Alle bereits erstellten Java Klassen findest du im Package Explorer und kannst diese von dort aus öffnen.
  • Du kannst aus jeder Klasse eine Programmstart-Klasse machen.
    Dazu musst du in den entsprechenden Java Klassen die main-Methode einfügen.
  • Achte bitte darauf, dass sich die main-Methode im Klassenrumpf befindet.
  • Sämtlicher Code, welcher sich im Rumpf der main-Methode befindet wird zum Programmstart ausgeführt.
  • Die ganze Objektorientierungsgeschichte richtet sich am realen Leben aus.
  • Dabei spielen die Eigenschaften bzw. Unterscheidungskriterien eines Objektes eine entscheidende Rolle.
  • Durch das Anlegen von Feldern werden deine Java Klassen zu einer Art Schablone oder Bauplan für Objekte.
  • Du kannst durch diese Attribute x-beliebig viele Objekte vom selben Typ erschaffen und diese mit individuellen Werten ausstatten – wie im wirklichen Leben.
  • Das Anlegen eines Attributes erfolgt immer auf der Hierarchieebene der jeweiligen Klasse.
  • Der ganze Ablauf erfolgt immer nach dem gleichen Muster: Zuerst der Datentyp, dann der Name.
  • Aus den einzelnen Java Klassen lassen sich Objekte erstellen.
  • Diese Instanzen entsprechen dann einem neuen Datentypen.
    Der Datentyp ist eine Zusammenfassung der Instanzvariablen aus den entsprechenden Java Klassen.
  • Um so eine Instanz zu erstellen, muss eine Referenzvariable des neuen Datentypen angelegt werden.
    Diese speichert einen Verweis zum Objekt.
  • Ein neues Objekt kann nur über den Aufruf des Konstruktors der entsprechenden Java Klassen erstellt werden.
  • Die Felder von Java Klassen werden initialisiert, sobald das Objekt angelegt wurde.
  • Dabei bekommen alle Attribute einen sogenannten default-Wert zugewiesen.
  • Du kannst den Wert der Variablen im Nachhinein abändern.
  • Dazu musst du an der Referenzvariablen die Punktnotation ausführen.
  • Durch die Punknotation oder dem Punktoperator sprichst du das Objekt direkt an.
    Du kannst dann jede vorgesehene Instanzvariable wählen und ihr einen individuellen Wert zuweisen.

Ähnliche Beiträge