Objektorientierte Programmierung am Beispiel von Java. Wie dir das wichtigste Programmierkonzept das Leben vereinfacht!

Keylearnings:

• Objekte in der Natur.
• Was ist eine Klasse?
• Wie werden Objekte mittels des Schlüsselwortes new erzeugt?
• Was ist ein Konstruktor?
• Was bedeutet es Konstruktoren zu überladen?
• Was sind getter bzw. setter Methoden?
• Was sind Klassenmethoden und Klassenvariablen?
• VIDEOERKLÄRUNG für Eclipse

I see trees, of green, red roses too.

Kim hör auf!!

Okay, Okay ich gebe es zu. Singen ist nicht meine Stärke.

Aber recht hat er doch, der gute Louis Armstrong.

Es gibt wirklich wundervolle Dinge da draußen.

Bäume, Sträucher, Blumen, Hunde, Katzen, starke Frauen und schöne Männer.

Als große Programmierer in spe, ist es natürlich unsere Aufgabe diese Liste um tolle Dinge zu erweitern.

Also los! Lass uns eine Frau Programmieren!! 😉

Okay, so einfach ist es nicht. Aber wir können tatsächlich einiges von der Natur lernen.

Denn wenn wir unsere obige Aufzählung genauer betrachten, dann stellen wir fest, dass wir die Objekte in Klassen einteilen können.

Du kannst mir im Kommentarbereich gerne widersprechen, aber ich denke wir sind uns einig:

Bäume, Sträucher und Blumen sind Pflanzen.

Hunde und Katzen sind Tiere.

Frauen und Männer sind Menschen.

Und genau auf dieser Beobachtung basiert das Konzept der objektorientierten Programmierung.

Das Konzept der objektorienrtierten Programmierung

Los schließen wir die Augen und denken an einen Baum.

Und wie sieht dein Baum aus? Ich denke es gibt einige allgemein anerkannte Vorstellungen darüber wie ein Baum auszusehen hat. So hat jeder Baum einen Stamm, eine Wurzel und eine Krone.

Aber vielleicht hast du an eine Fichte gedacht. Mir hingegen fiel sofort der Apfelbaum aus Omas Vorgarten ein.

Was ist eine Klasse?

Das Wort Baum stellt also lediglich eine grobe Beschreibung dar, die man in der objektorientierten Programmmierung Klasse nennt.

Um einen realen Baum zu beschreiben müssen wir zusätzliche Eigenschaften wie „hat der Baum Blätter oder Nadeln“ oder „wachsen daran Äpfel“ festlegen. Diese Eigenschaften nennt man Attribute.

Ein Baum wiederum ist eine Pflanze, genau wie ein Strauch, deshalb bezeichnen wir Pflanze als die Oberklasse von Baum und Strauch.

Genauso ist Tier die Oberklasse von Hund und Katze und Mensch die Oberklasse von Frau und Mann.

 

Du erinnerst dich an Franka? Natürlich! Niemand vergisst Franka!!

Wo ist Franka in unserer Kategorisierung anzuordnen?

Franka ist ein Mensch, und nicht nur das, Franka ist sogar eine Frau.

Was macht Franka aus? Schließlich ist Franka nicht irgendwer.

Nein! Franka ist die Instanz einer Frau mit individuellen Eigenschaften. Okay, das klingt jetzt ziemlich komplizert.

Lass mich dir das erklären.

Damit aus der Klasse Frau eine Franka wird, müssen wir spezifische Eigenschaften zuweisen. Um die Sache übersichtlich zuhalten beschränken wir uns auf die Eigenschaften, die auf einem typischen Personalausweis stehen.

Unsere Klasse Frau hat also die Eigenschaften Name, Vorname, Geburtsdatum, Staatsangehörigkeit, Adresse. Körpergröße und Augenfarbe.

Durch Festlegung dieser Eigenschaften wird aus der Klassifizierung Frau eine echte Franka.

