Unterschied zwischen Klassenvariable und Instanzvariable im Java Programm
Bei der Java Programmierung unterscheidet man drei Arten von Variablen.
Als erste Gruppe sind die lokalen Variablen zu nennen.
Auf diese gehe ich in einem separaten Artikel ein.
Mich interessieren die zwei anderen Variablentypen.
Zum einen existieren Klassenvariablen.
Und dann sind da noch die Instanzvariablen.
Inhalt
Wo liegt der Unterschied zwischen Instanz und Klassenvariablen im Java Programm
Instanzvariablen stehen einem Objekt zur Verfügung.
Klassenvariablen stehen allen Objekten zur Verfügung.
Wie meine ich das?
Ganz einfach.
Stell dir vor, du erstellst eine Mitarbeiterverwaltung.
Dazu erstellst du Mitarbeiterobjekte.
Jeder Mitarbeiter hat eine Nummer.
Diese wären Instanzvariablen.
Nehmen wir weiter an, du hast drei Mitarbeiter.
Carmen, Peter und Mathias.
Und jeder Mitarbeiter bekommt jetzt diese Nummer.
Bei einer Instanzvariablen würde diese Nummer dann dreimal existieren.
Jedes Objekt hätte diese Nummer.
Und natürlich könnte diese Nummer dann auch dreimal den gleichen Wert annehmen.
Du erstellst also das Carmen-, das Peter- und das Mathias-Objekt.
Und schon haben alle drei Objekte die Nummern -Instanzvariable.
Ich verdeutlich das ganze Prinzip einmal auf diesem Bild.
Und im Java Programm würde dies dann so aussehen:
public class Mitarbeiter {
int nummer=1;//das soll eigentlich eine laufende Nummer werden
String vorname;//der Vorname des Mitarbeiters
Mitarbeiter (String derVorname){ //Konstruktor mit Parameterliste
vorname=derVorname; //Zuweisung der Instanzvariablen vorname
System.out.println("Mitarbeiter "+nummer+" heißt "+vorname);
}
}
Ganz kurz – Was siehst du hier.
In der Klasse Mitarbeiter legst du den Bauplan für ein Mitarbeiter Objekt an.
Dieser Bauplan enthält einen Konstruktor und die Instanzvariablen „nummer“ und „vorname“.
Der Konstruktor hat eine Parameterliste und nimmt den Vornamen entgegen.
Im Konstruktorrumpf wird jetzt das Argument aus der Paramterliste zugewiesen.
Außerdem kannst du im Konstruktorrumpf eine Konsolenausgabe anlegen, welche dir den Wert der Instanzvariablen zurückgibt.
Und um die Instanzvariable „nummer“ geht es eigentlich nur.
Dann erstellst du eine Programmklasse.
public class MitarbeiterVerwaltung{
public static void main (String [] args) {
Mitarbeiter carmen = new Mitarbeiter ("Carmen");
Mitarbeiter peter = new Mitarbeiter ("Peter");
Mitarbeiter mathias = new Mitarbeiter ("Mathias");
}
}
Und diese enthält die main-Methode zum Programmstart.
Dann legst du deine Mitarbeiterobjekte an, übergibst die Argumente und startest das Programm.
Na was ist passiert?
Alle drei Objekte haben den gleichen „Nummern-Wert“.
Aber!
In einer Mitarbeiterverwaltung gibt es ja so etwas wie laufende Nummern oder Mitarbeiter ID-Nummern.
Und diese Nummern sollten dann mitarbeiterspezifisch sein.
Das bedeutet doch, dass der Wert dieser Nummern von Mitarbeiter zu Mitarbeiter unterschiedlich sein sollte.
Oder anders gesagt:
Kein Mitarbeiter darf die gleiche laufende Nummer besitzen, wie ein anderer.
Versuchen wir doch einmal die Instanzvariable im Konstruktor zu erhöhen.
public class Mitarbeiter {
int nummer=1;//das soll eigentlich eine laufende Nummer werden
String vorname;//der Vorname des Mitarbeiters
Mitarbeiter (String derVorname){ //Konstruktor mit Parameterliste
vorname=derVorname; //Zuweisung der Instanzvariablen vorname
nummer=nummer+1;//Erhöhung um jeweils 1
System.out.println("Mitarbeiter "+nummer+" heißt "+vorname);
}
}
Die Klasse „MitarbeiterVerwaltung“ brauchst du nicht ändern.
Klicke auf „Run“.
Und alle Mitarbeiter haben jetzt die Nummer 2.
Blöd…
So ein Vorhaben kannst du nicht über Instanzvariablen lösen.
So etwas bekommst du aber mit Klassenvariablen hin.
Klassenvariablen sind globale Variablen.
Das bedeutet:
Klassenvariablen stehen nicht einem Objekt zur Verfügung.
Eine Klassenvariable steht allen Objekten zur Verfügung.
Wenn du dies jetzt in deine Mitarbeiterverwaltung einbauen möchtest, musst du eine statische Variable anlegen.
Der Ausdruck statisch ist lediglich eine andere Bezeichnung für die Klassenvariable.
Klassenvariablen sollten immer public sein.
Denn es sollen ja schließlich alle Objekte darauf zu greifen.
Eine Klassenvariable wird immer durch das Keyword static ausgezeichnet.
public static int
Und jetzt kannst du dieser Variablen einen Wert, im Konstruktor, zuweisen.
Ich werde den Wert der Variablen bei jedem Konstruktoraufruf um eins erhöhen.
Und so sieht das Ganze dann aus.
public class Mitarbeiter {
public static int laufendeNummer;//die Klassenvariable laufende Nummer
int nummer=1;
String vorname;//der Vorname des Mitarbeiters
Mitarbeiter (String derVorname){ //Konstruktor mit Parameterliste
vorname=derVorname; //Zuweisung der Instanzvariablen vorname
laufendeNummer=laufendeNummer+1;//Erhöhung der Klassenvariablen um jeweils 1
System.out.println("Mitarbeiter "+laufendeNummer+" heißt "+vorname);
}
}
Wenn du jetzt dein Programm startest, dann bekommt jedes Objekt eine individuelle Nummer zugewiesen.
Nochmal ganz kurz:
Du setzt also Instanzvariablen dazu ein, einen Mitarbeiter:
- Eine individuelle Größe
- Eine individuelle Anschrift
- Eine individuelle Telefonnummer zuzuweisen.
Klassenvariablen nutzt du, um etwas nicht Individuelles zu platzieren.
Jetzt lass uns die Klassenvariable einmal an anderer Stelle aufrufen
Und zwar, möchte ich die laufende Nummer nicht bei null, sondern bei 1.000 starten.
Klar, du könntest in der Klasse Mitarbeiter der Variable gleich einen Wert zuweisen.
Ich möchte dir aber etwas anderes zeigen.
Und zwar möchte ich den Wert der Variablen in der main Methode zuweisen.
Jetzt befindet sich die main Methode in einer anderen Klasse.
Und deshalb musst du die Variable per Punktnotation ansprechen.
Also schreibe die Klasse, dann den Punkt und dann den Variablennamen.
Danach kannst du der statischen Variablen einen Wert zuweisen.
public class MitarbeiterVerwaltung{
public static void main (String [] args) {
Mitarbeiter.laufendeNummer=1000;//neuer Startwert der Variablen
Mitarbeiter carmen = new Mitarbeiter ("Carmen");
Mitarbeiter peter = new Mitarbeiter ("Peter");
Mitarbeiter mathias = new Mitarbeiter ("Mathias");
}
}
Klicke auf „Run“ und du startest mit einem neuen Startwert.
Du siehst:
Es besteht auch beim Zugriff ein Unterschied zu den Instanzvariablen.
Für einen Zugriff auf eine Instanzvariable musst du immer ein Objekt erschaffen.
Und dann kannst du per Punktnotation auf dieses Objekt und deren Eigenschaften zugreifen.
Auf eine Klassenvariable greifst du immer mit dem entsprechenden Klassennamen zu.
Zusammenfassung:
- Instanzvariablen stehen immer einem Objekt zur Verfügung.
- Immer wenn du einem bestimmten Objekt einen ganz individuellen Wert zuweisen möchtest, nutzt du Instanzvariablen.
- Klassenvariable stehen allen Objekten zur Verfügung.
- Deshalb nutzt du Klassenvariablen immer dann, wenn alle Objekte darauf zugreifen. (Beispiel: laufende Nummern, Summe aller Gehälter, einheitliche Hintergrundfarben bei Anwendungen usw.)
Über den Autor