Aber genug der Theorie! Schauen wie uns die Umsetzung der objektorientierten Programmierung in JAVA an.

Das Schlüsselwort class

Um in JAVA eine Klasse zu definieren gibt es das Schlüsselwort class. Die Eigenschaften werden innerhalb der Klasse in Variablen gespeichert. Die meisten unserer Eigenschaften sind Texte, die in JAVA am einfachsten im Datentyp String gespeichert werden.

Anders als die Datentypen double oder integer ist ein String kein primitiver Datentyp sondern ein Objekt. Auch wenn du die Konsequenzen jetzt noch nicht durchschaust. Bitte ich dich das bereits im Hinterkopf zu behalten wir werden darauf nochmal zurückkommen.

Schauen wir uns die Implementierung unserer Klasse Frau an.

1: class Frau{
2:      public String strName, strVorname;
3:      public String strGeburtstdatum, strStaatsangehörigkeit;
4:	public String strAdresse, strAugenfarbe;
5:	public int intKoerpergroesse;
6:};

Um eine Klasse zu definieren gibt es das Schlüsselwort class.

Merke: Grundsätzlich gilt bei der Namensvergabe das gleiche wie bei Variablen. Allerdings hat sich eingebürgert Klassen stets mit großgeschriebenen Wörtern zu bezeichnen.

In den Zeilen zwei bis sechs haben wir Variablen eingeführt, in denen wir die Eigenschaften unseres Objekts Frau speichern.

Kim, was hat es mit dem Wörtchen public auf sich?

Ja, sehr gut, du bist aufmerksam! Das klären wir als nächstes!

Erzeugung einer Instanz mit Hilfe von new!

Wir wollen eine Franka erzeugen! Also aus der groben Beschreibung der Klasse Frau ein Objekt kreieren mit Vorname = Franka.

Hierzu gibt es das Schlüsselwort new. Mit diesem können wir eine Instanz (also ein Objekt) der Klasse Frau erzeugen. Und das geht so!

Frau franka = new Frau();

Okay, was passiert hier?

Nun, urplötzlich haben wir offenbar einen Datentypen Frau. Dadurch, dass wir eine Klasse mit dem Namen Frau erzeugt haben, können wir jetzt Variablen vom Datentyp Frau anlegen.

Anders als bei unseren primitiven Datentypen wie integer oder double wird darin allerdings nur eine Referenz auf einen Speicherbereich im Arbeitsspeicher gespeichert in welchem das eigentlich Objekt existiert.

Um das Objekt zu erzeugen gibt es das Schlüsselwort new. Durch new wird der Speicherbereich für das Objekt reserviert.

Für unsere Franka Instanz bedeutet dies, dass ein Bereich im Speicher, in dem die Objektvariablen wie strName oder strVorname, in denen wir die Eigenschaften unseres Franka-Objekts speichern angelegt wird.

Achso guter Punkt! Wie weisen wir unserem Frau Objekt eigentlich die Eigenschaften wie Vorname, Name, Augenfarbe etc. zu?

Wie dir schon aufgefallen ist, haben wir allen unseren Objektvariablen das Wörtchen public vorangesstellt. Hierdurch haben wir die Möglichkeit über den Punktoperator auf die Variablen zuzugreifen.

Okay, schauen wir uns das ganze in der freien Wildbahn an.

1: franka.strVorname = "Franka";
2: franka.strName = "Mueller";
3: franka.strGeburtstdatum = "01.07.1985";
4: franka.strStaatsangehörigkeit = "Norwegen";
5: franka.strAdresse = "Finnstr. 10 56077 Koblenz";
6: franka.strAugenfarbe = "grün";	
7: franka.intKoerpergroesse = 165; 
8: System.out.println(franka.strVorname+" "+franka.strName+
 " aus "+franka.strStaatsangehörigkeit+" hat Augenfarbe "
 +franka.strAugenfarbe+".");

Gut, fangen wir mal hinten an! Kannst du die Programmausgabe erraten?

Bingo!! So ist es! Die Ausgabe ist Franka Mueller aus Norwegen hat Augenfarbe grün..

War garnicht so schwer, oder.? In den Zeilen eins bis acht weisen wir wie angekündigt die Eigenschaften, die unsere Frau-Instanz zu einer Franka werden lassen über den Punktoperator zu.

Kim, welchen Wert hat die Variable franka, wenn wir ihr noch keine Instanz zugewiesen haben?

Hierfür gibt es den Wert null. Wurde noch keine Instanz zugewiesen, dann hat franka den Wert null.

Natürlich kannst du diesen Wert auch selber zuweisen. Das sieht dann so aus:

Frau franka = null;

Kim, wird so die Instanz franka gelöscht?

In Java genießen wir den Service des sogenannten Garbage Collectors. Dank diesem müssen wir uns nicht selbst um das Löschen von Instanzen kümmern.

Ist franka die einzigste Referenz auf das Objekt Franka, dann wird der Garbage Collector den Speicher, den das Objekt belegt freigeben.

Was ist ein Konstruktor?

Hmm, also ich weiß nicht wie es dir geht. Aber bisher find ich nur Franka hübsch!

Aber keine Angst JAVA ist auch schön. Es gibt nämlich die sogenannten Konstruktoren, mit denen wir
die Eigenschaften viel eleganter zuweisen können

Und das sogar, während wir das Objekt mit Hilfe von new erzeugen.

Sind dir, als wir Franka erzeugt haben, die runden Klammern hinter dem Klassennamen Frau aufgefallen? Wir haben new Frau() geschrieben.

Kim, es sieht so aus als wäre Frau() eine Funktion!

Ja genau! So ist es auch. Die Funktion die wir hier aufrufen wird Kontstruktorfunktion genannt.

Der Funktionsname der Konstruktorfunktion entspricht dem Namen der Klasse.

Gut, jetzt wirst du bestimmt den Einwand haben, dass es in unserer Klasse Frau keine Funktion mit dem Namen Frau existiert.

Ja, auch das stimmt! In diesem Fall stellt JAVA den Standardkonstruktor Frau() zur Verfügung. Hierbei handelt es sich um eine Funktion mit leerem Funktionsrumpf.

public Frau(){
}

Nichts spannendes also. Eines solltest du dir aber unbedingt merken! Obwohl eine Konstruktorfunktion keinen Rückgabewert liefert, verwenden wir im Funktionskopf NICHT das Schlüsselwort void.

Richtig interessant werden Konstruktoren erst, wenn wir sie selbst erstellen.

Wir erweitern unserer Klasse Frau um einen Konstruktor, mit dem wir die Eigenschaften unseres Objekts initialisieren.

Dazu verändern wir unsere Klasse Frau von oben wie folgt:

1: class Frau{
2:   public String strName, strVorname;
3:   public String strGeburtstdatum, strStaatsangehörigkeit;
4:   public String strAdresse, strAugenfarbe;
5:   public int intKoerpergroesse;
6:
7:   public Frau(String pStrName,String pStrVorname,
   String pStrGeburtsdatum, String pStrStaatsangehörigkeit,
       String pStrAdresse,String pStrAugenfarbe,
                                int pIntKoerpergroesse){

8:	strName  = pStrName; 
9:	strVorname = pStrVorname;
10:	strGeburtstdatum = pStrGeburtsdatum;
11:	strStaatsangehörigkeit = pStrStaatsangehörigkeit;
12:	strAdresse = pStrAdresse;
13: 	strAugenfarbe = pStrAugenfarbe;
14:	intKoerpergroesse = pIntKoerpergroesse;
15: }
16:};

In den Zeilen sieben bis 15 haben wir eine Konstruktorfunktion eingefügt, deren Parametern den Eigenschaften des Frau Objekts entspricht.

Innerhalb des Konstruktors werden die Parameter einfach den Objektvariablen zugewiesen.

Um die Eigenschaften unseres Objekts wie Name, Augenfarbe etc. festzulegen, müssen wir jetzt nicht mehr mit dem eher unelegant wirkenden Punktoperator arbeiten, sondern es reicht, wenn wir den Konstruktor mit entsprechenden Argumenten aufrufen.

Das ist deutlich kompakter. Und sieht genau so aus:

1: Frau franka = new Frau("Mueller","Franka","01.07.1981",
   "Finnland","56077 Koblenz An der   Muehle","gruen",165);		 
2:System.out.println(franka.strVorname+" "+franka.strName+
  " aus "+franka.strStaatsangehörigkeit+" hat Augenfarbe "
      +franka.strAugenfarbe+".");

Die Programmausgabe errätst du im Schlaf! Diese lautet Franka Mueller aus Finnland hat Augenfarbe gruen..

Dank des Konstruktors hat sich der Umfang unseres Programms auf zwei Zeilen reduziert.

In der ersten Zeile erzeugen wir Franka, eine Instanz der Klasse Frau. Die Eigenschaften übergeben wir diesmal als Argumente an den Konstruktor, der diese in den entsprechenden Objektvariablen speichert.

Zeile zwei gibt zum Beweis, dass es auch wirklich funktioniert hat einige der Objekteigenschaften auf dem Bildschirm aus.

Hauptgrund weshalb man die objektorientierte Programmierung erfunden hat, ist die super einfache Möglichkeit einmal geschriebenen Code wiederzuverwenden.

Unsere Klasse Frau ist fix und fertig, daher können wir jetzt ohne großen Aufwand unserer Franka eine Busenfreundin Tanja an die Seite stellen. Wir müssen den Konstruktor einfach mit anderen Argumenten aufrufen. Hier der Programmcode für diesen Zweck:

1: Frau tanja = new Frau("Maier","Tanja","02.05.1985",
"Norwegen","56077 Franka An der Kirche","blau",165);
2: System.out.println(tanja.strVorname+" "+tanja.strName+
  " aus "+tanja.strStaatsangehörigkeit+" hat Augenfarbe "+
   tanja.strAugenfarbe+".");

Die Programmausgabe ist für dich keine Überraschung:

Tanja Maier aus Norwegen hat Augenfarbe blau.

Das Überladen von Konstruktoren

Und weißt du was der Hammer ist? Wir müssen uns nicht einmal für einen Konstruktor entscheiden. JAVA bietet die Möglichkeit Konstruktoren zu überladen.

Wir können also mehrere Konstruktorfunktionen definieren.

Jeder Konstruktor, den du definierst muss natürlich den gleichen Namen haben. In unserem Fall also Frau.

Allerdings dürfen sich die Anzahl der Paramater unterscheiden. JAVA ist clever genug beim Aufruf des Konstruktors zu entscheiden, welche Kontruktorfunktion die richtige ist.

Du forderst den Beweis? Klar, hier ein Beispiel für eine überladene Konstruktorfunktion.

Nehmen wir mal an. Wir möchten ein Objekt der Klasse Frau auch erzeugen, wenn wir keine Kenntnisse über Augenfarbe oder Staatsangehörogkeit haben.

Mit unserem bisherigen Konstruktor könnten wir dann nur ein Objekt erzeugen, wenn wir als Argument den Initialwert null übergeben.

Frau franka = new Frau("Mueller","Franka",null,null,null,null,0);

Nicht so schön!

Viel besser ist es unsere Klasse um einen weiteren Konstruktor zu erweitern, der als Parameter nur die absolut notwendigen Informationen wie Name und Vorname benötigt.

1:   public Frau(String pStrName,String pStrVorname){
2:	strName  = pStrName; 
3:	strVorname = pStrVorname;
4:	strGeburtstdatum = "unbekannt";
5:	strStaatsangehörigkeit = "unbekannt";
6:	strAdresse = "unbekannt";
7: 	strAugenfarbe = "unbekannt";
8:	intKoerpergroesse = 0;
9: }

Unser neuer Konstruktor erwartet nur die beiden Argumente Namen und Vorname, welche den Objektvariablen strName und strVorname zugewiesen werden.

Allen anderen String-Variablen weisen wir den Wert unbekannt zu. Die Variable intKoerpergroesse für die Körpergröße setzen wir auf den Wert 0.

Jetzt kannst du, obwohl du keine Ahnung hast welche Augenfarbe und Staatsangehörigkeit Tanja hat, eine Tanja Instanz erzeugen.

1: Frau tanja = new Frau("Marakowski","Tanja");		 
2:System.out.println(tanja.strVorname+" "+tanja.strName+" aus "+
      tanja.strStaatsangehörigkeit+" hat Augenfarbe "
      +tanja.strAugenfarbe+".");

Sicher wirst du keine Schwierigkeiten haben die Programmausgabe zu erraten. Diese lautet:

Tanja Marakowski aus unbekannt hat Augenfarbe unbekannt.

JAVA merkt anhand der Anzahl der Parameter, welcher Konstruktor verwendet werden muss.

Das Objekt als Blackbox

Bis jetzt könntest du den Eindruck gewonnen haben, dass ein Objekt nichts weiter als eine Datenstruktur ist.

Aber das stimmt so nicht! Denn wir können in einer Klasse nicht nur Variablen definieren sondern auch Funktionen, mit der wir einem Objekt ein Verhalten einverleiben können. Diese Funktionen werden dann in der Regel Methoden genannt.

Eine besondere Art solcher Funktionen sind die getter bzw. setter Funktionen, welche ausschließlich die Aufgabe haben Attribute eines Objektes zusetzen bzw. auszulesen und zurückzuliefern.

Setter und getter Methoden!

Nein, keine Angst Setter ist nicht dieser hippe Techno DJ. Der heißt David Getter oder so ähnlich. HAHA!!

Als Programmierer wirst du oft in einem Team arbeiten und dein Ziel muss sein, deine Klassen so zu schreiben, dass deine Kollegen ohne Schwierigkeiten damit arbeiten können. Das erreichst du am einfachsten dadurch, dass du deine Klassen als Blackboxes erstellst.

Die interne Arbeitsweise deiner Klassen soll denjenigen der damit arbeitet also nicht interessieren müsssen.

Hierfür ist es natürlich sinnvoll möglichst viel nach außen zu verbergen.

Aber Kim!! Ich muss doch auf die Daten zugreifen!

Ich bemerke deine Skepsis!

Okay, erweitern wir unsere Klasse um den, bei uns Codeadventurern, mittlerweile legendär gewordenen Kontostand.

Wir legen fest, dass unsere Konten grundsätzlich nicht überziehbar sind. Dein Kollege, der ebenfalls in einem komplizierten Projekt eingespannt ist, könnte diesen Umstand vergessen.

Deshalb sorgen für zwei Dinge!

1. Die Objektvariable, in der der Kontostand gespeichert wird, ist von außen nicht sichtbar.
2. Der Kontostand kann nur über eine Methode verändert werden, die eine Fehlermeldung wirft, wenn das Konto überzogen wird.

Bisher haben wir unsere Objektvariablen als public deklariert, weshalb wir die Möglichkeit hatten über den Punktoperator die Werte in den Variablen zu verändern.

Um dies zu verhindern, werden wir die Variable, die den Kontostand speichert als private deklarieren.

private double dKontostand = 3000;

Wir initialisieren den Kontostand mit 300Euro. Versuch mal auf die Variable über den Punktoperator zuzugreifen.

private double dKontostand = 3000;

Du erhälst die Fehlermeldung, dass die Variable von außen nicht sichtbar ist. Unser Vorhaben diese Variablen nach außen hin zu verbergen, war also einer voller Erfolg!

Um den Wert der Variable dKontostand zu verändern, benötigen wir eine Methode.

Wir fügen unserer Klasse eine Funktion mit dem Namen bezahlen hinzu, der als Parameter der Zahlungsbetrag übergeben werden muss.

Außerdem sorgen wir in der Funktion dafür, dass es nicht möglich ist das Konto zu überziehen.

1: public void bezahlen(double dZahlungsbetrag){
2: if (dZahlungsbetrag > dKontostand){
3:   System.out.println("Es ist zuwenig Geld auf dem Konto!");
4:  }else{
5:   dKontostand -= dZahlungsbetrag;
6:  }
7:}

Die Funktion bezahlen rufen wir außerhalb der Klasse auf, daher ist es zwingend erforderlich die Methode als öffentlich (public) zu deklarieren.

Da wir keinen Rückgabewert haben, verwenden wir im Funktionskopf das Schlüsselwort void. Unsere Methode hat genau einen Übergabeparameter, nämlich den Zahlungsbetrag.

In der if-Abfrage in Zeile zwei, wird überprüft, ob der zu zahlende Betrag den aktuellen Kontostand übersteigt. In diesem Fall wird die Fehlermeldung

Es ist zuwenig Geld auf dem Konto!

ausgegeben.

Andernfalls wird in Zeile fünf der zu zahlende Betrag von dem aktuellen Kontostand abgezogen.

Erinnerst du dich? Wir haben die Variable dKontostand als private definiert. Aber natürlich möchten wir trotzdem Informationen über den Kontostand abfragen.

Wir brauchen also eine getter-Methode getKontostand()!

public double getKontostand(){
   return dKontostand;
}

Auch auf diese Funktion müssen wir außerhalb der Klasse zugreifen. Deshalb muss die getter Methode als public definiert werden.

Natürlich hat jede getter Methode einen Rückgabewert. In unserem Fall den aktuellen Kontostand dKontostand.

Jetzt haben wir alles zusammen.

Franka möchte eine Bohrmaschine im Wert von 199Euro bezahlen. Nach der Bezahlung muss der Kontostand also 2801Euro betragen.

Gut, schauen wir mal, ob unsere Überlegungen funktionieren.

1: Frau franka = new Frau();
2: franka.bezahlen(199);
3: System.out.println("Kontostand: "+franka.getKontostand());

In Zeile eins erzeugen wir mit Hilfe des Standardkonstruktors eine Instanz von Franka, für die wir in Zeile zwei die Objektmethode bezahlen mit dem Argument 199Euro aufrufen.

Am Schluss des Programms in Zeile drei rufen wir noch die getter Methode getKontostand() auf, mit der wir den Kontostand des Objekts franka auf dem Bildschirm ausgeben. Wie erwartet erhalten wir die Programmausgabe:

Kontostand: 2801.0

Im folgenden Video zeige ich dir, wie du das Konzept der obektorientierten Programmierung in Eclipse umsetzt.

Klassenmethoden und Klassenvariablen!

Bisher haben wir nur mit Objektvariablen und Objektmethoden gearbeitet. Das führte dazu, dass die Daten unserer Instanzen gekapselt waren. So hat Franka und Tanja beispielsweise keinen gemeinsamen Pool an Daten.

In den allermeisten Fällen ist gerade das einer der großen Vorteile der objektorientierten Programmierung.

Schließlich hat sowohl Tanja als auch Franka eine eigene Augenfarbe, eine eigene Staatsangehörigkeit und einen eigenen Geburtsort.

Manchmal werden aber auch objektübergreifende Daten benötigt. Ein klassischer Fall, in dem es wünschenswert ist, Daten Instanz übergreifend zur Verfügung zu stellen ist ein Zähler.

Und genau das funktioniert mit Hilfe von Klassenvariablen.

In JAVA werden Klassenvariablen über das Schlüsselwort static definiert.

Wir werden unserer Klasse Frau einen Zähler hinzufügen, der protokolliert wie viele Objekte der Klasse Frau erzeugt wurden.

Hierzu erweitern wir unsere Klasse Frau um eine Klassenvariable intZaehler, und da wir diese verborgen halten (private), um eine statische getter Methode.

1: class Frau{
2:  private static int intZaehler = 0;
    .
4:  public Frau(){
5:    intZaehler++;			
6:  }
    .
7:  public Frau(String pStrName,String pStrVorname,String pStrGeburtsdatum,
      String pStrStaatsangehörigkeit,String pStrAdresse,
      String pStrAugenfarbe,int pIntKoerpergroesse){
      .	
8:    intZaehler++;	
      .
    }

10: public static int getZaehler(){
11:	return intZaehler;
12: }
13:}

In Zeile zwei definieren wir mittels des Schlüsselwortes static eine private Klassenvariable intZaehler vom Typ Integer.

Immer wenn wir eine Instanz der Klasse Frau erzeugen. Also einen der Konstruktoren aufrufen. Machen wir ein Inkrement auf die Zählervariable intZaehler (Zeile fünf bzw. acht).

Da wir die Klassenvariable intZaehler als privat deklariert haben, benötigen wir um deren Wert auszulesen in Zeile zehn die getter Methode getZaehler(). Da es sich hier um eine Klassenmethode handelt, müssen wir auch diese mittels des Schlüsselwortes static deklarieren.

Oben hatten wir zwei Objekte der Klasse erzeugt. Nämlich Franka und Tanja. Unsere Zählervariable sollte also nach Adam Riese den Wert zwei haben.

Ich schlage vor. Wir überprüfen das indem wir über die getter Klassenmethode getZaehler() den Wert von intZaehler auf dem Bildschirm ausgeben.

Kim, wie rufe ich die Klassenmethode getZaehler auf?

Da eine Klassenvariable objektübergreifend ist, ist es egal, ob wir über die Instanz franka oder tanja die Funktion aufrufen. Oder?

Probier es mal aus!

system.out.println(tanja.getZaehler());

Alles klar! Es funktioniert tatsächlich. Wir erhalten die Programmausgabe Es wurden 2 Instanzen erzeugt!.

Das Programm klappt auch noch, wenn wir die Instanz tanja durch franka ersetzen.

Da eine Klassenmethode aber vollkommen losgelöst von der Instanz einer Klasse ist, können wir die Klassenmethoden einer Klasse auch einfach über den Namen der Klasse aufrufen. In unserem Fall also Frau. Das sieht dann ganz unspektakulär so aus.

system.out.println(Frau.getZaehler());

Aber ACHTUNG! Eines geht nicht! Du darfst niemals aus einer als static deklarierten Funktion auf Objektvariablen zugreifen. Das führt zu einem Laufzeitfehler deines Programmes.

Also merke: Auf Variablen, die nicht über das Schlüsselwort static als Klassenvariablen deklariert wurden, kann nicht aus Klassenmethoden zugegriffen werden. Und auch wenn ich mich wiederhole! Klassenmethoden sind genau die Methoden die im Funktionskopf das Wörtchen static stehen haben.

Wie erwartet erhalten wir auch hier die Programmausgabe Es wurden 2 Instanzen erzeugt!.

Auch das Konzept der Klassenvariablen und Methoden möchte ich dir in einem kleinen Filmchen zeigen.

Ich hoffe ich habe dir in diesem Artikel das Konzept der objektorientierten Programmierung am Beispiel von JAVA ein wenig näher bringen können. Es gehört zu den wichtigsten Konzepten überhaupt und als großer Programmierer musst du es beherrschen.

Als nächstes werden wir uns Näher mit der Klassenhierarchie beschäftigen. Im zweiten Teil dieser Artikel-Serie werde ich dir zeigen, wie du eine allgemeine unspezifische Oberklasse (z.B. Pflanze) definierst und deren Eigenschaften an eine Unterklasse (z.B. Baum) vererbst.

Wie immer freue ich mich über deine Fragen im Kommentarbereich.

Hat dir der Artikel gefallen? Dann folge uns doch am besten auf facebook.